Dimmer with ESP32 – ESP RainMaker Cloud platform + Mobile APP.

ESP RainMaker® is a complete system for building AIoT products with a minimal amount of code, empowering your team to develop and deploy secure, customized AIoT solutions. It covers all Espressif chips and modules, device firmware, voice-assistant integrations, phone apps and cloud backend. This helps you save a large investment in cloud, gain independence and focus on innovating your core-value offering.

In this Dimmer tutorial, we will introduce you to ESP RainMaker with ESP32 using Arduino IDE. Create Arduino code for dimming, upload to the microcontroller, and connect to the mobile APP. https://rainmaker.espressif.com/ 

Integrierte Unterstützung für Amazon Alexa & Google Assistant Integration über Smart-Home-Skills und -Aktionen. Sie können auch eigene benutzerdefinierte Skills erstellen.

Ein Beispiel-Sketch für einen Dimmer ist enthalten. Werfen wir einen kurzen Blick auf den Code, der dies ermöglicht.

//Dieses Beispiel demonstriert ESP RainMaker mit dem Dimmer
#include "RMaker.h"
#include "WiFi.h"
#include "WiFiProv.h"
#include <RBDdimmer.h>   //Dimmer-Anschluss an Mikrocontroller und Arduino-Bibliothek. https://rocketcontroller.com/dimmer-connection-to-microcontroller-and-arduino-library-examples/
#define DEFAULT_POWER_MODE true
#define DEFAULT_DIMMER_LEVEL 50
const char *service_name = "PROV_1234";
const char *pop = "abcd1234";
//GPIO für Taster
#if CONFIG_IDF_TARGET_ESP32C3
static int gpio_0 = 9;
static int gpio_dimmer = 7;
static int gpio_zerocross  5 // Pin-Einstellungen
#else
//GPIO für virtuelles Gerät
static int gpio_0 = 0;
static int gpio_dimmer = 23;
static int gpio_zerocross  5 // Pin-Einstellungen
#endif
dimmerLamp dimmer(gpio_dimmer, gpio_zerocross);
bool dimmer_state = true; 
// Das Framework stellt einige Standardgerätetypen bereit wie Schalter, Glühbirne, Ventilator, Temperatursensor.
// Sie können aber auch benutzerdefinierte Geräte mit dem Basisklassenobjekt 'Device' definieren, wie hier gezeigt
static Device my_device("Dimmer", "custom.device.dimmer", &gpio_dimmer);
void sysProvEvent(arduino_event_t *sys_event)
{
    switch (sys_event->event_id) {      
        case ARDUINO_EVENT_PROV_START:
#if CONFIG_IDF_TARGET_ESP32S2
        Serial.printf("\nProvisioning Started with name \"%s\" and PoP \"%s\" on SoftAP\n", service_name, pop);
        printQR(service_name, pop, "softap");
#else
        Serial.printf("\nProvisioning Started with name \"%s\" and PoP \"%s\" on BLE\n", service_name, pop);
        printQR(service_name, pop, "ble");
#endif        
        break;
        default:;
    }
}
void write_callback(Device *device, Param *param, const param_val_t val, void *priv_data, write_ctx_t *ctx)
{
    const char *device_name = device->getDeviceName();
    const char *param_name = param->getParamName();
    if(strcmp(param_name, "Power") == 0) {
        Serial.printf("Received value = %s for %s - %s\n", val.val.b? "true" : "false", device_name, param_name);
        dimmer_state = val.val.b;
        (dimmer_state == false) ? dimmer.setPower(OFF) : dimmer.setPower(ON);
        param->updateAndReport(val);
    } else if (strcmp(param_name, "Level") == 0) {
        Serial.printf("\nReceived value = %d for %s - %s\n", val.val.i, device_name, param_name);
        param->updateAndReport(val);
        dimmer.setPower(val.val.i);   // DIMMEN
    }
}
void setup()
{
    Serial.begin(115200);
    pinMode(gpio_0, INPUT);
    dimmer.begin(NORMAL_MODE, ON);
    Node my_node;    
    my_node = RMaker.initNode("ESP RainMaker Node");
    //Benutzerdefiniertes Dimmer-Gerät erstellen
    my_device.addNameParam();
    my_device.addPowerParam(DEFAULT_POWER_MODE);
    my_device.assignPrimaryParam(my_device.getParamByName(ESP_RMAKER_DEF_POWER_NAME));
    //Benutzerdefinierten Level-Parameter erstellen und hinzufügen
    Param level_param("Level", "custom.param.level", value(DEFAULT_DIMMER_LEVEL), PROP_FLAG_READ | PROP_FLAG_WRITE);
    level_param.addBounds(value(0), value(100), value(1));
    level_param.addUIType(ESP_RMAKER_UI_SLIDER);
    my_device.addParam(level_param);
    my_device.addCb(write_callback);
    
    //Benutzerdefiniertes Dimmer-Gerät zum Knoten hinzufügen   
    my_node.addDevice(my_device);
    //Dies ist optional 
    RMaker.enableOTA(OTA_USING_PARAMS);
    //Wenn Sie die Zeitplanung aktivieren möchten, setzen Sie die Zeitzone für Ihre Region mit setTimeZone(). 
    //Die Liste der verfügbaren Werte finden Sie hier https://rainmaker.espressif.com/docs/time-service.html
    // RMaker.setTimeZone("Asia/Shanghai");
    // Alternativ aktivieren Sie den Zeitzonen-Dienst und lassen die Telefon-Apps die entsprechende Zeitzone einstellen
    RMaker.enableTZService();
    RMaker.enableSchedule();
    RMaker.start();
    WiFi.onEvent(sysProvEvent);
#if CONFIG_IDF_TARGET_ESP32S2
    WiFiProv.beginProvision(WIFI_PROV_SCHEME_SOFTAP, WIFI_PROV_SCHEME_HANDLER_NONE, WIFI_PROV_SECURITY_1, pop, service_name);
#else
    WiFiProv.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, pop, service_name);
