Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Messages - DDEFF

Pages: 1 ... 36 37 [38] 39 40 ... 55
556
Je propose aujourd'hui de faire le point sur ce que je veux faire, à terme, et ce qui fonctionne déjà.

Étant donné le prix des logiciels du commerce, n'ayant peur de rien, j'ai cherché à en faire un moi-même, à ma sauce.
Je dis tout de suite que, sans un site comme Locoduino, je n'y serais jamais arrivé. Imaginez qu'en 2014, je ne connaissais pas le langage C…

Quatre ordinateurs

Le premier, c'est celui du salon (ou du bureau, comme vous voulez) et vous devez installer dessus la dernière version de Java et du logiciel Processing.
Avec Processing, mon premier logiciel en Processing : TCO.

Processing ?

Pour faire simple, un Arduino sait exécuter une tâche quand vous appuyez sur un bouton poussoir, allumer une LED, …
Mais il est très pauvre en entrées sorties avec un écran.

Processing sait, par contre, gérer quasiment tout ce que vous voulez faire sur un écran (faire tourner des figures en 3D, dessiner en 2D, …) mais il ne sait pas allumer une LED !

En fait, ces deux là sont faits pour s'entendre, via le bus série.

Donc, sur votre ordinateur (PC, Mac ou Linux) vous allez créer votre TCO en jouant avec des petits cubes. Vous pourrez les déplacer, les copier-coller ou couper-coller.
Tout ça avec une palette qui contient, à l'origine, tous les types de figures (ligne droite, courbe, aiguilles, croisements, TJD, TJS et triples)

J'ai voulu une interface sobre, épurée, avec le moins de texte possible.
En plus, je cherche à dessiner un réseau complet (c'est absolument indispensable ici, vous verrez pourquoi), une représentation assez proche de la réalité, y compris des longueurs à l'échelle.

On peut évidemment sauver le résultat et cela génère 4 fichiers textes :

Block___2016_11_10__08_04_55.tsv
C_panel_2016_11_10__08_04_55.tsv
Turnout_2016_11_10__08_04_55.tsv
Specifs.h

Les trois premiers sont liés par une date-heure commune (à la seconde près) et sont destines au deuxième ordinateur.
Le quatrième est destiné au troisième ordinateur.

Quand votre TCO est complètement dessiné, vous n'avez plus besoin du premier ordinateur. Après tout, on ne change pas de réseau tous les jours…



Le deuxième ordinateur

Ce n'est plus un vrai ordinateur, mais un couple PCDuino3 - écran.
Et quand je dis écran, c'est un grand écran (27", au moins) et il est attaché au mur, comme les vrais TCO.
Et si je pouvais, il ferait toute la longueur du mur, comme les vrais TCO.
Je pense qu'on peut même recycler une ancienne TV à écran plat.

PCDuino3 ?

Pour 70 €, vous allez avoir un micro ordinateur qui fonctionne en Linux. L'écran se branche en HDMI.
Et comme Processing fonctionne aussi en Linux, vous installerez mon deuxième logiciel : Commandes.

Il faut copier les 3 fichiers en .tsv avec et vous retrouverez votre joli dessin de TCO, mais plus la palette qui servait à le dessiner.



A la place, un boîtier de commandes qu'on peut déplacer et dimensionner pour conduire de 1 à n trains. Commande uniquement à la souris.
Cette partie est en cours de développement.

A court terme, je souhaite doter le programme de Jean-Luc d'entrées sorties plus conviviales en le gérant depuis Processing. Et intégrer le programme de Pierre (= Pierre59), celui qui gère le célèbre Locodrome.

Par rapport aux solutions du commerce, j'insiste sur trois points :

1°) Maintenant que j'ai dessiné le TCO, je ne décrirai plus le réseau une nouvelle fois. Il faudra que ça se débrouille pour toutes les fonctions.

On vient de voir que le programme de Jean-Luc pouvait être intégré (http://forum.locoduino.org/index.php?topic=167.45) et que donc, automatiquement, tous les itinéraires possibles sont calculés. C'est même tellement rapide qu'on n'a pas besoin de les sauvegarder : ils sont calculés à la demande, en quelques millisecondes.

Je ne veux pas non plus décrire des trajets : ce sera au programme de les trouver, en fonction de paramètres à définir.

2°) J'affiche sur chaque commande le signal que "voit" le conducteur de la loco.
Sous une forme agréable et conforme à la réalité SNCF, pas un simple voyant.

