Auteur Sujet: Projet Dominique  (Lu 61976 fois)

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2024
  • 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: 346
    • 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: 2024
  • 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: 1000
  • 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: 346
    • 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: 2024
  • 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: 2024
  • 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: 2024
  • 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: 2024
  • 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: 2024
  • 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: 2024
  • 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é pariemment et soigneusement :

« Modifié: août 18, 2020, 03:07:04 pm par Dominique »
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2024
  • 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