Utiliser GPIO pour l’entrée binaire

Les broches d’E/S à usage général (GPIO) peuvent être configurées pour recevoir des signaux électriques comme entrée. Au niveau le plus simple, cela est utile pour les scénarios qui détectent l’ouverture/fermeture d’un circuit. Ces circuits peuvent inclure des boutons-poussoirs, des interrupteurs à bascule, des interrupteurs à lames, des interrupteurs de pression et d'autres appareils qui représentent des valeurs binaires (activées/désactivées) en complétant un circuit.

Dans ce tutoriel, vous allez utiliser .NET et les broches GPIO de Raspberry Pi pour détecter l'ouverture et la fermeture d'un circuit.

Prerequisites

• Ordinateur monocarte basé sur ARM (ARMv7 ou supérieur) (SBC)
• Fils de jumper
• Plaque d'essai (facultatif)
• Plaque d'extension GPIO Raspberry Pi (facultatif)
• .NET SDK 10 ou version ultérieure

Vérifiez que SSH est activé sur votre appareil. Pour Raspberry Pi, reportez-vous à la configuration d’un serveur SSH dans la documentation Raspberry Pi.

Préparer le matériel

Utilisez les composants matériels pour générer le circuit comme illustré dans le diagramme suivant :

L’image ci-dessus illustre une connexion directe entre une broche au sol et une broche 21.

Reportez-vous au schéma de brochage suivant si nécessaire.

Image courtesy Raspberry Pi Foundation.

Créer l’application

Effectuez les étapes suivantes dans votre environnement de développement préféré :

1. Créez une nouvelle application console .NET à l’aide de la CLI .NET ou de Visual Studio. Nommez-le InputTutorial.

   dotnet new console -o InputTutorial
   cd InputTutorial
   

2. Ajoutez le package System.Device.Gpio au projet. Utilisez .NET CLI à partir du répertoire du projet ou Visual Studio.

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

3. Remplacez le contenu du fichier Program.cs par le code suivant :

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

   Dans le code précédent :

   • Une déclaration using crée une instance de GpioController. La using déclaration garantit que l’objet est supprimé et que les ressources matérielles sont correctement libérées.
     • GpioController est instancié sans paramètres, indiquant qu’il doit détecter la plateforme matérielle sur laquelle il s’exécute et utiliser le schéma de numérotation de broche logique.
   • La broche GPIO 21 est ouverte avec PinMode.InputPullUp.
     • Cela ouvre la broche avec une résistance PullUp engagée. Dans ce mode, lorsque la broche est connectée au sol, elle retourne PinValue.Low. Lorsque la broche est déconnectée du sol et que le circuit est ouvert, la broche retourne PinValue.High.
   • L’état initial est écrit dans une console à l’aide d’une expression ternaire. L’état actuel de la broche se lit avec Read(). Si c’est PinValue.High, il écrit la Alert chaîne dans la console. Sinon, il écrit la chaîne de caractères Ready.
   • RegisterCallbackForPinValueChangedEvent() inscrit une fonction de rappel pour les événements PinEventTypes.Rising et PinEventTypes.Falling sur le pin. Ces événements correspondent respectivement aux états des broches PinValue.High et PinValue.Low.
   • La fonction de rappel pointe vers une méthode appelée OnPinEvent(). OnPinEvent() utilise une autre expression ternaire qui écrit également les chaînes correspondantes AlertReady .
   • Le thread principal est en veille indéfiniment en attendant les événements de broche.

4. Générez l'application. Si vous utilisez l’interface CLI .NET, exécutez dotnet build. Pour générer dans Visual Studio, appuyez sur Ctrl+Shift+B.

5. Déployez l’application sur le SBC en tant qu’application autonome. Pour obtenir des instructions, consultez Déployer des applications .NET sur Raspberry Pi. Veillez à accorder à l’exécutable l’autorisation d’exécution à l’aide de chmod +x.

6. Exécutez l’application sur Raspberry Pi en basculant vers le répertoire de déploiement et en exécutant l’exécutable.

   ./InputTutorial
   

   La console affiche du texte similaire à ce qui suit :

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

7. Déconnectez la broche 21 du sol. La console affiche du texte similaire à ce qui suit :

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

8. Reconnectez la broche 21 et la terre. La console affiche du texte similaire à ce qui suit :

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

9. Terminez le programme en appuyant sur Ctrl+C.

Félicitations ! Vous avez utilisé GPIO pour détecter les entrées à l’aide du System.Device.Gpio package NuGet ! Il existe de nombreuses utilisations pour ce type d’entrée. Cet exemple peut être utilisé avec n’importe quel scénario où un commutateur se connecte ou interrompt un circuit. Voici un exemple qui l’utilise avec un commutateur magnétique, qui est souvent utilisé pour détecter les portes ouvertes ou les fenêtres.

Fils-piège laser

En étendant le concept d’exemple précédent un peu plus loin, examinons comment cela pourrait être appliqué à la création d’un tripwire laser. La création d’un tripwire laser nécessite les composants supplémentaires suivants :

• Module émetteur laser KY-008
• Module de capteur de récepteur laser (voir la remarque ci-dessous)
• 2 résistances de 10 kΩ

Connecter le matériel tripwire laser

Connectez les composants comme indiqué dans le diagramme suivant.

Faites attention aux résistances de 10 000 Ω. Ceux-ci implémentent un diviseur de tension. Cela est dû au fait que le module récepteur laser génère 5V pour indiquer que le faisceau est rompu. Raspberry Pi prend uniquement en charge jusqu’à 3,3V pour l’entrée GPIO. Étant donné que l'envoi du 5V complet à la broche risque d'endommager le Raspberry Pi, le courant du module récepteur passe par un diviseur de tension pour réduire de moitié la tension à 2,5V.

Appliquer des mises à jour de code source

Vous pouvez presque utiliser le même code que précédemment , à une exception près. Dans les autres exemples, nous avons utilisé PinMode.InputPullUp de sorte que lorsque la broche est déconnectée du sol et que le circuit est ouvert, la broche retourne PinValue.High.

Toutefois, dans le cas du module récepteur laser, nous ne détectons pas un circuit ouvert. Au lieu de cela, nous voulons que la broche agisse comme un récepteur pour le courant provenant du module récepteur laser. Dans ce cas, nous allons ouvrir la broche avec PinMode.InputPullDown. De cette façon, la broche retourne PinValue.Low quand elle n’obtient pas de courant et PinValue.High quand elle reçoit le courant du module récepteur laser.

controller.OpenPin(pin, PinMode.InputPullDown);

Obtenir le code source

La source de ce didacticiel est available sur GitHub.

Prochaines étapes