3°) Par ailleurs, je veux voir les trains se déplacer.
J'entends par "se déplacer" un mouvement continu. Pas un bond brutal de canton en canton.
Un mouvement coulé qui suit de belles courbes, sur des cantons pas forcément rectilignes, horizontaux ou verticaux.

C'est même cette fonction qui doit me permettre d'avoir sur la commande la vitesse réelle du train.
Quel plaisir de voir la vitesse réelle se rapprocher progressivement de la vitesse de consigne !

Certes, ça suppose que les paramètres DCC soient bien ajustés, via une phase de tests. A mon avis assez longue.

Donc, un point va se déplacer, accélérer, ralentir, en fonction de la vitesse réelle du train. C'est pour cette raison que le tracé du TCO doit correspondre au vrai tracé du train.
A chaque signal de changement de canton, d'aiguille, cela donnera un top qui resynchronisera le point par rapport au point sur l'écran. Plus les paramètres DCC seront précis, plus le dessin du TCO sera proche de la réalité, plus ce sera facile de resynchroniser.

Une fois qu'on est synchrone, tout est possible :
1°) Plus besoin de couper les rails pour les zones d'arrêt
2°) On peut déclencher une action (sifflet, par exemple) a un point précis du réseau, sans ILS ou autre.

Le troisième ordinateur

Cette fois-ci, c'est un Arduino DUE, gestionnaire du réseau.
Il est relié au PCDuino3 par un câble USB série (au moins pour les essais).
Il reçoit du PCDuino3 les ordres (choix d'itinéraires, vitesse, …) et lui envoie le résultat (occupation des cantons, couleur des signaux, …)

C'est là que vous utilisez le fichier "Specifs.h" généré par TCO, au début.

La partie description du réseau existe (le programme de Jean-Luc), mais il reste beaucoup à faire.
En particulier répondre à la question très complexe : parmi tous les itinéraires calculés, quel est le meilleur ?

C'est là aussi qu'il me faut intégrer la partie signaux de Pierre. J'ai bon espoir.

Et, évidemment, le DUE est relié au réseau via un bus CAN.

Je ne veux pas voir de fils sous le réseau.
Uniquement des câbles Ethernet avec des RJ11/RJ45 qui vont de modules en modules.

Jean-Luc a réalisé le premier d'entre eux : le module 8 aiguilles.

On fera évidemment un module cantons.

Les possibilités du bus CAN sont énormes et permettront à la fois de gérer la mise en place des aiguilles, mais de gérer aussi toute la rétro-signalisation.

Les bibliothèques de Thierry permettront une gestion simplifiée de tous ces échanges.

Le quatrième ordinateur

C'est la centrale DCC, avec un Arduino MEGA.

Logiciel DCC++ dont Dominique vous a déjà parlé sur le Forum et dans des articles.

Relié bien sûr au gestionnaire. A définir.
Je penche pour un lien vers le DUE par le bus série et relier le DUE au PCDuino par un bus CAN.
Le deuxième bus CAN du DUE vers le réseau.

En fait, la seule information qui va être véhiculée sera du DUE vers le MEGA, c'est la vitesse maxi de consigne.
Exemple : "Je veux que le train 1 aille au maximum à 30 km/h".

Cela suppose que cette centrale DCC puisse commander plusieurs trains. A suivre.

Comme vous le voyez, c'est extrêmement ambitieux, mais faisable.
Et qu'on peut agglomérer les réalisations des uns et des autres en un ensemble complet.

C'est très motivant.
N'hésitez pas à vous exprimer, à donner vote avis.

557
Le logiciel DCC++ / Re : DCC++ sur Nano avec LMD18200
« le: novembre 11, 2016, 02:05:06 pm »
Et quand on boit du thé, on fait comment ?  ;D ;D ;D

Je rigole : magnifique réalisation.  ;)

Évidemment, il faut un article pour la partie technique, la réalisation proprement dite.

