MicroPython con ESP32 y ESP8266: Interactuando con GPIO

En este artículo exploraremos cómo interactuar con los pines GPIO de los microcontroladores ESP32 y ESP8266 utilizando MicroPython. Aprenderemos a controlar luces, sensores y otros dispositivos a través de la programación en este lenguaje amigable y versátil. ¡Prepárate para sumergirte en el emocionante mundo de la programación de hardware con estos poderosos microcontroladores!

En este artículo, veremos cómo interactuar con los GPIO ESP32 y ESP8266 usando MicroPython. Le mostraremos cómo leer entradas digitales y analógicas, controlar salidas digitales y generar señales PWM.

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

requisitos

Para programar ESP32 y ESP8266 con MicroPython, utilizamos uPyCraft IDE como entorno de programación. Siga los siguientes tutoriales para instalar uPyCraft IDE y actualizar el firmware MicroPython en su placa:

  • Instale uPyCraft IDE: PC con Windows, MacOS X o Linux Ubuntu
  • Flashear/cargar firmware MicroPython a ESP32 y ESP8266

Si tiene problemas al usar uPyCraftIDE, le recomendamos usar Thonny IDE en su lugar: Introducción a Thonny MicroPython (Python) IDE para ESP32 y ESP8266

Si es la primera vez que trabaja con MicroPython, es posible que le resulten útiles los siguientes tutoriales:

  • Comenzando con MicroPython en ESP32 y ESP8266
  • Conceptos básicos de la programación MicroPython con ESP32 y ESP8266

Descripción del proyecto

En este tutorial aprenderá a utilizar los GPIO ESP32 o ESP8266 con MicroPython. Puede leer instrucciones separadas para cada tema:

  • Leer entradas digitales
  • Control de salidas digitales
  • Leer entradas analógicas
  • Generar señales PWM

Creemos un ejemplo simple que funcione así:

MicroPython con ESP32 y ESP8266: Interactuando con GPIO
  • Lea el voltaje de un potenciómetro y atenúe un LED según la posición del eje del potenciómetro.
MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Esquema

El circuito para este proyecto incluye el cableado de dos LED, un pulsador y un potenciómetro. Aquí hay una lista de todas las piezas necesarias para construir el circuito:

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

ESP32 – diagrama de circuito

Siga el siguiente diagrama esquemático si está utilizando un ESP32:

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Nota: El ESP32 admite lectura analógica en varios GPIO: 0, 2, 4, 12, 13, 14, 15, 25, 26, 27 32, 33, 34, 35, 36 y 39.

Recomendaciones de literatura: Referencia de distribución de pines de ESP32: ¿Qué pines GPIO debería utilizar?

ESP8266 – Diagrama de circuito

Siga el siguiente esquema si está utilizando un ESP8266:

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Nota: El ESP8266 solo admite lectura analógica en el pin ADC0 (A0).

código

Copie el siguiente código en el principal.py Archivo en el IDE de uPyCraft.

Nota: La lectura analógica funciona de manera diferente para ESP32 y ESP8266. Con ESP32 el código funciona inmediatamente. Para usarlo con ESP8266, debe descomentar y descomentar las líneas descritas en el script MicroPython.

# Complete project details at https://RandomNerdTutorials.com
# Created by Rui Santos

from machine import Pin, ADC, PWM
from time import sleep

led = Pin(2, Pin.OUT)
button = Pin(15, Pin.IN)

#Configure ADC for ESP32
pot = ADC(Pin(34))
pot.width(ADC.WIDTH_10BIT)
pot.atten(ADC.ATTN_11DB)

#Configure ADC for ESP8266
#pot = ADC(0)

led_pwm = PWM(Pin(4),5000)

while True:
  button_state = button.value()
  led.value(button_state)

  pot_value = pot.read()
  led_pwm.duty(pot_value)

  sleep(0.1)

Ver código sin formato

Así es como funciona el código

Continúe leyendo para saber cómo funciona el código.

Importando bibliotecas

Para interactuar con los GPIO, debe tener la máquina Módulo que contiene clases para interactuar con los GPIO. Importar el Bolígrafo Clase para interactuar con los pines que CAD Clase para leer valores analógicos y el PWM Clase para generar señales PWM.

from machine import Pin, ADC, PWM

Importar el dormir() método de la Tiempo El dormir() Este método le permite agregar retrasos al código.

from time import sleep

Pines de creación de instancias

Después de importar todos los módulos necesarios, cree una instancia de uno Bolígrafo Objeto nombrado CONDUJO En GPIO2 este es un PROBLEMA.

led = Pin(2, Pin.OUT)

El Bolígrafo El objeto acepta los siguientes atributos en el siguiente orden:

Pin(Pin number, pin mode, pull, value)
  • alfiler se refiere al GPIO que queremos controlar;
  • Modo de fijación se puede introducir (EN), Producción (FUERA DE) o drenaje abierto (DRENAJE ABIERTO);
  • El jalar El argumento se utiliza cuando queremos activar una resistencia interna pull-up o pull-down (PARA LEVANTARo DERRIBAR);
  • El Valorcorresponde al estado GPIO (ya sea encendido o apagado): puede 0 o 1 (Bien o mal). Actitud 1 significa que el GPIO está encendido. Si no pasamos un parámetro, su estado es 0 de forma predeterminada (eso es lo que haremos en este ejemplo).

Después de instanciar el CONDUJO objeto, necesita otra instancia del Bolígrafo Clase para el pulsador. El pulsador está conectado a GPIO 15 y se establece como entrada. Entonces se ve así:

button = Pin(15, Pin.IN)

Crear una instancia de ADC

Para tener uno en el ESP32 CAD Objeto para el potenciómetro en GPIO 34:

pot = ADC(Pin(34))

Si usa un ESP8266, solo admite ADC en el pin ADC0 (A0). Para crear una instancia de un objeto ADC usando ESP8266:

pot = ADC(0)

La siguiente línea solo se aplica al ESP32. Define que queremos poder leer el voltaje en todo el rango. Eso significa que queremos leer voltajes de 0 a 3,3 V.

pot.atten(ADC.ATTN_11DB)

La siguiente línea significa que queremos lecturas con una resolución de 10 bits (de 0 a 1023).

pot.width(ADC.WIDTH_10BIT)

El Ancho() El método acepta otros parámetros para establecer otras resoluciones:

  • ANCHO_9BIT: Rango 0 a 511
  • ANCHO_10BIT: Rango 0 a 1023
  • ANCHO_11BIT: Rango 0 a 2047
  • ANCHO_12BIT: Rango 0 a 4095

Si no especifica la resolución, el ESP32 tiene por defecto una resolución de 12 bits.

Crear una instancia de PWM

Luego crea uno PWM Objeto nombrado led_pwm En GPIO4 con 5000 Hz.

led_pwm = PWM(Pin(4), 5000)

Aquí se explica cómo crear uno. PWM Objeto que debe pasar como parámetros: pin, frecuencia de señal y ciclo de trabajo.

El frecuencia puede ser un valor entre 0 y 78125. Una frecuencia de 5000 Hz es completamente suficiente para un LED.

El nivel de utilización puede ser un valor entre 0 y 1023. Donde 1023 corresponde a un ciclo de trabajo del 100% (brillo total) y 0 corresponde a un ciclo de trabajo del 0% (LED apagado).

Simplemente configuramos el ciclo de trabajo en el ciclo while, por lo que no necesitamos pasar el parámetro del ciclo de trabajo en este momento. Si configura el ciclo de trabajo al crear una instancia del PWM Objeto, el valor predeterminado es 0.

Obtener estado GPIO

Luego tenemos un bucle while que siempre es Verdadero. Esto es similar a eso Cinta() Función en el IDE de Arduino.

Comenzamos obteniendo el estado del botón y guardándolo en el Estado del botón Variable. Para obtener el estado del PIN, utilice el Valor() Método de la siguiente manera:

button_state = button.value()

Esto devuelve 1 o 0 dependiendo de si se presiona la tecla o no.

Configuración del estado de GPIO

Para configurar el estado del PIN, utilice el Valor (estado) método en el Bolígrafo Objeto. En este caso fijamos el Estado del botón Variable como argumento. Así se enciende el LED cuando pulsamos el pulsador:

led.value(button_state)

Lectura de entradas analógicas

Para leer una entrada analógica, utilice el leer() método en uno CAD Objeto (en este caso se llama objeto ADC Maceta).

pot_value = pot.read()

Control del ciclo de trabajo.

Para controlar el ciclo de trabajo, utilice el Deber() Método en el objeto PWM (led_pwm). El Deber() El método acepta un valor entre 0 y 1023 (donde 0 corresponde a un ciclo de trabajo del 0 % y 1023 corresponde a un ciclo de trabajo del 100 %). Entonces pasa el como argumento. valor_pot (Esto varía entre 0 y 1023). De esta manera cambias el ciclo de trabajo girando el potenciómetro.

led_pwm.duty(pot_value)

Probando el código

Descargar el principal.py Archivo en su ESP32 o ESP8266. Para hacer esto, abra uPyCraft IDE y copie el código proporcionado en el principal.py Archivo. Ir a Herramientas > De serie y seleccione el puerto serie. Elige tu tabla en Herramientas > tablón.

