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.

Základní přehled ESPček, už tak v tom může být docela guláš.

Varianty

SoC

• System on a Chip
• integráče
• pro velkovezíry

Moduly

• Připravené SoC v modulu
• stíněné
• certifikace FCC
• pro výrobce a hobíky

Dev Kity

• vývojová deska s modulem nebo SoC
• vyvedený piny
• konektory
• a další fičury
• pro vývojáře a hobíky

Převodníky USB na UART

CP2102

• Silicon Labs
• 1Mbps
• podpora Win, macOS, Linux

CH340G

• WCH (Nanjing Qinheng Microelectronics)
• 2Mbps
• může vyžadovat instalaci ovladačů

Modely

ESP8266

• 32-bit Single Core Xtensa LX106 80 - 160 MHz
• 2.4 GHz Wi-Fi
• SPI
• I2C
• UART
• I2S
• RAM 160KB - 64KB instrukce, 96KB Data
• externí QSPI Flash pamět 512KB a 4MB

Espressif Systems

• ESP-WROOM-02 - PCB anténa, 2MiB Flash
• ESP-WROOM-02D - PCB anténa, 2MiB Flash
• ESP-WROOM-02U - U.FL anténa, 2MiB Flash
• ESP-WROOM-S2 - PCB anténa 2MiB Flash

Ai-Thinker

• ESP-01S - PCB anténa, 1MiB Flash
• ESP-01M - PCB anténa, 1MiB Flash
• ESP-07S - U.FL anténa, 4MiB Flash
• ESP-08S - bez Wi-Fi, 4MiB Flash
• ESP-12F - PCB anténa, 4MiB Flash
• ESP-12S - PCB anténa, 4MiB Flash

WeMos

• D1 R2 - PCB anténa, 1MiB Flash
• D1 mini - PCB anténa, 4MiB Flash
• D1 mini Lite - PCB anténa, 1MiB Flash
• D1 mini Pro - U.FL anténa, 16MiB Flash

ESP32

• uvedena 2016
• 160 - 240 MHz
• FPU
• 32-bit MCU Single & Dual Core
• 2.4 GHz Wi-Fi
• Bluetooth / Bluetooth LE
• Camera Bus
• Hall Sensor
• SD Interface

Espressif Systems

• ESP32-WROOM-32 - 240MHz, 520KB RAM, 4MB Flash, 2.4GHz, BLE 4.2, 26 GPIO
• ESP32-WROVER - 240MHz, 520KB RAM + 8MB PSRAM, 4MB Flash, 2,4GHz, BLE 4.2, 26 GPIO
• ESP32-PICO-D4 - 240MHz, 520KB RAM, 4MB Flash, 2.4GHz, BLE 4.2, 19 GPIO, prcek
• ESP32-CAM - 240MHz, 520KB RAM, 4MB Flash, 2.4GHz, BLE 4.2, 9 GPIO, integrovaná kamera

ESP32-S

• uvedena 2020

• 240 MHz

• Camera Bus

  S2

  • 32-bit Single Core MCU
  • 2.4 GHz Wi-Fi
  • nemá Bluetooth
  • 13-bit ADC

  S3

  • 32-bit Dual Core MCU
  • 2.4 GHz Wi-Fi
  • Bluetooth 5 (LE)
  • podporuje extérní paměť

ESP32-C

• uvedena 2020
• RISC-V procesor
• 120 - 160MHz
• jedno jádrové

C2

• 32-bit RISC-V MCU
• 2.4 GHz Wi-Fi
• Bluetooth 5 (LE)
• náhrada za ESP8266

C3

• 32-bit RISC-V MCU
• 2.4 GHz Wi-Fi
• Bluetooth 5 (LE)
• má RTC

C6

• 32-bit RISC-V MCU
• 2.4 GHz Wi-Fi 6
• Bluetooth 5 (LE)
• IEEE 802.15.4 (LR-WPAN)
• podpora THREAD
• podpora ZIGBEE

C61

• uvedena 2024
• 160 MHz
• Wi-Fi 6
• podpora Matter (ESP Matter SDK)
• 32-bit RISC-V MCU
• 2.4 a 5 GHz
• Bluetooth 5 (LE)
• může být použit jako koprocesor

C5

• uvedena 2024
• 240 MHz
• 32-bit RISC-V MCU
• Wi-Fi 6
• podporuje Dual Band - 2.4 a 5 GHz
• Bluetooth 5 (LE)
• podporuje externí flash paměť
• může být použit jako koprocesor

ESP32-H

• uvedena 2023
• RISC-V
• 96 MHz
• zaměření na IoT aplikace
• podporuje externí paměť
• podpora THREAD
• podpora ZIGBEE

H2

• 32-bit RISC-V MCU
• Bluetooth 5 (LE)
• IEEE 802.15.4 (LR-WPAN)

ESP32-P

