ESP32 a iTAG: Probouzíme k životu Bluetooth klíčenku za 40 Kč
Technologie Bluetooth, a zvláště Bluetooth Low Energy (BLE), nepatří zrovna mezi bastlíři k těm úplně nejoblíbenějším. Na první pohled se totiž může zdát, že celá její struktura, hierarchie GATT profilů, abstrakce služeb a charakteristik i asynchronní obsluha komunikace jsou zbytečně složité a nepřehledné. Na druhou stranu, když procházíme různé čínské e-shopy a narážíme na záplavu nejrůznějších dostupných Bluetooth „kravinek“ za pár korun, správného bastlíře to prostě musí provokovat. Touha podívat se těmto bezdrátovým hračkám na (Modrý)zoubek a přimět je k poslušnosti musí přece být silnější než strach z nějakých BLE specifikací. I když někdy opravdu mohou být trochu „ble“…
Typickým zástupcem z kategorie „za hubičku“ je malý BLE lokátor (chytrá klíčenka) iTAG, který lze na internetu sehnat přibližně za 40–100 Kč. Uvnitř se přitom skrývá hotový bezdrátový prvek vybavený tlačítkem, piezo bzučákem, LED diodou a běžná napájecí knoflíková baterie CR2032. Pro každého nadšence do modulu ESP32 to je skvělá výzva! Dokážeme modul ESP32 přimět k tomu, aby vystupoval v roli BLE klienta (Central) a třeba iTAG v okolí automaticky vyhledal, připojil se k němu, sledoval stisky jeho tlačítka a v případě potřeby na něm spustil hlasitý alarm?
Pojďme to zkusit…
- Poznámka úvodem:
- V tomto článku se nebudeme zdržovat opakovaným vysvětlováním základních principů komunikace BT/BLE, architektury GATT nebo podrobností o tom, jak fungují služby a charakteristiky. Tyto teoretické základy i nízkoúrovňový popis jsme detailně probrali v předchozích článcích:
nebo:
Pokud si potřebujete osvěžit tyto znalosti nebo zopakovat, jak se v BLE světe vyznat, doporučujeme tyto články prostudovat.
Nyní půjdeme rovnou „tvrdě“ po praktickém využití iTAGu v prostředí Arduino IDE s využitím standardní knihovny BLEDevice.h. Postupně se krok za krokem dopracujeme k finálnímu programu – přehlednému stavovému automatu, který z ESP32 vytvoří spolehlivou základnu pro vlastní iTAG alarm.
Od Apple AirTagu až po iTAG za 40 Kč
Když se podíváte na trh s Bluetooth lokátory a chytrými přívěšky, zjistíte, že je nabídka opravdu pestrá. Můžeme je rozdělit do několika základních kategorií:
- Drahé a sofistikované lokátory (např. Apple AirTag) – Tyto přívěšky využívají pokročilé šifrování, šrokopásmovou technologii (UWB) a rozsáhlé uzavřené sítě (jako je síť Apple Find My). Jsou sice neuvěřitelně přesné a designové, ale pro bastlířské pokusy s ESP32 zcela nevhodné a uživatelsky uzamčené.
- Standardní lokalizační majáky (Beacons/iBeacon) – Zařízení vysílající v pravidelných intervalech identifikátory (tzv. advertising). Slouží především pro pasivní určování polohy v budovách, indoor navigaci nebo marketingové účely.
- Levné obousměrné BLE klíčenky (iTAG a jeho klony) – A právě o ty nám nyní jde především! Za cenu kolem 40 Kč získáte plnohodnotné BLE zařízení v plastové krabičce s kroužkem na klíče, které v sobě ukrývá tlačítko, piezo bzučák, indikační LED a držák na běžnou knoflíkovou baterii CR2032.
Je třeba zdůraznit, že každý výše uvedený typ Bluetooth přívěšku je něčím specifický a ovládá se trochu jinak. My si ukážeme postup, jak si „proklepnout“ a ovládnout jednoduchý ten nejjednodušší iTAG.
První seznámení s iTAGem a aplikace pro telefon
V balení iTAGu kromě samotného BT prvku najdete i malý letáček s QR kódem. Ten odkazuje na mobilní aplikaci pro Android nebo iOS (často se jmenuje iSearching nebo nějak podobně). Aplikace slouží k tomu, aby klíčenka pípala, když ji hledáte přes mobil, nebo aby stisk tlačítka na klíčence spustil zvonění telefonu či vyfotil snímek.
Tovární aplikaci je dobré vyzkoušet vlastně jen jednou – abyste ověřili, že baterie v iTAGu není vybitá a hardware (bzučák a tlačítko) funguje. Pro náš projekt ji ale nadále vůbec nepotřebujeme. Naším cílem je přece nahradit chytrý telefon mikrokontrolérem ESP32!
Jediná aplikace, kterou si na svůj telefon opravdu nainstalujeme (a která by neměla chybět ve výbavě řádného bastlíře pracujícího s BLE), je nRF Connect for Mobile od společnosti Nordic Semiconductor. S její pomocí nyní pronikneme přímo do GATT struktury iTAGu.
Vnitřní struktura GATT iTAGu pod drobnohledem
Když iTAG zapneme (dlouhým stiskem tlačítka, až pípne) a v aplikaci nRF Connect stiskneme tlačítko  SCAN  a následně tlačítko  CONNECT , objeví se před námi kompletní databáze služeb (Services) a charakteristik (Characteristics).
Pro náš ukázkový program na ESP32 budou klíčové především tři následující služby:
Služba baterie (Battery Service)
- UUID služby:
0x180F(standardní SIG UUID) - Charakteristika:
0x2A19(Battery Level) - Funkce: Umožňuje načíst aktuální stav baterie CR2032 v procentech (0–100 %). ESP32 tak může po připojení ihned ověřit, zda klíčenka nepotřebuje novou baterii.
- UUID služby:
Služba okamžitého alarmu (Immediate Alert Service)
- UUID služby:
0x1802(standardní SIG UUID) - Charakteristika:
0x2A06(Alert Level) - Vlastnost: Zápis bez odezvy (Write Without Response)
- Funkce: Slouží k dálkovému spuštění a vypnutí piezo bzučáku na iTAGu.
- Zápisem bajtu
0x02(High Alert) aktivujeme hlasité pípání iTAGu. - Zápisem bajtu
0x00(No Alert) alarm vypneme.
- Zápisem bajtu
- UUID služby:
Vlastní služba tlačítka (Simple Key/
Button Service) - UUID služby:
0xFFE0(vlastní vendor-specific UUID) - Charakteristika:
0xFFE1(Button State) - Vlastnost: Notifikace (Notify)
- Funkce: Jakmile na iTAGu stisknete fyzické tlačítko, tato charakteristika pošle připojenému klientovi (našemu ESP32) notifikaci.
- Hodnota
0x01(případně0x02) značí stisknuté tlačítko. - Hodnota
0x00značí uvolněné tlačítko.
- Hodnota
- Poznámka: Abychom tyto notifikace od iTAGu přijímali, musím nejprve do jejího deskriptoru CCCD (
0x2902) zapsat hodnotu0x0100. (s tím si ještě v závěru užijeme „legraci“)
- UUID služby:
Koncept ukázkového programu řízení iTAGu
Aby byl náš kód v prostředí Arduino IDE přehledný, stabilní a dobře udržovatelný, postavíme ho na konceptu konečného stavového automatu (Finite State Machine). Koho koncept tzv. konečného stavového automatu (FSM) překvapil, nechť si přečte článek: Programujeme ESP32 jako stavový automat (FSM).
Místo složitého a nepřehledného kódu si tak chování modulu ESP32 rozdělíme do několika jasných stavů:
STATE_– ESP32 skenuje okolí a hledá iTAG.SCANNING STATE_– iTAG byl nalezen, navazuje se spojení.CONNECTING STATE_– Spojení je aktivní, čtou se data a čeká se na stisk tlačítka.CONNECTED STATE_– Probíhá poplachová sekvence.ALARM
V první fázi se zaměříme výhradně na první dva stavy – jak iTAG v okolí najít, připojit se k němu a jak přečíst jeho základní údaje (MAC adresu a stav baterie).
Vyhledání, připojení a načtení baterie
Následující kód předvádí základní kostru skenování a připojení k iTAGu v Arduino IDE za použití standardní knihovny BLEDevice.h:
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEClient.h>
// UUID Služeb a charakteristik
static BLEUUID buttonServiceUUID((uint16_t)0xFFE0);
static BLEUUID batteryServiceUUID((uint16_t)0x180F);
static BLEUUID batteryCharUUID((uint16_t)0x2A19);
// Definice stavů
enum SystemState {
STATE_SCANNING,
STATE_CONNECTING,
STATE_CONNECTED
};
static SystemState currentState = STATE_SCANNING;
static BLEAddress *pServerAddress = nullptr;
static BLEClient *pClient = nullptr;
static String deviceName = "Neznámý iTAG";
// Callback při nalezení BLE zařízení
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
void onResult(BLEAdvertisedDevice advertisedDevice) {
String devName = advertisedDevice.haveName() ? advertisedDevice.getName().c_str() : "<bez jmena>";
bool isITagByName = advertisedDevice.haveName() &&
(devName.equalsIgnoreCase("iTAG") ||
devName.equalsIgnoreCase("iTag") ||
devName.equalsIgnoreCase("ITAG"));
bool isITagByService = advertisedDevice.haveServiceUUID()
&& advertisedDevice.isAdvertisingService(buttonServiceUUID);
if ((isITagByName || isITagByService) && currentState == STATE_SCANNING) {
Serial.println(">>> Našel jsem iTAG, zastavuji sken a přecházím k připojení... <<<");
BLEDevice::getScan()->stop();
if (pServerAddress != nullptr) delete pServerAddress;
pServerAddress = new BLEAddress(advertisedDevice.getAddress());
deviceName = devName;
currentState = STATE_CONNECTING;
}
}
};
bool connectToServer() {
Serial.printf("\n--- Připojování k MAC: %s ---\n", pServerAddress->toString().c_str());
pClient = BLEDevice::createClient();
if (!pClient->connect(*pServerAddress)) {
Serial.println("X CHYBA: Připojení selhalo!");
return false;
}
Serial.println("OK: Připojeno k iTAGu.");
// Načtení stavu baterie
BLERemoteService* pBatteryService = pClient->getService(batteryServiceUUID);
if (pBatteryService != nullptr) {
BLERemoteCharacteristic* pBatteryChar = pBatteryService->getCharacteristic(batteryCharUUID);
if (pBatteryChar != nullptr && pBatteryChar->canRead()) {
uint8_t batteryLevel = pBatteryChar->readUInt8();
Serial.printf("[BATERIE] Stav baterie: %d %%\n", batteryLevel);
}
}
return true;
}
void setup() {
Serial.begin(115200);
Serial.println("\nStartuji ESP32 BLE Client...");
BLEDevice::init("ESP32_Master");
BLEScan* pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setInterval(100);
pBLEScan->setWindow(99);
pBLEScan->setActiveScan(true);
}
void loop() {
switch (currentState) {
case STATE_SCANNING:
BLEDevice::getScan()->start(5, false);
BLEDevice::getScan()->clearResults();
break;
case STATE_CONNECTING:
if (connectToServer()) {
Serial.println("==================================================");
Serial.println(">>> iTAG ÚSPĚŠNĚ PŘIPOJEN! <<<");
Serial.printf(" - Název zařízení: %s\n", deviceName.c_str());
Serial.printf(" - MAC Adresa: %s\n", pServerAddress->toString().c_str());
Serial.println("==================================================");
currentState = STATE_CONNECTED;
} else {
currentState = STATE_SCANNING;
}
break;
case STATE_CONNECTED:
// Zde budeme v příští části obsluhovat tlačítko a alarm
break;
}
delay(20);
}
Popis funkce kódu:
- Aktivní skenování a detekce: V metodě
setup()inicializujeme BLE skener a nastavíme mu aktivní skenování (set). To zajišťuje, že ESP32 získá i doplňující pakety se jménem zařízení.Active Scan(true)
BLEDevice::getScan()->start(5, false);
BLEDevice::getScan()->clearResults();
- Rozpoznání iTAGu: V třídě
Mykontrolujeme každé nalezené zařízení. iTAG identifikujeme buď podle jeho názvu (Advertised Device Callbacks "iTAG") nebo podle toho, zda inzeruje službu tlačítka0xFFE0. Jakmile jej najdeme, skenování ihned zastavíme a uložíme si jeho MAC adresu (pServerAddress).
bool isITagByName = advertisedDevice.haveName() &&
(devName.equalsIgnoreCase("iTAG") ||
devName.equalsIgnoreCase("iTag") ||
devName.equalsIgnoreCase("ITAG"));
bool isITagByService = advertisedDevice.haveServiceUUID() &&
advertisedDevice.isAdvertisingService(buttonServiceUUID);
:
:
:
if ((isITagByName || isITagByService) && currentState == STATE_SCANNING) {
Serial.println(">>> Našel jsem iTAG, zastavuji sken a přecházím k připojení... <<<");
BLEDevice::getScan()->stop();
if (pServerAddress != nullptr) delete pServerAddress;
pServerAddress = new BLEAddress(advertisedDevice.getAddress());
- Navázání spojení a načtení baterie: Ve funkci
connectvytvoříme BLE klienta. Po úspěšném připojení vyhledáme službu baterieToServer() 0x180Fa její charakteristiku0x2A19. MetodoureadUInt8()z ní přečteme hodnotu v procentech, kterou vypíšeme na sériový monitor.
bool connectToServer() {
Serial.printf("\n--- Připojování k MAC: %s ---\n", pServerAddress->toString().c_str());
pClient = BLEDevice::createClient();
if (!pClient->connect(*pServerAddress)) {
Serial.println("X CHYBA: Připojení selhalo!");
return false;
}
Serial.println("OK: Připojeno k iTAGu.");
// Načtení stavu baterie
BLERemoteService* pBatteryService = pClient->getService(batteryServiceUUID);
if (pBatteryService != nullptr) {
BLERemoteCharacteristic* pBatteryChar = pBatteryService->getCharacteristic(batteryCharUUID);
if (pBatteryChar != nullptr && pBatteryChar->canRead()) {
uint8_t batteryLevel = pBatteryChar->readUInt8();
Serial.printf(" [BATERIE] Stav baterie: %d %%\n", batteryLevel);
}
}
return true;
}
Následující obrázek č. 4 ukazuje výstup výše uvedeného programu – tedy vyhledání iTAGu, připojení a načtení MAC a stavu baterie.
- Bastlířská odbočka:
- K čemu tento základ využít? Už tento jednoduchý vyhledávací a připojovací kód otevírá prostor pro řadu praktických projektů v domácnosti i dílně, například:
- Automatický docházkový/přítomnostní systém – ESP32 umístěné u vchodových dveří může pravidelně ověřovat přítomnost vašich klíčů s iTAGem. Když dorazíte domů, ESP32 vás rozpozná a může například odemknout elektronický zámek nebo rozsvítit světlo na chodbičce.
- Bezdrátový imobilizér pro motocykl či auto – ESP32 vestavěné v motocyklu blokuje zapalování. Motor půjde nastartovat pouze tehdy, pokud je v těsné blízkosti přítomen váš iTAG na klíčích od zapalování.
- Důležitá poznámka:
- Rádiový přenos BLE může být v reálném prostředí ovlivněn rušením, překážkami nebo náhlým poklesem signálu. Detekce nepřítomnosti iTAGu by proto nikdy neměla reagovat okamžitě při prvním neúspěšném skenu. Program by měl vyhodnotit odchod uživatele (nebo ztrátu klíčenky) až po několikátém po sobě jdoucím neúspěšném pokusu o připojení. Předejdete tak falešným poplachům a zbytečnému vypínání zařízení.
Pokud jsme zvládli první dva stavy našeho budoucího hlavního programu, můžeme se hned vrhnou na ty další.
Obsluha tlačítka – Notifikace a deskriptor CCCD
Při bezdrátové komunikaci s tlačítkem narážíme na klasický problém – jak se o jeho stisku dozvědět a jak to udělat bez zbytečného zdržení? Neustálé dotazování v cyklu (polling) by zbytečně zahltilo bezdrátové pásmo i procesor modulu ESP32. Řešením jsou BLE Notifikace (Notify), kdy iTAG sám aktivně odešle zprávu v okamžiku, kdy fyzicky stisknete jeho tlačítko. Abychom však tyto zprávy z iTAGu začali přijímat, nestačí charakteristiku tlačítka pouze najít. V BLE
architektuře musíme zařízením explicitně potvrdit, že notifikace chceme odebírat. K tomu slouží speciální deskriptor zvaný CCCD (Client Characteristic Configuration Descriptor) se standardním UUID 0x2902. Teprve poté, co ESP32 zapíše do tohoto deskriptoru dvoubajtovou hodnotu 0x0100 ({0x01, 0x00}), iTAG interně aktivuje notifikační obvod.
Registrace notifikací a callback funkce
Příjem notifikací zrealizujeme pomocí tzv. callback funkce, která se automaticky zavolá na pozadí pokaždé, když z iTAGu dorazí nový paket o stavu tlačítka.
Prvním krokem je registrace notifikací ve funkci connect po úspěšném připojení k iTAGu:
// 1. Vyhledání služby tlačítka (0xFFE0) a charakteristiky (0xFFE1)
BLERemoteService* pButtonService = pClient->getService(buttonServiceUUID);
if (pButtonService != nullptr) {
BLERemoteCharacteristic* pButtonChar = pButtonService->getCharacteristic(buttonCharUUID);
if (pButtonChar != nullptr && pButtonChar->canNotify()) {
// Registrace naší callback funkce
pButtonChar->registerForNotify(buttonNotifyCallback);
// Zápis hodnoty 0x0100 do CCCD deskriptoru (0x2902) pro aktivaci notifikací
BLERemoteDescriptor* pCCCD = pButtonChar->getDescriptor(BLEUUID((uint16_t)0x2902));
if (pCCCD != nullptr) {
uint8_t notifyOn[] = {0x01, 0x00};
pCCCD->writeValue(notifyOn, 2, true);
Serial.println("[OK] Notifikace tlačítka aktivovány."); class="pb"
}
}
}
Sami si pak nadefinujeme obslužnou callback funkci button, která zpracuje příchozí bajty z iTAGu:
// Callback volaný automaticky při příjmu notifikace z iTAGu
static void buttonNotifyCallback(BLERemoteCharacteristic* pBLERemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify) {
if (length > 0) {
uint8_t state = pData;
if (state == 0x01 || state == 0x02) { // Tlačítko STISKNUTO
if (currentState == STATE_CONNECTED) {
// Krátce rozsvítíme vestavěnou LED na ESP32 (na 300 ms) jako vizuální odezvu
digitalWrite(LED_PIN, HIGH);
isLedActive = true;
ledTurnOffTime = millis() + 300;
// Inkrementujeme počítadlo stisků
buttonPressCount++;
Serial.printf(">>> [Tlačítko STISKNUTO] Celkem stisků: %d / 10 <<<\n", buttonPressCount);
}
} else if (state == 0x00) { // Tlačítko UVOLNĚNO
if (currentState != STATE_ALARM) {
digitalWrite(LED_PIN, LOW);
}
isLedActive = false;
Serial.println("-> [Tlačítko UVOLNĚNO]");
}
}
}
Jak registrace a obsluha tlačítka funguje?
- Aktivace CCCD deskriptoru: Při volání
pCCCDpošle ESP32 do iTAGu požadavek na zapnutí notifikací. Bez tohoto zápisu by iTAG o stiscích tlačítka mlčel.-> writeValue( notifyOn, 2, true) - Dešifrování stavu: iTAG posílá v prvním bajtu přijatých dat (
pData) hodnotu0x01(případně0x02podle typu klonu) při stisknutí a0x00při uvolnění tlačítka. - Neblokující vizuální odezva: Abychom měli okamžitou kontrolu nad funkčností, při stisku tlačítka rozsvítíme na ESP32 vestavěnou LED
na pinu
GPIO2. Nepoužíváme ale žádné blokujícídelay(), ale časovač založený namillis()(ledTurn).OffTime = millis() + 300 - Čítač stisků: Každý platný stisk navýší čítač
button. Jakmile počítadlo dosáhne stanoveného limitu (v našem ukázkovém programu 10 stisků), stavový automat to vyhodnotí a přejde do stavu spuštění alarmu – viz podmínka v cykluPress Count++ loop()dále.
Doplnění stavu STATE_CONNECTED v hlavní smyčce loop()
Aby výše popsaný princip fungoval i v naší koncepci stavového automatu, v hlavní smyčce loop() ve stavu STATE_ budeme pouze udržovat neblokující zhasínání LED a budeme sledovat, zda jsme nedosáhli limitu stisků pro spuštění alarmu:
case STATE_CONNECTED:
// Neblokující zhasnutí LED po 300 ms od stisku tlačítka
if (isLedActive && millis() > ledTurnOffTime) {
digitalWrite(LED_PIN, LOW);
isLedActive = false;
}
// Při dosažení 10 stisků přejdeme do stavu ALARM
if (buttonPressCount >= 10) {
Serial.println(">>> Dosaženo 10 stisků! Přecházím do stavu ALARM... <<<");
// Zde v příští části aktivujeme piezo bzučák na iTAGu
currentState = STATE_ALARM;
}
break;
Aktivace alarmu – spuštění bzučáku na iTAGu (stav STATE_ALARM )
V předchozích částech jsme si ukázali, jak iTAG najít, připojit se k němu, přečíst stav baterie a přijímat notifikace o stisku tlačítka. Nyní tuto logiku naší ukázky uzavřeme. Jakmile čítač stisků dosáhne hodnoty 10, ESP32 přejde do stavu STATE_, což bude znamenat, že dálkově aktivuje bzučák na iTAGu a rozbliká svoji vestavěnou LED.
K ovládání bzučáku využijeme standardní službu Immediate Alert Service (0x1802) a její charakteristiku 0x2A06.
Příprava charakteristiky alarmu a pomocná funkce setAlarm()
Už při připojování v metodě connectToServer() si vyhledáme službu alarmu a uložíme si odkaz na její charakteristiku do ukazatele pAlertChar:
// Příprava charakteristiky alarmu (0x1802 -> 0x2A06)
BLERemoteService* pAlertService = pClient->getService(alertServiceUUID);
if (pAlertService != nullptr) {
pAlertChar = pAlertService->getCharacteristic(alertCharUUID);
if (pAlertChar != nullptr) {
Serial.println("[OK] Alarm charakteristika připravena.");
}
}
Pro samotné zapnutí a vypnutí alarmu si vytvoříme jednoduchou pomocnou funkci setAlarm(:
- Zápis bajtu
0x02(High Alert) dopAlertChar– iTAG spustí hlasité pípání piezo bzučáku. - Zápis bajtu
0x00(No Alert) dopAlertChar– alarm se utiší.
/**
* @brief Řídí alarm na iTAGu.
* @param enable true = spustit (0x02), false = vypnout (0x00)
*/
void setAlarm(bool enable) {
if (pAlertChar != nullptr) {
uint8_t alertVal = enable ? 0x02 : 0x00; // 0x02 = High Alert, 0x00 = No Alert
pAlertChar->writeValue(&alertVal, 1, true);
if (enable) {
Serial.println("\n>>> [ALARM] SPUŠTĚN! (Bude pípat 15 sekund) <<<");
} else {
Serial.println("\n>>> [ALARM] VYPNUT! Čítač tlačítka vynulován. <<<");
Serial.println("Můžete znovu mačkat tlačítko...\n");
}
} else {
Serial.println("[X] Chyba: pAlertChar je NULL!");
}
}
Přechod do stavu STATE_ALARM a jeho neblokující obsluha
V hlavní smyčce loop() ve stavu STATE_ sledujeme, zda čítač stisků button nedosáhl hodnoty 10. Pokud ano, zavoláme setAlarm(, uložíme si počáteční čas spuštění alarmu (alarm) a přepneme stavový automat do STATE_:
case STATE_CONNECTED:
// Neblokující zhasnutí LED po krátkém stisku tlačítka (300 ms)
if (isLedActive && millis() > ledTurnOffTime) {
digitalWrite(LED_PIN, LOW);
isLedActive = false;
}
// Při dosažení 10 stisků přejdeme do stavu ALARM
if (buttonPressCount >= 10) {
Serial.println(">>> Přecházím do stavu ALARM <<<");
setAlarm(true);
alarmStartTime = millis();
lastLedBlinkTime = millis();
alarmLedState = true;
digitalWrite(LED_PIN, HIGH);
currentState = STATE_ALARM;
}
break;
Ve stavu STATE_ pak probíhají dvě činnosti paralelně a opět zcela bez použití zpožďujícího delay():
- Rychlé blikání LED na modulu ESP32 (v intervalu 250 ms) jako optická signalizace právě probíhajícího poplachu.
- Časovač trvání alarmu (15 sekund = 15
000 ms). Po uplynutí této doby vypneme alarm na iTAGu ( setAlarm(), zhasneme LED, vynulujeme čítač stiskůfalse) buttona vrátíme se zpět do stavuPressCount = 0 STATE_.CONNECTED
case STATE_ALARM:
// 1. Neblokující blikání LED na ESP32 (interval 250 ms)
if (millis() - lastLedBlinkTime >= 250) {
lastLedBlinkTime = millis();
alarmLedState = !alarmLedState;
digitalWrite(LED_PIN, alarmLedState ? HIGH : LOW);
}
// 2. Vypršení alarmu po 15 sekundách (15000 ms)
if (millis() - alarmStartTime >= 15000) {
setAlarm(false);
digitalWrite(LED_PIN, LOW);
alarmLedState = false;
buttonPressCount = 0;
Serial.println(">>> Alarm ukončen, vracím se do stavu CONNECTED <<<");
currentState = STATE_CONNECTED;
}
break;
Tím máme kompletně vyřešenou logiku stavového automatu i obsluhu bzučáku na klíčence iTAG.
Detekce odpojení
V naší bastlířské odbočce jsme zmiňovali dvě možné inspirace pro možné aplikace iTAGu. Obě počítaly s tím, že se v blízkosti modulu ESP32 objeví zadaný iTAG, ale měli bychom počítat i s tím, že zmizí. Pojďme se tedy podívat na otázku: Co se stane, když se iTAG ztratí z dosahu?
V klasickém sériovém nebo drátovém rozhraní poznáme přerušení vodiče okamžitě. V rozhraní Bluetooth Low Energy udržuje spojení mezi klientem (ESP32) a serverem (iTAG) spojovací interval (Connection Interval) a tzv. Supervisory Timeout. Pokud iTAG po stanovenou dobu neodpoví na potvrzovací pakety z ESP32, bezdrátový zásobník BLE vyhodnotí spojení jako přerušené.
Na straně ESP32 musíme na tuto situaci zareagovat tak, aby kód „nezamrzl“ ve stavu STATE_ nebo STATE_, ale bezpečně přešel zpět k hledání.
V knihovně BLEDevice.h máme k dispozici metodu pClient, která vrací stav aktuálního BLE spojení. V hlavní smyčce loop() zařadíme kontrolu ještě před samotný přepínač stavů switch (currentState).
void loop() {
// Kontrola nečekané ztráty spojení během provozu nebo alarmu
if ((currentState == STATE_CONNECTED || currentState == STATE_ALARM) &&
(pClient == nullptr || !pClient->isConnected())) {
Serial.println("\n[X] Spojení přerušeno (iTAG je mimo dosah nebo vypnut)!");
Serial.println("Vracím se do stavu SCANNING...\n");
// Zhasneme LED a resetujeme čítač stisků
digitalWrite(LED_PIN, LOW);
isLedActive = false;
buttonPressCount = 0;
// Návrat k automatickému skenování okolí
currentState = STATE_SCANNING;
}
// Samotný stavový automat...
switch (currentState) {
// ...
}
delay(20);
}
Co se stane po odpojení?
- Okamžitá detekce: Jakmile spojení padne (
!pClient), ESP32 vypíše varování na sériový monitor.-> isConnected() - Bezpečný reset: Vypneme indikaci LED a vynulujeme čítač stisků tlačítka.
- Automatická obnova spojení: Přepnutím do stavu
STATE_začne ESP32 v hlavní smyčceSCANNING loop()opět automaticky skenovat okolí. Jakmile se s iTAGem vrátíte do dosahu (nebo ho znovu zapnete), ESP32 jej zachytí, naváže spojení, načte baterii a pokračuje v provozu bez nutnosti cokoliv restartovat.
- Bastlířský tip: (Filtrování krátkodobých výpadků signálu)
- Pokud byste náš kód stavěli například jako zmiňovaný docházkový systém nebo bezpečnostní alarm, vyplatí se počítat s tím, že BLE signál může na zlomek sekundy vypadnout (např. při průchodu kovu kolem přijímače). V takovém případě je vhodné vyhodnotit stav „iTAG je opravdu pryč“ až ve chvíli, kdy se ESP32 nepodaří zařízení znovu najít ani po několika po sobě jdoucích skenovacích cyklech (např. po dobu 30 sekund). Opět tím předejdete planým poplachům a nechtěným spínáním relé.
Kompletní kód:
Nyní máme všechny potřebné stavební kameny: skenování okolí, bezpečné připojení, načtení stavu baterie, příjmy notifikací přes deskriptor CCCD, neblokující obsluhu bzučáku i ošetření náhlé ztráty signálu.
Všechny tyto funkce jsme propojili do jednoho přehledného skriptu pro Arduino IDE, který je postaven na zmíněném stavovém automatu. Kód nevyužívá žádná blokující zpoždění (delay()), takže ESP32 reaguje na stisky tlačítka okamžitě a spolehlivě.
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEClient.h>
#define LED_PIN 2
// STANDARDNÍ A VLASTNÍ BLE UUID
static BLEUUID alertServiceUUID((uint16_t)0x1802);
static BLEUUID alertCharUUID((uint16_t)0x2A06);
static BLEUUID buttonServiceUUID((uint16_t)0xFFE0);
static BLEUUID buttonCharUUID((uint16_t)0xFFE1);
static BLEUUID batteryServiceUUID((uint16_t)0x180F);
static BLEUUID batteryCharUUID((uint16_t)0x2A19);
// DEFINICE STAVŮ STAVOVÉHO AUTOMATU
enum SystemState {
STATE_SCANNING,
STATE_CONNECTING,
STATE_CONNECTED,
STATE_ALARM
};
// JEDINÁ HLAVNÍ STAVOVÁ PROMĚNNÁ
static SystemState currentState = STATE_SCANNING;
// GLOBÁLNÍ PROMĚNNÉ PRO BLE A TLAČÍTKO
static BLEAddress *pServerAddress = nullptr;
static BLEClient* pClient = nullptr;
static BLERemoteCharacteristic* pAlertChar = nullptr;
static String deviceName = "Neznámý iTAG";
static int buttonPressCount = 0;
// ČASOVAČE (millis) PRO NEBLOKUJÍCÍ ŘÍZENÍ
static unsigned long ledTurnOffTime = 0;
static bool isLedActive = false;
// ČASOVAČE A INTERVALY PRO ALARM A BLIKÁNÍ LED
static unsigned long alarmStartTime = 0;
static const unsigned long ALARM_DURATION = 15000; // Doba trvání alarmu (15 sekund)
static unsigned long lastLedBlinkTime = 0;
static const unsigned long LED_BLINK_INTERVAL = 250; // Interval blikání LED na ESP32 (250 ms)
static bool alarmLedState = false;
/**
* @brief Řídí alarm na iTAGu.
* @param enable true = spustit (0x02), false = vypnout (0x00)
*/
void setAlarm(bool enable) {
if (pAlertChar != nullptr) {
uint8_t alertVal = enable ? 0x02 : 0x00; // 0x02 = High Alert, 0x00 = No Alert (Vypnuto)
pAlertChar->writeValue(&alertVal, 1, true);
if (enable) {
Serial.println("\n>>> [ALARM] SPUŠTĚN! (Bude pípat 15 sekund) <<<");
} else {
Serial.println("\n>>> [ALARM] VYPNUT! Čítač tlačítka vynulován. <<<");
Serial.println("Můžete znovu mačkat tlačítko...\n");
}
} else {
Serial.println(" [X] Chyba: pAlertChar je NULL!");
}
}
/**
* @brief Callback volaný při stisku tlačítka.
*/
static void buttonNotifyCallback(
BLERemoteCharacteristic* pBLERemoteCharacteristic,
uint8_t* pData,
size_t length,
bool isNotify) {
if (length > 0) {
uint8_t state = pData[0];
if (state == 0x01 || state == 0x02) { // Tlačítko stisknuto
// V běžném stavu (mimo alarm) krátce rozsvítíme LED při stisku
if (currentState == STATE_CONNECTED) {
digitalWrite(LED_PIN, HIGH);
isLedActive = true;
ledTurnOffTime = millis() + 300;
buttonPressCount++;
Serial.printf(">>> [Tlačítko STISKNUTO] Celkem: %d / 10 <<<\n", buttonPressCount);
} else if (currentState == STATE_ALARM) {
Serial.println("-> [Tlačítko STISKNUTO] (Alarm již běží, stisky se nepočítají)");
}
} else if (state == 0x00) { // Tlačítko uvolněno
if (currentState != STATE_ALARM) {
digitalWrite(LED_PIN, LOW);
}
isLedActive = false;
Serial.println("-> [Tlačítko UVOLNĚNO]");
}
}
}
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
void onResult(BLEAdvertisedDevice advertisedDevice) {
String devName = advertisedDevice.haveName() ? advertisedDevice.getName().c_str() : "<bez jmena>";
bool isITagByName = advertisedDevice.haveName() &&
(devName.equalsIgnoreCase("iTAG") ||
devName.equalsIgnoreCase("iTag") ||
devName.equalsIgnoreCase("ITAG"));
bool isITagByService = advertisedDevice.haveServiceUUID() &&
advertisedDevice.isAdvertisingService(buttonServiceUUID);
if ((isITagByName || isITagByService) && currentState == STATE_SCANNING) {
Serial.println(" >>> Našel jsem iTAG, zastavuji sken a přecházím k připojení... <<<");
BLEDevice::getScan()->stop();
if (pServerAddress != nullptr) {
delete pServerAddress;
}
pServerAddress = new BLEAddress(advertisedDevice.getAddress());
deviceName = devName;
// Přechod do stavu připojování
currentState = STATE_CONNECTING;
}
}
};
bool connectToServer() {
Serial.printf("\n--- Připojování k MAC: %s ---\n", pServerAddress->toString().c_str());
pClient = BLEDevice::createClient();
if (!pClient->connect(*pServerAddress)) {
Serial.println("X CHYBA: Připojení selhalo!");
return false;
}
Serial.println("OK: Připojeno k iTAGu.");
// Vyčtení baterie
BLERemoteService* pBatteryService = pClient->getService(batteryServiceUUID);
if (pBatteryService != nullptr) {
BLERemoteCharacteristic* pBatteryChar = pBatteryService->getCharacteristic(batteryCharUUID);
if (pBatteryChar != nullptr && pBatteryChar->canRead()) {
uint8_t batteryLevel = pBatteryChar->readUInt8();
Serial.printf(" [BATERIE] Stav baterie: %d %%\n", batteryLevel);
}
}
// Příprava charakteristiky alarmu
BLERemoteService* pAlertService = pClient->getService(alertServiceUUID);
if (pAlertService != nullptr) {
pAlertChar = pAlertService->getCharacteristic(alertCharUUID);
if (pAlertChar != nullptr) {
Serial.println(" [OK] Alarm charakteristika připravena.");
}
}
// Aktivace notifikací tlačítka
BLERemoteService* pButtonService = pClient->getService(buttonServiceUUID);
if (pButtonService != nullptr) {
BLERemoteCharacteristic* pButtonChar = pButtonService->getCharacteristic(buttonCharUUID);
if (pButtonChar != nullptr && pButtonChar->canNotify()) {
pButtonChar->registerForNotify(buttonNotifyCallback);
BLERemoteDescriptor* pCCCD = pButtonChar->getDescriptor(BLEUUID((uint16_t)0x2902));
if (pCCCD != nullptr) {
uint8_t notifyOn[] = {0x01, 0x00};
pCCCD->writeValue(notifyOn, 2, true);
Serial.println(" [OK] Notifikace tlačítka aktivovány.");
}
}
}
return true;
}
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
Serial.println("\nStartuji ESP32 BLE Client...");
BLEDevice::init("ESP32_Master");
BLEScan* pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setInterval(100);
pBLEScan->setWindow(99);
pBLEScan->setActiveScan(true);
}
void loop() {
// Kontrola ztráty spojení během provozu
if ((currentState == STATE_CONNECTED || currentState == STATE_ALARM) &&
(pClient == nullptr || !pClient->isConnected())) {
Serial.println("\n[X] Spojení přerušeno (iTAG je mimo dosah nebo vypnut)!");
Serial.println("Vracím se do stavu SCANNING...\n");
// Zhasneme LED a resetujeme čítač stisků
digitalWrite(LED_PIN, LOW);
isLedActive = false;
buttonPressCount = 0;
currentState = STATE_SCANNING;
}
// REÁLNÝ STAVOVÝ AUTOMAT
switch (currentState) {
case STATE_SCANNING:
// Spuštění skenování pokud ještě neběží
BLEDevice::getScan()->start(5, false);
BLEDevice::getScan()->clearResults();
break;
case STATE_CONNECTING:
if (connectToServer()) {
Serial.println("\n==================================================");
Serial.println(">>> iTAG ÚSPĚŠNĚ PŘIPOJEN! <<<");
Serial.printf(" - Název zařízení: %s\n", deviceName.c_str());
Serial.printf(" - MAC Adresa: %s\n", pServerAddress->toString().c_str());
Serial.println("==================================================");
Serial.println("Mačkejte tlačítko na iTAGu...\n");
buttonPressCount = 0;
currentState = STATE_CONNECTED;
} else {
Serial.println("X Připojení selhalo. Vracím se ke skenování...");
currentState = STATE_SCANNING;
}
break;
case STATE_CONNECTED:
// Neblokující zhasnutí LED po krátkém stisku tlačítka (300 ms)
if (isLedActive && millis() > ledTurnOffTime) {
digitalWrite(LED_PIN, LOW);
isLedActive = false;
}
// Při dosažení 10 stisků přejdeme do stavu ALARM
if (buttonPressCount >= 10) {
Serial.println(">>> Přecházím do stavu ALARM <<<");
setAlarm(true);
alarmStartTime = millis();
lastLedBlinkTime = millis();
alarmLedState = true;
digitalWrite(LED_PIN, HIGH);
currentState = STATE_ALARM;
}
break;
case STATE_ALARM:
// 1. Neblokující blikání LED na ESP32 (interval 250 ms)
if (millis() - lastLedBlinkTime >= LED_BLINK_INTERVAL) {
lastLedBlinkTime = millis();
alarmLedState = !alarmLedState;
digitalWrite(LED_PIN, alarmLedState ? HIGH : LOW);
}
// 2. Neblokující vypršení alarmu po 15 sekundách
if (millis() - alarmStartTime >= ALARM_DURATION) {
setAlarm(false);
digitalWrite(LED_PIN, LOW);
alarmLedState = false;
buttonPressCount = 0;
Serial.println(">>> Alarm ukončen, vracím se do stavu CONNECTED <<<");
currentState = STATE_CONNECTED;
}
break;
}
delay(20);
}
Jak program otestovat
Pro kompilaci kódu nám postačí standardní balíček desek ESP32 (Arduino ESP32 Core). Žádné externí BLE knihovny instalovat nemusíte – knihovna BLEDevice.h je již přímou součástí nastavení desek ESP32. Pro nahrání přeloženého programu do modulu ESP32 musíme jen zvolit správnou vývojovou desku (např. ESP32 Dev Module) a COM port, ke kterému je modul připojen. Po nahrání programu do modulu ESP32 otevřeme sériový monitor v prostředí Arduino IDE a nastavíme rychlost komunikace na 115200 baudů.
Zapneme iTAG dlouhým stiskem tlačítka (až pípne). Na sériovém monitoru uvidíme, jak modul ESP32 klíčenku během pár sekund zachytí, vypíše její MAC adresu i stav baterie. S každým stiskem tlačítka se krátce rozsvítí LED na ESP32 a navýší se čítač počtu zmáčknutí. Při desátém stisku modul ESP32 spustí v iTAGu hlasitý alarm, který po 15 sekundách opět vypne.
Průběh zkoušky ukazuje následující výpis sériového monitoru prostředí Arduino IDE:
Dalo by se říci, že máme hotovo. Před samotným závěrem dnešního článku si však dovolíme zařadit ještě jednu (a myslíme, že důležitou) část.
iTAG – Web Bluetooth API & nesmlouvavý Chrome
Pokud jste četli předchozí článek Ovládání přes Web Bluetooth, možná vás v průběhu čtení článku o iTAGu napadla kacířská myšlenka: „Nebylo by možné zahodit ESP32 i Arduino IDE a napsat si jednoduchou HTML stránku s JavaScriptem, ze které bych iTAG ovládal přímo z webového prohlížeče v počítači nebo mobilu?“
Teoreticky vzato by to mělo fungovat skvěle. Web Bluetooth rozhraní v prohlížečích založených na jádře Chromium (Google Chrome, Microsoft Edge, Opera) umožňuje webovým aplikacím skenovat BLE zařízení, připojovat se k jejich GATT profilům a číst i zapisovat jejich charakteristiky. Ale je tu to pověstné ALE! V praxi u těchto nejlevnějších iTAGů za 40 Kč narazíte na nepříjemný háček, kvůli kterému notifikace tlačítka přes Web Bluetooth nerozchodíte. V čem je problém?
Kámen úrazu jménem CCCD
Jak jsme si vysvětlili výše, aby nám iTAG posílal notifikace o stisku tlačítka, musíme nejprve zapsat aktivační bajty do deskriptoru CCCD (0x2902). A právě v tomto místě se projevuje zásadní rozdíl mezi mikrokontrolérem ESP32 a webovým prohlížečem:
- Modul ESP32 pošle požadavek na zápis do
CCCDdeskriptoru a na samotnou specifikaci odpovědi iTAGu tak trochu „kašle“. I když levný čip uvnitř iTAGu neodpoví zcela podle rigorózní BLE specifikace (nebo pošle mírně nestandardní potvrzení), C++ knihovna v ESP32 tento přešlap toleruje a notifikace normálně přijímá a zpracovává. - Naopak vývojáři prohlížeče Chrome implementovali BLE specifikaci velmi striktně – Chrome je v tomto smyslu doslova „pěkný pedant“. Když v JavaScriptu zavoláte metodu
characteristic, prohlížeč se pokusí o standardní nízkoúrovňový zápis do deskriptoru.start Notifications() CCCDa nekompromisně vyžaduje 100% předpisovou odpověď. Levný firmware iTAGu však tento protokoly vyžadovaný nízkoúrovňový handshake nezvládne vrátit korektně.
Proč? To nevíme, na to se zeptejte v Číně. Při pohledu do GATT struktury to dokonce trochu vypadá, že tam tato charakteristika prostě úplně chybí!
Prohlížeč však takovou situaci okamžitě odmítne a vyhodí výjimku (typickyGATT operation failedneboOperation Not Permitted).
Co to pro nás znamená?
Pokud byste se pokusili iTAG obsluhovat přes Web Bluetooth API z webové stránky, počítejte s následujcí situací:
- Načtení baterie (
0x180F->0x2A19) bude fungovat bez problémů (jednoduché čtení projde). - Spuštění alarmu (
0x1802->0x2A06) bude také fungovat (přímý zápis hodnoty 0x02 do bzučáku projde). - Příjem stisku tlačítka (
0xFFE0->0xFFE1) selže už při samém úvodním nastavení, protože Chrome odmítne aktivovat notifikace přes nekompatibilně odpovídajícíCCCDdeskriptor. (Jen pozor, při běhu JavaScriptu se to ani nemusíme dozvědět, program běží dál a předešlé funkce normálně fungují.)
Rázem vidíme obrovskou nevýhodu přílišné dokonalosti Web Bluetooth API. Naopak modul ESP32 je za těchto podmínek pro tyto levné klíčenky doslova ideálním partnerem. Na rozdíl od upjatého a pedantského Chromu totiž dokáže s velkorysým nadhledem přimhouřit oko nad drobnými hardwarovými nedokonalostmi a prohřešky levných čipů.
A buďme k sobě upřímní – přesně o tom přece to pravé a spokojené partnerství bývá, ne? O schopnosti tolerovat malé chybičky a táhnout za jeden provaz i tam, kde ostatní při prvním náznaku nekompatibility okamžitě vyvolají scénu, zabalí kufry a hodí vám na hlavu chybovou výjimku. 😉
ESP32 zkrátka drží, odpouští a tím pádem i funguje!
Závěr:
Kód a postupy, které jsme si v tomto článku ukázali, samozřejmě nejsou žádné dogma. Určitě by šlo vymyslet podporu pro více iTAGů současně, odesílání stavů přes Wi-Fi a MQTT na domácí server nebo rovnou celý propracovaný docházkový systém. To už by ale bylo na jeden článek moc a rádi to necháme na vaší vlastní fantazii.
Tento článek berte především jako odrazový můstek a praktický zdroj informací pro vaše vlastní projekty. V rukách teď máte kompletní funkční základ:
- Automatické vyhledání a identifikaci iTAGu v okolí,
- spolehlivé připojení a načtení stavu baterie,
- detekci odpojení při ztrátě signálu a návrat ke skenování,
- příjem stisků tlačítka pomocí BLE notifikací a
CCCDdeskriptoru, - dálkové spuštění a vypnutí alarmu zapsáním do charakteristiky bzučáku.
Nic dalšího vlastně ani nepotřebujete.
Cílem celého tohoto článku bylo též ukázat, že i na první pohled bláznivý nápad – vzít tu nejlevnější Bluetooth klíčenku z internetu a ovládnout ji pomocí ESP32 – není vůbec nerealizovatelný projekt. S modulem ESP32 se z takového projektu jistě rázem stane skvělá zábava.
Tedy pokud za zábavu považujeme i ty bezesné noci nad nefunkčním kódem, kdy se člověk marně ptá, proč ty notifikace stále nechodí! 😕
Ale ten pocit, když to pak všechno zaklapne a funguje přesně tak, jak má… To už je ale jen a jen na vás!