Main Content

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

Prototipazione con sensore di prossimità Sonar

Apri live script

Questo esempio mostra come prototipare con ThingSpeak™ utilizzando una scheda Arduino® connessa tramite Wi-Fi.

Leggi e scrivi i dati dei canali con la libreria di comunicazione ThingSpeak . In questo esempio, una soglia regolabile viene letta da ThingSpeak per creare un rilevatore di prossimità. L'hardware è costituito da un Arduino MKR100 con un sensore sonar e un LED indicatore per indicare la presenza di un oggetto.

La prototipazione di un progetto di sensore può richiedere più modifiche del codice per ottimizzare i parametri di calibrazione, come quelli di un sensore di temperatura. Una modifica hardware aggiunge complessità, riduce l'affidabilità e può essere difficile da raggiungere quando il progetto viene distribuito. Puoi invece leggere i parametri di calibrazione da ThingSpeak e modificare i parametri in tempo reale. Puoi migliorare la qualità delle tue misurazioni quando regoli un parametro di ottimizzazione memorizzato su ThingSpeak.

Hardware supportato

  • Arduino MKR1000

  • Arduino Uno, Mega, Due o Leonardo con rete wireless o connessione Ethernet

  • Particle Photon (con alcuni aggiustamenti al codice e allo schema)

In questo esempio, un sensore sonar monitora una cucitrice e pubblica la misurazione sul tuo canale. Il sensore sonar funziona inviando un impulso sonoro e misurando il tempo necessario affinché l'impulso ritorni da un oggetto. Il sistema utilizza la soglia di distanza letta da ThingSpeak e confronta la soglia con la distanza misurata. Il LED è acceso quando è presente la cucitrice.

PrototypingWithSonarProximitySensorTSExample_01.png

Dopo aver completato questo esempio, vedrai i dati di prossimità e le impostazioni nel tuo canale. La visualizzazione del canale ThingSpeak mostra i seguenti dati e impostazioni di prossimità:

  • La soglia è impostata a 15 cm

  • Per ciascuna media vengono effettuate dieci misurazioni

  • Il flag di lettura è impostato per forzare la lettura dei parametri di calibrazione

  • I dati mostrano che qualcuno ha "preso in prestito" la cucitrice alle 11 del mattino, restituendola più tardi in una nuova posizione

Hardware richiesto

  • Arduino MKR1000 o altro Arduino con connessione di rete Ethernet o wireless

  • Sensore ecoscandaglio HC-SR04

  • Cavi di avviamento (almeno 4)

  • LED

  • Piccolo resistore (100 Ω – 1 kΩ)

  • Cavo USB

Impostazione del canale

1) Creare un canale ThingSpeak, come mostrato in Collect Data in a New Channel. Memorizzare i dati nel primo campo e memorizzare le impostazioni del dispositivo nei campi successivi. Le impostazioni del dispositivo includono la soglia di distanza, il numero di misurazioni da calcolare in media e un flag per controllare se il dispositivo aggiorna le impostazioni su ciascun loop.

2) Abilita i campi 1, 2, 3 e 4 nella visualizzazione Impostazioni canale. Per distinguere tra i campi, fornire un nome descrittivo per ciascun campo. Questa immagine mostra un singolo canale configurato per raccogliere dati nel primo campo e memorizzare i parametri di calibrazione nei campi 2, 3 e 4.

3) Prendere nota delle chiavi API di lettura e scrittura appropriate dalla scheda Chiavi API nella vista Impostazioni canale (cerchiata nell'immagine).

4) Compilare i campi di calibrazione utilizzando una finestra del browser. Puoi copiare il testo dalla scheda Chiavi API o modificare questo testo con la tua chiave API di scrittura. Inserisci ciascun URL direttamente nella barra degli indirizzi del tuo browser, cambiando la TUA CHIAVE API DI SCRITTURA con la chiave API di scrittura per il tuo canale.

A. Imposta la soglia per il rilevamento di un oggetto (50 cm è un buon punto di partenza):

https://api.thingspeak.com/update?api_key=YOUR WRITE API KEY&field2=THRESHOLD

B. Imposta il numero di misurazioni sulla media:

