<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Projets plus ou moins stupides</title>
    <link>https://luclu7.fr/blog/</link>
    <description>Recent content on Projets plus ou moins stupides</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>fr-fr</language>
    <lastBuildDate>Sat, 06 Aug 2022 13:41:37 +0200</lastBuildDate><atom:link href="https://luclu7.fr/blog/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Confinement, Train Simulator et STM32: partie 2, le KVB</title>
      <link>https://luclu7.fr/blog/post/ts-part2/</link>
      <pubDate>Sat, 06 Aug 2022 13:41:37 +0200</pubDate>
      
      <guid>https://luclu7.fr/blog/post/ts-part2/</guid>
<description>Le KV-quoi? Le KVB, ou Contrôle de Vitesse par Balises, est un système qui surveille la vitesse du train pour éviter les accidents. Le système est composé de deux parties: le calculateur, dans le train; et la partie IHM (Interface Homme-Machine), qui contient les boutons et divers affichages, que je vais tenter de recréer.
Le calculateur&hellip; calcule, les courbes de vitesses, et selon la vitesse de la section (par radio avec une balise au sol, entre les rails), détecte les problèmes éventuels.</description>
<content:encoded><h2 id="le-kv-quoi">Le KV-quoi?</h2>
<p>Le KVB, ou Contrôle de Vitesse par Balises, est un système qui surveille la vitesse du train pour éviter les accidents. Le système est composé de deux parties: le calculateur, dans le train; et la partie IHM (Interface Homme-Machine), qui contient les boutons et divers affichages, que je vais tenter de recréer.</p>
<p>Le calculateur&hellip; calcule, les courbes de vitesses, et selon la vitesse de la section (par radio avec une balise au sol, entre les rails), détecte les problèmes éventuels. Si la vitesse est supérieur de 5 km/h à la vitesse maximale théorique, trois choses se passent: le voyant V s&rsquo;allume (Vitesse), une alerte sonore s&rsquo;active pendant 2 secondes, et les deux afficheurs 7 segments clignotent. Si la vitesse dépasse les 10km/h au dessus de la limite, déclenchement du freinage d&rsquo;urgence et le voyant &ldquo;FU&rdquo; (Freinage d&rsquo;Urgence, le symbole avec une roue et des patins des deux côtés) s&rsquo;allume. Si vous voulez plus d&rsquo;explications dans le détail, je vous envoie sur ce <a href="http://lesiteferroviaire.free.fr/kvb.htm">fantastique site</a>.</p>
<p><img src="/blog/img/kvb/kvb-rio.jpg" alt="KVB d&rsquo;une rame RIO">
<em>Source de l&rsquo;image: <a href="https://commons.wikimedia.org/wiki/File:Rame_inox_de_banlieue_-_KVB_sur_le_pupitre_de_conduite.jpg">Clicsouris</a></em></p>
<p>Je n&rsquo;ait fait, pour l&rsquo;instant, que la partie supérieur.</p>
<h3 id="explication-des-différents-boutons-et-afficheurs">Explication des différents boutons et afficheurs</h3>
<ul>
<li>
<h4 id="boutons-carrés-et-blancs">Boutons (carrés et blancs)</h4>
<ul>
<li>VAL (BP-VAL): validation, permet de valider la configuration entrée</li>
<li>Violet avec 3 points blancs (BP-MV): bouton manoeuvre</li>
<li>Rouge et blanc (BP-FC): franchissement carré (signal fermé)</li>
<li>Test (BP-TEST): test du KVB (affichages, boutons, arrêt d&rsquo;urgence)</li>
<li>SF (BP-SF): permet d&rsquo;éteindre la lampe de répétition des signaux (voir LS-SF)</li>
</ul>
</li>
<li>
<h4 id="afficheurs-7-segments">Afficheurs 7 segments</h4>
<ul>
<li>Visualisateur auxiliaire, en jaune</li>
<li>visualisateur principal, en vert</li>
</ul>
</li>
<li>
<h4 id="lampes">Lampes</h4>
<ul>
<li>V (LS-V): Vitesse, s&rsquo;allume en cas d&rsquo;excès de vitesse de 5 km/h.</li>
<li>FU (LS-FU): Freinage d&rsquo;urgence, s&rsquo;allume en cas d&rsquo;arrêt d&rsquo;urgence par le KVB (+10 km/h)</li>
<li>Panne sol: s&rsquo;allume en cas de balise défaillante (ce qui ne devrait pas arriver en simulation !)</li>
<li>Panne engin: idem, mais en cas de panne sur l&rsquo;engin moteur</li>
<li>Grosse lampe en haut à droite: LS-SF, Signal Fermé, pas réellement du KVB (c&rsquo;est en réalité la <a href="http://lesiteferroviaire.free.fr/repetition%20des%20signaux.htm" title="Répétition des Signaux Optiques">RSO</a>) mais incorporée dans le panneau pour des raisons pratiques</li>
</ul>
</li>
</ul>
<p><a href="http://lesiteferroviaire.free.fr/Files/Image/panneau_kvb_detaille.gif">Schema</a></p>
<h2 id="maintenant-que-vous-savez-ce-que-cest-comment">Maintenant que vous savez ce que c&rsquo;est, comment?</h2>
<p>Au lieu de vouloir bricoler une plaque avec une scie sauteuse et beaucoup de patience, j&rsquo;ai décidé de faire tout un boîtier (et la facade) en impression 3D.
Le 19 mai 2021, à 02:37 du matin précisément, j&rsquo;ai donc lancé Fusion 360 et ait commencé mon sketch.</p>
<p>Pour modéliser, j&rsquo;ai pris exactement la même photo que ci-dessus pour m&rsquo;en servir de modèle, puis, en partant du principe que les vis étant du M3 ou M4, j&rsquo;ai tout mis à la bonne échelle. Parce que le boîtier est vissé/dévissé souvent, j&rsquo;ai choisi d&rsquo;utiliser des inserts.</p>
<h2 id="le-plus-important-les-afficheurs-7-segments">Le plus important: les afficheurs 7 segments</h2>
<p>Les information les plus importantes sont données sur les deux visualisateurs à base d&rsquo;afficheurs 7 segments. Cependant, n&rsquo;ayant jamais trouvé de bon modules pour l&rsquo;afficheur auxiliaire (en jaune/ambre), je vais me concentrer sur l&rsquo;afficheur principal, en vert.</p>
<h3 id="les-debuts">Les debuts</h3>
<p><img src="/blog/img/kvb/tm1637-green.png" alt="Afficheur TM1637 vert" title="Exemple de module à base de TM1637">
Pour des raisons très techniques de pure simplicité, j&rsquo;ai choisi d&rsquo;utiliser un module à base de TM1637 (<a href="/blog/img/kvb/TM1637.pdf">datasheet</a>). Si vous lisez la datasheet, vous trouverez que c&rsquo;est une puce qui fonctionne à anode commune (c&rsquo;est à dire le côté positif des segments, pour se souvenir: PANIC (Positive is Anode, Negative Is Cathode)). Quelle ne fut pas ma surprise quand j&rsquo;ai accidentellement commandé des afficheurs à cathode commune.</p>
<p>Après avoir commandé les bons afficheurs, j&rsquo;en ai testé un manuellement en le connectant directement aux pins sur le module TM1637.
<img src="/blog/img/kvb/1-7seg-tm1637.jpg" alt="Un seul afficheur soudé sur une perfboard">
<em>C&rsquo;était 4h du matin !</em>
<img src="/blog/img/kvb/2-7seg-tm1637.jpg" alt="Câblage sur la plaquette"></p>
<h3 id="un-cest-bon-plus-que-le-reste-">Un c&rsquo;est bon, plus que le reste !</h3>
<p>Vu qu&rsquo;avec un seul segment ça fonctionnait, autant continuer avec trois ! Je me suis donc empressée de souder 3 afficheurs 7 segments, toujours sur un perfboard, et de relier les différents segments et cathodes. C&rsquo;est&hellip; pas très propre, mais ça marche !
<img src="/blog/img/kvb/3-7seg-tm1637.jpg" alt="Perfboard avec 3 afficheurs 7 segments vert branchés avec le module TM1637">
<img src="/blog/img/kvb/3bis-7seg-tm1637.jpg" alt="Derrière la perfboard">
C&rsquo;est compliqué de relier 7 segments en communs, plus les cathodes individuelles. J&rsquo;ai fait un peu de <a href="https://fr.wikipedia.org/wiki/Wrapper_(%C3%A9lectronique)">wire wrapping</a>, mais sans outil ! C&rsquo;est un peu sportif, ça met beaucoup de temps (comptez une très bonne soirée) et avec un peu de malchance, le fil se casse en plein milieu et il faut tout recommencer. Vous avez vite envie de faire un PCB ! (<em>foreshadowing quand tu nous tiens</em>&hellip;)</p>
<p><img src="/blog/img/kvb/4-7seg-tm1637.jpg" alt="Afficheur affichant trois tirets, indiquant que ça fonctionne">
Bonne nouvelle ! Les trois tirets veulent dire que tout fonctionne ! (dans la réalité, ils signifient que tout va bien et le KVB fonctionne)</p>
<h3 id="un-pcb">Un PCB?</h3>
<p>L&rsquo;étape suivante, c&rsquo;est de faire un PCB (Printed Circuit Board, un circuit imprimé) !
Toute heureuse, je me lance bêtement pour faire un schéma, puis un PCB avec le TM1637 et de quoi brancher mon module 7 segments. Je suis bien la datasheet, mais moi et ma chance&hellip; Je reçoit les circuits (assemblés s&rsquo;il vous plaît !), je le branche et&hellip; Rien !
<img src="/blog/img/kvb/pcb1.png" alt="Rendu 3D du premier PCB" title="Rendu 3D du premier PCB">
Tant pis, je ferais de manière moche.</p>
<p>Je fais à la place un autre circuit pour tenir les 7 segments et réunir leurs connexions en un seul point, pour éviter de devoir tout câbler à la main à nouveau.
<img src="/blog/img/kvb/pcb2.png" alt="Rendu 3D du second PCB" title="Rendu 3D du second PCB (pas complet)">
<em>Vous trouvez le problème? Indice, c&rsquo;est en bas !</em></p>
<p>Cependant, à la réception je me suis aperçue qu&rsquo;il y avait une trace qui passait trop près de tous les pins sur un des afficheurs. Résultats, je suis obligée de couper cette trace manuellement entre chaque point. Oups !
<img src="/blog/img/kvb/pcb-trace-bodge-wire.jpg" alt="Bodge wire et coup de cutter pour corriger cette erreur" title="Bodge wire et coup de cutter pour corriger cette erreur"></p>
<h2 id="le-début-de-la-modélisation">Le début de la modélisation</h2>
<p><img src="/blog/img/kvb/kvb-20-mai.png" alt="20 mai, à 14h et quelques" title="Le lendemain aprem">
Après quelques jours
<img src="/blog/img/kvb/kvb-29-mai.png" alt="Une grosse semaine après" title="Une grosse semaine après">
Cette version vous intéresse? J&rsquo;ai un export du <a href="/blog/img/kvb/KVB-mai.stp">STEP ici</a>.</p>
<p>Après pas mal de temps passé avec ma perceuse et une lime pour corriger la taille des trous, trop petits, impressions 3D oblige, j&rsquo;ai fait beaucoup de légers changements. Quasiment un an plus tard, voici le résultat &ldquo;final&rdquo;, en prenant en compte les problèmes suivants:</p>
<ul>
<li>Je n&rsquo;ai pas trouvé d&rsquo;afficheur 7 segment &ldquo;ambre&rdquo;, encore moins de la bonne taille (et 3 chiffres), donc à la place j&rsquo;utilise un simple module 4 chiffres rouges</li>
<li>Normalement on peut tourner le LS-SF afin d&rsquo;ajuster la luminosité, cependant je ne le supporte pas.</li>
</ul>
<h3 id="1ère-version">1ère version</h3>
<p>Première version imprimée, avec d&rsquo;anciens boutons (qui n&rsquo;étaient ni assez grands, ni rétro éclairés, ni satisfaisants, ni fonctionnels après avoir été soudé, et il n&rsquo;est pas non plus possible d&rsquo;insérer une étiquette) et seulement l&rsquo;afficheur principal:
<img src="/blog/img/kvb/kvb-1ere-impression.jpg" alt="Impression 3D de la plaque frontale avec l&rsquo;afficheur 7 segment principal qui rentre pile"></p>
<p>On arrive en juin et en juillet: l&rsquo;heure de faire une petite pause.</p>
<p>De retour fin juillet, j&rsquo;ai reçu de nouveaux boutons (excellents, je le recommande clairement, sur <a href="https://fr.aliexpress.com/item/32918157519.html">AliExpress</a>)</p>
<p>À l&rsquo;époque, j&rsquo;avais tout sur une breadboard, mais c&rsquo;était un enfer (les câbles qui se déconnectent, les mauvais contact, et puis la taille !)
<img src="/blog/img/kvb/breadboard.jpg" alt="Breadboard avec seulement les câbles, sans composant">
J&rsquo;ai donc heureusement décidé de passer sur un perfboard, ce que j&rsquo;ai fait plutôt rapidement.
<img src="/blog/img/kvb/perfboard1.jpg" alt="Perfboard vue de dessus">
Les câbles à droite vont vers les boutons, les afficheurs 7 segments se branchent en haut à gauche
<img src="/blog/img/kvb/perfboard2.jpg" alt="Perfboard vue de dessous">
On peut voir les gros blobs de soudure, en haut pour le &ldquo;rail +5V&rdquo; et en bas pour la masse. On peut apercevoir la demi-tonne de câbles rouges, avec un élastique à droite. Ce sont les câbles qui relient l&rsquo;afficheur principal (vert) et le module 7 segments derrière.</p>
<p>Pour des raisons de bricolage, ça tient à la patafix blanche.</p>
<p>Avec tout câblé, les LEDs ajoutées et le PCB venu à l&rsquo;élastique, voilà le résultat !
<img src="/blog/img/kvb/kvb-led.jpg" alt="Plaque frontale peuplée de tous ses composants">
Test automatique des LEDs:</p>
<p>
 
