TCO en processing

[DDEFF]

Je m'amuse bien …

Le premier qui m'a parlé de Processing, c'est Guillaume.
J'avais même cru que c'était une bibliothèque Arduino…
Thierry m'avait montré mon erreur et Pierre m'avait donné un exemple frappant d'une aiguille commandée à l'écran.
Mais je ne voulais pas d'ordinateur sur le réseau.

Puis, lundi je me suis lancé quand j'ai trouvé un exemple de dialogue Arduino - Processing :
http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerieGraphiquePCGraphXYAnalemne
Bien sûr, ça n'a rien à voir avec les trains, mais les petits carrés et le dialogue m'ont convaincu.

Ce que je voulais, c'est un TCO avec de petits cubes, comme chez Weissmann, Trix, Heki (mon article "Qui Heki" en 1995 dans Loco Revue).
Tapez "GleisBild" dans Google et regardez les images.

Mais il y a 2 graves problèmes :
1°) Le prix exorbitant
2°) le câblage, même si c'est "simplifié".

Par ailleurs, je n'ai pas trouvé de bibliothèque Arduino qui dépassait le VGA (640x480). Dommage.

Donc, je vais avoir un écran (et l'ordi qui va avec), mais sans commander par l'ordi.
On affiche un TCO et l'Arduino envoie dessus la position des trains et des signaux.

J'ai donc fait un TCO avec Processing, avec les petits cubes dont je rêvais. Avec même des petits reflets 

En haut à gauche, les cubes modèles, qui ne bougent pas.
Tous les cubes sont coupés (de façon invisible) en 9 cases :

0 1 2
3 4 5
6 7 8

Quand la souris est sur les cases 0, 1, 2, 4 et 5, on peut déplacer le cube.
Quand on appuie sur 3, on a un effet miroir vertical.
Quand on appuie sur 7, on a un effet de miroir horizontal.
Quand on appuie sur 6, le cube tourne dans le sens horaire.
Quand on appuis sur 8, le cube tourne dans le sens trigo.

Après, on peut dessiner ce qu'on veut. 

Quand on est content, on appuie sur "s" (save) et le dessin est sauvé dans data sous la forme d'un fichier Cube.csv.
Si on veut le récupérer, on lance le programme et on appuie sur "l" (load) et il s'affiche.
Je vous joins ma gare comme exemple.

Donc, il faut télécharger Processing 3 et l'installer.
On décompresse le .Zip qui est joint et on lance le .pde
On appuie sur "l" et ma gare se charge.

Mais faites-en ce que vous voulez.

On peut, bien sûr, modifier la taille des cubes.
Mais si vous sauvez un grand nombre de cubes, vous allez avoir des problèmes quand vous rechargerez si vous affichez maintenant moins de cubes.

On pourrait aussi utiliser les cubes pour la construction et ne plus afficher de traits de contour pour l'exploitation. C'est très ouvert.

Amusez-vous bien.

[Pierre59]

Bonjour

Quand j’avais vu les TCO du gestionnaire Hornby (faits de pavés standards) j’avais écrit un petit programme en Java pour faire des tests, il y a peu de paves de base nécessaires, les variantes nécessaires sont obtenues par des rotations et des symétries simples à faire. Voici un exemple de ce que cela peut donner,  voir dans les deux fichier ci joints:

- la palette des pavés possibles (ils peuvent tous êtres tournés et/ou inversés)
- un exemple de ce que l’on peut faire avec

Le graphisme peut encore être amélioré,au niveau des aiguilles et des TJD.
Je rappelle que Processing c'est du Java.

Pierre

[DDEFF]

Merci Pierre,

Bons vœux pour 2016 !

Je m'aperçois que je ne t'avais même pas cité alors que tu m'avais montré un exemple de ce que pouvait donner une aiguille qu'on pouvait faire changer avec un clic de souris.
J'ai honte ... 

Toi aussi, tu m'as mis le pied à l'étrier par un exemple pourtant frappant ! Et instructif !
Comme ta gare, claire aussi.

J'aimerais faire apparaitre aussi les signaux et j'aime bien ton idée avec un petit carré à côté de la voie.
J'ai comme autre idée possible : donner à la couleur de la "voie" du canton la couleur du signal (tracé en vert, jaune, rouge, ...) avec le sens indiqué comme la zone blanche qui se déplace sur fond vert (téléchargements de fichiers en Windows).
Mais c'est peut être un peu trop flashy !

Je reprendrais certainement aussi l'idée du fond gris foncé pour dessiner les aiguilles et voies, en faisant apparaître la voie sélectionnée en noir. C'est très parlant.

Je sais bien que Processing est en Java, mais, franchement, je trouve que ça ressemble à la programmation de l'Arduino (au vocabulaire supplémentaire près, évidemment).
C'est un hasard ??

Par contre, je préfère mettre les TJD en 2 aiguilles, ce qui décale tout d'1/2 cube par rapport à tes modèles. Mais j'en viendrais peut-être, à l'usage, à ta méthode.
J'en suis au tout début.

Encore merci.

[Pierre59]

Bonjour et bonne année

Si tu comptes utiliser le PC que pour le TCO, un mini PC genre PCduino serait plus adapté, il supporte Processing et l'Arduino.

Pour la ressemblance entre Processing et Arduino c'est normal car Arduino a été inspiré par Processing.

Des pavés TJD ou TJS un peu plus longs (1.5) cela posera des problèmes pour retrouver dans quel pavé on fait un click de souris, pour manoeuvrer un aiguille ou pour choisir un itinéraire par exemple.

Quand j'ai écrit, vite fait, le programme je voulais surtout tester les opérations de rotation et de symétrie, permettant d'avoir tous les cas possibles avec une palette très réduite, et je ne me suis pas beaucoup intéressé au graphisme des pavés que je n'aime pas trop, pas assez de différences entre les TJD, TJS et les croisements, mais je sais comment faire plus joli.

Bon courage.

Pierre

[DDEFF]

Merci Pierre,

Effectivement, PCDuino est nettement moins cher qu'un PC.
Ce que je veux, c'est qu'on puisse mettre un écran 27" de définition 1920 x 1080.
Visiblement, le PCDuino sort en HDMI, donc ça devrait marcher.
Je trouve cette solution idéale.

Par contre, je ne souhaite pas commander mon réseau avec cet écran, qui ne me servirait qu'en sortie.

L'entrée serait par une manette qui ressemblerait à la tienne, avec un petit écran.

Puisque j'arrive à trouver le canton N+1 et même N+2 dans ma liste_Trains, pourquoi ne pas avoir une mini reproduction des aiguilles qui vont arriver devant le train, avec un BP en face de chacune d'elle, sur la manette, sur un écran LCD 2,4" ?

Ex (voir PJ plan numéroté) : tu es sur le canton 107 (avec ma numérotation du réseau de l'article SGDD) : affichage de 5 voies :
123, 124, 125, 126 et 127.
123, 125 et 126 sont des traits dessinés en rouge (occupés), mais 124 et 127 sont des traits dessinés en vert (libres) : on peut donc sélectionner 127.
Comme le gestionnaire sait qu'on est en 107, il va pouvoir fabriquer 131 - 127.
Avec mes "matrices", ça doit être assez simple.

On ne dessine pas les aiguilles, on met juste un trait vertical, de la couleur qui va bien, en face des BP.
Évidemment, si on choisit une voie occupée, on peut, mais le train va s'arrêter.

Pour ma gare, cela suppose jusqu'à 12 voies et 12 BP (ou une roue codeuse ?) (Voir PJ ma gare)

Concernant les pavés, on les voit (les 4 en haut à gauche) et je fais les TJD avec 2 aiguilles tête-bêche, comme dans mon programme Arduino, justement.
Il faut d'autres pavés, bien sûr.
On peut les arrondir au lieu de faire anguleux, mais j'aime bien et ça correspond à la réalité (j'ai des photos, mais ça ne tient pas ici).

Rotation, symétrie fonctionnent, il me faut maintenant pouvoir sélectionner plusieurs pavés, soit individuellement, soit en groupe (ceux sous un rectangle dessiné à la souris).
Dès que j'ai un peu de temps, je m'y met.
Puis viendra l’interfaçage avec l'Arduino DUE via le bus série. Le DUE qui gère le CAN et les modules sous le réseau.

J'ai encore de quoi m'occuper ... 
Heureusement...

[DDEFF]

Bonjour Pierre,

Finalement, je trouve que remplacer une TJD par 2 aiguilles pose un problème de place à l'affichage.
Ta méthode, qui met une TJD sur un seul cube, est meilleure.

Exemples :
http://www.berros.eu/de/itrain/images/MainFrame.png
(je ne reproduirais pas la partie gauche)
http://www.berros.eu/de/itrain/images/SwitchboardEditor.png

Il y a un peu plus de motifs de base, mais l'affichage est sympa, même les signaux (à franciser, bien sûr).

[DDEFF]

On passe à la V2 ! 

Gros changements :

1°) Définitivement adopté les cubes dans lesquels la TJD est dans un seul cube.
Cela donne des schémas plus compacts et bien plus proches de la réalité.
Merci Pierre. 

