Amazon Echo...nodeMCU (ESP8266)...e codice Arduino

Buona vigilia a tutti. Siccome sono a casa (…ma guarda un pò) mi diverto. Ora sto testando l’integrazione di Arduino (codice) con Alexa. La scheda che utlizzo (non avendo ancora un Arduino wifi) è una nodeMCU con ESP8266 che utilizza appunto il codice di Arduino. Come da mia abitudine, ho cercato sul web e trovato un bel codice che gira bene ed il dispositivo si integra con Alexa.
Come potete vedere il codice include un if legato al valore brightness richiamato da “uint8_t” per ogni lampada…almeno così ho capito. Ora volendo togliere tale “parametro” ed avere semplicemente due stati i due stati on ed off…dove diamine li inserisco…overo quale parametro devo/posso prendere a riferimento?

Intanto capovolgendo il valore del ciclo if e le condizioni ho ottenuto la logica che volevo. Ma non so se lo stratagemma sia corretto.

#ifdef ARDUINO_ARCH_ESP32
#include <WiFi.h>
#else
#include <ESP8266WiFi.h>
#endif
#include <Espalexa.h>
// define the GPIO connected with Relays
#define RelayPin1 5  //D1
#define RelayPin2 4  //D2
#define RelayPin3 13 //D7
#define RelayPin4 14 //D5
#define RelayPin5 12 //D6

// prototypes
boolean connectWifi();

//callback functions
void firstLightChanged(uint8_t brightness);
void secondLightChanged(uint8_t brightness);
void thirdLightChanged(uint8_t brightness);
void fourthLightChanged(uint8_t brightness);
void fifthLightChanged(uint8_t brightness);

// WiFi Credentials
omesso

// device names
String Device_1_Name = "Room light";
String Device_2_Name = "Blue bulb";
String Device_3_Name = "Yellow bulb";
String Device_4_Name = "Red bulb";
String Device_5_Name = "CFL bulb";

boolean wifiConnected = false;

Espalexa espalexa;

void setup()
{
  Serial.begin(9600);

  pinMode(RelayPin1, OUTPUT);
  pinMode(RelayPin2, OUTPUT);
  pinMode(RelayPin3, OUTPUT);
  pinMode(RelayPin4, OUTPUT);
  pinMode(RelayPin5, OUTPUT);

  // Initialise wifi connection
  wifiConnected = connectWifi();

  if (wifiConnected)
  {
    // Define your devices here.
    espalexa.addDevice(Device_1_Name, firstLightChanged); //simplest definition, default state off
    espalexa.addDevice(Device_2_Name, secondLightChanged);
    espalexa.addDevice(Device_3_Name, thirdLightChanged);
    espalexa.addDevice(Device_4_Name, fourthLightChanged);
    espalexa.addDevice(Device_5_Name, fifthLightChanged);

    espalexa.begin();
  }
  else
  {
    while (1)
    {
      Serial.println("Cannot connect to WiFi. Please check data and reset the ESP.");
      delay(2500);
    }
  }
}

void loop()
{
  espalexa.loop();
  delay(1);
}

//our callback functions
void firstLightChanged(uint8_t brightness)
{
  //Control the device
  if (brightness == 255)
    {
      digitalWrite(RelayPin1, HIGH);
      Serial.println("Device1 ON");
    }
  else
  {
    digitalWrite(RelayPin1, LOW);
    Serial.println("Device1 OFF");
  }
}

void secondLightChanged(uint8_t brightness)
{
  //Control the device 
  if (brightness == 255)
    {
      digitalWrite(RelayPin2, HIGH);
      Serial.println("Device2 ON");
    }
  else
  {
    digitalWrite(RelayPin2, LOW);
    Serial.println("Device2 OFF");
  }
}

void thirdLightChanged(uint8_t brightness)
{
  //Control the device  
  if (brightness == 255)
    {
      digitalWrite(RelayPin3, HIGH);
      Serial.println("Device3 ON");
    }
  else
  {
    digitalWrite(RelayPin3, LOW);
    Serial.println("Device3 OFF");
  }
}

void fourthLightChanged(uint8_t brightness)
{
  //Control the device 
  if (brightness == 255)
    {
      digitalWrite(RelayPin4, HIGH);
      Serial.println("Device4 ON");
    }
  else
  {
    digitalWrite(RelayPin4, LOW);
    Serial.println("Device4 OFF");
  }
}

void fifthLightChanged(uint8_t brightness)
{
  //Control the device 
  if (brightness == 255)
    {
      digitalWrite(RelayPin5, HIGH);
      Serial.println("Device5 ON");
    }
  else
  {
    digitalWrite(RelayPin5, LOW);
    Serial.println("Device5 OFF");
  }
}

// connect to wifi  returns true if successful or false if not
boolean connectWifi()
{
  boolean state = true;
  int i = 0;

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("");
  Serial.println("Connecting to WiFi");

  // Wait for connection
  Serial.print("Connecting...");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (i > 20) {
      state = false; break;
    }
    i++;
  }
  Serial.println("");
  if (state) {
    Serial.print("Connected to ");
    Serial.println(ssid);
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  }
  else {
    Serial.println("Connection failed.");
  }
  return state;
}

Non puoi.
Se definisci un dispositivo Alexa di tipo "Lampada" esso è dimmerabile ovvero puoi variarne intensità luminosa. Se poi lampada a colori allora hai pure i colori.
Per un led io lo definirei di tipo "Presa" che può essere solo acceso/spento

...quindi se ho ben capito basta settarlo in Alexa come presa e NON come lampada.
Comunque non facevo alcun riferimento a lampada ma mi riferivo genericamente ad uno switch o rele. Volendo però eliminare il parametro brightness e lasciare che l'if sia pilotato da un altro genere di input...come faccio?
E' questo "uint8_t" che mi disorienta.

vince59:
E' questo "uint8_t" che mi disorienta.

uint8_t sta semplicemente per unsigned interger 8 bit ovvero unsigned char che in Arduino equivale anche a byte

vince59:
E’ questo “uint8_t” che mi disorienta.

Altra bacchettata …
… vatti a studiare <stdint.h> che fa parte di AVR libc che … dovresti ben conoscere … :smiling_imp: :smiling_imp: :smiling_imp:

Guglielmo

gpb01:
Altra bacchettata …
… vatti a studiare <stdint.h> che fa parte di AVR libc che … dovresti ben conoscere … :smiling_imp: :smiling_imp: :smiling_imp:

Guglielmo

Di sicuro approfondirò. Ma il quesito principale riguarda il fatto che nei vari void del codice si parte con un if che è “condizionato” dal verificarsi della condizione. Ora io mi chiedo: nel caso specifico di questo codice come si fa a sostituire quella condizione legata ad un parametro variabile con una condizione legata invece ad uno stato tipo 0/1. NOn so se spiego.

... NO, non ho capito ... 0 e 1, oppure true e false, sono due uint8_t ... puoi comunque passarli come parametro o ... cosa vorresti invece?

Magari fai un diagrammino se è difficile spiegare direttamente con il codice o metti dello pseudo-codice :slight_smile:

Guglielmo

Gug, cerco di spiegare - quello che ho capito smanettando - anche se ho un pò di Berlucchi e panettone Borsari in circolo :blush:
Premetto che - come da oggetto - sto caricando codici Arduino su nodeMCU per successiva integrazione su Amazon Echo.
Una volta caricato il codice, il dispositivo viene correttamente visto e risponde ai comandi di Alexa.
I dispositivi vengono visti come lampadina (devo smanettare per vedere se possbile farlo vedere come presa) ed è quindi presente sul menù, una barra con cui dimmerare la lampada anche se nel codice si parla di pin rele. Ancora non mi è chiaro se la barra dimmer appare per default di Alexa OPPURE perchè è previsto nel codice. Fatto è che il comando vocale al momento lavora con accendi/spegni. Mentre l’interfaccia grafica sul cell lavora con il pulsante on/off ma ANCHE con lo slider che dovrebbe regolare la luminosità. Ovvero muovendolo accende ma NON spegne. Ora io vorrei:

  • capire per bene il funzionamento del codice laddove parte con l’if condizionato dal valore brightness;
  • avere un codice con un “semplice” on/off…passami il termine…non condizionato.
    Se non sono stato chiaro nemmeno questa volta non mi rimane che salire in macchina e raggkunngerti sfidando la notte ed il DPCM.

