Main Content

Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la versión original en inglés.

Creación de prototipos con sensor de proximidad Sonar

Este ejemplo muestra cómo crear prototipos con ThingSpeak™ utilizando una placa Arduino® conectada a Wi-Fi. Puede leer y escribir datos de canales con la biblioteca de comunicación de ThingSpeak. En este ejemplo, se lee un umbral ajustable de ThingSpeak para crear un detector de proximidad. El hardware consta de un Arduino MKR100 con un sensor de sonda y un indicador LED para mostrar la presencia de un objeto.

La creación de prototipos de un proyecto de sensor puede requerir varias actualizaciones del código para ajustar los parámetros de calibración, como los de un sensor de temperatura. Un ajuste de hardware agrega complejidad, reduce la confiabilidad y puede ser difícil de alcanzar cuando se implementa su proyecto. En su lugar, puede leer los parámetros de calibración de ThingSpeak y cambiar los parámetros en tiempo real. Puede mejorar la calidad de sus mediciones cuando ajusta un parámetro de ajuste almacenado en ThingSpeak.

Hardware compatible

  • Arduino MKR1000

  • Arduino Uno, Mega, Due o Leonardo con una red inalámbrica o conexión Ethernet

  • Particle Photon (con algo de código y ajustes esquemáticos)

En este ejemplo, un sensor de sonda monitorea una engrapadora y publica la medición en su canal. El sensor de sonda funciona enviando un pulso de sonido y midiendo el tiempo que tarda el pulso en regresar de un objeto. El sistema usa el umbral de distancia leído de ThingSpeak y compara el umbral con la distancia medida. El LED está encendido cuando la grapadora está presente.

Después de completar este ejemplo, verá los datos de proximidad y la configuración en su canal. La vista de canal de ThingSpeak muestra los siguientes datos y configuraciones de proximidad:

  • El umbral se establece en 15 cm.

  • Se toman diez medidas para cada promedio.

  • El indicador de lectura está configurado para forzar la lectura de los parámetros de calibración

  • Los datos muestran que alguien "tomó prestada" la engrapadora a las 11 a. m. y la devolvió más tarde a una nueva posición

Hardware requerido

  • Arduino MKR1000 u otro Arduino con conexión de red Ethernet o inalámbrica

  • Sensor de sonda HC-SR04

  • Cables puente (al menos 4)

  • DIRIGIÓ

  • Resistencia pequeña (100 Ω – 1 kΩ)

  • cable USB

Configuración de canales

1) Cree un canal ThingSpeak, como se muestra en Recopilar datos en un nuevo canal. Almacene los datos en el primer campo y almacene la configuración del dispositivo en campos sucesivos. La configuración del dispositivo incluye el umbral de distancia, el número de mediciones para promediar y un indicador para controlar si el dispositivo actualiza la configuración en cada bucle.

2) Habilite los campos 1, 2, 3 y 4 en el Configuración de canales vista. Para distinguir entre los campos, proporcione un nombre descriptivo para cada campo. Esta imagen muestra un solo canal configurado para recopilar datos en el primer campo y almacenar los parámetros de calibración en los campos 2, 3 y 4.

3) Tenga en cuenta las claves API de lectura y escritura apropiadas del Claves API pestaña en el Configuración de canales vista (encerrada en un círculo en la imagen).

4) Complete sus campos de calibración utilizando una ventana del navegador. Puede copiar el texto de la Claves API o modifique este texto con su clave API de escritura. Ingrese cada URL directamente en la barra de direcciones de su navegador, cambiando SU CLAVE API DE ESCRITURA a la clave API de escritura para su canal.

una. Establezca el umbral para detectar un objeto (50 cm es un buen punto de partida):

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

b. Establezca el número de mediciones en promedio:

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

C. Establezca el indicador de control para que el dispositivo busque nuevas configuraciones periódicamente:

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

El navegador devuelve el número de entradas en el canal. Si acaba de crear el canal, verá un 1, 2 y 3 cuando complete los tres campos de calibración requeridos.

Esquema y Conexiones

1) Conecte VCC a 5 V en el MKR-1000.

2) Conecte la tierra del sensor a la tierra de Arduino.

3) Conecte el pin Trig al pin 8 de Arduino.

4) Conecte el pin Echo al pin 12 de Arduino.

5) Conecte una resistencia al pin 5 de Arduino y conecte la resistencia a un indicador LED. Conecte el ánodo del LED a tierra.

Programa tu Arduino

1) Descargue el último IDE de Arduino.

2) Añadir el Biblioteca ThingSpeak para Arduino y ESP8266 al director de la biblioteca. Seleccione Sketch > Include Library > Manage Libraries. Seleccione ThingSpeak para agregarlo a su boceto.

3) Añadir el WiFi101 biblioteca en el administrador de la biblioteca. Nota: Asegúrese de instalar la versión 0.13 de la biblioteca. Hay un error en la versión 0.14 que hace que las publicaciones fallen. Seleccione Sketch > Include Library > Manage Libraries. Seleccione WiFi101 para agregarlo a su boceto.

4) Crear la aplicación. Abra una nueva ventana en el IDE de Arduino y guarde el archivo. Agregue el código proporcionado en la sección Código. Asegúrese de editar la información de la red inalámbrica, la identificación del canal y las claves API.

5) Después de cargar con éxito su programa, puede monitorear la salida usando el monitor serial. Si un objeto está presente a una distancia más cercana que el umbral establecido, entonces su dispositivo publica la distancia en su canal. Intente experimentar con la cantidad de mediciones para promediar y vea cómo cambian las fluctuaciones medidas. Una vez que establezca los parámetros, puede cambiar el valor del indicador de lectura de 1 a 0. Una vez que su dispositivo lee este indicador como 0, deja de verificar los parámetros de ThingSpeak, lo que ahorra energía y ancho de banda.

Código

1) Incluya bibliotecas e inicialice los pines de control.

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

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

2) Definir e inicializar las variables. Asegúrese de editar la información de la red inalámbrica, la identificación del canal y las claves API. Encuentre su ID de canal en la parte superior de la página principal de su canal.

// 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) Inicialice los pines para entrada y salida, y lea los parámetros de calibración por primera vez en el setup rutina.

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) Cada vez que se ejecute el bucle principal, realice varias mediciones. Si los datos no se han escrito en ThingSpeak durante un tiempo, escríbalos en el canal de salida. Además, si el indicador de lectura se leyó por última vez como verdadero, verifique los datos de calibración y los indicadores en cada 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) Utilice estas funciones para leer y escribir datos hacia y desde 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) Uso getDistance para obtener una sola medida del sensor.

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) Conecte su dispositivo a una red inalámbrica usando el connectWiFi función.

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