Anuncios

Migración urgente para Pebble


Pebble ha sido el proyecto mas exitoso  financiado por crowdfunding en Kickstarter,  quizás por la originalidad de su propuesta : ser el primer smartwatch  con contar con una pantalla de tinta electrónica (e-ink) lo cual se traduce en una gran duración de la batería comparada con sus homólogos  basadas en pantallas TFT, lo cual  ha quedado demostrado ser una de  las mejores opciones para un reloj inteligente a pesar de sus limitaciones en cuanto a resolución.

Respecto a todo lo demás,como cualquier smartwatch se conecta a un smartphone Android o Ios  a través de Bluetooth para proporcionar notificaciones personalizadas y aplicaciones descargables pudiéndose  personaliza  con watchfaces y aplicaciones para adaptarlo al estilo e intereses personales.

Una  de las posibilidades que ofrece todavía  es controlar sus aplicaciones musicales favoritos, incluyendo iTunes, Spotify y Pandora de su Pebble mientras realiza deporte y por supuesto , como cualquier  reloj inteligente saber quien nos llama colgando o descolgando desde el propio Pebble. Respcto a las notificaciones,se  puede obtener actualizaciones discretos sobre la información que es más importante. Además de identificador de llamadas, correo electrónico, mensaje de texto y alertas de calendario,se puede elegir recibir notificaciones de Facebook, Twitter, Instagram y mil cosas mas,   todo ello  con un precio muy contenido  pues cuesta aun en Amazon aun menos de 50€.

Pero tras el gran éxito  comercial durante años  dominando el mercado de los smartwatches  ( incluso  innovando incluyendo pantallas  e-ink en color) , finalmente Fitbit,  el gigante de los cuantificadores  a finales de 2016  compró Pebble,

 

Recientemente Fitbit anunció que a finales de este mes de junio de 2018  dejará de dar soporte  técnico a los relojes Pebble después de que el gigante de los cuantificadores comprara esta  startup ,así que en teoría los Pebble dejarán de ser útiles a partir de esa fecha  tal y como muestra su pagina oficial justo en la cabecera del home.

pebble2.PNG

 

Pero ¿que podemos hacer los usuarios de un Pebble?, pues la alternativa se llama Rebble   , los cuales ya  han lanzado su propio sitio https://auth.rebble.io/

De hecho , el propio  fundador de Pebble ha recomendado, o más bien implorado a los usuarios de Pebble, que migren sus cuentas a Rebble.io,

Rebble es pues  el proyecto de un grupo de desarrolladores independientes que  se supone  continuarán dando soporte a la plataforma Pebble  mediante un cambio en el firmware de los relojes inteligentes  y gracias a  su nueva  propia plataforma de actualizaciones con tienda de aplicaciones e incluso  soporte técnico  reemplazando todas las funciones actuales de los Pebble.

La aspiración es que la plataforma sea gratuita  pues  de momento Rebble se financia mediante Patreon, pero es posible que en el futuro decidan cobrar una pequeña cantidad por algunos de sus servicios.

No hay muchos detalles sobre el proyecto, pero lo primero que debemos hacer es migrar nuestros datos antes de que eliminen estos los de Fitbit, asi   para hacer esto es vital que sigamos los siguientes  pasos:

Paso1 

El sistema de cuenta Rebble está funcionando asi que ahora es el momento para que podemos crear nuestra nuevas cuentas en Rebble , por lo que debemos dírigirnos a Rebble Auth e iniciar sesión utilizando su nuevo sitio https://auth.rebble.io/

 

rebble

 

Paso 2

Como son dos sitios  bien diferentes , lo primero que tenemos que hacer es logarnos  creando una nueva cuenta en Rebble ofreciéndonos para ello  4 opciones: facebook, twitter, google + o github .

Obviamente tenemos que tener cuanta en alguna de ellas  y tenemos que estar logados en la que elijamos  en otra ventana de un navegador o introducir y validar con sus credenciales de alguan de esas opciones

Paso 3

Entonces se le pedirá  vincular la nueva cuenta con la antigua de Pebble pues necesitan  utilizar esto para importar información desde los servidores de Pebble antes de que cierren con el fin de ayudar a hacer la transición más suave.

Es especialmente importante para los desarrolladores enlazar sus cuentas de Pebble ahora. Una vez que los servicios de Pebble se cierre a finales de este mes, ya no seran capaces de identificar a los desarrolladores que no hayan  vinculado sus cuentas, y así no podran permitirles actualizar o modificar de cualquier manera sus aplicaciones.
También nos comentan  que van a utilizar el número de cuentas creadas para ayudarles a determinar la utilización de los servicios y tratar de validar sus s suposiciones sobre el número de usuarios que esperan  ve en la nueva plataforma.

Bien , una vez que hayamos elegido y validado o cualquiera de las cuatro alternativas  para entrar en Rebble , lo siguiente es introducir las credenciales  vigentes de nuestra cuenta de Pebble

