[syntax=cpp]uint16_t pomiar (uint8_t kanal)[/syntax]
zapewnia jednokkrotny pomiar ADC.
ponowne przywrócenie multipleksera było zrealizowane za pomocą
[syntax=cpp]ADCSRA &= ~(1<<ADEN); //wyłącz ADC[/syntax]
silnik się kręcił dalej, więc przerwania działały dobrze.
No dobrze, poprawiłem kod i zmieniłem trochę koncepcję. Teraz pomiar nie będzie realizowany w przerwaniu, ale w pętli głównej, zaraz po tym jak nastąpi przerwanie od pierwszej komutacji o czym inforumuje
[syntax=cpp]bldc_polozenie_wirnika == KOMUT_1[/syntax]
Tera program main w którym odbywa się pomiar:
[syntax=cpp]/*
Sterownik silnika BLDC.
Sterowanie silnikiem z wykorzystaniem Back-EMF.
Częstotliwość F_CPU: 8MHz (ustaw w opcjach projektu)
Szczegóły: http://mikrokontrolery.blogspot.com/2011/03/silnik-bldc-sterownik-back-emf.html
2013 Dondu
*/
#include "avr/io.h"
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include "bldc.h"
#include "myuart.h"
#define SR 8
typedef struct vol {
uint16_t adc_mid;
uint16_t ref_adc;
uint16_t ref_v;
char v1[3];
char v2[3];
}TVOL;
TVOL accu1_vol;
#define REF_VCC (1<<REFS0)
uint16_t pomiar (uint8_t kanal);
void get_vol (uint16_t adc, TVOL * voltage);
volatile uint16_t wynik=0;
//------------------------------------------------------------------
int main (void)
{
uart_init ( __UBRR );
uart_puts("gthfhfth");
//zmienne potrzebne do przykładu zmiany prędkości
//patrz pętla główna while() poniżej
unsigned char PWM_akt;
//unsigned char PWM_kier = 1; //kierunek zmiany prędkości
//0 - zmniejszanie
//1 - zwiększanie
//diody testowe
DDRC|= (1<<PC5) | (1<<PC4);//wyjście LED
PORTC|= (1<<PC5) | (1<<PC4);//zgaś diody, bo są zapalane zerem
//opóźnienie na ustabilizowanie zasilania (można usunąć)
//_delay_ms(1000);
//inicjujemy sterownik
bldc_inicjuj_sterownik();
//Przerwania globalne włącz
sei();
//Start silnika
bldc_start();
//odczytaj aktualnie ustawione PWM (dla potrzeb przykładu poniżej)
PWM_akt = 100;
tr_cls(0); //czyszczenie ekranu do UART
//pętla główna
while(1){
//... tutaj dowolny Twój program
//--- PRZYKŁAD ------------------------
//Przykład funkcji zmieniającej prędkość obrotów silnika
//tylko wtedy, gdy sterownik już rozkręcił silnik i przeszedł
//w tyb pracy
//Aby przykład działał usuń na początku main() komentarze
//dla deklaracji zmiennych PWM_akt oraz PWM_kier
if(bldc_tryb_pracy== TRYB_PRACA){
//PWM_akt += skok_PWM;
//if(PWM_kier) PWM_akt++;
//else PWM_akt--;
//sprawdzamy, czy osiągnęliśmy próg prędkości maksymalnej
//if(PWM_akt >254) PWM_kier = 0; //od teraz zmniejszamy obroty
//sprawdzamy, czy osiągnęliśmy próg prędkości minimalnej
//if(PWM_akt <40)PWM_kier = 1; //od teraz zwiększamy obroty
//PWM_akt=30;
//OCR0A=PWM_akt;
PWM_akt=150; // z góry ustalam wypełnienie PWM
//ustaw aktualne PWM w celu regulacji prędkości
OCR0B=PWM_akt;
OCR1A=PWM_akt;
OCR1B=PWM_akt;
OCR2A=PWM_akt;
OCR2B=PWM_akt;
//dla testów, opóźnienie zmian prędkości
//POMIAR ADC Z POTENCJOMETRU przeprowadzany przy pierwszej komutacji
if(bldc_polozenie_wirnika == KOMUT_1){
//inicjalizacja ADC
ADCSRA |= (1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //preskaler 128 8000000/168
ADMUX |= REF_VCC; //ust. źródło odniesienia 5 V
ADCSRA |= (1<<ADEN); //włącz ADC
accu1_vol.ref_adc = 548;
accu1_vol.ref_v = 141;
wynik = pomiar ( PC5 );
wynik=wynik/4;
tr_locate(3,3);
uart_putlong(wynik,10); //wywietlanie wyniu z pomiaru
ADCSRA &= ~(1<<ADEN); //wyącz ADC
}
_delay_ms(100);
}
//--- PRZYKŁAD - Koniec -------------
//... tutaj dowolny Twój program
}
}
uint16_t pomiar (uint8_t kanal) {
ADMUX = (ADMUX & 0b11111000) | kanal;
ADCSRA |= (1<<ADSC); //start konwersji
while ( ADCSRA & (1<<ADSC) ) ;
return ADCW;
}
void get_vol (uint16_t adc, TVOL * voltage) {
static uint16_t sr[SR];
static uint8_t idx;
uint32_t sr1=0;
uint8_t i;
sr[ idx++ & (SR-1) ] = adc;
//sr[idx]=adc;
//idx++;
//if(idx>7) idx=0;
//if( idx & (SR-1) ) return;
for ( i=0; i<SR; i++) sr1+=sr[i];
sr1 /=SR;
voltage->adc_mid =sr1;
uint16_t wynik = (sr1 * (uint32_t) voltage->ref_v ) / voltage->ref_adc;
div_t divmod = div(wynik,100 );
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10 );
if (divmod.rem <10) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}
}[/syntax]
Program bldc.c gdzie są przerwania
[syntax=cpp]/*
Sterownik silnika BLDC.
Sterowanie silnikiem z wykorzystaniem Back-EMF.
Częstotliwość F_CPU: 8MHz (ustaw w opcjach projektu)
Szczegóły: http://mikrokontrolery.blogspot.com/2011/03/silnik-bldc-sterownik-back-emf.html
2013 Dondu
*/
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include "bldc.h"
volatile unsigned charbldc_polozenie_wirnika = KOMUT_1;
volatile unsigned char bldc_tryb_pracy; //aktualny tryb pracy
volatile unsigned int bldc_komp_licznik; //licznik przerwań komparatora
//--------------------------------------------------------------------
void bldc_bezpiecznik_stop(void){
//Funkcja wyłącza wszelkie tranzystory oraz przechodzi w stan sygnalizacji
//błędu komutacji. Funkcja ta razem z funkcją bezpiecznik() pełni rolę
//zabezpieczenia przeciwzwarciowego dla błędnie działającego algorytmu
//komutacji w czasie pisania i testów programu.
//wyłącz przerwania
cli();
//natychmiast wyłącz tranzystory
WYLACZ_TRANZYSTORY
//i ustaw stany niskie na pinach sterujących
U_TR_G_USTAW_DDR
V_TR_G_USTAW_DDR
W_TR_G_USTAW_DDR
U_TR_D_USTAW_DDR
V_TR_D_USTAW_DDR
W_TR_D_USTAW_DDR
U_TR_G_PIN_L
V_TR_G_PIN_L
W_TR_G_PIN_L
U_TR_D_PIN_L
V_TR_D_PIN_L
W_TR_D_PIN_L
//ustaw pin LED jako wyjście
BEZP_LED_DDR|=(1<<BEZP_LED_PIN);
//zatrzymaj program w pętli nieskończonej sygnalizując błąd
while(1){
//zmień stan LED na przeciwny
BEZP_LED_PORT ^= (1<<BEZP_LED_PIN);
//co 100ms
_delay_ms(100);
}
}
//------------------------------------------------------------------
void bldc_bezpiecznik(void){
//Sprawdzamy, czy nie występuje konflikt sterowania, powodujący
//jednoczene otwarcie tranzystora górnego i dolnego w tej samej fazie,
//co oznacza wystąpienie zwarcia !!!
if(U_TR_G_SPRAW_STAN && U_TR_D_SPRAW_STAN){
//Faza U - oba tranzystory są włączone - sytuacja niedopuszczalna!!!
bldc_bezpiecznik_stop();
}else if(V_TR_G_SPRAW_STAN && V_TR_D_SPRAW_STAN){
//Faza V - oba tranzystory są włączone - sytuacja niedopuszczalna!!!
bldc_bezpiecznik_stop();
}else if(W_TR_G_SPRAW_STAN && W_TR_D_SPRAW_STAN){
//Faza W - oba tranzystory są włączone - sytuacja niedopuszczalna!!!
bldc_bezpiecznik_stop();
}
}
//-----------------------------------------------------------
void bldc_inicjuj_sterownik(void){
//Funkcja inicjująca pracę sterownika.
//-konfiguruje wszystkie wykorzystywane moduły mikrokontrolera
//-ustawia piny mikrokontrolera tak, by wszystkie tranzystory
// były wyłączone
//-ustawia licznikia PWM na początkową wartość DutyCycle
//ustaw stan początkowy wyjść sterujących tranzystorami
U_TR_G_USTAW_DDR
V_TR_G_USTAW_DDR
W_TR_G_USTAW_DDR
U_TR_D_USTAW_DDR
V_TR_D_USTAW_DDR
W_TR_D_USTAW_DDR
U_TR_G_PIN_L
V_TR_G_PIN_L
W_TR_G_PIN_L
U_TR_D_PIN_L
V_TR_D_PIN_L
W_TR_D_PIN_L
//sprawdzamy, czy nie ma stanu zabronionego na tranzystorach
//ZAWSZE WYWOŁUJ TĘ FUNKCJĘ, GDY ZMIENIASZ STAN TRANZYSTORÓW!!!
bldc_bezpiecznik();
//--- T I M E R Y P W M -------------------
//Timer0
//Obsługa PWM dla wyjść !!! BEZ OC0A !!! oraz OC0B
//Mode 5 (Fast PWM, 8bit)
//Clear OC0A/OC0B on Compare Match, set OC0A/OC0B at BOTTOM,
//(non-inverting mode)
//preskaler 1
TCCR0A|=(1<<WGM01) | (1<<WGM00) | (1<<COM0B1);
TCCR0B|=(1<<CS00);
//Timer1
//Obsługa PWM dla wyjść OC1A oraz OC1B
//Mode 5 (Fast PWM, 8bit)
//Clear OC1A/OC1B on Compare Match, set OC1A/OC1B at BOTTOM,
//(non-inverting mode)
//preskaler 1
TCCR1A|=(1<<WGM12) | (1<<WGM10) | (1<<COM1A1) | (1<<COM1B1);
TCCR1B|=(1<<WGM12) | (1<<WGM10) | (1<<CS10);
//Timer2
//Obsługa PWM dla wyjścia OC2
//Mode 3 (Fast PWM, 8bit)
//Clear OC2 on Compare Match, set OC2 at BOTTOM, (non-inverting mode)
//preskaler 1
TCCR2A|=(1<<WGM21) | (1<<WGM20)| (1<<COM2A1) | (0<<COM2B1);
TCCR2B |=(1<<CS20) ;
//--- K O M P A R A T O R ---
//Obsługuje wykrywanie położenia wirnika poprzez BEMF,
//czyli ustalanie momentów przejścia przez zero sygnałów sterujących
//przerwanie dla każdej zmiany wyjścia komparatora
//Przerwanie jest włączane w funkcji startującej silnik.
ADCSRB|= (1<<ACME);//włącz multiplekser wejść ujemnych komparatora
//ustaw wartość początkową PWM
OCR0B = PWM_MIN;
OCR1A = PWM_MIN;
OCR1B = PWM_MIN;
OCR2A = PWM_MIN;
OCR2B = PWM_MIN;
//na wszelki wypadek
WYLACZ_TRANZYSTORY
bldc_bezpiecznik();
}
//------------------------------------------------------------------
void bldc_start_delay_ms(unsigned char il_ms){
//Funkcja opóźnienia o zmiennej wartości czasu
while(il_ms){
_delay_ms(1);
il_ms--;
}
}
//-----------------------------------------------------------
void bldc_start_komutacja(void){
//Funkcja komutacji w czasie rozruchu silnika.
//nie zawiera obsługi BackEMF
//zależnie od numeru aktualnej komutacji przełącza na następną
switch (bldc_polozenie_wirnika++){
case (KOMUT_1)://komutacja 1
W_TR_G_OFF
U_TR_G_ON
break;
case (KOMUT_2)://komutacja 2
V_TR_D_OFF
W_TR_D_ON
break;
case (KOMUT_3)://komutacja 3
U_TR_G_OFF
V_TR_G_ON
break;
case (KOMUT_4)://komutacja 4
W_TR_D_OFF
U_TR_D_ON
break;
case (KOMUT_5)://komutacja 5
V_TR_G_OFF
W_TR_G_ON
break;
case (KOMUT_6)://komutacja 6
U_TR_D_OFF
bldc_polozenie_wirnika = KOMUT_1; //komutacja od początku
V_TR_D_ON
break;
}
//sprawdzamy konflikty sterowania
bldc_bezpiecznik();
}
//-----------------------------------------------------------
void bldc_start(void){
//Funkcja odpowiedzialna za:
//- ustawienie wirnika w pozycji początkowej
//- rozkręcenie silnika do momentu uzyskania odczytów BackMEF
signed int i; //zmienna pomocnicza
//wartości początkowe
bldc_tryb_pracy= TRYB_START;
////RUSZAMY SILNIK
////Poniżej przykład kolejnych kroków, mających na celu ruszenie silnika
////z miejsca oraz rozkręcenie go do momentu w którym uzyskamy sygnał
////BackEMF. Po osiągnięciu odpowiedniej ilości przerwań z komparatora,
////uznajemy, że nadszedł moment w którym należy się przełączyć na
////sterowanie komutacjami z wykorzystaniem przerwań BackEMF (komparatora).
//
////UWAGA!
////W zależności od silnika należy dobrać doświadczalnie procedurę startu
//
//
//
////KROK 1
////Ustaw wirnik w pozycji startowej
//bldc_polozenie_wirnika= KOMUT_1;
U_TR_G_ON//włączamy wybraną parę tranzystorów
W_TR_D_ON
_delay_ms(300);
bldc_bezpiecznik();//sprawdzamy konflikty sterowania
//
////odczekujemy oscylacje wirnika zmniejszając wypełnienie PWM
////tutaj możesz dostosować doświadczalnie parametry pozycjonowania silnika
////do bezwładności wirnika
for(i=100; i>0; i-=5){
//ustaw nowe PWM wykorzystując jawne rzutowanie http://mikrokontrolery.blogspot.com/2011/02/kurs-jezyka-c-rzutowanie-promocja-typow.html
OCR0B = (unsigned char) i;
OCR1A = (unsigned char) i;
OCR1B = (unsigned char) i;
OCR2A = (unsigned char) i;
OCR2B = (unsigned char) i;
//opóźnienie
_delay_ms(100);
}
//
//
////KROK 2
////ruszamy silnik z miejsca
//
//początkowa wartość PWM dla startu silnika (regulacja prądu)
OCR0A = 254;
OCR1A = 254;
OCR1B = 254;
OCR2A = 254;
OCR2B = 254;
//
////rusz silnik z miejsca przełączając komutacje ze zmienjszającym się
////opóźnieniem, by osiągnąć początkową prędkość
for(i=40; i>0; i-=1){
bldc_start_komutacja();//kolejna komutacja
bldc_start_delay_ms(50);//opóźnienie
}
for(i=80; i>0; i-=1){
bldc_start_komutacja();//kolejna komutacja
bldc_start_delay_ms(30);//opóźnienie
}
//
////KROK 3
////zwiększaj dalej prędkość, ale mniejszymi krokami PWM
//for(i=60; i>=10; i-=1){
//bldc_start_komutacja();//kolejna komutacja
//bldc_start_delay_ms(i);//opóźnienie
//
//}
//
////KROK 4
////włącz przerwania z komparatora ponieważ już mogą być prawidłowe
////sygnały BEMF.
ACSR|= (1<<ACIE);
//
for(i=200; i>0; i-=1){
bldc_start_komutacja();//kolejna komutacja
bldc_start_delay_ms(20);//opóźnienie
////ustabilizuj obroty i czekaj na wykrycie odpowiedniej ilości przerwań
//for(i=0; i<200; i++){
//
//bldc_start_komutacja(); //kolejna komutacja
//bldc_start_delay_ms(10); //opóźnienie
//Przerwij, gdy wykryto już wystarczającą ilość przerwań z komparatora
//ilość impulsów zależy tylko od Ciebie - ja wybrałem 40
if(bldc_komp_licznik > 80){
//Wykryto odpowiednią ilość przerwań z sygnałów BackEMF
//uznajemy więc, że możemy przejść na sterowanie za pomocą
//przerwań z sygnałów BackEMF
//ustaw tryb pracy i wróć do main()
bldc_tryb_pracy= TRYB_PRACA;
WYLACZ_TRANZYSTORY
DDRD |=(1<<PD2);
PORTD ^=(1<<PD2);
break;
}
}
//KROK 5
//sprawdzamy, czy sterownik przełączył się na tryb pracy
if(bldc_tryb_pracy!= TRYB_PRACA){
//Sterownik nie przełączył się, ponieważ pomimo wielu obrotów wirnika
//komparator nie wykrył założonej ilości impulsów sygnału BackEMF,
//stąd przerywamy procedurę startu.
//Jeżeli sytuacja będzie się powtarzać, powinieneś zmienić parametry
//kroków 2, 3 i 4
//wyłącz przerwania z komparatora
ACSR&= ~(1<<ACIE);
//wyłącz tranzystory
WYLACZ_TRANZYSTORY
bldc_bezpiecznik();
}
//wróć do main()
}
//-----------------------------------------------------------
ISR (ANALOG_COMP_vect)
{
//Funkcja obsługi przerwania z komparatora wykrywającego punkty ZC
//funkcja zajmuje się wykryciem właściwego położenia wirnika
//oraz przełączeniem następnej komutacji
//DLA TESTÓW ZC możesz podłączyć do pinu PB0 oscyloskop i obserwować
//moment wykonania się przerwania. Wcześniej musisz ustawić
//pin PBO jako wyjście
//PORTB^=(1<<PB0);//zmień stan pinu na przeciwny
//w zależności od trybu pracy sterownika
switch (bldc_tryb_pracy){
//-------------------------------------------------
case TRYB_START:
//Podczas trybu startu jedynie zliczaj wykryte przerwania
//z komparatora, czyli punkty ZC sygnału BackEMF
bldc_komp_licznik++;
break;
//-------------------------------------------------
case TRYB_PRACA:
//tryb normalnej pracy czyli kręcenia silnikiem na podstawie
//wykrytych punktów ZC sygnałów BackEMF
//w zależności od położenia wirnika (fakt wystąpienia przerwania
//oraz sprawdzenie stanu wyjścia komparatora)
switch (bldc_polozenie_wirnika)
{
case (KOMUT_1)://kąt 0 stopni
if(!KOMP_STAN_AKT)//gdy komparator = 0
{
W_TR_G_OFF//wyłącz tranzystor górny W
KOMP_KANAL_W;//włącz kanał fazy W
bldc_polozenie_wirnika = KOMUT_2; //następna komutacja
U_TR_G_ON//włącz tranzystor górny U
}
break;
case (KOMUT_2)://kąt 60 stopni
if(KOMP_STAN_AKT)//gdy komparator = 1
{
V_TR_D_OFF//wyłącz tranzystor dolny V
KOMP_KANAL_V;//włącz kanał fazy V
bldc_polozenie_wirnika = KOMUT_3; //następna komutacja
W_TR_D_ON//włącz tranzystor dolny W
}
break;
case (KOMUT_3)://kąt 120 stopni
if(!KOMP_STAN_AKT)//gdy komparator = 0
{
U_TR_G_OFF//wyłącz tranzystor górny U
KOMP_KANAL_U;//włącz kanał fazy U
bldc_polozenie_wirnika = KOMUT_4; //następna komutacja
V_TR_G_ON//włącz tranzystor górny V
}
break;
case (KOMUT_4)://kąt 180 stopni
if(KOMP_STAN_AKT)//gdy komparator = 1
{
W_TR_D_OFF//wyłącz tranzystor dolny W
KOMP_KANAL_W;//włącz kanał fazy W
bldc_polozenie_wirnika = KOMUT_5; //następna komutacja
U_TR_D_ON//włącz tranzystor dolny U
}
break;
case (KOMUT_5)://kąt 240 stopni
if(!KOMP_STAN_AKT)//gdy komparator = 0
{
V_TR_G_OFF//wyłącz tranzystor górny V
KOMP_KANAL_V;//włącz kanał fazy V
bldc_polozenie_wirnika = KOMUT_6; //następna komutacja
W_TR_G_ON//włącz tranzystor górny W
}
break;
case (KOMUT_6)://kąt 300 stopni
if(KOMP_STAN_AKT)//komparator = 1
{
U_TR_D_OFF //wyłącz tranzystor dolny U
KOMP_KANAL_U;//włącz kanał fazy U
bldc_polozenie_wirnika = KOMUT_1; //komut. od początku
V_TR_D_ON//włącz tranzystor dolny V
}
break;
}
break;
}
}[/syntax]
i biblioteka bldc.h
[syntax=cpp]/*
Sterownik silnika BLDC.
Sterowanie silnikiem z wykorzystaniem Back-EMF.
Częstotliwość F_CPU: 8MHz (ustaw w opcjach projektu)
Szczegóły: http://mikrokontrolery.blogspot.com/2011/03/silnik-bldc-sterownik-back-emf.html
2013 Dondu
*/
//--- D E F I N I C J E D O T. B E Z P I E C Z N I K A ------
//LED bezpiecznika
#define BEZP_LED_DDRDDRD
#define BEZP_LED_PORTPORTD
#define BEZP_LED_PINPD3
//--- D E F I N I C J E D O T. S I L N I K A ------
//Faza U
//tranzystor górny
#define U_TR_G_PORTxPORTB
#define U_TR_G_DDRxDDRB
#define U_TR_G_PINxPINB
#define U_TR_G_PINPB1
#define U_TR_G_USTAW_DDRU_TR_G_DDRx |= (1<<U_TR_G_PIN); //ustaw port
#define U_TR_G_PIN_LU_TR_G_PORTx &= ~(1<<U_TR_G_PIN); //ustaw niski
#define U_TR_G_ON TCCR1A |= (1<<COM1A1);//włącz tranzystor
#define U_TR_G_OFFTCCR1A &=~(1<<COM1A1);//wyłącz tranzystor
#define U_TR_G_SPRAW_STAN (TCCR1A & (1<<COM1A1))//warunek stanu
//tranzystor dolny
#define U_TR_D_PORTxPORTD
#define U_TR_D_DDRxDDRD
#define U_TR_D_PINxPIND
#define U_TR_D_PINPD3
#define U_TR_D_USTAW_DDRU_TR_D_DDRx |= (1<<U_TR_D_PIN); //ustaw port
#define U_TR_D_PIN_LU_TR_D_PORTx &= ~(1<<U_TR_D_PIN); //ustaw niski
//#define U_TR_D_ON U_TR_D_PORTx |= (1<<U_TR_D_PIN); //włącz tranz.
//#define U_TR_D_OFFU_TR_D_PORTx &= ~(1<<U_TR_D_PIN); //wyłącz tranz.
//#define U_TR_D_SPRAW_STAN(U_TR_D_PINx & (1<<U_TR_D_PIN)) //warunek stanu
#define U_TR_D_ON TCCR2A |= (1<<COM2B1); //włącz tranz.
#define U_TR_D_OFFTCCR2A &= ~(1<<COM2B1); //wyłącz tranz.
#define U_TR_D_SPRAW_STAN(TCCR2A & (1<<COM2B1)) //warunek stanu
//Faza V
//tranzystor górny
#define V_TR_G_PORTxPORTB
#define V_TR_G_DDRxDDRB
#define V_TR_G_PINxPINB
#define V_TR_G_PINPB3
#define V_TR_G_USTAW_DDRV_TR_G_DDRx |= (1<<V_TR_G_PIN); //ustaw port
#define V_TR_G_PIN_LV_TR_G_PORTx &= ~(1<<V_TR_G_PIN); //ustaw niski
#define V_TR_G_ON TCCR2A |= (1<<COM2A1);//włącz tranzystor
#define V_TR_G_OFFTCCR2A &= ~(1<<COM2A1);//wyłącz tranzystor
#define V_TR_G_SPRAW_STAN(TCCR2A & (1<<COM2A1))//warunek stanu
//tranzystor dolny
#define V_TR_D_PORTxPORTD
#define V_TR_D_DDRxDDRD
#define V_TR_D_PINxPIND
#define V_TR_D_PINPD5
#define V_TR_D_USTAW_DDRV_TR_D_DDRx |= (1<<V_TR_D_PIN); //ustaw port
#define V_TR_D_PIN_LV_TR_D_PORTx &= ~(1<<V_TR_D_PIN); //ustaw niski
//#define V_TR_D_ON V_TR_D_PORTx |= (1<<V_TR_D_PIN); //włącz tranz.
//#define V_TR_D_OFFV_TR_D_PORTx &= ~(1<<V_TR_D_PIN); //wyłącz tranz.
//#define V_TR_D_SPRAW_STAN(V_TR_D_PINx & (1<<V_TR_D_PIN)) //warunek stanu
#define V_TR_D_ON TCCR0A |= (1<<COM0B1); //włącz tranz.
#define V_TR_D_OFFTCCR0A &=~(1<<COM0B1); //wyłącz tranz.
#define V_TR_D_SPRAW_STAN(TCCR0A & (1<<COM0B1)) //warunek stanu
//Faza W
//tranzystor górny
#define W_TR_G_PORTxPORTB
#define W_TR_G_DDRxDDRB
#define W_TR_G_PINxPINB
#define W_TR_G_PINPB2
#define W_TR_G_USTAW_DDRW_TR_G_DDRx |= (1<<W_TR_G_PIN); //ustaw port
#define W_TR_G_PIN_LW_TR_G_PORTx &= ~(1<<W_TR_G_PIN); //ustaw niski
#define W_TR_G_ON TCCR1A |= (1<<COM1B1);//włącz tranzystor
#define W_TR_G_OFFTCCR1A &=~(1<<COM1B1);//wyłącz tranzystor
#define W_TR_G_SPRAW_STAN(TCCR1A & (1<<COM1B1))//warunek stanu
//tranzystor dolny
#define W_TR_D_PORTxPORTD
#define W_TR_D_DDRxDDRD
#define W_TR_D_PINxPIND
#define W_TR_D_PINPD7
#define W_TR_D_USTAW_DDRW_TR_D_DDRx |= (1<<W_TR_D_PIN); //ustaw port
#define W_TR_D_PIN_LW_TR_D_PORTx &= ~(1<<W_TR_D_PIN); //ustaw niski
#define W_TR_D_ON W_TR_D_PORTx |= (1<<W_TR_D_PIN); //włącz tranz.
#define W_TR_D_OFFW_TR_D_PORTx &= ~(1<<W_TR_D_PIN); //wyłącz tranz.
#define W_TR_D_SPRAW_STAN(W_TR_D_PINx & (1<<W_TR_D_PIN)) //warunek stanu
//Kąty położenia wirnika
#define KOMUT_11
#define KOMUT_22
#define KOMUT_33
#define KOMUT_44
#define KOMUT_55
#define KOMUT_66
#define KOMUT_7 7
#define KOMUT_8 8
//Wspólna definicja wyłączająca wszystkie tranzystory
#define WYLACZ_TRANZYSTORYU_TR_G_OFF; U_TR_D_OFF; V_TR_G_OFF; V_TR_D_OFF; W_TR_G_OFF; W_TR_D_OFF;
//--- D E F I N I C J E P W M ---
#define PWM_MIN 240//początkowa wartość wypełnienia PWM
//Tryb pracy
#defineTRYB_START0
#defineTRYB_PRACA1
//--- D E F I N I C J E K O M P A R A T O R A ----
#define KOMP_STAN_AKT(ACSR & (1<<ACO))//aktualny stan wyjścia
//komparatora
#define KOMP_KANAL_UADMUX = 0;//kanał U do pomiaru BEMF
#define KOMP_KANAL_VADMUX = 1;//kanał V do pomiaru BEMF
#define KOMP_KANAL_WADMUX = 2;//kanał W do pomiaru BEMF
extern volatile unsigned charbldc_polozenie_wirnika;
extern void bldc_bezpiecznik(void);
extern void bldc_bezpiecznik_stop(void);
extern void bldc_start_komutacja(void);
extern void bldc_inicjuj_sterownik(void);
extern void bldc_start_delay_ms(unsigned char il_ms);
extern void bldc_start(void);
extern volatile unsigned char bldc_tryb_pracy; //aktualny tryb pracy
extern volatile unsigned int bldc_komp_licznik; //licz. przerwań komparatora[/syntax]
Bibliotek do UARTA nie wrzucam do są na pewno dobrze, robione ze stronki mirekk36.blogspot.com, tam wszystko działa.
No i na koniec program o który się opierwałem z pomiarem ADC który DZIAŁA
[syntax=cpp]//Data utworzenie: 20-09-2014
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include "MYUART/myuart.h"
#include "MK_TERMINAL/mk_term.h"
#define REF_256 (1<<REFS1)|(1<<REFS0)
#define REF_VCC (0<<REFS1)|(1<<REFS0)
#define SR 8
typedef struct vol {
uint16_t adc_mid;
uint16_t ref_adc;
uint16_t ref_v;
char v1[3];
char v2[3];
}TVOL;
TVOL accu1_vol;
uint16_t pomiar (uint8_t kanal);
void get_vol (uint16_t adc, TVOL * voltage);
int main ( void ) {
//inicjalizacja ADC
ADCSRA |= (1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //preskaler 128 8000000/168
ADMUX |= REF_VCC; //ust. źródło odniesienia 2.56 V
ADCSRA |= (1<<ADEN); //włącz ADC
accu1_vol.ref_adc = 548;
accu1_vol.ref_v = 141;
uart_init ( __UBRR );
uint16_t wynik=0;
tr_cls(0);
while(1) {
tr_cls(0);
wynik = pomiar ( PC5 );
wynik=wynik/4;
get_vol( wynik, &accu1_vol );
tr_locate(3,3);
tr_pen_color(RED);
uart_putlong(wynik,10);
uart_puts("/");
uart_putlong(accu1_vol.adc_mid,10);
}
}
uint16_t pomiar (uint8_t kanal) {
ADMUX = (ADMUX & 0b11111000) | kanal;
ADCSRA |= (1<<ADSC); //start konwersji
while ( ADCSRA & (1<<ADSC) ) ;
return ADCW;
}
void get_vol (uint16_t adc, TVOL * voltage) {
static uint16_t sr[SR];
static uint8_t idx;
uint32_t sr1=0;
uint8_t i;
sr[ idx++ & (SR-1) ] = adc;
//sr[idx]=adc;
//idx++;
//if(idx>7) idx=0;
//if( idx & (SR-1) ) return;
for ( i=0; i<SR; i++) sr1+=sr[i];
sr1 /=SR;
voltage->adc_mid =sr1;
uint16_t wynik = (sr1 * (uint32_t) voltage->ref_v ) / voltage->ref_adc;
div_t divmod = div(wynik,100 );
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10 );
if (divmod.rem <10) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}
}[/syntax]Statystyki: Napisane przez apollo1412 — 19 lis 2014, o 13:40
]]>