ATNEL tech-forum 2014-02-06T09:07:11+01:00 https://forum.atnel.pl/feed.php?f=8&t=5841&mode 2014-02-05T21:05:52+01:00 2014-02-05T21:05:52+01:00 https://forum.atnel.pl/viewtopic.php?t=5841&p=68620#p68620 <![CDATA[Re: AT90PWM3B - Power Stage Controller]]> Statystyki: Napisane przez Krauser — 5 lut 2014, o 21:05

]]> 2014-02-06T09:07:11+01:00 2014-02-05T20:28:20+01:00 https://forum.atnel.pl/viewtopic.php?t=5841&p=68608#p68608 <![CDATA[AT90PWM3B - Power Stage Controller]]> tutaj.
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdbool.h>

enum {BIPOLAR, UNIPOLAR0, UNIPOLAR1};
enum {CW, CCW};
enum {HALL_001 = 1, HALL_010 = 2, HALL_011 = 3, HALL_100 = 4, HALL_101 = 5, HALL_110 = 6};
enum {STOP = false, RUN = true};

#defineMSB(uint16_t)(((uint8_t*)&uint16_t)[1])
#defineLSB(uint16_t)(((uint8_t*)&uint16_t)[0])
#defineHIGH(void)MSB(void)
#defineLOW(void)LSB(void)
//Max predkosc silnika
// MAXSPEED = (60 * 255) / (N * t_timer0 * max_speed[RPM])
// N - liczba biegunow
// t_timer0 = 16us
#define MAXSPEED 30000
//ilosc probek do pomiaru predkosci/ default = 8
#define SAMPLES 8
//stala do regulacji
#define KMUL 4
// definicja do czujnikow halla
#define HALL() \
((PIND&(1<<PIND7)) >> PIND7) \
| ((PINC&(1<<PINC6)) >> 5)\
| ((PIND&(1<<PIND5)) >> 3)
//definicje do ledow
#defineLED_RUN(1<<PORTC7)
#defineLED_STOP(1<<PORTB5)
#defineLED_STANDBY(1<<PORTB4)
#defineLED_ERROR(1<<PORTB3)
//zmienne
//jezeli zmienna globlana jest w innych plikach dodaj przedrostek extern
uint8_t strategia, overflow_t0 = 0, j = 1, i = 0;
uint8_t mcu_zmierzona_predkosc = 0, mc_cmd_speed =0;
uint16_t srednia =0;
bool ticktick, kierunek_obrotow, rzeczywista_predkosc = true, predkosc_do_odczytu = false, tryb_mcu_run_stop = STOP, hamowanie = false;
uint16_t predkosc_zmierzona = 0;
uint8_t nastawa_predkosci;
uint8_t cykl_pracy = 0;
//zmienne do regulatora PID
int16_t blad_predkosci = 0, ostatni_blad_predkosci = 0, s_integral = 0, integral = 0, proportional = 0;
int16_t s_derivative = 0, derivative = 0;
uint8_t KP = 1, KI = 1, KD = 1;
uint16_t g_reg =0;
//funkcje
void HARDWARE_init();
void PSC_init();
void OVERCURRENT();
void PSC_OCRxx_default(uint16_t OCRnRA, uint16_t OCRnRB, uint16_t OCRnSA, uint16_t OCRnSB);
void PSC_TO_UPDATE();
void PSC_UPDATE();
void mcu_cykl_pracy(uint8_t poziom);
void timer0_init();
void timer1_init();
void okreslenie_predkosci();
void motor_restart();
void motor_start();
void ACOMP_init();
void zmiana_komutacji(uint8_t pozycja);
uint8_t kontrola_predkosci(uint8_t komenda_predkosci);
void zmierz_predkosc_silnika(uint8_t zmierzona_predkosc);
uint8_t pobierz_zmierzona_predkosc();
uint8_t pobierz_polozenie_czujnikow();
void petla_regulacji();
uint8_t pobierz_cykl_pracy();
void ustaw_predkosc_silnika(uint8_t speed);
uint8_t pobierz_predkosc_silnika();

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////PROGRAM GLOWNY//////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
HARDWARE_init();
// strategia sterowania silnikiem => BIPOLAR - sterowanie bipolarne
// UNIPOLAR0 - sterowanie unipolarne dodatnie, UNIPOLAR1 - sterowanie unipolarne ujemne
strategia = BIPOLAR;
kierunek_obrotow = CW;
tryb_mcu_run_stop = STOP;
ustaw_predkosc_silnika(0);//0 -255
zmierz_predkosc_silnika(0);
for (i = 0; i < 6; i++)
{
PORTB ^=LED_STANDBY;
_delay_ms(1000);
}
void motor_start();
while(1)
{
if(ticktick == true)
{
ticktick = false;
g_reg += 1;
if(g_reg >= 320)
{
g_reg =0;
ustaw_predkosc_silnika(100);
petla_regulacji();
}//end if
}//end if
//if (PIND &(1<<PIND1)) PORTB |= LED_ERROR;
//else PORTB &= ~LED_ERROR;
if (PCTL2 & (1<<PRUN2))
{
PORTC |= LED_RUN;
PORTB &= ~LED_STOP;
}//end if
else
{
PORTC &= ~LED_RUN;
PORTB |= LED_STOP;
}//end else if
} //end while(1)


} //end main

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////FUNKCJEIPODPROGRAMY//////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
void HARDWARE_init()
{
DDRB |= (1<<DDB5) | (1<<DDB4) | (1<<DDB3) | (1<<DDB1) | (1<<DDB0) | (1<<DDB6) | (1<<DDB7);
DDRC |=(1<<DDC7) | (1<<DDC0);
DDRD |=(1<<DDD0);
PORTB &= ~((1<<PORTB5) | (1<<PORTB4) | (1<<PORTB3) | (1<<PORTB0) | (1<<PORTB1) | (1<<PORTB6) | (1<<PORTB7));
PORTC &=~((1<<PORTC7) | (1<<PORTC0));
PORTD &=~(1<<PORTD0);
PSC_init();
timer0_init();
timer1_init();
ACOMP_init();
//OVERCURRENT();
sei(); //zezwolenie na przerwanie
} //end HARDWARE_init

