Zobrazenie zdroja stránky Riadenie sústavy 1. rádu



Azda najjednoduchší dynamický elektrický obvod je tvorený odporom a kondenzátorom. Takýto RC člen má výrazné filtračné účinky, používa sa napríklad na vyhladenie PWM priebehov, filtráciu vysokofrekvenčných zložiek signálu, ochranu kontaktov relé a pod. Veľa krát je vo funkcii filtra PWM signálu, je regulovaná sústava. To je náš prípad.

<div style='text-align: center;'>
[[Súbor:RC-modul.jpg|250px]][[Súbor:RC-schema1.png|350px]]<BR>
''Komerčný modul na ochranu kontaktov relé a jeho schéma zapojenia (RC obvod).''
</div>

Schému zapojenia doplníme o označenie vstupných a výstupných signálov. . Bude nás zaujímať priebeh napätia na kondenzátore po pripojení napätia 5V.  Je zrejmé, že kondenzátor sa bude nabíjať a že rýchlosť nabíjania bude závisieť od veľkosti rezistora R. Čim vyššia bude hodnota odporu, tým menší bude nabíjací prúd a tým dlhšie sa bude kondenzátor nabíjať. Podobná situácia bude platiť aj pre vybíjanie. Ale aký bude presný tvar nabíjacej krivky? Nabíjacia krivka je vlastne prechodová charakteristika. Prepokladáme, že pripojený zdroj má prakticky nulový vnútorný odpor.

<div style='text-align: center;'>
[[Súbor:RC-schema2.png|500px]]<BR>
''Jednoduchý RC obvod s doplneným označením veličín.''
</div>

V elektrickom obvode podľa obrázku  podľa Kirchoffovho zákona platí, že súčet napätí v uzavretej slučke je nulový:
<div style='text-align: center;'><math>
  u_{in}(t) - R i(t) - u_{out}(t) = 0,
</math></div>

kde <math>i(t)</math> je prúd v slučke a <math>R</math> je odpor rezistora, pričom pre výstupné napätie <math>u_{out}</math> ďalej platí

<div style='text-align: center;'><math>
  u_{out}(t) = \frac{1}{C} \int_{0}^{t} i(t) dt, 
</math></div>

kde <math>C</math> je kapacita kondenzátora.


Po zohľadnení počiatočných podmienok dostaneme riešením diferenciálnej rovnice pre skokovú zmenu vstupného napätia <math>u_{in}</math> z hodnoty 0 na <math>U_0</math> v čase <math>t=0</math> nasledovný priebeh výstupného napätia <math>u_{out}</math>: 

<div style='text-align: center;'><math>
   u_{out}(t) = U_{0} K (1-e^{-t/T}) 
</math></div>

kde <math>K=1</math> je tzv. ''zosilnenie'' obvodu a <math>T = RC</math> je tzv. ''časová konštanta''. Jej veľkosť určuje tvar a rýchlosť nabíjacej krivky kondenzátora. 
 
Pre opačný priebeh, t.j. vybíjanie kondenzátora, je potrebné na vstup pripojiť napätie 0 V, nestačí len rozpojiť spínač. Náboj musí niekam odtiecť, pri odpojení by ostal
na kondenzátore. Tvar krivky pre vybíjanie je podobný, ale samozrejme jej matematický opis je trocha iný a naviac musíme započítať aj iné (nenulové) počiatočné podmienky.
Pre naše meranie zabezpečíme pripojenie napätia aj jeho odpojenie a pripojenie na zem kvôli vybíjaniu pomocou jedného z digitálnych výstupov mikroprocesora. Pri stave 
log. 1 bude na vstupe (takmer) 5 V a naopak, pri log. 0 bude kondenzátor pripojený cez odpor R k zemi a tak sa bude môcť vybiť.


<div style='text-align: center;'>
[[Súbor:RC-simulaciaT.png|800px]]<BR>
''Časové priebehy vstupného (modrá) a výstupného (červená) napätia - simulácia.''
</div>


Ako z nameraného priebehu zistíme časovú konštantu? Zabudnite na poučky o dotyčnici v počiatočnom bode...

Pozrime sa, na akú hodnotu stihne vystúpiť napätie za čas rovný presne jednej časovej konštante. Ak do funkcie pre priebeh výstupného napätia dosadíme za čas  <math>t = T</math>, dostaneme

<div style='text-align: center;'><math>
   u_{out}(T) = U_{0} K (1-e^{-T/T})  = U_{0} K (1-e^{-1})  = 0,632 U_{0} K 