nid69ita:
Non puoi.
Se definisci un dispositivo Alexa di tipo “Lampada” esso è dimmerabile ovvero puoi variarne intensità luminosa. Se poi lampada a colori allora hai pure i colori.
Per un led io lo definirei di tipo “Presa” che può essere solo acceso/spento

Ho studiato qualcosa…e qualcosa è più chiaro. Però rimangono degli interrogativi:

  • come si fa a definire un dispositivo in maniera diversa da “lampada”?..ci ho provato attraverso l’app ma non riesco o non funziona. Ovvero la faccio rilevare come presa e viene semprea aggiunta come lampada;
  • non ho compreso cosa significa o a cosa serva il “brightness” nella seguente linea di codice che richiama una callback void:

void firstLightChanged(uint8_t brightness);

PS: forse ci sono arrivato…è la librera ESPAlexa che prevede la modalità lampada.

Cercando sul web ho trovato il codice che segue che sono riuscito a far girare attraverso la IDE di Arduino sia su ESP8266 che su nodeMCU. Il codice è per me molto avanzato ma riesco a comprendere i blocchi. Questo codice comanda un solo dispositivo ed io vorrei farne comandare di più. Da qui la domanda che crco di rendere chiara.
Per avere un secondo dispositivo è sufficente “duplicare” tutto ciò che riguarda ilprio dispositivo (linee di codice e vari void) o c’è altro su cui lavorare? Una prima prova fatta ha dato risultato negativo in quanto non partiva la connessione.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <WiFiUdp.h>
#include <functional>

void prepareIds();
boolean connectWifi();
boolean connectUDP();
void startHttpServer();
void turnOnRelay();
void turnOffRelay();
void sendRelayState();

const char* ssid = "i";  // CHANGE: Wifi name
const char* password = "";  // CHANGE: Wifi password 
String friendlyName = "presa";        // CHANGE: Alexa device name

const int relayPin = 2;  // 2: ESP pin del nodeMCU - ESP8266 1: BLUE led, 2: GPIO2 (PIN 3 vicino al GND)

//More info: https://github.com/esp8266/Arduino/blob/master/variants/d1_mini/pins_arduino.h#L49-L61

WiFiUDP UDP;
IPAddress ipMulti(239, 255, 255, 250);
ESP8266WebServer HTTP(80);
boolean udpConnected = false;
unsigned int portMulti = 1900;      // local port to listen on
unsigned int localPort = 1900;      // local port to listen on
boolean wifiConnected = false;
boolean relayState = false;
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
String serial;
String persistent_uuid;
boolean cannotConnectToWifi = false;

void setup() {
  Serial.begin(9600);

  // Setup Relay
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH);
  
  prepareIds();
  
  // Initialise wifi connection
  wifiConnected = connectWifi();

  // only proceed if wifi connection successful
  if(wifiConnected){
    Serial.println("Ask Alexa to discover devices");
    udpConnected = connectUDP();
    
    if (udpConnected){
      // initialise pins if needed 
      startHttpServer();
    }
  }  
}

void loop() {

  HTTP.handleClient();
  delay(1);
  
  
  // if there's data available, read a packet
  // check if the WiFi and UDP connections were successful
  if(wifiConnected){
    if(udpConnected){    
      // if there’s data available, read a packet
      int packetSize = UDP.parsePacket();
      
      if(packetSize) {
        //Serial.println("");
        //Serial.print("Received packet of size ");
        //Serial.println(packetSize);
        //Serial.print("From ");
        IPAddress remote = UDP.remoteIP();
        
        for (int i =0; i < 4; i++) {
          Serial.print(remote[i], DEC);
          if (i < 3) {
            Serial.print(".");
          }
        }
        
        Serial.print(", port ");
        Serial.println(UDP.remotePort());
        
        int len = UDP.read(packetBuffer, 255);
        
        if (len > 0) {
            packetBuffer[len] = 0;
        }

        String request = packetBuffer;
        //Serial.println("Request:");
        //Serial.println(request);
        
        // Issue https://github.com/kakopappa/arduino-esp8266-alexa-wemo-switch/issues/24 fix
        if(request.indexOf("M-SEARCH") >= 0) {
            // Issue https://github.com/kakopappa/arduino-esp8266-alexa-multiple-wemo-switch/issues/22 fix
            //if(request.indexOf("urn:Belkin:device:**") > 0) {
             if((request.indexOf("urn:Belkin:device:**") > 0) || (request.indexOf("ssdp:all") > 0) || (request.indexOf("upnp:rootdevice") > 0)) {
                Serial.println("Responding to search request ...");
                respondToSearch();
             }
        }
      }
        
      delay(10);
    }
  } else {
      Serial.println("Cannot connect to Wifi");
  }
}

