Reconocimiento de colores con Pixy


En efecto, si no tenemos demasiado tiempo  para experimentar con algoritmos de reconocimiento de imágenes con opencv o similares ,por ejemplo para integrar  la visión artificial en un robot que siga una linea, hay un producto llamado   Pixy2    que puede hacer todo eso y mas. Además, esta segunda version,  es más rápida, más pequeña y más potente que el Pixy original, agregando algoritmos de seguimiento / seguimiento de línea, así como otras características  (de  hecho la velocidad de procesamiento  en tiempo real   se ha mejorado en 60 fotogramas por segundo)

Como  puede  suponer  Pixy2  incorpora una cámara  y  una fuente de luz , y con todo  este hw puede detectar líneas, intersecciones y pequeños códigos de barras, diseñados para robots que siguen líneas.

Precisamente  por la utilidad de integrarlo en pequeños robots ,se han agregado algoritmos de seguimiento a la detección de objetos basada en color. Ademas tampoco descuidan su conexión con otras placas pues proporcionan bibliotecas mejoradas y simplificadas para Arduino, Raspberry Pi.

Veamos a continuación   mas detalles sobre esta interesante  placa

 

Hablamos de una placa  bastante pequeña(de unos 8x7cm) ,  tanto que incluso se puede conectar varios Pixy2 a un microcontrolador pues  Pixy2 es más pequeño, más rápido y más potente que el Pixy original. 

Este sistema de visión inteligente plug-and-play para Arduino-compatibles, Raspberry Pi u otros microcontroladores / sistemas de computadora.

 Al igual que su predecesor, Pixy2 puede aprender a detectar objetos que le enseñe, simplemente presionando un botón. Además, Pixy2  implementa nuevos algoritmos que detectan y rastrean las líneas para su uso con robots de seguimiento de línea (  incluso con  los nuevos algoritmos también pueden detectar intersecciones y “señales de tráfico”.)

 

Aunque la nueva cámara puede funcionar hasta 60 fps, se  ejecuta aproximadamente la mitad de esa velocidad y existen múltiples opciones para el ajuste fino del reconocimiento de objetos, todo  ello  para  mejorar la precisión   el reconocimiento de imágenes   ya que la cámara no esta diseñada para la grabación de imágenes pero si  pasará el centro X, Y, y el ancho, la altura de un objeto, y lo hace muy bien.

La nueva version  Pixy2  lleva  modo de seguimiento de línea y fuente de luz LED integrada simplificando  su programación recibiendo solo los objetos que le interesan.

Se puede utilizar el controlador que desee pues incluye bibliotecas de software para Arduino, Raspberry Pi y BeagleBone Black.

Si lo conectamos a  un pc, podemos instalar la utilidad de configuración (se ejecuta en Windows, MacOS y Linux) asi como el sw  Pixy2 CMUCam5, un sensor de imagen para su microcontrolador que puede enseñarle qué buscar.También es una gran mejora con respecto a las versiones anteriores de Pixy CMUCam, que agrega una mayor flexibilidad cuando se trata de cambios de iluminación y exposición. También puede recordar siete firmas de colores diferentes, encuentre cientos de objetos en a visión del robot es fácil: presione el botón para enseñarle a Pixy2 un objeto

Por ello el   Pixy2   es un sensor de imagen con un potente procesador que puede programar para enviar solo la información que está buscando para que su microcontrolador no se vea abrumado por los datos  ya que Pixy2 exporta su información en una variedad de formas útiles (UART serie, SPI, I2C, salida digital o salida analógica) para que su microcontrolador o microcomputadora pueda comunicarse fácilmente mientras realiza otras tareas.

Las coordenadas  enviadas  desde   Pixy2  pueden decirle a su robot qué hacer, como girar a la izquierda, girar a la derecha, disminuir la velocidad, etc. Y Pixy2 hace todo esto a 60 cuadros por segundo, para que su robot también pueda ser rápido. Pixy2 utiliza el tono y la saturación como su principal medio de detección de imágenes, en lugar del RGB normal. Esto significa que la iluminación o la exposición no afectarán la detección de Pixy2 de un elemento, lo cual es un problema frustrante con muchos sensores de imagen. .

 

 

Vamos  a ver un ejemplo publicado en instructables.com  de un interesante  robot seguidor que implementa  esta tecnologia  creado  por chaabani houssem 

Necesitaremos  al menos los  siguientes componentes:

  • 1 Arduino mega (o en su defecto un Arduno uno o Arduino nano … )
  • Pixy2  
  • 2 motores  paso  a paso
  • 2 ruedas y sus engranajes 
  • Un l293d
  • Una batería de  9v  (o   cualquiera que pueda reciclar 

 

Podemos  enseñar cualquier objeto a pixy a través de este enlace:

http: //cmucam.org/projects/cmucam5/wiki/Teach_Pixy …

Para controlar  los dos motores usaremos un famoso controlador , el CI   l293d

Este circuito integrado     de 16 pines ofrece los siguintes carasterciticas: 

  • Capacidad del canal: 600 mA de corriente de salida / canal.
  • Sistema de activación.
  • Pico de salida de corriente: 1,2 A / canal (no repetitivo).
  • Protección contra sobretemperatura.
  • Entrada lógica “0” a 1,5 V (alta inmunidad al ruido).

Picture of Build the Robot

Conectemos  los pines del L293D   a un  Arduino   de la siguiente manera :

  • Pin  1 al pin Arduino 2.
  • Pin 2 al pin 3 de Arduino.
  • Entrada 3 al pin 4 de Arduino.
  • Entrada 4 al pin Aduino 5.

Con estas conexiones ya  se puede probar el robot como verificar el avance, probar el giro a la izquierda o  el giro a la derecha y la parada.

Si todo va  bien ahora ya puede agregar pixy, pero para que  funcione el robot  antes tendrá que  programar Arduino  para  que  en función de la  salida de  Pixy2   de las  ordenes oportunas a los motores

Como  ejemplo de código  vamos a ver  una demostracion de como podemos  controlar lso dos motores usando  unicamente la informacion apoportada por Pixy2  

 

//definición de  puertos  que se usaran

int mg2 = 4;

int mg1 = 5;

int md1 = 3;

int md2 = 2;

int enag= 6;

//librerias  externas

#include <Wire.h>

#include <Pixy.h>

//llamada a las primitivas de Pixy

Pixy pixy;




//definición de puertos 

void setup()
{
pinMode(enag, OUTPUT);

pinMode(md1, OUTPUT);

pinMode(md2, OUTPUT);

pinMode(mg1, OUTPUT);

pinMode(mg2, OUTPUT);

//sacamos  por consola de Arduino mensajes de depuración

Serial.begin(9600);

Serial.print("Arrancando...\n");

pixy.init();

}







//comienzo del programa  principal

void loop()
{

static int i = 0;

int j;

uint16_t blocks;

char buf[32];


blocks = pixy.getBlocks();

if (blocks)

{
i++;

// Hacer esto cada 50 cuadros porque si se  supero colapsaria Arduino


if (i%50==0)

{
sprintf(buf, "Detected %d:\n", blocks);
Serial.print(buf);


//bucle for que recorre todos lox bloques enviados por Pixy
for (j=0;  j<blocks;    j++) 

{

sprintf(buf, " block %d: ", j);

Serial.print(buf);  //sacamos las salida por consola

pixy.blocks[j].print();

}


}

if((pixy.blocks[0].x>120)&&(pixy.blocks[0].x<190))
{
go();  //avanzar
}

if((pixy.blocks[0].x<120) && (pixy.blocks[0].x>10))
{

gauche();//girar a derecha

}

if(pixy.blocks[0].x>190)
{

droite();} //girar  a izda
}

else
{

o9if();//hacia atras

}
}






//giro a la derecha
void droite()
{
analogWrite(enag,210);
analogWrite(mg1,0);
analogWrite(mg2,0);
analogWrite(md1,255);
analogWrite(md2,0);
delay(30);
}




//giro a al izda

void gauche()
{
analogWrite(enag,210);
analogWrite(mg1,255);
analogWrite(mg2,0);
analogWrite(md1,0);
analogWrite(md2,0);
delay(30);
}




//hacia atras
void o9if()

{
analogWrite(mg1,0);
analogWrite(mg2,0);
analogWrite(md2,0);
analogWrite(md1,0);
delay(30);
}

//avanzar

void go ()
{
analogWrite(enag,210);
analogWrite(mg1,255);
analogWrite(mg2,0);

analogWrite(md1,255);
analogWrite(md2,0);
delay(30);
}

 

Y   ahora en un vídeo podemos ver el robot   funcionando:

 

En general,   Pixy2   es un excelente sistemas de visión inteligente introductorio  pues  podemos dar seguimiento de objetos a un  robot de manera mucho más fácil que usar un pc de una sola placa con OpenCV (más requisitos de menor potencia) pues se conecta fácilmente a un Arduino Nano o Uno (entre otros sistemas)  gracias  a los ejemplos de código que proporcionan que  ayudan a ponerlo en marcha rápidamente .Ademas es  muy fácil configurarlo utilizando las instrucciones en su sitio web pues hay ejemplos integrados en su software.

 

Interaccionar con FireBase desde Arduino


Como  podemos ver en este blog en numerosas  entradas que hablamos de dispositivos de IoT, es  relativamente sencillo construir nuestros  propios dispositivos de IoT con algunos sensores y microcontroladores  como Arduino, NodeMCU, Raspberry  Pi, etcétera , lo cual le permitirán automatizar su hogar apoyándose en estos dispositivos como por ejemplo usando el servicio de Cayenne .

De hecho ,como ejemplo de lo  sencillo  y económico  que puede ser  la construcción de dispositivos   IoT desde un punto de vista más empírico , lo ideal es usar un o NodeMCU ESP-12E para   acceder a Firebase  

 

Picture of Bill of Materials

 NodeMCU ESP-12E  es muy barato (unos 6€)   ,  y al tener  wifi incorporado para conectarse a internet,  ya tenemos los elementos suficientes  para conectarnos a  bases de datos avanzada  en l anube como puede ser Firevase y   gracias a un hardware tan eficiente  (y por supuesto los servicios cloud de Firebase).

Precisamente  FirebaseArduino (abstracción completa de la API REST de Firebase expuesta a través de las llamadas de C ++ de una manera amigable con el cableado.)   es una biblioteca muy útil usada   para simplificar la conexión a la base de datos Firebase desde cualquier cliente Arduino .Esta biblioteca  como podemos imaginar  se encarga de todo el análisis de Json y puede realizar transacciones en tipos C / Arduino puros.

En un post anterior “Primeros pasos con NodeMCU y Firebase”  ya vimos un sencillo ejemplo de como ambos componentes pueden funcionar, Veamos a  a continuación  que podemos hacer c muchas mas cosas con esta famosa librería

 

class FirebaseArduino

Esta es la clase principal para que los clientes de Arduino interactúen con Firebase. Como es habitual con arduino  para referenciarla  y poderla usar necesitamos  introducir  esta libreria con un include  al principio del programa , como por ejemplo

 #include <FirebaseArduino.h>”

Esta implementación está diseñada para seguir las mejores prácticas de Arduino y favorecer la simplicidad sobre todo lo demás. Para casos de uso más complicados y más control, podemos usar la clase Firebase en Firebase.h.

Esta libreria debe ser llamada primero con void begin ( const String y host , const String y auth = “” )  , lo cual inicializa el cliente con el host y las credenciales de base de fuego dados.

Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);  //intentamos conectarnos a la base de datos Firebase con nuestras credenciales