</math></div>

teda na 63,2% z ustálenej hodnoty. To vieme vypočítať celkom presne, je to 0,632*5 = 3,16 V.
Ak teda nájdeme na grafe hodnotu napätia  3,16 V, na časovej osi tomu zodpovedajúci čas je priamo hodnota T. Na obrázku vyššie je tento čas 2 sekundy, ale keďže skoková zmena na vstupe nastala v čase 1 sekunda, hodnota časovej konštanty je (2-1) = 1 sekunda.



== Identifikácia sústavy ==


No a presne to treba spraviť aj pomocou vášho mikropočítača. Aby sme merania vedeli priradiť k reálnemu času, potrebujeme merania robiť s nejakou presnou periódou vzorkovania. 
Na to nám poslúži počítadlo T2, ktoré nastavíme tak, aby vyvolalo požiadavku o výpis hodnoty napätia na kondenzátore každých 10 ms. Samotné počítadlo bude generovať prerušenie každé 2 ms. Toto prerušenie použijeme ako “generátor” 10ms vzoriek a na opakované spustenie AD prevodu. <ref>Pravdepodobne zistíte, že 8-bitovým počítadlom T0 s kryštálom 16 MHz sa vám nepodarí nastaviť preddelič a register OCR na takú kombináciu, aby interval bol naozaj presne 10,00 ms. V rámci presnosti nášho merania to nevadí, ale je to principiálny problém. Buď by sme museli použiť 16-bitové počítadlo T1, alebo zmeniť hodnotu kryštálu napr. na 18,432 MHz, v takom prípade by nám čas vyšiel presne.</ref>. Teoretická hodnota časovej konštanty je 0,5 s. T.j.  Presnosť merania postačuje. 
Napätie na kondenzátore je merané nasledovným spôsobom: AD prevodník je nastavený na maximálnú možnú rýchlosť realizácie AD prevodu. Prevod je spustený v prerušení od T2, t.j. každé 2ms. Je povolené prerušenie od ukončenia AD prevodu.  V obsluhe prerušenia prečítame napätie na kondenzátore. Ak treba, môžeme ho aj, napr. Filtrom typu “kĺzavý priemer” filtrovať. Ak by sme merali viac AD kanálov nastavili by sme ďalší analógový vstup. Spustenie AD prevodu sa zase uskutoční v prerušení od T2 (každé 2 ms).

Vzorový program predpokladá pripojenie 5V (pin D5) na RC člen. V takomto prípade by sme mohli vykreslovať aj meraný priebeh napätia nav stupe RC člena. My ale budeme vstupné napätie generovať ako PWM signal (Fast PWM MOD3 výstup na pin D5). T.j. bude vhodnejšie vykreslovať teoretický priebeh strednej hodnoty PWM signálu. Na začiatku nastavíme plnenie na nulu, čo odpovedá napätiu 0V a po 1 s zmeníme na plnenie odpovedajúce hodnote napr. 4V (plnenie nastavíme do  registra … ako číslo z intervalu (0 až 255)). Teoretický čas ustálenia napätia na kondenzátore je 5*T (časová konštanta RC člena -  T=R*C) Po tomto čase výpis cez sériový kanál na SERIAL PLOTER ukončíme. Ak by sme chceli opakovanie vykreslovať prechodovú charakteristiku, musíme najskôr kondenzátor vybiť. To sad á napr. Tak, že pripojíme malý resistor, napr. 330Ohm cez pin D4. Ten na začiatku nastavíme ako výstupný na hodnotu LOW. V okamžiku začatia generovania PWM signálu pin D4 nastavíme ako vstupný a vybíjanie tým ukončíme. Keďže potrebujeme poznať čas ( násobok 10ms)  budeme na základe info s T2 inkrementovať premenú, ktorá bude načítavať  údaj o čase.   Je vhodné do grafu okrem napätia na kondenzátore vykreslovať ustálenú hodnotu a hodnotu odpovedajúcu “časovej konštante”. Vykreslovať môžeme realizovať v rozsahu 0 až 5V, resp. v rozsahu AD prevodníka 0 až 1023, resp. v tzv. MU rozsah 0 až 1.  

<div style='text-align: center;'>
[[Súbor:RC-schema3.png|350px]]<BR>
''Schéma zapojenia pre identifikáciu aj reguláciu.''
</div>



'''Úloha 1:''' Odmerajte časový priebeh signálov pri nabíjaní kondenzátora C cez rezistor R. Z nameraného grafu určte hodnotu časovej konštanty T a spresnite hodnoty R a C.