2°) Plus de dessins anguleux, mais de belles courbes de Béziers. 
Au passage, la construction des cubes est nettement plus compacte et plus logique.

La rotation des cubes devient ainsi beaucoup plus simple.
Au passage, on tourne d'1/8 de tour à chaque fois.

3°) On peut maintenant sélectionner des cubes :

- On appuie sur la touche CTRL, ce qui a pour effet de mettre le curseur en croix (move) pour voir que l'appui sur CTRL est validé.
On peut relâcher la touche.

- On peut sélectionner des zones, des cubes particulier, disjoints ou non.
Au fur et à mesure, ils passent en grisé.
Sélectionner à nouveau, c'est désélectionner.

- On appuie sur C pour copier, X pour couper.
On peut alors les déplacer à son gré. Ne sont mobiles que les cubes qui ont des rails.

- On appuie sur V pour coller, ce qui déverrouille l'appui sur CTRL.

4°) Les tracés sont en gris clair, la position des aiguilles sera en noir pour la bonne position.

Il reste quelques cubes à définir (aiguille triple, aiguille symétrique, tunnels, ponts, angle, …).

Et, surtout, à le relier à l'Arduino pour que les trains roulent sur les tracés et que les aiguilles soient en bonne position.

[DDEFF]

Bonjour,

