Mehrere Servo-Signale einlesen, ggf. manipulieren, ausgeben

Zitat:

---

Zitat von wkrug

Bevor Du da die Flinte ins Korn wirfst ...

---

Niemals! Dann wirds ja nie fertig. Außerdem kann man ne Flinte immer mal gebrauchen... ;-)
Ich hoff übers Wochenende, oder dann über die Feiertage findet sich ein bisschen Zeit da noch etwas rumzuprobieren.
Evtl. bekomm ich das Programm ja im AVR Studio Sim zum laufen, muss ich mal schaun.

Gruß Basti

Ok, Ich bin dann mal so frech und hau nen Code raus.
Im Simulator hab ich das mal getestet - Da scheints zu funktionieren.
Mit nem Controller kann ich leider nicht testen ( Kein ATMEGA 88 hier ).
Ich hab das Prinzip mit dem Pinchange umgesetzt.
Die Simulation war mit 8MHz, dabei kann ein Versatz ( Jitter ) von 30µS bei den Signalen entstehen.

Code:

---

/*****************************************************

Project : Einzelimpulse zu Summensignal
Version : 0.1
Date    : 19.12.2014
Author  :                 
Company :         
Comments:


Chip type          : ATmega88
Program type        : Application
Clock frequency    : 8,000000 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size    : 256

Zeitversatz beim Einlesen der Impulse 30µs!
*****************************************************/

/********
PC0 = Kanal 1
PC1 = Kanal 3
PC2 = Kanal 5
PC3 = Kanal 7
PD0 = Kanal 2
PD1 = Kanal 4
PD2 = Kanal 6
PD3 = Kanal 8
PB1 = Summensignalausgang
********/

#include <mega88.h>

volatile unsigned int ui_timerold[8];    //Speicherwerte für die Steigende Flanke der entsprecheden Kanäle
volatile unsigned int ui_pulslengh[8]={1500,1500,1500,1500,1500,1500,1500,1500};  //Ermittelte Pulslängen
volatile unsigned char uc_oldgerade=0;    //Zwischenspeicher für den alten Zustand der geraden Kanäle 2,4,6,8
volatile unsigned char uc_oldungerade=0; //Zwischenspeicher für den alten Zustand der geraden Kanäle 1,3,5,7
volatile unsigned char uc_cyclecount;    //Zyklenzähler für die Impulsausgabe
#define maxcycle 15
#define interpulspause 50                //50 = 50µs
#define interframepause 4000              //4000 = 4ms Interframepause

//#define normal                          //Bestimmt ob die Impulsausgabe normal oder invers geschehen soll
//#define revers
#define portsungerade PINC
#define portsgerade PIND
#define outport PORTB.1
// Pin change 8-14 interrupt service routine
interrupt [PCINT1] void pin_change_isr1(void)
{
unsigned char uc_portungerade,uc_result;
unsigned int ui_timer;
ui_timer=TCNT1H;
ui_timer=(ui_timer<<8)+TCNT1L;
uc_portungerade=portsungerade&0x0F;
uc_result=uc_portungerade^uc_oldungerade;
if(uc_result&0x01)
    {
    if(uc_portungerade&0x01)        //Es war ne steigende Flanke
        {
        ui_timerold[0]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[0]=ui_timer-ui_timerold[0];
        };
    }

if(uc_result&0x02)
    {
    if(uc_portungerade&0x02)        //Es war ne steigende Flanke
        {
        ui_timerold[2]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[2]=ui_timer-ui_timerold[2];
        };
    }
   
if(uc_result&0x04)
    {
    if(uc_portungerade&0x04)        //Es war ne steigende Flanke
        {
        ui_timerold[4]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[4]=ui_timer-ui_timerold[4];
        };
    }
   
if(uc_result&0x08)
    {
    if(uc_portungerade&0x08)        //Es war ne steigende Flanke
        {
        ui_timerold[6]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[6]=ui_timer-ui_timerold[6];
        };
    }
uc_oldungerade=uc_portungerade;
}

// Pin change 16-23 interrupt service routine
interrupt [PCINT2] void pin_change_isr2(void)
{
unsigned char uc_portgerade,uc_result;
unsigned int ui_timer;
ui_timer=TCNT1H;
ui_timer=(ui_timer<<8)+TCNT1L;
uc_portgerade=portsgerade&0x0F;
uc_result=uc_portgerade^uc_oldgerade;
if(uc_result&0x01)
    {
    if(uc_portgerade&0x01)        //Es war ne steigende Flanke
        {
        ui_timerold[1]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[1]=ui_timer-ui_timerold[1];
        };
    }

if(uc_result&0x02)
    {
    if(uc_portgerade&0x02)        //Es war ne steigende Flanke
        {
        ui_timerold[3]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[3]=ui_timer-ui_timerold[3];
        };
    }
   
if(uc_result&0x04)
    {
    if(uc_portgerade&0x04)        //Es war ne steigende Flanke
        {
        ui_timerold[5]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[5]=ui_timer-ui_timerold[5];
        };
    }
   
if(uc_result&0x08)
    {
    if(uc_portgerade&0x08)        //Es war ne steigende Flanke
        {
        ui_timerold[7]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[7]=ui_timer-ui_timerold[7];
        };
    }
uc_oldgerade=uc_portgerade;
}

// Timer 1 output compare A interrupt service routine
interrupt [TIM1_COMPA] void timer1_compa_isr(void)
{
unsigned char uc_low,uc_high;
unsigned int ui_buffer;
switch(uc_cyclecount)
    {
    case 0:
    outport=1;                    //Der erste Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[0];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
    case 1:                      //Die Pausen
    case 3:
    case 5:
    case 7:
    case 9:
    case 11:
    case 13:
    outport=0;
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=interpulspause;
    uc_low=ui_buffer&0x00FF;
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
    case 2:
    outport=1;                    //Der zweite Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[1];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 4:
    outport=1;                    //Der dritte Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[2];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 6:
    outport=1;                    //Der vierte Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[3];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 8:
    outport=1;                    //Der fünfte Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[4];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 10:
    outport=1;                    //Der sechste Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[5];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 12:
    outport=1;                    //Der siebte Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[6];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 14:
    outport=1;                    //Der achte Impuls
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=ui_pulslengh[7];    //Pulslänge dazuzählen
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 15:
    outport=0;
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=interframepause;
    uc_low=ui_buffer&0x00FF;
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    default:
    uc_cyclecount=0;
    }
uc_cyclecount++;
if(uc_cyclecount>maxcycle){uc_cyclecount=0;}
}

