Vstupy a výstupy AVR

Digitálne výstupy (LED)

Teraz už vieme celkom dobre ovládať výstupy, takže by sme mohli skúsiť ten obligátny príkaz na blikanie LED diódou, potrebujeme už len nejaké oneskorenie. Vedeli by sme to robiť pomocou funkcie napísanej v assembleri, ako sme to robili na prvom cvičení. Trocha (ale len trocha) si to zjednodušíme a využijeme už zadefinovanú funkciu _delay_ms()

Využívanie funkcie _delay_ms()

AVR CArduino

#define F_CPU 16000000UL  // toto je lepsie vlozit do parametrov pre kompilator

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

#define set_bit(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
#define clear_bit(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))

#define LED1  PB5          // zabudovana dioda 

void delay(int delay)      // vlastna funkcia pre dlhsie casy 
{
  for (int i=1; i<=delay; i++)
  _delay_ms(1);
}	

int main(void)
{
   set_bit(DDRB,LED1);       // set pin LED1 as output
   
   while(1)
   {
	 delay(250);             // 250 ms delay
     set_bit(PORTB,LED1);    // LED1 = log.1
     delay(250);             // 250 ms delay
     clear_bit(PORTB,LED1);  // LED1 = log.0
   }
	
   return(0);                // sem nikdy neprideme
}

void setup() 
{
  pinMode(LED_BUILTIN, OUTPUT);       // initialize digital pin LED_BUILTIN as an output.
}

void loop() 
{
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(250);                        // wait for a quarter second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(250);                        // wait for a quarter second
}

Prečo je tento program napísaný práve takto, s pomocnou funkciou delay a prečo nepoužijeme rovno _delay_ms() sa dočítate v podrobnejšom texte Oneskorenia_s_AVR.

Digitálne vstupy (Tlačidlá)

Rozličné typy tlačidiel vhodných pre mikropočítač.

Chceli by sme ďalej naprogramovať zapínanie a vypínanie jedným tlačítkom. Na predmete Základy počítačov sme tento problém riešili pomocou stavového diagramu.

Stavový diagram pre tlačítko.

K nemu zodpovedajúci program môže vyzerať napríklad nasledovne. Na ukladanie aktuálneho stavu {On, Off} sme použili špeciálny datový typ Enumerate, ktorý má práve dve hodnoty. Okrem toho si všimnite, že testujeme, či je vstup v log. 0 (tlačítko spína k zemi).

program03-1.c

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

#define set_bit(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
#define clear_bit(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))

#define LED1  PB5          // zabudovana dioda 
#define SW1   PD6          // tlacitko

enum states { On, Off };

int main(void)
{
   enum states LedState = Off;
     
   set_bit(DDRB,LED1);       // set pin LED1 as output
   set_bit(PORTD,SW1);       // pull-up resistor ON
   
   while(1)
   {
	 
	 if ( (LedState == Off) && bit_is_clear(PIND,SW1) )
	  { 
           LedState = On;
           set_bit(PORTB,LED1);    // LED1 = log.1
	  }	  	  
	 else if  ( (LedState == On) && bit_is_clear(PIND,SW1) )
	  { 
           LedState = Off;
	   clear_bit(PORTB,LED1);  // LED1 = log.0
	  }	  		  	 
   }
	
   return(0);                // sem nikdy neprideme
}

Ak si to skúsite, zistíte, že to ako tak funguje, ale viacmenej len náhodne. Je to spôsobené tým, že mirkopočítač je strašne rýchly, a kým držíme tlačítko stlačené, zmení stav aj niekoľkotisíc krát, takže výsledný stav je potom viacmenej náhodný. Aby to fungovalo správne, musíme rozlišovať až štyri rozličné stavy tlačítka: Vypnuté (Off), Práve stlačené (Down), Zapnuté (On) a Práve pustené (Up).

Stavový diagram tlačítka s rozpoznaním zmeny stavov.

Keď máme nakreslený stavový diagram, ľahko podľa neho preklopíme vyššieuvedený program.

program03-2.c

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

#define set_bit(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
#define clear_bit(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))

#define LED1  PB5          // zabudovana dioda 
#define SW1   PD6          // tlacitko

enum states { Off, Down, On, Up }; 