https://api.thingspeak.com/update?api_key=YOUR WRITE API KEY&field3=NUMTOAVERAGE

c. Imposta il flag di controllo in modo che il dispositivo controlli periodicamente le nuove impostazioni:

https://api.thingspeak.com/update?api_key=YOUR WRITE API KEY&field4=1

Il browser restituisce il numero di voci nel canale. Se hai appena creato il canale, vedrai 1, 2 e 3 quando compili i tre campi di calibrazione richiesti.

Schema e collegamenti

1) Collega VCC a 5 V sul MKR-1000.

2) Collega la terra del sensore alla terra dell'Arduino.

3) Collega il pin Trig al pin 8 di Arduino.

4) Collega il pin Echo al pin 12 di Arduino.

5) Collega un resistore al pin 5 di Arduino e collega il resistore a un indicatore LED. Collega l'anodo del LED a terra.

Programma il tuo Arduino

1) Scarica l'ultimo IDE Arduino.

2) Aggiungi ThingSpeak Library for Arduino and ESP8266 al gestore della libreria. Seleziona Sketch > Include Library > Manage Libraries. Seleziona ThingSpeak per aggiungerlo al tuo schizzo.

3) Aggiungi la libreria WiFi101 nel gestore della libreria. Nota: Assicurati di installare la versione 0.13 della libreria. C'è un bug nella versione 0.14 che causa il fallimento dei post. Seleziona Sketch > Include Library > Manage Libraries. Seleziona WiFi101 per aggiungerlo al tuo schizzo.

4) Crea l'applicazione. Apri una nuova finestra nell'IDE di Arduino e salva il file. Aggiungi il codice fornito nella sezione Codice. Assicurati di modificare le informazioni sulla rete wireless, l'ID del canale e le chiavi API.

5) Dopo aver caricato con successo il programma, è possibile monitorare l'output utilizzando il monitor seriale. Se un oggetto è presente a una distanza inferiore alla soglia impostata, il dispositivo pubblica la distanza sul tuo canale. Prova a sperimentare il numero di misurazioni di cui calcolare la media e osserva come cambiano le fluttuazioni misurate. Una volta impostati i parametri, è possibile modificare il valore del flag di lettura da 1 a 0. Una volta che il tuo dispositivo legge questo flag come 0, smette di controllare i parametri ThingSpeak , risparmiando energia e larghezza di banda.

Codice

1) Includere le librerie e inizializzare i pin di controllo.

#include <ThingSpeak.h>
#include<WiFi101.h>

#define triggerPin 8
#define echoPin 12
#define LEDpin 6

2) Definire e inizializzare le variabili. Assicurati di modificare le informazioni sulla rete wireless, l'ID del canale e le chiavi API. Trova l'ID del tuo canale nella parte superiore della pagina principale del tuo canale.

// Network information
const char* ssid = "SSID";
const char* password = "xxxxxxxxxx";

// ThingSpeak information
char* writeAPIKey = "XXXXXXXXXXXXXXXX";
char* readAPIKey = "YYYYYYYYYYYYYYYY"; 
const long channelID = 000000; 
const unsigned int firstReadFieldNumber = 2;
const unsigned int secondReadFieldNumber = 3; 
const unsigned int switchField = 4; // Field number (1-8) to use to change status of device.  Determines if data is read from ThingSpeak.

// Other constants
const unsigned long postingInterval = 60L * 1000L;   // Post data every 60 seconds

// Global variables
unsigned long lastConnectionTime = 0;
long lastUpdateTime = 0;
float distanceThreshold = 0;
bool getInfo = 1;  // Set this to zero if you don’t want to read data from ThingSpeak anymore (i.e. calibration complete)
int points = 7; 
WiFiClient client;

3) Inizializzare i pin per ingresso e uscita e leggere i parametri di calibrazione per la prima volta nella routine setup .

void setup() {
  Serial.begin (9600); 
  pinMode(triggerPin, OUTPUT); 
  pinMode(LEDpin, OUTPUT);
  pinMode(echoPin, INPUT);
  connectWifi();
  Serial.println("Start");

  // Get the initial parameters from ThingSpeak.
  distanceThreshold = readTSData(channelID,firstReadFieldNumber,readAPIKey); 
  points = readTSData(channelID,secondReadFieldNumber,readAPIKey);   
}

