LOCODUINO - Réalisation d’un affichage de gare ARRIVEE DEPART

Réalisation d’un affichage de gare ARRIVEE DEPART

Le 22 février 2017.
Par : Gilbert

DIFFICULTÉ :★☆☆

Cet article est un tutoriel qui a pour but de vous expliquer, en vous guidant pas à pas, comment réaliser un afficheur fonctionnel "arrivée et départ" pour l’intégrer dans vos gares comme celui de la gare d’Aurillac. Le coût sera d’environ 40 à 80 Euros maximum. Que ceux qui connaissent déjà l’Arduino ne s’offusquent pas car je vais aller dans le détail mais en ne développant que ce qui est utile pour cet exercice ; ce n’est pas un cours sur l’Arduino et encore moins un cours de programmation, le but est de vous permettre de faire la même chose que moi. Il vous sera très facile de modifier le programme Aurillac pour afficher ce que vous voudrez (gare, horaire, voies).

Préambule

La vidéo ci-dessous vous présente ce que vous allez obtenir.

Affichage Aurillac
par Gilbert DANGUIRAL

https://www.youtube.com/watch?featu...

Je vous conseille de lire entièrement le tuto avant de vous décider à acheter le matériel de façon à être certain que vous avez tout assimilé et que vous vous sentez capable de le faire. Cela n’est pas compliqué si vous suivez bien les explications, mais ce serait dommage d’avoir tout acheté pour ne pas y arriver.
C’est pour cette raison que nous allons charger et configurer les logiciels en premier car si vous n’arrivez pas à franchir cette étape, il ne sert à rien d’acheter le matériel.

Chargement de l’application Arduino

Si vous n’avez pas encore installé l’application Arduino, aussi appelée IDE, alors suivez cet article Installation de l’IDE Arduino pour connaître la marche à suivre.

Chargement de logiciels et d’applications dont nous aurons besoin

Nous vous avons préparé un fichier compressé ZIP qui contient 3 dossiers :

Le programme "Affichage_Gare_Aurillac" qui utilise les 2 bibliothèques suivantes :
La bibliothèque "Adafruit_GFX" qui est la bibliothèque d’origine d’Adafruit [1]
La bibliothèque "SSD1306" qui est la bibliothèque modifiée à partir de celle d’Adafruit, "Adafruit_SSD1306" [2]

Voici le lien pour télécharger ce dossier :

Affichage de gare ARRIVÉE DÉPART

Une fois téléchargé, nous allons le décompresser pour récupérer les trois dossiers qui sont à l’intérieur.

Copiez-collez le dossier Affichage_Gare_Aurillac dans le dossier "Carnet de croquis" ou "Sketchbook", là ou vous stockez vos programmes Arduino habituellement.
Les deux autres dossiers sont des bibliothèques dont le programme a besoin, nous devons les installer en suivant les explications du paragraphe suivant.

Chargement des deux nouvelles bibliothèques pour notre programme Arduino

Installer une bibliothèque à partir d’un fichier est très simple. Si vous ne l’avez jamais fait, consultez l’article Installer une bibliothèque qui explique comment faire.
Vous devez donc installer les deux bibliothèques suivantes :

La bibliothèque "Adafruit_GFX" qui est la bibliothèque d’origine d’Adafruit
La bibliothèque "SSD1306" qui est une version modifiée [3], ce qui n’empêche pas d’utiliser la bibliothèque d’origine dans un autre programme.

Vérification que nous avons toutes les fonctions pour gérer nos afficheurs

Nous allons vérifier que le programme de démonstration des afficheurs qui est livré avec la bibliothèque SSD1306 peut fonctionner dans votre environnement et qu’il n’affiche pas d’erreurs. Pour cela nous allons le charger dans l’IDE Arduino, puis le vérifier en lançant une compilation (la compilation c’est la transformation de ce qui est lisible sous forme de texte en instructions codées en binaire pour le microprocesseur).

Nous allons donc charger le programme de démonstration de nos afficheurs : pour cela, nous allons cliquer sur le menu Fichier puis Exemples puis SSD1306 puis sur SSD1306_128X64_i2c (nos afficheurs doivent fonctionner avec une matrice 128 par 64 et avec le bus série I2C)


Figure 1: Exemple de démonstration du SSD1306

Sur l’écran suivant, nous vérifions que nous avons chargé le bon programme en lisant son nom en haut de la fenêtre, puis nous allons le vérifier en le compilant. Pour cela cliquez dans la case à cocher √ et vous devez voir le texte Vérifier apparaître lorsque la souris se trouve au dessus de cette case.


Figure 2: Compilation du programme SSD1306_128x64_i2c

Une barre en bas de la fenêtre va afficher le déroulement de la compilation et des messages s’affichent dans le cadre juste au-dessus, indiquant que la compilation est terminée.


Figure 3: Résultat de la compilation

Si vous avez un autre message d’erreur, c’est certainement que le chargement des bibliothèques c’est mal déroulé, il faudra refaire cette étape.

Maintenant nous allons faire la même opération avec notre programme "Affichage_gare_Aurillac".
Nous choisissons le programme ’’Affichage_gare_Aurillac" dans le menu Fichier, sous-menu Carnet de croquis.


Figure 4: Programme Affichage_Gare_Aurillac

Nous vérifions à nouveau que nous avons chargé le bon programme en lisant son nom en haut puis nous allons le vérifier en le compilant, comme précédemment, en cliquant sur la case √.
La compilation doit aussi se passer sans problème toujours avec un avertissement sur la taille mémoire occupée, ce n’est pas un problème si le programme est utilisé tel quel.


Figure 5: Résultat de la compilation

Une remarque : vous pouvez voir que nous sommes aux limites de la mémoire de l’Arduino Uno, cependant ça fonctionne quand même à condition de ne rien changer au programme et de respecter le formatage des écrans.

En particulier il est déconseillé de développer des annexes autour des écrans comme des animations ou une gestion de boutons extérieurs pour changer l’affichage, qui pourrait conduire à créer des variables locales ou de nouvelles fonctions qui, elles, seraient problématiques pour la mémoire vive...

Si tout s’est bien passé, vous saurez facilement gérer les afficheurs de votre gare ; dans ce cas, vous pouvez acheter le matériel et continuer ce tuto.

Liste du matériel

Au cas où vous n’auriez pas déjà vos propres sources d’approvisionnement, je vous conseille de lire l’article Où acheter ? donnant quelques sites de vente par correspondance. A votre comparaison des prix, pensez à ajouter les frais d’expédition ! Essayez au maximum d’avoir du matériel identique au mien, le montage n’en sera que plus facile ; pour cette raison, j’indique aussi quelques liens. Il arrive parfois que le matériel reçu ne soit pas tout à fait identique à celui commandé parce qu’il a pu évoluer, parce que le fournisseur n’en avait plus mais vous a fourni un modèle équivalent, etc. Ne vous inquiétez pas, grâce à l’aide de la communauté Arduino et de notre forum, vous trouverez toujours la solution à vos problèmes. Je mets aussi les références des produits tels que je les ai achetés : les taper dans un moteur de recherche pourra vous aider à trouver.

• 1 ARDUINO UNO rev 3 avec cordon USB référence : NEW ATmega328P CH340G UNO R3 Conseil & Câble USB pour Arduino (référence : 961777)

http://www.dx.com/fr/p/dccduino-atm...