Je ne pense pas que quelqu'un va réaliser exactement la même chose, puisque ton proto correspond à une situation particulière, mais savoir pourquoi tu as choisi tel matériel et pas un autre, où tu l'as eu, le schéma de câblage, ... Tout cela ne peux que donner des pistes pour des réalisations personnelles.

Par ailleurs, je sais que l'article sur la programmation, nécessaire aussi, évidemment, va, là aussi, ouvrir l'esprit des Locoduiniens.
Que demander de mieux ?

558
Je prends un autre exemple :
Faire un circuit 107, 110, 112, 114, 115, 117, 124, 131.
On indique à la ligne 115 ce qu'on veut :
  testItineraire(VOIE_4, VOIE_23);(en suivant bien ce que le fichier Transform.txt a dit)

Réponse dans la fenêtre du moniteur :
Gestionnaire reseau
Nombre de voies : 50
**** Test des ensembles ****
VOIE_4
    AIGUILLE_10
        VOIE_23
================
*vide*
================

Ajout de VOIE_23
================
VOIE_23
================

Ajout de AIGUILLE_10
================
VOIE_23 AIGUILLE_10
================

Ajout de VOIE_4

Qui se lit comme suit :

VOIE_4
AIGUILLE_10 = AIGUILLE_1 (les numéros d'aiguille sont multipliés par 10. Je ne sais pas quelle est la raison)
VOIE_23.

Puis la construction :

Ajout de VOIE_23
Ajout de AIGUILLE_10
Ajout de VOIE_4

C'est dans le sens DIRECTION AVANT.

Pour l'autre sens, il faut aller modifier la ligne 31 en DIRECTION_ARRIERE.
Et téléverser.

Ce qui donne dans le moniteur série, en vous faisant grêce du début :
================
VOIE_7 VOIE_9 VOIE_11 VOIE_12 VOIE_14 VOIE_19 VOIE_23 AIGUILLE_40 AIGUILLE_50 AIGUILLE_70 AIGUILLE_80 AIGUILLE_90 AIGUILLE_150 AIGUILLE_160
VOIE_7 VOIE_9 VOIE_11 VOIE_12 VOIE_14 VOIE_20 VOIE_23 AIGUILLE_40 AIGUILLE_50 AIGUILLE_70 AIGUILLE_80 AIGUILLE_90 AIGUILLE_150 AIGUILLE_160 TJD_0 TJD_1
VOIE_7 VOIE_9 VOIE_11 VOIE_12 VOIE_14 VOIE_17 VOIE_23 AIGUILLE_40 AIGUILLE_50 AIGUILLE_60 AIGUILLE_100 AIGUILLE_110 AIGUILLE_150
VOIE_7 VOIE_9 VOIE_11 VOIE_12 VOIE_14 VOIE_18 VOIE_23 AIGUILLE_40 AIGUILLE_50 AIGUILLE_60 AIGUILLE_110 AIGUILLE_150
================

Ajout de VOIE_4

Il y a cette fois 4 façons d'aller de la VOIE_4 à la VOIE_23.
On peut passer par la VOIE_17, la VOIE_18, la VOIE_19 et la VOIE_20
N'oubliez pas, les numéros d'aiguilles sont multipliés par 10...

Ce que je retiens, c'est que ce magnifique programme résout de façon entièrement automatique la problématique d'aller d'un point A à un point B, sur absolument n'importe quel réseau.

Il donne toutes les solutions.

S'agissant d'un cœur de programme, la partie intelligente si vous voulez, la partie communication avec l'extérieur, aussi bien en entrée qu'en sortie n'a pas été développée. Mais, justement, chacun peut développer la sienne.

J'ai apporté ma pierre en simplifiant l'entrée des données, elle aussi automatisée. On a juste à "jouer aux cubes"...  ;D

Je vais m'attacher maintenant à communiquer avec ce programme Arduino via le bus série et mon programme "Commande.pde" écrit en Processing.

La suite sur mon post http://forum.locoduino.org/index.php?topic=211.0  :P
 


559
Présentez vous ! / Re : Bonsoir a vous tous
« le: novembre 10, 2016, 08:38:51 pm »
Bienvenue parmi nous.

J'aime bien les deux parties de ton propos :
1°) A la recherche de solutions
ET
2°) De faire des choses par moi même.

Un parfait résumé du site.
A bientôt