Zdrojové kódy pre AVRGCC
------------------------------------

'''POZN.:'''  
* Projekt otvorte cez šablónu MIPS a okrem nového <code>main.c</code> si pridajte aj oba súbory <code>p_f_1.h</code> a <code>p_f_1.c</code>
* V nastaveniach projektu je potrebné zmeniť rýchlosť z pôvodnej hodnoty 9600 na 115200 cez <code>Project -> Properties -> Toolchain -> Symbols -> BAUD = 115200</code>
* Výstup programu sledujeme v programe '''SerialPlot''', treba tam nastaviť rýchlosť na 115200, počet kanálov na 4, data oddelené čiarkou a počet bodov pre graf 500.
* Aby sa vám ľahšie odčítali potrebné hodnoty, vykreslujeme okrem napätia na kondenzátore aj aktuálny čas, ustálenú hodnotu a 63% ustálenej hodnoty. Posledné dve veličiny však musíte najprv v programe správne vypočítať. 

<tabs>

<tab name="main.c"><source lang="c++" style="background: LightYellow;">
/*
 * Cvicenie 12 - RC identifikacia
 * 
 * Definicie:
 *              ATmega328P
 *              F_CPU 16000000UL
 *              BAUDRATE 115200
 *
 * Pripojenie: 
 *                D5 cez R 10k pripoj C 47 uF na zem
 *                D4 cez cca 330 ohm pripoj na C
 *                A0 pripoj na C
 *                GND pripoj na zaporny pol C
 *
 * Konfiguracia:
 *                SerialPlot 500 krokov. 115200 Baud
 *
 */ 

#include <avr/io.h>
#include "p_f_1.h"            // pomocne funkcie pre toto cvicenie

#include "uart.h"
#undef  BAUD_RATE             // chceme rychlejsiu komunikaciu 
#define BAUD_RATE 115200

#include <stdio.h>            // a tiez pouzivat printf
FILE mystdout = FDEV_SETUP_STREAM(uart_putc, NULL, _FDEV_SETUP_WRITE);
                              
							                              
int main(void)
{
   hw_init();
   uart_init();
   stdout = &mystdout;           // printf() works from now

   /* 0. Toto je uloha pre studentov    */
   unsigned int y_oo = 0;        // tu nahradte hodnotu vypocitanou pre ADC zodpovedajuce ustalenej hodnote 4V
   unsigned int y_63 = 0;        // tu nahradte hodnotu vypocitanou pre 63 ustalenej
   

   
    /*  1. Najprv vybijeme kondenzator: */
	set_bit(DDRD,pinB );       // Pin nastavime ako vystupny
	clear_bit(PORTD,pinB);     // a dame tam log. 0


    /* 2. Pokracujeme incializaciou:   */
    ini_TC2();                 // Tv_zaklad = 2ms, v preruseni x5 = 10ms
	ini_PWM();             
 	adc_init();
 	sei();                     // Povolenie preruseni, aby to vsetko slapalo

	while(1)
	{
	
	    /* 3. pockame az do casu 1.0 s aby sme vybili kondenzator */  
		if (poc_time == 100 )      // 100 x 10ms = 1 sekunda
		{
        	clear_bit(DDRD,pinB);  // Pin odpojime, t.j. input, "odstranim skrat"
			OCR0B = 204;           // a na vystup poslem PWM, ktore zodpoveda 4V 
		}
					
		
		/* 4. a teraz od 0.0 az po 5.0 sec sledujeme napatie na C */
		
		if( (flag_T_v)&&(poc_time<500 ))
		{                                        // 400 * Tv = 5s; 6*T + T + 1s;  chyba  == cca 2-promile
			flag_T_v = 0;        
		                                         // Vypiseme: aktualny cas, napatie na kondenzatore a dve pomocne veliciny  
			printf("%u,%u,%u,%u\r\n",poc_time,y_C,y_oo,y_63); 	// ako dekadicke hodnoty
		} 
		
		// po uplynuti 5 sekund uz nerobime nic
				       									
  }

  
  return(0);
}




</source></tab>
<tab name="p_f_1.h"><source lang="c++" style="background: LightYellow;">
/*
 * p_f_1.h
 *
 *  Pomocne funkcie na cvicenie 12 s RC clenom
 *  Date: 30. 04. 2024
 *  Author: S. Chamraz
 */ 

#ifndef P_F_1_H_
#define P_F_1_H_

