LOCODUINO
Parlons Arduino => Vos projets => Discussion démarrée par: bobyAndCo le juin 24, 2018, 12:38:04 am
-
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.
(http://alkans.fr/locoduino/tco/img/NodeMCU_DEVKIT_1.0.jpg)
-
Node MCU et MCP2515 : Pin mapping et programmes test.
Faire fonctionner le Node MCU avec un MCP2515 est facile. Voici le Pin Mapping.
(http://alkans.fr/locoduino/tco/img/node_mcu_mcp2515.png)
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
(http://alkans.fr/locoduino/tco/img/mega_mcp2515.png)
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.
(http://alkans.fr/locoduino/tco/img/can_captureCoolTerm.png)
-
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 :
(http://alkans.fr/locoduino/tco/img/repertoire_ESP8266FS.png)
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 :
(http://alkans.fr/locoduino/tco/img/menu_afficher_croquis.png)
Dans le dossier de votre sketch, créez un dossier data et glissez-y les fichiers que vous souhaitez recopier sur la carte :
(http://alkans.fr/locoduino/tco/img/repertoire_data.png)
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 :
(http://alkans.fr/locoduino/tco/img/menu_data_upload.png)
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 (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 (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 :)
-
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 (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
-
Je pense qu'il existe un portage de DCC++ sur 8266,
https://github.com/atanisoft/BaseStation (https://github.com/atanisoft/BaseStation)
mais, en tout cas, il existe sur ESP32 :
https://github.com/atanisoft/DCCppESP32 (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/ (https://code.visualstudio.com/)
Pour l’ESP32, j’ai l’impression que c’est quasi obligatoire.
-
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 (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":
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.
-
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 (https://github.com/esp8266/Arduino)
Biblithèque FS
https://github.com/esp8266/arduino-esp8266fs-plugin (https://github.com/esp8266/arduino-esp8266fs-plugin)
-
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é :)
-
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 :
(http://alkans.fr/locoduino/locoduinodrome/img/ESP8266_mapping.jpg)
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
-
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
-
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
-
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é.
-
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
-
Ca y est, je commande les satellites à partir d'une page web via ma passerelle CAN/WiFi :
https://youtu.be/ZPbDnoiOLdE (https://youtu.be/ZPbDnoiOLdE)
La programmation de toutes les configurations devrait être assez rapide maintenant.
-
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 !
https://youtu.be/hTkR-SHBqp8 (https://youtu.be/hTkR-SHBqp8)
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.
(http://alkans.fr/locoduino/locoduinodrome/img/satellite_01.jpg)
L'application est visible en vrai grandeur ici (http://alkans.fr/locoduino/locoduinodrome/param_satellite_v04.html#)
(http://alkans.fr/locoduino/locoduinodrome/img/ecran_reglage_satellites_01.png)
-
Bon, je vais pouvoir revenir au sujet central de ce post qui est la réalisation d'un TCO interactif avec les outils web. J'ai pu réaliser le tracé du Locoduinodrome en SVG (graphisme vectoriel).
Résultat, un code ultra léger de moins de 10 Ko et un rendu parfait avec qui plus est des courbes de Bezier. Pour illustration, voici ci-dessous la totalité du code qui sert au tracé (dont les commentaires qui prennent presque autant de lignes !) :
<!--Z0-->
<line id="Z0" class="free" x1="550" y1="600" x2="850" y2="600" />
<!--Z1-->
<line id="Z1" class="busy" x1="550" y1="550" x2="850" y2="550" />
<!--Z2-->
<path id="Z2" class="free dasharray" d="M 400,600 c 75,0 75,-50 150,-50" />
<line id="Z22" class="free" x1="400" y1="600" x2="550" y2="600" />
<!--Z3-->
<path id="Z3" class="free" d ="M 400,100 A 250 250 0 0 0 400,600" />
<!--Z4-->
<path id="Z4" class="free" d ="M 1000,100 A 250 250 0 0 1 1000,600" />
<!--Z5-->
<path id="Z5" class="busy dasharray" d="M 850,550 c 75,0 75,50 150,50" />
<line id="Z52" class="busy" x1="850" y1="600" x2="1000" y2="600" />
<!--Z6-->
<line id="Z6" class="busy" x1="400" y1="100" x2="1000" y2="100"/>
Chaque ligne de code correspond à un élément graphique, droite ou courbe.
Voici ce que ça donne en vrai ici : http://alkans.fr/locoduino/tco/tco_v01.html (http://alkans.fr/locoduino/tco/tco_v01.html)
Vous pourrez même actionner les aiguillages si vous cliquez dessus. La représentation actuelle simule qu'un convoi est détecté (en rouge) sur la voie du haut et un autre sur la voie déportée et l'aiguille de droite.
Aujourd'hui je vais réaliser l'implantation de feux.
Bonne journée à tous.
-
Magnifique ! Mais la création d'un dessin vectoriel n'est pas forcément à la portée du premier béotien venu... Il faudra prévoir un frontal de création de réseau.
-
Et puis j’imagine que les styles et la bibliothèque sont bien plus gros que le petit code que tu montres ;D
Personnellement, je tracerais les voies avec des traits plus épais si c’est possible.
Mais c’est superbe. 8)
-
Pas OK avec toi, j'ai fait le code du tracé sans aucun outil. Il faut juste comprendre la logique qui est très simple.
Une ligne s'appelle "line", jusqu'ici facile, x1 et y1 coordonnées du début de la droite, x2 et y2 coordonnées de la fin !!! Peut difficilement faire plus simple.
<line id="Z0" class="free" x1="550" y1="600" x2="850" y2="600" />
Pour une courbe, il y a un peu plus d'informations :
<path id="Z4" class="free" d ="M 1000,100 A 250 250 0 0 1 1000,600" />
mais toujours les coordonnées de départ, coordonnées d'arrivé, rayon et si l'on veut un demi cercle ou un cercle entier (0 ou 1). id="Z4" class="free" id et class ne sont pas des informations de tracé mais d'identification et de rendu. id identifie les zones telles que nous les avons définies, z0, z1... et class, le rendu : free, pas de détection, rendu gris, busy, détection, rendu rouge. Bien sûr cela est mis automatiquement à jour en fonction des informations reçu sur le bus CAN... et donc ce pourquoi il fallait que je commence par ma passerelle CAN/WiFi,=> CQFD
Pour les courbes de Bezier, j'expliquerai plus tard, mais vous verrez que c'est également déconcertant de simplicité. Par ailleurs, on peut se faire une bibliothèque des differentes formes, les dupliquer et changer simplement leur position sur l TCO.
-
Dominique, pour le style, voici le code :
<style type="text/css">
/* <![CDATA[ */
line, path {
stroke-width: 10px;
fill:none;
}
.free {
stroke: grey;
}
.busy {
stroke: red;
}
.dasharray {
stroke-dasharray: 1, 2;
}
.aiguille {
fill:transparent;
cursor: pointer;
}
/* ]]> */
</style>
Pas franchement consequent. Et il n'y a pas de bibliothèque, les navigateurs savent en natif afficher des informations vectorielles.
Pour l'épaisseur du tracé tu changes la valeur de stroke-width: 10px; qui est ici à 10 pixels.
-
Je m’incline, c’est très simple ;D
-
Bon, je ne suis pas encore un spécialiste de la signalisation ferroviaire mais c'est le principe qui compte. Si vous cliquez sur l'aiguillage de gauche, la signalisation change.
De même pour le feu jaune clignotant, je profite des animations existante en natif avec le SVG ! Cool non ?
http://alkans.fr/locoduino/tco/tco_v02.html (http://alkans.fr/locoduino/tco/tco_v02.html)
-
Ca y est la passerelle entre le bus CAN et le WiFi fonctionne parfaitement. Le TCO est bien avancé et l'on peut voir sur cette vidéo les zones occupées s'afficher en rouge et celles libérées reprendre leur couleur grise.
Je vais maintenant m'occuper des capteurs ponctuels, ce qui va être assez simple, le gros du travail ayant été fait avec les détecteurs d'occupation. Puis enfin la signalisation en cohérence avec la position de la loco. Mais c'est le travail du gestionnaire, le TCO se contentant de reproduire la signalisation du plateau.
https://youtu.be/IcFV6u8Z9Bk (https://youtu.be/IcFV6u8Z9Bk)
-
Bon maintenant, tous les capteurs ponctuels fonctionnent et le TCO se met bien à jour en fonction des événements détectés sur le réseau. Il ne me reste plus maintenant que le gestionnaire qui va gérer les trains et la signalisation.
https://youtu.be/0wTkDJWdN_c (https://youtu.be/0wTkDJWdN_c)
-
Bonjour
Qui a dit que Processing c'était "lourd". Voici le dessin du Locoduinodrome en Processing, le programme est complet, rien à rajouter. Bien évidemment il utilise des courbes de Bezier. Il ne fait que le dessin, mais il serait facile de rajouter des signaux et les manoeuvres des aiguilles.
void setup() {
size(1500,750); // taille de la fenetre
}
void draw() {
stroke(127); strokeWeight(10); strokeCap(SQUARE); noFill(); // styles (couleur (gris), largeur (10), raccords (carres), ...)
line(550,600,850,600); // Z0
line(550,550,850,550); // Z1
stroke(0); bezier(400,600, 400+75,600, 550-75,550, 550,550); // Z2 noir
stroke(127); line(400,600,550,600); // gris
bezier(400,100, 75,100, 75,600, 400,600); // Z3
bezier(1000,100, 1325,100, 1325,600, 1000,600); //Z4
stroke(0); line(850,600,1000,600); // Z5 noir
stroke(127); bezier(850,550, 850+75,550, 1000-75,600, 1000,600); // gris
stroke(#FF0000); line(400,100,1000,100); // Z6 rouge
}
Voir ci dessous ce qu'affiche le programme .
Pierre
-
C'est vrai, qui a dit ça ???
-
L'avant dernière étape sur le TCO est terminée.
La signalisation, sémaphores avec œilleton ou non, réagit conformément aux informations transmises par les capteurs. Les feux ne repassent au vert qu’après s’être assuré que la zone n'est pas occupée par un train qui se serait avancé au feu jaune.
Sur le TCO, il ne reste donc plus à programmer que les carrés et les avertissements en fonction de la position des aiguilles.
Ensuite, ce sera le tour du gestionnaire pour que locos et événements sur le plateau soit synchronisés. Un peu de boulot encore donc !
https://youtu.be/ZTQuxB_aRl4 (https://youtu.be/ZTQuxB_aRl4)
-
Bravo, ça avance bien ;D
-
Eh, c'est qu'il ne reste plus que 3 semaines :( :( :(
-
Voilà, j’ai créé un premier scénario pour la 241 P qui quitte la gare fait trois tours de circuit, puis s’arrête à nouveau à la gare.
Ce scénario est complétement interactif. Cela veut dire que si un convoi est par exemple arrêté sur la voie, la 241 P s’arrêtera elle aussi au canton précèdent et attendra que la voie soit libre pour repartir.
De la même façon, un autre convoi pourra chercher à la contourner quand elle est arrêtée en gare en demandant le changement des aiguilles. Si rien ne s’y oppose, (train déjà stationné sur la seconde voie de la gare par exemple) le second train va donc doubler le premier.
Le tout obéissant aux ordres et aux messages véhiculés sur le bus du réseau (capteurs, détecteurs…).
Plus que dix jours mais on devrait être prêt.
A suivre !
https://youtu.be/Pyfu03cfzzQ (https://youtu.be/Pyfu03cfzzQ)
-
Superbe !
ça me donne envie de passer au numérique et au H0...
-
Merci Christian,
Et que ça donne envie à d'autres ! De venir au modélisme ferroviaire... et sur Locoduino en particulier.
Bien à toi.
-
J'évoquais plus tôt dans ce fil la nécessité d'utiliser un convertisseur de tension pour que les signaux en sortie du MCP2515 en 5V puissent communiquer avec l'ESP qui lui est en 3,3V.
Je viens de trouver ce tuto qui montre comment on peut isoler une partie de la carte et l'alimenter en 3,3V pour se dispenser du convertisseur :
https://vimtut0r.com/2017/01/17/can-bus-with-raspberry-pi-howtoquickstart-mcp2515-kernel-4-4-x/
Note du 10/03/2019 : Bon il se trouve que ceci n'est as une bonne idée, voir plus loin le post de Jean-Luc.
-
Effectivement, je viens de vérifier que le MCP2515 peut être alimenté en 3,3 V et le TJA1050 en 5 V et accepter l’interface avec le 2515 en 3,3 V.
Je pense que tu pourrais alimenter TOUTE la carte en 3,3 V sans la charcuter : j’ai un Due sur mon réseau avec un transmetteur Can alimenté en 3,3 V et ça communique sans problème avec toutes les autres cartes Can alimentées en 5 V et c’est même fait pour ça, le Can.
N’oublies pas de multiplier la vitesse par 2 à cause du Quartz à 8 MHz.
C’est intéressant de disposer aussi d’une solution Can pour le RPi (Jean-Claude ?).
Attention, ne crame rien à quelques jours de l’expo !
Amicalement
Diminique
-
Non je ne fais pas les tests sur le Locoduinodrome mais effectivement sur Raspberry. Non, le reste de la carte nécessite d'être alimenté en 5V, j'ai fait le test
-
Oui je fais erreur, le TJA1050 ne tolère qu’une alimentation de 5V :
(https://i1.wp.com/henrysbench.capnfatz.com/wp-content/uploads/2017/01/Arduino-CAN-Bus-Module-Schematics.png)
-
C'est ce que j'ai constaté et d'ailleurs la datasheet du TJA1050 donne un Vcc de 4,75 à 5,25
-
Non mais non :(
Le TJA 1050 va délivrer une tension sur RXD (5V) qui dépasse ce qui est admissible par le 2515 (3,3 + 1 = 4,3). Ça va marcher car les entrées ont des diodes reliant la broche à VDD mais ces diodes sont prévues pour des dépassement ponctuels, pas répétés. Elle vont chauffer et un jour lâcher.
Pour connecter un 2515 en 3,3 à un transceiver, il faut que ce dernier soit bi-tension : 1 pour le bus, 1 pour l'interface. Par exemple un MCP2562.
Ci-dessous, par exemple, à un CPU en 1,8V
-
Et donc comme le module CAN chinois ne remplit pas le cahier des charge, il faudrait faire une carte passerelle WIFI - CAN. 8)
-
C'est ce que j'ai fait :
(http://www.locoduino.org/local/cache-vignettes/L610xH398/locoduino_wifi_can-gatewayesp8266_nirenmcp2515_dsc6798-deb7b.jpg?1548598598)
-
Envoie moi ton schéma complet :)
-
Le schéma complet de la carte, je ne l'ai pas fait mais MCP et Node MCU voici, pour le reste ce ne sont que des convertisseurs de tension :
(http://alkans.fr/locoduino/tco/img/node_mcu_mcp2515.png)
-
Pour le programme, voici le voici. Je voulais m'y replonger car il y a surement moyen d'optimiser encore.
Le code est disponible sur le github de Locoduino : https://github.com/Locoduino/CanGateway_ESP8266 (https://github.com/Locoduino/CanGateway_ESP8266)