//funkcja inicjujaca
void PSC_init()
{
//PLL_init
PLLCSR |= (0<<PLLF) | (1<<PLLE);
//zaczekaj az uruchomi sie PLL
while(!(PLLCSR & (1<<0)))
//PSC_clock

PCNF0 |=(1<<PCLKSEL0); // 0 - CLK - I/O // 1 - CLK PLL
PCTL0 |=(0<<PPRE01) | (0<<PPRE00); //PRESCALER - CLK/1
PCNF1 |=(1<<PCLKSEL1); // 0 - CLK - I/O // 1 - CLK PLL
PCTL1 |=(0<<PPRE11) | (0<<PPRE10); //PRESCALER - CLK/1
PCNF2 |=(1<<PCLKSEL2); // 0 - CLK - I/O // 1 - CLK PLL
PCTL2 |=(0<<PPRE21) | (0<<PPRE20); //PRESCALER - CLK/1

//zainicjowanie podstawowych parametrow rejestrow OCRxx
PSC_OCRxx_default(0,0,0,0);

//PSC_config
// POPn // 0 - wyjscia aktywne w stanie niskim/ 1 - wyjscia aktywne w stanie wysokim
//(PCNFn)PMODEn1 PMODEn0(0,0) - ONE RAMP (0,1) - TWO RAMP (1,0) - FOUR RAMP (1,1) - CENTERED
// (PCTLn) PAOcnA PAOcnB / 1 - sygnal z PSCINn zadziala bezposrednio na wyjscia PSC
PCNF0 |=(1<<POP0);
PCNF0 |=(1<<PMODE01) | (0<<PMODE00);
PCTL0 |=(1<<PAOC0A) | (1<<PAOC0B);
PCTL0 |= (1<<PARUN0); //autorun on set PRUN2

PCNF1 |=(1<<POP1);
PCNF1 |=(1<<PMODE11) | (0<<PMODE10);
PCTL1 |=(1<<PAOC1A) | (1<<PAOC1B);
PCTL1 |= (1<<PARUN1); //autorun on set PRUN2 & PARUN0

PCNF2 |=(1<<POP2);
PCNF1 |=(1<<PMODE21) | (0<<PMODE20);
PCTL2 |=(1<<PAOC2A) | (1<<PAOC2B);
PCTL2 |= (1<<PRUN2); //PSC START

}//PSC_init

