Timbre a distancia por wifi


Hoy en dia es relativamente asequible poder abordar proyectos con un nivel de acabado excepcional usando tecnologia de impresión 3d por ejemplo , y al mismo tiempo emplear componentes muy compactos, económicos y muy sencillos de programar además sin necesidad de soldar nada.

En este post vamos a ver un interesante proyecto de Giovanni Aggiustatutto en su proyecto de timbre a distancia por Wifi , que básicamente se compone de un módulo de micrófono de detección compatible con Arduino y dos módulos compatibles con ESP8266 : uno para la parte de transmisión y otro para la parte de recepción. Además el circuito se completa con dos cajas impresas en 3D , aunque por su tamaño se puede usar cualquier otro soporte.

El resultado desde luego queda totalmente sorprendente como podemos ver en la imagen.

Obviamente este proyecto puede servir para reenviar el timbre a otro lugar gracias a la cobertura wifi, lo cual lo hace muy versatil por ejemplo para extender la llamada del clasico interfono, la llamada de un intercomunicador, la llamada normal de un telefono fijo/inalambrico y como no como sencilla alarma por sonido.

La electrónica de este proyecto, aunque nos pueda asustar, en realidad es bastante sencilla porque todo pasa por el módulo detector que viene ya ensamblado pero que debemos ajustar al nivel de ruido en que sea detectado la señal de timbre que generara un pulso de disparo que será recogido por un ESP8266 y enviado hacia el otro ESP8266 que presentara una alerta.

El AZDelivery KY038 es un módulo de detección de sonido de alta sensibilidad ideal para muchos proyectos y aplicaciones, por ejemplo para sistemas de alarma sonora (como el de este proyecto).

El Modulo de micrófono cuenta con un micrófono de condensador eléctrico y una salida de señal de un solo canal. La señal de salida de bajo nivel se utiliza para la luz de control de sonido. Este módulo utiliza un micrófono en miniatura para detectar los niveles de sonido. Es crucial que dispone de un comparador basado en un CI LM393 con un potenciómetro para ajustar el nivel disparo para producir una salida digital de nivel alto, que es el que utilizaremos para transmitir la señal de alarma.

Componentes

Estos son los componentes del proyecto:

2 mini placas ESP8266 Wemos D1 (en realidad puede usarse también un ESP32 adaptando el código y las librerías correspondientes)
5 LEDs rojos
1 LED verde
6 resistencias de 330 ohmios para los LEDs
1 zumbador fuerte
1 interruptor
1 módulo sensor de sonido Arduino
Conector JST de 3 pines
Cable de JST a puente
Conectores Jumper
Perfboard
Cable
8 insertos roscados M3
8 tornillos M3x12 mm

El circuito

El receptor no puede ser mas sencillo pues básicamente se compone de un pequeño display de 5 leds conectados directamente a los 5 puertos (configurados como salidas digitales del ESP8266) mediante sendas resistencias de 680 ohmios . Además también para que sea perceptible realmente la llamada, usaremos un pequeño zumbador piezoeléctrico de alta potencia conectado también a un puerto del microcontrolador con un interruptor en serie para poder cortar el sonido y no moleste si es persistente porque si lo veremos con una indicación luminosa.

La parte del transmisor es si cabe mas simple pues únicamente se compone del detector de sonido cuya salida se conecta a un pin de entrada digital del ESp8266.

En este punto es importante estudiar la parte que detecta cuando suena algun sonido fuerte como el timbre del teléfono o del interfono, pues para detectar cuando suena el teléfono, se utiliza un módulo sensor de sonido hecho para Arduino, que lleva un pequeño micrófono.

Estos módulos son muy sencillos de usar porque en los pines hay conexiones para la alimentación y una salida digital, que se activa cuando el ruido que escucha el micrófono es superior a un cierto umbral, que fijamos con el potenciómetro. Este micrófono se colocará cerca de la base del teléfono o interfono lo mas cerca del timbre o altavoz interno (en el caso de un telefono convencional) o en caso de un interfono cerca del altavoz del micro teléfono o del zumbador, por lo que activará el timbre adicional cuando haya una llamada.

Montaje

La caja exterior que contendrá la placa transmisora ESP8266 conectada al micrófono será igual que la caja del timbre, pero en la parte trasera tendrá un conector para conectar el micrófono y en la parte delantera sólo tendrá un LED, para indicar cuando se detecta un sonido y es transmitido al otro modulo receptor.

De forma practica soldamos un conector JST de 3 pines en un pequeño trozo de placa perforada , al que conectamos tres cables para 3,3v, GND y la señal digital del módulo del micrófono. Estos tres cables van a los pines correspondientes de la placa.Para conectarle el módulo de micrófono utilizamos un cable JST a jumper, con el conector JST enchufado a la caja que acabamos de hacer y el conector jumper enchufado a GND, positivo y salida digital del módulo de micrófono.