#endif
}
void loop()
{
    if(digitalRead(gpio_0) == LOW) { //Taster gedrückt
        // Tastenentprellung
        delay(100);
        int startTime = millis();
        while(digitalRead(gpio_0) == LOW) delay(50);
        int endTime = millis();
        if ((endTime - startTime) > 10000) {
          // Wenn Taste länger als 10 Sekunden gedrückt, alles zurücksetzen
          Serial.printf("Reset to factory.\n");
          RMakerFactoryReset(2);
        } else if ((endTime - startTime) > 3000) {
          Serial.printf("Reset Wi-Fi.\n");
          // Wenn Taste länger als 3 Sekunden, aber weniger als 10, Wi-Fi zurücksetzen
          RMakerWiFiReset(2);
        } else {
          // Gerätezustand umschalten
          dimmer_state = !dimmer_state;
          Serial.printf("Toggle State to %s.\n", dimmer_state ? "true" : "false");
          my_device.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, dimmer_state);
          (dimmer_state == false) ? dimmer.setPower(OFF) : dimmer.setPower(ON);
      }
    }
    delay(100);
}

Der Schalter kann über die mobile APP sowie über Alexa- und Google Voice Assistant-Skills gesteuert werden.

Wenn wir diesen Code ausführen:

• Das Gerät prüft zunächst, ob ein Wi-Fi-Netzwerk konfiguriert ist. Wenn das Netzwerk nicht konfiguriert ist, wird der Provisioning-Prozess gestartet. Das Gerät kann dann mit den oben genannten Telefon-Apps konfiguriert werden.
• Wenn eine Wi-Fi-Konfiguration gefunden wird, verbindet es sich mit dem konfigurierten Netzwerk.
• Nach der Verbindung stellt es eine Verbindung zur RainMaker-Cloud her und wartet auf Befehle zur Änderung seiner Parameter (in diesem Fall der Schalterzustand).
• Das Gerät sucht auch nach Befehlen im lokalen Wi-Fi-Netzwerk.
• Wenn jemand den Schalterzustand über Telefon-Apps oder Sprachintegrationen ändert, wird die Funktion write_callback() aufgerufen.

Erste Schritte

Bevor Sie beginnen, beachten Sie einige Punkte

• For using RainMaker, you first have to get started with the ESP32 support in Arduino.
• RainMaker support is not yet part of a stable esp32-arduino release. So we will use the master branch of the ESP32 Arduino repository. We will update here and elsewhere once this support is available in a stable release.

Sobald Ihre Arduino-Umgebung mit ESP32-Unterstützung eingerichtet ist, folgen Sie diesen Schritten

1. Öffnen Sie die Arduino IDE, gehen Sie zu Tools und stellen Sie Folgendes ein

• Board: „ESP32 Dev Module"
• Flash Size: „4MB" (entsprechend Ihres ESP32-Controllers)
• Partition Scheme: „RainMaker"
• Core Debug Level: „Info"
• Port: Wählen Sie den entsprechenden ESP32-Port je nach Ihrer Host-Plattform aus der Liste. Durch An-/Abstecken Ihres ESP32-Boards können Sie die Portnummer ermitteln.

2. Laden Sie den Sketch auf Ihr ESP32-Board hoch, indem Sie auf die Upload-Schaltfläche in der IDE klicken, oder gehen Sie zu Sketch -> Upload

3. Gehen Sie zu Tools -> Serial Monitor. Wählen Sie 115200 als Baudrate. Wenn im Monitor-Fenster nichts angezeigt wird, setzen Sie Ihr Board zurück (über die RST-Taste).

4. Download the ESP RainMaker phone app, sign-up or sign-in and you are ready to go.

5. Folgen Sie den Anweisungen im Serial Monitor, um den Schalter über die RainMaker-App hinzuzufügen. (Wenn die Anweisungen nicht angezeigt werden, überprüfen Sie die Option „Core Debug Level: Info" unter Tools)

Jede Steuerung über die Telefon-App sollte sich nun auf dem Gerät widerspiegeln, und jede Änderung am Gerät (durch Drücken der BOOT-Taste) sollte in der mobilen App angezeigt werden.