Messages

1996

Vos projets / Re : Rétrosignalisation/Bus Can

« le: août 22, 2017, 10:46:01 pm »

Effectivement, le détecteur doit être hors de cause.

1997

Vos projets / Re : Rétrosignalisation/Bus Can

« le: août 21, 2017, 11:00:34 pm »

  Comme j'utilise un Can 8Mhz cela peut il provenir de celui-ci? Un 16 Mhz serait plus rapide. A moins que dans le programme l'on puisse augmenter la vitesse...

À quelle vitesse est programmé le bus CAN ?
1Mb/s ? 500Kb/s ?

Je pense aussi qu'il faut bien relire mon article cite précédemment : il y a quelques précautions à respecter pour ne pas perdre des messages.

1998

Vos projets / Re : Rétrosignalisation/Bus Can

« le: août 21, 2017, 08:32:14 am »

D'après ce que je comprends, l'Arduino détecteur reçoit la rétro et la transmet sur le CAN. Ce sont 2 processus distincts à tester séparément.

Côté gateway c'est la même chose.

En décomposant ce qui fonctionne et ce qui ne fonctionne pas, je pense que tu vas trouver où se situe l'anomalie. Pour cela il faut écrire des programmes de test simples.

Bon courage.

1999

Vos projets / Re : Rétrosignalisation/Bus Can

« le: août 18, 2017, 07:50:55 pm »

Le fonctionnement à 8 MHz est indiqué sur le lien vers Seeedstudio. Ça doit être une evolution naturelle de la bibliothèque puisqu'on trouve des cartes CAN à 8 MHz maintenant.

Mais si toutes les cartes qui causent ensemble sont du même type, cela n'a pas d'importance !
À 8 Mhz les échanges risquent seulement d'être 2 fois moins rapide qu'à 16 MHz.

2000

Vos projets / Re : Rétrosignalisation/Bus Can

« le: août 17, 2017, 10:44:32 pm »

En cherchant un peu sur Locoduino :

http://www.locoduino.org/spip.php?article148

Mais, apparemment elle a changé.
Elle est aussi adaptée au 2515 à 8 MHz.

En regardant le .h il doit être facile de trouver la bonne syntaxe. Il n'y a pas toujours de mode d'emploi détaillé. Mais on fait comme ça aussi.

Je vais modifier l'article en conséquence dés mon retour à la fin du mois.
Merci d'avoir soulevé la question 

Je peux poster ma version de référence pour l'article. Mais il faudra attendre un peu.
Dominique

2001

Vos projets / Re : Rétrosignalisation/Bus Can

« le: août 17, 2017, 11:37:50 am »

Ce n'est probablement pas la bonne bibliothèque mcp_can qui est chargée dans l'IDE.

2002

Présentez vous ! / Re : Nouveau

« le: août 07, 2017, 10:03:29 am »

Oui.

Prenez soin de relier la masse du capteur avec la masse (GND) de l'Arduino et assurez-vous que la tension après diviseur soit bien comprise entre 0 et la tension d'alim de l'Arduino (souvent un peu moins que 5 V).

2003

Présentez vous ! / Re : nouveau et plein de projets

« le: août 01, 2017, 02:44:39 pm »

Bonjour Yves,

D'après ce que je lis sur ton fil, tu as de bonnes connaissances en électronique et tu es capable de reproduire un projet Arduino (matériel et logiciel), c'est déjà très bien !

Mais tu sembles plutôt faible coté programmation de l'Arduino, qui utilise le langage C (créé en 1970) et C++(programmation objet), si je ne me trompe !

Il n'y a pas de logique Arduino, c'est tout simplement la programmation C dont il existe des milliers de cours sur le net.
Pour faciliter l'apprentissage, le site Arduino.cc présente de nombreux documents, un forum très riche que nous consultons tous encore quand se pose une question et l'IDE Arduino est livré avec de nombreux exemples que tout débutant en programmation se devrait de tester pour se former progressivement.

Je pense que ton bagage en électronique te permettra de le compléter avec la programmation, avec un peu de patience.

Par exemple, la question des 10 sorties peut se programmer en s'inspirant de l'exemple "Array" http://www.arduino.cc/en/Tutorial/Array et cela donne :

Code: [Sélectionner]

