Archivo de la categoría: Arduino;Netduino-Plus

Que es CheapDuino


 cheapduino.PNG

CheapDuino es una  placa  compatible con Arduino  de un tamaño muy reducido pero no hace honor actualmente a su origen (cheap , es decir barato ) pues  si bien el precio es aceptable (1/5 precio del Arduino UNO R3)   una de sus mejores puntos es su reducido espacio  proporcionando un procesador de  relativo bajo costo para  estudiantes y los aficionados al desarrollo profesional adecuado para  proyecto personalizados de bricolaje, taller, regalos para amigos, E-Textiles y uso educativo.

Pretendía esta placa ser una opción para aquellos estudiantes de países del segundo o tercer mundo que no pueden pagar el precio del Arduino oficial( entre 25 a 30€) ,  intentando abrir una puerta al mundo físico (unos 10€ por placa), pero   no debemos olvidar que existen clones de Arduino de un precio similar  o incluso mas bajo, así que su gran bazas es su  potencia en tamaño compacto pues  tiene una dimensión de solo 2 cm x 2 cm..

La placa tiene  integrado con un microcontrolador ATmega8 y Arduino NG.  Se  puede  programar directamente con Arduino IDE a través del programador FTDI o el adaptador de serie USB.3

(Cuando conecte el cable de programación fpc al programador DFRobot FPC y al dispositivo CheapDuino, por favor, el lado azul hacia arriba).

A nivel de hardware el procesador tiene 3 pines digitales pwm, 3 pines analógicos e interfaz de fuente de alimentación con almohadillas hexagonales alrededor de la placa, lo que hace que sea muy fácil de soldar para los principiantes.

Por supuesto, la interfaz I2C y el puerto serie también están disponibles para extender los dispositivos periféricos de 2 cables directamente. La adopción del conector micro FPC ahorra espacio adicional en comparación con la interfaz USB Arduino normal.

CheapDuino1.png

Especificaciones

  • Voltaje de funcionamiento: 3 ~ 5 voltios
  • Fuente de alimentación recomendada: 5v
  • Microctonroller: Atmel AVR ATmega8
  • gestor de arranque (opción de placa en Arduino IDE): Arduino NG / w ATmega8
  • 3 pines digitales, 3 pines analógicos con almohadillas hexagonales fáciles de soldar
  • Integra 3 pines pwm, interfaz I2C e interfaz UART
  • Adecuado para talleres, uso educativo y proyectos personalizados de bricolaje
  • Controlador compatible con Arduino de bajo costo
  • Diseñado para los estudiantes y DIYers
  • Dimensiones: 2cm x 2cm x 0.2cm

 

 

 

CheapDuino se puede comprar  en la página dee DFRobot o también en Amazon

 

Anuncios

Como leer el pulso cardiaco


En efecto existen sensores de pulso cardíaco de forma  compacta, el cual podemos usar para nuestros proyectos para lo que se nos  ocurra, como por ejemplo  visualizar las pulsaciones cardíacas.
La esencia de estos circuitos es un sensor integrado de circuito de amplificación óptica y con un circuito de eliminación de ruido de la frecuencia cardíaca  todo ello alimentado  con una tensión de alimentación: 3.3V ~ 5 V

Lo ideal  para medir el pulso  es  poner  el sensor de pulso en el dedo o lóbulo de la oreja, directamente  o bien  mediante algún sistema mecánico que lo deje fijo como por ejemplo   alguno de los sistemas que mostramos a continuación:

 

soportes sensores.PNG

 

Estos sensores cuentan con una salida analógica   que se puede conectar por ejemplo a una entrada analógica de un  Arduino, para probar la frecuencia cardíaca

Estudiantes, artistas, deportistas, creadores, desarrolladore3s de juegos, o terminales móviles puedan desarrollar software o interactivos relacionado con el ritmo cardíaco, pero no obstante también existe  una aplicación de código abierto para la visualización en tiempo real de la gráfica de la frecuencia cardíaca en https://github.com/WorldFamousElectronics/PulseSensor_Amped_Arduino/.

 

 

El sensor de pulso cardiaco es esencialmente un fotopletismógrafo, que es un dispositivo médico conocido que se usa para controlar la frecuencia cardíaca de forma no invasiva. Asimismo  los fotopletismógrafos miden los niveles de oxígeno en la sangre (SpO2) pero no siempre lo soportan.

La señal de pulso cardíaco que sale de un fotopletismograma es una fluctuación analógica de voltaje, y tiene una forma de onda predecible, tal como estamos acostumbrados a ver ( la representación de la onda de pulso se denomina fotopletismograma o PPG).

El Sensor de pulso  amplifica la señal bruta del Sensor de pulso anterior y normaliza la onda de pulso alrededor de V / 2 (punto medio en voltaje) respondiendo a los cambios relativos en la intensidad de la luz

Tal y como esta construido ,veremos que  la luz  interna del LED verde del sensor  se refleja de nuevo en el sensor cambiando durante cada impulso, ocurriendo las siguintes casuiticas:.

  • Si la cantidad de luz incidente en el sensor permanece constante, el valor de la señal permanecerá en (o cerca de) 512 (punto medio del rango de ADC).
  •  Más luz y la señal aumentará.
  • Menos luz, todo lo contrario: el valor de la señal analógica dismuniira

El objetivo es encontrar momentos sucesivos de latido instantáneo del corazón y medir el tiempo transcurrido entre ellos, llamado intervalo Inter Beat (IBI)  pues al seguir la forma y el patrón predecibles de la onda PPG, podemos hacer exactamente eso.

Cuando el corazón bombea sangre por el cuerpo, con cada latido hay una onda de pulso (una especie de onda de choque) que viaja a lo largo de todas las arterias hasta las mismas extremidades del tejido capilar donde está conectado el sensor de pulso. La sangre real circula en el cuerpo mucho más lentamente de lo que viaja la onda de pulso.

 

Figura 1

 

Sigamos los eventos a medida que progresan desde el punto ‘T’ en el PPG a continuación. Se produce un aumento rápido en el valor de la señal a medida que la onda de pulso pasa por debajo del sensor, luego la señal vuelve a descender hacia el punto normal. A veces, la muesca dicroica (pico descendente) es más pronunciada que otras, pero, en general, la señal se establece en el ruido de fondo antes de que la siguiente onda de pulso se filtre. 

Como la onda se repite y es predecible, podríamos elegir casi cualquier característica reconocible como punto de referencia, por ejemplo, el pico, y medir la frecuencia cardíaca haciendo cálculos matemáticos sobre el tiempo entre cada pico,pero sin embargo, esto puede dar lugar a lecturas falsas desde la muesca dicroica, si está presente, y puede también ser susceptible a la imprecisión con respecto al ruido de línea base.