<video width=100% controls loop alt="">
    <source src="/blog/img/kvb/kvb-led-test.mp4" type="video/mp4">
    La vidéo ne fonctionne pas?
    <a href="/blog/img/kvb/kvb-led-test.mp4">Téléchargez là directement</a>
</video>

Pour donner une idée, voici l&rsquo;intérieur du boîtier à l&rsquo;époque:
<img src="/blog/img/kvb/arriere-boitier-1.jpg" alt="Vue de l&rsquo;intérieur">
(<a href="/blog/img/kvb/arriere-boitier-2.jpg">autre vue</a>)</p>
<h3 id="final">Final</h3>
<p>Le résultat &ldquo;final&rdquo; de l&rsquo;époque (5 août 2021) !
<img src="/blog/img/kvb/kvb-sur-bureau.jpg" alt="KVB complet, en fonctionnement"></p>
<p>Fin août j&rsquo;ai rajouté la fameuse lampe LS-SF. Cependant, elle fonctionne en 12V, j&rsquo;ai donc rajouté un boost converter pour passer à 12 V puis&hellip; un optocoupleur, pour contrôler la LED. C&rsquo;est ce que j&rsquo;avais sous la main le plus simple, et puis c&rsquo;est drôle.
Et voici donc une démo en fonctionnement:

 
<video width=100% controls loop alt="">
    <source src="/blog/img/kvb/kvb-test.mp4" type="video/mp4">
    La vidéo ne fonctionne pas?
    <a href="/blog/img/kvb/kvb-test.mp4">Téléchargez là directement</a>
