SensorWiki - Príspevky používateľa [sk]

Integrátor s mikroprocesorom

2026-06-23T21:16:26Z

StudentMIPS: /* Algoritmus a program */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Zdrojový kód: [[Médiá:Domchuk_Dmytro_MIPS_projekt.zip|zdrojak Domchuk.zip]]

=== Overenie ===

Overovali sme naš program tym že menili sme polohu potenciometra a pozerali ako sa zmeni graf na serial plot.

[[Súbor:Potenciometr0.jpg|400px|thumb|center|Poloha potenciometra 0.]]
[[Súbor:Graf0.jpg|400px|thumb|center|Graf pri polohe potenciometra 0.]]

[[Súbor:Potenciometr3.7.jpg|400px|thumb|center|Poloha potenciometra 3.7.]]
[[Súbor:Graf3.7.jpg|400px|thumb|center|Graf pri polohe potenciometra 3.7.]]

[[Súbor:Potenciometr4,2.jpg|400px|thumb|center|Poloha potenciometra 4.2.]]
[[Súbor:Graf4.2.jpg|400px|thumb|center|Graf pri polohe potenciometra 4.2.]]

[[Súbor:Potenciometr5.2.jpg|400px|thumb|center|Poloha potenciometra 5.2.]]
[[Súbor:Graf5.2.jpg|400px|thumb|center|Graf pri polohe potenciometra 5.2.]]

== Čo by som urobil inak ==

Nabuduce pre riešenie tohto problemu zrušil by som posun nuly pri sčitanií ADC. Takže zmenil by som Baud na dajme tomu 115200 pre rychlejší prenos signalu. Takže nabuduce spravil by som to z viac profesionalnym pristupom a vytvorenim samostatnych funkcí.
Nepodarilo sa mi odladiť program tak aby signal bol ustalený a ne kmital.

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

Súbor:Domchuk Dmytro MIPS projekt.zip

2026-06-23T21:15:08Z

StudentMIPS:

Integrátor s mikroprocesorom

2026-06-23T21:13:25Z

StudentMIPS: /* Čo by som urobil inak */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Overovali sme naš program tym že menili sme polohu potenciometra a pozerali ako sa zmeni graf na serial plot.

[[Súbor:Potenciometr0.jpg|400px|thumb|center|Poloha potenciometra 0.]]
[[Súbor:Graf0.jpg|400px|thumb|center|Graf pri polohe potenciometra 0.]]

[[Súbor:Potenciometr3.7.jpg|400px|thumb|center|Poloha potenciometra 3.7.]]
[[Súbor:Graf3.7.jpg|400px|thumb|center|Graf pri polohe potenciometra 3.7.]]

[[Súbor:Potenciometr4,2.jpg|400px|thumb|center|Poloha potenciometra 4.2.]]
[[Súbor:Graf4.2.jpg|400px|thumb|center|Graf pri polohe potenciometra 4.2.]]

[[Súbor:Potenciometr5.2.jpg|400px|thumb|center|Poloha potenciometra 5.2.]]
[[Súbor:Graf5.2.jpg|400px|thumb|center|Graf pri polohe potenciometra 5.2.]]

== Čo by som urobil inak ==

Nabuduce pre riešenie tohto problemu zrušil by som posun nuly pri sčitanií ADC. Takže zmenil by som Baud na dajme tomu 115200 pre rychlejší prenos signalu. Takže nabuduce spravil by som to z viac profesionalnym pristupom a vytvorenim samostatnych funkcí.
Nepodarilo sa mi odladiť program tak aby signal bol ustalený a ne kmital.

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

Integrátor s mikroprocesorom

2026-06-23T21:07:45Z

StudentMIPS: /* Overenie */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Overovali sme naš program tym že menili sme polohu potenciometra a pozerali ako sa zmeni graf na serial plot.

[[Súbor:Potenciometr0.jpg|400px|thumb|center|Poloha potenciometra 0.]]
[[Súbor:Graf0.jpg|400px|thumb|center|Graf pri polohe potenciometra 0.]]

[[Súbor:Potenciometr3.7.jpg|400px|thumb|center|Poloha potenciometra 3.7.]]
[[Súbor:Graf3.7.jpg|400px|thumb|center|Graf pri polohe potenciometra 3.7.]]

[[Súbor:Potenciometr4,2.jpg|400px|thumb|center|Poloha potenciometra 4.2.]]
[[Súbor:Graf4.2.jpg|400px|thumb|center|Graf pri polohe potenciometra 4.2.]]