void OVERCURRENT()
{
DDRD &=~(1<<DDD1);
PFRC0A |=(1<<PFLTE0A) | (1<<PRFM0A2) | (1<<PRFM0A1) | (1<<PRFM0A0);
}//end OVERCURRENT
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
// RA - on time0RB - on time1SA - dead time0SB - dead time1
void PSC_OCRxx_default(uint16_t OCRnRA, uint16_t OCRnRB, uint16_t OCRnSA, uint16_t OCRnSB)
{
// OCRnSALOCRnSAHOCRnRALOCRnRAHOCRnSBLOCRnSBHOCRnRBLOCRnRBH
//PSC0
OCR0SAL =LOW(OCRnSA);//dead time0
OCR0SAH =HIGH(OCRnSA);//dead time0
OCR0RAL =LOW(OCRnRA);//on time0
OCR0RAH =HIGH(OCRnRA);//on time0
OCR0SBL =LOW(OCRnSB);//dead time1
OCR0SBH =HIGH(OCRnSB);//dead time1
OCR0RBL =LOW(OCRnRB);//on time1
OCR0RBH =HIGH(OCRnRB);//on time1
//PSC1
OCR1SAL =LOW(OCRnSA);//dead time0
OCR1SAH =HIGH(OCRnSA);//dead time0
OCR1RAL =LOW(OCRnRA);//on time0
OCR1RAH =HIGH(OCRnRA);//on time0
OCR1SBL =LOW(OCRnSB);//dead time1
OCR1SBH =HIGH(OCRnSB);//dead time1
OCR1RBL =LOW(OCRnRB);//on time1
OCR1RBH =HIGH(OCRnRB);//on time1
//PSC2
OCR1SAL =LOW(OCRnSA);//dead time0
OCR1SAH =HIGH(OCRnSA);//dead time0
OCR1RAL =LOW(OCRnRA);//on time0
OCR1RAH =HIGH(OCRnRA);//on time0
OCR1SBL =LOW(OCRnSB);//dead time1
OCR1SBH =HIGH(OCRnSB);//dead time1
OCR1RBL =LOW(OCRnRB);//on time1
OCR1RBH =HIGH(OCRnRB);//on time1
}

void PSC_TO_UPDATE()
{
//(PCNFn)PLOCKn / 1 - wlacza tryb aktualizacji rejestrow OCR / 1 --> 0 aktualizacja rejestrow po zmianie na stan niski
PCNF0 |=(1<<PLOCK0);
PCNF1 |=(1<<PLOCK1);
PCNF2 |=(1<<PLOCK2);
PCNF0 |=(1<<POP0);
PCNF0 |=(1<<PMODE01) | (0<<PMODE00);
PCNF1 |=(1<<POP1);
PCNF1 |=(1<<PMODE11) | (0<<PMODE10);
PCNF2 |=(1<<POP2);
PCNF1 |=(1<<PMODE21) | (0<<PMODE20);
PCNF0 |=(1<<PCLKSEL0); // 0 - CLK - I/O // 1 - CLK PLL
PCNF1 |=(1<<PCLKSEL1); // 0 - CLK - I/O // 1 - CLK PLL
PCNF2 |=(1<<PCLKSEL2); // 0 - CLK - I/O // 1 - CLK PLL
}
void PSC_UPDATE()
{
//(PCNFn)PLOCKn / 1 - wlacza tryb aktualizacji rejestrow OCR / 1 --> 0 aktualizacja rejestrow po zmianie na stan niski
PCNF0 &=~(1<<PLOCK0);
PCNF1 &=~(1<<PLOCK1);
PCNF2 &=~(1<<PLOCK2);
}