int main(void)
{
   enum states LedState = Off;
   enum states Tlacitko = Off;
       
   set_bit(DDRB,LED1);       // set pin LED1 as output
   set_bit(PORTD,SW1);       // pull-up resistor ON
   
   while(1)
   {
	  /* Oproti predoslemu programu sem pridame druhy    *
	   * stavovy automat len pre tlacitko s jeho styrmi  *
	   * stavmi Off, Down, On a Up                       */  
	   
	  if ( (Tlacitko == Off) &&  bit_is_clear(PIND,SW1)  )
	  {
		 Tlacitko = Down;	  
	  }
	  else if ( (Tlacitko == Down) &&  bit_is_clear(PIND,SW1)  )
	  {
  		 Tlacitko = On;
	  }
	  else if  ( (Tlacitko == On) &&  bit_is_set(PIND,SW1) ) 	  
	  {
		 Tlacitko = Up;
	  }
	  else if (  (Tlacitko == Up) &&  bit_is_set(PIND,SW1) )
	  {
		 Tlacitko = Off;
	  }
	  
	 
	 /* Toto je povodny stavovy automat pre LEDku        *
	  * upraveny tak, ze menime stav len ak je tlacitko  *
	  * v stave DOWN, cize ked zmenilo stav.             */
	  
	  if ( (LedState == Off) && (Tlacitko==Down) )
 	   {  
		 LedState = On;          
		 set_bit(PORTB,LED1);
	   }			  
	  else 
	  if ( (LedState == On ) && (Tlacitko==Down) )
	   {  
		 LedState = Off;          
		 clear_bit(PORTB,LED1);
	   }			  
	  
   }  /* end of while loop */
 	
   return(0);                // sem nikdy neprideme
}

Takto by to už malo fungovať, ale napriek tomu môžete občas pozorovať ako keby náhodné prepnutie stavu. Je to spôsobené javom, kedy sa z mechanických príčin nezmení stav na tlačítku okamžite a trvale, ale kontakt niekoľkokrát preskočí, vzniknú tzv. zákmity.

Zákmity zachytené osciloskopom.

Aby nám všetko naozaj správne fungovalo, musíme aj tieto zákmity ošetriť (angl. termín debouncing).

Ošetrenie zákmitov (debouncing)

a) Hardvérové

Jeden spôsob, ako sa vysporiadať so zákmitmi je pridať okolo tlačítka niekoľko ďalších súčiastok, ktoré zákmity eliminujú.

Niekoľko príkladov hardvérového odstránenia zákmitov.

b) Softvérové

Jednoduchší a lacnejší spôsob je ošetriť zákmity softvérovo, ale za cenu zdržania programu. Princíp je jednoduchý, ak zistíme, že sa stav tlačítka zmenil, počkáme nejaký čas na ustálenie a potom overíme, či je tento stav stabilný, alebo to bol len náhodný impulz. Realizácia je možná napríklad takto (uvádzame len jedno z miest, kde sa program zmenil o doplnkovú kontrolu stavu

program03-3.c

 /* Test s osetrenim zakmitov */

 if ( (Tlacitko == Off) &&  bit_is_clear(PIND,SW1)  )
	  {                                 // Ak je tlacitko stlacene, 
	     _delay_ms(10);                 // potom chvilu pockajme
		 if ( bit_is_clear(PIND,SW1) )  // a skontrolujme, ci naozaj je	
		 Tlacitko = Down;	            // a ak ano, tak zmenime stav.
	  }

Úlohy

Ak ste úspešne prišli až sem, pozrite si zadanie v Classroome a vyplňte formulár s otázkami. K zadaniu potom nahrajte aj zdrojový kód program03.c a fotografiu alebo video fungujúceho programu s so zapínaním a vypínaním aspoň jednej LED diódy na vašom procesore.

Literatúra

• Jack G. Ganssle: A Guide to Debouncing. The Ganssle Group, Rev 2: April, 2007.
• Elliot Williams: Embed With Elliot:Debounce Your Noisy Buttons, Part I. Hackaday, 2015.
• Elliot Williams: Embed With Elliot:Debounce Your Noisy Buttons, Part II. Hackaday, 2015.
• Mike Szczys: Debounce Code – One Post To Rule Them All. Hackaday, 2010.

+ Naviac:

• https://www.ladyada.net/learn/arduino/lesson5.html
• https://raw.githubusercontent.com/j-bellavance/Tutorials/master/State%20machines%20Tutorial/Part%201/State%20machine%20with%20Arduino%20Part%201.pdf
• https://www.avrfreaks.net/sites/default/files/forum_attachments/debounce.pdf

+ Stavové automaty

• https://hackaday.com/2018/04/06/state-your-intentions-more-clearly-with-state-machines/
• https://gist.github.com/NormalUniverse/f807ca9f267b861365c688193ddfdd68
• http://johnsantic.com/comp/state.html
• Simulacia krok za krokom https://graphit.web.app/app
• FSM v LaTeX https://hayesall.com/blog/latex-automata/
• https://ivanzuzak.info/noam/webapps/fsm_simulator/

Navigácia: 🡄 Predošlé cvičenie | 🡅 Zoznam cvičení | Nasledujúce cvičenie 🡆