Partager via

Utiliser GPIO pour l’entrée binaire

  • Article

Les broches d’E/S à usage général (GPIO) peuvent être configurées pour recevoir des signaux électriques en tant qu’entrée. Au niveau le plus élémentaire, cela est utile pour les scénarios qui détectent l’ouverture/la fermeture d’un circuit. Ces circuits peuvent inclure des boutons de commande, des commutateurs bascules, des commutateurs magnétiques, des commutateurs à pression et d’autres appareils qui représentent des valeurs binaires (activées/désactivées) en effectuant un circuit.

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

Prérequis

  • Ordinateur à carte unique (SBC) basé sur ARM (ARMv7 ou version ultérieure)
  • Câbles de liaison
  • Tableau de navigation (facultatif)
  • Carte d’évaluation GPIO Raspberry Pi (facultative)
  • Kit de développement logiciel (SDK) .NET version 7 ou ultérieure

Notes

Ce tutoriel est écrit en supposant que l’appareil cible est Raspberry Pi. Toutefois, ce tutoriel peut être utilisé pour n’importe quel SBC Linux qui prend en charge .NET, comme Orange Pi, ODROID, etc.

Vérifiez que SSH est activé sur votre appareil. Pour Raspberry Pi, consultez 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 :

Diagramme montrant un circuit qui connecte une broche de mise à la terre à la broche 21.

L’image ci-dessus illustre une connexion directe entre une broche de mise à la terre et une broche 21.

Conseil

Le diagramme représente un tableau de navigation et une carte d’évaluation GPIO à des fins d’illustration, mais n’hésitez pas à connecter une broche de mise à la terre et une broche 21 avec un fil de raccordement sur le Raspberry Pi.

Si nécessaire, reportez-vous au schéma de raccordement suivant :

Diagramme montrant le raccordement de l’en-tête GPIO Raspberry Pi. Image avec la permission de Raspberry Pi Foundation.
Image avec la permission de Raspberry Pi Foundation.

Créer l’application

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

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

    dotnet new console -o InputTutorial
cd InputTutorial

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

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

  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 déclaration using garantit que l’objet est supprimé et que les ressources matérielles sont correctement libérées.
    • La broche GPIO 21 est ouverte avec PinMode.InputPullUp.
      • Cette opération ouvre la broche avec une résistance PullUp enclenchée. Dans ce mode, lorsque la broche est connectée à la terre, elle retourne PinValue.Low. Lorsque la broche est déconnectée de la terre 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 est lu avec Read(). S’il s’agit de PinValue.High, il écrit la chaîne Alert dans la console. Sinon, il écrit la chaîne Ready.
    • RegisterCallbackForPinValueChangedEvent() enregistre une fonction de rappel pour les événements PinEventTypes.Rising et PinEventTypes.Falling sur la broche. Ces événements correspondent aux états de broche PinValue.High et PinValue.Low, respectivement.
    • La fonction de rappel pointe vers une méthode appelée OnPinEvent(). OnPinEvent() utilise une autre expression ternaire qui écrit également les chaînes Alert ou Ready correspondantes.
    • Le thread principal se met en veille indéfiniment pendant l’attente d’é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+Maj+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 exécuter à l’aide de chmod +x.

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

    ./InputTutorial

    La console affiche un texte semblable à ce qui suit :

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

  7. Déconnectez la broche 21 de la terre. La console affiche un texte semblable à ce qui suit :

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

  8. Rebranchez la broche 21 et la terre. La console affiche un texte semblable à 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 package NuGet System.Device.Gpio ! 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 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 ou les fenêtres ouvertes.

GIF animé montrant un commutateur magnétique ouvrant et fermant. Le commutateur est exposé à un aimant et l’application affiche PRÊT. L’aimant est supprimé et l’application affiche ALERTE. L’action est ensuite répétée.

Fil de déclenchement laser

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

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

Notes

Module de capteur de récepteur laser est le nom générique appliqué à un module commun trouvé chez de nombreux détaillants Internet. Le nom ou le fabricant de l’appareil peut varier, mais doit ressembler à cette image.

Image d’un module de capteur de récepteur laser

Connecter le matériel de déclenchement laser

Connectez les composants comme indiqué dans le diagramme suivant.

Diagramme montrant un circuit qui obtient l’entrée d’un module de capteur de récepteur laser.

Prêtez une attention particulière aux résistances de 10K Ω. Celles-ci implémentent un diviseur de tension. Cela est dû au fait que le module récepteur laser génère 5 V pour indiquer que le faisceau est cassé. Raspberry Pi prend uniquement en charge jusqu’à 3,3 V pour l’entrée GPIO. Étant donné que l’envoi de la totalité des 5 V à la broche pourrait endommager le Raspberry Pi, le courant du module récepteur passe à travers un diviseur de tension pour réduire la tension de moitié à 2,5 V.

Appliquer les mises à jour du 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 pour que, lorsque la broche est déconnectée de la terre 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 de circuit ouvert. Au lieu de cela, nous voulons que la broche joue le rôle de 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 lorsqu’elle ne reçoit pas de courant et PinValue.High quand elle reçoit le courant du module récepteur laser.

controller.OpenPin(pin, PinMode.InputPullDown);

Important

Assurez-vous que le code déployé sur votre Raspberry Pi inclut cette modification avant de tester un fil de déclenchement laser. Le programme fonctionne sans lui, mais l’utilisation du mauvais mode d’entrée risque d’endommager votre Raspberry Pi !

GIF animé montrant une démonstration du fil de déclenchement laser. L’émetteur laser allume le module du capteur laser et l’application affiche PRÊT. Le faisceau laser est cassé et l’application affiche ALERTE. L’action est ensuite répétée.

Obtenir le code source

La source de ce tutoriel est disponible sur GitHub.

Étapes suivantes

Apprendre à lire les conditions environnementales sur un capteur