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

Cette page documente l'expérience d'installation électronique et de programmation d'une carte raspberry pi dans le cadre du projet de fabrication d'une cabine téléphonique anglaise (la fabrication de l'ossature de la cabine est documentée dans cette autre page).

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

26 septembre 2024 - mappage des boutons du téléphone

Nous venons aujourd'hui d'acquérir un publiphone IPT 701.

Nous cherchons à savoir quand on appuie sur un bouton.

Boutons du publiphone IPT 701

Dans le boîtier, nous récupérons la nappe qui ressort du bloc boutons. Elle est composée de 10 fils que nous nommons de A à J.

Nappe de connexion du bloc boutons

Ensuite nous branchons ces fils sur une carte Arduino, pour essayer de comprendre comment sont mappés les boutons.

Branchement nappe boutons sur carte Arduino

Voici le tableau du résultat obtenu :

Tableau de mappage des boutons avec les fils de la nappe

Ci dessous le tableau remis en forme borne (fils) / boutons afin de faire ressortir les lignes et les colonnes du clavier matriciel (ligne en jaune, colonnes en blanc).

Le tableau précédent permet de déterminer que le clavier matriciel est symbolisable comme ci-dessous.

-> on peut brancher directement les fils sur le raspberry, en suivant par exemple ce tuto, ou alors utiliser un décodeur clavier matriciel vers numérique.

On laisse ça là pour l'instant, et on essaye de faire fonctionner le combiné. Le câble du combiné comporte 4 fils : 1 rouge, 1 bleu, 1 vert foncé et 1 vert clair.

En branchant la sortie audio du raspberry pi sur les fils bleu (-) et rouge (+), le son s'entend parfaitement bien dans le téléphone.

Par contre impossible d'utiliser le micro depuis les 2 fils verts. Nous avions eu le même problème sur tous les vieux téléphones que nous avons testé : en branchant les 2 fils sur l'entrée audio de la carte son, rien ne passe... Et c'est bien normal, tous ces vieux téléphones utilisent des micros à charbon.

Une piste ici : https://www.sonelec-musique.com/electronique_realisations_preampli_micro_016.html et https://sonelec-musique.com/electronique_realisations_ligne_tel_audio.html

Une autre là : http://pafgadget.free.fr/bidouillages/telephone-intercom.htm

31 octobre 2024

On se relance dans la prog, sur une install neuve de raspberry OS (l'ancienne carte SD ne répond plus).

Installation de pip : https://pimylifeup.com/raspberry-pi-pip/

Pour ensuite installer la librairie GPIO : pip install RPi.GPIO