Entradas y Salidas Digitales (GPIO MicroPython) Raspberry Pi Pico / ESP8266

En esta entrada de nuestro curso de MicroPython para principiantes, aprenderemos a utilizar los pines de proposito general para configurar entradas y salidas digitales usando nuestra tarjeta de Raspberry Pi Pico y adicionalmente en nuestra nodeMCU 8266, GPIO en MicroPython.

Antes de comenzar te invito a que le des un vistazo a nuestro curso de MicroPython enfocado principalmente en la Raspberry Pi Pico.

Y que te suscribas al canal si deseas seguir aprendiendo sobre programación de microcontroladores.

Pinout Raspberry Pi Pico y ESP8266

Cuando nos disponemos a programar cualquier tipo de microcontrolador, es importante conocer la ubicación y función de cada uno de sus pines donde incialmente debemos encontrar los GPIO a configurar en MicroPython (General Purpose Input/Output, Entrada/Salida de Propósito General).

A continuación se presentan el PINOUT de la Raspberry Pi Pico:

y también del NodeMCU8266 v3 lolin.

De los diagramas anteriores, por ahora solo nos vamos a centrar en los pines GPIO los cuales podremos configurarlos como pines digirales de entradas o como salidas.

Que son Pines Digitales

Primero, vamos a recordar que una entrada o salida digital es una señal binaria, esto quiere decir que toma únicamente 2 valores. Para el caso de la raspberry pi pico y la nodemcu8266v3 son valores de voltaje de 0V (GND) y 3.3V.

Como usar los pines GPIO con MicroPython (Raspberry Pi Pico/ESP)

Para trabajar con los pines de proposito general (entradas/salidas digitales) GPIO con MicroPython y nuestra trajeta Raspberry Pi Pico o ESP vamos a importar una biblioteca llamada machine.

import machine

De esta manera cargamos una colección de código en MicroPython conocida que contiene todas las instrucciones que MicroPython necesita para comunicarse con la Pico, el ESP y otros dispositivos compatibles con MicroPython.

Si no importamos esta biblioteca, no podremos controlar ninguno de los pines GPIO de nuestro microcontrolador.

Biblioteca Machine

El módulo de machine contiene funciones específicas relacionadas con el hardware en una placa en particular. La mayoría de las funciones de este módulo permiten lograr acceso directo y sin restricciones y control de bloques de hardware en un sistema (como CPU, temporizadores, buses, etc.).  En el stio oficial de MicroPython puedes ver todas las funciones de Machine.

IMPORTACIONES SELECTIVAS

Sin embargo, al igual que lo hacemos en Python, con MicroPython también es posible importar parte de una biblioteca, en lugar de toda la biblioteca.

Con esto podemos ahorrar memoria en el microcontrolador y podemos mezclar y combinar funciones de diferentes bibliotecas de una forma más limpia.

Por ejemplo, si solo estamos interesados en el manejo de los pines GPIO de la placa, podemos únicamente importar la función PIN de MACHINE.

from machine import pin

Salidas Digitales GPIO MicroPython

Bien sea que importemos toda la biblioteca, o únicamente importemos la función PIN, podremos definir los pines GPIO como salidas de la siguiente forma:

import machine

led = machine.Pin(25, machine.Pin.OUT) #Crea el objeto led

o equivalentemente

from machine import Pin

led = Pin(25, Pin.OUT)  #Crea el objeto led

Una vez definido el pin digital como salida en la Raspberry Pi Pico o en la nodemcu8266 podremos establecer un estado alto (HIGH) con cualquiera de las siguientes instrucciones:

led.value(1)
led.on()

O un estado bajo (LOW) con cualquiera de las siguientes instrucciones:

led.value(0)
led.off()

Retardos (utime)

Para aplicar retardos a nuestro código con Micro Python dentro de la Raspberry Pi Pico o el ESP podemos hacer uso de otra librería conocida como utime.

import utime

utime posee diversas funciones relacionadas con el manejo de tiempo dentro del microcontrolador, estas funciones puedes verlas directamente desde la página oficial de MicroPython – utime.

Dentro de las funciones que podemos destacar, son unas parecidas a las que usábamos en nuestro curso de Arduino o microcontroladores PIC, y son las funciones:

utime.sleep( segundos )

Establece un retardo en segundos. En ese tiempo el microcontrolador se queda perdiendo tiempo.

utime.sleep_ms( ms )

Retardo en milisegundos

utime.sleep_us( us )

Retardo en microsegundos

UTIME VS TIME

Normalmente cuando programamos en Python, usamos el módulo «time». Sin embargo la biblioteca «utime» es una versión diseñada para microcontroladores como la Pico: la «u» significa «μ», la letra griega «mu», que se utiliza como abreviatura de «micro». Si se te olvida y usas time al momento de la importación, no te preocupes pues MicroPython usará automáticamente la biblioteca utime en su lugar.

Ejemplo

Vamos a hacer el clasico Hola Mundo de los microcontroladores como primer programa, en este caso vamos a prender y apagar un led con nuestra placa.