// Declare your global variables here

void main(void)
{
// Declare your local variables here

// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=Out Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=0 State0=T
PORTB=0x00;
DDRB=0x02;

// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=P State2=P State1=P State0=P
PORTC=0x0F;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=P State2=P State1=P State0=P
PORTD=0x0F;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 1000,000 kHz
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: On
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x02;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// Interrupt on any change on pins PCINT0-7: Off
// Interrupt on any change on pins PCINT8-14: On
// Interrupt on any change on pins PCINT16-23: On
EICRA=0x00;
EIMSK=0x00;
PCICR=0x06;
PCMSK1=0x0F;
PCMSK2=0x0F;
PCIFR=0x06;

// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=0x00;
// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=0x02;
// Timer/Counter 2 Interrupt(s) initialization
TIMSK2=0x00;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
ADCSRB=0x00;

// Watchdog Timer initialization
// Watchdog Timer Prescaler: OSC/128k
// Watchdog Timer interrupt: Off
/*#pragma optsize-
#asm("wdr")
WDTCSR=0x1E;
WDTCSR=0x0E;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif  */

// Global enable interrupts
#asm("sei")

while (1)
      {
      #asm("wdr")
     
      // Place your code here

      };
}

---

Auch wenn mehrere Ports ihre Level zu gleichen Zeit ändern, sollte der Code funzen.

Auch BASCOM hat einen internen Simulator. So grundlegende Dinge wie der Timer und Interrupts sollten auch da funktionieren.

Der Umstieg von BASCOM auf C bringt vielleicht einen Faktor 2-3 bei der Geschwindigkeit . ist aber unterschiedlich je nach Aufgabe. Der Overhead bei der Interruptsroutine ist in BASCOM recht groß - etwa 100 Zyklen extra gegenüber GCC bei einer eher kurzen ISR. In BASCOM hat man den Vorteil das man leichter mit inline ASM kombinieren kann - das geht auch in C, aber nicht so einfach. Da BASCOM einige Register normal nicht nutzt, kann man mit BASCOM und ISR in ASM ggf. sogar schneller werden als mit GCC und ASM.

Zitat:

---

....inline ASM kombinieren kann

---

Das hatte ich schon ein paar Post's weiter vorne auch vorgeschlagen.
Ob man's dann mit BASCOM oder nen C-Compiler macht dürfte relativ egal sein.
Auch bei CodeVision AVR lässt sich inline Assembler problemlos einbinden.
Wie das bei AVR GCC geht weiss ich leider nicht.
Wenn man in der Interruptroutine nur Assembler verwendet kann man zusätzlich die automatische Registersicherung abschalten, da BASCOM normalerweise bei jedem ISR-Aufruf ja alle 32 Register sichert und wieder zurückschreibt.
Bei ASM müssen nur das SREG und die Register gesichert werden, die man selber benotigt.
Zusätzlich ist es sinnvoll den Controller mit der maximal möglichen Taktrate zu takten weil damit der Jitter minimiert wird.
Also einen Typen wählen der mit 20MHz läuft und auch 20MHz verwenden.

Ein Bekannter von mir hat mit BASCOM und inline Assembler einen Testbildgenerator für Fernseher gebaut und das ist noch wesentlich zeitkritischer als Servoimpulse einlesen.

Inline ASM geht auch mit GCC. Es ist sogar recht mächtig und erlaubt dem Compiler den Code davor und dahinter entsprechend anzupassen / optimieren. Allerdings ist deshalb das Interface etwas umständlich, auch wenn man es für die ISR nicht braucht. Man kann in C auch so etwas wie die ISR als extra ASM Code teil einbinden und erst vom Linker dazu packen lassen.

ASM in BASCOM geht halt sehr einfach, weil die Registernutzung bei BASCOM fest ist. Normal sind einige Register ungenutzt, die man dann in der ISR nicht mal retten muss.

Gibt es da irgendwo eine zuverlässige Übersicht?

Euch allen erst mal Frohe Weihnachten.

Hab nun endtlich das AVR Studio 4.19 zum laufen gebracht ;-) das 6er Atmel Studio ist mir einfach viel zu überladen.
Ich denke über die Feiertage habe ich dann auch etwas Zeit mich näher damit zu befassen.
Die letzten Tage waren Arbeits-Technisch etwas stressiger....

Gruß Basti

In C spuckt er mir leider die selben Mist Werte wie im Bascom Prog aus. Also scheint irgendwas an meinem Prinzip völlig daneben zu gehen.

main.c

Code:

---

#include <avr/io.h>
#include <stdlib.h>
#include <stdint.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "uart.h"
#include "input.h"

/* define CPU frequency in Mhz here if not defined in Makefile */
#ifndef F_CPU
#define F_CPU 16000000UL
#endif

/* 9600 baud */
#define UART_BAUD_RATE      9600     


int main(void)
{


    //Uart initialisieren
    uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );


    //Eingänge INT0 und INT1 initialisieren
    init_inputs();


    while(1)
    {
        char tmp[5];
        itoa(input_channel[3], tmp, 10);
        uart_puts(tmp);
        uart_puts("\n");
        _delay_ms(50);
    }; //Endlosschleife
   
}

---

input.c

Code:

---

#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>

#include "input.h"

// **************************
//        Prototypen
// **************************
void init_inputs(void);//Initialisiert INT0 und INT1

// **************************
//        Deklarationen
// **************************
uint16_t (input_channel)[7]; //Array für die einzelnen Kanäle
uint8_t (fail_flag); //Flag für Fail Safe Modus

uint8_t (ch_cnt); //Counter für aktuellen Kanal