Denis

560
Trouvé les 25 :



Ce qui correspond à ce que je lui ai demandé :
Origine     : VOIE_GARAGE_1, VOIE_GARAGE_5 et VOIE_GARAGE_6
Extrémité : VOIE_GARAGE_0, VOIE_GARAGE_2, VOIE_GARAGE_3 et VOIE_GARAGE_4

Et les deux impossibilités sont donc : VOIE_GARAGE_5 vers VOIE_GARAGE_0 ou VOIE_GARAGE_1, ainsi que VOIE_GARAGE_6 vers VOIE_GARAGE_0 ou VOIE_GARAGE_1

On peut demander individuellement ce qu'on veut (un peu plus haut dans le programme).
Ex VOIE_21 -> VOIE_20
Il trouve les 4 solutions :
Via la VOIE_2, la VOIE_3, la VOIE_4 ou la VOIE_5, prenant le périphérique intérieur ou le périphérique extérieur  :D

Je savais que ce programme était génial ! Bravo Jean-Luc !

Pour transformer les numéros de voie DD -> nom des voies JLB, utiliser le fichier Transform.txt (post précédent).
Je conseille d'imprimer le plan avec mes numéros et d'écrire dessus les noms de Jean-Luc.
Comme ça, c'est plus facile à suivre.

Moyennant quelques modifs simples, je vais l'adapter au port série et lui faire échanger avec mon programme de commandes, cette fois.
Je lui demanderai sur le TCO par où je démarre (CTRL, clic souris sur le canton puis I (= in) et où je veux aller (CTRL, clic souris sur le canton puis O (= out))
Et il me sortira la liste des itinéraires.

Reste une question à la quelle on ne sait pas répondre : lequel choisir ? ???
"A que" on est bien embêtés  :-\, d'autant que cette réponse doit être dynamique, en fonction des itinéraires demandés et des présences des autres trains...

A suivre  :-*

561
Il en trouve 26 et 2 impossibles.
Mais je n'ai pas compris lesquels ...  ???

Je m'explique :

1°) je te fournis le plan de ton réseau avec ma numérotation (celle du programme TCO et de SGDD).

2°) Je te fournis aussi le programme Arduino de Jean-Luc, avec la version ton réseau.
Celui-là, tu peux le téléverser sur un Arduino DUE et voir ce qu'il donne.

L'onglet Specifs.h est la description, "comme Jean-Luc" cette fois, de ton réseau.

Pour t'aider je te joins aussi le fichier tansform.txt qui est la traduction numérotation DD -> numérotation JLB.
(numérotation DD = 1000+numérotation DD du plan pour que tout soit bien aligné)
Ce fichier ne sert à rien d'autre qu'à nous aider, pauvres humains  :)
Il est quand même généré par l'ordi, sans intervention humaine.

En retirant les // pour voir les tâches, tu verras comment travaille le programme de Jean-Luc.
Et tu comprendras ma réponse du début  ;D

562
Finalement, j'ai continué  ;D

Parce que le réseau de Dominique ne marchait pas et que ça n'était pas dû au programme de Jean-Luc, mais au mien ...  :(
J'ai donc retroussé mes manches et j'ai revu l'onglet Analysis qui a connu une simplification drastique.
Maintenant, c'est beaucoup plus simple, plus facile à comprendre et plus carré.
J'ai revu l'onglet routes et, là, seulement quelques bricoles.
C'est quand même sympa, la récursivité...  8)

Et maintenant, les deux fonctionnent parfaitement  ;D ;D

J'ai volontairement retiré les // devant la trace de l'onglet debug => c'est plus long. Soyez patients : ça s'arrête bien à la fin dans la fenêtre du moniteur.
Vous pourrez toujours remettre les //, bien sûr.

Ce qui veut dire, entre autres, que le programme de Jean-Luc fonctionne avec un réseau bouclé.

A suivre  :P


563
Grand nouveauté sur Locoduino : un programme qui écrit … un programme Arduino !

Dès le début, j'ai bien aimé ce programme de Jean-Luc.
D'abord, il s'intéressait à une gare que je connaissais bien : la mienne … ;D ;D


