domingo, 11 de diciembre de 2016

Control REST del Witty ESP8266

Ya hemos visto como podemos convertir al Witty en un dispositivo IOT utilizando plataformas como Blynk. Pero hay otras maneras de comunicarnos con los microcontroladores ESP8266 que nos permitirán controlarlos desde aplicaciones de escritorio, apps móviles o incluso desde otro ESP8266. Es posible ejecutar en ellos un servidor web que nos permita, utilizando REST por ejemplo, interactuar con el dispositivo. Esta puede ser la solución ideal para controlarlos desde una red local aprovechando que ese interfaz es muy fácil de utilizar desde cualquier lenguaje de programación.
Vamos a ver cómo podríamos controlar el RGB y leer los datos recogidos por la fotoresistencia del Witty.

Primeramente comprobar que tenemos instaladas estas librerías desde el gestor de librerías del IDE Arduino:




Accede al código fuente del programa en gitHub y flashealo en tu Witty. Deberás adaptar las siguientes líneas a a las características de tu red local:


// Static IP
IPAddress ip(192, 168, 1, 99);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

Y configurar correctamente el SSID y la contraseña de la Wifi:

WiFi.begin("MYSSID", "MYPASSWORD");





Para probarlo instala el complemento RESTClient para Firefox.


Con el firmware que has flasheado el Witty expone dos entidades a través de las cuales podemos interactuar con el hardware: Led, que nos permitirá modificar los tres valores del led RGB y photo a través de la cual podremos consultar los valores de luminosidad que capta la fotoresistencia.

Por ejemplo, introduce estos valores en el cliente REST de Firefox. pulsa el botón SEND y el led tomará el color naranja:


Para leer la fotoresistencia sólo tenemos que acceder a la url:

Como se puede ver este tipo de interfaces es muy potente y fácil de programar. De una manera sencilla podemos exponer un api que nos permita lanzar procesos en el microcontrolador, leer sensores y activar actuadores. Es ideal para Domótica donde varios de estos pequeños dispositivos pueden estar repartidos por toda la casa y controlados desde un ordenador central.

domingo, 4 de diciembre de 2016

Hola Mundo con OpenSDK para Witty ESP8266

Como hemos visto en anteriores entradas, Arduino IDE no es el único entorno que existe para programar el ESP8266. Tenemos varias alternativas. Hoy vamos a ver cómo podemos programar nuestro microcontrolador utilizando el OpenSDK. Este SDK es una toolchain que une las librerías opensource de Espressif Systems, fabricante del microcontrolador y otra serie de librerías de terceros también opensource.
Las ventajas que tenemos al utilizar este SDK frente al de Arduino es un mayor control del procesador. Accederemos a todas las funcionalidad que nos da el fabricante del procesador Xtensa y prodremos sacarle más partido. La contraprestación que debemos pagar a cambio es que debemos tener mayor conocimiento del lenguaje C y que nuestros programas no serán tan fáciles de leer y entender como los que podríamos hacer con el C de Arduino.
Para probar este entorno utilizaremos a nuestro viejo conocido Witty y el IDE Code:Blocks todo ello utilizando linux.


Instalación del entorno de desarrollo.

Vamos a ver como sería la instalación y configuración del SDK y el IDE Code::blocks en Ubuntu.

Instala git si no lo tienes instalado.

sudo apt-get install git

Clona el repositorio.

git clone --recursive https://github.com/pfalcon/esp-open-sdk.git

Construye el SDK. Tardará un buen rato en descargar los ficheros de espressif y generar todos los ficheros necesarios.

make STANDALONE=y

Instala la última versión de codeblocks.

sudo add-apt-repository ppa:damien-moore/codeblocks-stable
sudo apt-get update
sudo apt-get install codeblocks codeblocks-contrib

Instalamos ahora el wizard para ESP8266. Primero colócate en la carpeta wizard de tu usuario y realiza un clonado del repositorio.

cd ~/.local/share/codeblocks/templates/wizard/
git clone https://github.com/dziadu/codeblocks-esp8266-wizard esp8266

