Testy przeprowadzam obecne na żarówce żeby łatwiej było określić czy działa ten regulator.
Niestety mam problem z wartościami inputValue. Wyświetlam sobie wartość temperatury z czujnika, zwartość zadaną oraz właśnie wartość inputValue.
Na początku po włączeniu zasilania układu gdy wartość nastawy równa się 0 to inputValue (żarówka jest wyłączona) pokazuje się -30 ( i co ciekawe gdy podgrzewam czujnik wartość inputValue taka sama jak wartość temperatury w Celsjuszach tylko że ze znakiem "-").
I teraz jest dziwna zależność, gdy ustawie wartość zadaną powyżej 30 stopni to wartość inputValue skacze do 255 i nic się nie zmienia wraz ze wzrostem temperatury. A co ciekawe powyżej nastawy 110 stopni wartość InputValue zaczyna maleć (żarówka świeci słabiej) i przy nastawie 175 stopni InputValue przeskakuje na -255 :/ . Przy nastawie 185 stopni żarówka miga na przemian pełną mocą, a przy 190 wartość InputValue powoli spada a następnie rośnie.
W czym jest problem źle podaje wartości zwracane przez funkcje Get_Reference i Get_Measurement ???
Nie mam już pomysłu w czym może być problem poza tym InputValue jest typu int16_t więc powinna się zmieniać w zakresie -32768 do +32767 a zmienia się od -255 do 255
Czujnik temperatury w moim przypadku mierzy od 30 stopni w górę więc ograniczyłem wartość zwracaną przez funkcję Get_Reference w taki sposób:
[syntax=c]int16_t Get_Reference(void)
{
int16_t l;
if(zmienna2<30) l=0;
if(zmienna2>=30) l=ADCTable[(zmienna2/5)];
return l;
}[/syntax]
Natomiast funkcja Get_Measurement zwraca temperaturę w stopniach Celsjusza.
[syntax=c]int16_t Get_Measurement(void)
{
return t;
}[/syntax]
Funkcja Set_Input sterująca triakiem przeskalowuje wartości z inputValue na zakres od 0 do 200 wygląda następująco:
[syntax=c]void Set_Input(int16_t inputValue)
{
pwm_value = inputValue; // Skalowanie wyniku -
if(pwm_value >= 200)
pwm_value = 200;
if(pwm_value < 0)
pwm_value = 0;
kanal1=pwm_value;
}[/syntax]
Cały kod main.c:
[syntax=c]//F_CPU 8MHz
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "LCD/lcd44780.h"
#include "PID/pid.h"
int ADC_czujnik=0;
int ADC_pomiar=0;
uint16_t pomiar(uint8_t kanal);
uint16_t adc_kx[3] PROGMEM = {245,488,1023};
uint8_t keys[3];
int zmienna=0,zmienna1=0,zmienna2=0,zmienna3=0;
int16_t pwm_value;
#define REF_256 (1<<REFS1)|(1<<REFS0)
int16_t t;
uint32_t srednia1 = 0;
uint8_t k=0;
uint8_t sw_on;
uint8_t menu_element = 0;
int16_t referenceValue, measurementValue, inputValue;
#define ADC_RANGE 50 // zakres "skakania" napięcia
volatile uint16_t Timer1,Timer2;
uint8_t sw_on;
//Constants for conversion
#define TablePoints (35)
//Conversion to şCelsius
#define ToCels (30)
#define dTCels (5)
//Prototipes for public functions
int TempNTC(unsigned int adc, int To, int dT);
//** NTC Linealization table
const unsigned int ADCTable[TablePoints]=
{
1017, 998, 977, 952, 924, 894, 860, 824,
786, 746, 705, 663, 621, 579, 538, 498,
460, 423, 388, 355, 325, 297, 271, 247,
225, 205, 187, 170, 155, 141, 129, 118,
108, 99, 90
};
//***************************************************************************
//* Function TempNTC
//* Returns temperature value converted by means of interpolation
//* ADC is the ADC result
//* To is temperature blealue for index 0 from the table (-30şC)
//* dT is temperature difference between two entries in the tabel (10şC)
//***************************************************************************
int TempNTC(unsigned int adc, int To, int dT)
{
int aux;
unsigned int min, max;
unsigned char i;
//Search the interval where adc value fits
for(i=0;(i<TablePoints)&&(adc<(ADCTable[i])); i++);
if ((i==0)) //If we don't find it, return error
return ToCels;
max=ADCTable[i-1]; //Took the highest value of the interval
min=ADCTable[i]; //and the smallest
aux=(max-adc)*dT; //first step of the interpolation
aux=aux/(max-min); //and second step
aux+=(i-1)*dT+To; //and we add the offset
return aux;
}
//************************ The End *******************************************
/*********************** D I M M E R - U S T A W I E N I A ***************************/
#define LICZBA_KROKOW 200
// czas trwania szpilki (Detekcja ZERA) wyrażony w milisekundach np: 1,2,... albo np: 0.5
#define SZPILKA_MS 1.6
/*********************** D I M M E R - U S T A W I E N I A ***************************/
#define __OCR_STEP ((F_CPU/8)*((1000-((SZPILKA_MS*100)/2))/LICZBA_KROKOW))/100000
static uint8_t procent(uint8_t pr) {
return (pr * (LICZBA_KROKOW-1))/100;
}
#define TRIAK_ON PORTD |= (1<<PD1)
#define TRIAK_OFF PORTD &= ~(1<<PD1)
#define TIMER2_START TCCR2 |= (1<<CS21) // prescaler=8
#define TIMER2_STOP TCCR2 &= ~(1<<CS21) // prescaler off
volatile uint8_t kroki;
volatile uint8_t kanal1;
volatile uint8_t ika1;
//************************ The End *******************************************
/*********************** REGULATOR PID ***************************/
#define K_P 1.00
#define K_I 0.00
#define K_D 0.00
struct GLOBAL_FLAGS {
//! True when PID control loop should run one time
uint8_t pidTimer:1;
uint8_t dummy:7;
} gFlags = {0, 0};
//! Parameters for regulator
struct PID_DATA pidData;
#define TIME_INTERVAL 157
void Init(void)
{
pid_Init(K_P * SCALING_FACTOR, K_I * SCALING_FACTOR , K_D * SCALING_FACTOR , &pidData);
}
int16_t Get_Reference(void)
{
int16_t l;
if(zmienna2<30) l=0;
if(zmienna2>=30) l=ADCTable[(zmienna2/5)];
return l;
}
int16_t Get_Measurement(void)
{
return t;
}
void Set_Input(int16_t inputValue)
{
pwm_value = inputValue; // Skalowanie wyniku -
if(pwm_value >= 200)
pwm_value = 200;
if(pwm_value < 0)
pwm_value = 0;
kanal1=pwm_value;
}
//************************ The End *******************************************
int main(void)
{
uint32_t srednia = 0;
uint8_t dt = 10;
int wzr;
Init(); //inicjalizacja regulatora PID
// Ustawienie pinów sterującego triak jako wyjście
DDRD |= (1<<PD1);
// Przerwanie INT0 służące do wykrywania przejścia przez Zero sieci
MCUCR |= (1<<ISC01)|(1<<ISC00);// zbocze narastające
GICR |= (1<<INT0);// odblokowanie INT0
// TIMER0 - konfiguracja timera do programowych timerów
TCCR0 |= (1<<CS02); //prescaler = 1024
TIMSK |= (1<<TOIE0); // zezwolenie na przerwanie OVF
TCNT0 = 195; // częstotliwość przerwania 100 Hz
//TIMER1 - konfiguracja timera do PID - tryb CTC
TCCR1B |= (1<<WGM12)|(1<<CS11) |(1<<CS10); //Tryb CTC i preskaler 64
TIMSK |= (1<<OCIE1A); // zezwolenie na przerwanie COMPARE MATCH
OCR1A = 124;
// TIMER2 - konfiguracja timera do programowych timerów
TCCR2 |= (1<<WGM21);// tryb CTC
TIMSK |= (1<<OCIE2);// odblokowanie przerwania COMPARE MATCH
OCR2 = __OCR_STEP;
// inicjalizacja przetwornika ADC
ADCSRA |= (1<<ADEN); // włącz ADC
ADCSRA |= (1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); // preskaler
ADMUX |= REF_256;// ustawiamy wewn. źr odn. 2,56V
//===== LCD ======================
_delay_ms(50); //opóźnienie wymagane przez niektóre wyświetlacze.
lcd_init(); //inicjalizuj LCD
//Napis startowy
lcd_locate(0,0);
lcd_str("Sterwonik");
lcd_locate(1,0);
lcd_str("v 1.0");
_delay_ms(2000);
lcd_cls();
TRIAK_OFF;
sei(); //włącz przerwania globalne
while(1){ //pętla główna
//pomiar ADC klawiatura
ADC_pomiar = pomiar(7);
//pomiar ADC termistor
ADC_czujnik = pomiar(PC1);
srednia = srednia * dt;
srednia = srednia + ADC_czujnik * 10;
srednia = (srednia+dt) / (dt+1);
srednia1=srednia/10;
// Przeliczanie ADC na temperature w stopniach
t = TempNTC(srednia1,ToCels,dTCels);
// Run PID calculations once every PID timer timeout
if(gFlags.pidTimer)
{
referenceValue = Get_Reference();
measurementValue = Get_Measurement();
inputValue = pid_Controller(referenceValue, measurementValue, &pidData);
Set_Input(inputValue);
gFlags.pidTimer = FALSE;
}
lcd_locate(0,0);
lcd_str("Temp:");
lcd_locate(0,10);
lcd_int(t);
lcd_locate(1,0);
lcd_int(ADC_pomiar);
lcd_str(" ");
lcd_locate(1,4);
lcd_int(zmienna2);
lcd_str(" ");
lcd_locate(1,10);
lcd_int(inputValue);
lcd_str(" ");
if( keys[0]==29 && zmienna2<190) {
zmienna2+=5;
}
if( keys[1]==29 && zmienna2>0) {
zmienna2-=5;
}
uint8_t i;
for(i=0;i<3;i++){
wzr = pgm_read_word (&adc_kx[i]);
if((ADC_pomiar > wzr-ADC_RANGE) && (ADC_pomiar < wzr+ADC_RANGE)){
if( keys[i]<30) keys[i]++;
} else keys[i]=0;
}
}
}
uint16_t pomiar(uint8_t kanal){
ADMUX = (ADMUX & 0b11111000) | kanal;
ADCSRA |= (1<<ADSC); //start pomiaru
while( ADCSRA & (1<<ADSC) );
return ADCW;
}
ISR(TIMER0_OVF_vect){
zmienna++;
uint16_t x;
x=Timer1;
if(x) Timer1 = --x; //częstotliwość 100Hz
x=Timer2;
if(x) Timer2 = --x; //częstotliwość 100Hz
}
//Przejście napięcia sieci przez zero
ISR(INT0_vect) {
TIMER2_STOP;
TRIAK_OFF;
kroki=LICZBA_KROKOW;
/* podwójne buforowanie, synchronizacja do 50Hz */
ika1=kanal1;
TCNT2 = 0;
TIMER2_START;
}
ISR(TIMER2_COMP_vect) {
if(ika1 && kroki == ika1) TRIAK_ON;
kroki--;
}
ISR(TIMER1_COMPA_vect) {
static uint16_t i = 0;
if(i < TIME_INTERVAL)
i++;
else{
gFlags.pidTimer = TRUE;
i = 0;
}
}[/syntax]
Statystyki: Napisane przez faber33 — 12 kwi 2015, o 12:59
]]>