Voir les contributions

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


Messages - Dominique

Pages: 1 ... 149 150 [151] 152 153 154
2251
Vos projets / Le module Fête Foraine du CMFA
« le: décembre 05, 2015, 10:28:11 am »
Notre Club du Modélisme Ferroviaire d'Arpajon (CMFA) intègre depuis l'année dernière quelques modules Arduino dans le réseau N d'expositions.

La meilleure entrée en matière est cette vidéo :



Au menu :

  • la centrale DCC du va-et-vient entre le village de Tout Juste et la Fête Foraine
  • La commande des manèges
  • L'animation lumineuse de stands
  • La balançoire
  • Le karting

Claude est le génie du décor de cette maquette et maintenant un expert Arduino  8)

Des détails vont suivre...

2252
Bus CAN / Re : Le bus CAN
« le: novembre 28, 2015, 03:05:49 pm »
Bonjour Jack,

Cette carte : "MCP2515 CAN Bus Module TJA1050"

http://www.ebay.fr/itm/311379482437

contient un quartz à 8Mhz
Vous pouvez le dessouder (il faut une bonne tresse à dessouder) et mettre un quartz de 16 MHz à la place.

Je l'ai testé et ça marche avec la bibliothèque CAN préconisée.

Cordialement
Dominique

2253
Juste une petite précision supplémentaire :
J'ai volontairement réduit les tailles des images qui doivent, au total, ne pas dépasser 192Ko.

Donc si vous voulez en savoir plus, je répondrai volontiers aux questions.

Dominique

2254
Bonjour à tous,

Je voudrais témoigner ici que la modélisation "objet" de Pierre fonctionne bien !

J’ai donc modélisé mon réseau avec les objets Aiguille et Zone seulement pour commencer.

Cela se passe en 4 étapes :

Etape 1 : les classes prototypes (copier-coller du code de Pierre).

J’en ai profité pour ajouter l’action d’envoi des commandes d’aiguille sur le bus CAN, mais cela ne sert pas pour le moment.

///////////// PROTOTYPE CLASSE AIGUILLE ////////////////////

class Aiguille {
private:
  byte index;             // 0.. MaxAIG-1
  boolean etat=true;      // directe (true) ou deviee false)
  Zone* zone;             // la Zone ou est l'aiguille

public:
 
  Aiguille(byte a_index, Zone* z) { // constructeur
    index = a_index;
    zone=z; 
  }
 
  boolean directer() {     // commande de l'aiguille en position directe
    this->etat=true;
    output.id = 0x40;
    output.length = 1;
    output.data.bytes[0] = this->index + 0xC0;
    Can0.sendFrame(output);
    return true;
  }
 
  boolean devier()   {     // commande de l'aiguille en position déviée
    this->etat=false;
    output.id = 0x40;
    output.length = 1;
    output.data.bytes[0] = this->index + 0x80;
    Can0.sendFrame(output);
    return true;
  }
 
  boolean directe() {     // demande d'état
    return this->etat;
    } // méthode utilitaire};
};

////////////////// PROTOTYPE CLASSE ZONE ////////////////////

class Zone {
public:
  byte index;           // 0.. MaxZone-1
  boolean etat;         // libre ou occupé
  Signal* signalPair;
  Signal* signalImpair; // les signaux éventuels de la zone

  Zone(byte a_index, Signal* sp, Signal* si) { // constructeur
    index = a_index;
    signalPair=sp;
    signalImpair=si; }
   
   virtual Zone* suivantePaire() { return NULL; } // la zone suivante paire (éventuellement vide)
   virtual Zone* suivanteImpaire() { return NULL; } // la zone suivante impaire (éventuellement vide)

   virtual void actions() {} // les actions spécifiques à faire en cas d'occupation
   virtual void desactions() {} // les actions spécifiques à faire en cas de libération

   boolean occupee() { return etat; } // méthode utilitaire
   boolean libre() { return !etat; } // méthode utilitaire

   void occuper() { // appelée par la rétrosignalisation
      // fait tout ce qu'il y a à faire en cas d'occupation (actions communes à toutes les zones)
      actions(); // fait les actions spécifiques à une zone
   }
   void liberer() { // appelée par la rétrosignalisation
      // fait tout ce qu'il y a à faire en cas de libération (actions communes à toutes les zones)
      desactions(); // fait les actions spécifiques à une zone
   }

   Zone* selonAiguille(Aiguille* a,Zone* z1,Zone* z2) { return a->directe()?z1:z2; } // méthode utilitaire
};

Etape 2 : je crée toutes mes zones par héritage du prototype (voici seulement les 4 premières, elle sont toutes identiques)

////////////// HERITAGES CLASSES ZONES REELLES ////////////////////
// les zones reelles (héritages de Zone)