Existen otras buenas razones para no basar el algoritmo de detección de latidos en fenómenos de onda arbitrarios. Idealmente, queremos encontrar el momento instantáneo del latido del corazón. Esto es importante para el cálculo preciso de BPM, la variabilidad del ritmo cardíaco ( y mida la frecuencia cardíaca haciendo cálculos en el tiempo entre cada pico.

Sin embargo, esto puede dar lugar a lecturas falsas desde la muesca dicroica, si está presente, y puede también ser susceptible a la imprecisión con respecto al ruido de línea base.

.

 

Algunos investigadores del corazón dicen que es cuando la señal alcanza el 25% de la amplitud, algunos dicen que es el 50% de la amplitud, y algunos dicen que es el momento en que la pendiente es más pronunciada durante el evento ascendente.

 

El circuito que vamos  a ver es muy simple pues solo se precisa conectar  un buzzer y el sensor de pulsos cardíacos  .

Como podemos ver en el video  , el sensor de pulsos cardíacos  se conecta a la alimentación de +5V  entre el hilo rojo(+5v)   y el naranja (GND)   y del  hilo marrón obtenemos la salida analógica que conectaremos a la primera entrada analogica (A0) de cualquier placa que  soporte entradas analogicas como pueden ser Arduino o Netduino

 

arduino.PNG

Para complementar el circuito puede ser interesante reflejar el punto maximo de nivel qeu reproduciremos mediante un buzzer  conectado al pin 11 de salida binaria

 

A continuación  en este breve  ejemplo  para Arduino se puede mostrar un pulso de latido del corazón humano en directo ayudándonos por medio de “Serial Plotter” de arduino o  por ejemplo con una aplicacion móvil usando   un modulo bluetooth coenctado a nuestro arduino

 

En este pequeño programa para Arduino qeu vamos a ver , sonará un buzzer con cada latido de tu corazón al mismo tiempo que se envia el valor de la señal de forma serie (esta es la señal directa del sensor de pulso) el cual podemos visualizar en un ordenador  o si tenemos conectado un modulo bluettoth a nuestro arduino mediante un smarptphone usando una app .

 

//Programa para capturar el pulso cardiaco

// Variable para fijar el puerto donde conectaremos el buzzer 

int buzzer = 11;

// la variable pulso contiene los datos brutos entrantes pudiendo  variar entre 0-1024

int pulso;

 

// Determina qué señal “se contará como un latido” y qué señal ignorar.

int limite = 550;

 

void setup() {

//definimos donde conectamos el buzzer , que  sonará al ritmo de su corazón

pinMode(buzzer,OUTPUT);

 

// Configura la comunicación serial a 9600 dependiendo de su adaptador bluetooth como esté configurado

Serial.begin(9600);
}

void loop() {

// Lee el valor del pin analógico 0, y Asigna este valor a la variable “pulso”.
pulso = analogRead(A0);

 

//Este caracter lo filtra la aplicación en APP inventor

Serial.print(“*”);

// Envíe el valor de pulso al Plotter serial. Comentar si queremos visualizar en “serial ploter”
Serial.println(pulso);
if(pulso > limite){

// Si la señal es superior a “550”, entonces suena el buzzer.
digitalWrite(buzzer,HIGH);

}

else

{

// De lo contrario, deja de sonar el buzzer.
digitalWrite(buzzer,LOW);
}

//Retardo de 35ms
delay(35);
}

 

 

Desbloquear un Netduino inaccesible


La palabra “ladrillo” (bricked) ,se utiliza en referencia a la electrónica de consumo, describiendo como  un dispositivo electrónico tal omo un smartphone, videoconsola, router,tablet, o placa de desarrollo  debido a un severo daño físico, un grave error de configuración, corrupto firmware  o un problema de hardware , ya no funciona, por lo tanto, sólo puede ser útil  tecnológicamente como un ladrillo (y de ahí la sugerencia humoristica  de que el dispositivo  ya sólo puede funcionar como un objeto sin vida, tal como  un pisapapeles o tope de puerta).

Este término es comúnmente usado como verbo. Por ejemplo,  “bricked” mi reproductor de MP3 cuando trató de modificar su firmware y no le funciono. También puede ser utilizado como un sustantivo, por ejemplo, si queda corrupto y se aplica usando fastboot, el dispositivo es un “brick”(ladrillo).

En el uso común del término, “bricking” sugiere que el daño es tan grave que se inutilizó el dispositivo permanentemente.

Antiguamente para desbriquear placas Netduino teníamos la herramienta .NET Micro Framework Deploy Tool (MFDeploy) , herramienta que se instala con  el Framework .NET . Por  ejemplo, para la version 4.3    normalmente el ejecutable estará en  la ruta “C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.3\Tools\MFDeploy.exe”. Esta antigua herramienta nos puede resolver el problema , pero adolece de un  serio inconveniente: no incluye el  firmware disponible ( que como sabemos dependiente de la placa  y  version ) , pero ademas, no siempre logra su objetivo sobra una placa bloqueada.

Asegurar que su Netduino tenga el firmware más reciente significa que será actualizado con la actual ejecución de Netduino específica de  .NET Micro Framework   .Además, a menos que su Netduino tenga el firmware más reciente, pueden tener problemas implementando su aplicación  en ese contexto, de modo   que merece la pena intentar cargar el ultimo firmware oficial.

Las instrucciones para  cargar el ultimo firmware  son diferentes  para el SO donde conectaremos nuestra placa Netduino ( Windows y  tambien Mac).

Desgraciadamente, por consideraciones tecnológicas, las placas soportadas  por esta nueva herramienta son sólo aquellas versiones superiores   a la version 2  ( es decir a partir de Netduino 2 en adelante).

Windows

  1. Descargue la aplicación Netduino Updater .
  2. Descomprimir  la aplicación Netduino Updater_4.3.2.3 en una ubicacion del disco de su ordenador .
  3. Ejecutar la aplicación Netduino Updater.exe .
  4. Incluso conectado su Netduino a su PC no debería aperecer nada   :                                              
  5. Mientras su Netduino está desenchufado de su pc mediante un cable USB, mantenga pulsado el pulsador interno de la placa y luego  al conectarlo suéltelo, para ponerlo en Modo Bootloader de DFU:                                                                                          
  6. Su Netduino debería aparecer en la lista de dispositivos de la lista. Si no apareciese, puede que el driver no este actualizado,  o simplemente que Windows tiene problemas para cargar el driver para ese puerto , por lo que recomendamos probar  conectando el cable a otro puerto USB disponible.
  7. Una vez aparezca su placa en la pantalla de Netduino Adapter, haga clic en la casilla de verificación junto a él y haga clic en el botón Upgrade (Actualizar) : netduino.png
  8. Netduino updater instalará automáticamente la última versión de firmware:
  9. Cuando termine, se reiniciará el Netduino y así que debe ya no se mostrar nada en la lista de dispositivos.                              
  10. Existen tres opciones disponible en esta herramienta ademas de poder actualizar el firmware:
  • Cambiar el nombre de la placa desde la pestaña “General” . Observe que este dato se almacena en una zona de memoria no borrable por lo que su cambio no se puede asegurar hasta que lo repita unas cuantas veces ( al menos dos o mas)general.png
  • Cambiar la dirección MAC  de su placa Netduino  desde la pestaña “Network” .Observe que este dato se almacena en una zona de memoria no borrable por lo que su cambio no se puede asegurar hasta que lo repita unas cuantas veces ( al menos dos o mas)                                          mac.png
  • Borrar la ultima aplicación que haya desplegado en su placa Netduino desde la pestaña “Tools”                                                                         borrar.png

 

Mac

  1. Mientras su Netduino está desenchufado, mantenga pulsado el botón y luego conectarlo, para ponerlo en Modo Bootloader de DFU:
  2. Iniciar el Netduino Mac desplegar (disponible en la página de descargas ):
  3. Haga clic en el botón, debe instalar el firmware: Install Firmware

Instalación de Firmware de los archivos .hex o .s19

La herramienta de Mac Firmware también permite la implementación de firmware manual:

  1. Siga los pasos 1 y 2 anteriores.
  2. Haga clic en el botón y seleccionar la o y archivos: Choose.hex.s19ER_CONFIGER_FLASH
  3. Haga clic en y se deben desplegar el firmware: Deploy

Fuente   http://developer.wildernesslabs.co

Detector de movimiento inteligente


En este ejemplo    volveremos a  usar  un economico NodeMCU ,junto con un  sensor de movimiento PIR  y la plataforma de IoT  Carriots para  construir, usando el IDE de Arduino, un  detector de movimiento inteligente para comerciales y hogar.

El tema  gira en torno a la seguridad de un edificio o casa o una zona restringida detectando cualquier movimiento dentro de un rango específico con un sensor PIR . Gracias al  IoT, además de detectar objetos en movimientos podemos hacer  muchas más cosas como por ejemplo:

  • Encender un dispositivo mediante un relé (en el ejemplo es una luz durante unos 30 segundos).
  •  Al mismo tiempo enviar un correo electrónico al usuario, utilizando la IOT – plataforma Carriots sobre WIFI.
  • El relé se puede conectar a cualquier luz del dispositivo, alarma, cámara, sistema de seguridad…
  • Incluso el disparo puede ser SMS, llamar a las autoridades, llamando a otros servicios…

Node MCU es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  a los que indudablemente se une su bajisimo precio comparado con otras opciones.
De este componente destaca  integra capacidades de comunicación via WiFi , conteniendo en su interior  microprocesador que puede ser programado fácilmente usando en conocido lenguaje de programación Lua o vía Arduino IDE.

¿Se pregunta cómo controlar  su económico ESP8266 de forma remota desde cualquier lugar del mundo?

En este post repasaremos precisamente el proceso, paso a paso, de cómo escribir código en el IDE de Arduino y programar su ESP8266 permitiendo  que el código  escrito para  el ESP8266 se comunique con la plataforma  de Iot   Carrriots,  la cual  nos va  permitir monitorear  y controlar el ESP8266.

Los pasos  a seguir   para conectar un ESP8266   a  Carriots   son los siguientes:

  •  Instalación del IDE de Arduino .Si aun no lo tiene instalado ,se puede hacer  desde aqui
  • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino

esp

  • Instalación de los controladores USB

Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.

El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador

Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema)
Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