</video>
</p>
<p>Récemment je me suis décidée à éditer un peu le modèle 3D pour mieux tenir les boutons, avoir un gap plus faible sur le visualisateur auxiliaire et utiliser des vrais &ldquo;LED holders&rdquo; (sur <a href="https://www.ebay.fr/itm/112408248171">eBay</a>), car la patafix c&rsquo;est pas vraiment ça. Je remplacerait aussi bientôt LS-SF par la même lampe mais avec un angle plus élevé (30° actuellement, 120 après).
<img src="/blog/img/kvb/kvb-final.jpg" alt="Rendu actuel"></p>
<p>Pour le modèle 3D actuel c&rsquo;est <a href="/blog/img/kvb/KVB.stp">ici</a>. Notez qu&rsquo;il faut vous même percer le trou pour LS-SF.</p>
<h2 id="pcb">PCB</h2>
<p>Pour me simplifier la vie, j&rsquo;ai rapidement fait un PCB, quasiment à l&rsquo;identique de la perfboard.</p>
<p><a href="/blog/img/kvb/schema-pcb-final.png"><img src="/blog/img/kvb/schema-pcb-final.png" alt="Schéma"></a>
<img src="/blog/img/kvb/pcb3.png" alt="PCB final de commande"></p>
<h2 id="côté-communication">Côté communication</h2>
<p>Bien que j&rsquo;utilise une carte à base de STM32F103C8T6, notamment pour son port USB type C, il devrait être possible d&rsquo;utiliser un autre Arduino sans trop de problème.</p>
<p>Étant donné qu&rsquo;il y a beaucoup plus d&rsquo;informations qu&rsquo;avant (les 5 boutons dans le sens Arduino ↦ PC, les 9 LEDs (4 statut, 4 boutons, LS-SF) et les deux afficheurs 7 segments dans le sens PC ↦ Arduino), j&rsquo;ai fait le choix d&rsquo;utiliser du JSON en série pour la communication. C&rsquo;est extrêmement inefficace et ce n&rsquo;est pas du tout une bonne solution, mais ça fonctionne et c&rsquo;est pratique. J&rsquo;utilise donc l&rsquo;excellente librairie <a href="https://arduinojson.org/">ArduinoJson</a>. J&rsquo;utilise aussi la librairie <a href="https://github.com/thomasfredericks/Bounce2">Bounce2</a> afin d&rsquo;éviter de devoir implémenter du debouncing manuellement.</p>
<p>Pour éviter de spammer TrainSim, j&rsquo;ai implémenté une simple vérification qui n&rsquo;envoie une nouvelle ligne que si elle est différente de la précédente. Côté PC, les deux fonctions (readInput et writeOutput) fonctionnent en parallèle, dans deux threads séparés.</p>
<h2 id="code-source">Code source</h2>
<p><a href="/blog/img/kvb/kvb.ino">Code source Arduino</a>
<a href="/blog/img/kvb/kvb.py">Code source PC</a> (le frein/Grand débit est à moitié supporté.)</p>
<h2 id="conclusion">Conclusion</h2>
<p>Ça m&rsquo;en aura pris du temps pour brancher une dizaine de LEDs et de boutons ! La tâche qui aura pris le plus de temps est sûrement de remplir les paramètres pour les afficheurs 7 segments. En tout cas j&rsquo;ai pas mal appris sur tout ça (*tousse* DRC).</p>
<p>En terminant cet article, je viens de réaliser la quantité d&rsquo;afficheurs 7 segments que j&rsquo;ai acheté pour ce projet. Je vous laisse juger !
<img src="/blog/img/kvb/7segments.jpg" alt=""></p>
<p>Merci beaucoup de m&rsquo;avoir lue !</p>
</content:encoded>

    </item>
    
    <item>
      <title>Confinement, Train Simulator et STM32: partie 1, la VA</title>
      <link>https://luclu7.fr/blog/post/ts-part1/</link>
      <pubDate>Thu, 04 Aug 2022 14:06:07 +0200</pubDate>
      
      <guid>https://luclu7.fr/blog/post/ts-part1/</guid>