Los parámetros son :

  • host : es decir el  host de base de datos de base de datos de Fierbase , normalmente X.firebaseio.com.
  • auth : credenciales  para la db  que pueden ser  una palabra  secreta o token.

 

Lo más sencillo  precisamente para pasar las credenciales de Firebase   a esta clase es usando  variables que  definiremos al principio del programa:

  • #define FIREBASE_HOST “xxxxxxxxxxxxxxx.firebaseio.com”
  • #define FIREBASE_AUTH “xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx”

 

Veamos algunas funciones que podemos usar con esta clase:  pushInt,pushFloat, pushBool,pushString,push,setInt, setFloat,setBool,setString,set ,getInt, getFloat,getBool,getString,get,   las relacionadas con Firebaseobject(get,readevent)  .   asi como remove,stream, available,read ,success, failed,error

 

 

String pushInt ( const String & path , int value )

Anexa el valor entero al nodo en la ruta.Equivalente al POST de la API REST. Debe comprobar  success()  después de llamar. Devuelve la clave única del nuevo nodo hijo.

Los parámetros que usa:

  • path : La ruta del nodo padre.
  • value : valor entero que desea agregar al nodo.

 

String pushFloat(const String &path, float value)

Esta función anexa el valor flotante al nodo en la ruta.  Es equivalente al POST de la API REST. Debe comprobar   success()   después de llamar. Devuelve la clave única del nuevo nodo hijo.

Los parámetros que usa:

  • path : La ruta del nodo padre.
  • value : valor flotante que desea agregar al nodo.

String pushBool(const String &path, bool value)

Esta función anexa el valor booleano al nodo en la ruta.  Es equivalente al POST de la API REST. Debe comprobar el resultado de salida con  success()  después de llamar a a funcion . Devuelve la clave única del nuevo nodo hijo.

Los parámetros que usa:

  • path : La ruta del nodo padre.
  • value : valor Booleano que desea agregar al nodo.

String pushString(const String &pathconst String &value)

Esta función anexa el valor de cadena al nodo en la ruta.Es equivalente al POST de la API REST. Debe comprobar el resultado de salida con  success()  después de llamar a a funcion. Devuelve la clave única del nuevo nodo hijo.

Los parámetros que usa:

  • path : La ruta del nodo padre.
  • value : valor de la  cadena que desea agregar al nodo.

 

String push(const String &pathconst JsonVariant &value)

Esta función anexa los datos JSON al nodo en la ruta.Equivalente al POST de la API REST.   Devuelve la clave única del nuevo nodo hijo.

Parámetros

  • path : La ruta del nodo padre.
  • value : los datos JSON que desea agregar al nodo.

 

void setInt(const String &path, int value)

Escribe el valor entero en el nodo ubicado en la ruta equivalente al PUT de la API REST. Debe comprobar el resultado de salida con  success()  después de llamar a a función

Parámetros que usa

  • path : la ruta dentro de su base de datos al nodo que desea actualizar.
  • value : valor entero que desea escribir.

void setFloat(const String &path, float value

Escribe un  valor en coma flotante en el nodo ubicado en la ruta equivalente al PUT de la API REST.Debe comprobar el resultado de salida con  success()  después de llamar a a función

Parámetros necesarios:

  • path : la ruta dentro de su base de datos al nodo que desea actualizar.
  • value : el valor flotante que desea escribir.

void setBool(const String &path, bool value)

Escribe el valor booleano  en el nodo ubicado en la ruta equivalente al PUT de la API REST.  Debe comprobar el resultado de salida con  success()  después de llamar a a función  

Parámetros que usa

  • path : la ruta dentro de su base de datos al nodo que desea actualizar.
  • value :  valor booleano  que desea escribir.

void setString(const String &pathconst String &value)

Escribe el valor de la cadena en el nodo ubicado en la ruta equivalente a la PUT de la API REST. Debe comprobar el resultado de salida con  success()  después de llamar a a función

Parámetros que requiere:

  • path : la ruta dentro de su base de datos al nodo que desea actualizar.
  • value : valor de la cadena que desea escribir.

 

void set(const String &pathconst JsonVariant &value)

Escribe los datos JSON en el nodo ubicado en la ruta.  Equivalente al PUT de la API REST.  Debe comprobar el resultado de salida con  success()  después de llamar a a función

Parámetros necesarios:

  • path : la ruta dentro de su base de datos al nodo que desea actualizar.
  • value : datos JSON que desea escribir.

 

int getInt(const String &path)

Obtiene el valor entero ubicado en la ruta. Debe comprobar el resultado de salida con  success()  después de llamar a a función   Devuelve el valor entero ubicado en esa ruta. Solo será poblado si  success()   es verdadero. Requiere un único  parámetro path : la ruta al nodo que desea recuperar.

 

float getFloat(const String &path)

Obtiene el valor flotante ubicado en la ruta. Debe comprobar el resultado de salida con  success()  después de llamar a a función. Devuelve  un valor flotante ubicado en ese camino. Solo será poblado si un success()  ) es verdadero.

Requiere un único  parámetropath : la ruta al nodo que desea recuperar.

 

String getString(const String &path)

Obtiene el valor de cadena ubicado en la ruta.Debe comprobar el resultado de salida con  success()  después de llamar a a función.   Devuelve el valor de cadena ubicado en esa ruta. Solo será poblado si el   success()   es verdadero.

Requiere un único  parámetropath : la ruta al nodo que desea recuperar.

 

bool getBool(const String &path)

Obtiene el valor booleano ubicado en la ruta.Debe comprobar el resultado de salida con  success()  después de llamar a a función. Devuelve el  valor booleano ubicado en esa ruta. Solo será poblado si el éxito () es verdadero. Requiere un único  parámetro  path : la ruta al nodo que desea recuperar.

Es muy usado para  activar o desactivar un  nivel  lógico  en los pines binarios  en la placa ,por ejemplo para activar una salida a nivel alto  o bajo 

Ejemplo

      bool isLedOn = Firebase.getBool(“led”); // recuperamos el valor del objeto led de la sesión firebase

 

 

FirebaseObjectget(const String &path)

Obtiene el valor del objeto json ubicado en la ruta.Debe comprobar el resultado de salida con  success()  después de llamar a a función. Devuelve el valor FirebaseObject ubicado en esa ruta. Solo será poblado si el éxito () es verdadero.Requiere un único  parámetro path : la ruta al nodo que desea recuperar.

FirebaseObjectreadEvent()

Lee el siguiente evento en una stream ( secuencia).Esto solo tiene sentido una vez que se ha llamado a  stream() 

A la salida FirebaseObject tendrá [“type”] que describe el tipo de evento, [“path”] que describe la ruta efectuada y [“data”] que se actualizaron.

 

 

 

void remove(const String &path)

Elimina el nodo, y posiblemente el árbol completo, ubicado en la ruta.Debe comprobar el resultado de salida con  success()  después de llamar a a funcion.Requiere un único  parámetro path : la ruta al nodo que desea eliminar, incluidos todos sus hijos.

void stream(const String &path)

Inicia la transmisión de los cambios realizados en el nodo ubicado en la ruta, incluido cualquiera de sus elementos secundarios.

Debe comprobar el resultado de salida con  success()  después de llamar a a funcion Esto cambia el estado de este objeto. Una vez que se llama a esto, puede comenzar a monitorear available () y llamar a readEvent () para obtener nuevos eventos.

Requiere un único  parámetro path : la ruta dentro de su db al nodo que desea monitorear.

bool available()

Comprueba si hay nuevos eventos disponibles.Esto solo tiene sentido una vez que se ha llamado a  stream()  .Devuelve si un nuevo evento está listo.

bool success ( ) 

Devuelve   si el último comando fue exitoso.

bool failed ( ) 

Devuelve si el último comando falló.

 

const String &error()

 Devuelve el  mensaje de error del último comando si  failed() es verdadero.

 

 

 

 

 

class FirebaseObject

 

Representa el valor almacenado en Firebase , puede ser un valor singular (nodo de tipo leaf) o una estructura de árbol.

Las  funciones publicas  definidas para esa clase son las siguientes:

 

FirebaseObject ( const char * data ) 

Construir a partir de json.  Requiere un único  parámetro data : cadena formateada JSON.

 

bool getBool ( const String & path = “” ) const

Devuelve el valor como un booleano. .Requiere un único  parámetro optional : ruta en el objeto JSON.

 

int getInt ( const String & path = “” ) const

 Devuelve el  resultado como un entero.Requiere un único  parámetro optional : ruta en el objeto JSON.

 

float getFloat ( const String & path = “” ) const

Devuelve el valor como un flotador..Requiere un único  parámetro optional : ruta en el objeto JSON.

 

String getString ( const String & path = “” ) const

