// SIPO posuvný registr 74HC595 (Texas Instruments)/*Mapa vývodů:
 QB--+-- --+--VCC     |  U  | QC--+     +--QA     |     | QD--+     +--SER     |     | QE--+     +--!OE     |     | QF--+     +--RCLK     |     | QG--+     +--SRCLK     |     | QH--+     +--!SRCLR     |     |GND--+-----+--QH'
V "SER" nastavíme vstupní bit 0/1 (sériový vstup).Náběžnou hranou "SRCLK" dáme povel k posunu.Náběžnou hranou "RCLK" povel k zápisu.Na výstupy "QA" až "QH" (posun se fyzicky projeví)."!SRCLR" maže nastavením LOW paměť registru => tedy nuluje,proto jej držíme na HIGH, dokud jej nechceme smazat."!OE" nastaveno na LOW povoluje výstupy "QA až QH",na HIGH je zakazuje => pracujeme při hodnotě LOW."QH'" je kopií "QH" určenou pro přenos na vstup dalšíhoposuvného registru připojeného do kaskády.*/
uint8_t pidTlData = 2;      // tlačítko pro nastavení hodnoty 0/1 na vstupuuint8_t pidTlPosun = 3;     // SRCLK - tlačítko pro posunuint8_t podVypnuto = 13;    // !OAuint8_t podData = 4;        // SER (DATA IN)uint8_t podSmazat = 9;      // !SRCLRuint8_t podVystup  = 7;     // RCLK - paměťový hodinový signál (též LATCH)uint8_t podPosun = 8;       // SRCLK - hodinový signál pro posuv výstupů (též CLOCK)uint8_t sidTlData[2];       // stavy tlačítka pro nastavení hodnoty vstupuuint8_t sidTlPosun[2];      // stavy tlačítka pro posun [0] aktuální, [1] minulýuint8_t sodData;            // aktuální hodnota vstupního bituuint8_t posun;              // 0 čekání, 1 posunuint8_t sodSmazat = HIGH;   // nechceme mazatuint16_t cas, perioda = 60; // nejkratší trvání loop() 60 ms
// puls signálu na daném pinu, zaručena náběžná i sestupná hranavoid puls(uint8_t pin){   digitalWrite(pin,LOW);   digitalWrite(pin,HIGH);   digitalWrite(pin,LOW);}
void setup(){   // piny   pinMode(pidTlData, INPUT_PULLUP);   pinMode(pidTlPosun, INPUT_PULLUP);   pinMode(podVypnuto, OUTPUT);   pinMode(podData, OUTPUT);   pinMode(podPosun, OUTPUT);   pinMode(podVystup, OUTPUT);   pinMode(podSmazat, OUTPUT);   // příprava registru   digitalWrite(podVypnuto, LOW);   // zapneme   digitalWrite(podVystup, LOW);    // příprava pro výstup   digitalWrite(podData, LOW);      // vstup LOW   digitalWrite(podSmazat, HIGH);   // nemazat   // intro - běžící bit   digitalWrite(podData, HIGH);     // "rozsvítíme" poslední bit   puls(podPosun);    // potřebujeme oba pulsy v tomto pořadí:   puls(podVystup);   // nejprve posun, pak teprve výstup   for(uint8_t i=0; i<8; i++)   // světélko "běží" doleva (až zmizí ven)   {      digitalWrite(podData, LOW);      puls(podPosun);      puls(podVystup);      delay(250);   // cca 4 skoky za sekundu   }}
void loop(){   cas = millis();   // synchronizace - reset času - měříme délku smyčky   // vstupy z tlačítek   sidTlData[0] = !digitalRead(pidTlData);   sidTlPosun[0] = !digitalRead(pidTlPosun);
   // mazání – stiskem obou tlačítek mažeme celý registr,   // přestaneme mazat a blokovat další akce až po uvolnění obou tlačítek   if(sidTlData[0] == HIGH && sidTlPosun[0] == HIGH) sodSmazat = LOW;   else if(!sodSmazat && !sidTlData[0] && !sidTlPosun[0]) sodSmazat = HIGH;         // nastavení vstupního bitu registru (SER) - tlačítko TlData přepíná bit mezi 0 a 1   if(sidTlData[0] == HIGH && sidTlData[1] == LOW) sodData = !sodData;   // načtení vstupního bitu do registru a posun ostatních tlačítkem TlPosun   if(sidTlPosun[0] == HIGH && sidTlPosun[1] == LOW)   {      /* Tlačítko pidTlPosun musí zařídit náběžnou hranu SRCLK         a následně i do RCLK, aby se posun projevil         na výstupech posuvného registru. */      posun = HIGH;   }
   // příprava výstupu   sodData &= sodSmazat;   // aby mazání zahrnulo i vstupní bit   posun |= !sodSmazat;    // aby se případné smazání ihned projevilo      // výstupy   digitalWrite(podSmazat, sodSmazat);   // maže nebo drží data   digitalWrite(podData, sodData);   // nastaví hodnotu vstupního bitu registru   if(posun)   // jen pokud je aktivován posun tlačítkem nebo mažeme   {      puls(podPosun);    // posune bity v registru      puls(podVystup);   // zapíše na výstup      posun = LOW;       // už je posunuto   }      // posun v bufferu tlačítek   sidTlData[1] = sidTlData[0];   sidTlPosun[1] = sidTlPosun[0];   // synchronizace - garantovaná minimální perioda smyčky (kvůli tlačítkům)   while(cas - millis() < perioda) /* čekej*/;}

// sedmisegmentový displej
#define C_CATHODE B0#define C_ANODE B11111111/*typ rozhoduje o zapojení i o úrovni signálu:- společnou katodu připojujeme ke GND a signál HIGH rozsvěcuje segment, LOW zhasíná- společnou anodu připojujeme k 5 V a signál LOW rozsvěcuje segment, HIGH zhasíná*/byte typ = C_ANODE;   // se společnou anodou// byte typ = C_CATHODE;   // se společnou katodouuint8_t cislo;/*značení segmentů:A, B, C, D, E, F, G tvoří znak, o = des. tečka  --A-- |     | F     B |     |  --G-- |     | E     C |     |  --D--  o                { o,G,F,E, D, C,B,A} */uint8_t podSegmenty[8] = {12,9,6,5,11,10,8,7};   // mapování segmentů na piny Arduina
byte znaky[12] =   /* 7+1=8 segmentů => vejdou se do 1 bajtu,   pozice určuje segment (A je 1. zleva, tedy obráceně než při mapování segmentů na piny) */{   B11111100,   // 0   B01100000,   // 1   B11011010,   // 2   B11110010,   // 3   B01100110,   // 4   B10110110,   // 5   B10111110,   // 6   B11100000,   // 7   B11111110,   // 8   B11110110,   // 9   B00000001,   // .   B10011111    // E. = error (chyba)};
void tisk7sBajt(byte znak){   znak = znak ^ typ;         // zohledníme typ displeje, společná anoda prohodí 0 a 1 v bajtu   for(uint8_t i=0;i<8;i++)   // procházíme bajt zprava bit po bitu (segment po segmentu od o po A)   {       digitalWrite(podSegmenty[i], znak & B1);       znak >>= 1;   }}
void tisk7sCislo(int8_t cifra){   if(cifra < 0) cifra = 10;        // des. tečka   else if(cifra > 9) cifra = 11;   // chyba   tisk7sBajt(znaky[cifra]);}
void setup(){   for(uint8_t i=0;i<8;i++) pinMode(podSegmenty[i], OUTPUT);   tisk7sBajt(B0);   // zhasneme = pošleme nulový bajt}
void loop(){   // všechny znaky (včetně des. tečky a chyby) se postupně střídají dokola po 1 sekundě   if(cislo == 11) cislo = -1;  // des. tečka   tisk7sCislo(cislo);   cislo++;   delay(1000);}

// sedmisegmentový displej#include "7sd.h"   // načtení naší knihovny
// použitíuint8_t podSegmenty[8] = {5,6,7,8,9,10,11,12};   // mapa segmentů na piny Arduinauint8_t podZn[] = {2,3,4,13};  // mapa pozic znaků na piny Arduina, max. 8displej7s displej(C_CATHODE,podSegmenty,4,podZn);   // konstrukce displeje
#define MIN -100         // nejmenší zkušební hodnota#define MAX 200          // největší zkušební hodnotaint cislo = MIN;         // počáteční zkušební hodnotauint64_t loCas;          // pomocná proměnná pro synchronizaciuint16_t perioda = 500;  // perioda změny zkušební hodnoty
void setup(){   loCas = millis();     // začátek synchronizace}
void loop(){   displej.tiskCislo(cislo);         // zobrazení čísla na displeji      if(millis() - loCas >= perioda)   // číslo se změní po určité periodě   {      loCas = millis();              // začátek nové periody      cislo++;                       // jednoduše roste po 1      if(cislo > MAX) cislo = MIN;   // po dosažení max. hodnoty začne znovu   }}

// základní knihovna pro práci se 7 segmentovým displejem o max. 8 znacích
#ifndef _7SD_H_ #define _7SD_H_ 1   // ochrana proti opakovanému načtení
#define C_CATHODE B0        // pro displej se společnou katodou#define C_ANODE B11111111   // pro displej se společnou anodou#define MINUS 17            // znak mínus má index 17#define NIC 18              // prázdný znak má index 18
class displej7s             // vytvoření třídy pro displej{   byte typ;                // typ displeje   uint8_t pocetZn, aktZnak, chyba;   // počet znaků displeje, pořadí aktuálního znaku, druh chyby   int8_t zaporne, i;       // -1/1 záporné/kladné č., i pomocná pro cykly   int32_t loCislo;         // minule zobrazované číslo (celé víceciferné)   uint8_t cifra[8];        // pole cifer, na které se číslo rozloží   /*   značení segmentů:   A, B, C, D, E, F, G tvoří znak, o = des. tečka    --A--   |     |   F     B   |     |    --G--   |     |   E     C   |     |    --D--  o   v pořadí {o,G,F,E,D,C,B,A}   */   uint8_t *segmenty;   // ukazatel na začátek pole pinů pro segmenty   uint8_t *poZn;       // ukazatel na začátek pole pinů pro pozice displeje
   byte znaky[19] =   /* 7+1=8 segmentů => vejdou se do 1 bajtu,      pozice určuje segment (A je 1. zleva, tedy obráceně než při mapování segmentů na piny).      Máme připraveno na 16 soustavu a plovoucí tečku, ale nepoužijeme je. */   {      B11111100,   // 0      B01100000,   // 1      B11011010,   // 2      B11110010,   // 3      B01100110,   // 4      B10110110,   // 5      B10111110,   // 6      B11100000,   // 7      B11111110,   // 8      B11110110,   // 9      B11101110,   // A      B00111110,   // b      B00011010,   // c      B01111010,   // d      B10011110,   // E      B10001110,   // F      B00000001,   // . nebo :      B00000010,   // - (mínus)      B0           // prázdný znak   };
   // konstrukce a inicializace   public:   // konstruktor objektu displeje   displej7s(byte typD, uint8_t pinyS[], uint8_t pocetZ, uint8_t pinyZ[])   {      // inicializace trvalých proměnných      typ = typD;      segmenty = pinyS;      pocetZn = pocetZ;      poZn = pinyZ;      // aktivace pinů      for(i=0; i<8; i++) pinMode(segmenty[i], OUTPUT);      for(i=0; i<pocetZn; i++)      {         pinMode(poZn[i], OUTPUT);         tisk7sBajt(i, B0);   // začneme se zhasnutým displejem      }      aktZnak = 0;            // začneme na levém okraji displeje   }
   void tisk7sBajt(uint8_t pozice, byte znak)   // tiskne na danou pozici jakýkoliv bajt s definicí segmentů   {      uint8_t i;      znak = znak ^ typ;      // zohledníme typ displeje, společná anoda prohodí 0 a 1 v bajtu      for(i=0;i<pocetZn;i++)         if(i == pozice) digitalWrite(poZn[i], typ & B1);   // aktuální pozice         else digitalWrite(poZn[i], !(typ & B1));           // ostatní vypneme (ale může v nich zbýt energie)      for(i=0;i<8;i++)   // procházíme bajt zprava bit po bitu (segment po segmentu od o po A)      {         digitalWrite(segmenty[i], znak & B1);              // rozsvěcíme nebo zhasínáme segment         znak >>= 1;   // posun na další segment (bude na konci bajtu)      }   }
   void tisk7sCislo(uint8_t pozice, int8_t cifra)   // usnadňuje tisk číslice   {      if(cifra < 0) cifra = 16;          // des. tečka      else if(cifra > 18) cifra = 18;    // chyba - nic      tisk7sBajt(pozice, znaky[cifra]);  // tiskne předdefinovaný znak z pole   }
   uint8_t tiskCislo(int32_t cislo, uint8_t z = 10)  // preferujeme desítkovou soustavu, ale umí do 16   {      if(cislo != loCislo)  // se změnou zobrazovaného čísla začínáme znovu      {         chyba = 0;                             // zatím bez chyby         loCislo = cislo;                       // zapamatuje si aktuální číslo         if(cislo <= -pow(z,pocetZn-1) || cislo >= pow(z,pocetZn)) chyba = 1;   // mimo rozsah         zaporne = cislo < 0 ? -1 : 1;          // znaménko se projeví později         cislo *= zaporne;                      // dále číslo zpracováváme bez znaménka
         for(i=pocetZn-1; i>=0 && cislo; i--)   // číslo rozkládáme na cifry odzadu         {            cifra[i] = cislo % z;               // Hornerovo schema / Archimedův algoritmus            cislo /= z;                         // přechod do vyššího řádu         }         if(i == pocetZn-1)                     // samotná nula se vypíše         {            cifra[i] = 0;            i--;         }         else if(zaporne == -1)                 // pokud je číslo záporné, předřadí se znaménko         {            cifra[i] = MINUS;            i--;                     }         for(; i>=0; i--) cifra[i] = NIC;       // směrem doleva případně doplní prázdné znaky         aktZnak = 0;      }
      tisk7sBajt((aktZnak-1)%pocetZn,B0);   // odstraníme "ducha" z minulé pozice (zbytková energie zlobí)
      if(chyba) tisk7sCislo(aktZnak, MINUS);      // chyba se zobrazí jako samé pomlčky      else tisk7sCislo(aktZnak, cifra[aktZnak]);  // jinak zobrazí znak na aktuální pozici
      aktZnak = (aktZnak+1) % pocetZn;            // posune se na další pozici
      return chyba;   // kdybychom chtěli dále zpracovávat chybu   }};   // středník nutný – konec definice objektu
#endif

// Matice 8x8 LED s řadičem MAX7219/*   Program umožňuje kreslit obrázky 8x8 pixelů. Kurzor je zobrazen blikáním LED   na aktuální pozici. Periodu blikání prázdného pixelu určuje proměnná   "dobaKmitu", obsazený pixel kmitá čtyřikrát rychleji a navíc obsazenost   monitoruje dioda na pinu D13. Pohyb je řízen čtyřmi směrovými tlačítky,   naplnění/smazání pixelu tlačítkem na pinu "pidTlPotvrd". Stiskem tlačítka na   pinu "pidTlZrus" dojde ke smazání displeje, nastavení kurzoru do levého   horního rohu a vypsání C definice obrázku jako pole bajtů do sériové linky.   Ze sériového monitoru ji lze kopírovat do zdrojového kódu...*/#include<LedControl.h>   // knihovna pro ovládání LED matic pomocí obvodů MAX72XX
// přiojení řadiče matic (SPI)uint8_t podData = 12;   // datauint8_t podClk = 11;    // hodinový signáluint8_t podCS = 10;     // výběr matice (je-li jich více)// tlačítkauint8_t pidTlPotvrd = 5, sidTlPotvrd[2];uint8_t pidTlZrus = 4, sidTlZrus[2];uint8_t pidTlLeve = 7, sidTlLeve[2];uint8_t pidTlHorni = 6, sidTlHorni[2];uint8_t pidTlPrave = 2, sidTlPrave[2];uint8_t pidTlDolni = 3, sidTlDolni[2];// stavová LEDuint8_t podLed = 13;// ostatníuint8_t pocetMatic = 1; // počet matic připojených k řadiči (max. 8)uint8_t mAsta = 0;      // jedinou matici pojmenujeme "mAsta", její pořadí = 0uint8_t mBod[2];        // mBod[0] = souřadnice X, mBod[1] = Y aktivního boduuint8_t loBOD[3];       // stav minulého bodubyte mObraz[8];         // binární mapa obrazu na maticiuint8_t casPmZ = 100;   // nutná časová prodleva mezi zobrazenímiuint64_t cas,mCas,dobaKmitu = 1200;
// zpřístupnění připojených maticLedControl matice = LedControl(podData,podClk,podCS,pocetMatic);
void setup(){   // aktivace tlačítek   pinMode(pidTlPotvrd,INPUT_PULLUP);   pinMode(pidTlZrus,INPUT_PULLUP);   pinMode(pidTlLeve,INPUT_PULLUP);   pinMode(pidTlHorni,INPUT_PULLUP);   pinMode(pidTlPrave,INPUT_PULLUP);   pinMode(pidTlDolni,INPUT_PULLUP);   // aktivace stavové LED   pinMode(podLed,OUTPUT);   /* Ze začátku jsou matice v režimu úspory energie (paměť je aktivní,      ale LED jsou zhasnuté). Pro povolení zobrazení tu naši musíme probudit. */   matice.shutdown(mAsta,false);   zobrazLogo(mAsta);               // pomalu se rozsvítí a zhasne logo Arduina   //matice.setIntensity(mAsta,8);  // nastavení jasu v rozmezí 0-15, 8 je napůl   matice.clearDisplay(mAsta);      // smažeme obraz   Serial.begin(9600);              // sériová linka   mCas = millis();                 // reset času pro dodržení min. periody zobrazení}
void loop(){   cas = millis() % dobaKmitu;   // aktualizace času pro blikání kurzoru   // vstupy z tlačítek   sidTlPotvrd[0] = !digitalRead(pidTlPotvrd);   sidTlZrus[0] = !digitalRead(pidTlZrus);   sidTlLeve[0] = !digitalRead(pidTlLeve);   sidTlHorni[0] = !digitalRead(pidTlHorni);   sidTlPrave[0] = !digitalRead(pidTlPrave);   sidTlDolni[0] = !digitalRead(pidTlDolni);
   // aktualizace hodnoty pixelu před případným přesunem   matice.setLed(mAsta,mBod[1],mBod[0],mObraz[mBod[1]] >> 7-mBod[0] & B1);   // reakce na náběžnou hranu tlačítek (jen jednoho - podle pořadí)   if(sidTlPotvrd[0] == HIGH && sidTlPotvrd[1] == LOW) akcePotvrd();   else if(sidTlZrus[0] == HIGH && sidTlZrus[1] == LOW) akceZrus();   else if(sidTlLeve[0] == HIGH && sidTlLeve[1] == LOW) mBod[0] -= mBod[0] ? 1 : 0;   else if(sidTlHorni[0] == HIGH && sidTlHorni[1] == LOW) mBod[1] -= mBod[1] ? 1 : 0;   else if(sidTlPrave[0] == HIGH && sidTlPrave[1] == LOW) mBod[0] += mBod[0] < 7 ? 1 : 0;   else if(sidTlDolni[0] == HIGH && sidTlDolni[1] == LOW) mBod[1] += mBod[1] < 7 ? 1 : 0;
   zobrazBod(mAsta,mBod);   // zobrazení aktuálního pixelu
   // zapamatování tlačítek do další smyčky   sidTlPotvrd[1] = sidTlPotvrd[0];   sidTlZrus[1] = sidTlZrus[0];   sidTlLeve[1] = sidTlLeve[0];   sidTlHorni[1] = sidTlHorni[0];   sidTlPrave[1] = sidTlPrave[0];   sidTlDolni[1] = sidTlDolni[0];
   // zaručíme minimální délku smyčky, aby matice stíhala zobrazovat   while((millis()-mCas) < casPmZ) /*čekej*/;   mCas = millis();}
void akcePotvrd()   // zapsání hodnoty pixelu jako bitu do aktuálního řádku obrazu{   mObraz[mBod[1]] ^= B1 << 7 - mBod[0];}
void akceZrus()   // zápis do sériové linky a smazání obrazu na displeji{   String text = "byte obrazek[] =\n{";   Serial.println(text);   matice.clearDisplay(mAsta);   // smazání matice   mBod[0] = mBod[1] = 0;        // reset pozice   for(uint8_t i=0; i<8; i++)   {       text = "   B" + String(mObraz[i],BIN) + ",";       Serial.println(text);       mObraz[i] = B0;   }   Serial.println("};");}
void zobrazBod(uint8_t cMatice, uint8_t bod[])   // zobrazení bodu na displeji{   uint8_t signal = mObraz[bod[1]] >> 7-bod[0] & B1;   uint64_t uprDobaKmitu = signal ? dobaKmitu/4 : dobaKmitu;   if(cas%uprDobaKmitu > uprDobaKmitu/2) matice.setLed(cMatice,bod[1],bod[0],signal);   else matice.setLed(cMatice,bod[1],bod[0],!signal);   digitalWrite(podLed,signal);}
void zobrazLogo(uint8_t cisloM)   // úvodní intro s logem Arduina{   uint8_t i,radek;   uint16_t prodleva = 50;   byte logo[] =   {      B00001110,      B00010001,      B00010101,      B01110001,      B10001110,      B10101000,      B10001000,      B01110000   };
   // zhasneme   matice.setIntensity(cisloM,0);   // nastavíme obraz loga   for(radek = 0; radek < 8; radek++)      matice.setRow(cisloM,radek,logo[radek]);   delay(prodleva);   // postupně rozjasňujeme   for(i = 1; i < 16; i++)   {      matice.setIntensity(cisloM,i);      delay(prodleva);   }   // postupně zhasínáme   for(i = 15; i > 0; i--)   {      matice.setIntensity(cisloM,i);      delay(prodleva);   }   // pro jistotu smažeme úplně   matice.clearDisplay(cisloM);}

// motor na dálkové ovládání
#include<IRremote.h>   // verze >= 3.0.0#include<LiquidCrystal_I2C.h>
// tlačítka dálkového ovladače (adresy zjištěny analyzátorem)#define TL_VYP0 0x45    // všechna#define TL_VYP1 0x46    //    červená#define TL_VYP2 0x47    //    tlačítka#define TL_ZAP 0x43     // zelené tlačítko >||#define TL_PLUS 0x15    // +#define TL_PLUS10 0x40  // >>|#define TL_MINUS 0x7    // -#define TL_MINUS10 0x44 // |<<#define TL_0 0x16       // 0
// rozsah otáček motoru v %#define MOTOR_MIN -100#define MOTOR_MAX 100
//////////////// proměnné ////////////////
LiquidCrystal_I2C lcd(0x27,16,2);   // displejuint8_t pidIR = 2;          // vstupní pin IR čidlauint8_t pidTl = 6;          // vypínací tlačítkouint8_t podLed[] = {3,4};   // provozní Ledky - 3 červená (zapnuto), 4 zelená (provoz)uint8_t poaMotor = 5;       // PWM, výkon motoru - 1. póluint8_t podMotorSmer = 7;   // směr otáčení motoru - 2. pól
int8_t soaMotor;  // otáčky motoru MOTOR_MIN až MOTOR_MAXbool sodLed[2];   // signály pro ledky [0] červená, [1] zelenábool sidTl[2];    // [0] aktuální a [1] minulý stav vypínacího tlačítkabool zapnuto;     // zařízení zapnuto = HIGH / vypnuto = LOWbool provoz;      // je/není v úrovni provoz
uint64_t minCasTl = 100;     // minimální prodleva opakovaného čtení tlačítkauint64_t minCasIR = 200;     // minimální prodleva opakovaného čtení IRuint64_t loCasTl, loCasIR;   // časy minulých stisků
////////////// funkce //////////////
void zapVyp()   // zapnutí nebo vypnutí tlačítkem{   zapnuto = !zapnuto;  // přepnutí   provoz = LOW;        // zhasne zelenou LED   soaMotor = 0;        // zastaví motor   lcd.clear();         // smaže displej   if(zapnuto) lcd.backlight();  // rozsvítí displej   else lcd.noBacklight();       // zhasne displej}
void motor(int8_t procenta)   // nastaví směr a otáčky motoru{   uint8_t soaVykon;   // úroveň signálu PWM pro motor   if(procenta < 0)    // záprorný směr   {      soaVykon = map(procenta,0,MOTOR_MIN,255,0);   // mapujeme obráceně!!!      digitalWrite(podMotorSmer,HIGH);   // HIGH --> U1 = 5V --> obrátíme polaritu      analogWrite(poaMotor,soaVykon);    // U2 <= 5V --> U2 - U1 < 0   }   else   // kladný směr   {      soaVykon = map(procenta,0,MOTOR_MAX,0,255);      digitalWrite(podMotorSmer,LOW);   // LOW --> U1 = 0V      analogWrite(poaMotor,soaVykon);   // U2 > 0V --> U2 - U1 > 0   } }
void setup(){   pinMode(pidTl,INPUT_PULLUP);   pinMode(podLed[0],OUTPUT);   pinMode(podLed[1],OUTPUT);   pinMode(poaMotor,OUTPUT);   pinMode(podMotorSmer,OUTPUT);   IrReceiver.begin(pidIR, ENABLE_LED_FEEDBACK);   // aktivace IR přijímače   lcd.init();                     // aktivace displeje   loCasTl = loCasIR = millis();   // časovače pro stisk tlačítka mechanického i z IR}
void loop() {   // bezpečně načte tlačítko, ale nebrzdí čtení IR signálu   if(millis()-loCasTl > minCasTl) sidTl[0] = !digitalRead(pidTl);
   if(sidTl[0] && !sidTl[1])   // zapnutí/vypnutí tlačítkem   {      loCasTl = millis();  // reset časovače      zapVyp();            // zapne nebo vypne   }   sidTl[1] = sidTl[0];    // zapamatování tlačítka do další smyčky     // IR signál   if (zapnuto && IrReceiver.decode())   // něco zachytil   {      // úroveň pohotovost - nadřízená      switch(IrReceiver.decodedIRData.command)      {         // úroveň pohotovost - nadřízená         case TL_VYP0: case TL_VYP1: case TL_VYP2:            provoz = LOW;            soaMotor = 0;            break;         case TL_ZAP:            provoz = HIGH;            soaMotor = 0;            break;         default:            // úroveň provoz - podřízená            // bráníme se rychlému opakování povelu, ale neblokujeme ostatní            if(provoz && millis()-loCasIR > minCasIR)            {               loCasIR = millis();   // reset časovače               switch(IrReceiver.decodedIRData.command)               {                  case TL_0:                     soaMotor = 0;                     break;                  case TL_MINUS:                     soaMotor -= (soaMotor == MOTOR_MIN ? 0 : 1);                     break;                  case TL_MINUS10:                     soaMotor = (soaMotor >= MOTOR_MIN + 10? soaMotor - 10 : MOTOR_MIN);                     break;                  case TL_PLUS:                     soaMotor += (soaMotor == MOTOR_MAX ? 0 : 1);                     break;                  case TL_PLUS10:                     soaMotor = (soaMotor <= MOTOR_MAX -10 ? soaMotor + 10 : MOTOR_MAX);                     break;               }            }      }      IrReceiver.resume();   // IR přijímač pokračuje v naslouchání   }
   // zobrazení na displeji   if(zapnuto)      if(provoz)   // provoz      {          lcd.home();          lcd.print("Motor: "+String(soaMotor)+"     ");   // přepíše otáčky motoru v %          lcd.setCursor(0,1);          lcd.print("+/-/0 otacky    ");      }            else   // pohotovost      {          lcd.home();          lcd.print("Zapni zelenym   ");          lcd.setCursor(0,1);          lcd.print("tlacitkem...    ");      }
   // výstupy   // příprava   sodLed[0] = zapnuto;  // červená LED   sodLed[1] = provoz;   // zelená LED   // zápis   digitalWrite(podLed[0],sodLed[0]);   digitalWrite(podLed[1],sodLed[1]);   motor(zapnuto*provoz*soaMotor);   // motor}