Funções e aplicações GPIO no Raspberry Pi

Muitas vezes se ouve dizer que os computadores de placa única Raspberry Pi são uma forma muito conveniente de iniciar uma aventura em eletrônica. Mas onde realmente se encontram os mundos da programação teórica e da placa de circuito impresso?

Resumo, ou seja, para os impacientes

Já está tudo pronto e você já quer começar a programar? Vá aqui.

Introdução

Os computadores Raspberry Pi foram desenvolvidos como uma ferramenta educacional. Seguindo o exemplo dos "microcomputadores" britânicos dos anos 80 (inspirados pelos produtos da Commodore ou Apple), eles foram projetados para oferecer ampla adaptabilidade a baixo custo. E esse objetivo foi alcançado. Os modelos Raspberry Pi da família Zero são até incrivelmente acessíveis, enquanto o fabricante e a enorme comunidade de engenheiros/entusiastas oferecem uma quantidade incontável de materiais didáticos, auxiliares, bibliotecas, etc. Na verdade, tudo o que você precisa para desenvolver suas habilidades usando o Raspberry Pi é entusiasmo. E um pouco de tempo.

Do ponto de vista da eletrônica, a funcionalidade mais importante (e certamente a mais única) do Raspberry Pi é a capacidade de conectar diretamente o computador a componentes eletrônicos, eletromecânicos etc. Isso é feito por meio do conector GPIO — que não se encontra em laptops ou computadores de mesa. É a saída das interfaces do microprocessador e de outros componentes da placa-mãe, que em outros dispositivos são inacessíveis ao usuário. Vamos analisar esse conector e suas capacidades.

Neste artigo abordamos tópicos como:

• Uma discussão sobre o GPIO e suas várias funções
• Interfaces de comunicação do Raspberry Pi
• Como evitar falhas na aprendizagem e no desenvolvimento de projetos
• Os ambientes de desenvolvimento mais importantes para o RPi
• Bibliotecas Python para manipular as pinagens GPIO
• Suporte para entrada e saída digital dos pinos
• Conectando uma lâmpada de 230V ao Raspberry Pi
• Geração de sinais de onda quadrada
• Introdução à interface I2C
• Produtos que utilizam o conector GPIO

O que é um GPIO?

GPIO significa General Purpose Input/Output, ou seja, entrada/saída de uso geral. E, de fato, é isso que a conexão específica na placa-mãe do RPi oferece. Ele passou por apenas pequenas mudanças desde a segunda geração do computador e agora é estritamente padronizado, garantindo compatibilidade entre diferentes versões do dispositivo, sempre no mesmo formato e oferecendo as mesmas (ou pelo menos quase idênticas) capacidades.

Para o formato do conector, foi escolhido o popular conector "pin" no raster de 2,54 mm (0,1 polegada), comumente usado em eletrônica, e principalmente — na educação. O espaçamento dos pinos compatível é baseado, por exemplo, em placas de prototipagem, módulos arduino e (literalmente) milhões de componentes.

Layout, tipos e capacidades dos pinos individuais

A documentação detalhada do GPIO está amplamente disponível na Internet, então aqui vamos discutir apenas o básico — e prestar especial atenção às funções que podem ser usadas praticamente imediatamente após o boot do computador. A tabela a seguir mostra o espaçamento dos pinos (para referência: o pino nº 2 está localizado próximo ao canto da placa):

O conector GPIO está sempre na mesma posição relativa aos furos de montagem.

Alimentação

Os pinos de alimentação são divididos entre aqueles que fornecem tensão de 3,3V CC (1, 17), 5,0V CC (2, 4) e aterrados no sistema (6, 9, 14, 20, 25, 30, 34, 39). A corrente máxima retirada dos pinos GPIO é limitada e depende de vários fatores. Embora teoricamente o circuito de alimentação presente na placa-mãe possa fornecer 1A na linha de 3,3V, essa energia é compartilhada entre todos os componentes presentes na placa. No caso dos pinos de 5,0V — eles são curtos-circuitos com a linha de alimentação de todo o computador, de modo que a limitação é a eficiência das fontes de alimentação usadas e o consumo atual do computador (que varia dependendo do modelo, software em execução, etc.). Os pinos GND compartilham o polo terra com toda a placa-mãe.