• uvedena 2024
• 400 MHz
• RISC-V
• FPU
• zaměřena na vysoký výkon
• nemá Wi-Fi
• nemá Bluetooth

P4

• 32-bit Dual Core RISC-V MCU

The post Základní přehled ESPček first appeared on Hard Wired.

V dnešním článku se podíváme na to, jak se z ESP32 development boardu připojit pomocí SSH ke vzdálenému počítači.

Pro vývoj je použito PlatformIO.

platformio.ini

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps = ewpa/LibSSH-ESP32@^4.2.0

main.cpp

Jediná externí závislost je libssh-esp32.

#include <Arduino.h>
#include <WiFi.h>
#include <libssh_esp32.h>
#include "libssh_esp32_config.h"
#include <libssh/libssh.h>
#include <vector>
#include <string>

Budeme potřebovat SSID WiFi sítě a heslo.

const char *ssid = "ssid-vasi-wifi";
const char *password = "vase-nejtajnejsi-heslo";

Potřebujeme nastavit přihlašovací údaje pro SSH a příkaz který po přihlášení provedeme.

const int ssh_port = 22;
const char *ssh_username = "pi";
const char *ssh_password = "super-tajne-heslo";
const char *ssh_command = "ls -l";

Dále seznam IP adres serverů na které se chceme připojit.

std::vector<std::string> server_ips = {
    "192.168.1.254",
};

Vytvoříme funkci pro připojení k WiFi. Na konci vypíšeme do konzole MAC adresu přístupového bodu, ke kterému jsme se připojili.

void connectToWiFi()
{
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(1000);
        Serial.println("Connecting to WiFi..");
    }
    Serial.print("Připojeno k AP s MAC: ");
    Serial.println(WiFi.BSSIDstr());
}

Ted ta nejdelší část. Funkce co vytvoří SSH spojení, provede příkaz a výsledek vypíše na standardní výstup. Funkce si po sobě uklízí.

/**
 * Execute SSH Command
 *
 * @param ip Server IP
 * @param username SSH Username
 * @param password SSH Password
 * @param command Command to execute
 */
void executeSSHCommand(const char *ip, const char *username, const char *password, const char *command)
{
    // Create a new SSH session
    ssh_session session = ssh_new();
    if (session == NULL)
    {
        Serial.println("Failed to create SSH session");
        return;
    }

    // Set SSH options for the session
    ssh_options_set(session, SSH_OPTIONS_HOST, ip);
    ssh_options_set(session, SSH_OPTIONS_USER, username);

    // Connect to SSH server
    int rc = ssh_connect(session);
    if (rc != SSH_OK)
    {
        Serial.println("Failed to connect to SSH server");
        return;
    }

    // Verify the server's identity
    rc = ssh_userauth_password(session, NULL, password);
    if (rc != SSH_AUTH_SUCCESS)
    {
        Serial.println("Failed to authenticate");
        return;
    }

    // Create a new SSH channel
    ssh_channel channel = ssh_channel_new(session);
    if (channel == NULL)
    {
        Serial.println("Failed to create SSH channel");
        return;
    }

    // Open a new SSH session
    rc = ssh_channel_open_session(channel);
    if (rc != SSH_OK)
    {
        Serial.println("Failed to open SSH session");
        return;
    }

    // Execute the command
    rc = ssh_channel_request_exec(channel, command);
    if (rc != SSH_OK)
    {
        Serial.println("Failed to execute command");
        return;
    }

    // Read the output of the command
    char buffer[256];
    int nbytes; // Number of bytes read
    nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
    while (nbytes > 0)
    {
        if (write(1, buffer, nbytes) != nbytes) // Write to stdout
        {
            Serial.println("Failed to write to stdout");
            return;
        }
        nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
    }

    // Check if there was an error reading from the channel
    if (nbytes < 0)
    {
        Serial.println("Failed to read from SSH channel");
        return;
    }

    // Send EOF and close the channel
    ssh_channel_send_eof(channel);

    // Close the channel
    ssh_channel_close(channel);

    // Free the channel
    ssh_channel_free(channel);

    // Disconnect the session
    ssh_disconnect(session);

    // Free the session
    ssh_free(session);
}

Teď potřebujeme funkci která provede SSH příkaz pro všechny naše servery, které jsou definované v server_ips.

/**
 * Execute SSH Command on all servers
 * 
 * @param username SSH Username
 * @param password SSH Password
 * @param command Command to execute
 */
void executeSSHCommandOnAllServers(const char *username, const char *password, const char *command)
{
    for (std::string ip : server_ips)
    {
        executeSSHCommand(ip.c_str(), username, password, command);
    }
}

Teď už jen zbývá provést vše při startu ESPčka.

void setup()
{
    Serial.begin(115200);
    while (!Serial)
    {
        ; // Wait for serial to be ready
    }

    connectToWiFi();
    ssh_init();
    executeSSHCommandOnAllServers(ssh_username, ssh_password, ssh_command);
}

