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/ 

Soporte integrado para la integración de Amazon Alexa & Google Assistant a través de skills y acciones de hogar inteligente. También puede crear sus propios skills personalizados.

Se ha incluido un sketch de ejemplo para un dimmer. Echemos un vistazo rápido al código que lo hace posible.

//Este ejemplo demuestra ESP RainMaker con el dimmer
#include "RMaker.h"
#include "WiFi.h"
#include "WiFiProv.h"
#include <RBDdimmer.h>   //Conexión del dimmer al microcontrolador y biblioteca 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 para el botón pulsador
#if CONFIG_IDF_TARGET_ESP32C3
static int gpio_0 = 9;
static int gpio_dimmer = 7;
static int gpio_zerocross  5 // configuración de pines
#else
//GPIO para dispositivo virtual
static int gpio_0 = 0;
static int gpio_dimmer = 23;
static int gpio_zerocross  5 // configuración de pines
#endif
dimmerLamp dimmer(gpio_dimmer, gpio_zerocross);
bool dimmer_state = true; 
// El framework proporciona algunos tipos de dispositivos estándar como interruptor, bombilla, ventilador, sensor de temperatura.
// Pero también puede definir dispositivos personalizados usando el objeto de clase base 'Device', como se muestra aquí
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);   // ATENUACIÓN
    }
}
void setup()
{
    Serial.begin(115200);
    pinMode(gpio_0, INPUT);
    dimmer.begin(NORMAL_MODE, ON);
    Node my_node;    
    my_node = RMaker.initNode("ESP RainMaker Node");
    //Crear dispositivo dimmer personalizado
    my_device.addNameParam();
    my_device.addPowerParam(DEFAULT_POWER_MODE);
    my_device.assignPrimaryParam(my_device.getParamByName(ESP_RMAKER_DEF_POWER_NAME));
    //Crear y agregar un parámetro de nivel personalizado
    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);
    
    //Agregar dispositivo dimmer personalizado al nodo   
    my_node.addDevice(my_device);
    //Esto es opcional 
    RMaker.enableOTA(OTA_USING_PARAMS);
    //Si desea habilitar la programación, establezca la zona horaria de su región usando setTimeZone(). 
    //La lista de valores disponibles se encuentra aquí https://rainmaker.espressif.com/docs/time-service.html
    // RMaker.setTimeZone("Asia/Shanghai");
    // Alternativamente, habilite el servicio de zona horaria y deje que las aplicaciones móviles establezcan la zona horaria apropiada
    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) { //Botón pulsador presionado
        // Manejo del rebote del botón
        delay(100);
        int startTime = millis();
        while(digitalRead(gpio_0) == LOW) delay(50);
        int endTime = millis();
        if ((endTime - startTime) > 10000) {
          // Si el botón se mantiene más de 10 segundos, restablecer todo
          Serial.printf("Reset to factory.\n");
          RMakerFactoryReset(2);
        } else if ((endTime - startTime) > 3000) {
          Serial.printf("Reset Wi-Fi.\n");
          // Si el botón se mantiene más de 3 segundos, pero menos de 10, restablecer Wi-Fi
          RMakerWiFiReset(2);
        } else {
          // Alternar el estado 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);
}

El interruptor se puede controlar con la aplicación móvil, así como con los skills de los asistentes de voz Alexa y Google.

Cuando ejecutamos este código:

• El dispositivo primero verificará si hay una red Wi-Fi configurada. Si la red no está configurada, se iniciará el proceso de aprovisionamiento. El dispositivo puede entonces configurarse usando las aplicaciones móviles mencionadas anteriormente.
• Si se encuentra una configuración Wi-Fi, se conectará a la red configurada.
• Una vez conectado, se conectará a la nube de RainMaker y buscará comandos para modificar sus parámetros (el estado del interruptor en este caso).
• El dispositivo también buscará comandos en la red Wi-Fi local.
• Cuando alguien cambia el estado del interruptor usando aplicaciones móviles o integraciones de voz, se llama a la función write_callback().

Primeros pasos

Antes de comenzar, algunos puntos a tener en cuenta

• 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 vez que su Arduino esté configurado con el soporte de ESP32, siga estos pasos

1. Abra Arduino IDE, vaya a Tools y configure lo siguiente

• Board: «ESP32 Dev Module»
• Flash Size: «4MB» (según su controlador ESP32)
• Partition Scheme: «RainMaker»
• Core Debug Level: «Info»
• Port: Elija el puerto ESP32 apropiado según su plataforma host de la lista. Conectando/desconectando su placa ESP32, puede determinar el número de puerto.

2. Cargue el sketch en su placa ESP32 haciendo clic en el botón Upload en el IDE, o vaya a Sketch -> Upload

3. Vaya a Tools -> Serial Monitor. Elija 115200 como velocidad en baudios. Si no ve nada en la ventana del monitor, reinicie su placa (usando el botón RST).

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

5. Siga las instrucciones en el Serial Monitor para agregar el interruptor desde la aplicación RainMaker. (Si no ve las instrucciones, verifique la opción «Core Debug Level: Info» en Tools)

Cualquier control desde la aplicación móvil debería reflejarse ahora en el dispositivo y cualquier cambio en el dispositivo (presionando el botón BOOT) debería reflejarse en la aplicación móvil.