http://www.cdiscount.com/search/10/...

• 2 modules afficheur OLED I2C blanc 128X64 référence : Blanc OLED 0.96" SPI I2C IIC série 128*64 Display affichage Module pour écran Arduino (référence : 958196)

http://www.dx.com/fr/p/0-96-128x64-...

http://www.cdiscount.com/maison/bri...

Pour les afficheurs il y en a sur Ebay, Amazon ou Cdiscount : ils ne doivent avoir que 4 contacts et non pas 6 ou 8 et doivent bien autoriser deux adresses possibles avec une résistance ou un strap à déplacer

• Barrettes femelles droites pas de 2.54 BL LP1/36/S référence : 409062-62
• Barrettes mâles droites pas de 2.54 SL 1/025/36/S référence : 737711-62
• Fil souple 0.5 mm² noir référence : 1180250-62
• Fil souple 0.5 mm² rouge référence : 1180251-62
• Fil souple 0.5 mm² bleu référence : 1180260-62
• Fil souple 0.5 mm² vert référence : 1180252-62
• Gaine thermorétractable diam 1.6 mm référence : 531243-62
• Vis M2 longueur 10 mm référence : 839660-62
• Écrous hexagonaux M2 référence : 216363-62
• Rondelles diam intérieur 2.2 mm référence : 105343-62
• Chargeur USB 1A pour prise murale référence : 393439-62
Les références sont celles de Conrad

• Tube EVERGREEN diam ext 4 diam int 2.25 référence : 269-PS-225
Chez MICRO MODELE par exemple

Une photo du gros matériel :


Figure 6: Le matériel

Câblage et mécanique

Nous allons déjà nous débarrasser du câblage.
Première opération souder sur la carte Arduino un morceau de barrette mâle de 4 contacts comme indiqué sur la photo.
Appliquez-vous pour les soudures et vérifier qu’elles sont bien faites (pas de pont de soudure ou de soudure manquante).


Figure 7: Soudure sur carte UNO

Si votre module Uno est un module d’origine (Arduino ou Genuino), il se présente différemment et vous ne pourrez pas souder la barrette de 4 plots, mais vous pourrez néanmoins récupérer sur les connecteurs les signaux SCL sur la Pin A5, SDA sur la Pin A4, 5V et GND.


Figure 8: Emplacement des signaux sur Arduino/Genuino UNO

Nous avons deux afficheurs, or ils doivent avoir des adresses différentes pour que l’affichage soit différent sur les deux écrans.
Pour cela sur une des deux cartes, nous allons déplacer la minuscule résistance de coté comme indiqué sur la photo. Attention c’est délicat, il faut prendre la résistance avec une pince brucelles et avec la pointe du fer chauffer alternativement les deux côtés pour qu’elle se dessoude. Ensuite la souder à l’autre emplacement.
Il faut avoir une panne de fer pas trop grosse et vérifier vos soudures, si possible à la loupe.


Figure 9: Changement des adresses I2C

Sur mes afficheurs malgré ce qui était écrit au dos du circuit imprimé les adresses sont en réalité 3C et 3D.

Nous allons maintenant nous occuper de réaliser le câble de liaison en vous aidant des couleurs et en respectant bien l’ordre des fils (attention entre le clone Arduino et les écrans il y une inversion de position des fils SCL et SDA).
Utiliser des morceaux de barrette femelle de 4 plots, il faut pour être calme, puis isoler les soudures avec de la gaine thermorétractable.

Voici le plan de câblage :


Figure 10: Le câblage des écrans