void prepareIds() {
  uint32_t chipId = ESP.getChipId();
  char uuid[64];
  sprintf_P(uuid, PSTR("38323636-4558-4dda-9188-cda0e6%02x%02x%02x"),
        (uint16_t) ((chipId >> 16) & 0xff),
        (uint16_t) ((chipId >>  8) & 0xff),
        (uint16_t)   chipId        & 0xff);

  serial = String(uuid);
  persistent_uuid = "Socket-1_0-" + serial;
}

void respondToSearch() {
    Serial.println("");
    Serial.print("Sending response to ");
    Serial.println(UDP.remoteIP());
    Serial.print("Port : ");
    Serial.println(UDP.remotePort());

    IPAddress localIP = WiFi.localIP();
    char s[16];
    sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);

    String response = 
         "HTTP/1.1 200 OK\r\n"
         "CACHE-CONTROL: max-age=86400\r\n"
         "DATE: Fri, 15 Apr 2016 04:56:29 GMT\r\n"
         "EXT:\r\n"
         "LOCATION: http://" + String(s) + ":80/setup.xml\r\n"
         "OPT: \"http://schemas.upnp.org/upnp/1/0/\"; ns=01\r\n"
         "01-NLS: b9200ebb-736d-4b93-bf03-835149d13983\r\n"
         "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n"
         "ST: urn:Belkin:device:**\r\n"
         "USN: uuid:" + persistent_uuid + "::urn:Belkin:device:**\r\n"
         "X-User-Agent: redsonic\r\n\r\n";
  
    // Try changing to this if you have problems discovering
    /* https://github.com/kakopappa/arduino-esp8266-alexa-wemo-switch/issues/26
    String response =
      "HTTP/1.1 200 OK\r\n"
      "CACHE-CONTROL: max-age=86400\r\n"
      "DATE: Fri, 15 Apr 2016 04:56:29 GMT\r\n"
      "EXT:\r\n"
      "LOCATION: http://" + String(s) + ":80/setup.xml\r\n"
      "OPT: "http://schemas.upnp.org/upnp/1/0/\"; ns=01\r\n"
      "01-NLS: b9200ebb-736d-4b93-bf03-835149d13983\r\n"
      "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n"
      "ST: ssdp:all\r\n"
      "USN: uuid:" + persistent_uuid + "::upnp:rootdevice\r\n"
      "X-User-Agent: redsonic\r\n\r\n";
    */

    UDP.beginPacket(UDP.remoteIP(), UDP.remotePort());
    UDP.write(response.c_str());
    UDP.endPacket();                    

    /* add yield to fix UDP sending response. For more informations : https://www.tabsoverspaces.com/233359-udp-packets-not-sent-from-esp-8266-solved */
    yield(); 
  
    Serial.println("Response sent !");
}

