Usar GPIO para entrada binária

2025-04-09

Os pinos de E/S de uso geral (GPIO) podem ser configurados para receber sinais elétricos como entrada. Em seu nível mais básico, isso é útil para cenários que detectam a abertura/fechamento de um circuito. Esses circuitos podem incluir botões de ação, comutadores de alternância, sensores magnéticos, comutadores de pressão e outros dispositivos que representam valores binários (on/off) completando um circuito.

Neste tutorial, você usará os pinos GPIO do .NET e do Raspberry Pi para detectar a abertura e o fechamento de um circuito.

Pré-requisitos

Computador de placa única baseado em ARM (ARMv7 ou superior) (SBC)
Cabos de jumper
Breadboard (opcional)
Placa de contato impresso GPIO do Raspberry Pi (opcional)
SDK do .NET 8 ou posterior

Observação

Este tutorial é escrito supondo que o dispositivo de destino seja Raspberry Pi. No entanto, este tutorial pode ser usado para qualquer SBC baseado em Linux que dê suporte ao .NET, como Orange Pi, ODROID e muito mais.

Verifique se o SSH está habilitado em seu dispositivo. Para Raspberry Pi, consulte Configurar um servidor SSH na documentação do Raspberry Pi.

Preparar o hardware

Use os componentes de hardware para criar o circuito, conforme descrito no diagrama a seguir:

A imagem acima mostra uma conexão direta entre um pino de terra e um pino 21.

Dica

O diagrama ilustra uma placa de ensaio e uma fuga GPIO para fins ilustrativos, mas sinta-se à vontade para conectar apenas um pino terra e um pino 21 com um fio jumper no Raspberry Pi.

Consulte o seguinte diagrama de pinagem conforme necessário:

Imagem cortesia Raspberry Pi Foundation.

Criar o aplicativo

Conclua as seguintes etapas em seu ambiente de desenvolvimento preferencial:

Crie um novo aplicativo de console do .NET usando a CLI do .NET ou o Visual Studio. Nomeie-o InputTutorial.
```
dotnet new console -o InputTutorial
cd InputTutorial
```
Adicione o pacote System.Device.Gpio ao projeto. Use o CLI do .NET do diretório do projeto ou o Visual Studio.
```
dotnet add package System.Device.Gpio --version 3.2.0-*
```
Substitua o conteúdo do Program.cs pelo seguinte código:
```
using System.Device.Gpio;
using System.Threading.Tasks;

const int Pin = 21;
const string Alert = "ALERT 🚨";
const string Ready = "READY ✅";

using var controller = new GpioController();
controller.OpenPin(Pin, PinMode.InputPullUp);

Console.WriteLine(
    $"Initial status ({DateTime.Now}): {(controller.Read(Pin) == PinValue.High ? Alert : Ready)}");

controller.RegisterCallbackForPinValueChangedEvent(
    Pin,
    PinEventTypes.Falling | PinEventTypes.Rising,
    OnPinEvent);

await Task.Delay(Timeout.Infinite);

static void OnPinEvent(object sender, PinValueChangedEventArgs args)
{     
    Console.WriteLine(
        $"({DateTime.Now}) {(args.ChangeType is PinEventTypes.Rising ? Alert : Ready)}");
}
```
No código anterior:
- Uma declaração de uso cria uma instância de GpioController. A using declaração garante que o objeto seja descartado e os recursos de hardware sejam liberados corretamente.
  - GpioController é instanciado sem parâmetros, indicando que ele deve detectar em qual plataforma de hardware está em execução e usar o esquema de numeração de pino lógico.
- O pino 21 do GPIO é aberto com PinMode.InputPullUp.
  - Isso abre o pino com um resistor PullUp acoplado. Nesse modo, quando o pino estiver conectado ao solo, ele retornará PinValue.Low. Quando o pino é desconectado da terra e o circuito está aberto, o pino retorna PinValue.High.