pebblelogin.PNG

Paso 4

Si las credenciales son correctas, eso sera todo,  de modo que  durante las próximas semanas nos irán detallando los siguientes pasos a seguir para recuperar el control de nuestros relojes desde la nueva plataforma.

yoset.PNG

 

Eso es todo hay que hacer ahora mismo: no hay ninguna app para instalar, y de hecho reconocen sus creadores  no están aun listos para que los usuarios cambien a los servicios de Rebble  pero prometen hacerlo cuanto antes

De momento registrarse no cuesta nada y es la única manera de conservar sus datos y seguir usando el reloj. Si nos atenemos a lo que dicen en Rebble, el acceso a las funciones básicas de Pebble parece completamente asegurado y a Fitbit no le importa que se haya creado esta plataforma, lo cual también da cierta confianza en que la plataforma no desaparecerá de la noche a la mañana a golpe de demanda.

Como vemos es muy importante que los usuarios de estos relojes que quieran seguir disfrutando de ellos se registren en la página web de Rebble antes del 30 de junio si quieren conservar sus datos.

 

 

 

 

Anuncios

Como enviar correos con adjuntos desde Linux desde linea de comandos


Es frecuente   en el manejo de maquinas Linux  usar muchos scripts en bash o c-shell para automatizar tareas  de una forma sencilla, dado  que al contrario de lo que muchas personas piensan,   shell script (o c-shell)  son  bastantes potentes  a la hora de manipular información .

Ante la cuestión de cómo enviar un correo electrónico desde linea de comandos  o desde un script , incluso  con archivos adjuntos desde una máquina Linux ,    lo primero   que pensamos es usar  la utilidad  mailx la cual mejora en muchos aspectos a la utilidad mail de viejos sistemas

La sintaxis básica para enviar correos electrónicos desde una máquina Linux mediante el comando mailx se muestra a continuación:

mailx -vvv -s   $asunto -r   $from  -S   $smtp     $destino

Como vemos , podemos   observar  varios parámetros en la  línea  anterior;

  • -vvv = Verbosity.
  • -s = especifica el asunto (subject).
  • -r = especificar el origen del Email.
  • -S = especifica el  smtp server.

Y lo ideal es usar variables:

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $from : almacenamos el usuario que envía el correo
  • $smtp : almacenamos el servidor de correo
  • $destino : almacenamos  la dirección de correo destinatario  ( pueden poner sucesivas separando con espacios estas)

El comando anterior se puede complementar añadiendo   un cuerpo al contenido del correo  gracias al comando echo redirigiendo con el pipe (|)  hacia mailx

 echo  $cuerpo  | mailx -vvv -s   $asunto -r   $from  -S   $smtp     $destino

Dónde  $cuerpo  es  una variable que almacena el cuerpo del  email

person using macbook pro on brown wooden desk

Photo by rawpixel.com on Pexels.com

Es importante destacar que podemos obviar el servidor  stmp server si está configurado en la máquina así  como el origen del correo obvio , quedando su uso habitual tal como sigue:

 echo  $cuerpo  | mailx  -s   $asunto  -S     $destino1  $destino2  $destino3

Como se aprecia,   se  añade   un cuerpo al contenido del correo  gracias al comando echo redirigiendo con el pipe (|)  hacia mailx y se usan varias variables:

  • $cuerpo  es  una variable que almacena el cuerpo del  email
  • $asunto: almacenamos el asunto ( subject ) del correo
  • $smtp : almacenamos el servidor de correo
  • $destino1 : almacenamos  la dirección de correo destinatario
  • $destino2 : almacenamos  la dirección de correo destinatario
  • $destino3 : almacenamos  la dirección de correo destinatario

Anexando  adjuntos

Si   la versión de mailx que esta usando está por encima  de 12.x,e puede usar el nuevo interruptor adjunto (-a) en mailx para enviar archivos adjuntos con el correo ,  lo cual es una opción más simple  que el comando uuencode.

Como ejemplo mandar un fichero  a un destinatario, es muy sencillo usando el siguiente comando:

mailx -a $file  -s  $asunto  $destino1

En l comando anterior  se usan estas variables :

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $destino1 : almacenamos  la dirección de correo destinatario
  • $file: ruta directa cal fichero a  anexar

El comando anterior imprimirá una nueva línea en blanco en el cuerpo del mensaje  aunque puede escribir el cuerpo del mensaje  presionar [ctrl] + [d] para enviar, lo cual  adjuntará el archivo al correo electrónico saliente correctamente con el Content-Type y encabezados  apropiados.

Para hacer esto más “scriptable”, puede enviar el mensaje sin un cuerpo con el siguiente comando:

mailx -a $file  -s  $asunto  $destino1< /dev/null

Para enviar correos con un cuerpo de mensaje, reemplace / dev / null en el comando anterior con su archivo de cuerpo de mensaje.

