Auteur Sujet: Projet Dominique  (Lu 67316 fois)

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #75 le: janvier 14, 2019, 09:02:20 pm »
Avec les evolutions de mon va-et-vient automatique, j’ai ajoute une commande manuelle avec l’encodeur, de telle sorte que le passage par zero entraine un changement de sens.

Je me rends compte qu’il faudrait un retour rapide a zero sans le depasser pour eviter un arret d’urgence qui n’est pas realiste.
Cordialement

Tony04

  • Sr. Member
  • ****
  • Messages: 361
    • Voir le profil
Re : Projet Dominique
« Réponse #76 le: janvier 15, 2019, 12:26:10 am »
Bonsoir Dominique,

Pourquoi ne pas passer à 0 par un simple appui sur l'encodeur, c'est très pratique, je l'ai intégré dans ma souris et cela a été adopté à l'unanimité ?

Amitiés
Antoine

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #77 le: janvier 15, 2019, 08:49:39 am »
Oui mais c’est déjà mon arrêt d’urgence (vitesse à 0 et arrêt DCC).
Cordialement

msport

  • Hero Member
  • *****
  • Messages: 1079
  • HO avec DCC++ en DIY Réseaux très éphémères
    • Voir le profil
Re : Projet Dominique
« Réponse #78 le: janvier 15, 2019, 09:44:51 am »
Peut-être discriminer par un appui long ?
Cordialement

Tony04

  • Sr. Member
  • ****
  • Messages: 361
    • Voir le profil