#include <avr/io.h>
#include <avr/interrupt.h> 
#include <stdio.h>

#define toggle_bit(ADDRESS,BIT) (ADDRESS ^= (1<<BIT))

#define con_T_v  5-1		// T_v = 10 ms  (5 * 2ms) - vypis  kazdych 10ms

// port D
#define  pinA 5		// skok 5,0V,  
#define  pin_PWM 5		// resp. PWM 
#define  pinB 4		// vybijanie kondenzatora 


void ini_TC2(void);
void ini_PWM(void);
void adc_init(void);


#define f_opak_TC2 500		// 500 Hz -> 2ms
#define N_D_TC2 128			// Delic = 128
#define OCR2A_f_opak_TC2 F_CPU/f_opak_TC2/N_D_TC2 - 1		// Vysledkom je 2ms casova vzorka !!!!!

extern volatile int poc_time ;	// prirastok 10ms

extern volatile int y_C ;  // u_C = y_C;  
 
extern volatile unsigned char flag_T_v ;
extern volatile unsigned char poc_T_v;

//unsigned char vyk_w_zel = 0;
                          
extern volatile unsigned char poc_T_vypis; // vypis aj v nultej vzorke
//extern volatile unsigned char flag_Vypisov;	


#endif /* P_F_1_H_ */

</source></tab>
<tab name="p_f_1.c"><source lang="c++" style="background: LightYellow;">
/*
 * p_f_1.c
 *
 *  Pomocne funkcie na cvicenie 12 s RC clenom
 *  Date: 30. 04. 2024
 *  Author: S. Chamraz
 */ 

#include "uart.h"
#include "p_f_1.h"
volatile int poc_time = 0;	// prirastok 10ms
volatile int y_C = 0;  // u_C = y_C;  
 
volatile unsigned char flag_T_v = 0;
volatile unsigned char poc_T_v = 0;


void ini_PWM(void)                             // T0 (D6) budeme pouzivat ako "analogovy" vystup
{
    OCR0B  = 0;
	TCCR0A = (1<<COM0B1)|(0<<COM0B0)           // Turn output off when TCNT0 >= OCR0B
               |(1<<WGM01)|(1<<WGM00);         // Select Fast PWM Mode         
    TCCR0B = (0<<CS02)|(1<<CS01)|(1<<CS00);    // fopak = cca 1kHz
    DDRD  |= (1<<pin_PWM);			           // output  PD5	
	
}


void ini_TC2(void)
{	                                           //  Nastavenie TC2
	                                           // 7 6         5 4         3 2     1 0
	                                           // COM2A[1:0]  COM2B[1:0]  - - 	  WGM2[1:0]
	TCCR2A = 0b00000011;	                   // OC2B  PWM mod = 7
	TCCR2B = 0b00001101;	                   // fosc/128
	
	OCR2A = OCR2A_f_opak_TC2;                  // nastavenie frekvencie opakovania na 2ms
	TIMSK2  = (1<<TOIE2);                      // Enable interrupts @ overflow TC2 MOD 7
}


ISR(TIMER2_OVF_vect)                           
{                                        // toto sa vykona kazde 2,0ms
 	set_bit(ADCSRA,ADSC);                //   spustenie dalsieho prevodu ADSC = TRUE
	
	if (!poc_T_v)
	{	flag_T_v = 1;			// priznak vypoctu PI reg.
		toggle_bit(PORTB,LED);
        	poc_time++;
		poc_T_v = con_T_v;		
	} 
	else poc_T_v--;		
}

void adc_init(void){
	ADMUX = (0<<REFS1)|(1<<REFS0);				// AVCC - nastavenie zdroja ref. napatia
	ADCSRA = (1<<ADEN)							// "zapnutie" ADC
             |(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); // nastavenie preddelica
			                                    // fADC = 125kHz
			                                    // trvanie jedneho prevodu cca 0,1ms
			                                    // zarovnanie doprava
	ADMUX = (ADMUX & 0xF8);						// nastavenie kanalu AD0
	ADCSRA |= (1<<ADSC)|(1<<ADIE);				// spustenie prevodu, povolenie prerusenia od AD
}

ISR(ADC_vect){
                                             	// precitanie AD prevodu kanal 0;
	                                            // ak treba tu nastavíme dalsi kanal 
	                                            // a spustíme az v preruseni od TC2 
	                                            // a vycitame posledne ukonceny prevod
	y_C = ADC;                                  // precitanie AD0
}