Carriots es una Plataforma como Servicio (PaaS en sus siglas en inglés) diseñada para proyectos del Internet de las Cosas (IoT) y de Máquina a Máquina (M2M)

carriots

Carriots es una plataforma IoT creada en España  que  permite crear potentes productos y servicios IoT  haciendo posible conectar fácilmente “sus cosas” al Internet de las Cosas.

Se  pueden construya sus apps inteligentes con Carriots en pocos pasos.

  1. Conectar Dispositivos
  2. Recopilar Datos
  3. Gestionar Dispositivos y Datos
  4. Construir APPs

Principales ventajas

  • Listo para empezar a desarrollar.
  • Minimizar tiempo de desarrollo.
  • Gestión simplificada de múltiples proyectos: Arquitectura de 7 niveles
  • Amplia variedad de APIs y potente SDK: REST API y SDK
  • Escalabilidad inmediata
  • Inicio gratuito y pago por uso.
  • Alojamiento simplificado: Oferta PaaS para escalabilidad fiable.

Hardware

Ahora preparado el entorno , necesitamos el hw  que lo permita , el cual  como vamos a ver,  es muy simple reduciendose a la placa o NodeMCU, una placa de relé, el sensor PIR  y una fuente de 5V DC

Sensor PIR

El sensor PIR usado , es del tipo HC-SR501, de bajo coste   el cual es ampliamente utilizado en diversos equipos eléctricos de detección automática, productos para el control automático especialmente a batería.Tiene alta sensibilidad, alta fiabilidad, bajo consumo de energía, el modo de operación de bajo voltaje.

Especificaciones:

  •  Dimensiones: Cerca de 3,2 x 2,4 cm (L x W).
  •  Rango de tensión: 5V-20V DC.
  •  Corriente estática: < 50uA
  •  Voltaje de salida: 3,3 V (alto) / 0V (bajo)
  •  Modo del disparador: L (no se puede gatillo repetida), H gatillo repetida (Repetición predeterminado de disparo)
  •  El Tiempo de retardo: 0,3 seg 18 seg (ajustable)
  •  Temperatura De funcionamiento: -15 C a 70

 Placa de rele

Por  precio  es mucho mas asequible optar por una placa    de  2 reles    con salida de relé máxima: DC 30V / 10A, AC 250V / 10A. Es  importanet   que el interfaz de tarjeta de relé sea de 5v . En nuestro caso es de 2 canales y cada canal necesita 15-20mA actual controlador

Este tipo de placas es de fácil instalación por el microcontrolador como Arduino, 8051, AVR, PIC, DSP, BRAZO, MSP430, PLC, lógica TTL pues solo ha que conectar la alimentacion  y dos cables de datos en caso de necesitar los dos canales 

Resumiendo , estos son los componentes  necesarias:

  • Placa de desarrollo de NodeMcu Lua WIFI Internet de las cosas basado en ESP8266 – 1 (capacidad de MCU y WIFI)
  • Sensor PIR ( hemos hablado  en este blog )
  • 1 módulo de relé con opto aislamiento de  5V1
  • Fuente de alimentación conmutada  220V/5v ( nos sirve cuaqluier cargador de movil  con salida microusb)
  • Placa Protoboard

Diagrama del circuito:

El circuito   no incluye dificultad alguna ,pues se reduce a conectar el sensor PIR a +5V  y la salida binaria al pin D2, el módulo de rele a +5v   y al pin D2    y por  supuesto la alimentación del circuito que puede ser bien a baterías  o  bien por medio del  propio micro-usb   usado para programar el  NodeMcu

Resumiendo las conexiones con las siguientes:

  • NodeMCU (ESP8266 Dev Kit) D1—> INI del relé
  • NodeMCU (ESP8266 Dev Kit) D2—> Digital sensor PIR
  • NodeMCU (ESP8266 Dev Kit) VCC—> VCC (+) de la batería
  • NodeMCU (ESP8266 Dev Kit) GND—> GND (-) de la batería
  • Relé de VCC—> VCC (+) de la batería
  • Relé de tierra—> GND (-) de la batería
  • PIR Sensor VCC—> VCC (+) de la batería
  • PIR Sensor de tierra—> GND (-) de la batería

Software

