Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Manufacturing Technology >> Proceso de manufactura

Monitoreo ambiental de Arduino

Componentes y suministros

Arduino MKR1000
× 1
Haga clic en MikroE Environment
× 1

Herramientas y máquinas necesarias

Cables de puente hembra / hembra Adafruit

Aplicaciones y servicios en línea

Arduino IDE
WolkAbout IoT Platform

Acerca de este proyecto

Introducción

Teníamos a mano algunos sensores de clic del entorno, por lo que decidimos conectarlos al Arduino MKR1000 y visualizarlos en WolkAbout IoT Platform. La idea era hacer una medición cada minuto y publicar los resultados una vez cada 15 minutos. Si la publicación de las lecturas del sensor falla (debido a una red ocupada o algún otro problema), los resultados deben conservarse en la memoria Flash del dispositivo. Con un máximo potencial de 96 escrituras al día, minimizamos las posibilidades de que la memoria Flash esté en un estado incorrecto (Arduino garantiza 10,000 ciclos de escritura).

Configuración de hardware

El sensor de clic del entorno está conectado a los pines de comunicación I2C (es decir, 11 y 12 en el MKR1000), Vcc y tierra.

Configuración de software

Usamos un par de bibliotecas para hacer posible este proyecto, todas las cuales se pueden instalar desde el administrador de bibliotecas de Arduino IDE, o descargando archivos .zip de los repositorios de GitHub enumerados en los archivos adjuntos y luego agregándolos a Arduino IDE.

  • WiFi101
  • Controlador de sensor unificado Adafruit
  • Biblioteca Adafruit BME680
  • RTCZero
  • FlashStorage
  • WolkConnect

Una vez instaladas todas las bibliotecas necesarias, siga adelante y copie el contenido de Monitorización del entorno boceto de los archivos adjuntos en Arduino IDE.

Implementa una estructura de búfer circular y la usa para almacenar los resultados de la medición. También hay una implementación de cómo almacenar esa estructura en la memoria Flash usando la biblioteca FlashStorage. La lectura y publicación cronometradas de los datos se logran mediante el uso de la biblioteca RTCZero. Inicialmente, después de conectarnos a WiFi, enviamos un ping a WolkAbout IoT Platform para obtener la época actual que se ingresará en la biblioteca RTC para que las lecturas del sensor se puedan marcar correctamente.

Una interrupción de alarma cambia los indicadores de las tareas que deben realizarse (leer y publicar) y el resto del trabajo se maneja en la función de bucle. Aquí comprobamos si necesitamos leer o publicar. Para un consumo de energía mínimo, WiFi está configurado para estar en un modo de bajo consumo, así como el MKR1000. El sensor del clic del entorno se reduce automáticamente hasta que se solicita una lectura.

Los cambios que deben realizarse en el boceto incluyen ingresar las credenciales de WiFi en las líneas 33 y 34:

  const char * ssid ="<* YOUR SSID *>"; 
const char * wifi_pass ="<* YOUR WIFI PASSWORD *>";

así como ingresar las credenciales del dispositivo de WolkAbout IoT Platform.

Para obtener estas credenciales, primero debe crear un dispositivo utilizando un tipo de dispositivo.

El tipo de dispositivo para este proyecto, Environment click-deviceType.json, está disponible en los archivos adjuntos del proyecto, así que cree una copia. Inicie sesión o cree su cuenta en WolkAbout IoT Platform y abra el Dispositivo Gestión aplicación.

Seleccione el Dispositivo Tipo Gestión pestaña y luego presione + firmar y seleccionar Subir opción, navegando a su copia local del tipo de dispositivo.

Ahora que un tipo de dispositivo está disponible, puede crear un dispositivo a partir de él haciendo clic en Crear dispositivo .

Aquí, debe dar un nombre a su dispositivo, configurar el Tipo de conectividad a MQTT y marque la casilla de verificación para Crear valores predeterminados Semántico (necesario para crear widgets en su panel más adelante).

Presione Guardar y se mostrará el formulario con las credenciales del dispositivo. Almacene esta información como desee y luego ingrésela en su boceto en Arduino IDE:

  const char * device_key ="device_key"; 
const char * device_password ="device_password";

Ahora puede continuar, verificar y cargar este boceto en su tablero, pero aún necesita crear una forma de mostrar los datos del sensor recibidos.

