Bluetooth bezpečnostní rizika: Jak se chránit před skrytými hrozbami

Bluetooth se stal součástí našeho každodenního života – od připojení sluchátek po synchronizaci chytrých hodinek. Tato neviditelná technologie však skrývá vážná bezpečnostní rizika, která mohou ohrožovat naše osobní data i soukromí.

Skrytá hrozba v kapse

Bluetooth technologie dnes běží na miliardách zařízení po celém světě. Její všudypřítomnost a schopnost navazovat spojení na dálku z ní však činí atraktivní cíl pro útočníky. Na rozdíl od tradičních kybernetických útoků, které vyžadují aktivní účast uživatele, mohou Bluetooth exploity zasáhnout bez jakékoliv interakce ze strany oběti.

Bezpečnostní experti varují, že i zdánlivě neškodné zapnutí Bluetooth může vystavit zařízení útoku. Stačí být ve špatnou chvíli na špatném místě – například v kavárně, na letišti nebo na zastávce.

BlueBorne a BrakTooth: Reálné hrozby současnosti

Mezi nejznámější Bluetooth exploity patří BlueBorne, poprvé detailně popsaný v roce 2017 výzkumníky ze společnosti Armis Labs. Tento typ útoku umožňuje útočníkovi získat přístup k zařízení přes aktivní Bluetooth bez nutnosti párování nebo jakékoliv akce uživatele.

BlueBorne původně ohrožoval přes 8,2 miliardy Bluetooth zařízení na platformách Android, iOS, Linux i Windows. Ačkoliv byl v mnoha systémech opraven, princip útoku zůstává aktuální i v roce 2025.

Novějším příkladem je BrakTooth – skupina zranitelností zveřejněná v roce 2021, která dokázala způsobit vše od odmítnutí služby až po vzdálené spuštění kódu na cílových zařízeních.

Jak útoky fungují

Problém nespočívá v konkrétních aplikacích, ale v samotném Bluetooth stacku – způsobu, jak zařízení spravují bezdrátové spojení. Pokud obsahuje bezpečnostní díru, může útočník pomocí speciálně upraveného signálu:

• Získat neautorizovaný přístup do systému
• Spustit škodlivý kód
• Proniknout na další zařízení v okolí
• Ukrást citlivá data

Dosah útoku je omezen pouze dosahem Bluetooth signálu – typicky 10 až 30 metrů.

Proč jste stále v ohrožení

Trvalá připravenost: Většina uživatelů má Bluetooth zapnutý 24/7 kvůli připojeným sluchátkům, chytrým hodinkám nebo dalším gadgetům. Tato permanentní dostupnost poskytuje útočníkům neustálou příležitost.

Zastaralé systémy: Miliony zařízení v Česku stále běží na starších verzích Androidu (verze 8 a nižší) nebo používají levnější hardware s neaktualizovaným Bluetooth softwarem.

Zero-click útoky: Vývoj směřuje k útokům, které nevyžadují žádnou interakci uživatele – Bluetooth je pro tyto techniky ideálním nosičem.

Praktická ochrana

Efektivní ochrana proti Bluetooth útokům nevyžaduje technické znalosti, ale důslednost:

Vypínejte Bluetooth, když ho nepotřebujete – zejména v noci a na veřejných místech. Znemožníte tím útočníkům vyhledávat vaše zařízení.

Udržujte systém aktuální – bezpečnostní záplaty jako ty pro BlueBorne jsou účinné pouze u aktualizovaných zařízení.

Omezte viditelnost – zkontrolujte nastavení, aby vaše zařízení nebylo trvale viditelné pro ostatní.

Kontrolujte oprávnění aplikací – nepovolujte přístup k Bluetooth aplikacím, které ho skutečně nepotřebují.

Buďte opatrní při párování – nepřipojujte se k neznámým zařízením, která mohou napodobovat legitimní hardware.

Používejte Bluetooth selektivně – zvažte jeho použití pouze doma nebo v autě, nikoliv na veřejnosti.

Závěr

Bluetooth není nutné se bát, ale stejně jako u Wi-Fi nebo hesel platí základní pravidlo: bezpečnost začíná u správného nastavení a rozumného používání. S rostoucím počtem připojených zařízení a vývojem nových útočných technik se preventivní opatření stávají klíčovými pro ochranu našich digitálních životů.

Jednoduché změny v chování a nastavení mohou dramaticky snížit riziko a zajistit, že Bluetooth zůstane užitečným nástrojem, nikoliv bezpečnostní hrozbou.

The post Bezpečnostní rizika Bluetooth first appeared on Hard Wired.

MeshCore: Revoluce v off-grid komunikaci prostřednictvím LoRa mesh sítí

Představte si situaci: bouře vyřadí mobilní věže, internet je nedostupný, klasické komunikační kanály selhávají. Právě v takových chvílích oceníte technologie, které fungují nezávisle na centralizované infrastruktuře. A přesně to je oblast, kde se MeshCore etabluje jako game-changer.