Ensuite, comme expliqué, ce programme trouve tous les itinéraires, sans autre préalable que de décrire le réseau dans le .ino.
C'est-à-dire qu'il cherche tout seul tous les itinéraires possibles : on n'a pas besoin de les décrire un par un. Tant mieux, il y en a 241 !  :o

Cependant, cette description du grill de la gare, bien que d'une grande logique, n'est pas aussi simple qu'on le penserait de prime abord.

Aussi, je me suis dit que j'allais la faire écrire par l'ordi, sans intervenir directement. ;)

Je commence par du très simple : mettre tout ce qui concerne le réseau dans le même onglet.

Donc, je crée un onglet "Specifs" (sans accent).
Je mets dedans :
enum { … }
La création des objets (voies, aiguilles, TJD, …)
La table des sources
La table des destinations
Le void afficheNomVoie { … }
Jusque là, ce sont de simples copier-coller. On démarre cool.
Je mets tout au début du .ino un #include "Specifs.h" pour que l'Arduino s'y retrouve.

Pour les connexions des voie, cette fois dans le setup(), il faut créer un void()
Je crée donc void export_setup() { … } dans Specifs, que j'appelle depuis le setup().
Un dernier copier coller des connexions de voies et c'est fini.

Une vérification pour voir qu'on n'a rien oublié ni raté une ligne et le programme fonctionne comme avant. C'était bien la peine… :P

Mais, avez-vous remarqué que pour créer l'onglet dans l'IDE de l'Arduino, il ne vous a pas demandé le nom de l'onglet, mais le nom du fichier correspondant. Et c'est là qu'est la première astuce : tout ce que je dois créer, c'est un simple fichier texte : Specifs.h !

Si je veux changer de réseau, j'ai juste à changer de Specifs.h. C'est dur de faire plus simple.

Reste un "détail" : générer ce fichier…

C'est là que j'utilise mon programme de TCO en Processing.

En deux mots :

1°) Je dessine mon réseau, en positionnant des petits cubes.


2°) Je regroupe les cubes en cantons en leur affectant un numéro (de 101 à 255) et je numérote de la même façon les aiguilles  (de 1 à 100). J'utilise la touche CTRL et la touche M (pour "memorize").


3°) Une petite analyse, pour voir s'il reste des erreurs (cubes isolés, …) et mise en forme des cantons.
Un simple appui sur A (pour "analysis"). Corrections des erreurs trouvées.

4°) Je sélectionne les voies entrantes de la gare, avec CTRL et quand je les ai toutes, j'appuie sur I (pour "in")

5°) Je sélectionne les voies sortantes de la gare, avec CTRL et quand je les ai toutes, j'appuie sur O (pour "out")

6°) J'appuie sur R (pour "Route", faux ami pour itinéraire).

Et c'est fini.
J'ai, non seulement un TCO sur mesure à l'écran, mais aussi un fichier Specifs.h !
L'affichage du TCO serait presque accessoire (alors que c'est quand même l'essentiel)…

Maintenant, je copie ce fichier Specifs.h pour remplacer celui existant dans la directory du programme Arduino. Et ça marche. ;D ;D

Quelques précisions :

1°) Le programme de Jean-Luc utilise des "voies libres", c'est-à-dire des voies qui sont bien reliées côté gare et "en l'air" vers l'extérieur.
Je n'ai pas retenu cette notion qui n'existe pas dans la réalité, mais dont je comprends parfaitement l'utilité dans ce programme, dans son état actuel.
Les curieux auront remarqué que j'ai donc mis des voies de garage à chaque entrée sortie. Pas très réaliste non plus… ???
C'est donc un point à creuser dans l'avenir.

2°) J'ai donc un peu modifié le programme de Jean-Luc en retirant les tests de debug au départ (qui font allusion aux voies libres). Mais qui ne sont pas nécessaires au fonctionnement.

3°) Evidemment, j'ai essayé avec le réseau de Dominique que j'utilise dans mes articles.
Le fichier Specifs.h est bien créé, mais il ne fonctionne pas avec l'Arduino.
Est-ce parce qu'il est bouclé ?? Je ne sais pas. :-[ :-[

