Auteur Sujet: Un TCO interactif sur votre navigateur WEB et relié au bus CAN du réseau  (Lu 2284 fois)

bobyAndCo

  • Global Moderator
  • Sr. Member
  • *****
  • Messages: 362
  • HO avec DCC++
    • Voir le profil
Le projet :

Le projet s’inscrit dans l’ensemble du projet Locoduinodrome et en liaison tout particulièrement avec le développement des cartes satellites.
 
Il s’agit d’un TCO très interactif qui offrira une représentation précise et en temps réel de l’état du réseau.

Ainsi par exemple, les segments de voie qui sont occupés sont représentés par une couleur particulière avec l’icône de la locomotive concernée.

La représentation de la signalisation lumineuse elle aussi sera très fidèle à ce qui est affiché sur le réseau. Et cela vaut également pour les positions des aiguillages.

Il est également prévu que ce TCO puisse permettre de piloter certains accessoires du réseau comme les aiguillages et donc de modifier en conséquence la signalisation ferroviaire.

L'architecture générale :

Le TCO s’alimente des différentes informations qui circulent sur le bus CAN du réseau.

Il peut bien sûr filtrer les seuls messages qui l’intéresse et dispose de sa propre base de données de correspondance de messages. Il peut donc mettre à jour la représentation graphique de chaque objet en fonction des informations qui circulent sur le bus.

Lorsque l’on agit sur l’un des éléments graphiques du TCO comme une aiguille, le message correspondant est envoyé sur le bus CAN et l’aiguillage change effectivement de position.

L'architecture logicielle est somme toute assez simple et grandement facilitée par l'usage du bus CAN. J'envisage en effet de placer sur le bus une passerelle CAN/WiFi qui serait également un serveur WebSocket.

C'est l’ESP8266 dans sa version de prototypage Node MCU E12 qui sera retenu. Il dispose en effet d’un grand nombre de bibliothèques qui seront utiles et ses performances sont de taille pour l'exercice.

Ainsi, tous les messages circulants sur le bus CAN du réseau seront envoyés à une page HTML (la représentation du TCO) gérée par du code en JavaScript en ayant largement recours à la POO. Chaque élément du réseau (aiguille, loco, feux...) étant lui-même un objet informatique. Tout résidant en mémoire et propulsé par le moteur V8 de Google, c'est un fonctionnement ultra rapide.

Ce TCO fonctionne avec tous les gestionnaires puisqu'il est indépendant de toutes plateformes pour peu, bien sûr que les informations transitent par un bus CAN.

Comme vous pourrez vous en rendre compte, l’intérêt des solutions techniques mises en œuvre dépasse largement le cadre d’un TCO et dont pourront s’inspirer de nombreux autres projets.

1° - On y trouve une passerelle CAN/WiFi-Ethenet
2° - Le Node MCU dispose d’un espace de stockage de fichiers qui sera utilisé ici pour héberger un serveur web assez complexe. Mais on pourrait tout aussi bien y stocker des fichiers son par exemple comme on le fait sur une carte SD.
3° - Pour communiquer entre l’ESP8266 et le navigateur web, nous utiliserons la technologie des websocket qui constitue aujourd’hui la plus performante des solutions d’échanges sur le web.
4° - Le TCO sera conçu comme une application à part entière disposant de ses propres bases de données objets stockées en mémoire RAM de l’ordinateur ou de la tablette. Là encore, l’assurance de performances accrues.

Parmi les nombreuses applications possibles, je pense à une centrale DCC++ hébergée sur l’ESP8266 à laquelle on pourrait accéder en CAN et Wifi. Une manière de contourner Processing assez « lourd » à mon sens pour le développent d’applications graphiques de commande comme peuvent l’être un TCO ou un contrôleur.



bobyAndCo

  • Global Moderator
  • Sr. Member
  • *****
  • Messages: 362
  • HO avec DCC++
    • Voir le profil
Node MCU et MCP2515 : Pin mapping et programmes test.

Faire fonctionner le Node MCU avec un MCP2515 est facile. Voici le Pin Mapping.



Bien que la data sheet du MCP2515 annonce des courants de fonctionnement compris entre 2,7V et 5,5V, je n’ai pas réussi à le faire fonctionner avec le 3,3V du Node MCU mais avec un 5V externe. Il sera donc préférable d’ajouter un convertisseur de niveaux entre les broches du MCP2515 alimenté en 5V et les broches de l’ESP8266 qui doivent être « attaquées » en 3,3V.