Évolutions d'hier :

1°) J'ai mis un peu de couleurs. 

J'ai changé le fond des cubes qui est maintenant vert pâle.
Je garde le gris clair pour la position non choisie des aiguilles et le noir pour la position choisie.

2°) Les aiguilles ont maintenant 2 positions. 

Pour le fun (ça n'a aucun intérêt autre que de montrer que ça marche), si on appuie sur SHIFT, on change la position de toutes les aiguilles et TJD.
Il faut au préalable charger la gare (appui sur L) et elle apparaît avec toutes les aiguilles tout droit.
Un coup sur SHIFT et tout est dévié, etc...

3°) L'Arduino envoie maintenant une info au TCO. 

Il faut installer le programme sur un Arduino (il est dans le Zip) et le laisser branché sur le port USB pour utiliser le port série.
Cela fait changer toutes les secondes le contenu de la case 35,0.

A ce sujet, on se rend compte que le port série n'est pas fiable (au moins à 115 200 bits/s) et j'ai dû créer un "trop grand" dans Processing. 

4°) Évidemment, je vais faire le lien avec SGDD pour que la position des aiguilles soit répétée sur le TCO via le bus série.

Autre évolution : la couleur des rails des cantons sera fonction du signal vu par le train.

Pas de train : rails du canton en noir
Signal VL : rails en vert
Signal S ou C : rails en rouge
Autres signaux (et donc en ralentissement) : rails en orange.