Le câble fini (la distance Arduino/écrans peut être grande 50 cm alors que la distance entre écrans est normalement courte car les écrans arrivée et départ sont côte à côte.


Figure 11: Le connecteur pour les écrans

Nous avons fini le câblage, il faut de suite faire la mécanique car il ne faut pas, lors de vos essais et manipulations, que l’arrière de l’Arduino ou des écrans se retrouvent posés sur du métal qui traînerait sur votre bureau. Quand on bidouille c’est souvent le bazar sur l’établi et le court-circuit fatal est vite arrivé.
Sur deux plaques en matière isolante (par exemple du FOREX ou du plastique épaisseur 2) fixer la carte Arduino par trois vis à l’aide des vis écrous rondelles de 2 mm et en faisant des entretoises de hauteur 4 mm avec le tube EVERGREEN.
Faire de même pour les deux écrans, vous pouvez les positionner de manière à ce qu’ils soient assez proches.
Penser à faire deux trous de 3 mm dans chaque plaque pour la fixation future.
Voilà le résultat que vous devez obtenir :


Figure 12: Raccordement des écrans à la carte UNO

Le test des afficheurs

Nous raccordons notre Arduino à notre PC, par le câble USB.

Dans le menu Outils, choisir Arduino Uno dans le sous-menu Type de carte.


Figure 13: Menu Outils > Type de carte

Puis, dans le sous-menu Port, choisir le port COM correspondant à votre carte UNO (en principe les mots "Arduino UNO" s’affichent).

Nous allons recharger notre programme de démonstration des afficheurs que nous avons déjà utilisé pour la vérification de nos chargements dans l’Arduino.
Pour rappel nous devons cliquer sur Fichier puis sur Exemples puis sur SSD 1306 puis sur SSD1306_128X64_i2c (nos afficheurs doivent fonctionner avec une matrice 128 par 64 et avec le bus série I2C).

Nous allons le compiler puis le téléverser.
A la fin du téléversement nous aurons un des deux écrans (normal dans le programme de démonstration il n’y a qu’un écran qui est adressé dans ce programme) qui va s’animer en faisant le programme de démonstration se terminant par des étoiles.
Si vous voulez animer l’autre écran il faut modifier l’adresse à cet endroit-là d’ailleurs nous pouvons voir que nous adressions l’afficheur ayant comme adresse 3D.


Figure 14: Modification des adresses dans le programme

Nous changeons l’adresse en 3C. Au passage pour qu’il soit en conformité nous modifions aussi le commentaire qui comme expliqué précédemment est précédé de //


Figure 15: La ligne à modifier

Puis nous allons compiler à nouveau et téléverser le programme modifié, c’est notre autre afficheur qui s’anime à son tour.

Si rien ne s’affiche, en particulier si l’adresse I2C de vos afficheurs ne correspondent pas à 3C et 3D et que vous ne trouvez pas l’adresse dans la documentation (souvent il n’y a pas de documentation du tout), alors allez sur l’article Bibliothèque Wire : I2C et lisez le paragraphe "Rechercher l’adresse I2C d’un périphérique". Quand vous aurez déterminé les adresses, alors appliquez ce qui est ci-dessus avec ces adresses.

Nous pouvons nous intéresser désormais au programme des afficheurs Aurillac.

Le principe et la spécification de l’affichage d’Aurillac

Pour l’affichage de la gare d’Aurillac j’ai cherché à simuler le défilement d’affichage lors de la mise à jour des écrans en affichant les lignes les unes après les autres.
Autre règle, lors de la mise à jour d’écran, je rappelle les 3 derniers horaires de l’écran précédent.
L’écran se compose de 8 lignes de 21 caractères, un espace est un caractère.

J’ai donc créé un tableau Excel qui définit les différents écrans pour les départs et les arrivées, il tient compte des espaces.
Ce qui fait 6 écrans pour les départs et 6 écrans pour les arrivées. Il faudra que vous fassiez le vôtre en fonction de votre gare et votre région.

Voici le tableau des départs et les différents écrans sans compter les écrans de défilement :


Figure 16: Affichage des départs

Voici le tableau des arrivées et les différents écrans :


Figure 17: Affichages des arrivées

Programme Aurillac

Voici le programme qui tourne sur Aurillac

/*********************************************************************
Programme de gestion d'un ecran monochrome OLEDs sur une base SSD1306 drivers
pour l'affichage de la gare d'Aurillac.

Ce programme utilise une version personnalisee de la bibliotheque adafruit_SSD1306, adaptee pour des ecrans 128x64
Cette bibliothque est renommee SSD1306
La modification est la suivante :
1) Changement du nom de la bibliotheque pour utilisation sans modification par le sketch "Affichage_Gare_Aurillac"
2) #define SSD1306_128_64

*********************************************************************/
// Ce qui suit sert a initialiser le compilateur et qui defini les applications a utiliser
#include <avr/pgmspace.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <SSD1306.h>
#define OLED_RESET 4


// creation de deux afficheurs
SSD1306 display1(OLED_RESET);
SSD1306 display2(OLED_RESET);


// verification que nous sommes bien configure en 128X64
#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif


// generation des tables de variables (c'est ici que vous devrez modifier vos ecrans
// tables des departs
const char depart_0[]PROGMEM= "HEURE    DEPART     V---------------------O5h15 BRIVE         3";  
const char depart_1[]PROGMEM= "HEURE    DEPART     V---------------------O5h15 BRIVE         305h54 CLERMONT FR   2";  
const char depart_2[]PROGMEM= "HEURE    DEPART     V---------------------O5h15 BRIVE         3O5h54 CLERMONT FR   2O6h45 TOULOUSE      1";  
const char depart_3[]PROGMEM= "HEURE    DEPART     V---------------------O5h15 BRIVE         3O5h54 CLERMONT FR   2O6h45 TOULOUSE      1O7h55 CLERMONT FR   2"; 
const char depart_4[]PROGMEM= "HEURE    DEPART     V---------------------O5h15 BRIVE         3O5h54 CLERMONT FR   2O6h45 TOULOUSE      1O7h55 CLERMONT FR   2O8h46 TOULOUSE      1";  
const char depart_5[]PROGMEM= "HEURE    DEPART     V---------------------O5h15 BRIVE         3O5h54 CLERMONT FR   2O6h45 TOULOUSE      1O7h55 CLERMONT FR   2O8h46 TOULOUSE      1O9h13 NEUSSARGUES   3";


const char depart_6[]PROGMEM= "HEURE    DEPART     V---------------------O7h55 CLERMONT FR   2";  
const char depart_7[]PROGMEM= "HEURE    DEPART     V---------------------O7h55 CLERMONT FR   2O8h46 TOULOUSE      1";
const char depart_8[]PROGMEM= "HEURE    DEPART     V---------------------O7h55 CLERMONT FR   2O8h46 TOULOUSE      1O9h13 NEUSSARGUES   3";
const char depart_9[]PROGMEM= "HEURE    DEPART     V---------------------O7h55 CLERMONT FR   2O8h46 TOULOUSE      1O9h13 NEUSSARGUES   31Oh27 CLERMONT FR   2";
const char depart_10[]PROGMEM= "HEURE    DEPART     V---------------------O7h55 CLERMONT FR   2O8h46 TOULOUSE      1O9h13 NEUSSARGUES   31Oh27 CLERMONT FR   21Oh49 BRIVE         3";
const char depart_11[]PROGMEM= "HEURE    DEPART     V---------------------O7h55 CLERMONT FR   2O8h46 TOULOUSE      1O9h13 NEUSSARGUES   31Oh27 CLERMONT FR   21Oh49 BRIVE         311h22 PARIS AUSTER  5";


const char depart_12[]PROGMEM= "HEURE    DEPART     V---------------------1Oh27 CLERMONT FR   2";
const char depart_13[]PROGMEM= "HEURE    DEPART     V---------------------1Oh27 CLERMONT FR   21Oh49 BRIVE         3";
const char depart_14[]PROGMEM= "HEURE    DEPART     V---------------------1Oh27 CLERMONT FR   21Oh49 BRIVE         311h22 PARIS AUSTER  5";
const char depart_15[]PROGMEM= "HEURE    DEPART     V---------------------1Oh27 CLERMONT FR   21Oh49 BRIVE         311h22 PARIS AUSTER  512h55 TOULOUSE      1";
const char depart_16[]PROGMEM= "HEURE    DEPART     V---------------------1Oh27 CLERMONT FR   21Oh49 BRIVE         311h22 PARIS AUSTER  512h55 TOULOUSE      113h28 NEUSSARGUES   3";
const char depart_17[]PROGMEM= "HEURE    DEPART     V---------------------1Oh27 CLERMONT FR   21Oh49 BRIVE         311h22 PARIS AUSTER  512h55 TOULOUSE      113h28 NEUSSARGUES   316h39 CLERMONT FR   2";


const char depart_18[]PROGMEM= "HEURE    DEPART     V---------------------12h55 TOULOUSE      1";
const char depart_19[]PROGMEM= "HEURE    DEPART     V---------------------12h55 TOULOUSE      113h28 NEUSSARGUES   3";
const char depart_20[]PROGMEM= "HEURE    DEPART     V---------------------12h55 TOULOUSE      113h28 NEUSSARGUES   316h39 CLERMONT FR   2";
const char depart_21[]PROGMEM= "HEURE    DEPART     V---------------------12h55 TOULOUSE      113h28 NEUSSARGUES   316h39 CLERMONT FR   216h53 TOULOUSE      1";
const char depart_22[]PROGMEM= "HEURE    DEPART     V---------------------12h55 TOULOUSE      113h28 NEUSSARGUES   316h39 CLERMONT FR   216h53 TOULOUSE      117h1O BRIVE         3";
const char depart_23[]PROGMEM= "HEURE    DEPART     V---------------------12h55 TOULOUSE      113h28 NEUSSARGUES   316h39 CLERMONT FR   216h53 TOULOUSE      117h1O BRIVE         317h44 CLERMONT FR   2";


const char depart_24[]PROGMEM= "HEURE    DEPART     V---------------------16h53 TOULOUSE      1";
const char depart_25[]PROGMEM= "HEURE    DEPART     V---------------------16h53 TOULOUSE      117h1O BRIVE         3";
const char depart_26[]PROGMEM= "HEURE    DEPART     V---------------------16h53 TOULOUSE      117h1O BRIVE         317h44 CLERMONT FR   2";
const char depart_27[]PROGMEM= "HEURE    DEPART     V---------------------16h53 TOULOUSE      117h1O BRIVE         317h44 CLERMONT FR   218h32 FIGEAC        3";
const char depart_28[]PROGMEM= "HEURE    DEPART     V---------------------16h53 TOULOUSE      117h1O BRIVE         317h44 CLERMONT FR   218h32 FIGEAC        319h18 NEUSSARGUES   2";
const char depart_29[]PROGMEM= "HEURE    DEPART     V---------------------16h53 TOULOUSE      117h1O BRIVE         317h44 CLERMONT FR   218h32 FIGEAC        319h18 NEUSSARGUES   221h17 FIGEAC        3";


const char depart_30[]PROGMEM= "HEURE    DEPART     V---------------------18h32 FIGEAC        3";
const char depart_31[]PROGMEM= "HEURE    DEPART     V---------------------18h32 FIGEAC        319h18 NEUSSARGUES   2";
const char depart_32[]PROGMEM= "HEURE    DEPART     V---------------------18h32 FIGEAC        319h18 NEUSSARGUES   221h17 FIGEAC        3";
const char depart_33[]PROGMEM= "HEURE    DEPART     V---------------------18h32 FIGEAC        319h18 NEUSSARGUES   221h17 FIGEAC        321h46 BRIVE         1";


// Initialisation de la table (attention il doit y avoir le meme nombre de depart que dans les lignes au-dessus en faisant bien attention a la syntaxe)
const char*const depart_table[]PROGMEM={depart_0,depart_1,depart_2,depart_3,depart_4,depart_5,depart_6,depart_7,depart_8,depart_9,depart_10,depart_11,depart_12\
,depart_13,depart_14,depart_15,depart_16,depart_17,depart_18,depart_19,depart_20,depart_21,depart_22,depart_23,depart_24,depart_25,depart_26,depart_27,depart_28\
,depart_29,depart_30,depart_31,depart_32,depart_33};


// table des arrivees
const char arrivee_0[]PROGMEM= "HEURE    ARRIVEE    V---------------------O5h45 TOULOUSE      2"; 
const char arrivee_1[]PROGMEM= "HEURE    ARRIVEE    V---------------------O5h45 TOULOUSE      2O6h15 PARIS AUSTER  5"; 
const char arrivee_2[]PROGMEM= "HEURE    ARRIVEE    V---------------------O5h45 TOULOUSE      2O6h15 PARIS AUSTER  5O6h45 BRIVE         3";
const char arrivee_3[]PROGMEM= "HEURE    ARRIVEE    V---------------------O5h45 TOULOUSE      2O6h15 PARIS AUSTER  5O6h45 BRIVE         3O7h26 CAPDENAC      2";
const char arrivee_4[]PROGMEM= "HEURE    ARRIVEE    V---------------------O5h45 TOULOUSE      2O6h15 PARIS AUSTER  5O6h45 BRIVE         3O7h26 CAPDENAC      2O8h23 CLERMONT FR   1";  
const char arrivee_5[]PROGMEM= "HEURE    ARRIVEE    V---------------------O5h45 TOULOUSE      2O6h15 PARIS AUSTER  5O6h45 BRIVE         3O7h26 CAPDENAC      2O8h23 CLERMONT FR   1O9h47 FIGEAC        3";


const char arrivee_6[]PROGMEM= "HEURE    ARRIVEE    V---------------------O7h26 CAPDENAC      2";
const char arrivee_7[]PROGMEM= "HEURE    ARRIVEE    V---------------------O7h26 CAPDENAC      2O8h23 CLERMONT FR   1";
const char arrivee_8[]PROGMEM= "HEURE    ARRIVEE    V---------------------O7h26 CAPDENAC      2O8h23 CLERMONT FR   1O9h47 FIGEAC        3";
const char arrivee_9[]PROGMEM= "HEURE    ARRIVEE    V---------------------O7h26 CAPDENAC      2O8h23 CLERMONT FR   1O9h47 FIGEAC        31Oh32 NEUSSARGUES   2";
const char arrivee_10[]PROGMEM= "HEURE    ARRIVEE    V---------------------O7h26 CAPDENAC      2O8h23 CLERMONT FR   1O9h47 FIGEAC        31Oh32 NEUSSARGUES   21Oh45 BRIVE         3";
const char arrivee_11[]PROGMEM= "HEURE    ARRIVEE    V---------------------O7h26 CAPDENAC      2O8h23 CLERMONT FR   1O9h47 FIGEAC        31Oh32 NEUSSARGUES   21Oh45 BRIVE         311h55 CLERMONT FER  1";


const char arrivee_12[]PROGMEM= "HEURE    ARRIVEE    V---------------------1Oh32 NEUSSARGUES   2";
const char arrivee_13[]PROGMEM= "HEURE    ARRIVEE    V---------------------1Oh32 NEUSSARGUES   21Oh45 BRIVE         3";
const char arrivee_14[]PROGMEM= "HEURE    ARRIVEE    V---------------------1Oh32 NEUSSARGUES   21Oh45 BRIVE         311h55 CLERMONT FER  1";
const char arrivee_15[]PROGMEM= "HEURE    ARRIVEE    V---------------------1Oh32 NEUSSARGUES   21Oh45 BRIVE         311h55 CLERMONT FER  112h29 TOULOUSE      2";
const char arrivee_16[]PROGMEM= "HEURE    ARRIVEE    V---------------------1Oh32 NEUSSARGUES   21Oh45 BRIVE         311h55 CLERMONT FER  112h29 TOULOUSE      214hO6 BRIVE         3";
const char arrivee_17[]PROGMEM= "HEURE    ARRIVEE    V---------------------1Oh32 NEUSSARGUES   21Oh45 BRIVE         311h55 CLERMONT FER  112h29 TOULOUSE      214hO6 BRIVE         315h28 NEUSSARGUES   2";


const char arrivee_18[]PROGMEM= "HEURE    ARRIVEE    V---------------------12h29 TOULOUSE      2";
const char arrivee_19[]PROGMEM= "HEURE    ARRIVEE    V---------------------12h29 TOULOUSE      214hO6 BRIVE         3";
const char arrivee_20[]PROGMEM= "HEURE    ARRIVEE    V---------------------12h29 TOULOUSE      214hO6 BRIVE         315h28 NEUSSARGUES   2";
const char arrivee_21[]PROGMEM= "HEURE    ARRIVEE    V---------------------12h29 TOULOUSE      214hO6 BRIVE         315h28 NEUSSARGUES   215h33 BRIVE         3";
const char arrivee_22[]PROGMEM= "HEURE    ARRIVEE    V---------------------12h29 TOULOUSE      214hO6 BRIVE         315h28 NEUSSARGUES   215h33 BRIVE         316h32 TOULOUSE      2";
const char arrivee_23[]PROGMEM= "HEURE    ARRIVEE    V---------------------12h29 TOULOUSE      214hO6 BRIVE         315h28 NEUSSARGUES   215h33 BRIVE         316h32 TOULOUSE      217hO7 NEUSSARGUES   1";


const char arrivee_24[]PROGMEM= "HEURE    ARRIVEE    V---------------------15h33 BRIVE         3";
const char arrivee_25[]PROGMEM= "HEURE    ARRIVEE    V---------------------15h33 BRIVE         316h32 TOULOUSE      2";
const char arrivee_26[]PROGMEM= "HEURE    ARRIVEE    V---------------------15h33 BRIVE         316h32 TOULOUSE      217hO7 NEUSSARGUES   1";
const char arrivee_27[]PROGMEM= "HEURE    ARRIVEE    V---------------------15h33 BRIVE         316h32 TOULOUSE      217hO7 NEUSSARGUES   118h32 FIGEAC        3";
const char arrivee_28[]PROGMEM= "HEURE    ARRIVEE    V---------------------15h33 BRIVE         316h32 TOULOUSE      217hO7 NEUSSARGUES   118h32 FIGEAC        319hO8 CLERMONT FER  2";
const char arrivee_29[]PROGMEM= "HEURE    ARRIVEE    V---------------------15h33 BRIVE         316h32 TOULOUSE      217hO7 NEUSSARGUES   118h32 FIGEAC        319hO8 CLERMONT FER  22OhO1 BRIVE         3";


const char arrivee_30[]PROGMEM= "HEURE    ARRIVEE    V---------------------19hO8 CLERMONT FER  2";
const char arrivee_31[]PROGMEM= "HEURE    ARRIVEE    V---------------------19hO8 CLERMONT FER  22OhO1 BRIVE         3";
const char arrivee_32[]PROGMEM= "HEURE    ARRIVEE    V---------------------19hO8 CLERMONT FER  22OhO1 BRIVE         321h17 FIGEAC        3";
const char arrivee_33[]PROGMEM= "HEURE    ARRIVEE    V---------------------19hO8 CLERMONT FER  22OhO1 BRIVE         321h17 FIGEAC        321h4O TOULOUSE      1";


// Initialisation de la table (attention il doit y avoir le meme nombre d'arrivees que dans les lignes au-dessus en faisant bien attention a la syntaxe)
const char*const arrivee_table[]PROGMEM={arrivee_0,arrivee_1,arrivee_2,arrivee_3,arrivee_4,arrivee_5,arrivee_6,arrivee_7,arrivee_8,arrivee_9,arrivee_10,arrivee_11,arrivee_12\
,arrivee_13,arrivee_14,arrivee_15,arrivee_16,arrivee_17,arrivee_18,arrivee_19,arrivee_20,arrivee_21,arrivee_22,arrivee_23,arrivee_24,arrivee_25,arrivee_26,arrivee_27,arrivee_28\
,arrivee_29,arrivee_30,arrivee_31,arrivee_32,arrivee_33};


//Definition du buffer
char buffer[170];


//Creation d'un sous-programme d'initialisation des afficheurs
void initaffichage()  
{
  // Initialisation de l'afficheur 1
  // Vider le buffer.
  display1.clearDisplay();
  // choix de la taille
  display1.setTextSize(1);
  // choix de la couleur
  display1.setTextColor(WHITE);
  // initialisation du debut d'affichage
  display1.setCursor(0,0);
  
  // Initialisation de l'afficheur 2
  // Vider le buffer.
  display2.clearDisplay();
  // choix de la taille
  display2.setTextSize(1);
  // choix de la couleur
  display2.setTextColor(WHITE);
  // initialisation du debut d'affichage
  display2.setCursor(0,0);
}
//fin du sous-programme d'initialisation des afficheurs


void setup()   
{                
  // initialisation de la vitesse de la liaison serie
  Serial.begin(9600);
  // par defaut nous allons generer une tension de 3.3v 
  // initialisation de la liaison ID2C avec l'adresse 0x3D
  display1.begin(SSD1306_SWITCHCAPVCC, 0x3D); 
  // initialisation de la liaison ID2C avec l'adresse 0x3C 
  display2.begin(SSD1306_SWITCHCAPVCC, 0x3C); 
  // fin de l'initialisation
   }
   
void loop() 
{
  int tempo; //creation d'une variable tempo
// creation d'une boucle for
  for(int i=0;i<34;i++)
  {
    initaffichage();
    strcpy_P(buffer,(char*)pgm_read_word(&(depart_table[i])));
    display1.println(buffer);
    display1.display();
    if (i==5 ||i==11 ||i==17 ||i==23 ||i==29 ||i==33)
      tempo=4000;
      else tempo=20;
      
    initaffichage();
    strcpy_P(buffer,(char*)pgm_read_word(&(arrivee_table[i])));
    display2.println(buffer);
    display2.display();
    delay(tempo);
  }
}

Explication du programme d’affichage d’Aurillac

Je vais vous expliquer comment adapter l’affichage Aurillac à vos destinations.
Nous avons dans le programme les lignes suivantes, la démarche sera la même pour les arrivées, vous retrouvez les données du tableau Excel fourni précédemment.

Voici le premier écran et la première ligne de cette l’écran.
const char depart_0[]PROGMEM= "HEURE….DEPART…..V---------------------O5h15.BRIVE………3";}