Para la Raspberry Pi Pico, vamos a usar el led propio de la placa que se encuentra en el GPIO 25.

Para el NodeMCU8266v3 lolin vamos a usar un Led Externo concetado pin D1 (GPIO5).

from machine import Pin
import utime


def main():
    led = Pin(25, Pin.OUT) #Raspberry Pi Pico
    #led = Pin(5, Pin.OUT) #NodeMCU ESP8266 v3
    while True:
        #Prende y apaga por 1 segundo
        led.value(1)
        utime.sleep(1)
        led.value(0)
        utime.sleep(1)
        
        #Prende y Apaga por medio segundo
        led.on()
        utime.sleep_ms(500)
        led.off()
        utime.sleep_ms(500)
        

if __name__ == '__main__':
    main()

Entradas Digitales

Los pines GPIO en MicroPython también pueden ser definidos como entradas para poder leer eventos externos con nuestro microcontolador.

De la misma forma, vamos a necesitar importar la librería machine y en la declaración del objeto configuramos el GPIO como entrada:

Bien sea que importemos toda la biblioteca, o únicamente importemos la función PIN, podremos definir los pines GPIO como salidas de la siguiente forma:

import machine

boton = machine.Pin(15, machine.Pin.IN) #Crea el objeto boton

o equivalentemente

from machine import Pin

boton = Pin(15, Pin.IN)  #Crea el objeto boton

Es importante destacar, que las entradas en la Raspberry Pi Pico y en el nodemcu8266, o en otros microcontroladores, es posible configurar la entrada GPIO para habilitar las resistencias PULL_UP o PULL_DOWN internas de la placa y de esa forma economizamos un componente de hardware.

En el siguiente esquema se muestra como trabaja una resistencia pull_up interna y se compara con la configuración GPIO con resistencia pull_down externa.

boton_up = Pin(0, Pin.IN, Pin.PULL_UP) #Configura entrada con pull_up
boton_down = Pin(0, Pin.IN, Pin.PULL_DOWN) #Configura entrada con pull_down

Para leer el estado lógico de la entrada digital usamos la siguiente instruccion:

boton.value()

Ejemplo

Crear un código en MicroPython para la Raspberry Pi Pico o para el NodeMCUESP8266 que tenga 3 leds y 2 botones.

Un botón deberá ser configurado normalmente como entrada, mientras el otro botón deberá ser configurado con la resistencia pull_up activa.

El programa debe hacer lo siguiente:

1. Los leds deben prender y apagar uno a uno de izquierda a derecha inicialmente.
2. Si se presiona el botón de la derecha (sin pull_up) los leds deben prender y apagar uno a uno de derecha a izquierda.
3. Si se presiona el botón de la izquierda (con pull_up) los leds deben prender y apagar uno a uno de izquierda a derecha.
4. si los dos botones se presionan al tiempo, se deben prender todos los LEDs mientras los botones permanezcan presionados.

from machine import Pin
import utime


def main():
    
    # Salidas Digitales GPIO Raspberry Pi Pico
    led_amarillo = Pin(20, Pin.OUT)
    led_azul     = Pin(19, Pin.OUT)
    led_rojo     = Pin(18, Pin.OUT)
    
    # Entradas Digitales GPIO Raspberry Pi Pico
    boton_izquierda = Pin(17, Pin.IN, Pin.PULL_UP)
    boton_derecha   = Pin(16, Pin.IN)
    
    """
    # Salidas Digitales GPIO NodeMCU 8266v3
    led_amarillo = Pin(16, Pin.OUT)
    led_azul     = Pin(5, Pin.OUT)
    led_rojo     = Pin(4, Pin.OUT)
    
    # Entradas Digitales GPIO NodeMCU 8266v3
    boton_izquierda = Pin(0, Pin.IN, Pin.PULL_UP)
    boton_derecha   = Pin(2, Pin.IN)
    """
    
    # Almaceno los leds en una lista
    leds = [led_amarillo, led_azul, led_rojo]
    
    #variables de desplazamiento
    izquierda = True
    derecha   = False
    
    for i in range(3):
        leds[i].off()

    #Ciclo infinito
    while True:
        #Si presiona el botón de la izquierda
        if boton_izquierda.value() == 0:
            izquierda = True
            derecha   = False
            
        #Si presiona el botón de la derecha
        if boton_derecha.value() == 1:
            izquierda = False
            derecha   = True
            
        #Si presiona ambos botones
        if boton_izquierda.value() == 0 and boton_derecha.value() == 1 :
            izquierda = True
            derecha   = True
        
        #Rotación de leds a la izquierda
        if izquierda and not derecha:
            for i in range(3):
                leds[i].on()
                utime.sleep_ms(100)
                leds[i].off()
                utime.sleep_ms(100)
                
        #Rotación de leds a la derecha
        if not izquierda and derecha:
            for i in range(2,-1,-1):
                leds[i].on()
                utime.sleep_ms(100)
                leds[i].off()
                utime.sleep_ms(100)
                
        if  izquierda and derecha:
            for i in range(3):
                leds[i].on()
                


if __name__ == '__main__':
    main()

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.