MicroPython + Wifi con el Modulo ESP8266 por 4 dolares


Me ha llegado mi modulo Wifi + plataforma de desarrollo ensamblada por Node MCU que no me a salido por mas de 4 dolares (USD). Desde china hasta mi casa.

Este kit de desarrollo (NodeMCU) ya cuenta con unidad conversora de RS-232 (TTL) a USB con su respectivo regulador 3.3 Voltios con lo cual permite conectar éste directamente al puerto USB de nuestra computadora y programarlo o cargar el firmware y desde luego el modulo Wifi ESP8266 que está basado en el Modulo EAP-12E que cuenta con 22 Pines y mas que ya podremos apreciar en las siguientes imágenes:

Modulo Wifi ESP8266 (EAP-12E)

Modulo Wifi ESP8266 (EAP-12E)

Kit de Desarrollo NodeMCU - ESP8266 (ESP-12E)

El modulo Node MCU

Mas info ESP8266

Lo he comprado por su precio y funcionalidad además que su tamaño me encanta y pretendo embeberle MycroPython como firmware que para quienes no saben para mucho y ahí me incluyo MicroPython es el futuro de los lenguajes embebidos.

FIRMWARE - MicroPython

Para contextualizar un poco o si tienes te surgen dudas o algo de curiosidad MicroPython es: Micro Python es una implementación del lenguaje de programación Python 3 optimizado para microcontroladores [1].

Otro de los grandes proyectos financiados por crowdfunding Micro Python: Python for microcontrollers creado por DamienGeorge

Puedes probar MicroPython de manera virtual corriendo en la pybord y testeando una serie de periféricos:

http://micropython.org/live

Ahora lo genial es que puedes tener MicroPython en el modulo Wifi que eh citado anteriormente.

Gracias a los chic@s de Adafruit tenemos una grandiosa guía en la cual eh basado parte de este post.

Para embeber MicroPython en el modulo Wifi ESP8266 existen dos manera de hacerlo, La forma rápida y la manera correcta en donde compilamos desde el código fuente la ultima versión de MicroPython, sin dejar de lado que podemos realizar modificaciones aportando nuevas características que se han implementado en las ultimas revisiones pues hay día de hoy es un proyecto reciente.

INSTALANDO firmware MicroPython funcional

Primero hemos de probar nuestro modulo, verificando que todo esta bien y que podemos cargar un firmware (Micropython) de manera correcta y funcional. Bastara con descargar, descomprimir y cargar el ultimo firmware compilado "firmware-combined.bin" debemos recordar que este firmware que cargamos de esta manera se encuentra desactualizado, no posee características o modificaciones a medida y que éste no soportara las ultimas funcionalidades de MycroPython.

Para cargar el firmware usaremos en script en Python esptool.py, desde luego en cualquier plataforma sea GNU/Linux windows o Mac OS, desde sistemas windows se puede usar la herramienta con interfaz gráfica nodemcu-flasher.

https://github.com/nodemcu

Si usamos el script escrito en python exptool.py hemos de cumplir algunos requerimientos fundamentales como:

  1. Python 2.7.x
  2. La librería pyserial (python-serial)
  3. Gestor de versiones GIT.

En sistemas Debian o basados en Debian como Ubuntu usar:

$ apt-get install python python-serial git 

Descargamos el script esptool.py

git clone https://github.com/themadinventor/esptool.git 

También podemos solo descargar el script presidiendo de la herramienta de gestión de versiones GIT.

  1. Descargamos el firmware MicroPython para el modulo ESP8266 “firmware-combined.bin”
  2. Versiones oficiales: https://micropython.org/download#esp8266
  3. El que yo eh compilado, la versión 1.67xxx firmware - MicroPython v1.7xx [2016/04], firmware-combined 2016-Oct u otros.
  4. Ultima versión compilada del firmware: MicroPython-current_version

Hemos de ubicar el firmware-combined.bin en conjunto con el script esptool.py

Firmware MicroPython & Programa de carga


El siguiente paso es conectar nuestro modulo vía USB e identificar el puerto serie emulado. Para lo cual abrimos una terminal y listamos los dispositivos serie

$ ls -l /dev/tty*

Dispositivo Serial - USB


