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.

Všem nám dávno došlo že na Raspberry Pi si ještě nějaký pátek počkáme. Když se budeme poohlížet po nějakých alternativách tak nám opět rychle dojde, že je pozdě protože prostě už jsou vyprodané anebo prodávané za nesmyl, popřípadě totálně nevyhovující. V tomto okamžiku se dostává ke slovu společnost RADXA.

Vypadá to jako by se jednalo o klon Raspberry a dost možná že i je ale, a to opravdu ALE jejich produkty nejsou jen laciné klony, jak se můžeme setkat třeba se šmejdem co se tvoří jako Arduino a vlastně nestojí za nic. RADXA desky jsou velice kvalitně vyvedeny a do posledního detailu promyšleny. Jedná se teda o klon myšlenky, a ne produktu samotného. Jedna z mála nevýhod je komunita. RPI má obrovskou komunitu a opravdu propracovaný OS což u Rock Pi (radxa) bohužel zatím nenajdete. Ale nemusíme zoufat, protože na konci tohohle tunelu je světlo.

Co Radxa nabízí?

V jejich nabídce je poměrně široká škála SBC a my si zde zkusíme všechny vyjmenovat.

Radxa Zero

Radxa Zero je ultratenký SBC v malém provedení s vysokým výkonem založeným na Amlogic S905Y2. Může provozovat Android a vybrané distribuce Linuxu. Radxa Zero obsahuje čtyřjádrový 64bitový procesor ARM, až 4 GB 32bitové paměti LPDDR4, výstup HDMI na 4K@60, připojení Wifi a Bluetooth, USB 3.0 a 40pinový GPIO header. Kromě toho lze napájecí port použít také pro USB 2.0 OTG pro připojení dalších periferií. Radxa Zero se dodává v několika konfiguracích, aby vyhovoval vašim potřebám.

Kompletní specifikace, návody a informace naleznete na webu výrobce.

Rock 3

ROCK3 je řada Rockchip RK3566/RK3568 založených na SBC (jednodeskový počítač) a výpočetním modulu od Radxa. Může na ní běžet android nebo některé distribuce Linuxu. Řada ROCK3 obsahuje čtyřjádrový procesor Cortex-A55 ARM, 32bit 3200 Mb/s LPDDR4, až 4K@60 HDMI, MIPI DSI, MIPI CSI, 3,5 mm jack s mikrofonem, USB port, GbE LAN, PCIe 3.0, PCIe 2.0, 40 -pin rozšiřující header, RTC. ROCK3 také podporuje USB PD a QC napájení.

Kompletní specifikace, návody a informace naleznete na webu výrobce.

Rock Pi 4

ROCK Pi 4 je SBC založený na Rockchip RK3399 . Může na ní běžet android nebo některé distribuce Linuxu. ROCK Pi 4 obsahuje šestijádrový procesor ARM, 64bitový dvoukanálový 3200Mb/s LPDDR4, až 4K@60 HDMI, MIPI DSI, MIPI CSI, 3,5mm jack s mikrofonem, 802.11 ac WIFI, Bluetooth 5.0, USB port, GbE LAN, 40 pin header, RTC. ROCK Pi 4 také podporuje USB PD a QC napájení. ROCK Pi 4 je k dispozici ve dvou modelech, Model A a Model B, každý model má možnosti 1GB, 2GB nebo 4GB RAM.

Kompletní specifikace, návody a informace naleznete na webu výrobce.

Rock Pi S

ROCK Pi S je mini SBC založený na Rockchip RK3308. Je vybaven 64bitovým čtyřjádrovým procesorem, USB, ethernetem, bezdrátovým připojením a jádrem detekce hlasu o velikosti 1,7 palce, takže je ideální pro IoT a hlasové aplikace. ROCK Pi S se dodává ve dvou velikostech paměti RAM 256 MB nebo 512 MB DDR3 a pro operační systém a úložiště používá kartu uSD. Volitelně může ROCK Pi S poskytnout verzi s integrovaným úložištěm s 1Gb/2Gb/4Gb/8Gb NAND flash.

