Como construir display gigantes


En efecto podemos construir nosotros mismos nuestros propios displays leds  de la medidas que necesitemos  simplemente con Arduino ;Netduino o  Raspberry Pi y por supuesto  un poco de bricolaje

Un dígito led  en realidad esta formado por  7 segmentos  o mas   y es un componente que se utiliza para la representación de caracteres o números en muchos dispositivos   , debido en gran medida a su simplicidad y bajo coste

Aunque externamente difiere considerablemente de un led típico, internamente están constituidos por una serie de leds con unas determinadas conexiones internas, estratégicamente ubicados de tal forma que forme un número ‘8’.

Cada uno de los segmentos que forman la pantalla están marcados con siete primeras letras del alfabeto (‘a’-‘g’), y se montan de forma que permiten activar cada segmento por separado, consiguiendo formar cualquier dígito numérico

Por ejemplo para representar el numero 15 lo conseguiremos , activando los segmentos B y C del primer dígito  y  los segmentos AF,G C y D  para el segundo dígito

 

15

 

Montaje

Ahora que entendemos como funciona un display de 7 segmentos, la idea  es realmente sencilla  pues básicamente  consiste en auto-construirnos  dicho dígito  pensando en los  7 segmentos    de los que lo compone   usando para ellos  7 leds  acoplados a un caja  con    difusores para todos los leds  ¿sencillo verdad ?

Para el montaje  necesitaremos los siguientes elementos:

  • Trozos de cartón
  • Trozos de cartulina
  • 7 LEDs difusa
  • 7 resistencias de 50 ohm
  • Cinta carrocera (usada por los pintores )
  • Pegamento
  • Soporte con Esquema del display
  • Cables
  • Arduino uno
  • Un trozo de papel contacto

Una vez que tengamos el dígito compuesto por 7 los leds lo conectaremos a 7 salidas binarias de Arduino  siguiendo el siguiente esquema de conexiones;

  • PD2  segmento a;
  • PD3 segmento b
  • PD4 segmento c
  • PD5 segmento d
  • PD6 segmento e
  • PD7 segmento f
  • PD8 segmento g

Y para facilitar la gestión del display  también dos pulsadores

  •  PP1
  • PB2

Y finalmente   en la siguiente imagen podemos ver el esquema donde se aprecian claramente las resistencias de 50ohm para los leds   y las de 10 K para los pulsadores

 

arduino

 

Según la configuración ya decidida  para gestionar el display solo necesitamos mapear  cada combinación  de segmentos asociado a cada numero que queramos representar  ,  y por medio delos pulsadores incrementamos o decrementamos una unidas representando el siguiente o el anterior digito respectivamente

Como en muchos otros casos ,es de señalar que debemos controlar los rebotes en las pulsaciones para lo cual leeremos varias veces el valor de la entrada hasta asegurarnos que el valor esta estables.

 

El código arduino es bien sencillo

 

//definiciones de segmentos con las primeras pines digitales puerto A

const int a = 2;
const int b = 3;
const int c = 4;
const int d = 5;
const int e = 6;
const int f = 7;
const int g = 8;

//Definición de pines de entrada para los pulsadores
const int botonIncremento = 9;
const int botonDecremento = 10;

//valor para controlar los antirrebotes

const int tiempoAntirebote = 10;

//Al encender parece este numero

int cuenta = 0;  
int estadoBotonIncremento;
int estadoBotonAnteriorIncremento;
int estadoBotonDecremento;
int estadoBotonAnteriorDecremento;

boolean antirebote(int pin) {
int contador = 0;
boolean estado;
boolean estadoAnterior;

do {
estado = digitalRead(pin);
if(estado != estadoAnterior) {
contador = 0;
estadoAnterior = estado;

}
else {
contador = contador + 1;
}
delay(1);
} while(contador < tiempoAntirebote);

return estado;

}

void actualizarNumero() {
switch(cuenta) {
case 0:     // digito 1
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
break;

case 1:// valor 2

digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 2:
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
break;
case 3: //digito 3
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
break;
case 4://digito 4
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 5: //digito 5
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 6: //digito 6
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 7: //digito 7
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 8: //digito 8
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 9: //digito 9
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
}

}

 

//programamos lo 7 primeros pines del puerto A como salida 

//y los dos primeros del puerto B como entrada 
void setup() {
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
pinMode(botonIncremento, INPUT);
pinMode(botonDecremento, INPUT);
}
void loop() {
estadoBotonIncremento = digitalRead(botonIncremento);
if(estadoBotonIncremento != estadoBotonAnteriorIncremento) {
if(antirebote(botonIncremento)) {
cuenta++;
if(cuenta > 9) {
cuenta = 9;

}
}
}
estadoBotonAnteriorIncremento = estadoBotonIncremento;

estadoBotonDecremento = digitalRead(botonDecremento);

if(estadoBotonDecremento != estadoBotonAnteriorDecremento) {
if(antirebote (botonDecremento)) {
cuenta–;
if(cuenta < 0)

{
cuenta = 0;
}
}
}
estadoBotonAnteriorDecremento = estadoBotonDecremento;

actualizarNumero();
}

 

 

Y finalmente en este vídeo del canal  MFH de youtube  podemos ver el montaje en funcionamiento

 

Anuncios

Interactuar con Netduino via twitter


ThingSpeak™ es un servicio web gratuito muy veterano  y del que hemos  hablado en este blog en numerosas ocasiones   que  permite recopilar y almacenar datos de sensores  conectados a Rasberry Pi, Arduino ,Netduino  entre otros  para enviarlos  hacia  un servicio de datalogger  en la nube.

Asimismo  también sirve para  desarrollar aplicaciones de Internet de las cosas como por ejemplo desencadenar ciertas acciones  ante determinados cambios en las medidas  , tal y como vamos a ver en este caso desencadenando envíos de tweets con  el motivo de la alerta.

 

 

bandwidth close up computer connection

Photo by panumas nikhomkhai on Pexels.com

 

El servicio de web de ThingSpeak es uno de los servicios mas veteranos  en la red proporcionando  aplicaciones que le permiten analizar y visualizar los datos en MATLAB®y luego actuar sobre los cambios en esos  datos desencadenando acciones.

Los datos de los sensores pueden enviarse a ThingSpeak desde  un  Arduino®, Raspberry Pi™, BeagleBone Black  asi como  desde Netduino+  entre otras  plataformas

 