A bientôt.

[DDEFF]

Grosse évolution : on passe à la V3 

Mode d'emploi :

1°) télécharger processing :

https://processing.org/download/?processing

C'est du Java, mais ça ressemble énormément au langage Arduino.
C'est normal, Arduino dérive de processing.

2°) télécharger le .zip joint qui contient :
- Les fichiers .pde qui sont ceux de Processing
- Une directory qui contient un programme de démo en Arduino
- une directory "data" qui contient les sauvegardes :
   - Cubes.tsv, c'est l'image du réseau
   - RailID.tsv qui contient les identifiants du réseau (numéros de cantons, des aiguilles, identifications des compositions des cantons, …)
   - Une gare exemple qui est une copie de Cubes.tsv
   - Des étiquettes exemples qui sont les étiquettes de la gare.

3°) Il faut brancher un Arduino UNO (p. ex), c'est indispensable au fonctionnement.
Et il faut le laisser branché puisque c'est par le câble USB que transitent les échanges Arduino -> Processing.

4°) On lance d'abord le programme Arduino.
Il faut le faire avant car sinon, on ne peut pas téléverser car le port est déjà utilisé par Processing.

5°) On lance le programme Processing "Essai de cube…", ce qui ouvre tous les autres dans des onglets.

6°) Dans le setup de processing, entouré par des étoiles, les 2 variables à initialiser une fois pour toutes :
- size : ici, c'est size(1920, 1080), mais vous prenez ce que vous voulez.
- edge (arête d'un cube), ici à 40.
En changeant l'arête d'un cube, toutes les autres dimensions se recalculent toutes seules.

7°) Vous lancez le programme ("play", en haut à gauche)
Apparaissent les cubes exemple de la légende sur la gauche.
Par "glisser-déposer", on peut prendre un cube à gauche et le poser où on veut.
Puis on peut l'orienter (coin en bas à gauche pour le sens horaire, coin en bas à droite pour le sens trigo).
Petit à petit, vous construisez votre réseau. 
Je vous propose ma gare déja dessinée et étiquetée.
Faire simplement L.

8°) Si vous voulez recopier une partie ou déplacer une zone, c'est presque comme d'habitude.
- appuyez sur CTRL. Vous pouvez relâcher la touche
- vous sélectionnez la zone (qui passe en grisé). Si vous resélectionnez un cube, il se déselectionne.
- si vous appuyez sur C, les rails (et seulement les rails !) adhèrent au curseur.
- si vous appuyez sur X, pareil
- en appuyant sur V, vous collez. CTRL C+V = copier-coller, CTRL X+V = couper-coller.
Petite subtilité :
Si vous appuyez sur c minuscule, vous ne copiez qu'une fois et tout est perdu.
Mais c'est plus simple.
Si vous appuyez sur C majuscule, la copie est gardée et vous pouvez vous en resservir tout de suite.
C'est particulièrement utile pour des droites.
Pour arrêter, faire M et cliquer sur "annull" dans la boîte qui s'ouvre.

9°) Pour numéroter les cantons et les aiguilles, il faut mémoriser des étiquettes.
- appuyez sur CTRL, comme avant
- Il faut sélectionner cette fois uniquement des rails, un par un ou en groupe.
Attention : il faut les sélectionner uniquement dans le sens horaire (ça servira par la suite)
- puis appuyer sur M (mémory) une fenêtre pop-up apparait et vous donnez le numéro du canton ou de l'aiguille.
- Puis OK et c'est fini.

Mais vous allez vouloir vérifier. C'est normal.
- appuyez sur D (display) et toutes les étiquettes apparaissent.
En grand la première et en petit les filles. Vous pouvez voir ainsi si des zones sont non étiquetées, ou à l'envers.

La touche M (memory)sert aussi à déselectionner :
Vous avez appuyé par erreur sur CTRL. Vous appuyez sur M puis sur "annul".