Para mostrar estos datos, cambie a Visualización y supervisión en WolkAbout IoT Platform y cree un nuevo panel presionando + Agregar panel e ingresando un nombre para el tablero y estableciendo el alcance a cualquiera que sea el nombre del dispositivo. Luego, puede comenzar a agregar widgets a su panel presionando Agregar widget.

Seleccione Tendencias

y luego seleccione Temperatura desde su dispositivo.

Repita el proceso para Presión y Humedad . Cree otro widget del tipo Lectura seleccione Altitud y crea otro widget de tarjeta para Gas Resistencia . Puede reorganizar los widgets como desee.

Después de agregar widgets para toda la lectura del sensor individual que espera recibir de su dispositivo, el siguiente panel estará listo para recibir los datos de su dispositivo.

Por lo tanto, continúe e implemente el dispositivo en el entorno que ha elegido y controle las condiciones de forma remota.

Conclusión

Al conectar Arduino MKR1000 y Environment Click a WolkAbout IoT Platform, creó una forma de eficiencia energética para informar las condiciones ambientales del lugar que desea monitorear de forma remota. Esta solución se puede ampliar mediante el uso del motor de reglas de WolkAbout IoT Platform, que le permite recibir diferentes tipos de notificaciones si un determinado valor supera un umbral que usted definió.

Para obtener más información sobre el motor de reglas y otras características de WolkAbout IoT Platform, puede visitar nuestra página de Guías de usuario.

Código

  • Bosquejo de monitoreo ambiental
  • Entorno click-deviceType.json
