Cargar NodeMCU En ESP8266 ESP-01 (y Otros)

Hacia finales del 2014 se ha empezado a hablar de un chip numerado como ESP8266, en primer lugar se empezó a hablar de él como una forma simple de conectar una placa de desarrollo vía WiFi, por ejemplo una placa del entorno Arduino.

Pero ahora estamos ante la explosión del verdadero potencial de este chip, ya que no se trata simplemente de un chip dedicado a la administración de la comunicación por radiofrecuencia bajo el estándar 802.11 b/g/n, sino que además incorpora un microprocesador a 80MHz (hasta 160MHz), que podemos programar del mismo modo que podemos programar el Atmega mediante Arduino.

¡Pero incluso más! Ya existe un firmware que ha portado Lua (como lenguaje) al ESP8266, lo que nos permite con una sintaxis sencilla programar este microcontrolador que trae por diseño capacidades de comunicación adecuadas al estándar más extendido.

Pero... será algo muy caro... ¿quién podría pensar que por 5€ se puede tener todo eso? ¡Empecemos!

Step 1: Diferentes Placas

Esto puede resultar algo confuso para alguna gente... ¡hay más de una forma de encontrarnos el chip ESP8266!

Diferentes tipos de placas, diferentes montajes, con mayor o menor número de conexiones disponibles... ESP-01, ESP-02, ESP-07, ESP-12...

Al final se trata del mismo chip, pero con diferentes opciones tanto en conexiones y especialmente respecto a la antena y su conexión. Teniendo antenas basadas simplemente en una pista en la propia placa de circuitos en zigzag, hasta un conector para una antena externa.

Debemos valorar en cada caso lo que más nos conviene, en este ejemplo vamos a emplear el modelo más común y extendido, el ESP-01, que tiene 8 conexiones disponibles y una antena impresa en placa.

Step 2: Materiales

Además de que evidentemente vas a necesitar tener una placa ESP-01 (o cualquier otra que contenga el chip ESP8266, pero tendrás que buscar información extra de tu placa en concreto a la hora de realizar conexiones), vas a necesitar algunos materiales extra:

1x - Convertidor USB a UART, que permita señales a 3.3 voltios

7x - Cables de conexión (2 hembra-hembra y 5 hembra-macho)

1x - Fuente de alimentación de 3.3 voltios

1x - Breadboard

No es suficiente con la alimentación que suelen proporcionar los convertidores UART mediante el puerto USB, sobre todo si además de cargar NodeMCU luego vamos a trabajar con la placa y a hacer uso de sus capacidades inalámbricas. El consumo puede y suele ser superior al que puede soportar el adaptador UART, lo que puede llevar a reinicios de la placa inesperados ante la caída de tensión.

Step 3: Conectores De La Placa ESP-01

Para facilitar el trabajo, a partir de ahora identificaremos cada conexión a la placa ESP-01 con un código de colores, que en las imágenes cumplirán los cables.

Son 6 conexiones las que debemos tratar para poder cargar un firmware nuevo al chip, y podemos clasificarllas de la siguiente manera (ver imagen).

Conexiones de datos: 1 y 8 (TX y RX de UART)

Conexiones de alimentación: 2 y 7 (GND y VCC de 3.3 voltios)

Conexiones para activar el modo de carga: 6 (GPIO0, para activar el modo de carga debe conectarse a GND)

Conexiones para activar el chip: 3 (CH_PD, debe conectarse a VCC para que el chip se active)

Step 4: Realización De Conexiones

1. Conexiones al convertidor UART

Empezaremos por conectar dos cables al convertidor UART, de este únicamente usaremos las conexiones TX y RX. En el convertidor haremos las conexiones de la siguiente manera por colores:

Verde -> TX de UART

Blanco -> RX de UART

2. Conexiones a la placa

Por una parte, conectaremos los dos cables del UART a la placa, invirtiendo TX y RX, de tal forma que quedaría de la siguiente manera (los colores también se pueden ver en la imagen del Paso 3):

Verde -> RX de la placa (conexión 8)

Blanco -> TX de la placa (conexión 1)

A continuación conectaremos las dos conexiones de alimentación a la placa, tal que así:

Negro -> GND de la placa (conexión 2)

Rojo -> VCC de la placa (conexión 7)

Por último conectaremos las 2 conexiones restantes, de la siguiente manera:

Naranja -> CH_PD de la placa (conexión 3)

Marrón -> GPIO0 de la placa (conexión 6)

3. Conexiones en breadboard

En este ejemplo empleamos una fuente de alimentación conectable directamente a breadboard, que nos suministra 3.3V directamente en uno de los raíles. Por el momento tenemos 4 cables sueltos y 2 que conectan el UART con la placa, ahora debemos conectarlos en los lugares respectivos.

Negro -> Raíl GND (0V)

Rojo -> Raíl de alimentación (3.3V)

Esto era sencillo y muy evidente, ahora llegan las cosas no tan evidentes.

Naranja -> Raíl de alimentación

Marrón -> Raíl GND

El cable naranja debemos conectarlo siempre a los 3.3V, de lo contrario el chip no comenzará a funcionar (en cualquier modo, tanto normal como cuando intentemos cargar un nuevo firmware). Por su parte, el cable marrón que está conectado al GPIO0 de la placa, debemos conectarlo a GND únicamente cuando queramos subir un nuevo firmware. Debe estar conectado a los 3.3V para que la placa se inicie en su modo normal.