Hlavní smyčku programu pro tento příklad necháme odpočívat.

void loop()
{
    delay(1000); // Delay for 1 second
}

To je vše. Po kompilaci, nahrání kódu a spuštění ESPčka se připojí k WiFi a poté provede SSH připojení na zadané IP adresy a provede ls -l příkaz. Ten vypíše do konzole.

main.cpp full

#include <Arduino.h>
#include <WiFi.h>
#include <libssh_esp32.h>
#include "libssh_esp32_config.h"
#include <libssh/libssh.h>
#include <vector>
#include <string>

// WiFi Credentials
const char *ssid = "ssid-vasi-wifi";
const char *password = "vase-nejtajnejsi-heslo";

// SSH Credentials
const int ssh_port = 22;
const char *ssh_username = "pi";
const char *ssh_password = "super-tajne-helso";
const char *ssh_command = "ls -l";

// Server IPs List
std::vector<std::string> server_ips = {
    "192.168.1.254",
};

/**
 * Connect to WiFi
 */
void connectToWiFi()
{
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(1000);
        Serial.println("Connecting to WiFi..");
    }
    Serial.print("Připojeno k AP s MAC: ");
    Serial.println(WiFi.BSSIDstr());
}

/**
 * Execute SSH Command
 *
 * @param ip Server IP
 * @param username SSH Username
 * @param password SSH Password
 * @param command Command to execute
 */
void executeSSHCommand(const char *ip, const char *username, const char *password, const char *command)
{
    // Create a new SSH session
    ssh_session session = ssh_new();
    if (session == NULL)
    {
        Serial.println("Failed to create SSH session");
        return;
    }

    // Set SSH options for the session
    ssh_options_set(session, SSH_OPTIONS_HOST, ip);
    ssh_options_set(session, SSH_OPTIONS_USER, username);

    // Connect to SSH server
    int rc = ssh_connect(session);
    if (rc != SSH_OK)
    {
        Serial.println("Failed to connect to SSH server");
        return;
    }

    // Verify the server's identity
    rc = ssh_userauth_password(session, NULL, password);
    if (rc != SSH_AUTH_SUCCESS)
    {
        Serial.println("Failed to authenticate");
        return;
    }

    // Create a new SSH channel
    ssh_channel channel = ssh_channel_new(session);
    if (channel == NULL)
    {
        Serial.println("Failed to create SSH channel");
        return;
    }

    // Open a new SSH session
    rc = ssh_channel_open_session(channel);
    if (rc != SSH_OK)
    {
        Serial.println("Failed to open SSH session");
        return;
    }

    // Execute the command
    rc = ssh_channel_request_exec(channel, command);
    if (rc != SSH_OK)
    {
        Serial.println("Failed to execute command");
        return;
    }

    // Read the output of the command
    char buffer[256];
    int nbytes; // Number of bytes read
    nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
    while (nbytes > 0)
    {
        if (write(1, buffer, nbytes) != nbytes) // Write to stdout
        {
            Serial.println("Failed to write to stdout");
            return;
        }
        nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
    }

    // Check if there was an error reading from the channel
    if (nbytes < 0)
    {
        Serial.println("Failed to read from SSH channel");
        return;
    }

    // Send EOF and close the channel
    ssh_channel_send_eof(channel);

    // Close the channel
    ssh_channel_close(channel);

    // Free the channel
    ssh_channel_free(channel);

    // Disconnect the session
    ssh_disconnect(session);

    // Free the session
    ssh_free(session);
}

/**
 * Execute SSH Command on all servers
 *
 * @param username SSH Username
 * @param password SSH Password
 * @param command Command to execute
 */
void executeSSHCommandOnAllServers(const char *username, const char *password, const char *command)
{
    for (std::string ip : server_ips)
    {
        executeSSHCommand(ip.c_str(), username, password, command);
    }
}

void setup()
{
    Serial.begin(115200);
    while (!Serial)
    {
        ; // Wait for serial to be ready
    }

    connectToWiFi();
    ssh_init();
    executeSSHCommandOnAllServers(ssh_username, ssh_password, ssh_command);
}

void loop()
{
    delay(1000); // Delay for 1 second
}

The post SSH připojení pomocí ESP32 first appeared on Hard Wired.

Mnoho lidí, kteří nejsou obeznámeni s elektronikou, se často snaží rozlišit mezi ESP8266 a ESP32. Lidé mají mnoho pochybností o tom, kterou desku použít a jaký je mezi nimi rozdíl.

Jak ESP32, tak ESP8266 jsou levné SOC (Systems on Chip) založené na WiFi, dokonale vhodné pro kutilské projekty na internetu věcí. Oba mají 32bitové procesory, ESP32 je dvoujádrový 80MHz až 240MHz CPU a ESP8266 je 80MHz jednojádrový procesor. Tyto moduly jsou dodávány s GPIO, které podporují různé protokoly jako SPI, I2C, UART, ADC, DAC a PWM. ESP32 a ESP8266 pracují při 3,3V.

