/*****************************************************
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 : Multiswitch Empfänger
Version : 1.1
Date    : 25.10.2009
Author  : Wilhelm Krug                    
Company : 92345 Dietfurt, Germany         
Comments: 


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


#include <mega8.h>
#include <delay.h>
#include <math.h>

/* Portbelegung des ATMEGA 8
PortB,0 = Ausgang 1
PortB,1 = Ausgang 2
PortB,2 = Ausgang 3
PortB,3 = Ausgang 4
PortB,4 = Ausgang 5
PortB,5 = Ausgang 6
PortC,0 = Ausgang 7
PortC,1 = Ausgang 8
PortC,2 = Ausgang 9
PortC,3 = Ausgang 10
PortC,4 = Ausgang 11
PortC,5 = Ausgang 12
PortD,0 = Ausgang 13
PortD,1 = Ausgang 14
PortD,2 = Servoeingang bzw. Schrittschaltwerk mit Widerstand gegen Masse und Optokoppler gegen +
PortD,3 = Servoeingang zusätzlicher Eingang vorerst frei
PortD,4 = Ausgang 15
PortD,5 = Ausgang 16
PortD,6 = Grüne LED mit Vorwiderstand gegen + und Tastereingang
PortD,7 = Rote LED mit Vorwiderstand gegen + und Programmierbrücke
*/
// Declare your global variables here
bit newvalue0=0;/* Bei 1 = Neue Werte vorhanden Bearbeitung notwendig*/
bit newvalueint=0;/* Bei 1 = Neue Werte nur für Interruptbearbeitung vorhanden */
bit sync1=0;/* Flag Bei 1 = Synchronisationspuls 1 empfangen (langer Impuls)*/
bit sync2=0;/* Flag Bei 2 = Synchronisationspuls 2 empfangen (langer Impuls)*/
bit setport=0;/* Alle 8 Kanäle wurden empfangen -> zur Auswertung*/
bit error=0;/* Fehler - Impulse zu lang oder zu kurz */
bit countpulse=0;/* Ein Counter 0 Overflow Interrupt wurde abgearbeitet (nötig für Setup Routine)*/

