Atmega16 generowanie przebiegów pwm na 16 serw

Code C - [expand]
 
void SerwaInit()
{	
	i=0;
	//ustawienie portów gdzie są podłączone serwa jako wyjscia
	DDRSERWOA=0xFF;
	#ifdef SERWA16
		DDRSERWOA=0xFF;
	#endif
	//inicjacja poszczególnych serw
	int i;
	for( i=0;i<8;i++)
	{
		serwa[i].enable=0;
		serwa[i].nrPort=i;
		serwa[i].skok=2;
		serwa[i].pos=(1.0f/667.0f)/(64.0f/(float)F_CPU); //1.5ms 667hz
		serwa[i].max=(1.0f/455.0f)/(64.0f/(float)F_CPU); //2.2ms 455hz
		serwa[i].min=(1.0f/1250.0f)/(64.0f/(float)F_CPU); //0.8ms 1250hz
		#ifdef SERWA16
			serwa[i+8].enable=0;
			serwa[i+8].nrPort=i;
			serwa[i+8].skok=2;
			serwa[i+8].pos=(1.0f/667.0f)/(64.0f/(float)F_CPU); //1.5ms 667hz
			serwa[i+8].max=(1.0f/455.0f)/(64.0f/(float)F_CPU); //2.2ms 455hz
			serwa[i+8].min=(1.0f/1250.0f)/(64.0f/(float)F_CPU); //0.8ms 1250hz
		#endif
	}
	//timer1
	//Tryb CTC timera
 
	TCCR1B|=(1<<WGM12) | (1<<CS10)|(1 << CS11);//preskaler 64 i tryb CTC
	 OCR1A=(1.0f/667.0f)/(64.0f/(float)F_CPU);  //375-1.5ms 200-0.8ms    549-2.2ms dla zegara 16mhz     //ustaw 1.5ms(neutrum serwa) 667hz
	 #ifdef SERWA16
	 OCR1B=(1.0f/667.0f)/(64.0f/(float)F_CPU);  //375-1.5ms 200-0.8ms    549-2.2ms dla zegara 16mhz     //ustaw 1.5ms(neutrum serwa) 667hz
	 #endif
 
   OCR2=(1.0f/417.0f)/(256.0f/(float)F_CPU);// coś około 2.6ms 385hz
    // tryb OCT | preskaler 256
   TCCR2=_BV(WGM21) | _BV(CS22) | _BV(CS21);
   TIMSK|=(1<<OCIE2);//włączenie przerwania compare	
}
 
 
//przerwanie timera2 compare
// po koleji wszystkie serwa przechodzi, każde przerwanie to kolejna para serw
// przetwarza 2 naraz 0 i 8 ,1 i 9, 2 i 10 itd.
ISR(TIMER2_COMP_vect)
{
	 PORTSERWOA^=(1<<5);
 
	////obsługa  serw 2 naraz z timera1A i timera1B
	//pierwsza 8 serw na timer1A
  	if(serwa[i].enable==1)//jak Serwo włączone to generuj mu impuls
	{
		//pierwsza 8 serw
	   TCNT1=0;//licznik timera1, zerujemy
	   OCR1A=serwa[i].pos;
	  TIFR|=(0<<OCF1A);//wyzerowanie flagi CTC
	 PORTSERWOA|=(1<<serwa[i].nrPort);//ustaw 1
	   while(bit_is_clear(TIFR,OCF1A))
	   {//i tu jest pies pogrzebany
	   }
	   PORTSERWOA&=~(1<<serwa[i].nrPort);//ustaw 0
	}
   //druga 8 serw na timer1B do poprawy tak jak 1 8 ma wygladac
//wyrzucone
 
   if(++i>7) i=0;//nastepne serwa, jak koniec to do poczatku
} 
 

Code C - [expand]
 
 
//inicjacja taka sama
 
//przerwanie timera2 compare
// po koleji wszystkie serwa przechodzi, każde przerwanie to kolejna para serw
// przetwarza 2 naraz 0 i 8 ,1 i 9, 2 i 10 itd.
ISR(TIMER2_COMP_vect)
{
	 PORTSERWOA^=(1<<5);
 
	////obsługa  serw 2 naraz z timera1A i timera1B
	//pierwsza 8 serw na timer1A
  	if(serwa[i].enable==1)//jak Serwo włączone to generuj mu impuls
	{
		//pierwsza 8 serw
	   TCNT1=0;//licznik timera1, zerujemy
	   OCR1A=serwa[i].pos;
//to jest inne	
TIMSK |= (1 << OCIE1A); // Zezwolenie na przerwania dla CTC
PORTSERWOA&=~(1<<serwa[i].nrPort);//ustaw 1
 
	}
   //druga 8 serw na timer1B do poprawy tak jak 1 8 ma wygladac
/////
 
   if(++i>7) i=0;//nastepne serwa, jak koniec to do poczatku
} 
 
//timer1a
ISR(TIMER1_COMPA_vect)
{
	 PORTSERWOA|=(1<<serwa[i].nrPort);//ustaw 1
 
	//TIMSK &= ~(1 << OCIE1A);/
 
}
 
//timer1b
//////	
 

Code C - [expand]
 
 
 
 
 