Ahora copia el fichero config.script en la carpeta wizard.

cp /usr/share/codeblocks/templates/wizard/config.script ~/.local/share/codeblocks/templates/wizard/

Añade la siguiente línea al fichero config.script.


RegisterWizard(wizProject,     _T("esp8266"),      _T("ESP8266 Project"),       _T("Embedded Systems"));

Ya tienes tu entorno preparado para desarrollar.

El "Hola Mundo".

Ahora vas a crear el código necesario para hacer parapadear el led interno del ESP8266. Primeramente ejecuta el programa Code::blocks.


 Selecciona New Project.


Selecciona ESP8266 Project.


 Pulsa Next.


Informa el campo de texto con la carpeta a los binarios del SDK, en mi caso es:

~/git/esp-open-sdk/xtensa-lx106-elf/bin


Pulsa Next.


Informa el campo de texto con la carpeta HOME del SDK. En mi caso es:
~/git/esp-open-sdk/sdk


En esta pantalla marca "Use Blinky example" y pulsa el botón Next.


Por último pon nombre al título y al proyecto y pulsa el botón "Finish".


Debe aparecer una estructura de ficheros creada a partir del workspace, si la despliegas verás el fichero con el ejemplo del led parpadeante. Para compilarlo y generar el firmware pulsa en el botón de play. Debe indicar que todo ha ido bien mostrando el siguiente mensaje en la ventana de log.


Ahora flashearemos el firmware. Busca la carpeta firmware dentro del proyecto y abre un terminal en esa carpeta. Con el Witty ya conectado al Pc ejecuta estas dos sentencias consecutivamente:


esptool.py --port /dev/ttyUSB0  write_flash -fm  dio 0x00000 0x00000.bin
esptool.py --port /dev/ttyUSB0  write_flash -fm  dio 0x10000 0x10000.bin

Si todo ha ido bien verás parpadear el led azul interno del ESP8266.

domingo, 27 de noviembre de 2016

Hola Mundo en Python con el Witty ESP8266


Arduino no es el único entorno en el que podemos programar nuestro Witty y en general el ESP8266. También podemos utilizar otros entornos, incluso otros lenguajes. Hoy vamos a realizar el mismo ejemplo de "Hola Mundo" que ya hicimos en Arduino, pero esta vez lo haremos utilizando el lenguaje Python. El programa que vamos a escribir, hará parpadear el led rojo del led RGB montado en el Witty. 
Utilizar Python para programar, en lugar de C, tiene bastantes ventajas y algún inconveniente. Como ventajas podemos citar que Python es uno de los lenguajes más fáciles de aprender y por ello está recomendado para iniciarse en la programación en general. Utilizarlo para iniciarnos en la programación de microcontroladores puede ser una buena manera de empezar en este mundillo. También es un lenguaje que nos permite prototipar más rápido que C y es más fácil de leer y de entender. Como puntos en contra podemos destacar que es más lento, menos eficiente, y permite menos control del hardware que estamos programando.
Para el ejemplo que vamos a realizar, debemos tener una versión de Python instalada en nuestra máquina. Como vamos a utilizar Ubuntu tendrás seguramente ya una en nuestro sistema, si no es así debes instalarla.

Primeramente descarga el último firmware para el ESP8266 de la página de micropython.

Instala esptool.

sudo pip install esptool

Borra el firmware del dispositivo.

esptool.py --port /dev/ttyUSB0 erase_flash

Instala el firmware descargado.

esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect -fm dio 0 esp8266-20161110-v1.8.6.bin

Ahora ya tienes un intérprete de Python en el Witty. Conecta con la consola.

minicom -b 115200 -D /dev/ttyUSB0

Accederás a la consola de Python del dispositivo y podrás realizar las operaciones habituales. Desde la consola podrías programar directamente el microcontrolador. Nosotros vamos a escribir el programa en un fichero en el PC y luego lo subiremos al Witty.


