BlogPython Training

Cómo: Introducción a MicroPython para microcontroladores ESP8266

Para cualquier persona interesada en usar microcontroladores baratos conectados a Wi-Fi como el ESP8266, el lenguaje de programación Arduino puede ser una barrera de entrada. Basado en C ++, Arduino requiere conocimientos de más informática que lenguajes como Python. Afortunadamente para los principiantes, configurar MicroPython en un ESP8266 permite a cualquiera escribir Python en microcontroladores asequibles en cuestión de minutos.

Los precios económicos vienen con una curva de aprendizaje

Uno de los primeros lenguajes que muchas personas aprenden para programar electrónica es Arduino, que requiere el conocimiento de la estructura específica necesaria para hacer que un boceto funcione. Debido a la forma en que los microcontroladores ejecutan el código, incluso un simple boceto de Arduino generalmente constará de dos funciones: configuración y bucle.

Para escribir un boceto que hace parpadear un LED conectado al pin D1 (también llamado GPIO pin 5), podemos usar el siguiente boceto en Arduino para configurar el LED a la salida, encenderlo por un segundo y luego apagarlo por un segundo .

void setup() {
  pinMode(D4, OUTPUT);
}
void loop() {
  digitalWrite(D4, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for one second
  digitalWrite(D4, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for another second
}

Para esta acción aparentemente simple, tenemos una gran cantidad de código que parece poco intuitivo para que un principiante lo entienda. Lo que sucede en este programa es que la función de configuración se ejecuta una vez, girando nuestro pin D4 al modo de salida, y luego el bucle se ejecuta continuamente para encender y apagar el LED. Si bien este es un boceto simple, MicroPython puede hacerlo aún más fácil.

MicroPython al rescate

En MicroPython, podemos hacer lo mismo de una manera que sea claramente comprensible en dos líneas. Primero, importamos los módulos que necesitamos y luego explicamos lo que queremos hacer en Python claro y directo.

from time import sleep; from machine import Pin; led = Pin(2, Pin.OUT) # Imports modules and defines output pin 5
while True: led.on(); sleep(1); led.off(); sleep(1) # Blinks LED on and off forever

Si queremos ser más técnicos, incluso podemos escribir una función para leer si el LED está encendido o apagado y cambiar su estado cada segundo, todo en la misma línea. Esto requeriría más configuración en Arduino y es un excelente ejemplo de cómo MicroPython puede facilitar la codificación simple.

También podemos usar trucos de Python como operadores ternarios para hacer nuestro código más compacto sin que sea demasiado difícil de entender. En esta estructura, las condiciones se escriben como si más , lo que nos permite expresar tanto condiciones como expresiones en la misma línea.

from time import sleep; from machine import Pin; led = Pin(2, Pin.OUT);
while True: led.value(1) if (led.value() == 0) else led.value(0); sleep(1)

Lectura de MicroPython frente a Arduino

Por supuesto, la programación no se trata de hacer que su código sea lo más corto posible. Si desea abusar de ambos idiomas, es posible escribir nuestro código para hacer parpadear un LED en una sola línea, pero es difícil de entender y generalmente no es una buena práctica. Aquí, podemos ver un programa MicroPython de una línea abusado.

exec("import time; machine; led = Pin(2, Pin.OUT)nwhile True: led.on(); sleep(1); led.off(); sleep(1)")

Si bien esto es definitivamente más difícil de leer que la versión de dos líneas anterior, sigue siendo mucho más fácil de entender que la versión abusada de Arduino a continuación.

void setup() {pinMode(D4, OUTPUT);}void loop(){digitalWrite(D4,1);delay(1000);digitalWrite(D4,0);delay(1000);}

El valor real de MicroPython no es más compacto que Arduino. En general, a los nuevos en microcontroladores les resultará más fácil comprender y escribir el código MicroPython, ya que llevado en() es un comando mucho más fácil de recordar que escritura digital (D1,0) para encender un LED.

REPL y REPL web

Otra característica de MicroPython es la capacidad de ejecutar código línea por línea, en lugar de tener que compilarlo primero como en Arduino. Eso significa que si desea comenzar a escribir un programa o trabajar con una pieza de hardware, puede conectarse al REPL (leer, evaluar, imprimir bucle) a través de una conexión en serie y comandos de entrada directamente, sin necesidad de escribir un boceto completo primero.

Esto tiene muchas ventajas, y aunque la interfaz de línea de comandos REPL no es la única forma de trabajar con MicroPython, es, con mucho, la forma más rápida y sencilla de comenzar a escribir código en su microcontrolador. Por supuesto, también podemos escribir archivos Python y subirlos, pero la simple capacidad de conectarnos a un ESP8266 y crear una red Wi-Fi en tiempo real es bastante sorprendente.

MicroPython v1.11-8-g48dcbbe60 on 2019-05-29; ESP module with ESP8266
Type "help()" for more information.
>>> print("Hello world!")
Hello world!
>>>

Esta sencilla interfaz está disponible desde la línea de comandos cada vez que conecta su ESP8266 a través de un cable USB, y puede incluso estar configurado para funcionar también a través de Wi-Fi.

Lo que necesitarás

Para usar MicroPython, necesitará un microcontrolador basado en ESP8266, como el D1 Mini o NodeMCU. Estos tableros son baratos y fáciles de encontrar en sitios web como AliExpress y Amazon.

También necesitará una computadora con Python3 instalado y un Cable micro-USB para conectar a la placa. Necesitará una conexión a Internet para descargar el firmware binario de MicroPython, un tablero de circuitos para conectar componentes, y un LED RGB de tres colores para probar nuestros pines de salida. Si no tiene un LED RGB de tres colores, puede usar LEDs regulares así como.

Imagen de Kody / Null Byte

Paso 1: descargue la herramienta ESPtool

Para descargar la herramienta que necesitaremos para flashear en nuestro ESP8266, necesitamos usar el administrador de paquetes de Python, Pip. Para hacerlo, podemos ejecutar el siguiente comando. Si esto no funciona, también puede intentar reemplazar pip3 con pepita. También puede intentar instalarlo manualmente desde el repositorio de GitHub.

~$ pip3 install esptool

Collecting esptool
  Downloading https://files.pythonhosted.org/packages/68/91/08c182f66fa3f12a96e754ae8ec7762abb2d778429834638f5746f81977a/esptool-2.8.tar.gz (84kB)
    100% |████████████████████████████████| 92kB 928kB/s
Requirement already satisfied: ecdsa in /usr/lib/python3/dist-packages (from esptool) (0.13)
Collecting pyaes (from esptool)
  Downloading https://files.pythonhosted.org/packages/44/66/2c17bae31c906613795711fc78045c285048168919ace2220daa372c7d72/pyaes-1.6.1.tar.gz
Requirement already satisfied: pyserial>=3.0 in /usr/lib/python3/dist-packages (from esptool) (3.4)
Building wheels for collected packages: esptool, pyaes
  Running setup.py bdist_wheel for esptool ... done
  Stored in directory: /root/.cache/pip/wheels/56/9e/fd/06e784bf9c77e9278297536f3df36a46941c885eb23593bb16
  Running setup.py bdist_wheel for pyaes ... done
  Stored in directory: /root/.cache/pip/wheels/bd/cf/7b/ced9e8f28c50ed666728e8ab178ffedeb9d06f6a10f85d6432
Successfully built esptool pyaes
Installing collected packages: pyaes, esptool
Successfully installed esptool-2.8 pyaes-1.6.1

Para verificar que la herramienta está funcionando, puede ejecutar esptool.py y busque el siguiente resultado.

esptool.py

esptool.py v2.8
usage: esptool [-h] [--chip {auto,esp8266,esp32}] [--port PORT] [--baud BAUD]
               [--before {default_reset,no_reset,no_reset_no_sync}]
               [--after {hard_reset,soft_reset,no_reset}] [--no-stub]
               [--trace] [--override-vddsdio [{1.8V,1.9V,OFF}]]
               {load_ram,dump_mem,read_mem,write_mem,write_flash,run,image_info,make_image,elf2image,read_mac,chip_id,flash_id,read_flash_status,write_flash_status,read_flash,verify_flash,erase_flash,erase_region,version}
               ...

esptool.py v2.8 - ESP8266 ROM Bootloader Utility

positional arguments:
  {load_ram,dump_mem,read_mem,write_mem,write_flash,run,image_info,make_image,elf2image,read_mac,chip_id,flash_id,read_flash_status,write_flash_status,read_flash,verify_flash,erase_flash,erase_region,version}
                        Run esptool {command} -h for additional help
    load_ram            Download an image to RAM and execute
    dump_mem            Dump arbitrary memory to disk
    read_mem            Read arbitrary memory location
    write_mem           Read-modify-write to arbitrary memory location
    write_flash         Write a binary blob to flash
    run                 Run application code in flash
    image_info          Dump headers from an application image
    make_image          Create an application image from binary files
    elf2image           Create an application image from ELF file
    read_mac            Read MAC address from OTP ROM
    chip_id             Read Chip ID from OTP ROM
    flash_id            Read SPI flash manufacturer and device ID
    read_flash_status   Read SPI flash status register
    write_flash_status  Write SPI flash status register
    read_flash          Read SPI flash content
    verify_flash        Verify a binary blob against flash
    erase_flash         Perform Chip Erase on SPI flash
    erase_region        Erase a region of the flash
    version             Print esptool version

optional arguments:
  -h, --help            show this help message and exit
  --chip {auto,esp8266,esp32}, -c {auto,esp8266,esp32}
                        Target chip type
  --port PORT, -p PORT  Serial port device
  --baud BAUD, -b BAUD  Serial port baud rate used when flashing/reading
  --before {default_reset,no_reset,no_reset_no_sync}
                        What to do before connecting to the chip
  --after {hard_reset,soft_reset,no_reset}, -a {hard_reset,soft_reset,no_reset}
                        What to do after esptool.py is finished
  --no-stub             Disable launching the flasher stub, only talk to ROM
                        bootloader. Some features will not be available.
  --trace, -t           Enable trace-level output of esptool.py interactions.
  --override-vddsdio [{1.8V,1.9V,OFF}]
                        Override ESP32 VDDSDIO internal voltage regulator (use
                        with care)

También puede ver las muchas opciones disponibles para nosotros. Estaremos aprovechando el borrar y destello funciones para introducir el binario correcto en nuestro microcontrolador.

Paso 2: Identifique su puerto serie

Tendremos que encontrar la dirección de serie de nuestro ESP8266. Para hacerlo en Linux, podemos usar el siguiente comando. Asegúrese de que su placa ESP8266 esté conectada a su computadora o no encontrará nada.

~$ dmesg | grep tty

/dev/cu.Bluetooth-Incoming-Port /dev/cu.usbserial-14140
/dev/cu.MALS            /dev/cu.wchusbserial14140

En macOS, el comando y la salida tienen este aspecto:

~$ ls /dev/cu.*

/dev/cu.Bluetooth-Incoming-Port /dev/cu.usbserial-14140
/dev/cu.MALS            /dev/cu.wchusbserial14140

La dirección correcta aquí para usar es /dev/cu.wchusbserial14140 a pesar de que tanto él como /dev/cu.usbserial-14140 están asociados con nuestro ESP8266. Puede identificar cuáles están vinculados a su dispositivo desenchufándolo y volviendo a ejecutar el comando para ver la diferencia. Una vez que sepa dónde encontrar su ESP8266 en el sistema, es hora de borrarlo y actualizarlo.

Paso 3: borre el ESP8266

Con la dirección de serie correcta de antes, usaremos el siguiente comando para borrar nuestro ESP8266, asegurándonos de cambiar su –Puerto valor a la dirección del ESP8266 que ha encontrado en su sistema.

~$ esptool.py --port /dev/cu.wchusbserial14140 erase_flash

esptool.py v2.8
Serial port /dev/cu.wchusbserial14140
Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: 2c:f4:32:4b:07:83
Uploading stub...
Running stub...
Stub running...
Erasing flash (this may take a while)...

Una vez que vemos el resultado, estamos listos para cargar un binario MicroPython en nuestra placa y comenzar.

Paso 4: descargue el firmware binario

Necesitaremos descargar el binario MicroPython más reciente para nuestro ESP8266. Puedes hacerlo desde el página oficial de descargas de MicroPython. Cuando haya terminado, podremos usar la herramienta esptool para mostrarlo en nuestro tablero ahora vacío.

Paso 5: Actualice su firmware a la placa

Para actualizar nuestro firmware, necesitaremos usar un comando en el siguiente formato, asegurándonos de reemplazar el puerto serie y la ruta al binario del firmware con los que está trabajando.

~$ esptool.py --port SERIAL_PORT --baud 460800 write_flash --flash_size=detect 0 FIRMWARE.BIN

Al ejecutar el comando, debería ver un resultado como el siguiente.

esptool.py --port /dev/cu.wchusbserial14140 --baud 460800 write_flash --flash_size=detect 0 /Users/skickar/Downloads/esp8266-20190529-v1.11.bin
esptool.py v2.8
Serial port /dev/cu.wchusbserial14140
Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: 2c:f4:32:4b:07:83
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 460800
Changed.
Configuring flash size...
Auto-detected Flash size: 4MB
Flash params set to 0x0040
Compressed 617880 bytes to 402086...
Wrote 617880 bytes (402086 compressed) at 0x00000000 in 9.6 seconds (effective 514.5 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Después de permitir que la esptool termine de escribir en la placa, ¡debería tener la capacidad de conectarse a través de una interfaz REPL de MicroPython!

Paso 6: Ingrese MicroPython REPL

Para conectarse a la interfaz de línea de comandos, use el siguiente formato en una ventana de terminal, asegurándose de reemplazar el puerto serie con el que está usando su dispositivo.

~$ screen SERIAL_PORT 115200

En un sistema Windows, deberá usar Putty para conectarse a través de Telnet. Una vez que se conecte, debería ver un mensaje como el siguiente.

C:> MicroPython v1.11-8-g48dcbbe60 on 2019-05-29; ESP module with ESP8266

Type "help()" for more information.
>>>

Para salir, puedes golpear Control-K para matar la ventana. Desde dentro de nuestro indicador, podemos ejecutar un pequeño fragmento de código para confirmar que podemos ejecutar Python en el ESP8266.

>>> x = "Hello World"
>>> print(x)
Hello World

Ahora que tenemos MicroPython en ejecución, probemos algunos comandos para trabajar con salidas.

Paso 7: Conceptos básicos de MicroPython

En nuestro shell REPL de MicroPython, ejecutemos las siguientes dos líneas para ver si podemos controlar el hardware con éxito. Después de buscar el diagrama de pines del D1 Mini, podemos ver que el LED interno está ubicado en el pin 2 o D4 en la serigrafía.

>>> from time import sleep; from machine import Pin; led = Pin(2, Pin.OUT) # Imports modules and defines output pin 5
>>> while True: led.on(); sleep(1); led.off(); sleep(1) # Blinks LED on and off forever
...

¡Debería ver que el LED de su D1 Mini comienza a parpadear una vez por segundo! Puedes presionar Control-C para detener el programa.

Paso 8: carga de un programa Python

Ahora podemos agregar una salida para ver si podemos controlar componentes externos. Usaré un LED RGB, pero también puedes usar tres LED normales. Conectaré los cables rojo, verde y azul del LED en los pines GPIO 0, 2 y 4. Esto funciona en los pines D2, D3 y D4 de la serigrafía.

Imagen de Kody / Null Byte

Ahora, necesitaremos instalar Adafruit Ampy. Podemos hacer esto en una nueva ventana de terminal con el siguiente comando.

~$ pip3 install adafruit-ampy

Collecting adafruit-ampy
  Downloading https://files.pythonhosted.org/packages/59/99/f8635577c9a11962ec43714b3fc3d4583070e8f292789b4683979c4abfec/adafruit_ampy-1.0.7-py2.py3-none-any.whl
Requirement already satisfied: click in /usr/lib/python3/dist-packages (from adafruit-ampy) (7.0)
Collecting python-dotenv (from adafruit-ampy)
  Downloading https://files.pythonhosted.org/packages/57/c8/5b14d5cffe7bb06bedf9d66c4562bf90330d3d35e7f0266928c370d9dd6d/python_dotenv-0.10.3-py2.py3-none-any.whl
Requirement already satisfied: pyserial in /usr/lib/python3/dist-packages (from adafruit-ampy) (3.4)
Installing collected packages: python-dotenv, adafruit-ampy
Successfully installed adafruit-ampy-1.0.7 python-dotenv-0.10.3

Una vez instalado Ampy, podemos usar el formato ampy –port / serial / port ejecutar test.py para ejecutar un archivo Python en nuestra placa conectada. Para pulsar nuestro LED RGB, escriba nano fades.py para crear un archivo Python en blanco, luego pegue el siguiente código en él.

import time; from machine import Pin, PWM; list = [0,2,4]
def PWMChange(pinNumber, intensity, delayTime): pwm2 = PWM(Pin(pinNumber), freq=20000, duty=intensity); time.sleep_ms(delayTime)
def flashing():
    for elements in list: PWMChange(elements, 0, 10)
    for elements in list:
        for i in range (0,255): PWMChange(elements, i, 10)
        if i > 253:
            for i in range(255, 0, -1): PWMChange(elements, i, 10)
while True: flashing();

Ahora, guarde el archivo escribiendo Control-X y Y para confirmar. Para ejecutar el archivo en la placa, confirme que tiene el puerto serie correcto y luego escriba el siguiente comando, después de cambiar /dev/cu.wchusbserial14440 para el puerto serie de su placa.

~$ ampy --port /dev/cu.wchusbserial14440 run fades.py

¡Debería ver que el código comienza a ejecutarse en su tablero! Si desea que su código se ejecute en el arranque (pero no en un bucle) como un Arduino, deberá reemplazar el archivo “main.py” en la placa. Puede cargar nuestro archivo Python y reemplazar el main.py archivo en el tablero con el siguiente comando.

~$ ampy -p /dev/cu.wchusbserial14440 put fades.py /main.py

Con este comando, nuestra placa ejecutará el programa que acabamos de cargar, pero no en un bucle como un Arduino, a menos que lo especifiques con un bucle sin fin como hicimos en el código anterior. Los bucles “while true” se ejecutan para siempre y no le dan a la placa la oportunidad de arrancar si han reemplazado al main.py, pero puede detener el programa en el REPL serial presionando Control-C y luego borrar el tablero para solucionar el problema.

MicroPython puede controlar el hardware en una sola línea de código

En unos pocos pasos, configuramos un microcontrolador ESP8266 para que funcione con MicroPython y aprendimos los conceptos básicos para trabajar con salidas. También hemos pasado de ejecutar código línea por línea en el shell REPL a escribir archivos Python y ejecutarlos y cargarlos en nuestro tablero. Para obtener más información sobre lo que puede hacer con MicroPython, le recomiendo que consulte la documentación oficial en el sitio web de MicroPython.

¡Espero que haya disfrutado de esta guía para comenzar con MicroPython en el ESP8266! Si tiene alguna pregunta sobre este tutorial sobre MicroPython, deje un comentario a continuación y no dude en comunicarse conmigo en Twitter. @KodyKinzie.

Foto de portada de Kody / Null Byte

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Mira también
Cerrar
Botón volver arriba
Cerrar