A l'occasion des 80 ans de la libération de Rennes, (re)découvrez l'ensemble des
contributions autour de la Seconde Guerre mondiale et de la libération sur Wiki-Rennes.
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).
Pour l'instant, cette page est utilisée pour rassembler toutes les notes suites aux expériences vécues pendant ce projet. A terme ces notes seront mises en forme pour constituer la documentation du projet.
Initiation à la programmation en C# sur .Net
Les premiers pas
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
Configuration du Publiphone IPT 701
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.
.jpg)
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.
.jpg)
Ensuite nous branchons ces fils sur une carte Arduino, pour essayer de comprendre comment sont mappés les boutons.
.jpg)
Voici le tableau du résultat obtenu :
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
7 novembre 2024 - premier test audio réussi
On a fait fonctionner le carbon microphone du combiné de l'IPT701 ! Avec un signal trop faible par contre, on va refaire le cablage clean et peut-être qu'on aura besoin d'utiliser un ampli classe D.
Les microphnes à chrbon sont des vieux micros, qui fonctionnent avec une alimentation électrique. Pour notre montage, nous nous sommes inspirés du "schéma sans transformateur" de cette page : https://www.sonelec-musique.com/electronique_realisations_preampli_micro_016.html
Nous avons choisi d'alimenter le circuit, pour cette phase de test, avec 4 piles 1V5 = 5Volts
A gauche les fils gris et orange vont vers l'entrée micro du raspberry. Les fils rouge et noir vont vers le bloc de piles. A droite les fils marron et noir vont vers le micro du combiné de l'IPT701.
Voici ce que ça donne avec le schéma :
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/
python3 -m venv venv
source venv/bin/activate
Pour ensuite installer la librairie GPIO : pip install RPi.GPIO