Una vez el hardware  montado nos toca escribir el código  el código utilizando el IDE de Arduino para hacer que NodeMCU trabaje con un relé, sensor de movimiento PIR y utilizar IOT plataforma carriots sobre WIFI

El autor se  encontró con  algunos puntos problemas  en el diseño del programa  para ejecutar en la placa NodeMcu;

  • Compruebe que los pines de NodeMcu  están dando la entrada o salida correcta como se están asumiendo, por ejemplo, asegurándose  que usted no está tomando el pin 4 (GPIO) como un pin de entrada asi que por defecto que este pin debe leer…
  • Utilizar un método directo de get y post HTTP en lugar de utilizar una función de visualización por BLYNK o Thinger.io.
  • Observe  que el PIR da salida permanentemenet alta durante un par de envíos pero se necesita traer retraso para evitar el envío de múltiples correos electrónicos. Con algunos servicios como BLYNK este retraso causa un problema  asi que  es mejro a llamar a esa función una vez despues  de 6 o 7 seg.
  • Una vez satisfecha la condición de if loop, llamar a una función, en lugar de escribir todo con el bucle. Esto aporta claridad del código y ayuda en la resolución de problemas.
  • Se  puede  ajustar la sensibilidad del PIR para reducir el tiempo que permanece alta.

A continuación veamos el codigo completo del sw  que habrá que subir  a la placa desde el entorno  de Arduino:

#include “ESP8266WiFi.h”

const char * ssid = “NETGXXXXX”;   //red wifi a la que se conectara

const char * clave = “XXXXXXXXX”;  //clave red wifi para coenctarse

const char * servidor = “api.carriots.com”;

const String APIKEY = XXXXXXXXXX”; //Sustituir con su apikey de Carriots

 const  String DEVICE = “[email protected]”; //Reemplazar por el id_developer del dispositivo de  carriots

int ledpin = 4;

pirpin INT = 12;

int pirstate = LOW;

int val = 0;

void setup() {

Serial.Begin(115200);

Delay(10);

pinMode(ledpin,OUTPUT);

pinMode(pirpin,INPUT);

Serial.println(“calibrando”);

for (int i = 0; i < 20; i ++) {

Serial.Print(“.”);

Delay(1000);

}

//iniciar wifi

Serial.println();

Serial.println();

Serial.Print (“conectarse”);

Serial.println(SSID);

WiFi.begin (ssid, clave);

while  (WiFi.status()! = WL_CONNECTED) {

Delay(500);

Serial.Print(“.”);

}

Serial.println(“”);

Serial.println (“Wi-Fi conectado”);

Serial.println (“dirección IP:”);

Serial.println(WiFi.localIP());

}

//función para hablar con la plataforma Carriot

void sendStream()

{

String txt = “”; //Texto para enviar

if (pirstate == HIGH)

{/ / alarma

txt = “Detecta movimiento;”

} else {/ / alarma en

txt = “Algo mal”;

}

 

Serial.println(txt);

Serial.println(Val); / / para fines de depuración

Client WiFiClient;

const int httpPort = 80;

if  (client.connect (servidor, 80)) {/ / si hay una conexión exitosa

Serial.println(F(“Conectedo”));

//Construir el campo de datos

String json = “{\”protocol\”:\”v2\”,\”device\”:\””+DEVICE+”\”,\”at\”:\”now\”,\”data\”:{\”light\”:\””+txt+”\ “}}”;

//Realizar una solicitud HTTP

Client.println (“POST /streams HTTP/1.1”);

Client.println (“Host: api.carriots.com”);

Client.println (“Accept: aplicación/json”);

Client.println (“User-Agent: Arduino-Carriots”);

Client.println (“Content-Type: aplicación/json”);

Client.Print (“carriots.apikey:”);

Client.println(APIKEY);

Client.Print (“Content-Length:”);

int thisLength = json.length();

Client.println(thisLength);

Client.println (“conexión: cerrar”);

Client.println();

Client.println(JSON);

}

Else {}

//Si no tiene una conexión con el servidor:

Serial.println (F (“Conexión fallida”));

}

}

 

void loop() {}

Val = digitalRead(pirpin);

Serial.println(Val);

if(Val == HIGH) {}

digitalWrite(ledpin,HIGH);

if  (pirstate == LOW) {

Serial.println (“movimiento detectado”);

pirstate = HIGH;

Serial.println (F (“secuencia de enviar”));

sendStream();

Delay(30000);

}

/ * {while(client.available())}

String linea = client.readStringUntil(‘\r’);

Serial.Print(line);

Delay(30000);

} */

}

Else {}

digitalWrite(ledpin,LOW);

if(pirstate == HIGH) {}

Serial.println (“movimiento detectado correo enviado”);

pirstate = LOW;

}

}

}

Programación de disparadores de Carriots enviar Email:

Una vez   que  tenga desplegado el  sw en su  placa NodeMcu  ,la capacidad de activar un correo debe ser  programado o configurado en la plataforma de Internet para este producto que está utilizando (la plataforma Carriots IOT) . Si no sabe como hacerlo en el siguiente video podemso  ver  como  familiarizarse con las funciones y cómo utilizarlas:

 

Obviamente esto podría programarse para llamada, o un texto o una alarma a la policía o quien sea. !Como podemos adivinar   las posibilidades  son infinitas!.

Fuente 

Primeros pasos con ESP8266


Node MCU es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  que pueden ademas  pueden   involucrar el IoT  .

Esta placa  destaca  porque integra capacidades de comunicación via WiFi , conteniendo en su interior  un microprocesador que puede ser programado fácilmente usando el  conocido lenguaje de programación Lua o bien vía Arduino IDE.

Obviamente ante todo no podemos perder de vista su bajisimo precio ( menos de 10€  ) comparados con otras opciones , pues no debemos olvidar  que incluye  el modulo wifi integrado  y un bus GPIO para conectar dispositivos de E/S.
Node MCU es una plataforma de desarrollo permite un prototipado rápido, para una vez satisfechos con el resultado, portar el desarrollo a un sistema final con un chip ESP8266 como pieza central.

A la hora de programar nuevas funciones, si optamos por utilizar Lua, dispondremos de un sistema simple con buena comunidad de usuarios. En cambio programar con el sistema Arduino nos aporta un fantástico IDE y un sinfin de manuales y ejemplos de desarrollo.

Este modulo es Ideal como una solución independiente en lugar de Arduino además de Wi-Fi  integrado siendo fácil de programar a través del IDE de Arduino (como vamos a ver ) , al igual que un Arduino.
Todos los periféricos con bus I2C puede unirse,por ejemplo Pantallas OLED, pantallas LCD, temperatura, presión, sensores de humedad pueden ser conectados en paralelo. También se puede conectar múltiples DS18B20

Sin embargo, sólo hay una entrada analógica y salida y las pantallas táctiles no se pueden conectar con ella.

 

¿Se pregunta cómo empezar a  desarrollar código  con  su económico ESP8266 ?

Los pasos  a seguir   para conectar un ESP8266     son los siguientes:

  •  Instalación del IDE de Arduino .Si aun no lo tiene instalado ,se puede hacer  desde aqui
  • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino

esp

  • Instalación de los controladores USB

Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.

El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador

Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema)
Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

Ahora que estamos listos para comunicarnos con nuestro ESP8266 a través del CP2102, podemos explorar algunas de las diferentes opciones de firmware disponibles.

node.png

  • En el IDE de Arduino, vaya al menú de herramientas, seleccionada su placa y elija el  puerto al que está conectado su ESP8266.En el ejemplo  es el COM11

 

puerto.png

  • Ahora  copie el siguiente código  para probar que puede subir y ejecutar código código  en la placa :

 

/*
ESP8266 Led Parapadeante
*/

void setup(){

pinMode(LED_BUILTIN, OUTPUT);// Initializa el  pin de  LED_BUILTIN como salida

}

void loop() {       // la función de bucle se repite una y otra vez para siempre

digitalWrite(LED_BUILTIN, LOW);// encienda el LED 

delay(1000); //Espera de 1 segundo

digitalWrite(LED_BUILTIN, HIGH);//  Apague el LED haciendo que el voltaje sea ALTO

delay(2000); // Espere dos segundos  para dejar apagado  LED 

}

 

El LED azul en el módulo ESP – 01 está conectado a GPIO 1, (que también es el pin TXD, por lo que no podemos usar Serial.print () al mismo tiempo)

Tenga en cuenta que el nivel de voltaje es BAJO  pero en realidad el LED está encendido, porque es bajo en el ESP – 01

En este código se usa  LED_BUILTIN para encontrar el pin con el LED interno  de modo

Como puede apreciar , el código ejecuta un bucle infinito en el que pone el estado bajo  un segundo (encendiendo el led)    para posteriormente forzar a nivel alto  dos segundos(apagando el led  )  y así   indefinidamente gracias al bucle  que se repite indefinidamente

 

Envio de datos a la nube de Cayenne

  • Agregue la biblioteca de Cayenne MQTT a Arduino IDE  desde aqui como un fuchero zip
  • Instale la biblioteca zip descargada en el paso anterior desde Programa -> Incluir biblioteca -> Añadir libreria ZIP. y seleccionar ahora el fichero descargado con anterioridad  Cayenne-MQTT-ESP-master.zip
  • Ya puede crear una cuenta Starter en cayenne ( si aun no la tiene  ya creada)
  • Una vez ya validado vaya a la esquina  superior  izquierda  y pulse sobre el botón verde  add new
addnew.png
  • Ahora seleccione Generic ESP8266  como la placa y  tome nota  ahora  de los siguintes paraetros ofrecidos por la  pagina:
    •  MQTT USERNAME:
    • MQTT PASSWORD:
    • CLIENT ID:
    • MQTT SERVER:
    • MQTT PORT:
    • NAME YOUR DEVICE (optional):
  • Abra el boceto de ejemplo incluido desde Archivo -> Ejemplos -> Cayenne-MQTT-ESP. Modifique el boceto incluido con su información de red y la información de autenticación de Cayenne que recibió al agregar su dispositivo.

Primeros pasos con ESP8266 y Cayenne


Node MCU es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  a los que indudablemente se une su bajisimo precio comparado con otras opciones.
De este componente destaca  integra capacidades de comunicación via WiFi , conteniendo en su interior  microprocesador que puede ser programado fácilmente usando en conocido lenguaje de programación Lua o vía Arduino IDE.

¿Se pregunta cómo controlar  su económico ESP8266 de forma remota desde cualquier lugar del mundo?

