Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatică și Microelectronică

Departamentul Microelectronică și Inginerie Biomedicală

RAPORT

La lucrarea de laborator Nr:5

La disciplina :Sisteme Electronice Incorporate
Tema:Controlul PID

A efectuat: st.gr.ISBM-172 , Rotari Nicu

A verificat: lector.univ., Verjbitchi Valerii

Chișinău 2020
Scopul lucrării:

Implementarea unui sistem ce ar compensa variatia unor conditii pastrind tensinea la iesire la un
nivel constant.

Sarcina lucrării:

Să se proiecteze un sistem bazat pe microcontroler ce ar monitoriza in permanenta nivelul

tensiunii intr-un sistem si ar preveni variatia acestui nivel de la nivelul dorit. Variatia nivelului dorit
se induce prin intermediul actiunii unor factori externi. Pentru simulare in calitate de factor
perturbator se introduce un buton in circuitul electronic.

Proiectul se realizeaza utilizind microcontrolerul ATmega32. Pentru simularea sistemului se

utilizeaza circuitul ilustrat in partea finala a raportului. Coeficientii pentru calculare se determina
prin variatia unor potentiometre conectate la intrarile modulului ADC.

Astfel variind pozitia cursorului potentiometrelor se poate schimba valoarea coeficientilor ce se

utilizeaza in calcule. Dirijarea nivelului tensiunii la acel dorit se realizeaza prin intermediul unui
semnal PWM generat la pinul OCR1A asociat cu modulul TIMER1.
 

Notiuni teoretice:

Un regulator proporțional-integral-derivat ( controler PID ) este o buclă de control mecanism

de feedback ( controler ) utilizate în mod obișnuit în sistemele industriale de control . Un regulator
PID calculează în mod continuu o valoare de eroareca diferența dintre o dorită valoare
de referință și o măsurată variabilă de proces . Controlorul încearcă să minimizeze eroarea în timp
prin ajustarea unei variabile de control , cum ar fi poziția unui ventil de comandă , un amortizor sau
alimentarea cu energie electrică a unui element de încălzire, la o nouă valoare determinată printr - o
sumă ponderată:

în cazul în care  ,  și  , toate non-negativ, denotă coeficienții

pentru proporționale , integrale și derivate termeni, respectiv (uneori notat P, I, și D ). În acest
model,
P reprezintă valorile actuale ale erorii. De exemplu, în cazul în care eroarea este mare și pozitiv
de control de ieșire va fi , de asemenea , mari și pozitive.
I reprezintă valorile anterioare ale erorii. De exemplu, în cazul în care curentul de ieșire nu este
suficient de puternică, deeroare se va acumula în timp, iar controlerul va răspunde prin aplicarea
unei acțiuni mai puternice.
D reprezintă posibile valori viitoare ale erorii, în funcție de rata actuală de schimbare. [1]
Ca un regulator PID se bazează doar pe variabila de proces măsurate, nu pe cunoașterea procesului
de bază, este aplicabil în linii mari. [2] Prin reglarea celor trei parametri ai modelului, un regulator
PID poate face cu cerințe specifice de proces. 
Răspunsul controlerului poate fi descrisă în ceea ce privește capacitatea de a răspunde la o eroare,
gradul în care sistemul de depășire a unei valori de referință, precum și gradul de orice oscilație
a sistemului. Utilizarea algoritmului PID nu garantează un control optim al sistemului sau chiar
sa stabilitate .

Anumite aplicații pot necesita utilizarea doar unul sau doi termeni pentru a asigura controlul adecvat
sistemului. Acest lucru se realizează prin stabilirea alți parametri la zero. Un controler PID va fi
numit PI, PD, P sau controler I în absența acțiunilor de control respective. controlere PI sunt destul
de frecvente, deoarece acțiunea derivat este sensibil la măsurarea nivelului de zgomot, în timp ce
lipsa unui termen integrale poate împiedica sistemul să atingă valoarea țintă.

Pentru timp discrete sisteme, termenul PSD, pentru proportional-însumării-diferență , este adesea

utilizat.

Figura1.Schema bloc a unui regulator PID într - o buclă de feedback

Mersul lucrării :

1. Pentru început a fost realizată schema bloc a programului :

2. Au fost create fișierele header ale programului în AVR Studio.

Fișierul adc_decl.h:

#ifndef ADC_DECL_H_ // Libraria este destinata pornirii, configurarii si receptionarii

datelor //de la modulul periferic ADC

#define ADC_DECL_H_ // Functiile disponibile:

//ADCInit--initializeaza si porneste conversia in mod continuu receptionind semnalul de
pe //pinul 0
//ADCResult--returneaza valoarea obtinuta in urma conversiei

void adc_init(); // functia de setare a modulului ADC

int adc_result(int); // functia ce returneaza valoarea perceputa de ADC

#endif /* ADC_DECL_H_ */

Fișierul pwm_decl.h:

#include <avr/io.h>

#ifndef PWM_DECL_H_ //Libraria este destinata configurarii modulului periferic TIMER1 a

//microcontrolerului ATmega32 pentru generarea semnalelor PWM .

#define PWM_DECL_H_ //Modulul periferic este configurat pentru generarea semnalelor cu o

//rezolutie de 10 biti, frecventa de lucru este egala cu frecventa microprocesorului.

void pwm_init();//functia de initializare a semnalului PWM

void set_pwm(int);//functia de setare a factorului de umplere a PWM