void init_inputs(void)
{


    //INT0 und INT1 als Eingang
    //DDRD = 0b11111001;
    DDRD &= ~((1 << DDD1) | (1 << DDD2));

    //INT0 und INT1 aktivieren
    GICR |= ((1 << INT0) | (1 << INT1));

    //Beide INT auf steigene Flanke konfigurieren
    MCUCR |= ((1 << ISC01) | (1 << ISC00)); //INT0
    MCUCR |= ((1 << ISC11) | (1 << ISC10)); //INT1

    //Timer1 Prescaler auf 1 stellen
    TCCR1B |= (1 << CS10);

    //Timer1 Overflow INT aktivieren
    TIMSK |= (1 << TOIE1);

    //Interrupts anschalten
    sei();
};


//ISR von INT0
ISR(INT0_vect)
{   
    //Wenn der CH != 0 dann speichere Zählerstand
    if(ch_cnt != 0){input_channel[ch_cnt] = TCNT1;}

    //Ch Zähler erhöhen
    ch_cnt++;

    //Zähler zurücksetzen
    TCNT1 = 0;

    //INT0 auf fallende Flanke
    if(ch_cnt == 6){MCUCR &= ~(1 << ISC00);}
}


//ISR von INT1
ISR(INT1_vect)
{
    //Wenn der CH != 0 dann speichere Zählerstand
    if(ch_cnt != 0){input_channel[ch_cnt] = TCNT1;}

    //Ch Zähler erhöhen
    ch_cnt++;

    //Zähler zurücksetzen
    TCNT1 = 0;

    //INT1 auf fallende Flanke
    if(ch_cnt == 6){MCUCR &= ~(1 << ISC10);}
}


//Timerüberlauf nach ~4ms, wenn nicht manuell zurückgesetzt wird
ISR(TIMER1_OVF_vect)
{
    //Kanalzähler zurücksetzen
    ch_cnt = 0;

    //Beide INT auf steigene Flanke konfigurieren
    MCUCR |= ((1 << ISC01) | (1 << ISC00)); //INT0
    MCUCR |= ((1 << ISC11) | (1 << ISC10)); //INT1
}

---

Aus hTerm

Code:

---

...
...
...
9618<\n>
9618<\n>
9618<\n>
9618<\n>
9618<\n>
9618<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
8837<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
6762<\n>
-2320<\n>
-2320<\n>
-2320<\n>
-2320<\n>
-2320<\n>
-2320<\n>
-2320<\n>
...
...
...

---

Ich versteh nur langsam nicht mehr so ganz wieso dieses Prinzip nicht funktioniert.
Bei jedem INT den Zähler speichern und zurücksetzen.
Beim letzten auf fallende Flanke, damit das Ende des letzten Puls erfasst wird.

Die Pause nach den Pulsen ist dann größer als 4ms, sodass der Timer überläuft.
Der setzt dann alles auf Anfang zurück. Die 4ms Pause ist quasi das Syncronistations Signal.

Jemand ne Idee was ich falsch mache?

Gruß Basti
PS.: Schönen Feiertag noch :-)

EDIT:
gerade festgestellt, für Ch1 passt es eigentlich. Da bringt er mir einen Wert zwischen etwa 18000 und 30000 Ticks des Timers.
Nur die weiteren Ch haben dann falsche oder sogar negative Werte. Wie kann der Timer negativ Zählen?

Das sind die 6Ch Daten die er mir ausspuckt....

Code:

---

23925 | -239 | 2331 | -14653 | 0 | 0<\n>

---

Nur Ch1 verhält sich wie gewollt, äquivalent zum Knüpel der Fernbedienung, alle anderen springen ab und zu mal wild umher, aber nicht unbedingt auf Knüpelbewegungen.

EDIT2:
Weitere Erkenntnis, wenn ich beide Oszi Kanäle an die INTS halte und mir die Signale anschauen will, kommen die auch auf einmal korrekt an :-D scheinbar hängt der ganze scheiß irgendwie in der Luft und fängt sich Müll ein, sobal ich das aber - wenn auch nur minimal - mit dem Oszi belaste, haut's hin. Mal überlegen was ich da nun mache....

EDIT3:
Tatsache, die Ausgänge des Empfängers hingen bei Low Pegel völlig in der Luft. 10k gegen Masse und die Nummer läuft wie geschmiert.
Is ja klar, das der mir nur Müll auswertet, wenn die INTs sich alles einfangen, nur nicht das richtige Signal :-D

Aber aus lauter Trotz bleibe ich jetzt bei C, dann lern ich das auch endlich mal - bis dato noch NIE angefasst.
Alles was oben steht habe ich mir in etwa 48h angelesen ;-)

Zitat:

---

Aber aus lauter Trotz bleibe ich jetzt bei C

---

Ich denk mal, da machst Du sicher keinen Fehler.
Eine der wichtigsten Erkenntnisse von C ist, das der Compiler von oben nach unten arbeitet.
Nur das was oben definiert ist kann dein Programm darunter auch nutzen.
Deshalb steht da auch die main Routine ganz unten.
Wenn er mal ne Routine nicht findet, obwohl sie vorhanden ist, denk mal wie der Compiler und guck, ob die Routine vor der aufrufenden steht.
Damit hatte ich Anfangs die meisten Probleme.

Was mich persönlich bei C auch etwas nervt ist, das man für "Sonderfunktionen" immer erst die entsprechenden Includes im Programm machen muss.
Also für Mathematische Funktionen, String Verarbeitung usw. müssen immer die entsprechenden Includes eingefügt werden.
Aber C ist halt ein Baukasten, aus dem man sich halt nur nimmt, was man auch für seine Anwedung braucht.

Zitat:

---

Zitat von wkrug

Eine der wichtigsten Erkenntnisse von C ist, das der Compiler von oben nach unten arbeitet.

---

Hat mich 8 Std gekostet bis ich das im Zusammenhang mit den Header Dateien komplett verstanden habe. Jetzt ist es Logisch und ich finde die Herangehensweise, jede C Datei als "eigenständig" kompilierbares Programm zu generieren auch nicht mal schlecht.

Zitat:

---

Zitat von wkrug

Deshalb steht da auch die main Routine ganz unten.

---