ESP8266

Modul ESP-12E na vývojové desce obsahuje čip ESP8266 s mikroprocesorem Tensilica Xtensa 32-bit LX106 RISC, který podporuje RTOS a pracuje na 80 až 160 MHz nastavitelné taktovací frekvenci. ESP8266 je levné, uživatelsky přívětivé zařízení pro připojení vašich IoT projektů k internetu. Nodemcu ESP8266 obsahuje Wi-Fi transceiver 802.11b/g/n HT40, který umožňuje připojení k WiFi síti a interakci s internetem, modul může fungovat jako přístupový bod (vytvoření hotspotu) i stanice (připojení k Wi-Fi), může jednoduše načíst data a odeslat je na internet, díky čemuž je internet věcí (IoT) co nejjednodušší. To rozšiřuje možnosti ESP8266 NodeMCU.

Tento modul má dostatečně výkonnou integrovanou kapacitu zpracování a úložiště, která umožňuje jeho integraci se senzory a dalšími zařízeními specifickými pro aplikace prostřednictvím jeho GPIO s minimálním vývojem předem a minimálním zatížením za běhu. 128 KB RAM a 4 MB Flash paměti (pro ukládání aplikací a dat), což je více než dost na to, aby zvládlo obrovské řetězce, které tvoří webové stránky, data JSON/XML a vše ostatní, co v dnešní době házíme do zařízení IoT.

Modul ESP8266 NodeMCU je k dispozici ve dvou variantách, kde jedna je vestavěna s můstkem CP2102 USB-UART a druhá s můstkem CH340 USB-UART.

Napájení

Deska má regulátor napětí LDO pro udržení stabilního napětí na 3,3V, zatímco provozní napětí ESP8266 je 3V až 3,6V. Když ESP8266 odebírá při RF přenosech až 80mA, dokáže spolehlivě dodat až 600mA, což by mělo být více než dostatečné. Výstup regulátoru je také vylomen na jednu ze stran desky a označen jako 3V3. Přes tento pin lze napájet externí komponenty. Integrovaný MicroB USB konektor poskytuje napájení ESP8266 NodeMCU. Pin VIN můžete použít k přímému napájení ESP8266 a jeho periferií, pokud poskytujete napájení prostřednictvím 5V zdroje.

Pro komunikaci vyžaduje ESP8266 3,3V napájecí zdroj a 3,3V logické úrovně. Piny GPIO nemají toleranci 5V.

PINOUT

Wifi modul ESP8266 má na obou stranách vývojové desky k dispozici celkem 17 GPIO pinů. Tyto piny lze přiřadit všem druhům periferních funkcí.

• POWER PIN : Napájecí kolíky se skládají z jednoho kolíku VIN a tří kolíků 3,3V. Pokud máte regulovaný 5V zdroj napájení, můžete využít pin VIN k přímému napájení ESP8266 a jeho periferií. 3,3V kolíky jsou výstupy z regulátoru napětí zabudovaného do desky. Prostřednictvím těchto pinů lze napájet externí komponenty.
• I2C kolíky : Používají se k připojení všech I2C senzorů a periferií vašeho projektu. I2C Master a Slave jsou podporovány.
• GPIO PINY: ESP8266 NodeMCU obsahuje 17 GPIO pinů, které lze programově přiřadit různým úlohám, jako je I2C, I2S, UART, PWM, IR dálkové ovládání, LED světlo a tlačítko. Každé GPIO s digitální schopností lze naladit na vnitřní pull-up nebo pull-down, nebo příliš vysokou impedanci.
• GROUND: Je to zemnící kolík vývojové desky ESP8266 NodeMCU.
• ADC CHANNEL: NodeMCU má vestavěný 10bitový přesný SAR ADC. Testování napájecího napětí pinu VDD3P3 a testování vstupního napětí pinu TOUT jsou dvě funkce, které lze implementovat pomocí ADC. Nelze je implementovat současně.
• PINY UART: NodeMCU ESP8266 obsahuje dva porty UART, UART0 a UART1, které mohou komunikovat rychlostí až 4,5 Mbps a umožňují asynchronní komunikaci (RS232 a RS485). Pro komunikaci lze použít UART0 (piny TXD0, RXD0, RST0 a CTS0). Podporuje kontrolu tekutin. Protože však UART1 (vývod TXD1) pouze přenáší data, obvykle se používá k tisku protokolů.
• SPI PINY: ESP8266 má dvě SPI (SPI a HSPI), které lze použít v režimu slave a master.
• PWM PINY: Na desce plošných spojů jsou čtyři kanály pulzní šířkové modulace (PWM). Výstup PWM lze programově implementovat a využít k pohonu digitálních motorů a LED. Frekvenční rozsah PWM je nastavitelný od 1000 μs do 10000 μs, tj. mezi 100 Hz a 1 kHz.
• OVLÁDACÍ PINY: slouží k ovládání mikrokontroléru ESP8266. Mezi tyto piny patří Enable pin (EN), Reset pin (RST) a WAKE.