Devuelve el valor como una cadena.Requiere un único  parámetro optional : ruta en el objeto JSON.

 

JsonVariant getJsonVariant ( const String & path = “” ) const

Devuelve el valor como JsonVariant.Requiere un único  parámetro optional : ruta en el objeto JSON.

bool success ( ) const

Devuelve si hubo un error en la descodificación o el acceso al objeto JSON.bool 

 

failed ( ) const

Devuelve si  hubo un error en la descodificación o el acceso al objeto JSON.const 

 

String & error ( ) const

 Devuelve un mensaje de error si  failed()  es verdadero.

 

 

Mas informacion en  https://firebase-arduino.readthedocs.io/en/latest/

Primeros pasos con NodeMCU y Firebase


Hoy en día muchos dispositivos que usamos día a día se conectan a internet como la televisión, altavoces inteligentes, refrigeradores, Aires Acondicionados , etc …, dispositivos  que extienden sus funciones primarias  permitiéndoles  interactuar con otros dispositivos en internet siendo de  este modo  posible controlar estos  remotamente.

Como  podemos ver en este blog en numeras  entradas que hablamos de dispositivos de IoT, es  relativamente sencillo construir nuestros  propios dispositivos de IoT con algunos sensores y microcontroladores  como Arduino, NodeMCU, Raspberry  Pi, etcétera , lo cual le permitirán automatizar su hogar apoyándose en estos dispositivos como por ejemplo usando el servicio de Cayenne .

Como ejemplo de lo  sencillo  que puede ser  la construcción de dispositivos   IoT desde un punto de vista más empírico , vamos a ver como usando NodeMCU ESP-12E podemos  acceder a Firebase  para encender y apagar un  LED remoto. 

 

Picture of Bill of Materials

 NodeMCU ESP-12E  es muy barato (unos 6€)   ,  y al tener  wifi incorporado para conectarse a internet,  ya tenemos los elementos suficientes  para conectarnos a  bases de datos avanzadas  gracias a un hardware tan eficiente  y por supuesto los servicios de Firebase.

En esta ocasión aunque  NodeMCU ESP-12E cuenta con un puerto analogico  denominado A0 y 13 pines digitales numerados del D0 al D12, vamos a usar un puerto  interno al que  esta conectado el led interno denominado LED_BUILTIN y  de este modo no hace falta usar ningún componte externo

 

 

NodeMCU 

ESP12E   está 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 . las  versiones más antiguas  de esta placa no integraban conexión usb  ( para lo cual necesitaremos un USB FTDI   para programarlo o un  controlador Setup CH340g).

Las características principales son las siguientes:

  • Incorpora una MCU de 32-bit de bajo consumo (Tensilica L106)
  • Módulo WiFi de 2.4 GHz
  • RAM de unos 50 kB
  • 1 entrada analógica de 10-bit (ADC)
  • 17 pines de entrada y salida GPIO (de propósito general)

Dentro de los diferentes módulos del ESP8266,(ESP01,ESP03,ESP04,ESP05,…ESP12)  destaca el ESP-12 o el ESP-12E, módulo que utiliza usando NodeMCU ESP-12E para procesar la información.

Básicamente estos módulos incorpora la memoria Flash para almacenar los programas o sketchs y la antena estando internamente los pines del ESP8266 cableados hasta los pines del módulo ESP-12 siendo así más fácil su acceso. 

En todo caso,  esta familia de placas todas cuentan con 11 pines digitales de entrada / salida, todos los pines tienen interruptor / pwm / I2C / 1-wire    siendo su chip principal el  ESP8266 CH340G , siendo una gran diferencia con una placa Arduino es que sólo cuenta  con 1 entrada analógica (entrada máxima de 3,3 V)

 

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

Veamos con mas detalles  como conseguimos configurar entorno de desarrollo tanto de Arduino como Firebase para que ambos puedan interaccionar entre si

 

Configuracion IDE de Arduino

1. Vamos a usar Arduino IDE para escribir el código . Si no lo tiene instalado  puede descargar la última versión del IDE aquí.

2. Puesto que estamos usando NodeMCU que no es oficialmente compatible con IDE de Arduino, tenemos que agregar el archivo JSON del dispositivo. En el IDE de Arduino añadir esta URL en  :

Archivo  > Preferencias >Gestor de URL’s Adicionales de Tarjetas : http://arduino.esp8266.com/stable/package_esp8266com_index.json

4. Seleccione la placa  pulsando en 

Herramientas > Placa >NodeMCU 1.0

4. Para utilizar la base de datos bases avanzadas en NodeMCU puede descargar la biblioteca de bases avanzadas-arduino que abstrae la API REST de las bases avanzadas  por los qeu necesitamos descargar la librería de Firebase desde github aquí.

5. Incluir el archivo zip descargado (firebase-arduino-master.zip)  en el IDE de Arduino.

Programa > Incluir Libreria  > Añadir .zip >  Seleccionar archivo  .zip descargado en el paso anterior

6. También necesitará instalar la biblioteca de ArduinoJson que puede descargarse desde el IDE de Arduino así mismo. Tenga en cuenta que la versión de la biblioteca no debe 6.x.x  por lo que debe utilizar la última 5.x.x

Programa > Incluir Libreria  > Añadir biblioteca .zip >Buscar  ArduinoJson  por Benoit Blanchon

 

Creación de una base de datos Firebase

7. Cree un nuevo proyecto de Firebase  desde la consola (necesitará   tener  cuenta de google   para crear proyecto de FireBase) y diríjase hacia la sección de base de datos. Seleccione la base de datos en tiempo real de bases avanzadas (firebase real-time database).

8. Necesitamos copiarnos   el código secreto de la base de datos para la autenticación desde el Panel de configuración > Cuentas de servicio.>Mostrar

 
 
 
Una vez copiado la clave secreta  ( que colocaremos en el código de arduino en #define FIREBASE_AUTH “XXXXXXXXXXX”),  nos iremos a la opción de DataBase, y  Realtime Database

9.Ahora debemos agregar un nodo asociado  a la base de datos de firebase. Tenemos que seleccionar Realtime Database  y  pulsar el botón de +  añadiendo el campo led . POsteriormente como veremos mas  adelante,  el  valor de  este campo decidirá si activar o desactivar el LED.

 


El tipo de dato  es booleano  ya  que según lo  pongamos a true o false esto accionará el led en el  NodeMCU ESP-12E  

 

Debemos actualizar la configuración de uso compartido de datos del proyecto NodeMCU.

 
Usar la configuración predeterminada para compartir datos de Google Analytics for Firebase , lo cual tendrá las siguientes consecuencias :
  • Compartir tus datos de Analytics con todas las funciones de Firebase
  • Comparte tus datos de Analytics con nosotros para ayudarnos a mejorar nuestros productos y servicios.
  • Comparte tus datos de Analytics con nosotros para habilitar el servicio de asistencia técnica.
  • Comparte tus datos de Analytics con nosotros para habilitar las comparativas.
  • Comparte tus datos de Analytics con los especialistas en cuentas de Google.
  • Aceptar las condiciones entre responsables del tratamiento de datos. Es obligatorio marcar esta casilla si vas a compartir tus datos de Analytics para mejorar los productos y servicios de Google. Más información


Asimismo  tenemos dos opciones de modo de uso de la BBDD:en modo bloqueo  o en  modo de prueba para el caso que nos corresponde para probar la  funcionalidad
Por último apuntaremos la  instancia de firebase  de acceso  que luego  insertamos en el código de Arduino  en  #define FIREBASE_HOST “xxxxxxxxxx.firebaseio.com/”
 
 
 
 

Configurar el IDE de Arduino y base de datos de Firebase a trabajar juntos

Ahora que hemos realizado todos los procedimientos de configuración,  vamos a comenzar la codificación  del código que ejecutaremos en  nuestro módulo NodeMCU

Para simplificar, vamos a escribir un código sencillo para encender y apagar  el LED interno  del NodeMCU    aunque realmente seria exactamente el mismo código si decidimos usar alguno de los 17 pines de entrada y salida GPIO (de propósito general), pues simplemente tendremos que conectar un led entre masa  y uno de los pines , cambiando la constante LED_BUILTIN  por un valor entero del 0 al 16  correspondiente al  número del puerto al  que hayamos conectado el led.

 

El código empleado es el siguiente:

 

         // By CRN   mayo-2019

#include <ArduinoJson.h>

#include <ESP8266WiFi.h>  

#include <FirebaseArduino.h>

// Firebase

#define FIREBASE_HOST “xxxxxxxxxxxxxxx.firebaseio.com”

#define FIREBASE_AUTH “xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx”

// Wifi

#define WIFI_SSID “wwwwwwwwwwwww”

#define WIFI_PASSWORD “pppppppppppppppppppp”


void setup()

{

Serial.begin(115200); //inicializa el puerto de salida a 115200

pinMode(LED_BUILTIN, OUTPUT);   //configurar el puerto interno como salida 
digitalWrite(LED_BUILTIN, HIGH);   //enciende el led interno

// conectando a la red wifi.

WiFi.begin(WIFI_SSID, WIFI_PASSWORD);  //conexión a la red wifi

delay(2000);   //espera la  conexión

Serial.println(“Conectando…”); 

while (WiFi.status() != WL_CONNECTED)  //bucle para esperar la conexión

{

Serial.println(“.”);  //mientras pintamos un puntito que sacamos por consola

delay(3000);

}

Serial.println(“Conectado”);   // ya hemos conseguido conectar por wifi

Serial.println(WiFi.localIP());   // pintamos la ip asignada 

 

// Configurando conexión a firebase

Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);  //intentamos conectarnos a la base de datos Firebase con nuestras credenciales

//fin configuración

}

 

void loop()  //bucle principal

{

//leer estado en Firebase el valor del registro led  y observar que el valor recuperado al ser booleano se asigna directamente a la variables es booleana

bool isLedOn = Firebase.getBool(“led”); // recuperamos el valor del objeto led de la sesión firebase

 

if (isLedOn)   // condicional  para decidir en función del valor recuperado de firebase si se enciende o no el led

{

digitalWrite(LED_BUILTIN, HIGH);  //encendemos el led 
Serial.println(“LED ON “); 
delay(2000);

}

else

{

digitalWrite(LED_BUILTIN, LOW);    //apagamos el  led 
Serial.println(“LED OFF”);
delay(2000);

}

 

}

 

 