Les espaces du tableau Excel (vous vous rappelez un espace du tableau Excel est équivalent à un caractère) sont ici simulés par des points, vous remarquerez que les afficheur retournent à la ligne tout seul donc nous devons taper les caractères d’affichage à la suite.

Ce qui donne :
HEURE….DEPART…..V première ligne de l’écran (21 caractères avec les espaces)

deuxième ligne de l’écran (21 tirets haut)
O5h15.BRIVE………3 troisième ligne de l’écran (21 caractères avec les espaces)

Ecran suivant je rajoute une ligne :
const char depart_1[]PROGMEM= "HEURE DEPART V---------------------O5h15 BRIVE 305h54 CLERMONT FR 2";

Et ainsi de suite en n’oubliant pas qu’à la fin d’un écran les trois dernières lignes sont répétées une par une en tête de l’écran suivant.
Vous pouvez modifier les données en respectant la syntaxe.

Maintenant il faut faire attention dans mon programme, j’ai 34 écrans différents pour les départs et 34 écrans pour les arrivées.
A la fin de la création des écrans on doit créer la table, donc voici la ligne de programme.

// Initialisation de la table {{(attention il doit y avoir le même nombre de départ que dans les lignes au-dessus en faisant bien attention à la syntaxe)}}

const char*const depart_table[]PROGMEM {depart_0,depart_1,depart_2,depart_3,
depart_4,depart_5,depart_6,depart_7,depart_8,depart_9,depart_10,depart_11,
depart_12 ,depart_13,depart_14,depart_15,depart_16,depart_17,depart_18,
depart_19,depart_20,depart_21,depart_22,depart_23,depart_24,depart_25,
depart_26,depart_27,depart_28,depart_29,depart_30,depart_31,depart_32,
depart_33};