V posledních letech jsme svědky dramatického růstu zájmu o decentralizované komunikační systémy. Ať už jde o přírodní katastrofy, výpadky infrastruktury, nebo jednoduše potřebu komunikace v odlehlých oblastech, tradiční řešení často selhávají právě tehdy, kdy je potřebujeme nejvíce. Zde vstupuje do hry mesh networking - technologie, která umožňuje zařízením komunikovat přímo mezi sebou, vytvářet samoléčící se sítě a poskytovat komunikační kanály tam, kde žádné neexistují.

MeshCore reprezentuje novou generaci této technologie. Zatímco jeho starší bratr Meshtastic si získal obrovskou popularitu a přinesl mesh networking do povědomí širší veřejnosti, zároveň odkryl některé fundamentální problémy škálovatelnosti. Právě tyto výzvy se MeshCore rozhodl řešit od základů - s čistším designem, efektivnějším routingem a architekturou pripravenou na budoucnost.

Problém s přetížením sítí: Zatímco populární Meshtastic trpí problémy se zahlcováním sítě kvůli své architektuře, MeshCore přináší elegantní řešení těchto problémů od samého počátku.

Co je MeshCore?

MeshCore je multiplatformní systém umožňující bezpečnou textovou komunikaci využívající LoRa rádiový hardware. Jde o lightweight, open-source C++ knihovnu vytvořenou pro umožnění mesh networkingu přes LoRa a další packet-based rádia.

Hlavní charakteristiky MeshCore zahrnují:

Multi-hop packet routing - zařízení mohou předávat zprávy přes více uzlů, rozšiřuje dosah nad rámec jednoho rádia. Systém podporuje konfigurovatelný počet hopů pro vyvážení efektivity sítě.

Decentralizovaná architektura - nevyžaduje centrální server ani internet; síť je self-healing, což znamená, že pokud jeden uzel selže nebo se dostane mimo dosah, MeshCore najde alternativní cestu.

Nízká spotřeba energie - ideální pro zařízení napájená z baterií nebo solárních panelů, což umožňuje dlouhodobé nasazení v odlehlých oblastech.

Proč vznikl MeshCore?

Problémy Meshtastic

Ačkoliv se Meshtastic stal velmi populárním (v České republice bylo registrováno přes 1110 zařízení), přinesl to i problémy:

Zahlcení sítě: Radiokomunikační pásmo 868 MHz se rychle zahltilo kvůli architektuře, kdy se každá zpráva šíří z každého bodu na všechny dostupné body. Meshtastic ve skupině 10 zařízení funguje dobře, ale ve skupině stovek zařízení už zprávy často nedorazí nebo nedorazí potvrzení.

Neefektivní provoz: Každá krabička se spojí s každou, což vytváří zbytečný síťový provoz a degraduje celkový výkon sítě.

Problém s aktualizacemi: I když Meshtastic verze 2.6 slibuje vylepšení, musela by se nainstalovat na všechna existující zařízení - což u tisíců zařízení na stožárech a těžko přístupných místech představuje obrovský problém.

Použití a aplikace

MeshCore nachází uplatnění v široké škále scénářů:
Může být použit pro off-grid komunikaci, emergency response & disaster recovery, outdoor aktivity. Systém umožňuje zůstat v kontaktu i v odlehlých oblastech bez pokrytí mobilní sítě.

Taktické a bezpečnostní aplikace

Taktická bezpečnost včetně práva a pořádku a soukromé bezpečnosti - MeshCore poskytuje šifrovanou komunikaci pro profesionální použití.

IoT a senzorové sítě

Také IoT senzorové sítě - systém dokáže efektivně přenášet data ze vzdálených senzorů zpět do centrálního místa.

Technické specifikace

Architektura a vývojové prostředí

MeshCore je lightweight, portable C++ knihovna určená pro vývojáře, kteří chtějí vytvářet resilientní, decentralizované komunikační sítě bez internetu. Na rozdíl od Meshtastic, který je přizpůsoben pro casual LoRa komunikaci, nebo Reticulum s pokročilým networkingem, MeshCore balancuje jednoduchost se škálovatelností.

Vývojové možnosti:

• Pro koncové uživatele - předkompilované firmware k přímému flashování
• Pro vývojáře - otevřená C++ knihovna pro custom embedded řešení
• MIT licence - volné použití pro osobní i komerční projekty

Podporovaná zařízení

MeshCore podporuje širokou škálu LoRa hardware:

• Heltec - V3 LoRa Boards, T114, V2
• RAK Wireless - RAK4631 (nejúspornější varianta)
• LilyGo - T3S3, TLora32 v1.6
• Xiaomi - XiaoS3 WIO (sx1262 combo), XiaoC3 (plus externí sx126x modul)
• Sensecap - T1000e
• Station G2

V České republice můžete zařízení zakoupit u specializovaných distributorů elektronických komponent jako je Pájeníčko.

Protokol a routing

MeshCore funguje jako mesh knihovna v jazyce C++ i jako hotový firmware, který stačí nahrát do podporovaného zařízení. Systém vytváří self-organizing mesh síť, kde každý uzel udržuje routing tabulku a může předávat pakety jménem ostatních uzlů.

Klíčové funkce routingu:

• Flood a path memory - první soukromou zprávu posílá jako Flood, jakmile je zpráva doručena, zapamatuje si její cestu a pak ji posílá jen přes zapamatované uzly
• Fixed path routing - možnost ručně nastavit cesty pro zprávy, což vede ke spolehlivějšímu doručení ve složitějších topologiích
• Automatické routing - pokud doručení selže, posílá se znovu Flood
• Multi-hop routování - zprávy mohou cestovat přes více uzlů
• Rozlišení rolí - klient nebo router jsou oddělené role, routery jen přeposílají packety bez zbytečných funkcí

MeshCore vs. konkurence

Porovnání s Meshtastic

Zatímco Meshtastic je nejpopulárnějším off-grid messaging řešením, MeshCore nabízí několik klíčových výhod a nevýhod:

Výhody MeshCore:

• Vyšší flexibilita - díky otevřené knihovně mohou vývojáři tvořit specifická síťová řešení
• Vylepšené routování - možnost ručně nastavit cesty nebo využít efektivnější fixed path routing
• Méně zahlcení sítě - menší objem status provozu, výhodné v rozsáhlých sítích
• MIT licence - umožňuje použití i v komerčních projektech
• Strukturovanější přístup s pokročilými síťovými funkcemi jako static path optimalizace
• Oddělené role - routery jsou jen routery, klienti jen klienti
• Store-and-forward messaging - ukládání zpráv pro offline příjemce (mailbox funkce)
• Čistě mesh komunikace - žádné internetové propojení, funguje i bez elektriky jen se solárním napájením

Nevýhody MeshCore:

• Menší komunita - méně uživatelské podpory a návodů (ale rychle rostoucí)
• Statické role - nelze dynamicky měnit role uzlů bez reflashe firmware
• Menší podpora hardware - zatím podporuje méně zařízení než Meshtastic
• Chybí MQTT integrace - zaměřuje se čistě na mesh komunikaci bez internetového rozhraní
• Nekompatibilita - sdílí stejné frekvenční pásmo s Meshtastic, ale nejsou navzájem kompatibilní

Referenční aplikace

MeshCore nabízí několik předkompilovaných firmware typů:

Companion Radio - pro použití s externí chat aplikací přes BLE, USB nebo WiFi s podporou pro:

• Web aplikace - app.meshcore.nz
• Android aplikace - dostupná v Google Play Store
• iOS aplikace - dostupná v App Store
• NodeJS a Python - pro vývojáře a automatizaci

Simple Repeater - rozšiřuje pokrytí sítě předáváním zpráv, konfigurovatelný přes web config tool nebo mobilní aplikaci

Simple Room Server - jednoduchý BBS server pro sdílené příspěvky a store-and-forward messaging

Simple Secure Chat - bezpečná terminálová textová komunikace přímo mezi zařízeními

Boom MeshCore v České republice

Červenec 2025 se stal přelomovým měsícem pro MeshCore v České republice. 20. července 2025 se Ještěd přepnul na MeshCore, což spustilo lavinu dalších nasazení.

Rychlý růst sítě

Následovalo nasazení MeshCore na klíčových místech:

• Říp - strategické místo pro severní Čechy
• Klínovec - nejvyšší hora Krušných hor
• Další menší vysílače po celé republice

Za pouhý týden se pokrytí dramaticky zlepšilo a aktivita ukazuje, že trend pokračuje.

Česká komunita

Vznikl specializovaný komunitní web meshcore.cz s návody, tipy a triky. Telegram skupina meshcore_cz rychle roste a sdružuje nadšence po celé republice.

Klíčové výhody oproti Meshtastic v ČR:

• Funkčnost - na rozdíl od přetížené Meshtastic sítě MeshCore skutečně funguje
• Méně telemetrie - síť není zahlcená zbytečnými daty
• Čistě offline - žádné internetové propojení, skutečná nezávislost
• Solární napájení - funguje i bez elektrické sítě, jen se slunečním svitem

Doporučené nastavení pro ČR

Česká komunita se domluvila na těchto parametrech:

• Frekvence: 869.525 MHz
• Bandwidth: 62.5 kHz
• Spreading Factor: 7
• Coding Rate: 5
• Transmit Power: 22

Praktické nasazení v ČR

1. Získání hardware - doporučujeme Heltec LoRa v3.1, dostupný u specializovaných distributorů jako je Pájeníčko
2. Flashování firmware - využijte webový flasher na https://flasher.meshcore.co.uk/
   • Vyberte podporované zařízení
   • Zvolte typ firmware (Companion, Repeater, Room Server)
   • Klikněte FLASH
3. Připojení klientů:
   • Web aplikace - app.meshcore.nz (funguje offline)
   • Mobilní aplikace - Android/iOS z oficiálních obchodů
   • Bluetooth pairing - PIN zobrazený na OLED displeji zařízení
4. Kontrola pokrytí - mapa uzlů dostupná na https://map.meshcore.dev/

Důležité upozornění: Žádné zařízení s konektorem pro externí anténu nesmí být spuštěno bez připojené antény - hrozí zničení vysílací části čipu.

Zdroje pro českou komunitu

• Oficiální web: https://meshcore.co.uk/
• Česká stránka: https://meshcore.cz/
• GitHub repository: https://github.com/ripplebiz/MeshCore
• Webový flasher: https://flasher.meshcore.co.uk/
• Web aplikace: https://app.meshcore.nz
• Telegram skupina: @meshcore_cz
• Discord komunita: Andy Kirby's Discord pro podporu vývojářů
• Mapa uzlů: https://map.meshcore.dev/
• FAQ a dokumentace: GitHub wiki s detailními návody