mailx -a $file  -s  $asunto  $destino1<   $cuerpo

Donde $cuerpo  es  una variable que almacena el cuerpo del  email

En esta  versión de mailx, los encabezados que se usan en el correo electrónico saliente cambian de:

From:
Date:
To:
Subject:

A la forma siguiente:

From:
Date:
To:
Subject:
User-Agent:
MIME-Version:
Content-Type:
Content-Transfer-Encoding:

Si la versión de mailx está por debajo de 12.x, puede usarse el comando uuencode para enviar correos con archivos adjuntos.

El comando uuencode  se utiliza para codificar un archivo binario.De forma predeterminada, uuencode tiene entrada desde la entrada estándar y escribe en la salida estándar como se muestra a continuación ( esa es la razón por la que se repite el nombre del fichero) utilizando  por defecto el formato de codificación estándar de UU.

 uuencode  $fichero $fichero | mailx -s $asunto  $destino

Usando el formato anterior ,como se aprecia, se  añade   un cuerpo al contenido del correo  gracias al comando echo redirigiendo con el pipe (|)  hacia mailx  , de forma similar a añadir un cuerpo al  correo ,  pero esta vez estamos anexamos un fichero previamente codificado con uuencode

Las variables usadas:

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $destino : almacenamos  la dirección de correo destinatario
  • $fichero : almacenamos  la ruta completa del fichero a adjuntar
  •  $fichero : almacenamos  la misma  ruta completa del fichero a adjuntar ( en efecto se repite y no es un error)

Por cierto, en caso de necesitar adjuntar varios ficheros, puede usar esta receta:

uuencode $fichero1 $fichero1  >/tmp/out.mail

uuencode $fichero2 $fichero2  >/tmp/out.mail

cat email-body.txt >>/tmp/out.mail

Y ahora ya si podemos  enviar el correo:

mailx -s $asunto  $destino </tmp/out.mail

high angle view of paper against white background

Photo by Pixabay on Pexels.com

Correos con anexos y cuerpo

La sintaxis  para enviar correos electrónicos desde una máquina Linux mediante el comando mailx  puede tener problemas a la hora de incluir  además de anexo un cuerpo  en el mensaje, por lo que podemos usar en su lugar el comando mutt usando la siguiente sintaxis:

echo $body | mutt -s $asunto -a $fichero  $destino1  $destino2 $destino3

Como vemos , podemos   observar  varios parámetros en la  línea  anterior;

  • -s = especifica el asunto (subject).
  • -a = especifica el nombre del fichero con la ruta completa

Y como en  los ejemplos anteriores , lo ideal es usar variables:

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $destino1 : almacenamos  la dirección de correo destinatario
  • $destino2 : almacenamos  la dirección de correo destinatario
  • $destino3 : almacenamos  la dirección de correo destinatario
  • $body : almacenamos el cuerpo del correo

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

Monitorización de gases con Arduino


Gracias  a la plataforma de Cayenne , de la que hemos hablado en este blog en numerosas  ocasiones, es bastante sencillo monitorizar cualquier variable física  de un modo realmente sencillo  simplemente arrastrando al panel de control de Cayenne sin escribir apenas código, tanto para el dispositivo IoT como para la parte web  o incluso la app móvil,  pues incluso proporcionan una app multipropósito para controlar su dispositivo IoT.

En esta ocasión  ejemplo  vamos a lo fácil que es crear un monitor temperatura ,humedad y humos  usando Arduino   y la plataforma Cayenne , sin tener conocimientos  de programación consiguiendo controlar o monitorizar  un Arduino o Raspberry Pi    en tan solo unos minutos.

 

En efecto   gracias  a un  framework  genérico desarrollado por  myDevices IO Project Builder llamado Cayenne , los desarrolladores , fabricantes y  también aficionados  pueden  construir rápidamente prototipos y proyectos que requieran controlar o monitorizar   cualquier cosa conectada a una  Raspberry  o un ARduino  , permitiendo con una sóla cuenta gratuita de Cayenne, crear un número ilimitado de proyectos  mediante una solución  muy sencilla  basada en arrastrar y solta.
Obviamente el punto fuerte de Cayenne  son las  capacidades de  IO  para que pueda controlar de forma remota sensores, motores, actuadores, incluidas los puertos  de GPIO con  almacenamiento ilimitado de datos recogidos por los componentes de hardware,   triggers y alertas,  pues  proporcionan las herramientas necesarias para la automatización y la capacidad de configurar alertas. 
Ademas desde el interfaz se puede crear cuadros de mando personalizados para mostrar su proyecto con arrastrar y soltar widgets que también son totalmente personalizables.