Ahora instala la herramienta de Adafruit Ampy. Esta herramienta sirve para interactuar con micropython a través del puerto de comunicaciones y nos permitirá subir archivos desde el ordenador al microcontrolador.

sudo pip install adafruit-ampy

Escribe el siguiente programa y guárdalo en un fichero llamado holamundo.py

from machine import Pin
import time
pinR = Pin(15, Pin.OUT)
pinG = Pin(12, Pin.OUT)
pinB = Pin(13, Pin.OUT)
pinG.low()
pinR.low()
while True:
 pinR.high()
 time.sleep(0.5)
 pinR.low()
 time.sleep(0.5)

Sube el programa desde el PC al Witty escribiendo la siguiente línea en el terminal:

ampy --port /dev/ttyUSB0  --baud  115200 put holamundo.py /main.py

Si has seguido todos los pasos sin problemas, resetea el Witty y verás parpadear en rojo el led del RGB.


domingo, 20 de noviembre de 2016

Depuración gráfica en arduino con ESP8266 Witty Linux y SciDavis

Programar en Arduino es sencillo,  depurar los programas que hacemos en busca de errores ya no lo es tanto. Al contrario que en otros entornos de programación no disponemos de herramientas de depuración paso a paso ni de puntos de ruptura. En muchas ocasiones es complicado saber qué está pasando exactamente dentro de ese pequeño objeto al que tenemos un acceso bastante limitado.
La única herramienta que tenemos para visualizar como se está comportando nuestro programa es la escritura en el puerto de comunicaciones. Con la clase Serial podemos escribir la información que nos parezca significativa y ver esa información en la consola del IDE de Arduino. El problema es que esa información a veces es muy difícil de interpretar , sea porque varía muy rápido  en el tiempo y no podemos leerla sea porque el valor que queremos examinar depende a su vez de otro sensor  u otros y no es fácil ver como se relacionan. Esto ocurre sobre todo cuando hemos cometido un error a la hora de conectar, diseñar el circuito o programar el sketch.
Sin embargo, hay una manera de depurar gráficamente los valores de nuestros sensores y variables de una manera relativamente sencilla. Lo vamos a ver con un ejemplo muy simple y bastante tonto, pero que servirá para el caso. Usaremos, como no, nuestro pequeño Witty que trae de serie incorporados ya una fotoresistencia y un botón los cuales vamos a utilizar para el ejemplo.

A continuación vemos un programa que utiliza el puerto serie para volcar los valores significativos y poder visualizar desde la consola qué es lo que está ocurriendo dentro del microcontrolador.


int PHOTO_R = A0;
int BUTTON = 4;

void setup(){
  Serial.begin(115200);

  pinMode(PHOTO_R,INPUT);
  pinMode(BUTTON,INPUT);
   
}

void loop(){
  
    //Photoresistence read and print
    int photoResistence = analogRead(PHOTO_R);
    Serial.print(photoResistence);
    Serial.print("-");

    //Button read and print
    int buttonVal = digitalRead(BUTTON);
    Serial.print(buttonVal);
    Serial.print("-");

    //Calculated value and print
    int calc = photoResistence / ((buttonVal + 1) * 2);
    Serial.printĺn(calc);
    
    delay(100);
    
}

El programa lee el valor de la fotoresistencia, (posibles valores entre 0 y 1024) y lo envía al puerto serie.  Posteriormente envía también un guión con objeto de separar este dato del siguiente. A continuación se realiza la lectura del botón (posibles valores entre 0 y 1, pulsado y sin pulsar respectivamente) El valor se envía al puerto serie e inmediatamente se envía también un guión separador. Por último se realiza un cálculo cuyo valor dependerá del valor de la fotoresistencia y si se encuentra o no pulsado el botón. Al igual que los anteriores se envía al puerto serie. Este programa producirá la siguiente salida ( He tapado la fotoresistencia y pulsado el botón durante la ejecución para hacer variar los valores).

