Integração de Python com Raspberry Pi e Arduino
Sumário rápido
Visão geral e quando usar cada placa
Lista de hardware e software (prérequisitos)
Configuração inicial do Raspberry Pi
Conexão Arduino ↔ Raspberry Pi (USB serial vs TTL) — segurança e level shifting
Protocolos comuns: GPIO, I2C, SPI, UART, PWM, ADC
Exemplos práticos (com código): Firmata + pyFirmata, Serial JSON + pyserial, MCP3008 SPI ADC, DHT/BMP I2C, Servo, PWM via pigpio
Padrões de arquitetura: Pi como gateway, Arduino como sensor node, MQTT/REST, edge ML, armazenamento e dashboard
Boas práticas: energia, proteção, desempenho e segurança
Troubleshooting comum
Projetos sugeridos e ideias “fora da caixa”
Bibliotecas úteis e referências rápidas
1. Visão geral — por que integrar Pi + Arduino?
Raspberry Pi: computador Linux (Python, rede, banco de dados, web, MQTT, dashboard). Ideal como gateway, servidor, processamento/visualização, conectividade Wi-Fi/Ethernet, machine learning leve (TFLite), armazenamento local.
Arduino: microcontrolador em tempo real, ótimo para leitura de sensores analógicos, controle de PWM/servos, baixo consumo, latência determinística. Ideal como nó de sensor/atuador.
Combinar: Arduino cuida do tempo real e aquisição analógica; Pi agrega, processa, armazena, exibe e publica na nuvem.
2. Hardware e software — pré-requisitos
Hardware mínimo sugerido
Raspberry Pi (3/4/Zero 2 W) com cartão SD (Raspberry Pi OS), fonte adequada (2.5–5A dependendo do modelo/periféricos).
Arduino Uno / Nano / Pro Mini (ou Pro Mini 3.3V se fizer ligação direta com GPIO do Pi)
Cabos: micro USB / USB-C para Pi, cabo USB-A ↔ USB-B (ou micro USB) para Arduino
Protoboard, jumpers, resistor, LEDs, sensores (DHT22, BMP280, LDR), servomotor, ADC externo (MCP3008), módulo de nível lógico (level shifter), transistores e diodos para cargas.
Opcional: módulo Wi-Fi / LoRa / NRF24 para nós sem fio, fonte externa para carga.
Software (Raspberry Pi)
Raspberry Pi OS atualizado
Python 3.8+ (venv)
pip, virtualenv
Bibliotecas Python:
pyserial,pyfirmata,gpiozero,RPi.GPIO,spidev,smbus2ouadafruit-circuitpython-*,paho-mqtt,flask/fastapi,pandas,matplotlib,sqlite3(stdlib),pigpio(Opcional) Docker (arm), Node-RED, Mosquitto (MQTT broker)
Software (Arduino)
Arduino IDE ou PlatformIO
Firmata (StandardFirmata) se usar pyFirmata
Sketches simples para serial JSON se preferir protocolo próprio
3. Configuração inicial do Raspberry Pi
Atualizar OS
sudo apt update && sudo apt upgrade -y
Habilitar interfaces
raspi-config→ Interfaces: I2C, SPI, Serial (serial console OFF, serial hardware ON) (se necessário).
Instalar pacotes úteis
sudo apt install python3-venv python3-pip git i2c-tools
sudo apt install python3-rpi.gpio # opcional
Instalar pigpio (recomendado para PWM preciso)
sudo apt install pigpio python3-pigpio
sudo systemctl enable pigpiod
sudo systemctl start pigpiod
Criar virtualenv (boa prática)
python3 -m venv ~/env/pi
source ~/env/pi/bin/activate
pip install pyserial pyfirmata gpiozero spidev smbus2 paho-mqtt flask pandas matplotlib
4. Conectar Arduino ao Raspberry Pi — USB serial vs TTL direto
Conexão via USB (recomendada)
Mais segura e simples: Arduino conectado via cabo USB ao Pi. Comunicação serial por
/dev/ttyUSB0ou/dev/ttyACM0.Protege contra diferenças de voltagem (o Arduino usa seu próprio Vcc).
Conexão TTL (GPIO UART) — usar com cuidado
Pi opera em 3.3 V; Arduino Uno padrão usa 5 V. NUNCA conectar pinos 5V do Arduino diretamente ao GPIO do Pi sem conversor de nível (level shifter).
Se usar Arduino Pro Mini 3.3V ou um conversor de nível bidirecional, é possível ligar RX/TX aos pinos UART (GPIO14 TX, GPIO15 RX).
Dicas de segurança
Use ground comum (GND) quando ligar TTL.
Use conversores de nível para sinais bidirecionais.
Evite alimentar Arduino pelo 5V do Pi sem planejar corrente/consumo.
5. Protocolos e periféricos (resumo rápido)
GPIO digital — leitura/escrita simples (gpiozero ou RPi.GPIO).
PWM — servos e dimmers; Pi tem PWM limitado;
pigpioougpiozerocom hardware PWM preferíveis.I2C — sensores (BMP280, BME280, RTC), endereçamento múltiplo, nível 3.3V (não conectar 5V).
SPI — MCP3008 (ADC), displays, sensores rápidos.
ADC — Pi não tem ADC integrado: use MCP3008 (SPI) ou Arduino ADC.
UART/Serial — comunicação Raspberry Pi ↔ Arduino (via USB-serial/TTL).
USB — Arduino conectado via USB ao Pi para upload e com serial.
6. Exemplos práticos (código + wiring)
A seguir exemplos práticos. Cada exemplo vem com explicação e código para Raspberry Pi (Python) e, quando relevante, Arduino (C++ Sketch).
Exemplo A — Blink LED (Arduino) e controle via Python (USB Serial)
Objetivo: Arduino fica responsável por piscar LED ou receber comando serial para ligar/desligar um LED; Pi envia comando via serial.
Arduino (sketch):
// Sketch simples: escuta serial para 'ON'/'OFF'
const int LED_PIN = 13;
void setup() {
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
Serial.begin(9600);
}
void loop() {
if (Serial.available()) {
String cmd = Serial.readStringUntil('\n');
cmd.trim();
if (cmd == "ON") digitalWrite(LED_PIN, HIGH);
else if (cmd == "OFF") digitalWrite(LED_PIN, LOW);
}
}
Carregue no Arduino via IDE.
Raspberry Pi (Python):
import serial
import time
ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
time.sleep(2) # espera inicial
def send_cmd(cmd):
ser.write((cmd + '\n').encode())
ser.flush()
send_cmd("ON")
time.sleep(2)
send_cmd("OFF")
ser.close()
Observações: ajustar /dev/ttyACM0 para o dispositivo correto.
Exemplo B — Firmata + pyFirmata — ler analog (Arduino) e controlar relé (Pi)
Quando usar: controle de pinos Arduino via API Python (alta produtividade em prototipagem).
No Arduino: carregar StandardFirmata (na IDE: Exemplos → Firmata → StandardFirmata).
Python (pyFirmata):
from pyfirmata import Arduino, util
import time
board = Arduino('/dev/ttyACM0') # ajuste a porta
it = util.Iterator(board)
it.start()
analog0 = board.get_pin('a:0:i') # leitura analógica A0
led_pin = board.get_pin('d:13:o') # saída digital 13
try:
while True:
val = analog0.read() # None ou 0..1
if val is not None:
print("A0:", val)
if val > 0.5:
led_pin.write(1)
else:
led_pin.write(0)
time.sleep(0.5)
except KeyboardInterrupt:
board.exit()
Vantagem: você trata Arduino como "extensão de I/O" controlável por Python. Bom para protótipos.
Exemplo C — MCP3008 + SPI (ler sensor analógico no Pi)
Wiring (MCP3008 ↔ Raspberry Pi):
MCP3008 VDD -> 3.3V
MCP3008 VREF -> 3.3V
MCP3008 AGND -> GND
MCP3008 DGND -> GND
MCP3008 CLK -> GPIO11 (SCLK)
MCP3008 DOUT -> GPIO9 (MISO)
MCP3008 DIN -> GPIO10 (MOSI)
MCP3008 CS -> GPIO8 (CE0)
Python (spidev):
import spidev
import time
spi = spidev.SpiDev()
spi.open(0, 0) # bus 0, device CE0
spi.max_speed_hz = 1350000
def read_channel(channel):
adc = spi.xfer2([1, (8 + channel) << 4, 0])
data = ((adc[1] & 3) << 8) + adc[2]
return data
try:
while True:
val = read_channel(0) # 0..1023
voltage = (val * 3.3) / 1023
print(f"ADC0: {val} | Voltage: {voltage:.2f} V")
time.sleep(0.5)
except KeyboardInterrupt:
spi.close()
Exemplo D — DHT22 sensor (temperatura/umidade) no Raspberry Pi
Instalar: Adafruit_DHT (pode haver variações — use o pacote compatível).
Python:
import Adafruit_DHT
import time
sensor = Adafruit_DHT.DHT22
pin = 4 # GPIO4
while True:
humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)
if humidity is not None and temperature is not None:
print(f"Temp={temperature:.1f}C Humidity={humidity:.1f}%")
else:
print("Falha na leitura")
time.sleep(2)
Exemplo E — Arduino envia JSON via Serial; Raspberry Pi consome e armazena em SQLite
Arduino (sketch):
// Envia JSON com leitura analógica a cada 2s
void setup() {
Serial.begin(9600);
}
void loop() {
int sensor = analogRead(A0);
float voltage = sensor * (5.0 / 1023.0);
Serial.print("{\"sensor\":");
Serial.print(sensor);
Serial.print(",\"voltage\":");
Serial.print(voltage, 3);
Serial.println("}");
delay(2000);
}
Raspberry Pi (Python — pyserial + sqlite3):
import serial, json, sqlite3, time
ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
conn = sqlite3.connect('sensores.db')
c = conn.cursor()
c.execute('CREATE TABLE IF NOT EXISTS leituras (ts DATETIME DEFAULT CURRENT_TIMESTAMP, sensor INT, voltage REAL)')
try:
while True:
line = ser.readline().decode().strip()
if not line:
continue
try:
data = json.loads(line)
c.execute('INSERT INTO leituras(sensor, voltage) VALUES (?, ?)', (data['sensor'], data['voltage']))
conn.commit()
print("Inserido:", data)
except json.JSONDecodeError:
print("JSON inválido:", line)
except KeyboardInterrupt:
ser.close()
conn.close()
Exemplo F — Servo controlado pelo Raspberry Pi (gpiozero)
from gpiozero import Servo
from time import sleep
servo = Servo(17) # GPIO17 (BCM) — verificar wiring com alimentação separada se necessário
try:
while True:
servo.min()
sleep(1)
servo.mid()
sleep(1)
servo.max()
sleep(1)
except KeyboardInterrupt:
pass
Nota: servos geralmente requerem alimentação externa (5V) e GND comum com o Pi. Não alimentar pelo 3.3V do Pi.
Exemplo G — Sensor I2C (BMP280) via smbus2 ou Adafruit lib
Usar biblioteca Adafruit CircuitPython (recomendada por simplicidade):
pip install adafruit-circuitpython-bmp280
import board, busio
import adafruit_bmp280
i2c = busio.I2C(board.SCL, board.SDA)
bmp = adafruit_bmp280.Adafruit_BMP280_I2C(i2c)
print("Temperatura:", bmp.temperature)
print("Pressão:", bmp.pressure)
7. Arquiteturas e padrões de integração
Padrão 1 — Pi como gateway / Arduino como sensor node
Arduino(s) distribuídos (com cabos USB ou rádios) enviam leituras para Pi.
Pi agrega, persiste (SQLite/InfluxDB), processa (pandas) e publica (MQTT/REST).
Padrão 2 — Pi central + múltiplos Arduinos sem fio
NRF24L01 / LoRa / Wi-Fi (ESP8266/ESP32) em nós; Pi roda gateway listener.
Padrão 3 — Edge ML no Pi
Pi roda TFLite: alimenta modelos com features extraídas dos sensores (ex.: detecção de falhas, classificação de som).
Comunicação recomendada
MQTT para telemetria (leve, assíncrono, persistência no broker). Use
paho-mqttno Pi; Mosquitto como broker local.HTTP/REST para APIs ad-hoc (Flask/FastAPI).
WebSocket para dashboards em tempo real.
8. Deploy e automação
8.1 systemd — rodar script Python no boot
Arquivo: /etc/systemd/system/sensores.service
[Unit]
Description=Serviço de leitura de sensores
After=network.target
[Service]
User=pi
WorkingDirectory=/home/pi/projeto
Environment="PATH=/home/pi/env/bin"
ExecStart=/home/pi/env/bin/python /home/pi/projeto/reader.py
Restart=always
[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable sensores.service
sudo systemctl start sensores.service
sudo journalctl -u sensores.service -f
8.2 Docker (opcional)
É possível empacotar aplicações Python (Flask, consumers) em containers arm-compatíveis e rodar no Pi. Atenção ao desempenho e acesso a hardware (mount
/devou usar--privilegedquando necessário).
9. Boas práticas — eletrônica, performance e segurança
Eletrônica / Energia
Use fontes estáveis. Picos de corrente (servos, relés) não devem ser alimentados pela porta USB do Pi. Use fonte externa e compartilhe GND.
Protete entradas analógicas/digitais com resistores e diodos de roda (para cargas indutivas).
Evite alimentar sensores de 5V diretamente no Pi.
Níveis lógicos
Pi = 3.3V. Arduino Uno = 5V. Use level shifters ou use Arduino Pro Mini 3.3V variant.
Performance e latência
Para PWM/tempo crítico use Arduino (mais determinístico).
Para PWM no Pi,
pigpioé mais preciso queRPi.GPIO.Use hardware SPI/I2C para taxas altas.
Software / segurança
Não exponha services sem autenticação (Flask sem TLS é inseguro).
Use MQTT com TLS e autenticação (user/pass) para produção.
Atualize OS e pacotes; minimize portas abertas.
Proteja credenciais (use arquivos
.envesystemdsecrets ou vault).
10. Troubleshooting comum
/dev/ttyACM0 não aparece: desconecte e reconecte; verifique
dmesg | tail; usarls /dev/tty*antes/depois.Sensor I2C não é detectado: rode
i2cdetect -y 1e verifique endereços; habilite I2C noraspi-config.Leituras ADC incorretas com MCP3008: verifique VREF = 3.3V (não 5V), wiring SPI corretos.
Problemas com nível 5V: não conecte 5V a GPIO do Pi; usar level shifter.
Permissões: para acesso GPIO sem sudo, configure
gpiogroup corretamente (ou rode como root se necessário).Baixa taxa serial / buffer: ajuste
timeoute buffering empyserial.
11. Projetos sugeridos e ideias criativas (soluções que você talvez não espere)
Gateway Pi + rede de Arduinos LoRa: nós Arduinos low-power coletam dados; Pi agrega e publica para cloud com MQTT TLS.
Sistema de manutenção preditiva: Arduino com acelerômetro/ADS-B envia vibração; Pi executa modelo TFLite para detectar anomalias.
Web IDE para Arduino no Pi: hospede um serviço que permite compilar/upload via WebUSB/avrdude (usar Pi como estação de desenvolvimento remota).
Edge analytics + vector DB: Pi processa textos de sensores (logs), extrai embeddings (distilBERT pequeno) e indexa localmente para busca sem nuvem.
Rede de sensores com auto-configuração: Arduinos definem ID único, anunciam via MQTT Discovery; Pi auto-cria dashboards por nó.
Hedge automático: integrar dados de preço (yfinance), sinais de sensores (temperatura, produção) e executar ordens (simuladas) com backtesting.
12. Bibliotecas e ferramentas úteis (rápido resumo)
Python (Raspberry Pi)
pyserial— serial/USBpyfirmata— Firmata protocolRPi.GPIO,gpiozero— GPIOpigpio— PWM/servo precisospidev— SPI (MCP3008)smbus2ouadafruit-circuitpython-*— I2C sensorspaho-mqtt— MQTT clientflask/fastapi— REST APIspandas,matplotlib— análise e plots
Arduino
StandardFirmata (firmata.org)
Biblioteca
Servo,DHT,Adafruit_BMP280etc.
Conclusão e próximos passos
A integração Raspberry Pi + Arduino com Python combina controle determinístico (Arduino) com processamento, rede e visualização (Pi). Comece com experimentos simples (LED, leitura analógica) e evolua para arquiteturas mais complexas (MQTT, edge ML, dashboards). Siga boas práticas — energia, níveis lógicos e segurança — e automatize com systemd ou Docker quando for produção.
Comentários
Postar um comentário