Borykam się od pewnego czasu z regulatorem PID na Atmege8. Atmel dostarcza biblioteki ale wymagają one przeróbek, po dokonaniu kilku okazało się że coś jest nie tak i program się nie kompiluje (gdzieś tkwi błąd), prześledziłem kod i może ktoś bardziej obeznany z językiem będzie w stanie pomóc i wyłapać błąd.
pid_cy.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/iom8.h>
#include "stdint.h"
#include "pid.h"
/*! \brief P, I and D parameter values
*
* The K_P, K_I and K_D values (P, I and D gains)
* need to be modified to adapt to the application at hand
*/
//! \xrefitem todo "Todo" "Todo list"
#define K_P 1.00
//! \xrefitem todo "Todo" "Todo list"
#define K_I 0.00
//! \xrefitem todo "Todo" "Todo list"
#define K_D 0.00
int16_t referenceValue, measurementValue, inputValue;
/*! brief Flags for status information
*/
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;
/*! \brief Sampling Time Interval
*
* Specify the desired PID sample time interval
* With a 8-bit counter (255 cylces to overflow), the time interval value is calculated as follows:
* TIME_INTERVAL = ( desired interval [sec] ) * ( frequency [Hz] ) / 255
*/
//! \xrefitem todo "Todo" "Todo list"
#define TIME_INTERVAL 3922 // zmieniłem ze 157 po obliczeniach 3922
/*! \brief Timer interrupt to control the sampling interval
*/
#pragma vector = TIMER0_OVF_vect
__interrupt void TIMER0_OVF_ISR( void )
{
static uint16_t i = 0;
if(i < TIME_INTERVAL)
i++;
else{
gFlags.pidTimer = TRUE;
i = 0;
}
}
/*! \brief Init of PID controller demo
*/
void Init(void)
{
pid_Init(K_P * SCALING_FACTOR, K_I * SCALING_FACTOR , K_D * SCALING_FACTOR , &pidData);
// Set up timer, enable timer/counte 0 overflow interrupt
TCCR0 = (1<<CS00);
TIMSK = (1<<TOIE0);
TCNT0 = 0;
}
/*! \brief Read reference value.
*
* This function must return the reference value.
* May be constant or varying
*/
int16_t Get_Reference(void)
{
temp_zad();
return 8;
}
/*! \brief Read system process value
*
* This function must return the measured data
*/
int16_t Get_Measurement(void)
{
double temp; // temp przechowuje aktualną temperaturę
unsigned char ds18b20_pad[9]; // w tablicy ds18b20 są przechowywane dane z czujnika
if (ds18b20_ConvertT())
{
_delay_ms(750); // 750ms czas konwersji
ds18b20_Read(ds18b20_pad);// Odczyt z układu ds18b20 i zapis dwóch bajtów do tablicy ds18b20_pad
temp = ((ds18b20_pad[1] << 8) + ds18b20_pad[0])/16.0;
measurementValue=temp;//TUTAJ WYNIK ( WARTOSC CYFROWEGO CZUJNIKA TEMPERATURY)
}
return 4;
}
/*! \brief Set control input to system
*
* Set the output from the controller as input
* to system. wyjcie z kontrolera wejciem do obiektu czyli sygnał PWM
*/
void Set_Input(int16_t inputValue)
{
DDRB |=(1<<PB1);
TCCR1A |= (1<<WGM10);// tryb fast PWM
TCCR1A |= (1<<COM1A1);
TCCR1B |= (1<<CS10); // preskaler na 1 fpwm=3,9kHz przy f_cpu 1MHz
OCR2=inputValue ;
}
/*! \brief Demo of PID controller
*/
void pid_cy(void)
{
Init();
__enable_interrupt();
while(1)
{
// 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;
}
}
}[/syntax]
pid.c
[syntax=c]#include "pid.h"
#include "stdint.h"
/*! \brief Initialisation of PID controller parameters.
*
* Initialise the variables used by the PID algorithm.
*
* \param p_factor Proportional term.
* \param i_factor Integral term.
* \param d_factor Derivate term.
* \param pid Struct with PID status.
*/
void pid_Init(int16_t p_factor, int16_t i_factor, int16_t d_factor, struct PID_DATA *pid)
// Set up PID controller parameters
{
// Start values for PID controller
pid->sumError = 0;
pid->lastProcessValue = 0;
// Tuning constants for PID loop
pid->P_Factor = p_factor;
pid->I_Factor = i_factor;
pid->D_Factor = d_factor;
// Limits to avoid overflow
pid->maxError = MAX_INT / (pid->P_Factor + 1);
pid->maxSumError = MAX_I_TERM / (pid->I_Factor + 1);
}
/*! \brief PID control algorithm.
*
* Calculates output from setpoint, process value and PID status.
*
* \param setPoint Desired value.
* \param processValue Measured value.
* \param pid_st PID status struct.
*/
int16_t pid_Controller(int16_t setPoint, int16_t processValue, struct PID_DATA *pid_st)
{
int16_t error, p_term, d_term;
int32_t i_term, ret, temp;
error = setPoint - processValue;
// Calculate Pterm and limit error overflow
if (error > pid_st->maxError){
p_term = MAX_INT;
}
else if (error < -pid_st->maxError){
p_term = -MAX_INT;
}
else{
p_term = pid_st->P_Factor * error;
}
// Calculate Iterm and limit integral runaway
temp = pid_st->sumError + error;
if(temp > pid_st->maxSumError){
i_term = MAX_I_TERM;
pid_st->sumError = pid_st->maxSumError;
}
else if(temp < -pid_st->maxSumError){
i_term = -MAX_I_TERM;
pid_st->sumError = -pid_st->maxSumError;
}
else{
pid_st->sumError = temp;
i_term = pid_st->I_Factor * pid_st->sumError;
}
// Calculate Dterm
d_term = pid_st->D_Factor * (pid_st->lastProcessValue - processValue);
pid_st->lastProcessValue = processValue;
ret = (p_term + i_term + d_term) / SCALING_FACTOR;
if(ret > MAX_INT){
ret = MAX_INT;
}
else if(ret < -MAX_INT){
ret = -MAX_INT;
}
return((int16_t)ret);
}
/*! \brief Resets the integrator.
*
* Calling this function will reset the integrator in the PID regulator.
*/
void pid_Reset_Integrator(pidData_t *pid_st)
{
pid_st->sumError = 0;
}[/syntax]
pid.h
[syntax=c]#ifndef PID_H
#define PID_H
#include "stdint.h"
#define SCALING_FACTOR 128
/*! \brief PID Status
*
* Setpoints and data used by the PID control algorithm
*/
typedef struct PID_DATA{
//! Last process value, used to find derivative of process value.
int16_t lastProcessValue;
//! Summation of errors, used for integrate calculations
int32_t sumError;
//! The Proportional tuning constant, multiplied with SCALING_FACTOR
int16_t P_Factor;
//! The Integral tuning constant, multiplied with SCALING_FACTOR
int16_t I_Factor;
//! The Derivative tuning constant, multiplied with SCALING_FACTOR
int16_t D_Factor;
//! Maximum allowed error, avoid overflow
int16_t maxError;
//! Maximum allowed sumerror, avoid overflow
int32_t maxSumError;
} pidData_t;
/*! \brief Maximum values
*
* Needed to avoid sign/overflow problems
*/
// Maximum value of variables
#define MAX_INT INT16_MAX
#define MAX_LONG INT32_MAX
#define MAX_I_TERM (MAX_LONG / 2)
// Boolean values
#define FALSE 0
#define TRUE 1
void pid_Init(int16_t p_factor, int16_t i_factor, int16_t d_factor, struct PID_DATA *pid);
int16_t pid_Controller(int16_t setPoint, int16_t processValue, struct PID_DATA *pid_st);
void pid_Reset_Integrator(pidData_t *pid_st);
#endif[/syntax]
wynik z konsoli
warning: ignoring #pragma vector
../pid_cy.c:67: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'void'
../pid_cy.c: In function 'Get_Reference':
../pid_cy.c:97: warning: implicit declaration of function 'temp_zad'
../pid_cy.c: In function 'Get_Measurement':
../pid_cy.c:109: warning: implicit declaration of function 'ds18b20_ConvertT'
../pid_cy.c:112: warning: implicit declaration of function 'ds18b20_Read'
make: *** [pid_cy.o] Error 1
niepokoi mnie fragment #pragma vector = TIMER0_OVF_vect
__interrupt void TIMER0_OVF_ISR( void )
jak się domyślam jest to związane z przerwaniem tyle że w tej czerwonej linii eclips wskazuje błąd.
Kolejnym pytaniem jest zezwolenie na przerwanie jak się ono odbywa ( linia __enable interrupt ?).
Mam nadzieję że ktoś z was jest w stanie mi pomóc z tym niechlujnym (przez to że jestem nowicjuszem) kodem
PozdrawiamStatystyki: Napisane przez Gonzales1891 — 13 lis 2014, o 20:28
]]>