Programmation d'une cabine téléphonique anglaise - cabine de témoignages

Cette page documente l'expérience de programmation d'une carte raspberry pi dans le cadre du projet de fabrication d'une cabine téléphonique anglaise.

30/05/2024 - Initiation à la programmation en C# sur .Net

Installation du logiciel

La première étape est d'installer l'environnement, sur un ordinateur (et non pas sur le raspberry).

Télécharger et installer visual studio 2022 community https://visualstudio.microsoft.com/fr/vs/community/

C'est un IDE, donc il y a plein de possibilités : lors de l'installation, il faut sélectionner ASP.NET pour la charge de travail Web, et vérifier que dans les composants individuels on a bien .NET8 sélectionné.

Attention, on ne peut utiliser que des raspberry v4 ou +. Les versions 3 et antérieures ne sont pas compatibles avec .Net.

Découverte d'un premier programme

On suit le tuto d'initiation de Microsoft : recherche google pour aller chercher "C# raspberry pi blink a led" https://learn.microsoft.com/fr-fr/dotnet/iot/tutorials/blink-led

Sur cette page, dans la partie "Créer l’application", on va au numéro 3 et on trouve ce code :

using System;
using System.Device.Gpio;
using System.Threading;

Console.WriteLine("Blinking LED. Press Ctrl+C to end.");
int pin = 18;
using var controller = new GpioController();
controller.OpenPin(pin, PinMode.Output);
bool ledOn = true;
while (true)
{
    controller.Write(pin, ((ledOn) ? PinValue.High : PinValue.Low));
    Thread.Sleep(1000);
    ledOn = !ledOn;
}

Les 3 première lignes, sont les déclarations d'utilisation ("using"). C'est la même chose que "include" qu'on connaît bien parcequ'on a beaucoup utilisé ça sur Arduino.

Ensuite le 2ème morceau (jusqu'avant le while) c'est la déclaration pour le programme. :

• int pin = 18; -> on déclare une variable qui va s'appeler "pin" et qui prend la valeur 18.
• using var controller... -> ce n'est pas un using de déclaration, c'est un using de sécurité. On s'assure que la variable sera supprimée à la fin du programme = on libère la mémoire qui est utilisée par la variable.
• "var" c'est aussi une déclaration de variable, mais une variable non typée (contrairement au mot "int" qui déclare une variable de nombre entier)
• controller.OpenPin(pin, PinMode.Output); -> on dit à notre controller qu'on déclare en mode sortie le pin 18 (="pin", c'est marqué plus haut, faut suivre)
• bool ledOn = true; -> une variable booléenne qui s'appelle ledOn. Elle pourra avoir seulement 2 valeurs, true ou false.

Puis la fin, c'est la boucle du programme (while) c'est une boucle infinie.

• controller.Write(pin, ((ledOn) ? PinValue.High : PinValue.Low)); -> on envoie dans le port "pin" (=18) : si la variable ledOn est sur High, on envoie du 5Volts, sinon on envoie du 0 Volts.
• Thread.Sleep(1000); -> Ensuite on attend 1000 millisecondes
• ledOn = !ledOn; -> On inverse la valeur de ledOn : si c'est true on passe à false, si c'est false on passe à true.

Test du programme

Le programme visual studio 2022 community est installé, on l'ouvre et on crée un nouveau projet.

Bouton "Créer un projet" -> Application console. -> .Net8 -> Créer

Le premier programme console existe, il n'est pas écrit pour raspberry mais pour un PC. C'est le fameux "Hello World". On peut le lancer pour voir ce que ça fait.

Si on revient sur le tuto de tout à l'heure, l'étape 1 est déjà faite (parcequ'on a choisi le nom quand on a créé le nouveau projet.

Par contre il faut faire l'étape 2 : la librairie gpio n'est pas encore installée, il faut le faire. On peut le faire en ligne de commande comme sur le tuto mais on peut aussi le faire dans l'interface de Visual Studio.

Clic droit sur Dépendances, Gérer les packages NuGet, et dans la fenêtre de gauche on clique sur Parcourir et on tape "system.device.gpio". On sélectionne la librairie et on clique sur Installer.

On peut maintenant copier le contenu du programme ci-dessus dans l'interface. Et on enregistre.

Etape 4 du tuto : il va falloir compiler le programme pour pouvoir le mettre dans le raspberry. Menu Générer -> Générer la solution

Etape 5 : déployer l'application en tant qu'application autonome. Si on choisit en tant qu'application dépendante de la plateforme, il faudrait installer .Net sur le raspberry pour que ça marche. Le tuto nous indique de faire ça en ligne de commande, mais on peut passer par Visual Studio : dans la colonne de droite, clic droit sur le nom du projet > Publier.

On est pas encore prêt à communiquer direct avec la carte, donc on va passer par un dossier. Donc Publier > Dossier.

Attention, dans la fenêtre, cliquer sur un des crayons : modifier "Mode de déploiement" et mettre "autonome". Et Runtime cible : "linux-arm64"

Puis on clique en haut sur Publier.

Ensuite on copie le dossier généré dans la carte microSD du raspberry, sur le bureau.

On démarre le raspberry. On connecte une led sur les ports GPIO GND et 18. Attention à la correspondance des numérotations. Il faut prendre GPIO18 (numéro 12 sur case grise) -> https://www.framboise314.fr/scratch-raspberry-pi-composants/gpio/

On lance une console, on se dirige vers le bureau (cd /Desktop/NomduDossier). Et on tape ./<ConsoleApp1> (remplacer par le nom donné au programme)

-> attention, lors d'un test, la console renvoie "permission non accordée". Il a fallu faire chmod 777 ConsoleApp1 et ensuite en relançant ./ConsoleApp1 ça a marché.

6 juin 2024 - prise en compte d'un bouton

On commence à imaginer le fonctionnement : un état du programme va se lancer lors du décrochage du téléphone. Pour l'instant on travaille avec un bouton poussoir

Au passage on crée un compte github pour héberger notre projet. https://github.com/mqlt35/CabineTemoignage/

Pour le code, on ne sait pas si le bouton de décrochage du téléphone sera en Rising ou en Falling, on écrit donc deux fonctions, et on appellera celle qui faudra le moment venu.

controller.RegisterCallbackForPinValueChangedEvent(
    PinCombine,
    PinEventTypes.Falling,
    DecrochageCombine);

controller.RegisterCallbackForPinValueChangedEvent(
    PinCombine,
    PinEventTypes.Rising,
    RaccorchageCombine);

On pense utiliser la librairie NAudio https://github.com/naudio/NAudio qui permettra de gérer directement l'entrée microphone sur la carte, et lire nos fichiers audio.

Yannick a trouvé un projet documenté qui va nous permettre d'avoir des ressources sur le branchement d'un vieux téléphone et la gestion audio de l'écouteur et du micro : https://github.com/nickpourazima/rotary-phone-audio-guestbook