Dans mon montage test, les messages CAN sont envoyés par un Mega lui aussi relié à un MCP2515.

Voici le Pin Mapping pour un Mega




Voici enfin le code test pour, d’un côté le Mega qui envoie des messages sur le bus CAN :

// demo: CAN-BUS Shield, send data

#include <mcp_can.h>
#include <SPI.h>

// MOSI 51 -> SI
// MISO 50 -> SO
// SS   53 -> SS
// SCK  52 -> SCK

const int SPI_CS_PIN = 53;
MCP_CAN CAN(SPI_CS_PIN);                                    // Set CS pin
char msgString[128];                        // Array to store serial string

void setup() {
  Serial.begin(115200);

  while (CAN_OK != CAN.begin(CAN_500KBPS))              // init can bus : baudrate = 500k
  {
    Serial.println("CAN BUS Shield init fail");
    Serial.println(" Init CAN BUS Shield again");
    delay(100);
  }
  Serial.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 1, 2, 3, 4, 5, 6, 7};

void loop() {

  Serial.print("CAN send datas : \t");
  for (byte i = 0; i < 8; i++) {
    sprintf(msgString,  " 0x%.2X", stmp[i]);
    Serial.print(msgString);
    Serial.print(" ");
  }
  Serial.print("\n");
  // send data:  id = 0x00, standard frame, data len = 8, stmp: data buf
  CAN.sendMsgBuf(0x70, 0, 8, stmp);
  delay(1000);                       // send data once per second
}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

Et de l’autre côté, le code pour le Node MCU qui reçoit les messages :

// NODE_MCU_ESP_8266_CAN_Receive
//

#include <mcp_can.h>
#include <SPI.h>

long unsigned int rxId;
unsigned char len = 0;
unsigned char rxBuf[8];
char msgString[128];                        // Array to store serial string

// PINS:  CS=D8, INT=D4, SCK=D5, SO=D6, SI=D7
#define CAN0_INT 2                            // Set INT to pin 2 = D4
MCP_CAN CAN0(15);                             // Set CS to pin 15 (D8)
volatile bool flagRecv = false;

/******************** Interruption pour CAN ***************************/
void MCP2515_ISR() {
  flagRecv = true;
}

void setup()
{
  Serial.begin(115200);

  while (CAN_OK != CAN0.begin(CAN_500KBPS))              // init can bus : baudrate = 500k
  {
    Serial.println("CAN BUS Shield init fail");
    Serial.println(" Init CAN BUS Shield again");
    delay(100);
  }
  Serial.println("CAN BUS Shield init ok!");

  pinMode(CAN0_INT, INPUT);                                       // CAN int pin
  attachInterrupt(digitalPinToInterrupt(CAN0_INT), MCP2515_ISR, FALLING); // start interrupt
}

void loop() {

  if (flagRecv) { // Datas sur bus CAN
    flagRecv = false;
    CAN0.readMsgBuf(&len, rxBuf);

    if ((rxId & 0x80000000) == 0x80000000)    // Determine if ID is standard (11 bits) or extended (29 bits)
      sprintf(msgString, "Extended ID: 0x%.8lX  DLC: %1d  Data:", (rxId & 0x1FFFFFFF), len);
    else
      sprintf(msgString, "Standard ID: 0x%.3lX       DLC: %1d  Data:", rxId, len);

    Serial.print(msgString);

    if ((rxId & 0x40000000) == 0x40000000) {  // Determine if message is a remote request frame.
      sprintf(msgString, " REMOTE REQUEST FRAME");
      Serial.print(msgString);
    } else {
      for (byte i = 0; i < len; i++) {
        sprintf(msgString, " 0x%.2X", rxBuf[i]);
        Serial.print(msgString);
      }
    }
    Serial.println();
  }
}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/



Les échanges peuvent être visualisé dans le moniteur série de l’IDE (alternativement pour l’une et l’autre carte) ou mieux avec CoolTerm.


« Modifié: mars 10, 2019, 06:00:54 pm par bobyAndCo »

bobyAndCo

  • Global Moderator
  • Sr. Member
  • *****
  • Messages: 362
  • HO avec DCC++
    • Voir le profil
