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/ 

Supporto integrato per l'integrazione con Amazon Alexa & Google Assistant tramite skill e azioni per la casa intelligente. È possibile anche creare skill personalizzati.

È incluso uno sketch di esempio per un dimmer. Diamo una rapida occhiata al codice che rende tutto questo possibile.

//Questo esempio dimostra ESP RainMaker con il dimmer
#include "RMaker.h"
#include "WiFi.h"
#include "WiFiProv.h"
#include <RBDdimmer.h>   //Collegamento del dimmer al microcontroller e libreria 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 per il pulsante
#if CONFIG_IDF_TARGET_ESP32C3
static int gpio_0 = 9;
static int gpio_dimmer = 7;
static int gpio_zerocross  5 // configurazione dei pin
#else
//GPIO per il dispositivo virtuale
static int gpio_0 = 0;
static int gpio_dimmer = 23;
static int gpio_zerocross  5 // configurazione dei pin
#endif
dimmerLamp dimmer(gpio_dimmer, gpio_zerocross);
bool dimmer_state = true; 
// Il framework fornisce alcuni tipi di dispositivi standard come interruttore, lampadina, ventilatore, sensore di temperatura.
// Ma è possibile anche definire dispositivi personalizzati utilizzando l'oggetto della classe base 'Device', come mostrato qui
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);   // DIMMERIZZAZIONE
    }
}
void setup()
{
    Serial.begin(115200);
    pinMode(gpio_0, INPUT);
    dimmer.begin(NORMAL_MODE, ON);
    Node my_node;    
    my_node = RMaker.initNode("ESP RainMaker Node");
    //Creare un dispositivo dimmer personalizzato
    my_device.addNameParam();
    my_device.addPowerParam(DEFAULT_POWER_MODE);
    my_device.assignPrimaryParam(my_device.getParamByName(ESP_RMAKER_DEF_POWER_NAME));
    //Creare e aggiungere un parametro di livello personalizzato
    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);
    
    //Aggiungere il dispositivo dimmer personalizzato al nodo   
    my_node.addDevice(my_device);
    //Questo è opzionale 
    RMaker.enableOTA(OTA_USING_PARAMS);
    //Se si desidera abilitare la pianificazione, impostare il fuso orario della propria regione con setTimeZone(). 
    //L'elenco dei valori disponibili è fornito qui https://rainmaker.espressif.com/docs/time-service.html
    // RMaker.setTimeZone("Asia/Shanghai");
    // In alternativa, abilitare il servizio di fuso orario e lasciare che le app impostino il fuso orario appropriato
    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) { //Pulsante premuto
        // Gestione dell'antirimbalzo
        delay(100);
        int startTime = millis();
        while(digitalRead(gpio_0) == LOW) delay(50);
        int endTime = millis();
        if ((endTime - startTime) > 10000) {
          // Se il pulsante viene tenuto premuto per più di 10 secondi, ripristinare tutto
          Serial.printf("Reset to factory.\n");
          RMakerFactoryReset(2);
        } else if ((endTime - startTime) > 3000) {
          Serial.printf("Reset Wi-Fi.\n");
          // Se il pulsante viene tenuto premuto per più di 3 secondi, ma meno di 10, ripristinare il Wi-Fi
          RMakerWiFiReset(2);
        } else {
          // Commutare lo stato del dispositivo
          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'interruttore può essere controllato tramite l'applicazione mobile, nonché con gli skill degli assistenti vocali Alexa e Google.

Quando eseguiamo questo codice:

• Il dispositivo verificherà innanzitutto se è configurata una rete Wi-Fi. Se la rete non è configurata, verrà avviato il processo di provisioning. Il dispositivo può quindi essere configurato utilizzando le applicazioni mobili menzionate sopra.
• Se viene trovata una configurazione Wi-Fi, si connetterà alla rete configurata.
• Una volta connesso, si collegherà al cloud RainMaker e attenderà comandi per modificare i propri parametri (in questo caso lo stato dell'interruttore).
• Il dispositivo cercherà anche comandi nella rete Wi-Fi locale.
• Quando qualcuno modifica lo stato dell'interruttore tramite le applicazioni mobili o le integrazioni vocali, viene chiamata la funzione write_callback().

Per iniziare

Prima di iniziare, alcuni punti da tenere presente

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

Una volta configurato Arduino con il supporto ESP32, seguire questi passaggi

1. Aprire l'Arduino IDE, andare su Tools e impostare quanto segue

• Board: «ESP32 Dev Module»
• Flash Size: «4MB» (in base al proprio controller ESP32)
• Partition Scheme: «RainMaker»
• Core Debug Level: «Info»
• Port: Scegliere la porta ESP32 appropriata in base alla propria piattaforma host dall'elenco. Collegando/scollegando la scheda ESP32, è possibile determinare il numero di porta.

2. Caricare lo sketch sulla scheda ESP32 facendo clic sul pulsante Upload nell'IDE, oppure andare su Sketch -> Upload

3. Andare su Tools -> Serial Monitor. Scegliere 115200 come velocità in baud. Se non si vede nulla nella finestra del monitor, resettare la scheda (usando il pulsante RST).

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

5. Seguire le istruzioni nel Serial Monitor per aggiungere l'interruttore dall'applicazione RainMaker. (Se le istruzioni non vengono visualizzate, verificare l'opzione «Core Debug Level: Info» in Tools)

Qualsiasi controllo dall'applicazione mobile dovrebbe ora riflettersi sul dispositivo e qualsiasi modifica sul dispositivo (premendo il pulsante BOOT) dovrebbe riflettersi nell'applicazione mobile.