Wenn ich das Richtig verstanden habe ist es egal, wo die main() steht, solange ich oben bzw. in der Header Datei die Funktionen als Prototyp definiert habe, oder nicht?

Zitat:

---

Zitat von wkrug

Was mich persönlich bei C auch etwas nervt ist, das man für "Sonderfunktionen" immer erst die entsprechenden Includes im Programm machen muss.
Also für Mathematische Funktionen, String Verarbeitung usw. müssen immer die entsprechenden Includes eingefügt werden.

---

Genau das schätze ich an C ;-) Kein byte zu viel Schrott im Code, sondern nur was auch Sinn macht.

BTT:
Also die Eingänge laufen jetzt, Jitter werde ich mir mal ansehen, denke aber das ein gleitender Mittelwert über 3 Werte da schon einiges rausholen kann.
Die Frage ist, was ich nun mit den Ausgängen mache. Timer1 ist ja nun blockiert :-/

Gruß Basti

Zitat:

---

Die Frage ist, was ich nun mit den Ausgängen mache. Timer1 ist ja nun blockiert :-/

---

Wenn Du den Timer nicht im CTC ( Clear Timer at Comparematch ) Mode laufen lässt, kannst Du problemlos auch die Impulsgenerierung darüber machen.
Du gibst den Comparematch Interrupt frei und stellst Ihn auf das nächste Ereignis ein.
Wie weit Du bei der Impulsgenerierung schon bist, kannst Du mit einer Zählvariable abspeichern.
Guck mal den Code ein paar Post's weiter vorne von mir an und zwar den Abschnitt

Code:

---

// Timer 1 output compare A interrupt service routine
interrupt [TIM1_COMPA] void timer1_compa_isr(void)........

---

Der Code ist für CodeVision, sollte aber auch mit ein paar Änderungen auf AVR GCC laufen.
Elementar ist, das das TCNT1 Register nicht manipuliert werden darf, also keine Werte reinschreiben und kein CTC.
Dann kannst Du, wenn Du lustig bist, sogar noch den Comparematch B für die Generierung einer weiteren Impulskette benutzen.
Wenn Du die Variablen unsigned machst, sind auch Timer Überläufe kein Problem.

Zitat:

---

Zitat von wkrug

Dann kannst Du, wenn Du lustig bist, sogar noch den Comparematch B für die Generierung einer weiteren Impulskette benutzen..

---

Danke, schau ich mir nochmal genauer an. Aber ich brauch keine Impulskette sondern wieder die 8 einzelnen Servo Signale ;-) sollen ja dann direkt die Servos dran.

EDIT:
Ich versteh das jetzt so:

Also der Timer läuft einfach vor sich hin, kein Eingriff durch mich.
Ich speicher die zeit beim beginn des Puls und beim Ende. Differenz ist dann die Dauer (aktuell Messe ich ja immer von 0 ab).
Durch unsigned ist der Überlauf irrelevant.

Wenn ich den Timer jetzt mit den ~4ms Überlauf so lasse, könnte ich bei jedem Überlauf einfach den Wert des nächsten Kanals in das Compare Register schreiben und den Ausgang high setzen. Und durch den Compare INT dann wieder auf LOW. Beim nächsten Timerüberlauf das gleich für den nächsten Kanal.

Dann komme ich bei 6 Kanälen mit 4ms Paketdauer auf 24ms Dauer eines Signals für einen einzelnen Servo, statt der 20ms, denke das ist noch im vertretbaren Rahmen?

Nur wie mache ich dann die Synchronistation auf CH1?

Zitat:

---

Also der Timer läuft einfach vor sich hin, kein Eingriff durch mich.
Ich speicher die zeit beim beginn des Puls und beim Ende. Differenz ist dann die Dauer (aktuell Messe ich ja immer von 0 ab).
Durch unsigned ist der Überlauf irrelevant.

---

Genau richtig!

Zitat:

---

Beim nächsten Timerüberlauf das gleich für den nächsten Kanal.

---

Lass doch den Timer Überlauf Interrupt komplett weg und füg die Pausen zwischen den Pulsen auch bei der Comparematchroutine mit ein.
Dadurch bleibt die Pausezeit auch variabel.
Du musst nur darauf achten, das das Comparematchregister einen höheren Wert hat als das TCNT1 Register, sonst wird da kein Interrupt mehr ausgelöst.
Eine Pause von 50µs reicht da völlig aus. Die CodeZeilen für das Setzen des TCC1Ax Register müssen abgearbeitet sein, bevor der TCNT1 diesen Zählerstand erreicht - Simulieren.

Für die Mehrfachkanalausgabe auf verschiedenen Ports geht das im Prinzip genauso, weil wer sagt, das in einem Comparematchinterrupt nur ein Port verändert werden darf.

Ich mach das so, das nach dem ersten Impuls der erste Port nach 0 gesetzt dann gleich der 2te gesetzt wird usw. bis alle Kanäle - Ausgänge durch sind.
Dann fügst Du eine Pause ein, damit die Wiederholrate nicht zu groß wird und fängst dann wieder von vorne an.

Für die Sync mit dem Empfänger gibt's im Prinzip mehrere Möglichkeiten.
Einmal kannst Du für Kanal 1 einen eigenen Interrupt verwenden, dann ist Kanal 1 klar definiert.
Zum anderen kannst Du die Pausen zwischen 2 Impulsketten auswerten, die ja mindestens 4ms betragen muß.
Zum dritten kannst Du auch die Idee mit den Pin Change Interrupts realisieren, dann sind die Kanäle ohnehin klar erkennbar.

Zitat:

---

... bei 6 Kanälen mit 4ms Paketdauer auf 24ms Dauer eines Signals für einen einzelnen Servo, statt der 20ms ... im vertretbaren Rahmen? ...

---

Die Antwort heißt eigentlich "im Prinzip könnte es gehen" - aber bei mir gehts wirklich gut! Und ich hatte anfangs deutliche Zweifel: bei meinem Archie (z.B. Video vom Kopf) verbrauche ich für die von mir gewünschte hohe Auflösung (Puls wird auf 0,4µs-Scheiben aufgeteilt - aber der Servo reagiert eher erst nach zwei, drei, vier µs) bei den im Kopf verbauten zehn Servoansteuerungen 25,60 ms für eine Servoperiode. Läuft aber ziemlich ansprechend finde ich.