4°) J'ai aussi changé le mot "aiguillage" que j'ai remplacé par "aiguille" (on n'est pas pinailleur pour rien  :D). Je vais essayer d'ajouter les TJS et les triples, mais c'est plus sournois qu'il y paraît.

Et maintenant ?

"Que vais-je faire ?", disait Becaud.
Moi, rien.
Mais j'aimerais bien que Jean-Luc puisse trouver un peu de temps libre pour continuer son magnifique programme.

Parce qu'en l'état actuel, il trouve en un temps record tous les itinéraires d'une gare (et, j'en suis sûr, d'un réseau complet). Mais d'un point A à un point B, il en trouve "trop". Lequel choisir ?

Donc, à suivre. :P

En PJ : mon TCO en Processing, version 3.8 et le fichier de Jean-Luc avec les quelques modifs décrites et qui marche avec mon Specifs.h

564
Bus DCC / Re : Protocole Motorola Lenz LE 930 / Roco 10739
« le: novembre 03, 2016, 09:16:23 am »
J'étais pas au courant..  ;D ;D
Au delà du jeu de mots (nul), c'est toujours une bonne idée de passer aux LEDs.

565
Présentez vous ! / Re : Présentation
« le: novembre 02, 2016, 09:55:59 am »
Bonjour Eric,

Ta présentation est très intéressante, site sympa. Locoduino devient international ... ;D
Dans un club de 50 (!!) membres, obligation du multi-protocole, évidemment.

Je note aussi plusieurs logiciels (RRTC, Itrain, RailUino...). D'où ma première question : quels sont les avantages et inconvénients de ces systèmes ?
Un comparatif serait le bienvenu, d'autant que c'est très rare.
Je suis pourtant lecteur de nombreuses revues, y compris américaines, depuis plus de 40 ans (Aïe :'() et je n'ai jamais vraiment vu quelque chose de sérieux sur les possibilités des différents systèmes. Et les impossibilités, les limites, évidemment.

Je suis d'autant plus intéressé que j'essaie, avec mes moyens, de faire une solution maison (voir le forum). Il devrait y avoir une avancée d'ici quelques jours (encore un truc à terminer).

Booster 4A "transformé pour le multi-protocole". Comment ? La source est évidemment excellente  ;D ;D

Content de t'avoir parmi nous.

Denis.

566
Suite à quelques questions qui m'ont été posées (en off), je précise un peu plus ma démarche.
J'ai, en cours de développement toujours, deux programmes complémentaires.
Je vous ai présenté le deuxième dans le précédent post et, en PJ, vous trouverez le premier. Je sais, c'est un peu bizarre ... :)

Le premier programme est un éditeur de TCO.

Le but étant que quelqu'un qui n'est pas forcément féru de C++ (Arduino), de Java (Processing) puisse dessiner son réseau et avoir un vrai TCO.
On a à sa disposition une palette contenant tous les symboles nécessaires (on pourrait en ajouter, d'ailleurs) et, par drag & drop, on les mets où on veut, on les oriente, on les copie, on les déplace par lots, ... Bref, on dessine petit à petit son réseau.

Je me suis très fortement inspiré du Locodrome de Pierre (=Pierre59), qui est une formidable boîte à outils concernant les objets, des briques, qu'on peut adapter à ses goûts et ses besoins.

Les briques qui permettent de dessiner une Ferrari peuvent aussi servir à dessiner un tracteur :
Ils ont tous les deux quatre roues. Je prends les roues de la Ferrari, je change la taille et j'ai des petites roues à l'avant et des grandes à l'arrière !

Ce programme a été développé sous Windows, avec une vraie souris à molette, ce qui est extrêmement pratique à l'usage.

Pour la fonction zoom, on a le choix entre mettre la souris au dessus de la partie à zoomer et tourner la molette dans un sens ou dans l'autre.
Si on n'a pas de souris, on fait + ou -, toujours en ayant mis la souris sur la partie qu'on veut zoomer.

Sur un portable, avec un touchpad, c'est effectivement moins pratique, mais possible.

On peut évidemment sauver ce qu'on a fait (ouf ! ;)) simplement en appuyant sur "S".

Cela génère trois fichiers texte :
--> Un fichier qui décrit chaque cube, avec toutes ses caractéristiques
--> Un fichier qui décrit les cantons (donne la liste des cubes qui le composent) et qui donne l'élément suivant et précédent
--> Un fichier qui décrit les aiguilles (donne la liste des cubes qui le composent) et qui donne les éléments qui y sont rattachés
J'appelle "élément" un canton ou une aiguille.
"Aiguille" au sens (très) large : aiguille, TJD, croisement, triple...

Quand on a fini de dessiner son TCO, ces 3 fichiers seront à transférer de la directory "data" du TCO à la directory "data" des commandes.
Comme vous le remarquerez, le nom des fichiers suit une logique stricte : quand on sauve, le nom du fichier contient la date, l'heure (minutes et secondes).
C'est comme ça qu'on les relie ensemble.
Il est d'ailleurs quasi obligatoire de trier la directory data en fonction de la colonne date. Comme ça, les 3 fichiers sont ensemble.

Le deuxième programme sert à commander les trains

Il y a toujours une palette, mais elle contient des éléments de commande des trains.
L'autre palette a disparu, on ne peut plus bouger les cubes ni modifier le tracé.
Mais, alors qu'on ne pouvait pas changer la position des aiguilles, là, on pourra (pas encore fait).

Je pense que je ne ferais pas directement la commande des aiguilles, mais celle des itinéraires, en utilisant une méthode différente du Locodrome :
Premier clic sur un train, deuxième clic sur sa destination. Et c'est le programme qui se débrouillera pour savoir comment y aller.

Là, le programme de Jean-Luc sera bien utile, même si, pour l'instant, il n'a pas cette fonction.

En tous cas, je ne veux pas avoir à dresser moi-même la liste de tous les itinéraires possibles.

La nouvelle palette contient à l'ouverture 14 manettes. C'est beaucoup trop.
Allez ligne 57 et mettez "8" au lieu de "28". Vous n'aurez plus que 4 manettes, ce qui est déjà pas mal.

Et là, vous apprécierez (je l'espère) de pouvoir déplacer la manette où vous voulez et surtout de zoomer dessus.
Vous verrez la qualité des fonctions de dessin vectoriel de Processing : ça reste net à grande échelle. Vous pourrez voir les ombres sous le curseur, etc...

Avenir :

Malheureusement, je me rends compte en développant le deuxième programme qu'il a une influence sur le premier. D'où le fait que ferai l'article sur le premier quand je saurais qu'il n'évoluera plus.

Ce que je voudrais développer aussi, c'est que le point qui symbolise une loco dans le Locodrome avance exactement en phase avec le vrai train.
J'entends par là qu'on puisse en déduire la vitesse réelle du train à tout moment. J'ai des pistes, mais il faut se lancer.

Processing existe aussi pour Android (et pas trop pour Iphone). On peut donc envisager une manette déportée sur un mobile.
J'attends l'article de bobyAndCo pour voir comment l'intégrer  ;D ;D

Vous noterez également que les fonctions DCC sont distinctes du reste. En virant une colonne sur deux, on peut envisager une commande analogique. A voir.
En fait, c'est aussi un labo. C'est quand même agréable de faire ce qu'on veut...


567
Bonjour à tous,

J'en suis arrivé à une version 1.3 qui possède déjà pas mal des caractéristiques finales. ;D ;D

Mode d'emploi :


Lancer Processing, choisir l'un des 3 fichiers, ce qui prend les 3 (les trois dont le nom ont la même date)
Faire clic, puis L (= load).
Je ne sais pas pourquoi je suis obligé de faire clic, mais c'est obligatoire et je n'arrive pas à m'en débarrasser...

Là, on voit 14 (!!!) commandes de locos, mais c'est pour voir presque tous les types de feux.
On peut choisir parmi les 29 (!!) fonctions du DCC par un clic, pour chaque loco.

Évidemment, je vais faire une version 7 fonctions (F0 à F6), 14 fonctions (F0 à F13).
On peut zoomer sur la palette, la déplacer.
Et on peut sélectionner le nombre de trains dans le 1er onglet, ligne 57, variable c_max_p = 28 colonnes pour 14 trains. Il faut évidemment choisir un nombre pair ...

Il reste des lignes à virer, des lignes à ajouter (la dernière case qui servira à la photo de la loco) et, plus dur, gérer le port série avec le DUE.
Et .... tester PCDuino !

Pour l'instant, ce qui marche :

1°) un feu aux dimensions exactes (époque III).  ;D ;D

Dans la V1.2, les dimensions étaient fausses et j'ai dû tout revoir.
J'ai eu du mal à récupérer les infos dont j'avais besoin.
C'était sur le forum LR (http://forums.e-train.fr/viewtopic.php?f=20&t=57722) et sur un autre que certains connaissent déjà : le petit train du Tertre (http://lestrainsdutertre.redheberg.com/TouteVapeur/Bienvenue.html)
Vaut le détour !

2°) Le fonctionnement du signal est calqué sur le CabSignal de Pierre59, un futur additif du Locodrome (http://www.locoduino.org/spip.php?article172&var_mode=calcul), dont j'avais eu la primeur (merci Pierre).
Globalement, le programme complet est fortement inspiré du locodrome et j'ai encore d'autres choses à y découvrir et adapter à mon projet.
C'est une véritable mine.
Pour info, j'ai pris la vraie fréquence de clignotement, 1.1 Hz.

3°) J'ai voulu une interface agréable à regarder (je vais l'avoir sous les yeux ... un certain temps).

La vitesse est réglée par un curseur qu'on peut déplacer à la souris.
C'est la vitesse demandée par le conducteur.
A droite, on a un barregraphe coloré qui correspondra à la vitesse réelle du train.
C'est à dire que si, pour l'instant, les deux sont liées, ce ne sera plus vrai à terme.
On demande la vitesse maxi, par exemple, et le train va mettre un certain temps pour l'atteindre.
D'où le décalage qu'il y aura entre la position du curseur et la hauteur du barregraphe.

Le gestionnaire enverra une consigne de vitesse maxi, quelle que soit la position du curseur.

Par ailleurs, la cote du barregraphe, analogique par nature, est affichée en digital au dessus, en bleu.

Pour l'instant, ça va de 0 à 100, mais il faudra que la vitesse maxi soit fonction de la loco (dans son fichier, j'y reviendrai).
J'ai mis des graduations logarithmiques, pour l'instant.
J'ai essayé des graduations qui suivent la courbe logistique, la vraie, mais ce n'est pas terrible, tassé en haut et en bas...