En  el código anterior     en primer lugar se incluyen las librerías  necesarias  para hacer  toda gestión de conexión con Fireabase, así como las comunes de arduino para gestionar json  y las propias del ESP8266 

  • #include <ArduinoJson.h>
  • #include <ESP8266WiFi.h>  
  • #include <FirebaseArduino.h>

 

Después  se definen cuatro variables de tipo constante para almacenar: 

  • #define WIFI_SSID “Nombre de Router Wifi” Cambiaremos en esa a línea  la red del router WiFi al que nos vayamos a conectar
  • #define WIFI_PASSWORD “Contraseña del Router” Cambiaremos en esa  línea contraseña de su router WiFi 
  • #define FIREBASE_HOST “xxxxxxxxx.firebaseio.com” Insertaremos quie elnombre de la instancia de Firebase asociada a su usuario, para ello haremos clic en base de datos ahora se verá el nombre de host .Pulsamos Mostrar en imagen.Copiar el nombre sin el” http://”  en el código de Arduino 
  • #define FIREBASE_AUTH “xxxxxxxxxxxxxxxxxxxxxxxxxxx”Insertaremos la palabra secreta de Forebase ,para ello iremos  a Configuración > configuración del proyecto > cuentas de servicio > base de datos secreta .Copiar y pegar la palabra secreta  en el código 

Ahora   toca inicializa el puerto de salida a 115200,  ,configurar el puerto interno como salida  enciende el led interno

Asimismo es necesario  conectar la red wifi, que hacemos con un bucle para esperar la conexión  mientras pintamos un puntito que sacamos por consola

La última parte del bloque de configuración es la  conexión a firebase donde intentamos conectarnos a la base de datos Firebase con nuestras credenciales

LLegamos  ahora al cuerpo  principal (loop )    donde leeremos el  estado en Firebase el valor del objeto  led   y actuaremos   según su valor en el estado lógico de  un pin del GPIO   donde es  interesante  observar que el valor recuperado al ser booleano se asigna directamente a la variables que también es booleana.

La magia  se hace   justo con   esta línea “bool isLedOn = Firebase.getBool(“led”); “  donde  recuperamos el valor del objeto led de la sesión firebase

Finalmente mediante  condicional   decidiremos  en función del valor recuperado de firebase si se enciende o no el led

 

 
 

 

Este código ,  donde  incluiremos nuestras  credenciales del Firebase  y de nuestra red wifi,    lo subiremos   desde el IDE de Arduino  Programas > Subir y en seguida  deberíamos ver el led interno luciendo o apagado en función del estado del objeto led en su base de datos Febase

 

Ahora intente cambiar el valor del objeto led en  la base de datos a verdadero y falso. El led debería  encenderse  o apagarse en función del valor que hayamos seleccionado en el objeto led en Firebase .

Por supuesto   puede ampliar este proyecto si decidimos cualquiera de  los 17 pines de entrada y salida GPIO (de propósito general)  asi  como  manejar  estos    mediante la creación de una aplicación web   o móvil   que accionará los  puertos en lugar de cambiar manualmente el valor de la base de datos Firebase.

Además en este articulo hemos hablado de leer un objeto de Firebase desde  un  NodeMCU   pero también   es posible  enviar datos desde la placa para salvarlos en Firebase  y luego leer estos mediante una aplicación móvil o web, Sin duda el limite esta en nuestra imaginación …

 

 

Controlando placas de IoT desde javascript


Node.js framework  fue  creado por Bocoup para controlar placas de desarrollo en una configuración de host-cliente   aunque   realmente su uso mayoritario sea como plataforma web   siendo    Johnny-Five la plataforma open  source de Robótica e IoT de JavaScript 

En realidad existen diferentes  plataformas donde se puede ejecutar el programa Johnny-Five :

  • En un entorno Linux a bordo: beagleBone Black,Chip,Intel Galileo gen 1,Intel Galileo Gen 2,Intel Edison Arduino,Intel Edison Mini, SparkFun Edison GPIO Block,SparkFun Arduino Block, Intel Joule 570x (Carrier Board),Linino One,pcDuino3 Dev Board,Raspberry Pi 3 Model B, Raspberry Pi 2 Model B. Raspberry Pi Zero,Raspberry Pi Model A Plus,Raspberry Pi Model B Plus, Raspberry Pi Model B Rev 1, Raspberry Pi Model B Rev 2, Tessel 2
  • En una máquina host conectada (a través de Serial USB o Ethernet) a un cliente.: Arduino Uno,SparkFun RedBoard, On a host machine communicating over Bluetooth to the client. Arduino Uno,Arduino Leonardo, Arduino Mega, Arduino Fio,Arduino Micro,Arduino Mini,arduino Nano,Arduino pro Mini,Boatduino,chipKit uno32,Spider robot Controller,DfRobot Romeo,Teensy 3,
  • En una máquina host que se comunica por wifi al cliente: Electric Imp April, pinoccio Scout, Particle Core ( Spark Core) ,Particle Photon, Sparkfun Photon RedBoard
  • En una máquina host que se comunica a través de Bluetooth al cliente :Blend Micro v1.0,LightBlue bean,

Johnny-Five como vemos hacer un énfasis especial en la robótica, pero tambien puede hacer muchas cosas diferentes con el software.De hecho ha existido durante hacer  más tiempo que la mayoría de los marcos de JavaScript para hardware . Ademas iene una API clara  y “fresca” ,ambas cosas ideales para los principiantes de hardware.

Lanzado porBocoup en 2012, Johnny-Five esta mantenido por una comunidad de desarrolladores de software apasionados e ingenieros de hardware. De hecho más de 75 desarrolladores han hecho contribuciones para construir un ecosistema robusto, extensible y muy versatil.

 

Hola Mundo! 

A los microcontroladores y las plataformas SoC nos gusta decir “Hola mundo” con un simple LED parpadeante, así  que veamos en primer lugar un ejemplo como lo hariamos  usando el Ide clásico  de Arduino

Como vemos en la imagen ,conectaremos un led entre el pin 13  y masa , respetando la polaridad (el ánodo al pin13 y el cátodo o pin corto a masa )

Para  hacer destellear el citado led,  estos son los pasos básicos  que tenemos que seguir en nuestro sketch  programandolo desde el IDE de Arduino:

  1. Configurar el pin 13 (con LED incorporado) como una SALIDA
  2. Establecer el pin 13 ALTO para encender el LED
  3. Esperamos 500 ms (medio segundo)
  4. Establecer el pin 13 BAJO para apagar el LED

Y este es el código completo para ejecutar desde el Ide de Arduino:

void setup() {
pinMode(13, OUTPUT);    
}
void loop() {
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);  
delay(500);
}

Y ahora vamos a ver el mismo ejemplo , pero ejecutandolo en Javascript por medio de node-js,

Desgraciadamente  si usamos un Arduino o alguno de sus variantes (Arduino Uno,SparkFun RedBoard, On a host machine communicating over Bluetooth to the client. Arduino Uno,Arduino Leonardo, Arduino Mega, Arduino Fio,Arduino Micro,Arduino Mini,arduino Nano,Arduino pro Mini,Boatduino,chipKit uno32,Spider robot Controller,DfRobot Romeo,Teensy 3,)   necesitaremos que el programa JavaScript se ejecute en una máquina host que ejecute Node.js. de modo que el programa transmitirá instrucciones básicas de E / S a la placa a través de una interfaz  serie USB , que actuara como un cliente ligero .

El método host-cliente implica la comunicación a través de una API común entre el host y el cliente. El marco Node.js usado con Arduino y placas similares , Johnny-Five, se comunica (de forma predeterminada) con las placas  utilizando un protocolo llamado Firmata, protocolo que permite que los hosts (computadoras) y los clientes (microcontroladores) intercambien mensajes de ida y vuelta en un formato basado en mensajes MIDI. El protocolo Firmata especifica cómo deben ser esos mensajes de comando y datos. La implementación de Firmata de Arduino proporciona el firmware real que puede poner en su tablero para hacer que “hable” Firmata. Toma la forma de un boceto de Arduino que sube al tablero.

Firmata es lo suficientemente popular como para que los bocetos de Firmata que necesita vengan empaquetados con el IDE de Arduino asi que bastara con subir este a Arduino una única vez  ya que  el código javascript  correra en el host usando node.js.

Puede seguir estos pasos para cargar el interfaz correcto de Firmata en su Arduino  para que se pueda utilizar como cliente en una configuración de host-cliente:

Resumidamente estos son los pasos previos para ejecutar el   mismo  ejemplo del led parpadeante  que hemos visto pero   en  javascript en una placa Arduino;

  • En primer lugar  conectar  su Arduino  mediante USB a  su ordenador
  • Lanzar el IDE de Arduino.
  • Asegurarse que esta configurada la version de su placa,  así como el puerto COM  virtual al que esta conectado
  • Acceda al menú Archivo> Ejemplos> Firmata
  • Seleccione StandardFirmataPlus de la lista y despliegue este sw sobre su Arduino

  • Ahora Instale Node.js   en su pc . Funciona  con ultima version 11.3.0  de  64 bit que incluye  npm 6.4 (no olvidar de chequear que se instalen  otros componentes )Este es el link de descarga https://nodejs.org/en/download/ 
  • En la instalación de Node.js, repetimo  no debemos olvidar de chequear que se instalen  otros componentes  pues  con ellos se   instalara automáticamente
    • Python 2.7.3 (http://www.python.org/getit/releases/2.7.3/)
    • Visual Studio Express 2010 de 32 bits (con  las dependencias de C ++)
    • El comando npm
    • Alternativamente si dispusiésemos de npm podríamos instalar ambos entornos  con  npm --add-python-to-path install --global --production windows-build-tools
  • Este pasos anterior ( instalacion de componentes ) es  innecesario  si chequeamos en la instalación  de node.js  pues se instalaran  esos componentes  automáticamente
  • Ahora instalar node-gyp  medianete  el comando  npm install -g node-gyp (esto instalará node-gyp globalmente)                          
  • Ya puede  crear su primer proyecto Johnny-Five, por lo que en primer lugar cree un directorio para él e instale el paquete framework npm, como se muestra en la siguiente lista:
    • < mkdir hello-world
    • < cd hello-world
    • < npm install johnny-five
  • Ejecute  el comando “npm install johnny-five” desde la carpeta del proyecto
  • Ya por fin podemos crear el fichero javascript  con su editor de texto  que contendrá el código en javascript  . 

Realmente estos son los pasos  que tenemos que seguir:

  1. Requerir el paquete johnny-five
  2. Inicializar un nuevo objeto Board que represente a su placa .
  3. Esperar a que el tablero dispare el evento listo
  4. Crear una instancia de un objeto LED en el pin 13 (el pin LED incorporado de Uno)
  5.  Hacer que el LED parpadee cada 500 ms

Este es el código en js :


const five = require(‘johnny-five’);
const board = new five.Board();
board.on(‘ready’, () => {
 const led = new five.Led(13);
   led.blink(500);
});


Guarde el archivo como hello-world.js  y  conecte su Arduino  a un puerto USB en su ordenador  si aún no está conectado.

En una terminal  de windows  vaya al directorio del proyecto y ejecute este comando:

<node hello-world.js


Verá una salida como la siguiente en su terminal ejecutando hello-world.js en una terminal

 

 

Si el LED incorporado parpadea ,!enhorabuena !  !acaba de controlar una placa Arduino con JavaScript!  ¿a que es realmente sencillo?.

Aunque en el caso de la familia Arduino tiene la innegable penalización de necesitar un host para operar , la ventajas de este  modelo son evidentes pues no tenemos que estar constantemente compilando  y  subiendo el sketch con el ide de Arduino ya que el programa corre en host . Ademas  podemos usar un simple editor de texto para cambiar el código en javascript fácilmente

Asimismo el lenguaje javascript ha ido evolucionando hasta un ritmo que no podemos imaginar   incluyendo muchas características que no son soportadas de forma directa desde Arduino

Por ultimo mencionar la autentica potabilidad del código , pues el código que hemos visto en el ejemplo podremos usarlos  en múltiples plataformas  tan diferentes como Raspberry pi, Intel Edison , etc usando siempre el mismo código fuente aun siendo soportado por placas muy diferentes ¿ a que es interesante?

 

 

Placas soportadas

Johnny-Five ha sido probado con una variedad de tableros compatibles con Arduino . 

Para los proyectos que no están basados ​​en Arduino, los complementos de IO específicos de la plataforma están disponibles. Los complementos IO permiten que el código Johnny-Five se comunique con cualquier hardware en cualquier idioma que la plataforma hable.

Como comentábamos   existen diferentes  formas de   ejecutar  el programa Johnny-Five  segun la placa:

  • En un entorno Linux a bordo: beagleBone Black,Chip,Intel Galileo gen 1,Intel Galileo Gen 2,Intel Edison Arduino,Intel Edison Mini, SparkFun Edison GPIO Block,SparkFun Arduino Block, Intel Joule 570x (Carrier Board),Linino One,pcDuino3 Dev Board,Raspberry Pi 3 Model B, Raspberry Pi 2 Model B. Raspberry Pi Zero,Raspberry Pi Model A Plus,Raspberry Pi Model B Plus, Raspberry Pi Model B Rev 1, Raspberry Pi Model B Rev 2, Tessel 2) ,   Es  facil adivinar qeu este es el mabiente ideal   pues dentro de la placa se oprtan tanto el host como el cliente  por lo qeu no ncesitamos conectarnos con otro dispositivo
  • En una máquina host conectada (a través de Serial USB o Ethernet) a un cliente.: Arduino Uno,SparkFun RedBoard, On a host machine communicating over Bluetooth to the client. Arduino Uno,Arduino Leonardo, Arduino Mega, Arduino Fio,Arduino Micro,Arduino Mini,arduino Nano,Arduino pro Mini,Boatduino,chipKit uno32,Spider robot Controller,DfRobot Romeo,Teensy 3,
  • En una máquina host que se comunica por wifi al cliente.: Electric Imp April, pinoccio Scout, Particle Core ( Spark Core) ,Particle Photon, Sparkfun Photon RedBoard
  • En una máquina host que se comunica a través de Bluetooth al cliente :Blend Micro v1.0,LightBlue bean,

Veamos  ahora cada  caso en concreto;

Arduino Uno 

Ambiente 

  • Firmware / Runtime: : StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

SparkFun RedBoard 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

ping

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

 

Arduino leonardo 

Ambiente 

  • Firmware / Runtime:  StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

Arduino Mega 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
ping

Arduino Fio 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

Arduino Micro 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire no
Paso a paso no
Serial / UART
Dac no
Ping

Arduino Mini 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire no
Paso a paso no
Serial / UART
Dac no
Ping

Arduino Nano 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Ping

Arduino Pro Mini 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire no
Paso a paso no
Serial / UART
Dac no
ping

BotBoarduino 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere amarre.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
ping

chipkit uno32 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire
Paso a paso
Serial / UART
Dac no
ping

Spider Robot Controller 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere  tetehering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
ping

DFRobot Romeo 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere amarre.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

Teensy 3 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere amarre.
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART no
Dac no
ping

BeagleBone Black 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

CHIP 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo no
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Ping no

Blend Micro v1.0 

Ambiente 

  • Complemento IO: BlendMicro-IO ( instrucciones adicionales )
  • Firmware / Runtime: BLEFirmata
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a través de Bluetooth a la placa, que actúa como un cliente ligero .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Ping no

 Electric Imp  April 

Ambiente 

Plataforma específica 

  • Requiere una conexión WiFi conectada a Internet y está sujeto a la limitación de la tasa de solicitud por parte del servidor de Electric Imp API.
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C no
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Intel Galileo Gen 1 

Ambiente 

Plataforma específica 

  • Las compilaciones que no son IoTKit ya no son compatibles.
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Intel Galileo Gen 2 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Silbido no

Intel Edison Arduino 

Ambiente 

Plataforma específica 

  • El hardware es capaz de soportar solo 4 salidas PWM. Como resultado, los enlaces nativos no admiten PWM en los pines 10 y 11.
  • Aunque Galileo-io / Edison-io / Joule-io todavía no admite comunicaciones en serie, puede enlazar a / dev / ttyFMD1 en la placa Edison Arduino usando el módulo serialport .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Silbido no

Intel Edison Mini 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Silbido no

SparkFun Edison GPIO Block 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

SparkFun Arduino Block

Ambiente 

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART no
Dac no
ping no

Intel Joule 570x (Carrier Board) 

Ambiente 

Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

LightBlue Bean

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Linino uno 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

pcDuino3 Dev Board 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo no
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Pinoccio Scout 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C no
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Raspberry Pi 3 Modelo B 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no

Raspberry Pi 2 Modelo B 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Silbido no

Raspberry Pi Zero 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no

Raspberry Pi Model A Plus 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no

Frambuesa Pi Modelo B Plus 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Silbido no

Raspberry Pi Modelo B Rev 1 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Ping no

Raspberry Pi Modelo B Rev 2 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no


Particle Core (Spark Core)

Ambiente 

Plataforma específica 

  • Los temporizadores se comparten en grupos: Temporizador 2: A0 , A1 , Temporizador 3: A4 , A5 , A6 , A7 , Temporizador 4: D0 , D1
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping


Particle Photon

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
ping no
Silbido

Sparkfun Photon RedBoard 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping

Tessel 2 

Ambiente 

Plataforma específica 

  • El soporte de servo se proporciona a través de componentes I2C (por ejemplo, PCA9685 )
  • DAC está limitado a Puerto B, Pin 7
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac
ping no

Mas información en  http://johnny-five.io/platform-support/

Como supeditar el encendido de una TV al de un descodificador,Blueray u otros dispositivos ( parte 1)


Puede parecer  extraño , pero cada vez tenemos dispositivos  conectados a nuestro TV  que  suelen ser  el origen de  vídeo  por defecto  como pueden ser dispositivos Android   TV, reproductores blueray, etc.  o   sobre todo descodificadores de TV  

En este sentido  podría ser interesante  supeditar  automáticamente el  encendido  de la TV  al de la fuente de vídeo ( normalmente un descodificador de TV) , para lo cual   vamos a intentar implementar una solución que lo automatice

Pensando en una solución , una aproximación  podría ser basarse en  las señales de infrarrojos entre el TV  y la fuente de vídeo ,pero esto conlleva mucha complejidad pues en el mercado existe una infinidad de marcas  y modelos de  dispositivos diferentes , que haría  muy difícil  contemplar un método practico para resolverlo , así  que debemos pensar en otra solución …

Pensando  en la variación del consumo de un dispositivo  ,una solución puede pasar por detectar  esa variación  de consumo   y con ello  sabremos si debemos o no activar la TV , para lo cual nos puede basta el sensor   ACS712    , un  Modulo Sensor de corriente para Arduino con un rango de medida máximo de 5 Amperios ( suficiente para la mayoría de los dispositivos  que conectaremos al TV) 

Este sensor esta basado  en efecto Hall   que detecta el campo magnético que se produce por inducción de la corriente que circula por la línea que se está midiendo , por lo que no hay disipación de potencia a través de este como ocurriría  con soluciones clásicas  que  usarían una resistencia de valor bajo  en serie  para medir la corriente que circula por ella  y el circuito (pero  con el consiguiente disipación  de potencia en esta )

Concretamente  en las pruebas  junto a un Arduino UNO , usaremos el  chip sensor  ACS712ELC-05A  alimentado  con  5V a través del propio Arduino ( lleva un led a bordo como e indicador de energia) 


El modulo puede medir los positivos y negativos de máximo 5 amperios, correspondiente a la salida analógica 185mV / A   entregando una salida de voltaje proporcional a la corriente, Dependiendo la aplicación podemos usar otros módulos  como el ACS712-05A, ACS712-20A o el ACS712-30A, para rangos de 5, 20 o 30 amperios respectivamente