Entradas/saídas digitais

Todos os pinos marcados como GPIO podem atuar como entradas e saídas digitais, bem como em funções relacionadas executadas via software (por exemplo, geração de sinal PWM, emulação da interface i²C). O usuário pode configurar livremente seu estado lógico, que corresponderá às tensões 0V para o estado baixo e 3,3V para o estado alto. Também é possível configurar esses contatos para atuar como entradas, ou seja, verificar se foi conectado a eles uma tensão de 3,3V ou 0V — isso possibilita operar, por exemplo, botões e interruptores, lendo seu estado.

Observe que em nenhuma hipótese deve-se aplicar uma tensão superior a 3,3V — isso causará danos permanentes ao computador.

Da mesma forma: a corrente retirada dos pinos, quando atuam como saída, não deve exceder alguns miliamperes.

Interfaces de comunicação serial

Na prática, o funcionamento dos circuitos eletrônicos modernos baseia-se em interfaces de comunicação, como UART, I²C, SPI etc. São métodos de comunicação serial, ou seja, que envolvem a transmissão de dados bit a bit. Essa comunicação pode ser implementada de forma "hardware" (manipulada por um circuito especializado) ou "software" (o processador supervisiona diretamente a transmissão e recepção de sinais por meio de entradas e saídas digitais). No primeiro caso, o usuário é obrigado a usar os pinos que os projetistas designaram para uma função específica; no segundo caso, ele pode escolher livremente os pontos de conexão, mas a comunicação pode atrapalhar ou atrasar a operação do programa — mas temporariamente, em um nível básico, esses problemas podem ser ignorados com segurança.

I²C

O barramento I²C (jogo de palavras com Inter-Integrated Circuit) é muito popular em outros dispositivos eletrônicos — mas também em projetos amadores. Isso se deve à sua simplicidade que facilita a emulação por software, a possibilidade de conectar muitos periféricos, grande tolerância em termos de velocidade de transmissão, bem como a ampla disponibilidade de componentes e sensores compatíveis com o padrão. Apenas duas linhas são necessárias para a interface funcionar: a linha de relógio (SCL, do signal clock, pino 5) e a de dados (SDA, signal data, pino 3). É possível conectar (teoricamente) 128 chips independentes ao barramento (incluindo o chip hospedeiro, que no nosso caso é o Raspberry Pi) — cada um deve ter um endereço único (geralmente definido em certo grau).

SPI

A interface serial SPI ( Serial Peripheral Interface) funciona de modo um pouco diferente do I²C, privilegiando a resiliência na transmissão. O GPIO no Raspberry Pi possui duas dessas interfaces, mas aqui vamos focar apenas na padrão (numerada 0).

Na comunicação SPI, em vez de endereçar chips individuais no barramento, cada um recebe sua própria linha CE (Chip Enable), que é usada para ativar a comunicação com um periférico dado (os pinos 24 e 26 permitem manipular dois receptores independentes). Fora isso, a comunicação é feita usando duas linhas independentes: uma que conduz do circuito mestre (Master) para o escravo (Slave), i.e., Master Out, Slave In (MOSI , pino 21); e na direção inversa: Master In, Slave Out (MISO), pino 10). A última linha é o sinal de relógio, CLK no pino 23.

O SPI permite uma comunicação mais rápida que o I²C, podendo ocorrer no modo full-duplex (transmissão simultânea de dados em ambas as direções). O protocolo é simples e flexível. Muitas memórias e módulos usam esse método de transmissão.

UART