La caja para la placa conectada al receptor es exactamente igual a la del transmisor, para dar continuidad al diseño. El otro ESP8266 configurado como receptor puede ir en una placa de prototipos y encaminar los pines del ESP8266 necesarios para el módulo del micrófono y los LEDs de estado que conectaremos a la placa mediante conectores jumper. Esta vez la resistencia para el LED en la placa, y dos cables directamente entre los dos pines de un LED rojo y los dos puentes correspondientes de la placa. También esta vez pegamos el LED en el soporte del LED, y pegamos también el soporte a la caja. Luego pegamos el conector JST en el agujero del panel trasero de la caja. Al igual que con el timbre, pegamos la placa dentro de la caja con un trozo de plástico debajo, para que el puerto USB quede alineado con el agujero del panel. Como última cosa cerramos la tapa con tornillos M3 atornillados en los agujeros roscados, y podemos decir que también el sensor de sonido está terminado.

ESP-Now

Antes de realizar cualquier conexión eléctrica, primero tenemos que subir el código a las dos placas ESP8266. Para conectar el ESP8266 que estará cerca del teléfono al que está conectado al zumbador y a los LEDs, utilizamos el protocolo de comunicación WiFi ESP-NOW, que es una librería proporcionada por Espressif, el fabricante del chip ESP.

ESP-Now es otro protocolo de comunicación inalámbrica desarrollado por Lexin, que puede permitir que múltiples dispositivos se comuniquen sin Wi-Fi sin usar Wi-Fi. Este protocolo es similar a un bajo consumo de energía de una conexión inalámbrica de 2.4GHz comúnmente común en el dispositivo de ratón inalámbrico debe emparejarse antes de comunicarse. Después del emparejamiento, la conexión entre los dispositivos es continua, punto a punto, y no se requiere un protocolo de apretón de manos. Es una breve transmisión de datos y una tecnología de comunicación rápida no conectada que permite que los controladores de baja potencia controlen directamente todos los dispositivos inteligentes sin conectar enrutadores. Es adecuado para luces inteligentes, control remoto y retorno de datos del sensor.

Después de usar la comunicación ESP-Now, si un determinado dispositivo se apaga repentinamente, siempre que se reinicie, se conecta automáticamente al nodo correspondiente para volver a comunicarse.

ESP-Now admite las siguientes características:

  • Paquete de paquete de transmisión única o paquete de transmisión única sin comunicación cifrada;
  • Uso mixto de equipos de emparejamiento de cifrado y equipos no cifrados;
  • Se pueden transportar datos de carga útil que pueden transportar hasta 250 bytes;
  • Configuración de soporte para enviar una función de devolución de llamada para notificar a la fallas o éxito de envío de envío o éxito de envío de la capa de aplicación.

Del mismo modo, hay algunas restricciones en ESP-Now:

  • Los paquetes de transmisión no son compatibles temporalmente;
  • Hay restricciones en el dispositivo de emparejamiento cifrado, y el modo de estación admite hasta 10 dispositivos de emparejamiento encriptados; el modo híbrido SoftAP o SoftAP + Station admite hasta 6 dispositivos de emparejamiento cifrados en el modo mixto. Los dispositivos de emparejamiento no cifrados admiten varios, y el número total de dispositivos de cifrado no es más de 20;
  • La carga útil efectiva se limita a 250 bytes.

Elegimos esta biblioteca porque es muy fácil de usar configurando ambos ESP como una comunicación unidireccional.

FIRMWARE

En la parte transmisora usaremos los pines 12 (ledPin) y el pin 14 ( pic Pin), respectivamente el pin 12 al que conectaremos el led indicador de detección de sonido y el pin 14 al que conectaremos la salida digital del modulo detector de sonido.

Antes de subir el código a las dos placas, necesitamos saber la dirección MAC de la placa que usaremos como receptor. Para ello, podemos subir el siguiente boceto a través del IDE de Arduino.

#include "WiFi.h"

//#include <ESP8266WiFi.h>

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_MODE_STA);
  //WiFi.mode(WIFI_AP_STA);
  Serial.println(WiFi.macAddress());
}

void loop() {
}

Una vez subido el sketch, abrimos el monitor serie y esperamos a que aparezca la dirección MAC de la placa. Esta dirección hay que copiarla de ahí y pegarla en el código de la placa transmisora, antes de subirla.

#include <ESP8266WiFi.h>
#include <espnow.h>

//Aquí es donde se inserta la dirección MAC en el código.
// REPLACE WITH RECEIVER MAC Address (example 34:94:54:8E:13:20)
uint8_t broadcastAddress[] = {0x34, 0x94, 0x54, 0x8E, 0x13, 0x20};


// Structure example to send data
// Must match the receiver structure
typedef struct struct_message {
  bool isRinging;
} struct_message;


// Create a struct_message called myData
struct_message myData;