En este post repasaremos precisamente el proceso, paso a paso, de cómo escribir código en el IDE de Arduino y programar su ESP8266 permitiendo  que el código  escrito para  el ESP8266 se comunique con la plataforma myDevices Cayenne (https://cayenne.mydevices.com) la cual nos va  permitir monitorear y controlar el ESP8266 a través de un tablero muy intuitivo.

 

De  Cayenne hemos hablado  en este humilde blog, en muchisimas  ocasiones pero resumidamente es una solución innovadora   para la construcción de aplicaciones IoT  basada en la mayoría de las  plataformas conocidas como son Arduino, Raspberry pi, ESP8266 y dispositivos  Seriales, Wifi y dispositivos Lora

Ademas   también  incluye una API Mqtt para conectar cualquier cliente MQTT la cual utilizaremos en este caso

Después de configurar una cuenta en Cayenne, utilizamos el Tablero para configurar un cualquier puerto del GPIO al que conectemos una entrada o una salida  . La comunicación entre el ESP8266 y Cayenne se realiza utilizando un protocolo muy ligero llamado MQTT (http://mqtt.org/).

Una vez que todo esté hecho, podemos monitorear y controlar el ESP8266 desde cualquier parte del mundo simplemente accediendo a Cayenne.

Los pasos  a seguir   para conectar un ESP8266   a  la nube de Cayenne  son los siguientes:

  •  Instalación del IDE de Arduino .Si aun no lo tiene instalado ,se puede hacer  desde aqui
  • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino

esp

  • Instalación de los controladores USB

Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.

El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador

Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema)
Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

Ahora que estamos listos para comunicarnos con nuestro ESP8266 a través del CP2102, podemos explorar algunas de las diferentes opciones de firmware disponibles.

  • Agregue la biblioteca de Cayenne MQTT a Arduino IDE  desde aqui como un fuchero zip
  • Instale la biblioteca zip descargada en el paso anterior desde Programa -> Incluir biblioteca -> Añadi libreria ZIP. y selecionar ahorael fichero descargado con anterioridad  Cayenne-MQTT-ESP-master.zip
  • Conecte el ESP8266 a su PC / Mac a través de un cable USB con capacidad de datos.
  • En el IDE de Arduino, vaya al menú de herramientas, seleccione su placa y el puerto al que está conectado su ESP8266.
  • Ya puede crear una cuenta Starter en cayenne ( si aun no la tiene  ya creada)
  • Una vez ya validado vaya a la esquina  superior  izquierda  y pulse sobre el botón verde  add new
addnew.png
  • Ahora seleccione Generic ESP8266  como la placa y  tome nota  ahora  de los siguintes paraetros ofrecidos por la  pagina:
    •  MQTT USERNAME:
    • MQTT PASSWORD:
    • CLIENT ID:
    • MQTT SERVER:
    • MQTT PORT:
    • NAME YOUR DEVICE (optional):
  • Abra el boceto de ejemplo incluido desde Archivo -> Ejemplos -> Cayenne-MQTT-ESP. Modifique el boceto incluido con su información de red y la información de autenticación de Cayenne que recibió al agregar su dispositivo.
.// This example shows how to connect to Cayenne using an ESP8266 and send/receive sample data
.// Make sure you install the ESP8266 Board Package via the Arduino IDE Board Manager and select the correct ESP8266 board before compiling.
//#define CAYENNE_DEBUG
#define CAYENNE_PRINT Serial
#include <CayenneMQTTESP8266.h>
// WiFi network info.
char ssid[] = “ssid”;
char wifiPassword[] = “wifiPassword”;
// Cayenne authentication info. This should be obtained from the Cayenne Dashboard
char username[] = “MQTT_USERNAME”;
char password[] = “MQTT_PASSWORD”;
char clientID[] = “CLIENT_ID”;
unsigned long lastMillis = 0;
void setup()
{ serial.begin(9600);
Cayenne.begin(username, password, clientID, ssid, wifiPassword);
}
void loop()
{
Cayenne.loop();
//Publish data every 10 seconds (10000 milliseconds). Change this value to publish at a different interval.
if (millis() – lastMillis > 10000)
{ lastMillis = millis();
//Write data to Cayenne here. This example just sends the current uptime in milliseconds.
Cayenne.virtualWrite(0, lastMillis);
//Some examples of other functions you can use to send data.
//Cayenne.celsiusWrite(1, 22.0);
//Cayenne.luxWrite(2, 700);
//Cayenne.virtualWrite(3, 50, TYPE_PROXIMITY, UNIT_CENTIMETER);
}
}
//Default function for processing actuator commands from the Cayenne Dashboard.
//You can also use functions for specific channels, e.g CAYENNE_IN(1) for channel 1 commands.
CAYENNE_IN_DEFAULT()
{ CAYENNE_LOG(“CAYENNE_IN_DEFAULT(%u) – %s, %s”, request.channel, getValue.getId(), getValue.asString());
//Process message here. If there is an error set an error message using getValue.setError(), e.g getValue.setError(“Error message”);
}
  • Compile y sube el programa  a su dispositivo. La carga puede requerir configurar el dispositivo en modo de carga de arranque. Para el módulo Adafruit HUZZAH ESP8266, esto se hace siguiendo los siguientes pasos:
    • Mantenga presionado el botón GPIO0.
    • Haga clic en el botón Restablecer.
    • Suelta el botón GPIO0.
    • El LED rojo debería encenderse, lo que indica que el dispositivo está listo para cargar.
    • Cargue su boceto.
    • Compruebe el tablero de Cayenne para asegurarse de que está recibiendo datos de muestra de su dispositivo.

 

Hay mas ejemplos desde el  interfaz de Arduino   en  File → Examples → Cayenne-MQTT-ESP8266 → ESP8266

 

Monitorizacion de liquidos via wifi desde su smartphone


Utilizando la placa WiFi NodeMCU-12E v3 ESP8266  y 2 sondas ultrasónicas de tipo HC-SR04 a prueba de agua , se  puede  medir el volumen de agua en 2 tanques de agua y ofrecer esa información  de un modo gráfico  y en tiempo real.

El  sonar suena por la parte superior del agua, obteniendo la distancia en cm,calculando la profundidad del agua en cm y luego extrapolando  el volumen de agua a litros.   Toda la información se pasa por WiFi en la WLAN al servidor local (RPi3) que ejecuta el servidor local Blynk. Finalmente la información está disponible en un teléfono usando la aplicación Blynk registrada en el servidor local.

Es importante destacar que el el mapeo de los pines es diferente en estas placa frente a lo s pines de un Arduino ( los números de pin son generalmente números de GPIO)

Es  este proyecto se usaran los típicos sensores ultrasónicos HC-SR04 estándar  sensores que transmiten   y reciben  señales  ultrasónicas ,  que en este caso deberán o bien  impermeabilizarse para ser resistentes al agua e impermeables ( el aspecto es muy similar a las mismas unidades que se usan en los vehículos para detectar colisiones al aparcar ) o bien comprarlos  ya  estancos espaciales  para ambientes húmedos, ( como en la foto).

sesnor

Concretamente este sensor se alimenta de  DC 5 V( consumo  30mA) usando  e emisión de frecuencia: 40 khz  con  una detección  máxima distancia de 4.5 m y resolución  cerca de 0.5 cm

Sus conexiones son 4:

  • VCC+ 5 V (fuente de alimentación positiva)
  • Trig (lado de control) RX
  • eco (lado receptor) TX
  • GND (negativo)

El uso de la ubicación disparador del IO TRIG puerto, pone el alto nivel de la señal de al menos 10us; el módulo automáticamente envía 8 trens de  40 KHz  con detección automática si  hay vuelta de señal.Una señal de vuelta se marca como  un alto nivel de salida a través del puerto IO de ECO. El tiempo de duración de alto nivel   ultrasónica es el del lanzamiento de volver.

La formula  para calcular la  distancia es la siguiente:

D(m) = tiempo de alto nivel * velocidad del sonido (los 340 M/S)) /2 

Como vemos este módulo utiliza el método sencillo, un puerto de control con un 10US por encima de alto nivel,  esperando un alto nivel de salida en el puerto de recepción. Una salida puede conducir el temporizador, de modo que cuando este puerto se pone la señal  bajo puede leer el valor del temporizador, y  esta vez para la ubicación del tiempo, se puede calcular la distancia de modo que así  constantemente hay un ciclo de  medicino

Estos sensores HCSR04 los conectamos  a una placa WiFi ESP8266 NodeMCU y yna pequeña placa para la alimenticio  de 3.3v  del ESP8200

El esquema es bastante sencillo como podemos ver en  la siguiente imagen:

Imagen de Primeros pasos con el banco para las pruebas iniciales

El  total de compontes    en resumen son los siguintes :

Para fines de prueba se puede  usar  un  PC para alimentar el circuito ,pero con la idea de que cuando este ya programado  funcione independiente , lo mejor es   utilizar un pequeño conversor  DC-DC de 3 v3  y asi usar cualquier fuente de alimentación de  220v/ 12v para alimentar el circuito (usando el coneversor como adptador de tension) 

 Tenga en cuenta que estas placas ESP12E funcionan con 3,3 voltios pero tienen un pin de suministro de entrada de 5v (VIN) y también funcionan con el suministro de USB cuando están conectados a su PC. No suministre más de 5 voltios al pin VIN si lo usa.

La conexiones  a usar son las siguientes :

  • Sensoring a Arduino GPIO5 (D1)
  • Sensor1 echo a Arduino GPIO4 (D2)
  • Sensor2 ping a Arduino GPIO14 (D5)
  • Sensor2 echo a Arduino GPIO12 (D6)

Estos sensores funcionan también a 3.3 voltios   y dan un  buen nivel de salida asi que no es necesario  convertidores de salida .Conecte ambos VCC a los sensores Arduino 3v3 y conecte ambos sensores GND a Arduino GND.

Puede usar un  LED  pero como se encenderá   solo de 50mS cada 2 segundos,  no merece la pena conectar una resistencia limitadora de corriente, (pero se puede agregar una resistencia 1 / 4W 470R si lo desea.). ElÁnodo del led  (pata larga) ira al Arduino GPIO13 (D7) y el Cátodo a Arduino GND

Tenga en cuenta   que los cables de los sensores  tienen cables coaxiales de 2 m de longitud., si necesita extender estoso pues usar un viejo cable coaxial que tenga , asegúrandose  de cubrir todas las uniones soldadas con termofluente.

 

 Instalando el Software

Este monitor de nivel de agua usa su tarjeta ESP8266 en su teléfono a través de sus servidores.

El servidor de Blynk en la nube sirve su aplicación con la información en los widgets en el teléfono. Al registrarte con Blynk, recibe 2000 puntos de energía de modo que con estos puntos se usan para ‘comprar’ widgets para su programa ( 2000 puntos son suficientes para construir esta aplicación de monitor de agua).