Na ESP8266 NodeMCU jsou dvě tlačítka. Tlačítko Reset, označené RST a umístěné v levém horním rohu, slouží k resetování čipu ESP8266. Tlačítko FLASH se nachází v levém dolním rohu a slouží k aktualizaci firmwaru. Na desce je také uživatelsky programovatelný LED indikátor, který je propojen s pinem D0.

ESP 32

Vývojová deska je vybavena modulem ESP-WROOM-32 obsahujícím 32bitový mikroprocesor Tensilica Xtensa Dual-Core LX6. Tento procesor je srovnatelný s ESP8266, až na to, že obsahuje dvě CPU jádra (každá z nich lze provozovat samostatně), taktovací frekvenci 80 až 240 MHz a výkon až 600 DMIPS (Dhrystone Million Instructions Per Second).

ESP32 integruje 802.11b/g/n HT40 Wi-Fi transceiver, který umožňuje nejen připojení k WiFi síti pro interakci s internetem, ale také vytvoření vlastní sítě, ke které se mohou přímo připojit další zařízení. WiFi Direct podporuje také ESP32, což je vhodná alternativa pro peer-to-peer připojení, která nevyžadují přístupový bod. Je jednodušší nastavit WiFi Direct a má podstatně vyšší rychlosti přenosu dat než Bluetooth. Čip také podporuje jak Bluetooth 4.0 (BLE/Bluetooth Smart), tak Bluetooth Classic (BT), díky čemuž je ještě všestrannější.

Nodemcu ESP32 je řada levných mikrokontrolérů s nízkou spotřebou energie s vestavěným ESP32 Wi-Fi a duálním Bluetooth. ESP32 je navržen pro aplikace internetu věcí s nízkou spotřebou. Jeho vysoký výpočetní výkon v kombinaci s vestavěnými funkcemi Wi-Fi, Bluetooth a Deep Sleep, 520 KB SRAM, 448 KB ROM a 4 MB Flash paměti (pro ukládání softwaru a dat) je vhodný pro většinu přenosných IoT zařízení.

Napájení 

Deska má regulátor napětí LDO pro udržení stabilního napětí na 3,3 V, zatímco rozsah provozního napětí Arduino ESP32 je 2,2 V až 3,6 V. Když ESP32 odebírá při RF přenosech až 250 mA, dokáže spolehlivě dodat až 600 mA, což by mělo být více než dostatečné. Výstup regulátoru je také vylomen na jednu ze stran desky a označen jako 3V3. Přes tento pin lze napájet externí komponenty. Integrovaný MicroB USB port poskytuje napájení vývojové desce ESP32. Pin VIN můžete použít k napájení ESP32 a jeho periferií přímo přes 5V externí napájení.

Pro komunikaci vyžaduje ESP32 3,3V napájení a 3,3V logické úrovně. Piny GPIO nemají toleranci 5V.

PINOUT

Deska ESP-32 má 48 vstupně/výstupních pinů pro všeobecné použití, z nichž pouze 25 je k dispozici jako pin headery na obou stranách desky ESP-32. Tyto piny lze přiřadit všem druhům periferních funkcí.

• POWER PINS : Pin VIN a pin 3,3V jsou dva napájecí kolíky. Pokud máte řízený 5V zdroj napájení, můžete využít pin VIN k přímému napájení ESP32 a jeho periferií. Výstup palubního regulátoru napětí je připojen na pin 3,3V. Přes tento pin lze napájet externí komponenty.
• ARDUINO PINS: hardwarové I2C a SPI piny ESP32, které můžete použít k připojení všech druhů senzorů a periferií k vašemu projektu.
• GPIO PINY: Vývojová deska ESP32 obsahuje 25 GPIO pinů, které lze programově přiřadit různým funkcím. Každé digitálně aktivované GPIO lze nastavit na vysokou impedanci nebo interní pull-up nebo pull-down. Může být také nastaven na spouštění na hraně nebo na úrovni spouštění pro generování přerušení CPU, když je nakonfigurován jako vstup
• GROUND: Zemnicí kolík vývojové desky ESP32.
• ADC CHANNELS: Deska má 12bitové SAR ADC a 15 měřicích kanálů (analogové piny). Některé z těchto pinů lze využít k sestavení programovatelného zesilovače zesílení pro měření malých analogových signálů. ESP32 je také schopen měřit napětí, když je v režimu spánku.
• DAC CHANNELS: Dva 8bitové DAC kanály v obvodu převádějí digitální signály na skutečné analogové napětí. Tento duální DAC může řídit další obvody. TouchPady Deska nabízí 9 kapacitních snímacích GPIO, které detekují kapacitní odchylky způsobené přímým kontaktem GPIO nebo blízkostí prstu nebo jiných předmětů.
• UART PINS: Vývojová deska ESP32 obsahuje dvě rozhraní UART, UART0 a UART2, která zajišťují asynchronní komunikaci (RS232 a RS485) a IrDA rychlostí až 5 Mbps. UART poskytuje hardwarovou správu signálů CTS a RTS a také softwarové řízení toku (XON a XOFF).
• SPI PINS: SPI Pins ESP32 obsahuje tři SPI (SPI, HSPI a VSPI) v režimu slave a master. Všechny SPI lze také použít k připojení k externí paměti Flash/SRAM a LCD.
• ~ PWM PINY: Deska má 25 kanálů (téměř všechny GPIO piny) pinů PWM řízených řadičem Pulse Width Modulation (PWM). Výstup PWM lze použít pro řízení digitálních motorů a LED. Regulátor se skládá z PWM časovačů a PWM operátora. Každý časovač poskytuje časování v synchronní nebo nezávislé formě a každý operátor PWM generuje průběh pro jeden kanál PWM.

