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/ 

Prise en charge intégrée de l'intégration Amazon Alexa & Google Assistant via les skills et actions de maison connectée. Vous pouvez également créer vos propres skills personnalisés.

Un sketch d'exemple pour un variateur a été inclus. Examinons rapidement le code qui rend cela possible.

//Cet exemple illustre ESP RainMaker avec le variateur
#include "RMaker.h"
#include "WiFi.h"
#include "WiFiProv.h"
#include <RBDdimmer.h>   //Connexion du variateur au microcontrôleur et bibliothèque Arduino. 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 pour le bouton-poussoir
#if CONFIG_IDF_TARGET_ESP32C3
static int gpio_0 = 9;
static int gpio_dimmer = 7;
static int gpio_zerocross  5 // configuration des broches
#else
//GPIO pour le périphérique virtuel
static int gpio_0 = 0;
static int gpio_dimmer = 23;
static int gpio_zerocross  5 // configuration des broches
#endif
dimmerLamp dimmer(gpio_dimmer, gpio_zerocross);
bool dimmer_state = true; 
// Le framework fournit des types d'appareils standard comme interrupteur, ampoule, ventilateur, capteur de température.
// Mais vous pouvez aussi définir des appareils personnalisés en utilisant l'objet de classe de base 'Device', comme montré ici
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);   // VARIATION
    }
}
void setup()
{
    Serial.begin(115200);
    pinMode(gpio_0, INPUT);
    dimmer.begin(NORMAL_MODE, ON);
    Node my_node;    
    my_node = RMaker.initNode("ESP RainMaker Node");
    //Créer un périphérique variateur personnalisé
    my_device.addNameParam();
    my_device.addPowerParam(DEFAULT_POWER_MODE);
    my_device.assignPrimaryParam(my_device.getParamByName(ESP_RMAKER_DEF_POWER_NAME));
    //Créer et ajouter un paramètre de niveau personnalisé
    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);
    
    //Ajouter le périphérique variateur personnalisé au nœud   
    my_node.addDevice(my_device);
    //Ceci est optionnel 
    RMaker.enableOTA(OTA_USING_PARAMS);
    //Si vous voulez activer la planification, définissez le fuseau horaire de votre région avec setTimeZone(). 
    //La liste des valeurs disponibles est fournie ici https://rainmaker.espressif.com/docs/time-service.html
    // RMaker.setTimeZone("Asia/Shanghai");
    // Vous pouvez aussi activer le service de fuseau horaire et laisser les applications mobiles définir le fuseau approprié
    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) { //Bouton-poussoir appuyé
        // Gestion de l'anti-rebond
        delay(100);
        int startTime = millis();
        while(digitalRead(gpio_0) == LOW) delay(50);
        int endTime = millis();
        if ((endTime - startTime) > 10000) {
          // Si le bouton est appuyé pendant plus de 10 s, tout réinitialiser
          Serial.printf("Reset to factory.\n");
          RMakerFactoryReset(2);
        } else if ((endTime - startTime) > 3000) {
          Serial.printf("Reset Wi-Fi.\n");
          // Si le bouton est appuyé pendant plus de 3 s mais moins de 10, réinitialiser le Wi-Fi
          RMakerWiFiReset(2);
        } else {
          // Basculer l'état de l'appareil
          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);
}

L'interrupteur peut être contrôlé avec l'application mobile, ainsi qu'avec les skills Alexa et Google Voice Assistant.

Lorsque nous exécutons ce code :

• L'appareil vérifie d'abord si un réseau Wi-Fi est configuré. Si le réseau n'est pas configuré, il lance le processus de provisionnement. L'appareil peut alors être configuré à l'aide des applications mobiles mentionnées ci-dessus.
• Si une configuration Wi-Fi est trouvée, il se connecte au réseau configuré.
• Une fois connecté, il se connecte au cloud RainMaker, à la recherche de commandes pour modifier ses paramètres (l'état de l'interrupteur dans ce cas).
• L'appareil recherche également des commandes sur le réseau Wi-Fi local.
• Lorsque quelqu'un modifie l'état de l'interrupteur via les applications mobiles ou les intégrations vocales, la fonction write_callback() est appelée.

Prise en main

Avant de commencer, quelques points à noter

• 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.

Une fois votre Arduino configuré avec le support ESP32, suivez ces étapes

1. Ouvrez Arduino IDE, allez dans Outils et définissez les paramètres suivants

• Board : « ESP32 Dev Module »
• Flash Size : « 4MB » (selon votre contrôleur ESP32)
• Partition Scheme : « RainMaker »
• Core Debug Level : « Info »
• Port : Choisissez le port ESP32 approprié selon votre plateforme hôte dans la liste. En connectant/déconnectant votre carte ESP32, vous pouvez identifier le numéro de port.

2. Téléversez le sketch sur votre carte ESP32 en cliquant sur le bouton Téléverser dans l'IDE, ou en allant dans Sketch -> Upload

3. Allez dans Outils -> Moniteur série. Choisissez 115200 comme débit en bauds. Si vous ne voyez rien dans la fenêtre du moniteur, réinitialisez votre carte (avec le bouton RST).

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

5. Suivez les instructions dans le moniteur série pour ajouter l'interrupteur depuis l'application RainMaker. (Si vous ne voyez pas les instructions, vérifiez l'option « Core Debug Level: Info » dans Outils)

Tout contrôle depuis l'application mobile devrait maintenant se refléter sur l'appareil et tout changement sur l'appareil (en appuyant sur le bouton BOOT) devrait se refléter dans l'application mobile.