1024-1-256
1024-1-256
1024-1-256
1024-1-256
1024-1-256
1024-1-256
1024-1-256
1024-1-256
1024-1-256
574-1-143
364-1-91
350-1-87
354-1-88
435-1-108
947-1-236
906-1-226
388-1-97
367-1-91
557-1-139
779-1-194
940-1-235
934-1-233
738-1-184
509-1-127
458-1-114
435-1-108
428-1-107
421-1-105
422-1-105
430-1-107
1024-1-256
1024-1-256
909-1-227
649-1-162
618-1-154
881-1-220
629-0-314
797-0-398
910-0-455
635-0-317
1024-0-512
752-0-376

Gracias a que hemos puesto un retardo al final del loop, podemos leer la salida, de lo contrario veríamos pasar los numeros a toda velocidad y sin posibilidad de leerlos. Aún así tampoco es fácil interpretar lo que está pasando. Vamos a intentar mejorarlo realizando unas modificaciones en el programa.

Modifica el separador (aunque podríamos dejarlo, como está, la verdad) y añade los milisegundos de ejecución a la salida por el puerto serie. También disminuye el tiempo de retardo para aumentar el número de muestras. Se podría eliminar el retardo si queremos la máxima resolución. El valor del botón lo multiplicamos por 1024 para que pueda tomar dos valores 0 y 1024 que serán más fáciles de observar después.

int PHOTO_R = A0;
int BUTTON = 4;

void setup(){
  Serial.begin(115200);

  pinMode(PHOTO_R,INPUT);
  pinMode(BUTTON,INPUT);
   
}

void loop(){
  
    //Photoresistence read and print
    int photoResistence = analogRead(PHOTO_R);
    Serial.print(photoResistence);
    Serial.print(";");

    //Button read and print
    int buttonVal = digitalRead(BUTTON);
    Serial.print(buttonVal * 1024);
    Serial.print(";");

    //Calculated value and print
    int calc = photoResistence / ((buttonVal + 1) * 2);
    Serial.print(calc);
    Serial.print(";");

    //Time in milliseconds
    Serial.println(millis());

    delay(10);
    
}

Instala el programa cu si no lo tienes instalado. En Debian / Ubuntu sería:

apt-get install cu

Ahora crea este script con el nombre dump0.sh y  dale permisos de ejecución:

#!/bin/bash
cu -l /dev/ttyUSB0 -s 115200
cat </dev/ttyUSB0

Con el squetch subido al Witty y en ejecución, desde una consola en linux ejecuta:

./dump0.sh > data.csv

Pulsa el botón, pasa la mano por delante de la fotoresistencia, es decir prueba el circuito durante unos segundos. Para finalizar cierra el terminal. Habrás generado el fichero data.csv con todos los datos de la ejecución.

Instala el programa SciDavis. Si lo quieres instalar desde los repositorios de Debian / Ubuntu sería:

sudo apt-get install scidavis

Arranca el programa y ejecuta la opción Archivo -> Importar ASCII



Selecciona el fichero data.csv desde el sistema de ficheros y elige el punto y coma como separador.



Se importarán los datos en una tabla. Haz  click con el botón derecho del ratón en las columnas y sustituye los números por nombres significativos desde la opción editar. Asegúrate que las columnas 1,2 y 3 tienen asignado en la gráfica el eje Y de ordenadas y la columna 4 el eje X de abcisas.



Pulsando en la tecla control, pincha en las cabeceras de las cuatro columnas. Deberían que dar todas seleccionadas. Hecho esto seleccionar la opción de menú Gráfica -> Línea.


Deberíamos ver una gráfica similar a esta:


Ahora podemos entender mejor como están evolucionando los valores de nuestro circuito en el tiempo. También es posible realizar un zoom muy rápido y detallado en la zona de la gráfica que nos interese así como saber exactamente qué valores está tomando un punto de la gráfica si utilizamos la herramienta correspondiente. Evidentemente podríamos utilizar cualquier otro programa para representar la gráfica, una hoja de cálculo, por ejemplo, que importan directamente los ficheros con formato csv. El motivo de usar este programa es que está pensado específicamente para el análisis de datos, es muy rápido, maneja bien volúmenes altos de datos, de código abierto, permite realizar zoom sobre áreas muy pequeñas, etc.
Pues esto es todo, espero que os haya servido, y vosotros ¿cómo depuráis? Si tenéis alguna manera diferente de hacerlo por favor, dejadlo en los comentarios.