4°) Reste une case vide en bas.
Ce sera la photo de la loco.
Et, dans le fichier de la loco (un quatrième, donc), on sauvera la vitesse maxi du train et peut-être certains CV, quand je gèrerais le DCC.

A suivre  :P

Le fichier image joint, très tassé, ne rend pas la qualité du vrai affichage vectoriel.

568
Vos projets / Re : Commande de signaux mécaniques - Servomoteurs
« le: octobre 07, 2016, 06:53:05 pm »
Hé bé !
T'es en forme...  ;D
Bravo. Belle réalisation. ;D ;D

Quant à la programmation, elle a l'air simple et efficace. Mais je pense qu'elle est brutale.

Jean-Luc a bien décortiqué le sujet des servos à mouvement lent, le problème du "bond" au départ, etc...

Je n'ai pas le temps de te trouver les liens, mais regarde bien les articles et le forum Locoduino. Cette partie est améliorable.
Encore bravo.

Denis
PS : FRITZING, avec un F... ;)

569
De vrais bijoux de programmation objet.

Ces programmes valent vraiment le coup d'être étudiés et décortiqués.

Le programme TCO en processing a évidemment servi de base à mon propre développement (bientôt l'article ...  ;) ).
Je l'ai adapté à ma sauce, développé certains points, mais, fondamentalement, c'est le même programme.
Est même déjà développé ce que je voulais faire : mettre un point pour suivre le train !!
Merci Pierre.

570
Le logiciel DCC++ / Re : DCC++ sur Nano avec LMD18200
« le: septembre 25, 2016, 02:18:23 pm »
Et surtout en beaucoup moins cher... ;D ;D

Je ne connais pas bien RailCom, mais c'est sûr qu'il y a du matos pour chaque zone.
Il est hors de question de balader de l'analogique : il faut traiter au niveau du canton (ou de la zone, si tu veux.)
Mais je n'envisage pas de détecter la présence autrement qu'avec de la détection de consommation de courant.

Amicalement

Pages: 1 ... 36 37 [38] 39 40 ... 55