Vzdělávací videa a tutoriály

Andy Kirby YouTube kanál - klíčový zdroj pro pochopení MeshCore:

• MeshCore Intro Video - základní úvod do systému pro začátečníky
• Messaging System Tutorial - návod na používání komunikačního systému
• MeshCore Update série - pravidelné aktualizace o vývoji projektu
• Praktické testování - reálné testy dosahu a funkčnosti v terénu

Andy Kirby byl instrumental v getting projects known out there a pro helping educate people s jeho videi. Jeho videa poskytují praktické návody od základního nastavení až po pokročilé konfigurace repeaterů.

Doporučené sledování: Začněte s Intro Video, poté pokračujte tutoriály pro messaging systém a sledujte nejnovější update videa pro informace o vývoji.

Vývojářské možnosti

Pro pokročilé uživatele a vývojáře:

• PlatformIO a Visual Studio Code - kompletní vývojové prostředí
• Open-source - MIT licence umožňuje modifikace a komerční použití
• Příspěvky do projektu - PR požadavky přes 'dev' branch na GitHubu
• Bug reporting - GitHub Issues pro hlášení chyb a feature požadavky

Závěr

MeshCore představuje významný krok vpřed v oblasti decentralizované komunikace a v České republice už není jen teoretickou možností - je tu a funguje. Červencový boom ukázal, že česká komunita je připravena na alternativu k přetíženému Meshtastic.

Zatímco Meshtastic bojuje s problémy škálovatelnosti a čeká na nasazení verze 2.6 na tisíce existujících zařízení, MeshCore nabízí řešení těchto problémů od počátku. Jeho open-source povaha, nízké požadavky na energii, pokročilé mesh routing schopnosti a především funkčnost v reálném provozu z něj činí atraktivní volbu pro každého, kdo hledá spolehlivé off-grid komunikační řešení.

S rostoucím pokrytím a aktivní komunitou je MeshCore v České republice připraven stát se dominantní platformou pro decentralizovanou komunikaci. Jak říkají nadšenci: "Meshtastic je mrtev, ať žije MeshCore!"

The post MeshCore: Off-grid komunikaci prostřednictvím LoRa mesh sítí first appeared on Hard Wired.

ESP32: Backdooru v populárním čipu

Úvod

V posledních dnech se odbornou i laickou veřejností šířily znepokojivé zprávy o možném backdooru v čipu ESP32 od čínské společnosti Espressif. Vzhledem k tomu, že těchto čipů bylo celosvětově distribuováno přibližně miliarda kusů a nacházejí se v širokém spektru IoT zařízení, vyvolala tato informace značné obavy. Následující analýza objasňuje, co se skutečně zjistilo a proč se nejedná o závažné bezpečnostní riziko.

Co je ESP32?

ESP32 představuje tzv. "system on chip" (SoC) - kompletní mikrokontrolér integrovaný v jediném čipu o rozměrech přibližně 8×8 mm. Při maloobchodní ceně kolem 50 Kč nabízí mimořádný výkon a funkcionalitu:

• Velké množství vstupně-výstupních (GPIO) pinů pro připojení senzorů a ovládacích prvků
• Integrovanou podporu Wi-Fi a Bluetooth pro snadné připojení do sítě
• Podporu komunikačních standardů jako SPI, I2C, CAN-BUS a další
• Vynikající dokumentaci a vývojářskou podporu
• Příznivý poměr cena/výkon

Díky těmto vlastnostem se ESP32 stal dominantním čipem v oblasti IoT zařízení, chytrých domácností a řady dalších aplikací. Jeho hlavními konkurenty jsou některé čipy od Texas Instruments a pravděpodobně Raspberry Pi Pico 2TV.

Co bylo skutečně objeveno?

Na konferenci Rootcon konané 6.-8. března v Madridu prezentovali dva španělští výzkumníci objev nedokumentovaných příkazů v čipu ESP32. Tyto příkazy umožňují provádět některé nízkoúrovňové operace jako zápis do paměti nebo odesílání specifických Bluetooth paketů.

Je důležité zdůraznit, že existence nedokumentovaných příkazů je v hardwarových i softwarových řešeních běžná. Většina komplexnějších systémů obsahuje interní pomocné rutiny a metody, které nejsou určeny pro koncové uživatele, ale slouží k vnitřnímu fungování systému, ladění a podobným účelům.

Proč se nejedná o bezpečnostní riziko?

Klíčovým faktem je, že k využití těchto nedokumentovaných příkazů musí mít útočník již plnou kontrolu nad zařízením. To znamená:

1. Fyzický přístup k zařízení - Pro nahrání vlastního kódu do ESP32 je často nutné zařízení fyzicky rozebrat a připojit se k UART pinům na základní desce.

2. Překonání bezpečnostních mechanismů - ESP32 umožňuje implementaci kontroly digitálního podpisu firmware, kdy čip odmítne spustit kód, který není podepsán správným klíčem.

3. Harvardská architektura jako ochrana - Na rozdíl od běžných počítačů s von Neumannovou architekturou používá ESP32 harvardskou architekturu s oddělenou pamětí pro kód a data, což znesnadňuje spuštění škodlivého kódu.