El  ACS712  podemos encontrarlo en módulos, los cuales nos facilitan sus conexiones, Este modulo  trae una bornera para conectar la línea que queremos medir ( el descodificador)  y 3 pines por el otro extremo: dos para conectar la alimentación y un pin para la salida analógica.

Para las conexiones en el módulo debe  guiarse por los nombres de los pines, en algunos modelos vienen en diferente orden pero marcados en la serigrafia como Gnd,Out  y Vcc . En nuestro caso Vcc ira al pin +5V de Arduino, GND al GND del Arduino y  Out lo conectaremos al pin analógico de Arduino  A0 

En los terminales opuestos del  ACS712  conectaremos  en serie la alimentación del Descodificador ,o dispositivo que  vaya a controlar  la TV . Para medir la corriente se  debe conectar en serie con el dispositivo o carga, nunca conectar en paralelo a la fuente de voltaje.

 

 

El rango de corriente que podemos medir y sensibilidad varían dependiendo del modelo del integrado, existen tres modelos los cuales detallamos a continuación:

Modelo Rango Sensibilidad
ACS712ELCTR-05B-T -5 a 5 A 185 mV/A
ACS712ELCTR-20A-T -20 a 20 A 100 mV/A
ACS712ELCTR-30A-T -30 a 30 A 66 mV/A

El sensor  ACS712  nos entrega un valor de 2.5 voltios para una corriente de 0A y a partir de allí incrementa proporcionalmente de acuerdo a la sensibilidad, teniendo una relación lineal entre la salida de voltaje del sensor y la corriente. Dicha relación es una línea recta en una gráfica Voltaje vs Corriente donde la pendiente es la sensibilidad y la intersección en el eje Y es 2.5 voltios. La ecuación de la recta seria la siguiente

ecuacion V vs I en ACS712

Donde la pendiente es m y equivale a la Sensibilidad

Despejando tendremos la ecuación para hallar la corriente a partir de la lectura del sensor:

ecuacion para la corriente ACS712

 

Para realizar la lectura de corriente simplemente se necesita leer la entrada analógica y con la formula antes expuesta obtener la corriente.

A continuación se muestra el código para un realizar la lectura de corriente:

float Sensibilidad=0.185; 
//sensibilidad en Voltios
/Amperio para sensor de 5A void setup()
{    Serial.begin(9600); }
void loop()
{    float voltajeSensor= analogRead(A0)*(5.0 / 1023.0);
//lectura del sensor   
 float I=(voltajeSensor-2.5)/Sensibilidad;
//Ecuación  para obtener la corriente
 Serial.print("Corriente: ");
 Serial.println(I,3);
 delay(200);     
}

En nuestro caso estamos trabajando con un sensor de 5A ( ACS712  )  por eso usamos el valor de sensibilidad de 0.185V/A que es el equivalente 185mV/A que nos da el fabricante, si están trabajando con el sensor de 20A, reemplazar el valor de la sensibilidad por 0.100 V/A.

 

Existen varios tipos de filtros, que dependiendo de la complejidad pueden consumir recursos en la programación de nuestro Arduino, en nuestro caso  simplemente usaremos la media aritmética de varias lecturas consecutivas, implementar el promedio de las lecturas en Arduino es sencillo y fácil de entender, simplemente hay que sumar las lecturas y dividirlas en un  número de muestras suficiente.
La cantidad de muestras para calcular el promedio depende del nivel de ruido que tengan .En nuestro ejemplo con 200.000 son un valor lo suficiente bueno  para que nos de un resultado bastante preciso

El programa mejorado  seria el siguiente:

float Sensibilidad=0.185; 
//sensibilidad en Voltios/Amperio para sensor de 5A void setup()
{    Serial.begin(9600);
}
void loop()
{
 float I=get_corriente(200000);//obtenemos la corriente promedio de 200.00 muestras
 Serial.print("Corriente: ");
 Serial.println(I,3);
 delay(100);     
}
float get_corriente(int n_muestras)
{
 float voltajeSensor;
 float corriente=0;
 for(int i=0;i<n_muestras;i++)
 {    voltajeSensor = analogRead(A0) * (5.0 / 1023.0);
////lectura del sensor   
 corriente=corriente+(voltajeSensor-2.5)/Sensibilidad;
//Ecuación  para obtener la corriente  
}
 corriente=corriente/n_muestras;
 return(corriente);
}

 

 

Como  el error que obtenemos  aun con el numero tan elevado de muestras es grande, debemos de recalibrar y hallar los valores reales puesto que los valores que nos da el fabricante no son exactos.

Recordemos la ecuación que usamos para hallar la corriente:

ecuacion para la corriente ACS712

En esta ecuación solo tenemos dos constantes: los 2.5 que es el voltaje del sensor cuando la corriente es 0V y la sensibilidad, que equivale a la pendiente de la recta Voltaje Vs Corriente; tenemos que calcular los valores reales de estas dos constantes. Al ser una recta, basta con obtener dos puntos y con estos podemos calcular constantes.

Para esto necesitamos un polimetro en la escala de Intensidad   ( debe ser de buena precisión, ya que este será la herramienta para calibrar)  . El polimetro, el ACS712  y la carga deben de conectarse en serie. 

Después de conectar el aparato de medida y el  sensor, debemos de tomar lecturas de voltaje del sensor, esto se hace con el siguiente programa.

void setup() 
{  
 Serial.begin(9600);
} void loop()
{  
float voltajeSensor =get_voltage(10000);
//obtenemos voltaje del sensor(10000 muestras)
 Serial.print("Voltaje del sensor: ");
 Serial.println(voltajeSensor ,3);
     }
float get_voltage(int n_muestras)
{  float voltage=0;  
 for(int i=0;i<n_muestras;i++)
 {    
voltage =voltage+analogRead(A0) * (5.0 / 1023.0);    
 }  voltage=voltage/n_muestras;  return(voltage);
}

El primer punto que debemos medir es para una corriente de 0 amperios: esta es una de las constantes, en nuestro caso 2.527, que corresponde al punto P1(2.527,0)

Para hallar la segunda constante necesitamos una segunda medida, se recomienda que no sea cercano al valor de la primera medida, en nuestro caso usaremos una carga cuya corriente es superior a 1 amperio.Como se observa en el sensor  un voltaje de 2.687, y en el amperímetro medimos 1.155A, este sería nuestro segundo punto P2(2.687,1.155) ,

Para calcular la sensibilidad simplemente calculamos la pendiente.

Teniendo estos dos valores la ecuación para calcular la corriente es:

ecuacion de sensibilidad

Donde sensibilidad=0.139 V/A

Con estos nuevos valores debemos trabajar los ejemplos anteriores

Tener en cuenta que cada sensor tiene su propia característica

Otra forma puede ser en tomar varios puntos y al final aplicar regresión y hallara la ecuación de la recta.

 

 

Con estos dos valores  contemplados en el programa, toca  ejecutar el programa  y observar la salida  del monitor serie    en función de cuando activamos el descodificador  y lo apaguemos . En nuestro caso , las lecturas son inferiores a 0.207 cuando esta en stand-bye    , superando este valor  cuando esta encendido

Estos valores   son precisamente  los que podemos usar como umbral  para activar o desactivar un pin de salida  por ejemplo para activar/desactivar  un rele que  a su vez alimente  al TV

Con todos estos cambios , el código final del programa que detecta  si se enciende o no el descodificador es el siguiente:

 

 

const int sensorPin = A0; // seleccionar la entrada para el sensor
int sensorValue; // variable que almacena el valor raw (0 a 1023)
float value;
float Sensibilidad=0.185; //sensibilidad en Voltios/Amperio para sensor de 5A

void setup() {

// Iniciamos comunicacion serie
Serial.begin(9600);
}


void loop() {

float I=get_corriente(200000);//obtenemos la corriente promedio de 500 muestras

if (I<0.207)
{Serial.print(“Apagado: “);  // aqui podemos desactivar un pin binario de salida  para deactivar  un rel
Serial.println(I,3);
delay(100);
}
else
{Serial.print(“Encendido: “);// aquí podemos activar un pin binario de salida  para activar  un relé
Serial.println(I,3);
delay(100);
}


}