A continuación, cargue el código en ESP32 o ESP8266 usando el Descargar y ejecutar Botón.

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Nota: Para familiarizarse con el IDE de uPyCraft, puede leer el siguiente tutorial: Introducción a MicroPython en ESP32 y ESP8266

Después de cargar el código, presione el botón EN/RST incorporado del ESP32/ESP8266 para ejecutar el nuevo script.

Ahora prueba tu configuración. El LED debe encenderse cuando presiona el botón.

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Al girar el potenciómetro se cambia el brillo del LED.

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Envolver

Este sencillo ejemplo le mostró cómo leer entradas digitales y analógicas, controlar salidas digitales y generar señales PWM con las placas ESP32 y ESP8266 usando MicroPython.

Si te gusta MicroPython, es posible que también te gusten los siguientes proyectos:

  • ESP32/ESP8266 MicroPython interrumpe
  • MicroPython: LED RGB direccionables WS2812B con ESP32/ESP8266
  • Registrador de datos de estación meteorológica de bajo consumo que utiliza ESP8266 y BME280 con MicroPython
  • Servidor web ESP32/ESP8266 MicroPython

Esperamos que este artículo sobre el control de GPIO ESP32 y ESP8266 con MicroPython le haya resultado útil. Si desea obtener más información sobre MicroPython, asegúrese de consultar nuestro libro electrónico: Programación MicroPython con ESP32 y ESP8266.

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

En este artículo vamos a explorar cómo interactuar con los GPIO de ESP32 y ESP8266 utilizando MicroPython. Te mostraremos cómo leer entradas digitales y analógicas, cómo controlar salidas digitales y cómo generar señales PWM.

Prerrequisitos

Para programar el ESP32 y ESP8266 con MicroPython, utilizamos el IDE uPyCraft como entorno de programación. Sigue los siguientes tutoriales para instalar el IDE uPyCraft y flashear el firmware de MicroPython en tu placa:

  1. Instalar IDE uPyCraft: Windows PC, MacOS X, o Linux Ubuntu
  2. Flashear/Cargar Firmware de MicroPython en ESP32 y ESP8266

Alternativamente, si encuentras dificultades utilizando uPyCraft IDE, recomendamos utilizar el IDE Thonny en su lugar: Getting Started with Thonny MicroPython (Python) IDE for ESP32 and ESP8266

Si esta es tu primera vez trabajando con MicroPython, los siguientes tutoriales pueden serte útiles:

  1. Comenzando con MicroPython en ESP32 y ESP8266
  2. Conceptos Básicos de Programación con MicroPython en ESP32 y ESP8266

Visión General del Proyecto

Con este tutorial aprenderás cómo utilizar los GPIO de ESP32 o ESP8266 con MicroPython. Puedes consultar la guía individual para cada tema:

  1. Leer entradas digitales
  2. Controlar salidas digitales
  3. Leer entradas analógicas
  4. Generar señales PWM

Vamos a construir un ejemplo simple que funciona de la siguiente manera:

  • Leer el estado de un pulsador y ajustar el estado del LED en consecuencia – cuando presionas el pulsador, el LED se enciende.
  • Leer el voltaje de un potenciómetro y atenuar un LED según la posición del eje del potenciómetro.

Esquemático

El circuito para este proyecto involucra cablear dos LEDs, un pulsador y un potenciómetro. Aquí tienes una lista de todas las piezas necesarias para construir el circuito:

  • ESP32 o ESP8266
  • 2 LEDs
  • 2 resistencias de 330 Ohmios
  • Pulsador
  • Potenciómetro
  • Protoboard
  • Cables de conexión

Puedes encontrar todas las partes para tus proyectos al mejor precio en MakerAdvisor.com/tools.

ESP32 – Esquemático

Sigue el siguiente diagrama esquemático si estás utilizando un ESP32:

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Nota: el ESP32 soporta lectura analógica en varios GPIOs: 0, 2, 4, 12, 13, 14, 15, 25, 26, 27 32, 33, 34, 35, 36 y 39.

Lectura recomendada: ESP32 Pinout Reference: ¿Qué pines GPIO debes utilizar?

ESP8266 – Esquemático

Sigue el siguiente diagrama esquemático si estás utilizando un ESP8266:

MicroPython con ESP32 y ESP8266: Interactuando con GPIO

Nota: el ESP8266 solo soporta lectura analógica en el pin ADC0 (A0).

Código

Copia el siguiente código al archivo main.py en el IDE uPyCraft:

Nota: la lectura analógica funciona de manera diferente en ESP32 y ESP8266. El código funciona directamente en ESP32. Para utilizar con ESP8266, debes descomentar y comentar las líneas descritas en el script de MicroPython.

View raw code

Cómo funciona el código

