Main Content

Questa pagina è stata tradotta con la traduzione automatica. Fai clic qui per vedere l'ultima versione in inglese.

Aggiornamento dei canali e controllo della luce con ESP32

Apri live script

Questo esempio mostra come aggiornare il tuo canale e recuperare i comandi da una coda TalkBack ThingSpeak™ . Utilizza i comandi per modificare lo stato del LED integrato.

Utilizza TalkBack quando la tua applicazione coinvolge un computer che desideri eseguire solo quando è presente un comando in coda.

Puoi aggiornare contemporaneamente il tuo canale e recuperare l'ultimo comando salvato in una coda TalkBack. Aggiungi il parametro talkback_key alla tua richiesta POST e ThingSpeak restituirà l'ultimo comando TalkBack nella risposta.

Hardware supportato

  • ESP32

Prerequisiti

È necessario avere almeno un canale configurato per completare questo esempio. Create a Channel, come mostrato in Raccogliere dati in un nuovo canale e registrare la chiave API di scrittura. È inoltre necessario impostare un TalkBack. Vai su App > TalkBacks e seleziona Nuovo TalkBack.

Aggiungi comandi alla coda TalkBack

Puoi aggiungere comandi a una coda TalkBack in due modi.

  • Utilizzare l'interfaccia web ThingSpeak TalkBack per aggiungere comandi alla coda TalkBack. Puoi configurare TalkBack per avere fino a 8000 comandi.

  • Utilizza l'API ThingSpeak . È possibile utilizzare una richiesta HTTP POST per aggiungere un comando alla coda. Nel seguente POST, sostituire TALKBACK_ID, YOUR_TALKBACK_API_KEY, TALKBACK_COMMAND e POSITION_NUMBER con i valori appropriati dal tuo canale.

POST https://api.thingspeak.com/talkbacks/TALKBACK_ID/commands
 api_key=YOUR_TALKBACK_API_KEY
     command_string=TALKBACK_COMMAND
     position=POSITION_NUMBER

Programma il tuo ESP32

1) Scarica l'ultimo IDE Arduino®.

2) Installa il core ESP32. Per ulteriori informazioni, vedere Install Arduino ESP32 Support.

3) Nel menu Strumenti, selezionare la porta e la scheda appropriate nell'IDE di Arduino. Questo esempio viene testato utilizzando l'opzione Sparkfun ESP32 Thing .

4) Incolla il codice nell'IDE di Arduino. Aggiungi le informazioni sulla tua rete wireless, la chiave API TalkBack e il tuo numero TalkBack.

5) Programma il dispositivo e quindi osservare il monitor seriale e il LED per osservare i cambiamenti quando vengono utilizzati i comandi. Ogni comando eseguito viene rimosso dall'elenco. È necessario aggiungere più comandi all'elenco dopo che sono stati utilizzati.

Codice

1) Inizia includendo le librerie appropriate e definendo le variabili. Inserisci il SSID e la password della tua rete. Inserisci il numero del tuo canale e i parametri TalkBack: myTalkBackID e myTalkBackKey.

WriteMultipleFieldsAndFetchCommandFromTalkBack

Description: Checks a TalkBack queue every 60 seconds and sets the state of the built in LED according
             to the latest command fetched. Turn the LED on and off by using the commands TURN_ON and TURN_OFF.
             The TalkBack documentation can be found at https://www.mathworks.com/help/thingspeak/talkback-app.html            

Hardware: ESP32-based boards

Notes:
- Requires installation of EPS32 core. 
- Select the target hardware from the Tools -> Board menu

Copyright 2018, The MathWorks, Inc.
*/

#include <WiFi.h>

char ssid[] = <enter your SSID>;   // your network SSID (name) 
char pass[] = <enter your password>;   // your network password

WiFiClient  client;

unsigned long myChannelNumber = <enter your channel ID>;
unsigned long myTalkBackID = <enter your talkback ID>;
const char * myTalkBackKey = <enter your TalkBack API Key>;