4) Ogni volta che viene eseguito il ciclo principale, effettuare misurazioni multiple. Se i dati non sono stati scritti su ThingSpeak per un po', scriverli sul canale di uscita. Inoltre, se l'ultima volta il flag di lettura è stato letto come vero, controllare i dati di calibrazione e i flag in ogni ciclo.

void loop() {
  
  float  distance=0;

  // Make sure there is an Internet connection.
  if(WiFi.status() != WL_CONNECTED){
    
    connectWifi();  
    }

     for (uint16_t loops = 0; loops < points; loops++){
      distance += getDistance(triggerPin,echoPin);  //make a measurement, store the sum of all measurements
      delay(5);  
     }
     
     distance = distance/points;
     
    if (distance < distanceThreshold){
      digitalWrite(LEDpin,HIGH);
      }
    
     else{
      
      digitalWrite(LEDpin,LOW); 
      }
      
     
     Serial.println("Ave: "+ String(distance)+ " cm");
      
    if (millis() - lastUpdateTime >=  postingInterval) {  
      
      lastUpdateTime = millis();
      
           if (!(getInfo==0)){
            
            distanceThreshold = readTSData(channelID,firstReadFieldNumber,readAPIKey);
            points = readTSData(channelID,secondReadFieldNumber,readAPIKey);
            getInfo = (bool)readTSData(channelID,switchField,readAPIKey);
            }
            
       if (distance < distanceThreshold){
        
      // Write data to ThingSpeak channel.
       writeTSData(channelID, 1, distance, writeAPIKey);
       }
       
      }
      
    delay(500);    // Provide some delay between measurements.
    
}

5) Utilizzare queste funzioni per leggere e scrivere dati da e verso ThingSpeak.

int writeTSData(long TSChannel,unsigned int TSField,float data,char* ReadAPIKey){
  int  writeSuccess = ThingSpeak.writeField(TSChannel, TSField, data, writeAPIKey); //write the data to the channel
  return writeSuccess;
}

// Use this function if you want multiple fields simultaneously.
/*
int writeTDData(long TSChannel,unsigned int TSField1,float data1,unsigned int TSField2,data2,char* ReadAPIKey){
  ThingSpeak.setField(TSField1,data1);
  ThingSpeak.setField(TSField1,data2);
   
  writeSuccess = ThingSpeak.writeFields(TSChannel, writeAPIKey);
  return writeSuccess;
}
*/
 
float readTSData(long TSChannel,unsigned int TSField,char* ReadAPIKey){
  
  float data = 0;
  
  data = ThingSpeak.readFloatField(TSChannel,TSField,ReadAPIKey);
  Serial.println(" Data read from ThingSpeak "+String(data));
  return data;
}

6) Utilizzare getDistance per ottenere una singola misurazione dal sensore.

float getDistance(int tPin,int ePin){
  
  long duration, distance;
    
  digitalWrite(tPin, LOW);  // Reset the trigger pin.
  delayMicroseconds(2); 
  digitalWrite(tPin, HIGH);  // Start a measurement.
  delayMicroseconds(10); // 
  digitalWrite(tPin, LOW);   // Complete the pulse.
  duration = pulseIn(ePin, HIGH);  // Wait for a reflection pulse.
  distance = (duration/2) / 29.1;     // Calculate the appropriate distance using the estimated speed of sound.

  // This section is useful when debugging the sensor.
/*
  if (distance >= 200 || distance <= 0){
    Serial.println("Out of range");
  }
  else {
   Serial.print(distance);
   Serial.println(" cm");
  }
  */
  return distance;
}

7) Connettere il ​​proprio dispositivo ad una rete wireless utilizzando la funzione connectWiFi .

int connectWifi(){
     
    while (WiFi.status() != WL_CONNECTED) {
       WiFi.begin(ssid, password);
       delay(2500);
       Serial.println("Connecting to WiFi");
    }
    
    Serial.println("Connected");
    ThingSpeak.begin(client);
  }