Otra opción es usar un servidor local ejecutándose en una Raspberry Pi, lo cual  permite puntos ilimitados y una mejor seguridad y no usando el servidor Blynk en absoluto,(es completamente independiente). La instalación y configuración de un servidor local está más allá del alcance de este post  sobre todo porque hay muchas instrucciones y tutoriales en la red para hacer esto comenzando con el sitio web de Blynk.

La versión final  utiliza  OTA para recibir actualizacion en el aire desde el wifi sin necesidad de  sacar todo para actualizar el software ( veremos  los cambios y métodos del software OTA más adelante).

 

Lo primero que necesitará es el Arduino IDE si aún no lo tiene.

Descargue la biblioteca Blynk aquí Biblioteca Blynk , la descarga se encuentra en la parte inferior de la página. Siga las instrucciones en esa página para instalar la biblioteca.Obtenga  tambien  la aplicación del teléfono aquí Blynk App .Se puede crear una cuenta para Blynk si desea usar la aplicación. Recuerde la dirección de correo electrónico de inicio de sesión que utiliza, la necesitará más adelante. Probablemente sea mejor usar su cuenta de correo electrónico todos los días.

También necesitará esta biblioteca:NewPing Esta es una excelente biblioteca para usar sus dispositivos. No hay necesidad de perder el tiempo con milisegundos, etc.

Estas instrucciones son para el software ESP8266:

  • Comenzando con 1.6.4, Arduino permite la instalación de paquetes de plataforma de terceros usando Boards Manager. Tenemos paquetes disponibles para Windows, Mac OS y Linux (32 y 64 bits).
  • Inicie Arduino y abra la ventana Archivo> Preferencias.
  • Ingrese “ `http: // arduino.esp8266.com / stable / package_esp8266com_index.json“` en el campo * Additional Board Manager URLs *. Puede agregar varias URL, separándolas con comas.
  • Abra el Administrador de tableros desde Herramientas> Menú de la placa e instale la plataforma * esp8266 * (y no olvide seleccionar su placa ‘NodeMCU 1.0 (Módulo ESP-12E)’ desde Herramientas> Menú de la placa después de la instalación).
  • En el menú, seleccione Boceto> Incluir biblioteca> Administrar bibliotecas.Permitir que termine la descarga. Debería ver las bibliotecas de Blynk instaladas.
  • Para que su PC se comunique con el software USB to Serial de las placas Arduino debe instalar el controlador USB-UART CH341SER_win. Esto es necesario para todas las comunicaciones Arduino a través de USB. Obtengalo aqui

 

 Código de prueba para la placa ESP8266

Comenzaremos con dos sensores que informan la información al monitor serie integrado en el IDE de Arduino. Aún no se informa al servidor Blynk, OTA o WiFi.

Haga doble clic en el archivo ‘water_code_1.in’ a continuación, después de que Arduino IDE comience vaya a Archivo> ‘guardar como’ y guárdelo en su carpeta de bocetos.Se creará una carpeta con el archivo dentro.Confirme que tiene la placa correcta seleccionada, haga clic en el botón ‘verificar’ (botón muy a la izquierda en el IDE). Debe compilar sin error. Conecte su placa al cable USB, desde el menú IDE Herramientas> Puerto> COM n.

El puerto de comunicación correcto se puede encontrar simplemente desenchufando la placa y viendo qué puerto desaparece.Haga clic en el botón ‘Subir’ en IDE Arduino y permita que termine de compilar y cargar.En el IDE seleccione Herramientas> Monitor en serie

El LED debe parpadear cada 2 segundos y el monitor debe informar la distancia, la profundidad y los litros de agua de cada tanque durante 2 segundos, de forma similar a la imagen mostrada.

Imagen del código de prueba para el tablero ESP8266e Estos sensores tienen un rango d aproximadamente 3 mtrs. de modo que están configurados a 3 mtrs en el software de todos modos.

Pruebe cada sensor moviéndolo dentro y fuera de un objeto sólido como la pared, debería ver las figuras cambiar en la ventana del monitor. A medida que la distancia aumenta, simula un nivel de agua más bajo.

Este es  el codigo  final :

#include
#include

#define SONAR_NUM 2 // Number of sensors. Change to suit your requirements.
#define PI 3.1415926535897932384626433832795

//** CHANGE TO SUIT TANK DIMENSIONS
const int MAX_DISTANCE = 300; //max distance to measure
const int Diameter1 = 276; //internal Diameter of tank 1 cm
const int Diameter2 = 276; //internal Diameter of tank 2 cm
const int Depth1 = 265; //total depth of tank 1 cm , from sensor to base inside
const int Depth2 = 265; //total depth of tank 2 cm, from sensor to base inside

const unsigned int Period = 2000; //period between pings, in milliseconds. i.e 1 munute = 60,000. max 65535. Want longer? use unsigned long

//** SENSOR PINS

const int PingPin1 = 5; // GPIO5, D1
const int EchoPin1 = 4; // GPIO4, D2
const int PingPin2 = 14; // GPIO14, D5
const int EchoPin2 = 12; // GPIO12, D6

const int Area1 = PI * ((Diameter1 / 2) * (Diameter1 / 2)); //area of base of tank 1
const int Area2 = PI * ((Diameter2 / 2) * (Diameter2 / 2)); //area of base of tank 2

// Global variables
int Litres1, Litres2, Distance1, Distance2, WaterDepth1, WaterDepth2;

BlynkTimer timer; //config timer

NewPing sonar[SONAR_NUM] = { // Sensor object array.
NewPing(PingPin1, EchoPin1, MAX_DISTANCE), // Each sensor’s trigger pin, echo pin, and max distance to ping.
NewPing(PingPin2, EchoPin2, MAX_DISTANCE)
};

void sendSensorReadings()
{
//***********Readings Tank 1
Distance1 = sonar[0].ping_cm(); //get distance to the top of the water tank 1
if (Distance1 >= Depth1 || Distance1 == 0 ) Distance1 = Depth1; //check it does not go negative
WaterDepth1 = Depth1 – Distance1; //calculate the depth of the water
Litres1 = (Area1 * WaterDepth1) / 1000; //calculate the volume of the water as litres
delay(50);

//************Readings Tank 2
Distance2 = sonar[1].ping_cm(); //get distance to the top of the water tank 2
if (Distance2 >= Depth2 || Distance2 == 0) Distance2 = Depth2; //check it does not go negative
WaterDepth2 = Depth2 – Distance2; //calculate the depth of the water
Litres2 = (Area2 * WaterDepth2) / 1000; //calculate the volume of the water as liters

digitalWrite(13, HIGH); //flash the LED on D7, just to let us know it’s running
delay(50);
digitalWrite(13, LOW);

//************************* can be commented out, test use only
Serial.println();
Serial.println();
Serial.println(“Tank 1 water distance: ” + String(Distance1)); //print depth
Serial.println(“Tank 1 water depth: ” + String(WaterDepth1)); //print depth
Serial.println(“Tank 1 Litres: ” + String(Litres1)); //print litres

Serial.println();
Serial.println(“Tank 2 water distance: ” + String(Distance2)); //print depth
Serial.println(“Tank 2 water depth: ” + String(WaterDepth2)); //print depth
Serial.println(“Tank 2 Litres: ” + String(Litres2)); //print litres
//***********************************************

}