Les étiquettes suivent le déplacement en couper-coller, mais pas en copier-coller. C'est voulu.

10°) Le mode démo :
 En appuyant sur E (Exemple), une bascule débloque le port série, et ce qui est programmé dans l'Arduino se déroule.
Vous trouvez que ça va trop vite ? : modifiez le delay(1) dans le programme Arduino. Par exemple 500.

11°) Enfin, mais c'est important, vous pouvez sauver en faisant S (Save) : les fichiers Cubes.tsv et RailID.tsv sont alors écrasés et remplacés par vos fichiers.
Mes fichiers exemple sont dont recopiés sous un autre nom pour ne pas les perdre. Vous pouvez faire de même avec les vôtres.

Il reste des choses à faire :
- ajouter des cubes aiguille triple, aiguille symétrique, des ponts et des tunnels, …
- j'aimerais bien faire rouler des trains avec une loco et des wagons sur le TCO.
- finaliser le lien entre SGDD et le TCO.
Pour l'instant, le TCO est "universel". Vous le branchez à un port série sur ce que vous voulez.

Et après, dites-moi ce que vous voudriez en plus !

Merci à Thierry pour sa simplification drastique de la class RailID. 

Si quelqu'un connait personnellement Monsieur PCDuino, j'aimerais bien lui parler.
Juste pour le fun : en faisant S, vous sauvez bien sûr les positions des aiguilles. Cela évite la fameuse EEPROM.
Mais, bon, un écran 27" plus un PCDuino pour gagner une EEPROM ... 

[Pierre59]

Si quelqu'un connait personnellement Monsieur PCDuino, j'aimerais bien lui parler.
Mais, bon, un écran 27" plus un PCDuino pour gagner une EEPROM ... 

Bonjour

J'ai utilisé un PCduino pour réaliser un petit TCO annexe pour une petite gare terminus. Le PCduino est doté d'un petit écran tactile 1024x600, qui reproduit une partie du TCO principal du réseau (juste la petite gare). Le programme est écrit en Java (j'ai plus l'habitude) mais pourrait être écrit en Processing. Le PCduino communique avec le Mac qui gère le réseau par WIFI.

Si tu veux plus d'infos sur le PCduino, il n'y a qu'a demander !

Cordialement

Pierre

PS pour le plaisir j'ai aussi mis des courbes quadratiques sur les pavés de dessin de réseau, voir la palette sur le fichier joint.

[DDEFF]

Évolutions, suite :

J'ai changé de réseau pour préparer mes articles.
Correction de quelques bugs et, surtout, on peut maintenant supprimer le quadrillage et la légende !
On appuie sur G ou g (grid). C'est une bascule qui fait apparaître ou disparaitre le quadrillage.

A cette occasion, je me suis rendu compte que les jonctions n'étaient pas nettes. C'est corrigé.

Je peaufine le lien avec SGDD pour faire avancer des trains sur ce réseau de façon simple.

[DDEFF]

Je voulais tester l'affiche en conditions "réelles".
Voilà ce que ça donne :


On a donc le TCO en processing qui reçoit par le câble série les infos d'occupation, de sens, de position, ... à partir du programme Arduino SGDD.
J'ai complètement réécrit la partie essais pour qu'on puisse programmer un circuit facilement. Voilà ce qu'il faut écrire pour avoir le résultat de la vidéo :

Code: [Sélectionner]

    //  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
              byte    def_01[]  = { 105, 0, 109, 111, 113, 116, 118, 0, 127, 0, 130, 0, 105 };         //  Always in clockwise direction
              boolean train_dir = CLOCKWISE;                                                           //  CLOCKWISE or CONTERCLOCKWISE
              int     t_delay   = 1000;                                                                //  "speed" of the train
    //  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1°) La liste des cantons sur les quels le train va circuler, un "0" pour remplacer les aiguilles.
SGDD se débrouille pour trouver l'itinéraire qui va bien.