En este post vamos a intentar  ver  cómo se puede enviar un tweet cuando los datos de punto de rocío superan un umbral  usando dos  aplicaciones  como son ThingTweet y React :

  •  ThingTweet  sirve  para vincular una cuenta Twitter® a su cuenta ThingSpeak. Sus dispositivos pueden enviar alertas a través de Twitter utilizando la API de TweetContol. Por ejemplo, puede hacer que un dispositivo tuitee cuando la temperatura de su invernadero disminuya o cuando las baterías de un dispositivo se estén agotando. Los pasos son sencillos : entraremos c en Link Twitter Account para vincular una cuenta de Twitter a su cuenta ThingSpeak y cuando se le pida que autorice a ThingTweet a usar su cuenta ingresaremos el nombre de usuario y contraseña de Twitter marcando la casilla Recordarme para guardar en caché las credenciales de Twitter en su pc  y por supuesto haciendo clic en Autorizar aplicación
  • React funciona con las aplicaciones ThingHTTP, ThingTweet y MATLAB Analysis para realizar acciones cuando los datos del canal cumplen una determinada condición. Por ejemplo se  puede hacer que una aplicación móvil informe su latitud y longitud a un canal ThingSpeak, de modo que cuando su posición esté dentro de una cierta distancia de su casa,  ThingHTTP encienda las luces de su sala.

Como pasos previos para poder usar ambos servicios  se requiere que ya han realizado estos pasos:

  • Crear una cuenta de  Twitter® .
  • Iniciar sesión a su cuenta de MathWorks®   o la cuenta de ThingSpeak™ , o crear una nueva cuenta de MathWorks .
  • Crear un canal como el canal calculados del   punto de rocío.
  • Leer los datos de estación meteorológica( por ejemplo desde una placa Netduino)  en su canal y calcular el punto de rocío como vimos en el post anterior

Nota : En este  ejemplo vamos a  utilizar una medida   intermedia que es calculada en función de la humedad  y temperatura  , pero lógicamente  los desencadenantes se pueden  lanzar desde medidas sencillas   que no requieran un calculo intermedio .

Vincular  la cuenta de Twitter  a ThingSpeak