void startHttpServer() {
    HTTP.on("/index.html", HTTP_GET, [](){
      Serial.println("Got Request index.html ...\n");
      HTTP.send(200, "text/plain", "Hello World!");
    });

    HTTP.on("/upnp/control/basicevent1", HTTP_POST, []() {
      Serial.println("########## Responding to  /upnp/control/basicevent1 ... ##########");      

      //for (int x=0; x <= HTTP.args(); x++) {
      //  Serial.println(HTTP.arg(x));
      //}
  
      String request = HTTP.arg(0);      
      Serial.print("request:");
      Serial.println(request);

seconda parte codice

 if(request.indexOf("SetBinaryState") >= 0) {
        if(request.indexOf("<BinaryState>1</BinaryState>") >= 0) {
            Serial.println("Got Turn on request");
            turnOnRelay();
        }
  
        if(request.indexOf("<BinaryState>0</BinaryState>") >= 0) {
            Serial.println("Got Turn off request");
            turnOffRelay();
        }
      }

      if(request.indexOf("GetBinaryState") >= 0) {
        Serial.println("Got binary state request");
        sendRelayState();
      }
            
      HTTP.send(200, "text/plain", "");
    });

    HTTP.on("/eventservice.xml", HTTP_GET, [](){
      Serial.println(" ########## Responding to eventservice.xml ... ########\n");
      
      String eventservice_xml = "<scpd xmlns=\"urn:Belkin:service-1-0\">"
        "<actionList>"
          "<action>"
            "<name>SetBinaryState</name>"
            "<argumentList>"
              "<argument>"
                "<retval/>"
                "<name>BinaryState</name>"
                "<relatedStateVariable>BinaryState</relatedStateVariable>"
                "<direction>in</direction>"
                "</argument>"
            "</argumentList>"
          "</action>"
          "<action>"
            "<name>GetBinaryState</name>"
            "<argumentList>"
              "<argument>"
                "<retval/>"
                "<name>BinaryState</name>"
                "<relatedStateVariable>BinaryState</relatedStateVariable>"
                "<direction>out</direction>"
                "</argument>"
            "</argumentList>"
          "</action>"
      "</actionList>"
        "<serviceStateTable>"
          "<stateVariable sendEvents=\"yes\">"
            "<name>BinaryState</name>"
            "<dataType>Boolean</dataType>"
            "<defaultValue>0</defaultValue>"
           "</stateVariable>"
           "<stateVariable sendEvents=\"yes\">"
              "<name>level</name>"
              "<dataType>string</dataType>"
              "<defaultValue>0</defaultValue>"
           "</stateVariable>"
        "</serviceStateTable>"
        "</scpd>\r\n"
        "\r\n";
            
      HTTP.send(200, "text/plain", eventservice_xml.c_str());
    });
    
    HTTP.on("/setup.xml", HTTP_GET, [](){
      Serial.println(" ########## Responding to setup.xml ... ########\n");

      IPAddress localIP = WiFi.localIP();
      char s[16];
      sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);
    
      String setup_xml = "<?xml version=\"1.0\"?>"
            "<root>"
             "<device>"
                "<deviceType>urn:Belkin:device:controllee:1</deviceType>"
                "<friendlyName>"+ friendlyName +"</friendlyName>"
                "<manufacturer>Belkin International Inc.</manufacturer>"
                "<modelName>Socket</modelName>"
                "<modelNumber>3.1415</modelNumber>"
                "<modelDescription>Belkin Plugin Socket 1.0</modelDescription>\r\n"
                "<UDN>uuid:"+ persistent_uuid +"</UDN>"
                "<serialNumber>221517K0101769</serialNumber>"
                "<binaryState>0</binaryState>"
                "<serviceList>"
                  "<service>"
                      "<serviceType>urn:Belkin:service:basicevent:1</serviceType>"
                      "<serviceId>urn:Belkin:serviceId:basicevent1</serviceId>"
                      "<controlURL>/upnp/control/basicevent1</controlURL>"
                      "<eventSubURL>/upnp/event/basicevent1</eventSubURL>"
                      "<SCPDURL>/eventservice.xml</SCPDURL>"
                  "</service>"
              "</serviceList>" 
              "</device>"
            "</root>\r\n"
            "\r\n";
            
        HTTP.send(200, "text/xml", setup_xml.c_str());
        
        Serial.print("Sending :");
        Serial.println(setup_xml);
    });

    // openHAB support
    HTTP.on("/on.html", HTTP_GET, [](){
         Serial.println("Got Turn on request");
         HTTP.send(200, "text/plain", "turned on");
         turnOnRelay();
       });
 
     HTTP.on("/off.html", HTTP_GET, [](){
        Serial.println("Got Turn off request");
        HTTP.send(200, "text/plain", "turned off");
        turnOffRelay();
       });
 
      HTTP.on("/status.html", HTTP_GET, [](){
        Serial.println("Got status request");
 
        String statrespone = "0"; 
        if (relayState) {
          statrespone = "1"; 
        }
        HTTP.send(200, "text/plain", statrespone);
      
    });
    
    HTTP.begin();  
    Serial.println("HTTP Server started ..");
}
      
