Messages récents

Pages: [1] 2 3 ... 10
1
Petit point rapide avant le Salon de Lille...

Depuis un an et demi, je cherche à automatiser le passage d'un dessin de réseau à un programme Arduino qui gèrerait le réseau.

En novembre 2015, j'avais produit un article SGDD(1) où je modélisais ma gare, pourtant très complexe, en seulement 85 octets.
Mais il fallait pas mal de patience pour arriver à trouver ces 85 octets !
La suite du programme n'utilisait pas la programmation objet, que j'ai appris à connaître depuis, même si je ne maîtrise encore pas tout…

Grâce à Processing, j'ai mis l'accent sur l'esthétique du TCO et les récents posts donnent une idée des progrès accomplis. Mais le vrai problème restait là : comment modéliser automatiquement ?

Au début du mois d'avril 2017, j'avais réussi à modéliser le fameux locodrome, mais avec une méthode qui n'était guère extensible à d'autres réseaux.
La partie la plus délicate étant la désignation des suivants et des précédents des signaux.

En fait, évidemment, il faudrait une bonne récurrence qui étudierait tous les cas.

Seulement, la récurrence souffre de trois écueils :


-> Au début, ça ne démarre pas : on n'a pas suffisamment analysé les conditions initiales !
-> Après, ça ne s'arrête plus ! : Là, ce sont les conditions de sortie qu'on n'a pas bien encadrées.
-> Puis ça marche dans 99% des cas et on croit qu'on a fini.
Quelques réglages et… on voit que c'est carrément la méthode qui n'est pas bonne et se fait coincer dans certains cas.
Tout est à recommencer !

Je n'ai pas eu le temps de vérifier complètement le fichier Specifs.h.

Mais pour la partie méthodes des signaux, j'ai tout vérifié sur un circuit type où tous les éléments existent :

-> Des aiguilles, successives cette fois, et même en "communication" (terme SNCF officiel)
On va donc avoir à gérer des selonAiguille(a1, Sxx, selon(a2, Syy, Czz))
-> Une Traversée Jonction Double
-> Une "traversée" simple
-> Des voies de garage
-> Et même une aiguille triple, extension de la méthode des selonAiguille(a1, Sxx, Cyy Szz)

Voici le réseau vierge :



Puis le réseau numéroté :



Et enfin, si j'appuie sur "R", voilà la sortie (seulement la partie méthode des signaux)

Signal* C101_2::suivant() { return C104_8; }
Signal* C101_2::precedent() { return C103_1; }
 
Signal* C101_1::suivant() { return C103_9; }
Signal* C101_1::precedent() { return C104_2; }
 
Signal* C102_4::suivant() { return C104_8; }
Signal* C102_4::precedent() { return C103_1; }
 
Signal* C102_3::suivant() { return C103_9; }
Signal* C102_3::precedent() { return C104_2; }
 
Signal* C103_1::suivant() { return selonAiguille(a1, C101_2, selonAiguille(a3, C105_6, C102_4)); }
Signal* C103_1::precedent() { return C109_9; }
 
Signal* C103_9::suivant() { return C109_7; }
Signal* C103_9::precedent() { return selonAiguille(a1, C101_1, selonAiguille(a3, C105_5, C102_3)); }
 
Signal* C104_8::suivant() { return selonAiguille(a8, C107_7, C106_7); }
Signal* C104_8::precedent() { return selonAiguille(a2, C101_2, selonAiguille(a4, C105_6, C102_4)); }
 
Signal* C104_2::suivant() { return selonAiguille(a2, C101_1, selonAiguille(a4, C105_5, C102_3)); }
Signal* C104_2::precedent() { return selonAiguille(a8, C107_8, C106_8); }
 
Signal* C105_6::suivant() { return selonAiguille(a6, C202_0, C204_0, C104_8); }
Signal* C105_6::precedent() { return selonAiguille(a5, C201_5, C103_1); }
 
Signal* C105_5::suivant() { return selonAiguille(a5, C201_0, C103_9); }
Signal* C105_5::precedent() { return selonAiguille(a6, C202_6, C204_6, C104_2); }
 
Signal* C106_7::suivant() { return selonAiguille(a7, C108_9, C109_9); }
Signal* C106_7::precedent() { return C104_8; }
 
Signal* C106_8::suivant() { return C104_2; }
Signal* C106_8::precedent() { return selonAiguille(a7, C108_7, C109_7); }
 
Signal* C107_7::suivant() { return selonAiguille(a7, C109_9, C108_9); }
Signal* C107_7::precedent() { return C104_8; }
 
Signal* C107_8::suivant() { return C104_2; }
Signal* C107_8::precedent() { return selonAiguille(a7, C109_7, C108_7); }
 
