Messages

1006

Le logiciel DCC++ / Re : Re : DCC++ BaseStation

« le: mars 09, 2016, 02:19:38 pm »

Au delà de la bonne utilisation ou non des structures, j'ai moi aussi jeté un oeil sur le code et je dois dire que c'est bien écrit, clair et très documenté. Il y a de très bonnes idées, mais il reste une syntaxe dans DCCpp_Uno.ino que je n'ai pas comprise (ligne 443) :

  if(R.currentReg->activePacket->buf[R.currentBit/8] & R.bitMask[R.currentBit%8]){
    OCR ## N ## A=DCC_ONE_BIT_TOTAL_DURATION_TIMER ## N;
    OCR ## N ## B=DCC_ONE_BIT_PULSE_DURATION_TIMER ## N;
  } else{ /* ELSE it is a ZERO */
    OCR ## N ## A=DCC_ZERO_BIT_TOTAL_DURATION_TIMER ## N;
    OCR ## N ## B=DCC_ZERO_BIT_PULSE_DURATION_TIMER ## N;
} /* END-ELSE */

est-ce que ## est un opérateur ?? J'avoue que je sèche.
A part ça, j'ai commencé à extraire la partie DCC de son code et je vais tenter (à mon rythme, donc pas trop vite...) de le comparer en terme de mémoire consommée à cmrdArduino.
La partie reconnaissance du ACK est aussi très intéressante. Il semble que le LMD18200 ait sa broche 8 qui permette de vérifier la consommation de courant instantannée, comme les broches 1 et 15 du L298N qu'emploie Gregg . A creuser.
Pour ce qui est du prix de son montage, il faut voir les contraintes qu'il s'est imposé, c'est à dire aucune sourude, auncun composant autre que l'Arduino et le shield L298N (plutôt couteux) au dessus... Pour le prix de ce shield, on peut utiliser deux LMD18200 qui rempliront le même rôle !

J'ai toujours trouvé mystérieuse cette mesure de courant dans les hacheurs 4Q. Qu'est-ce qu'on mesure quand la tension s'inverse toutes les 1/2 périodes ? Surtout quand la mesure est prise n'importe quand !

J'ai tenté d'utiliser la mesure du courant du LMD18200 en reliant la sortie C/S sur une entrée analogique de l'Arduino, en moyennant des dizaines voire des centaines de mesures et j'avoue que ce n'est pas convainquant !
Là dans DCC++, il fait une mesure de courant toutes les 10 ms (pourquoi pas à chaque loop ?), puis il pratique un "lissage exponentiel" qui prend du temps calcul, c'est le moins qu'on puisse dire.

Je ne suis toujours pas convaincu !

Finalement la solution fiable que j'ai trouvée est extrêmement simple et peu couteuse :



Un MAX471 que l'on trouve sous forme de petit BoB sur eBay est monté en série avec l'alim 12/15v du LMD18200.
Ce Max 471 peut mesurer des courants de 0 à 3 A avec une sortie en tension de 1 volt/ampère.

Pour de plus gros ampèrages, il y a l'ACS712T qui monte jusqu'à 5 A.

Là la mesure est très fiable avec un seul Analogwrite.
Je m'en sers évidemment pour la mesure de court-circuit et c'est une merveille !

Reste maintenant à l'appliquer au retour des commandes de programmation.


J'ai ajouté la recette à mon article Comment piloter trains et accessoires en DCC avec un Arduino (3)
http://www.locoduino.org/spip.php?article19.

1007

Le logiciel DCC++ / Re : Re : DCC++ BaseStation

« le: mars 09, 2016, 01:57:52 pm »

Si je voulais être caustique, je dirais « le droit de concourir à The International Obfuscated C Code Contest »  http://www.ioccc.org

Plus sérieusement, bien fait ça donne un code (légèrement) plus efficace tout en restant concis. Personnellement je n'aime pas. Il y a tellement de possibilités de se faire avoir par le préprocesseur qu'il ne vaut mieux pas s'y frotter de cette manière

Donc, qu'est-ce ça donne en clair ?

1008

Le logiciel DCC++ / Re : Re : DCC++ BaseStation

« le: mars 09, 2016, 01:39:57 pm »

mais il reste une syntaxe dans DCCpp_Uno.ino que je n'ai pas comprise (ligne 443) :

Code: [Sélectionner]