</source></tab>
<tab name="Arduino code"><source lang="arduino" style="background: #9dd1e1;">

/* Arduino code az niekedy inokedy */


</source></tab>
</tabs>


<div style='text-align: center;'>
[[Súbor:RC-SerialPlot01.png|800px]]<BR>
''Výstup zo “SerialPtot“ by mohol vyzerať takto.''
</div>

== Regulácia sústavy ==

V druhej časti cvičenia bude našou snahou vytvoriť regulátor, ktorý bude udržiavať napätie na výstupe (t.j. na kondenzátore) na požadovanej hodnote a to aj pri zmene záťaže. Na podobnom princípe pracujú aj spínané zdroje, ktoré sa využívajú vo všetkých možných oblastiach. 


Zdrojové programy upravíme tak, aby sme mohli regulovať napätie na kondenzátore. Najskôr pomocou P regulátora.  Na začiatku treba povedať, že vstupom regulátora sú <math>w_{zel}</math> a <math>y_C</math> v rozsahu 0 až 1023. Výstup (plnenie PWM signálu) je z rosahu  (0 až 255)). To znamená, že ak chceme nastaviť zosilnenie P regulátora na hodnotu <math>K_P</math>, musí tomu odpovedať rovnica:

<math>
          m_{reg} (nT_v) =  (   e(nT_v) K_P )/4;
</math>
kde  <math> 4 = 1024/256 </math>.

Regulačnú odchýlku počítame podľa vzťahu
<math>
         e(nT_v) = w_{zel}(nT_v) - y_C(nT_v);
</math>

Samozrejme nesmieme zabudnúť na obmedzenie akčného zásahu (min = 0 a max = 255).

Na “pozadí” beží spojitý čas <code>timeVal</code> a my z neho využívame len disktretne vzorky, teda
<math>
        timeVal = n*T_v =  poc_{time}*T_v. 
</math>

V programe použíjeme namiesto <math>n</math> premennú <code>poc_time</code> typu int.

Môžeme to povedať, aj tak, že regulovaný system  mimo týchto okamžikov pracuje “v otvorenej slučke”. Perióda vzorkovania <math>T_v</math> musí byť dostatočne malá, aby sa stav systému medzi vzorkami zmenil len nepatrne. V zhode s prednáškou vyhovuje <math> T_v = 10</math> ms. Ak by sme použili PI, resp. PS regulátor, bolo by vhodné nastaviť samostatnú periódu vzorkovania pre zbiehanie PS algoritmu a samostatnú pre výpis priebehu regulovanej veličiny, akčného zásahu, želanej veličiny,...  


<div style='text-align: center;'>
[[Súbor:RC-SerialPlot02.png|800px]]<BR>
''Výstup zo “SerialPtot“ pre P regulátor so zosilnením 5 by mohol vyzerať takto.''
</div>


Pri realizáci P-regulátora využijeme program, ktorý sme vytvorili vyššie na identifikáciu parametrov sústavy. Musíme do neho doprogramovať samotný 
regulátor, viď nižšie. Keďže hodnoty sa aktualizujú mimo funkcie v prerušení od časovača, všetky premenné sú globálne (deklarované mimo tela funkcie)
a tie, ktoré meníme v prerušení navyše ako typ volatile. Definícia funkcie patrí ešte '''pred''' funkciu main.

<tabs>

<tab name="P_regulator.c"><source lang="c++" style="background: LightYellow;">

int K_P = 1;		// P zlozka regulatora: 1,2,3 max. 10
					 
int e_reg = 0;          // e - regulacna odchylka
int w_zel = 0;          // w - zelana hodnota
int u_reg = 0;          // u - akcny zasah

/*    Jednoduchy   P-regulator                          *
 *                                                      *
 *    Kedze pocitame vsetky veliciny v rozsahu 0-1023   *
 *    ale PWM je len 8-bitove, musime napokon vysledok  *
 *    prepocitat do rozsahu 0-255 a taktiez ak nam vy-  *
 *    sledok vyjde viac ako 255 alebo menej ako 0, tak  *
 *    ho musime obmedzit.                               *
 *                                                      */
void P_reg(void)                  
{                                // Regulator: vypocty
	e_reg = w_zel - y_C;         // regulacna odchylka e = w - y
	u_reg = K_P*e_reg;           // akcny zasah        u = K*e
	u_reg = u_reg>>2 ;            // 0-1023 do rozsahu  0-255
	
 	if (u_reg <   0 )  u_reg = 0;  // limiter
	if (u_reg > 255 )  u_reg = 255;

	OCR0B  = u_reg ;	         // a napokon 'u' posleme von
}


