GPIO do Raspberry Pi com Python, sem nenhum Pi na mesa
Iniciante
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as 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.
Não há Linux na página. Seu Python roda em um pequeno motor Python (MicroPython, feito para o navegador), com gpiozero 2.0.1 e RPi.GPIO 0.7.1 escritos para se comportar como as bibliotecas reais: as mesmas classes e argumentos, os mesmos avisos, os mesmos erros. time.sleep(1) é um segundo simulado, então o que um programa mede aqui é o que ele mede em um Pi.
O circuito acima é o primeiro programa em qualquer Pi: um LED no GPIO17, pino 11 do cabeçalho, através de um resistor de 330 ohms. Aperte Rodar e ele fica ligado um segundo, desligado um segundo, e o monitor serial mostra cada mudança. Medido no pino, cada metade do ciclo tem 1000 ms com precisão de 0,2 ms.
Um botão que alterna um LED
O Button do gpiozero chama uma função sua quando é pressionado, e signal.pause() mantém o programa esperando por isso. O botão aqui vai do GPIO2 ao terra. O GPIO2 tem o pull-up de 1,8 k da própria placa, então ele lê alto até o botão ser pressionado.
Um botão de verdade trepida: seus contatos abrem e fecham por alguns milissegundos antes de estabilizar, e o simulado também. Com bounce_time=0.05 o gpiozero relata uma mudança somente depois que o pino a mantém por 50 ms, então cada pressionada alterna o LED uma vez só. Sem isso, uma pressionada pode alterná-lo mais de uma vez, como em um Pi de verdade.
# 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
Um servo no PWM do RPi.GPIO
Um servo de hobby quer um pulso a cada 20 ms, 50 Hz, e o comprimento do pulso define o ângulo. GPIO.PWM(18, 50) gera esse pulso no GPIO18, e ChangeDutyCycle() define seu comprimento como uma porcentagem dos 20 ms. Este servo lê 0,544 ms como 0 graus e 2,4 ms como 180, então 0, 45, 90, 135 e 180 graus são 2,72%, 5,04%, 7,36%, 9,68% e 12,00% de duty, e o servo no canvas se move para cada ângulo por vez.
Em um Pi de verdade, o PWM do RPi.GPIO é por software, e um Linux ocupado faz os pulsos tremerem, então o servo se agita. Aqui os pulsos são exatos. O AngularServo do gpiozero faz a conta para você; em um Pi 5 ele define o duty em porcentagem inteira, então um pulso de 50 Hz se move em passos de 10 µs, como acontece lá.
# 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()
Um sensor de distância HC-SR04 em um 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.
Configure o sensor para 100 cm e o programa imprime 100,0 cm, com precisão de 0,5 cm; a 15 cm ele imprime 15,0 cm e o LED no GPIO17 acende, porque threshold_distance=0.2 faz de 20 cm a margem de "no alcance".
# 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 ou BOARD: dois jeitos de numerar os pinos
O RPi.GPIO precisa saber como você conta. GPIO.setmode(GPIO.BCM) usa os números de GPIO do chip, que o gpiozero sempre usa: GPIO17. GPIO.setmode(GPIO.BOARD) usa a posição do pino no cabeçalho, contando a partir do pino 1 no canto: pino 11. É o mesmo pino. O programa abaixo acende os pinos 11 e 13 do cabeçalho por vez, meio segundo cada, e eles são GPIO17 e GPIO27.
Peça um pino que não é um GPIO na numeração atual, como o pino 2 de BOARD, que é 5V, e o RPi.GPIO para com "The channel sent is invalid on a Raspberry Pi", como faz em um Pi de verdade. Configure um pino duas vezes sem GPIO.cleanup() e ele avisa que o canal já está em uso, com a linha.
# 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()
Um OLED em I2C com smbus2
O barramento I2C do cabeçalho é /dev/i2c-1: SDA no GPIO2 (pino 3) e SCL no GPIO3 (pino 5), como no Raspberry Pi OS com o I2C ativado no raspi-config. smbus2 e o mais antigo smbus falam com ele, e os componentes nele respondem em seus endereços: um OLED SSD1306 em 0x3C, um BME280 em 0x76. O programa abaixo desenha texto com um pequeno driver em sua própria aba, enviando a imagem em blocos de 16 bytes do jeito que os tutoriais clássicos de Pi fazem.
O barramento roda a 100 kHz, o padrão do Raspberry Pi OS, no relógio simulado, então um quadro de 1 KB demora o mesmo que demora em uma mesa: o programa imprime 100 a 125 ms por quadro. Peça um endereço que ninguém responde e o smbus levanta OSError: [Errno 121] Remote I/O error, o erro que um fio solto dá em um Pi de verdade.
# 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)
Um potenciômetro por um MCP3008
Um Pi não tem entradas analógicas, então um botão giratório ou um sensor de luz passa por um conversor analógico-digital, e o MCP3008 é o que a documentação do gpiozero usa. Ele fica na SPI0: CLK no GPIO11, DOUT no GPIO9, DIN no GPIO10 e CS no GPIO8, que é /dev/spidev0.0. MCP3008(channel=0) o lê através do spidev, e led.source = pot entrega a leitura a um PWMLED.
O código do chip é 1024 vezes a entrada sobre sua referência, então um botão giratório em 800 de 1023 em 3,3 V lê 800, e o value do gpiozero é 0,782, escalado como o gpiozero 2.0.1 o escala. O spidev também funciona sozinho: spi.xfer2([1, 0x80, 0]) é a mesma leitura feita à mão.
# 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 em um Raspberry Pi 5
O RPi.GPIO não funciona em um Pi 5. Os pinos dele estão em um chip novo, o RP1, onde o RPi.GPIO não os encontra, e o primeiro GPIO.setup() para com RuntimeError: Cannot determine SOC peripheral base address. O Pi 5 do Mokxi faz o mesmo, e o editor diz para usar o gpiozero, que é o que a documentação do Raspberry Pi usa e que funciona nas três placas.
O que é simulado, e o que não é
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.
Não simulado: o próprio Linux, então não há desktop, terminal nem sudo; pip e apt, então só os módulos que vêm com a placa podem ser importados; rede de qualquer tipo; a câmera, a tela e o áudio; threads; e a configuração de velocidade do barramento I2C e o clock stretching, então o I2C roda nos 100 kHz padrão. O motor é MicroPython, não CPython, então algumas coisas na linguagem diferem: isinstance(True, int) é False, por exemplo. Um programa que controla os pinos roda sem mudanças.
Abra este circuito no editor. Raspberry Pi 4: gpiozero pisca um LED no GPIO17, ligado como roda no topo desta página. Mude um componente ou um valor e rode de novo.
Abrir o circuitoPerguntas
Isto é um 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.
Quais placas de Raspberry Pi existem?
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.
O I2C e o SPI funcionam?
Sim. `/dev/i2c-1`, `/dev/spidev0.0` e `0.1` estão lá, como no Raspberry Pi OS com as duas interfaces ativadas, e smbus, smbus2, spidev e o MCP3008 da gpiozero conversam com os componentes I2C e SPI do canvas na velocidade do barramento.
Posso fazer pip install de uma biblioteca?
Não. pip e apt não são simulados. Adicione o arquivo .py de uma biblioteca como uma aba própria e importe-o do main.py, o que funciona para bibliotecas escritas em Python puro.
Ele baixa alguma coisa?
O primeiro Rodar de um projeto de Raspberry Pi baixa o motor Python, cerca de 150 KB, e o navegador o guarda para todo Rodar seguinte. Um projeto de Arduino nunca o baixa.
Continuar
De onde vêm as informações desta página
Monte isto de verdade
Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.