Jak došlo k nedorozumění?

Společnost Tarlogic, mateřská organizace zmíněných výzkumníků, vydala původně bombastickou tiskovou zprávu hovořící o "ohrožení stovek milionů IoT zařízení". Tuto zprávu převzal server Bleeping Computer, který v titulku navýšil počet potenciálně ohrožených zařízení na miliardy. Následně se informace lavinovitě šířila dalšími médii.

Po bližším prozkoumání problematiky byly původní články staženy a přeformulovány, aby lépe odrážely skutečnou závažnost situace. Nicméně, původní senzační zprávy už stihly vyvolat značné obavy.

https://www.tarlogic.com/news/hidden-feature-esp32-chip-infect-ot-devices/
https://www.bleepingcomputer.com/news/security/undocumented-commands-found-in-bluetooth-chip-used-by-a-billion-devices/

Závěr

Používání čipu ESP32 je nadále bezpečné. Přítomnost nedokumentovaných příkazů nepředstavuje sama o sobě bezpečnostní riziko, protože k jejich využití je nutná plná kontrola nad zařízením, což by útočníkovi umožnilo i mnohem závažnější zásahy do systému bez ohledu na existenci těchto příkazů.

Bezpečnost zařízení s ESP32 závisí primárně na kvalitě jejich návrhu:

• Zařízení, která byla navržena s důrazem na bezpečnost, zůstávají bezpečná i nadále
• Zařízení s bezpečnostními nedostatky byla zranitelná již před tímto objevem

Uživatelé zařízení s ESP32 mohou tedy pokračovat v jejich používání bez obav a vývojáři mohou nadále implementovat tento čip do svých konstrukcí.

The post ESP32 neobsahuje backdoor first appeared on Hard Wired.

Rozšíření článku ESP32 Bluetooth Server. Kód vytváří UART BLE server na ESP32 vývojové desce. Bluetooth server se jde připojit pomocí programu Serial Bluetooth Terminal na telefonu se systémem Android, nebo ekvivalentním na iOS.

Bluetooth server reaguje na dva příkazy.

• get
• set <payload>

Příkazem set se do dočasné paměti ukládá textová hodnota payload. Pokud vše proběhne v pořádku, server vrátí do konzole uloženou zprávu.

Příkazem get získáme ze serveru uloženou zprávu. Po poslání uložené zprávy klientovi se zpráva ze serveru smaže.

/**
 * @file main.cpp
 * @author Hard Wired
 * @brief Bluetooth server reagující na příkazy.
 * @version 0.1
 * @date 2023-02-01
 * @details Umožňuje připojení telefonu přes Bluetooth terminal aplikaci a
 *          pomocí příkazu "set <text>" uložit textový řetězec do paměti
 *          Bluetooth serveru. Při úspěšném uložení pošle server zprávu
 *          zpět do konzole na telefonu jako potvrzení. Zpráva v takovém
 *          případě zůstává uložena v paměti serveru.
 *
 *          Při opětovném připojení a zadání příkazu "get" server pošle zpět do
 *          Bluetooth konzole na telefonu uloženou zprávu. Tuto zprávu
 *          následně smaže.
 */

#include <Arduino.h>

// Bluetooth knihovny
#include <BLE2902.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>

// inicializace modulu z knihovny
BLECharacteristic *pCharacteristic;

const String COMMAND_GET = "get";
const String COMMAND_SET = "set";

/**
 * @brief Definuje zda li je klient aktualne pripojeny
 *
 */
bool deviceConnected = false;

/**
 * @brief Flag definující akci odeslat
 *
 */
bool send = false;

/**
 * @brief Flag definující ponechat zprávu uloženou i po odeslání
 *
 */
bool keepMessage = false;

/**
 * @brief Obsahuje zprávu kterou klient pošle serveru
 *
 */
std::string receivedMessage;

/**
 * @brief Zpráva, která se bude odesílat klientovi
 *
 */
String out = "Lorem ipsum";

#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

/**
 * @brief Převede std::string na String objekt.
 *
 * @param message
 * @return String
 */
String convertMessageToString(std::string message)
{
    return String(message.c_str());
}

String normalizeMessage(String message)
{
    message.trim();
    message.toLowerCase();

    return message;
}

/**
 * @brief Zpracovává a ukládá zprávu pro odeslání.
 *
 * @param message
 */
void setOutputMessage(String message)
{
    message.trim();

    out = message;
}

/**
 * @brief Maže zprávu pro odeslání
 *
 */
void clearOutputMessage() { out = ""; }

/**
 * @brief Vrací `payload` příkazu typu `[command] <payload>`.
 *
 * @param str
 * @return String
 */
String getCommandPayload(String str, int spacePosition)
{
    return str.substring(spacePosition + 1, str.length());
}

/**
 * @brief Hledá první mezeru v řetězci. Když nenajde, vraci délku řetězce + 1.
 *
 * @param str
 * @return int
 */
int findCommandPositionIndex(String str)
{
    int spacePosition = 0;
    int length = str.length();

    for (int i = 0; i < length; i++)
    {
        spacePosition = i;

        if (str[i] == ' ')
        {
            return spacePosition;
        }
    }

    return spacePosition + 1;
}