Transférer des fichiers dans file system de l’ESP8266.

Pour transférer des fichiers, il faut tout d’abord télécharger l’outil ESP8266FS :

https://github.com/esp8266/arduino-esp8266fs-plugin/releases/download/0.1.3/ESP8266FS-0.1.3.zip

Dans votre répertoire contenant les sketches Arduino, créez (si ce n’est pas déjà fait) un dossier tools et glissez-y le dossier ESP8266FS (dézippé). Dans votre dossier Arduino, vous devez maintenant avoir ceci :




Il faut quitter puis redémarrer l’IDE de l’Arduino.

Ouvrez un sketch existant ou créez en un nouveau que vous enregistrerez.

Dans le menu Croquis de l’IDE, choisissez Afficher le dossier des croquis :





Dans le dossier de votre sketch, créez un dossier data et glissez-y les fichiers que vous souhaitez recopier sur la carte :




Dans le dossier de votre sketch, créez un dossier data et glissez y les fichiers que vous souhaitez recopier sur la carte :

Assurez-vous que vous avez sélectionné la bonne carte et le bon port dans le menu outils de l’IDE puis sélectionnez dans le menu, ESP8266 Sketch Data Upload :





Le tour est joué !

L'upload des fichiers peut aussi être programmé dans le setup du scketch :

void startSPIFFS() { // Start the SPIFFS and list all contents
  SPIFFS.begin();                             // Start the SPI Flash File System (SPIFFS)
  Serial.println("SPIFFS started. Contents:");
  {
    Dir dir = SPIFFS.openDir("/");
    while (dir.next()) {                      // List the file system contents
      String fileName = dir.fileName();
      size_t fileSize = dir.fileSize();
      Serial.printf("\tFS File: %s, size: %s\r\n", fileName.c_str(), formatBytes(fileSize).c_str());
    }
    Serial.printf("\n");
  }
}

Toutes ces informations sont extraites de la documentation officielle qui contient encore plein d'autres informations :

http://esp8266.github.io/Arduino/versions/2.0.0/doc/filesystem.html

PS : La bibliothèque FS est incluse dans le package ESP8266 core for Arduino téléchargeable ici : https://github.com/esp8266/Arduino

Dans le post suivant, nous créerons une page HTML que nous copierons sur l'ESP8266, puis nous le programmerons en seveur web et enfin, nous accéderons à cette page au travers d'un navigateur.

Je considère que tant que je n'ai ni messages ni questions de votre part, c'est que tout est parfaitement clair  :)


« Modifié: juin 25, 2018, 08:03:05 am par bobyAndCo »

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1714
  • 100% Arduino et N
    • Voir le profil
Bravo Christophe,

Voilà qui me donne envie (mais après Orléans).

Ce serait en effet super de charger DCCpp sur un ESP8266, 8255 (qui a 1M de flash) ou un ESP32 (Thierry doit y travailler probablement).