Continúa leyendo para aprender cómo funciona el código.

Importando Librerías

Para interactuar con los GPIOs, necesitas importar el módulo machine que contiene las clases para interactuar con los GPIOs. Importa la clase Pin para interactuar con los pines, la clase ADC para leer valores analógicos y la clase PWM para generar señales PWM.

Importa también el método sleep() del módulo time. El método sleep() te permite agregar retardos al código.

Instantiating Pins

Después de importar todos los módulos necesarios, instanciamos un objeto Pin llamado led en el GPIO 2 que es una SALIDA.

El objeto Pin acepta los siguientes atributos en el siguiente orden:

  • Número del pin se refiere al GPIO que queremos controlar.
  • El modo de pin puede ser de entrada (IN), salida (OUT) o de drenaje abierto (OPEN_DRAIN).
  • El argumento de resistencia se utiliza si queremos activar una resistencia interna de pull-up o pull-down (PULL_UP, o PULL_DOWN).
  • El valor corresponde al estado del GPIO (si está encendido o apagado). Puede ser 0 o 1 (Verdadero o Falso).

Después de instanciar el objeto led, necesitas otra instancia de la clase Pin para el pulsador. El pulsador está conectado al GPIO 15 y se configura como una entrada.

Instantiating ADC

En el ESP32, para crear un objeto ADC para el potenciómetro en el GPIO 34:

Si estás utilizando un ESP8266, solo soporta ADC en el pin ADC0 (A0). Para instanciar un objeto ADC con el ESP8266:

La siguiente línea aplica solo al ESP32. Define que queremos poder leer voltaje en todo el rango. Esto significa que queremos leer voltaje de 0 a 3.3 V.

La siguiente línea significa que queremos lecturas con una resolución de 10 bits (de 0 a 1023).

El método width() acepta otros parámetros para configurar otras resoluciones:

  • WIDTH_9BIT: rango de 0 a 511
  • WIDTH_10BIT: rango de 0 a 1023
  • WIDTH_11BIT: rango de 0 a 2047
  • WIDTH_12BIT: rango de 0 a 4095

Si no especificas la resolución, por defecto será de 12 bits en el ESP32.

Instantiating PWM

Luego, creamos un objeto PWM llamado led_pwm en el GPIO 4 con una frecuencia de 5000 Hz.

Para crear un objeto PWM, necesitas pasar como parámetros: pin, frecuencia de la señal, y ciclo de trabajo.

La frecuencia puede ser un valor entre 0 y 78125. Una frecuencia de 5000 Hz para un LED funciona muy bien.

El ciclo de trabajo puede ser un valor entre 0 y 1023. Donde 1023 corresponde a un ciclo de trabajo del 100% (brillo completo) y 0 corresponde a un ciclo de trabajo del 0% (LED apagado).

Solo configuramos el ciclo de trabajo en el bucle while, por lo que no necesitamos pasar el parámetro de ciclo de trabajo al instanciar el objeto PWM. Si no configuras el ciclo de trabajo al instanciar el objeto PWM, será 0 por defecto.

Probamos el código

Sube el archivo main.py a tu ESP32 o ESP8266. Para eso, abre el IDE uPyCraft y copia el código proporcionado al archivo main.py. Ve a Herramientas > Serial y selecciona el puerto serie. Selecciona tu placa en Herramientas > Placa.

Luego, carga el código al ESP32 o ESP8266 presionando el botón Descargar y Ejecutar.

Después de subir el código, presiona el botón EN/RST de la placa ESP32/ESP8266 para ejecutar el nuevo script.

Ahora, prueba tu configuración. El LED debería encenderse cuando presiones el pulsador.

El brillo del LED cambia cuando giras el potenciómetro.

Conclusión

Este simple ejemplo te mostró cómo leer entradas digitales y analógicas, controlar salidas digitales y generar señales PWM con las placas ESP32 y ESP8266 utilizando MicroPython.

Si te gusta MicroPython, es posible que te interesen los siguientes proyectos:

  • Interrupciones de MicroPython en ESP32/ESP8266
  • MicroPython: LEDs RGB Addressable WS2812B con ESP32/ESP8266
  • Estación Meteorológica de Bajo Consumo con ESP8266 y BME280 con MicroPython
  • Servidor Web MicroPython ESP32/ESP8266

Esperamos que hayas encontrado útil este artículo sobre cómo controlar los GPIO de ESP32 y ESP8266 con MicroPython. Si deseas aprender más sobre MicroPython, asegúrate de consultar nuestro eBook: MicroPython Programming with ESP32 and ESP8266.

Gracias por leer.

5 comentarios en «MicroPython con ESP32 y ESP8266: Interactuando con GPIO»

Deja un comentario