Acceso al código y ficheros en GitHub:

domingo, 13 de noviembre de 2016

IoT con Witty ESP8266 y Blynk

Vamos a seguir intentando sacar partido a la  placa de desarrollo Witty. Esta vez construiremos un sistema de IoT utilizando esta pequeña placa de prototipado que nos va a permitir controlar todos los elementos que monta utilizando un smartphone conectado a internet. Lo más increible  es que lo vamos a hacer utilizando dos líneas de código y con un resultado espectacular. Para ello vamos a utilizar nuestro Witty y un móvil con Android con la aplicación Blynk.

Primeramente instala la aplicación en tu móvil desde Google Play (o bien desde la App Store si tienes un iPhone). Te pedirá un usuario y una password para darte de alta. Una vez hecho esto accede a la opción de añadir proyecto:



Elige el nombre del proyecto y el tipo de tarjeta que quieres utilizar, en nuestro caso NodeMCU. La pantalla nos informa del token de autorización (en azul). Este token debes conservarlo a buen recaudo y no compartirlo con nadie, ya que con el se podrá acceder por completo a tu proyecto. Para no tener que copiar a mano el token, la aplicación  permite enviarlo a tu correo pulsando el botón E-Mail. Una vez introducidos los datos pulsa el botón Create. Aparecerá una pantalla vacía donde podremos colocar nuestros componentes.



Antes de continuar creando nuestro proyecto en la aplicación, vamos a flashear en el Witty el programa necesario para poder controlarlo desde la aplicación. Para ello, primeramente tienes que instalar en el IDE de arduino la librería correspondiente. Ve a la opción de menú Programas -> Incluir librerías -> Gestionar librerías y busca la librería Blynk.


Instala la librería y a continuación escribe este sketch en el IDE. Modifica las variables de esta manera: asigna a la variable auth el valor del token que ha generado Blynk para tu proyecto y las variables WifiNetwork  y WifiPassword con el nombre de tu wifi y la clave del mismo respectivamente.


#include <BlynkSimpleEsp8266.h>


char auth[] = "valorDelToken";
char WiFiNetwork[] = "miSSID";
char WiFiPassword[] = "miContraseña";


void setup() {
  Blynk.begin(auth, WiFiNetwork, WiFiPassword);
}

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

Compila el código y súbelo al Witty desde el IDE. Ten en cuenta que debes configurarlo para utilizar la placa NodeMCU antes de flashearlo.


Una vez hecho esto vuelve a la aplicación Blynk en el móvil y desde la paleta de componentes (se presenta deslizando la pantalla de derecha a izquierda) coloca el componente zeRGBa




Toca encima del componente y aparecerá la pantalla para configurar sus propiedades. Informa los valores igual que en la captura inferior. Para informar los valores, simplemente pulsa sobre las cajas correspondientes.


Regresa a la pantalla y añade el componente Gauge a la misma debajo de la cebra.


Establece sus propiedades de la misma manera que en la captura inferior.



Esto es todo. Ahora pulsa el botón play y tendrás funcionando tu proyecto. Puedes ver el funcionamiento en el vídeo. Los cambios de color no se aprecian demasiado, pero espero que os sirva para haceros una idea.




Acceso al código en GitHub:

domingo, 6 de noviembre de 2016

Hola Mundo en Witty ESP8266

Como es tradición, lo primero que hay que hacer cuando se aprende un lenguaje de programación es el Hola Mundo, que consiste en pintar en alguna parte, la pantalla habitualmente, la frase "Hola Mundo" . En el caso del mundillo Arduino, lo tradicional es hacer parpadear un led (led blinking) El parpadeo de un led es lo más básico que se puede hacer al programar un microcontrolador. En este caso lo vamos a utilizar para probar que todo funciona correctamente en la placa Witty (mini nodemcu) Esta placa incluye un led RGB que podemos utilizar para esta prueba. Lo cierto es que también podríamos haber utilizado el led interno del ESP8266 que está en el pin 2, pero , es muy pequeño, y queda mejor hacerlo con el RGB.