Signal* C108_9::suivant() { return C203_0; }
Signal* C108_9::precedent() { return selonAiguille(a7, C106_7, C107_7); }
 
Signal* C108_7::suivant() { return selonAiguille(a7, C106_8, C107_8); }
Signal* C108_7::precedent() { return C203_9; }
 
Signal* C109_9::suivant() { return C103_1; }
Signal* C109_9::precedent() { return selonAiguille(a7, C107_7, C106_7); }
 
Signal* C109_7::suivant() { return selonAiguille(a7, C107_8, C106_8); }
Signal* C109_7::precedent() { return C103_9; }
 
Signal* C201_5::suivant() { return C105_6; }
Signal* C201_5::precedent() { return ; }
 
Signal* C201_0::suivant() { return ; }
Signal* C201_0::precedent() { return C105_5; }
 
Signal* C202_0::suivant() { return ; }
Signal* C202_0::precedent() { return C105_6; }
 
Signal* C202_6::suivant() { return C105_5; }
Signal* C202_6::precedent() { return ; }
 
Signal* C203_0::suivant() { return ; }
Signal* C203_0::precedent() { return C108_9; }
 
Signal* C203_9::suivant() { return C108_7; }
Signal* C203_9::precedent() { return ; }
 
Signal* C204_0::suivant() { return ; }
Signal* C204_0::precedent() { return C105_6; }
 
Signal* C204_6::suivant() { return C105_5; }
Signal* C204_6::precedent() { return ; }

Je ne regrette pas les trois semaines que je viens de passer… ;D

Je n'ai pas le temps de détailler, mais je le ferais bientôt.
Notez, au passage que, maintenant, je tiens compte des signaux capables d'afficher le carré (Cxx) et ceux qui se limitent au Sémaphore (Syy)

Tout ce que je peux dire aujourd'hui, c'est que je demande quand même assez peu de choses à l'amateur :

1°) Dessiner son réseau avec le programme TCO.
Profiter que le plan est vierge pour en faire une copie : elle resservira.

2°) Numéroter le réseau dans le programme avec quelques règles :
-> numéroter les aiguilles de 1 à 100
Zéro n'est pas possible.
J'appelle "Aiguille" tout ce qui n'est pas un "canton" : les branchements, les traversées,…

-> numéroter les cantons de 101 à 200
Un canton n'a pas d'aiguille. Ce n'est pas une zone dans la terminologie de Pierre.

-> numéroter les voies de garage de 201 à 255

3°) Comme mes appellations ne vont pas vous plaire, il faudra que vous fassiez une table d'équivalences (transform.tsv) avec juste deux colonnes :
Votre numérotation / ma numérotation.
Pour l'instant, je ne m'en sers pas, mais ce sera facile à gérer.
Et c'est pour ça que vous apprécierez d'avoir gardé un dessin de réseau vierge  ;)

4°) Appuyez sur "A" (analysis) pour vérifier que tout est OK
Puis appuyez sur "R"
Vous récupérerez le fichier Specifs.h  :o

Quelques remarques utiles :

Grâce à ce programme, vous générez un programme Arduino.
(Pour l'instant, les itinéraires ne sont pas faits, mais c'est à venir).
Mais je n'ai fait aucune hypothèse, ni sur l'alimentation du réseau (DCC ou analogique), ni sur la façon dont sera fait le TCO !

Même si vous voulez un TCO physique, avec de vrais boutons, vous aurez besoin d'un gestionnaire Arduino. Et vous pourrez utiliser mon programme TCO pour le générer...  ;)

Ce n'est pas fini, mais un grand pas vient d'être franchi.   :P
2
Présentez vous ! / Re : Bonjour à vous tous
« Dernier message par DDEFF le avril 26, 2017, 03:01:54 pm »
Bonne idée de suivre notre site  ;)

On a pas mal de boulot en ce moment, mais on pense à toi.
250 m de voies ? Impressionnant ! D'où le Train Controller ...
Tant que je tiens quelqu'un qui maîtrise Train Controller, j'ai une question : il peut piloter un bus CAN (Controller Area Network) ?

Bienvenue parmi nous

Denis
3
Présentez vous ! / Re : Je me présente
« Dernier message par Thierry le avril 21, 2017, 04:29:48 pm »
Bienvenue parmi nous. N'hésites pas à nous montrer ton travail dans un fil dédié !
4
Présentez vous ! / Je me présente
« Dernier message par cachart le avril 21, 2017, 03:00:08 pm »
Bonjour,