Resumidamente algunas  características clave de esta novedosa  plataforma son las siguientes:

  •  Ofrecen una aplicación móvil para configurar, el monitor y los dispositivos de control y sensores desde cualquier lugar.
  • Fácil instalación que conecta rápidamente los dispositivos, sensores, actuadores, y las extensiones en cuestión de minutos.
  • Motor de reglas para desencadenar acciones a través de dispositivos.
  • Panel personalizable con widgets de visualización de arrastrar y soltar.
  • Programación de las luces, motores y actuadores
  •  Control de GPIO que se pueden configurar desde una aplicación móvil o  desde un navegador
  • Acceso remoto instantáneo desde su smartphone o con un ordenador
  • Para construir un proyecto de la IO a partir de cero se ha logrado el objetivo de proporcionar  un Proyecto Generador de IO que reduce el tiempo de desarrollo de horas en lugar de meses.

Sabemos la gravedad que puede suponer un incendio, por lo que es sumamente importante disponer de medidas en los edificios de detección eficaces para protegerlos contra la acción del fuego.

En este post  vamos a intentar abordar el grave problema de los incendios desde una perspectiva completamente diferente usando para ello un Arduino   y  un hardware especifico consistente en un DHT22 , un detector de  gas   junto con  la plataforma  Cayenne.

Tradicionalmente los detectores de incendios difieren en función de los principio de activación siendo los mas habituales los de Tipo Óptico basado en células fotoeléctricas ,las cuales, al oscurecerse por el humo o iluminarse por reflexión de luz en las partículas del humo, disparando una sirena o alarma.Asimismo existen detectores de calor

La solución que se propone se basa en detectores termicos al ser los mas precisos ,al que se ha añadido para aumentar la fiabilidad y mejorar la flexibilidad un doble sensor permitiendo de esta manera poder modificar los parámetros de disparo con un enorme facilidad como vamos a ver aparte de poder transmitir la información en múltiples formatos y formas hasta nunca vistas.

 

Monitorización de gases con Arduino

En esta  ocasión vamos  a ver  cómo monitorizar  temperatura, humedad así como ofrecer a alertas en tiempo real  si suben  las concentraciones de gas o humo respecto al nivel normal usando la plataforma a Arduino (si no dispone de un Arduino , un    proyecto  muy similar  lo  abordamos en este blog  con una Raspberry Pi 2)

Como vamos  a ver es realmente sencillo  construir un proyecto de este tipo  usando la plataforma  Cayenne  y desde luego  muy útil , pues podemos prevenir fuego o incluso  fugas de gas  en cualquier lugar   monitorizando  ademas en tiempo real desde Internet.

El hardware  necesario para este proyecto es el  que describimos  a continuación:

 

Sensor de Co2