- O status inicial é gravado em um console usando uma expressão ternária. O estado atual do pino é verificado usando Read(). Se for PinValue.High, ele gravará a cadeia de caracteres Alert no console. Caso contrário, gravará a cadeia de caracteres Ready.
- RegisterCallbackForPinValueChangedEvent() registra uma função de retorno de chamada para os eventos PinEventTypes.Rising e PinEventTypes.Falling no pino. Esses eventos correspondem aos estados dos pinos de PinValue.High e PinValue.Low, respectivamente.
- A função de retorno de chamada aponta para um método denominado OnPinEvent(). OnPinEvent() usa outra expressão ternária que também grava as cadeias de caracteres correspondentes Alert ou Ready.
- O thread principal é suspenso indefinidamente enquanto aguarda os eventos dos pinos.
Crie o aplicativo. Se estiver usando a CLI do .NET, execute dotnet build. Para compilar no Visual Studio, pressione Ctrl+Shift+B.
Implante o aplicativo no SBC como um aplicativo independente. Para obter instruções, consulte Implantar aplicativos .NET no Raspberry Pi. Certifique-se de conceder permissão de execução ao executável usando .
Execute o aplicativo no Raspberry Pi acessando o diretório de implantação e executando o arquivo executável.
```
./InputTutorial
```
O console exibe texto semelhante ao seguinte:
```
Initial status (05/10/2022 15:59:25): READY ✅
```
Desconecte o pino 21 do terra. O console exibe texto semelhante ao seguinte:
```
(05/10/2022 15:59:59) ALERT 🚨
```
Reconecte o pino 21 e o terra. O console exibe texto semelhante ao seguinte:
```
(05/10/2022 16:00:25) READY ✅
```
Encerre o programa pressionando Ctrl+C.

Parabéns! Você usou o GPIO para detectar a entrada usando o System.Device.Gpio pacote NuGet! Há muitos usos para esse tipo de entrada. Este exemplo pode ser usado com qualquer cenário em que um comutador se conecta ou interrompe um circuito. Aqui está um exemplo usando-o com um comutador de palheta magnética, que geralmente é usado para detectar portas abertas ou janelas.

GIF animado demonstrando um sensor magnético abrindo e fechando. O comutador é exposto a um ímã e o aplicativo exibe READY. O ímã é removido e o aplicativo exibe ALERTA. Então, a ação é repetida.

Mecanismo a laser

Estendendo um pouco mais o conceito do exemplo anterior, veremos como isso pode ser aplicado à criação de um mecanismo a laser. A criação de um tripwire a laser requer os seguintes componentes adicionais:

Módulo de transmissor a laser KY-008
Módulo do sensor do receptor laser (veja a observação abaixo)
2 resistores de 10K Ω

Observação

O módulo de sensor do receptor laser é o nome genérico aplicado a um módulo comum encontrado em muitos varejistas da Internet. O dispositivo pode variar em nome ou fabricante, mas deve ser semelhante a essa imagem.

Imagem de um módulo de sensor de receptor laser

Conectar um hardware do mecanismo a laser

Conecte os componentes conforme detalhado no diagrama a seguir.

Preste muita atenção aos resistores de 10KΩ. Elas implementam um divisor de tensão. Isso ocorre porque o módulo do receptor laser gera 5V para indicar que o feixe está quebrado. O Raspberry Pi só dá suporte a até 3,3V para entrada GPIO. Como enviar o 5V completo para o pino pode danificar o Raspberry Pi, a corrente do módulo receptor é passada por um divisor de tensão para reduzir pela metade a tensão para 2,5V.

Aplicar atualizações de código-fonte

Você quase pode usar o mesmo código que anteriormente, com uma exceção. Nos outros exemplos, usamos PinMode.InputPullUp para que, quando o pino for desconectado do solo e o circuito estiver aberto, o pino retorne PinValue.High.

No entanto, no caso do módulo do receptor laser, não estamos detectando um circuito aberto. Em vez disso, queremos que o pino atue como um coletor para a corrente proveniente do módulo receptor laser. Nesse caso, abriremos o pino com PinMode.InputPullDown. Dessa forma, o pino retorna PinValue.Low quando não está recebendo nenhuma corrente e PinValue.High quando recebe a corrente do módulo do receptor laser.

controller.OpenPin(pin, PinMode.InputPullDown);

Importante

Verifique se o código implantado no Raspberry Pi inclui essa alteração antes de testar um tripwire a laser. O programa funciona sem ele, mas usar o modo de entrada errado corre o risco de danificar o Raspberry Pi!

GIF animado com uma demonstração do mecanismo a laser. O emissor do laser acende o módulo do sensor a laser e o aplicativo exibe READY. O raio a laser é interrompido e o aplicativo exibe ALERTA. Em seguida, a ação é repetida.

Obter o código-fonte

A origem deste tutorial está disponível no GitHub.

Próximas etapas

Saiba como ler condições ambientais de um sensor

Compartilhar via