float get_corriente(int n_muestras)
{
float voltajeSensor;
float corriente=0;
for(int i=0;i
{
voltajeSensor = analogRead(sensorPin) * (5.0 / 1023.0);////lectura del sensor
corriente=corriente+(voltajeSensor-2.5)/Sensibilidad; //Ecuación para obtener la corriente
}
corriente=corriente/n_muestras;
return(corriente);
}

// cambio de escala entre floats
float fmap(float x, float in_min, float in_max, float out_min, float out_max)
{
return (x – in_min) * (out_max – out_min) / (in_max – in_min) + out_min;
}

 

 

 

Como emular un mando con Arduino


A veces   puede ser  interesante emular del comportamiento  de un mando infrarrojo  con el fin de automatizar procesos  que de otra manera  seria mucho mas complejo . Como ejemplo típico de dispositivos que podemos controlar vía infrarojos, hablamos de  reproductores de cámaras, televisores, DVD, VCR, lectores de blueray, equipos de sonidos, descodificadores  y  un largo etcétera 

Aunque pueda parecer descabellado repetir las mismas señales desde una placa Arduino , lo cierto  es que no es descabellado querer emular este comportamiento , porque  podemos  hacer cosas  que seria muy dificultoso  sin la ayuda del procesamiento de señales de infrarojos como por ejemplo  encender automáticamente  el Aire Acondicionado  cuando la temperatura  suba un determinado valor , o se desconecte a una determinadas horas ,  se apague  cuando no haya movimiento  y un largo  etcétera 

Como paso previo  debemos analizar las señales infrarrojas emitidas por el mando usado para el control de ese dispositivo  por lo que deberemos averiguar  cómo recibir los códigos y luego una vez conocidas intentar ver como transmitirlas.

Para nuestra tarea necesitamos :

  • 1 x Arduino (cualquier versión sirve  siempre que pueda procesar señales  “PWM” )
  • 1 x LED IR   (usted puede conseguir éstos de cualquier TV remoto)
  • 1 x receptor IR (usted puede conseguir éstos de cualquier TV remoto)

 

Preparación para recibir señales

Para el análisis  de las señales infrarrojas  producidas por el mando del  dispositivo a controlar en primer lugar necesitaremos  un receptor de infrarrojos ,   que bien  puede proceder de   uno reciclado de cualquier viejo proyecto que ya no utilice  o bien adquirido específicamente  en el comercio

Una interesante opción son los famosos kits para Arduino que integran por unos 4€  todo los necesario para habilitar la comunicación en los dos sentidos  gracias a un led IRDa, un receptor IRDA  y un mando para pruebas.

Kit Modulo Receptor Infrarojo IR Protocolo Nec con Mando a Distancia Arduino

Como sugerencia  para captar el código correcto , deberíamos poner el receptor IR y el mando en una caja opaca  o algo que sea oscuro  lo cual  asegurará que habrá el mínimo de interferencias y  podremos tener el código más claro para que no tengamos que programar  nuestro  Arduino  muchas veces para una simple tarea. También, asegúrese de que estar alejados de personas viendo la televisión.

Realmente el circuito es bastante sencillo pues únicamente tendremos que alimentar con 5v DC  ( que podemos tomar directamente desde nuestro Arduino )   y luego conectar la salida del receptor digital al pin digital A2 de Arduino

 

Picture of Preparing to Receive Signals

Una vez montado el simple circuito del receptor de infrarrojo es hora de  subir el programa a su Arduino  para  poder descodificar la señal infrarroja .

El siguiente programa utiliza el Arduino y un PNA4602 para descifrar IR recibido lo cual se  puede utilizar para hacer un receptor de infrarrojos. (buscando un código en particular) o transmisor (pulsando un LED IR a ~ 38KHz para el duraciones detectadas,

Este código es de dominio público (visite http://www.ladyada.net y adafruit.com), pero en esta ocasión se ha traducido para que sea mas legible y fácil de entender:


// Necesitamos usar los métodos de lectura de pin ‘raw’  porque el tiempo es muy importante aquí y el digitalRead () es un  procedimiento s más lento!

#define IRpin_PIN PIND
#define IRpin 2

// el pulso máximo que escucharemos: 65 milisegundos es mucho tiempo
#define MAXPULSE 65000

// lo que debería ser nuestra resolución de tiempo, más grande es mejor ya que es más ‘preciso’ – pero demasiado grande y no se conseguirá  tiempo exacto
#define RESOLUTION 20

// almacenaremos hasta 100 pares de pulsos (esto son muchos )
uint16_t pulses[100][2]; // par es pulso alto  y bajo 
uint8_t currentpulse = 0; // indice para pulsos que estamos almacenando

void setup(void)

{
Serial.begin(9600);
Serial.println(“Ready to decode IR!”);
}

void loop(void)

{

// tiempo de almacenamiento temporal
uint16_t highpulse, lowpulse;

//empezar sin pulso 
highpulse = lowpulse = 0;

//esto es demasiado lento!
while (IRpin_PIN & (1 << IRpin)) {
// pin esta a nivel alto

// continúa otros microsegundos
highpulse++;
delayMicroseconds(RESOLUTION);

// Si el pulso es demasiado largo, ‘se agotó el tiempo’ – o bien nada / se recibió o el código está terminado, así que imprima lo que  hemos obtenido hasta ahora, y luego reiniciamos
if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
printpulses();
currentpulse=0;
return;
}
}
// no nos detuvimos, así que escondamos la lectura
pulses[currentpulse][0] = highpulse;

// lo mismo que arriba
while (! (IRpin_PIN & _BV(IRpin))) {
// pin esta aun bajo
lowpulse++;
delayMicroseconds(RESOLUTION);
if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
printpulses();
currentpulse=0;
return;
}
}
pulses[currentpulse][1] = lowpulse;

// leemos un pulso alto-bajo con éxito, ¡continuamos!
currentpulse++;
}

void printpulses(void) {
Serial.println(“\n\r\n\rReceived: \n\rOFF \tON”);
for (uint8_t i = 0; i < currentpulse; i++) {
Serial.print(pulses[i][0] * RESOLUTION, DEC);
Serial.print(” usec, “);
Serial.print(pulses[i][1] * RESOLUTION, DEC);
Serial.println(” usec”);
}
}


Una vez que hemos subido el código anterior  y  todo está configurado correctamente, abrir el serial monitor haciendo clic en el botón en el programa de Arduino que es el botón de un círculo en la imagen y  ya estára en marcha así que ahora usted necesitará encontrar un control remoto que desee usar para controlar algo con Arduino

El proceso  esquemáticamente  a seguir es el siguiente :

  1. Encontrar el mando a distancia del dispositivo  que quiere controla
  2. Ejecutar el código del  receptor anteriormente citado
  3. Presione el botón del mando cuyo  código desea obtener 
  4. Ver el Monitor Serial
  5. Pegar el todo el código del monitor serie  en un editor de texto 
  6. Repetir los paso 3, 4 6  con todos los botones del mando que desee descodificar 

 Interpretando las señales

Una vez siga la secuencia de paso anteriores recibirá un montón de números seguidos por “usecs” o “usec”.
Asegúrese de que ha copiado la señal que se desea formateando la salida para más fácil referencia.

Se verá algo como esto:
500 usec, 300 usec
600 usec, usec 1200

Pero habrá números mucho más que eso.

Ahora en el programa emisor  verá esto bastantes veces:

delayMicroseconds();
pulseIR();

Es decir tenemos que  tomar el primer número y poner paréntesis en delayMicroseconds(“here”); el  valor obtenido en el monitor
y a su vez   tomar el segundo número de la misma línea como el de la delayMicroseconds()  valorar y poner en el paréntesis de pulseIR(); valor.

Veamos otro ejemplo .Si conseguimos esto en el monitor serial:

OFF ON
1660 usec, usec 580
1640 usec, usec 560

Ahroa para poner los  correspondiente valores en sus áreas correspondientes lo haremos asi :

delayMicroseconds(1660);
pulseIR(580);
delayMicroseconds(1640);
pulseIR(560);

Como puede apreciar ,la  tarea de transcripción  es muy fácil.

Una vez que tenga los códigos que desee, abra un nuevo  archivo IR_SEND.pde en el programa de Arduino y luego tendremos que  poner  los valores que tiene del monitor de serie entre paréntesis haciéndolo  del mismo modo  que hemos visto anteriormente .

Ahora, una vez que tenemos los códigos que desea y haya cargado el programa con la señal que desea enviar, todo lo que tiene que hacer es conectar el LED IR al pin 13 y luego a tierra  No necesita la resistencia si tiene un Duemilanove Arduino porque tiene una resistencia integrada para PIN 13, por lo que no tiene que preocuparse.


Como ejemplo veamos este código cuando se presiona el botón para subir el canal en un  control remoto de Comcast. . Aquí está el código de Serial Monitor: Recibido:

OFF  ON
36328 usec, 280 usec
820 usec, 300 usec
1580 usec, 320 usec
640 usec, 240 usec
2740 usec, 240 usec
1280 usec, 240 usec
1240 usec, 240 usec
1120 usec, 240 usec
2600 usec, 240 usec
12740 usec, 240 usec
840 usec, 240 usec
980 usec, 240 usec
700 usec, 240 usec
700 usec, 240 usec
720 usec, 240 usec
2460 usec, 260 usec
700 usec, 240 usec
700 usec, 240 usec
14904 usec, 260 usec
820 usec, 240 usec
1660 usec, 240 usec
700 usec, 260 usec
2740 usec, 240 usec
1240 usec, 240 usec
1260 usec, 240 usec
1100 usec, 240 usec
2620 usec, 240 usec
12720 usec, 260 usec
840 usec, 220 usec
2080 usec, 240 usec
1780 usec, 260 usec
700 usec, 240 usec
700 usec, 240 usec
2480 usec, 240 usec
700 usec, 240 usec
700 usec, 240 usec

Aquí está el código realizado a partir de los datos en bruto anteriores  pero no se  asociado al código  

En el siguiente  programa   se ha introducido  un detalla original ; Arduino cambiará el canal cada diez segundos para que se puedan hacer otras cosas , Por ejemplo mientras se ve televisión y esta haciendo otras cosa  así  no tendrá que cambiar el canal de modo que el sw  recorrerá los canales para que tenga las manos libres. (todos sabemos que presionar un botón es tan difícil, ¿por qué no hacerlo de forma automática?)

 

He aquí el programa realizado por Wally_Z:


int IRledPin =  13;    // LED conectado al pin digital 13

// El método setup () se ejecuta una vez, cuando comienza el boceto

void setup()   {               
  // initializa  el pin como salida :
  pinMode(IRledPin, OUTPUT);     

  Serial.begin(9600);
}

void loop()                    
{
  SendChannelUpCode();

  delay(20*1000);  // espera veinte segundos (20 segundos * 1000 milisegundos) Cambia este valor para diferentes intervalos.

}

// Este procedimiento envía un pulso de 38KHz al IRledPin  para un cierto  numero de microsegundos. Usaremos esto siempre que tengamos que enviar códigos.

void pulseIR(long microsecs)

{
  // contaremos desde la cantidad de microsegundos que se nos dice que esperemos

  cli();  // esto apaga cualquier interrupción de fond

  while (microsecs > 0) {
   // 38 kHz tiene aproximadamente 13 microsegundos de alto y 13 microsegundos de bajo
   digitalWrite(IRledPin, HIGH);  //Esto lleva alrededor de 3 microsegundos
   delayMicroseconds(10);         // esperar 10 microseconds
   digitalWrite(IRledPin, LOW);   // esto toma sobre 3 microseconds
   delayMicroseconds(10);         // esperar   10 microseconds

   // asi que  26 microseconds  todo junto
   microsecs -= 26;
  }

  sei();  // esto devuelve el control
}

void SendChannelUpCode()

{
  // Este es el código para CHANNEL + para TV COMCAST.
 
  delayMicroseconds(36328);      //Tiempo libre (columna IZQUIERDA)      
  pulseIR(280);                               //Tiempo en (columna DERECHA) <——- NO MEZCLAR ESTOS ARRIBA
  delayMicroseconds(820);
  pulseIR(300);
  delayMicroseconds(1580);
  pulseIR(320);
  delayMicroseconds(640);
  pulseIR(240);
  delayMicroseconds(1280);
  pulseIR(240);
  delayMicroseconds(1240);
  pulseIR(240);
  delayMicroseconds(1120);
  pulseIR(240);
  delayMicroseconds(2600);
  pulseIR(240);
  delayMicroseconds(12740);
  pulseIR(240);
  delayMicroseconds(840);
  pulseIR(240);
  delayMicroseconds(980);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(720);
  pulseIR(240);
  delayMicroseconds(2460);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(14904);
  pulseIR(240);
  delayMicroseconds(820);
  pulseIR(240);
  delayMicroseconds(1600);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(260);
  delayMicroseconds(2740);
  pulseIR(240);
  delayMicroseconds(1240);
  pulseIR(240);
  delayMicroseconds(1260);
  pulseIR(240);
  delayMicroseconds(1100);
  pulseIR(240);
  delayMicroseconds(2620);
  pulseIR(240);
  delayMicroseconds(12720);
  pulseIR(260);
  delayMicroseconds(840);
  pulseIR(220);
  delayMicroseconds(2080);
  pulseIR(240);
  delayMicroseconds(1780);
  pulseIR(260);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(2480);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
}

 

Via Instrucables.com

 

 

 

Como controlar cualquier electrodoméstico con mando vía wifi


Modernamente están apareciendo muchos electrodomésticos convencionales como equipos de Aire  Acondicionado , Robots de limpieza , Persianas eléctricas , TV , etc con la opción de poderlos controlar  a distancia gracias  a la  conectividad  WIFI ,lo cual puede ser muy interesante  para configurarlos , programarlos o activarlos no solo desde casa, sino incluso fuera de esta  , y con ello mejorar nuestra calidad  de vida  . El punto  negativo es que en la mayoría de los casos   incrementa  sustancialmente el precio  desgraciadamente frente a los  equipos convencionales que no cuentan  con  dicho control y ademas  si contamos con equipos instalados operativos  pero sin esa funcionalidad de control por wifi   , no es una razón de peso para desechar estos¿no?. 

Asimismo ,como sin duda el lector conocerá, cada día  son mas frecuentes los asistentes de voz  como Alexa de Amazon , Google Home o el propio novedoso Aura de Movistar , todos ellos que poco podrán hacer sobre dichos  equipos  a controlar, si no disponen de los  módulos de control  correspondientes. Por ejemplo   con un Amazon Echo Dot o un Google Home Mini  si quiere enseñarle a encender el aparato de Aire Acondicionado  antes de llegar a casa o encender la TV   cuando olvida el mando a distancia lejos del sofá  no podrá hacerlo fácilmente   directamente  pues estos equipos no están preparados par ser controlados por dichos asistentes ,  pero no se alarme, porque   en efecto  no hace falta invertir una gran suma de dinero en cambiar dicho aparato , pues nos bastara ,  si este equipo es controlable   por infrarrojos o RF , de  instalar  un control remoto de luz infrarroja compatible con Alexa o Google Home  que haga las veces de “puente” entre ambos mundos.

Como opción interesante para controlar nuestros dispositivos en el salón destaca el Broadlink RM mini3, un pequeño dispositivo  que  puede controlar sin limitaciones  a  todos los dispositivos y dispositivos controlados con mandos a distancia por infrarrojos  o  que  emiten radiofrecuencia  en las frecuencias de 433 Mhz y 315 Mhz en toda la casa. ( excepto si el código es variable, Broadlink Rm Pro no puede admitirlo) 

 El BroadLink en cuestión tiene el tamaño de un vaso de chupito   contando con  varios leds de infrarojos  repartidos en la cabeza en forma 360° , que hacen que su área de actuación sea muy buena, por ejemplo  para encender el aire acondicionado antes de llegar a casa o para simular presencia encendiendo la tele  gracias a  una app específica para Europa (Intelligent Home Center For EU  , la cual se rige por el Reglamento General de Protección de Datos de la Unión Europea, famoso por ser estricto con el manejo de datos personales).

 

 Con este tipo de dispositivo podremos reemplazar  todos los controles remotos  por  su teléfono inteligente, pues cuenta con soporte para más de 80,000 dispositivos controlados por infrarrojos como aire acondicionado, TV, DVD, PVR, CD, SAT, aire acondicionado, persianas eléctricas, lámparas, purificadores, WiFi, reproductores BluRay, proyectores , Unidades de CA, salidas de RF, ventiladores y mucho más.

Aunque se ha comentado alguna  vez en este blog ,para saber si un mando es IR o RF, enfoque con la cámara del móvil a la punta del mando que controle ese dispositivo y pulse un botón: si en la pantalla del móvil  se ve un destello de  luz azul/blanca, es IR ( si no se ve nada, es de RF).

 

 

Los pasos a seguir para la instalación del el Broadlink RM mini3,  son realmente  muy sencillos:

  1. Instalar la app en el móvil ( esta disponible tanto para Android  como para  iOS)
  2. Enchufarle  una conexión de 5v  por el conector micro-USB ( no esta incluido el adaptador )                                                                                     ,
  3. Abriremos la   app   (esta disponible tanto para Android  como para  iOS)  y vincularemos el  Broadlink RM mini3,por  bluetooth a nuestro terminal                                                                       .
  4. Tendremos que conectar  el  Broadlink RM mini3 a nuestra red wifi añadiendo las credenciales  de nuestra red. Este modelo solo es compatible con redes de 2,4 GHz, pero no 5G  y la  contraseña de Wifi debe ser de  menos de 32 bytes, sin espacios y símbolos especiales, solo con alfabeto y número,
  5. Seguidamente añadiremos el  dispositivo a controlar  para lo cual elegiremos el  tipo de dispositivo, buscando  este modelo en la base de datos   que ofrece la propia aplicación  
  6. Probaremos  si funciona el control remoto desde la propia app , pero  si no funciona , cambiaremos  de modelo  hasta que reaccione)
  7. Si el control remoto no reconoce el dispositivo, puede copiar la señal del mando a distancia manualmente (pero los dispositivos que no están en la base de datos de BroadLink no son compatibles con los asistentes de voz)
  8. Repetiremos el proceso  para  todos los dispositivos controlados por infrarrojo que el BroadLink RM mini 3 tenga a su alcance  como puede ser los equipos de  aire acondicionado, televisores, equipos de música,lectores de dvd o blueray , descodificadores  de televisión de pago ,  barra de sonido, robot aspirador, reproductor multimedia, persianas eléctricas, etc..
  9. .El siguiente paso es configurar escenas que luego usaremos como comandos de Alexa o Google Home. Por  ejemplo para el televisor podemos tener varias  escenas para “encender la television”  o apagar la televisión  o incluso subir o bajar el volumen   o para el equipo de aire acondicionado  por ejemplo podemos tener una escena “calienta la casa” que sube la temperatura a 26 ºC y otra  escena “enfría la casa” que baja la temperatura a 18 ºC.
  10. El último paso es conectar la app de BroadLink con el altavoz inteligente. Hay un manual de instrucciones en el menú Más > Añadir servicio de voz, pero en resumen tenemos que abrir la aplicación Alexa o Google Home en el móvil e instalar la skill o servicio correspondiente. El asistente reconocerá automáticamente los nuevos dispositivos y sus comandos o escenas. Llegados a este punto  ya podrá decir “enciende el aire acondicionado”, “pon el aire acondicionado en modo calefacción” o “enfría la casa” para que el altavoz inteligente se comunique con el control remoto y este, a su vez, envíe la orden al aire acondicionado. También puedes decir “enciende la tele”, “silencia la tele” o “pon La Sexta” para que el control remoto envíe esas órdenes al televisor, aunque no sea una Smart TV ni nada parecido.
  11. Si puede  añadir un nivel de complejidad, creando rutinas desde las apps de Alexa y Google Home para encender las luces del salón de un color determinado cuando ponga el fútbol, conectar  la calefacción todos los días a una hora determinada o apagar el equipo de música cuando enciende la tele. 

 