int timer = 1000;   // une seconde d'interval entre 2 sorties
int timer2 = 15000; // 15 secondes a la fin du cycle
int ledPins[] = {
  2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
int pinCount = 10;           // nombre de pins

void setup() {
  for (int thisPin = 0; thisPin < pinCount; thisPin++) {
    pinMode(ledPins[thisPin], OUTPUT);
  }
}

void loop() {
  // loop from the lowest pin to the highest:
  for (int thisPin = 0; thisPin < pinCount; thisPin++) {
    // turn the pin on:
    digitalWrite(ledPins[thisPin], HIGH);
    delay(timer);
  }
 
  delay(timer2);
    // turn all the pin off:
    for (int thisPin = 0; thisPin < pinCount; thisPin++) {
      digitalWrite(ledPins[thisPin], LOW);
  }
}
A toi de personnaliser cet exemple avec les numéros de pins et les tempos souhaitées

Quand aux commandes de servo multiples, la réponse est sur Locoduino quelque part, et je te laisse chercher, étant en vacances !

Cordialement
Dominique

2004

Présentez vous ! / Re : Bonjour à tous

« le: juillet 23, 2017, 05:55:02 pm »

Il n'y a pas le feu, en cette période de vacances !
Dominique

2005

Infos et bonnes affaires / Re : Du WiFi à 6,95$ chez Sparkfun

« le: juillet 23, 2017, 04:01:37 pm »

Bonjour,

Je viens de recevoir ce module ESP32
http://www.ebay.fr/itm/ESP-32S-ESP32-Development-Board-2-4GHz-Dual-Mode-WiFi-Bluetooth-Antenna-Module/201853283621?ssPageName=STRK%3AMEBIDX%3AIT&_trksid=p2057872.m2749.l2649
et je suis perdu dans la liste des cartes de l'IDE Arduino

Elle est équipée de la puce ESP VROOM 32

Que dois-je choisir ?

Dominique

2006

Présentez vous ! / Re : Bonjour à tous

« le: juillet 23, 2017, 02:52:23 pm »

Merci Sylvain,

Pourrais-tu faire un tuto sur la mise en oeuvre de RocRail avec DCC++, sur Windows si j'ai bien compris, avec pas mal de copies d'écran ?

Soit tu le fais dans un nouveau fil à créer dans le sujet "Le logiciel DCC++", et tu auras du mal à y mettre les images car c'est limité en taille (la solution est de nous envoyer les images et on les mettra dans la mediathèque), soit tu m'envoies un PDF et on le mettra sur le forum.

Tu m'envoies un MP pour transmettre des choses.

Merci d'avance
Dominique

2007

Présentez vous ! / Re : Bonjour à tous

« le: juillet 23, 2017, 12:29:43 pm »

Bonjour Sylvain et Christophe,

J'ai failli répondre à peu près la même chose !

J'ajouterai que DCC++ ne semble pas en cause à priori car au moins une commande fonctionne sur la voie principale, ce qui prouve que Config.h doit être bon.

En tout cas, après les tests proposés par Christophe entre le terminal (RocRail non connecté évidemment) et DCC++, il faudrait pouvoir afficher ce qu'envoie RocRail à DCC++.

Je ne connais pas RocRail bien que je l'ai téléchargé et regardé un peu, mais pas encore utilisé, je pense même que je ne l'utiliserai pas, faisant mon gestionnaire autrement.

Par contre, pour les modélistes de Locoduino, c'est très intéressant d'avoir quelqu'un comme vous qui pourrait partager son expérience.

Ce qui serait intéressant, ce serait de savoir si RocRail permet l'affichage des échanges de caractères entre RocRail et DCC++.  Je pense que RocRail n'envoie pas les commandes correctes à DCC++

Cordialement
Dominique

2008

Les réseaux / Re : Projet Dominique

« le: juillet 22, 2017, 06:43:36 pm »

Construction du contrôleur d’aiguilles

Le contrôleur d’aiguilles est construit sur une base Arduino Mega 2560 associé à une carte bus CAN et un ensemble de 40 relais qui commandent les 18 aiguilles (2 relais par aiguille) et 2 dételeurs (1 relai par dételeur).



L’Arduino est disposé coté tableau de bord tandis que les relais, disposés de chaque coté d’une planche de CP monté sur charnière, sont placés à l’intérieur, sous le circuit. Des câbles en nappes relient l’Arduino aux relais, comme expliqué pour le TCO, avec une carte prototype permettant la soudure des nappes pour un maximum de fiabilité.



Comme les aiguillages choisis sont des modèles Fleischmann à moteur à courant alternatif, j'ai utilisé 2 relais par aiguille, avec le schéma suivant :



Le relai Impulsion est activé 150 millisecondes après que le relai Sens est positionné selon le sens direct/droit ou dévié.

Les relais en couples sont affectés aux pins de l’Arduino (tout est noté dans un tableau):
Relais d'aiguilles 4,5(A),6,7(B),8,9(C),10,11(D) - 22,23(G),24,25(H),26,27(I),28,29(J) - 30,31(K),32,33(L),34,35(M),36,37(N) - 38,39(O),40,41(P),42,43(Q),44,45(R) - 12,13(E),14,15(F),46,47(S),48(T1),49(T2).
La carte CAN est raccordée par les pins : 50 (SO), 51 (SI), 52 (SCK), 53 (CS), 2 (INT).
Les pins A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 restent libres pour le moment. Elles sont réservées pour des relais supplémentaires (ça va arriver, il y en a 4 maintenant installés) et des détecteurs complémentaires (RFID, Hall, IR).

Comme pour le TCO, le logiciel utilise les routines CAN décrites ci-dessus, avec des messages dont les Ids sont :

• Réception Id = 0x4x (commande aiguille)
• Emission, Id = 0x12 (etat aiguille)

Les aiguilles sont déclarées sous forme d'objets :

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();               // din de la periode : desarmement relais
  byte NomAig();
  bool EtatAig();
};
Une des astuces que j'aime bien est le rafraichissement des positions de chaque aiguille, une toutes les 10 secondes. Cela permet d'éviter quelques déraillements en cas de changement de position provoqué par exemple par un convoi entrant par un talon positionné differemment.

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 !
  }