int LED_R = 15;

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

 }

void loop() {
  
  analogWrite(LED_R, 255);
  delay(500);
  analogWrite(LED_R, 0);
  delay(500);
  
}

El programa es sencillo:
   En el setup se establece el pin asignado al led rojo como pin de salida. En el loop se establece el led al máximo valor,  se espera medio segundo y se apaga el led se vuelve a esperar medio segundo y se repite indefinidamente.

Para flashear el programa utilizaremos el IDE Arduino con la placa NodeMCU 1.0 seleccionada.


El cable USB debe conectarse al puerto micro usb de la placa inferior. Luego desde el IDE, compilar, subir y listo.


domingo, 30 de octubre de 2016

Truco breadboard ESP8266



Las placas de desarrollo que montan ESP8266, al menos las que yo conozco, no se llevan muy bien con las  protoboard. Una vez la placa está "pinchada" no hay manera de conectar los pines de los cables al correspondiente pin de la placa. Las soluciones que he visto a este problema siempre pasan por conectar cables (sin pines) por debajo de la placa. Es un remedio incómodo y que obliga a estar permanentemente moviendo la placa cada vez que se requiere conectar otra entrada o salida del controlador.
 La solución a este problema es muy sencilla y la pongo aquí porque no la he visto en ninguna otra parte. Se trata simplemente de utilizar dos pequeñas protoboard. Tendremos espacio de sobra para pinchar nuestros cables.



domingo, 23 de octubre de 2016

Witty - ESP8266 12F

   Hace unos días que me ha llegado la nueva placa de prototipado para el ESP8266. La he comprado en una conocida página china por poco más de 4 euros. Me animo a escribir esta breve reseña porque no hay mucha información de las características de esta placa y la poca información que hay está muy dispersa. Así que esto es lo que he podido encontrar por si a alguien le es de utilidad.
   En realidad, se trata de dos placas independientes que están ensambladas mediante unos conectores que pueden desensamblarse manualmente. La placa superior monta el microcontrolador ESP8266-12F,  que tiene un procesador de 32 bits con capacidad para la memoria de programas de 64Kb, 96Kb de RAM y 4Mb de memoria Flash. La característica más destacable de este pequeño microcontrolador es que implementa un módulo WIFI 802.11 b/g/n que lo hace muy interesante para todo tipo de proyectos. También se incluyen en esta placa una fotoresistencia (LDR) y un led RGB WS2812. Por último, debajo de la antena, se encuentra un botón que también puede ser utilizado para nuestros proyectos. La placa puede funcionar independientemente alimentada mediante un conector micro USB de 5v .


   La placa inferior incluye un interfaz USB-UART que permite flashear el microcontrolador, así como proporcionar alimentación. También podemos encontrar dos botones. Estos no son programables. Son el boton de Reset y Flash necesarios en algunos entornos de desarrollo.


Mapa de pines:

  • PIN 2: Led del ESP8266.
  • PIN 4: Botón (Placa superior bajo la antena) LOW pulsado.
  • PIN 12: Led verde del led RGB.
  • PIN 13: Led azul del led RGB.
  • PIN 15: Led rojo del led RGB.
  • PIN A0: Fotoresistencia (LDR) entrada analógica.



 Una vez grabado el firmware en el microcontrolador, es posible utilizar la placa superior en una protoboard ya que los pines son totalmente compatibles.

   Este módulo es idóneo para el aprendizaje de la programación de microcontroladores, ya que nos permite, sin tener que conectar ni un cable, experimentar tanto con las entradas como las salidas del ESP8266 desde el primer momento. Si a esto le añadimos el precio que tiene, tenemos un producto muy recomendable.