Usare GPIO per l'input binario

I/O (GPIO) per utilizzo generico possono essere configurati per ricevere segnali elettrici come input. A livello di base, questo è utile per gli scenari che rilevano l'apertura/chiusura di un circuito. Tali circuiti possono includere pulsanti, interruttore, commutatori reed, commutatori di pressione e altri dispositivi che rappresentano valori binari (on/off) completando un circuito.

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

Prerequisiti

• Computer a scheda singola (SBC) basato su ARM (ARMv7 o versione successiva)
• Cavi ponticello
• Pane (facoltativo)
• Scheda di interruzione Raspberry Pi GPIO (facoltativa)
• .NET SDK 7 o versione successiva

Nota

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

Assicurarsi 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'interruzione di pane e GPIO per scopi illustrativi, ma si è liberi di connettere solo 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 di Raspberry Pi Foundation.

Creare l'app

Completare i passaggi seguenti nell'ambiente di sviluppo preferito:

1. Creare una nuova app console .NET usando l'interfaccia della riga di comando .NET o Visual Studio. Denominarlo InputTutorial.

   dotnet new console -o InputTutorial
   cd InputTutorial
   

2. Aggiungere il pacchetto System.Device.Gpio al progetto. Usare l'interfaccia della riga di comando .NET dalla directory del progetto o da Visual Studio.

   dotnet add package System.Device.Gpio --version 2.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 using crea un'istanza di GpioController. La using dichiarazione garantisce che l'oggetto venga eliminato e le risorse hardware vengano rilasciate correttamente.
     • GpioController viene creata un'istanza senza parametri, che indica che deve rilevare quale piattaforma hardware è in esecuzione e usare lo schema di numerazione dei pin logici.
   • Il pin GPIO 21 viene aperto con PinMode.InputPullUp.
     • Verrà aperto il pin con un resistore PullUp impegnato. In questa modalità, quando il pin è connesso a terra, restituirà PinValue.Low. Quando il pin viene disconnesso dal terreno 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 sia per gli PinEventTypes.Rising eventi che PinEventTypes.Falling per il pin. Questi eventi corrispondono rispettivamente agli stati di pin di PinValue.High e PinValue.Low, .
   • La funzione callback punta a un metodo denominato OnPinEvent(). OnPinEvent()usa un'altra espressione ternaria che scrive anche le stringhe o Ready corrispondentiAlert.
   • Il thread principale dorme in modo indefinito durante l'attesa di eventi di pin.

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

5. Distribuire l'app in 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 dal terreno. La console visualizza testo simile al seguente:

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

8. Riconnettere il pin 21 e il terreno. La console visualizza testo simile al seguente:

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

9. Terminare il programma premendo CTRL+C.

Congratulazioni! È stato usato GPIO per rilevare l'input usando il System.Device.Gpio pacchetto NuGet. 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 che lo usa con un commutatore reed magnetico, che spesso viene usato per rilevare porte o finestre aperte.

Tripwire laser

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

• Modulo del trasmettitore laser KY-008
• Modulo sensore del ricevitore laser (vedere la nota seguente)
• 2 10K Ω resistori

Nota

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

Connettere l'hardware di tripwire laser

Connettere i componenti come descritto nel diagramma seguente.

Prestare attenzione ai resistori di Ω 10K. Queste implementano un divisore di tensione. Questo perché il modulo del ricevitore laser restituisce 5V per indicare che il raggio è interrotto. Raspberry Pi supporta solo fino a 3.3V per l'input GPIO. Poiché l'invio del valore completo 5V al pin potrebbe danneggiare Raspberry Pi, la corrente dal modulo ricevitore viene passata attraverso un divisore di tensione per metà della tensione a 2,5V.

Applicare gli aggiornamenti del codice sorgente

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

Tuttavia, nel caso del modulo del ricevitore laser, non viene rilevato un circuito aperto. Si vuole invece che il pin funzioni come sink per l'attuale proveniente dal modulo del ricevitore laser. In questo caso, si aprirà il pin con PinMode.InputPullDown. In questo modo, il pin restituisce PinValue.Low quando non ottiene alcuna corrente e PinValue.High quando riceve l'corrente dal modulo del ricevitore laser.

controller.OpenPin(pin, PinMode.InputPullDown);

Importante

Assicurarsi che il codice distribuito nel Raspberry Pi includa questa modifica prima di testare un tripwire laser. Il programma funziona senza di esso, ma usando la modalità di input sbagliata rischia di danneggiare raspberry Pi!

Ottenere il codice sorgente

L'origine per questa esercitazione è disponibile in GitHub.

Passaggi successivi

Informazioni su come leggere le condizioni ambientali da un sensore