void setup() {

pinMode(13, OUTPUT); //LED GPIO13 D7

timer.setInterval(Period, sendSensorReadings); // Setup a function to be called every ‘n’ seconds
delay(10);

//** can be commented out, test only
Serial.begin(115200); // Open serial console.
Serial.println();
//*******************************

delay(20);
}

void loop() {

Blynk.run();
timer.run();

}

 

Código  Final con WiFi y Blynk

Ahora vamos a conectarnos al servidor de Blynk. Descargue y abre el water_code_2.ino

En el IDE de Arduino, seleccione Archivo> “guardar como” en su carpeta de bocetos.

Abra la aplicación Blynk, inicie sesión. Cree un nuevo proyecto,  dispositivo = ESP8266, tipo de conexión = WiFi, configure el tema que prefiera.presione el botón Crear.Se enviará un token de autoridad a su cuenta de correo electrónico designada.Presione OK  y vaya a su correo electrónico , copie el token de autoridad, péguelo en su programa arduino donde dice ‘char auth [] = “YourAuthToken“

También ingrese su SSID y su contraseña.Ahora cárgalo en su ESP.

Ahora  terminaremos el proyecto Blynk viendo como configurar la aplicación.

Configuración del programa de aplicación Blynk

Imagen de la configuración del programa de la aplicación Blynk

 

Entre en su app movil  Blync e introduzca sus credenciales de acceso. Siga los siguientes pasos para configurar la aplicación para la medición de los niveles de dos tanques

  • Presione + en la parte superior de la pantalla en la aplicación, desplázese hacia abajo y presiona Value Display. Haga esto 4 veces
  • Presione + en la parte superior de la pantalla en la aplicación, desplázese hacia abajo y presiona NivelV. Haga esto dos veces
  • Presione + en la parte superior de la pantalla en la aplicación, desplázesee hacia abajo y presiona SuperChart.
  • Diseñe los widgets como en la imagen. Una pulsación larga en el widget le da identificadores para redimensionarlos.
  • Colócalos como mejor le parezca.
  • Presione la primera Pantalla de valor (arriba a la izquierda), asígnele el nombre Profundidad 1, seleccione V1, 0 a 300 y PULSE
  • Presione la segunda pantalla de valores, nombre Profundidad 2, seleccione V4, 0 a 300 y PUSH
  • Presione la tercera pantalla de valores (2 abajo a la izquierda), nombre Liters 1, seleccione V2, 0 a 9999 y PUSH
  • Presione la cuarta pantalla de valores, nombre Liters 2, seleccione V5, 0 a 9999 y PUSH
  • Presione el nivel vertical izquierdo, nómbrelo Nivel 1, seleccione V3, 0 a 1600, APAGADO y EMPUJE
  • Presione el nivel Vertical derecho, nómbrelo Nivel 2, seleccione V6, 0 a 1600, APAGADO y PULSE
  • Presione SuperChart, Litros 1 y Litros 2.
  • Presione el ícono (flujo de datos) al lado de Nombre, PIN = V3, interruptor deslizante = VALORES, minn = 0, máximo = 1600
  • Presione el ícono (secuencia de datos) al lado del segundo nombre, PIN = V6, interruptor deslizante = VALORES, min = 0, máximo = 1600

Puede jugar con las otras configuraciones para adaptarlas a sus preferencias. Para eliminar un widget, arrástrelo a la derecha de la pantalla.

Si todo se ve bien, presione la esquina superior derecha de la pantalla. Si su Arduino se está ejecutando, debería ver los mismos números (excepto la distancia) que en el monitor de serie.

Como se puede ver en la imagen anterior de la app movil  de Blync   debe tener en cuenta que debe ajustar el valor real de  Profundidad1 y Profundidad2  en la app  , pero también deberá reflejar los  valores correspondientes en el codigo de Arduino  para calcular el volumen par lo cual es importante  no olvidar este detalle.

En el ejemplo los depósitos son circulares de modo que hay especificar tanto el diámetro como la profundidad:

 

Imagen de Mount the Sensors en los tanques

También  debe señalar que estos sensores tienen un rango mínimo de 20 cm, lo cual se debe a que el transmisor y el receptor comparten la misma distancia.

 

Configurar la  actualización por  OTA

Imagen de la configuración de la actualización de OTA

OTA o ‘Over The Air‘ es una característica realmente útil, especialmente en este caso donde ESP está dentro de una caja y afuera.

Este es un proceso bastante simple:

  1.  El cargador de arranque OTA se carga primero en la placa.
  2.  La placa se reinicia presionando el botón de reinicio en la placa.
  3.  Su nuevo código para el proyecto de tanque de agua que contiene las adiciones de OTA a su placa por USB.

Las cargas futuras se logran seleccionando el puerto WiFi en Herramientas> Puerto.

Vaya a Archivo> Ejemplos> ArduinoOTA> BasicOTA

El programa se cargará, ingrese su nombre de red y contraseña en el código.Suba esto a su placa. Ahora presione el botón de reinicio en el tablero.

Regrese a su programa de tanque de agua y vea los 3 lugares que se muestran en las imágenes, estos son necesarios para la carga de OTA.

Suba esto a su placa , usando  USB serial.

Si mira en Herramientas> Puerto en IDE Arduino, verá un nuevo puerto.Tendrá ‘esp8266’, la ID de la placa y la dirección IP de la placa.

Para una carga futura, use este puerto, sin necesidad de una conexión serial USB.

La placa ahora puede ser cargada por otros medios , es decir por wifi  sin tener que llevar el pc  y conectarlo por USB.

Montaje  final

Imagen de Monte las tablas en la caja

Puede montar  el ESP8266, tanto las placas ultrasónicas como el convertidor DC-DC en la caja con clasificación IP66, ya que estará   expuesto a los elementos. Si usa conectores de cable hembra-hembra, mucho mejor. Es interesante montar el convertidor CC-CC en una posición donde el conector de alimentación pueda enchufarse desde el exterior. 

También se deben tome todas las conexiones de alimentación y tierra a esta placa para evitar los bucles de tierra usando se 3.3 voltios para todo.

Es interesante hacer un agujero para el LED, e intentar ajustarlo para que no se necesite adhesivo.

Conecte todo y asegúrese de que todo sea resistente a la intemperie

Verifique todo, especialmente el cableado de alimentación.Enchufe la alimentación y conéctelo a la caja, conecte los sensores y enciéndalo.No verá nada en el monitor de serie, pero consulte la aplicación de su teléfono mediante la aplicación Blynk 

Mueva los sensores alrededor, las figuras deberían cambiar en la aplicación. Recuerde que una transmisión de ping e información solo se realiza cada 2 segundos.

Si sus tanques están a una distancia mayor, deberá  usar un extensor WiFi.

.

 

Fuente  Instructables.com