Sterowanie ośmioma serwami na Atmega8 - błędy w kodzie C/C++

#include <avr/interrupt.h>
#include <avr/delay.h>
 
volatile int counter=0;
int serwo1, serwo2, serwo3, serwo4, serwo5, serwo6, serwo7, serwo8;

//   volatile unit8_t flagi;
  unsigned char liczt0;

 
  ISR(SIG_OVERFLOW0)
 
     {
      TIMSK |= _BV(TOIE2);
      TCNT0=200;
      counter++;
    }

   
 int main(void)
  {
   DDRB=0b00000111;
   DDRD=0b11101100;
   DDRC=0x00;
   
 

   TIMSK = (1<<TOIE0) | (1<<TOIE2); //elaczenie przerwan
 //  TCNT0=200 ; // od 61 liczy do 255 - przepelnienie
   TCCR0 = _BV(CS00) ; //ust bez preskalera
 
 
   
   sei();
  //   if ((PINC & 0x01) == 0)
//
//      serwo7=10;
//   else
//      serwo7=22;

   
        serwo1=8;
        serwo2=12;
        serwo3=12;
        serwo4=12;
        serwo5=12;
        serwo6=12;
        serwo7=12;
        serwo8=12;

   while(1)
   {
      if (counter<=1)
      {
      PORTD |= _BV(2); // SERWO 1
      PORTD |= _BV(3); // SERWO 2
      PORTD |= _BV(5); // SERWO 3
      PORTD |= _BV(6); // SERWO 4         
      PORTD |= _BV(7); // SERWO 5            
      PORTB |= _BV(0); // portb0=1 SERWO 6
      PORTB |= _BV(1); // SERWO 7
      PORTB |= _BV(2); // SERWO 8   
      }
      
         if (counter>=serwo1)
      PORTD &= ~(_BV(2));

         if (counter>=serwo2)
      PORTD &= ~(_BV(3));

         if (counter>=serwo3)
      PORTD &= ~(_BV(5));

         if (counter>=serwo4)
      PORTD &= ~(_BV(6));

         if (counter>=serwo5)
      PORTD &= ~(_BV(7));

      if (counter>=serwo6)
      PORTB &= ~(_BV(0));

      if (counter>=serwo7)
      PORTB &= ~(_BV(1));

      if (counter>=serwo8)
      PORTB &= ~(_BV(2));


      if (counter>=500)
      counter=0;

/*   if(licznik==zadane0)
      PORTD &= ~(_BV(6));
   if(licznik==zadane0)
      PORTD &= ~(_BV(7));
   if(licznik==zadane0)
      PORTB &= ~(_BV(0));
   if(licznik==zadane1)
      PORTB &= ~(_BV(1));      
   if(licznik == zadane2)
         PORTB &= ~(_BV(2));
   if(licznik == 100)
      {
      TIMSK &= ~(_BV(TOIE2));
      TCCR2 = 0;
      licznik = 0;
      }                        */
   }
}

DDRB=0b00000111; 
   DDRD=0b11101100; 
   DDRC=0x00;

PORTD |= _BV(2); // SERWO 1 
      PORTD |= _BV(3); // SERWO 2 
      PORTD |= _BV(5); // SERWO 3 
      PORTD |= _BV(6); // SERWO 4          
      PORTD |= _BV(7); // SERWO 5            
      PORTB |= _BV(0); // portb0=1 SERWO 6 
      PORTB |= _BV(1); // SERWO 7 
      PORTB |= _BV(2); // SERWO 8 

– Three PWM Channels

// 8 = neutral		3=noga prawo		14=noga lewo
#include <avr/interrupt.h> 
#include <avr/delay.h> 
 
volatile int counter, licz =0;
int serwo1, serwo2, serwo3, serwo4, serwo5, serwo6, serwo7, serwo8;


  
  ISR(SIG_OVERFLOW0) 
  
  	{ 
		TIMSK |= _BV(TOIE0);
		TCNT0=250; 
		counter++

		if (counter>=50)  // 107 to ok 20ms
		counter=0; 

		if (counter==0)
		{
		PORTD = 0b11101100;
	
		}
		

			if (counter==serwo1)
		PORTD &= ~(_BV(2));

			if (counter==serwo2)
		PORTD &= ~(_BV(3));
	} 

// przewanie pomocnicze przerw miedzy ruchem poszczegolnych serw
						
                                                       ISR(SIG_OVERFLOW2) 
  
  				{ 
					TIMSK |= _BV(TOIE2);
					
					TCNT2=0; 
					licz++;
					}					
    
 int main(void) 
  { 
  	
   DDRB=0b00000111; 
   DDRD=0b11101100;
  
   TIMSK = (1<<TOIE0) | (1<<TOIE2); //wlaczenie przerwan 
 
   TCCR0 = _BV(CS00) ; //ust preskalera dla Timer0 na 1
   TCCR2 = _BV(CS22)| _BV(CS21)| _BV(CS20) ; //ust preskalera dla Timer2 na 1024
 
   
   sei();

	
		  serwo1=8;
		  serwo2=8;


	 void prawa_przod ()
		{
		if (licz<100)
		serwo1=5;

		if (licz==50)
		{
		serwo2=5;
		
		}
		if (licz==100)
		{
		serwo1=3;
	
		}
		if (licz==150)
		{
		serwo2=3;
	
		}
		if (licz==200)
		{
		serwo1=14;
	
		}
		if (licz==250)
		{
		serwo2=11;
		
		}
		if (licz==300)
		{
		serwo1=11;
		
		}
		
		}
   while(1)
   {
 prawa_przod();
		
   }
}

//dla 16 MHz - Atmega8
//40 - 180stopni, FF - ok.30 stopni:/
#include <avr/io.h>
#include <avr/interrupt.h>

unsigned char volatile polozenie[8] = {0x40,0x30,0x70,0x90,0x40,0xFF,0xFF,0xFF}; // wartosc impulsu do serwa
unsigned char volatile wartosc[8] = {0x04,0x04,0x04,0x08,0x10,0x20,0x40,0x80}; 	// kolejne numery portu D
int numer; 


ISR(TIMER2_COMP_vect)
{
if (numer==8) numer=0;

if (polozenie[numer]>0)
  {
   OCR1AL = polozenie[numer];
   numer++; 
 }

TCCR1B|=_BV(CS11);
TCNT1L=0x00;
PORTD=wartosc[numer];
}


ISR(TIMER1_COMPA_vect)
{
   PORTD=0x00;
   TCCR1B=(0<<CS11);
   TCNT1L=0x00;
}


void main(void)
{
// Ustawienia licznika 2   
TCCR2=_BV(WGM21)|_BV(CS22)|_BV(CS20); 	// kasowanie timera przy zrównaniu (CTC) | preskaler 128
OCR2= 0x12;								// wartość porównywana do TCNT2 i przerwanie
   
//Ustawienia licznika 1
TCCR1B=_BV(CS11)/*|_BV(CS10)*/|_BV(WGM12);// preskaler na 8 | CTC z OCR1A
OCR1AL=0x00;								// porównywane z TCNT1
   
//Odblokowanie przerwan   
   TIMSK=_BV(OCIE2)|_BV(OCIE1A);
   TIFR =_BV(OCF2)|_BV(OCF1A);
   sei();
   DDRD=0xFC;

   while(1)
   {
   }
}