Hallo,
@Bomberpilot: Ich bin mir nicht im Klaren, was für Signale bei Dir ankommen und wie Du sie weiterschicken möchtest.

Ist es richtig, daß es 6 Servosignale (jedes zwischen 1ms und 2ms high) auf 6 verschiedenen Leitungen sind.

Wenn das erste Signal low geht, geht direkt ohne Pause das zweite Signal auf high. Geht das auf low, sofort das dritte auf high usw.

Da alle Signale verschiedene Längen haben können, ist die Schlußpause bis zum 20ms Raster, bis das erste Signal wieder high wird, unbestimmt lang und ist abhängig von den high Zeiten aller 6 Signale. (20ms minus Gesamthighzeit = Lowschlußpause)

Du hast jetzt das erste, dritte, fünfte Signal per Dioden zusammengeführt und auf INT0 Pin vom µC gelegt. Das Gleiche mit dem zweiten, vierten und sechsten Signal auf INT1.

Nun möchtest Du die Signale messen, modifizieren und in einem 4ms Raster ausgeben.

Erstes Signal ab Zeitpunkt 0 ausgeben, zB 1,5ms lang high, dann low und bis 4ms warten, dann zweites Signal auf high, zB 1,2ms high, dann low, wieder bis Zeitpunkt 8ms warten, nächstes high usw.

Die Ausgabe der Signale sollen alle auf dem gleichen µC Pin passieren.

Großes Fragezeichen :lol:

Gruß
Searcher

Zitat:

---

Zitat von Searcher

Ist es richtig, daß es 6 Servosignale (jedes zwischen 1ms und 2ms high) auf 6 verschiedenen Leitungen sind.

Wenn das erste Signal low geht, geht direkt ohne Pause das zweite Signal auf high. Geht das auf low, sofort das dritte auf high usw.

Da alle Signale verschiedene Längen haben können, ist die Schlußpause bis zum 20ms Raster, bis das erste Signal wieder high wird, unbestimmt lang und ist abhängig von den high Zeiten aller 6 Signale. (20ms minus Gesamthighzeit = Lowschlußpause)

Du hast jetzt das erste, dritte, fünfte Signal per Dioden zusammengeführt und auf INT0 Pin vom µC gelegt. Das Gleiche mit dem zweiten, vierten und sechsten Signal auf INT1.

---

Bis hierhin absolut korrekt...

Zitat:

---

Zitat von Searcher

Nun möchtest Du die Signale messen, modifizieren und in einem 4ms Raster ausgeben.

Erstes Signal ab Zeitpunkt 0 ausgeben, zB 1,5ms lang high, dann low und bis 4ms warten, dann zweites Signal auf high, zB 1,2ms high, dann low, wieder bis Zeitpunkt 8ms warten, nächstes high usw.

Die Ausgabe der Signale sollen alle auf dem gleichen µC Pin passieren.

---

Will die 6 Signale wieder getrennt voneinander ausgeben. Die sollen dann quasi direkt zu den einzelnen Servos.

Die Ausgabe wird jetzt etwas anders realisiert.
Die mache ich jetzt im Prinzip etwa so wie sie auch mein Empfänger macht.
Schiebe einfach ein Bit durchs Port und warte per Compare Register immer so lange wie es an sein muss. (Dadruch ensteht der direkte Wechsel - ein Pin geht LOW, anderer gleichzeitig HIGH)
Danach warte ich dann noch so lange bis 20ms voll sind.

Das ganze mit Timer1 und Prescaler 1 (Eingabe UND Ausgabe) also mehr Auflösung wird sich nicht rausholen lassen.
(Aktuell läuft Timer0 nur mit um die lange Pause zum synchronisieren zu erkennen. Der wird bei jedem INT resetet, läuft er nach 4ms über, gabs zu lange kein Signal mehr, also wird alles auf Anfang gestellt)

Aktuell bin ich soweit, das nun beides funktioniert. Jitter scheint extrem gering zu sein, kann gerade nicht genau messen. Probiere ich aber noch.
Muss noch optimieren. Aber ich reiche natürlich alles an Infos nach ;-)

Gruß Basti

EDIT:
Wie am besten mit Analog Oszi den Jitter messen?
Bekomm die Flanke leider nur bis 200uS/Div. ins Bild. Dort kann man auf jeden Fall einen Jitter < 10uS erahnen.
Vermutlich noch kleiner, aber das hat dann mit messen weis Gott nix mehr zu tun.

Zitat:

---

Aktuell bin ich soweit, das nun beides funktioniert. Jitter scheint extrem gering zu sein, kann gerade nicht genau messen. Probiere ich aber noch.
Muss noch optimieren. Aber ich reiche natürlich alles an Infos nach

---

Ja, Ich freue mich auf diese Informationen. Das klingt sehr gut, das beides funktioniert.

Gruß
Enre



iphone 6 tasche

Nachtrag:
Ich hab mir mal nen ATMEGA88 beschafft und meine Idee mit den PinChanges realisiert.
Das klappt auch, wenn alle Servoimpulse zur gleichen Zeit eintreffen.

Code:

---

/*****************************************************
This program was produced by the
CodeWizardAVR V1.25.3 Standard
Automatic Program Generator
© Copyright 1998-2007 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : Einzelimpulse zu Summensignal
Version : 1.0
Date    : 30.12.2014
Author  :                   
Company : Germany       
Comments:


Chip type          : ATmega88
Program type        : Application
Clock frequency    : 16,00000 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size    : 256

Zeitversatz beim Einlesen der Impulse 15µs!
*****************************************************/

/********
PC0 = Kanal 1
PC1 = Kanal 3
PC2 = Kanal 5
PC3 = Kanal 7
PD0 = Kanal 2
PD1 = Kanal 4
PD2 = Kanal 6
PD3 = Kanal 8
PB1 = Summensignalausgang
PB2 = Syncsignal startet bei Pausenbeginn
********/

#include <mega88.h>