On voit bien qu’il y en a 34 (du n° 0 au n°33, cela fait 34 éléments), mais si vous créez moins d’écrans il faudra mettre en concordance cette table en respectant la syntaxe.
Même chose pour les arrivées.

Maintenant il faut faire attention à d’autres endroits du programme où le nombre d’écrans à une influence. Voici ces endroits :

//création d'une boucle for
  for(int i=0; i<34; i++) 
     {
     ...
     }

Ici nous avons une boucle d’incrémentation qui va de 0 à 33 donc nous devons mettre le chiffre 33+1 c’est à dire 34, car 34 est précédé du symbole inférieur.
On aurait pu mettre aussi <=33 à la place de <34.

    initaffichage();
    strcpy_P(buffer,(char*)pgm_read_word(&(depart_table[i])));
    display1.println(buffer);
    display1.display();
    if (i==5 ||i==11 ||i==17 ||i==23 ||i==29 ||i==33)

Ici nous avons une condition qui correspond à la fin de chaque écran et qui sont des multiples de 6 car nous avons deux lignes identiques et 6 affichages de destination.
Donc 5 (car nous commençons à 0) puis 11 (5+6), puis 17, puis 23, puis 29, puis 33 (qui est notre dernier écran).
Si vous créez moins ou plus d’écrans il faudra mettre en concordance cette table en respectant la syntaxe.

Vous remarquerez que vous avez obligation d’avoir autant d’écrans arrivées que d’écrans départs car cette boucle est commune aux deux afficheurs.

