Mise en oeuvre d’Alexa sur un module ESP32 (WEMOS R32)

WEMOS R32

D’après le site esp32.net pour cette carte :

  • Arduino-style development board.
  • Has “WeMos” branding on the board, but not actually from WeMos.
  • Similar to DOIT’s ESPDUINO-32 board, but was available before the ESPDUINO-32.
  • Sellers: vendors on AliExpress

Détection sous GNU/Linux :

$ dmesg
...
[314350.843124] usb 1-5: New USB device found, idVendor=1a86, idProduct=7523
[314350.843125] usb 1-5: New USB device strings: Mfr=0, Product=2, SerialNumber=0
[314350.843126] usb 1-5: Product: USB2.0-Serial
[314350.862015] usbcore: registered new interface driver usbserial_generic
[314350.862023] usbserial: USB Serial support registered for generic
[314350.862951] usbcore: registered new interface driver ch341
[314350.862964] usbserial: USB Serial support registered for ch341-uart
[314350.862974] ch341 1-5:1.0: ch341-uart converter detected
[314350.863302] usb 1-5: ch341-uart converter now attached to ttyUSB0python esptool.py --port /dev/ttyUSB0 flash_id

$ lsusb
...
Bus 001 Device 019: ID 1a86:7523 QinHeng Electronics HL-340 USB-Serial adapter

Pour les tests, j’ai utilisé ce shield :

#ifndef PINOUT_H
#define PINOUT_H

// Shield pour WEMOS R32

/*
  RGB :
  D9 -> 13 = RGB ROUGE
  D10 -> 5 = RGB BLEUE
  D11 -> 23 = RGB VERTE

  Leds :
  D12 -> 19 = LED ROUGE
  D13 -> 18 = LED BLEUE

  Buttons :
  D2 -> 26 = SW1
  D3 -> 25 = SW2

  DHT11 :
  D4 -> 17

  Buzzer :
  D5 -> 16

  IR :
  D6 -> 27

  Rotation :
  A0 -> 2

  Ligth :
  A1 -> 4

  LM35 :
  A2 -> 35

  D0 = RXD
  D1 = TXD
 */

static const uint8_t AN0   = 2; // Rotation
static const uint8_t AN1   = 4; // Light
static const uint8_t AN2   = 35; // LM35
static const uint8_t AN3   = 34; // Libre
static const uint8_t AN4   = 36;
static const uint8_t AN5   = 39;

static const uint8_t D2   = 26; // SW1
static const uint8_t D3   = 25; // SW2
static const uint8_t D4   = 17; // DHT11
static const uint8_t D5   = 16; // Buzzer
static const uint8_t D6   = 27; // IR
static const uint8_t D7   = 14; // Libre
static const uint8_t D8   = 12; // Libre
static const uint8_t D9   = 13; // RGB Rouge
static const uint8_t D10   = 5; // RGB Bleu
static const uint8_t D11   = 23; // RGB Vert
static const uint8_t D12   = 19; // Led Rouge
static const uint8_t D13   = 18; // Led Bleue

#endif

L’ESP32

L’ESP32 est le successeur de l’ESP8266 auquel on a ajouté le Bluetooth :

  • Microprocesseur dual core de 80 MHz à 240 MHz
  • 4MB de mémoire flash
  • WiFi 802.11 b/g/n
  • Bluetooth 4.0 LE et BR/EDR
  • 26x E/S digitales (3.3V)
  • 12x entrées analogiques
  • 4x SPI, 2x I²S, 2x I²C, 3x UART, CAN 2.0, IR, Touch Sensor (écran tactile)
  • Capteur de température

Il existe différents modules.

Liens :

Activités :

Alexa et Echo

Alexa est un assistant personnel intelligent développé par Amazon.com et rendu populaire par Echo. Il est capable d’interaction vocale, de lire de la musique, faire des listes de tâches, régler des alarmes, lire des podcasts et des livres audio, et donner la météo, le trafic et d’autres informations en temps réel.

Amazon Echo est une enceinte connectée, conçue par Amazon, ayant la capacité d’obéir à la voix humaine, de parler, et, dans une certaine mesure, d’interagir avec un humain. L’appareil peut être connecté à des objets domotiques qui peuvent ainsi être contrôlés par la voix humaine.

Exemple

L’objectif est de pouvoir commander la LED RGB de l’ESP32 à partir d’Alexa. Par exemple : « Alexa, allume la led rouge » …

