Um guia GPIO para iniciantes

Por Nathan Busler | Março 11, 2022
Um guia GPIO para iniciantes Imagem do título

Neste post de blog você vai aprender tudo sobre os pinos GPIO do Raspberry Pi. Este post é especialmente para iniciantes em eletrônica.

Antes de mais, um aviso:

O Raspberry Pi pode ser irremediavelmente danificado se os pinos forem usados de forma incorrecta. Por isso, certifique-se sempre de que o seu circuito está correcto e que utiliza resistências suficientes.

O que são pinos GPIO

Os pinos GPIO são os 40 pequenos pinos metálicos na parte superior do Raspberry Pi. A abreviatura GPIO significa "general purpose input output" (saída de entrada geral). Isto significa que os pinos GPIO podem ser usados como uma interface para quase todos os dispositivos eletrônicos.

Devido ao grande número de maneiras de (mal) usar os pinos, começar pode ser um pouco confuso. Por isso, este post do blogue fornece alguns exemplos sobre como controlar os pinos usando Bash, C e Python. Portanto, um pouco de experiência em programação é uma vantagem.

Embora os 40 pinos pareçam idênticos, eles têm funções diferentes. 26 pinos podem ser usados para GPIO e alguns têm funções adicionais. Outros 4 pinos são usados como fonte de energia (POWER, duas vezes 3V3 e duas vezes 5V) e 8 como pólo negativo (também aterrado ou GROUND). Os dois pinos restantes são a interface I2C para ID EEPROM.

Pinout

O gráfico abaixo mostra a informação mais importante, entre outras coisas o pinout. O pinout é idêntico para a maioria dos modelos Raspberry Pi, mas há diferenças. Verifique sempre o pinout exacto do seu modelo antes de ligar um dispositivo. Para isso basta abrir um terminal no seu Raspberry Pi (Ctrl+Alt+t) e executar o seguinte comando.

pinout

Você verá um gráfico de todas as conexões e o pinout exato do seu Raspberry Pi.

Pi Pinout de framboesa

Você deve ter notado que os números GPIO aparecem aleatoriamente e não correspondem à numeração dos pinos. Para evitar confusão, eu me refiro à numeração de 1 a 40 como o número BOARD e o número de 1 a 26 como o número BCM ou GPIO.

Portanto, o pino BOARD 1 é o conector 3V3 POWER e o pino GPIO 2 é o pino ao lado dele com BOARD número 3.

Como ligar um dispositivo aos pinos

Existem várias alternativas para ligar um dispositivo aos pinos GPIO. Alguns dispositivos têm um cabeçalho GPIO para que o dispositivo possa ser conectado diretamente aos pinos GPIO. Geralmente, no entanto, este não é o caso, e é por isso que são usados fios de jumper ou cabos de extensão GPIO.

Ver o nosso Vídeo sobre os GPIO Pins!

No exemplo seguinte, um LED é conectado ao Raspberry Pi usando cabos jumper.

O circuito

O Salta Fêmea para Salta Masculino liga o pino GPIO a um cabeçalho ou a uma tábua de cortar pão. O pino deve então ser programado para operar o dispositivo. O dispositivo pode ser um botão, um LED, um sensor, um motor ou um display. É importante apenas que o dispositivo possa ser operado com 5 volts ou menos e que seja compatível com as interfaces I2C, SPI ou UART.

Para a construção precisamos dos seguintes equipamentos.

  • Raspberry Pi com Raspberry Pi OS
  • Dois Fios de Salta Macho para Fêmea
  • Um Macho para um Macho Jumper Wire
  • Resistência de 10 kilo Ohm
  • LED
  • Tábua de pão sem solda

Conecte o pino GPIO 13 (BOARD número 33) ao + faixa e o pino da TERRA ao seu lado (BOARD número 34) para a - faixa da tábua de pão. Em seguida, ligue uma extremidade da resistência de 10 kilo Ohm (qualquer resistor) no + faixa e a outra ponta em uma das tiras de cruz. Para o LED, a orientação é crucial. O ânodo é o mais longo dos dois braços e muitas vezes dobrado, o cátodo é o braço mais curto. O ânodo deve sempre apontar para o + direção, ou seja, para a fonte de energia, e o cátodo no – direção, ou seja, em direção à TERRA. Portanto, coloque o braço mais longo na mesma faixa transversal que a resistência, de modo que o braço mais curto esteja na faixa transversal adjacente. Por último, utilizar o cabo jumper macho a macho para conectar a tira transversal do cátodo (braço mais curto do LED) ao - faixa.

O diagrama seguinte mostra a montagem, certifique-se de que tudo está correto e que os componentes estão inseridos na placa até onde eles vão, caso contrário haverá contatos soltos.

Aufbau des Schaltkreises

Os três exemplos de código seguintes em Bash, Python e C são baseados nesta estrutura. Se você usar outros pinos, você deve modificar o código de acordo.

Bash

Controlar os pinos GPIO através do Bash é muito fácil. No Linux, os pinos GPIO são controlados pelos arquivos no diretório /sys/class/gpio pasta. Para usar um pino GPIO, ele deve ser exportado primeiro. Como exemplo, eu uso o pino GPIO 13. A seguir os nomes dos arquivos são em negrito e itálico.

Abra um terminal e liste o conteúdo da pasta gpio.

cd /sys/class/gpio
ls

A pasta contém os arquivos de exportação e exportação, bem como as subpastas para cada pino GPIO exportado.

Nós exportamos o pino escrevendo o número GPIO no /sys/class/gpio/exportação arquivo. Execute este comando no terminal.

echo 13 > /sys/class/gpio/export
ls

Agora foi criada uma pasta com o número de pino correspondente gpio13. Esta pasta contém outras pastas e arquivos. Por enquanto, somente os arquivos de direção e valores são importantes para nós.

O direção guarda o modo do pino:

em -> Pino está em modo de leitura ou entrada

sair -> Pin está em modo de escrita ou saída

O valor armazena o estado de voltagem do pino:

0 -> o pino está em modo BAIXO -> nenhuma tensão é aplicada ao pino

1 -> O pino está em modo ALTO -> A tensão é aplicada ao pino

Os seguintes comandos definem o modo para sair e o valor para 1.

echo out > /sys/class/gpio/gpio13/direction
echo 1 > /sys/class/gpio/gpio13/value

O LED está agora aceso. É importante repor os valores dos pinos após o uso. Os seguintes comandos devem ser executados após cada uso.

echo 0 > /sys/class/gpio/gpio13/value
echo in > /sys/class/gpio/gpio13/direction
echo 13 > /sys/class/gpio/unexport

programa Python

Agora nós abstraímos e automatizamos estes comandos Bash em Python.

O seguinte script Python fornece um simples GPIO_Pin classe. Isto torna a utilização extremamente fácil. O os permite-nos executar os mesmos comandos bash que os acima a partir do Python. Também, usando o módulo __del__ não precisamos mais reinicializar manualmente e não exportar os pinos.

import os
from time import sleep

class GPIO_Pin:
    def __init__(self, num, mode):
        if 0 <= num or num <= 40:
            self.num = num
        else:
            print('Invalid Pin Number -> Enter a number from 0 - 40')
        if mode == 'out' or mode == 'write':
            self.mode = 'out'
        elif mode == 'in' or mode == 'read':
            self.mode = 'in'
        else:
            print('Invalid Pin Mode -> Enter "out" or "write" for output, "in" or "read" for input')
        if self.num and self.mode:
            os.system(f'echo {str(self.num)} > /sys/class/gpio/export')
            sleep(0.05)
            os.system(f'echo {self.mode} > /sys/class/gpio/gpio{str(self.num)}/direction')

    def reset(self):
        os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/value')
        os.system(f'echo in > /sys/class/gpio/gpio{str(self.num)}/direction')

    def write(self, value):
        if value == 0 or value == 'LOW':
            os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/value')
        elif value == 1 or value == 'HIGH':
            os.system(f'echo 1 > /sys/class/gpio/gpio{str(self.num)}/value')
        else:
            print('Invalid value -> Enter 1 or "HIGH" for HIGH, 0 or "LOW" for LOW')

    def __del__(self):
        self.reset()
        os.system(f'echo {str(self.num)} > /sys/class/gpio/unexport')

    def set_mode(self, mode):
        self.mode = mode
        os.system(f'echo {str(self.mode)} > /sys/class/gpio/gpio{str(self.num)}/direction')

def main():
    pin = GPIO_Pin(13, 'out')
    number_of_blinks = 10
    for i in range(number_of_blinks):
        pin.write('HIGH')
        sleep(0.5)
        pin.write('LOW')
        sleep(0.5)

if __name__ == '__main__':
    main()

Com o módulo de tempo podemos até fazer o LED piscar sem qualquer problema. O script inteiro pode ser estendido a um módulo Python para controle GPIO.

Programa C

Também em C podemos editar facilmente o conteúdo da pasta gpio. Usando a biblioteca padrão stdlib podemos abrir arquivos e alterar o conteúdo.
O seguinte programa em C deve ser compilado antes de poder ser executado. Criar um arquivo gpio.c e copiar o programa para dentro dele.
Depois abra um terminal e navegue até à pasta onde o gpio.c O arquivo está localizado. Use os seguintes comandos para compilar e executar o programa.

gcc -o gpio gpio.c
./gpio

Aqui está o programa.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define GPIO_ROOT "/sys/class/gpio"
#define EXPORT "/sys/class/gpio/export"
#define UNEXPORT "/sys/class/gpio/export"

#define LOW 0
#define HIGH 1

int export_pin(int num) {
    FILE* export = fopen(EXPORT, "w");
    if (export == NULL) {
        printf("Failed to open the export file\n");
        exit(-1);
    }
    fprintf(export, "%d", num);
    fclose(export);
    return 0;
}

int unexport_pin(int num) {
    FILE* unexport = fopen(UNEXPORT, "w");
    if (unexport == NULL) {
        printf("Failed to open the unexport file\n");
        exit(-1);
    }
    fprintf(unexport, "%d", num);
    fclose(unexport);
    return 0;
}

int set_direction(char *mode, int num) {
    char direction_file_path[1024];
    snprintf(direction_file_path, sizeof(direction_file_path), "/sys/class/gpio/gpio%d/direction", num);
    FILE* direction = fopen(direction_file_path, "w");
    if (direction == NULL) {
        printf("Failed to open the direction file\n");
        exit(-1);
    }
    fputs(mode, direction);
    fclose(direction);
    return 0;
}

int set_value(int val, int num) {
    char value_file_path[1024];
    snprintf(value_file_path, sizeof(value_file_path), "/sys/class/gpio/gpio%d/value", num);
    FILE* value = fopen(value_file_path, "w");
    if (value == NULL) {
        printf("Failed to open the value file\n");
        exit(-1);
    }
    fprintf(value, "%d", val);
    fclose(value);
    return 0;
}

int main() {

    int rslt;
    int num;
    int num_blinks;

    num = 13;
    num_blinks = 10;

    rslt = export_pin(num);
    rslt = set_direction("out", num);
    for (int i = 0; i < num_blinks; i++) {
        rslt = set_value(HIGH, num);
        sleep(1);
        rslt = set_value(LOW, num);
        sleep(1);
    }

    rslt = set_value(LOW, num);
    rslt = set_direction("in", num);
    rslt = unexport_pin(num);

    return EXIT_SUCCESS;
}

PiCockpit - Aplicação GPIO

A maneira mais fácil de controlar os pinos GPIO é com a ajuda do aplicativo GPIO. O PiCockpit interface web é grátis para até 5 Raspberry Pi. Oferece duas grandes vantagens: Não precisa de saber programação para controlar os seus pinos GPIO e pode fazer isto a partir de qualquer lugar.

Basta instalar o cliente PiCockpit no seu Raspberry Pi e ligar-se à sua conta PiCockpit. Depois disso você pode facilmente controlar os pinos GPIO através da interface web.

Próximos Passos

Agora já sabes como utilizar os pinos GPIO com a ajuda de fios de ligação em ponte. Claro que também existem módulos Python externos e bibliotecas C para controlar os pinos GPIO. Um bom passo seguinte seria alargar um dos exemplos de código. Por exemplo, utilizando LEDs adicionais ou um botão.


Divirta-se experimentando!

Deixe um comentário