Re : Projet Dominique
« Réponse #79 le: janvier 15, 2019, 10:27:03 am »
Avec la librairie avdweb_Switch par exemple (clic, double-clic et appui long)

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #80 le: janvier 15, 2019, 05:35:49 pm »
Voilà plein de bonnes idées pour un futur article sur les encodeurs ...
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #81 le: août 12, 2020, 03:42:33 pm »
Bon, je me disperse tellement que des bouts de description de mon réseau se retrouvent un peu partout dans ce forum  :o >:(

Je vais essayer de rassembler les morceaux !
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
« Modifié: août 12, 2020, 04:21:13 pm par Dominique »
Cordialement

Pyk35

  • Jr. Member
  • **
  • Messages: 94
    • Voir le profil
Re : Projet Dominique
« Réponse #83 le: août 15, 2020, 12:01:58 pm »
Bonjour Dominique,

Je n'ai pas encore tout lu mais je suis très impressionné par cette réalisation !
Un grand bravo.
A+
Cédric

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #84 le: août 18, 2020, 02:35:19 pm »
Pour continuer la description de mon réseau, j'aborde maintenant le TCO graphique que j'ai intégré au gestionnaire des circulations. Ce gestionnaire tourne sur un DUE avec une interface CAN. Il reçoit donc tous les messages de rétrosignalisation, ainsi que ceux de la traction. Je n'aborde pas ici le fonctionnement du gestionnaire (encore en chantier) mais seulement l'onglet Graphiques.h du programme gestionnaire graphique-tactile sur DUE que je donne en PJ : (Graphiques.h).

Il y a 1360 lignes !
C'est normal, vu le nombre de zones (47) et d'aiguilles (21).

Mais cela nécessite des explications que je vais donner progressivement :

Le tracé réel de mon réseau est à peu près ceci (RéseauDBReel.jpg)

Les couleurs correspondent à l'altitude (bleu en bas, vert au milieu et rouge en haut).

Mais pour caser tout cela dans un écran 5 pouces, j'ai replié les grandes longueurs dans le milieu entre les 2 gares, afin de permettre la visualisation plus confortable des occupations (MonResauTypeTCO.png).


Maintenant, pour programmer tous les segments et arcs qui constituent les 21 aiguilles et les 47 zones (qui incluent parfois une ou plusieurs aiguilles), il faut determiner les coordonnées graphiques de tous les éléments graaphiques, ce qui est fastidieux et donne ceci (tracéDB0.png)


Je vais expliquer le code dans une réponse suivante ...

En ce qui concerne le matériel utilisé : j'ai combiné un Arduino DUE avec un écran 5 pouces et la carte d'interface Sainsmart comme présenté dans la page suivante :
https://www.ebay.com/itm/5-inch-800x480-TFT-LCD-Resistive-Touch-Shield-for-Arduino-Due-MEGA-2560-Library/291874076554?
« Modifié: août 18, 2020, 03:02:14 pm par Dominique »
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #85 le: août 18, 2020, 02:52:03 pm »
Vu le nombre d'objets aiguilles (21) et zones (47), autant passer en C++.

Leurs classes sont définies au début du fichier :
// classe de base AIGUILLE Graphique

class GAiguille {
public:
  boolean etat=true; // directe (true) ou deviee (false)
  int no;       // numéro de l'aiguille
  int nz;       // le numéro de Zone ou est l'aiguille
 
  GAiguille(int n, int z) { no=n; nz=z; } // constructeur utilisé

  boolean directe() { return etat; }  // méthode de test
  boolean deviee()  { return !etat; } // méthode de test
  void directer() {etat=true;}   // mettre l'aiguille en position directe
  void devier()   {etat=false;}  // mettre l'aiguille en position deviee
  virtual void tracer(int c); // TCO c= couleur K_ouvert ou K_iti ou Kocc selon etat, K_ferme selon !etat
};
 
// classe de base ZONE Graphique

class GZone {
public:
   boolean etat=false; // libre (false) ou occupé (true)
   int no; // le numero de la zone pour commander l'electronique ( TCO, relais, ... )
   int na=-1; // le numéro de l'aiguille dans la zone, sinon -1
   int nb=-1; // le numéro de l'aiguille dans la zone, sinon -1

   GZone(int n) { no=n; } // constructeur mini
   GZone(int n,int a) { no=n; na=a; } // constructeur   OPTION
   GZone(int n,int a,int b) {no=n; na=a; nb=b;} // constructeur   OPTION
 
   void occuper() {etat=true;} // appelée par la rétrosignalisation lors de l'occupation d'une zone
   void liberer() {etat=false;} // appelée par la rétrosignalisation lors de la liberation d'une zone
   virtual void tracer(int c, boolean s); // TCO c= couleur K_ouvert ou K_iti ou Kocc selon etat, K_ferme selon !etat
};


Ces classes définissent les fonctions qu'il faudra appeler par le gestionnaire en fonction des occupations, libérations, manœuvres d'aiguilles, tracés graphiques.
Ces classes de base servent de modèle aux classes spécifiques de chaque zone et chaque aiguille.

Les classes aiguille sont dénommées GA0 à GA20.
par exemple :
class GA0: public GAiguille {
  public:
  GA0(int n,int z):GAiguille(n,z) { no=n; nz=z; } // constructeur utilisé
  void tracer(int c);   
};
void GA0::tracer(int c) {
  if (etat) {//droit
    myGLCD.setColor(K_ferme);
    geo.drawArc(90, 358, 38, 0, 45, 5);
    myGLCD.setColor(c);
    drawbarreH(90, 320, 27);
  }
  else {     // devié
    myGLCD.setColor(K_ferme);
    drawbarreH(90, 320, 27);
    myGLCD.setColor(c);
    geo.drawArc(90, 358, 38, 0, 45, 5);
  }
}
GAiguille* Ga0 = new GA0(0,26); // a0  est dans la zone z26

On voit que le dessin d'une aiguille est la combinaison de segments de droite et d'arc avec 2 cas différents selon que l'aiguile est droite ou déviée.

De même, les classes zones sont dénommées de GZ0 à GZ46.
Par exemple :
class GZ2 : public GZone {
  public:
  //GZone(int n) { no=n; } // constructeur mini
  GZ2(int n,int a):GZone(n,a) { no=n; na=a; } // constructeur   OPTION
  //GZone(int n,int a,int b) {no=n; na=a; nb=b;} // constructeur   OPTION
  void tracer(int c,boolean s); // TCO c= couleur K_ouvert ou K_iti ou Kocc selon etat, K_ferme selon !etat
};
void GZ2::tracer(int c, boolean s) {
  myGLCD.setColor(c);
  Ga15->tracer(c);
  if (Ga15->directe()) {drawbarreH(547, 72, 26);}
  myGLCD.setColor(K_trace);
  if (Ga15->deviee()) {drawbarreH(547, 72, 26);} // Z2 contient a15
}
GZone* Gz2 = new GZ2(2,15); 

On remarque ici, dans la zone 2 qu'il y a une aiguille 15, d'ou les appels aux fonctions graphiques de l'aiguille 15.

A la fin, pour manupuler les objets, les tables d'objets indexées sont créees :
////////////////////////// table des aiguilles

GAiguille* tableGA[MaxAig]= {
  Ga0, Ga1, Ga2, Ga3, Ga4, Ga5, Ga6, Ga7, Ga8, Ga9, Ga10, Ga11,
  Ga12, Ga13, Ga14, Ga15, Ga16, Ga17, Ga18, Ga19, Ga20 };
 
/////////////////// TABLE DES ZONES /////////////////

GZone* tableGZ[MaxZone]=  { 
    Gz0, Gz1, Gz2, Gz3, Gz4, Gz5, Gz6, Gz7, Gz8, Gz9, Gz10, Gz11, Gz12, Gz13, Gz14, Gz15,
    Gz16, Gz17, Gz18, Gz19, Gz20, Gz21, Gz22, Gz23, Gz24, Gz25, Gz26, Gz27, Gz28, Gz29, Gz30,
    Gz31, Gz32, Gz33, Gz34, Gz35, Gz36, Gz37, Gz38, Gz39, Gz40, Gz41, Gz42, Gz43, Gz44, Gz45, Gz46  };
   
   
void drawallzones(int k) {
  for (int i=0; i<MaxZone; i++)
 {
  tableGZ[i]->tracer(k, true);
 }
}
////////////////////////////////////////////////////////////////////////////////////

On remarque la fonction drawallzones() qui sert à aficher l'ensemble du circuit au démarrage et lors des rafraichissements d'écran.

Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #86 le: août 18, 2020, 02:59:44 pm »
Donc le tracé de mon réseau sur un écran graphique est constitué de multiples segments de droite et d'arcs.

Les bibliothèques UTFT nous donnent tout ce qu'il faut :
#include <UTFT.h>
#include <UTFT_Geometry.h>
#include <UTouch.h>
#include <UTFT_Buttons.h>
#include <UTFT_SdRaw.h>
#include <SdFat.h>

// Declare which fonts we will be using
extern uint8_t SmallFont[];
extern uint8_t BigFont[];

// CTE TFT LCD/SD Shield for Arduino Due       : <display model>,25,26,27,28
UTFT           myGLCD(CTE50,25,26,27,28);
UTFT_Geometry  geo(&myGLCD);
UTouch         myTouch(6,5,32,3,2);
UTFT_Buttons   myButtons(&myGLCD, &myTouch);


int max_x, max_y;
int kolor[16] = {VGA_WHITE,VGA_RED,VGA_GREEN,VGA_BLUE,VGA_SILVER,VGA_GRAY,VGA_MAROON,
VGA_YELLOW,VGA_OLIVE,VGA_LIME,VGA_AQUA,VGA_TEAL,VGA_NAVY,VGA_FUCHSIA,VGA_PURPLE,VGA_BLACK};
int kolori[4] = {VGA_WHITE,VGA_RED,VGA_GREEN,VGA_BLUE};

int K_fond = VGA_SILVER; // indice 4
int K_trace = VGA_GRAY;
int K_ferme = VGA_BLACK;
int K_ouvert = K_trace;
int K_iti = VGA_WHITE;
int K_occ = VGA_RED;

Donc il faut comencer par des routines graphiques de segment en d'arc :
///////////////////////// ROUTINES GRAPHIQUES ////////////////////////
// barre horizontale long=+/-, vers droite s1 l>0 ou gauche si l<0
void drawbarreH(int x, int y, int l) {
  myGLCD.fillRect(x,y-2,x+l,y+2);
}
// barre verticale long=+/-, vers droite s1 l>0 ou gauche si l<0
void drawbarreV(int x, int y, int l) {
  myGLCD.fillRect(x-2,y,x+2,y+l);
}

Maintenant interviennent le papier, le crayon et la calculatrice pour déterminer les paramêtres de ces fonctions appelées dans chaque aiguille et chaque zone.

C'est bien le but de ce dessin renseigné soigneusement :

« Modifié: octobre 20, 2020, 08:18:39 pm par Dominique »
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #87 le: août 18, 2020, 03:09:24 pm »
A ce stade, je pense que chacun pourra adapter cette méthode à le représentation de son propre réseau.

J'aborderai plus tard l'intégration du TCO graphique avec le reste du gestionnaire.

A suivre...
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #88 le: octobre 20, 2020, 07:26:16 pm »
Un gros "petit détail" à respecter : le choix de la carte interface de votre écran à "décommenter" dans le fichier "HW_ARM_defines.h" du dossier "arm" comme le montre l'arborescence en image pour un Due et la carte CTE_DUE que j'utilise (CT50 avec un écran de 5 pouces).

Sinon, rien ne s'affiche sur l'écran et on peut croire qu'il est en panne.
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2094
  • 100% Arduino et N
    • Voir le profil
Re : Projet Dominique
« Réponse #89 le: novembre 04, 2020, 10:18:04 pm »
Voici un exemple de circulation sur mon réseau, dans son état actuel :
Pour rappel, j'ai décidé de matérialiser un TCO (un Arduino Mega) pour visualiser les occupations et positionner les aiguilles à la main , puis un module de commande des aiguilles (un Mega caché sous la plaque à coté de l'écran 5 pouces) puis une centrale (DCCpp bien-sur, encore un Mega) capable de piloter 12 trains avec des potars linéaires (j'adore), on les voit à droite sur la photo (le bloc noir) :



puis un module de programmation des locos (à gauche, pas aussi sophistiqué que ce que fait Denis, mais ça me suffit) et enfin un gestionnaire basé sur le gestionnaire en C++ de Pierre qui occupe un Due avec un écran 5 pouces tactile.
Il y a en plus des détecteurs de consommation, des détecteurs RFID pour déterminer les trains à coup sur et des détecteurs ponctuels pour les zones d'arrêt. Un jour il y aura des barrières infrarouges pour compter les wagons et vérifier que les trains n'en perdent pas (ça se passera dans les tunnels).

Tout ce petit monde est relié par un bus Can (c'est d'ailleurs le truc qui pose le moins de problème dans l'ensemble du réseau !).

L'écran 5 pouces fait donc partie du gestionnaire (le Due fait la gestion et l'affichage graphique) et permet de suivre son propre fonctionnement par les affichages et aussi de piloter les aiguilles (faire des itinéraires), de piloter les trains (suivre les trains, varier les vitesses, assurer la sécurité, les arrêts, les pannes, etc..).

Voici un exemple avec 4 trains stockés en gare cachée (sous le village) et un itinéraire pour un premier train qui démarre pour aller dans la gare visible devant le village (en faisant le grand tour) :



Puis un 2eme train avec un autre itinéraire (plus court, mais dans l'autre sens) pendant que le premier se déplace (il démarre) :



A noter : j'ai supprimé le segment noir qui est remplacé par rien sur les positions d'aiguilles non réalisées : on voit mieux le chemin à parcourir sur un petit écran.

Les boutons tactiles permettent à mon petit fils (4 ans) de faire marcher tout ça sans moi (enfin je reste pas loin, mais en cas de déraillement sous la montagne, c'est lui le meilleur !). De plus je garde le contrôle manuel à tout moment ! Tout n'est pas automatique. Les potars restent actifs en double commande.
Et je n'ai pas fini et je passerai à 7 pouces prochainement .
Cordialement