/**
 * @brief Nastaví odchozí zprávu na základě přijatého příkazu SET.
 *
 * @param message
 */
void commandSet(String payload)
{
    keepMessage = true;
    send = true;

    setOutputMessage(payload);
}

/**
 * @brief Nastavi odeslání zprávy klientovi a její následné smazání.
 *
 */
void commandGet()
{
    keepMessage = false;
    send = true;
}

/**
 * @brief Zpracování příkazu zaslaného klientem.
 *
 * @param message
 */
void processCommand(std::string message)
{
    /*
     * Převedení std::string zprávy na String.
     */
    String stringMessage = convertMessageToString(message);

    /*
     * Odstranění mezer na začátku a konci řetězce. Převedení na malá písmena.
     */
    String normalizedMessage = normalizeMessage(stringMessage);

    /*
     * Vyhledá kde v řetězci končí příkaz. Hledá první mezeru :).
     */
    int commandPositionIndex = findCommandPositionIndex(normalizedMessage);

    String command = normalizedMessage.substring(0, commandPositionIndex);

    if (command == COMMAND_GET)
    {
        commandGet();
    }
    else if (command == COMMAND_SET)
    {
        String payload = getCommandPayload(stringMessage, commandPositionIndex);
        commandSet(payload);
    }
}

/**
 * @brief Odešle zprávu přes Bluetooth.
 *
 */
void sendMessage()
{
    /*
     * Úprava pro výstup do terminálové aplikace.
     */
    String txMessage = out + "\n";
    int txMessageLength = txMessage.length() + 1;

    char message[txMessageLength];

    txMessage.toCharArray(message, txMessageLength);

    pCharacteristic->setValue(message);

    pCharacteristic->notify();
}

/**
 * @brief Vytiskne přijatou zprávu do sériové konzole.
 *
 * @param receivedMessage
 */
void printReceivedMessage(std::string receivedMessage)
{
    Serial.print("Prijata zprava: ");

    for (int i = 0; i < receivedMessage.length(); i++)
    {
        Serial.print(receivedMessage[i]);
    }

    Serial.println();
}

/**
 * @brief Connect, disconnect callbacks
 *
 */
class MyServerCallbacks : public BLEServerCallbacks
{
    void onConnect(BLEServer *pServer) { deviceConnected = true; };

    void onDisconnect(BLEServer *pServer)
    {
        deviceConnected = false;
        pServer->getAdvertising()->start();
    }
};

/**
 * @brief Callback zpracovávající příchozí zprávy
 *
 */
class MyCallbacks : public BLECharacteristicCallbacks
{
    void onWrite(BLECharacteristic *pCharacteristic)
    {
        receivedMessage = pCharacteristic->getValue();

        if (receivedMessage.length() > 0)
        {
            printReceivedMessage(receivedMessage);
            processCommand(receivedMessage);
        }
    }
};

void setup()
{
    Serial.begin(115200);

    BLEDevice::init("ESP32 BLE SERVER");

    BLEServer *pServer = BLEDevice::createServer();
    pServer->setCallbacks(new MyServerCallbacks());

    BLEService *pService = pServer->createService(SERVICE_UUID);

    pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
    pCharacteristic->addDescriptor(new BLE2902());

    BLECharacteristic *pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
    pCharacteristic->setCallbacks(new MyCallbacks());

    pService->start();

    pServer->getAdvertising()->start();

    Serial.println("BLE nastaveno, ceka na pripojeni..");
}

void loop()
{
    if (deviceConnected == true && out.length() > 0 && send == true)
    {
        sendMessage();
        delay(100);

        if (keepMessage == false)
        {
            clearOutputMessage();
        }

        send = false;
        keepMessage = false;
    }

    delay(1000);
}

; PlatformIO Project Configuration File
;
;   Build options: build flags, source filter
;   Upload options: custom upload port, speed and extra flags
;   Library options: dependencies, extra library storages
;   Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

The post ESP32 Bluetooth Server – Rozšíření first appeared on Hard Wired.

Dneska se podíváme jak zprovoznit Bluetooth na ESP32. Cílem je umožnit telefonu připojit se na naše Bluetooth zařízení a odpovídat na specifické zprávy. Jako vývojové prostředí použijeme PlatformIO.

ESP32

Pro projekt použijeme ESP32 Development Board z Aliexpressu. V době psaní článku stojí zhruba 120CZK.

platformio.ini

Konfigurační soubor pro projekt.

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

main.cpp

Jako základ kódu jsem použil výborný článek ESP32 a Bluetooth Low Energy (BLE) z Drátek Návody a provedl úpravy pro potřeby projektu. Pro zjednodušení nejprve celý kód projektu. Rozbor bude pokračovat.

#include <Arduino.h>

// Bluetooth knihovny
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

// inicializace modulu z knihovny
BLECharacteristic *pCharacteristic;

// proměnná pro kontrolu připojených zařízení
bool deviceConnected = false;

// proměnná pro ukládání přijaté zprávy
std::string receivedMessage;

// proměnná pro zprávu pro odeslání
String out = "";

// definice unikátních ID pro různé služby,
// pro vlastní UUID využijte generátor
// https://www.uuidgenerator.net/
#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