En mi kit de desarrollo no en necesario pero para algunos kit de desarrollo o dependiendo el firmware pre-instalado se requiere mantener pulsado el botón flash y darle botón reset o el botón flash o ambos procedimientos anteriormente descritos para lograr cargar el firmware.

Se recomienda antes de cargar cualquier firmware limpiar la flash, esto se realiza mediante:

$ python esptool.py --port /dev/ttyUSB0 erase_flash

Por ultimo procedemos a cargar el firmware, para posteriores cargas del firmware como el que construiremos se aplica el mismo proceso de carga del firmware,obtenemos un resultado similar al siguiente:

$ python esptool.py -p /dev/ttyUSB0 --baud 460800 write_flash --flash_size=4m 0 firmware-combined.bin

En las versiones mas actualizadas de esptool cargar el firmware mediante:

$ python esptool.py --port /dev/ttyUSB0 write_flash 0 firmware-combined-current.bin

Flash firmware con MicroPython


Y esto por si requieres volver al firmware Lua por alguna razón:

$ ./esptool.py --port /dev/ttyUSB0 write_flash --flash_size=4m --flash_mode dio 0x00 ./nodemcu_integer_0.9.5_20150318.bin 

Si todo ah salido bien saltar a la parte final del post para ver el USO de MicroPython en la ESP8266. Más info:

CONSTRUIR EL FIRMWARE

Nuevamente todo el crédito es para Tony DiCola (Adafruit) y sus grandes aportes.

Para construir el firmware MicroPython el método mas sano es realizarlo desde una maquina virtual (Que si lo puedes hacer desde tu sistema nativo), esto porque es mas fácil y portable realizarlo en una maquina virtual además de poder usar el SDK abierto de manera aislada y que no entre en conflicto con las herramientas propias del sistema y sin depender de la plataforma en la que te encuentres (windows, Mac OS, GNU/Linux), una maquina virtual que ejecuta Ubuntu, que ejecuta las herramientas y SDK para compilar el firmware de MicroPython para el procesador de la ESP8266.

Dependencias

  • VirtualBox - Software de visualización open source o no; se requiere version 4.x
  • Vagrant -Que nos permite crear y configurar entornos de desarrollo virtualizados desde la grandiosa y poderosa terminal (linea de comandos).
  • Git - software de control de versiones que usaremos para descargar la ultima revisión de MicroPython y el SDK.

En Debian y derivados, como en otras distros, están en los repos. Una vez cumplido las dependencias nuestro primer paso sera el de descargar una archivo-vagrant el cual determina que sistema operativo usar, además de algunos comandos que adecuan el sistema operativo para construir el SDK. desde la terminal clone el repositorio.

Clonar el repositorio, donde se encuentra el archivo vagrant

$ git clone https://github.com/adafruit/esp8266-micropython-vagrant.git

Clonar Repositorio


Luego entrar al directorio

$ cd esp8266-micropython-vagrant/

Ejecutar maquina virtual

$ vagrant up

Es normal que tarde un tiempo la primera vez

vagrant - levantar maquina virtual


Ahora viene lo genial y es que podremos acceder a nuestra maquina virtual en linea de comandos con:

$ vagrant ssh

vagrant ssh - Acceder a la maquina virtual


Bueno "manos a la obra" a construir el ESP-SDK

La maquina virtual ya viene preparada para su trabajo, es decir ya tiene el código fuente del SDK, si no lo tiene ó lo requieres pues descárgalo, accede a el y a compilar:

$ cd ~/esp-open-sdk
$ make STANDALONE=y

Si has compilado alguna vez, un programa, sabrás que toma tiempo y claro mas si lo haces desde una maquina virtual, si te genera error en Adafruit dicen que puede ser por muy poca memoria RAM en dado caso solo asígnale mas en editando el archivo Vagrantfile.

Compilar ESP DSK


Con esto tendremos el ESP Open SDK listo, el paso siguiente desde luego, es el de compilar el firmware MicroPython pero antes requerimos exportar el directorio del SDK para que este pueda encontrado por MicroPython.

$ echo "PATH=$(pwd)/xtensa-lx106-elf/bin:\$PATH" >> ~/.profile
$ exit
$ vagrant ssh

Con el siguiente comando se verifica que el path este bien:

$ echo $PATH 

Finalmente vamos a construir el firmware de MicroPython para la ESP8266, recuerda que debes tener la maquina virtual en ejecución y el SDK compilado.