Conclusiones 

Puede ser interesante para poder manejar la tele, aire acondicionado, bomba de calor y decodificador con el móvil pero sobre todo mediante un asistente de voz como  Google Home o Alexa 

Si nos remitimos al móvil , gracias a este dispositivo se pueden manejar multitud de aparatos sin problemas, configurarse  estos  fácilmente desde la aplicación y enseguida se pueden usar todos, desde casa o fuera de ella ( eso si sólo aquellos que usen infrarrojos  no Radiofrecuencia)

La app ademas permite poner temporizadores para que automáticamente la aplicación ejecute la función del aparato que se desee, en una hora o día concreto, o cada cierto tiempo. También existen los ambientes, que permiten ejecutar varios pasos automáticamente que nosotros indiquemos, de uno o varios aparatos, con un solo click. 

La pega viene con su compatibilidad con Google Home ya que no es del todo correcta. Para el RM Mini3 hay dos app, versión global y europea, que se usan igual para configurar los mandos, pero con la primera de ellas, Google Home no integra ni detecta los dispositivos, sólo los ambientes, y no los ejecuta bien. Con la otra, la europea, Google Home integra los dispositivos, pero solo las de tipo lámpara y tipo aire acondicionado, no las TV ni otros aparatos personalizados.

Respecto a Alexa , aunque la configuración a través de ambientes , escenas y rutinas se hace ardua y repetitiva una vez conseguida el funcionamiento es perfecto. Puedes controlar todo aparato que use infrarojos  que tenga en la misma habitación, y la función de aprendizaje de botones te facilita muchas tareas, así como las funciones pre-configuradas que otros usuarios ya han colgado en el servidor.  Es   un aparato imprescindible en dúo con Alexa.

En el siguiente video podemos ver un ejemplo de integración de Alexa con el Broadlink RM mini3,

Por cierto este  puente  de infrarrojos con wifi   se puede comprar  en Amazon por unos 24,99,   pero tenga cuidado porque hay otros modelos de Broadlink  algo mas económicos que no son controlables por asistentes de voz como Alexa o Google Home.Si necesita controlar aparatos que vayan por radiofrecuencia en lugar de infrarrojos necesitarás su hermano mayor…. El pro