EN PIN: Používá se k povolení ESP32. Čip je povolen, když je vytažen HIGH. Při vytažení LOW čip pracuje na minimální výkon.

Který z nich je lepší, ESP8266 VS ESP32?

ESP8266 je velmi oblíbená a dostupná platforma pro implementaci energeticky účinných aplikací IoT, které fungují na základě připojení Wi-Fi.
Espressif ESP32 je zase relativně nové a pokročilejší řešení, kde tvůrci zvýšili rychlost Wi-Fi, přidali podporu Bluetooth 4.2 a Bluetooth Low Energy a zvýšili počet vstupů/výstupů.

ESP32 má více GPIO než ESP8266 a v kódu můžete určit, které piny se používají pro UART, I2C a SPI. To je možné díky schopnosti multiplexování čipu ESP32, který umožňuje přiřadit četné funkce jedinému kolíku. Signály PWM lze nastavit v libovolném GPIO s konfigurovatelnými frekvencemi a pracovními cykly kódu. Analogové piny jsou statické, ale ESP32 podporuje měření na 18 kanálech (analogové piny), zatímco ESP8266 Arduino má pouze jeden 10bitový ADC pin. ESP32 podporuje také dva 8bitové kanály DAC. Kromě toho ESP32 obsahuje 10 kapacitních snímacích GPIO, které detekují dotyk a lze je použít ke spouštění událostí nebo probuzení ESP32 z hlubokého spánku. ESP32 ve výchozím nastavení podporuje komunikační protokol Bluetooth, zatímco ESP8266 nikoli

Bezdrátová komunikace

Pozoruhodný rozdíl oproti ESP32 je jeho Bluetooth schopnost, která umožňuje ESP32 neomezit se pouze na Wi-Fi komunikaci, což umožňuje jeho integraci do více projektů. Podporuje klasické Bluetooth i Bluetooth Low Energy. Zatímco ESP8266 nepodporuje Bluetooth.

zpracovává se

ESP8266 má vestavěný procesor, ale kvůli multitaskingu, který je součástí aktualizace Wi-Fi stacku, většina aplikací používá samostatný mikrokontrolér pro propojení se senzory, digitální I/O a zpracování dat. Při používání ESP32 možná nebudete muset používat další mikrokontrolér, protože ESP32 má duální 32bitové mikroprocesory a poběží na breakout deskách a modulech od 160 MHz do 240 MHz. To poskytuje dostatečnou rychlost pro jakoukoli aplikaci, která vyžaduje mikrokontrolér s konektivitou.

• ESP32 je rychlejší než ESP8266;
• ESP32 přichází s více GPIO s více funkcemi;
• ESP32 podporuje analogová měření na 18 kanálech (analogové piny) oproti pouze jednomu 10bitovému ADC pinu na ESP8266;
• ESP32 podporuje Bluetooth, zatímco ESP8266 ne;
• ESP32 je dvoujádrový a ESP8266 je jednojádrový;
• ESP8266 je levnější než ESP32;
• ESP8266 má širší komunitu (i když si to v tuto chvíli nemyslíme, rozdíl je tak velký);
• U mnoha projektů IoT a Wi-Fi může ESP8266 tuto práci zvládnout za nižší cenu;
• Obě desky lze naprogramovat pomocí Arduino IDE nebo jiných podporovaných IDE.
• Obě desky podporují firmware MicroPython.

Zde je srovnávací tabulka pro technické specifikace ESP8266 a ESP32:

Závěr

Shrneme-li náš stručný přehled, můžeme říci, že ESP8266 je vynikající levný mikrokontrolér na bázi Wi-Fi, ale pokud potřebujete něco energeticky účinnějšího a kompatibilního s Bluetooth, zvažte jeho nástupce – modul ESP32. Mikrokontroléry ESP8266 a ESP32 SoC poskytují nadšencům internetové komunikační zařízení, ale ESP32 je o něco lepší volba . V každém případě jsou obě zařízení dobrými představiteli svých nik.