if(R.currentReg->activePacket->buf[R.currentBit/8] & R.bitMask[R.currentBit%8]){
  OCR ## N ## A=DCC_ONE_BIT_TOTAL_DURATION_TIMER ## N;
  OCR ## N ## B=DCC_ONE_BIT_PULSE_DURATION_TIMER ## N;
} else{ /* ELSE it is a ZERO */
  OCR ## N ## A=DCC_ZERO_BIT_TOTAL_DURATION_TIMER ## N;
  OCR ## N ## B=DCC_ZERO_BIT_PULSE_DURATION_TIMER ## N;
} /* END-ELSE */

est-ce que ## est un opérateur ?? J'avoue que je sèche.

C'est le token de concaténation de macros :

https://gcc.gnu.org/onlinedocs/cpp/Concatenation.html#Concatenation

Donc là, OCR, N, A sont des macros qui sont respectivement expansées et concaténées

DCC_ONE_BIT_TOTAL_DURATION_TIMER (ou DCC_ONE_BIT_PULSE_DURATION_TIMER) et N sont également expansées et concaténées

Le résultat repasse par le préprocesseur pour traitement et éventuelle réexpansion.

Comme je ne suis pas encore familier avec ce type de Macros concatenées ou expansées, j'aimerai bien comparer cette écriture au langage C classique sans Macros.

D'ailleurs, dans ce cas, qu'est-ce qu'on gagne avec les Macros ? (Au vin blanc ou à la moutarde ?)

1009

Modélisation, Architectures logicielles et matérielles / Re : Modélisation logicielle d'un réseau - le système de Jean-Luc

« le: mars 09, 2016, 12:30:34 pm »

Ça compile bien sur un Mega !

Pour le Due, je l'ai vu aussi. C'est probablement parce que ce n'est plus un AVR, mais un Sam, non ?
La classe Serial est différente.

1010

Le logiciel DCC++ / Re : DCC++ BaseStation

« le: mars 08, 2016, 10:51:55 pm »

Je n'ai pas résisté non plus à télécharger et essayer le "Controller" écrit en Processing, dont voici une image ci-dessous.

Mais Denis nous en dira plus sur cette partie ...

1011

Le logiciel DCC++ / Re : DCC++ BaseStation

« le: mars 08, 2016, 10:44:24 pm »

L'architecture a de quoi intéresser pas mal de monde :

• une station de base qui génère du DCC sur 2 voies (principales et programmation avec retour des acquittements), qui peut gérer des capteurs et des actionneurs, en bref un système presque complet sur un Mega, + une interface série (async, internet, ...) avec un protocole du type de celui de JMRI
• une plateforme de commande interactive basée sur Processing qui utilise ce protocole.

Le code est assez difficile à lire, il faut du temps. Le développeur doit être un expert. Il y a des tonnes de commentaires donc c'est bien ! Mais ses classes C++ ne sont que des structs ! Il perd le bénéfice des données et fonctions protégées.

La génération du DCC est du même type que celui de la première version présentée dans mon premier articles : http://www.locoduino.org/spip.php?article17.
Un ensemble de 12 tableaux de bits (sur 10 octets) contiennent des trames prêtes à émettre et une routine sous interruption émet les bits avec des timers. C'est différent de CMDRArduino.
A coté de cela il y a un module de préparation des trames (registres), gestionnaire des "files à émettre", à partir des commandes reçues par la liaison série.

Ce qui est assez simple, c'est que les commandes reçues sous forme de message texte sont directement traduites en série de bits placés dans un registre (le numéro de registre est même dans la commande, il faut donc faire attention !).

Ce qui fait que le programme LOOP ne fait pas grand chose d'autre que :

Code: [Sélectionner]

void loop(){
 
  SerialCommand::process();              // check for, and process, and new serial commands
 
  if(CurrentMonitor::checkTime()){      // if sufficient time has elapsed since last update, check current draw on Main and Program Tracks
    mainMonitor.check();
    progMonitor.check();
  }

  Sensor::check();    // check sensors for activate/de-activate
 
} // loop