// Initialize values for ThingSpeak updates
int number1 = 0;
int number2 = random(0,100);
int number3 = random(0,100);
int number4 = random(0,100);

2) Nella funzione setup inizializzare il LED e avviare il monitor seriale.

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);  // Set up LED
  Serial.begin(115200);  // Initialize serial
  WiFi.mode(WIFI_STA);
}

3) Nel ciclo principale, inizia stabilendo una connessione alla rete Wi-Fi locale. Crea il messaggio POST dai numeri generati casualmente. Effettua il POST, verifica il risultato e controlla la presenza di un comando TalkBack. Quindi genera nuovi numeri casuali da pubblicare nuovamente in 20 secondi.

void loop() {

  // Connect or reconnect to Wi-Fi
  if(WiFi.status() != WL_CONNECTED){
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(String(ssid));
    while(WiFi.status() != WL_CONNECTED){
      WiFi.begin(ssid, pass);  
      Serial.print(".");
      delay(5000);     
    } 
    Serial.println("\nConnected.");
  }

  // Create the message body for the POST out of the values
  String postMessage =  String("field1=") + String(number1) +
                        String("&field2=") + String(number2) +
                        String("&field3=") + String(number3) +
                        String("&field4=") + String(number4) +
                        String("&api_key=") + String(myWriteAPIKey) +
                        String("&talkback_key=") + String(myTalkBackKey);                      
                       

   // Make a String for any commands that might be in the queue
  String newCommand = String();

  // Make the POST to ThingSpeak
  int x = httpPOST(postMessage, newCommand);
  client.stop();
  
  // Check the result
  if(x == 200){
    Serial.println("checking queue..."); 
    // Check for a command returned from TalkBack
    if(newCommand.length() != 0){

      Serial.print("  Latest command from queue: ");
      Serial.println(newCommand);
      
      if(newCommand == "TURN_ON"){
        digitalWrite(LED_BUILTIN, HIGH);  
      }

      if(newCommand == "TURN_OFF"){
        digitalWrite(LED_BUILTIN, LOW);
      }
    }
    else{
      Serial.println("  Nothing new.");  
    }
    
  }
  else{
    Serial.println("Problem checking queue. HTTP error code " + String(x));
  }

  // Confirm code works by changing values
  number1++;
  if(number1 > 99){
    number1 = 0;
  }
  number2 = random(0,100);
  number3 = random(0,100);
  number4 = random(0,100);
  
  delay(20000); // Wait 20 seconds to update the channel again
}

4) Utilizzare la funzione httpPOST per inviare dati a ThingSpeak e leggere il successivo comando TalkBack.

int httpPOST(String postMessage, String &response){

  bool connectSuccess = false;
  connectSuccess = client.connect("api.thingspeak.com",80);

  if(!connectSuccess){
      return -301;   
  }
  
  postMessage += "&headers=false";
  
  String Headers =  String("POST /update HTTP/1.1\r\n") +
                    String("Host: api.thingspeak.com\r\n") +
                    String("Content-Type: application/x-www-form-urlencoded\r\n") +
                    String("Connection: close\r\n") +
                    String("Content-Length: ") + String(postMessage.length()) +
                    String("\r\n\r\n");

  client.print(Headers);
  client.print(postMessage);

  long startWaitForResponseAt = millis();
  while(client.available() == 0 && millis() - startWaitForResponseAt < 5000){
      delay(100);
  }

  if(client.available() == 0){       
    return -304; // Didn't get server response in time
  }

  if(!client.find(const_cast<char *>("HTTP/1.1"))){
      return -303; // Couldn't parse response (didn't find HTTP/1.1)
  }
  
  int status = client.parseInt();
  if(status != 200){
    return status;
  }

  if(!client.find(const_cast<char *>("\n\r\n"))){
    return -303;
  }

  String tempString = String(client.readString());
  response = tempString;
  
  return status;
}