/*
************************************************************************  
  Nazwa pliku	-  servos.h
 
  Kompilator	-  AVR Studio 4.17 + WinAVR 2010.01.10
 
  Autor 		-  Marcin Szumlański
 
  Data 			-  10-03-2010
 
  Procesor 		-  ATmega16/32 
 
  Opis	:
 
************************************************************************ 
*/
#ifndef _SERVOS_H_
#define _SERVOS_H_
 
 
#define cbi(sfr,b) (sfr &=~(1<<b))
#define sbi(sfr,b) (sfr |=(1<<b))
 
//port Servo
#define ServoPort			PORTA
#define ServoDir			DDRA
 
//kanały Servo
#define ServoChannel0		0
#define ServoChannel1		1
#define ServoChannel2		2
#define ServoChannel3		3
#define ServoChannel4		4
#define ServoChannel5		5
#define ServoChannel6		6
#define ServoChannel7		7
 
//min liczba przerwań T0 do odliczenia aby długośc imp nie trwała mniej niż 0,76ms
#define ServoInterruptMin	76
//max liczba przerwań To do odliczenia aby długośc imp nie trwała dłużej niż 2,06ms
#define ServoInterruptMax	130+ServoInterruptMin 
 
//pozycje domyślne (inicjalizacyjne) serv w stopniach
#define ServoDefault0		0+ServoInterruptMin
#define ServoDefault1		0+ServoInterruptMin
#define ServoDefault2		0+ServoInterruptMin
#define ServoDefault3		0+ServoInterruptMin
#define ServoDefault4		0+ServoInterruptMin
#define ServoDefault5		0+ServoInterruptMin
#define ServoDefault6		0+ServoInterruptMin
#define ServoDefault7		0+ServoInterruptMin
 
//inicjalizacja sterownika Servo (konfig T0,T1 i I/O)
void ServosInit(void);
 
//ustawia/pobiera pozycję serwa w określonym kanale format wyskalowany w stopniach (0-130)
void ServoSetPosition(unsigned char Channel, unsigned char Position);
unsigned char ServoGetPosition(unsigned char Channel);
 
#endif
 

Code C - [expand]
 
 
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include "servos.h"
 
volatile unsigned char ServoInterruptCounter = 0;
volatile unsigned char ServoPerioid[8];
 
void ServosInit(void)
{
  ServoDir = 0xFF;	//Port PWM=Output
  ServoPort = 0x00;	//Zerowanie wyść
 
  //Timer1
  OCR1A  = 0x04E2; //1250
  //Odmaskowanie przerwania CTC
  sbi(TIMSK,OCIE1A);
  //Tryb CTC,presk.=256(przerwanie co 20ms dla F_CPU 16Mhz)
  TCCR1B = _BV(WGM12)|_BV(CS12);
 
  //Timer0
  OCR0 = 20;
  //Tryb CTC,presk.=8(przerwanie co 0,01ms dla F_CPU 16Mhz)
  sbi(TCCR0,WGM01);
   //Odmaskowanie przerwania CTC
  sbi(TIMSK,OCIE0);
}
 
//ustawia pozycję serwa w określonym kanale format wyskalowany
void ServoSetPosition(unsigned char Channel, unsigned char Position)
{
  ServoPerioid[Channel] = Position+ServoInterruptMin;
}
 
//pobiera pozycję serwa w określonym kanale format wyskalowany w stopniach
unsigned char ServoGetPosition(unsigned char Channel)
{
  return(ServoPerioid[Channel]-ServoInterruptMin);
}
 
 
//OBSŁUGA PRZERWAŃ
ISR(TIMER1_COMPA_vect)
{
  //wyjścia PWM w stan wysoki
  ServoPort = 0xFF;
  //zerowanie T0
  TCNT0 = 0x00;
  //start T0
  sbi(TCCR0,CS01);
}
 
ISR(TIMER0_COMP_vect)
{
  //jeśli liczba przerwań odpowiada wypełnieniu kanału zeruj odpowiedni pin I/O
  if(ServoInterruptCounter == ServoPerioid[ServoChannel0])
  {
    cbi(ServoPort,ServoChannel0);
  }
    if(ServoInterruptCounter == ServoPerioid[ServoChannel1])
  {
    cbi(ServoPort,ServoChannel1);
  }
    if(ServoInterruptCounter == ServoPerioid[ServoChannel2])
  {
    cbi(ServoPort,ServoChannel2);
  }
    if(ServoInterruptCounter == ServoPerioid[ServoChannel3])
  {
    cbi(ServoPort,ServoChannel3);
  }
    if(ServoInterruptCounter == ServoPerioid[ServoChannel4])
  {
    cbi(ServoPort,ServoChannel4);
  }
    if(ServoInterruptCounter == ServoPerioid[ServoChannel5])
  {
    cbi(ServoPort,ServoChannel5);
  }
    if(ServoInterruptCounter == ServoPerioid[ServoChannel6])
  {
    cbi(ServoPort,ServoChannel6);
  }
     if(ServoInterruptCounter == ServoPerioid[ServoChannel7])
  {
    cbi(ServoPort,ServoChannel7);
  }
  //inkrementujemy licznik przerwań T0
  ServoInterruptCounter++;
  //jeśli liczba przerwan > max wyłącz T0 i zeruj licznik
  if(ServoInterruptCounter > ServoInterruptMax)
  {
    cbi(TCCR0,CS01);
  	ServoInterruptCounter = 0;
  }
}