volatile unsigned int ui_timerold[8];    //Speicherwerte für die Steigende Flanke der entsprecheden Kanäle
volatile unsigned int ui_pulslengh[8]={3000,3000,3000,3000,3000,3000,3000,3000};  //Ermittelte Pulslängen
volatile unsigned int ui_lastchange;      //Letzter Impulsstart für Summensignalgenerierung
volatile unsigned char uc_oldgerade=0;    //Zwischenspeicher für den alten Zustand der geraden Kanäle 2,4,6,8
volatile unsigned char uc_oldungerade=0; //Zwischenspeicher für den alten Zustand der geraden Kanäle 1,3,5,7
volatile unsigned char uc_cyclecount;    //Zyklenzähler für die Impulsausgabe
#define maxcycle 17                      //Maximale Zyklenzahl für die Impulsausgabe
#define minlengh 1200                      //Minimal zulässige Impulslänge 600µs
#define midlengh 3000                      //Servo Mittelstellung
#define maxlengh 5400                    //Maximal zulässige Impulslänge 2700µs
#define interpulspause 1000                //1000 = 500µs
#define interframepause 12000              //12000 = 6ms Interframepause

//#define normal                          //Bestimmt ob die Impulsausgabe normal oder invers geschehen soll
//#define revers                          //zur Zeit noch nicht implementiert - Bedingte Assemblierung
#define portsungerade PINC                //Ungerade Kanäle auf Port C
#define portsgerade PIND                  //Gerade Kanäle auf Port D
#define outport PORTB.1                  //Summen Ausgangssignal
#define syncport PORTB.2                  //Sync Signal für Oszilloskop

// Pin change 8-14 interrupt service routine Kanal 1,3,5,7
interrupt [PCINT1] void pin_change_isr1(void)
{
unsigned char uc_portungerade,uc_result,uc_low,uc_high;
unsigned int ui_timer;
uc_portungerade=portsungerade;
uc_low=TCNT1L;
uc_high=TCNT1H;
ui_timer=uc_high;
ui_timer=ui_timer<<8;
ui_timer+=uc_low;
uc_portungerade&=0x0F;
uc_result=uc_portungerade^uc_oldungerade;
if(uc_result&0x01)
    {
    if(uc_portungerade&0x01)        //Es war ne steigende Flanke
        {
        ui_timerold[0]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[0]=ui_timer-ui_timerold[0];
        };
    }

if(uc_result&0x02)
    {
    if(uc_portungerade&0x02)        //Es war ne steigende Flanke
        {
        ui_timerold[2]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[2]=ui_timer-ui_timerold[2];
        };
    }
   
if(uc_result&0x04)
    {
    if(uc_portungerade&0x04)        //Es war ne steigende Flanke
        {
        ui_timerold[4]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[4]=ui_timer-ui_timerold[4];
        };
    }
   
if(uc_result&0x08)
    {
    if(uc_portungerade&0x08)        //Es war ne steigende Flanke
        {
        ui_timerold[6]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[6]=ui_timer-ui_timerold[6];
        };
    }
uc_oldungerade=uc_portungerade;
}

// Pin change 16-23 interrupt service routine Kanal 2,4,6,8
interrupt [PCINT2] void pin_change_isr2(void)
{
unsigned char uc_portgerade,uc_result,uc_low,uc_high;
unsigned int ui_timer;
uc_portgerade=portsgerade;
uc_low=TCNT1L;
uc_high=TCNT1H;
ui_timer=uc_high;
ui_timer=ui_timer<<8;
ui_timer+=uc_low;
uc_portgerade&=0x0F;
uc_result=uc_portgerade^uc_oldgerade;
if(uc_result&0x01)
    {
    if(uc_portgerade&0x01)        //Es war ne steigende Flanke
        {
        ui_timerold[1]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[1]=ui_timer-ui_timerold[1];
        };
    }

if(uc_result&0x02)
    {
    if(uc_portgerade&0x02)        //Es war ne steigende Flanke
        {
        ui_timerold[3]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[3]=ui_timer-ui_timerold[3];
        };
    }
   
if(uc_result&0x04)
    {
    if(uc_portgerade&0x04)        //Es war ne steigende Flanke
        {
        ui_timerold[5]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[5]=ui_timer-ui_timerold[5];
        };
    }
   
if(uc_result&0x08)
    {
    if(uc_portgerade&0x08)        //Es war ne steigende Flanke
        {
        ui_timerold[7]=ui_timer;
        }
    else                            //Es war ne fallende Flanke
        {
        ui_pulslengh[7]=ui_timer-ui_timerold[7];
        };
    }
uc_oldgerade=uc_portgerade;
}

// Timer 1 output compare A interrupt service routine
interrupt [TIM1_COMPA] void timer1_compa_isr(void)
{
unsigned char uc_low,uc_high;
unsigned int ui_buffer;
switch(uc_cyclecount)
    {
    case 0:                      //Die Pausen
    syncport=0;                    //Sychronosationsimpuls stoppen
    outport=1;
    uc_low=OCR1AL;
    uc_high=OCR1AH;
    ui_buffer=uc_high;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+uc_low;
    ui_lastchange=ui_buffer;
    ui_buffer+=interpulspause;    //Preimpuls dazuzählen und einfügen
    uc_low=ui_buffer&0x00FF;
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 1:
    outport=0;                    //Der erste Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[0];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 2:                      //Pausen zwischen den Impulsen einfügen
    case 4:
    case 6:
    case 8:
    case 10:
    case 12:
    case 14:
    case 16:
    outport=1;
    uc_low=OCR1AL;
    uc_high=OCR1AH;
    ui_buffer=uc_high;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+uc_low;
    ui_lastchange=ui_buffer;
    ui_buffer+=interpulspause;    //Pause zwischen den Impulsen dazuzählen und einfügen
    uc_low=ui_buffer&0x00FF;
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 3:
    outport=0;                    //Der zweite Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[1];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 5:
    outport=0;                    //Der dritte Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[2];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 7:
    outport=0;                    //Der vierte Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[3];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 9:
    outport=0;                    //Der fünfte Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[4];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 11:
    outport=0;                    //Der sechste Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[5];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 13:
    outport=0;                    //Der siebte Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[6];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 15:
    outport=0;                    //Der achte Impuls
    ui_buffer=ui_lastchange+ui_pulslengh[7];
    uc_low=ui_buffer&0x00FF;      //OCR Register für nächsten Interrupt vorbelegen
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    case 17:
    syncport=1;                    //Syncpuls Starten
    outport=0;
    ui_buffer=OCR1AH;              //Aktuelle Werte holen
    ui_buffer=(ui_buffer<<8)+OCR1AL;
    ui_buffer+=interframepause;    //Pause zwischen den Frames also nach 8 Impulsen einfügen
    uc_low=ui_buffer&0x00FF;
    uc_high=(ui_buffer>>8)&0x00FF;
    OCR1AH=uc_high;
    OCR1AL=uc_low;
    break;
   
    }
uc_cyclecount++;
if(uc_cyclecount>maxcycle){uc_cyclecount=0;}
}