No passado, a "porta serial" era o equipamento básico de todo computador, hoje sua função é assumida pelo padrão derivado USB. UART significa Universal Asynchronous Receiver-Transmitter, ou seja, receptor-transmissor universal assíncrono. É um método de comunicação usado há muitas décadas, principalmente para envio de comandos em forma alfanumérica. Como no RPi essa interface é suportada em hardware, o manuseio do buffer e o envio de dados são feitos nativamente, proporcionando transmissão muito estável mesmo em altas velocidades (tipicamente 9600 b/s). A limitação é, infelizmente, bastante restritiva — o UART é usado para comunicação entre apenas dois dispositivos. Contudo, muitos módulos eletrônicos, por exemplo, receptores GPS, modems GSM (LTE, 4G, 5G) requerem o uso dessa interface.

Dois pinos GPIO são usados para a comunicação UART: transmissão (TXD, do transmit, pino 8) e recepção (RXD, receive, pino 10). Lembre-se de que para o funcionamento correto ambos os dispositivos devem estar com a mesma taxa de baud.

Segurança e boas práticas

Antes de entrarmos em aplicações práticas e exemplos, vamos revisar considerações de segurança — as duas mais importantes que já mencionamos:

Tensão de apenas 3,3V CC

Diferentemente do Arduino, os pinos lógicos e interfaces do Raspberry Pi (os discutidos acima!) operam com tensões de 3,3V CC. Isso significa que é melhor conectar circuitos que operem com essa alimentação ao computador — caso contrário, é necessário um conversor de nível (um componente que “traduz” uma faixa de tensão para outra).

Economize energia!

Como cada pino GPIO pode fornecer no máximo 16mA (e o consumo total não deve exceder cerca de 50mA), é preciso escolher cuidadosamente os componentes para não sobrecarregar as capacidades do computador. Para lidar com cargas maiores é melhor usar elementos intermediários (transistores, relés) — sobre os quais aprenderemos mais adiante no artigo.

Use diodos de proteção e filtros

Ao utilizar componentes que geram ruídos e picos de tensão, é um bom hábito usar elementos que suprimam interferências (por exemplo, diodos que fazem curto nos enrolamentos do relé, capacitores que filtram a tensão na saída de motores CC). Isso evitará problemas no programa, bem como possíveis falhas dos componentes.

Manuseie com cuidado a alimentação do computador e periféricos

Dedicaremos um artigo separado ao tema de ligar e desligar computadores Raspberry Pi — certamente uma coisa a se notar é que em nenhuma hipótese é recomendável desconectar e conectar a alimentação “quente”. No caso do computador, isso é tentador quando o programa trava. Portanto, vale lembrar que no Linux (e seu terminal) o atalho Ctrl+C é usado para abortar o programa. Se quiser desligar o computador, é melhor usar o comando sudo shutdown -h agora ou sudo poweroff, ou escolha um comando análogo pelo menu principal (se usar interface gráfica).

Quanto a conectar componentes externos, é melhor fazê-lo com o computador desligado. Claro que nem sempre é prático, por exemplo, ao corrigir o funcionamento de um programa/circuito. Em tais situações, você deve simplesmente usar o bom senso e (mais ainda) lembrar de usar componentes intermediários.

Cautela nunca é demais

Finalmente, vamos apenas lembrar da cautela. Ela nos permitirá evitar muitos erros desnecessários e potencialmente perigosos, como curtos-circuitos. Também vale prototipar seus circuitos em uma placa de contato e usar cabos de diferentes cores padrão (por exemplo, preto para terra, vermelho para alimentação), para corrigir erros inevitáveis com maior eficiência.

Exemplos de interação e programação

Como os sistemas Raspberry Pi são baseados no kernel Linux, e o dispositivo todo foi projetado para uso educacional, temos uma ampla gama de ambientes de desenvolvimento com os quais é possível interagir com a porta GPIO. Abaixo, focaremos na linguagem Python, que é fundamental para os computadores do fabricante britânico, mas vale conhecer as alternativas.

Scratch

Para usuários jovens começando sua aventura com programação, uma introdução interessante à interação com componentes eletrônicos será o Scratch. Esse ambiente visual permite construir programas complexos usando blocos (cada um representando uma instrução, operador ou função) conectados na tela como peças. Normalmente essa ferramenta é usada para criar jogos simples, etc. O Raspberry Pi OS inclui uma versão do Scratch com capacidades adicionais: ler e configurar estados lógicos nos pinos GPIO. Os aprendizes podem assim em pouco tempo criar um programa que opera um interruptor, LEDs ou até um Controlador de Motor CC.

C/C++

Para quem conhece C ou C++, a comunicação com a porta GPIO não apresentará grandes dificuldades. A versão completa do sistema RPi inclui os compiladores gcc e g++, portanto um editor de texto simples como o nano (também pré-instalado) é suficiente para escrever um programa. Uma biblioteca para manipulação da porta precisará ser instalada. Atualmente, o pigpio é o mais usado para essa finalidade, ou a solução mais antiga (e não mais mantida) WiringPi.

Java

A situação é semelhante com Java, embora aqui seja necessário instalar o ambiente por conta própria, usando os comandos sudo apt update e sudo apt install default-jdk. Você então terá acesso à versão mais recente do Java. Há vários anos, desenvolve-se o projeto Pi4J (que se lê "Pi para Java"), que fornece um conjunto abrangente de ferramentas de desenvolvimento para suportar interfaces do computador via Java, com API orientada a objetos e legível. Os desenvolvedores aqui previram acesso aos pinos GPIO, ao barramento i²C, ao gerador PWM e à comunicação serial.

Node-RED

Para quem já conhece sistemas de automação, uma alternativa atraente às opções acima será a possibilidade de instalar o Node-RED. Trata-se de software para execução de aplicações de controle de dispositivos, processamento de dados, etc. Ele roda em navegador web, assim não será necessário conectar um monitor ao RPi — ele pode ser colocado em um gabinete separado, por exemplo, em um projeto eletromecânico em que se está trabalhando. A conexão é feita pelo endereço IP local do computador. O Node-RED é perfeitamente adequado para criação de projetos de IoT, automação residencial etc. A instalação do ambiente é feita por meio de um script publicado na Internet, basta digitar no terminal bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered).

Módulos/bibliotecas Python populares

No caso da linguagem Python, o aprendizado é muito mais fácil, porque um dos objetivos do RPi foi popularizar essa linguagem — que já era muito respeitada devido à sua filosofia rigorosa, transparência e simplicidade relativa. Os usuários interessados no suporte GPIO para Python têm 4 bibliotecas básicas para escolher.

RPi.GPIO

Primeira, mais antiga, é a RPi.GPIO — não é recomendada para projetos rodando no Raspberry Pi 5, porém funciona bem em versões mais antigas do dispositivo, e também era instalada por padrão no Raspberry Pi OS até 2023.

gpiozero

A biblioteca gpiozero pertence ao nível alto — o que significa que é mais amigável ao usuário (possui, por exemplo, classes prontas para objetos), mas pode causar atrasos na execução do programa. Isso é aceitável durante o aprendizado e em programas simples, mas em aplicações que requerem precisão essa solução pode ser inconveniente. Instale a biblioteca pelos comandos: sudo apt update e sudo apt install python3-gpiozero.

pigpio

Uma alternativa suportada por todos os modelos RPi (do 1A ao 5, incluindo as versões Zero 1, W e 2) é a ferramenta pigpio, que consiste, na verdade, em dois componentes. Um daemon rodando no sistema e uma biblioteca que permite controlá-lo a partir do Python. Essa solução tem diversas vantagens (velocidade, compatibilidade), porém a dependência de software adicional não será sempre desejável. Talvez a maior vantagem do pigpio seja o suporte ao PWM e ao I²C.

lgpio/libgpiod

As bibliotecas lgpio e libgpiod são baseadas no chamado "libgpiod", dispositivos caracteres (/dev/gpiochipN). Elas substituem a abordagem antiga baseada em sysfs, da qual o Linux está se afastando. Essas bibliotecas permitem controle direto, seguro e eficiente dos pinos GPIO. São recomendadas para novos projetos, incluindo Raspberry Pi. No entanto, como essas soluções são (temporariamente) menos populares e relativamente pouco documentadas, vamos omiti-las do panorama abaixo.

Configurando o estado na saída GPIO

Para escrever um programa em Python, basta abrir um editor de texto qualquer, colocar o código nele e depois salvar em um arquivo com formato nome.py — de preferência em um local de fácil acesso, por exemplo, a pasta pessoal /home. Então execute o script pelo terminal, navegando até o local do arquivo e usando o comando python nome.py, ou opcionalmente sudo python nome.py (usar permissões de superusuário pode ser necessário às vezes, especialmente no uso da biblioteca pigpio).

No primeiro exemplo mais simples, que pisca um LED conectado ao GPIO, usaremos a biblioteca RPi.GPIO. A conexão elétrica deve ser assim:

Quanto ao código do programa, seu conteúdo pode ser o seguinte:

import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)

print("Ctrl+C → STOP")

try:

    while True:
        GPIO.output(18, GPIO.HIGH)
        sleep(1)
        GPIO.output(18, GPIO.LOW)
        sleep(1)

except KeyboardInterrupt:
    print("
Arrivederci!")
    GPIO.cleanup()

Ao rodar, inicialmente declaramos que usaremos a biblioteca RPi.GPIO (e a chamaremos de GPIO), e da biblioteca time baixamos apenas uma instrução: sleep (causa pausa do programa pelo tempo especificado em segundos).

Declaramos que no programa nos referiremos aos pinos pelos seus números GPIO (de acordo com a tabela fornecida no início do texto), e não pela ordem física dos pinos no conector: GPIO.setmode(GPIO.BCM). Depois, configuramos o GPIO18 como pino de saída.

A seguir, incluímos uma instrução informando ao usuário que, para terminar o programa, deve pressionar a combinação de teclas Ctrl+C. Para que a finalização ocorra corretamente e para abortar todas as ações tomadas pelo Python no GPIO, a saída não deve ser “brusca”, por isso usamos a construção try … except. Ela faz com que o código dentro do bloco try seja executado enquanto não for detectado um interrupt Ctrl+C (KeyboardInterrupt) — então o Python passa para o bloco except e encerra sua operação, saudando o usuário e liberando o GPIO: GPIO.cleanup().

Escrevemos o bloco mais importante do programa propriamente dito sob a forma de loop infinito (semelhante ao ambiente Arduino). Ou seja, as instruções sob o while True serão executadas repetidamente (pois True sempre será verdadeiro). Assim, primeiro colocamos o estado alto no pino 18 (GPIO.HIGH), esperamos um segundo, depois configuramos estado baixo (GPIO.LOW), novamente esperamos um segundo e retornamos ao início do loop. Como resultado, os LEDs conectados acenderão e apagarão até que interrompamos o programa.

Controlando uma lâmpada de 230V

Neste ponto, note que do ponto de vista do programa controlar uma lâmpada 230V seria idêntico. Contudo, a conexão elétrica seria modificada, tendo que ser feita segundo um esquema mais complexo:

O fechamento do circuito da lâmpada conectada à rede (L1) é feito usando um relé (K1) com bobina de 5V CC, alimentado pelo conector GPIO. A corrente passa por meio de um transistor (Q1), graças ao qual uma corrente base muito pequena vinda do pino 18 é suficiente para controlar o circuito. No circuito, podemos adicionar um LED (D2) e seu resistor (R2), que será a luz piloto do transistor. O diodo D1 é um dispositivo de proteção típico, serve para eliminar interferências que surgem na entrada do relé quando os contatos retornam à posição de repouso, isto é, quando o circuito é desconectado — assim protege-se o conector GPIO, a fonte do computador e os transistores.

Leitura do estado do GPIO

Ler o estado em um pino GPIO é tão simples quanto escrever nele. Vamos fazê-lo usando desta vez a biblioteca gpiozero e os dois modos diferentes de leitura que ela oferece.

O esquema para ambos os exemplos não poderia ser mais simples:

Usamos um interruptor com contatos normalmente abertos (NA), podendo ser um botão monostável comum, bem como uma alavanca bistável.

O primeiro código do programa é:

from gpiozero import Button
from time import sleep

SW = Button(21)

print("Ctrl+C → STOP")

try:

    while True:
        print(SW.value)
        sleep(0.5)

except KeyboardInterrupt:
    print("
Hasta la vista!")

Já se percebe que aqui usamos uma estrutura semelhante à do primeiro exemplo, então vamos focar nas diferenças. Primeiramente, da biblioteca gpiozero baixamos apenas a classe Button. Ao contrário da biblioteca RPi.GPIO, ela faz a maior parte da configuração para nós. Basta criarmos um novo objeto da classe Button e atribuir o pino 21 a ele: SW = Button(21). Em um loop infinito, verificamos o estado do interruptor a cada meio segundo e exibimos em forma textual: print(SW.value). Veremos no terminal uma sequência crescente de 0 (quando o botão está solto) ou 1 (quando o interruptor fecha o circuito):

Ctrl+C → STOP
0
0
0
0
0
1
0
1
0
0
1
1

Aqui é importante notar que no momento de criar um novo objeto (SW) no microprocessador, resistor pull-up interno foi conectado ao pino 21, portanto a tensão na saída tem valor aproximadamente 3,3V. Quando o pino é curto para GND ao pressionar o botão, a tensão cai abaixo do limiar para zero lógico (próximo a 0V). No entanto, a biblioteca gpiozero tenta facilitar nossa vida e inverte esses valores binários. Um botão pressionado é o valor 1, enquanto solto é 0. É um bom exemplo de simplificações que para um técnico experiente em eletrônica podem causar confusão.

Uma característica útil da biblioteca gpiozero é a capacidade de manipular interrupções acionadas pela mudança do estado do interruptor. Um exemplo é apresentado abaixo:

from gpiozero import Button
from time import sleep

SW = Button(21)

def on_press():
    print("ON")
    sleep(0.1)

def on_release():
    print("OFF")
    sleep(0.1)

SW.when_pressed = on_press
SW.when_released = on_release

print("Ctrl+C → STOP")

try:
    while True:
        print(".")
        sleep(0.5)

except KeyboardInterrupt:
    print("
Até logo!")

Como se vê, temos duas funções aqui: uma exibe ON, a outra OFF. Em ambas incluímos um atraso de 100ms para que o programa ignore oscilações do contato, que levariam a múltiplos acionamentos repetidos (o chamado debounce). Declaramos então que no momento da pressão do botão a função on_press, e no momento da soltura, on_release são executadas. Depois iniciamos nosso loop tradicional, que nesse caso simboliza operações muito importantes, um de facto serve apenas para escrever uma sequência de pontos no terminal em intervalos de meio segundo. A coluna de pontos será interrompida (assim como a execução do programa) sempre que o estado no pino 21 mudar. Veremos:

Ctrl+C → STOP
.
.
.
ON
.
.
OFF
.
.

Geração do sinal PWM

Para gerar o sinal PWM usaremos a terceira das bibliotecas citadas acima: pigpio. Importante: ela não funciona sozinha. Após instalar o pacote (sudo apt install pigpio), ainda é necessário executar o processo em background (daemon), que usa a biblioteca para gerenciar as interfaces GPIO de baixo nível. Ativamos digitando no terminal sudo pigpiod.

Agora já podemos testar o programa em Python:

import pigpio
import time

GPIO = pigpio.pi()
LED = 18

print("Ctrl+C → STOP")

try:

    while True:

        for duty in range(0, 256, 5):
            GPIO.set_PWM_dutycycle(LED, duty)
            time.sleep(0.01)

        for duty in range(255, 0, -5):
            GPIO.set_PWM_dutycycle(LED, duty)
            time.sleep(0.01)

except KeyboardInterrupt:
    GPIO.set_PWM_dutycycle(LED, 0)
    GPIO.feet()
    print("
Papa!")

Nosso script usa uma chamada ao programa pigpiod e é representado aqui por um objeto, que chamamos simplesmente de GPIO. A disposição do código é semelhante ao primeiro exemplo do LED piscando, mas em vez de alterar o estado uma vez por segundo, muda-o numa frequência imperceptível ao olho humano, gerando um sinal de onda quadrada (PWM). Isso dá a ilusão de um LED brilhando mais forte ou mais fraco. A razão entre o tempo em que ocorre um estado alto e o tempo em que está em nível baixo é chamado de duty cycle (ciclo de trabalho). No caso da biblioteca pigpio, o preenchimento máximo é 255 (significa que o estado alto ocorre continuamente), o mínimo é 0 (o oposto). Todos os valores intermediários produzem um efeito de luminosidade parcial.

Assim, criamos dois loops que serão executados alternadamente. No primeiro, a variável duty (preenchimento) assume valores de 0 a 255 em incrementos de 5 (0, 5, 10, 15 ...): for duty in range(0, 255, 5). Depois o valor é emitido como sinal PWM no pino 18 (set_PWM_dutycycle). No segundo loop, o processo é invertido, decrementamos o preenchimento — for duty in range(255, 0, -5). Os LEDs irão gradualmente clarear e depois escurecer. Se quisermos acelerar ou desacelerar esse processo, mudamos os valores na instrução time.sleep(0.01).

Conectando motores servo

Agora que cobrimos o tema da geração de sinais PWM, vamos dedicar um momento ao tema dos motores servo.

Os motores servo são motores numa única carcaça com redutor e controlador incorporados. Dependendo do sinal recebido, definem o ângulo de inclinação do seu eixo (órbita) em uma posição precisamente definida. Para controlar servos de modelo, são usados sinais PWM gerados com frequência de 50Hz (ou seja, a cada 20 ms). Pulso de 500 µs (às vezes 1000 µs) equivale à posição de 0°, enquanto pulsos com cerca de 2500 µs resultam no máximo movimento do orbitador (às vezes é 180°, outras vezes 270° ou até 360°). Muitos servos miniatura usados em robótica amadora funcionam com alimentação de 5V CC, assim um mecanismo pode ser conectado diretamente ao conector GPIO:

Para iniciar o motor conectado desta forma, usaremos a função set_servo_pulsewidth, cujo argumento não é o ciclo de trabalho, mas a duração do pulso, medida em microssegundos. Nosso programa enviará um sinal PWM para o servo com o estado alto ligado a cada 500 µs e depois a cada 2500 µs. Isso causará o movimento alternado do orbitador.

Nota: como existem diferenças entre motores servo, nosso motor pode se comportar de forma caótica — experimente então mudar os valores para 1000 e 2000.

import pigpio
import time

GPIO = pigpio.pi()
SERVO = 18

print("Ctrl+C → STOP")

try:

    while True:
        GPIO.set_servo_pulsewidth(SERVO, 500)
        time.sleep(1)
        GPIO.set_servo_pulsewidth(SERVO, 2500)
        time.sleep(1)

except KeyboardInterrupt:
    GPIO.set_PWM_dutycycle(SERVO, 0)
    GPIO.feet()
    print("
Au revoir!")

Manipulação do I²C

Manipular componentes via a interface I²C também não é complicado, mas requer familiaridade com a documentação do circuito/módulo usado. Para poupar tempo, aqui indicamos apenas os primeiros passos para estabelecer comunicação entre o computador e o receptor.

Para a conexão você precisará de apenas dois cabos — sim, conforme descrito na seção dedicada ao barramento I2C. Lembre-se de que o dispositivo deve funcionar com tensão de 3,3V, e não 5V! Além disso, deve-se notar que por padrão a interface não estará disponível. Para habilitá-la, abra o terminal e execute a ferramenta de configuração fornecida em cada versão do Raspberry OS: sudo raspi-config. Lá, na seção 3 (Interface Options), selecione o item I5 (Enable/disable automatic loading of I2C kernel module). Você será solicitado a confirmar. Em seguida, saia do programa e reinicie o computador com sudo reboot.

Após a reinicialização, você pode instalar o pacote i2c-tools, que contém vários acessórios úteis. Digitamos então sudo apt update e sudo apt install i2c-tools. Se nosso receptor já estiver conectado à interface I²C, para ver se ele é detectado, digite i2cdetect -y 1 (esse último parâmetro indica que estamos buscando dispositivos conectados à interface nº 1, ou seja, nos pinos 3 e 5 do conector GPIO). Devemos ver uma resposta mais ou menos assim:

A tabela resultante da ferramenta i2cdetect.

Cada linha indica o início do endereço (escrito em formato hexadecimal). As colunas referem-se ao segundo caractere do endereço. No exemplo acima, você vê que há apenas um dispositivo com o endereço 0x27 (em decimal = 39) disponível em todo o barramento. Assim, no nosso programa esse é o endereço que precisamos usar para comunicar com a periferia — mesmo sendo o único componente conectado à interface.

A manipulação mais eficiente do I²C é fornecida pela biblioteca pigpio. Conhecer alguns comandos é suficiente para a comunicação:

Overlays

As capacidades do porta GPIO não se restringem à experimentação com componentes eletrônicos. O conector GPIO também serve para outros propósitos, principalmente conectar placas de expansão, não só de fábrica, mas também auto-construídas.

Overlays para Raspberry, os chamados "HAT" (abreviação nativa para Hardware Attached on Top, ou seja, módulos conectados no topo). Diversos fabricantes oferecem overlays com várias funcionalidades. Estes incluem, por exemplo, displays, interfaces adicionais, controladores para motores (DC, BLDC, motores servo), adaptadores para outros padrões (LEGO® Powered Up).

Como o conector GPIO contém pinos de alimentação, que podem atuar não só como saída, mas também como entrada, frequentemente os HAT fornecem energia ao computador. Aqui vale distinguir principalmente dois tipos de overlays. O primeiro são unidades UPS (Uninterrupted Power Supply), que são fontes de alimentação ininterruptas que garantem funcionamento do computador mesmo após falha da fonte (possuem estabilizadores e células de bateria recarregáveis). Esses HATs podem ser usados também para fornecer energia por bateria ao RPi para projetos móveis. A segunda proposta interessante são os adaptadores PoE (Power over Ethernet), que adaptam o computador Raspberry para ser alimentado via cabo Ethernet (padrão 802.3).

Resumo

O conector GPIO é um dos maiores trunfos do computador Raspberry Pi — e tornou-se um padrão entre computadores de placa única. Além das tremendas oportunidades que oferece para engenheiros, é também uma ferramenta educacional ideal, proporcionando uma ponte entre brincar com computadores e aprender sobre componentes eletrônicos. Ao redor dos computadores Raspberry Pi cresceu uma enorme comunidade de entusiastas, amigável para novos usuários e sempre pronta a ajudar. É uma pena desperdiçar tal oportunidade, então se você está procurando uma forma de aprender sobre construção de sistemas embarcados ou eletrônica complexa — basta pegar as ferramentas e o conhecimento que estão ao seu alcance.

A Transfer Multisort Elektronik (TME) é um dos maiores distribuidores globais de componentes eletrônicos, peças eletrotécnicas, equipamentos de oficina e automação industrial. O catálogo inclui mais de 1.500.000 de produtos de 1.300 fabricantes líderes. Os modernos centros logísticos da TME em Łódź e Rzgów (Polónia), com uma área total superior a 40.000 m², enviam quase 6.000 pacotes diariamente para clientes em mais de 150 países.

A TME também investe no desenvolvimento do conhecimento e das competências de jovens engenheiros e entusiastas da eletrónica através do projeto TME Education e apoia a comunidade tecnológica organizando a série de eventos TechMasterEvent, promovendo a inovação e a troca de experiências.