void mcu_cykl_pracy (uint8_t poziom)
{
uint8_t poziom_cyklu;
poziom_cyklu = poziom;

PSC_TO_UPDATE();



if(strategia == BIPOLAR)
{
//PSCOUT00 / PSCOUT10 / PSCOUT20 - MOSFET HIGH
OCR0RAL = poziom_cyklu;
OCR0RAH = 0;
OCR1RAL = poziom_cyklu;
OCR1RAH = 0;
OCR2RAL = poziom_cyklu;
OCR2RAH = 0;
//PSCOUT01 / PSCOUT11 / PSCOUT21 - MOSFET LOW
OCR0RBL = poziom_cyklu;
OCR0RBH = 0;
OCR1RBL = poziom_cyklu;
OCR1RBH = 0;
OCR2RBL = poziom_cyklu;
OCR2RBH = 0;
}//endif
else if(strategia == UNIPOLAR0)
{
//PSCOUT00 / PSCOUT10 / PSCOUT20 - MOSFET HIGH
OCR0RAL = poziom_cyklu;
OCR0RAH = 0;
OCR1RAL = poziom_cyklu;
OCR1RAH = 0;
OCR2RAL = poziom_cyklu;
OCR2RAH = 0;
//PSCOUT01 / PSCOUT11 / PSCOUT21 - MOSFET LOW
OCR0RBL = 0;
OCR0RBH = 0;
OCR1RBL = 0;
OCR1RBH = 0;
OCR2RBL = 0;
OCR2RBH = 0;
}
else if(strategia == UNIPOLAR1)
{
//PSCOUT00 / PSCOUT10 / PSCOUT20 - MOSFET HIGH
OCR0RAL = 0;
OCR0RAH = 0;
OCR1RAL = 0;
OCR1RAH = 0;
OCR2RAL = 0;
OCR2RAH = 0;
//PSCOUT01 / PSCOUT11 / PSCOUT21 - MOSFET LOW
OCR0RBL = poziom_cyklu;
OCR0RBH = 0;
OCR1RBL = poziom_cyklu;
OCR1RBH = 0;
OCR2RBL = poziom_cyklu;
OCR2RBH = 0;
}
cli(); //nie zezwalaj na przerwania
PSC_UPDATE();
sei(); // zezwolenie na przerwanie
}//end cykl_pracy

void timer0_init()
{
//timer0 tryb NORMAL / PRESCALER = 256/ 16us
TCCR0B |=(1<<CS02);
TIMSK0 |=(1<<TOIE0);
}//end timer0_init
void timer1_init()
{
//timer 1 tryb CTC / PRESCALER = 64 / 256us
TCCR1A |=(1<<WGM12) | (1<<CS11) | (1<<CS10);
OCR1AL = 63;
TIMSK1 |=(1<<OCIE1A);
}//end timer1_init

void okreslenie_predkosci()
{
uint16_t wartosc_t0;
uint32_t nowy_odczyt_predkosci;
if(predkosc_do_odczytu==true)
{
wartosc_t0 = (overflow_t0<<8) + TCNT0;
if(wartosc_t0 ==0)wartosc_t0 += 1;
nowy_odczyt_predkosci = MAXSPEED / wartosc_t0;
if(nowy_odczyt_predkosci > 255) nowy_odczyt_predkosci = 255;

if(rzeczywista_predkosc == false)
{
//srednia predkosc
srednia += nowy_odczyt_predkosci;
if (j >= SAMPLES)
{
j = 1;
zmierz_predkosc_silnika(srednia >>3);
srednia = 0;
}//end if
else j++;
}//end if
else
{
//rzeczywista predkosc
zmierz_predkosc_silnika(nowy_odczyt_predkosci);
}//end else if
TCNT0 = 0x00;
overflow_t0 = 0;
predkosc_do_odczytu = false;
}//end if
}// end okreslenie_predkosci

void motor_restart()
{
tryb_mcu_run_stop = RUN;
petla_regulacji();
mcu_cykl_pracy(pobierz_cykl_pracy());
zmiana_komutacji(pobierz_polozenie_czujnikow());

} //end motor_restart

void motor_start()
{
if (!(PCTL2 & (1<<PRUN2)))PSC_OCRxx_default(0,0,0,0);
tryb_mcu_run_stop = RUN;
petla_regulacji();
mcu_cykl_pracy(pobierz_cykl_pracy());
zmiana_komutacji(pobierz_polozenie_czujnikow());

}//end motor_start