int compareCommand(std::string message, String command)
{
    String converted = String(message.c_str());
    converted.trim();
    converted.toLowerCase();

    return converted == command;
}

void setOutputMessage(String message)
{
    out = message;
    out += "\n";
}

void clearOutputMessage()
{
    out = "";
}

void sendMessage()
{
    char message[out.length() + 1];
    out.toCharArray(message, out.length() + 1);

    // přepsání zprávy do BLE služby
    pCharacteristic->setValue(message);

    // odeslání zprávy skrze BLE do připojeného zařízení
    pCharacteristic->notify();
}

// třída pro kontrolu připojení
class MyServerCallbacks : public BLEServerCallbacks
{
    // při spojení zařízení nastav proměnnou na log1
    void onConnect(BLEServer *pServer)
    {
        deviceConnected = true;
    };
    // při odpojení zařízení nastav proměnnou na log0
    void onDisconnect(BLEServer *pServer)
    {
        deviceConnected = false;
        pServer->getAdvertising()->start();
    }
};

// třída pro příjem zprávy
class MyCallbacks : public BLECharacteristicCallbacks
{
    // při příjmu zprávy proveď následující
    void onWrite(BLECharacteristic *pCharacteristic)
    {
        // načti přijatou zprávu do proměnné
        receivedMessage = pCharacteristic->getValue();

        // pokud není zpráva prázdná, vypiš její obsah
        // po znacích po sériové lince
        // a pokud přijde očekávaný příkaz pošli odpověď
        if (receivedMessage.length() > 0)
        {
            Serial.print("Prijata zprava: ");
            for (int i = 0; i < receivedMessage.length(); i++)
            {
                Serial.print(receivedMessage[i]);
            }
            Serial.println();

            if (compareCommand(receivedMessage, "ahoj"))
            {
                setOutputMessage("No nazdar");
            }
        }
    }
};

void setup()
{
    // zahájení komunikace po sériové lince
    // rychlostí 115200 baud
    Serial.begin(115200);

    // inicializace Bluetooth s nastavením jména zařízení
    BLEDevice::init("ESP32 BLE");

    // vytvoření BLE serveru
    BLEServer *pServer = BLEDevice::createServer();
    pServer->setCallbacks(new MyServerCallbacks());

    // vytvoření BLE služby
    BLEService *pService = pServer->createService(SERVICE_UUID);

    // vytvoření BLE komunikačního kanálu pro odesílání (TX)
    pCharacteristic = pService->createCharacteristic(
        CHARACTERISTIC_UUID_TX,
        BLECharacteristic::PROPERTY_NOTIFY);
    pCharacteristic->addDescriptor(new BLE2902());

    // vytvoření BLE komunikačního kanálu pro příjem (RX)
    BLECharacteristic *pCharacteristic = pService->createCharacteristic(
        CHARACTERISTIC_UUID_RX,
        BLECharacteristic::PROPERTY_WRITE);
    pCharacteristic->setCallbacks(new MyCallbacks());

    // zahájení BLE služby
    pService->start();

    // zapnutí viditelnosti BLE
    pServer->getAdvertising()->start();
    Serial.println("BLE nastaveno, ceka na pripojeni..");
}

void loop()
{
    if (deviceConnected == true && out.length() > 0)
    {
        sendMessage();
        delay(100);
        clearOutputMessage();
    }

    // pauza před novým během smyčky
    delay(1000);
}

Rozbor kódu

#include <Arduino.h>

// Bluetooth knihovny
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

Knihovny potřebné pro obsluhu Bluetooth.

BLECharacteristic *pCharacteristic;

Inicializace modulu knihovny pro práci s Bluetooth.

bool deviceConnected = false;

Indikace, že je zařízení připojeno k našemu Bluetooth zařízení.

std::string receivedMessage;

Proměnná pro uložení zprávy, kterou pošleme našemu Bluetooth zařízení.

String out = "";

Proměnná pro uložení odchozí zprávy.

#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

Bluetooth se skládá z jednotlivých služeb pro které je mít potřeba vygenerované unikátní identifikátory.

int compareCommand(std::string message, String command)
{
    String converted = String(message.c_str());
    converted.trim();
    converted.toLowerCase();

    return converted == command;
}

Naše Bluetooth zařízení se chová jako server. Pokud mu pošlete zprávu/příkaz, který rozpozná, tak odpoví zpět. Příchozí zpráva se ukládá do proměnné typu std::string. Zprávu je potřeba očistit od bílých znaků, normalizovat (převést na malá písmena ) a porovnat s příkazem, který chceme provést. Tady byl lehce zádrhel, protože vhodné metody obsahuje zase String objekt. Céčko/C++ jsem provozoval naposledy na vysoké pro školní projekty a už tam jsem většinu věcí řešil v Pythonu. Jsem už prostě zmlsaný moderními programovacími jazyky. Mé řešení asi nebude nejefektivnější, ale je lehce čitelné a funguje.

TLDR: compareCommand vezme příchozí zprávu, očistí od bordelu, porovná s námi zadaným příkazem a vrátí hodnotu porovnání.

void setOutputMessage(String message)
{
    out = message;
    out += "\n";
}

Pomocná funkce pro nastavení odchozí zprávy.

void clearOutputMessage()
{
    out = "";
}