#endif /* PWM_DECL_H_ */

Fișierul pid_decl.h:
#ifndef PID_DECL_H_
#define PID_DECL_H_
#define ERR_TAB_SIZE 5

int PID_Control(int, int); //functia de calculare a valorii pentru pwm

void set_ki(int k);//functia de setare a coeficientului ki
void set_kd(int k);//functia de setare a coeficientului kd
void set_kp(int k);//functia de setare a coeficientului kp
int kp,kd,ki;
#endif /* PID_DECL_H_ */

3. Au fost create fișierele sursă ale programului principal.

Fișierul adc_def.c:
#include "adc_decl.h"

int input=0;
int AdcTab[8];

ISR(ADC_vect) //subrutina de prelucrare a intreruperii de la ADC

{
ADMUX&=0b11100000;
switch(input) //verificarea de la care intrare a ADC a fost facuta conversia
{

case 0:{AdcTab[0]=ADC;  input=1;}break;

case 1:{AdcTab[1]=ADC;  ADMUX|=0b00000001; input=2;}break; //transmiterea
valorii conversate //la pinul respectiv
case 2:{AdcTab[2]=ADC;  ADMUX|=0b00000010; input=3;}break;
case 3:{AdcTab[3]=ADC;  ADMUX|=0b00000011; input=4;}break;
case 4:{AdcTab[4]=ADC;  ADMUX|=0b00000100; input=0;}break;

}
}

void adc_init() //functia de initializare a modului ADC fiind efectuate toate

configurarile //necesare.
{
ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADATE)|(1<<ADIE)|(1<<ADPS2)|(1<<ADPS1)|(0<<ADPS0);
ADMUX=(0<<REFS1)|(1<<REFS0)|(0<<ADLAR)|(0<<MUX4)|(0<<MUX3)|(0<<MUX2)|(0<<MUX1)|
(0<<MUX0);
}
int adc_result(int var) //functia de transmitere a valorii obtinute de la ADC
{
return AdcTab[var];
}

Fișierul main.c:

#include <avr/io.h>
#include "adc_decl.h"
#include "pwm_decl.h"
#include "pid_decl.h"
#include <avr/interrupt.h>
int main(void)
{

Pwm_init();//initializarea semnalului PWM

Adc_init();//initializarea modului ADC
port_init();//initializarea porturilor
sei();

   while(1);
}
ISR(TIMER1_OVF_vect)//subrutina de prelucrare a intreruperii de overflow a TIMER1
{
int temp;
int va;
int vd;
int vout;
va=adc_result(0); //preluarea valorii actuale
vd=adc_result(1);//preluarea valorii dorite
temp=adc_result(2);//setarea coeficientilor
set_kp(temp);
temp=adc_result(3);
set_kd(temp);
temp= adc_result(4);
set_ki(temp);
vout=pid_control(va,vd);
set_pwm(vout);//setarea factorului de umplere a semnalului PWM
}
void port_init()//functia de initializare a porturilor
{
DDRA=0x00;
PORTA=0xff;
DDRB=0x00;
PORTB=0xff;
DDRC=0x00;
PORTC=0xff;
DDRD=0b00100000;
PORTD=0b11011111;
}

Fișierul pwm_def.c:

#include "pwm_decl.h"

void pwm_init() //functia de configurare  a modulului TIMER pentru crearea semnalului PWM
{
TCCR1A=(1<<COM1A1)|(0<<COM1A0)|(1<<COM1B1)|(0<<COM1B0)|(1<<WGM11)|(1<<WGM10);
TCCR1B=(1<<WGM12)|(0<<WGM13)|(1<<CS12)|(0<<CS11)|(1<<CS10);
TIMSK|=(1<<TOIE1);
}

void set_pwm(int fact)

{
OCR1A=fact;//setarea factorului de umplere a PWM
}

Fișierul pid_def.c:
#include "pid_decl.h"
int pid_control(int va, int vd)//functia de calculare a valorii de iesire
{
int e;
static int vapr;
static int ErrTab[ERR_TAB_SIZE];
static int errpos;
int vp;
int vi;
int vo;

e=vd-va;//calculul erorii
vp=kp*e;
vd=kd*(va-vapr);
vapr=va;
if (errpos++>ERR_TAB_SIZE)//verificarea pozitiei si introducerea valorii in tabelul
errpos=0; //cu valorile precedente ale erorii
ErrTab[errpos]=e;
vi=ki*(ErrTab[0]+ErrTab[1]+ErrTab[2]+ErrTab[3]+ErrTab[4]+ErrTab[5]);
vo=vp+vd+vi; //calculul valorii pentru setare a factorului de umplere a PWM
return vo;
}
void set_kp(int k){
kp=k;
}
void set_kd(int k){
kd=k;
}
void set_ki(int k){
ki=k;
}

4. A fost creată schema electrică în ISIS Proteus și a fost simulată verificîndu-se astfel
corectitudinea programului.

Figura.2. Schema electrică a circuitului

Concluzii

Efectuând această lucrare de laborator am reușit să înțeleg modul de lucru cu PID cît și
configurarea acestuia.
Am observat că pentru ca sistemul să funcționeze corect trebuie să ținem cont de frecvențele
modulului ADC și a modulului TIMER ce generează semnalul PWM.
De asemenea este nevoie de ales corect coeficienții pentru recepționarea unui răspuns
adecvat la inducerea unor factori perturbatori.