// 0 gare base loisirs (pair/droite= 1 impair/gauche=0=butoir)
class Z0 : public Zone { // 0 gare base loisirs (pair/droite= 1 impair/gauche=0=butoir)
public:
  Z0(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
  virtual Zone* suivantePaire();
  virtual Zone* suivanteImpaire();
};
// 1 VV centre (pair/droite=2, impair/gauche=0)
class Z1 : public Zone { // 1 VV centre (pair/droite=2, impair/gauche=0)
public:
  Z1(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
  virtual Zone* suivantePaire();
  virtual Zone* suivanteImpaire();
};
// 2 liaison VV-Hor (pair/droite=3siPdroite, impair/gauche=1+aiguillePdevié=4)
class Z2 : public Zone {
public:
  Z2(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
  virtual Zone* suivantePaire();
  virtual Zone* suivanteImpaire();
};
// 3 gare centre (droite/pair=3=butoir, gauche/impair=2)
class Z3 : public Zone {
public:
  Z3(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
  virtual Zone* suivantePaire();
  virtual Zone* suivanteImpaire();
};
etc…

Etape 3 : déclaration des objets réels (zones et aiguilles).

Pour accéder individuellement aux objets, à partir des index contenus dans les messages CAN (dans un événement « occupation de zone » par exemple), j’ai déclaré un tableau de zones. De même pour le tableau d’aiguilles.
De cette façon, on ne manipule que des pointeurs sur les zones et les aiguilles.

/////////////////// DECLARATIONS ZONES ////////////////////
// zones
Zone* z0=new Z0(0,NULL,s2);
Zone* z1=new Z1(1,NULL,s2);
Zone* z2=new Z2(2,NULL,NULL);
Zone* z3=new Z3(3,s2,NULL);
Zone* z4=new Z4(4,s2,c2);
Zone* z5=new Z5(5,s2,c2);
Zone* z6=new Z6(6,s2,c2);
Zone* z7=new Z7(7,s2,c2);
Zone* z8=new Z8(8,s2,c2);
Zone* z9=new Z9(9,s2,c2);
etc…

const int MaxZone = 40;

Zone* listez[MaxZone]=  {
    z0, z1, z2, z3, z4, z5, z6, z7, z8, z9, z10, z11, z12, z13, z14, z15,
    z16, z17, z18, z19, z20, z21, z22, z23, z24, z25, z26, z27, z28, z29, z30,
    z31, z32, z33, z34, z35, z36, z37, z38, z39
  };

/////////////////// DECLARATIONS AIGUILLES //////////////////// 
// aiguilles
Aiguille* a0=new Aiguille(0,z26);  //A
Aiguille* a1=new Aiguille(1,z26);  //B
Aiguille* a2=new Aiguille(2,z15);  //C
Aiguille* a3=new Aiguille(3,z26);  //D
Aiguille* a4=new Aiguille(4,z15);  //E
Aiguille* a5=new Aiguille(5,z14);  //F
Aiguille* a6=new Aiguille(6,z14);  //G
Aiguille* a7=new Aiguille(7,z12);  //H
Aiguille* a8=new Aiguille(8,z12);  //I
Aiguille* a9=new Aiguille(9,z29);  //J
Aiguille* a10=new Aiguille(10,z38); //K
Aiguille* a11=new Aiguille(11,z29); //L
Aiguille* a12=new Aiguille(12,z39); //M
Aiguille* a13=new Aiguille(13,z6); //N
Aiguille* a14=new Aiguille(14,z35); //O
Aiguille* a15=new Aiguille(15,z2); //P
Aiguille* a16=new Aiguille(16,z4); //Q
Aiguille* a17=new Aiguille(17,z17); //R
Aiguille* a18=new Aiguille(18,z24); //S
Aiguille* a19=new Aiguille(19,z37); //T TJD demi a5 vers deviation
Aiguille* a20=new Aiguille(20,z37); //U TJD demi a6 vers deviation

const int MaxAig = 21;
 
Aiguille* listea[MaxAig]= {
  a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
  a12, a13, a14, a15, a16, a17, a18, a19, a20
};

Etape 4 : la modélisation de mon réseau commence maintenant par l’écriture des méthodes particulières « suivantePaire » et « suivanteImpaire »

Pour ce faire, j’ai découpé mon réseau en zones. Certaines zones contiennent une aiguille ou plusieurs. J’ai défini le sens Pair (horaire) et Impaire (trigo) pour savoir quelle est la zone suivante paire ou impaire en fonction de la position d’aiguille s’il y en a une à traverser.



J’applique alors la méthode utilitaire du prototype :

selonAiguille(Aiguille* a,Zone* z1,Zone* z2) { return a->directe()?z1:z2; }
et cela donne :

///////////////////// METHODES PARTICULIERES DES ZONES ///////////////////////
// les methodes des zones

// Z0 gare base loisirs (pair/droite= z1 impair/gauche=butoir)
Zone* Z0::suivantePaire() { return z1; }
Zone* Z0::suivanteImpaire() { return NULL; }

// 1 VV centre (pair/droite=2, impair/gauche=0)
Zone* Z1::suivantePaire() { return z2; }
Zone* Z1::suivanteImpaire() { return z0; }

// 2 liaison VV-Hor (pair/droite=3, impair/gauche=1+aiguillePdevié=4)
Zone* Z2::suivantePaire() { return selonAiguille(a15,z3,NULL); }
Zone* Z2::suivanteImpaire() { return selonAiguille(a15,z1,selonAiguille(a16,NULL,z4)); }

// 3 gare centre (droite/pair=3=butoir, gauche/impair=2)
Zone* Z3::suivantePaire() { return NULL; }
Zone* Z3::suivanteImpaire() { return z2; }

// 4 GC Hor Ext (pair=6+aiguilleQdevié=2, impair=17)
Zone* Z4::suivantePaire() { return selonAiguille(a16,selonAiguille(a13,NULL,z7),selonAiguille(a15,NULL,z3)); }
Zone* Z4::suivanteImpaire() { return selonAiguille(a17,NULL,z16); }

// 5 GC Hor Int (pair=6, impair=17)
Zone* Z5::suivantePaire() { return selonAiguille(a13,z7,NULL); }
Zone* Z5::suivanteImpaire() { return selonAiguille(a17,z16,NULL); }

// 6 sortie GC Hor (pair=7, impair=5+aiguilleNdevié=4) - Normalement pas utilisé
Zone* Z6::suivantePaire() { return z7; }
Zone* Z6::suivanteImpaire() { return selonAiguille(a13,z5,selonAiguille(a16,z4,NULL)); }

etc..

Tests et Simulations

J’ai réalisé un petit montage sur le Due, avec un écran graphique 2,4 pouces et 3 boutons poussoirs (+, - et OK).
+ et - permettent de se déplacer dans les lignes et OK execute une fonction (menu sélectionné ou action)
Le programme affiche une liste de menus:



- menus Aiguilles :  je peux positionner chaque aiguille



- menu train : je peux définir le sens de déplacement
- menu Itinéraire : j’ai défini 7 points de départ. En appuyant sur OK, le programme demande la zone suivante successives aux objets en fonction des positions d’aiguilles (ici elles sont toutes droites, d’ou la série de « 1 » en bas de l’écran)

Ce petit bout de code fait tout (exemple pour le départ de la zone 5) :

zonedepart = 5;
        Show("5 ");
        zindex = 5;
        for (int i=0; i<10; i++)  {
          zt = senstrain? listez[zindex]->suivantePaire() : listez[zindex]->suivanteImpaire();
          if (zt == NULL) break;
          zindex = zt->index;
          tft.print(zindex);
          tft.print(" ");
        }



J’ai varié les positions d’aiguilles, le sens du train et à chaque fois, en vérifiant sur mon plan de réseau, les itinéraires sont tous bons !!!

CQFD
Un bon tuto suivra peut-être, prochainement.

Bien cordialement

Dominique

2255
Bonjour à tous,

J'avoue découvrir l'UML !
J'ai trouvé ce cours très intéressant sur les différentes phases de conception qui se termine sur une synthèse :

http://laurent-audibert.developpez.com/Cours-UML/?page=mise-en-oeuvre-uml

avec un schéma global joint.

L' application à notre domaine de Marc-Henri est très interessante.
J'en profite pour essayer de l'appliquer à la "mise en mouvement" de la modélisation de mon réseau.

A suivre ...

Merci de m'avoir conduit vers ce savoir  :D

Bien cordialement
Dominique




2256
Bonjour à tous,

Je pensais au noyau de l'automate c'est à dire un modèle de programme à adapter à son cas personnel (et non a un noyau temps réel ou multitâche). En fait Jac56 a donné l'idée qui est un grand switch avec des case appelant les actions à exécuter aux transitions. Je peux comprendre que cela suffit pour démarrer.

Quand au configurateur, j'imagine que les liens entre les événements et les états et actions pourraient être inscrits dans des variables avec un outil interactif dit "configurateur" plutôt qu'entrés en "dur" dans l'automate "switch.. case".

Au stade de la réflexion dans lequel je suis, le crayon et le papier seront les plus utiles. Mais je pense déjà aux erreurs à corriger, aux évolutions et modifications futures, donc à la forme d'écriture la plus ouverte aux évolutions, si cela peut exister.

Sincères salutations
Dominique

2257
Merci pour cette excellente contribution qui nous éclaire bien sur les 2 briques essentielles d'une bonne gestion de réseau :
- la modélisation qui consiste à traduire en objets les éléments du réseau (zones, aiguilles, signaux, trains, itinéraires, ..), avec les méthodes propres à chaque objet,
- la table d'états et d'actions, l'automate qui associe les événements aux actions.

On a bien à faire avec deux démarches indépendantes qu'il faut étudier conjointement.

J'ai pratiqués les automates dans des machines de Telecom dans le passé et cette experience me revient bien à l'esprit en lisant ce fil. À l'époque il n'existait pas de logiciel de type StateChart. Le crayon et le papier précédaient l'assembleur !

Ce qui serait intéressant, ce serait de faire tourner un noyau et un configurateur d'automate sur Arduino !
Est-ce utopique ?

2258
Bonjour Marc-Henri,

Ce sujet est très intéressant, surtout du fait que tu en montres une application concrète.

Le fait d'installer un IDE supplémentaire comme Eclipse m'effraie toujours, ainsi que le fait d'utiliser plusieurs langages de programmation (C, C++, Java).

Je suppose qu'avant d'installer cet outil de développement Java sous Eclipse, tu as essayé de trouver quelques outils et bibliothèques dans l'environnement Arduino.

Quand j'écris "outil" je ne pense pas forcément "logiciel", mais aussi méthode de réflexion avec papier, crayon et neurones.

Peux-tu nous expliquer ton cheminement jusqu'à StateChart, ce qui pourrait nous éviter des pertes de temps, car je suis en pleine reflexion sur la modélisation et la gestion de mon réseau, avec d'autres amis de ce site, bien évidemment, car on est plus forts à plusieurs.

Merci d'avance
Dominique

2259
Présentez vous ! / Re : Bonjour de l'UAICF Nevers-Vauzelles
« le: octobre 01, 2015, 09:20:25 pm »
Bienvenue au club de modélisme de l'UAICF Nevers-Vauzelles.

Les réalisations présentées sur votre site sont très intéressantes et détaillées.

J'espère que vous trouverez votre bonheur sur Locoduino qui se construit petit à petit grâce à l'expérience partagée.
Vous pouvez y faire figurer vos réalisations.

Bon courage !

2260
Présentez vous ! / Re : Salut à Tous
« le: octobre 01, 2015, 09:06:12 pm »
Bienvenue Maximilien sur Locoduino  ;D

Tu as déjà des projets intéressants et tu vas certainement en trouver d'autres ensuite !

Bon courage
Dominique

2261
Présentez vous ! / Re : Bonjour à tous
« le: octobre 01, 2015, 08:59:29 pm »
Bienvenue Jean-Marie,

Locoduino te permettra d'échanger ton expérience avec nous et d'en faire profiter tout le monde via des articles qu'on peut même rédiger à plusieurs  :D

Bon courage
Dominique

2262
Bus CAN / Re : BreakoutBoard CAN
« le: août 29, 2015, 08:33:26 pm »
Bizarrement j'ai vu que Marklin utilise aussi des Id de 29 bits.

Franchement je n'en vois pas la justification. Mais, bon, ils font ce qu'ils veulent.

Méfies toi tout de même de la façon de faire le filtrage. Avec 2 masques et 6 filtres seulement, sur des Id de 29 bits, tu vas souffrir ! Tu as vu les questions sur le forum Arduino !

Attendons l'avis de l'expert : Jean-Luc

2263
Shields et Modules / Re : Carte « Cerveau du réseau »
« le: août 25, 2015, 01:13:47 pm »
Finalement j'étais loin du compte :

Dans ce fil sur le forum Arduino,
http://forum.arduino.cc/index.php?topic=131096.495

Un Due est capable de lire 1600 messages par seconde, connecté à une Zoé !

The Due proved a really good choice as this car is producing chatter in excess of 1600 frames per second on the main CANbus only and there is no way a smaller micro-controller can handle that, let alone push it out over real UART serial 115200.

2264
Bus CAN / Re : BreakoutBoard CAN
« le: août 23, 2015, 10:50:54 pm »
La bibliothèque est là

https://github.com/collin80/due_can

1600 messages CAN par seconde sur une Zoe de Renault parfaitement reçus par un Due : pas de souci à se faire pour nos trains  8)


2265
Bus CAN / Re : BreakoutBoard CAN
« le: août 23, 2015, 10:38:43 pm »
Bonjour,

Concernant le DUE, il y a un fil très développé sur le forum Arduino qui est consacré à la réalisation d'une carte d'extension et d'une bibliothèque.

http://forum.arduino.cc/index.php?topic=131096.480

La bibliothèque existe (Due-CAN), mais pas l'extension apparemment constituée d'un seul chip.

On y voit aussi comment utiliser les 2 bus CAN disponibles sur le Due (la doc n'en présente qu'un seul).

Qu'en pensez-vous ?

Pages: 1 ... 149 150 [151] 152 153 154