Le logiciel semble couvrir toutes les fonctions de la NMRA (du moins c'est à vérifier)

Il y a un beau "parser" de commandes pour piloter la bête.

Il y a surtout, pour les anglophiles, un blog de 46 pages qui commence là :

http://www.trainboard.com/highball/index.php?threads/introducing-dcc-a-complete-open-source-dcc-station-and-interface.84800/

On y trouve des discussions sur tout un tas d'interfaces de puissances (sauf le LMD18200 mais y compris l'IBT2 à base de double BTS7960 pouvant délivrer 43 ampères). Apparemment on peut faire du DCC de 2 à 5 A avec plein de cartes (shield Arduino pour 2 moteurs, cartes Polulu, etc.. qui coûtent néanmoins plus cher que le LMD18200.

Il y a aussi des tas de discussions sur le logiciel (open source) et les interfaces avec JMRI et autres gestionnaires. C'est très riche.
On a l'impression que ça marche, vu les commentaires des internautes qui l'on mis en oeuvre.

a suivre ....

1012

Le logiciel DCC++ / Re : DCC++ BaseStation

« le: mars 08, 2016, 10:32:04 pm »

En fait ce n'est pas une bibliothèque, c'est carrément un système de pilotage de trains et accessoires en DCC.

Le premier document d'introduction (en anglais) est ici ->https://sites.google.com/site/dccppsite/

Sur le plan matériel, on a deux sous-ensemble :

• une station DCC composée d'un Arduino UNO ou MEGA sur laquelle on insère une carte moteur double (Motor Shield)
• un ordinateur dans lequel on lance une application Processing qui s'occupe de l'interface utilisateur. L'ordinateur et l'Arduino sont reliés ensemble, soit en liaison série (cable USB) soit en TCP/IP si on ajoute une carte ethernet ou WiFi.

On a donc 2 programmes :

• Un programme Arduino : DCCpp_UNO pour l'Arduino avec son extension 2 moteurs
• Un programme Processing : DCCpp_Controller pour le PC

Les liens de téléchargement sont là :

• BaseStation : https://github.com/DccPlusPlus/BaseStation
• Controller : https://github.com/DccPlusPlus/Controller
• Documentation d'installation du shield Pololu : https://github.com/DccPlusPlus/Documentation

J'avoue que j'ai tout de suite installé le programme DCCpp_UNO sur un MEGA (oui le nom du programme est plutôt mal choisi!!), compilé (il y a juste quelques Warnings sur lesquels on reviendra plus tard), le téléversement se passe bien et un message s'affiche sur le moniteur :

<iDCC++ BASE STATION FOR ARDUINO MEGA / ARDUINO MOTOR SHIELD: V-1.2.1+ / Mar  8 2016 21:43:55><N0: SERIAL>

D'après la documentation très complète qui est intégrée au programme, je vois que c'est la pin 12 du MEGA qui délivre le signal DCC. Je branche mon petit oscillo de poche et je vois ce signal immédiatement, avec des créneaux de 50 et 100 microsecondes environ (mon oscillo n'est pas très précis, mais cela suffit).

Donc ça marche !

A suivre...

1013

Modélisation, Architectures logicielles et matérielles / Re : Modélisation logicielle d'un réseau - le système de Jean-Luc

« le: mars 08, 2016, 06:41:51 pm »

Salut Jean-Luc,

Il y a un truc qui m'intéresserait : comment mettre des images dans le dossier www.locoduino.org/pic ?
C'est peut-être réservé à l'admin ?

En tout cas c'est mieux de pouvoir mettre les images au bon endroit dans le texte

Danke !
Dominique

1014

Shields et Modules / Re : Carte Servomoteurs DCC + CAN

« le: mars 02, 2016, 09:33:35 pm »

Tres jolie carte !
On va pouvoir s'échanger des expériences intéressantes 

Merci mille fois

1015

Vos projets / Re : Contrôle numérique des aiguillages

« le: février 21, 2016, 03:02:23 pm »

Bonjour,

Si cela peut t'intéresser, ou quelqu'un d'autre, j'ai réalisé mon contrôleur d'aiguilles (pour 20 aiguilles) à partir d'un Mega et 40 relais car j'ai des aiguilles Fleishmann Piccolo qui s'alimentent plutôt en alternatif (entre 12 et 15v)

J'ai réalisé le montage ci-dessous qui exclut que les 2 bobines soient alimentées en même temps. Cette tension alternative n'est présente que du coté des contacts mobiles des relais.

Cela me fait une belle platine à relais (5 barrettes de 8 relais, répartis des 2 cotés d'une planche en bois montée sur charnière sous le circuit pour permettre un accès facile aux borniers à vis.

Comme le dit Denis, j'ai mis un bus CAN pour piloter ce contrôleur par le gestionnaire du réseau.

Coté code, chaque aiguille est un objet C++ :

Code: [Sélectionner]

class Aiguille
{
  private:   
    byte index;             // 0, .. MaxAIG-1
    char nom;               // 'A' ou 'B' ...
    byte pin_sens;          // sens droit (HIGH) ou devie (LOW)
    byte pin_pulse;         // impulsion de commande : actif LOW
    bool etat;              // true = droit, false =  devie
    bool change;            // rafraichir la position en fonction de etat avec envoi CAN
    bool echoCan;           // rafraichir la position en fonction de etat sans envoi CAN si false
    bool curstep;           // true = pulse en cours, false = cycle fini
    unsigned long milli;    // temps systeme au debut de l'impulsion
   
  public:
    // ----------- constructeur complet ------------
  Aiguille(byte a_index, char a_nom, byte a_pin_sens, byte a_pin_pulse);

  void Setup();
  void Armer();
  void Rafraichir();
  void Caner();
  void Preparer(bool a_sens);     // sur reception message CAN: mise en liste
  void Bouger();                  // execute suivant sens avec envoi CAN
  void Positionner(bool a_sens);  // si changement - cas recurent
  void Forcer(bool a_sens);       // cas setup lecture EEPROM
  void MiseAJour();               // fin de la periode : desarmement relais
  char NomAig();
  byte EtatAig();
};

Bouger une aiguille se fait par l'appel de la méthode Armer() qui positionne le relai de direction (droit ou dévié) puis démarre l'impulsion envoyée au relai qui va alimenter la bobine désirée.

Code: [Sélectionner]

void Aiguille::Armer()
  {
   if (this->etat) {
    digitalWrite(this->pin_sens, HIGH); // Droit = HIGH
   } else {
    digitalWrite(this->pin_sens, LOW);  // Devie = LOW
   }
   digitalWrite(this->pin_pulse, LOW);  // demarrage relai pulse
   this->curstep = true;
   this->milli = millis();              // armement du timer
  }
Tu remarques d'une variable milli de l'objet mémorise le temps système.

Le fin d'impulsion est faite par la méthode MiseAJour(). J'ai choisi une durée d'impulsion PulseAiguille = 150ms.

Code: [Sélectionner]

void Aiguille::MiseAJour()
  {
    // gestion de la fin du cycle pour relacher les relais
    if (this->curstep && (milli + PulseAiguille < millis())) { 
    digitalWrite(this->pin_pulse, HIGH);    // retour relai pulse
    digitalWrite(this->pin_sens, HIGH);     // retour relai sens
    if (this->echoCan) {
      Caner();
    }
    this->change = false;
    this->echoCan = false;
    this->curstep = false;
    }
  }
Cette méthode est appelée en tâche fond dans la loop par :

Code: [Sélectionner]

for (int i = 0; i < MaxAIG; i++)  {
    ListeAig[i].MiseAJour();
  }
Où ListeAig[] est mon tableau de pointeurs sur les objets aiguilles.

Pour éviter de commander plusieurs aiguilles en même temps, j'ai une liste de booleans (1 par aiguille) qui permet de "marquer" chaque aiguille à bouger. Les aiguilles ne sont, en fait, pas commandées directement par les ordres reçus, mais par ce code appellé à chaque loop. Il y a 200 ms entre 2 commandes d'aiguilles.

Code: [Sélectionner]

/*
   *  Toutes les 0,2 secondes
   */
 
  if (_AigTour + 200 < millis()) { 
    _AigTour = _AigTour + 200; 
   
    if (BougeAIG[BougeAiguille])  {
      BougeAIG[BougeAiguille] = false;
      ListeAig[BougeAiguille].Armer();
      BougeAiguille++;     
      if (BougeAiguille == MaxAIG) {BougeAiguille = 0;}
    }
  }

L'inconvénient c'est qu'une aiguille n'est pas forcément commandée immédiatement mais en général ça parait instantané  à l'échelle humaine.

Au démarrage du système, soit je lis les positions initiales dans une EEPROM, soit je mets les aiguilles en conformité avec les clés du TCO (via le CAN)

J'ajouterai pour finir que j'ai ajouté une tâche périodique qui repositionne chaque aiguille dans l'état où elle devrait être, une aiguille toutes les 10 secondes. Cela évite quelques déraillement au cas où une aiguille aurait été déplacée inopinément.

Code: [Sélectionner]

/*
   * Toutes les 10 secondes : rafraichissement d'une position d'aiguille
   */
   
  if (_Minute + 10000 < millis()) {                        // toutes les 10 secondes
    _Minute = _Minute + 10000;
    ListeAig[RafraichAiguille].Rafraichir();               // rafraichissment d'une position d'aiguille sans envoi CAN
    if (_debug) {
      Serial.print(" 10SEC : rafraich: ");Serial.print(RafraichAiguille);
      Serial.print(ListeAig[RafraichAiguille].NomAig());
      Serial.print(" ram ");Serial.println(_RamFree());
    }
    RafraichAiguille++;
    if (RafraichAiguille > MaxAIG-1) RafraichAiguille = 0; // pas de rafraichisement des Deteleurs, evidemment !
  }

voilà !

1016

Vos projets / Re : arduino gare cachee

« le: février 21, 2016, 11:10:36 am »

Dans l'article sur la barrière infrarouge :
http://www.locoduino.org/spip.php?article40#forum1627

il y a des exemples d'utilisation des capteurs pour détecter un convoi, sa tête et sa queue si on veut et même ignorer les trous entre les wagons.

Ces capteurs fonctionnent comme des ILS en ce qui concerne les changements d'état.
Dans cet exemple ce n'est pas trop le fonctionnement du capteur qui peut t'intéresser, mais les traitements autour.

Est-ce que ça peut te servir ?

1017

Bus CAN / Re : BreakoutBoard CAN

« le: février 17, 2016, 10:18:48 am »

Avant de vous lancer, avez-vous essayé cette carte ?

http://www.ebay.fr/itm/Arduino-MCP2515-CAN-Bus-Module-TJA1050-Receiver-SPI-Module-/311520457612?hash=item488810f38c

Elle fonctionne bien à condition de changer le quartz pour un modèle de 16 MHz (je l'ai testée avec la bibliothèque de Seeedstudio) ou d'utiliser une autre bibliothèque que je viens de trouver ici :

https://github.com/Flori1989/MCP2515_lib

Mais je ne l'ai pas encore testée.

Précaution indispensable : enlever la bibliothèque de SeeedStudio, le 2 bibliothèques ne pouvant coexister !
Cette bibliothèque semble être une simple évolution de la bibliothèque de SeeedStudio avec l'ajout du support de l'horloge à 8MHz (c'est pour cela qu'il ne faut pas laisser les 2 bibliothèques dans le dossier des bibliothèques).


Dans le fichier mcp_can_dfs.h il y a la définition pour les 2 fréquences d'horloge :

/*
 * clock
 */
#define MCP_16MHz   1
#define MCP_8MHz   2

D'après mon observation de la bibliothèque, je pense que la fréquence de l'horloge est de 16MHz par défaut.

Pour changer cette fréquence il faut appeler l'instruction "CAN.begin()" avec un argument supplémentaire :

- A 16 MHz :
CAN0.begin(CAN_500KBPS);              // init can bus : baudrate = 500k , clock = 16 MHz par défaut

- A 8 MHz :
CAN0.begin(CAN_500KBPS, MCP_8MHz);    // init can bus : baudrate = 500k , clock = 8 MHz

ici, le nom de l'objet "CAN0" est tiré des exemples "send" et "receive". Dans votre code, vous pouvez l'appeler autrement...

A suivre : je testerai seulement dans 2 semaines ;(
Dominique

1018

Bus CAN / Re : BreakoutBoard CAN

« le: février 16, 2016, 10:14:31 am »

Bonjour Bern69,

Il n'est pas nécessaire de modifier les fichiers de fabrication téléchargés sur Dropbox. Par rapport à la vidéo, seuls 2 composants ont changé de place.

J'en ai monté 6 récemment en suivant les instructions de la vidéo et je peux vous dire que ça ne pose aucun problème. D'ailleurs, vous pouvez faire l'économie du bouton de reset qui ne sert jamais !

Bonne réalisation
Dominique

1019

Débuter / Re : IDE Arduino

« le: février 13, 2016, 09:04:06 pm »

Effectivement, je ne vais pas m'embarquer dans cette galère ! :

1020

Débuter / Re : IDE Arduino

« le: février 13, 2016, 08:53:05 pm »

Hello,

Je viens d'installer TextWrangler 4.5.12 (because 10.6. et ça fonctionne nickel avec les mots clé Arduino.
Cela tombe bien, je n'avais pas encore installé BBedit dans cette machine. Ca y ressemble d'ailleurs !

Moi j'utilise souvent BBedit pour comparer des fichiers (voir ce qui a changé dans une bibliothèque, en plus ou sans infos d'évolutions) ou ouvrir un grand nombre de fichiers à la fois.

Merci pour cette discussion.

Mais pour compiler et téléverser, il faut toujours utiliser l'IDE officiel

Bon week-end
Dominique