Boceto de monitoreo del entorno Arduino
Importe este boceto en Arduino IDE y edite las credenciales WiFi y las credenciales del dispositivo
 #include  #include  #include  #include  #include  #include  #include  #include "WolkConn.h" #include "MQTTClient.h" / * Número de outbound_message_t para almacenar * / # define STORAGE_SIZE 32 # define SEALEVELPRESSURE_HPA (1013.25) / * Búfer circular para almacenar mensajes salientes para persistir * / typedef struct {boolean valid; outbound_message_t outbound_messages [STORAGE_SIZE]; uint32_t head; uint32_t tail; booleano vacío; booleano completo;} Mensajes; datos de mensajes estáticos; / * Detalles de la conexión * / const char * ssid ="ssid"; const char * wifi_pass ="wifi_pass"; const char * device_key ="device_key"; const char * device_password ="device_password "; const char * hostname =" api-demo.wolkabout.com "; int portno =1883; WiFiClient espClient; Cliente PubSubClient (espClient); / * Contexto del conector WolkConnect-Arduino * / static wolk_ctx_t wolk; / * Iniciar almacenamiento flash * / FlashStorage (flash_store, Messages); / * Inicia la comunicación del sensor i2c * / Adafruit_BME680 bme; RTCZero rtc; bool read; / * Lee el sensor cada minuto. Si cambia este parámetro, asegúrese de que sea <60 * / const byte readEvery =1; bool publish; / * Publish cada 10 minutos. Si cambia este parámetro, asegúrese de que sea <60 * / const byte publishEvery =10; byte publishMin; / * Almacenamiento Flash e implementación de persistencia personalizada * / void _flash_store () {data.valid =true; flash_store.write (data);} void aumento_pointer (uint32_t * pointer) {if ((* pointer) ==(STORAGE_SIZE - 1)) {(* pointer) =0; } else {(* puntero) ++; }} void _init () {datos =flash_store.read (); if (data.valid ==false) {data.head =0; data.tail =0; data.empty =verdadero; data.full =falso; }} bool _push (outbound_message_t * outbound_message) {if (data.full) {incremento_pointer (&data.head); } memcpy (&data.outbound_messages [data.tail], outbound_message, sizeof (outbound_message_t)); aumentar_pointer (&data.tail); data.empty =falso; data.full =(data.tail ==data.head); return true;} bool _peek (outbound_message_t * outbound_message) {memcpy (outbound_message, &data.outbound_messages [data.head], sizeof (outbound_message_t)); return true;} bool _pop (outbound_message_t * outbound_message) {memcpy (outbound_message, &data.outbound_messages [data.head], sizeof (outbound_message_t)); aumentar_pointer (&data.head); data.full =falso; data.empty =(data.tail ==data.head); return true;} bool _is_empty () {return data.empty;} void init_wifi () {if (WiFi.status ()! =WL_CONNECTED) {while (WiFi.begin (ssid, wifi_pass)! =WL_CONNECTED) {delay (1000 ); }}} void setup_wifi () {retraso (10); if (WiFi.status ()! =WL_CONNECTED) {int numAttempts =0; while (WiFi.begin (ssid, wifi_pass)! =WL_CONNECTED) {numAttempts ++; if (numAttempts ==10) {Serial.println ("¡No se pudo conectar WiFi!"); descanso; } retraso (1000); }}} configuración vacía () {pinMode (LED_BUILTIN, SALIDA); digitalWrite (LED_BUILTIN, BAJO); / * Inicializar la estructura circular del búfer * / _init (); init_wifi (); wolk_init (&wolk, NULL, NULL, NULL, NULL, device_key, device_password, &client, hostname, portno, PROTOCOL_JSON_SINGLE, NULL, NULL); wolk_init_custom_persistence (&wolk, _push, _peek, _pop, _is_empty); / * El LED integrado se encenderá si algo salió mal * / if (! Bme.begin ()) {digitalWrite (LED_BUILTIN, HIGH); } / * Sensor init * / bme.setTemperatureOversampling (BME680_OS_8X); bme.setHumidityOversampling (BME680_OS_2X); bme.setPressureOversampling (BME680_OS_4X); bme.setIIRFilterSize (BME680_FILTER_SIZE_3); bme.setGasHeater (320, 150); // 320 * C para un retraso de 150 ms (200); leer =verdadero; publicar =verdadero; / * Obtener la época actual del servidor * / wolk_connect (&wolk); retraso (100); wolk_update_epoch (&wolk); while (! (wolk.pong_received)) {wolk_process (&wolk); escritura digital (LED_BUILTIN, ALTO); retraso (1000); } digitalWrite (LED_BUILTIN, BAJO); wolk_disconnect (&wolk); rtc.begin (); rtc.setEpoch (wolk.epoch_time); rtc.setAlarmTime (rtc.getHours (), (rtc.getMinutes () + readEvery)% 60, rtc.getSeconds ()); rtc.enableAlarm (rtc.MATCH_MMSS); rtc.attachInterrupt (alarmMatch); publishMin =(rtc.getMinutes () + publishEvery)% 60; WiFi.lowPowerMode ();} void loop () {/ * Para mantener la rutina de interrupción lo más corta posible, la rutina solo establece las tareas a realizar read =true significa que la lectura del sensor debe realizarse. las lecturas deben publicarse en la plataforma o conservarse en flash si la conexión no está disponible * / if (read) {read =false; if (! bme.performReading ()) {digitalWrite (LED_BUILTIN, HIGH); } wolk_add_numeric_sensor_reading (&wolk, "T", bme.temperature, rtc.getEpoch ()); wolk_add_numeric_sensor_reading (&wolk, "H", bme.humidity, rtc.getEpoch ()); wolk_add_numeric_sensor_reading (&wolk, "P", bme.pressure / 100.0, rtc.getEpoch ()); wolk_add_numeric_sensor_reading (&wolk, "GR", bme.gas_resistance, rtc.getEpoch ()); wolk_add_numeric_sensor_reading (&wolk, "A", bme.readAltitude (SEALEVELPRESSURE_HPA), rtc.getEpoch ()); / * establecer una nueva alarma * / int alarmMin =(rtc.getMinutes () + readEvery)% 60; rtc.setAlarmMinutes (alarmMin); retraso (100); } si (publicar) {publicar =falso; setup_wifi (); wolk_connect (&wolk); if (! wolk.is_connected) {_flash_store (); } retraso (100); if (wolk_publish (&wolk) ==W_TRUE) {_flash_store (); } / * establecer una nueva hora de publicación * / publishMin =(rtc.getMinutes () + publishEvery)% 60; retraso (100); wolk_disconnect (&wolk); retraso (100); } retraso (100); } / * Rutina de interrupción temporizada * / void alarmMatch () {read =true; if (publishMin ==rtc.getMinutes ()) {publish =true; }} 