void ACOMP_init()
{
//vref internal 2,56V
ADMUX |=(1<<REFS1) | (1<<REFS0);
//inicjacja komparatora analogowego
// wlaczenie / odblokowanie przerwania komparatora po zmianie stanu jego wyjscia
// podlaczenia ujemnego wejscia do vref = 2,13V
//komparator 0
AC0CON |=(1<<AC0EN) | (1<<AC0IE) | (1<<AC0M1);
//komparator 1
AC1CON |=(1<<AC1EN) | (1<<AC1IE) | (1<<AC1M1);
//komparator 2
AC2CON |=(1<<AC2EN) | (1<<AC2IE) | (1<<AC2M1);
}

void zmiana_komutacji(uint8_t pozycja)
{
if((tryb_mcu_run_stop == RUN) && (nastawa_predkosci != 0))
{
mcu_cykl_pracy(pobierz_cykl_pracy());

switch(pozycja)
{
case HALL_001:
if(kierunek_obrotow == CCW)
{
//HIGH_COIL_W & LOW_COIL_U
PSOC0 |= (0<<POEN0A)|(1<<POEN0B);
PSOC1 |= (0<<POEN1A)|(0<<POEN1B);
PSOC2 |= (1<<POEN2A)|(0<<POEN2B);
}
else
{
//HIGH_COIL_U & LOW_COIL_W
PSOC0 |= (1<<POEN0A)|(0<<POEN0B);
PSOC1 |= (0<<POEN1A)|(0<<POEN1B);
PSOC2 |= (0<<POEN2A)|(1<<POEN2B);
}
break;
case HALL_101:
if(kierunek_obrotow == CCW)
{
//HIGH_COIL_V & LOW_COIL_U
PSOC0 |= (0<<POEN0A)|(1<<POEN0B);
PSOC1 |= (1<<POEN1A)|(0<<POEN1B);
PSOC2 |= (0<<POEN2A)|(0<<POEN2B);
}
else
{
//HIGH_COIL_U & LOW_COIL_V
PSOC0 |= (1<<POEN0A)|(0<<POEN0B);
PSOC1 |= (0<<POEN1A)|(1<<POEN1B);
PSOC2 |= (0<<POEN2A)|(0<<POEN2B);
}
break;
case HALL_100:
if(kierunek_obrotow == CCW)
{
//HIGH_COIL_V & LOW_COIL_W
PSOC0 |= (0<<POEN0A)|(0<<POEN0B);
PSOC1 |= (1<<POEN1A)|(0<<POEN1B);
PSOC2 |= (0<<POEN2A)|(1<<POEN2B);
}
else
{
//HIGH_COIL_W & LOW_COIL_V
PSOC0 |= (0<<POEN0A)|(0<<POEN0B);
PSOC1 |= (0<<POEN1A)|(1<<POEN1B);
PSOC2 |= (1<<POEN2A)|(0<<POEN2B);
}
break;
case HALL_110:
if(kierunek_obrotow == CCW)
{
//HIGH_COIL_U & LOW_COIL_W
PSOC0 |= (1<<POEN0A)|(0<<POEN0B);
PSOC1 |= (0<<POEN1A)|(0<<POEN1B);
PSOC2 |= (0<<POEN2A)|(1<<POEN2B);
}
else
{
//HIGH_COIL_W & LOW_COIL_U
PSOC0 |= (0<<POEN0A)|(1<<POEN0B);
PSOC1 |= (0<<POEN1A)|(0<<POEN1B);
PSOC2 |= (1<<POEN2A)|(0<<POEN2B);
}
break;
case HALL_010:
if(kierunek_obrotow == CCW)
{
//HIGH_COIL_U & LOW_COIL_V
PSOC0 |= (1<<POEN0A)|(0<<POEN0B);
PSOC1 |= (0<<POEN1A)|(1<<POEN1B);
PSOC2 |= (0<<POEN2A)|(0<<POEN2B);
}
else
{
//HIGH_COIL_V & LOW_COIL_U
PSOC0 |= (0<<POEN0A)|(1<<POEN0B);
PSOC1 |= (1<<POEN1A)|(0<<POEN1B);
PSOC2 |= (0<<POEN2A)|(0<<POEN2B);
}
break;
case HALL_011:
if(kierunek_obrotow == CCW)
{
//HIGH_COIL_W & LOW_COIL_V
PSOC0 |= (0<<POEN0A)|(0<<POEN0B);
PSOC1 |= (0<<POEN1A)|(1<<POEN1B);
PSOC2 |= (1<<POEN2A)|(0<<POEN2B);
}
else
{
//HIGH_COIL_V & LOW_COIL_W
PSOC0 |= (0<<POEN0A)|(0<<POEN0B);
PSOC1 |= (1<<POEN1A)|(0<<POEN1B);
PSOC2 |= (0<<POEN2A)|(1<<POEN2B);
}
break;
default: break;
}//end switch

}//end if
else if(hamowanie == true)
{
PSOC0 |= (0<<POEN0A)|(1<<POEN0B);
PSOC1 |= (0<<POEN1A)|(1<<POEN1B);
PSOC2 |= (0<<POEN2A)|(1<<POEN2B);
}//end else if
else
{
PSOC0 |= (0<<POEN0A)|(0<<POEN0B);
PSOC1 |= (0<<POEN1A)|(0<<POEN1B);
PSOC2 |= (0<<POEN2A)|(0<<POEN2B);


}//end else if
}//end zmiana_komutacji

