W swoim kodzie staram się wykorzystać wewnętrzne przerwania generowane przez TIMER1 atmegi32. Timer działa w trybie 3 (PWM z korekcją fazy). Chcę wykorzystać przerwania po ustawieniu flag TOV1 (do dokonywania pomiaru adc) i OCR1A (do obliczeń nowej wartości PWM'a). Najpierw zapomniałem ustawić flag TOIE1 i OCIE1A w rejestrze TIMSK - program działał, poza pomiarem i obliczeniami nowej wartości PWM (czyli działała komunikacja z PC i ręczne ustawianie PWM). Po dodaniu w main() linijki: TIMSK |= (0<<TOIE1) | (0<< OCIE1A); przestała działać komunikacja. Co robię źle?
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <string.h>
#include "mkuart.h"
#define LED (1<<PC7)
#define KIERUNEK1 (1<<PD7)
#define KIERUNEK2 (1<<PD2)
#define KIERUNEK_TOG1 PORTD ^= KIERUNEK1
#define KIERUNEK_TOG2 PORTD ^= KIERUNEK2
#define LED_ON PORTC |= LED
#define LED_OFF PORTC &= ~LED
//----------------- ZMIENNE
char uart_buf[100];
volatile uint32_t procent = 0;
volatile float pomiar1 = 0;
volatile int32_t wyjscie = 0;
volatile float tmp = 0;
volatile int16_t tmp1 = 0;
volatile float zadany = 0;
volatile float zmierzony = 0;
volatile uint8_t regulacja = 0;
volatile float do_wyslania = 0;
volatile uint16_t odebrane = 0;
//---------------- Struktura zmiennych PID
struct Struktura {
float R;
float L;
float Kpp;
float Kpi;
float Tii;
float Tp;
float int_I;
float int_old;
float ii;
float ei;
float iref;
uint16_t anti;
};
struct Struktura STR_PID;
//-------------------------------- FLAGI
volatile unsigned char timer0_flag = 0;
volatile unsigned char regulator_status = 0;
//-------------------------------- FUNKCJE
void analizuj_dane( char * buf );
float regulator(float zadany , float zmierzony);
uint32_t PWM_reczny(uint32_t procent);
int main(void){
//---------------------------- USTAWIENIA POCZATKOWE
DDRA=0xFF; //porty jako wyjscia
DDRB=0xFF;
DDRC=0xFF;
DDRD=0xFF;
DDRB |=LED; // dioda do testow
DDRA &= ~(1<<PA0); // PA0 jako wejście adc
DDRD |= (1<<PD2) | (1<<PD3) | (1<<PD5) | (1<<PD6) | (1<<PD7);// kierunek1, blokada1 (stan niski blokuje), PWM(PD5), blokada2, kierunek2.
PORTD &= ~(1<<PD2);// ustawienie zer na portach sterujacych po starcie
PORTD &= ~(1<<PD3);
PORTD &= ~(1<<PD6);
PORTD &= ~(1<<PD7);
PORTD |= (1<<PD7);// ustawienie obrotów w lewo
PORTD &= ~(1<<PD2);
PORTD|=(1<<PD5);
//------------------------------------------------- PWM Timer1 (PWM with phase correct)
TCCR1A |= (1<<WGM10) | (1<<WGM11);// pwm with phase correct (mode 3)
TCCR1A |= (1<<COM1A1); // nieodwracajacy
TCCR1B |= (1<<CS10); //preskaler 1
TIMSK |= (0<<TOIE1) | (0<< OCIE1A);
//------------------------------------------------- ADC
ADCSRA |= (1<<ADEN); //uruchomienie ADC
ADCSRA |= (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // preskaler 128
ADMUX |= (1<<REFS1) | (1<<REFS0); //napiecie odniesienia 2,56
ADMUX = (ADMUX & 0b11111000) | 0;
STR_PID.Tp = 0.0001; // 1/f
STR_PID.Tii = 0.001; // L/R
STR_PID.Kpi = 3.125; // (Tii * R)/(2*Kpp+Tp)
STR_PID.Kpp = 24;
//STR_PID.anti = 1;
// inicjacja usartu
register_uart_str_rx_event_callback ( analizuj_dane );
USART_Init( __UBRR );
_delay_ms(10);
sei();
while (1)
{
UART_RX_STR_EVENT( uart_buf );
//===================== STOP ===========================
if (regulator_status == 0)
{
PORTD &= ~(1<<PD3);
PORTD &= ~(1<<PD6);
STR_PID.int_I = 0;
}
//================= RĘCZNE WPISYWANIE PWM ==============
if(regulator_status == 2)
{
PWM_reczny(procent);
}
//================= Regulacja PI ==================
if(regulator_status == 1)
{
TIMSK |= (1<<TOIE1);
PORTD |= (1<<PD3) | (1<<PD6);// odblokowanie mostka
OCR1A = wyjscie;
}
}
}
void analizuj_dane( char * buf ){
char * wsk;
wsk = strtok( buf, "," );
if ( !strcmp(wsk, "led")){
wsk = strtok( NULL, "," );
if( *wsk == '1' ){
LED_ON;
}
if ( *wsk == '0' ){
LED_OFF;
}
}
if ( !strcmp(wsk, "K")){
wsk = strtok( NULL, "," );
if( *wsk == 'L' ){
PORTD |= (1<<PD7);
PORTD &= ~(1<<PD2);
}
if ( *wsk == 'P' ){
PORTD |= (1<<PD2);
PORTD &= ~(1<<PD7);
}
if ( *wsk == 'T' ){
KIERUNEK_TOG1;
KIERUNEK_TOG2;
}
}
if ( !strcmp(wsk, "PWM"))
{
wsk = strtok( NULL, "," );
procent = atoi(wsk);
}
if ( !strcmp(wsk, "REG"))
{
wsk = strtok( NULL, "," );
regulator_status = atoi(wsk);
}
if ( !strcmp(wsk, "ZAD"))
{
wsk = strtok( NULL, "," );
odebrane = atoi(wsk);
}
}
uint32_t PWM_reczny(uint32_t procent){
uint8_t wartosc_pwm = 0;
float wypelnienie = 0;
float mnoznik = 10.24;
if (procent == 0)
{
PORTD &= ~(1<<PD3);
PORTD &= ~(1<<PD6);
wyjscie = 0;
wypelnienie = 0;
}
else{
wartosc_pwm=procent;// Obliczanie wartości wypełnienia z procentów (PWM,%)
wypelnienie = ((mnoznik * wartosc_pwm) + 0.5);
PORTD |= (1<<PD3) | (1<<PD6); // Odblokowanie mostka
OCR1A = wypelnienie;
}
uart_putint( OCR1A, 10);
uart_puts("\r\n");
}
float regulator(float zadany, float zmierzony)
{
float ret;
STR_PID.ei = zadany - zmierzony;
STR_PID.int_I = 0;
ret =((float)STR_PID.Kpi * (float)STR_PID.ei);
return((float)ret);
}
// przerwanie w chwili porównania (TOP) - do obliczeń PI
ISR(TIMER1_COMPA_vect)
{
zadany = (float)0.3;
zmierzony = (float) 0.015 * pomiar1 - 7.992;
do_wyslania = pomiar1;
uart_putint( do_wyslania, 10);
uart_puts("\r\n");
tmp = regulator(zadany, zmierzony);
if (tmp >= 0)
{
PORTD |= KIERUNEK2;// kierunek 1
PORTD &= ~KIERUNEK1;// kierunek 2
}
else
{
PORTD |= KIERUNEK1;// kierunek 1
PORTD &= ~KIERUNEK2;// kierunek 2
tmp = tmp*(-1);
}
if (tmp >= 1)
{
tmp = 1;
}
tmp1 = (int16_t)(tmp * 255);
wyjscie = tmp1;
}
// przerwanie w chwili przepełnienia (BOTTOM) - pomiar ADC
ISR(TIMER1_OVF_vect)
{
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));
pomiar1 = ADCW;
do_wyslania = pomiar1;
uart_putint( do_wyslania, 10);
uart_puts("\r\n");
}[/syntax]
Kod troszkę długi i może niefachowo poukładany, więc jeśli przy okazji macie pomysł jak go ulepszyć to nie krępujcie się wytykać mi błędów - oczywiście konstruktywnie.Statystyki: Napisane przez lorddran — 23 sie 2015, o 17:44
]]>