Pomocná funkce pro vyčistění proměnné po odeslání zprávy.

void sendMessage()
{
    char message[out.length() + 1];
    out.toCharArray(message, out.length() + 1);

    pCharacteristic->setValue(message);

    pCharacteristic->notify();
}

Funkce zapouzdřující odeslání zprávy. Převede zprávu na pole znaků, předá Bluetooth knihovně a pomocí metody notify odešle na připojené zařízení.

class MyServerCallbacks : public BLEServerCallbacks
{
    void onConnect(BLEServer *pServer)
    {
        zarizeniPripojeno = true;
    };

    void onDisconnect(BLEServer *pServer)
    {
        zarizeniPripojeno = false;
        pServer->getAdvertising()->start();
    }
};

Během testů se objevil problém s opětovným připojením. Když se telefon odpojil od Bluetooth serveru, nešlo se znovu připojit. Pomohl jen restart ESPčka. Dle různých zdrojů za to můžou různé verze knihoven. Pokud přidáme při odpojení zařízení pServer->getAdvertising()->start();, který začne propagovat náš Bluetooth server do prostoru, opětovné připojení funguje.

Třída zapouzdřující callbacky pro náš Bluetooth server. Pokud se zařízení připojí/odpojí nastaví proměnnou deviceConnected.

class MyCallbacks : public BLECharacteristicCallbacks
{
    void onWrite(BLECharacteristic *pCharacteristic)
    {
        receivedMessage = pCharacteristic->getValue();

        if (receivedMessage.length() > 0)
        {
            Serial.print("Prijata zprava: ");
            for (int i = 0; i < receivedMessage.length(); i++)
            {
                Serial.print(receivedMessage[i]);
            }
            Serial.println();

            if (compareCommand(receivedMessage, "ahoj"))
            {
                setOutputMessage("No nazdar");
            }
        }
    }
};

Třída zapouzdřující callback pro příjem zprávy. Při příchozí zprávě nenulové délky se jako první vypíše do sériové konzole. Následně proběhne porovnání jestli obsahuje, pro nás známý, příkaz. V našem případě ahoj. Pokud ano, tak odpoví No nazdar.

setup()

Serial.begin(115200);

Nastavení rychlostí komunikace přes sériovou linku. Musí být stejné jako v platformio.ini.

BLEDevice::init("ESP32 BLE");

Inicializace Bluetooth s nastavením jména, na které se bude dát z telefonu připojit.

BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());

Vytvoření Bluetooth serveru. Nastavíme callbacky pro detekci připojení/odpojení zařízení pomocí třídy nadefinované výše.

BLEService *pService = pServer->createService(SERVICE_UUID);

Vytvoření Bluetooth služby.

pCharacteristic = pService->createCharacteristic(
        CHARACTERISTIC_UUID_TX,
        BLECharacteristic::PROPERTY_NOTIFY);
pCharacteristic->addDescriptor(new BLE2902());

Vytvoření komunikačního kanálu pro odesílání zpráv.

BLECharacteristic *pCharacteristic = pService->createCharacteristic(
        CHARACTERISTIC_UUID_RX,
        BLECharacteristic::PROPERTY_WRITE);
pCharacteristic->setCallbacks(new MyCallbacks());

Vytvoření kanálu pro příjem zpráv. Nastavujeme callback pro příjem nadefinovaný výše.

pService->start();

Nastartování Bluetooth služby.

pServer->getAdvertising()->start();
Serial.println("BLE nastaveno, ceka na pripojeni..");

Zviditelnění pro ostatní zařízení.

loop()

if (deviceConnected == true && out.length() > 0)
{
    sendMessage();
    delay(100);
    clearOutputMessage();
}

delay(1000);

Loop smyčka každou sekundu zkontroluje jestli je zařízení připojené k našemu Bluetooth serveru a jestli existuje zpráva co by šla odeslat. Pokud jsou obě podmínky splněny odešleme zprávu a vyčistíme data.

TLDR

Bluetooth server čeká na zp rávy. Pokud přijde zpráva, která obsahuje známy příkaz, nastaví se příslušné proměnné. Smyčka loop každou sekundu zkontroluje jestli jsou příslušné proměnné pro odchozí zprávu a pokud ano odešle zprávu na připojené zařízení. No raketová věda to teda není.

Serial Bluetooth Terminal

Kód je zkompilovaný, nahraný na ESP32 a běží. Teď je potřeba začít s naším Bluetooth zařízením komunikovat. Pro Android jde použít výbornou aplikaci Serial Bluetooth Terminal. Umí to co potřebujeme. Připojit se k zařízení, posílat a obdržet zprávy.

Po instalaci se v obrazovce Devices přepněte do tabu Bluetooth LE a naskenujte zařízení. Objeví se naše ESPčko. Kliknutím na něj se připojíte.

Pokud připojení proběhne v pořádku zobrazí se následující.

Po odeslání zprávy ahoj dostaneme odpověď.

Závěr

Prezentovaný kód je takové minimum, bez hlubší znalosti Bluetooth a jeho vnitřního fungování, které ověřuje koncept ESP32 jako Bluetooth serveru odpovídajícího na příkazy.

Happy coding.

The post ESP32 Bluetooth Server first appeared on Hard Wired.