LOCODUINO
Parlons Arduino => Vos projets => Discussion démarrée par: Jean-Luc le janvier 15, 2015, 06:36:28 pm
-
Bonjour,
Il s'agit ici de faire du cantonnement sur un réseau analogique. L'idée est de pouvoir piloter un réseau « comme en numérique » avec une grosse différence : les « décodeurs » sont associés aux cantons et non aux locomotives.
Ce n'est pas une idée nouvelle, feu Driving Railways faisait cela. Mais il s'agit d'aller un peu plus loin en ayant une régulation de vitesse (compensation de charge dans le jargon).
Une première solution est de faire un arbre de relais qui permet d'associer une alimentation à un ou plusieurs cantons.
Une autre solution consiste à associer une alimentation pilotée par un Arduino à chaque canton. En plus de l'alimentation du canton, il assure la détection de présence et, idéalement, la mesure de vitesse de la locomotive qui occupe le canton.
C'est cette seconde solution qui est choisie.
Une première chose à faire est de synchroniser les PWM de tous les cantons. En effet, si les PWM ne sont pas synchrones, une locomotive à cheval sur 2 cantons recevra une impulsion plus longue et verra sa vitesse modifiée tant qu'elle est à cheval. Elle fera donc potentiellement un petit bond à chaque passage d'un canton au suivant.
Voici donc une bibliothèque qui assure la synchronisation des PWM de plusieurs Arduino. Elle utilise le timer2 dans un mode de PWM particulier qui permet d'ajuster finement la fréquence.
Un Arduino maître diffuse un signal de synchronisation aux autres Arduino, le code exemple est dans MasterClock. Le signal de synchro sort sur la broche 3.
Avec l'exemple SyncPWM, chaque Arduino affecté à un canton génère une PWM synchronisée sur la broche 3 et reçoit le signal de synchro sur la broche 8.
La fréquence de la PWM est d'un peu moins d'1kHz. l'erreur maxi entre 2 PWM, du moins ce que j'ai pu mesurer à l'oscillo, est d'environ 8µs. Les valeurs possibles pour la PWM vont de 0 à 254.
À 1kHz, le signal de synchro devrait pouvoir voyager sur une certaine distance (combien ? faut voir). Au delà, il faut passer en différentiel.
Si vous avez des questions, n'hésitez pas.
La bibliothèque :
https://dl.dropboxusercontent.com/u/67740546/SyncPWM.zip
-
Comme en numérique c'est à dire ?
Chaque arduino pourra déterminer par exemple le sens du courant ?
Je ne connais pas ce log mais si on prend un exemple : réseau en 8 voie unique avec 2 gares sur les parties droites du 8 (dont une cachée donc)
pourrait-on faire partir chacun de leur coté un train d'une gare, ils vont chacun dans un sens pour arriver à l'autre gare et tout cela en analogique avec ce truc ? Comme en numérique donc ?
-
Il y a deux partie distinctes.
La première à réaliser est l'alimentation de la locomotive, ce que fait un décodeur de locomotive en numérique. La différence principale est qu'en analogique, c'est le canton qui est alimenté et non la locomotive. La locomotive change donc d'alimentation au fur et à mesure de son parcours.
Il y a deux façons de faire :
- avoir une collection d'alimentations centralisées, autant que tu veux avoir de locomotive en fonctionnement sur le réseau. Une série de relai permet de connecter chacune de ces alimentation a un ou plusieurs cantons.
- avoir une alimentation par canton sans relais pour l'y connecter.
Dans le premier cas, il y a énormément de câblage et la régulation de vitesse n'est probablement pas possible. Dans le second cas la regulation de vitesse est possible mais il faut que les PWM des alimentations soient synchronisées. Si on veut une marche régulière et de très bons ralentis, la seconde solution est la meilleure.
La 2ème partie est le suivi des convois sur les cantons. C'est la même problématique en analogique et en numérique. Habituellement c'est réalisé par un logiciel qui tourne sur un PC. Il y a deux parties dans cette partie : la sécurité c'est a dire éviter que les trains n'entrent en collisions via un bloc automatique. Le routage des trains pour automatiser la circulation. C'est a gérer de manière centralisée sur un Arduino dédié.
Mais ou, une fois tout cela en place, on peut piloter un réseau analogique comme un numérique.
Concernant SyncPWM, j'en suis l'auteur. C'est une des briques de base de la seconde solution.
-
Très intéressant ce truc comme je pensais.
La 1ère solution est vraiment compliqué : c'est sur que ce n'est pas une taille de lopette mais chalindrais en est un exemple.
Je garde cela sous le coude ;) ou le pied je sais pas
-
Il y a deux façons de faire :
- avoir une collection d'alimentations centralisées, autant que tu veux avoir de locomotive en fonctionnement sur le réseau. Une série de relai permet de connecter chacune de ces alimentation a un ou plusieurs cantons.
- avoir une alimentation par canton sans relais pour l'y connecter.
Dans le premier cas, il y a énormément de câblage et la régulation de vitesse n'est probablement pas possible.
Bonjour
Je ne vois pas pourquoi ce "n'est probablement pas possible" ? A priori je le fait sur mon réseau !
Pierre
-
Bonjour Pierre,
Pourrais-tu expliquer ce que tu fais sur ton réseau ?
-
Pourrais-tu expliquer ce que tu fais sur ton réseau ?
Je fonctionne au choix en analogique ou en digital. En analogique j'ai 4 sources PWM (128 pas) commandables par l'ordinateur, en digital une centrale commandable aussi par l'ordinateur.
L'ordinateur connait la position des trains (détection de présence dans les zones et cantons), des aiguilles (par le biais des itinéraires) et a des informations de détection ponctuelles pour les signaux.
Quand un train passe sur une détection ponctuelle, l'ordinateur connait l'état du signal, la vitesse du train (cran), si par exemple le signal est à l'avertissement l'ordinateur va envoyer des commandes à l'alimentation (analogique ou digitale) pour réduire progressivement la vitesse (cran) jusqu'a 30 km/h. Si le signal est fermé il arrive sur le détecteur ponctuel à 30 km/h et reçoit alors un ordre d'arret.
Voila c'est très classique.
Pierre
-
Bonjour Pierre.
Ok, je vois. Quand je parlais de régulation de vitesse, je parlais de mesurer la FCEM et de piloter la PWM par une loi de commande pour que la FCEM soit égale à une consigne. Dans ce contexte, je pense que réguler la vitesse est difficile car la longueur de fils entre les rails et l'alimentation traction nuit à la mesure de la FCEM.
-
Je reviens vers toi pour cette librairie. Je réfléchis un peu à un réseau. Deux questions pour toi :
peut-on augmenter au maximum la fréquence des PWM ? Sans cela, je serais dans l'impossibilité de gérer avec cette biblio. Au regard de ce que tu dis, oui mais différentiel ?
Si je comprends bien un peu le code, c'est que pour les arduinos de base avec un atmega je parle, pas de possibilité encore du due par exemple.
-
peut-on augmenter au maximum la fréquence des PWM ? Sans cela, je serais dans l'impossibilité de gérer avec cette biblio. Au regard de ce que tu dis, oui mais différentiel ?
Oui. On peut augmenter la fréquence de la PWM au maximum. Le signal de synchro sera à la même fréquence et donc il est préférable de le diffuser en différentiel. Le faire avec un MCP2551 est un peu coûteux. Il existe des drivers différentiels et des récepteurs moins coûteux (UA9638 et UA9637)
Si je comprends bien un peu le code, c'est que pour les arduinos de base avec un atmega je parle, pas de possibilité encore du due par exemple.
Je pense que tu parles du contrôleur central. Pour l'instant je n'ai pas fait l'émission de la synchro sur un Due mais je pense que ça se fait facilement et je le ferai.
-
Il faudra que tu nous expliques cela le truc différentiel. Un peu cher le mcp comme tu dis. Les autres c'est mieux.
Une autre question d'ailleurs, les arduinos sont aussi reliés par la masse ?
Si on reprend le truc, un arduino lambda uno ou mega ou mini pour le moment démarre le master clock sur la broche 3. Sont reliés ensuite d'autres arduino qui démarre le prog sync, crée un objet selon la biblio avec réception du signal sur la broche 8 et envoie le pwm sur la broche 3 en fonction d'un argument byte.
Chaque arduino mettant l'attribut byte qu'il veut d'où l'indépendance de chaque canton.
Le due n'est pas nécessaire pour le moment, je réfléchis à en prendre un vu son prix pas si différent d'un méga. Ca sera pour mon mini module en HOe.
-
Il faudra que tu nous expliques cela le truc différentiel. Un peu cher le mcp comme tu dis. Les autres c'est mieux.
http://fr.m.wikipedia.org/wiki/Signalisation_différentielle (http://fr.m.wikipedia.org/wiki/Signalisation_différentielle)
Une autre question d'ailleurs, les arduinos sont aussi reliés par la masse ?
Oui via l'alimentation. Mais il ne faut pas considérer que les masses sont identiques partout. Un fil long n'est pas une équipotentielle.
Si on reprend le truc, un arduino lambda uno ou mega ou mini pour le moment démarre le master clock sur la broche 3. Sont reliés ensuite d'autres arduino qui démarre le prog sync, crée un objet selon la biblio avec réception du signal sur la broche 8 et envoie le pwm sur la broche 3 en fonction d'un argument byte.
Chaque arduino mettant l'attribut byte qu'il veut d'où l'indépendance de chaque canton.
Oui c'est ça. Mais les valeurs de PWM appliquées sur chaque canton sont décidées par un Arduino maître qui connaît l'emplacement des trains via une rétro-signalisation.
Le due n'est pas nécessaire pour le moment, je réfléchis à en prendre un vu son prix pas si différent d'un méga. Ca sera pour mon mini module en HOe.
Le due me semble bien taillé pour jouer le rôle de l'Arduino maître.
-
Merci pour ces réponses.
C'était un raccourci pour la valeur des PWM.
Pour ce qui est du DUE, il va falloir d'abord que je puisse accéder à l'IDE 1.5.8 car à ce jour impossible de l'avoir sur aucun de mes ordis, en attente. Cela marchait sur un seul de mes ordis, mais le temps faisait, il ralentissait de plus en plus vu toutes les installations de prog que je faisais, et les versions devenant de plus en plus gourmandes j'ai réinstallé pour un truc plus light. Bref, je dois cogiter un peu...
A suivre
-
Finalement, la dernière version en stable qui remplace tout la 1.6 a résolu le pb sans intervention de ma part.
Plus qu'à commander le DUE.
-
Pour l'instant je fais des essais avec un moteur Graupner Speed 500E sans chercher à optimiser quoique ce soit. La seule chose que j'ai faite est de passer la fréquence de la PWM à 31,45kHz (d'après l'oscillo).
Le moteur est donc piloté avec une PWM à 31,45kHz.
Toutes les 10ms, la PWM est coupée et l'Arduino mesure la force contre électromotrice du moteur (FCEM). Quand un moteur tourne, il produit une tension, comme une dynamo de vélo, qui est proportionnelle à la vitesse de rotation. Pour cela, un montage à d'amplificateur opérationnel permet de la mesurer. Ça ramène une valeur entre 0 et 10V entre 0 et 5V et ça fonctionne avec des masses qui ne sont pas exactement les mêmes, elles peuvent différer de plusieurs volts.
L'Arduino effectue 6 mesures car la FCEM est très bruitée et les trie. Les deux extrêmes sont éliminés et une moyenne des 4 centrales est effectuée.
J'ai mis en œuvre un asservissement de vitesse du moteur avec un régulateur PI (j'utilise asservissement plutôt que régulation pour ne pas confondre). PI pour Proportionnel Intégral. La consigne est la FCEM à atteindre. En soustrayant la FCEM mesurée à la consigne, on calcule une erreur. Cette erreur est multipliée par une constante qu'il faut régler : le gain proportionnel. On calcule également la somme des erreurs ce qui donne l'intégrale de l'erreur. Cette intégrale est également multipliée par un gain. La PWM est donc calculée comme suit (ici on divise par l'inverse du gain intégral) :
int erreur = consigneVitesse - fcem;
cumulErreur += erreur;
pwm = erreur * gainProportionnel + cumulErreur / inverseGainIntegral;
La PWM est ensuite relancée avec la nouvelle valeur.
Pour l'instant l'électronique est un peu crade. L'ampli op est alimenté directement par la tension qui alimente le MOSFET et elle est très bruitée. Mais ça marche quand même :)
-
J'ai fait une vidéo, je vous mets ça en ligne dès que possible.
-
Voici la vidéo avec une petite BR64 au ralenti. L'ovale d'essai est incliné comme on peut le voir sur la 2e moitié de la vidéo via l'absence de parallélisme entre les joints du carrelage et le rebord. La loco descend donc au début puis remonte la pente de l'autre côté de l'ovale.
https://dl.dropboxusercontent.com/u/67740546/ralenti.m4v
-
Bonjour,
Le github pour SyncPWM qui remplace la version postée ici en pièce jointe :
https://github.com/Koryphon/SyncPWM
-
Bonjour,
J'ai avancé sur la carte d'alimentation de canton version Arduino. Les composants tiennent sur une carte 10x10 avec un Arduino Nano aux commandes. J'ai testé sur breadboard la mesure de vitesse, l'asservissement de vitesse et la détection. Le CAN a été testé par ailleurs. Le reste attendra la carte car ça devient compliqué sur breadboard :)
J'ai disposé un certains nombre de pastilles sur les signaux entre l'électronique et l'Arduino pour mettre des sondes et voir ce qui se passe.
Voici l'implantation des composants :
(https://dl.dropboxusercontent.com/u/67740546/AlimTraction/AlimTraction.plc.png)
Le cuivre côté composants :
(https://dl.dropboxusercontent.com/u/67740546/AlimTraction/AlimTraction.cmp.png)
Le cuivre côté cuivre :
(https://dl.dropboxusercontent.com/u/67740546/AlimTraction/AlimTraction.sol.png)
C'est compliqué mais ça fait également la détection et ça gère un canton double sens avec zone d'arrêt. C'est également une alimentation « One step beyond » car, à ma connaissance, il n'existe pas d'alimentation avec asservissement et synchronisation entre les cantons (L'alimentation avec asservissement de l'AMFN semble être monolithique). Les systèmes comme Driving Railways, LadyBug ou UTS utilisent de la tension hachée basse fréquence sans asservissement.
-
Je trouve le principe très bien pensé. Félicitations!!!
Petites questions :
1) Comment se fait la détection? Uniquement via la mesure de la FCEM ou y a t-il autre chose qui permet de détecter la machine?
2) Si je comprends bien, tu mesures la FCEM pour en déduire la vitesse de la locomotive. Cela marche ben avec des locomotives analogiques, mais cela marche t-il aussi avec des locomotives équipées de décodeurs?
3) Quel logiciel utilises tu pour faire tes typons?
4) qu'appelles tu une alimentation "one step beyond"? Je ne trouve pas d'article sur le net expliquant ce que c'est...
-
Je trouve le principe très bien pensé. Félicitations!!!
Merci :)
Petites questions :
1) Comment se fait la détection? Uniquement via la mesure de la FCEM ou y a t-il autre chose qui permet de détecter la machine?
Non car quand la machine est à l'arrêt la FCEM est nulle. La détection se fait via le système classique : une serie de diodes (ici 4 pour avoir une bonne sensibilité) quand un courant circule, on a une tension, qui est la somme des tensions de seuil des diodes en série, qui sert à saturer un transistor. Quand le courant ne circule pas, le transistor est bloqué. Ça permet de détecter une résistance de plus de 68kΩ ce qui correspond à des essieux de wagons pas très bien graphités.
2) Si je comprends bien, tu mesures la FCEM pour en déduire la vitesse de la locomotive. Cela marche ben avec des locomotives analogiques, mais cela marche t-il aussi avec des locomotives équipées de décodeurs?
Probablement pas. Le décodeur étant intercalé entre la voie et le moteur, la FCEM ne doit pas être visible.
3) Quel logiciel utilises tu pour faire tes typons?
Canari (http://canari.rts-software.org) (Mac OS X), développé par un collègue.
4) qu'appelles tu une alimentation "one step beyond"? Je ne trouve pas d'article sur le net expliquant ce que c'est...
C'était juste pour dire que ça va au delà de ce qui se fait habituellement. Ce n'est pas un terme consacré ;)
-
Merci pour le logiciel, je n'en avais jamais entendu parler avant! J'utilisais Cidess, mais sous mac, j'étais obligé d'utiliser wineskin pour l'installer, ce qui provoquait quelques bugs supplémentaires...
-
...Une première chose à faire est de synchroniser les PWM de tous les cantons. En effet, si les PWM ne sont pas synchrones, une locomotive à cheval sur 2 cantons recevra une impulsion plus longue et verra sa vitesse modifiée tant qu'elle est à cheval. Elle fera donc potentiellement un petit bond à chaque passage d'un canton au suivant...
Bonjour Jean-Luc,
Je suis interpellé par la synchronisation des PWM des cantons. Avec une fréquence de 1 KHz et l'effet passe-bas des moteurs, est-ce vraiment indispensable ?
Meilleures salutations.
Marc-Henri
-
Bonjour Marc-Henri
Une synchronisation est nécessaire. Sinon, les PWM peuvent se trouver carrément en opposition de phase. Même un déphasage pas très important se traduit par une accélération de la machine quand elle passe d'un canton a l'autre :
(http://modelleisenbahn.triskell.org/IMG/png/synchro.png)
La PWM est à 32kHz
Amicalement
-
Je dirais même CRC / acquittement et re-émission
Je me suis posé ces questions pour la liaison sans fil entre le TCO et le réseau. J'envisageais de placer les ordres envoyés dans une file et d'attendre la confirmation pour les en retirer. J'avais regardé la lib. QueueArray (http://playground.arduino.cc/Code/QueueArray) à cette fin.
Mais je vais me focaliser sur l'alim PWM dans un premier temps, pour des questions pratiques (le vieux transfo n'est pas très précis).
La fréquence de la PWM est d'un peu moins d'1kHz. l'erreur maxi entre 2 PWM, du moins ce que j'ai pu mesurer à l'oscillo, est d'environ 8µs. Les valeurs possibles pour la PWM vont de 0 à 254.
Sur la base de tes articles, je partais une PWM de 32kHz (la fréquence native du Timer2 d'un Uno). Comme je ne compte pas cantonner (le réseau est petit, 1,6 * 0,7m), je vais rester sur 1 seule source.
Par contre comment gères-tu l'étage de puissance, avec des MOSFET ou un pont en H ? J'ai l'impression que les ponts commutent suffisamment vite pour suivre la fréquence de la PWM.
Sinon, faut-il supprimer les condos et les selfs sur les locos analogiques ? Je partais du principe que oui, vu qu'il faut le faire lors d'une digitalisation...
[Edit: en train de voir ton autre fil dans "Shields et Modules" ; donc MOSFET, et parfois oui, parfois non...]
-
Merci Jean-Luc pour l'explication relative à la synchro PWM.
J'ai regardé en détail ta bibliothèque SynchroPWM et le principe me paraît clair. 2 lectures successives de la PWM envoyée par le maître sont effectuées à chaque interruption et cela permet de déterminer si on est en retard ou en avance. Seule une transition dans le même sens que celle qui a généré l'interruption du timer est considérée comme synchrone. Il y a alors un décalage égal à la période de l'horloge du timer.
Ce qui n'est par contre pas clair pour moi, c'est pourquoi tu n'utilises pas la même interruption avec les Atmega168/328 (timer compare) qu'avec l'Atmega32U (timer overflow). Je suppose que ce n'est pas exactement le même mode PWM qui est utilisé selon le processeur ?
Meilleures salutations.
Marc-Henri
-
Par contre comment gères-tu l'étage de puissance, avec des MOSFET ou un pont en H ? J'ai l'impression que les ponts commutent suffisamment vite pour suivre la fréquence de la PWM.
MOSFET car l'inversion de marche est faite via un ou des relais.
Sinon, faut-il supprimer les condos et les selfs sur les locos analogiques ? Je partais du principe que oui, vu qu'il faut le faire lors d'une digitalisation...
Condos oui, impératif. Selfs non
-
Ce qui n'est par contre pas clair pour moi, c'est pourquoi tu n'utilises pas la même interruption avec les Atmega168/328 (timer compare) qu'avec l'Atmega32U (timer overflow). Je suppose que ce n'est pas exactement le même mode PWM qui est utilisé selon le processeur ?
héé ééé ben peut-être parce que je me suis planté. Faut que je regarde mais de mémoire j'ai testé avec un 328 en maître et un 32u4 en esclave et ça marchait. Il est également possible que dans le mode où la PWM est programmé overflow == compare étant donné que le TOP du compteur est COMPA. À voir
-
Bonsoir Jean-Luc,
J'ai finalement mis plus de temps à comprendre le code de SyncPWM, mais c'est ok maintenant. Pour les 168/328, la synchro se fait sur output compare A qui déclenche l'interruption et la génération du fast PWM se fait sur output compare B qui change directement la sortie OC correspondante (sans interruption).
Je pense que ton commentaire relatif au 32 où output compare == overflow est correct.
Je vais voir si l'Attiny 2313 a les mêmes capacités pour fonctionner en fast PWM esclave.
Bonne fin de semaine & meilleures salutations.
Marc-Henri
-
Bonjour à tous,
Je reviens sur la description de l'asservissement de vitesse par mesure de la force électromotrice décrit par Jean-Luc.
Je serais intéressé par quelques compléments d'information sur l'étape d'amplification à ampli op.- Quelle est la valeur brute typique de la tension mesurée à l'entrée ?
- Comment les ampli ops gèrent-ils les écarts de masse ? J'avoue ne pas être des plus à l'aise avec les questions de masses pouvant être différentes !
- La tension de sortie est-elle limitée avant d'attaquer l'entrée du convertisseur AD ?
- Est-il possible de voir le schéma de cette partie ?
Par ailleurs, combien de temps dure l'interruption de la PWM qui survient toutes les 10 ms ? J'imagine que c'est plutôt court !
Encore un grand merci pour ces échanges très instructifs.
-
Bonjour,
Je recolle au peloton après une longue période d'occupation professionnelle intense.
Quelle est la valeur brute typique de la tension mesurée à l'entrée ?
Sur une loco H0, ça peut monter à 10V
Comment les ampli ops gèrent-ils les écarts de masse ? J'avoue ne pas être des plus à l'aise avec les questions de masses pouvant être différentes !
La mesure est différentielle donc les écarts de masse ne gênent pas.
La tension de sortie est-elle limitée avant d'attaquer l'entrée du convertisseur AD ?
Oui, il y a deux diodes 1N4148 qui empêchent la tension de sortie d'être > 5V et < 0V.
Est-il possible de voir le schéma de cette partie ?
Bien sûr. Je l'ajoute ici même dès ce soir
-
Bonsoir,
Voici les schémas : https://dl.dropboxusercontent.com/u/67740546/AlimTraction/AlimentationTraction.pdf
-
Merci beaucoup Jean-Luc pour ces précisions et le schéma.
Bon dimanche et meilleures salutations.
Marc-Henri
-
Bonjour Jean Luc,
Nouveau sur le forum que je parcours avec grand intérêt je serai preneur d'information sur l'alimentation traction canton analogique.
Vous nous proposez gentiment un lien via dropbox. Seulement il ne fonctionne plus.
Y a t il un endroit ou un lien qui permettrait de le visualiser svp?
Merci beaucoup
-
Bonsoir Pierre
Dropbox a poignardé ses utilisateurs dans le dos en rendant privé le dossier public.
Voici un autre lien : http://www.locoduino.org/pic/AlimentationTraction.pdf
Cordialement
-
Jean Luc bonsoir,
je voulais savoir à propos de ta librairie, il est possible d'envoyer l'info de synchro à tous les arduinos par wifi ou RJ 45? et est ce que ça marche avec la wemos D1 ?
Ps: le premier lien , avec ta librairie, ne marche plus, tu peux me la faire parvenir
STP ,
Merci
-
Bonsoir
Je ne pense pas que l’envoyer par wifi ou par ethernet, via UDP par exemple, soit faisable. Non seulement il y a trop de latence mais de plus cette latence varie énormément.
Dans ce que j’ai fait un signal carré à la fréquence de la PWM est envoyé en filaire.
Par ailleurs, pour recaler la PWM du wemos D1, il va falloir rentrer dans le code pour voir comment cette PWM logicielle est engendrée et modifier le code.
-
J’ai regardé le code de Jean-Luc, il est écrit pour les processeurs Atmel ATMega 328 et 2560 ou 32U4 uniquement. Les structures internes des autres processeurs étant complètement différentes, il faut réécrire un nouveau code.
-
snif
-
En fait, je ne comprends pas trop le parti pris de ton projet.
Pourquoi s'embêter à mettre des PWM sur les voies quand il y a suffisamment de place dans la loco pour y mettre l'ESP et le pont en H. Sur les voies, il y a juste la détection de présence à mettre
-
Bonjour Jean Luc,
Je suis en train de finaliser mon projet de canton analogique. J'ai 17 cantons à synchroniser. J'utilise un LMD 18200 pour les alimentations des voies.
J'ai deux questions:
1- je ne comprends pas bien l'utilisation de la synchronisation des PWM. Un arduino maitre pour la générer ok. Mais ensuite? la sortie PWM est elle cablée en parallèle une sortie raccordée à 17 entrées ou en série la sortie sur le premier canton puis du premier vers le deuxième etc..? ou autre solution?
2- en page deux de la discussion en mars 2015 vous proposez des shémas de carte et d'implantation des composants. Ils ne sont pas lisible dans le fils de la discussion. Je ne les retrouve pas dans le lien dropbox qui fonctionne. Auriez vous la gentillesse de les proposer sur un lien qui fonctionne?
merci à vous
Pierre
-
Bonjour,
(je ne suis pas très réactif en ce moment)
La synchronisation des PWM suppose qu'il y a plusieurs Arduino qui génèrent une PWM, un par canton en fait (comme l'indique le titre du fil).
Si vous considérez deux cantons adjacents, chacun alimenté par un Arduino différent, il n'y a aucune raison pour que les PWM des deux Arduino soient synchrones. Même si elles ont la même valeur, elle seront déphasées et ce déphasage change assez rapidement au cours du temps.
Par conséquent, une locomotive qui passerait d'un canton à l'autre verrait une PWM de durée plus importante comme explicité dans le schéma ci-dessous
(https://modelleisenbahn.triskell.org/local/cache-vignettes/L429xH149/synchro-7268b.png?1393496303)
Voici l'implantation des composants :
(https://www.locoduino.org/pic/AlimTraction/AlimTraction.plc.png)
Le cuivre côté composants :
(https://www.locoduino.org/pic/AlimTraction/AlimTraction.cmp.png)
Le cuivre côté cuivre :
(https://www.locoduino.org/pic/AlimTraction/AlimTraction.sol.png)
Les schémas :
https://www.locoduino.org/pic/AlimTraction/AlimentationTraction.pdf (https://www.locoduino.org/pic/AlimTraction/AlimentationTraction.pdf)
-
Bonjour Jean-Luc,
Ce fil est passionnant et contient énormément d'éléments. Mais la complexité du sujet fait quand même peur et il faudra certainement y aller doucement et "réinventer" en partie, refaire le chemin.
Objectif 1 : un premier montage qui me permette d-obtenir un signal tension représentatif de la FCEM.
Et pour cela, lui fournir les bonnes mesures comme expliqué : la moyenne de quatre sur 6, les extrêmes étant éliminées.
Pour éviter de tâtonner sur ce point là... trouver la durée de l'interruption de PWM, l'intervalle de temps entre chacune des 6 mesures etc (puisque dans le fil la seule donnée disponible est la fréquence de l'échantillonnage tous les 10us) serait-il possible d'avoir... carrément !... le bout de code qui permet d'obtenir ces valeurs ?
En vous remerciant par avance ?
Bien cordialement
Philippe
-
Bonjour,
Il y a mieux que ça, le code est ici : https://framagit.org/locoduino.org/AlimentationTraction.
Je ne peux pas t'envoyer une carte en ce moment, ma poste est fermée.
Cordialement
-
Bonjour Jean-Luc,
Merci pour la réponse et le lien ! (chic du travail qui rentre... )
Pour ce qui est de la carte :
Je ne peux pas t'envoyer une carte en ce moment, ma poste est fermée.
... je lis que ça sera donc possible "après" ? Un grand merci d'avance, voilà certainement beaucoup de temps et de composants épargnés !! Je n'aurai "plus qu'à" trouver comme résoudre mon cas particulier évoqué en MP : ayant choisi de ne pas polariser les cantons au moyen de relais inverseurs mais via des ponts H, il me faudra mesurer une FCEM polarisée !
Bien cordialement
Philippe
-
Bonjour Jean-Luc,
Désolé de vous solliciter : j'ai commencé à prendre en main le croquis "AlimentationTraction" (très formateur !) que je vais expérimenter par tranches mais je voulais vous signaler une difficulté.
Pour commencer j'ai trouvé votre librairie : https://framagit.org/locoduino.org/CommandInterpreter
mais qui étrangement provoque cette erreur :
"class CommandInterpreter' has no member named 'readUnsignedLong'; did you mean 'readUnsignedInt'?" ;
Par similitude avec l'existant, j'ai donc tenté d'ajouter dans le CommandInterpreter.h cette ligne :
bool readUnsignedLong(unsigned long& result);et dans le .cpp la fonction bool CommandInterpreter::readUnsignedLong(unsigned long& result)
{
char **endChar;
char *arg = mBuffer.getArg();
if (! isANumber(arg)) return false;
long longResult = strtol(arg, endChar, 0);
if (**endChar != '\0' || longResult < 0 || longResult > 65535) return false;
else {
result = (unsigned long)longResult;
return true;
}
}
Ceci m'a permis de compiler (mais pas d'affirmer que le code ainsi bricolé fonctionne...)
J'espère ne pas être hors du sujet de ce fil, dans ce cas j'effacerai ce message, mais que mon retour d'expérience puisse servir.
Bien cordialement
Philippe
-
Bonjour Philippe,
Effectivement il y avait du code non comité sur mon disque. C'est poussé sur framasoft
Bien cordialement
-
Bonjour à tous
Je crains d'avoir raté le train...
Je suis en LGB analogique, j"ai évalué Driving Railway... j'ai tenté Chenevez il y a 50 ans...
Bref... un Arduino par canton et un réseau Can me semble être la solution... mais sans créer une usine à gaz !
Càd pas de PWM... une tension continue "propre" par canton : la pièce manquante.
Pour le reste, l'Arduino du canton peut tout faire
Quelqu'un a-t'il une suggestion ?
Cordialement
Roland
PS: sinon c'est l'arbre à relais et de bons gros transfo LGB
Pour l'nstant c'est un switch par canton "à l'américaine"
-
Ne connaissant pas la contrainte sur le PWM, on peut juste suggérer de lisser ce PWM avec une constante de temps bien supérieure aux 550 Hz (si c'est celle utilisée), pour obtenir une tension continue "propre" et piloter avec celle-ci une alimentation programmable linéaire.
-
Bonjour Jean Luc
J'essaie d'utiliser la bibliothèque SyncPWM. Sur les cartes cantons esclaves arduino nano j'ai inclus les deux lignes
#include <SyncPWM.h>
SyncPWM pwmsynchro;
et ces deux là dans le setup
pwmsynchro.begin(6); // Start a synchronized PWM with sync on pin 6
pwmsynchro.analogWrite(30);
à la compilation j'ai ce message d'erreur:
Arduino : 1.8.13 (Mac OS X), Carte : "Arduino Nano, ATmega328P (Old Bootloader)"
In file included from /Users/Pierre/Library/Arduino15/packages/arduino/tools/avr-gcc/7.3.0-atmel3.6.1-arduino7/avr/include/avr/io.h:99:0,
from /Users/Pierre/Library/Arduino15/packages/arduino/tools/avr-gcc/7.3.0-atmel3.6.1-arduino7/avr/include/avr/pgmspace.h:90,
from /Users/Pierre/Library/Arduino15/packages/arduino/hardware/avr/1.8.3/cores/arduino/Arduino.h:28,
from /Users/Pierre/Documents/Arduino/libraries/SyncPWM-master/SyncPWM.h:24,
from /Users/Pierre/Documents/Arduino/libraries/SyncPWM-master/SyncPWM.cpp:24:
/Users/Pierre/Documents/Arduino/libraries/SyncPWM-master/SyncPWM.cpp:123:29: error: stray '$' in program
TIMSK2 = _BV(OCIE2A=$);
^
/Users/Pierre/Documents/Arduino/libraries/SyncPWM-master/SyncPWM.cpp: In member function 'void SyncPWM::begin(byte)':
/Users/Pierre/Documents/Arduino/libraries/SyncPWM-master/SyncPWM.cpp:123:18: error: expected primary-expression before ')' token
TIMSK2 = _BV(OCIE2A=$);
^
exit status 1
Erreur de compilation pour la carte Arduino Nano
Et là j'avoue que cela dépasse mes compétences.
Ai je oublié d'inclure une bibliothèque?
Dans la bibliothèque avr je n'ai pas de io.h et dans pgmspace.h il n'y a pas de ligne 99 cela s'arrête à la ligne 44
-
Bonjour Pierre
Sans doute une faute de frappe de ma part. Je venais de tester avec l'ATMega32u4 et je suis passé à côté.
Retirez le =$ ligne 123 de manière à ce que vous ayez :
TIMSK2 = _BV(OCIE2A);
Dites moi si c'est ok;
-
Merci pour cette réponse rapide.
J'ai fait la modification indiquée et cela compile parfaitement et sur le maitre et sur l'esclave.
Parfait et bravo.
Cordialement
Pierre
-
bonsoir Jean Luc,
Après avoir utiliser la bibliothéque PWM Freq qui fonctionne parfaitement, barvo, j'essaye toujours d'intégrer Syncpwm à mes programmes de cartes canton bâties autour d'un arduino nano et d'un LMD 18200. J'ai lu que les deux bibliothèques sont incompatibles j'en ai tenu compte.
J'ai compris qu'il fallait un arduino maitre sur lequel j'installe le programme Masterclock comme cité dans les exemples.
Je récupère une horloge maitresse sur la pin 3 de cet arduino maitre.
J'ai 17 cartes cantons. J'envoie l'horloge maitresse par 17 fils en parallèles sur la broche 8.
Je récupère la PWM de chaque carte canton esclave sur la pin 3 et c'est elle que je connecte au LMD18200.
J'ai fait l'essai avec un arduino maitre n'ayant que le programme master clock téléchargé.
Constat: je ne peux pas régler la vitesse. Je suis toujours à vitesse max.
Question 1 :ai je bien compris le câblage?
Question 2: cet arduino maitre peut il être une des cartes cantons?
Question 3 : que fais je de mal pour ne plus pouvoir régler la vitesse?
Question 4: mes cartes sont malheureusement déjà cablées avec la pwm entre arduino et le LMD18200 sur la broche 11 compatible comme la broche 3 avec le timer 2. Pour pouvoir utiliser la broche 11 au lieu de la 3 pour la PWM suffit il de changer dans Syncpwm.cpp en lignes 59 et 86 le chiffre 3 par 11? Cela a t il une influence sur la pin de sortie de la masterclock?
Question 5: pour récupérer l'horloge maitresse sur la pin 6 au lieu de la pin 8 suffit il d'écrire pwm.begin(6)?
Beaucoup de questions en fait
Merci par avance
Bien cordialement
Pierre
-
Bonjour Pierre
Constat: je ne peux pas régler la vitesse. Je suis toujours à vitesse max.
Que faites vous pour régler la vitesse ?
Question 2: cet arduino maitre peut il être une des cartes cantons?
Non
Question 3 : que fais je de mal pour ne plus pouvoir régler la vitesse?
Je ne sais pas car je n'ai pas compris exactement comment vous vous y prenez
Question 4: mes cartes sont malheureusement déjà cablées avec la pwm entre arduino et le LMD18200 sur la broche 11 compatible comme la broche 3 avec le timer 2. Pour pouvoir utiliser la broche 11 au lieu de la 3 pour la PWM suffit il de changer dans Syncpwm.cpp en lignes 59 et 86 le chiffre 3 par 11?
Non. Il faut changer le code de SyncPWM::startPWM, de SyncPWM::analogWrite et de l'ISR. Actuellement OCR2A est utilisé pour maintenir le timer synchrone et OCR2B sert pour la PWM. Il faudrait échanger les deux.
Cela a t il une influence sur la pin de sortie de la masterclock?
Oui puisque SyncPWM::beginMasterClock appelle startPWM
Question 5: pour récupérer l'horloge maitresse sur la pin 6 au lieu de la pin 8 suffit il d'écrire pwm.begin(6)?
Oui
Cordialement
-
Bonjour Jean Luc,
Merci pour cette réponse rapide.
Pour la vitesse j'utilise un potentiomètre de 10kohms sur la broche A6 et le programme suivant:
void potreglagevitesse ()
{
Serial.println("lecture réglage potentiomètre");
mesure_potreglage = analogRead(pot_reglage); // lecture de la valeur du potar réglage valeur max de la pwm
valeurmaxpwm = map(mesure_potreglage,0,1023,0,255); // transfert de cette valeur en valeur correspondant à celle le la pwm
vitesse = valeurmaxpwm;
analogWrite (PWM, vitesse);
}
Pour le câblage ai je bien compris?
Bien cordialement
-
Sur l'Arduino qui envoie la clock ?
-
Non sur les arduino canton. Sur l'arduino qui envoie le clock je n'ai mis que le programme master clock et rien d'autre
#include <SyncPWM.h>
SyncPWM sp;
void setup() {
sp.beginMasterClock(); // start a master clock on PWM pin 3 on Uno/Nano
// pin 6 on a Leonardo
}
void loop() {
}
-
Ok.
Le premier problème que je vois est que il devrait y avoir un objet SyncPWM du côté du sketch des Arduino de canton également. Vous pouvez me mettre le sketch complet ?
-
désolé c'est un peu long. Je joins le setup et le loop. Il y a aussi plusieurs fonctions. Je compte ouvrir un projet sur le forum dés que j'aurai réussi cette intégration.
// déclaration des variables
#include <SyncPWM.h>
SyncPWM pwmsynchro;
const int pot_inertie_ACC = A0; // Règle l'inertie a l'accélération
int val_inertie_ACC; // Variable pour lire la valeur de pot_inertie_acc
const int detecteur_en_ZA = A1; // Détecteur produisant un signal 0v
bool etat_ZA = true; // si un train est à l'arrêt en ZA true sinon false
const int detecteur_en_ZT = A2; // Détecteur produisant un signal 0v
bool etat_ZT = true; // si un train est à l'arrêt en ZA, il l'est aussi en ZT true sinon false
const int pot_reglage = A6; // potar pour régler la valeur max de la pwm et donc la vitesse
const int MarcheArret = A4; // Interrupteur marche arrêt
const int pot_inertie_FREIN = A5; // Règle l'inertie au freinage
int val_inertie_FREIN; // Variable pour lire la valeur de pot_inertie_frein
// A6 libre
// A7 libre
// LIBRE pour l'instant const int reglagevitesse = 2; // sur la pin 2 ou 3 exclusivement pour les interruption
const int led_feuxrouges = 4; // Led rouge si à l'arrët - Feu rouge
const int led_feuxoranges = A3; // Led orange si ralenti
const int led_feuxverts = 5; // Led verte si en marche - Feu vert
const int occup_canton_n1 = 13; // occupation du canton n1
const int occup_canton_n = 7; // occupation du cabton n
const int led_A_B = 8; // Led sens de A vers B
//N1 et N2 correspondent aux bornes d'un pont en H L298N sont remplacés par DIR et PWM
const int BRAKE = 9; // Utilisation de BRAKE pour l'arrêt et le démarrage
const int DIR = 10; // Utilisation du PWM pour la direction
const int PWM = 3; // changer en 3 pour test syncpwm// Utilisation du PWM pour la valeur de PWM moteur analogique
const int LedMarcheArret = 12;
bool EtatMarcheArret = false; // on initialise Etat marche arrêt sur arrêt
int vitesse;
int vitesseralenti; // pour la vitesse de ralenti
int vitessearret; //pour mise en route
int vitessetest = 200;
int vitessetestetape6 = 50;
int mesure_potreglage = 0; // valeur pour mesurer la valeur du potar de réglage de la valeur max de la pwm
int mesure_potreglageancien = 0;
int etatinterruption = LOW;
int valDIR = 0;
int valPWM = 0;
int valBRAKE = 0;
int valeurmaxpwm =0;
bool sens_A_vers_B; // vrai si sens gare A vers gare B
int compteur; // pour suivre dans le monniteur l'avancement du programme
int timer = 3000;
int etat_detecteuren_ZA; // mémorise l'état du détecteur utilisé dans les tests HIGH si le détecteur a été actif
int etat_detecteuren_ZT; // quand N1 est libre le mettre systématiquement à LOW car nous l'utilisons pour un test qui provoque le ralenti du train.
//Si n1 devient libre avant l'arrêt du train il faut réinitialiser cette variable
//*************************************************************
void setup()
{
pinMode (BRAKE, OUTPUT);
digitalWrite (BRAKE,HIGH);
pinMode (DIR,OUTPUT);
pinMode (PWM, OUTPUT);
digitalWrite (DIR,LOW);
digitalWrite (PWM,LOW);
pinMode (MarcheArret,INPUT);
pinMode (LedMarcheArret,OUTPUT);
digitalWrite (LedMarcheArret,HIGH);
EtatMarcheArret= digitalRead (MarcheArret);
while (EtatMarcheArret == LOW) // tant que le bouton marche arrêt n'est pas sur marche il ne se passe rien
{
EtatMarcheArret= digitalRead (MarcheArret);
}
// on passe l'état marche arrêt qui est devenu marche en ligne ci-dessus à arrêt pour mesurer plus tard le changement d'état du bouton marche arrêt
delay(300);
Serial.begin(9600);
digitalWrite (LedMarcheArret,LOW);
Serial.println("Etat Marche Arret");
Serial.println (EtatMarcheArret);
Serial.println( "demarrage du programme");
// Changement de fréquence du PWM
//TCCR1B &= 0xF8;
//TCCR1B |= B00000010;
pwmsynchro.begin(6); // Start a synchronized PWM with sync on pin 6
pwmsynchro.analogWrite(30);
pinMode (occup_canton_n, OUTPUT);
digitalWrite (occup_canton_n, HIGH); // LOW pour libre, HIGH pour occupé
pinMode (occup_canton_n1, INPUT);
pinMode (pot_inertie_ACC, INPUT);
pinMode (pot_inertie_FREIN, INPUT);
valDIR = digitalRead (DIR);
Serial.println ("valeur DIR =");
Serial.println (valDIR);
valPWM = analogRead (PWM);
Serial.println ("valeur PWM =");
Serial.println (valPWM);
pinMode (detecteur_en_ZA, INPUT);
pinMode (detecteur_en_ZT, INPUT);
pinMode (led_A_B,OUTPUT); // led de sens bicolore
digitalWrite (led_A_B,LOW);
pinMode (led_feuxrouges,OUTPUT);
digitalWrite (led_feuxrouges,HIGH);
pinMode (led_feuxverts,OUTPUT);
digitalWrite (led_feuxverts,LOW);
pinMode (led_feuxoranges,OUTPUT);
digitalWrite (led_feuxoranges,LOW);
analogWrite (vitesse,0); // initialisation de la vitesse à 0
//attachInterrupt (0,Marche_Arret,FALLING); // validation du changement de vitesse ( commandé par le potentiomètre vitesse)
// sur le réseau. mettre 0 si pin 2 et 1 si pin 3 V6 je change le nom de la fonction sans les ()
compteur =1;
etat_detecteuren_ZA = LOW; // ou = digitalRead (detecteur_en_ZA) mais le détecteur ne détecte pas si loco à l'arrêt
etat_detecteuren_ZT = LOW; //digitalRead (detecteur_en_ZT)
Serial.print ("test sur mise en route");
Serial.println ();
mise_en_route(); // cette fonction met les feux au rouge ou au vert et libère le brake pour que le LMD soit opérationnel
//potreglagevitesse ();
Serial.println("lecture réglage potentiomètre");
mesure_potreglage = analogRead(pot_reglage); // lecture de la valeur du potar réglage valeur max de la pwm
valeurmaxpwm = map(mesure_potreglage,0,1023,0,255); // transfert de cette valeur en valeur correspondant à celle le la pwm
Serial.print(valeurmaxpwm);
}
//*******************************************************
void loop()
{
delay (30);// lorsque qu'une carte n'est pas une Arduino ou une Genuino
Serial.print ("passage dans le loop");
Serial.println ();
Marche_Arret(); // arrêt d'urgence
digitalRead(occup_canton_n1);
Serial.print("occupation canton n1 = ");
Serial.println(digitalRead(occup_canton_n1));
digitalRead(occup_canton_n);
Serial.print("occupation canton n = ");
Serial.println(digitalRead(occup_canton_n));
Serial.print("vitesse ");
Serial.println (vitesse);
Serial.print("lecture réglage potentiomètre");
mesure_potreglage = analogRead(pot_reglage); // lecture de la valeur du potar réglage valeur max de la pwm
valeurmaxpwm = map(mesure_potreglage,0,1023,0,255); // transfert de cette valeur en valeur correspondant à celle le la pwm
Serial.print("vitesse début loop ");
Serial.println(vitesse);
analogWrite(PWM,vitesse); // c'est celui ci qui me redonne la vitesse en fin étape 4 à l'initialisation
detection();
}
-
Ok
Donc votre PWM il faut la régler avec
pwmsynchro.analogWrite(vitesse);
Partout
Si vous utilisez le analogWrite qui vient avec le logiciel Arduino, vous cassez la synchro (Je suppose, j'ai pas regardé ce que ça fait)
-
Quelques conseils :) :
1 - Indentez proprement votre programme, tout doit être bien aligné et bien mis en page. C'est sans effort : vous avez une commande « Formattage automatique » dans le menu outils de l'IDE.
2 - faites des fonctions par thème :
initialiseFeux
initialiseDetection
etc
et appelez les dans setup
Une fonction doit tenir sur l'écran sans avoir à scroller, ça permet de la comprendre en un coup d'œil ;)
-
Merci beaucoup je vais essayer avec pwmsynchro.analogWrite(vitesse);
et merci pour les conseils
Bien cordialement
Pierre
-
Bonjour Jean-Luc,
... j'aurais besoin d'un coup de pouce siouplé...
Dans la laborieuse mise au point de mon asservissement de vitesse et pour m'éviter un téléversement chaque fois que je bouge un paramètre, j'aimerais utiliser la librairie CommandInterpreter et juste adapter les moniteur.cpp moniteur.h de votre code AlimentationTraction. Or lorsque je charge ce dernier, autant les "strings" sont acceptés sans souci, autant je n'arrive pas à passer un "int". J'ai essayé des tas de syntaxe, dont la plus évidente (par exemple : gi 20)... rien à faire. La lecture de la valeur est OK, les messages d'instruction OK, mais la modif de la valeur... non.
La solution est bien sûr dans la librairie elle-même... mais le code est hélas trop abscons pour mon niveau ! Pouvez vous me dire ce qu'il faut écrire ?
Grand merci par avance