Le plus dur est sans doute de travailler les registres pour utiliser les interruptions comme sur les Arduino pour générer le signal DCC en tache de fond, comme ne le fait pas lulu_ho sur le forum LR Presse (http://forum.e-train.fr/viewtopic.php?f=3&t=84400&hilit=10+balles) où il utilise intensivement des delaymicroseconds() donc plus du tout en tache de fond, dommage, dans son projet D17 : une centrale à 10 balles.

Amicalement
Dominique
« Modifié: août 12, 2018, 12:01:52 pm par Dominique »

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1714
  • 100% Arduino et N
    • Voir le profil
Je pense qu'il existe un portage de DCC++ sur 8266,

https://github.com/atanisoft/BaseStation

mais, en tout cas, il existe sur ESP32 :

https://github.com/atanisoft/DCCppESP32

Il y a dans ce dossier quelques plateformes qui ont été testées comme l’ESP32-D1-mini

En regardant le code je vois que ça se compile avec plateformeIO et non pas l’IDE Arduino.

J’ai trouvé cette plateforme qui existe sur Mac:
https://code.visualstudio.com/

Pour l’ESP32, j’ai l’impression que c’est quasi obligatoire.
« Modifié: août 20, 2018, 04:48:08 pm par Dominique »

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1714
  • 100% Arduino et N
    • Voir le profil
Pour l'ESP8266, ce n'est peut-être pas un vrai portage mais une association entre 8266 et Mega/Uno :

https://github.com/bjorniuppsala/BaseStation/tree/master/DCCpp_ESP

mais le recours à plateformeIO semble quand même nécessaire.

J'ai cherché en vain le code générateur de DCC : ce projet n'est, semble-t-il qu'une interface Web avec le DCC++ BaseStation sur Mega ou Uno.

D'ailleurs, il est écrit dans "Adding support for ESP based WiFi shield as frontend to the DCC++ base":
Citer
For Mega2560 base stations the ESP should be connected to Serial1, for Uno
(or other) boards you must define two pins and set them in Config.h as
WIFI_SERIAL_RX and WIFI_SERIAL_TX.

Once the base station has successfully connected to the ESP it will
attempt to connect to the defined WiFi AP defined in WIFI_SSID using
WIFI_PASSWORD.  Upon successfull connection to the WiFi AP DCC++ will
start a server on the ESP8266 with port 2560 (for JMRI) and port 80 for
HTTP and WebSocket.  The http server on the ESP8266 provides a two
cab throttle and eventually will provide a more complete interface to
DCC++ base station functionality (define turnouts, sensors, etc).

WiThrottle support is planned in the future with the ESP8266 providing a
listener and interpreter layer for converting to/from DCC++ protocol.


« Modifié: août 20, 2018, 04:49:51 pm par Dominique »

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1714
  • 100% Arduino et N
    • Voir le profil
Pendant que j'y suis, je donne les liens vers les éléments mentionnés par Christophe :

ESP8266 Core for Arduino
https://github.com/esp8266/Arduino

Biblithèque FS
https://github.com/esp8266/arduino-esp8266fs-plugin

Thierry

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 500
    • Voir le profil
De mon côté, je tente de porter la version d'atani (https://github.com/atanisoft/DCCppESP32), un portage complet de Basestation++, vers DCCpp pour que la même interface DCCpp utilisée actuellement fonctionne aussi avec un ESP32. Ce serait toujours ma biblio DCCpp, mais selon l'Arduino sélectionné dans l'IDE, la biblio prendra la version AVR de gregg, ou la version ESP d'atani. C'est encore à un stade embryonnaire, mais je ne désespère pas d'arriver à tout compiler sur l'IDE Arduino, même pour la version ESP32. Je n'ai pas installé Platform.IO, et je n'ai pas l'intention de le faire à moins d'y être obligé :)

bobyAndCo

  • Global Moderator
  • Sr. Member
  • *****
  • Messages: 362
  • HO avec DCC++
    • Voir le profil
Re : Un TCO interactif sur votre navigateur WEB et relié au bus CAN du réseau
« Réponse #8 le: septembre 20, 2018, 02:08:26 pm »
Bonjour à tous,

Ce projet avance. Je n'ai pas beaucoup publié car j'ai entrepris un travail un peu plus ambitieux que ce que je prévoyais au départ. En plus d'être un serveur web pour mon TCO, je suis en train de programmer l'ESP8266 (et le 32 en parallèle) pour en faire aussi un routeur CAN <-> WiFi (et port série).

Je mets en ligne un schéma détaillé du mapping car beaucoup de schémas présentent soit les GPIO, soit les D0, D1, D... mais rarement les deux à la fois et c'est souvent utile :



Je profite aussi pour vous rappeler que si vous rencontrez des difficultés à initialiser les modules CAN, regardez en premier vos alimentations électriques.

Les petits modules CAN NiRen doivent être alimentés en 5V (et non en 3,3V comme on voit parfois) et les ESP en 3,3v. N'oubliez pas de mettre un convertisseur de tension (comme je le montre ci-dessus) ou des transistors entre les sorties du module CAN (5v) et les entrées de l'ESP qui sont prévues pour du 3,3 - 3,6v pas plus.

Enfin, si vous utilisez un FTDI, la puissance et rarement suffisantes pour alimenter l'ensemble du montage, ESP + module CAN source de non fonctionnement que l'on ne détecte pas forcement tout de suite. N'hésitez pas à utiliser de bonnes alimentations externes dont vous serez sûr des tensions délivrées et que les puissances seront suffisantes.

Bien amicalement.

Christophe

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1714
  • 100% Arduino et N
    • Voir le profil
De mon côté, je tente de porter la version d'atani (https://github.com/atanisoft/DCCppESP32), un portage complet de Basestation++, vers DCCpp pour que la même interface DCCpp utilisée actuellement fonctionne aussi avec un ESP32. Ce serait toujours ma biblio DCCpp, mais selon l'Arduino sélectionné dans l'IDE, la biblio prendra la version AVR de gregg, ou la version ESP d'atani. C'est encore à un stade embryonnaire, mais je ne désespère pas d'arriver à tout compiler sur l'IDE Arduino, même pour la version ESP32. Je n'ai pas installé Platform.IO, et je n'ai pas l'intention de le faire à moins d'y être obligé :)

Hier j’ai pu installer proprement l’environnelent ESP32 dans l’IDE Arduino avec le board manager et programmer un serveur web.

C’est récent, on n’a plus besoin de faire des manips bas niveau comme avant et le dossier exemples est bien rempli. L’Arduino progresse toujours  ;D

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1714
  • 100% Arduino et N
    • Voir le profil
Les petits modules CAN NiRen doivent être alimentés en 5V (et non en 3,3V comme on voit parfois) et les ESP en 3,3v. N'oubliez pas de mettre un convertisseur de tension (comme je le montre ci-dessus) ou des transistors entre les sorties du module CAN (5v) et les entrées de l'ESP qui sont prévues pour du 3,3 - 3,6v pas plus.

Pourtant la fiche caractéristique du 2515 indique bien que le circuit fonctionne avec 3,3V.

Mais le TJA1050 ne fonctionne qu’en 5V.

C’est vraiment bête de la part du concepteur car il y a plein de transmetteurs en 3.3V.
Par exemple, avec un Due qui a 2 canaux Can intégrés, j’utilise un SN65HVD230.

A noter que des cartes Can en 5V communiquent très bien avec d’autres en 3,3V.

Dominique

bobyAndCo

  • Global Moderator
  • Sr. Member
  • *****
  • Messages: 362
  • HO avec DCC++
    • Voir le profil
Re : Un TCO interactif sur votre navigateur WEB et relié au bus CAN du réseau
« Réponse #11 le: septembre 21, 2018, 09:56:31 am »
Eh bien oui c'est bête et ça peut faire perdre beaucoup de temps (je parle par expérience). Tout semble fonctionner les LEDs sont allumées, mais rien..., jusqu'à ce qu'on lui donne du 5V !

J'ai chercheé une datasheet mais je n'ai rien trouvé.
« Modifié: octobre 02, 2018, 07:53:23 pm par bobyAndCo »

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1714
  • 100% Arduino et N
    • Voir le profil
Re : Un TCO interactif sur votre navigateur WEB et relié au bus CAN du réseau
« Réponse #12 le: septembre 21, 2018, 10:01:30 am »
Tu vas sur TME.eu
Tu cherches MCP2515 (ou n’importe quoi d’autre)
Tu trouves un composant
Tu cliques sur fichiers/documentation
Tu arrives sur la fiche en pdf

Moi je ne cherche plus ailleurs, il y a tout chez TME

bobyAndCo

  • Global Moderator
  • Sr. Member
  • *****
  • Messages: 362
  • HO avec DCC++
    • Voir le profil
Re : Un TCO interactif sur votre navigateur WEB et relié au bus CAN du réseau
« Réponse #13 le: octobre 01, 2018, 09:05:44 pm »
Ca y est, je commande les satellites à partir d'une page web via ma passerelle CAN/WiFi :



La programmation de toutes les configurations devrait être assez rapide maintenant.

bobyAndCo

  • Global Moderator
  • Sr. Member
  • *****
  • Messages: 362
  • HO avec DCC++
    • Voir le profil
Re : Un TCO interactif sur votre navigateur WEB et relié au bus CAN du réseau
« Réponse #14 le: octobre 02, 2018, 06:59:01 pm »
N'est-ce pas ce à quoi tout modéliste ferroviaire peut rêver ? Pouvoir régler ses butées de servos d'aiguillages avec une précision et une facilité déconcertante !



Sur l'écran de gauche vous avez les données reçues par la passerelle WiFi/CAN et sur l'écran de droite, les données reçues par le satellite.



L'application est visible en vrai grandeur ici


« Modifié: janvier 31, 2019, 12:12:53 am par bobyAndCo »