Voici le traitement des messages CAN:

Code: [Sélectionner]

/*
   *  Récupération d'un seul message par loop dans la memoire circulaire _Circule
   */
   
  while (_Ncan > 2)  {                 // messages dans _Circule : au moins 3 bytes
    //digitalWrite(LedV, HIGH);       // led activité CAN reste allumée jusqu'à loop suivante
    _Ncan--;
    RId = _Circule[_indexR];        // recup Id
    _indexR++;
    if (_indexR == sizeof(_Circule))  {_indexR = 0;}
    _Ncan--;
    Rlen = _Circule[_indexR];       // recup longueur
    _indexR++;
    if (_indexR == sizeof(_Circule))  {_indexR = 0;}
    if (_dumpCan)  {     
      Serial.print("CAN id ");
      Serial.print(RId);
      Serial.print(", data ");
    }
    for (int k = 0; k < Rlen; k++)  {
      _Ncan--;
      Rbuf[k] = _Circule[_indexR];  // recup octets message
      _indexR++;
      if (_indexR == sizeof(_Circule))  {_indexR = 0;}
      if (_dumpCan)  { 
      Serial.print("0x");
      Serial.println(Rbuf[k], HEX);
      }
    } // le message est dans les globales RId, Rlen et Rbuf[..]
    curAIG = Rbuf[0] & 0x3F;      // garder que les bits 0..5 = index aiguille

    /*
     * commandes aiguilles CAN sur ID 0x40
     */
     
    if (RId == RId_AIGUILLE)  {
      // commandes relatives aux aiguilles
      // 1 octet donnees:  bit 7,6 -> 1,0 = devie ou 1,1 = droit, bits 5..0 = numero aiguille

      if (bitRead(Rbuf[0], 7)) {  // commande de changement d'aiguille
        if (curAIG < MaxAIG) {    // aiguille
          if (bitRead(Rbuf[0], 6) != ListeAig[curAIG].EtatAig())  {
            ListeAig[curAIG].Positionner(bitRead(Rbuf[0], 6)); // bit 6 = position
            BougeAIG[curAIG] = true;
            if (_debug) {
              Serial.print(" CAN : curAIG ");Serial.print(curAIG);
              Serial.print(" Aiguille "); Serial.print(ListeAig[curAIG].NomAig());
              if (bitRead(Rbuf[0], 6)) {
                Serial.println(" DROIT");
              } else {
                Serial.println(" DEVIE");
              }
            }
          }
        }
      }
    }
  } 

Les commandes d'aiguilles ne sont pas directement émises par le TCO (les clés) mais par le Gestionnaire.