Enfin dernier endroit où vous pouvez modifiez des valeurs : ici, on définit les durées des tempos d’affichage.

      tempo=4000;
      else tempo=20;

La valeur de 4000 correspond au délai d’affichage fixe, là c’est quatre secondes car c’était pour la Vidéo que j’ai réalisée (c’est trop court).

La valeur de 20 c’est le temps entre deux écrans lors du défilement des lignes quand la mise à jour d’écran se fait, cette valeur me semble correcte.

Voilà. Ce sont les seuls endroits que vous pouvez modifier sans trop de risques.

A vous de jouer

Maintenant que votre programme vous satisfait, qu’il tourne et qu’il est chargé dans l’Arduino, vous remplacez au bout du câble USB, le PC par le chargeur USB.
Votre affichage est autonome, il ne reste plus qu’à l’intégrer dans votre gare.

Une discussion est ouverte sur le forum pour permettre les échanges et les partages d’expérience. Nous vous remercions de réserver les commentaires sous cet article à des précisions techniques qui complètent l’article.

[1] qui se trouve à cette adresse https://github.com/adafruit/Adafrui...

[2] qui se trouve à cette adresse https://github.com/adafruit/Adafrui...

[3] Cette modification s’est avérée nécessaire pour sélectionner la taille d’afficheur 128x64, soit 64 lignes de 128 points, qui correspond au modèle d’écran que nous allons utiliser. Ceci afin de ne pas vous imposer de modifier cette bibliothèque par vous-même, ce qui aurait pu être une opération un peu hasardeuse !

45 Messages

Réalisation d’un affichage de gare ARRIVEE DEPART 22 février 2017 19:53, par BobyAndCo

J’adore !

C’est un super exemple de ce que l’on peut faire en modélisme ferroviaire avec des Arduino.

Bravo Gilbert.

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 23 février 2017 10:55, par Jose

Bonjour,
Super, je me suis inscrit hier soir et Christophe m’a passé ce lien, vraiment impeccable pour moi. C’est plus clair que de l’eau de roche, un super boulot, ce sera sûrement présent sur mon réseau à venir.
merci

Répondre
Réalisation (arduino nano) d’un affichage de gare ARRIVEE DEPART 23 février 2017 22:55, par Christophe25

A l’expo de Meursault(21), en Décembre 2016, nous avons découvert la réalisation de Gilbert : :)Impressionnant, SUPER ;), et cet homme n’est pas avare pour communiquer et partager, encore merci à lui !
Pour gagner de la place (et quelques euros), j’ai pris un arduino Nano.
Par contre, suite au copier/coller du programme de Dangui95 et en téléversant, j’avais de nombreuses erreurs à la compilation.
Quelques recherches sur le net et j’ai pu résoudre le problème en supprimant et en retapant tous les espaces (barre d’espacement) et la compilation fut bonne (les mystères de l’informatique !) .
Je joins une vidéo .

Voir en ligne : Afficheur gare départ/arrivée (arduino nano)

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 24 février 2017 09:32, par DDEFF

Voilà un article comme je les aime : complet, détaillé et clair.

Tout d’abord, une excellente analyse du problème à résoudre.

Cette phase, apparemment évidente, ne l’est pas du tout !
Il faut savoir exactement ce que l’on veut et pas une vague idée, vague idée qui se traduit par des "à peu près" plus tard...
Et, si la solution peut paraître "simple", c’est justement parce qu’elle a bien été analysée au départ.

Après, bien programmé, bien indenté et une explication claire de l’interfaçage (câbles et bibliothèques)avec le matériel.

Bravo Gilbert !!

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 24 février 2017 12:38, par Christian

Bonjour à tous,

Gilbert ne va pas tarder à vous répondre puisqu’il vient de me demander comment faire.
Le montage qu’il présente a été réalisé par quelques personnes (d’ailleurs bravo à Christophe25 pour sa petite vidéo), parce que ce montage est à la portée d’un débutant et que le tutoriel est complet et guide pas à pas. C’est la preuve qu’Arduino n’est pas si compliqué qu’il parait et bien souvent, il suffit de s’y mettre pour le découvrir. La même chose pour un kit laiton, non ?
Pour la petite histoire, sachez qu’on a fait souffrir un peu notre ami Gilbert en lui demandant d’intégrer son article dans notre environnement LOCODUINO où certaines parties étaient déjà décrites en détail, et surtout en l’aidant à pouvoir vous fournir des bibliothèques déjà prêtes à l’emploi. Je vous rassure, cela s’est bien passé et il est toujours en pleine forme, prêt à migrer vers d’autres projets. Alors, on ne va pas le lâcher...
Merci à tous pour vos retours encourageants : cela lui fait plaisir, cela nous fait plaisir.
Christian pour l’équipe LOCODUINO.

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 24 février 2017 12:57, par Gilbert
  
  Bonjour à tous,
  Un grand merci à tous pour vos réponses et encouragements.
  Ce fut un grand plaisir d’écrire ce tuto pour le site Locoduino, l’équipe de rédaction par sa compétence m’a beaucoup aidé pour la simplification de l’article.
  
  Je travaille sur un autre projet toujours dans le cadre des annonces en gare.
  
  Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 3 mars 2017 15:44, par michael

Pourquoi ne pas utiliser une chaîne de caractère à laquelle on ajouterai à chaque boucle la nouvelle ligne ? Cela éviterait d’avoir un tableau rempli de plusieurs fois la même chose... Et on gagnerait énormément de mémoire aussi.
A quand la même chose en N !!! (ou sur des afficheurs de quai ?)
En tout cas ça doit être très sympa sur un réseau

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 16 octobre 2022 18:52, par jacky
  
  Bonjour, oui je suis d’accord avec vous, j’ai mis un peu de temps a comprendre la logique d’affichage, en effet elle consomme beaucoup de memoire, le programme passe son temps a effacer son ecran et imprime une ligne de plus a chaque fois. mais ca fonctionne tres bien quand meme. cordialement
  
  Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 1er avril 2017 18:56, par Pierre

Excellente réalisation. je débute sur Arduino. Ce tutoriel est vraiment très bien fait et fonctionne impeccablement. Le plus difficile reste à faire... l’intégrer dans l’univers d’une gare en HO

Merci beaucoup

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 13 septembre 2017 12:17, par Denis
Bonjour
J’ai beaucoup apprécié votre projet, etant moi meme en apprentissage sur l’utilisation d’un ecran oled et d’un arduino uno ainsi que d’un esp8266.

N’ayant qu’un seul afficheur J’ai modifié votre sketch en consequence ; j’ai aussi supprimé les lignes suivantes :
- #include (sans provoquer de probleme, mais ?)
- #include <SPI.h> qui n’est pas utilisé (cablage I²C)
  Enfin j’ai renommé la variable "buffer" en "tampon" pour eviter toute confusion avec une fonction
Si vous le souhaitez je peux vous faire parvenir le sketch modifie
Cordialement Denis
Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 3 novembre 2017 20:31, par remi genois

Arduino:1.8.0 (Windows 10), Scheda :"Arduino/Genuino Uno"

ssd1306_128x64_i2c:54 : error : #error ("Height incorrect, please fix Adafruit_SSD1306.h !") ;

#error("Height incorrect, please fix Adafruit_SSD1306.h !") ;

^