<description>Le contexte C&rsquo;était le confinement, vers mi-2020. À l&rsquo;époque où tout sur AliExpress ne coûtait pas encore un prix ridicule, à l&rsquo;époque où on pouvait acheter un module STM32F103(C8T6) avec USB type C pour&hellip; 1€60 ! Je suis fan de trains (et donc de Train simulator) et j&rsquo;avais beaucoup de temps libre, école à distance/hybride oblige. Comme beaucoup de passioné·e·s, je rêve d&rsquo;avoir, un jour, un vrai pupitre (de commande) chez moi, et de pouvoir le connecter à un simulateur ferroviaire (TS, ou surtout OpenRails, comme souvent).</description>
<content:encoded><h2 id="le-contexte">Le contexte</h2>
<p>C&rsquo;était le confinement, vers mi-2020. À l&rsquo;époque où tout sur AliExpress ne coûtait pas encore un prix ridicule, à l&rsquo;époque où on pouvait acheter un module STM32F103(C8T6) avec USB type C pour&hellip; 1€60 !
<img src="/blog/img/kvb/aliexpress-1.png" alt="Capture d&rsquo;écran d&rsquo;Aliexpress montrant la commande d&rsquo;un STM32 pour 1€60">
Je suis fan de trains (et donc de <a href="https://store.steampowered.com/app/24010/Train_Simulator_Classic/?l=french">Train simulator</a>) et j&rsquo;avais beaucoup de temps libre, école à distance/hybride oblige. Comme beaucoup de passioné·e·s, je rêve d&rsquo;avoir, un jour, un vrai pupitre (de commande) chez moi, et de pouvoir le connecter à un simulateur ferroviaire (TS, ou surtout OpenRails, comme souvent).
Par exemple:
<a href="https://www.youtube.com/watch?v=fl0SIUiUrc0"><img src="/blog/img/kvb/pupitre-72000-ferrovisim.jpg" alt="Pupitre ce CC 72000, converti par Ferrovisim" title="Pupitre de CC 72000 converti sous OpenRails"></a></p>
<p>N&rsquo;ayant pas de pupitre (ça se trouve pas sur leboncoin (quoi que&hellip;)), il existe une autre option: le RailDriver.
<img src="/blog/img/kvb/raildriver.png" alt="Contrôleur RailDriver pour TrainSimulator">
Le seul problème, c&rsquo;est que ça coûte cher, et je ne croule pas sous l&rsquo;argent. Doooonc, la bricole à la rescousse (et puis c&rsquo;est plus intéressant !)</p>
<h2 id="en-pratique">En pratique?</h2>
<p>Donc pour commencer, j&rsquo;ai voulu tenter par un élément simple: la pédale de VA (<a href="https://fr.wikipedia.org/wiki/Veille_automatique">Veille Automatique</a>).
Explication rapide: la VA (complet: VACMA, veille automatique à contrôle du maintien d&rsquo;appui) sert à éviter qu&rsquo;en cas de (notamment) malaise conducteur, le train s&rsquo;arrête automatique.</p>
<p>La VA est présente sous différentes formes: une pédale à maintenir appuyée, mais pas plus de 55 secondes. Il faut en effet la relâcher et rappuyer pour prouver qu&rsquo;on est bien conscient. Si le conducteur garde sa pédale enfoncée 55s, une sonnerie se met à sonner. Si au bout de 2.5s il n&rsquo;a pas relâché l&rsquo;appui, le freinage d&rsquo;urgence s&rsquo;engage.</p>
<p>L&rsquo;avantage de commencer par cette partie est qu&rsquo;elle est très simple à implémenter (un seul élément booléen), et qu&rsquo;une pédale est bien plus pratique que la barre espace !</p>
<p>J&rsquo;avais acheté par curiosité une pédale à connecter avant: parfait !
<img src="/blog/img/kvb/p%C3%A9dale.png" alt="Pédale">
<img src="/blog/img/kvb/p%C3%A9dale_avec_connecteur.jpg" alt="Pédale connecteurisée"></p>
<p>Donc côté matériel, c&rsquo;est presque fini. Plus que la connexion avec le logiciel.</p>
<h2 id="la-communication-et-lintégration">La communication et l&rsquo;intégration</h2>
<p>Et c&rsquo;est là qu&rsquo;on a de la chance: grâce au RailDriver précédemment évoqué, il existe une DLL pour s&rsquo;interface &ldquo;facilement&rdquo; avec TS: &ldquo;RailDriver.dll&rdquo; et &ldquo;RailDriver64.dll&rdquo;.</p>
<p>Je saute toute la partie &ldquo;bricoler avec un outils en Java&rdquo; (<a href="https://github.com/reallyinsane/trainsimulator-controller">cet outil</a>), j&rsquo;ai pas réussi à en faire grand chose.</p>
<p>Cependant, il existe un autre language plus pratique que Java: Python !
Malgré que je n&rsquo;aime pas spécialement Python (manque d&rsquo;expérience, j&rsquo;aime pas trop la syntaxe basée sur l&rsquo;indentation, etc), il existe une superbe librairie: <a href="https://github.com/piotrkilczuk/py-raildriver">py-raildriver</a>.</p>
<p>Ainsi, côté Arduino (le STM32F103 précédent, quand il était encore vivant) en série, j&rsquo;envoie simplement un 0 ou un 1, suivi d&rsquo;un LF (\n, retour à la ligne), et côté client (sur le PC):</p>
<p><div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#719e07">from</span> serial <span style="color:#719e07">import</span> <span style="color:#719e07">*</span>
</span></span><span style="display:flex;"><span><span style="color:#719e07">import</span> raildriver
</span></span><span style="display:flex;"><span><span style="color:#719e07">import</span> os
</span></span><span style="display:flex;"><span><span style="color:#719e07">import</span> configparser
</span></span><span style="display:flex;"><span><span style="color:#719e07">import</span> json
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>rd <span style="color:#719e07">=</span> raildriver<span style="color:#719e07">.</span>RailDriver()
</span></span><span style="display:flex;"><span>rd<span style="color:#719e07">.</span>set_rail_driver_connected(<span style="color:#cb4b16">True</span>)  <span style="color:#586e75"># start data exchange</span>
</span></span><span style="display:flex;"><span>loco_name <span style="color:#719e07">=</span> rd<span style="color:#719e07">.</span>get_loco_name()      <span style="color:#586e75"># checks if it actually works</span>
</span></span><span style="display:flex;"><span><span style="color:#b58900">print</span>(loco_name)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>config <span style="color:#719e07">=</span> configparser<span style="color:#719e07">.</span>ConfigParser()
</span></span><span style="display:flex;"><span>config<span style="color:#719e07">.</span>read(<span style="color:#2aa198">&#39;config.ini&#39;</span>)
</span></span><span style="display:flex;"><span><span style="color:#719e07">try</span>:
</span></span><span style="display:flex;"><span>    keys <span style="color:#719e07">=</span> config[loco_name[<span style="color:#2aa198">1</span>]]
</span></span><span style="display:flex;"><span><span style="color:#719e07">except</span> <span style="color:#cb4b16">TypeError</span> <span style="color:#719e07">as</span> e:
</span></span><span style="display:flex;"><span>    <span style="color:#b58900">print</span>(e)
</span></span><span style="display:flex;"><span>    <span style="color:#b58900">print</span>(<span style="color:#2aa198">&#34;Is train Simulator running correctly?&#34;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#b58900">input</span>(<span style="color:#2aa198">&#39;Press Enter to exit&#39;</span>)
</span></span><span style="display:flex;"><span>    os<span style="color:#719e07">.</span>_exit(<span style="color:#2aa198">1</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>port_serie <span style="color:#719e07">=</span> Serial(port<span style="color:#719e07">=</span>COM46, baudrate<span style="color:#719e07">=</span><span style="color:#2aa198">115200</span>, timeout<span style="color:#719e07">=</span><span style="color:#2aa198">1</span>, writeTimeout<span style="color:#719e07">=</span><span style="color:#2aa198">1</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#719e07">if</span> port_serie<span style="color:#719e07">.</span>isOpen():
</span></span><span style="display:flex;"><span>    <span style="color:#719e07">while</span> <span style="color:#cb4b16">True</span>:
</span></span><span style="display:flex;"><span>        ligne <span style="color:#719e07">=</span> port_serie<span style="color:#719e07">.</span>readline()<span style="color:#719e07">.</span>rstrip()
</span></span><span style="display:flex;"><span>        rd<span style="color:#719e07">.</span>set_controller_value(keys[<span style="color:#2aa198">&#34;VACMA&#34;</span>], <span style="color:#b58900">float</span>(ligne<span style="color:#719e07">.</span>decode(<span style="color:#2aa198">&#34;utf-8&#34;</span>)))</span></span></code></pre></div>
Le nom des contrôles dépend du matériel utilisé. J&rsquo;utilise donc un fichier .ini, qui contient un <em>mappage</em> entre les termes génériques (ici VACMA) et le terme spécifique au matériel (La VACMA sur AGC, c&rsquo;est <code>CommandeVacma</code> mais sur matériel <em>SimExpress</em> c&rsquo;est <code>vacma_control</code>).</p>
<p>Et avec un peu de chance ça marche. Bon, il faut parfois relancer quelques fois le jeu ou le script, mais à part ça, ça marche !</p>
<h2 id="la-suite">La suite</h2>
<p>Le plus évident pour contrôler un train est le, en language SNCF, ✨ MPT ✨: le ManiPulateur de Traction (en terme TS, <em>Regulator</em>).</p>
<p>Si on ne peut pas avancer, on ne peut pas faire grand chose !</p>
<p><img src="/blog/img/kvb/slide_pot.png" alt="Potentiomètre de côté"></p>
<p>Côté Arduino:
J&rsquo;envoie une virgule entre chaque valeur, <em>CSV-style</em>, et après je découpe côté PC.
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-C" data-lang="C"><span style="display:flex;"><span><span style="color:#719e07">#include</span> <span style="color:#719e07">&lt;Arduino.h&gt;</span><span style="color:#719e07">
</span></span></span><span style="display:flex;"><span><span style="color:#719e07"></span>
</span></span><span style="display:flex;"><span><span style="color:#dc322f">void</span> <span style="color:#268bd2">setup</span>()
</span></span><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">pinMode</span>(VA, INPUT_PULLUP); <span style="color:#586e75">// remplacez VA par votre pin
</span></span></span><span style="display:flex;"><span><span style="color:#586e75"></span>
</span></span><span style="display:flex;"><span>  Serial.<span style="color:#268bd2">begin</span>(<span style="color:#2aa198">115200</span>); <span style="color:#586e75">// on initialise la connexion série
</span></span></span><span style="display:flex;"><span><span style="color:#586e75"></span>
</span></span><span style="display:flex;"><span>  <span style="color:#719e07">while</span> (Serial.<span style="color:#268bd2">available</span>())
</span></span><span style="display:flex;"><span>  {
</span></span><span style="display:flex;"><span>    Serial.<span style="color:#268bd2">println</span>(<span style="color:#2aa198">&#34;Arduino démarré&#34;</span>);
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#dc322f">void</span> <span style="color:#268bd2">separate</span>()
</span></span><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  Serial.<span style="color:#268bd2">print</span>(<span style="color:#2aa198">&#34;,&#34;</span>);
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#dc322f">void</span> <span style="color:#268bd2">loop</span>()
</span></span><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>    Serial.<span style="color:#268bd2">print</span>(<span style="color:#268bd2">readButton</span>(PB14)); <span style="color:#268bd2">separate</span>();
</span></span><span style="display:flex;"><span>    Serial.<span style="color:#268bd2">println</span>(<span style="color:#dc322f">float</span>(<span style="color:#268bd2">analogRead</span>(PA7)) <span style="color:#719e07">/</span> <span style="color:#2aa198">1023</span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">delay</span>(<span style="color:#2aa198">300</span>); <span style="color:#586e75">// temporaire, pas très propre, mais bon
</span></span></span><span style="display:flex;"><span><span style="color:#586e75"></span>}</span></span></code></pre></div>
Ensuite, côté PC, c&rsquo;est pareil:
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#719e07">if</span> port_serie<span style="color:#719e07">.</span>isOpen():
</span></span><span style="display:flex;"><span>    <span style="color:#719e07">while</span> <span style="color:#cb4b16">True</span>:
</span></span><span style="display:flex;"><span>        ligne <span style="color:#719e07">=</span> port_serie<span style="color:#719e07">.</span>readline()<span style="color:#719e07">.</span>rstrip()
</span></span><span style="display:flex;"><span>        args <span style="color:#719e07">=</span> ligne<span style="color:#719e07">.</span>split(<span style="color:#2aa198">&#34;,&#34;</span>)
</span></span><span style="display:flex;"><span>        rd<span style="color:#719e07">.</span>set_controller_value(keys[<span style="color:#2aa198">&#34;VACMA&#34;</span>], <span style="color:#b58900">float</span>(args[<span style="color:#2aa198">0</span>]<span style="color:#719e07">.</span>decode(<span style="color:#2aa198">&#34;utf-8&#34;</span>)))
</span></span><span style="display:flex;"><span>        rd<span style="color:#719e07">.</span>set_controller_value(keys[<span style="color:#2aa198">&#34;Regulator&#34;</span>], <span style="color:#b58900">float</span>(args[<span style="color:#2aa198">1</span>]))</span></span></code></pre></div></p>
<p>Et normalement, ça devrait marcher. Cependant, j&rsquo;écris ce code presque deux ans après l&rsquo;avoir réellement expérimenté donc ça peut ne pas être parfait.</p>
<h2 id="final">Final</h2>
<p><img src="/blog/img/kvb/plaque.jpg" alt="Plaque de test &ldquo;terminée&rdquo;">
Après m&rsquo;être ratée à gauche sur la découpe, j&rsquo;ai rentré, plus proprement à droite. De gauche à droite:</p>
<ul>
<li>Interrupteur 3 position - inverseur: avancer, neutre, reculer</li>
<li>Bouton vert - Grand Débit: permet de retirer rapidement les freins</li>
<li>Bouton rouge réarmable - Arrêt d&rsquo;urgence</li>
<li>Interrupteur avec protection rouge - Aucun usage, juste pour tester</li>
<li>Potentiomètre vertical qui sert pour le manipulateur de traction</li>
</ul>
<p>C&rsquo;était sympa, mais niveau immersion, on a vu mieux. Notamment car, dans la liste des éléments vraiment obligatoires, il manque&hellip; de quoi freiner !</p>
<p>Donc j&rsquo;ai décidé de m&rsquo;attaquer à un composant de tous les pupitres modernes: le <a href="https://fr.wikipedia.org/wiki/Contr%C3%B4le_de_vitesse_par_balises" title="Contrôle de Vitesse par Balises">KVB</a>. Mais ça, c&rsquo;est pour le prochain article.</p>
</content:encoded>

    </item>
    
  </channel>
</rss>