Entorno click-deviceType.json JSON
Tipo de dispositivo que se utiliza para crear un dispositivo en WolkAbout IoT Platform
 [{"name":"Environment click", "description":"Tipo de dispositivo para el sensor BME680 en la placa de MikroElektronika Environment Click", "guid":" def68ff6-63c5-4f9c-a066-bcc944b7bd2d "," deviceType ":" ESTÁNDAR "," protocolo ":" JSON "," ConnectType ":null," firmwareUpdateType ":null," feeds ":[{" nombre ":" Temperatura "," descripción ":nulo," referencia ":" T "," unidad ":{" nombre ":" CELSIUS "," guid ":" 7c805d10-a879-11e9-83cd-0a0027000005 "}}, {" name ":" Humedad "," descripción ":nulo," referencia ":" H "," unidad ":{" name ":" HUMIDITY_PERCENT "," guid ":" 7c8080a3-a879-11e9-83cd-0a0027000005 "} }, {"nombre":"Presión", "descripción":nulo, "referencia":"P", "unidad":{"nombre":"MILLIBAR", "guid":"7c807980-a879-11e9-83cd -0a0027000005 "}}, {" nombre ":" Resistencia al gas "," descripción ":nulo," referencia ":" GR "," unidad ":{" nombre ":" OHM "," guid ":" 7c805890- a879-11e9-83cd-0a0027000005 "}}, {" nombre ":" Altitud "," descripción ":nulo," referencia e ":" A "," unidad ":{" nombre ":" MEDIDOR "," guid ":" 7c805a59-a879-11e9-83cd-0a0027000005 "}}]," actuadores ":[]," alarmas ":[], "configs":[], "atributos":[{"nombre":"CONNECTIVITY_TYPE", "dataType":"ENUM", "validationRegex":"^ (MQTT | HTTP) $", "opciones":["MQTT", "HTTP"], "defaultValue":"MQTT", "required":true, "readOnly":true}, {"name":"FIRMWARE_UPDATE_ENABLED", "dataType":"BOOLEAN", "validationRegex ":" ^ (true | false) $ "," options ":null," defaultValue ":null," required ":false," readOnly ":true}, {" name ":" FIRMWARE_VERSION "," dataType ":"STRING", "validationRegex":null, "options":null, "defaultValue":null, "required":false, "readOnly":true}, {"name":"FILE_DIRECT_DOWNLOAD_ENABLED", "dataType":"BOOLEAN "," validationRegex ":" ^ (true | false) $ "," options ":null," defaultValue ":null," required ":false," readOnly ":true}, {" name ":" FILE_URL_DOWNLOAD_ENABLED ", "dataType":"BOOLEAN", "validationRegex":"^ (true | false) $", "options":null, "defaultValue":null, "required":false, " readOnly ":true}]}] 
WolkAbout Environment Monitoring
Este repositorio contiene el boceto de Arduino utilizado en este proyecto https://github.com/Wolkabout/Wolk-Arduino-Environment-Monitoring
Arduino WiFi 101 Shield
Biblioteca Wifi para Arduino WiFi 101 Shieldhttps://github.com/arduino-libraries/WiFi101
Controlador de sensor unificado Adafruit
Se requiere una biblioteca de sensores unificada para todos los sensores https://github.com/adafruit/Adafruit_Sensor
Biblioteca Adafruit BME680
Biblioteca utilizada para el medio ambiente haga clic para obtener lecturas del sensor https://github.com/adafruit/Adafruit_BME680
Biblioteca RTC para Arduino
Biblioteca RTC para placas basadas en SAMD21 https://github.com/arduino-libraries/RTCZero
Biblioteca FlashStorage para Arduino
Una forma conveniente de almacenar datos en la memoria Flash en el ATSAMD21 https://github.com/cmaglie/FlashStorage
WolkConnect-Arduino
Biblioteca de Arduino que proporciona una fácil conectividad a WolkAbout IoT Platform.https://github.com/Wolkabout/WolkConnect-Arduino

Esquemas


Proceso de manufactura

  1. Arduino Spybot
  2. Monitoreo de CO2 con sensor K30
  3. FlickMote
  4. Televisión casera B-Gone
  5. Reloj maestro
  6. Encuéntrame
  7. Arduino Power
  8. Tech-TicTacToe
  9. Arduino Cuadrúpedo
  10. Puerta de control de temperatura sin contacto
  11. Sistema de monitoreo y detección de incendios forestales (con alertas por SMS)