exit status 1
#error ("Height incorrect, please fix Adafruit_SSD1306.h !") ;
BONSOIR
le message qui me vient et quand je charge
excusez moi mon incapacite en imformatique
je voudrais savoir ou je me trompe
Merci de votre cooperation
Remi

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 4 novembre 2017 09:27, par Gilbert
  
  Je pense que la bibliothèque Adafruit_SSD1306.h est mal chargée ou mal paramétrée.
  
  Il faut bien faire le paragraphe ‘’vérification que nous avons toutes les fonctions pour gérer nos afficheurs’’
  
  Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 20 novembre 2017 08:36, par DR17

bonjour
super réalisation
serait il possible d inverser a chaque cycle l affichage départ et arrivée, de sorte que l on est sur le même afficheur une fois les départs suivi des arrivées et ainsi de suite.
merci de votre retour

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 20 novembre 2017 10:48

Oui il suffit de réécrire les tables d’affichages en alternant un écran arrivée et un écran départ, car à chaque écran en début d’écran on doit afficher ’’heure arrivée ou départ voie’’.
On initialise un seul LCD.

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 22 novembre 2017 07:37, par DR17
  
  bonjour
  merci du retour
  mais le but est de garder les 2 afficheurs et de les faire alterner entre arrivé et départ
  
  Répondre
  - Réalisation d’un affichage de gare ARRIVEE DEPART 22 novembre 2017 19:20, par Gilbert
    
    Même réponse, il suffit de définir vos écrans dans un tableau excel en faisant attention aux espaces, puis de transposer cela dans les tables d’affichages suivant l’ordre que vous aurez défini.
    
    Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 22 mars 2018 18:18, par Logejj

Bonsoir,
Comme dans le sujet déjà abordé, lorsque je fait "verifier " j ai toujours cette erreur.

#error("Height incorrect, please fix Adafruit_SSD1306.h

J ai suivi suivi vos indication du sujet précédant mais aucun changement .
je precise que je suis novice dans ce nouveau monde d Arduino.
Merci pour votre aide
Cordialement
JJL

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 22 mars 2018 18:36, par Jean-Luc
  
  Bonjour,
  
  C’est la seule erreur ?
  
  Répondre
  - Réalisation d’un affichage de gare ARRIVEE DEPART 22 mars 2018 20:25, par Logejj
    
    Re bonsoir
    
    Oui c est la seule erreur qui est donnée
    
    Répondre
    - Réalisation d’un affichage de gare ARRIVEE DEPART 23 mars 2018 07:44, par Jean-Luc
      
      Je n’arrive pas à la reproduire. J’ai téléchargé l’archive, mis les bibliothèques à leur place et tout compile.
      
      Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 23 mars 2018 11:50, par jjloge
Bonjour,

J ai télécharger à nouveau l IDE et même chose. Ci joint un extrait
B00000000, B00110000 }; #if (SSD1306_LCDHEIGHT != 64) #error("Height incorrect, please fix Adafruit_SSD1306.h!"); #endif void setup() { Serial.begin(9600);
Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 24 mars 2018 09:08, par Jean-Luc
  Bonjour.
  
  Deux possibilités :
  
  le symbole SSD1306_LCDHEIGHT n’est pas défini parce que le fichier .h où il est n’est pas trouvé
  le symbole SSD1306_LCDHEIGHT ne vaut pas 64
  
  ajoutez dans votre fichier :
  
  #ifndef SSD1306_LCDHEIGHT #error ("SSD1306_LCDHEIGHT n’est pas defini") #endif
  
  Pour voir.
  Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 24 mars 2018 09:32, par jjloge

Bonjour,
Merci pour votre aide
super après modification la compilation s est faite sans aucune erreur’
— -un mystère de résolu-----
cordialement
JJL

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 24 mars 2018 15:39, par Jean-Luc
  
  Oui mais non.
  
  Le mystère n’est pas résolu. Je vous demandais d’ajouter ces lignes, pas de remplacer celles qui posaient problèmes par les nouvelles. Donc si vous n’avez plus d’erreur, cela veut dire que le symbole est défini mais ne vaut pas 64. Il est possible que bien que ça compile, le programme ne fonctionne pas.
  
  Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 24 mars 2018 18:51, par Logejj

Bonsoir,
Je me suis mal exprimé pour moi le rajout des lignes fournies c est une modification dans le programme d origine.
Maintenant que le gramme "semble correct" il me reste qu’ à commander les 2 modules afficheur chez DX.com

Cordialement
JJL

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 23 mai 2019 22:37, par Germain

Bonsoir,

Merci pour ce merveilleux tuto.
Pour moi la seule difficulté fût le déplacement de la résistance CMS pour changer l’adresse I2C.
En une petite après-midi mon ensemble fonctionnait parfaitement.
Maintenant il ne me reste plus qu’à personnaliser l’affichage.
Encore un grand merci.

Cordialement.
Germain

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 28 novembre 2019 22:36, par Antoine

Bonjour,
Bravo pour ce tuto d’une précision ’chirurgicale’.
Mes seules modifications ont été de modifier les deux tableaux d’horaires pour couvrir la région de Belfort.

Encore Bravo !

Répondre

Réalisation d’un affichage de gare ARRIVEE DEPART 1er mai 2020 15:21, par Michel

Bonjour,
Bravo pour cette réalisation, et de manière générale pour ce site qui explique avec une très grande clarté les automates réalisables avec l’environnement Arduino.
J’ai réalisé une version "du pauvre" de votre programme, utilisant un seul afficheur un Attiny 85 et la lib lcdgfx, je colle le sketch ci-dessous. J’ai fait une petite video, mais je ne sais pas comment l’inserer.
Détail technique : il a fallu compiler avec l’horloge de l’Attiny à 16 MHZ.

/**
 *   Attiny85 PINS (i2c)
 *             ____
 *   RESET   -|_|  |- 3V
 *   SCL (3) -|    |- (2)
 *   SDA (4) -|    |- (1)
 *   GND     -|____|- (0)
 *
 *
 */

#include "lcdgfx.h"

DisplaySSD1306_128x64_I2C display(-1);

static void arrivees()
{
    display.setFixedFont( ssd1306xled_font6x8 );
    display.clear();
    display.printFixed(0,  8, "HEURE    ARRIVEE    V---------------------", STYLE_NORMAL);
    display.printFixed(0, 24, "O5h45 TOULOUSE      2", STYLE_NORMAL);
    lcd_delay(100);
    display.printFixed(0, 32, "O6h15 PARIS AUSTER  5", STYLE_NORMAL);
    lcd_delay(100);
    display.printFixed(0, 40, "O6h15 PARIS AUSTER  5", STYLE_NORMAL);
    lcd_delay(100);
    display.printFixed(0, 48, "O7h26 CAPDENAC      2", STYLE_NORMAL);
    lcd_delay(100);
    display.printFixed(0, 56, "O8h23 CLERMONT FR   1", STYLE_NORMAL);
 //   display.printFixed(0, 64, "O9h47 FIGEAC        3", STYLE_NORMAL);
    lcd_delay(300);
}
static void departs()
{
    display.setFixedFont( ssd1306xled_font6x8 );
    display.clear();
    display.printFixed(0,  8, "HEURE    DEPART     V---------------------", STYLE_NORMAL);
    display.printFixed(0, 24, "O5h15 BRIVE         3", STYLE_NORMAL);
     lcd_delay(100);
    display.printFixed(0, 32, "05h54 CLERMONT FR   2", STYLE_NORMAL);
     lcd_delay(100);
    display.printFixed(0, 40, "O6h45 TOULOUSE      1", STYLE_NORMAL);
     lcd_delay(100);
    display.printFixed(0, 48, "O7h55 CLERMONT FR   2", STYLE_NORMAL);
     lcd_delay(100);
//    display.printFixed(0, 56, "O8h23 CLERMONT FR   1", STYLE_NORMAL);
//    display.printFixed(0, 64, "O9h47 FIGEAC        3", STYLE_NORMAL);
    lcd_delay(300);
}