// Declare your global variables here

void main(void)
{
// Declare your local variables here
unsigned char uc_i;
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=Out Func1=Out Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=0 State0=T
PORTB=0x00;
DDRB=0x06;

// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=P State2=P State1=P State0=P
PORTC=0x0F;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=P State2=P State1=P State0=P
PORTD=0x0F;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 1000,000 kHz
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: On
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x02;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// Interrupt on any change on pins PCINT0-7: Off
// Interrupt on any change on pins PCINT8-14: On
// Interrupt on any change on pins PCINT16-23: On
EICRA=0x00;
EIMSK=0x00;
PCICR=0x06;
PCMSK1=0x0F;
PCMSK2=0x0F;
PCIFR=0x06;

// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=0x00;
// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=0x02;
// Timer/Counter 2 Interrupt(s) initialization
TIMSK2=0x00;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
ADCSRB=0x00;

while(PINC.0==0);              //Warten auf Impulse
while(PINC.0>0);
// Watchdog Timer initialization
// Watchdog Timer Prescaler: OSC/128k
// Watchdog Timer interrupt: Off
#pragma optsize-
#asm("wdr")
WDTCSR=0x1E;
WDTCSR=0x0E;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Global enable interrupts
#asm("sei")

while (1)
      {
      #asm("wdr")
      for (uc_i=0;uc_i<8;uc_i++)
        {
        if(ui_pulslengh[uc_i]<minlengh||ui_pulslengh[uc_i]>maxlengh)
            {
            ui_pulslengh[uc_i]=midlengh;
            }
        };
      };
}

---

Der Code braucht 630 Words, also 1260Byte

Gut zu wissen, den Code werde ich mal in der Hinterhand halten.
Allerdings ganz schön viel Code, im Vergleich zu meinem ^^
Wie groß ist das ganze kompilliert? Mein Code kommt auf 1634 byte, lauffähig...

Gruß Basti

Hier mal meine aktuellen Ergebnisse

Ich hoffe einigermaßen sinnvoll programmiert und verständlich kommentiert.
Immerhin spreche ich GCC erst seit ner knappen Woche ;-)

Gruß Basti

Jitter konnte ich allein mit Analog Oszi nicht wirklich feststellen, und das obwohl ich alle Werte ca alle 100ms per UART ausgegeben habe.
Evtl kann das ja mal jemand nachmessen der besseres Gerät hat?

main.c

Code:

---

#include <avr/io.h>
#include <stdlib.h>
#include <stdint.h>


#include "inout.h"


/* define CPU frequency in Mhz here if not defined in Makefile */
#ifndef F_CPU
#define F_CPU 16000000UL
#endif


int main(void)
{
    //Ein- und Ausgabe initialisieren
    init_inout();


    while(1)
    {
        set_ch(1,get_ch(1));
        set_ch(2,get_ch(2));
        set_ch(3,get_ch(3));
        set_ch(4,get_ch(4));
        set_ch(5,get_ch(5));
        set_ch(6,get_ch(6));
    }; //Endlosschleife
   
}

---

inout.h

Code:

---

//Name: inout.c
//Autor: Bastian Schroll
//Date:  31.12.2014
//Description:
//Ließt 6 getrennte Servo Kanäle über INT0 und INT1 ein
//Die Eingangs Signale werden dem Programm per get_ch(KANAL) zur Verfügung gestellt
//Nach Verarbeitung der Signale können diese per set_ch(KANAL,PULSLÄNGE) wieder Ausgegeben werden
//Dabei werden die Signale auf PORTA.0 - .5 per Compare INT generiert


#ifndef INOUT_H
#define INOUT_H


// **************************
//        Prototypen
// **************************
void init_inout(void);//Initialisiert INT0 und INT1 sowie Timer1 und Timer0
uint16_t get_ch(uint8_t channel); //Liefert aktuellen Wert zurück
void set_ch(uint8_t channel, uint16_t puls); //Setzt Kanal 1-6 (Min. 1000 - Max. 2000)




// **************************
//        Deklarationen
// **************************
uint8_t (fail_flag); //Flag für Fail Safe Modus


#endif

---

inout.c

Code:

---

//Name: inout.c
//Autor: Bastian Schroll
//Date:  31.12.2014
//Description:
//Ließt 6 getrennte Servo Kanäle über INT0 und INT1 ein
//Die Eingangs Signale werden dem Programm per get_ch(KANAL) zur Verfügung gestellt
//Nach Verarbeitung der Signale können diese per set_ch(KANAL,PULSLÄNGE) wieder Ausgegeben werden
//Dabei werden die Signale auf PORTA.0 - .5 per Compare INT generiert


#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>


#include "inout.h"


// **************************
//        Prototypen
// **************************
void init_inout(void);//Initialisiert INT0 und INT1 sowie Timer1 und Timer0
uint16_t get_ch(uint8_t channel); //Liefert aktuellen Wert zurück
void set_ch(uint8_t channel, uint16_t puls); //Setzt Kanal 1-6 (Min. 1000 - Max. 2000)




// **************************
//        Deklarationen
// **************************
//IN
volatile uint16_t (input_channel)[7]; //Array für die einzelnen Kanäle
uint8_t (fail_flag); //Flag für Fail Safe Modus