volatile unsigned char uc_kanal=0;
volatile unsigned char uc_mode[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
volatile unsigned char uc_sectimer=0;

volatile unsigned int ui_starttime0,ui_endtime0,ui_value0;
volatile unsigned int ui_oldvalue[9]={1595,1595,1595,1595,1595,1595,1595,1595,1595};
volatile unsigned int ui_value[9]={1596,1596,1596,1596,1596,1596,1596,1596,1596};
volatile unsigned int ui_kancount[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
volatile unsigned int ui_kantime[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

flash unsigned int ui_minerror=850; /* Untere Fehlergrenze */
flash unsigned int ui_maxerror=2350; /* Obere Fehlergrenze */
flash unsigned int ui_minpuls=1345; /* Untere Schaltschwelle */
flash unsigned int ui_maxpuls=1740; /* Obere Schaltschwelle */
flash unsigned int ui_syncpuls=2030; /* alt 1940 Synchronisationspuls */

eeprom unsigned int ee_kantime[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
eeprom unsigned char ee_mode[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
#asm
    .equ tcnt1l=0x2C
    .equ tcnt1h=0x2D
    .equ PORTB=0x18
    .equ PORTC=0x15
    .equ PORTD=0x12
    .equ DDRD=0x11
    .equ PIND=0x10
#endasm



// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
unsigned char stat=0;
#asm
        push r22                ;Register retten
        in r22,SREG
        push r22
        push r23
        push r24
        push r25
        in r22,tcnt1l             ;Timer 1 auslesen
        in r23,tcnt1h
        in r24,MCUCR           ;Status laden
        bst r24,0               ;Wenn das Bit 0 von "MCUCR" gesetzt ist
        brtc mess1              ;2 ten Messung auslesen und beenden
        sts _ui_starttime0,r22          ;Startwert für Servo 1 abspeichern
        sts _ui_starttime0+1,r23
        in r22,MCUCR            ;MCUCR Register laden
        cbr r22,0b00000011      ;Interruptstatus für INT0 löschen
        sbr r22,0b00000010      ;Interruptstatus auf fallende Flanke einstellen
        out MCUCR,r22
        rjmp endisr0
    
    mess1:    
        sts _ui_endtime0,r22          ;Endwert für Servo 1 abspeichern
        sts _ui_endtime0+1,r23
        lds r24,_ui_starttime0          ;Startwert von Servo 1 holen
        lds r25,_ui_starttime0+1
        sub r22,r24             ;Startwert vom Endwert abziehen
        sbc r23,r25
        sts _ui_value0,r22          ;... das ergiebt den Wert für die Servoimpulslänge Servo 1
        sts _ui_value0+1,r23          ;der wird hier zur Verarbeitung abgespeichert
        in r22,MCUCR            ;MCUCR Register holen
        sbr r22,0b00000011      ;auf INT1 steigende Flanke einstellen
        out MCUCR,r22           ;Den neuen Wert zurückschreiben
    endisr0:
        pop r25                 ;Register zurückholen
        pop r24
        pop r23
        pop r22
        out SREG,r22
        pop r22

#endasm
stat=MCUCR;
stat=stat&0b00000001; /*War ein Impuls dran oder ne Pause ? */
if (stat==1)
    {
    newvalue0=1;
    newvalueint=1;
    }
else
    {
    newvalue0=0;
    newvalueint=0;
    }    

if (newvalueint==1&&(ui_value0<ui_minerror||ui_value0>ui_maxerror)) /* Fehler: Impulse zu lang oder zu kurz */
    {
    error=1;
    newvalue0=0;
    newvalueint=0;
    sync1=0;
    sync2=0;
    uc_kanal=0;
    }

if (newvalueint==1&&ui_value0>ui_syncpuls&&sync1==0)/* Der erste Sync Impuls wurde empfangen */
    {
    setport=0;
    sync1=1;
    sync2=0;
    uc_kanal=0;
    newvalueint=0;
    uc_sectimer=10;/* Sicherheitstimer wird resettet */
    }
    
if (newvalueint==1&&ui_value0<ui_syncpuls&&sync1==1)/* Fehler kurzer Impuls nach erstem Sync Impuls wurde empfangen */
    {
    setport=0;
    sync1=0;
    sync2=0;
    uc_kanal=0;
    newvalueint=0;
    }
    
if (newvalueint==1&&ui_value0>ui_syncpuls)/* Der zweite Sync Impuls wurde empfangen */
    {
    setport=0;
    sync1=0;
    sync2=1;
    uc_kanal=0;
    newvalueint=0;
    }

if (newvalueint==1&&sync2==1&&sync1==0)/* Die einzelnen 8 Kanäle 0..7 werden bearbeitet */
    {
    ui_value[uc_kanal]=ui_value0;
    uc_kanal++;
    if (uc_kanal==8)
        {
        setport=1;
        }
    if (uc_kanal>8)/* wenn mehr als 8 Kanäle übertragen werden ... */
        {
        uc_kanal=8;
        }
    newvalueint=0;
    }      
}
 
// Timer 0 overflow interrupt service routine
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
unsigned char i=0;
#asm ("SEI");
countpulse=1;
    for (i=0;i<16;i++)
    {
        if (ui_kancount[i]>0)
        {
            ui_kancount[i]--;
        }

    }
    if (uc_sectimer>0)
    {
        uc_sectimer--;
    }
}

//Setup Routine
void setup (void)
{
volatile unsigned char i=0;
#asm ("SEI"); /* Interrupts freigeben */
    for (i=0;i<16;i++)
    {
        ui_kantime[i]=0xFFFF;/* Zähler vorbereiten */
        uc_mode[i]=0;/* Kanal Mode auf 0 setzen */
    }    
/*LED vom Controller aus einschalten */
#asm ("CBI PORTD,6");
#asm ("SBI DDRD,6");

delay_ms(1000);/*Eine Sekunde warten*/

/*LED vom Controller aus ausschalten */
#asm ("CBI DDRD,6");
#asm ("SBI PORTD,6");

// Programmierung des Kanalmodes
while ((PIND&0b01000000)==0b01000000)
{
    for (i=0;i<8;i++)
    {
        if (ui_value[i]>ui_maxpuls)
        {
            uc_mode[i]=1;
        }
    }
    for (i=0;i<8;i++)
    {
        if (ui_value[i]<ui_minpuls)
        {
            uc_mode[i+8]=1;
        }
    }
//Port Leds schalten !
    if (uc_mode[0]==1)/* Kanal 1*/
    {
        #asm ("sbi PORTB,0");
    }
    else
    {
        #asm ("cbi PORTB,0");
    }
    if (uc_mode[1]==1) /* Kanal 2*/
    {
        #asm ("sbi PORTB,1");
    }
    else
    {
        #asm ("cbi PORTB,1");
    }
    if (uc_mode[2]==1) /* Kanal 3*/
    {
        #asm ("sbi PORTB,2");
    }
    else
    {
        #asm ("cbi PORTB,2");
    }
    if (uc_mode[3]==1)/* Kanal 4*/
    {
        #asm ("sbi PORTB,3");
    }
    else
    {
        #asm ("cbi PORTB,3");
    }
    if (uc_mode[4]==1)/* Kanal 5*/
    {
        #asm ("sbi PORTB,4");
    }
    else
    {
        #asm ("cbi PORTB,4");
    }
    if (uc_mode[5]==1) /* Kanal 6*/
    {
        #asm ("sbi PORTB,5");
    }
    else
    {
        #asm ("cbi PORTB,5");
    }
    if (uc_mode[6]==1)/* Kanal 7*/
    {
        #asm ("sbi PORTC,0");
    }
    else
    {
        #asm ("cbi PORTC,0");
    }
    if (uc_mode[7]==1)/* Kanal 8*/
    {
        #asm ("sbi PORTC,1");
    }
    else
    {
        #asm ("cbi PORTC,1");
    }
    if (uc_mode[8]==1) /* Kanal 9*/
    {
        #asm ("sbi PORTC,2");
    }
    else
    {
        #asm ("cbi PORTC,2");
    }
    if (uc_mode[9]==1)/* Kanal 10*/
    {
        #asm ("sbi PORTC,3");
    }
    else
    {
        #asm ("cbi PORTC,3");
    }
    if (uc_mode[10]==1) /* Kanal 11*/
    {
        #asm ("sbi PORTC,4");
    }
    else
    {
        #asm ("cbi PORTC,4");
    }
    if (uc_mode[11]==1)/* Kanal 12*/
    {
        #asm ("sbi PORTC,5");
    }
    else
    {
        #asm ("cbi PORTC,5");
    }
    if (uc_mode[12]==1) /* Kanal 13*/
    {
        #asm ("sbi PORTD,0");
    }
    else
    {
        #asm ("cbi PORTD,0");
    }
    if (uc_mode[13]==1) /* Kanal 14*/
    {
        #asm ("sbi PORTD,1");
    }
    else
    {
        #asm ("cbi PORTD,1");
    }
    if (uc_mode[14]==1) /* Kanal 15*/
    {
        #asm ("sbi PORTD,4");
    }
    else
    {
        #asm ("cbi PORTD,4");
    }
    if (uc_mode[15]==1) /* Kanal 16*/
    {
        #asm ("sbi PORTD,5");
    }
    else
    {
        #asm ("cbi PORTD,5");
    }

}
/*LED durch den Controller einschalten */
#asm ("CBI PORTD,6");
#asm ("SBI DDRD,6");

delay_ms(2000);

/*LED durch den Controller ausschalten */
#asm ("CBI DDRD,6");
#asm ("SBI PORTD,6");

// Programmierung der Kanal - Einschaltdauern
countpulse=0;
while ((PIND&0b01000000)==0b01000000)
{
    if (countpulse==1)
    {
        for (i=0;i<8;i++)
        {
            if (ui_value[i]>ui_maxpuls&&countpulse==1)/* Die Einschaltzeit herunterzählen */
            {
                ui_kantime[i]--;
            }
        }
        for (i=0;i<8;i++)
        {
            if (ui_value[i]<ui_minpuls&&countpulse==1)
            {
                ui_kantime[i+8]--;
            }
        }
        countpulse=0;
    }
    
}
/*LED durch den Controller einschalten */
#asm ("CBI PORTD,6");
#asm ("SBI DDRD,6");

delay_ms(2000);

// Werte im EEPROM abspeichern
#asm ("CLI");
    for (i=0;i<16;i++)
    {
        ui_kantime[i]=0xFFFF-ui_kantime[i];
        if(ui_kantime[i]<30)
        {
            ui_kantime[i]=30;/* (Minimale Einschaltdauer 1 Sekunde)*/
        }
        ee_kantime[i]=ui_kantime[i];
        ee_mode[i]=uc_mode[i];
    }
/*LED durch den Controller ausschalten */
#asm ("CBI DDRD,6");
#asm ("SBI PORTD,6");

//Gehe niemals raus hier ! -> Zwang zum manuellen abschalten
while (1){#asm ("nop");}
}


//Routine zum Einschalten der Ports
void setports (void)
    {
    unsigned char uc_i=0;
    //Impulstimer für Kanäle 1..8 mit laufzeitwert vorladen
    //Beim nächsten durchlauf werden Sie eingeschaltet
    for (uc_i=0;uc_i<8;uc_i++)
    {
        if (uc_mode[uc_i]==1)
        {
            if (ui_value[uc_i]>ui_maxpuls&&ui_oldvalue[uc_i]<ui_maxpuls)
            {
            ui_kancount[uc_i]=ui_kantime[uc_i];
            }
        }
                  
    }
    //Impulstimer für Kanäle 9..16 mit laufzeitwert vorladen
    //Beim nächsten durchlauf werden Sie eingeschaltet
    for (uc_i=0;uc_i<8;uc_i++)
    {
        if (uc_mode[uc_i+8]==1)
        {
            if (ui_value[uc_i]<ui_minpuls&&ui_oldvalue[uc_i]>ui_minpuls)
            {
                ui_kancount[uc_i+8]=ui_kantime[uc_i+8];
            }
        }
            
    }    


    /* 1. Kanal */
    if (ui_value[0]>ui_maxpuls&&ui_oldvalue[0]>ui_maxpuls)
        {
            if (uc_mode[0]==1&&ui_kancount[0]==0) /* Wenn die Einschaltezeit abgelaufen ist Port abschalten */
            {
                #asm ("cbi PORTB,0");
            }
            else
            {    
                #asm ("sbi PORTB,0");
            }
        }
    else
        {            
        #asm ("cbi PORTB,0");
        }
    
    /* 2. Kanal */
    if (ui_value[1]>ui_maxpuls&&ui_oldvalue[1]>ui_maxpuls)
        {
            if (uc_mode[1]==1&&ui_kancount[1]==0)
            {
                #asm ("cbi PORTB,1");
            }
            else
            {
                #asm ("sbi PORTB,1");
            }
        }
    else
        {            
        #asm ("cbi PORTB,1");
        }
    /* 3. Kanal */
    if (ui_value[2]>ui_maxpuls&&ui_oldvalue[2]>ui_maxpuls)
        {
            if (uc_mode[2]==1&&ui_kancount[2]==0)
            {
                #asm ("cbi PORTB,2");
            }
            else        
            {
                #asm ("sbi PORTB,2");
            }
        }
    else
        {            
        #asm ("cbi PORTB,2");
        }
    /* 4. Kanal */
    if (ui_value[3]>ui_maxpuls&&ui_oldvalue[3]>ui_maxpuls)
        {
            if (uc_mode[3]==1&&ui_kancount[3]==0)
            {
                #asm ("cbi PORTB,3");
            }
            else        
            {
                #asm ("sbi PORTB,3");
            }
        }
    else
        {            
        #asm ("cbi PORTB,3");
        }
    /* 5. Kanal */
    if (ui_value[4]>ui_maxpuls&&ui_oldvalue[4]>ui_maxpuls)
        {
            if (uc_mode[4]==1&&ui_kancount[4]==0)
            {
                #asm ("cbi PORTB,4");
            }
            else        
            {
                #asm ("sbi PORTB,4");
            }
        }    
    else
        {            
        #asm ("cbi PORTB,4");
        }
    
    /* 6. Kanal */
    if (ui_value[5]>ui_maxpuls&&ui_oldvalue[5]>ui_maxpuls)
        {
            if (uc_mode[5]==1&&ui_kancount[5]==0)
            {
                #asm ("cbi PORTB,5");
            }
            else       
            {
                #asm ("sbi PORTB,5");
            }
        }
    else
        {            
        #asm ("cbi PORTB,5");
        }
    
    /* 7. Kanal */
    if (ui_value[6]>ui_maxpuls&&ui_oldvalue[6]>ui_maxpuls)
        {
            if (uc_mode[6]==1&&ui_kancount[6]==0)
            {
                #asm ("cbi PORTC,0");
            }
            else
            {        
                #asm ("sbi PORTC,0");
            }
        }
    else
        {            
        #asm ("cbi PORTC,0");
        }
    
    /* 8. Kanal */
    if (ui_value[7]>ui_maxpuls&&ui_oldvalue[7]>ui_maxpuls)
        {
            if (uc_mode[7]==1&&ui_kancount[7]==0)
            {
                #asm ("cbi PORTC,1");
            }
            else        
            {
                #asm ("sbi PORTC,1");
            }
        }
    else
        {            
        #asm ("cbi PORTC,1");
        }
    
   /* 9. Kanal */
    if (ui_value[0]<ui_minpuls&&ui_oldvalue[0]<ui_minpuls)
        {
            if (uc_mode[8]==1&&ui_kancount[8]==0)
            {
                #asm ("cbi PORTC,2");
            }
            else        
            {
                #asm ("sbi PORTC,2");
            }
        }
    else
        {            
        #asm ("cbi PORTC,2");
        } 
    
    /* 10. Kanal */
    if (ui_value[1]<ui_minpuls&&ui_oldvalue[1]<ui_minpuls)
        {
            if (uc_mode[9]==1&&ui_kancount[9]==0)
            {
                #asm ("cbi PORTC,3");
            }
            else        
            {
            #asm ("sbi PORTC,3");
            }
        }
    else
        {            
        #asm ("cbi PORTC,3");
        }
    
    /* 11. Kanal */
    if (ui_value[2]<ui_minpuls&&ui_oldvalue[2]<ui_minpuls)
        {
            if (uc_mode[10]==1&&ui_kancount[10]==0)
            {
                #asm ("cbi PORTC,4");
            }
            else        
            {
                #asm ("sbi PORTC,4");
            }
        }
    else
        {            
        #asm ("cbi PORTC,4");
        }
    
    /* 12. Kanal */
    if (ui_value[3]<ui_minpuls&&ui_oldvalue[3]<ui_minpuls)
        {
            if (uc_mode[11]==1&&ui_kancount[11]==0)
            {
                #asm ("cbi PORTC,5");
            }
            else        
            {
                #asm ("sbi PORTC,5");
            }
        }
    else
        {            
        #asm ("cbi PORTC,5");
        }
    
    /* 13. Kanal */
    if (ui_value[4]<ui_minpuls&&ui_oldvalue[4]<ui_minpuls)
        {
            if (uc_mode[12]==1&&ui_kancount[12]==0)
            {
                #asm ("cbi PORTD,0");
            }
            else        
            {
                #asm ("sbi PORTD,0");
            }
        }
    else
        {            
        #asm ("cbi PORTD,0");
        }
    
    /* 14. Kanal */
    if (ui_value[5]<ui_minpuls&&ui_oldvalue[5]<ui_minpuls)
        {
            if (uc_mode[13]==1&&ui_kancount[13]==0)
            {
                #asm ("cbi PORTD,1");
            }
            else        
            {
                #asm ("sbi PORTD,1");
            }
        }
    else
        {            
        #asm ("cbi PORTD,1");
        }
    
    /* 15. Kanal */
    if (ui_value[6]<ui_minpuls&&ui_oldvalue[6]<ui_minpuls)
        {
            if (uc_mode[14]==1&&ui_kancount[14]==0)
            {
                #asm ("cbi PORTD,4");
            }
            else        
            {
                #asm ("sbi PORTD,4");
            }
        }
    else
        {            
        #asm ("cbi PORTD,4");
        }
    
    /* 16. Kanal */
    if (ui_value[7]<ui_minpuls&&ui_oldvalue[7]<ui_minpuls)
        {
            if (uc_mode[15]==1&&ui_kancount[15]==0)
            {
                #asm ("cbi PORTD,5");
            }
            else        
            {
                #asm ("sbi PORTD,5");
            }
        }    
    else
        {            
        #asm ("cbi PORTD,5");
        }
    
    // Der verarbeitetet aktuelle Wert wird in den OLD Speicher übernommen
    for (uc_i=0;uc_i<8;uc_i++)
        {
        ui_oldvalue[uc_i]=ui_value[uc_i];
        };
    }   
    
void clearports(void)/* Ports abschalten bei Fehler usw.*/
{    
    PORTB=0b00000000;
    PORTC=0b00000000;
    PORTD=0b11000000; /* 11 am Anfang schaltet auch die LED's ab */
}



void main(void)
{
// Declare your local variables here
volatile unsigned char i=0;
// Input/Output Ports initialization
// Port B initialization
// Func7=In Func6=In Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 
// State7=T State6=T State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 
PORTB=0x00;
DDRB=0x3F;

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

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

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 7,813 kHz
TCCR0=0x05;
TCNT0=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: Off
// 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
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// INT1: Off
// INT1 Mode: Off
GICR|=0x40;
MCUCR=0x03;
GIFR=0x40;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x01;

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

// Global enable interrupts
#asm("sei");
// Wenn Brücke gesteckt -> Setup aufrufen
if ((PIND&(1<<7))==0)
{
    setup();
}
/*Werte aus dem EEPROM holen*/
for (i=0;i<16;i++)
{
    uc_mode[i]=ee_mode[i];
    ui_kantime[i]=ee_kantime[i];
}
DDRD=0xB3;
PORTD=0b11000000;
/* Hauptprogramm */
while (1)
      {
      if (error==1)
            {
            clearports();
            error=0;
            }
      if (setport==1&&sync2==1&&newvalue0==1)/*Nur nach Empfang von Sync 1+2 + 8 Kanälen */
            {
            newvalue0=0;
            setports();
            sync1=0; /*Warten auf neuen Sync Impuls*/
            sync2=0; 
            #asm
            SBIS PORTD,7
            RJMP LEDOFF
            SBIC PORTD,7
            RJMP LEDON
            LEDOFF:
            SBI PORTD,7
            RJMP END
            LEDON:
            CBI PORTD,7
            END:
            NOP          
            
            #endasm/* LED PD,7 blinkt */
            }
      if (uc_sectimer==0)
      {
      clearports();/*Ports bei Ausfall des Servosigal ausschalten. Wird bei neuem Servoimpuls resettet*/
      }
    }
}