void setup()
{
    /* Select the font to use with menu and all font functions */
    display.setFixedFont( ssd1306xled_font6x8 );
    display.begin();
    display.clear();
}

void loop()
{
    //lcd_delay(1000);
    arrivees();
    delay(3000);
    display.clear();
    departs();
    delay(2000);
    display.clear();
}

Répondre

Réalisation d’un affichage de gare ARRIVEE DEPART 1er mai 2020 19:47, par Michel

Je me réponds moi-même ;-)
.1 Les accolades ont sauté quand j’ai copié/collé le code
.2 on peut commencer au coordonnées 0,0.

Répondre

Réalisation d’un affichage de gare ARRIVEE DEPART 1er mai 2020 22:46, par msport

Petit manque du mode d’emploi : pour le code il faut encadrer avec :
£codeùclass="arduino sans_telechargement">
</codeµ

en remplaçant
£ par <
ù par un espace
µ par >

Repostez, un modérateur fera le ménage ... Merci pour le partage.

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 2 mai 2020 00:03, par Jean-Luc
  
  Les balises sont :
  
  <code class="arduino sans_telechargement">
  </code>
  
  Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 12 novembre 2020 00:59, par Pedro

J’ai reçu 2 écrans où ils ne correspondent pas à ceux indiqués dans votre article car vous n’avez pas la possibilité de changer d’adresse.

2 résistances R3 et R4 apparaissent avec la possibilité de déplacer leur position, ¿est-ce avec elles que le sens change ?

Répondre
- Réalisation d’un affichage de gare ARRIVEE DEPART 23 juin 2022 15:36, par Olivier CASSE
  
  Bonjour,
  
  super tuto comme on aimerait en voir encore plus, bravo :)
  
  j’ai reçu un Arduino UNO (mon 4ème) et 2 afficheurs OLED pour la fete des pères...
  en effet mon fils était avec moi a Dreux lors de l’expo de novembre 2021 et on avait vu ce montage en demo sur un stand, qui m’avait plu :)
  
  j’avais oublié mais lui avait gardé ca comme idée cadeau : sympa
  
  mon fils n’étant pas electronicien il a commandé des afficheurs OLED un peu différents (AZDelivery) , notamment le chipset qui est un SH1106 (au lieu du SSD1306 du montage).
  Deux soucis : une seule ligne s’affichait et pas de réglage de l’adresse...
  
  1er souci résolu avec la bibliothèque OLED SSD1306 - SH1106 de Fabio Durigon
  2eme souci en ajoutant un Mux TCA9548A, qui dédouble en plusieurs bus I2C
  
  Cela fonctionne nickel et m’a donné des idées pour ajouter d’autres afficheurs, en gare ou pas !
  
  Le source requiert peu de modifications, si vous etes intéressé je peux fournir le code modifié
  
  Olivier
  
  Répondre
  - Réalisation d’un affichage de gare ARRIVEE DEPART 23 juin 2022 17:34, par msport
    
    Bonjour,
    aucun doute qu’il y aura des amateurs intéressés.
    Postez votre contribution sur le forum, par exemple :
    Cordialement
    
    Voir en ligne : un affichage de gare ARRIVEE DEPART
    
    Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 12 novembre 2020 09:23, par Danguiral

Peut être mais il faut vérifier avec la documentation .

Répondre
affichage incomplet 1er février 2021 13:48, par Boulery Michel

Bonjour
Bravo pour votre tutoriel.
J’ai suivi les instructions le montage des afficheurs . J’ai versé le programme Arduino
résultats : affichage 4 lignes( la ligne de texte départ arrivée ,la ligne de pointillés,
une ligne horaire, une deuxième ligne horaire)
J’ai ajouté une instruction concernant la hauteur de texte ( sans effets)
je suis dans une impasse !
je n’ai pas de grande connaissance dans le domaine de la programmation
Pouvez vous me conseiller.
Merci

Répondre
- affichage incomplet 1er février 2021 18:03, par Danguiral
  
  Le texte d’affichage c’est celui d’Aurillac ou le votre ?
  
  Répondre
  - affichage incomplet 1er février 2021 23:44, par Boulery michel
    
    Merci pour votre réponse
    j’utilise le texte d’affichage de la gare d’Aurillac
    
    Répondre
    - affichage incomplet 2 février 2021 11:11, par msport
      
      Bonjour,
      Je vous suggère de poster sur le forum votre programme pour avoir des avis en retour.
      De même avec une photo du montage des afficheurs.
      
      Voir en ligne : Dépannage de l’affichage ARRIVEE DEPART
      
      Répondre
      - affichage incomplet 2 février 2021 16:15, par boulery michel
        
        Bonjour
        
        J’ai préparé les photos et le code
        Comment vous poster l’ensemble
        Par avance merci
        
        Cordialement
        
        Répondre
        
        affichage incomplet 2 février 2021 18:45, par msport
        
        ... via le lien du message précédent. (pour répondre, il faudra vous inscrire - et vous présenter si vous le souhaitez)
        
        Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 2 février 2021 09:12, par Danguiral

Vous avez voulu modifier le programme, c’est peut être de là que vient le PB.(un point virgule est vite oublié)
Il faut recharger le programme Aurillac original sans modifs et voir le résultat.
Si c’est Ok c’est les modifs, si ce n’est pas Ok alors c’est l’électronique et là c’est difficile de vous aider.
Bon courage.

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 8 juin 2022 20:27, par lionel

Bonjour
bravo pour votre tuto..
je vous contacte pour un autre sujet.
J essai de commander un pont tournant avec un arduino, et je suis tombé sur votre vidéo YouTube « fonctionnement pont aurillac », cela m’a énormément plus mais les commentaires sont désactivés et nous ne pouvons pas vous joindre.
Serait il possible de recevoir de votre part cette programmation arduino.
en vous remerciant d avance
cordialement

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 31 août 2022 13:50, par pierre

Bonjour,

Je viens de le réaliser.
Fonctionnement parfait du premier coup.

la seule difficulté, c’est de déplacer la petite résistance.
J’ai complètement « loupée « la chose, aussi j’ai remplacé
cette minuscule résistance par une résistance classique de
4700 ohm. Et ça fonctionne très bien.

J’ai aussi soudé les écrans côte à côte sur une petite
plaquette de CI.

Je vais maintenant modifier le programme pour changer les gares.

Cette réalisation ce n’est que du bonheur.

Répondre
Réalisation d’un affichage de gare ARRIVEE DEPART 30 septembre 2022 17:26, par jacky

Bonjour, cet afficheur gare d’aurillac est une super réalisation et Bravo
Avec une carte arduino / pas de problème ; par contre si j’utilise une carte esp8266, cela ne donne rien ! Pas d’affichage. s’avez vous pourquoi ? et avez vous une version pour esp8266 (Wemos D1 mini). Merci

Répondre