ESP32 a ESP8266 jsou levné moduly Wi-Fi , které jsou ideální pro projekty internetu věcí (IoT) a domácí automatizace .

EN zdroj: hnhcart.com

The post Rozdíl mezi ESP8266 a ESP32 first appeared on Hard Wired.

Pokud potřebujete na ESP32 spouštět naplánované úlohy, určitě se nemůžete spoléhat na vnitřní časování. Budete potřebovat nějaký externí modul reálného času (RTC), který vám na vyžádání vrátí přesný čas.

V bastlířské oblasti se hodně často používá DS1307. Vyniká hlavně v tom, že je extrémně levný. Na Aliexpressu se dá koupit za necelých 14 CZK. Cena kompenzuje určitou nepřesnost. Udává se zpoždění cca 5 minut za měsíc.

Sice několika násobně dražší, ale pořád směšně levný je DS3231. Na Aliexpressu se dá pořídit za 60 CZK.

U Lásky 128 CZK plus poštovné.

Tento modul je daleko přesnější a obsahuje tepelně kompenzovaný krystalový oscilátor (TCXO), který odolává změnám teplot. Pro náš testovací projekt použijeme DS3231.

DS3231

Modul umí sledovat roky, měsíce, dny, hodiny, minuty a sekundy. Umí dokonce přestupné roky do roku 2100. Dokáže pracovat v 12 hodinovém nebo 24 hodinovém formátu. Obsahuje dva programovatelné alarmy.

Modul má piny pro připojení přes sběrnici I2C. Má také pin INT, který umí produkovat signál přerušení a pin SQW pro generování "square wave" signálu na frekvencích 1Hz, 4kHz, 8kHz nebo 32kHz.

Přesnost modulu je +-2 minuty za rok.

Modul se napájí pomocí knoflíkové baterie CR2032, LIR2032 nebo ekvivalentní o průměru 20mm. Při použití 220mAh baterie je teoretická životnost 8 let.

Modul obsahuje 32 bytový AT24C32 EEPROM paměťový čip s milionem zapisovacích cyklů. Neslouží pro běh hodin, může být použit pro zápis logů nebo libovolných dat.

Vyčerpávající popis modulu najdete na lastminuteengineers.com.

Zapojení

Pomocí I2C připojíme k ESP modulu.

Program

Pokud nejsou hodiny nastaveny nebo mají starší čas, než je čas při kompilaci kódu, přenastaví se na aktuální čas. Po inicializaci modulu se vytvoří naplánovaná úloha pomocí modulu TaskScheduler a každých 10 sekund vypíše aktuální čas modulu do sériové konzole. Zbytek v komentovaném kódu.

main.cpp

/**
 * @file main.cpp
 * @author Hard Wired
 * @brief ESP32 I2C RTC test project.
 * @details
 *      Based on https://github.com/Makuna/Rtc/blob/master/examples/DS3231_Simple/DS3231_Simple.ino example.
 *      Modul tutorial https://lastminuteengineers.com/ds3231-rtc-arduino-tutorial/
 * @version 0.1
 * @date 2023-02-08
 */

#include <Arduino.h>

#include <Wire.h>
#include <RtcDS3231.h>
#include <TaskScheduler.h>

const int SECOND_IN_MILS = 1000;
const int TEN_SECONDS_IN_MILS = SECOND_IN_MILS * 10;

/**
 * @brief Vytvoření plánovače
 *
 */
Scheduler runner;

/**
 * @brief Vytvoření RTC objektu a připojení pomocí I2C sběrnice.
 *
 * @return RtcDS3231<TwoWire>
 */
RtcDS3231<TwoWire> Rtc(Wire);

/**
 * @brief Vytáhne z objektu "Rtc" poslední chybový stav a vypíše chybovou hlášku¨
 *        a dá vědět pomocí true/false.
 * @details see https://www.arduino.cc/reference/en/language/functions/communication/wire/endtransmission/
 *
 * @param errorTopic
 * @return true
 * @return false
 */
bool wasError(const char *errorTopic = "")
{
    uint8_t error = Rtc.LastError();
    if (error != 0)
    {
        Serial.print("[");
        Serial.print(errorTopic);
        Serial.print("] WIRE communications error (");
        Serial.print(error);
        Serial.print(") : ");

        switch (error)
        {
        case Rtc_Wire_Error_None:
            Serial.println("(none?!)");
            break;
        case Rtc_Wire_Error_TxBufferOverflow:
            Serial.println("transmit buffer overflow");
            break;
        case Rtc_Wire_Error_NoAddressableDevice:
            Serial.println("no device responded");
            break;
        case Rtc_Wire_Error_UnsupportedRequest:
            Serial.println("device doesn't support request");
            break;
        case Rtc_Wire_Error_Unspecific:
            Serial.println("unspecified error");
            break;
        case Rtc_Wire_Error_CommunicationTimeout:
            Serial.println("communications timed out");
            break;
        }
        return true;
    }
    return false;
}