Es recomendable no cambiar estas dos conexiones si ya existe alimentación en la placa, para cambiar de modo la placa debe reiniciarse por completo, y para ello es mejor retirar la alimentación y devolverla cuando todas las conexiones oportunas estén realizadas.

Por último, y es algo que puede dar muchos dolores de cabeza, ¡debemos unir los GND del UART y de la fuente de alimentación! Por lo tanto, necesitaremos un cable extra que unirá el conector GND del UART al raíl GND.

Step 5: Software

Existe más de una posibilidad a la hora de cargar un nuevo firmware. Es habitual encontrar ejemplos empleando XTCOM, pero siendo una herramienta engorrosa, privativa y que no es multiplataforma, por nuestra parte preferimos hacer uso de esptool.py, que intenta ser independiente de la plataforma, haciendo uso de Python.

Por lo tanto, lo primero que nos va a hacer falta es descargar esptool.py, lo cual podemos hacer desde la siguiente dirección de GitHub:

https://github.com/themadinventor/esptool

Este método no únicamente sirve para cargar NodeMCU, sino en principio cualquier firmware. Como nuestro objetivo es cargar NodeMCU, debemos obtener el binario con el firmware ya listo para subir. También es posible descargar las fuentes y crear el binario nosotros mismos, pero se trata de una tarea mucho más complicada que simplemente cargarlo. NodeMCU se puede descargar desde este GitHub:

https://github.com/nodemcu/nodemcu-firmware/releases/latest

Una vez descargado todo, por comodidad podemos poner tanto esptool.py como el binario de NodeMCU en la misma carpeta. No es necesario pero simplifica el encontrar los archivos.

Dependiendo de la plataforma en la que hagas uso de Python puede que sea necesario instalar alguna librería extra, como pySerial. Consulta lo necesario en la página de GitHub de esptool.py, o ponte en contacto con sus desarrolladores para mayor soporte. Por lo general no suele ser necesario instalar nada a mayores en Ubuntu, que es la distribución de GNU/Linux que empleamos en este ejemplo.

Step 6: Manos a La Obra

Asumimos que están realizadas todas las conexiones que hemos especificado antes, que aún no hay alimentación en la placa y que el adaptador UART está ya conectado al puerto USB.

Es importante que a partir de ahora se sigan los pasos de manera ordenada, de lo contrario aparecerán errores. En la red circulan varios tutoriales al respecto que fallan precisamente a la hora de ser claros sobre el orden que hay que desarrollar en los pasos y los pasos específicos.

1. Conectamos la alimentación

Importante, asegúrate de que estás alimentando la placa con 3.3V y que igualmente el convertidor UART emplea señales a 3.3V. Emplear 5V y no 3.3V en cualquiera de los casos puede suponer quemar la placa sin vuelta atrás. ¡Asegúrate!

Si ya te has asegurado, al conectar la alimentación se encenderá una luz roja en la placa y parpadeará una sola vez una luz azul de manera muy breve. Si es así, la placa ha entrado en modo de carga. Si la luz azul parpadea más de una vez (3 o 4 quizá), es que la placa se ha iniciado de manera normal, revisa la conexiones.

2. Abrimos un terminal y accedemos a la carpeta donde se encuentran los archivos que nos interesan

Una vez allí ejecutamos esptool.py tal que:

sudo python esptool.py --port /dev/ttyUSB1 write_flash 0x00000 nodemcu_latest.bin

Empleamos sudo en Ubuntu para ejecutar con permisos de superusuario, en otros entornos deberá adaptarse. Debemos prestar atención a dos parámetos:

- Puerto serie, que suele ser /dev/ttyUSB0 pudiendo cambiar el número si hemos conectado más de un adaptador UART u otro periférico que emplee esa numeración.

- Nombre del firmware, en nuestro caso nodemcu_latest.bin, pero puede cambiar y debemos escribir el nombre en cada caso.

Si todo ha ido bien, nos mostrará el progreso de la carga del nuevo firmware, que tardará no más de un par de minutos.

Una vez cargado el firmware, podemos cambiar el cable marrón desde GND a VCC para que la placa se inicie de manera normal. Para ello llega con retirar y devolver la alimentación.

¡¡¡Listo!!!

Step 7: Fallos Comunes

Aquí algunos fallos comunes y las soluciones también comunes:

serial.serialutil.SerialException: could not open port /dev/ttyUSB0: [Errno 2] No such file or directory: '/dev/ttyUSB0'

El puerto seleccionado no es correcto. Si desconectas y vuelves a conectar rápido el adaptador UART, el sistema puede asignarle un nuevo nombre, aunque solo tengas un adaptador conectado a la vez. Asegúrate de que el nombre no es /dev/ttyUSB1 o /dev/ttyUSB2 o cualquier otro número...

Exception: Failed to connect

Se trata de un error genérico, pero indica que la conexión con la placa no es correcta. Intenta desconectar y conectar el UART (y asegúrate de que ahora no tiene asignado otro número, como en el error anterior), e inténtalo de nuevo.

- Revisa que no has confundido el orden de TX y RX en el UART.

- Asegúrate de que has conectado entre sí el GND del UART y de la fuente de alimentación que estás empleando.

- Asegúrate de que tanto CH_PD está conectado a VDD como que GPIO0 está conectado a GND

- Intenta reiniciar la placa apagando la fuente de alimentación un par de segundo y volviéndola a encender.