</source></tab>
<tab name="Arduino code"><source lang="arduino" style="background: #9dd1e1;">

/* Arduino code az niekedy inokedy */


</source></tab>

</tabs>


Hlavnú programovú slučku potom doplníme nasledovne:
* (11) v čase 1 s ( v programe 100, t.j. vtedy, keď vybijeme kondenzátor na 0V ) nastavíme hodnotu želanej veličiny na 800
* (14-18) v čase 3,5 s ( v programe 350, to musíme ešte doplniť)  nastavíme hodnotu želanej veličiny na 600
* (20) do slučky treba doplniť samotné volanie funkcie <code>P_reg();</code>, ktorý vypočíta regulačnú odchylku a zmení akčný zásah.
* (28) navyše by bolo dobré zmeniť vykreslované hodnoty, a namiesto veličín y_oo a y_63 si vypísať (a vykresliť) aktuálnu hodnotu želanej hodnoty w_zel a akčného zásahu u_reg.

<tabs>

<tab name="P_regulator.c"><source lang="c++" style="background: LightYellow;" highlight="11,14-20,28" line>
...
while(1)
  {
	
	    /* 3. pockame az do casu 1.0 s aby sme vybili kondenzator */  
		if (poc_time == 100 )      // 100 x 10ms = 1 sekunda
		{
        	clear_bit(DDRD,pinB);  // Pin odpojime, t.j. input, "odstranim skrat"
			OCR0B = 204;           // a na vystup poslem PWM, ktore zodpoveda 4V 
			
			w_zel = 800;
		}
					

		if (poc_time == 350 )      // 100 x 10ms = 1 sekunda
		{
			w_zel = 600;
		}
		
		P_reg();
		
		/* 4. a teraz od 0.0 az po 5.0 sec sledujeme napatie na C */
		
		if( (flag_T_v)&&(poc_time<500 ))
		{                                        // 400 * Tv = 5s; 6*T + T + 1s;  chyba  == cca 2-promile
			flag_T_v = 0;        
		                                         // Vypiseme: aktualny cas, napatie na kondenzatore a dve pomocne veliciny  
			printf("%u,%u,%u,%u\r\n",poc_time,y_C,u_reg,w_zel); 	// ako dekadicke hodnoty
		} 
		
		// po uplynuti 5 sekund uz nerobime nic
				       									
  }
</source></tab>
</tabs>

'''Úloha 2:'''

# Realizovať regulator pre K_P = 1, 2,3 a porovnať teoretickú a skutočnú trvalú regulačnú odchýlku.
# Akým skutočným napätiam zodpovedajú hodnoty 800 a 600? Overte meraním pomocou multimetra.
# Ak sa niekomu podarí doplniť aj I zložku regulátora môže pripojiť aj záťaž regulovaného systému. Viď. prednáška.


'''Poznámka:''' veľkosť trvalej regulačnej odchýlky v ustálenom stave pre uzavretý regulačný obvod so sústavou prvého rádu (K, T) a P-regulátor (K_P) sa dá vypočítať podľa vzťahu



<html>
<!-- math>e_\infty = 1 - \frac{K_P*K}{1+K_P*K}</math -->

<math display="block" class="tml-display" style="display:block math;">
  <mrow>
    <msub>
      <mi>e</mi>
      <mi>∞</mi>
    </msub>
    <mo>=</mo>
    <mn>1</mn>
    <mo>−</mo>
    <mfrac>
      <mrow>
        <msub>
          <mi>K</mi>
          <mi>P</mi>
        </msub>
        <mo>⋅</mo>
        <mi>K</mi>
      </mrow>
      <mrow>
        <mn>1</mn>
        <mo>+</mo>
        <msub>
          <mi>K</mi>
          <mi>P</mi>
        </msub>
        <mo>⋅</mo>
        <mi>K</mi>
      </mrow>
    </mfrac>
  </mrow>
</math>


</html>


Samozrejme, že podkladové programy nie sú napísané dokonale. Študenti môžu programy upravovať a vylepšovať. Napr.:  AntiWindUpReset, Ručné riadenie, Zmena w_zel pomocou potenciometra, …

== Literatúra ==

<references group="REF" />






[[Mikropočítačové systémy (MIPS)#Cvičenia|Návrat na zoznam cvičení...]]

[[Category: AVR]][[Category: MIPS]]