volatile uint16_t (input_channel_tmp)[7]; //Array für Timer1 Messwerte
uint8_t (in_ch_cnt); //Counter für aktuellen Kanal
uint8_t (fail_cnt); //Zähler für Fehlmessungen


//OUT
volatile uint16_t (output_channel)[7]; //Array für die einzelnen Kanäle


uint32_t (sig_rest) = 320000; //Wird auf 20ms gesetzt und dann wird jede Ch Ausgabe abgezogen. Was übrig bleibt muss Pause sein
uint8_t (out_ch_cnt); //Counter für aktuellen Kanal




void init_inout(void)
{
    //PORTA als Ausgang
    DDRA = 0b11111111;   


    //INT0 und INT1 als Eingang (vermutlich unnötig bei INT Konfiguration?)
    DDRD &= ~((1 << DDD2) | (1 << DDD3));
    //Beide INT auf steigene Flanke konfigurieren
    MCUCR |= ((1 << ISC01) | (1 << ISC00)); //INT0
    MCUCR |= ((1 << ISC11) | (1 << ISC10)); //INT1
    //INT0 und INT1 aktivieren
    GICR |= ((1 << INT0) | (1 << INT1));


    //Timer0 auf Pres 256 (~4ms)
    TCCR0 |= (1 << CS02);
    //Timer0 Overflow INT aktivieren
    TIMSK |= (1 << TOIE0);


    //Timer1 Prescaler auf 1 stellen
    TCCR1B |= (1 << CS10);
    //Timer1 CompareA Interrupt aktivieren
    TIMSK |= (1 << OCIE1A);


    //Interrupts anschalten
    sei();
};




//ISR von INT0
ISR(INT0_vect)
{   
    //speichere Zählerstand von Timer1
    input_channel_tmp[in_ch_cnt] = TCNT1;
    //Ch Zähler erhöhen
    in_ch_cnt++;
    //Timer0 zurücksetzen
    TCNT0 = 0;
    //bei letztem Kanal INT0 auf fallende Flanke
    if(in_ch_cnt == 6){MCUCR &= ~(1 << ISC00);}
}




//ISR von INT1
ISR(INT1_vect)
{
    //speichere Zählerstand von Timer1
    input_channel_tmp[in_ch_cnt] = TCNT1;
    //Ch Zähler erhöhen
    in_ch_cnt++;
    //Timer0 zurücksetzen
    TCNT0 = 0;
    //bei letztem Kanal INT0 auf fallende Flanke
    if(in_ch_cnt == 6){MCUCR &= ~(1 << ISC10);}
}




//Erkennt die lange Synronitäts Pause im Eingangssignal
//Wenn länger als 4ms kein Interrupt passiert wird diese ISR geworfen.
ISR(TIMER0_OVF_vect)
{
    //Prüfen ob wirklich alle INT kamen (Alle Signale erfasst)
    if(in_ch_cnt == 7)
    {   
        //Wenn ja, Fail Flag und Zähler zurücksetzen
        fail_flag = 0;
        fail_cnt = 0;
       
        uint8_t i;
          for (i=1; i<=6; i++){
            //Aktuelles Eingangssignal = Endwert - Startwert
            input_channel[i] = input_channel_tmp[i] - input_channel_tmp[i-1];
          }
    }
    else
    {   
        //Wenn mehr als 5 Fehlmessungen detektiert wurden, wird das Fail Flag gesetzt
        fail_cnt++;
        if(fail_cnt >= 5){fail_flag = 1;}
    }
    //Kanalzähler zurücksetzen
    in_ch_cnt = 0;
    //Beide INT auf steigene Flanke konfigurieren
    MCUCR |= ((1 << ISC01) | (1 << ISC00)); //INT0
    MCUCR |= ((1 << ISC11) | (1 << ISC10)); //INT1
}




//Kümmert sich um die Ausgabe der 6 Signale
ISR(TIMER1_COMPA_vect)
{       
    //Wenn Ch1 beginnt, PORTA.0 auf High
    if(out_ch_cnt == 0)
    {
        PORTA = 1;
    }   


    //Solange noch nicht alle Channel abgearbeitet
    if(out_ch_cnt <= 6)
    {
        //Bit in PORTA weiter schieben
        PORTA = (1 << out_ch_cnt);
        //Kanal Zähler erhöhen
        out_ch_cnt ++;
        //CompareA Register von T1 auf den Wert des Kanals setzen
        OCR1A = TCNT1 + output_channel[out_ch_cnt];
        //Zeit von den 20ms Gesamtlänge abziehen
        sig_rest -= output_channel[out_ch_cnt];
    }
    else //Wenn alle Kanäle durch sind
    {   
        //PORTA abschalten
        PORTA = 0;
        //Prüfen ob noch mehr Zeit, als ein kompletter Durchlauf abzuwarten ist
        if(sig_rest > 65536)
        {
            //Einen vollen Zyklus abwarten und vom Rest-Zeitzähler abziehen
            OCR1A = TCNT1 + 65536;
            sig_rest -= 65536;   
        }
        else//Wenn kein kompletter Durchlauf mehr möglich ist
        {
            //Die restliche Zeit warten und alles für einen neuen Durchgang voreinstellen
            OCR1A = TCNT1 + sig_rest;   
            out_ch_cnt = 0;   
            sig_rest = 320000 - 60000; //Entsprich 20ms bei Timer1 16MHZ/Prescaler1   
            //Da dir ISR natürlich auch ein wenig Rechnenzeit verbraucht ziehen wir einfach 60.000 Ticks ab
            //Damit kommen wir dann laut Oszi auf exakt 20ms Versatz zwischen den Pulsen (ausporbiert)   
        }
    }
}




//Liefert Wert des Kanals zurück
uint16_t get_ch(uint8_t channel)
{
    return input_channel[channel] / 16;
}




//Zum setzen einzelner Kanäle
void set_ch(uint8_t channel, uint16_t puls)
{   
    //Wert auf Min und Max begrenzen
    if(puls < 1000){puls = 1000;}
    else if(puls > 2000){puls = 2000;}


    output_channel[channel] = puls * 16;
}

---