uint8_t kontrola_predkosci(uint8_t komenda_predkosci)
{
uint8_t praca = 0;
int32_t increment = 0;

blad_predkosci = komenda_predkosci - pobierz_zmierzona_predkosc();
//regulator - czlon P
proportional = KP * blad_predkosci;
//regulator - czlon I
s_integral = s_integral + blad_predkosci;
if(s_integral >255)s_integral = 255;
if(s_integral < -255)s_integral = -255;
integral = KI * s_integral;
//regulator - czlon D
s_derivative = blad_predkosci - ostatni_blad_predkosci;
if(s_derivative >255)s_derivative = 255;
if(s_derivative < -255)s_derivative = -255;

derivative = KD * s_derivative;
ostatni_blad_predkosci = blad_predkosci;

//kalkulacja cyklu pracy
increment = proportional + integral + derivative;
increment = increment >> KMUL;

//nasycenie zmiennej
if(increment >= (int16_t)(255)) praca = 255;
else
{
if(increment <= (int16_t)(0)) praca = 0;
else praca = (uint8_t)(increment);
}//end else if
return praca;
}//end kontrola_predkosci

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
uint8_t pobierz_polozenie_czujnikow()
{
return HALL();
}//end pobierz_polozenie_czujnikow

void petla_regulacji()
{
cykl_pracy = kontrola_predkosci(pobierz_predkosc_silnika());
}//end petla_regulacji

void zmierz_predkosc_silnika(uint8_t zmierzona_predkosc)
{
mcu_zmierzona_predkosc = zmierzona_predkosc;
}//end zmierz_predkosc_silnika

uint8_t pobierz_zmierzona_predkosc()
{
return mcu_zmierzona_predkosc;
}//end pobierz_zmierzona_predkosc

uint8_t pobierz_cykl_pracy()
{
return cykl_pracy;
}//end pobierz_cykl_pracy

void ustaw_predkosc_silnika(uint8_t speed)
{
mc_cmd_speed = speed;
}
uint8_t pobierz_predkosc_silnika()
{
return mc_cmd_speed;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////// Podprogramy przerwań//////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(TIMER0_OVF_vect)
{
TCNT0 = 0x00;
++overflow_t0;
//sprawdzenie czy po 125 ms nastapila komutacja
if(overflow_t0 >= 100)
{
overflow_t0 = 0;
if(tryb_mcu_run_stop == STOP) motor_restart();
}//end if
}//end ISR timer0
ISR(TIMER1_COMPA_vect)
{
ticktick = true;
}//end ISR timer1

ISR(ANALOG_COMP_0_vect)
{
zmiana_komutacji(HALL());
if(PIND&(1<<PORTD7))
{
okreslenie_predkosci();
predkosc_do_odczytu = false; // odczekaj obrot
}//end if
else predkosc_do_odczytu = true;
}// end ISR ACOMP0

ISR(ANALOG_COMP_1_vect)
{
zmiana_komutacji(HALL());
}// end ISR ACOMP1

ISR(ANALOG_COMP_2_vect)
{
zmiana_komutacji(HALL());
}// end ISR ACOMP2[/syntax]

Statystyki: Napisane przez Lauthar — 5 lut 2014, o 20:28

]]>