Depuis quelques mois, je réalise un réseau en N sur une plaque de 125cm par 60cm avec 3 niveaux qui est aujourd'hui roulant . J'ai une commande Multimaus raccordée à une centrale Fleischmann 680801. J'ai dans un premier temps réalisé un programme pour un Arduino UNO qui gèrer la signalisation d'une partie du réseau avec un pilotage des aiguillages par un switchPilot ESU et un switchPilot Extension pour récupérer la position des aiguilles.

Je tente de mettre en œuvre le TCO XpressNet de Nicolas ZIN avec, à terme, l'espoir de remplacer les boutons à levier par des poussoirs, mais pour l'instant j'essaie de comprendre son programme que j'ai implémenté dans un arduino MEGA car j'obtiens sur la console uniquement le message ---starting--- et rien d'autre.

Je souhaite profiter de l'expérience des personnes qui maitrisent le digital appliqué au réseau ferroviaire pour ensuite mettre à disposition mes réalisations.

Merci.
5
Présentez vous ! / Bonjour à vous tous
« Dernier message par Mcarmina le avril 19, 2017, 01:27:09 pm »
Bonjour
nouvel inscrit et  utilisateur de arduino
je suis ce site depuis 6 mois (environ)
merci à vous tous, ce site est une mine d'info sur notre passion qui est l'automatisme d'un réseau.
intéressé par la conception d'un décodeur d’accessoire pilotable avec Train Controller.
merci de m’accueillir parmi vous,
mes projets :
pilotage d'un moteur pap pour commande d'une table transfert et pont tournant + creation d'un switch board pour actionner les aiguillages + renvoi au TCO .
mon réseau : 250m de voie piloté par Train Controller centrale lenz
bien à vous,
6
Vos projets / Re : Alimentations analogiques
« Dernier message par TF53 le avril 16, 2017, 10:46:41 pm »
Je dois bien en avoir un qui traine quelque part... Envoi moi un MP avec ton adresse et le convertisseur tu auras  ;)
7
Vos projets / Re : Alimentations analogiques
« Dernier message par DDEFF le avril 16, 2017, 10:39:35 pm »
J'y avais pensé (c'était tentant  ;)), mais pour avoir de bons ralentis, il faut du courant pulsé pour nos petites locos.
Sinon, le ralenti n'est pas bon.

Et comme il faut aussi gérer des locos à moteur à rotor sans fer, on doit travailler avec des fréquences de l'ordre de 20 à 30 kHz.
D'où ma proposition.
Je pense que je vais déjà bien m'amuser à dessouder une patte du LM2596  :P

La fréquence de hachage des convertisseurs Buck est très élevée, gage d'un bon rendement et donc d'un échauffement moindre.

Là, il en faut une un peu plus basse.

Je vais déjà commander un lot de convertisseurs Buck avec un afficheur.
Mais comme ça met 1 mois 1/2 à arriver, je demande à l'assistance en délire (!) si elle ne peut pas m'en envoyer un que je massacrerai au fer à souder pour faire mes essais ( :o) et que j'en renverrai un neuf dans 1 mois 1/2 ?
8
Vos projets / Re : Alimentations analogiques
« Dernier message par TF53 le avril 16, 2017, 10:10:43 pm »
Pourquoi ne pas tout simplement déporter les potentiomètre des convertisseurs? En remplaçant le potentiomètre soudé sur la carte du convertisseur par un potentiomètre + une résistance, tu peux facilement régler ta tension, sans passer par l'arduino...
9
Vos projets / Re : Alimentations analogiques
« Dernier message par DDEFF le avril 16, 2017, 09:00:23 am »
Le but est de conduire des trains.

Donc, il faut une alim avec un potar, des cadrans et une PWM réglable de 0 à 100%.

Je pars d'un transfo 24V 10A.

Je mets 3 convertisseurs.
-> 1 réglé à 15V / 2A, définitivement
-> 1 réglé à 12V / 2A, définitivement
-> 1 réglé à 9V / 2A , définitivement

Puis un Arduino qui génère du 20 à 30 kHz et 1 potar (0 à 100%) pour chaque tension.
Et une protection anti-surtension (qui mets la patte 5 à la masse).

Voilà, voilà  ;)
10
Vos projets / Re : Re : Alimentations analogiques
« Dernier message par TF53 le avril 15, 2017, 11:06:43 pm »
J'ai l'impression que tu as loupé mon dernier lien (ou alors j'ai la tête complètement ailleurs  ;D)

Sinon il y a ça si tu veux à la fois afficheur et réglage de courant...

Avec ça, tu as affichage et réglage du courant et de la tension + un bus série qui doit surement permettre de récupérer tension / courant. Je ne comprends tout simplement pas l'intérêt de rajouter un arduino pour faire de la PWM là dedans???
Pages: [1] 2 3 ... 10