[[Súbor:Potenciometr5.2.jpg|400px|thumb|center|Poloha potenciometra 5.2.]]
[[Súbor:Graf5.2.jpg|400px|thumb|center|Graf pri polohe potenciometra 5.2.]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T21:04:54Z

StudentMIPS: /* Overenie */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Overovali sme naš program tym že menili sme polohu potenciometra a pozerali ako sa zmeni graf na serial plot.

[[Súbor:Potenciometr0.jpg|400px|thumb|center|Poloha potenciometra 0.]]
[[Súbor:Graf0.jpg|400px|thumb|center|Graf pri polohe potenciometra 0.]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Súbor:Graf5.2.jpg

2026-06-23T21:00:45Z

StudentMIPS:

Súbor:Graf0.jpg

2026-06-23T21:00:25Z

StudentMIPS:

Súbor:Graf4.2.jpg

2026-06-23T21:00:10Z

StudentMIPS:

Súbor:Graf3.7.jpg

2026-06-23T20:59:50Z

StudentMIPS:

Súbor:Potenciometr5.2.jpg

2026-06-23T20:59:27Z

StudentMIPS:

Súbor:Potenciometr3.7.jpg

2026-06-23T20:59:01Z

StudentMIPS:

Súbor:Potenciometr0.jpg

2026-06-23T20:58:20Z

StudentMIPS: StudentMIPS nahral novú verziu Súbor:Potenciometr0.jpg

Súbor:Potenciometr4,2.jpg

2026-06-23T20:57:45Z

StudentMIPS:

Súbor:Potenciometr0.jpg

2026-06-23T20:56:02Z

StudentMIPS:

Integrátor s mikroprocesorom

2026-06-23T19:08:53Z

StudentMIPS: /* Overenie */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]
[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T19:08:26Z

StudentMIPS: /* Overenie */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|left|Aplikácia.]]
[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T19:08:01Z

StudentMIPS: /* Overenie */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|left|Aplikácia.]]
[[Súbor:GeminiAI-image1.jpg|400px|thumb|right|Aplikácia.]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T19:07:36Z

StudentMIPS: /* Overenie */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|left|Aplikácia.]]
[[Súbor:GeminiAI-image1.jpg|400px|thumb|right|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T19:05:47Z

StudentMIPS: /* Algoritmus a program */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.
Funkcia void UART_init() robo inicializaciu UART pre baud 14400 a posialanie 8 datovych bitov a 1 stop bit. Funkcia void UART_transmit_byte(uint8_t data) čaka pokial bufer sa vyprazdni a posiela 8 datovych bitov. Funkcia void UART_send_int16(int16_t value) 2 krat použiva predchadzajucu funkciu na posielani jedneho čisla typu int16. Inicializaciu ADC robi void ADC_init(). Funkcia uint16_t ADC_read() načitava hodnotu z ADC.Inicializujeme Timer1 v void Timer1_init(). Funkcia ISR(TIMER1_COMPA_vect) je rutiniu prerušenia. Ne použil som funkcie uart.c a adc.c zo semestra lebo musel by som ich moc silno zmeniť, takže na jeden krat stači aj realizacia priamo v programe. Ale pri vetšiem počte podobnych programov alebo pre zabezpečenie fungovania na viacerych zariadeniach radšej spraviť zvlašť hlavnu slučku a funkcie.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T18:49:25Z

StudentMIPS: /* Algoritmus a program */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu v hlavnej slučke sa začina tym že robí inicializaciu UART, ADC a Timer1 apovoluje prerušenia pomocou sei(). Ďalej zapisuje parametre integratora. Potom program zčita hodnotu z ADC a spravi posun nuly. Ďalej sa vytvori pasmo necitlivosti na +-3 jednotky z hodnoty ADC. Potom program vypočita integral Eulerovou metodou a spravi anti-windup aby hodnota integrala ne prekročila hranice 10000 a -10000. Ďalej v programe vytvorime 2 premennych typu int16_t plot_input a plot_ integral ktore sa rovnaju hodnotam input a integral. Ďalej posielame hodnoty premennych cez seriovu linku v binarnom tvare.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddelic 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() {
// Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12);
// Nastavenie preddelica na 64
// Frekvencia casovaca = 16 MHz / 64 = 250 kHz
// Požadovaný cas = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpocet urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Nacítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void);

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T18:07:41Z

StudentMIPS: /* Algoritmus a program */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu využíva toto a toto, základné funkcie sú takéto a voláma ich tuto...
Výpis kódu je nižšie...

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddeli? 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() { // Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12); // Nastavenie preddelica na 64
// Frekvencia ?asova?a = 16 MHz / 64 = 250 kHz
// Požadovaný ?as = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpo?et urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Na?ítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
void UART_init();
void UART_transmit_byte(uint8_t data);
void UART_send_int16(int16_t value);
void ADC_init();
uint16_t ADC_read();
void Timer1_init();
ISR(TIMER1_COMPA_vect);
int main(void)

</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T17:51:47Z

StudentMIPS: /* Analýza a opis riešenia */

Záverečný projekt predmetu MIPS / LS2026 - '''Dmytro Domchuk'''

== Zadanie ==

Integrátor. Potenciometer zadá veľkosť vstupu integrátora. Vytvorí sa zdroj reálneho času, prírastku času, napr. 5ms. A s nastavenou integračnou časovou konštantou sa bude meniť v reálnom čase, výstup, ktorý sa bude zobrazovať na serialplot. Takže, sčitame hodnotu ADC vstupu z potenciometra a budeme ju integrovať každych 5ms. Ďalej, vysledky budeme posielať cez seriovu linku do programu SerialPlot.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Našou ulohou bolo vytvoriť integrator na zaklade vyvijivej dosky Acrob a petenciometroveho modula. Potenciometrový model sa saklada z potenciometra, prepinača režimu fungovania(linearný alebo parabolický), reset tlačidko a kontrolera. Zapojili sme modul potenciometra ku doske Acrob na port X4. A pripojili Acrob ku počitaču pomocou USB kabla. Na moldule potenciometra nastavujeme velkosť potenciometra, sčitavame hodnotu z ADC, vypočitame integral a posielame dve hodnoty na SerialPlot. Prva hodnota je velkosťou vstupu a druha je integrolom.

[[Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.

[[Súbor:schemazapojenia.png|400px|thumb|center|Schéma zapojenia.]]

=== Algoritmus a program ===

Algoritmus programu využíva toto a toto, základné funkcie sú takéto a voláma ich tuto...
Výpis kódu je nižšie...

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
// Globálne premenné
volatile uint8_t timer_flag = 0;// Príznak z prerušenia

// --- Inicializácia UART pre 14400 baud (pri 16 MHz) ---

void UART_init() {
uint16_t ubrr = 68;
UBRR0H = (uint8_t)(ubrr >> 8);
UBRR0L = (uint8_t)ubrr;
UCSR0A &= ~(1 << U2X0); // Dvojnásobná rýchlost off
UCSR0B = (1 << TXEN0); // Povolenie vysielaca
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
} // 8 dátových bitov, 1 stop bit . Odošle jeden znak

void UART_transmit_byte(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // caká na vyprázdnenie buffra
UDR0 = data;
}

void UART_send_int16(int16_t value){
UART_transmit_byte((uint8_t)(value & 0xFF));
UART_transmit_byte((uint8_t)((value>>8) & 0xFF));
}

// --- Inicializácia ADC ---
void ADC_init() { // Referencia AVCC (REFS0=1), výber kanála ADC0 (MUX = 0000)
ADMUX = (1 << REFS0)|(1<<MUX2); // Povolenie ADC (ADEN=1), preddeli? 128 (ADPS2..0 = 111) pre frekvenciu 125 kHz
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); }

// Nacítanie hodnoty z ADC0
uint16_t ADC_read() {
ADCSRA |= (1 << ADSC); // Spustenie prevodu
while (ADCSRA & (1 << ADSC)); // cakanie na dokoncenie
return ADC;
}
// --- Inicializácia Timer1 pre 5ms prerušenie ---
void Timer1_init() { // Režim CTC (Clear Timer on Compare Match),
TCCR1B |= (1 << WGM12); // Nastavenie preddelica na 64
// Frekvencia ?asova?a = 16 MHz / 64 = 250 kHz
// Požadovaný ?as = 5 ms (0.005 s)
// Hodnota do OCR1A = (0.005 * 250000) - 1 = 1249

OCR1A = 1249;
// Povolenie prerušenia pri zhode (Compare Match A)
TIMSK1 |= (1 << OCIE1A);
// Spustenie casovaca s preddelicom 64 (CS11=1, CS10=1)
TCCR1B |= (1 << CS11) | (1 << CS10); }

// Rutina obsluhy prerušenia od Timer1 (vykoná sa každých 5 ms)
ISR(TIMER1_COMPA_vect) {
timer_flag = 1; // Len nastavíme vlajku, výpo?et urobíme v main slu?ke
}
int main(void) {
UART_init();
ADC_init();
Timer1_init();
sei(); // Globálne povolenie prerušení

// Parametre integrátora
const float Ts = 0.005; // 5 ms
const float Ti = 1.0;
float integral = 0.0;
float input =0;

while (1) {
if (timer_flag) {
timer_flag = 0; // Zhodenie vlajky

// 1. Na?ítanie vstupu a posunutie nuly
uint16_t raw_adc = ADC_read();
input = (float)(raw_adc - 512);
// Softvérové pásmo necitlivosti (Deadband)
// Ignoruje jemný šum (napr. +- 3 hodnoty z ADC okolo stredu), aby integrátor nedriftoval
if (input > -3.0 && input < 3.0) {
input = 0.0;
}
// 2. Výpocet (Eulerova dopredná metóda)
integral = integral + (Ts / Ti) * input;
// Anti-windup
if (integral > 10000.0) integral = 10000.0;
if (integral < -10000.0) integral = -10000.0;

int16_t plot_input=(int16_t)input;
int16_t plot_integral=(int16_t)integral;

// 4. Odoslanie vo formáte pre Serial Plotter: "Hodnota1,Hodnota2\n"

UART_send_int16(plot_input);
UART_send_int16(plot_integral);
UART_transmit_byte('\r');
UART_transmit_byte('\n');
}
}
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

void adc_init(void); // A/D converter initialization

unsigned int adc_read(char a_pin);
</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Integrátor s mikroprocesorom

2026-06-23T16:39:34Z

StudentMIPS: /* Analýza a opis riešenia */

Súbor:Schemazapojenia.png

2026-06-23T16:38:47Z

StudentMIPS:

Integrátor s mikroprocesorom

2026-06-23T16:31:43Z

StudentMIPS: /* Analýza a opis riešenia */

Integrátor s mikroprocesorom

2026-06-23T16:30:53Z

StudentMIPS: /* Analýza a opis riešenia */

Súbor:08d34a4c-397f-4d53-b44a-7e9815cb343b.jpg

2026-06-23T16:30:02Z

StudentMIPS:

Úsporné režimy procesora

2026-06-23T15:39:43Z

StudentMIPS:

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

* Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

* Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

* '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

* '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

sleep.h ma funkcia na vypnutie BOD (Brown-out Detector) - sleep_bod_disable(). Najlepšie vyvolať pred povolnim prerušenia.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Chýba praktická ukážka.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T15:31:25Z

StudentMIPS:

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

sleep.h ma funkcia na vypnutie BOD (Brown-out Detector) - sleep_bod_disable(). Najlepšie vyvolať pred povolnim prerušenia.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Chýba praktická ukážka.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T15:30:54Z

StudentMIPS:

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

sleep.h ma funkcia na vypnutie BOD (Brown-out Detector) - sleep_bod_disable(). Najlepšie vyvolať pred povolnim prerušenia.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Chýba praktická ukážka.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Súbor:Usporne rezimy Gordii Chornyi.7z

2026-06-23T15:23:33Z

StudentMIPS: StudentMIPS nahral novú verziu Súbor:Usporne rezimy Gordii Chornyi.7z

Integrátor s mikroprocesorom

2026-06-23T15:23:22Z

StudentMIPS: /* Analýza a opis riešenia */

Úsporné režimy procesora

2026-06-23T15:20:09Z

StudentMIPS: /* Zapojenie, algoritmus, program */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

sleep.h ma funkcia na vypnutie BOD (Brown-out Detector) - sleep_bod_disable(). Najlepšie vyvolať pred povolnim prerušenia.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Chýba praktická ukážka.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T15:16:10Z

StudentMIPS:

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Chýba praktická ukážka.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T15:14:46Z

StudentMIPS: /* Čo by som urobil inak */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Chýba praktická ukážka.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T15:14:39Z

StudentMIPS: /* Čo by som urobil inak */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Chýba praktická ukážka.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T15:11:07Z

StudentMIPS: /* Zapojenie, algoritmus, program */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|300px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T15:10:47Z

StudentMIPS:

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

[[Obrázok:Schema_zpojenia_usporne_rezimy.png|600px|thumb|center|Jednoduché zapojenie na zobudenie externou zmenou stavu pinu s použitim tlačidla.]]

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Súbor:Schema zpojenia usporne rezimy.png

2026-06-23T15:07:53Z

StudentMIPS:

Vstupná jednotka s palcovým prepínačom TS211

2026-06-23T15:04:35Z

StudentMIPS: /* Algoritmus a program */

Záverečný projekt predmetu MIPS / LS2026 - '''Sofiia Nevzorova'''

== Zadanie ==

Navrhnite a realizujte vstupnú jednotku na báze dvojsekčného palcového prepínača TS211 s BCD kódovaním pripojenú k vývojovej doske ACROB. Programovo zabezpečte čítanie hodnôt z oboch sekcií prepínača (desiatky a jednotky) v negatívnej logike s využitím interných pull-up rezistorov mikrokontroléra ATmega328P. Implementujte algoritmus na prevod BCD kódov z portov PORTC a PORTD na výsledné dekadické číslo v rozsahu 00 až 99. Zabezpečte výpis aktuálnej hodnoty cez rozhranie UART do konzoly pri každej zmene nastavenia(na overenie).

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Základným komponentom tohto riešenia je dvojsekčný palcový prepínač TS211. Každá sekcia prepínača funguje ako mechanický dekodér, ktorý prevádza nastavenú číslicu (0–9) na 4-bitový signál v kóde BCD (Binary Coded Decimal). Prepínač má pre každú sekciu 5 výstupov: jeden spoločný kontakt (Common) a štyri dátové kontakty s váhami 1, 2, 4 a 8.

[[Súbor:TS211_Nevzorova_realizacia.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Princíp činnosti a softvérové spracovanie:
Vstupy mikrokontroléra sú nakonfigurované v režime s aktivovanými internými pull-up rezistormi. To znamená, že piny pracujú v negatívnej logike:
Ak je kontakt v prepínači otvorený, pull-up rezistor drží na pine logickú 1.
Ak je kontakt zopnutý (číslica je zvolená), pin sa prepojí so zemou (GND) a procesor načíta logickú 0.
V programe sa preto načítané hodnoty z registrov PINC a PIND najskôr bitovo invertujú (~).
Pre desiatky (PORTC) sa priamo maskujú spodné 4 bity.
Pre jednotky (PORTD) sa využíva bitový posun doprava o 2 miesta (>> 2), aby sa bity z pozícií D2–D5 dostali na pozície 0–3 pre správny výpočet váhy BCD kódu.

Výsledné číslo sa vypočíta podľa vzťahu: Hodnota = (Desiatky * 10) + Jednotky, a následne sa posiela cez rozhranie UART do konzoly PuTTY.

[[Súbor:schemaMips.png|400px|thumb|center|Schéma zapojenia.]]

Hardvérové zapojenie:
Prepojenie s mikrokontrolérom ATmega328P na doske ACROB bolo realizované nasledovne:
Ľavý blok (Desiatky): Výstupy s váhami 1, 2, 4, 8 sú pripojené na piny A0, A1, A2 a A3 (čo zodpovedá portu PORTC, bity 0–3).
Pravý blok (Jednotky): Výstupy sú pripojené na digitálne piny D2, D3, D4 a D5 (port PORTD, bity 2–5).
Spoločné kontakty (C): Obe sekcie majú spoločný kontakt pripojený na GND (zem).
Z hľadiska mechanickej konštrukcie bolo kvôli nedostatočnej dĺžke kontaktov prepínača pre montáž priamo do breadboardu zvolené pripojenie pomocou flexibilných vodičov, čím sa zabezpečil spoľahlivý elektrický kontakt.

=== Algoritmus a program ===

V programe sme využili 8-bitovú premennú <code>uint8_t</code> na uloženie stavu jednotlivých sekcií prepínača. Hodnota z portov sa po inverzii maskuje pomocou <code>0x0F</code>, čím získame čistý BCD kód (0–9).

V úvode funkcie <code>main</code> prebieha inicializácia smerových registrov
<code>DDR</code> a nastavenie vstupov:

<code>DDRC &= ~0x0F; PORTC |= 0x0F;</code>

<code>DDRD &= ~0x3C; PORTD |= 0x3C;</code>

Týmto krokom aktivujeme vnútorné pull-up rezistory ešte pred vstupom do hlavného cyklu <code>while(1)</code>, čo zabezpečuje stabilné čítanie hodnôt z prepínača hneď po štarte mikrokontroléra.

Výsledná hodnota sa vypočíta podľa vzťahu:

<code>total = (tens * 10) + units;</code>

Pre výpočet desiatkovej hodnoty z portu D sme použili bitový posun o 2 miesta doprava, pretože fyzické pripojenie prepínača na piny D2 až D5 posúva dáta v registri <code>PIND</code>.

Vzťah pre prepočet je:

<code>tens = (~PIND >> 2) & 0x0F;</code>

Táto úprava je nevyhnutná, aby sa logické úrovne zarovnali do intervalu 0 až 9, ktorý zodpovedá číslam na prepínači. Všetky výpočty sú vykonávané v celočíselnej aritmetike, čo je pre daný rozsah 0–99 úplne postačujúce.

Na riadenie výpisu do konzoly bola použitá pomocná premenná <code>last_val</code>:

<code>if (total != last_val) {</code>

<code> printf("Value: %02u\n", total);</code>

<code> last_val = total;</code>

<code>}</code>

Táto podmienka zabezpečuje, že mikrokontrolér odosiela dáta cez UART len v momente, keď dôjde k fyzickej zmene nastavenia na prepínači. Týmto sa minimalizuje zaťaženie sériovej linky a terminál PuTTY zostáva prehľadný.
Pri implementácii boli využité štandardné typy

<code>uint8_t</code> pre dáta z portov a

<code>uint16_t</code> pre výslednú hodnotu, čo je z hľadiska pamäťových nárokov na procesor ATmega328P optimálne.

V hlavnom cykle programu je zaradené krátke oneskorenie <code>_delay_ms(150);</code>. Táto pauza slúži na stabilizáciu hodnôt pri mechanickom prepínaní kontaktov a zabraňuje náhodným chybám v načítaných dátach počas pohybu prepínača.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include "uart.h"

FILE mystdout = FDEV_SETUP_STREAM(uart_putc, NULL, _FDEV_SETUP_WRITE);

uint8_t read_bcd_tens(void) {
uint8_t status = ~PINC;
return (status & 0x0F);
}

uint8_t read_bcd_units(void) {
uint8_t status = ~PIND;
return ((status >> 2) & 0x0F);
}

int main(void)
{
uart_init();
stdout = &mystdout;

DDRC &= ~0x0F; PORTC |= 0x0F;
DDRD &= ~0x3C; PORTD |= 0x3C;

uint8_t last_val = 255;

while(1)
{
uint8_t tens = read_bcd_tens();
uint8_t units = read_bcd_units();

uint16_t total = (tens * 10) + units;

if (total != last_val) {
printf("Value: %02u\n", total);
last_val = total;
}

_delay_ms(150);
}
return 0;
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

void adc_init(void); // A/D converter initialization

unsigned int adc_read(char a_pin);
</syntaxhighlight ></tab>
</tabs>

Zdrojový kód: [[Médiá:projekt_Nevzorova.zip|projekt_Nevzorova]]

=== Overenie ===

Správna funkcia projektu bola overená sledovaním sériového výstupu v termináli PuTTY. Pri každej mechanickej zmene polohy palcového prepínača sa v konzole okamžite zobrazila zodpovedajúca dvojciferná hodnota. Testovaním všetkých polôh oboch sekcií (0–9) sa potvrdilo, že program správne interpretuje BCD kód a bezchybne vypočítava výsledné dekadické číslo v rozsahu 00 až 99.

'''Video:'''
<center><youtube>e5XRd5vfh3U</youtube></center>

== Čo by som urobil inak ==

V budúcej verzii by som namiesto neustáleho dopytovania sa na stav portov v cykle (polling) skúsila implementovať čítanie pomocou externých prerušení (interrupts), čo by zvýšilo efektivitu programu. Taktiež by som pridala ďalšiu sekciu prepínača pre zadávanie trojciferných čísel a navrhla kompaktný plošný spoj, aby som nahradila veľké množstvo prepojovacích káblov stabilnejším riešením.

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

Integrátor s mikroprocesorom

2026-06-23T14:45:50Z

StudentMIPS: /* Analýza a opis riešenia */

Vstupná jednotka s palcovým prepínačom TS211

2026-06-23T14:44:11Z

StudentMIPS: /* Overenie */

Záverečný projekt predmetu MIPS / LS2026 - '''Sofiia Nevzorova'''

== Zadanie ==

Navrhnite a realizujte vstupnú jednotku na báze dvojsekčného palcového prepínača TS211 s BCD kódovaním pripojenú k vývojovej doske ACROB. Programovo zabezpečte čítanie hodnôt z oboch sekcií prepínača (desiatky a jednotky) v negatívnej logike s využitím interných pull-up rezistorov mikrokontroléra ATmega328P. Implementujte algoritmus na prevod BCD kódov z portov PORTC a PORTD na výsledné dekadické číslo v rozsahu 00 až 99. Zabezpečte výpis aktuálnej hodnoty cez rozhranie UART do konzoly pri každej zmene nastavenia(na overenie).

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:'''
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]

__TOC__

== Analýza a opis riešenia ==

Základným komponentom tohto riešenia je dvojsekčný palcový prepínač TS211. Každá sekcia prepínača funguje ako mechanický dekodér, ktorý prevádza nastavenú číslicu (0–9) na 4-bitový signál v kóde BCD (Binary Coded Decimal). Prepínač má pre každú sekciu 5 výstupov: jeden spoločný kontakt (Common) a štyri dátové kontakty s váhami 1, 2, 4 a 8.

[[Súbor:TS211_Nevzorova_realizacia.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]

Princíp činnosti a softvérové spracovanie:
Vstupy mikrokontroléra sú nakonfigurované v režime s aktivovanými internými pull-up rezistormi. To znamená, že piny pracujú v negatívnej logike:
Ak je kontakt v prepínači otvorený, pull-up rezistor drží na pine logickú 1.
Ak je kontakt zopnutý (číslica je zvolená), pin sa prepojí so zemou (GND) a procesor načíta logickú 0.
V programe sa preto načítané hodnoty z registrov PINC a PIND najskôr bitovo invertujú (~).
Pre desiatky (PORTC) sa priamo maskujú spodné 4 bity.
Pre jednotky (PORTD) sa využíva bitový posun doprava o 2 miesta (>> 2), aby sa bity z pozícií D2–D5 dostali na pozície 0–3 pre správny výpočet váhy BCD kódu.

Výsledné číslo sa vypočíta podľa vzťahu: Hodnota = (Desiatky * 10) + Jednotky, a následne sa posiela cez rozhranie UART do konzoly PuTTY.

[[Súbor:schemaMips.png|400px|thumb|center|Schéma zapojenia.]]

Hardvérové zapojenie:
Prepojenie s mikrokontrolérom ATmega328P na doske ACROB bolo realizované nasledovne:
Ľavý blok (Desiatky): Výstupy s váhami 1, 2, 4, 8 sú pripojené na piny A0, A1, A2 a A3 (čo zodpovedá portu PORTC, bity 0–3).
Pravý blok (Jednotky): Výstupy sú pripojené na digitálne piny D2, D3, D4 a D5 (port PORTD, bity 2–5).
Spoločné kontakty (C): Obe sekcie majú spoločný kontakt pripojený na GND (zem).
Z hľadiska mechanickej konštrukcie bolo kvôli nedostatočnej dĺžke kontaktov prepínača pre montáž priamo do breadboardu zvolené pripojenie pomocou flexibilných vodičov, čím sa zabezpečil spoľahlivý elektrický kontakt.

=== Algoritmus a program ===

V programe sme využili 8-bitovú premennú <code>uint8_t</code> na uloženie stavu jednotlivých sekcií prepínača. Hodnota z portov sa po inverzii maskuje pomocou <code>0x0F</code>, čím získame čistý BCD kód (0–9).

V úvode funkcie <code>main</code> prebieha inicializácia smerových registrov
<code>DDR</code> a nastavenie vstupov:

<code>DDRC &= ~0x0F; PORTC |= 0x0F;</code>

<code>DDRD &= ~0x3C; PORTD |= 0x3C;</code>

Týmto krokom aktivujeme vnútorné pull-up rezistory ešte pred vstupom do hlavného cyklu <code>while(1)</code>, čo zabezpečuje stabilné čítanie hodnôt z prepínača hneď po štarte mikrokontroléra.

Výsledná hodnota sa vypočíta podľa vzťahu:

<code>total = (tens * 10) + units;</code>

Pre výpočet desiatkovej hodnoty z portu D sme použili bitový posun o 2 miesta doprava, pretože fyzické pripojenie prepínača na piny D2 až D5 posúva dáta v registri <code>PIND</code>.

Vzťah pre prepočet je:

<code>tens = (~PIND >> 2) & 0x0F;</code>

Táto úprava je nevyhnutná, aby sa logické úrovne zarovnali do intervalu 0 až 9, ktorý zodpovedá číslam na prepínači. Všetky výpočty sú vykonávané v celočíselnej aritmetike, čo je pre daný rozsah 0–99 úplne postačujúce.

Na riadenie výpisu do konzoly bola použitá pomocná premenná <code>last_val</code>:

<code>if (total != last_val) {</code>

<code> printf("Value: %02u\n", total);</code>

<code> last_val = total;</code>

<code>}</code>

Táto podmienka zabezpečuje, že mikrokontrolér odosiela dáta cez UART len v momente, keď dôjde k fyzickej zmene nastavenia na prepínači. Týmto sa minimalizuje zaťaženie sériovej linky a terminál PuTTY zostáva prehľadný.
Pri implementácii boli využité štandardné typy

<code>uint8_t</code>pre dáta z portov a

<code>uint16_t</code> pre výslednú hodnotu, čo je z hľadiska pamäťových nárokov na procesor ATmega328P optimálne.

V hlavnom cykle programu je zaradené krátke oneskorenie <code>_delay_ms(150);</code>. Táto pauza slúži na stabilizáciu hodnôt pri mechanickom prepínaní kontaktov a zabraňuje náhodným chybám v načítaných dátach počas pohybu prepínača.

<tabs>
<tab name="AVR C-code"><syntaxhighlight lang="c++" style="background: LightYellow;">
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include "uart.h"

FILE mystdout = FDEV_SETUP_STREAM(uart_putc, NULL, _FDEV_SETUP_WRITE);

uint8_t read_bcd_tens(void) {
uint8_t status = ~PINC;
return (status & 0x0F);
}

uint8_t read_bcd_units(void) {
uint8_t status = ~PIND;
return ((status >> 2) & 0x0F);
}

int main(void)
{
uart_init();
stdout = &mystdout;

DDRC &= ~0x0F; PORTC |= 0x0F;
DDRD &= ~0x3C; PORTD |= 0x3C;

uint8_t last_val = 255;

while(1)
{
uint8_t tens = read_bcd_tens();
uint8_t units = read_bcd_units();

uint16_t total = (tens * 10) + units;

if (total != last_val) {
printf("Value: %02u\n", total);
last_val = total;
}

_delay_ms(150);
}
return 0;
}

</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

void adc_init(void); // A/D converter initialization

unsigned int adc_read(char a_pin);
</syntaxhighlight ></tab>
</tabs>

Zdrojový kód: [[Médiá:projekt_Nevzorova.zip|projekt_Nevzorova]]

=== Overenie ===

Správna funkcia projektu bola overená sledovaním sériového výstupu v termináli PuTTY. Pri každej mechanickej zmene polohy palcového prepínača sa v konzole okamžite zobrazila zodpovedajúca dvojciferná hodnota. Testovaním všetkých polôh oboch sekcií (0–9) sa potvrdilo, že program správne interpretuje BCD kód a bezchybne vypočítava výsledné dekadické číslo v rozsahu 00 až 99.

'''Video:'''
<center><youtube>e5XRd5vfh3U</youtube></center>

== Čo by som urobil inak ==

V budúcej verzii by som namiesto neustáleho dopytovania sa na stav portov v cykle (polling) skúsila implementovať čítanie pomocou externých prerušení (interrupts), čo by zvýšilo efektivitu programu. Taktiež by som pridala ďalšiu sekciu prepínača pre zadávanie trojciferných čísel a navrhla kompaktný plošný spoj, aby som nahradila veľké množstvo prepojovacích káblov stabilnejším riešením.

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

Integrátor s mikroprocesorom

2026-06-23T14:32:10Z

StudentMIPS: /* Zadanie */

Úsporné režimy procesora

2026-06-23T14:29:01Z

StudentMIPS:

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T14:28:07Z

StudentMIPS: /* Zapojenie, algoritmus, program */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T14:27:44Z

StudentMIPS: /* Zapojenie, algoritmus, program */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:Usporne_rezimy_Gordii_Chornyi.7z|Usporne_rezimy_Gordii_Chornyi.7z]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Súbor:Usporne rezimy Gordii Chornyi.7z

2026-06-23T14:27:03Z

StudentMIPS:

Úsporné režimy procesora

2026-06-23T14:24:34Z

StudentMIPS: /* Zapojenie, algoritmus, program */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T14:24:19Z

StudentMIPS: /* Zapojenie, algoritmus, program */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tabs>
<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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

Úsporné režimy procesora

2026-06-23T14:23:45Z

StudentMIPS: /* Zapojenie, algoritmus, program */

Záverečný projekt predmetu MIPS / LS2026 - '''Gordii Chornyi'''

== Zadanie ==

Cieľom tohto projektu je oboznámenie s zabudovanymí úspornymí režimami procesora.

Hardware v tomto projekte je doska ACROB s mikrokontroler ATmega328P.

[[Obrázok:ard.jpg|600px|thumb|center|Vývojová doska ACROB s ATmega328P.]]

'''Literatúra:'''
* [https://www.engineersgarage.com/reducing-arduino-power-consumption-sleep-modes How to optimize Arduino for low power design]
* [https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management Sleep Modes and Power Management]
* [https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf Dokumentacia k ATmega328P ]
* [https://developerhelp.microchip.com/xwiki/bin/view/products/mcu-mpu/8-bit-avr/structure/sleep/ AVR® Low Power Sleep Modes]
* [https://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html <avr/sleep.h>: Power Management and Sleep Modes]

__TOC__

== Analýza a opis riešenia ==

Arduino doska može byť použitá v strojoch, ktoré s spoliehaju na externý zdroj energie a hlavné na uchovanú energiu v akumulatori. Prístup ku externému zdroju môže byť nepravidelný a nie je tak efektívny, ako by sme chceli.

V takejto situácii chceme, aby komponenty stroja využívalí čo najmenej energie a zaroveň zachovávali požadovanú efektivnosť a potrebné schopnosti.

V tomto momente, pravdepodobne, nastane problem: Chceme zobrať malu dosku s malou spotrebou energie, ale pre správnu prácu stroja musime zobrať väčšiu dosku, s väčšou spotrebou, s požadovaným výkonom a funkciami.

Ako jeden zo spôsobov vyriešiť problem veľkej spotreby energie je použiť jeden z úsporných režimov.

'''Nam sú dostupné 6 úsporných režimov:'''
:- Idle
:- ADC noise Reduction
:- Power-down
:- Power-save
:- Standby
:- Extended standby

[[Súbor:Sleep_Modes_and_Wake_up_Sources.png|700px|thumb|center|Tabuľka Úsporných režimov a spôsob zobudenia.]]

==== Idle ====
Vypína iba procesor, a necháva dosť veľa možnosti zobudenia z vonku aj z vnutra.

Môže byť zobudený: Pretečením časovača , USART prenosom , prerušením prostrednictvom Analógového komparatora, ADC prevodnika, Timer/Counters, Watchdog , zmenou na pinoch.

==== ADC noise Reduction ====
Veľmi podobný ako '''Idle''' s rozdielom v tom, že vypína aj ''SPI'' a ''USART''. Toto umožňuje zväčšiť kvalitu merania ADC prevodnika.

==== Power-down ====
Vypína skoro všetko. Zobudenie je možne iba cez ''(TWI) 2-wire serial interface'', ''Watchdog'', ''prerušenie na pinoch INT0'' a ''INT1 z vonka'', ''prerušenie z ostatných pinov''.

Má možnosť vypnúť BOD - Brown-out Detector

==== Power-save ====
Od '''Power-down''' sa líši možnosťou zapnúť ''Timer/Counter2'' v synchronnom alebo asynchronnom režime. Ak ''Timer/Counter2'' nepotrebujem, tak lepšie zapnúť '''Power-down''' režim.

==== Standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-DOWN''' s jednou vynimkou - oscilator pokračuje pracovať.

==== Extended standby ====
Mal by sa používať s vonkajším krýštalom alebo rezonatorom v role časovača. Je identický ku '''Power-SAVE''' s jednou vynimkou - oscilator pokračuje pracovať.

----
=== Zapojenie, algoritmus, program ===

Ku doske je pripojene jedno tlačitko s rezistorm na pine PD4 ( INT0 ). Bude využité na externe prerušenie.

Knižnica avr/interrupt.h je opcionálna. Potrebujem iba na krásne blikanie LEDky.

V '''main''' nastavime zabudovanú LED ako výstup a Tlačitko na PD4 ako vstup s pull-up.

Následne mame vybrať úsporný režim, ktorý chceme využiť.

Môžeme to spraviť dvoma spôsbmi:

# Ručne nastavime register '''SMCR'''
:: Ma 4 piny - ''SM2'', ''SM1'' a ''SM0'' určuje úsporný režim. SE, ktorý povoluje spustenie uspania. Bit SE je najlepšie aktivovať tesne pred spustenim uspania, aby nenastalo skôr než potrebujeme.

# Využijeme funkciu set_sleep_mode() z knižnice sleep.h ''[ Nastavuje SMCR za nas ]''
:: Do zatvoriek doplnime SLEEP_MODE_'''''"nazov_režimu"'''''. Povolenie uspania dávame neskôr, inými funkciami.

V loope najprv vypneme prerušenie. Zapneme vtedy, kedy potrebujeme.

Zablika LEDka - signál, že procesor nespi.

Na uspanie použieme funkcie z sleep.h

# '''sleep_mode()'''
:: Tesné pred sleep_mode() treba povoliť prerušenie [ funkcia sei() ].
:: Funkcia nastavuje SE bit na log. 1 a tymto povoluje uspanie. Spušťa uspanie. Po zobudeni nastavuje SE bit na log. 0.

# '''sleep_enable() , sleep_cpu() , sleep_disable'''
:: Funkciu na povovlenie prerušenia sei() volame medzi sleep_enable() a sleep_cpu().
:: ''sleep_enable()'' - nastavuje SE bit na log. 1.
:: ''sleep_cpu()'' - uspava procesor.
:: ''sleep_disable()'' - nastavuje SE bit na log. 0.

Stlačenie zapojeneho tlačitka zmeni stav na pine PD4, čo bude signalom na zobudenie.

<tabs>
<tab name="Usporne_rezimy_Gordii_Chornyi.c"><syntaxhighlight lang="c++" style="background: LightYellow;">

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Delay funkcia pre požadované medzery
void delay(int delay)
{
for (int i=1; i<=delay; i++)
_delay_ms(1);
}

#define LED PB5 // Zabudovaná LED dioda
#define SW1 PD4 // Tlacitko ako zdroj externého prerušenia

int main(void)
{
DDRB |= ( 1 << LED );
DDRD &= ~( 1 << SW1 );
PORTD |= ( 1 << SW1 );

// SMCR - Sleep Mode Control Regiter
// Ma 4 bity: SM2 , SM1 , SM0 , SE
// SM2..0 zodpovedaju za výber úsporného režimu.
// SE (Sleep Enable) umoznuje uspanie pri vyvolaní SLEEP inštrukcie.

/*
SMCR |= ( 0 << SM2 ) | ( 1 << SM1 ) | ( 0 << SM0 ); // 0 1 0 = Power-down.
SMCR |= ( 1 << SM1 ); // To iste ako o riadok vyššie. Power-down
SMCR |= ( 1 << SE ); // Umožnime uspanie. Radšej aktivovat tesne pred vyvolaním SLEEP inštrukcie, aby omylom neuspat skôr než treba
*/

// set_sleep_mode umož?uje vybra? úsporný režim

set_sleep_mode(SLEEP_MODE_IDLE); // IDLE
//set_sleep_mode(SLEEP_MODE_ADC); // ADC noise Reduction
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power-down
//set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Power-save
//set_sleep_mode(SLEEP_MODE_STANDBY); // Standby
//set_sleep_mode(SLEEP_MODE_EXT_STANDBY); // Extended standbys

while(1)
{
cli(); // Zatial vypnime prerušenie. Potrebujeme ho aktívnym pred uspanim

PORTB |= ( 1 << LED ); // Zapni LED a cakaj 2 sekudny
delay(2000);
PORTB &= ~ ( 1 << LED ); // Vypni LED a cakaj pol sekundy
delay(500);

PORTB |= ( 1 << LED ); // Ešte ráz zapnut a vypnut LED na kratšiu dobu
delay(500);
PORTB &= ~( 1 << LED );

// sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme
sei(); // Umožnit prerušenie
sleep_mode(); // Aktivovat úspanie.

// ako alternativa môžeme postupovat podla jednotlivých krokoch
/*
sleep_enable(); // Nastavi sa SE (Sleep Enable) bit

sleep_bod_disable(); // Deaktivujeme Brown-out Detector ak ho nepotrebujeme

sei(); // Umožnit prerušenie
sleep_cpu(); // Uspi procesor
sleep_disable(); // PO zobudení vycisti SE bit
*/
}
}

</syntaxhighlight ></tab>

<tab name="filename.h"><syntaxhighlight lang="c++" style="background: LightYellow;">
#include <avr/io.h>

void adc_init(void); // A/D converter initialization

unsigned int adc_read(char a_pin);
</syntaxhighlight ></tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]

=== Overenie ===

Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.

[[Súbor:GeminiAI-image1.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>

== Čo by som urobil inak ==

Zamyslite sa spätne nad problémom, ktorý ste riešili a napíšte, čo sa vám nepodarilo a nabudúce by ste spravili inak.

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

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