// connect to wifi – returns true if successful or false if not
boolean connectWifi(){
  boolean state = true;
  int i = 0;
  
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("");
  Serial.println("Connecting to WiFi");

  // Wait for connection
  Serial.print("Connecting ...");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (i > 10){
      state = false;
      break;
    }
    i++;
  }
  
  if (state){
    Serial.println("");
    Serial.print("Connected to ");
    Serial.println(ssid);
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  }
  else {
    Serial.println("");
    Serial.println("Connection failed.");
  }
  
  return state;
}

boolean connectUDP(){
  boolean state = false;
  
  Serial.println("");
  Serial.println("Connecting to UDP");
  
  if(UDP.beginMulticast(WiFi.localIP(), ipMulti, portMulti)) {
    Serial.println("Connection successful");
    state = true;
  }
  else{
    Serial.println("Connection failed");
  }
  
  return state;
}

//---------------GESTIONE RELE ---------------------------

void turnOnRelay() {
 digitalWrite(relayPin, LOW); // default OFF = LOW; turn on relay with voltage HIGH 
 relayState = true;

  String body = 
      "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><s:Body>\r\n"
      "<u:SetBinaryStateResponse xmlns:u=\"urn:Belkin:service:basicevent:1\">\r\n"
      "<BinaryState>1</BinaryState>\r\n"
      "</u:SetBinaryStateResponse>\r\n"
      "</s:Body> </s:Envelope>";

  HTTP.send(200, "text/xml", body.c_str());
        
  Serial.print("Sending :");
  Serial.println(body);
}

void turnOffRelay() {
  digitalWrite(relayPin, HIGH);  // turn off relay with voltage LOW
  relayState = false;

  String body = 
      "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><s:Body>\r\n"
      "<u:SetBinaryStateResponse xmlns:u=\"urn:Belkin:service:basicevent:1\">\r\n"
      "<BinaryState>0</BinaryState>\r\n"
      "</u:SetBinaryStateResponse>\r\n"
      "</s:Body> </s:Envelope>";

  HTTP.send(200, "text/xml", body.c_str());
        
  Serial.print("Sending :");
  Serial.println(body);
}

void sendRelayState() {
  
  String body = 
      "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><s:Body>\r\n"
      "<u:GetBinaryStateResponse xmlns:u=\"urn:Belkin:service:basicevent:1\">\r\n"
      "<BinaryState>";
      
  body += (relayState ? "1" : "0");
  
  body += "</BinaryState>\r\n"
      "</u:GetBinaryStateResponse>\r\n"
      "</s:Body> </s:Envelope>\r\n";
 
   HTTP.send(200, "text/xml", body.c_str());
}

Bgiorno, capisco che il thread è un pò un mischietto...potete darmi per favore un indicazione di cosa "studiare" per comprendere come aggiungere un dispositivo al codice di cui ai due post precedenti.
L'esigenza è di far si che il dispositivo ricevente rilevi due dispotivi e NON uno solo.
Ho provato in più modi ma alcune parti del codice sono assolutamente fuori della mia portata.

... mai lavorato con Alexa e con codici che ci si interfacciano ... e non so quanti di quelli che frequentano regolarmente lo abbiano fatto ... ho idea che dovrai avere pazienza ... ::slight_smile:

Guglielmo

Grazie Gug. La domanda anche se appare molto specifica mi serve anche, forse soprattutto, per comprendere la logica delle diverse sezioni del codice. Ho cercato di interpretarle secondo la logica delle variabili globali e locali.
Vediamo se qualcuno sa…cmq è molto interessante l’interfacciamento.

nid69ita:
Non puoi.
Se definisci un dispositivo Alexa di tipo "Lampada" esso è dimmerabile ovvero puoi variarne intensità luminosa. Se poi lampada a colori allora hai pure i colori.
Per un led io lo definirei di tipo "Presa" che può essere solo acceso/spento