Pour interagir avec Alexa, on va utiliser la bibliothèque FauxmoESP pour les périphériques ESP8266 / ESP32. Elle est directement disponible sur PlatformIO (FauxmoESP).

Cette bibliothèque (depuis sa version 3) émule les lumières Philips Hue et vous permet ainsi de les contrôler via ce protocole à partir de périphériques Alexa, tels que Amazon Echo ou Dot. Elle dépend de la bibliothèque AsyncTCP pour la version ESP32 et de ESPAsyncTCP pour l’ESP8266.

La bibliothèque est très facile à utiliser. Le principe est le suivant :

  • on instancie un objet fauxmoESP,
#include "fauxmoESP.h"

fauxmoESP fauxmo;
  • on connecte l’ESP32 au Wifi,
#include <WiFi.h>

const char *WIFI_SSID = "SSID";
const char *WIFI_PASS = "PASS";

void wifiSetup()
{
    WiFi.mode(WIFI_STA); // Mode Station
    Serial.printf("[WIFI] Connexion %s ", WIFI_SSID);
    WiFi.begin(WIFI_SSID, WIFI_PASS);
    while (WiFi.status() != WL_CONNECTED)
    {
        Serial.print(".");
        delay(100);
    }
    Serial.println();
    Serial.printf("[WIFI] Adresse IP : %s\n", WiFi.localIP().toString().c_str());
}
  • on ajoute les périphériques virtuels
// Noms des appareils
#define ID_LED_ROUGE           "led rouge"
#define ID_LED_VERTE           "led verte"
#define ID_LED_BLEUE           "led bleue"

// démarrer le serveur
fauxmo.createServer(true);
fauxmo.setPort(80);
fauxmo.enable(true);

// ajouter les appareils
fauxmo.addDevice(ID_LED_ROUGE);
fauxmo.addDevice(ID_LED_VERTE);
fauxmo.addDevice(ID_LED_BLEUE);

...
  • et on crée une fonction de rappel pour obtenir les messages d’Alexa
// fonction de rappel (callback) lorsqu’une commande d’Alexa est reçue
fauxmo.onSetState([](unsigned char device_id, const char * device_name, bool state, unsigned char value)
{
    Serial.printf("[ALEXA] Appareil #%d (%s) état : %s - valeur : %d\n", device_id, device_name, state ? "ON" : "OFF", value);

    if (strcmp(device_name, ID_LED_ROUGE) == 0)
    {
        commanderLedRouge(state);
    }
    else if (strcmp(device_name, ID_LED_VERTE) == 0)
    {
        commanderLedVerte(state);
    }
    else if (strcmp(device_name, ID_LED_BLEUE) == 0)
    {
        commanderLedBleue(state);
    }
});

FauxmoESP utilise un serveur TCP asynchrone mais un serveur de synchronisation UDP. Par conséquent, il faut interroger cycliquement les paquets UDP :

void loop()
{
   fauxmo.handle();

   ...
}

Si l’état du périphérique est modifié par un autre moyen (MQTT, interrupteur, …), il est possible de signaler le nouvel état à Alexa :

fauxmo.setState(ID_LED_ROUGE, true, 255);

Pour la commande de la Led RGB du shield que j’ai utilisé :

#include "pinout.h"

// Shield WEMOS R32 (cf. pinout.h)
#define LED_RGB_ROUGE D9
#define LED_RGB_VERTE D11
#define LED_RGB_BLEUE D10

void commanderLedRouge(bool etat)
{
    digitalWrite(LED_RGB_ROUGE, etat ? HIGH : LOW);
}

void commanderLedVerte(bool etat)
{
    digitalWrite(LED_RGB_VERTE, etat ? HIGH : LOW);
}

void commanderLedBleue(bool etat)
{
    digitalWrite(LED_RGB_BLEUE, etat ? HIGH : LOW);
}

C’est tout !

Ensuite, on va faire détecter les nouveaux appareils par Alexa :

Il est maintenant possible de commander la LED RGB : « Alexa, allume la led verte », « Alexa, allume la led rouge », « Alexa, allume la led bleue », « Alexa, éteins la led rouge » et « Alexa, éteins la led verte » …

La fonction de rappel (callback) est bien appelée :

Code source : wemos-r32.zip

Voir aussi

La bibliothèque : Espalexa

Retour au sommaire