Una vez mas ya contamos con el código fuente de MicroPython en la maquina virtual gracias al acondicionamiento que realizo el vagrant. Aunque si vamos a requerir de cumplir unas cuantas dependencias externas, dependencias que en muchos caos se requieren para habilitar funcionalidades adicionales

$ cd ~/micropython 
$ git submodule update --init
$ make -C mpy-cross
$ cd ~/micropython/esp8266
$ make axtls
$ make

Compilar MicroPython


Errores?

Con esto, ya tendremos el firmware de MicroPython para el ESP8266, en el archivo ./build/firmware-combined.bin, esté sera el que carguemos a el modulo wi-fi, como este archivo, se encuentra en una maquina virtual necesitamos extraerlo a host esto lo realizamos con el siguiente comando gracias a que vagrant ya tiene un directorio para compartir archivos entre la maquina virtual y el host.

$ cp ./build/firmware-combined.bin /vagrant/

Compilar MicroPython


Para cargar el firmware favor volver a la parte de INSTALANDO firmware MicroPython funcional

Salimos e inhabilitamos la maquina virtual con:

$ exit 
$ vagrant halt

Recuerde que para habilitar la maquina virtual en un futuro, para compilar la una versión mas actualizada de MicroPython o para agregar nuevas funcionalidades usar:

$ vagrant up 

Y para acceder a esta:

$ vagrant ssh 

USO

Para usarlo en modo prompt REPL (stands for Read Evaluate Print Loop), es un modo de consola interactiva, este modo es la manera mas fácil de poner a prueba nuestro firmware MicroPython que acabamos de construir y cargar en al ESP8266. Basstara con identificar el dispositivo USB serial (si no sabes como te recomiendo mires en el principio del post - Dispositivo Serial - USB) con:

$ ls -l /dev/tty*

Es muy importante que este puerto se abra a 115200 baudio, en sistemas Unix, GNU/Linux puedes usar minicom, screen, picocom y demas yo usare screen.

$ screen /dev/ttyUSB0 115200

Recuerda dar un reset a tu Kit de desarrollo una vez terminado, de cargar el firmware y de presionar la tecla Enter por lo menos una vez. Si después reseteamos la placa de desarrollo con el puerto abierto identificaremos al versión de MicroPython cargado en la ESP8266 así como otra información:

Hola MicroPython en ESP8266


Si queremos terminar la consola interactiva o cerrar el puerto lo hacemos presionando primero la combinación de teclas CTRL + A y posteriormente presionando la tecla A.

Realicemos una serie de pruebas o test en nuestro prompt de MicroPython:

Hola Mundo ESP8266 con MicroPython


Igualmente podemos realziar este tipo de test sobre un IDE, ESPlorer es un IDE que esta en desarrollo para el modulo Wifi ESP8266, esta escrito en java por lo tanto es multi-plataforma asimismo soporta lenguajes como Lua y MicroPython entre muchas cosas mas.

En el siguiente link pueden descargar el IDE+firmware MicroPyhon: esp8266.ru

Hola Mundo MicroPython (ESP8266) desde el IDE ESPlorer


De momento el unico procedimiento de trabajar con scripts .py es guardarlo al momento de compilar el firmware pero no obstante aunque resulte algo tedioso no es difícil ya que solo basta habilitar la maquina virtual (vagrant up), acceder a la maquina (vagrant ssh) y almacenar el script en el directorio

$ cd ~/micropython/esp8266/scripts/

Recuerda que MicroPython esta totalmente reescrito para estas plataformas, además de ser MicroPython para la ESP8266 muy reciente y por lo tanto no es compatible con todas las bibliotecas de MicroPython. Lo mas sano es siempre fijarse la documentación y tener el firmware actualizado.

Documentación MicroPython y la referente a las funciones propias de ESP.

OJO MicroPython ESP8266

  • Aun no sopota mciroSD como los demás tarjetas con MicroPython como la pyboard.
  • No soporte threading o multiprocessing.
  • Micropython no cuenta aun con la biblioteca completa estándar de Python

Dejaremos para una próxima entrada la implementación de ejemplos de esta fantástica placa de desarrollo.

Lo referente a mi aporte se licencia bajo Creative Common by fandres.
Fuente:
MicroPython + Wifi con el Modulo ESP8266 por 4 dolares por fandres licenciado bajo CC BY 4.0