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

'''Projet coordonné par la [[Maison_de_quartier_La_Touche|Maison de quartier La Touche]]'''<br><br>
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 : <syntaxhighlight lang="c#" line="1">
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;
}
</syntaxhighlight>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.<syntaxhighlight lang="c#">
controller.RegisterCallbackForPinValueChangedEvent(
    PinCombine,
    PinEventTypes.Falling,
    DecrochageCombine);

controller.RegisterCallbackForPinValueChangedEvent(
    PinCombine,
    PinEventTypes.Rising,
    RaccorchageCombine);
</syntaxhighlight>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 [https://fr.m.wikipedia.org/wiki/Fichier:Publiphone_fran%C3%A7ais_IPT_701_de_Mon%C3%A9tel.JPG publiphone IPT 701].

Nous cherchons à savoir quand on appuie sur un bouton.
[[Fichier:20240926 171730 (Large).jpg|alt=Boutons du publiphone IPT 701|néant|vignette|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.
[[Fichier:20240926 171712 (Large).jpg|alt=Nappe de connexion du bloc boutons|néant|vignette|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.
[[Fichier:20240926 171721 (Large).jpg|alt=Branchement nappe boutons sur carte Arduino|néant|vignette|Branchement nappe boutons sur carte Arduino]]


Voici le tableau du résultat obtenu :
[[Fichier:Capture d’écran de 2024-09-26 17-54-48.png|alt=Tableau de mappage des boutons avec les fils de la nappe|néant|vignette|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). 
[[Fichier:Tableau-correspondance.png|600x600px]] 

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

[[Fichier:Clavier matriciel.png]] 

-> on peut brancher directement les fils sur le raspberry, en suivant par exemple [http://electroniqueamateur.blogspot.com/2022/07/clavier-numerique-et-raspberry-pi-pico.html 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 ! 

Les microphnes à charbon 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
[[Fichier:Montage carbonmicro.jpg|alt=Montage sur breadbord du circtui pour alimenter et récupérer le signal du micro|néant|vignette]]
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.

Le bouton poussoir est juste là pour que l'on puisse rapidement désactiver l'alimentation, si jamais on se rend compte que ça chauffe quelque part.

Voici ce que ça donne avec le schéma :
[[Fichier:Schema-alimmicro.jpg|alt=Schéma du circuit d'alimentation du micro charbon|néant|vignette|Schéma du circuit d'alimentation du micro charbon]]

M : le micro a lui-même une résistance intégrée de 1000 Ω (mesuré au mutli-mètre).

R : résistance de 150 Ω

C : condensateur de 10 µF

Le résultat n'est pas parfait, mais on entend un son, très faible, après enregistrement. On va refaire le cablage plus propre, et on va certainement utiliser un ampli classe D pour amplifier le signal avant de l'envoyer dans la carte son du raspberry.

=== 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
[[Fichier:Lignes-Colonnes clavier-matriciel.png|alt=Disposition en lignes et colonnes du clavier matriciel|néant|vignette|110x110px|Disposition en lignes et colonnes du clavier matriciel]]