Usare GPIO per l'input binario

I pin GPIO (General-Purpose I/O) possono essere configurati per ricevere segnali elettrici come input. Al livello più semplice, questo è utile per gli scenari che rilevano l'apertura/chiusura di un circuito. Tali circuiti possono includere pulsanti, interruttori a levetta, interruttori reed, interruttori di pressione e altri dispositivi che rappresentano valori binari (on/off) completando un circuito.

In questa esercitazione si useranno .NET e i pin GPIO di Raspberry Pi per rilevare l'apertura e la chiusura di un circuito.

Prerequisiti

• Computer basato su ARM (ARMv7 o versione successiva) a scheda singola (SBC)
• Cavetti di collegamento
• Basetta sperimentale (facoltativa)
• Scheda di interfaccia Raspberry Pi GPIO (facoltativa)
• .NET SDK 8 o versione successiva

Annotazioni

Questa esercitazione viene scritta presupponendo che il dispositivo di destinazione sia Raspberry Pi. Tuttavia, questa esercitazione può essere usata per qualsiasi SBC basato su Linux che supporta .NET, ad esempio Orange Pi, ODROID e altro ancora.

Verificare che SSH sia abilitato nel dispositivo. Per Raspberry Pi, vedere Configurazione di un server SSH nella documentazione di Raspberry Pi.

Preparare l'hardware

Usare i componenti hardware per compilare il circuito come illustrato nel diagramma seguente:

L'immagine precedente illustra una connessione diretta tra un pin di terra e un pin 21.

Suggerimento

Il diagramma illustra un breadboard e un breakout GPIO a scopo illustrativo, ma è possibile collegare semplicemente un pin di terra e un pin 21 con un cavo jumper sul Raspberry Pi.

Fare riferimento al diagramma di pinout seguente in base alle esigenze:

Immagine per gentile concessione Raspberry Pi Foundation.

Creare l'app

Completare i passaggi seguenti nell'ambiente di sviluppo preferito:

1. Creare una nuova app console .NET utilizzando il CLI di .NET o Visual Studio. Denominarlo InputTutorial.

   dotnet new console -o InputTutorial
   cd InputTutorial
   

2. Aggiungere il pacchetto System.Device.Gpio al progetto. Usare .NET CLI dalla directory del progetto o Visual Studio.

   dotnet add package System.Device.Gpio --version 3.2.0-*
   

3. Sostituire il contenuto di Program.cs con il codice seguente:

   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)}");
   }
   

   Nel codice precedente:

   • Una dichiarazione di 'using' crea un'istanza di GpioController. La using dichiarazione garantisce che l'oggetto venga eliminato e che le risorse hardware vengano rilasciate correttamente.
     • GpioController viene creata un'istanza senza parametri, a indicare che deve rilevare la piattaforma hardware in cui è in esecuzione e usare lo schema di numerazione dei pin logici.
   • Il pin GPIO 21 viene aperto con PinMode.InputPullUp.
     • Questo apre il pin con un resistore PullUp attivato. In questa modalità, quando il pin è collegato a terra, restituirà PinValue.Low. Quando il pin viene disconnesso da terra e il circuito è aperto, il pin restituisce PinValue.High.
   • Lo stato iniziale viene scritto in una console usando un'espressione ternaria. Lo stato corrente del pin viene letto con Read(). Se è PinValue.High, scrive la Alert stringa nella console. In caso contrario, scrive la Ready stringa.
   • RegisterCallbackForPinValueChangedEvent() registra una funzione di callback per gli eventi PinEventTypes.Rising e PinEventTypes.Falling sul pin. Questi eventi corrispondono rispettivamente agli stati dei pin di PinValue.High e PinValue.Low.
   • La funzione di callback punta a un metodo denominato OnPinEvent(). OnPinEvent() usa un'altra espressione ternaria che scrive le stringhe corrispondenti Alert o Ready.
   • Il thread principale dorme indefinitamente in attesa di eventi relativi ai pin.

4. Compilazione dell'app. Se si usa l'interfaccia della riga di comando di .NET, eseguire dotnet build. Per compilare in Visual Studio, premere CTRL+MAIUSC+B.

5. Distribuire l'app nel SBC come app autonoma. Per istruzioni, vedere Distribuire app .NET in Raspberry Pi. Assicurarsi di concedere all'eseguibile l'autorizzazione di esecuzione usando chmod +x.

6. Eseguire l'app in Raspberry Pi passando alla directory di distribuzione ed eseguendo il file eseguibile.

   ./InputTutorial
   

   La console visualizza testo simile al seguente:

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

7. Disconnettere il pin 21 da terra. La console visualizza testo simile al seguente:

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

8. Riconnettere il pin 21 e la messa a terra. La console visualizza testo simile al seguente:

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

9. Terminare il programma premendo CTRL+C.

Congratulazioni! Hai usato GPIO per rilevare l'input con il pacchetto NuGet System.Device.Gpio. Per questo tipo di input sono disponibili molti usi. Questo esempio può essere usato con qualsiasi scenario in cui un commutatore si connette o interrompe un circuito. Ecco un esempio di utilizzo con un interruttore magnetico reed, che viene spesso usato per rilevare porte aperte o finestre.

Tripwire laser

Estendendo ulteriormente il concetto di esempio precedente, si esaminerà come questo potrebbe essere applicato alla creazione di un tripwire laser. La creazione di un tripwire laser richiede i componenti aggiuntivi seguenti:

• Modulo di trasmissione laser KY-008
• Modulo sensore ricevitore laser (vedere la nota seguente)
• 2 resistori di Ω da 10.000

Annotazioni

Il modulo sensore del ricevitore laser è il nome generico applicato a un modulo comune trovato in molti rivenditori Internet. Il dispositivo può variare in base al nome o al produttore, ma dovrebbe essere simile a questa immagine.

Connettere l'hardware di tripwire laser

Connettere i componenti come descritto in dettaglio nel diagramma seguente.

Prestare particolare attenzione ai resistori Ω 10.000. Questi implementano un divisore di tensione. Questo perché il modulo ricevitore laser restituisce 5V per indicare che il fascio è rotto. Raspberry Pi supporta solo fino a 3,3 V per l'input GPIO. Poiché l'invio di tutti i 5V al pin potrebbe danneggiare il Raspberry Pi, il segnale dal modulo ricevitore viene passato attraverso un divisore di tensione per dimezzare la tensione a 2,5V.

Applicare gli aggiornamenti del codice sorgente

È quasi possibile usare lo stesso codice di prima, con un'eccezione. Negli altri esempi è stato usato PinMode.InputPullUp in modo che quando il pin viene disconnesso dal terreno e che il circuito sia aperto, il pin restituisce PinValue.High.

Tuttavia, nel caso del modulo del ricevitore laser, non viene rilevato un circuito aperto. Invece, si desidera che il pin agisca come dissipatore per la corrente proveniente dal modulo ricevitore laser. In questo caso, si aprirà il pin con PinMode.InputPullDown. In questo modo, il pin torna PinValue.Low quando non riceve corrente e PinValue.High quando riceve l'corrente dal modulo ricevitore laser.

controller.OpenPin(pin, PinMode.InputPullDown);

Importante

Assicurarsi che il codice distribuito in Raspberry Pi includa questa modifica prima di testare un tripwire laser. Il programma funziona senza di esso, ma l'uso della modalità di input sbagliata rischia di danneggiare Raspberry Pi!

Ottenere il codice sorgente

La sorgente per questa esercitazione è disponibile su GitHub.

Passaggi successivi

Informazioni su come leggere le condizioni ambientali da un sensore