Ho letto e provato alcuni codici. Non è la definizione che imposti su Alexa che determina come funziona ma è il codice stesso. Ho impostato una dispositivo "presa" come lampada ma la dimemrabilità non è apparsa. E' rimasto on/off come da codice. Viceversa ho impostato la lampada come presa e la dimmerabilità non è scomparsa. Ovviamente NON mi riferisco ai dispositivi plug&play dato che questi indicano direttamente ad alexa cosa sono.

Ciao,
dal readme della libreria vedo:

Device type Notes
EspalexaDeviceType::dimmable Works as intended (dimming)
EspalexaDeviceType::whitespectrum Color temperature adjustment not working on Dot
EspalexaDeviceType::color Works as intended (dimming + color)
EspalexaDeviceType::extendedcolor Color temperature adjustment not working on Dot
EspalexaDeviceType::onoff (experimental) Deprecated. Treated as dimmable.

Quindi si, direi che è la libreria che non ti accetta l'on-off.
Mi sa che non ti resta che impostare una soglia di intervento per attivare o disattivare il relay.

vince59:
L'esigenza è di far si che il dispositivo ricevente rilevi due dispotivi e NON uno solo.

Cosa intendi con "dispositivo ricevente"?
Se non ho capito male vuoi creare una doppia presa comandata, cioè qualcosa che gestisca 2 (o più) relay ma che figuri come un device solo su alexa. Un device con più opzioni, ovviamente.

In questo caso io proverei prima a fare dei semplici test di/tramite lettura seriale, bypassando ogni collegamento fisico.
Quando sei sicuro che il tuo micro e alexa comunichino correttamente poi penserai al cablaggio e a tutta la parte di webserver (che ammetto non aver neanche letto).

In ogni caso, io sono per il "un problema alla volta".
Sempre dal readme:

There is a second way to add devices which is more complicated, but allows you to update device values yourself. In global:

EspalexaDevice* d;
In setup:

d = new EspalexaDevice("Alexa name of the device", firstDeviceChanged);
espalexa.addDevice(d);
As you can see, EspalexaDevice takes the same parameters. However, you can now do stuff like:

d->setValue(22);
uint8_t bri = d->getValue(); //bri will have the device value
String name = d->getName(); //just in case you forget it

Io inizialmente proverei a fare TRE device così e ad assicurarmi che alexa e questa libreria si vogliano bene.

Grazie daysleeper. Sei stato di grande aiuto. Ho letto il readme della libreria tutto chiaro e funziona.
Forse non sono stato chiaro, ma il mio scopo è quello di aggiungere un dispositivo al codice laddove questo ne preveda uno solo. In pratica, Alexa vede un dispositivo ed io voglio aggiungerne un altro.
Problema con ESPAlex risolto...eccezion fatta per la funzone dimmer di cui non ho bisogno se gestiso una presa.
Ora ho trovato un altro codice, con altre librerie, predisposto per gestire prese. Leggo il readme per vedere se ha la possibilità come ESPAlexa.

Se ti funziona tutto a parte l'on/off potresti provare a contattare Aircoookie aprendo un issue su github, vedo che in genere risponde ed è disponibile.
Magari ci metti meno che a implementare altre librerie.

Ho dato un'occhiata alla libreria e per quanto "deprecata" (se non ricordo male proprio da Amazon) c'è anche il supporto per il tipo luce on/off.

Hai provato a guardare l'esempio suggerito?

EspalexaFullyFeatured.ino

Si, in effetti si potrebbe provare un

espalexa.addDevice("Alpha", alphaChanged, EspalexaDeviceType::onoff); //non-dimmable device

perchè in effetti questo tipo di device è deprecated e non obsolete.

Resta il fatto che anche se questa soluzione magari oggi funziona, è comunque a rischio di diventare incompatibile a breve. E comunque resta una soluzione experimental, quindi già ora non la suggerirei se non per test.

Non sarà "elegante" avere uno slider inutile nella schermata di alexa, ma regolando l'attivazione del relay tramite una semplice soglia il funzionamento sta in piedi.