Asi se shodneme, že učení a hromadění všemožných informací o modulu ESP32 už bylo dost. Pojďme si dnes prostě „jen tak“ postavit nějakou blbost pro radost. Z našeho testování interního čidla nám tu zbyla vývojová deska ESP32 TTGO OLED, která je z přední strany osazena barevným OLED displejem o rozlišení 135×240 pixelů), ze zadní strany je konektor pro připojení (a nabíjení) 3,7 V LiPo(l) akumulátoru. Deska je dále doplněna dvojicí tlačítek, která jsou připojena k pinům GPIO 0 a GPIO35. Obrázek č. 1 ukazuje celkové rozložení pinů vývojové desky TTGO.
Obrázek 1 – Rozložení pinů vývojové desky ESP32 TTGO OLED.
Je tedy jasné, že naše zapojení musí něco zobrazovat na displeji (nejlépe barevně), mělo by to být přenosné zařízení napájené baterií a ovládat se dá pomocí dvojice tlačítek. Popravdě řečeno, první co nás napadlo, byla herní konzole pro Tetris! 😁 Nakonec však vyhrála jednodušší varianta, tedy hodinky. Budeme chtít zobrazit čas jak na analogovém ciferníku, tak zároveň v podobě digitální. Levé a pravé tlačítko nám bude sloužit pro nastavování hodin a minut.
A protože už přece něco umíme, pojďme to celé naprogramovat pomocí přerušení!
Návrh programu
Základem celého programu musí být algoritmus, který se nám bude starat o časování a pochopitelně o vykreslování potřebných údajů na displej. Jak už jsme řekli, chceme využít přerušení. Všem, kterým je používání přerušení zatím zakryto mlhou nevědomosti, doporučujeme prostudovat článek: ESP32: Přerušení – konfigurace a použití.
Časovač
Obsluhu času budeme řešit softwarovým přerušením, vyvolávaným časovačem. Prvním krokem je tedy nastavení časovače s vhodnou časovací frekvencí. Dále musíme nastavit hodnotu intervalu („alarmu“) spouštění přerušení, aby k němu docházelo 1× za sekundu. To nám na změnu počtu sekund, popřípadě minut a hodin stačí. Nakonec je třeba vyřešit samotnou servisní rutinu přerušení.
Nastavení časovače, jeho přerušení a „alarmu“ uděláme následujícím způsobem:
bool NastalCas = false; // indikator, zda doslo k zavolani preruseni
hw_timer_t * timer = NULL; // objekt casovace
// --- Obsluzna rutina IRQ --
void IRAM_ATTR onTimer() {
NastalCas = true; // zprava pro hlavni smycky, ze ma zacit kreslit na displej
}
void setup(void) {
timer = timerBegin(0, 80, true); // nastaveni casovace (cislo, delicka, vzestupne)
timerAttachInterrupt(timer, &onTimer, true); // nastaveni preruseni (casovac, ISR, hrana)
timerAlarmWrite(timer, 1000000, true); // kdy spustit preruseni (casovac, 1s, opakovat)
timerAlarmEnable(timer); // vse nastaveno, tak jedem!
… atd …
Na začátku vytvoříme globální objekt časovače timer. Vytvořili jsme jej na hardwarovém časovači číslo 0. Děličku frekvence jsme nastavili na hodnotu 80, což odpovídá frekvenci čítání 1 MHz. Časovač bude počítat vzestupně. K nastavenému časovači je připojena servisní rutina pojmenovaná onTime a je spouštěna náběžnou hranou. Nakonec je nastavena hodnota alarmu na 1 000 000 mikrosekund (1 sec) a je nastaveno, aby se pak časovač opět (automaticky) znovu aktivovat.
V servisní rutině přerušení nastavíme jen globální logickou proměnnou příznaku, který hlavní smyčky upozorní, že bude třeba překreslit displej. Jak jistě víme servisní rutina musí proběhnout relativně rychle a vykreslování ciferníku na displej k těmto činnostem zrovna moc nepatří.
Tlačítka
Když jsme se tak pěkně „rozdováděli“ se softwarovým přerušením, (generovaným časovačem), můžeme se pustit do obsluhy tlačítek – pochopitelně pomocí přerušení hardwarového. Opět si trochu připomeneme, že je třeba vytvořit poměrně krátké (rychlé) servisní rutiny přerušení a na ně nasměrovat hardwarové události GPIO pinů. V našem případě půjde o stisknutí tlačítek, která jsou spojené s GPIO piny 0 a 35. Oba piny tedy nastavíme jako vstupy, a to nejlépe jako vstupy držené na úrovni log. 1 pomocí interních (volitelných) pull-up rezistorů. Problematika nastavení GPIO pinů jsme řešili v článku: ESP32 – Jak používat GPIO piny?
Opět se podíváme na kousek kódu, na kterém si vysvětlíme, klíčové informace:
#define RightBUT 35
#define LeftBUT 0
bool initial = true;
void IRAM_ATTR ISR_HOD() {
if (!initial) {
hh = hh + 1;
if (hh > 23) hh = 0;
initial = true;
}
}
void IRAM_ATTR ISR_MIN() {
if (!initial) {
mm = mm + 1;
if (mm > 59) mm = 0;
// ss = 0; //pokud chceme při zmene minuty nastavit vterinovku na 0
initial = true;
}
}
void setup(void) {
pinMode(RightBUT, INPUT_PULLUP);
pinMode(LeftBUT, INPUT_PULLUP);
attachInterrupt(LeftBUT, ISR_HOD, FALLING);
attachInterrupt(RightBUT, ISR_MIN, FALLING);
… atd …
Počáteční definice pro překladač nastavuje číslo GPIO 35 pinu pro pravé tlačítko (RightBUT), kterým budeme zvyšovat hodnotu počtu minut (posouvání minutové rafičky) a GPIO 0 pinu levého tlačítka (LeftBUT) pro zvyšování počtu hodin (posouvání hodinové rafičky). Logická proměnná initial bude dále v hlavní smyčce určovat, zda má být překreslen displej – poprvé to je hned po spuštění programu, dále vždy, jakmile proběhne změna v některé ze servisních rutin přerušení.
Druhý úkol proměnné initial si ještě ukážeme dále v servisních rutinách přerušení.
Servisní rutiny hardwarového přerušení ISR_HOD a IST_MIN reagují na sestupnou hranu (nastaveno v proceduře setup) a jedna zvyšuje globální proměnnou hh, která je počtem hodin, druhá zvyšuje počet minut. Servisní rutiny ještě obsahují podmínku hlídající tyto hodnotu, aby nebyly vyšší než 23 hodin nebo 59 minut.
A nyní se ještě jednou vraťme k proměnné initial. Další její funkce se ukazuje v servisní proměnné, kde ovlivňuje přičítání počtu hodin nebo minut.
Jinými slovy, pokud není proměnná initial rovna hodnotě false, nebude se zvyšování minut ani hodin provádět. Proč?
Zkusíme si tento trik vysvětlit trochu obšírněji. Co se děje, když stiskneme tlačítko. Teoreticky by se měla na příslušném GPIO pinu změnit hodnota z log. 1 na log. 0 (nebo chcete-li z hodnoty HIGH na hodnotu LOW). Prakticky tomu však není! Mechanický kontakt, který propojí GPIO pin proti zemi ve skutečnosti může drobně zapružit, takže chvilku skutečně GPIO pin se zemí spojí, pak rozpojí a pak zase spojí. Pro běžného člověka je to mžik, který ani nepostřehne. Ne však modul ESP32, jehož kód probíhá velikou rychlostí. Takže při prvním kontaktu proběhne první přerušení, po „dopružení“ kontaktu druhé. Rázem toto mechanické zachvění generovalo dvě stisknutí. A kdyby občas jen dvě! Tento jev je poměrně znám a mechanické vypínače se proti němu musí ošetřit. Hardwarově se to v elektronice řeší kupříkladu zapojením logických hradel (tzv. flip-flop obvod), nebo aspoň pomocí RC členu. Softwarově v kódu programu se to dá ošetřit zareagováním na první sepnutí a pak určitou prodlevou (zpožděním), kdy jsou další zákmity ignorovány. Ale ta představa, jak do servisních rutin přerušení dáváme nějaké čekací zpoždění, není asi moc ideální! Musíme to tedy udělat jinak! Při reakci na první zákmit (sepnutí) spínače se spustí přerušení a normálně proběhne, ale zároveň nastavíme proměnnou initial na hodnotu true. Takže při druhém, třetím… zákmitu již hodnota proměnné initial nedovolí další přičtení počtu hodin nebo minut. Teď je však potřeba zajisti, aby po nějakém čase bylo stisknut&icute; tlačítka „odemknuto“. K tomu vyžijeme fakt, že proměnná initial také ovládá překreslování displeje. Po návratu ze servisní rutiny přerušení dojde k překreslení displeje a na konci toho se opět nastaví proměnná initial na hodnotu false, která dovolí provedení inkrementace počtu hodin a minut v těle servisní procedury (to uvidíme v hlavní smyčce loop). Paradoxně pomalé překreslování displeje nám tady poslouží jako „zdržovačka“, která překlene zakmitání spínače. Toto zakmitání sice několikrát spustí rutinu přerušení, ale v dalších zákmitech se v rutině nic neprovádí (není splněna podmínka pro proměnou initial).
OLED displej
Vývojový kit ESP32 s TTGO OLED má na sobě zabudovaný OLED displej, který budeme v prostředí Arduino IDE ovládat prostřednictvím rozšiřující knihovny TFT_eSPI.h.
Funkce knihovny TFT_eSPI (API)
Zde je seznam nejběžnějších funkcí, které nabízí knihovna TFT_eSPI. Vzhledem k absenci oficiální dokumentace byly funkce extrahovány přímo ze zdrojového kódu knihovny.
width() – šířka obrazovky v pixelech
height() – výška obrazovky v pixelech
setRotation(m) – otočí obsah obrazovky. Orientace je číslo od 0 do 3 a 4 až 7 pro bitmapu
getRotation() – vrací orientaci obrazovky
invertDisplay(i) – invertovat barvy displeje (i = true invertovat, i = false normální)
fillScreen(color) – vybarví pozadí obrazovky. Funkce ve skutečnosti nakreslí celý obdélník zabírající celou plochu obrazovky
setCursor(x, y) – umístí kurzor.
getCursorX– vrátí souřadnici x kurzoru
getCursorY – vrátí souřadnici y kurzoru
setPivot(x, y) – bod otáčení obrazovky
getPivotX() – souřadnice x otočného bodu
getPivotY() – x souřadnice otočného bodu
readPixel(x, y) – přečte barvu pixelu ve formátu 565
drawCircle(x0, y0, r, barva) – nakreslí obrys kruhu
fillCircle(x0, y0, r, barva) – nakreslí vyplněný kruh
drawEllipse(x0, y0, rx, ry, barva) – nakreslí obrys elipsy
fillEllipse(x0, y0, rx, ry, barva) – nakreslí vyplněnou elipsu
drawRect(x, y, w, h, barva) – nakreslí obrys obdélníku
fillRect(x, y, w, h, barva) – nakreslí vyplněný obdélník
drawRoundRect(x, y, w, h, r, barva) – obrys obdélníku se zaoblenou hranou. Všechny úhly mají stejný poloměr
fillRoundRect(x, y, w, h, r, barva) – stejné jako předchozí, ale objekt je vyplněný
drawTriangle(x0, y0, x1, y1, x2, y2, barva) – obrys trojúhelníku. (je třeba zadat souřadnice tří vrcholů)
fillTriangle(x0, y0, x1, y1, x2, y2, barva) – stejné, ale s vyplněným trojúhelníkem
drawPixel(x, y, barva) – nakreslit barevný pixel
drawLine(x0, y0 , x1, y1 , barva) – nakreslí čáru mezi dvěma libovolnými body
drawFastVLine(x, y, h, barva) – svislá čára délky h
drawFastHLline(x, y, w, barva) – vodorovná čára délky w
drawBitmap(x, y, bitmapa, w, h, barva) – zobrazí obrázek uložený v poli bitmapa
drawXBitmap (x, y, bitmapa, w, h, color) – vykreslí monochromatický obrázek uložený v poli. (Můžete například převést obrázek JPG nebo PNG pomocí GIMPu do formátu XBM a načíst pole bodů.)
fontsLoaded() – vrací 16bitovou kódovanou hodnotu označující načtená písma
fontHeight(h) – výška písma
setFreeFont(f) – Nastaví písmo GFX, které se má použít
setTextSize(s) – nastavuje velikost textu. Musí být mezi 1 a 7 (max.)
setTextColor(barva) – přiřadí barvu textu (barva v šestnáctkové soustavě)
setTextColor(barva, pozadí) – stejné jako předchozí, ale také definuje barvu pozadí. Upřednostňuje se pro text, který se často mění (hodiny, souřadnice, poloha…), díky tomu nedochází k překreslování celé obrazovky při každé aktualizaci.
textWidth(string, font) – vrací šířku řetězce v daném písmu v pixelech
drawChar(x, y, znak, barva, pozadí, velikost) – zobrazí (vykreslí) znak na zadané pozici.
setTextDatum(d) – textový odkaz. Použijte jednu z níže uvedených konstant
Dostupné pozice:
- TL_DATUM 0 // vlevo nahoře (výchozí)
- TC_DATUM 1 // Horní střed
- TR_DATUM 2 // Vpravo nahoře
- ML_DATUM 3 // Levý záložník
- CL_DATUM 3 // Uprostřed vlevo, jak je uvedeno výše
- MC_DATUM 4 // Centrální centrum
- CC_DATUM 4 // Střed na střed, jak je uvedeno výše
- MR_DATUM 5 // Pravý záložník
- CR_DATUM 5 // Uprostřed vpravo, jak je uvedeno výše
- BL_DATUM 6 // Vlevo dole
- BC_DATUM 7 // Uprostřed dole
- BR_DATUM 8 // Vpravo dole
- L_BASELINE 9 // Základní řádek levého znaku (řádek, na kterém by seděl znak "A")
- C_BASELINE 10 // Základní řádek centrálního znaku
- R_BASELINE 11 // Základní řádek pravého znaku
setTextPadding(x_width) – vnitřní okraj (ekvivalent CSS stylu)
getTextPadding() – vrací aktuální výplň
drawString(string, x, y) – nakreslí řetězec (typ String)
drawCentreString(string, x, y, font) – nakreslí řetězec (typ String) se středem na pozici x, y
color8to16(color) – převod 8bitové barvy na 16bitovou hodnotu barvy 565
color16to24(color565) – převod 16bitové barvy na 24bitovou hodnotu barvy 888
color24to16(color888) – převést 24bitovou barvu na 16bitovou hodnotu barvy 565
decodeUTF8(znak) – převede znak ASCII do formátu UTF-8
decodeUTF8(buf, index, zbývající) – dekódování znakové vyrovnávací paměti v rozšířeném formátu ASCII v UTF-8
Seznam výše použitých proměnných:
- m, s – celé číslo
- barva, pozadí–barva v hexadecimálním formátu
- x, y, x0, y0, x1, y1– souřadnice (v pixelech)
- r, rx, ry– oblast (v pixelech)
- w – šířka (v pixelech)
- h– výška (v pixelech)
- i – logická hodnota (false/true)
- string – textový řetězec
Pochopitelně nebudeme všechny tyto funkce a metody používat, ale můžeme si je zde vypsat, abychom se k nim mohli vrátit jindy. Třeba, až nás právě programované hodinky přestanou bavit a budeme chtít naprogramovat tu herní konzolu na Tetris. 😉
Případným zájemcům o poměrně velkou sadu ukázkových kódů k ovládání OLED displeje knihovnou TFT_eSPI doporučujeme následující ukázkové kódy přímo od autora knihovny TFT_eSPI: https://platformio.org/lib/show/1559/TFT_eSPI/examples
Při vykreslování ciferníku analogových hodin, budeme postupovat následujícím způsobem. Po připojení potřebné knihovny TFT_eSPI (popř. její pomocné SPI) deklarujeme objekt knihovny TFT_eSPI, přes který budeme přistupovat k ovládání OLED displeje. Zároveň definujeme odstín šedé barvy, který budeme později používat a který není mezi předdefinovanými barvami – viz následující seznam předdefinovaných barevných konstant v knihovně TFT_eSPI.
Předdefinované barvy v knihovně TFT_eSPI:
- TFT_BLACK – 0x0000
- TFT_NAVY – 0x000F
- TFT_DARKGREEN – 0x03E0
- TFT_DARKCYAN – 0x03EF
- TFT_MAROON – 0x7800
- TFT_PURPLE – 0x780F
- TFT_OLIVE – 0x7BE0
- TFT_LIGHTGREY – 0xC618
- TFT_DARKGREY – 0x7BEF
- TFT_BLUE – 0x001F
- TFT_GREEN – 0x07E0
- TFT_CYAN – 0x07FF
- TFT_RED – 0xF800
- TFT_MAGENTA – 0xF81F
- TFT_YELLOW – 0xFFE0
- TFT_WHITE – 0xFFFF
- TFT_ORANGE – 0xFDA0
- TFT_GREENYELLOW – 0xB7E0
- TFT_PINK – 0xFC9F
#include <TFT_eSPI.h> // Graphics and font library for ST7735 driver chip
#include <SPI.h>
TFT_eSPI tft = TFT_eSPI(135, 240);
#define TFT_GREY 0xBDF7
V proceduře setup() pak inicializujeme ovládání displeje, nastavíme orientaci a vyplníme obrazovku černě. Další kroky se již týkají vykreslení ciferníku, který se vykreslí nyní a jen jednou. Pohyblivé prvky vyřešíme tak, aby nám tuto „masku“ nijak nepřemalovávali.
tft.init();
tft.setRotation(0);
tft.fillScreen(TFT_BLACK);
… atd …
V rámci vykreslení ciferníku je vymalováno orámování, malé značky minut a větší značky hodin a největší značky (řešeno dvojicí malých posunutých kružnic) pro číslice 3, 6, 9 a 12. Nesmíme také opomenout na vykreslení našeho loga, tím je vše statické hotovo.
V hlavní smyčce loop() je testován příznaková proměnná NastalCas, jejíž hodnotu true nastavuje servisní rutina přerušení časovače (již bylo zmíněno). Jakmile se tedy tato proměnná objeví jako true, je třeba nastavit tuto proměnou zpět na false, a především zvýšit počet sekund v proměnné ss. Pochopitelně je třeba ošetřit přetečení hodnoty 60 pro počet sekund a minut a hodnoty 24 pro počet hodin.
if (NastalCas) {
NastalCas = false;
ss++; // zvys počet sekund
if (ss == 60) {
ss = 0;
mm++; // po 60 sec, pridej minutu
if (mm > 59) {
mm = 0;
hh++; // po 60 min, pridej hodinu
if (hh > 23) {
hh = 0;
}
}
}
… atd …
}
Dále se v kódu (stále však v těle splněné) podmínky pro NastalCas se z hodnot sekund, minut a hodin spočítají souřadnice x a y pro rafičky.
// Predpoctete polohu rucicek an souřadnice x a y (pro rychlou aktualizaci obrazovky)
sdeg = ss * 6; // 0-59 -> 0-354
mdeg = mm * 6 + sdeg * 0.01666667; // 0-59 -> 0-360 - includes seconds
hdeg = hh * 30 + mdeg * 0.0833333; // 0-11 -> 0-360 - includes minutes and seconds
hx = cos((hdeg - 90) * 0.0174532925);
hy = sin((hdeg - 90) * 0.0174532925);
mx = cos((mdeg - 90) * 0.0174532925);
my = sin((mdeg - 90) * 0.0174532925);
sx = cos((sdeg - 90) * 0.0174532925);
sy = sin((sdeg - 90) * 0.0174532925);
… atd …
Běžně se překresluje jen vteřinová ručička. Pokud však je hodnota sekund rovna 0, začíná nová minuta, a tedy jsou překresleny všechny ručičky. Druhou částí podmínky pro překreslení všech rafiček je logická proměnná initial. Pokud si vzpomínáme, tak ta je nastavena na hodnotu true na začátku programu, aby se rafičky vykreslily okamžitě po spuštění. Ještě jednou je však nastavena na true, a to v případě stisknutí kteréhokoliv „seřizovacího“ tlačítka, aby se ručičky přemalovaly okamžítě po ručním přestavění času.
if (ss == 0 || initial) {
initial = false;
// Kazdou minutu mazte pozice hodinove a minutove rucicky
tft.drawLine(ohx, ohy, 65, 65, TFT_BLACK);
ohx = hx * 33 + 65;
ohy = hy * 33 + 65;
tft.drawLine(omx, omy, 65, 65, TFT_BLACK);
omx = mx * 44 + 65;
omy = my * 44 + 65;
tft.drawCentreString(to2dig(hh)+":"+to2dig(mm), 64, 180, 6);
}
Protože nám dole na displeji zbylo ještě trochu místa, přidáme tam čas v digitální podobě. I ten budeme přepisovat jen v případě, že se změní počet minut.
Pomocné procedury
Kromě servisních rutin přerušení, úvodní procedury setup() a hlavní smyčky loop() jsou ještě v programu další dvě pomocné funkce.
První pojmenovaná conv2d slouží pro získání hodnoty hodin, minut a vteřin z konstanty __TIME__, kterou vkládá při kompilaci kompilér prostředí Arduino IDE a která tyto údaje obsahuje. Vlastně jde o takový drobný trik. Modul ESP32 nemá vnitřní hodiny reálného času, které by běžely při odpojení napájení. Nastavením času při přeložení kódu na hodnotu z počítače (prostředí Arduino IDE), tak zaručí, že po kompilaci ukazují hodiny správný čas. Toto nastavení času dle času kompiléru ukazuje následující řádka (včetně použití funkce conv2d):
uint8_t hh = conv2d(__TIME__), mm = conv2d(__TIME__ + 3), ss = conv2d(__TIME__ + 6);
Na druhou stranu, tato metoda zadání času není úplně ideální, pokud modul ESP32 vypneme a opět zapneme, nastaví se čas na okamžik kompilace kódu a nikoliv na aktuální čas.
Druhou pomocnou funkcí je funkce to2dig, která převádí číslo na řetězec dvouznakového formátu, tedy čísla menší než 9 budou vpředu doplněna nulou. Tuto funkci
využíváme pro tisk digitální podoby času. Pokud by se někomu nelíbila nula na začátku počtu hodin, může tuto proceduru modifikovat tak, aby u hodin přidávala na začátek mezeru.
Kód
Pokud již rozumíme principu kódu našich hodinek, můžeme se podívat na celý kód.
/* hodiny na OLED displeji TTGO - verze s prerusenimi*/
#include <TFT_eSPI.h> // Graphics and font library for ST7735 driver chip
#include <SPI.h>
TFT_eSPI tft = TFT_eSPI(135, 240);
#define TFT_GREY 0xBDF7
#define RightBUT 35
#define LeftBUT 0
float sx = 0, sy = 1, mx = 1, my = 0, hx = -1, hy = 0;
float sdeg = 0, mdeg = 0, hdeg = 0;
uint16_t osx = 64, osy = 64, omx = 64, omy = 64, ohx = 64, ohy = 64;
uint16_t x0 = 0, x1 = 0, yy0 = 0, yy1 = 0;
bool NastalCas = false; //indikator, zda doslo k zavolani preruseni
bool initial = true;
hw_timer_t * timer = NULL; // objekt casovace
static uint8_t conv2d(const char* p) {
uint8_t v = 0;
if ('0' <= *p && *p <= '9') v = *p - '0';
return 10 * v + *++p - '0';
}
uint8_t hh = conv2d(__TIME__), mm = conv2d(__TIME__ + 3), ss = conv2d(__TIME__ + 6); // Get H, M, S from compile time
String to2dig(int cislo) {
if (cislo <= 9) return "0" + String(cislo);
else return String(cislo);
}
//----------------- IRQ --------------
void IRAM_ATTR ISR_HOD() {
if (!initial) {
hh = hh + 1;
if (hh > 23) hh = 0;
initial = true;
}
}
void IRAM_ATTR ISR_MIN() {
if (!initial) {
mm = mm + 1;
if (mm > 59) mm = 0;
// ss = 0; //pokud chceme při zmene minuty nastavit vterinovku na 0
initial = true;
}
}
void IRAM_ATTR onTimer() {
NastalCas = true; // zprava pro hlavni smycky, ze ma zacit kreslit na displej
}
// funkce SETUP se spusti jednou pri stisknuti tlacitka reset nebo pri zapnuti desky.
void setup(void) {
pinMode(RightBUT, INPUT_PULLUP);
pinMode(LeftBUT, INPUT_PULLUP);
attachInterrupt(LeftBUT, ISR_HOD, FALLING);
attachInterrupt(RightBUT, ISR_MIN, FALLING);
timer = timerBegin(0, 80, true); // nastaveni casovace (cislo, delicka, vzestupne)
timerAttachInterrupt(timer, &onTimer, true); // nastaveni preruseni (casovac, ISR, hrana)
timerAlarmWrite(timer, 1000000, true); // kdy spustit preruseni (casovac, 1s, opakovat)
timerAlarmEnable(timer); //vse nastaveno, tak jedem!
tft.init();
tft.setRotation(0);
tft.fillScreen(TFT_BLACK);
tft.setTextColor(TFT_GREEN, TFT_BLACK);
// Draw clock face
tft.fillCircle(64, 64, 61, TFT_BLUE);
tft.fillCircle(64, 64, 57, TFT_BLACK);
// Draw 12 lines
for (int i = 0; i < 360; i += 30) {
sx = cos((i - 90) * 0.0174532925);
sy = sin((i - 90) * 0.0174532925);
x0 = sx * 57 + 64;
yy0 = sy * 57 + 64;
x1 = sx * 50 + 64;
yy1 = sy * 50 + 64;
tft.drawLine(x0, yy0, x1, yy1, TFT_BLUE);
}
// Draw 60 dots
for (int i = 0; i < 360; i += 6) {
sx = cos((i - 90) * 0.0174532925);
sy = sin((i - 90) * 0.0174532925);
x0 = sx * 53 + 64;
yy0 = sy * 53 + 64;
if (i == 0 || i == 180) { // velka tecka pro 12 a 6
tft.fillCircle(x0, yy0, 1, TFT_CYAN);
tft.fillCircle(x0 + 1, yy0, 1, TFT_CYAN);
}
if (i == 90 || i == 270) { // velka tecka pro 3 a 9
tft.fillCircle(x0, yy0, 1, TFT_CYAN);
tft.fillCircle(x0 + 1, yy0, 1, TFT_CYAN);
}
}
tft.fillCircle(65, 65, 3, TFT_RED);
tft.drawCentreString("FyzKAB", 70, 140, 4);
tft.setTextColor(TFT_RED, TFT_BLACK); // Pridani cerne barvy pozadi automaticky vymaze predchozi text
tft.setTextSize(1);
}
// funkce LOOP bezi stale dokola.
void loop() {
if (NastalCas) {
NastalCas = false;
ss++; // zvys počet sekund
if (ss == 60) {
ss = 0;
mm++; // po 60 sec, pridej minutu
if (mm > 59) {
mm = 0;
hh++; // po 60 min, pridej hodinu
if (hh > 23) {
hh = 0;
}
}
}
// Predpoctete polohu rucicek an souřadnice x a y (pro rychlou aktualizaci obrazovky)
sdeg = ss * 6; // 0-59 -> 0-354
mdeg = mm * 6 + sdeg * 0.01666667; // 0-59 -> 0-360 - includes seconds
hdeg = hh * 30 + mdeg * 0.0833333; // 0-11 -> 0-360 - includes minutes and seconds
hx = cos((hdeg - 90) * 0.0174532925);
hy = sin((hdeg - 90) * 0.0174532925);
mx = cos((mdeg - 90) * 0.0174532925);
my = sin((mdeg - 90) * 0.0174532925);
sx = cos((sdeg - 90) * 0.0174532925);
sy = sin((sdeg - 90) * 0.0174532925);
if (ss == 0 || initial) {
// Kazdou minutu mazte pozice hodinove a minutove rucicky
tft.drawLine(ohx, ohy, 65, 65, TFT_BLACK);
ohx = hx * 33 + 65;
ohy = hy * 33 + 65;
tft.drawLine(omx, omy, 65, 65, TFT_BLACK);
omx = mx * 44 + 65;
omy = my * 44 + 65;
tft.drawCentreString(to2dig(hh)+":"+to2dig(mm), 64, 180, 6);
initial = false;
}
// Prekresleni nove pozice (hod a min rucicky nejsou vymazany, aby se zabranilo blikani
tft.drawLine(osx, osy, 65, 65, TFT_BLACK);
tft.drawLine(ohx, ohy, 65, 65, TFT_WHITE);
tft.drawLine(omx, omy, 65, 65, TFT_WHITE);
osx = sx * 47 + 65;
osy = sy * 47 + 65;
tft.drawLine(osx, osy, 65, 65, TFT_RED);
tft.fillCircle(65, 65, 3, TFT_RED);
}
}
Test kódu
Kód překopírujeme do prostředí Arduino IDE, ve kterém musíme nastavit správnou vývojovou desku. POZOR na to! Pokud jsme doteď používali „standardní“ vývojovou desku s ESP32, měli jsme zřejmě nastavenou desku typu „ESP32 DEV Module“. Nyní však používáme desku ESP32 TTGO s OLED displejem, musíme tedy v seznamu desek typu ESP32 vyhledat desku typy TTGO-OLED (např. TTGO-LoRa32-OLED). Po úspěšném přeložení kódu a jeho nahrání do modulu TTGO bychom měli na displeji modulu získat obrázek hodin, jako je znázorněno na následujícím obrázku č. 2.
Obrázek 2 – Modul TTGO s OLED displejem použitý jako jednoduché hodiny.
Na obrázku č. 2 vidíme modul napájený prostřednictvím USB kabelu (mimochodem tento modul je oproti starším kitům s modulem ESP32 osazen USB konektorem typu C). Napájení USB kabelem není moc praktické pro nějaké přenosné použití. 😕 Ale v úvodu jsme si říkali, že na rubové straně modulu TTGO je konektor pro LiPo(l) baterii – viz obrázek č. 3. Můžeme tedy připojit LiPo(l) akumulátor a rázem máme mobilní hodiny, se kterými můžeme vyrazit do světa. Pravda design zatím není nic moc, ale možná právě tato minimalistická surovost bude to, co ostatní „bastlíře“ nadchne!
Obrázek 3 – Modul TTGO s OLED disponuje konektorem pro připojení LiPo(l) baterie.
Závěr:
V dnešním článku jsme se snad trochu odpoutali od suché teorie, ve které jsme stále jen ukazovali nové a nové vlastnosti modulu ESP32. Představili jsme si poměrně zajímavý kit, který je oproti klasickým deskám s modulem ESP32 osazený OLED displejem, dvěma programovatelnými tlačítky, konektorem USB-C a konektorem pro externí akumulátor. Je pravda, že díky tomu, že jsme si museli zejména ovládání displeje trochu představit, nějaké té teorii jsme se přeci jen nevyhnuli, ale tak už to bývá – jakmile začneme pracovat na konkrétním projektu začínají se objevovat nové a nové věci a problémy, které je třeba nastudovat a vyřešit. Ale jedině tak, se člověk něco nového naučí. Už sám Démokritos říkal, že vzdělání má sice hořké kořeny, ale sladké ovoce. Tak ať Vám to ovoce jménem: „užitečné znalosti o modulu ESP32“ opravdu chutná a slouží ku zdraví!