Imaginons qu’une aiguille soit protégée pour laisser passer un convoi prioritaire : cette aiguille ne pourra être manœuvrée qu’après le passage du convoi. C’est ce que fera le gestionnaire : si je bascule la clé de l’aiguille sur le TCO, rien ne se passe ! Dès que le convoi est passé, l’aiguille change automatiquement et la Led sur le TCO, à coté de la clé, répercute ce changement.

Je vais donc bientôt décrire le Gestionnaire !

2009

Les réseaux / Re : Projet Dominique

« le: juillet 22, 2017, 06:12:51 pm »

Description du TCO "en dur"

Je précise "en dur" car réalisé sur une plaque de plexi avec de vraies Leds et de vrais inverseurs (clés). En réalité il y aura d'autres TCO tels qu'un écran graphique piloté par le Gestionnaire et un écran HDMI piloté par un pcDuino8 sous Ubuntu, avec Processing qui sera décrit plus tard.

Première opération, la plaque représentative du réseau :



Le TCO est constitué d'une plaque de plexiglass blanc sur lequel est collée une représentation simplifiée du réseau, dans laquelle les cantons des tracés haut, bas et la boucle sont réduits sur la partie droite.
J'ai réalisé le dessin avec RailModeller Express (https://itunes.apple.com/us/app/railmodeller-express/id1008811516?mt=12), imprimé sur papier avec l'imprimante jet d'encre, plastifié et collé sur une plaque de plexi blanc avec de la colle en bombe Cléopâtre.

Cette plaque est percée au milieu de chaque canton pour loger une Led rouge indiquant l'occupation du canton. Elle est aussi percée au niveau de chaque aiguille pour loger une clé de sélection de position et 2 Leds vertes représentant la position des aiguilles.

Pour réaliser les perçages proprement après le collage du dessin, j'ai utilisé un emporte-pièce et j'ai marqué le plexi en faisant sauter un confetti de papier ce qui a permis ensuite de percer les trous au bon diamètre, sans risque de dérapage de la perceuse.



Après montage des inverseurs et des Leds (collées), la vue "en coulisse" du TCO est édifiante :



Le TCO est animé par un Arduino MEGA 2560 qui gère :
- 20 inverseurs d’aiguilles = 20 pattes : AG1 à AG20 sur 21 bornes avec Gnd
- 36 Leds vertes (positions aiguilles) : 5 x 74HC595 chainés = 3 pattes
- 36 Leds rouges (occupations) : 5 x 74HC595 chainés = +1 patte
- 35 Détecteurs occupation = 35 pattes
- 36 bornes avec Gnd (y.c. va-et-vient)
- Bus CAN = 5 pattes (port SPI)
- Console = 2 pattes (port USB)
AU TOTAL = 68 pattes sur 70 !

Schéma de principe des interface avec 74HC595 (il y a en tout 2 bancs de 5 74HC595):



La réalisation de cette carte à 74HC595 est faite sur une platine 100 x 160 mm que j'avais en stock depuis très longtemps :




Pour les raccordements, surtout pour avoir la plus grande fiabilité possible et permettre le montage et les modifications, j'ai ajouté sur le MEGA une carte Prototype de ce type (il en existe plein) :



J'y ai soudé des nappes au bout desquelles j'ai soudé des borniers à vis déportées de chaque coté du MEGA.



Cela fait un peu fouillis car je n'ai pas cherché à ranger les fils mais c'est très fiable et toujours accessible en soulevant la plaque du TCO montée sur charnière. C'est promis, mon prochain TCO sera plus professionnel.

On voit sur la droite la carte CAN Locoduino et au fond au milieu la carte 74HC595.

Des trous dans le fond assurent le passage des fils avec le dessous du réseau.

Pour le bornier de raccordement des occupations de zones, j'ai fait un tableau avec les relations entre les Pins du Mega raccordées aux détecteurs d’occupation, les Leds Rouges (coordonnées de la led dans la matrice de 74HC595) et les Zones.



Bien entendu il y a quelques bornes disponibles pour ajouter des détections d'occupation supplémentaires, ce qui va arriver, on le verra plus loin.

Depuis la construction de ce TCO (ça fait bien 2 ans minimum), je n'ai jamais eu de panne !

2010

Vos projets / Re : Rétro-signalisation

« le: juillet 22, 2017, 11:29:31 am »

Là je dis bravo !

Bon courage

Dominique