Como sensor de humo se ha usado un detector de gases basado en el circuito MQ4 .Este detector se puede montar un circuito con el sensor , o bien se puede adquirir con el sensor y el modulo de disparo con un led ya soldado, lo cual por su bajo coste  (menos de 2€ en Amazon  )es la opción más recomendada. Estos módulos permiten Dual-modo de señal de salida, es decir cuentan con dos salidas diferenciadas:
  • Salida analógica : 0.1 – 0 .3 V (relativa a polución , La máxima concentración se muestra con un  voltaje de 4 V
  • Salida con sensibilidad de nivel TTL (la salida es a nivel alto si se detecta GLP, el gas, el alcohol, el hidrógeno y mas)

Estos módulos son de rápida a respuesta y recuperación ,cuentan con una buena estabilidad y larga vida siendo ideales para la detección de fugas de gas en casa o fabrica .Son ademas muy versátiles , pudiendo usarse para múltiples fines ,detectando con facilidad lo siguientes gases:

  • Gas combustible como el GLP
  • Butano
  • Metano
  • Alcohol
  • Propano
  • Hidrogeno
  • Humo
  • etc.

Algunas de las características del módulo:

  • Voltaje de funcionamiento: 5V DC
  • Rango de Detección: 300 a 10000 ppm
  • Salida TTL señal valida es baja
  • Tamaño: 32X22X27mm

 

Para conectar el  detector de gases a nuestra  placa Arduino, es esta ocasión optaremos por usar el puerto  analógico A0,  que conectaremos a la salida analógica  2 del sensor ( marcado como OUT).

La alimentación del sensor la tomaremos desde cualquiera de las dos conexiones de +5V de nuestra Arduino conectándo al pin 4 del sensor (marcado como +5v) y la conexión de masa pal pin1 del detector ( marcado como GND)

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 22  (No necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output al llevarla ya  integrada la placa ).

El esquema eléctrico queda como la siguiente imagen:

 

Los sensores DHT11 y DHT22 usan su propio sistema de comunicación bidireccional mediante un único hilo , empleando señales temporizadas por lo que en general, lo normal es que empleemos una librería existente para simplificar el proceso.Por ejemplo podemos usar la librería de Adafruit disponible en este enlace.

En este ejemplo como podemos  en el esquema final ver, el pin  digital usado es el el pin 22

Como realmente  lo que buscamos es controlar los puertos del GPIO  a distancia y mediante un interfaz gráfico remoto, para comenzar la configuración de su Arduno   ,lo primero es crear una cuenta gratuita en cayenne-mydevices.com que servirá tanto para entrar en la consola web como en la aplicación móvil.

Para ello, vaya a la siguiente url  e introduzca simplemente su nombre ,dirección de correo y una clave de acceso  que  utilizara para validarse.

paso1.png

Una vez registrado , solamente tendrá que elegir la plataforma  para avanzar en el asistente. Obviamente   seleccionamos  en nuestro caso   Arduino

paso2.png

El  siguiente pasos es obtener el Token para nuestro Arduino , el cual copiaremos en nuestro skecth

 Cargar Sketch

Necesitaremos    añadir el valor del token de Cayenne al obtenido  en el paso anterior  y cargar el  siguiente código .(fuente MQ2)

#include “CayenneEthernet.h”
#include “DHT.h”

#define DHTPIN 22
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

char token[] = “”; //fill with your token

const int MQ2 = A0;

void setup()
{
Serial.begin(115200);
Cayenne.begin(token);
dht.begin();
}

void loop()
{
Cayenne.run();
}

CAYENNE_OUT(V0)
{
float t = dht.readTemperature();
Cayenne.virtualWrite(V0, t); //virtual pin
}

CAYENNE_OUT(V1)
{
float h = dht.readHumidity();
Cayenne.virtualWrite(V1, h); //virtual pin
}

CAYENNE_OUT(V2) {
Cayenne.virtualWrite(V2, MQ2);
}

 Configuración Cayenne

Montado ya el circuito y cargado el firmware de Arduino  ( y por supuesto conectado este a Internet ) , lo siguiente es, configurar el panel de control de  Cayenne  y  añadir un widget para sensor de gas MQ2 al pin virtual 2.

 

Picture of Setup Cayenne Dashboard

Si ha seguido todos los pasos anteriores tendremos en la consola de Cayenne nuestra placa Arduino  con la información en tiempo real de la temperatura o detección de gas.Ademas, por si fuera poco gracias a la aplicación móvil  de Cayenne , también podemos ver en esta en tiempo real lo que están captando los sensores que hemos instalado

Pero aunque el resultado es espectacular todavía nos queda una característica para que el dispositivo sea inteligente : el poder interaccionar ante los eventos de una forma lógica,lo cual lo haremos a través de lo triggers , los cuales nos permitirán desencadenar acciones ante cambios en las variables medidas por los sensores.

A la hora de definir triggers en Cayenne podemos hacerlo tanto desencadenado acciones como pueden ser enviar corres de notificaciones o envio de SMS’s a los destinatarios acordados o bien actuar sobre las salidas.

Para definir un disparador en myTriggers, pulsaremos “New Trigger” y nos presentara dos partes:

  • IF ; aqui arrastraemos el desecadenante, lo cual necesariamene siempre sera la lectura de un sensor ( en uestro caso el termometro o el detector de gas)
  • THEN: aqui definiremos lo que queremos que se ejecute cuando se cumpla la condición del IF. Como comentábamos se pueden actuar por dos vías : se puede activar /desactivar nuestra actuador ( el buzzer) o también enviar correos o SMS’s

En este caso   puede establecer   el trigger para MQ2 sensor de gas  si el valor supera el valor  500,  que  entonces de  una alerta a su teléfono móvil.

 

Picture of Setup Cayenne Dashboard
Picture of Setup Cayenne Dashboard

 

Es obvio que las posibilidades son infinitas ( y las mejoras de este proyecto también), pero desde luego un circuito así es indudable la gran utilidad que puede tener.¿Se anima a replicarlo?

 

Fuente  parcial  instructables.com

Sistema de reconocimiento de colores para personas con discapacidades visuales


ColorDec  es un interesantismo  proyecto  que representará  al colegio Lope de Vega de 3ª de el ESO  para el concurso RetoTech que organiza ENDESA    creado por   Esther Scott, Irene Yebra, Irene Jimenez,Lucia Gomez y Paula  Vidal  ,  con el propósito de   ayudar  a  personas con discapacidad  visual para  mejorar su percepción de los colores,  gracias  a un hardware de bajo coste basado en Arduino   y una aplicación móvil  que ellas mismas han escrito usando el Mit App Inventor, una herramienta de la que por cierto hemos hablado en numerosas ocasiones en este blog .

El proyecto  tiene  pues su base  en un Arduino Nano, al que le han acoplado  un modulo bluetooth  para el envío de datos a  un smartphone  mediante los pines 9 (Rxd)  , 8(Txd)  para los datos  vía serie,   así como  VCC y gnd para la alimentación desde Arduino al  propio modulo  Bluetooth.

Para el reconocimiento de colores cuenta con un sensor especializado como es  el GY33 ( unos 15€ en Amazon)  el cual conectan al propio Arduino via I2C  por los pines A4,A5  alimentándose desde el propio Arduino  desde los pines  5v y GND.

El  GY-33 es un modulo  de reconocimiento de color de bajo costo que puede alimentarse  entre  3-5 V, con bajo consumo de energía, de  tamaño pequeño y facilidad de instalación.
Su principio de funcionamiento radica en que la iluminación de la irradiación de luz LED debe medirse  hacia el objeto de modo que la  luz de retorno es  detectada por los filtros de valores RGB y el propio modulo identifica los colores según los valores RGB.
Este módulo, soporta dos maneras de envió de  datos:

  • Via serie,  es decir mediante UART en serie (nivel TTL) configurando la conexión a 9600bps y 115200bps  siendo la velocidad en baudios del puerto en serie  configurable.
  • I2C (mediante 2 líneas) que es el que han empleado en este circuito mediante  lso pnes A4 y A5 .

El modulo puede hacer  un reconocimiento simple de 7 colores y no es necesario calcular el valor RGB o se puede gestionar  el dato de una manera compleja como vamos a ver.

Se complementa  el circuito   final con un pulsador(pin2)  con su respectiva resistencia para evitar rebotes    y la alimentación de  todo el conjunto  por un pila de 9v desde los pines VIN y GND de Arduino.

El diagrama   final  lo  podemos ver en  la imagen de mas abajo:

 

esquema

 

El dispositivo esta pensado para ser portátil de modo que sujetándolo con una mano se apoya en el objeto del que se  desea conocer el color , se pulsa el botón para que este lo transmita (tras convertirlo de RBG a HSV) por bluetooth al teléfono móvil del usuario, desde donde una APP   lo  reproduce hablando en inglés o castellano.

En cuanto al software para este  proyecto ha sido realizado utilizando el IDE de Arduino para programar un Arduino Nano, al que se le ha conectado un módulo Bluetooth, un Pulsador y un módulo GY-33 para el reconocimiento de color  lo cual es tarea del firmware de Arduino gestionarlo

El programa del Arduino, en su inicialización realiza un balance de blanco, y después espera a que se pulse el pulsador para leer el color, convertirlo a HSV y enviarlo por Bluetooth al móvil.

El código provisional para el firmware de Arduino que aun esta es proceso de mejora  nos lo comparten en estas lineas:

 

Colorview4-ino_1.png

Colorview4-ino_2.png

Colorview4-ino_3

Ya desde el teléfono, se conecta al Arduino por Bluetooth, se cargan dos arrays con los datos de dos ficheros CSV, uno con los códigos RGB de los colores y otro con los nombre de esos colores .

Se busca el color en el array y si se encuentra ese será el que el teléfono lea en voz alta.

Sino se encuentra entre los más de 600 códigos RGB, se usa el código en HVS para construir una frase que describe como es el color y se envía al sistema de síntesis de voz del teléfono.

La conversión a HVS han tenido que hacerla al no poder ordenar los códigos RGB para poder situarse sobre el color más cercano al leído.

Amablemente nos han compartido sin código escrito con el MIt App Inventor  para desplegarlo en un terminal Android

 

App-Inventor-Blocks 2-page.png

 

Es sin duda  un sistema  de mínimo coste  que puede ser de muchísima ayuda para  identificar  los colores para personas con deficiencias visuales,  así que le deseamos desde este blog  toda la suerte posible . El premio es una plaza para cada una de las cinco en un campamento de verano donde seguirán aprendiendo robótica y programación , así que queridos lectores porfavor  si os parece interesante  todo el esfuerzo de esta   chicas y  merece vuestra confianza, esta es la dirección para  votar   su proyecto:

https://pr.easypromosapp.com/voteme/826101/630232517

Personalmente  ya he votado porque me ha parecido impresionante el trabajo realizado , así que desde esta lineas  les deseamos toda la suerte en este concurso  y ojala puedan seguir aprendiendo  y perfeccionando sus conocimientos  tecnicos de modo que puedan seguir ayudando a construir un mundo mucho mejor gracias al uso de la tecnología y su ingenio

Watimetro con Arduino


Realmente construir un watimetro no es demasiado  complejo cuando hablamos de corriente continua , por ejemplo pensando en una instalación fotovoltaica , pues basta  simplemente en recordar  la formula física de la  Potencia(P)   , la cual es el producto de la tensión instantánea(voltios) por la intensidad  (Amp ) , es decir  P = V x I ,  expresándose la unidad de potencia en  Watt o KW
Pero la potencia  en watios,  no expresa  ensimismo  potencia energética, por lo  que se recurre  al  producto de la potencia (vatios)  por el tiempo (en horas) , es  decir  E = P x t , expresándose  la unidad de energía que  todo conocemos como  vatios hora(Wh) o kilovatios hora (kWh).

Si unimos ambas formulas sustituyendo el valor de P obtenemos E =Px t= (V xI) x t , es decir  el producto de la tensión  e intensidad por el el tiempo

Precisamente pues de la ultima fórmula anterior queda claro que para medir la energía que necesitamos tres parámetros:

  1.  Tensión
  2.  Intensidad
  3.  Tiempo

Veamos pues como  obtener estas valores con un Arduino  para obtener en tiempo real en un display lcd  la potencia en kwh de un sistema en cc

En el siguiente  video podemos ver el proyecto funcionando, incluso enviando datos al IoT  con  Xively (esta opción ya no esta disponible para aficionados)

Medida de tensión

El voltaje se puede medir con la ayuda de un circuito divisor de tensión  formado  por dos resistencias iguales  . Como el  voltaje de entrada en cualquier pin analógico de ARDUINO esta limitado a 5V por se logica TTL , el  divisor de voltaje servirá para  que el voltaje de la salida de ella sea menor que 5V y no queme la electronica interior.

Por ejemplo para una batería  que se utilice para almacenar la energía de un  panel solar de  6v  y   5.5Ah  de capacidad , tendríamos que bajar la  tensión desde 6.5v a una tensión menor que 5V para no estropear el Arduino.

Si usamos R1 = 10k y R2 = 10K  nos da una corriente pequeña 6.5v/(10k+10K)=0,325mA .

Es cierto que se podrían  tomar valores de R1 y R2    inferiores, pero el problema es que cuando la resistencia es menor  mayor corriente  pasas  a través de ella generando como resultado gran cantidad de energía  disipada en forma de calor(recuerde  que P = I ^ 2R) . por tanto el valor de las resistencias  puede ser elegido diferente pero debe tenerse cuidado para reducir al mínimo la pérdida de energía a través de las resistencias.

El resultado de la tensión entre una de las resistencias y masa seria igual a R xI =10k  x 0.325mA=3.25v que es inferior a 5v y, tensión soportada sin problemas  para el pin analógico de  ARDUINO

Calibración de voltaje:

Cuando la batería está completamente cargada (6.5v) obtenemos una Vout = 3.25v y ese seria el valor  que iría al  convertidor analógico digital  de un puerto analógico  de  Arduino

Si tenemos que medir los 3.25v desde el divisor de tensión   obtendremos un valor aproximado de 696 en el monitor serial (  sample1 es el valor de ADC corresponde a 3.25v)  .

Precisamente con ese valor o tendremos que extrapolar  que 3.25v  es equivalente a 696,  1 es equivalente a 3.25/696=4.669mv    por lo que podemos usar  estas dos reglas:

Vout = (4.669 * sample1 ) / 1000 voltios
voltaje de la batería real = (2 * Vout) voltios

Con el siguiente código de Arduino  podemos obtener el valor de tensión:

/ / tomar 150 muestras de divisor de tensión con un intervalo de 2 segundos y medio samples data collected for(int i=0;i<150;i++)
{
sample1=sample1+analogRead(A2); //leer  el voltaje del circuito divisor
delay (2);
}
sample1=sample1/150;
voltage=4.669*2*sample1/1000;

Medición de intensidad

Para mediciones de intensidad  es típico usar una resistencia en serie  de poco  valor con la carga  y medir la diferencia de potencial entre los extremos   de esta  y luego calcular   la intensidad gracias a la la ley de ohm (I=V/R  ) donde como vemos   dividiríamos este valor por el valor en ohmios de la resistencia

El efecto Hall se basa en  la producción de una diferencia de potencial(el voltaje de Hall) a través de un conductor eléctrico, transversal a una corriente eléctrica en el conductor y un campo magnético perpendicular a la corriente.

Afortunadamente actualmente existen CI especializados  como   son  los   sensores de corriente basados en efecto Hall ACS 712

Existen comercialmente  sensores de la gama ACS712  para  diferentes  rangos de corrientes máximas , así que se debe escoger este  según su requisito,como por ejemplo para una corriente máxima de 20 A.

ACS712.png

En el  esquema vemos un LED como una carga ( aunque  la carga real sera diferente) .

Tambien vemos el  ACS 712 (soporta  20Amps DC)  ofreciendo una una salida analógica 100mV/A

Tambien es destacar la alimentación del Arduino  cuya salida alimenta a través de la placa de prototipos a la ACS712

La calibración  es muy sencilla :
La lectura analógica  produce un valor de 0-1023, equiparando a 0v a 5v analógico .Leer 1 = (5/1024) V = 4.89mv
Valor = (4,89 * valor analógico leído) / 1000 V,  pero según hojas de datos offset 2.5V (cero corriente obtendrá 2.5V del sensor de salida)
valor Actual = (valor 2.5) V
corriente en amp = valor real * 10

Código de ARDUINO:

/ / tomando 150 ejemplos de sensores con un intervalo de 2 segundos y luego media de los datos de las muestras recogidos
for (int i = 0; i < 150; i ++)
{
+= sample2 analogRead(A3);  //  leer la corriente de sensor
delay(2);
}
sample2 = sample2/150;
=(5.0*sample2)/1024.0; 
actualval = val-2.5;  //tensión de offset es 2.5v
amperios = actualval * 10;

 Medición del tiempo

Para la medida del tiempo no se necesita ningún hardware externo, pues ARDUINO en sí mismo tiene contador de tiempo incorporado.

La función millis() devuelve el número de milisegundos desde que la placa Arduino comenzó a ejecutar el programa actual.

Código de ARDUINO:

long milisec = millis();  // calcular el tiempo en milisegundos
long time=milisec/1000; // convertir de milisegundos a segundos

 Calculo de la potencia y energía

Estas son las formulas basicas empleadas por el fw  en Arduino:
  • totamps = totamps + amperios;  //calcular amperios total
  • avgamps = totamps/tiempo;  // promedio de amps
  • amphr =(avgamps*time)/3600;  // Ah
  • Watts = voltaje * amperios;  //Potencia = Voltaje * corriente
  • energía =(watt*time)/3600;  // Vatios-seg vuelve a convertir en Watt-hora dividiendo 1hr(3600sec)
  •  energy=(watt*time)/(1000*3600); //para la lectura en kWh

completo.jpg

Todos los resultados se pueden visualizar en el monitor serial o mediante una pantalla LCD   de 16 x 2 caracteres para mostrar todos los resultados obtenidos en los pasos anteriores.

El conexionado del LCD sigue la conexión estandar de 4 pines para la linea de  datos mas las señales de control RS,RW  y Enable

Asimismo también es necesario un trimer de 10k  para el contraste de la pantalla

Resumidamente estas son pues las conexiones para el lcd

LCD -> Arduino
1. VSS -> GND de Arduino
2. VDD -> Arduino + 5v
3. VO -> Arduino GND pin + resistencia o potenciómetro
4. RS -> Arduino pin 8
5. RW -> Arduino pin 7
6. E -> pin Arduino 6
7. D0 -> Arduino – no conectado
8. D1 -> Arduino – no conectado
9. D2 -> Arduino – no conectado
10. D3 -> Arduino – no conectado
11. D4 -> Arduino pin 5
12. D5 -> Arduino pin 4
13. D6 -> Arduino pin 3
14. D7 -> pin Arduino 2
15. A -> Pin 13 de Arduino + resistencia (potencia de luz de fondo)
16. K -> Arduino GND (tierra de luz de fondo)

A continuación este es el  código de ejemplo para sacar por el monitor serie  los valores calculados

Serial.Print (“tensión:”);
Serial.print(voltage);
Serial.println(“Volt”);
Serial.print (“actual:”);
Serial.print(amps);
Serial.println(“Amps”);
Serial.print (“potencia:”);
Serial.print(watt);
Serial.println(“Watt”);
Serial.print (“energía consumida:”);
Serial.print(energy);
Serial.println(“Watt-Hour”);
Serial.println(“”);  //imprimir los siguiente conjuntos de parámetro después de una línea e
delay(2000);
Para manejar el  LCD tiene que primero importar la biblioteca de “LiquidCrystal” en el código.
A continuación este es el  código de ejemplo para sacar por el display  lcd  los valores calculados:
#include
lcd (8, 7, 6, 5, 4, 3, 2);
luz int = 9;
void setup()
{
pinMode (luz de fondo, salida); //set pin 9 como salida
analogWrite (contraluz, 150); //controls la intensidad de luz 0-254
lcd.begin(16,2); / / columnas, filas. tamaño de pantalla
LCD.Clear(); claro la pantalla
}
void loop()
{
lcd.setCursor(16,1); / / establecer el cursor fuera de la cuenta de pantalla
lcd.print(“”); imprimir carácter vacío
delay(600);
impresión de potencia y energía que un LCD / / /
lcd.setCursor(1,0); coloca el cursor en la columna 1 y fila 1

LCD.Print(Watt);
lcd.print (“W”);
lcd.print(voltage);
lcd.print(“V”);
lcd.setCursor(1,1); coloca el cursor en la fila 1 columna y 2 º
lcd.print(energy);
lcd.print (“WH”);
lcd.print(amps);
lcd.print(“A”);
}

 

Componentes

A continuación por ultimo algunos de los componentes necesarios para llevar a cabo este circuito:

 

1. ARDUINO UNO  (unos 9€ en Amazon)


3. Display LCD de 16 x 2 caracteres LCD (en Amazon con I2C  menos de 5€ )

4. ACS 712 SENSOR de corriente .Rango de corriente: 30A; Tamano: 31 x 13mm / 1.2 “x 0.5” (L * W) ( en Amazon unos 2€ )


Varios : resistencias de 10k v2,resistencia de 330ohm, POTENCIÓMETRO de 10K ,cables puente , placa de prototipos,etc

 

Pecados de Software

Sins4Software

pecados de software

Merecidos todos, disfrutados muchos y añorados a ratos.

A %d blogueros les gusta esto: