Usar GPIO para entrada binária

Os pinos de E/S de uso geral (GPIO) podem ser configurados para receber sinais elétricos como entrada. No seu nível mais básico, isso é útil para cenários que detetam a abertura/fechamento de um circuito. Esses circuitos podem incluir botões de pressão, interruptores de comutação, interruptores de palheta, pressostatos e outros dispositivos que representam os valores binários (ligado/desligado) ao completarem um circuito.

Neste tutorial, vais usar .NET e os pinos GPIO do teu Raspberry Pi para detetar a abertura e o fecho de um circuito.

Pré-requisitos

• Computador de placa única (SBC) baseado em ARM (ARMv7 ou superior)
• Fios de ligação
• Placa de ensaio (opcional)
• Placa de expansão GPIO para Raspberry Pi (opcional)
• .NET SDK 10 ou posterior

Certifique-se de que o SSH está ativado no seu dispositivo. Para o Raspberry Pi, consulte Configurando um servidor SSH na documentação do Raspberry Pi.

Preparar o hardware

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

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

Consulte o diagrama de pinagem abaixo, conforme necessário.

Imagem cortesia da Raspberry Pi Foundation.

Criar a aplicação

Conclua as seguintes etapas em seu ambiente de desenvolvimento preferido:

1. Crie uma nova aplicação de consola .NET usando .NET CLI ou Visual Studio. Chame-lhe InputTutorial.

   dotnet new console -o InputTutorial
   cd InputTutorial
   

2. Adicione o pacote System.Device.Gpio ao projeto. Use .NET CLI do diretório do projeto ou Visual Studio.

   dotnet package add System.Device.Gpio --version 4.0.1
   

3. 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 usando cria uma instância de GpioController. A using declaração garante que o objeto é eliminado e que os recursos de hardware são devidamente libertados.
     • GpioController é instanciado sem parâmetros, indicando que deve detetar em que plataforma de hardware está a correr e usar o esquema lógico de numeração de pinos.
   • O pino GPIO 21 é aberto com PinMode.InputPullUp.
     • Isto abre o pino com uma resistência PullUp ativada. Neste modo, quando o pino está ligado à terra, devolverá PinValue.Low. Quando o pino está desligado do terra e o circuito está aberto, o pino retorna a PinValue.High.
   • O status inicial é gravado em um console usando uma expressão ternária. O estado atual do pino é lido com Read(). Se for PinValue.High, escreve a cadeia Alert para a consola. Caso contrário, escreve a Ready string.
   • RegisterCallbackForPinValueChangedEvent() regista uma função de callback para ambos os eventos PinEventTypes.Rising e PinEventTypes.Falling no pin. Estes eventos correspondem aos estados de pino de PinValue.High e PinValue.Low, respetivamente.
   • A função de callback aponta para um método chamado OnPinEvent(). OnPinEvent() usa outra expressão ternária que também escreve as strings correspondentes Alert ou Ready.
   • O fio principal dorme indefinidamente enquanto espera por eventos de pinos.

4. Crie o aplicativo. Se estiver a usar a CLI .NET, execute dotnet build. Para construir em Visual Studio, pressione Ctrl+Shift+B.

5. Implante o aplicativo no SBC como um aplicativo independente. Para instruções, consulte Deploy .NET apps para Raspberry Pi. Certifique-se de dar permissão de execução ao executável usando chmod +x.

6. Execute a aplicação no Raspberry Pi mudando para o diretório de implantação e executando o executável.

   ./InputTutorial
   

   O console exibe texto semelhante ao seguinte:

   Initial status (05/10/2022 15:59:25): READY ✅
   

7. Desconecte o pino 21 da terra. O console exibe texto semelhante ao seguinte:

   (05/10/2022 15:59:59) ALERT 🚨
   

8. Reconecte o pino 21 e conecte-o à terra. O console exibe texto semelhante ao seguinte:

   (05/10/2022 16:00:25) READY ✅
   

9. Termine o programa pressionando Ctrl+C.

Parabéns! Usaste GPIO para detetar entradas usando o System.Device.Gpio pacote NuGet! Existem muitas utilizações para este tipo de entrada. Este exemplo pode ser usado com qualquer cenário em que um switch se conecta ou quebra um circuito. Aqui está um exemplo de usá-lo com um interruptor de palheta magnética, que é frequentemente usado para detetar portas ou janelas abertas.

Fio disparador a laser

Expandindo um pouco mais o conceito do exemplo anterior, vamos dar uma olhada em como isso poderia ser aplicado à criação de um tripwire de laser. A construção de um laser tripwire requer os seguintes componentes adicionais:

• KY-008 módulo transmissor laser
• Módulo sensor receptor laser (ver nota abaixo)
• 2 resistências Ω 10K

Conecte o equipamento sensor laser de disparo

Conecte os componentes conforme detalhado no diagrama a seguir.

Preste muita atenção aos resistores de 10K Ω. Estes implementam um divisor de tensão. Isso ocorre porque o módulo recetor a laser emite 5V para indicar que o feixe está quebrado. O Raspberry Pi suporta apenas até 3,3 V para entrada GPIO. Uma vez que enviar o 5V completo para o pino pode danificar o Raspberry Pi, a corrente do módulo recetor é passada através de um divisor de tensão para reduzir pela metade a tensão para 2,5V.

Aplicar atualizações de código-fonte

Quase se pode usar o mesmo código de antes, com uma exceção. Nos outros exemplos, usámos PinMode.InputPullUp de forma que, quando o pino está desligado da terra e o circuito está aberto, o pino devolve PinValue.High.

No entanto, no caso do módulo recetor laser, não estamos detetando um circuito aberto. Em vez disso, queremos que o pino atue como um dissipador de corrente proveniente do módulo recetor a laser. Neste caso, vamos abrir o pino com PinMode.InputPullDown. Desta forma, o pino regressa PinValue.Low quando não recebe corrente e PinValue.High quando recebe corrente do módulo receptor laser.

controller.OpenPin(pin, PinMode.InputPullDown);

Obter o código-fonte

A fonte deste tutorial está disponível em GitHub.

Próximos passos