/**
 * @brief Vypíše naformátované datum do sériové konzole.
 *
 * @param dt
 */
void printDateTime(const RtcDateTime &dt)
{
    char buffer[20];

    sprintf(buffer, "%d-%02d-%02d %02d:%02d:%02d", dt.Year(), dt.Month(), dt.Day(), dt.Hour(), dt.Minute(), dt.Second());

    Serial.println(buffer);
}

void printDateTimeAndTemperature()
{
    if (!Rtc.IsDateTimeValid())
    {
        if (!wasError("loop IsDateTimeValid"))
        {
            // Common Causes:
            //    1) the battery on the device is low or even missing and the power line was disconnected
            Serial.println("RTC lost confidence in the DateTime!");
        }
    }

    RtcDateTime now = Rtc.GetDateTime();
    if (!wasError("loop GetDateTime"))
    {
        printDateTime(now);
    }

    RtcTemperature temp = Rtc.GetTemperature();
    if (!wasError("loop GetTemperature"))
    {
        temp.Print(Serial);
        // you may also get the temperature as a float and print it
        // Serial.print(temp.AsFloatDegC());
        Serial.println("C");
    }
}

/**
 * @brief Vytvoření naplánované úlohy. Poběží navždy a spustí se každých 10 sekund.
 *
 * @return Task
 */
Task PrintDateTimeAndTemperatureTask(TEN_SECONDS_IN_MILS, TASK_FOREVER, &printDateTimeAndTemperature);

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

    Serial.print("compiled: ");
    // makro které expanduje datum při kompilaci kódu na "mmm dd yyyy" řetězec
    Serial.print(__DATE__);
    Serial.print(' ');
    // makro které expanduje čas při kompilaci kódu na "hh:MM:ss" řetězec
    Serial.println(__TIME__);

    Rtc.Begin();

#if defined(WIRE_HAS_TIMEOUT)
    Wire.setWireTimeout(3000 /* us */, true /* reset_on_timeout */);
#endif

    /**
     * @brief Vytvoří objekt RtcDateTime a nastaví ho podle času kompilace kódu.
     *
     */
    RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__);
    printDateTime(compiled);
    Serial.println();

    /**
     * @brief Pokud neni RTC nastaveno nastaví datum a čas.
     *
     */
    if (!Rtc.IsDateTimeValid())
    {
        if (!wasError("setup IsDateTimeValid"))
        {
            // Common Causes:
            //    1) first time you ran and the device wasn't running yet
            //    2) the battery on the device is low or even missing

            Serial.println("RTC lost confidence in the DateTime!");

            // following line sets the RTC to the date & time this sketch was compiled
            // it will also reset the valid flag internally unless the Rtc device is
            // having an issue

            Rtc.SetDateTime(compiled);
        }
    }

    /**
     * @brief V případě že není RTC spuštěno spustíme ho.
     *
     */
    if (!Rtc.GetIsRunning())
    {
        if (!wasError("setup GetIsRunning"))
        {
            Serial.println("RTC was not actively running, starting now");
            Rtc.SetIsRunning(true);
        }
    }

    /**
     * @brief V případě, že je čas hodin starší než čas kompilace, nastaví se nový čas. Vypíše do sériové konzole informaci o nastavení RTC.
     *
     */
    RtcDateTime now = Rtc.GetDateTime();
    if (!wasError("setup GetDateTime"))
    {
        if (now < compiled)
        {
            Serial.println("RTC is older than compile time, updating DateTime");
            Rtc.SetDateTime(compiled);
        }
        else if (now > compiled)
        {
            Serial.println("RTC is newer than compile time, this is expected");
        }
        else if (now == compiled)
        {
            Serial.println("RTC is the same as compile time, while not expected all is still fine");
        }
    }

    /*
     * Nastaví RTC modul do požadovaného stavu.
     */
    Rtc.Enable32kHzPin(false);
    wasError("setup Enable32kHzPin");
    // The INT/SQW pin on the DS3231 provides either an interrupt signal (due to alarm conditions) or a nice square wave at 1Hz, 4kHz, 8kHz, or 32kHz.
    Rtc.SetSquareWavePin(DS3231SquareWavePin_ModeNone);
    wasError("setup SetSquareWavePin");

    /**
     * @brief Přiřazení naplánované úlohy do plánovače.
     *
     */
    runner.addTask(PrintDateTimeAndTemperatureTask);

    /**
     * @brief Povolení naplánované úlohy.
     *
     */
    PrintDateTimeAndTemperatureTask.enable();
}

void loop()
{
    runner.execute(); // spouštění plánovače
}

platformio.ini

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

lib_deps =
  makuna/RTC @ ^2.3.6
  arkhipenko/TaskScheduler @ ^3.7.0

The post ESP32 RTC DS3231 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.