unsigned long lastTime = 0;  
unsigned long timerDelay = 800;  // send readings timer


int micStatus = 0;


const int micPin = 14;  // D5
const int ledPin = 12;  // D6


// Callback when data is sent
void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) {
  Serial.print("Last Packet Send Status: ");
  if (sendStatus == 0){
    Serial.println("Delivery success");
  }
  else{
    Serial.println("Delivery fail");
  }
}

void setup() {
  // Set microphone pin as input
  pinMode(micPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);

  // Init Serial Monitor
  Serial.begin(74880);

  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);


  // Init ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }


  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Trasnmitted packet
  esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
  esp_now_register_send_cb(OnDataSent);

  // Register peer
  esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
}

void loop() {
  if (digitalRead(micPin) == HIGH) {
    micStatus = 1;
    digitalWrite(ledPin, HIGH);
  }

  if ((millis() - lastTime) > timerDelay) {
    if (micStatus == 0) {
      myData.isRinging = false;
      digitalWrite(ledPin, LOW);
    }


    if (micStatus == 1) {
      myData.isRinging = true;
      micStatus = 0;
    }


    // Send message via ESP-NOW
    esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));

Respecto al receptor conectaremos cuatro leds indicadores de presencia de sonido en los pines 12,14,0 y 4 conformando así una especie de vu-meter . Además en el pin 13 conectaremos un led de estado , y para terminar , para que sea de verdad perceptible, en el pin 5 conectaremos un zumbador de alta potencia.

El código de la placa receptora es el siguiente, y puede cargarse sin modificaciones.

#include <ESP8266WiFi.h> 
#include <espnow.h>


// Structure example to receive data
// Must match the sender structure
typedef struct struct_message {
  bool isRinging; 
} struct_message;


// Create a struct_message called myData
struct_message myData;


const int led1 = 12;  // LEDs from the top to the bottom of the device
const int led2 = 14;
const int led3 = 0;
const int led4 = 4;
const int statusLed = 13;
const int buzzer =  5;
const long buzzerTime = 200 ;
long timeFromLastUpdate = 0;
unsigned long previousMillis = 0;
const long interval = 500;


bool produceSound = false;
bool produceLight = false;
bool flag = false;
bool previousFlag = false;
bool hasIncremented = false;
int numberOfBlinks = 10;


// Callback function that will be executed when data is received
void OnDataRecv(uint8_t * mac, uint8_t *incomingData, uint8_t len) {
  memcpy(&myData, incomingData, sizeof(myData));
  Serial.println("Data received!");


  if (myData.isRinging == false) {
    produceSound = false;

    digitalWrite(statusLed, LOW);
    timeFromLastUpdate = millis();
  }


  if (myData.isRinging == true) {
    digitalWrite(statusLed, LOW);
    timeFromLastUpdate = millis();
    //produceSound = true;
    //produceLight = true;


    //numberOfBlinks = 0;
  }
}

void setup() {
  // Set LED and ring pin as output
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(statusLed, OUTPUT);
  pinMode(buzzer, OUTPUT);

  // Initialize Serial Monitor
  Serial.begin(74880);

  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);


  // Init ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Once ESPNow is successfully Init, we will register for recv CB to
  // get recv packer info
  esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);
  esp_now_register_recv_cb(OnDataRecv);
}


void loop() {
  unsigned long currentMillis = millis();

  if ((timeFromLastUpdate + 10000) < millis()) {
    digitalWrite(statusLed, HIGH);
  } 


  if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;

    flag = !flag;
  }

  callRoutine();
  blinkLeds();
  soundBuzzer();
}


void blinkLeds() {
  if (flag == true && (produceLight == true || numberOfBlinks <= 5) && hasIncremented == false) {
    digitalWrite(led1, HIGH);
    digitalWrite(led2, HIGH);
    digitalWrite(led3, HIGH);
    digitalWrite(led4, HIGH);
    numberOfBlinks++;
    hasIncremented = true;

    produceLight = false;

    Serial.print("on ");
    Serial.println(numberOfBlinks);
  }


  if (flag == false) {
    digitalWrite(led1, LOW);
    digitalWrite(led2, LOW);
    digitalWrite(led3, LOW);
    digitalWrite(led4, LOW);
    Serial.println("off");


    hasIncremented = false;
  }
}


void soundBuzzer() {
  if (flag == true && produceSound == true) {
    digitalWrite(buzzer, HIGH);
    produceSound = false;
  }


  if (flag == false) {
    digitalWrite(buzzer, LOW);
  }
}


void callRoutine() {
  if (myData.isRinging == true && previousFlag != flag) {
    produceSound = true;
    produceLight = true;
    numberOfBlinks = 0;
  }


  else {
    previousFlag = flag;
  }
}

Mas información en https://www.instructables.com/Wireless-Loud-Phone-Ringer-Help-Elderly-With-Elect/

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