2°) Dans quel sens on va sur ce circuit.
Sans rien changer d'autre, il suffit de mettre CONTERCLOCKWISE pour que le circuit soit fait dans l'autre sens

3°) La "vitesse" du train (en fait, la durée des délais entre chaque canton). Là, il y a 1 seconde.

Apparaissent les cantons occupés :

- en vert si le feu est vert
- en rouge si le feu est rouge. On voit bien ainsi le moment où le train est sur 2 cantons
- en noir quand le train est passé.

Je n'ai pas voulu gérer ici les feux amenant un ralentissement, en orange, mais c'est dans le tuyau.

Évidemment, on ne remet pas les aiguilles en position tout droit après le passage du train. Ici, c'est juste pour le fun et voir bouger les aiguilles.

Ce programme, utilisé pour les essais, pourra, après adaptation, servir à programmer des trains automatiques, des navettes, etc
On rentrera les infos en cliquant sur les cases du TCO pour enregistrer le circuit.

Dernière adaptation : faire choisir au train une voie libre quand il y aura du choix. 

[Dominique]

Bonjour Denis,

Il est pas mal ton TCO : en plus il représente un réseau que j'aime bien :-))
 

[DDEFF]

En ce moment, je suis un peu occupé à autre chose...
Je ne programme plus, mais j'ai des idées. 

Programme à venir :
La vidéo précédente marche avec un onglet "_Train_01" qui fait partie du programme SGDD sur le DUE. Essai OK : on continue.

Étape suivante : je prends un nano avec un potar et un inverseur.
Ce sera un "train". Le programme reprendra ce qui est actuellement dans _Train_01.

Il contient un programme qui fait un circuit :
byte    def_01[]  = { 105, 0, 109, 111, 113, 116, 118, 0, 127, 0, 130, 0, 105 };
ça, c'est que je rentre.

Il envoie les infos (occupation, position des aiguilles, ...) dans un bus CAN qui va vers le DUE.
En particulier il "appuie sur les boutons" pour demander les itinéraires.
ex : 105, 109.
Le DUE répond par la liste des aiguilles à bouger.

Le nano envoie l'info au DUE : les aiguilles sont en position.
Le DUE envoie au TCO la position des aiguilles.

Quand on bouge le potar, on fait varier le delai, ce qui simule la variation de vitesse.
Et donc, la rapidité avec laquelle les occupations de canton sont envoyées au DUE.
Puis affichées par le DUE au TCO (bus Série)

Comme l'horloge du Nano est différente de celle du DUE, on a une vraie simulation de train.

Au passage les couleurs des signaux sont gérées, avec l'orange cette fois.
En particulier, si on traverse une gare tout droit, on a le vert et si on est dévié, on doit avoir l'orange (ralenti 30 ou 60).
En changeant simplement la voie demandée pour traverser la gare, on va voir évoluer la signalisation.

Étape suivante :
Un autre nano (= un nouveau "train"), mais dans l'autre sens. On doit pouvoir tester les signaux et les ordres d'arrêt.

En gros, le programme du DUE sera prêt, sans scories de tests, etc.
Celui du TCO aussi.
Et, bien sûr, du bus CAN.

Étape suivante : ajouter la gestion de la position des aiguilles sur les nanos.

Étape suivante : gérer les gares cachées (choix d'une voie libre et dire, où qu'on soit "rentre le train en gare cachée 01, voie 02" en cliquant au TCO.

A suivre (quand je pourrais) 

[DDEFF]

Grâce à Pierre59 qui m'a ré(!)expliqué la vraie programmation objet (sans pointeurs pour l'instant puisqu'il n'y a pas de pointeurs en java), je commence à réécrire mon TCO en Processing.
Non seulement c'est plus clair (mais vraiment plus clair), mais, en plus, c'est très économe en lignes.
Je pense que j'arriverai à passer de 2183 lignes à environ 500 !!

Après Thierry et ses articles, Jean-Luc et ses explications, je crois que la pulpe du fond commence à se décoller