Para empezar  tenemos que vincular una cuenta de twitter a  nuestra cuenta de thingspeak . Para ello  puede seguir lo siguintes  pasos:

  1. Validese en su cuenta de ThinSpeak
  2. Ir a aplicaciones(Apps) > ThingTweet.
  3. En la página ThingTweet, haga clic en (enlace de cuenta de Twitter (Link Twitter Account ) para vincular su cuenta de Twitter a tu cuenta de ThingSpeak.
  4. Tiene que autorizar el acceso a su cuenta de twitter desde ThingSpeak
  5. Introduzca su nombre de usuario de Twitter y contraseña y haga clic en Autorizar la aplicación.

  6. En la página de autorización , haga clic en volver a ThingTweet(back to ThingSpeak).   Nos avisara de que su cuenta de Twitter está relacionada con ThingSpeak  devolviendonos  el valor del APIKEY   , el cual por cierto podemos fiorzar a cambiar  gracis  al boton  Regenerate API Key.
  7. Si queremos  deshacer este cambio simplemente pulsaremos sobre el botón  desenlazar cuenta  (“Unlink Account”)

Reaccionar al cambio en el punto de rocío

Una vez vinculada   su cuenta de twitter a thingspeak    ya podemos indicar a React que  envie un tweet cada vez que el nivel de punto de rocío supere  un valor va sobre 15ªC , testeando el  canal cada 10 minutos.

Estos son los pasos para hacerlo:

  1. Ir a aplicaciones > react  hacera clic en Reaccionar de nuevo.
  2. Nombre este react por ejemplo como  “Tweet de punto de rocío.”
  3. Defina el tipo numérico.
  4. Ajuste la Frecuencia de la prueba a cada 10 minutos.
  5. Establecer la condición cuando el valor de la humedad en su canal alcanza o supera los 60:
    • Si canal: seleccione el canal de medición de punto de rocío.
    • campo: seleccione 3 (punto de rocío).
    • Para el tipo de condición, seleccione es mayor o igual a.
    • El valor de condición, entre 60 (se refiere a grados Fahrenheit)

    • Ajuste acción en ThingTweet.
    • Entrar en esta cadena en tweet a continuación:
      Turn off that humidifier! It's above 60F
    • Seleccione su cuenta de Twitter con la cuenta de Twitter.
    • En Opciones, elija Ejecutar acción cada vez que la condición se cumple.

    Click Save React.

El tweet se envíara cada vez que el nivel de humedad supere los 15,5ºC o 60 ° F.

Es evidente que esta facilidad de ThingSpeak   ,que sinsisteimo es soportado por un amplio abanico de hardware (como Raspberrry, Arduino o el propio Netduino), tiene una utilidad indudable para infinidad de condiciones  que nos pueden facilitar la vida como por ejemplo  apertura de puertas o ventanas,  temperaturas anómalas , caídas de tensión ,  y un largo etcétera.

Análisis de datos con MathWorks y Netduino


Este ejemplo muestra cómo leer datos de temperatura y humedad de ThingSpeak  ( del canal 12397)  , que recoge datos meteorológicos de un  dispositivo de  Iot que perfectamente  puede ser una placa  Arduino , Raspbery Pi o incluso  un Netduino.
La idea es enviar a los datos de temperatura y humedad en el canal de medición de punto de rocío, y calcular con arreglo a estos  datos el punto de rocío  utilizando ThingSpeak™ para visualizar los resultados en su canal.
El punto de rocío o temperatura de rocío es la más alta temperatura a la que se condensa el vapor de agua contenido en el aire, produciendo rocío, neblina, cualquier tipo de nube o, en caso de que la temperatura sea lo suficientemente baja, escarcha.

Este ejemplo  requiere que ya han realizado estos pasos:

  • Iniciar sesión a su cuenta de MathWorks®  o en la cuenta de ThingSpeak  o crear una nueva cuenta de MathWorks .
  • Crear un canal como el canal de medición de punto de rocío.

Leer datos de un canal

Leer la temperatura y humedad en el canal público de WeatherStation campos 3 y 4 y escribir los datos en campos 2 y 1, respectivamente, de su canal de medición de punto de rocío. Punto de rocío es calculado y escrito a campo 3.

Para usar el análisis de   MATLAB®  para leer, calcular y escribir los datos siga los siguientes pasos:

  1. Ir a la pestaña de aplicaciones y haga clic en Análisis de MATLAB.
  2. Haga clic en nuevo. Seleccione la plantilla personalizada y haga clic en crear.
  3. En el campo nombre , escriba.Dew Point Calculation
  4. En el campo de código MATLAB, introduzca las siguientes líneas de código.
    1. Guardar la estación pública canal ID y tu ID de canal de medición de punto de rocío a las variables.
      readChId = 12397;
      writeChId = 677;  % replace with your channel number
    2. Guardar su clave de API de escribir en una variable.
      writeKey = 'F6CSCVKX42WFZN9Y'; % Replace with your channel write key

      Para encontrar su canal ID y Write API Key, consulte información del canal en la pestaña de Mis canales .

    3. Leer los últimos 20 puntos de datos de temperatura con las marcas de tiempo y la humedad en el canal público de la estación meteorológica en las variables.
      [temp,time] = thingSpeakRead(readChId,'Fields',4,'NumPoints',20);
      humidity = thingSpeakRead(readChId,'Fields',3,'NumPoints',20);

Calcular el punto de rocío

Agregue el siguiente código MATLAB para calcular el punto de rocío con las lecturas de temperatura y humedad:

  1. Convertir la temperatura de Fahrenheit a Celsius.
    tempC = (5/9)*(temp-32);
  2. Especificar las constantes de vapor de agua () y (presión barométrica). bc
    b = 17.62;
    c = 243.5;
  3. Calcular el punto de rocío en grados Celsius.
    gamma = log(humidity/100) + b*tempC./(c+tempC);
    dewPoint = c*gamma./(b-gamma)
  4. Convertir el resultado a Fahrenheit.
    dewPointF = (dewPoint*1.8) + 32;
  5. Escribir datos en el canal de medición de punto de rocío. Este código entradas todos los datos en una operación e incluye las marcas de hora correcta.
    thingSpeakWrite(writeChId,[temp,humidity,dewPointF],'Fields',[1,2,3],...
    'TimeStamps',time,'Writekey',writeKey);

    El bloque completo de código aparece ahora como:

    % Enter your MATLAB Code below
    readChId = 12397;
    writeChId = ZZZZZ;              % Replace with your channel number
    writeKey = 'XXXXXXXXXXXXXXXX';  % Replace with your channel write key
    [temp,time] = thingSpeakRead(readChId,'Fields',4,'NumPoints',20);
    humidity = thingSpeakRead(readChId,'Fields',3,'NumPoints',20);
    tempC = (5/9)*(temp-32); 
    b = 17.62;
    c = 243.5;
    gamma = log(humidity/100) + b*tempC./(c+tempC);
    dewPoint = c*gamma./(b-gamma)
    dewPointF = (dewPoint*1.8) + 32;
    thingSpeakWrite(writeChId,[temp,humidity,dewPointF],'Fields',[1,2,3],...
    'TimeStamps',time,'Writekey',writeKey);
  6. Haga clic en Guardar y ejecutar para validar y procesar el código.Cualquier error en el código se indica en el campo de salida .
  7. A ver si el código funcionó con éxito, haga clic en su enlace de canal de Medición de punto de rocío en el panel de Información del canal .

El canal de medición de punto de rocío ahora muestra gráficos con datos de un canal de cada campo.

Código del calendario

Utilizaremos  la aplicación TimeControl para programar el cálculo del punto de rocío en el código de analisis MATLAB programando este  para leer los datos de la estación cada 30 minutos y calcular el punto de rocío

Estos son los pasos a seguir:

  1. Desplácese hasta la parte inferior de la página de MATLAB análisis cálculo de punto de rocío. Haga clic en TimeControl para abrir la aplicación MATLAB análisis pre-seleccion en el campo de acciones y el cálculo del punto de rocío como la ejecución de código.
  2. Nombre de su nuevo TimeControl Dew Point TC
  3. Elegir recurrentes en el campo de frecuencia .
  4. Elegir el minuto en el campo de la repetición .
  5. Seleccione 30 en el cada — minutos campo.
  6. Mantener el Tiempo de inicio en el valor predeterminado.
  7. Verificar que la acción es, y el código a ejecutar es el.MATLAB AnalysisDew Point Calculation
  8. Haga clic en Guardar TimeControl

Nota:Configurar un TimeControl para escribir datos en el canal utiliza mensajes disponibles en su cuenta de ThingSpeak. Esta acción puede agotar eventualmente mensajes disponibles, que se traduce en rechazo del canal de alimentación de actualizaciones. Asegúrese de que los datos que escribes a un canal de no se superponen en el dominio del tiempo como hace uso innecesario de los mensajes.

Visualizar medida de punto de rocío

Se puede utilizar la aplicación visualizaciones de MATLAB para visualizar los datos de punto de rocío medido, la temperatura y la humedad de tu canal de medición de punto de rocío. Este ejemplo utiliza la función Mostrar todos los puntos de tres datos en una única visualización.thingSpeakPlot

Ir a aplicaciones > MATLAB visualizacionesy haga clic en nueva para crear una visualización.

Alternativamente, usted puede hacer clic en Visualización de MATLAB en su punto de vista del canal de medición de punto de rocío.

Seleccione la plantilla personalizada y haga clic en crear.

  1. Nombre de la visualización “Punto de rocío.”
  2. Crear variables para su ID de canal de medición de punto de rocío y su clave de API de lectura. Sustituya los valores en el código con tu canal ID y la clave de API de lectura.
    readChId = 677
    readKey = '36LPYCQ19U37ANLE'
  3. Leer datos de los campos de canal y obtener los últimos 100 puntos de datos para:
    • Temperatura: De campo 1
    • Humedad: Del campo 2
    • Punto de Rocío: de campo 3
      [dewPointData,timeStamps] = thingSpeakRead(readChId,'fields',[1,2,3],...
          'NumPoints',100,'ReadKey',readKey);
  4. Parcela los datos x y y las etiquetas, un título y una leyenda.
    thingSpeakPlot(timeStamps,dewPointData,'xlabel','TimeStamps',...
        'ylabel','Measured Values','title','Dew Point Measurement',...
        'Legend',{'Temperature','Humidity','Dew Point'},'grid','on');

    El código se verá similar a este código:

    % Enter your MATLAB code below
    readChId = ZZZZZ              % Your Channel ID                 
    readKey = 'XXXXXXXXXXXXXXXX' %Your Read API Key
    [dewPointData,timeStamps] = thingSpeakRead(readChId,'fields',[1,2,3],...
        'NumPoints',100,'ReadKey',readKey);
        thingSpeakPlot(timeStamps,dewPointData,'xlabel','TimeStamps',...
        'ylabel','Measured Values','title','Dew Point Measurement',...
        'Legend',{'Temperature','Humidity','Dew Point'},'grid','on');
  5. Haga clic en Guardar y ejecutar. Si su código MATLAB no tiene errores, la salida de trama es similar a la trama que se muestra a continuación:

 

Control de nivel de agua con NodeMCU y Cayenne


En  este post  vamos   a ver nuevamente la gran versatilidad del sw de Cayenne , en este caso para controlar el nivel de un liquido   monitorando  este en tiempo real gracias al framework   de IoT gratuito  de Cayenne.

La finalidad de este proyecto es asegurar que un  depósito de agua siempre este lleno , porque podría suceder  que el suministro de agua sólo fluya a determinadas franjas horarias   por   lo que debemos permitir el flujo  solo cuando haya suministro  y el deposito no este lleno

Por tanto , el funcionamiento es relativamente simple  pues únicamente  la válvula se cerrará cuando el agua alcance el nivel superior del sensor.

La lista de materiales necesaria  para este proyecto es bastante reducida siendo el hardware necesario  el siguiente:

Picture of Bill of Materials

2. Sensor de nivel de líquido (calibrar primero para obtener el nivel de valor e inferior nivel superior)

Si usted necesita el sensor más profundo, puede cortar la tira superior del sensor y tome algún cable a dos lados del sensor

Picture of Bill of Materials

3. Módulo de relé de CH

Picture of Bill of Materials

4. Válvula solenoide 12V

5. 12V 2A fuente de alimentación

6. Cables de puente

 

En cuanto al Software necesario:

1. Arduino IDE

2. Cayenne para iOS/Android/Web Browser

Conectar NodeMCU Sensor líquido, módulo de relés y válvulas

ESP12E    esta basado en Arduino  pero cuenta   también conectividad wifi integrando la propia antena en la placa de circuito impreso en unas  dimensiones de  25.6mm x 34.2mm .  Además, por motivos de reducción de espacio esta placa no integra conexión usb  , para lo cual necesitaremos un USB FTDI   para programarlo o un  controlador Setup CH340g.

Esta placa cuenta con 11 pines digitales de entrada / salida, todos los pines tienen interruptor / pwm / I2C / 1-wire    siendo su chip principal el  ESP8266 CH340G

Una gran diferencia con una placa Arduino es que solo cuenta  con 1 entrada analógica (entrada máxima de 3,3 V)

 

Las conexiones son muy sencillas:

  • VIN (+5V): lo conectaremos a NodeMCU y al modulo Rele
  • 3.3V   : Alimentemos el sensor
  • GND : Sensor , Arduino y Rele
  • A0 de Arduino : a la salida del  sensor
  • D5 de Arduino : a la entra de control del Rele

 

Respecto al firmware necesitara  subir el código a NodeMCU, pera el cual debería   programar el NodeMCU con el IDE de Arduino.

Para  probar Cayenne  con el  ESP12E       necesitamos  programar su ESP-12E para conectarse a su punto de acceso wifi   .

Básicamente  el código a subir al    ESP12E     usa 3 librerías de Cayenne donde  tendremos que definir el SSID y la pwd de la red wifi así como las credenciales de Cayenne    ,

Es de destacar  la creación  de  dos puertos virtuales  para capturar  el  nivel de líquidos   en tiempo real  por el puerto A0  asi como accionar el rele por el puerto 14  , lo cual nos van a permitir comunicarnos con el API de Cayenne

Asimismo para efectos de pruebas se deja habilitado la salida por el pruerto serie de modo que podamos ver desde el IDE de Arduino  la evolucion del nivel del liquido y las actuaciones corresponientes

#include “CayenneDefines.h”
#include “CayenneWiFi.h”
#include “CayenneWiFiClient.h”
#define CAYENNE_PRINT Serial // Comment this out to disable prints and save space
#define RELAY_PIN 14 // RELAY PIN

const int sensorPin= A0; //sensor pin connected to analog pin A0
float liquid_level;
int liquid_percentage;
int top_level = 512;
int bottom_level = 3;

// Cayenne authentication token. This should be obtained from the Cayenne Dashboard.
char token[] = “”; // Insert your token here
char ssid[] = “”; // Insert your SSID here
char pwd[] = “”; // Insert your SSID password here

void setup() {
Serial.begin(115200);
Cayenne.begin(token, ssid, pwd);
pinMode(sensorPin, INPUT);
pinMode(RELAY_PIN, OUTPUT);
}

void loop() {
liquid_level = analogRead(sensorPin);
liquid_percentage = ((liquid_level-bottom_level)/top_level)*100;
Serial.println(liquid_level);
delay(100);
Cayenne.run();
}

CAYENNE_OUT(V10)
{
Cayenne.virtualWrite(V10, liquid_percentage);
}

CAYENNE_IN(V1)
{
// get value sent from dashboard
int currentValue = getValue.asInt(); // 0 to 1

// assuming you wire your relay as normally open
if (currentValue == 0) {
digitalWrite(RELAY_PIN, HIGH);
} else {
digitalWrite(RELAY_PIN, LOW);
}
}

Necesitara  subir  el programa anterior  WATER_CONTROL.ino, editar la contraseña del token, SSID de su red Wifi  , usaurio de Cayyene  así como editar valor nivel  inferior y superior

Entonce conecte su NodeMCU con el Cable USB al ordenador y cargue el código en NodeMCU mediante el IDE de Arduino.

Configuración Cayenne Dashboard

Hemos hablado en  muchas ocasiones de Cayenne  pues en realidad está concebido para  que su manejo sea realmente sencillo   de configurar

Nos iremos a  su   url :   https://cayenne.mydevices.com/  

Tras registrarnos nos iremos  al panel de control   ,clicamos en  Add new   y seleccionamos generic ESP8266

A continuación nos ofrece  la API key que deberemos añadir al sw del   ESP12E      y tras reiniciarlo  ya debería poderse  comunicar con el node de Cayenne

 

Si la placa  pues   está configurada con el MQTT  ( username /pwd)     asi como con conectividad  wifi ,  ya   debería  de  poder conectarse al framework de Cayenne   y podemos seguir hacia adelante añadiendo sensores que deberían estar de acuerdo con el sw instalado en el ESP12E

En este caso como hemos definido  dos puertos virtuales para nivel de liquiodso  y contol   necesitamos añadir dos widgets  asociados a esos dos canales:

  • Añadir widget de válvula interruptor del tablero de instrumentos del Cayenne y seleccione Virtual Pin 1.
  • Añadir Sensor analógico widget de Dashboard de cayena y el nombre de nivel de agua, seleccione Virtual Pin 10, unidad porcentaje

Picture of Setting Up Cayenne

Picture of Setting Up Cayenne

 

 

Configuración de  triggers

Los triggers  o disparadores en Cayenne son una forma de hacer que su placa  reaccione a un cambio  de un sensor conectado a él. Esto podría ser algo tan simple como un valor de temperatura superior a un cierto valor o incluso sólo si el ESP12E pierde la conexión, lo cual como se podría imaginar puede ser muy potente en la creación de dispositivos inteligentes que reaccionan a los alrededores ( como por ejemplo, si la habitación se pone demasiado fría, encienda un  calefactor, etc ).

El proceso de agregar un disparador es muy sencillo como vamos a ver a continuación:

  1. Ir a añadir en la esquina superior izquierda del tablero de instrumentos.
  2. Seleccionar un trigger desde el cuadro de abajo.
  3. Nombrar el trigger con un texto identificativo
  4. Ahora arrastrar y soltar su  ESP12E  desde la esquina izquierda en el caso de la caja.
  5. Por debajo de esto seleccionar el sensor 
  6. Ahora en el cuadro de selección a continuación, puede enviar  una notificación( bien a una dirección de correo electrónico o  a un  número de teléfono de un mensaje de texto pudiendo agregar ambos) o  una acción que en nuestro caso  sera activar desactiva  un relé. Asegúrese de marcar las casillas de verificación también.
  7. Ahora haga clic en “Save trigger”.

Haga  este  proceso para las  dos casuisticas:

  • Agregar desencadenadores y si el nivel del agua por encima de 100% entonces la válvula interruptor apague.
  • Agregar desencadenadores y si el nivel del agua por debajo de 100% entonces la válvula del interruptor se encienda
Picture of Setting Up CayennePicture of Setting Up Cayenne

 

Fuente   instructables.com

¿Que es Moteino?


Moteino es una plataforma de desarrollo totalmente compatible con Arduino por lo que podremos utilizar una gran variedad de librerías disponibles . Es inalámbrica de baja potencia basada en el popular chip ATmega328p utilizado en el Arduino-UNO, lo que lo hace 100% compatible con el IDE de Arduino (entorno de programación).Es del tamaño de una tarjeta de memoria y permite establecer una conexión inalámbrica bidireccional de una forma muy fácil y sencilla.

Respecto al nombre no es mágico , lo cierto es que viene del funky correspondiendo a la suma  de Mote+ ino

Para la programación, se necesita un adaptador FTDI externo para cargar los sketchs, con las ventajas de un menor costo y un tamaño más pequeño.Como vamos a  ver la variante MoteinoUSB incluye el convertidor de serie USB.

Los Moteinos son compatibles y se pueden comunicar con cualquier otra plataforma Arduino o de desarrollo que utilice los populares transceptores HopeRF RFM69 o LoRa. Moteino también viene con un chip de memoria flash SPI opcional para programación inalámbrica o registro de datos.

 

El modelo principal, el Moteino R4, se basa en un microcontrolador ATmega328 junto con un transmisor RFM69 que emite en el rango de los 915Mhz.

 

Moteino fue diseñado para ser una plataforma de desarrollo compacta, altamente personalizable y asequible, adecuada para IoT, domótica y proyectos inalámbricos de largo alcance. Estas son algunas de las características que distinguen a Moteino:

  • Diseño modular pequeño y ligero que se adapta a recintos minúsculos
  • Las configuraciones flexibles permiten el uso de varios transceptores inalámbricos
  • Verdadera potencia ultrabaja : con solo ~ 2uA alcanzable en el modo de suspensión profunda, AVR Moteinos permite que los proyectos con batería, como los sensores inalámbricos de movimiento / entorno, funcionen durante años. El modo de suspensión de Watchdog está en ~ 6uA (activación periódica). El nuevo 8Mhz Moteino permite el modo de sueño 100nA más bajo posible. ¡El nuevo MoteinoM0 basado en SAMD21 Cortex M0 + duerme a solo ~ 8uA!
  • Las radios sub-Ghz y LoRa producen un rango mucho más largo que las bandas de 2.4Ghz
  • Programable de forma inalámbrica(OTA) : puede volver a flashearlo sin cables, cuando se implementa en ubicaciones difíciles (solo con radios RFM69)
  • Fácil de usar desde el familiar IDE Arduino, muchos ejemplos de código brindados para ayudarlo a comenzar
  • asequible: las antenas monopolo de cable de costo cero producen un excelente rango de RF para proyectos inalámbricos completos. Con los pads del conector u.FL / IPEX y SMA puede conectar cualquier otra antena externa con mayor ganancia
  • Visite el foro de proyectos de usuario para ver cómo las personas están usando Moteinos
  • Consulte la plataforma de automatización doméstica de LowPowerLab : proyecto Moteino IoT Gateway

 

Este es el Pinout:

 

 

 MoteinoUSB

Moteino-USB incluye el chip USB-serial FTDI. Técnicamente, un MoteinoUSB es la combinación de un adaptador FTDI y un Moteino regular. Se puede programar y alimentar a través del conector USB, pero también se puede ejecutar desde una batería (pin VIN ) igual de bien:

 

 

 

 

MoteinoMEGA

 

El MoteinoMEGA utiliza el microcontrolador Atmega1284p. Aún funciona a 3.3V / 16Mhz pero tiene 128KB de flash interno (frente a 32KB en Atmega328p), 16KB de RAM (vs 2KB), 4KB EEPROM (vs 1KB), 2x puertos serie de hardware, 8x patillas PWM y muchas más patillas GPIO. Todavía es un tablero pequeño de apenas 1.0 × 2.0 “y amigable para el tablero. Viene con el mismo cargador dearranque DualOptiboot, por lo que es capaz de programación inalámbrica “OTA”, y puede tomar hasta 16V de entrada en los pines VIN (regulados por MCP1703).

Para cargar bocetos en MoteinoMEGA, primero deberá instalar el Moteino Core . Esto define el mapa de pines y otras definiciones de núcleo importantes que permiten programar el MEGA desde el IDE de Arduino. Una vez hecho esto, debe tener un nuevo objetivo de placa en Herramientas> Tarjetas llamadas MoteinoMEGA

Moteino MEGA, que es el hermano pequeño del clásico Arduino MEGA, ofreciendo muchos más pines para conectar otros dispositivos. Este sistema está pensado para aplicaciones de bajo consumo y también permite crear varias redes de sensores y nodos interconectados. Con el módulo transmisor RFM69 se puede llegar a cubrir distancias de hasta 300 metros en campo abierto.

Moteino con antena de rastreo (868-915Mhz)

También hay dos variantes especiales de Moteino con antenas de PCB integradas, disponibles para Moteino y MoteinoMEGA . Las antenas PCB están sintonizadas para las bandas 868-915mhz y tienen un rendimiento excelente dado su tamaño compacto. Además de la antena de PCB, son idénticos y funcionan igual que los Moteinos normales.

 

Transceivers

Los transceiver soportados por Moteino son los siguintes :

Aqui  podemos   sus  Datasheets

 

IMPORTANTE: Los módulos RFM69 no son LoRa y no son compatibles con los módulos RFM95/RFM96. Además los módulos RFM95/RFM96 necesitan de una librería de terceros.

 

Demostración en video  de soldadura de los  pines y de los cables de la antena:

 

 

 

.

Web Moteino: https://lowpowerlab.com/guide/moteino/

Monitor de pulso online usando NodeMCU y Cayenne


El fondo de este proyecto es la  monitorización cardíaca mediante un sensor de pulso del cuerpo humano mostrando en una  pantalla OLED  la forma de onda   y   enviando una alerta al  correo electrónico cuando el pulso del corazón supere la condición normal (en este caso 200).

La esencia de estos detectores  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  a una entrada analógica de un  Arduino, para probar la frecuencia cardíaca y de ahi que se pueda usar este sensor con un NodeMcu  junto con un pequeña pantalla OLED  para mostrar la fecuencia cardiaca en tiempo real

 

Los elementoshw y sw  necesarias para hacer este proyecto son las siguientes.

Hardware necesario:

1. NodeMCU ESP-12E

2. Sensor de pulso

3. SSD1306 0,96 pulgadas pantalla OLED

4. Cablezillos  de puente

Software necesario:

1. Arduino IDE

2. Cayenne para iOS/Android/Web Browser

3. Sensor de pulso modificado para ESP

4. biblioteca de Adafruit SSD1306 para Arduino    P

El sensor de pulso

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 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

Si usa un  ESP8266 ( no NodeMCU) no trate de conectarse directa señal de sensor A0. Debe agregar 2.2 KOhm entre señal y A0 y 10KOhm entre A0 a GND.  

arduino.PNG

Para complementar el circuito se conecta un pequeña pantalla OLED  de  2,4cm (128×64)  que ira a los pines digitales  D2 (salida SDA de la pantalla ) y  el pin D1(salida SCL de la pantalla)   ,asi como obviamente la alimentación Vcc( pin 5v) y Gnd

 

 

Software

Se necesita importar biblioteca de paso dos para hacer que funcione este código.

Asimismo debemos abrir ESP_OLED, modificar su contraseña de token, SSID, y el apikey de Cayenne y luego conecte su NodeMCU con el Cable USB al ordenador y suba el código a NodeMCU.

Ahora su OLED debe mostrar algo, esta es la señal si su proyecto trabajado. Y ahora su NodeMCU está conectado al Cayenne, pero pequeño paso otra vez para configurar panel de Cayena que mostrará su BPM y dar un alerta if BPM a alta.

 Configuración de Cayenne

Suponiendo qeu ya tenga  cuenta en Cayenne (es gratuita) ,siga estos pasos

  • Acceda al tablero de Cayena
  • Añadir widget personalizado gráfico de salpicadero de cayena y seleccione Virtual 13 Pin que contienen el valor de BPM de NodeMCU.
  • Agregar desencadenadores y si widget valor por encima del valor que necesites (por ejemplo puese ser 00, pero s160 es suficiente para darnos la alerta) y Cayena enviará alerta al correo electrónico.

Picture of Setting Up Cayenne

 

 

En el siguinte  video podemos ver el funcionamiento del circuito:

 

 

Fuente  aqui

Estación meteorológica conectada


Hay algunas otras estaciones meteorológicas basadas en NodeMcu o ESP8266 publicadas en la web, pero sin embargo,casi ninguna incluyen algunos sensores  de los que vamos a ver , y sobre todo,   se programan en un lenguaje más difícil: LUA.
En este proyecto de Ingenerare, los datos recuperados  por varios sensores , se envían a través de  wifi a la plataforma  Thingspeak, para posteriormente poder  visualizar su valores en el canal de Thingspeak o en un sitio web personal.

Este canal transmitirá los siguientes datos a un canal Thingspeak:

  • Temperatura  gracias a  un DHT11 / 22.
  • Temperatura por medio de un BMP180.
  • La humedad  gracias a un DHT11 / 22.
  • La presión atmosférica   por medio de un BMP180.
  • Temperatura del punto de rocío DHT11 / 22.
  • Altitud por medio de un BMP180.
  • La intensidad de la luz gracias  a un LDR.
  • El valor lluvia.

Los componentes  usados en este  proyecto son los siguientes:

caja.PNG

El corazón del sistema es una  placa  NodeMcu , la cual de hecho, es un Arduino  conmenos puertos analogicos  pero con un escudo wifi el cualpuede reconocerse por la placa de metal en la parte superior de la misma.  Este escudo puede ser comprado y utilizado como una controladora individual para su uso con un  Arduino para darle conectividad (de hecho incluso existe una versión conocida como la V1 esp8266 que sólo tiene 2 pines digitales,pero en versiones posteriores disponemos de mas pines digitales).

La gran ventaja de la placa  NodeMcu es que la placa  se puede programar en el entorno Arduino (el IDE  normal de Arduino). Además, la placa  incluye un convertidor de 5 voltios y así se puede conectar de forma segura mediante USB al ordenador sin tener que comprar un módulo conversor Dv-DC  de 3,3 voltios.

Si usted necesita  comprar una placa  NodeMcu se puede comprar la versión 0.9 o la versión 1.0: la única diferencia que sé es que la versión 0.9 es más ancha que la versión 1.0. ( de hecho no puede utilizar la versión 0.9 en una placa de prototipos standard  ).

Hay  gran cantidad de tutoriales en Internet donde explican como  programar esta placa  junta con el software de LUA, pero al ser  básicamente un Arduino con un escudo  wifi, también se puede usar el software Arduino IDE siguiendo estos pasos:

  • Ir   a “Archivo”
  • Haga clic en “Oreferencias”
  • Agregue el siguiente enlace en el campo “URL de la placa adicional ‘:http: //arduino.esp8266.com/stable/package_esp8266c 
  • Después de esto puede reiniciar el software y debe ser capaz de seleccionar la junta en el gestor de tabla (V1.0 o v0.9).

ThingSpeak

En esta ocasión se va a enviar   nuestros medidas a la veterana  plataforma Thingspeak  que ofrece varias opciones para la interacción con sus datos como Thingtweet, Thinghttp etc.

Lo primero que tenemos que hacer es crearnos una cuenta en thingspeak , para ello  simplemente vaya a thingspeak.com y cree  una cuenta ,donde  solo será necesario rellenar en al menos la primera y segunda en la configuración de campo.

Si se conecta un sensor de temperatura y humedad, como se describe mas adelante, rellenar “temperatura” en el campo 1, ‘humedad’ en el campo 2 y el “punto de rocío” en el campo 3. Si desea conectar otros sensores tales como el sensor de BMP, sensor de lluvia, LDR, sólo tiene que hacer lo mismo para el resto de los campos.

En este formulario puede encontrar  una clave API key  que habrá que mencionar en su código para  Arduino bajo la ‘clave de API’  , pues esta clave es necesaria para conectar el Arduino al canal Thingspeak recién creado.

thingspeak.PNG

Sensor DHTXX

DHT11 y  DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad usando ademas un único  hilo para comunicar los datos vía serie, para lo cual  ambos  disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino o ESP8266.

Ambos son similares ( DHT11 presenta una carcasa azul  , mientras que el sensor DHT22  es blanco)  compartiendo además los mismos pines  disponiendo de  4 patillas, de las cuales usaremos sólo 3: Vcc, Output y GND.  Como peculiaridad ,la  salida la conectaremos a una entrada digital  , pero necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.

El  DHT11  puede medir temperaturas entre 0 a 50, con una precisión de 2ºC, humedad entre 20 a 80%, con precisión del 5% y con una a frecuencia de muestreo de 1 muestras por segundo (1 Hz)

En clara superioridad  con el dHT11 , el modelo DHT22 tiene unas características mucho más profesionales.
  • Medición de temperatura entre -40 a 125, con una precisión de 0.5ºC
  • Medición de humedad entre 0 a 100%, con precisión del 2-5%.
  • Frecuencia de muestreo de 2 muestras por segundo (2 Hz)

Destacar que este tipo de  sensores de temperatura  ( y, aún más, los sensores de humedad) , son sensores con elevada inercia y tiempos de respuesta elevados. Es decir, al “lentos” para reflejar los cambios en la medición.

Conectar el DHT11   o el DHT22  a  un Arduino o ESP82366  es sencillo, simplemente alimentamos desde Arduino al sensor a través de los pines GND y Vcc del mismo. Por otro lado, conectamos la salida Output a una entrada digital de Arduino como por ejemplo el pin D4   (No necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output al llevarla ya  integrada la placa ).

El sensor de BMP

El sensor de BMP180  mide la de la temperatura y la presión del aire. Sí, ya tenemos un sensor de temperatura añadido en el paso anterior, pero no un sensor de presión de aire. Conectar la clavija de alimentación a la línea de 3,2 voltios de la NodeMCU y el conector de tierra en el pin GND de la NodeMCU. El SCL tiene que estar conectado a D1 y la SDA a D2.

Sensor de lluvia y sensor de luz

El sensor utiliza materiales de doble cara FR-04 de alta calidad, donde el área extensa es de 5.0 * 4.0CM, y la superficie niquelada, eficaz contra la oxidación, la conductividad, el funcionamiento superior y las áreas de la vida.

El sensor de lluvia no requiere ninguna  otra placa cuando queremos leer el valor analógico.Si queremos leer valores  binarios  en cambio podemos utilizar la placa adicional  que ofrece  una  conexión a los pines digitales . Gracias a un potenciómetro   que contiene  esta placa , se puede establecer el valor  de umbral con que se dispara pues el  formato de salida  puede ser  de conmutación digital (0 y 1) gracias a  un comparador de amplio voltaje LM393 (y salida de tensión analógica AO).

También en este proyecto se ha añadido un LDR , por lo que podemos  tener dos lecturas analógicas. Esta es una parte difícil pues el NodeMCU sólo tiene un pin analógico , pero podemos resolver este problema mediante la multiplexación de los pines analógicos de modo que con la ayuda de dos diodos y dos pines GPIO , podemos suministrar energía a ambos sensores en secuencia para tomar la lectura de ambos ( eso sí tendrá que controlar esta secuencia desde el  propio programa)

canlaes.PNG

Como se puede ver el sensor de lluvia está activada por el pin D7  (GPIO13)  yel LDR es alimentado por el   pin D8  (GPIO15).

Este es el trozo de código que permite la lectura de ambas señales analógicas:

int sensorPin = A0; // selecciona  el pi, t the input pin for the potentiometer
int enable1 = 10; // activar lectura  sensor A
int enable2 = 11; // acvtivar lectura sensor B

int sensorValue1 = 0; // variable to store the value coming from sensor A
int sensorValue2 = 0; // variable to store the value coming from sensor B

void setup() {
Serial.begin(9600);
// declare the enable and ledPin as an OUTPUT:
pinMode(enable1, OUTPUT);
pinMode(enable2, OUTPUT);
}

void loop() {
// read the value from sensor A:
digitalWrite(enable1, HIGH);
sensorValue1 = analogRead(sensorPin);
Serial.println(sensorValue1);
digitalWrite(enable1, LOW);

delay(100);

// read the value from sensor A:
digitalWrite(enable2, HIGH);
sensorValue2 = analogRead(sensorPin);
Serial.println(sensorValue2);
digitalWrite(enable2, LOW);
Serial.println(“—————————————-“);
delay(1000);
}

Las conexión  de todos los sensores  queda pues como en la figura siguiente:

esquema

Finalmente una vez montado el circuito  solo nos queda  programar el ESP por ejemplo usando el código de más abajo.

No debemos olvidar  de cambiar el apikey con el de su cuenta de thingspeak, pues si no se hace NO  se podrán enviar datos a su canal

Es asimismo importante añadir el nombre SSID  de su red Wi-FI (esto es simplemente el nombre que aparece cuando se hace clic en la esquina derecha de Bottum a filtrar) así como añadir la contraseña de esta red wifi.

Si ha cargado el boceto se puede comprobar en el monitor serie cómo funciona. Basta con abrir el monitor pulsando CNTR + M.

*
This sketch is a combination of two other sketches:
1.
Plot DTH11 data on thingspeak.com using an ESP8266
April 11 2015
Author: Jeroen Beemster
Website: http://www.arduinesp.com
2.
Example sketch: adafruit BMP 085
Sensor api BMP180
*/
//library DHT22
#include

//library esp
#include

//library bmp180
#include
#include
#include

// replace with your channel’s thingspeak API key,
String apiKey = “”; //fill in the api key from thingspeak
const char* ssid = “”; //fill in your wifi name
const char* password = “”; //fill in your wifi password

const char* server = “api.thingspeak.com”;
#define DHTPIN 2 // what pin we’re connected to

DHT dht(DHTPIN, DHT22,15);
WiFiClient client;

int sensorPin = A0; // input for LDR and rain sensor
int enable1 = 15; // enable reading LDR
int enable2 = 13; // enable reading Rain sensor
int sensorValue1 = 0; // variable to store the value coming from sensor LDR
int sensorValue2 = 0; // variable to store the value coming from sensor Rain sensor
//————————–setup————————-
void setup() {

// declare the enable and ledPin as an OUTPUT:
pinMode(enable1, OUTPUT);
pinMode(enable2, OUTPUT);
Serial.begin(115200);
delay(10);

dht.begin();

WiFi.begin(ssid, password);

Serial.println();
Serial.println();
Serial.print(“Connecting to “);
Serial.println(ssid);
Serial.print(“……….”);
Serial.println();
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);

}
Serial.println(“WiFi connected”);
Serial.println();

}
void loop() {
//————————–DHT22/DHT11————————-

float h = dht.readHumidity();
float t = dht.readTemperature();

if (isnan(h) || isnan(t)) {
Serial.println(“Failed to read from DHT sensor!”);
return;
}
Serial.print(“Temperature: “);
Serial.print(t);
Serial.print(” degrees Celcius “);
Serial.println();

Serial.print(“Humidity: “);
Serial.print(h);
Serial.print(“%”);
Serial.println();

//— extra—- you can measure dew point with the temperature and the humidity

double gamma = log(h/100) + ((17.62t) / (243.5+t));
double dp = 243.5
gamma / (17.62-gamma);

Serial.print(“Dew point: “);
Serial.print(dp);
Serial.print(” degrees Celcius “);
Serial.println();

//————————–BMP180————————

if(!bmp.begin()) {
Serial.print(“Failed to read from BMP sensor!!”);
while(1);
}

sensors_event_t event;
bmp.getEvent(&event);

Serial.print(“Pressure: “);
Serial.print(event.pressure);
Serial.println(” hPa”);

float temperature;
bmp.getTemperature(&temperature);
Serial.print(“Temperature: “);
Serial.print(temperature);
Serial.println(” degrees Celcius “);

//— extra—-you can measure the altitude with the temperature and the air pressure

float seaLevelPressure = 1015;
Serial.print(“Altitude: “);
Serial.print(bmp.pressureToAltitude(seaLevelPressure,event.pressure));
Serial.println(” m”);

//————————–LDR————————-

digitalWrite(enable1, HIGH);
sensorValue1 = analogRead(sensorPin);
sensorValue1 = constrain(sensorValue1, 300, 850);
sensorValue1 = map(sensorValue1, 300, 850, 0, 1023);
Serial.print(“Light intensity: “);
Serial.println(sensorValue1);
digitalWrite(enable1, LOW);
delay(100);

//————————–Rain Sensor————————-

digitalWrite(enable2, HIGH);

delay(500);
sensorValue2 = analogRead(sensorPin);
sensorValue2 = constrain(sensorValue2, 150, 440);
sensorValue2 = map(sensorValue2, 150, 440, 1023, 0);

Serial.print(“Rain value: “);
Serial.println(sensorValue2);
Serial.println();
delay(100);

digitalWrite(enable2, LOW);

//————————–thingspeak————————-

if (client.connect(server,80)) { // “184.106.153.149” or api.thingspeak.com
String postStr = apiKey;
postStr +=”&field1=”;
postStr += String(t);
postStr +=”&field2=”;
postStr += String(h);
postStr +=”&field3=”;
postStr += String(dp);
postStr +=”&field4=”;
postStr += String(event.pressure);
postStr +=”&field5=”;
postStr += String(temperature);
postStr +=”&field6=”;
postStr += String(sensorValue1);
postStr +=”&field7=”;
postStr += String(sensorValue2);
postStr +=”&field8=”;
postStr += String(bmp.pressureToAltitude(seaLevelPressure,event.pressure));
postStr += “\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n”;

client.print(“POST /update HTTP/1.1\n”);
client.print(“Host: api.thingspeak.com\n”);
client.print(“Connection: close\n”);
client.print(“X-THINGSPEAKAPIKEY: “+apiKey+”\n”);
client.print(“Content-Type: application/x-www-form-urlencoded\n”);
client.print(“Content-Length: “);
client.print(postStr.length());
client.print(“\n\n\n\n\n\n\n\n”);
client.print(postStr);

}
client.stop();
// thingspeak needs minimum 15 sec delay between updates
delay(20000);
}

Weather_station_for_instructables.inoWeather_station_for_instructables.ino

Todo el conjunto se puede meter en un pequeña caja .  El sensor de DHT y el sensor de BMP pueden posicionarse en el lado de la caja cubriendo los dos sensores con un poco de múltiplex para que la lluvia no pudo influir en las lecturas
Asimimos Thingspeak tiene un montón de opciones de plugin. Uno de ellos es que es posible hacer que los medidores  los publique en su página web de thingspeak   en la pestaña ‘vista privada’ de Thingspeak. Se pueden  vincular los medidores de su sitio web privado  mediante el uso de un iframe que tiene que estar conectado a Thingspeak para poder ver los medidores.

Fuente   aqui