Kompletní specifikace, návody a informace naleznete na webu výrobce.

Rock Pi E

ROCK Pi E založený na Rockchip RK3328. Je vybaven 64bitovým čtyřjádrovým procesorem, USB 3.0, dvěma ethernety, bezdrátovým připojením o velikosti 2,5 x 2,2 palce (56 x 65 mm), díky čemuž je ideální pro IoT a síťové aplikace. ROCK Pi E je k dispozici v různých velikostech paměti RAM od 512 MB do 4 GB DDR3 a používá kartu microSD pro operační systém a úložiště a také podporuje modul eMMC. Volitelně ROCK Pi E podporuje PoE, je vyžadován další HAT.

Kompletní specifikace, návody a informace naleznete na webu výrobce.

Rock Pi X

ROCK Pi X je první X86 SBC. Může provozovat distribuce Windows a Linux. Projekt ROCK Pi X byl spuštěn poté, co tým Radxa dostal spoustu dotazů od uživatelů, zda ROCK Pi 4 může provozovat Windows.

ROCK Pi X je vybaven čtyřjádrovým procesorem Intel Cherry Trail Z8350, 64bitový dvoukanálový 1866Mb/s LPDDR3, až 4K@30 HDMI, 3,5mm jack s mikrofonem, 802.11 ac WIFI, Bluetooth 4.2, USB port, GbE LAN, 40-pin header, RTC. ROCK Pi X také podporuje USB PD a QC napájení. ROCK Pi X je k dispozici ve dvou modelech, Model A a Model B, každý model má možnosti 1GB, 2GB nebo 4GB RAM.

Kompletní specifikace, návody a informace naleznete na webu výrobce.

Rock Pi N10

ROCK Pi N10 je SBC (jednodeskový počítač) od společnosti Radxa založený na Rockchip RK3399pro. Jedná se o NPU, AI desku, která slouží pro vývoj strojového učení. RK3399Pro je nízkoenergetický, vysoce výkonný procesor.

Je založeno na architektuře Big.Little a integruje dvoujádrový Cortex-A72 a čtyřjádrový Cortex-A53 se samostatným NEON koprocesorem. Je vybaven jednou výkonnou jednotkou pro zpracování neuronové sítě (NPU) a podporuje mainstream platformy na trhu, jako je caffe, tensor flow a tak dále.

Poskytuje optimalizovaný výkon pro high-end aplikace. RK3399Pro podporuje více formátové video dekodéry a kodéry. Díky integrovanému 3D GPU je RK3399Pro plně kompatibilní s OpenGL ES1.1/2.0/3.0/3.1, OpenCL a DirectX 11.1. Speciální 2D hardwarový engine s MMU maximalizuje zobrazení a poskytují velmi hladký provoz.

Kompletní specifikace, návody a informace naleznete na webu výrobce.

The post Radxa radxa radxa first appeared on Hard Wired.

Budeme potřebovat: 5V ventilátor (představovaný velkým stejnosměrným motorem na obrázku), odpor 680Ω a tranzistor NPN (2N2222).

Zapojení tranzistoru

Tranzistor je zajímavá elektrická součástka sloužící ke spínání nebo zesilování výkonu. V našem případě jej používáme jako přepínač. Existuje mnoho typů tranzistorů, ale my používáme tranzistor NPN. Takže „základní“ kolík tranzistoru je připojen k BCM 17 (vývod GPIO) s odporem 680Ω mezi nimi. Kladný vodič na ventilátoru je připojen k 5V kolíku a zem je připojena ke kolíku "kolektoru" v našem tranzistoru. Nakonec je "emitor" tranzistoru spojen se zemí.

Takže když je pin 17 přepnut na HIGH, pošle nějaké napětí do báze tranzistoru, což uzavře obvod a zapne ventilátor.

git clone https://github.com/Howchoo/pi-fan-controller.git

sudo apt-get install git

The post Automatické ovládání ventilátoru Raspberry first appeared on Hard Wired.