GPIO de Raspberry Pi con Python, sin una Pi en el escritorio
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Mokxi has the Raspberry Pi 4 Model B, the Raspberry Pi 5 and the Raspberry Pi Zero 2 W on its canvas. Put one down, write main.py with gpiozero or RPi.GPIO, the two libraries every Pi tutorial uses, and press Run. Your program drives the board’s 40-pin header, and the LEDs, buttons, servos and sensors wired to it behave as they would on the bench.
No hay Linux en la página. Tu Python corre en un pequeño motor de Python (MicroPython, compilado para el navegador), con gpiozero 2.0.1 y RPi.GPIO 0.7.1 escritos para comportarse como las bibliotecas reales: las mismas clases y argumentos, las mismas advertencias, los mismos errores. time.sleep(1) es un segundo simulado, así que lo que un programa mide aquí es lo que mide en una Pi.
El circuito de arriba es el primer programa en cualquier Pi: un LED en GPIO17, el pin 11 del header, a través de una resistencia de 330 ohm. Presiona Ejecutar y está encendido un segundo, apagado un segundo, y el monitor serie muestra cada cambio. Medido en el pin, cada mitad del ciclo dura 1000 ms con una precisión de 0.2 ms.
Un botón que alterna un LED
El Button de gpiozero llama a una función tuya cuando se presiona, y signal.pause() mantiene el programa esperándolo. El botón va de GPIO2 a tierra. GPIO2 tiene su propia pull-up de 1.8 k de la placa, así que lee alto hasta que se presiona el botón.
Un botón real rebota: sus contactos se abren y cierran durante unos milisegundos antes de asentarse, y el simulado también. Con bounce_time=0.05 gpiozero reporta un cambio solo cuando el pin lo ha mantenido durante 50 ms, así que cada presión alterna el LED una sola vez. Si lo omites, una sola presión puede alternarlo más de una vez, como en una Pi real.
# A button toggles an LED, with gpiozero.
# The button is between GPIO2 (pin 3) and ground: GPIO2 has the board's own
# 1.8 k pull-up, and Button() turns the pad's pull-up on as well.
from gpiozero import Button, LED
from signal import pause
led = LED(17)
button = Button(2, bounce_time=0.05) # ignore 50 ms of contact bounce
def toggle():
led.toggle()
print("LED is", "on" if led.is_lit else "off")
button.when_pressed = toggle
pause() # wait for presses forever; Ctrl-C in the Serial Monitor stops it
Un servo con el PWM de RPi.GPIO
Un servo de hobby quiere un pulso cada 20 ms, 50 Hz, y la duración del pulso fija el ángulo. GPIO.PWM(18, 50) genera ese pulso en GPIO18, y ChangeDutyCycle() fija su duración como porcentaje de los 20 ms. Este servo lee 0.544 ms como 0 grados y 2.4 ms como 180, así que 0, 45, 90, 135 y 180 grados son 2.72%, 5.04%, 7.36%, 9.68% y 12.00% de ciclo útil, y el servo del lienzo se mueve a cada ángulo por turnos.
En una Pi real, el PWM de RPi.GPIO es por software, y un Linux ocupado hace que los pulsos tiemblen, así que un servo se sacude. Aquí los pulsos son exactos. El AngularServo de gpiozero hace la aritmética por ti; en una Pi 5 fija el ciclo útil en porcentajes enteros, así que un pulso de 50 Hz avanza en pasos de 10 µs, como lo hace ahí.
# Sweep a servo with RPi.GPIO's software PWM on a Raspberry Pi 4.
# Signal on GPIO18 (pin 12), power from 5V (pin 2), ground on pin 6.
import RPi.GPIO as GPIO
import time
SERVO = 18
GPIO.setmode(GPIO.BCM)
GPIO.setup(SERVO, GPIO.OUT)
pwm = GPIO.PWM(SERVO, 50) # 50 Hz: one pulse every 20 ms
def angle_to_duty(angle):
# This servo reads a 0.544 ms pulse as 0 degrees and 2.4 ms as 180.
pulse_ms = 0.544 + angle / 180 * 1.856
return pulse_ms / 20 * 100 # the pulse as a percentage of the 20 ms frame
pwm.start(angle_to_duty(90))
try:
while True:
for angle in (0, 45, 90, 135, 180):
pwm.ChangeDutyCycle(angle_to_duty(angle))
print(f"{angle} degrees: {angle_to_duty(angle):.2f}% duty")
time.sleep(1)
except KeyboardInterrupt:
pwm.stop()
GPIO.cleanup()
Un sensor de distancia HC-SR04 en una Pi 5
gpiozero’s DistanceSensor sends the HC-SR04 a trigger pulse and times the echo. The echo is a 5 V signal, more than a Pi’s 3.3 V pin can take, so it comes through a 1 k and 2 k divider: 5 V times 2/3 is 3.3 V. Leave the divider out and the Circuit Doctor says so.
Ajusta el sensor a 100 cm y el programa imprime 100.0 cm, con una precisión de 0.5 cm; a 15 cm imprime 15.0 cm y el LED en GPIO17 se enciende, porque threshold_distance=0.2 pone 20 cm en el borde de “dentro de rango”.
# An HC-SR04 with gpiozero on a Raspberry Pi 5.
# TRIG on GPIO23 (pin 16). ECHO is a 5 V signal, so it reaches GPIO24 (pin 18)
# through a 1 k and 2 k divider: 5 V x 2/3 is 3.3 V, all a Pi's pin can take.
from gpiozero import DistanceSensor, LED
from time import sleep
sensor = DistanceSensor(echo=24, trigger=23, max_distance=2, threshold_distance=0.2)
led = LED(17)
sensor.when_in_range = led.on # closer than 20 cm: the LED lights
sensor.when_out_of_range = led.off
while True:
print(f"{sensor.distance * 100:.1f} cm")
sleep(0.5)
BCM o BOARD: dos formas de numerar los pines
Hay que decirle a RPi.GPIO cómo cuentas. GPIO.setmode(GPIO.BCM) usa los números de GPIO del chip, que gpiozero siempre usa: GPIO17. GPIO.setmode(GPIO.BOARD) usa la posición del pin en el header, contando desde el pin 1 en la esquina: pin 11. Son el mismo pin. El programa de abajo enciende por turnos los pines 11 y 13 del header, medio segundo cada uno, y son GPIO17 y GPIO27.
Pide un pin que no es un GPIO con la numeración actual, como el pin 2 de BOARD, que es 5V, y RPi.GPIO se detiene con “The channel sent is invalid on a Raspberry Pi”, como lo hace en una real. Configura un pin dos veces sin GPIO.cleanup() y advierte que el canal ya está en uso, con la línea.
# RPi.GPIO with BOARD numbering: pins by their place on the header.
# Header pin 11 is GPIO17 and pin 13 is GPIO27. With GPIO.setmode(GPIO.BCM)
# the same two LEDs would be 17 and 27.
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
LEDS = [11, 13]
GPIO.setup(LEDS, GPIO.OUT, initial=GPIO.LOW)
try:
while True:
for pin in LEDS:
GPIO.output(pin, GPIO.HIGH)
print("header pin", pin, "on")
time.sleep(0.5)
GPIO.output(pin, GPIO.LOW)
finally:
GPIO.cleanup()
Un OLED en I2C con smbus2
El bus I2C del header es /dev/i2c-1: SDA en GPIO2 (pin 3) y SCL en GPIO3 (pin 5), como en Raspberry Pi OS con I2C activado en raspi-config. smbus2 y el más antiguo smbus le hablan, y los componentes en él responden en sus direcciones: un OLED SSD1306 en 0x3C, un BME280 en 0x76. El programa de abajo dibuja texto con un pequeño driver en su propia pestaña, enviando la imagen en bloques de 16 bytes a la manera de los tutoriales clásicos de Pi.
El bus corre al valor predeterminado de 100 kHz de Raspberry Pi OS en el reloj simulado, así que un fotograma de 1 KB tarda lo mismo que en un escritorio: el programa imprime de 100 a 125 ms por fotograma. Pide una dirección que nadie responde y smbus lanza OSError: [Errno 121] Remote I/O error, el error que da un cable flojo en una Pi real.
# An SSD1306 OLED on a Raspberry Pi 4, over smbus2.
# SDA to GPIO2 (pin 3), SCL to GPIO3 (pin 5), VCC to 3V3 (pin 1), GND (pin 9).
# ssd1306_smbus.py is a small driver in its own tab.
import time
from ssd1306_smbus import SSD1306
oled = SSD1306(bus=1, address=0x3C) # /dev/i2c-1, the header's I2C bus
start = time.monotonic()
while True:
seconds = int(time.monotonic() - start)
oled.fill(0)
oled.text("Hello, Pi!", 0, 0)
oled.text("smbus2 on i2c-1", 0, 16)
oled.text("up %d s" % seconds, 0, 40)
t = time.monotonic()
oled.show() # 1 KB at 100 kHz: about a tenth of a second
print("frame", seconds, "took %.0f ms" % ((time.monotonic() - t) * 1000))
time.sleep(1)
Un potenciómetro a través de un MCP3008
Una Pi no tiene entradas analógicas, así que una perilla o un sensor de luz pasa por un convertidor analógico a digital, y el MCP3008 es el que usa la documentación de gpiozero. Va en SPI0: CLK a GPIO11, DOUT a GPIO9, DIN a GPIO10 y CS a GPIO8, que es /dev/spidev0.0. MCP3008(channel=0) lo lee a través de spidev, y led.source = pot pasa la lectura a un PWMLED.
El código del chip es 1024 veces la entrada sobre su referencia, así que una perilla girada a 800 de 1023 en 3.3 V lee 800, y el value de gpiozero es 0.782, escalado como lo escala gpiozero 2.0.1. spidev también funciona por sí solo: spi.xfer2([1, 0x80, 0]) es la misma lectura a mano.
# A potentiometer through an MCP3008 on a Raspberry Pi 5, with gpiozero.
# The Pi has no analog inputs, so the MCP3008 converts: CLK to GPIO11 (pin 23),
# DOUT to GPIO9 (pin 21), DIN to GPIO10 (pin 19), CS to GPIO8 (pin 24, CE0).
from gpiozero import MCP3008, PWMLED
from time import sleep
pot = MCP3008(channel=0) # spidev0.0: SPI0 with chip select CE0
led = PWMLED(18)
led.source = pot # the knob sets the LED's brightness
while True:
print("value %.3f raw %4d %.2f V" % (pot.value, pot.raw_value, pot.voltage))
sleep(0.5)
RPi.GPIO en una Raspberry Pi 5
RPi.GPIO no funciona en una Pi 5. Sus pines están en un chip nuevo, el RP1, donde RPi.GPIO no puede encontrarlos, y el primer GPIO.setup() se detiene con RuntimeError: Cannot determine SOC peripheral base address. La Pi 5 de Mokxi hace lo mismo, y el editor dice que uses gpiozero, que es lo que usa la documentación de Raspberry Pi y que funciona en las tres placas.
Qué se simula y qué no
Simulated: the 40-pin header of each board, with its 3.3 V and 5 V pins and its grounds, GPIO 0 to 27 as inputs with their pull-ups and pull-downs or as 3.3 V outputs, PWM, edge callbacks with their debounce, I2C and SPI through smbus, smbus2, spidev and gpiozero’s SPI devices, and Python’s time on the simulated clock. print() and input() use the Serial Monitor, and Ctrl-C stops the program with KeyboardInterrupt.
No simulado: Linux mismo, así que no hay escritorio, ni terminal, ni sudo; pip y apt, así que solo se pueden importar los módulos que vienen con la placa; redes de cualquier tipo; la cámara, la pantalla y el audio; hilos; y el ajuste de velocidad del bus I2C y el estiramiento de reloj, así que I2C corre al valor predeterminado de 100 kHz. El motor es MicroPython, no CPython, así que algunas cosas del lenguaje difieren: isinstance(True, int) es False, por ejemplo. Un programa que controla los pines corre sin cambios.
Abre este circuito en el editor. Raspberry Pi 4: gpiozero hace parpadear un LED en GPIO17, cableado como corre en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿Es esto un emulador completo de Raspberry Pi?
No. There is no Linux and no Arm processor in the page. Your Python program runs in a Python engine in the browser, and its gpiozero and RPi.GPIO drive the board’s 40-pin header. Everything a circuit can see of a Pi is there; the desktop, the shell and the operating system are not.
¿Qué placas de Raspberry Pi hay?
The Raspberry Pi 4 Model B, the Raspberry Pi 5 and the Raspberry Pi Zero 2 W, each with the same 40-pin header. RPi.GPIO works on the Pi 4 and the Zero 2 W and fails on the Pi 5, as it does on the real one; gpiozero works on all three.
¿Funcionan I2C y SPI?
Sí. `/dev/i2c-1`, `/dev/spidev0.0` y `0.1` están ahí, como en Raspberry Pi OS con ambas interfaces activadas, y smbus, smbus2, spidev y el MCP3008 de gpiozero se comunican con los componentes I2C y SPI del lienzo a la velocidad del bus.
¿Puedo instalar una biblioteca con pip?
No. pip y apt no se simulan. Agrega el archivo .py de una biblioteca como una pestaña propia e impórtalo desde main.py, lo que funciona para bibliotecas escritas en Python puro.
¿Descarga algo?
La primera ejecución de un proyecto de Raspberry Pi descarga el motor de Python, unos 150 KB, y el navegador lo conserva para cada ejecución posterior. Un proyecto de Arduino nunca lo descarga.
Sigue así
De dónde vienen los datos de esta página
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.