Juste pour éclaircir le débat, un SProg n'est ni plus ni moins qu'un microcontroleur dédié au DCC et à la programmation des décodeurs, et qui peut aussi servir de petite centrale. Ça ressemble furieusement à un Nano chargé de DCC++ ou DCCpp !!J’ai passé un bon bout de temps à réaliser un tel « Sprog » Locoduino qui, comme le dit Thierry n’est qu’un Nano chargé de DCC++ ou DCCpp légèrement modifié. J’y ai adjoint la partie « puissance » qui n’a pas donné les résultats attendus, donc je vais refaire ce projet avec un bon vieux L298 qui permet de cracher 4A avec ses 2 ponts en parallèle.
Dominique,Oui c’est une bonne idée. J’ai fait un proto avec un ESP8266 et les chips Can (plus exactement c’est Jean-Luc qui me l’a fait ;D). L’ESP32 devient la norme donc je le regarde mais de préférence une version bon marché genre WEMOS Mini. Garder le Nano pour DCC++ me semble plus facile pour commander la centrale en USB. De même j’ai pensé au L298 qui est moins cher que le LMD18200 mais nécessite une interface à 2 sorties inversées moins chère que la différence de prix du LMD. L’originalité sera de regrouper les ingrédients (sans CMS) sur un CI 10x10 cm et de rendre cette centrale assez simple pour un enfant de 4 ans avec un smartphone, mais pas forcément avec un soft pc serveur.
C’est un très beau projet, une centrale DCC 4A permettrait de couvrir énormément de cas de figure pour moins de 30€.
Alors le wifi en plus, c’est clairement une bonne idée.
Si je peux me permettre, je propose une autre idée. Et si on prenait un bon ESP32 comme ça on profiterait du wifi et du CAN natif ?
On intègrerait la passerelle wifi CAN qui va bien, le DCC+, un L298, et un SN65HVD230 pour le can. On ajouterait un Max 471 pour surveiller le courant Max.
Je veux bien contribuer si vous le souhaitez.
L'utilisation des deux ponts du L298 en parallèle m'inquiète un peu.
Si l'inversion n'est pas considérée comme rédhibitoire on peut regarder le L6203 donné pour 4A RMS (que j'ai testé fonctionnellement)
Vraiment simple en effet comme messagerie! On peut la coder sur n’importe quel langage, même depuis un autre Arduino/esp voire pire, en php ou en basic ;D
Bonjour à tous,ou celui-là : AMSRI-7805-NZ qui fourni 500mA largement suffisant à mon avis, pour 3€
Quelques questions :
Comment voyez-vous l'alimentation ?
On aurait une alimentation extérieur de 18V et il faudra l'abaisser pour l'alimentation de la carte donc l'ESP32.
L’entrée Vin du «ESP32 DEVKIT» doit fonctionner entre 4,5 et 12 volts. Un régulateur (NCP1117) sur le circuit abaisse la tension à 3,3 volts et fournit un courant maximum de 800ma. Le ESP32 fonctionne entre 2,2 et 3,6 volts.
Je propose de transformer le courant en 5V pour la carte. Il nous faut donc un convertisseur DCDC 18V->5V 1A par exemple.
On peut trouver ce genre de composant :
https://fr.rs-online.com/web/p/regulateurs-a-decoupage/1933998/
https://fr.farnell.com/tracopower/tsr-1-2450/convertisseur-dc-dc5v1asip/dp/1696320
Ayant déjà utilisé des Traco, j'ai un petit faible pour le dernier.
Concernant le SN65HVD233, cela me va bien mais on ne le trouve pas en traversant. Dominique est-ce un point si bloquant pour un voire 2 composants ?Si on ne peut pas éviter le CMS on fera une exception : il faudra que certains d'entre nous soudent ce composant pour ceux qui ne peuvent pas. L'entr'aide fonctionne bien !
Pour surveiller le courant, étant donné que l'on veut aller jusqu'à 4A, on élimine le max471. Il reste l'ACS712 qui fonctionne en 5V et non en 3.3V. Voyez vous d'autres composants pour cette fonction ? Est-ce que ca serait ce composant qui ferait la détection de court-circuit ou un montage plus instantané qui ne passerait pas par le microcontroleur ?L'ACS712ELCTR-05B-T suffirait (5A), mais c'est aussi en CMS ou sous cette forme de carte à adapter :
ou celui-là : AMSRI-7805-NZ qui fourni 500mA largement suffisant à mon avis, pour 3€=> Nickel !
https://www.tme.eu/en/details/amsri-7805-nz/dc-dc-converters/aimtec/
https://www.ebay.com/itm/SN65HVD230-CAN-bus-transceiver-communication-module-For-Arduino-AT/313017061996?hash=item48e145526c:g:CmkAAOSw69BeXmbx=> Celui-ci me va bien !
C'est juste une barette de 6 pattes pour le second ;D
L'ACS712ELCTR-05B-T suffirait (5A), mais c'est aussi en CMS ou sous cette forme de carte à adapter :Là ça me dérange beaucoup plus. Je pensais souder en direct un L298N sur notre PCB, sans prendre une carte breakout, en pontant les 2 drivers pour en voir qu'un seul donc la mesure de courant se prendrait directement sur le PCB, pas de connectique. Ca ferait un PCB super propre !
https://www.ebay.com/itm/1pcs-5A-ACS712ELCTR-05B-Range-Hall-Current-Sensor-Module/253045596473?hash=item3aeab16139:g:R6IAAOSwJq1ZaC61
ou un simple ampli op avec ses résistances pour fixer le gain, là c'est facile en traversant.
Dominique,Étonnant, l’année dernière le 1er septembre je suis passé à Pleurtuit ! J’étais à Dinard. J’aime bien cette région. Moi j’ai 72 ans, je prends mon temps.
J'ai mis à jour mon profil, je m'appelle Cédric, 44 ans et je suis de Dinard (juste à côté en fait, Pleurtuit).
Pour l'alimentation, je partira sur un truc comme ça :Oui. Le but est d'utiliser une alim qu'on a déjà dans un tiroir. Pour le HO (18 ou 19V) ça correspond aux alims de PC portable. Il y en a qui on un gros jack (6,5mm) : j'ai commandé un convertisseur 6,5 <-> 5,5 mais le vendeur s'est trompé et ça ne correspond pas. Ton convertisseur Jack-bornier me semble plus adapté.
On est avec le connecteur classique 5.5*2.1 que l'on retrouve partout. Je propose que l'on soude sur le PCB.
Je ne suis pas très fan d'un second connecteur à vis, je ne trouve pas ça hypra propre. On pourrait par contre associer cette pièce pour permettre de supporter toutes les sources d'énergie :
Là ca me dérange beaucoup plus. Je pensais souder en direct un L298N sur notre PCB, sans prendre une carte breakout, en pontant les 2 driversOui pour souder le pont.
J'ai l'habitude de commander chez tme.eu (c'est du pro, moins risqué)
... un problème à connecter les IN sur des Pin de l'ESP32?C'est justement le problème du L298 et du L6203. Ce problème a été résolu pour un UNO avec son shield moteur (à L298) puisque c'est la Base Station DCC++ d'origine. Je n'en ai pas vu la transposition sur Nano ou Mini, ce qui me fait supposer que ce n'est pas immédiat pour une autre plateforme. Les timings du DCC sont à respecter. Et donc l'avantage du LMD18200 qui ne nécessite pas deux signaux en opposition de phase.
Je n'en ai pas vu la transposition sur Nano ou Mini...
C'est justement le problème du L298 et du L6203. Ce problème a été résolu pour un UNO avec son shield moteur (à L298) puisque c'est la Base Station DCC++ d'origine. Je n'en ai pas vu la transposition sur Nano ou Mini, ce qui me fait supposer que ce n'est pas immédiat pour une autre plateforme. Les timings du DCC sont à respecter. Et donc l'avantage du LMD18200 qui ne nécessite pas deux signaux en opposition de phase.
mais est-ce utile de dépenser son énergie (et de précieux octets/cycles) pour remplacer un transistor à 0,01 € et deux résistances dans le cas du L6203 et L298 ?
- mettre un connecteur d'extension pour utiliser un booster externe (10A par exemple) en n'équipant pas le booster interne (L6203)A partir du moment où on a mis un inverseur pour le L6203, il peut servir pour un module à BTS7960B vendu pour 43A (Antoine connait).
Projet effectivement très intéressant et, cerise sur le gâteau, nous faisons la connaissance de Cédric. Bravo !Je te remercie pour ce message sympathique Denis, je suis très honoré de pouvoir travailler avec votre équipe que je suis depuis longtemps.
J'ajouterai que ce n'est plus possible à notre époque de se satisfaire d'un écran 2 x 20 caractères avec des petits points. Ras le bol de la Multimaus !La question qui se pose est à quoi doit servir l'écran ? Cette console serait piloté essentiellement par un smartphone, une tablette ou un PC. Leurs écrans remplacent avantageusement la multimauss. L'écran que Dominique a retenu (genre 4x20, https://encrypted-tbn0.gstatic.com/images?q=tbn%3AANd9GcQFXeI82cxspLbzkulmZarLNwKCnhaBx1pCjp89EzFd8g8VEYUjoxHZwtpNMPwJTqpE1s6VrMir&usqp=CAc) sur la console serait minimaliste et tu trouveras dans les captures d'écran (draft) ci-joint des cas d'usage que j'imagine.
Il faut alors un connecteur HE10 à 8 broches et une nappe.
Allez, je risque un "gros mot" : faire un cahier des charges :o :oOn est sur le coup, avec Dominique nous avons attaqué un document avec déjà 9 pages au compteur et il est loin d'être terminé.
Donc, au départ, raisonner en modules de fonctions, bien définies, avec toute la souplesse possible.Très bonne remarque. Je pense que si on se donne la possibilité de sortir un bus I2C et une interface SPI, on sera les rois du pétrole en matière d'extension (à nos risques et périls aussi) !
Si plusieurs fonctions sont liées, on les met sur un seul 10x10 et on gagne des connecteurs et de la place.
Tout le monde n'aura pas besoin de tout.
la connectique est un sujet annexe mais ô combien problématique. Le module BTS7960B à 43A est hors sujet mais pour les projets qui l'intègre, le HE10 est la solution native (photo du module) et professionnelle qui s'impose en câblage interne (ou en solution du pauvre en header 2.54) plutôt que de multiples soudures sur un DB9. Mais si on veut faire "pro", regardons ce qui se fait dans notre domaine.CiterIl faut alors un connecteur HE10 à 8 broches et une nappe.
Inutile de devenir les rois du pétrole, le prix du baril n'arrête pas de baisser !Excellent ! Je me suis un peu emporté j'avoue ;D
Si il doit y avoir un booster, il utilisera le signal DCC lui-même.On est d'accord mais du coup il faut juste une masse, le signal IN et le Enable je pense non ?
Et quant aux bus I2C ou SPI, il faudrait là aussi en définir le besoin. Restons intégré, le CAN est là pour çaPas certain en fait. Le CAN nous apportera toute la communication fonctionnelle et là on standardise la connexion en RJ12 comme pour les cartes satellites.
La centrale doit aussi être capable de faire de l'analogique sur du courant pulsé en PWM.J'ai prévu ceci dans le cahier des charges:
En fait, les deux fils du DCC suffisent :CiterSi il doit y avoir un booster, il utilisera le signal DCC lui-même.On est d'accord mais du coup il faut juste une masse, le signal IN et le Enable je pense non ?
Pour les tensions, ce sera à l'utilisateur de choisir le(s) bloc(s) secteur qui convient à son matériel.
En fonction de ses décodeurs ou de ses locos analogiques (et de son gout du risque)
On a donc CINQ ordres depuis le gestionnaire -> centrale DCC
Et AUCUN ordre depuis la centrale DCC -> le gestionnaire.
Je me demande si on doit absolument avoir un bus CAN dans la centrale DCC.
1°) si on n'a pas de gestionnaire, on n'a carrément pas besoin de bus du tout.
Nota : ce sera le cas de tous les débutants
2°) si on a un gestionnaire, on va échanger des informations.Et si on ne veut pas de PC Mac Linux qui, eux, n'ont pas de Can natif...
La distance entre le PC/Mac/Linux et la centrale est courte.
Les parasites seront donc faciles à éliminer.
On a donc CINQ ordres depuis le gestionnaire -> centrale DCCquel économie fais-tu en supprimant le Can, voire l'ESP32 que tu remplaces par quoi ?
Et AUCUN ordre depuis la centrale DCC -> le gestionnaire.
Donc, je trouve que mettre un CAN pour 5 ordres dans un seul sens, c'est luxueux. Et on gagne 2 RJ (au moins) et on n'est pas obligé de choisir un processeur avec le CAN en natif.
xTaskCreatePinnedToCore(
Task1code, /* Function to implement the task */
"Task1", /* Name of the task */
10000, /* Stack size in words */
NULL, /* Task input parameter */
0, /* Priority of the task */
&Task1, /* Task handle. */
0); /* Core where the task should run */
et ensuite on implémente notre fonction :Void Task1code( void * parameter) {
for(;;) {
Code for task 1 - infinite loop
(...)
}
}
Les logiciels classiques (Trains Controller, JMRI, ...) gèrent le réseau sur un ordi et utilisent la centrale effectivement quasiment comme un booster, comme l'a dit msport.Tu as raison pour les réseaux assez grands comme ceux que tu traites dans ton logiciel : la modélisation (définition) du réseau (cantons, aiguilles, signaux, itinéraires, beaucoup de trains) avec une IHM de configuration demandent un PC a part entière, pour adresser tous les cas possibles.
A une nuance près, importante :
La gestion qui doit être dans la centrale DCC, c'est la gestion du ralenti, de l'accélération, de l'inertie, des fonctions. Et là, on n'est plus dans le booster.
Des trains automatiques aussi sont possibles tant qu’il ne doivent pas traverser le grill de la gare saint lazare !
C'est là que commencent les ennuis ...... Et les choses intéressantes !
Et oui, avec des satellites on gère les signaux comme les aiguilles et les détecteurs !
Bonsoir,
Avec Dominique, on pensait qu'il fallait pouvoir profiter de l'ESP32 et notamment de ses doubles coeurs processeur.
L'ESP32 embarque le FreeRTOS, un OS temps réel puissant mais qui pour autant un peu bridé par Arduino IDE qui n'exploite au final qu'un coeur (le coeur n°1, sachant que le coeur n°0 ingère de l'idle pendant ce temps).
Après on entre dans le domaine du multitâche / multi thread donc attention aux MUTEX qu'il faudra gérer à la pogne si nécessaire.
Très interessant, mais est-ce accessible à l'Arduino IDE ?
TaskHandle_t Task0;
TaskHandle_t Task1;
int intVar = 0;
void setup() {
Serial.begin(115200);
delay(2000);
Serial.printf("\n");
//create a task that will be executed in the Task0code() function, with priority 1 and executed on core 0
xTaskCreatePinnedToCore(
Task0code, /* Task function. */
"Task0", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
1, /* priority of the task */
&Task0, /* Task handle to keep track of created task */
0); /* pin task to core 0 */
delay(500);
//create a task that will be executed in the Task1code() function, with priority 1 and executed on core 1
xTaskCreatePinnedToCore(
Task1code, /* Task function. */
"Task1", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
1, /* priority of the task */
&Task1, /* Task handle to keep track of created task */
1); /* pin task to core 1 */
delay(500);
}
//Task0code
void Task0code( void * pvParameters ) {
Serial.printf("Task0 running on core : %d\n", xPortGetCoreID());
for (;;) {
intVar++;
delay(1000);
}
}
//Task1code
void Task1code( void * pvParameters ) {
Serial.printf("Task1 running on core : %d\n", xPortGetCoreID());
for (;;) {
Serial.printf ("intVar = %d\n", intVar);
delay(1000);
}
}
void loop() {}
Bonjour Christophe,
Je pense que sur une donnée partagée de type int, ton code ne risque rien. Par contre, si on s'amuse à modifier un objet sur un coeur et de manipuler l'objet par l'autre coeur, je crois qua ça se passera mal tôt ou tard.
A+
L'exemple est sympa et parlant. La difficulté de la gestion multi-tâche réside essentiellement par les synchronisations qu'il faut généralement mettre en place pour éviter les conflits d’accès et/ou d'écriture sur les mêmes données. Les langages C et C++ prévoient des mécanismes type mutex, sémaphore ou lock pour justement contourner ces problèmes. Je ne sais pas ce qui est vraiment disponible pour l'ESP32, et en particulier si c'est utilisable avec un Arduino IDE...
Il m’intéresserait d’appliquer cela à ma passerelle CAN/WiFi car c’est exactement la problématique.
TaskHandle_t Task0;
TaskHandle_t Task1;
SemaphoreHandle_t xSemaphore = NULL; // semaphore d'exclusion mutuelle
int intVar0 = 0;
int intVar1 = 0;
void setup() {
Serial.begin(115200);
delay(2000);
Serial.printf("\n");
xSemaphore = xSemaphoreCreateMutex(); // creation du semaphore
//create a task that will be executed in the Task0code() function, with priority 1 and executed on core 0
xTaskCreatePinnedToCore(
Task0code, /* Task function. */
"Task0", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
1, /* priority of the task */
&Task0, /* Task handle to keep track of created task */
0); /* pin task to core 0 */
delay(500);
//create a task that will be executed in the Task1code() function, with priority 1 and executed on core 1
xTaskCreatePinnedToCore(
Task1code, /* Task function. */
"Task1", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
1, /* priority of the task */
&Task1, /* Task handle to keep track of created task */
1); /* pin task to core 1 */
delay(500);
}
//Task0code
void Task0code( void * pvParameters ) {
Serial.printf("Task0 running on core : %d\n", xPortGetCoreID());
for (;;) {
if( xSemaphore != NULL )
{
if( xSemaphoreTake( xSemaphore, ( TickType_t ) 10 ) == pdTRUE ) // essai d'obtention du semaphore
{
if (intVar0==intVar1) intVar0++;
xSemaphoreGive( xSemaphore ); // liberation du semaphore
}
else
{
Serial.printf("Task0 on core : %d pas obtenu semaphore\n", xPortGetCoreID());
}
}
delay(10); // delay(1000); // plus vite ou moins vite
}
}
//Task1code
void Task1code( void * pvParameters ) {
Serial.printf("Task1 running on core : %d\n", xPortGetCoreID());
for (;;) {
if( xSemaphore != NULL )
{
if( xSemaphoreTake( xSemaphore, ( TickType_t ) 10 ) == pdTRUE ) // essai d'obtention du semaphore
{
if (intVar0==intVar1+1) { intVar1++; Serial.printf (" %d %d\n", intVar0,intVar1); }
xSemaphoreGive( xSemaphore ); // liberation du semaphore
}
else
{
Serial.printf("Task1 on core : %d pas obtenu semaphore\n", xPortGetCoreID());
}
}
delay(500);
}
}
void loop() {}
TaskHandle_t vSenderTask;
TaskHandle_t vReceiverTask;
/* Declaration d'une variable xQueue de type QueueHandle_t qui servira a stocker la file. */
QueueHandle_t xQueue;
/* Taille de la file*/
int queueSize = 1000;
/* Taille maxi de la chaine de caractere */
#define maxCaractInQueue 25
void setup() {
Serial.begin(115200);
delay(2000);
Serial.printf("\n");
xQueue = xQueueCreate( queueSize, maxCaractInQueue );
if ( xQueue != NULL ) {
xTaskCreatePinnedToCore(
vSenderTaskCode, /* Task function. */
"vSenderTask", /* name of task. */
10000, /* Stack size of task */
NULL,
1, /* priority of the task */
&vSenderTask, /* Task handle to keep track of created task */
0); /* pin task to core 0 */
delay(500);
xTaskCreatePinnedToCore(
vReceiverTaskCode, /* Task function. */
"vReceiverTask", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
2, /* priority of the task */
&vReceiverTask, /* Task handle to keep track of created task */
1); /* pin task to core 1 */
delay(500);
}
else
/* The queue could not be created. */
Serial.printf("The queue could not be created.");
}
void vSenderTaskCode( void *parameter ) {
BaseType_t xStatus;
/* Variable qui va contenir la valeur a envoyer*/
char strTx[maxCaractInQueue];
Serial.print("vSenderTask\n");
for (int i = 0; i < queueSize; i++) {
sprintf(strTx, "Ligne %d", i);
xStatus = xQueueSendToBack( xQueue, (char*) strTx, 0 );
if ( xStatus != pdPASS )
Serial.printf( "Could not send to the queue.\r\n" );
else
Serial.printf("Send : %s\n", strTx);
}
vTaskDelete( NULL );
}
void vReceiverTaskCode( void *parameter ) {
BaseType_t xStatus;
/* Variable qui va contenir la valeur recue*/
char strRx[maxCaractInQueue];
const TickType_t xTicksToWait = pdMS_TO_TICKS( 100 );
Serial.print("vReceiverTask\n");
for ( ;; ) {
if ( uxQueueMessagesWaiting( xQueue ) != 0 )
Serial.printf( "Queue should have been empty!\n" );
xStatus = xQueueReceive( xQueue, &strRx, xTicksToWait );
if ( xStatus == pdPASS )
/* Data was successfully received from the queue, print out the received
value. */
Serial.printf( "Received : %s\n", &strRx );
else
Serial.printf( "Could not receive from the queue.\r\n" );
}
}
void loop() {}
TaskHandle_t Task0;
TaskHandle_t Task1;
SemaphoreHandle_t xSemaphore = NULL; // semaphore d'exclusion mutuelle
char chaine[11]; // chaine de 10 caracteres
void setup() {
Serial.begin(115200);
delay(2000);
Serial.printf("\n");
chaine[10]=0;
xSemaphore = xSemaphoreCreateMutex(); // creation du semaphore
//create a task that will be executed in the Task0code() function, with priority 1 and executed on core 0
xTaskCreatePinnedToCore(
Task0code, /* Task function. */
"Task0", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
1, /* priority of the task */
&Task0, /* Task handle to keep track of created task */
0); /* pin task to core 0 */
delay(500);
//create a task that will be executed in the Task1code() function, with priority 1 and executed on core 1
xTaskCreatePinnedToCore(
Task1code, /* Task function. */
"Task1", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
1, /* priority of the task */
&Task1, /* Task handle to keep track of created task */
1); /* pin task to core 1 */
delay(500);
}
//Task0code
void Task0code( void * pvParameters ) {
Serial.printf("Task0 running on core : %d\n", xPortGetCoreID());
for (;;) {
if( xSemaphore != NULL )
{
if( xSemaphoreTake( xSemaphore, ( TickType_t ) 10 ) == pdTRUE ) // essai d'obtention du semaphore
{
for (int i=0; i<10; i++) { chaine[i]='-'; delay(5); } // effacement de la chaine
for (int i=0; i<10; i++) { chaine[i]='0'+i; delay(5); } // fabrication de la chaine
xSemaphoreGive( xSemaphore ); // liberation du semaphore
}
else
{
//Serial.printf("Task0 on core : %d pas obtenu semaphore\n", xPortGetCoreID());
}
}
delay(10); // delay(1000); // plus vite ou moins vite
}
}
//Task1code
void Task1code( void * pvParameters ) {
Serial.printf("Task1 running on core : %d\n", xPortGetCoreID());
for (;;) { //int intVar;
if( xSemaphore != NULL )
{
if( xSemaphoreTake( xSemaphore, ( TickType_t ) 10 ) == pdTRUE ) // essai d'obtention du semaphore
{
for (int i=0; i<10; i++) { Serial.printf ("%c",chaine[i]); delay(10); }
Serial.printf ("\n"); // affichage de la chaine
xSemaphoreGive( xSemaphore ); // liberation du semaphore
}
else
{
//Serial.printf("Task1 on core : %d pas obtenu semaphore\n", xPortGetCoreID());
}
}
delay(500);
}
}
void loop() {}
/*
Documentation @ http://web.ist.utl.pt/~ist11993/FRTOS-API/group___queue_management.html#xQueueReceive
*/
TaskHandle_t vSenderTask;
TaskHandle_t vReceiverTask;
/* Declaration d'une variable xQueue de type QueueHandle_t qui servira a stocker la file. */
QueueHandle_t xQueue;
/* Taille de la file*/
const uint32_t queueSize = 1000; // Prevoir une taille suffisante pour ne pas perdre de messages
/* Taille maxi de la chaine de caractere */
#define maxCaractInQueue 25
struct Msg {
uint32_t id;
char str[maxCaractInQueue];
} msg;
void setup() {
Serial.begin(115200);
delay(2000);
Serial.printf("\n");
xQueue = xQueueCreate( queueSize, sizeof( struct Msg * ));
if ( xQueue != NULL ) {
xTaskCreatePinnedToCore(
vSenderTaskCode, /* Task function. */
"vSenderTask", /* name of task. */
10000, /* Stack size of task */
NULL,
1, /* priority of the task */
&vSenderTask, /* Task handle to keep track of created task */
0); /* pin task to core 0 */
delay(500);
xTaskCreatePinnedToCore(
vReceiverTaskCode, /* Task function. */
"vReceiverTask", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
2, /* priority of the task */
&vReceiverTask, /* Task handle to keep track of created task */
1); /* pin task to core 1 */
delay(500);
}
else
Serial.printf("The queue could not be created.");
}
void vSenderTaskCode( void *parameter ) {
struct Msg *ptTxMsg;
BaseType_t xStatus;
ptTxMsg = &msg;
Serial.print("vSenderTask\n");
for (int i = 0; i < 10000; i++) {
ptTxMsg->id = i;
sprintf(ptTxMsg->str, "Ligne %d", i);
xStatus = xQueueSendToBack( xQueue, (void*) &ptTxMsg, 0 );
if ( xStatus == pdPASS )
Serial.printf("Send : %d\n", ptTxMsg->id);
else
Serial.printf( "Could not send to the queue.\n" );
}
vTaskDelete( NULL );
}
void vReceiverTaskCode( void *parameter ) {
struct Msg *ptRxMsg;
BaseType_t xStatus;
const TickType_t xTicksToWait = pdMS_TO_TICKS( 100 );
Serial.print("vReceiverTask\n");
for ( ;; ) {
if ( uxQueueMessagesWaiting( xQueue ) != 0 )
Serial.printf( "Queue should have been empty!\n" );
xStatus = xQueueReceive( xQueue, &(ptRxMsg), xTicksToWait );
if ( xStatus == pdPASS )
Serial.printf( "Received n° %d - value : %s\n", ptRxMsg->id, ptRxMsg->str );
else
Serial.printf( "Could not receive from the queue.\n" );
}
}
void loop() {}
Tu est sur que les xQueue incluent un mécanisme de protection contre les accès simultanés issus de plusieurs taches ?
... lister les tâches qui vont résider dans ce processeur et les messages qui devront passer de l’une à l’autre (ou les autres).Bonsoir,
Pour me permettre une évolution en douceur vers les satellites en CAN, au moins l'entrée de commandes en serial sur RX/TX me serait nécessaire.
A mon avis, le gestionnaire, même mini, doit être à l'extérieur de la Box.
Dans un monde uniquement DCC, on peut changer la position d'une aiguille en envoyant un ordre DCC (par exemple depuis la Multimaus).
Vu de l'utilisateur, il y a une seule interface (un seul clavier, un seul "écran" d'affichage, un seul bus)
Ici, il n'est pas prévu d'envoyer cet ordre vers le DCC, mais vers le CAN. On est tous d'accords là dessus.
...
Dès que l'on aura une idée précise des messages sur le CAN, je ferai tout pour que mon gestionnaire soit compatible.
Ou plus simple avec 2 transistors et 4 résistances :C'est justement le schéma de la moitié de ce module à 0,92€ ...
A noter : When using the ESP32 with Arduino IDE, the default I2C pins are GPIO 22 (SCL) and GPIO 21 (SDA)
Je suis parti d’un code que Dominique avait trouvé sur internet : https://github.com/vhar/withrottle
J’ai corrigé quelques bugs sur les requêtes TCP et je l’ai adapté à l’ESP32 car à l’origine, il a été développé pour l’ESP8266.
Il faut que je mettre le code au propre et je le déposerai très bientôt sur le github de Locoduino (à moins que certains soient si pressés que je doive leur envoyer en l’état).
Alors que je viens tout juste de terminer cette première brique, je me rends compte qu’il y a tout de même une grosse lacune et qu’il est bien exagéré d’appeler ceci « centrale DCC ».
En effet, WiThrottle qui au passage est totalement verrouillé et pas du tout open source, ne permet pas de faire le moindre réglage sur les décodeurs ni même de lire l’adresse d’une locomotive. C’est pour cela que vous voyez deux locomotives sur la vidéo, j’avais complètement oublié l’adresse de la 150 Y et il m’était impossible de l’utiliser.
On ne peut pas avoir que des locomotives avec la seule adresse 3.
Tout au mieux, je pense qu’il faut considérer ce projet à ce stade comme une manette de commande qui ne peut se dispenser d’un logiciel comme JMRI et en particulier de son extension Decoder Pro !
Ou alors, il faut implémenter dans l’ESP32 une partie logicielle qui permettra de lire et écrire sur les décodeurs, modifier les adresses et certains paramètres comme le volume du son…
Dans la mesure où l’ambition de cette centrale est assez modeste, cette programmation devra pouvoir se faire sur la voie principale avec une seule carte moteur donc.
Donc ce n’est pas fini. Moi je suis plus tenté de faire une centrale autonome et je propose donc développer la partie programmation des décodeurs avec une IHM qui va bien sur l’ESP32.
A suivre donc.
Christophe
Ton point de vue me semble un peu négatif mais la discussion est ouverte !
J'invite donc les lecteurs de ce fil à indiquer ce qu'ils souhaitent et ce qu'ils en penses de leur point de vue.
Par exemple, je n'envisage pas de conduire mes trains avec un mobile. Ce n'est pas une nécessité.
Il faut pouvoir commander bêtement avec un ou plusieurs boutons qui seraient sur la Box et un simple TCO physique avec des vrais boutons et des LED.
Pour moi, c'est ça la brique de base, avec DCCpp.
Mais avec un CAN pour commander les aiguilles, le retour d'information, ...
Pensez à tous ceux qui, comme moi, aimeraient comprendre comment ça marche :
On tourne un potar, on appuie sur un bouton, on allume une LED, ça c'est du vrai et on essaie de suivre comment ça se passe dans la programme.
Parce que si on utilise le JMRI via le wifi pour utiliser le CAN, on y comprend que dalle.
Ce n'est pas par là qu'il faut commencer.
Ne perdez pas en route ceux qui essaient de vous suivre.
Denis
Mais je suis tout de même très réservé sur le principe de faire des développements sur la base d’un logiciel « non open source » que nous ne pouvons pas adapter alors que nous sommes tout à fait capables de réaliser nos propres développements. Et sur lequel nous n’avons aucune certitude pour le futur. Mais c’est juste une opinion et chacun peut faire comme il l’entend.
Personnellement et puisque tu nous demandes notre avis, voici comment moi je vois les choses.
- Un ESP32 qui sert de passerelle WiFi entre des périphériques communicants en TCP (Withrottle, JMRI, manette de Tony, développements propres comme mon controller …) C’est très vaste. Ca peut aussi être quelque chose de plus matériel (moins virtuel) comme la manette de Tony pour peu que l’un implémente dans la manette un codeur en langage DCC++. Ce n’est pas très compliqué et s’apparente à ce qui a été fait pour Withrottle.
- Un Arduino Nano qui fait office de Base Station pour DCC++ en attendant un déploiement de DCCpp sur ESP32
- Ces deux cartes étant implantées sur un PCB, je verrais bien sur le PCB l’implantation d’un pont en H (18200 ou mieux carte 4A dont vous parliez)
- L’emplacement pour un second pont en H (pour une voie de programmation optionnelle) qu’il serait possible d’implanter ou non selon le choix de chacun.
- Et bien sûr les mesures de courant et de tension pour les sécurités.
- Et puis des écrans oled, c’est vrai que ça fait chic pour tracer l’activité ! Et c’est pratique.
Voilà à quoi je me limiterais. Cela ferait donc une (petite) central DCC++ pouvant être pilotée par de nombreux périphériques, pour certains totalement logiciels comme JMRI ou mon controller, d’autres logiciels avec conversion de signaux comme Withrottle, d’autres très matériels avec des boutons et des encodeurs rotatifs pourquoi pas. On voit bien que ça devient une centrale très universelle avec un point de convergence, DCC++ qui fait l’unanimité.
Cette centrale, je me répète, pouvant disposer ou non des composants électroniques permettant de disposer ou non d’une voie de programmation et implantés ou non.
Il n’y a pas pour moi de nécessité de disposer du CAN sur cette carte.
Automate ou gestionnaire font pour moi l’objet d’un autre projet (en lien certes) mais sinon, nous ne sortirons jamais rien. Bien sûr, gestionnaires et automates sont des périphériques à part entière comme ceux que j'ai cité car ils se servent de cette Base Station pour transmettre leurs ordres aux locomotives.
Je suis totalement convaincu et je pousserai toujours pour l’utilisation des satellites et de la communication en CAN pour le gestionnaire, l’automate, la rétrosignalisation, les commandes d’aiguillages, de feux de signalisation etc… etc… mais je pense que vous avez bien compris que c’est pour moi un autre projet.
Christophe
Le Nano pour DCCpp : on attend de savoir si DCC++ est dispo sur ESP32 : on n'est pas à un mois près
J'ai poussé la version 1.4.0 de DCCpp qui intégre l'ESP32
Et à droite la carte L6203 faite par Michel, ... pouvant fournir 4A.
Vous avez prévu de le refroidir ou pas plus que ça ?
Pour l'approvisionnement, en L6203, avez-vous prévu quelque chose de particulier ? Tout le monde à pu se rendre compte qu'avec la Chine, c'était de plus en plus long.
Pour ma part, ayant un compte chez RS, je peux les toucher à 6,47 l'unité ou à 5,58 par 25. Franco de port, livré le lendemain même en ce moment. Est-ce que ça vous parait intéressant ?
Les principales usines de fabrication de ST sont situées à Agrate Brianza et Catane (Italie), Crolles, Rousset et Tours (France), ainsi qu'à Singapour. S'y ajoutent les sites d'assemblage et de test implantés en Chine, en Malaisie, à Malte, au Maroc, aux Philippines et à Singapour.
Les principales usines de fabrication de ST sont situées à Agrate Brianza et Catane (Italie), Crolles, Rousset et Tours (France), ainsi qu'à Singapour. S'y ajoutent les sites d'assemblage et de test implantés en Chine, en Malaisie, à Malte, au Maroc, aux Philippines et à Singapour.
Ok mais ça répond pas à ma question.
Je demandais simplement si : à 6,47 l'unité ou à 5,58 par 25. Franco de port, livré le lendemain même en ce moment. Est-ce que ça vous parait intéressant ?
Il y en a 75 en stock livrables mardi si commande lundi avant 19 H.
En d'autres termes, seriez vous intéressés que je passe commande à ce prix et que je dispatch (pas trop tout de même pour ne pas ajouter trop de port) ?
C'est comme tu veux Christophe, vu que l'ESP32 peut faire fonctionner quasiment toutes ses broches sous interruption. Pour mes tests j'ai utilisé
DCCpp::beginMain(UNDEFINED_PIN, 22, UNDEFINED_PIN, A0);
Michel a dessiné un 1er PCB, s'il peut nous le montrer pour se fixer les idées.les gerbers sont plus haut.
Vous avez prévu de le refroidir ou pas plus que ça ?
J'ai essayé : DCCpp::beginMain(UNDEFINED_PIN, 32, UNDEFINED_PIN, A6); et DCCpp::beginMain(UNDEFINED_PIN, 32, UNDEFINED_PIN, 34);
A titre indicatif, j'ai conservé le MAX471 du montage à LMD1800 avec le L6203 ( R sense shuntée) sans souci.
Bonjour à tous,
Je vais faire un test aussi de mon côté en partant aussi sur les pins 32 et 34.
Pour la mesure de courant, sachant qu’on utilisera le L6203 avec un ampli du côté GND ( contrairement au Max471), on déterminera cette valeur par expérience.
Je reviens vers vous dans la matinée.
Dominique
DCCpp::beginMain(UNDEFINED_PIN, 32, 34, UNDEFINED_PIN); // 32=DCC(Dir), 34=pwm/enable, 36=A0 current senseLe moniteur affiche le déroulement des commandes DCC++.| SCENARIO | CPU80MHz | CPU160MHz | CPU240MHz |
| CPU + électronique | 38mA | 51mA | 73mA |
| CPU + électronique + BT | 113mA | 123mA | 141mA |
| CPU (deep sleep) + électronique | 3.5mA | 3.5mA | 3.5mA |
Bonjour,
Tant qu'on en est aux limiteurs de surintensités, il faudra se rappeler de ce qu'on dit quand on en sera aux boosters.
Ex : 4 limiteurs 2,5 A en sortie d'un booster 10 A en séparant les zones.
Comme ça, si on a un CC à un endroit, on ne plante pas tout le réseau, mais seulement une zone correspondant à son limiteur.
Denis
2. Dans la philosophie du chinois pas cher et pas trop mauvais (dixit un vendeur de la rue Montgallet qui a su conserver son humour) :Je connais et j’aime assez ce composant. Il a inconvénient même si c’est plutôt mineur, il faut régler la tension de sortir avec le potentiomètre. Cela ne me semble pas le plus simple par contre le rendement est tellement qu’il chauffe peu.
https://www.ebay.fr/itm/3A-Voltage-Regulator-Converter-Buck-Converter-Mini-Step-Down-LM2596-2596S-Module/263153078280
Les 3A sont certainement optimistes mais 130mA, voire 600mA devraient passer. (1.5A permanent)
Je connais et j’aime assez ce composant. Il a inconvénient même si c’est plutôt mineur, il faut régler la tension de sortir avec le potentiomètre. Cela ne me semble pas le plus simple par contre le rendement est tellement qu’il chauffe peu.
Autre avantage, il ne coute pas grand chose surtout par 5 ou 10.
Dominique, je suis désolé, mais tout est donc à réécrire ! Je veux bien commencer à regarder et faire cela avec toi et avec tous ceux que ça intéresse.Il n'y a pas à être désolé car je comprends bien qu'on peut éviter deux parser en série et qu'il doit être possible d'attaquer DCC++ (paquetRegister) directement. Mais c'est une méthode d'accès nouvelle qui doit nécessiter une interface (qui existe déjà, à mon avis). Pour ce qui concerne le décodage des messages de Withrottle, le parser reste à peu près le même mais ne génèrera pas de messages DCC++.
Concernant la possibilité de communiquer via CAN avec cette centrale, l’une des premières préoccupations est d’adopter une messagerie performante. En existe t’il déjà ? Qui n’aurait pas forcément besoin d’être au format DCC++. Seule la structure en message CAN de chaque commande nous intéresse : Avant, arrière, vitesse, eStop, fonctions etc… Faut-il en créer une ? Oui s’il n’y en a pas. Par contre, pour la programmation et la lecture des CV's ça va être une autre paire de manche.
Le module a MP158 (1er) semble plus performant que celui a MP2307 (2e), plus petit. Mais on peut prévoir les deux empreintes superposées ...
J'ai regardé les schémas de l'ESP32 DevKitC et je vois un seul régulateur qui fait du 3.3V depuis une source 5V Externe. Cette source vient soit de la PIN 5V Ext soit de l'USB mais du coup il faut que cela soit un vrai 5V et non un 7 ou 8V car il ne sera pas régulé. Je crains que l'étalonnage s'impose.
Bonjour
https://model-railroad-hobbyist.com/node/35652
Marcel
la carte officielle (image ci-dessous) qui a la chance de se trouver partout
la carte officielle (image ci-dessous) qui a la chance de se trouver partout
A vrai dire, j'ai beau chercher je ne trouve pas ta carte, juste des tonnes d'exemplaires de la mienne, que ce soit sur ebay ou les sites chinois... Je voulais vérifier que le composant qui ressemble à un 7805 au milieu de ta carte était bien ça.
Sans être rabat-joie, j'ai commandé ces ESP32 pour la raison que GEOFFB explique ci-aprés.l
Il faut remonter à la source qui est ESPRESSIF :
on y trouve le schéma open source de la carte de développement :
Apparemment (à vérifier) l'entrée 5V ne fait qu'alimenter le régulateur 3.3V, un AMS1117 3.3 donc capable de tenir jusqu'à 15V.
Le problème reste la dissipation de température, Rth = 90°/W, température de fonctionnement maxi : 125°C avec protection thermique.
Mais il vaut mieux rester au standard de Vin = 5V si on ne voit pas de bonne raison d'en changer.
Le schéma open source prévoit un connecteur 2x19 pour cette version du 6/12/2017.
Cette version peut être retenue pour notre projet.
https://docs.espressif.com/projects/esp-idf/en/latest/esp32/hw-reference/esp32/get-started-devkitc.html
Bon on a quand même un gros problème : ce projet n'a pas de nom !
A vos plumes.
Non, ce que je vois, c'est de diviser le réseau en sections.
En sortie de La Box, on a 4A. C'est bien pour un réseau, mais c'est trop (à mon avis) pour une section.
Mon idée : séparer les sections de façon à ce qu'un CC ne plante pas toute La Box. Avec ce schéma, on n'a qu'une zone de coupée.
C'est dans cet usage que j'ai proposé ce petit circuit.
Received extended packet with id 0x1FFFFF27 and length 3 hex 1 4 FF
Received extended packet with id 0x1FFFFF27 and length 3 hex 81 4 FF Received extended packet with id 0x1FFFFF27 and length 4 hex 0 1 6 A5
Received extended packet with id 0x1FFFFF27 and length 4 hex 0 1 6 A6
Received extended packet with id 0x1FFFFF27 and length 4 hex 0 1 6 A7
Received extended packet with id 0x1FFFFF27 and length 4 hex 0 1 6 A8
Received extended packet with id 0x1FFFFF27 and length 4 hex 0 1 6 A9
Received extended packet with id 0x1FFFFF27 and length 6 hex 0 2 40 C CC CC
Received extended packet with id 0x1FFFFF27 and length 6 hex 0 2 40 13 33 32
Received extended packet with id 0x1FFFFF27 and length 6 hex 0 2 40 19 99 98
Received extended packet with id 0x1FFFFF27 and length 6 hex 0 2 40 1F FF FEReceived packet with id 0x20 and length 3 hex 0 0 0
Received packet with id 0x26 and length 3 hex 0 0 80
Received packet with id 0x22 and length 3 hex 0 0 80
Received packet with id 0x24 and length 3 hex 0 0 0
Il semble y avoir quelques divergences entre l'affectation des pins et le schéma Eagle, mais c'est de la relecture.Le mieux est que tu signales tout ce que tu vois.
Je ne comprends pas le branchement du MP2307, ni d'où vient le 3.3V ?LE MP2307 est une alternatif au MP1584. Les entrées à gauche pour le MP2307 sont décallées par rapport aux entrées du MP1584 de façon à pouvoir équiper la carte soit avec l'un, soit avec l'autres (les sorties sont les même).
Bonjour,Non, sauf via le bus d'extension
Mais, au fait, on prévoit une sortie pour la voie de programmation ? 1A est suffisant.
Denis
Bonjour,
Sur un schéma d'Elektor qui utilise un ESP32, on nous explique que si l'alimentation n'est pas faite par un 7805, mais par un convertisseur DC/DC, la tension de sortie (le 5V) peut n'être pas tout à fait stable au début.
Ils conseillent de brancher un condo de 10 µF entre la broche EN (broche 2) et la masse, ce qui retarde la mise en route de l'ESP32, le temps que la tension se stabilise.
Mais il est certainement trop tard pour modifier le CI...
Denis
... le numéro de version ...
| Michel | 2 |
| Dominique | 2 |
| Cédric | 1 |
| Christophe | 1 |
| Thierry | 1 |
| Denis | 1 |
| Marcel | 1 |
/*************************************************************
project: <LaBox>
author: <Thierry PARIS>
description: <LaBox Wifi Controller sample>
*************************************************************/
#include "LaBox.h"
#if !defined(USE_TEXTCOMMAND) || !defined(USE_WIFI)
#error To be able to compile this sample,the lines #define USE_TEXTCOMMAND and #define USE_WIFI must be uncommented in DCCpp.h
#endif
// WIFI
const char* ssid = "ssid";
const char* password = "password";
// the media access control (ethernet hardware) address for the shield:
uint8_t wifiMac[] = { 0xBE, 0xEF, 0xBE, 0xEF, 0xBE, 0x80 };
//the IP address for the shield:
uint8_t wifiIp[] = { 192, 168, 1, 100 };
// SERIAL
SERIAL_INTERFACE(Serial, Normal);
ThrottleSerial throttleSerial("Serial", new SerialInterfaceNormal());
ThrottleWifi throttleWifi("Wifi", wifiMac, wifiIp, 2560, TCP);
void setup()
{
Serial.begin(115200);
Serial.println("LaBox 0.2");
// Add 4 Wifi clients
ThrottleWifiAPClient::connectWifi(ssid, password, 23, 4);
Throttles::printThrottles();
DCCpp::begin();
/* Configuration for ESP32, can be adapted...
DIR -> GPIO_32
PWM -> EN
MAX471 -> GPIO_36 (A0)
*/
DCCpp::beginMain(UNDEFINED_PIN, 32, 34, A0);
}
void loop()
{
DCCpp::loop();
}
Bonjour
Pour répondre a la question, est ce que cela m'intéresse ?
Je répondrai oui, pour moi.
Je suis ce fil en sous-marin depuis bien longtemps.
Mais vous m'avez coulé depuis … bien longtemps aussi !
J'ai pas tout compris :)
redémarrer l'ESP suffit...J'ai dû louper quelque chose :o
Les connections réseau s'établissent pendant le setup, toutes les connections Wifi par exemple
Je pense que toutes ces infos doivent être dans le gestionnaire (le TCO, en particulier)
Ne pas s'inquiéter du clignotement, c'est juste une histoire de fréquence de l'IHM vs la fréquence de la caméra. En vrai, tout est net et sans clignotement.Désolé, mais, si, je m'inquiète. Il faut ajuster la fréquence de l'IHM pour qu'on n'ait plus ce phénomène. Tu vas me dire que je m'intéresse plus à la forme qu'au fond (et, ici, tu as raison), mais je n'ai toujours pas vu la fin de la vidéo (c'est vraiment pénible). Sorry…
Désolé...ceux-là ont l'air pas mal : https://www.aliexpress.com/snapshot/0.html?orderId=8011987484957074 (https://www.aliexpress.com/snapshot/0.html?orderId=8011987484957074)
J'ai, bien sûr, un Androïd, mais pas d'ESP32. Je vais faire une commande chez TME.
Denis
C'est vraiment bien. Plein de bonnes idées et visiblement, une bonne maîtrise. Bravo !Merci ;)
Ne pas s'inquiéter du clignotement, c'est juste une histoire de fréquence de l'IHM vs la fréquence de la caméra. En vrai, tout est net et sans clignotement.Je comprends, c'est pénible. Je t'assure que l'on ne voit rien à l'oeil. Ensuite cela ne vient pas de moi, j'ai beau mettre un vilain delay de 5000 dans la loop, cela clignote pareil. Pas contre mes boutons deviennent inutilisables :)
Désolé, mais, si, je m'inquiète. Il faut ajuster la fréquence de l'IHM pour qu'on n'ait plus ce phénomène. Tu vas me dire que je m'intéresse plus à la forme qu'au fond (et, ici, tu as raison), mais je n'ai toujours pas vu la fin de la vidéo (c'est vraiment pénible). Sorry…
C'est marrant que tu aies pensé, d'emblée, de gérer du multilingue…
Je note que tu parles de mémoriser et c'est une excellente chose.Pour l'instant je mémorise en RAM et je ne me suis pas encore penché sur l'EEPROM.
Que doit-on mémoriser quand on a fini la session pour pouvoir la retrouver la prochaine fois ?
Qu'est ce qui est vraiment indispensable ?
Mémorise-t-on des choses périodiquement pour pouvoir repartir suite à coupure courant ? (on appréciera lors d'une démo).
On sera certainement très limité par la taille de l'EPROM.
Je note que tu gère les trois derniers trains dynamiquement. Tu verras quand je publierai très prochainement la dernière version de mon gestionnaire sur laquelle je travaille actuellement qu'on a eu la même idée.Nickel ! En fait j'en garde 10 en mémoire mais l'afficheur permet simplement d'afficher 3 trains (les 3 premiers de la pile). A chaque réception d'un changement pour un train, je positionne ce train en haut de la pile (indice 0). Les autres sont alors tous décalés des un, jusqu'à l'effacement en cas de 11 trains pilotés.
Concernant les images : très bonne idée d'afficher notre logo au départ (sur ma télé, c'est marqué "Phillips" pendant 10 secondes).C'était facile à faire et on apporte une petite finition ;)
Par contre, par la suite, je pense qu'on pourrait gagner une ligne ? (encore la forme)Oui en effet. Pas de souci sur la forme, je trouve aussi que c'est très important.
Pour le fond, j'ai vu que tu pensais afficher la tension et l'intensité (avec 2 chiffres après la virgule).On a mis un pont diviseur en entrée d'alim (sur la tension continue) donc on devrait avoir une image de la tension correcte je pense. Attention à bien mettre des résistances de 1% ou mieux.
Franchement, ce serait super bien, mais, à mon avis infaisable tel quel.
On n'a pas de capteurs et on ne va pas pouvoir en mettre comme avec une alim analogique (un en série et un en parallèle) en sortie d'alim.
Pour mesurer une tension/intensité DCC, il faut un multimètre haut de gamme ("True RMS") pour que l'indication veuille dire quelque chose.Ce point là est la grand inconnue, cela fait partie des chosse que l'on doit tester dès réception des cartes. Cela va dépendre de la qualité du signal que l'on sera exploiter de la sortie Sense du L6203. Pas gagné en effet.
D'autre part, ce qui serait intéressant, ce serait la tension/intensité aux bornes du moteur. ;)C'est une autre histoire en effet. On connait la tension secteur, on connait le cran, il faut connaitre les paramètres de CV puis calculer la tension moyenne sortie du décodeur. Ca peut être rigolo en effet mais cela restera je pense assez théorique et on risque de ne pas être compatible avec tous les décodeurs non ?
Parce que, sinon, ça ne veut pas dire grand-chose puisque ce qui circule dans les rails, ce sont des messages DCC.
Là où on pourrait indiquer quelque chose, c'est en sortie du convertisseur buck puisqu'on est encore en analogique. Là, j'y crois.Je ne connais pas assez bien le sujet, désolé.
Et on pourrait éviter quelques grillages de locos... ::)
Enfin, comme l'ESP32 sait quel palier DCC est envoyé dans les rails (parmi 14/28/128) et qu'on a la tension maxi en sortie de convertisseur, on pourrait afficher une tension par une simple règle de trois.Tout un sujet en effet !!
Et, cerise sur le gâteau, on pourrait même tenir compte des CV2 à 6 et, ainsi, afficher quasiment la tension exacte aux bornes du moteur.
Voir, par exemple https://www.opendcc.de/french/information/dcc_cv_f.shtml (https://www.opendcc.de/french/information/dcc_cv_f.shtml)
Nota : la NMRA a mis à jour sa norme électrique DCC (maintenant 9.1) le 7 mars 2020. C'est très récent.
Je pense traduire la doc NMRA des CV. On y apprend, par exemple, que les CV 105 et 106 sont réservés aux utilisateurs… :P
Désolé, mais, si, je m'inquiète. Il faut ajuster la fréquence de l'IHM pour qu'on n'ait plus ce phénomène. Tu vas me dire que je m'intéresse plus à la forme qu'au fond (et, ici, tu as raison), mais je n'ai toujours pas vu la fin de la vidéo (c'est vraiment pénible). Sorry…
D'autre part, ce qui serait intéressant, ce serait la tension/intensité aux bornes du moteur. ;)Denis,
Parce que, sinon, ça ne veut pas dire grand-chose puisque ce qui circule dans les rails, ce sont des messages DCC.
Là où on pourrait indiquer quelque chose, c'est en sortie du convertisseur buck puisqu'on est encore en analogique. Là, j'y crois.
Et on pourrait éviter quelques grillages de locos... ::)
Denis
Je ne vois pas le 10 µF sur la broche ENABLE ? Ni dans la BOM ?
Tu vas être le premier, mais c'est cher !
PS pour Dominique : j'ai commandé la BOM chez TME (je ne sais pas pourquoi, en ce moment, j'ai du mal à commander trop loin de chez moi ;))
Total 89,54 €. Je pense que j'aurais tout lundi.
Dans un premier temps, on fait tourner UNE LOCO et on la chronomètre. On va finir au bout d'un "certain temps" par avoir une table qui va donner cran de vitesse => vitesse réelle POUR CETTE LOCO.
Le problème de la vitesse réelle est fondamental pour moi puisque, à terme, mes petits trains virtuels doivent être en phase avec les trains sur le réseau. J'en suis loin, mais c'est une autre histoire. ;DBonjour Denis,
Parce que pour Eagle je ne sais pas mais je peux vous dire que les bibliothèques KiCad sont truffées d’erreurs, c’est la fête du slip. Tout doit être vérifié, aucune confiance ne doit être accordée.
Je serais pour scinder en deux projets :
1°) LaBox pour les débutants (version "TrainInBox")
DCCpp+HMI+modification possible du CV1 (c'est un minimum).
Je ne suis pas certain, dans cette version, qu'il y ait besoin d'un connecteur JP1 (pour le prochain CI)L'idée pour le moment est de déplacer ce connecteur sous l'ESP32, le rendant accessible par des connecteurs coudés à 90°.
Si on veut faire un joueur de scénario, même interne, même minimal, il va falloir pouvoir commander quelques aiguilles et donc avoir un bus CAN.J'ai testé le Can avec un satellite.
Ou alors, on commande les aiguilles de l'extérieur (boutons sur un TCO physique), indépendant de LaBox. Je pense que c'est la solution à retenir.
Et comme scénario : une navette, puisque ça n'utilise pas les aiguilles.
Obligation du Wifi pour la Throttle.
Prévoir de brancher quand même une MultiMaus filaire ?
2°) Les essais de fonctions plus sophistiquées (développeurs)
Là, il faut un bus CAN (aiguilles, signaux et logiciel de gestion) et les développements de Christophe.
Pour WebAdmin, je me demande si ça ne pourrait pas être déjà sur la version débutants.
Bonsoir,
A vouloir en ajouter toujours un peu plus, cela risque de finir comme les satellites v2....
Il faut rester humble et ne pas trop s’écarter de la cible.
Le projet, c’est une base stable fonctionnelle, utilisable en wifi ou série. La suite serait modulaire et développée plus ou moins en fonction des aspirations (MQTT, TCO balaise...) effectivement le CAN reste un choix mûri.
Le mini TCO me semble juste un peu tard ou un peu trop tôt...
Yannick
Pour les bugs et les demandes d'évolution, le mécanisme existe dans GitHub. Il suffit de déclarer un 'Issue' dans le projet Labox.Tout à fait d'accord !
Pour le 12V :
Il semble que ce que j’ai constaté aussi (GPIO0 HIGH) soit un bug du bootloader non corrigé :
https://www.esp32.com/viewtopic.php?t=2205
Et qu’il peut être évité avec :
REG_WRITE(GPIO_FUNC0_OUT_SEL_CFG_REG, SIG_GPIO_OUT_IDX);
R4=3,3K, R3 = 10K
VS = (1 + R3/R4) VE
R3 = 10K
R4 = 3,3K
donc R3/R4 = 3
VS = 4 VE (gain de 4)
Pour le 12V :
Il semble que ce que j’ai constaté aussi (GPIO0 HIGH) soit un bug du bootloader non corrigé :
https://www.esp32.com/viewtopic.php?t=2205
Et qu’il peut être évité avec :
REG_WRITE(GPIO_FUNC0_OUT_SEL_CFG_REG, SIG_GPIO_OUT_IDX);
Lu sur le site d'Espressif : "Sometimes to program ESP32 via serial you must keep GPIO0 LOW during the programming process"
https://github.com/espressif/arduino-esp32 (https://github.com/espressif/arduino-esp32)
Dominique, la détection de l’intensité de court-circuit fonctionne ?
// A voir ce que l'on fait de cette fonction par rapport à celle de la HMI
void readCurrent() {
float c=0.0;
// TODO TODO TODO TODO
// Short-circuit détection
if (analogRead(PIN_CURRENT_MES) > 3000) { // 2,41A ??? A définir, c'est juste pour mettre la condition
shortCircuit();
}
// Filtre sur la mesure de courant
for(int j=0;j<300;j++){
c=(analogRead(PIN_CURRENT_MES)*0.2)+(c*0.8);
}
current = c;
if (current > topCurrent) {
topCurrent = current;
Serial.print("topCourant ");Serial.println(topCurrent);
}
}
Avant que je m'en aperçoive, il a bien chauffé mais n'est pas mort !
DCCpp::beginMain(UNDEFINED_PIN, 33, 32, 36); * #define PIN_VOLTAGE_MES 34Cette dernière modification est à faire dans le fichier hmiConfig.h, ligne 22#define HMI_VoltageK 0.10 // Voltage scaling coefficient
voltage = ((analogRead(PIN_VOLTAGE_MES) - 2740) * HMI_VoltageK) - 24 ;
La nombre 2740 est la valeur lue lorsque la tension est 0V. Le résultat n'est pas parfait et demande plus d'investigations.Pour info, j'ai poussé il y a deux minutes une nouvelle version avec juste les bonnes pins dans Labox.ino, et le numéro de version propre à Labox qui continuera d'évoluer : 0.6.1 . En développement, on ne met la version 1.0 que lors de la première distribution publique à fonctionnalités complètes du produit. On en est pas tout à fait là, même si on s'en approche.En effet, d'ailleurs je n'ai pas trouvé la fonction de recherche d'adresse DCC dans les menus HMI.
Donc WiThrottle semble mieux gérer les fonctions que EngineDriver qui ne laisse pas les lumières allumées... En tout cas c'est ce que laisse présager la photo avec l'écran qui signale la fonction activée et la lumière allumée de la loco.Ce n'est pas totalement certain car j'ai constaté que la lumière s'est éteinte et ne s'est pas rallumée alors que le symbole * est sur l'écran. J'ai mis cela sur le compte des faux contacts et le fait que les commandes de fonction ne sont pas répétées en permanence.
Je confirme le bon fonctionnement de la nouvelle version 0.6.1 avec les bonnes pin ...Pour info, j'ai poussé il y a deux minutes une nouvelle version avec juste les bonnes pins dans Labox.ino, et le numéro de version propre à Labox qui continuera d'évoluer : 0.6.1 . En développement, on ne met la version 1.0 que lors de la première distribution publique à fonctionnalités complètes du produit. On en est pas tout à fait là, même si on s'en approche.En effet, d'ailleurs je n'ai pas trouvé la fonction de recherche d'adresse DCC dans les menus HMI.
Aussi, de nombreuses commandes du menu HMI ne fonctionnent pas, sauf le redémarrage qui marche, mais avec une phase en tension continue - non DCC - (donc la loco part à fond la caisse) puis DCC off jusqu'à le connexion d'un throttle.
Donc WiThrottle semble mieux gérer les fonctions que EngineDriver qui ne laisse pas les lumières allumées... En tout cas c'est ce que laisse présager la photo avec l'écran qui signale la fonction activée et la lumière allumée de la loco.Quand la lumière est allumée elle reste bien allumée, sauf faux contact.
Hello
Ahg... c est beau...
Cela donne envie de sortir le fer a souder!!
Petite question on voit bien sur les capture la fonction 2 ou 5 activée mais que voit on si on a x fonctions actives, en même temps? (rotation d affichage, complétude jusque à saturation de l ecran? perte du reste? limites?
Aussi est il "possible d avoir un second écran pour d autres info ( ou une autre loc....?
Je dits cela... enfin ca peut servir!... :)
Laurent
Compte-tenu du gros défaut de linéarité du convertisseur analogique-numérique de l'ESP32, près du 0V, un offset de 0,2V est appliqué à l'entrée + de l'ampli et il est corrigé par logiciel dans le calcul de l'intensité.
Néanmoins la mesure d'intensité n'est pas très précise mais donne une bonne idée de la consommation sur les rails.
J’ai lu dans la documentation Digikeijs ou Z21 que les commandes des fonctions sont répétées automatiquement (pas très vite) ce qui permet aux locos de ne pas perdre les états des commandes à chaque faux contact.
Ce n’est pas dans la norme comme les commandes de vitesse, mais cela peut être un plus appréciable.
Merci pour <r>. Encore un petit effort et on aura <w> :D
Bonjour Dominique,
J'ai presque tous les composants de la deuxième mouture.
Je veux bien un CI ;D ;D
D'avance, merci
Denis :P
... une version 0.7.6 qui cette fois doit bien réagir à l'utilisation de commandes texte ...Effectivement un pas de plus, les commandes depuis une throttle de Dave Bodnar via HC12 sont affichées synchro sur LaBox. Nickel !
WifiDcc:16:27: error: declaration of 'Throttle* TextCommand::pCurrentThrottle' outside of class is not definition [-fpermissive]
WiFiServer DCCPP_INTERFACE(2560);
^
WifiDcc:16:32: error: invalid conversion from 'int' to 'Throttle*' [-fpermissive]
WiFiServer DCCPP_INTERFACE(2560);
^
/Users/christophe/Documents/Arduino/libraries/LaBox-master/examples/WifiDcc/WifiDcc.ino: In function 'void setup()':
WifiDcc:23:3: error: 'beginWifi' is not a member of 'DCCpp'
DCCpp::beginWifi(ssid, password, EthernetProtocol::TCP);
^
Plusieurs bibliothèque trouvées pour "WiFi.h"
Utilisé : /Users/christophe/Library/Arduino15/packages/esp32/hardware/esp32/1.0.4/libraries/WiFi
Non utilisé : /Applications/Arduino.app/Contents/Java/libraries/WiFi
Utilisation de la bibliothèque LaBox-master version 1.4.0 dans le dossier: /Users/christophe/Documents/Arduino/libraries/LaBox-master
Utilisation de la bibliothèque ArduinoJson version 6.15.2 dans le dossier: /Users/christophe/Documents/Arduino/libraries/ArduinoJson
Utilisation de la bibliothèque WiFi version 1.0 dans le dossier: /Users/christophe/Library/Arduino15/packages/esp32/hardware/esp32/1.0.4/libraries/WiFi
Utilisation de la bibliothèque Adafruit_GFX_Library version 1.5.7 dans le dossier: /Users/christophe/Documents/Arduino/libraries/Adafruit_GFX_Library
Utilisation de la bibliothèque Adafruit_SSD1306 version 1.3.0 dans le dossier: /Users/christophe/Documents/Arduino/libraries/Adafruit_SSD1306
Utilisation de la bibliothèque Wire version 1.0.1 dans le dossier: /Users/christophe/Library/Arduino15/packages/esp32/hardware/esp32/1.0.4/libraries/Wire
Utilisation de la bibliothèque SPI version 1.0 dans le dossier: /Users/christophe/Library/Arduino15/packages/esp32/hardware/esp32/1.0.4/libraries/SPI
Utilisation de la bibliothèque OneButton version 1.5.0 dans le dossier: /Users/christophe/Documents/Arduino/libraries/OneButton
Utilisation de la bibliothèque FS version 1.0 dans le dossier: /Users/christophe/Library/Arduino15/packages/esp32/hardware/esp32/1.0.4/libraries/FS
Utilisation de la bibliothèque SPIFFS version 1.0 dans le dossier: /Users/christophe/Library/Arduino15/packages/esp32/hardware/esp32/1.0.4/libraries/SPIFFS
exit status 1
conflicting declaration 'WiFiServer* TextCommand::pCurrentThrottle'
Le croquis utilise 751854 octets (57%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 44240 octets (13%) de mémoire dynamique, ce qui laisse 283440 octets pour les variables locales. Le maximum est de 327680 octets.
Le croquis utilise 751854 octets (57%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 44240 octets (13%) de mémoire dynamique, ce qui laisse 283440 octets pour les variables locales. Le maximum est de 327680 octets.
esptool.py v2.6
Serial port /dev/cu.SLAB_USBtoUART
Connecting........_
Chip is ESP32D0WDQ6 (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
MAC: 24:6f:28:7c:67:14
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 921600
Changed.
Configuring flash size...
Auto-detected Flash size: 4MB
Compressed 8192 bytes to 47...
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.0 seconds (effective 5131.6 kbit/s)...
Hash of data verified.
Compressed 17392 bytes to 11186...
Wrote 17392 bytes (11186 compressed) at 0x00001000 in 0.1 seconds (effective 988.7 kbit/s)...
Hash of data verified.
Compressed 751968 bytes to 452725...
Wrote 751968 bytes (452725 compressed) at 0x00010000 in 7.0 seconds (effective 863.8 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 128...
Wrote 3072 bytes (128 compressed) at 0x00008000 in 0.0 seconds (effective 1794.4 kbit/s)...
Hash of data verified.
Leaving...
Hard resetting via RTS pin...
Server IP address: 192.168.4.1 (Locoduino LaBox) connected ! connectWifi achieved.
Ino executing on core 1
Throttles command receivers executing on core 0
begin achieved
Signal started for Main track on pin 33
Main track DCC ESP32 started.
beginMain achivied with pin 33
*** LaBox LIBRARY : 0.8.0
VERSION DCC++ : 2.0.0
COMPILED : May 15 2021 17:13:23
ENABLE(PWM): 32
CURRENT: 36
Throttles ------------------
0 : Serial
1 : JMRI
2 : ThrottleWifi: Z21 - 1 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
3 : ThrottleWifi: Z21 - 2 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
4 : ThrottleWifi: Z21 - 3 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
5 : ThrottleWifi: WiThrottle - 1 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
6 : ThrottleWifi: WiThrottle - 2 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
7 : ThrottleWifi: WiThrottle - 3 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
dhcps: send_nak>>udp_sendto result 0Converter : New client
5 -> VN2.0
5 -> RL0
5 -> PPA2
5 -> RCL0
5 -> PW12080n
DCCpp PowerOn
Throttles ------------------
0 : Serial
1 : JMRI
2 : ThrottleWifi: Z21 - 1 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
3 : ThrottleWifi: Z21 - 2 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
4 : ThrottleWifi: Z21 - 3 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
5 : ThrottleWifi: WiThrottle - 1 WifiPort: 44444 WifiProtocol: TCP timeout: 60000 (WiThrottle converter) start:0 end:10 ip:192.168.4.2
6 : ThrottleWifi: WiThrottle - 2 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
7 : ThrottleWifi: WiThrottle - 3 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
5 From Throttle : NiPhoneDBThrottle 5 NiPhoneDB
5 -> <p1>*10
5 From Throttle : HUBDE241D3-07EA-4A60-BD6B-EE19
Throttle 5 HUBDE241D3-07EA-4A60-BD6B-EE195 From Throttle : MT+S3<;>S3
Throttle 5 MT+S3<;>S3
5 -> MT+S3<;>
5 -> MTAS3<;>F00
5 -> MTAS3<;>F01
5 -> MTAS3<;>F02
5 -> MTAS3<;>F03
5 -> MTAS3<;>F04
5 -> MTAS3<;>F05
5 -> MTAS3<;>F06
5 -> MTAS3<;>F07
5 -> MTAS3<;>F08
5 -> MTAS3<;>F09
5 -> MTAS3<;>F010
5 -> MTAS3<;>F011
5 -> MTAS3<;>F012
5 -> MTAS3<;>F013
5 -> MTAS3<;>F014
5 -> MTAS3<;>F015
5 -> MTAS3<;>F016
5 -> MTAS3<;>F017
5 -> MTAS3<;>F018
5 -> MTAS3<;>F019
5 -> MTAS3<;>F020
5 -> MTAS3<;>F021
5 -> MTAS3<;>F022
5 -> MTAS3<;>F023
5 -> MTAS3<;>F024
5 -> MTAS3<;>F025
5 -> MTAS3<;>F026
5 -> MTAS3<;>F027
5 -> MTAS3<;>F028
5 -> MT+S3<;>V0
5 -> MT+S3<;>R1
5 -> MT+S3<;>s1
Locomotives ------------------
0 : Loco reg:1 id:3 max:128 +/-speed:0 functions: 5 From Throttle : MTAS3<;>V3
Throttle 5 MTAS3<;>V3
DCCpp SetSpeed for loco 3 : 3/128 )
5 From Throttle : MTAS3<;>V16
Throttle 5 MTAS3<;>V16
DCCpp SetSpeed for loco 3 : 16/128 )
5 From Throttle : MTAS3<;>V26
Throttle 5 MTAS3<;>V26
DCCpp SetSpeed for loco 3 : 26/128 )
Voilà, je viens de pousser une version 0.7.6 qui cette fois doit bien réagir à l'utilisation de commandes texte.
Le concept de Locoduino Satellite Can evolutif et peu cher m'intéresse vraiment, autant le faire avec LaBox.
Vous pouvez me mettre une platine de coté, ou il faudra que je la fasse faire en Chine ?
Jerome
Pret a vous aider, mais pas tout de suite :)
port.write("power on <1>");<p1>DCCpp::setResendFunctions(false); Par défaut, la répétition est activée.DCCpp::setReplyToCommands(false); mais cette fonction ne fonctionnait pas. Elle a été corrigée, et le nom est passé de DontReply à ReplyToCommands pour enlever la négation et permettre de mieux comprendre son rôle.J'attends une machine en O pour confirmer
après cette description, il serait super si vous pouviez donner votre avis, si vous souhaitez acquérir LaBox et dans quel environnement l'utiliserez-vous.
Etape 5: surprise pour l'interface CAN, au dos de la carte les indications sont inversées par rapport à la photo. De plus ces indications sont inconsistantes avec celles au recto. Après recherches, ce problème a déjà été souvent rencontré par d'autres et ce sont les indications du verso qui sont fausses : il faut donc bien monter la carte comme indiqué. Pour l'OLED j'ai ajouté 4 entretoises en nylon de 12 mm avec vis de 2mm. Il faut juste adapter légèrement les 2 trous de droite prudemment avec une mèche de 2.Bonjour Jean-Paul et bonne année 2021 ;D
Je n'ai pas testé Z21, ...
Bonsoir,
Je vais faire un tableau via Excel avec les fonctions et le transmettre à qui de droit ;)
To set functions F0-F4 on=(1) or off=(0): <f CAB BYTE1 [BYTE2]>
< = Begin DCC++ command
f = (lower case f) This command is for a CAB,s function ie: Lights, horn, bell
CAB: the short (1-127) or long (128-10293) address of the engine decoder
BYTE1: 128 + F1*1 + F2*2 + F3*4 + F4*8 + F0*16
ADD the ones you want ON together
Add 1 for F1 ON
Add 2 for F2 ON
Add 4 for F3 ON
Add 8 for F4 ON
Add 16 for F0 ON
128 Alone Turns OFF F0-F4
BYTE2: omitted
> = End DCC++ command
...
LaBox est transparente pour la conversion des codes DCC++ en DCC tels que décrits dans la documentation DCC++ :
....
Il suffit d'envoyer la commande <f CAB BYTE1> à la locomotive suivant le calcul ci-dessus et voir le résultat.
....
Il faut sûrement un radiateur et surtout remonter au maximum la mesure de tension de court-circuit qui est actuellement aux alentours de 1A !. Normalement avec 1v/A il n’est pas possible de depasser 3,3A à moins de réduire le gain de l’aop.
A l’heure actuelle ca ne doit pas être possible. Il va falloir inventer quelque chose.
void begin(int pin, int inSignalPin, const char *msg, float inSampleMax = 800);byte jeuTestsSignaux[7][3] = {
0x20, 0x20, 0x00, //VL1 + VL2
0x02, 0x20, 0x00, //A1 + VL2
0x08, 0x80, 0x82, //S1 + RR2 + Devie
0x02, 0x20, 0x00, //A1 + VL2
0x20, 0x02, 0x00, //A1 + A2
0x02, 0x40, 0x01, //A1 + RRc2
0x08, 0x08, 0x80 //S1 + C2 + devie
};4 From Throttle : NiPhoneDB
4 From Throttle : HUBDE241D3-07EA-4A60-BD6B-EE19
4 From Throttle : MT+S18<;>S18
4 From Throttle : MT-S18<;>r
4 From Throttle : MT+S18<;>S18
4 From Throttle : MT-S18<;>r
4 From Throttle : MT+S18<;>S184 From Throttle : NiPhoneDB
Throttle 4 NiPhoneDB
4 -> *10
4 From Throttle : HUBDE241D3-07EA-4A60-BD6B-EE19
Throttle 4 HUBDE241D3-07EA-4A60-BD6B-EE19
4 From Throttle : *+
Throttle 4 *+
envoi 0 0x20 0x20 0x0
recu de 21 : 0x0
envoi 1 0x2 0x20 0x0
recu de 21 : 0x0
4 From Throttle : MT+S18<;>S18
Throttle 4 MT+S18<;>S18
4 -> MT+S18<;>
4 -> MTAS18<;>F00
4 -> MTAS18<;>F01
4 -> MTAS18<;>F02
4 -> MTAS18<;>F03
4 -> MTAS18<;>F04
4 -> MTAS18<;>F05
4 -> MTAS18<;>F06
4 -> MTAS18<;>F07
4 -> MTAS18<;>F08
4 -> MTAS18<;>F09
4 -> MTAS18<;>F010
4 -> MTAS18<;>F011
4 -> MTAS18<;>F012
4 -> MTAS18<;>F013
4 -> MTAS18<;>F014
4 -> MTAS18<;>F015
4 -> MTAS18<;>F016
4 From Throttle : *
4 -> MTAS18<;>F017
4 -> MTAS18<;>F018
4 -> MTAS18<;>F019
4 -> MTAS18<;>F020
4 -> MTAS18<;>F021
4 -> MTAS18<;>F022
4 -> MTAS18<;>F023
4 -> MTAS18<;>F024
4 -> MTAS18<;>F025
4 -> MTAS18<;>F026
4 -> MTAS18<;>F027
4 -> MTAS18<;>F028
4 -> MT+S18<;>V0
4 -> MT+S18<;>R1
4 -> MT+S18<;>s1
Locomotives ------------------
0 : Loco reg:1 id:18 max:128 +/-speed:0 functions:
Throttle 4 *
4 -> *10
envoi 2 0x8 0x80 0x82
recu de 21 : 0x0
envoi 3 0x2 0x20 0x0
recu de 21 : 0x0
4 From Throttle : *
Throttle 4 *
4 -> *10
envoi 4 0x20 0x2 0x0
recu de 21 : 0x0
envoi 5 0x2 0x40 0x1
recu de 21 : 0x0
4 From Throttle : *
Throttle 4 *
4 -> *10
envoi 0 0x20 0x20 0x0
recu de 21 : 0x0
envoi 1 0x2 0x20 0x0
recu de 21 : 0x0où l'on voit la connexion de Withrottle et les messages émis et reçusRid: 25 0x0 0x20 0x0 nor
Rid: 25 0x0 0x2 0x0 nor
Rid: 25 0x0 0x20 0x0 nor
Rid: 25 0x0 0x2 0x0 nor
Rid: 25 0x0 0x20 0x0 nor
Rid: 25 0x0 0x2 0x0 nor
Mais dès qu'un Throttle est correctement connecté, le test Can redevient normal. Cela vient peut-être du logiciel LaBox.Concernant ces petites cartes CJMCU-230, je me souviens avoir lu quelque part que la sérigraphie était inversée entre deux pins... Se pourrait-il que ce marquage soit quelquefois vrai, selon le fournisseur ?
Bonjour Dominique (c'est presque un message privé...)
Mais y aurait-il un test tout simple, un test "de paillasse", qui distingue celui qui marche des 4 autres ? Car il serait trop beau que l'adaptation du code ne réserve pas aussi des surprises et alors comment savoir !
Si tu as une idée, merci d'avance !
Concernant ces petites cartes CJMCU-230, je me souviens avoir lu quelque part que la sérigraphie était inversée entre deux pins... Se pourrait-il que ce marquage soit quelquefois vrai, selon le fournisseur ?
Vu à la loupe des deux cotés : pas de différence.
controleurCAN configuration OK
versionSW 0.1 17 Janvier 2021message envoyé
message envoyé
message envoyé
message envoyé
message envoyé
echec de l'envoi
echec de l'envoi
echec de l'envoi
etc. ets Jun 8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:9720
ho 0 tail 12 room 4
load:0x40080400,len:6352
entry 0x400806b8
LaBox 0.7.9
Server IP address: 192.168.4.1 (Locoduino LaBox) connected ! connectWifi achieved.
Ino executing on core 1
Throttles command receivers executing on core 0
begin achieved
Signal started for Main track on pin 33
Main track DCC ESP32 started.
beginMain achivied with pin 33
ESP32 CAN - LaBox + Satellite V1
*** LaBox LIBRARY : 0.7.9
VERSION DCC++ : 2.0.0
COMPILED : Feb 6 2021 17:17:16
ENABLE(PWM): 32
CURRENT: 36
Throttles ------------------
0 : Serial
1 : ThrottleWifi: Z21 - 1 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
2 : ThrottleWifi: Z21 - 2 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
3 : ThrottleWifi: Z21 - 3 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
4 : ThrottleWifi: WiThrottle - 1 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
5 : ThrottleWifi: WiThrottle - 2 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
6 : ThrottleWifi: WiThrottle - 3 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
envoi 0 0x20 0x20 0x0
envoi 1 0x2 0x20 0x0
envoi 2 0x8 0x80 0x82 0 From Throttle : 1
0 From Throttle : 1
0 From Throttle : t1 8 0 0
0 Message From Throttle :
0 Message From Throttle :
Utilisez un MCP2562. Il est moins cher que ce module et il fonctionne :)
Et on trouve bien une 120ohms entre CANH et CANL sur les quatre cartes que j'ai.
Be aware that they are some "FAKE" transceiver based on VP230 (SN65HVD230) !!!
I've lost days with 2pcs CJMCU-230 coming from the same supplier on Aliexpress. They were almost working at low speed (125kb) & only for few seconds at 500kb... Forcing High Speed mode with Rs connected to GND did not help really.
Applying another similar transceiver from Waveshare with same VP230 SN65HVD230 with Rs grounded solved all my troubles. Plugg & run! Smooth ESP32 read & writte at 500kb for hours with heavy REC trafic (Rx_PDO1_20ms, Rx_PDO2_1s, Rx_PDO3_5s, Tx_PDO1_1s)
https://www.waveshare.com/sn65hvd230-can-board.htm
ESP32 CAN - LaBox + Satellite V1
*** LaBox LIBRARY : 0.7.8
VERSION DCC++ : 2.0.0
COMPILED : Feb 5 2021 18:31:39
ENABLE(PWM): 32
CURRENT: 36
Throttles ------------------
0 : Serial
1 : ThrottleWifi: Z21 - 1 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
2 : ThrottleWifi: Z21 - 2 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
3 : ThrottleWifi: Z21 - 3 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) not connected
4 : ThrottleWifi: WiThrottle - 1 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
5 : ThrottleWifi: WiThrottle - 2 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
6 : ThrottleWifi: WiThrottle - 3 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 not connected
envoi 0 0x20 0x20 0x0
recu de 21 : 0x0
envoi 1 0x2 0x20 0x0
recu de 21 : 0x0
envoi 2 0x8 0x80 0x82
recu de 21 : 0x0
envoi 3 0x2 0x20 0x0
recu de 21 : 0x0
envoi 4 0x20 0x2 0x0
recu de 21 : 0x0
envoi 5 0x2 0x40 0x1
recu de 21 : 0x0
envoi 0 0x20 0x20 0x0
recu de 21 : 0x0
On va tranquillement vers une intégration du MCP2562 sur la carte LaBox.Tenir compte de ce que sa tension d'alimentation est 5V, et voir les I/O.
CAN sur Teensy,
Pour info je viens de faire un "panier" sur eBay ...
Le croquis utilise 755366 octets (57%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 44376 octets (13%) de mémoire dynamique, ce qui laisse 283304 octets pour les variables locales. Le maximum est de 327680 octets.
- centrale DCC de démonstration sur diorama / support vitrine etc. En O (mais je pense pouvoir tester rapidement que 3A seraient suffisant). Donc une LaBox sous chaque dio / support vitrine.
Serait-il possible de disposer du fichier GERBER du détecteur de présence DCC par consommation du courant en version simple et non double?
PS: Serait-il possible de disposer du fichier GERBER du détecteur de présence DCC par consommation du courant en version simple et non double?
Par avance MERCI.
C:\Users\miche\Documents\Arduino\libraries\LaBox-0712\src\Throttles\ThrottleAutomation.cpp: In member function 'void ThrottleAutomation::printThrottleItems()':
C:\Users\miche\Documents\Arduino\libraries\LaBox-0712\src\Throttles\ThrottleAutomation.cpp:177:37: error: 'SENSORID' was not declared in this scope
Serial.print(SENSORID(curr->delay));
^
C:\Users\miche\Documents\Arduino\libraries\LaBox-0712\src\Throttles\ThrottleAutomation.cpp:179:40: error: 'SENSORSTATE' was not declared in this scope
Serial.print(SENSORSTATE(curr->delay) ? "HIGH" : "LOW");je viens de recevoir 4 circuits MCP2562 (distri-compo en France) et j'ai cablé une mini carte sur le connecteur Can habituel 6 pins, + une liaison au 5V :
(https://forum.locoduino.org/index.php?action=dlattach;topic=922.0;attach=3717;image)
Ça marche comme l'avait prédit l'ami Jean-Luc, à 500 kb/s.
Mais il reste un cafouillage au démarrage à froid de l'ESP32 qui se résoud par un reset de l'ESP32.
A suivre...
Ce ne serait pas sorcier de faire un breakout à 7 pins (le +5 est juste à coté) avec un MCP2562.
(https://forum.locoduino.org/index.php?action=dlattach;topic=922.0;attach=3712;image)
Ce ne serait pas sorcier de faire un breakout à 7 pins (le +5 est juste à coté) avec un MCP2562.
(https://forum.locoduino.org/index.php?action=dlattach;topic=922.0;attach=3712;image)
Oui pour le strap et la résistance de 120Ω. La capa est entre quelles broches ?
Et pour ma culture générale, c'est quoi une "BB foireuse" ?
Mais il reste un cafouillage au démarrage à froid de l'ESP32 qui se résoud par un reset de l'ESP32.
Selon un montage comme celui-ci ?
Pour le Reset, on l’a fait sur le Due de cette façon.
C’est là, avec un mcp230 :
https://forum.locoduino.org/index.php?topic=258.msg2375#msg2375 (https://forum.locoduino.org/index.php?topic=258.msg2375#msg2375)
C'est quoi exactement votre « cafouillage au démarrage à froid » ? Je soupçonne qu'on ne parle absolument pas de la même chose ;)En relisant les messages du 11 Février, je me pose également la même question !
Ce ne serait pas sorcier de faire un breakout à 7 pins (le +5 est juste à coté) avec un MCP2562.
(https://forum.locoduino.org/index.php?action=dlattach;topic=922.0;attach=3712;image)
il manque les capas de découplage (100nF). Tant qu'à faire, met la résistance de terminaison de 120Ω et un strap pour la mettre en fonction. :)
Locomotive* pLoco = Locomotives::add("Test", 3);
pLoco->functions.setModal(1);
pLoco->functions.setModal(2);
pLoco->functions.setModal(3);
pLoco->functions.setModal(4);
Bien sûr là c'est par code, et il faut être sûr de son coup. Si on veut aller plus loin, il devrait être possible de faire une page web permettant de configurer les fonctions, mais même dans ce cas, il est peu probable que les fonctions modales d'un décodeur se suivent au point de constituer un bloc complet... Donc l'usage devient rare, voire inexistant. J'attend vos réflexions sur le sujet, mais du coup je ne suis plus très sûr du bienfondé de cette fonctionnalité.Je reviens sur la vue 1/2/3 trains. Je m'interroge sur l'intérêt de toutes ces vues et du coup est-ce que la vue 1 train ne suffirait pas ? Vous utilisez quoi de votre côté?
Pour le CAN, il aurait fallut intégrer la passerelle CAN / Wifi non ?
Pour moi la vue 1 me suffit.Je pense aussi, mais dans une optique sniffer, comme Thierry a déjà développé un affichage Loco Vitesse Sens pour débuguer, un affichage des commandes fonctions / accessoires reçues ne serait peut-être pas trop compliqué à mettre en place ?
Mais si il y a plusieurs manettes, celle qui s’affiche est alors la dernière vue.
Par ailleurs, l'écran I2C de 0,96", driver SSD1306 pourrait être remplacé en option par un I2C de 1,35", driver SH1106. (1€ de plus).A priori cet écran a la même résolution donc pas trop de mal.
On lui trouvera de la place dans la prochaine version de pcb.
https://github.com/nhatuan84/esp32-sh1106-oled
je n'ai pas vu ce que l'auteur a modifié par rapport à la bibliothèque SH1106 Adafruit pour l'ESP32.
Sur cette page, il donne le lien pour entreprendre cette modification.
http://www.iotsharing.com/2017/05/how-to-use-arduino-esp32-to-display-oled.html
N’oublions pas que le fait de devoir débrancher le Vcc pendant le téléversement et le rebrancher dans les 2 secondes qui suivent va être une difficulté ou cause d’échec pour pas mal de gens.
Here we connect:
[ESP32 3.3V – OLED VCC]
[ESP32 GND – OLED GND]
[ESP32 IO12– OLED SDA]
[ESP32 IO14 – OLED SCL]
NOTE: while flashing SW for ESP32 if you see md5 error, please detach OLED VCC from ESP32 3.3V, after finishing flashing, attach again (I put delay(2000) in setup() so we have enough time to attach) or you can use external power for OLED.
Il y a une petite faute, un 'amplement' pas vraiment bien orthographié... Pour le téléversement, sur Windows (je ne sais pas sur les autres systèmes...) il faut appuyer sur le bouton 'boot' de l'ESP32 pendant l'affichage des points d'attente pour que le téléversement démarre. Il vaudrait mieux en parler.
Merci Dominique (peut être aidé par d'autres ?)Bah oui, testes donc et donnes moi les choses à préciser...
Mon problème, dans l'ordre, est de déjà souder tous les composants (que j'ai depuis longtemps) au CI.
Il y a P23 ce qu'il faut, dans le détail, et, à l'époque, j'allais le faire ...
Arrive le post du 06/02 où tu parles d'un problème avec la carte d'interface CAN SN65HVD230 .
Comme je n'ai rien pour tester le CAN (et que c'est ma plus grosse attente sur LaBox), j'attendais.
Peut-on simplement tester si le SN65HVD230 que j'ai est un "bon" SN65HVD230 ?
Denis
Pour le téléversement, sur Windows ... il faut appuyer sur le bouton 'boot' de l'ESP32 pendant l'affichage des points d'attente pour que le téléversement démarre.
Mais je ne sais pas à quel moment, dans le fil des affichages, il faut appuyer sur le bouton 'boot' de l'ESP32.
Le croquis utilise 752642 octets (57%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 44408 octets (13%) de mémoire dynamique, ce qui laisse 283272 octets pour les variables locales. Le maximum est de 327680 octets.
esptool.py v2.6
Serial port COM4
Connecting....Chip is ESP32D0WDQ6 (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
MAC: 84:cc:a8:5c:30:08
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 921600
Changed.
... problème avec la carte d'interface CAN SN65HVD230 ...
Je construit déjà LaBox, mais il va falloir un programme côté ESP32 et un programme côté DUE (ou éventuellement NANO) pour tester le bus.
Je construit déjà LaBox, ...Il faut au moins remplacer la 10 K par un pont pour avoir une chance après le premier essai ...
... HVD230 que tu dois avoir ...
5 From Throttle : MTAS18<;>F10
Throttle 5 MTAS18<;>F10
DCCpp SetFunctions for loco 18 / Activated : 0 5 From Throttle : MTAS18<;>F10
Throttle 5 MTAS18<;>F10
DCCpp SetFunctions for loco 18 / Activated : 5 From Throttle : MTAS18<;>V33
Throttle 5 MTAS18<;>V33
DCCpp SetSpeed for loco 18 : 33/128 )
5 From Throttle : MTAS18<;>I
Throttle 5 MTAS18<;>I
DCCpp SetSpeed for loco 18 : 32/128 )
5 From Throttle : *
Throttle 5 *
5 -> <T2 18 32 1>*10
5 From Throttle : MTAS18<;>X
Throttle 5 MTAS18<;>X
DCCpp SetSpeed for loco 18 : 1/128 )
5 From Throttle : *
Throttle 5 *
5 -> <T2 18 1 1>*10
14:28:26.021 -> readCVraw : start reading cv 29
14:28:26.095 -> bit : 0 iter : 9, max : 9
14:28:26.731 -> bit : 1 iter : 11, max : 13
14:28:27.393 -> bit : 2 iter : 13, max : 11
14:28:28.069 -> bit : 3 iter : 2, max : 8
14:28:28.696 -> bit : 4 iter : 18, max : 14
14:28:29.367 -> bit : 5 iter : 6, max : 14
14:28:30.023 -> bit : 6 iter : 18, max : 10
14:28:30.653 -> bit : 7 iter : 0, max : 12
14:28:31.323 -> verif : iter : 19, max : 14
14:28:31.913 -> readCVraw : start reading cv 1
14:28:31.985 -> bit : 0 iter : 14, max : 7
14:28:32.660 -> bit : 1 iter : 6, max : 13
14:28:33.299 -> bit : 2 iter : 1, max : 13
14:28:33.936 -> bit : 3 iter : 3, max : 13
14:28:34.596 -> bit : 4 iter : 19, max : 16
14:28:35.270 -> bit : 5 iter : 0, max : 11
14:28:35.899 -> bit : 6 iter : 10, max : 10
14:28:36.566 -> bit : 7 iter : 1, max : 15
14:28:37.235 -> verif : iter : 10, max : 11
14:28:37.897 -> readCVraw : start reading cv 29
14:28:37.969 -> bit : 0 iter : 3, max : 17
14:28:38.603 -> bit : 1 iter : 12, max : 15
14:28:39.244 -> bit : 2 iter : 4, max : 13
14:28:39.917 -> bit : 3 iter : 9, max : 10
14:28:40.587 -> bit : 4 iter : 1, max : 11
14:28:41.240 -> bit : 5 iter : 3, max : 11
14:28:41.875 -> bit : 6 iter : 2, max : 14
14:28:42.534 -> bit : 7 iter : 18, max : 13
14:28:43.199 -> verif : iter : 2, max : 12
14:28:43.766 -> readCVraw : start reading cv 1
14:28:43.838 -> bit : 0 iter : 1, max : 9
14:28:44.510 -> bit : 1 iter : 3, max : 13
14:28:45.141 -> bit : 2 iter : 19, max : 9
14:28:45.814 -> bit : 3 iter : 4, max : 9
14:28:46.448 -> bit : 4 iter : 13, max : 9
14:28:47.108 -> bit : 5 iter : 12, max : 13
14:28:47.769 -> bit : 6 iter : 17, max : 11
14:28:48.435 -> bit : 7 iter : 5, max : 10
14:28:49.070 -> verif : iter : 7, max : 11
14:28:49.749 -> readCVraw : start reading cv 29
14:28:49.819 -> bit : 0 iter : 0, max : 10
14:28:50.453 -> bit : 1 iter : 5, max : 12
14:28:51.126 -> bit : 2 iter : 8, max : 12
14:28:51.763 -> bit : 3 iter : 10, max : 12
14:28:52.437 -> bit : 4 iter : 15, max : 15
14:28:53.101 -> bit : 5 iter : 14, max : 12
14:28:53.730 -> bit : 6 iter : 6, max : 12
14:28:54.372 -> bit : 7 iter : 15, max : 12
14:28:55.040 -> verif : iter : 6, max : 12
14:28:55.634 -> readCVraw : start reading cv 1
14:28:55.701 -> bit : 0 iter : 19, max : 11
14:28:56.374 -> bit : 1 iter : 0, max : 12
14:28:57.021 -> bit : 2 iter : 9, max : 9
14:28:57.653 -> bit : 3 iter : 4, max : 12
14:28:58.309 -> bit : 4 iter : 3, max : 11
14:28:58.985 -> bit : 5 iter : 19, max : 10
14:28:59.621 -> bit : 6 iter : 18, max : 11
14:29:00.289 -> bit : 7 iter : 10, max : 8
14:29:00.948 -> verif : iter : 15, max : 15
14:29:13.753 -> Converter : client 5 disconnected
14:53:04.169 -> readCVraw : start reading cv 29
14:53:04.237 -> bit : 0 iter : 11, max : 8
14:53:04.415 -> bit : 1 iter : 3, max : 358
14:53:04.587 -> bit : 2 iter : 6, max : 357
14:53:04.788 -> bit : 3 iter : 8, max : 8
14:53:04.961 -> bit : 4 iter : 15, max : 9
14:53:05.129 -> bit : 5 iter : 11, max : 6
14:53:05.337 -> bit : 6 iter : 6, max : 8
14:53:05.507 -> bit : 7 iter : 6, max : 8
14:53:05.712 -> verif : iter : 6, max : 392
14:53:05.814 -> readCVraw : start reading cv 1
14:53:05.886 -> bit : 0 iter : 4, max : 8
14:53:06.055 -> bit : 1 iter : 6, max : 362
14:53:06.190 -> 4 From Throttle : *
14:53:06.257 -> bit : 2 iter : 8, max : 6
14:53:06.432 -> bit : 3 iter : 14, max : 11
14:53:06.609 -> bit : 4 iter : 3, max : 361
14:53:06.777 -> bit : 5 iter : 5, max : 8
14:53:06.951 -> bit : 6 iter : 16, max : 9
14:53:07.159 -> bit : 7 iter : 0, max : 6
14:53:07.334 -> verif : iter : 6, max : 389
| Masque | Filtre | Resultat | ||
| 0b00000000000 (0x0000) (tous les bits validés) | 0b11111111111 (0x07FF) | Le Rx ne recevra que les messages avec l’Id 0x07FF | ||
| 0b00000000000 (0x0000) (tous les bits validés) | 0b01111111110 (0x03FE) | Le Rx ne recevra que les messages avec l’Id 0x03FE | ||
| 0b00000000001 (0x0001) | 0b01111111111 (0x03FF) | Le Rx ne recevra que les messages avec l’Id 0x03FE ou 0x03FF car le bit 0 du filtre est invalidé par le bit 0 du masque | ||
| 0b00000000001 (0x0001) | 0b01111111110 (0x03FE) | Le Rx ne recevra que les messages avec l’Id 0x03FE ou 0x03FF car le bit 0 du filtre est invalidé (idem cas précédent) | ||
| 0b00000000000 (0x0000) (tous les bits validés) | 0b01111111000 (0x03F8) | Le Rx ne recevra que les messages avec l’Id 0x03F8 | ||
| 0b00000000111 (0x0007) | 0b01111111000 (0x03F8) | Le Rx recevra tous les messages avec l’Id 0x03F8, 0x03F9, 0x03FA, 0x03FB,0x03FC, 0x03FD, 0x03FE, 0x03FF car les bit 0,1 & 2 du filtre sont invalidés | ||
| 0b00000000000 (0x0000) (tous les bits validés) | 0b00000000001 (0x0001) | Le Rx ne recevra que les messages avec l’Id 0x001 | ||
| 0b00000000111 (0x0007) | 0b00000000000 (0x0000) | Le Rx recevra tous les messages avec l’Id 0x000,0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007 car les bits 0,1 & 2 jeu filtre sont invalidés | ||
| 0b11111111000 (0x07F8) | 0b00000000000 (0x0000) | Le Rx recevra tous les messages don’t l’Id se termine par 0, 1, 2, 3, 4, 5, 6, ou 7 (0x121 = acepté, 0x0128 = eliminé) | ||
| 0b11111111111 (0x07FF) | 0b00000000000 (0x0000) | Tous les messages sont acceptés quelque soit l'identifiant |
const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::acceptStandardFrames () ;
Dans ce cas, les messages étendus sont rejetés et tous les messages standards sont acceptés. const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::acceptExtendedFrames () ;
Dans ce cas les messages standards sont rejetés et tous les messages étendus sont acceptés. const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::singleStandardFilter (ACAN_ESP32_Filter::data, 0x123, 0x404) ;
Le premier argument indique si on veut recevoir : const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::dualStandardFilter (
ACAN_ESP32_Filter::data, 0x123, 0x110,
ACAN_ESP32_Filter::remote, 0x456, 0x022
) ;
Pour le 1er filtre, les bits de 0x110 sont les #4 et #8: bits 4 et 8 de 0x123 sont ignorés dans le filtrage. Donc les identifiants 0x023, 0x033, 0x123 and 0x133 sont recevables. const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::singleExtendedFilter (ACAN_ESP32_Filter::data, 0x12345678, 0x20202) ;
Le 1er argument est "date" ou"remote" ou "dataAndRemote" const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::dualExtendedFilter (
0x12345678, 0x00060000, // First filter
0x19876543, 0x00009000 // Second filter
) ;
Noter que les bits 0 to 12 dans les paramètres sont toujours ignorés par ce type de filtre. const uint32_t errorCode = ACAN_ESP32::can.begin (settings, filter);
static const uint32_t DESIRED_BIT_RATE = 500UL * 1000UL ; // 0,5 Mb/s
ACAN_ESP32_Settings settings (DESIRED_BIT_RATE) ;
settings.mRequestedCANMode = ACAN_ESP32_Settings::NormalMode ;
// settings.mRxPin = GPIO_NUM_4 ; // Optional, default Tx pin is GPIO_NUM_4
// settings.mTxPin = GPIO_NUM_5 ; // Optional, default Rx pin is GPIO_NUM_5
const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::singleStandardFilter (ACAN_ESP32_Filter::data, 0x000, 0x01F) ;
// masque = tous les Id acceptes de 00 à 1F
const uint32_t errorCode = ACAN_ESP32::can.begin (settings, filter);
const ACAN_ESP32_Filter filter = ACAN_ESP32_Filter::dualStandardFilter (
ACAN_ESP32_Filter::data, 0x000, 0x00F, // acceptés de 00 à 0F
ACAN_ESP32_Filter::data, 0x010, 0x00F); // acceptés de 10 à 1F
const uint32_t errorCode = ACAN_ESP32::can.begin (settings, filter);
const uint32_t errorCode = ACAN_ESP32::can.begin (settings) ;
Test de la version 080 modifiée pour afficher l'HMI:
0 From Throttle : t1 19 0 1
0 From Throttle : t1 36 0 1
0 From Throttle : t1 8 0 1
0 From Throttle : t1 18 0 1
Throttle 0 <t1 19 0 1>
<t> parse command
<T1 19 0 1>
0 From Throttle : t1 2 0 1
Throttle 0 <t1 18 0 1>
<t> parse command
<T1 18 0 1>
0 From Throttle : 0
Throttle 0 <t1 2 0 1>
<t> parse command
<T1 2 0 1>
Throttle 0 <0>
<0> parse command
DCCpp PowerOff
<p0>
Throttle 0 <t1 36 0 1>
<t> parse command
<T1 36 0 1>
Throttle 0 <t1 8 0 1>
<t> parse command
<T1 8 0 1>
0 From Throttle : 1
Throttle 00 From Throttle : t1 19 0 0
<1>
<1> parse command
DCCpp PowerOn
<p1>
0 Message From Throttle :
0 Message From Throttle :
Throttle 0 <t1 19 0 0>
<t> parse command
<T1 19 0 0>
readCVraw : start reading cv 29
bit : 0 iter : 3, max : 34
bit : 1 iter : 7, max : 1113
bit : 2 iter : 7, max : 1021
bit : 3 iter : 18, max : 36
bit : 4 iter : 4, max : 33
bit : 5 iter : 8, max : 32
bit : 6 iter : 14, max : 31
bit : 7 iter : 1, max : 35
verif : iter : 3, max : 35
readCVraw : start reading cv 18
bit : 0 iter : 7, max : 36
bit : 1 iter : 12, max : 34
bit : 2 iter : 16, max : 40
bit : 3 iter : 3, max : 33
bit : 4 iter : 8, max : 34
bit : 5 iter : 13, max : 32
bit : 6 iter : 18, max : 33
bit : 7 iter : 5, max : 30
verif : iter : 9, max : 32
readCVraw : start reading cv 17
bit : 0 iter : 14, max : 44
bit : 1 iter : 19, max : 32
bit : 2 iter : 5, max : 34
bit : 3 iter : 10, max : 34
bit : 4 iter : 15, max : 32
bit : 5 iter : 2, max : 34
bit : 6 iter : 7, max : 33
bit : 7 iter : 12, max : 31
verif : iter : 14, max : 36
readCVraw : start reading cv 29
bit : 0 iter : 18, max : 39
bit : 1 iter : 3, max : 1113
bit : 2 iter : 3, max : 1131
bit : 3 iter : 15, max : 38
bit : 4 iter : 19, max : 41
bit : 5 iter : 1, max : 65
bit : 6 iter : 11, max : 33
bit : 7 iter : 16, max : 38
verif : iter : 18, max : 34
readCVraw : start reading cv 18
bit : 0 iter : 4, max : 35
bit : 1 iter : 9, max : 35
bit : 2 iter : 6, max : 40
bit : 3 iter : 19, max : 36
bit : 4 iter : 6, max : 33
bit : 5 iter : 11, max : 37
bit : 6 iter : 16, max : 39
bit : 7 iter : 3, max : 33
verif : iter : 6, max : 36
readCVraw : start reading cv 17
bit : 0 iter : 10, max : 36
bit : 1 iter : 15, max : 39
bit : 2 iter : 1, max : 38
bit : 3 iter : 6, max : 24
bit : 4 iter : 10, max : 33
bit : 5 iter : 14, max : 37
bit : 6 iter : 19, max : 36
bit : 7 iter : 6, max : 31
verif : iter : 10, max : 35
readCVraw : start reading cv 29
bit : 0 iter : 14, max : 38
bit : 1 iter : 3, max : 1092
bit : 2 iter : 7, max : 1076
bit : 3 iter : 11, max : 38
bit : 4 iter : 17, max : 33
bit : 5 iter : 2, max : 40
bit : 6 iter : 7, max : 37
bit : 7 iter : 13, max : 37
verif : iter : 14, max : 33
readCVraw : start reading cv 18
bit : 0 iter : 19, max : 35
bit : 1 iter : 5, max : 34
bit : 2 iter : 10, max : 40
bit : 3 iter : 15, max : 37
bit : 4 iter : 2, max : 36
bit : 5 iter : 6, max : 19
bit : 6 iter : 12, max : 36
bit : 7 iter : 17, max : 35
verif : iter : 2, max : 36
readCVraw : start reading cv 17
bit : 0 iter : 6, max : 38
bit : 1 iter : 11, max : 36
bit : 2 iter : 15, max : 37
bit : 3 iter : 2, max : 39
bit : 4 iter : 2, max : 65
bit : 5 iter : 12, max : 36
bit : 6 iter : 17, max : 36
bit : 7 iter : 4, max : 35
verif : iter : 5, max : 27
Curieux, dans mon relevé sur le serial, il n'y a pas de tentative de lecture du CV1 ...
11:59:08.755 -> 5 From Throttle : MT-S18<;>r
11:59:08.860 -> 5 From Throttle : Q
11:59:08.860 -> Throttle 5 MT-S18<;>r
11:59:08.860 -> 5 -> <T1 18 34 0>MT-S18<;>
11:59:08.860 -> Locomotives ------------------
11:59:08.860 -> 0 : Loco reg:1 id:18 max:128 +/-speed:-33 functions: 1
11:59:08.860 -> 1 : Loco reg:2 id:14 max:128 +/-speed:0 functions:
11:59:08.959 -> Throttle 5 Q
11:59:08.959 -> Converter : client 5 disconnected
11:51:23.777 -> readCVraw : start reading cv 29
11:51:23.850 -> bit : 0 iter : 15, max : 5
11:51:24.484 -> bit : 1 iter : 6, max : 8
11:51:25.152 -> bit : 2 iter : 5, max : 7
11:51:25.787 -> bit : 3 iter : 0, max : 5
11:51:26.458 -> bit : 4 iter : 6, max : 6
11:51:27.122 -> bit : 5 iter : 1, max : 7
11:51:27.760 -> bit : 6 iter : 0, max : 5
11:51:28.420 -> bit : 7 iter : 12, max : 6
11:51:29.064 -> verif : iter : 14, max : 5
11:51:29.666 -> readCVraw : start reading cv 1
11:51:29.734 -> bit : 0 iter : 10, max : 4
11:51:30.392 -> bit : 1 iter : 1, max : 11
11:51:31.020 -> bit : 2 iter : 7, max : 4
11:51:31.679 -> bit : 3 iter : 6, max : 5
11:51:32.336 -> bit : 4 iter : 12, max : 6
11:51:32.977 -> bit : 5 iter : 3, max : 5
11:51:33.645 -> bit : 6 iter : 2, max : 3
11:51:34.266 -> bit : 7 iter : 11, max : 7
11:51:34.957 -> verif : iter : 6, max : 5
11:51:35.616 -> readCVraw : start reading cv 29
11:51:35.683 -> bit : 0 iter : 3, max : 3
11:51:36.320 -> bit : 1 iter : 1, max : 5
11:51:36.986 -> bit : 2 iter : 9, max : 5
11:51:37.636 -> bit : 3 iter : 12, max : 5
11:51:38.292 -> bit : 4 iter : 0, max : 5
11:51:38.927 -> bit : 5 iter : 17, max : 6
11:51:39.596 -> bit : 6 iter : 5, max : 4
11:51:40.259 -> bit : 7 iter : 17, max : 4
11:51:40.891 -> verif : iter : 19, max : 6
11:51:41.473 -> readCVraw : start reading cv 1
11:51:41.545 -> bit : 0 iter : 8, max : 6
11:51:42.208 -> bit : 1 iter : 17, max : 7
11:51:42.870 -> bit : 2 iter : 19, max : 5
11:51:43.490 -> bit : 3 iter : 18, max : 5
11:51:44.159 -> bit : 4 iter : 14, max : 6
11:51:44.825 -> bit : 5 iter : 8, max : 4
11:51:45.449 -> bit : 6 iter : 18, max : 4
11:51:46.115 -> bit : 7 iter : 2, max : 3
11:51:46.777 -> verif : iter : 18, max : 4
11:51:47.435 -> readCVraw : start reading cv 29
11:51:47.502 -> bit : 0 iter : 7, max : 5
11:51:48.154 -> bit : 1 iter : 17, max : 5
11:51:48.815 -> bit : 2 iter : 5, max : 5
11:51:49.474 -> bit : 3 iter : 0, max : 5
11:51:50.100 -> bit : 4 iter : 2, max : 3
11:51:50.769 -> bit : 5 iter : 11, max : 6
11:51:51.397 -> bit : 6 iter : 3, max : 3
11:51:52.058 -> bit : 7 iter : 0, max : 3
11:51:52.718 -> verif : iter : 10, max : 6
11:51:53.322 -> readCVraw : start reading cv 1
11:51:53.389 -> bit : 0 iter : 2, max : 5
11:51:54.039 -> bit : 1 iter : 11, max : 6
11:51:54.705 -> bit : 2 iter : 7, max : 5
11:51:55.326 -> bit : 3 iter : 12, max : 6
11:51:55.977 -> bit : 4 iter : 4, max : 6
11:51:56.630 -> bit : 5 iter : 6, max : 3
11:51:57.284 -> bit : 6 iter : 8, max : 5
11:51:57.955 -> bit : 7 iter : 10, max : 6
11:51:58.626 -> verif : iter : 9, max : 5
11:52:09.962 -> Converter : client 5 disconnected
Nouvelle version 0.8.1 :OK
Corrige le bouton 'Stop' de WiThrottle qui mets bien maintenant la vitesse DCC à 1 (arrêt urgence).
Corrige le bouton 'Idle' de WiThrottle qui mets bien maintenant la vitesse DCC à 0 (arrêt total normal).OK
Stoppe l'effet 'timeout' de déconnexion des throttles pendant la lecture de l'adresse de la loco.NoK : le throttle est toujours déconnecté à la fin de la lecture
Corrige un problème de compilation sur l'IDE 2.0 Beta 6.je n'ai pas pu tester
Allumage du DCC si une demande de lecture d'adresse de loco a été faite au menu.OK
Ajout de la led de statut pendant le setup() dans labox.ino (merci Dominique).OK: merci Thierry
Retrait de la répétition des fonctions pour le moment.Pour allumer les lumières (phares), il faut encore cliquer sur FL, puis F1 (ou F2..). Un nouveau clic sur F0 eteint les lumières.
readCVraw : start reading cv 29
Bit : 0, NO-ACK, samples : 101, gaps : 0, max : -131, start : 0us, duration : 0us
Bit : 1, ACK , samples : 56, gaps : 12, max : 33, start : 43887us, duration : 12001us
Bit : 2, ACK , samples : 31, gaps : 13, max : 35, start : 17713us, duration : 13002us
Bit : 3, NO-ACK, samples : 101, gaps : 0, max : -131, start : 0us, duration : 0us
Bit : 4, NO-ACK, samples : 100, gaps : 0, max : -131, start : 0us, duration : 0us
Bit : 5, NO-ACK, samples : 101, gaps : 0, max : -131, start : 0us, duration : 0us
Bit : 6, NO-ACK, samples : 100, gaps : 0, max : -131, start : 0us, duration : 0us
Bit : 7, NO-ACK, samples : 100, gaps : 0, max : -131, start : 0us, duration : 0us
Verif: , NO-ACK, samples : 101, gaps : 0, max : -131, start : 0us, duration : 0us
qui prouve qu'une commande est bien parvenue à la locomotive. //----------- Start HMI -------------
boxHMI.begin();
readCVraw : start reading cv 29
Bit : 0, ACK , samples : 24, gaps : 1, max : 32, start : 22992us, duration : 1006us
Bit : 1, ACK , samples : 95, gaps : 1, max : 33, start : 94004us, duration : 1008us
Bit : 2, NO-ACK, samples : 101, gaps : 0, max : -112, start : 0us, duration : 0us
Bit : 3, ACK , samples : 87, gaps : 1, max : 37, start : 86134us, duration : 1003us
Bit : 4, NO-ACK, samples : 100, gaps : 0, max : -112, start : 0us, duration : 0us
Bit : 5, ACK , samples : 86, gaps : 1, max : 33, start : 84885us, duration : 999us
Bit : 6, NO-ACK, samples : 100, gaps : 0, max : -112, start : 0us, duration : 0us
Bit : 7, NO-ACK, samples : 101, gaps : 0, max : -112, start : 0us, duration : 0us
Verif: , NO-ACK, samples : 100, gaps : 0, max : -119, start : 0us, duration : 0us
readCVraw : start reading cv 29
Bit : 0, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 1, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 2, NO-ACK, samples : 100, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 3, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 4, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 5, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 6, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 7, NO-ACK, samples : 100, gaps : 0, max : -113, start : 0us, duration : 0us
Verif: , ACK , samples : 27, gaps : 2, max : 32, start : 24938us, duration : 2003us
readCVraw : start reading cv 1
Bit : 0, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 1, ACK , samples : 16, gaps : 1, max : 35, start : 15027us, duration : 1002us
Bit : 2, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 3, NO-ACK, samples : 100, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 4, ACK , samples : 66, gaps : 1, max : 31, start : 64901us, duration : 1000us
Bit : 5, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 6, NO-ACK, samples : 101, gaps : 0, max : -113, start : 0us, duration : 0us
Bit : 7, NO-ACK, samples : 100, gaps : 0, max : -113, start : 0us, duration : 0us
Verif: , ACK , samples : 11, gaps : 2, max : 39, start : 8609us, duration : 1998us
//throttleSerial.begin();
void loop()
{
boxHMI.update();
DCCpp::loop();
if (Serial.available()) {
char inChar = Serial.read();
if (inChar == '+') ackNewValue += 1;
if (inChar == '-') ackNewValue -= 1;
int old;
old = DCCpp::setAckThreshold(ackNewValue);
Serial.print("AckThreshold old ");Serial.print(old);
Serial.print(" -> new ");Serial.println(ackNewValue);
}
}readCVraw : start reading cv 29
Bit : 0, NO-ACK, samples : 100, gaps : 0, max : 12, start : 0us, duration : 0us
Bit : 1, ACK , samples : 48, gaps : 13, max : 358, start : 34914us, duration : 13001us
Bit : 2, ACK , samples : 48, gaps : 13, max : 370, start : 34799us, duration : 13000us
Bit : 3, NO-ACK, samples : 101, gaps : 0, max : 20, start : 0us, duration : 0us
Bit : 4, NO-ACK, samples : 100, gaps : 0, max : 21, start : 0us, duration : 0us
Bit : 5, NO-ACK, samples : 101, gaps : 0, max : 12, start : 0us, duration : 0us
Bit : 6, NO-ACK, samples : 100, gaps : 0, max : 14, start : 0us, duration : 0us
Bit : 7, NO-ACK, samples : 101, gaps : 0, max : 20, start : 0us, duration : 0us
Verif: , NO-ACK, samples : 101, gaps : 0, max : 13, start : 0us, duration : 0us
end reading value:-1
Là j'ai senti 2 coups pour les bits 1 et 2 (c'est normal), mais rien pour la vérification.readCVraw : start reading cv 29
Bit : 0, NO-ACK, samples : 100, gaps : 0, max : 16, start : 0us, duration : 0us
Bit : 1, ACK , samples : 48, gaps : 13, max : 344, start : 34914us, duration : 13000us
Bit : 2, ACK , samples : 48, gaps : 13, max : 341, start : 34796us, duration : 13000us
Bit : 3, NO-ACK, samples : 101, gaps : 0, max : 16, start : 0us, duration : 0us
Bit : 4, NO-ACK, samples : 100, gaps : 0, max : 15, start : 0us, duration : 0us
Bit : 5, NO-ACK, samples : 101, gaps : 0, max : 18, start : 0us, duration : 0us
Bit : 6, NO-ACK, samples : 100, gaps : 0, max : 11, start : 0us, duration : 0us
Bit : 7, NO-ACK, samples : 101, gaps : 0, max : 14, start : 0us, duration : 0us
Verif: , ACK , samples : 32, gaps : 13, max : 349, start : 18596us, duration : 12996us
end reading value:6
readCVraw : start reading cv 1
Bit : 0, NO-ACK, samples : 101, gaps : 0, max : 29, start : 0us, duration : 0us
Bit : 1, ACK , samples : 87, gaps : 1, max : 35, start : 85919us, duration : 999us
Bit : 2, NO-ACK, samples : 101, gaps : 0, max : 30, start : 0us, duration : 0us
Bit : 3, NO-ACK, samples : 101, gaps : 0, max : 27, start : 0us, duration : 0us
Bit : 4, ACK , samples : 53, gaps : 17, max : 378, start : 35904us, duration : 17000us
Bit : 5, NO-ACK, samples : 101, gaps : 0, max : 31, start : 0us, duration : 0us
Bit : 6, NO-ACK, samples : 101, gaps : 0, max : 28, start : 0us, duration : 0us
Bit : 7, NO-ACK, samples : 101, gaps : 0, max : 29, start : 0us, duration : 0us
Verif: , ACK , samples : 32, gaps : 13, max : 364, start : 18978us, duration : 12996us
end reading value:18 loadPacket(0, resetPacket, 2, 3); // NMRA recommends starting with 3 reset packets
loadPacket(0, bRead, 3, 5); // NMRA recommends 5 verify packets
// loadPacket(0, resetPacket, 2, 1); // forces code to wait until all repeats of bRead are completed (and decoder begins to respond)
loadPacket(0, idlePacket, 2, 6); // NMRA recommends 6 idle or reset packets for decoder recovery time
ret = RegisterList::checkAcknowlegde(i, channel, base);
https://github.com/DCC-EX/DCCInspector-EX
Je pense que le sniffer ne voit que les paquets de commande, il n'est pas équipé pour détecter les pics de consommation.
Une mise à jour verra le jour prochainement, soyez patient !
isr : 2
min : 54
max : 62
ave : 57.50
< 48: 0
= 48: 0
= 49: 0
= 50: 0
= 51: 0
= 52: 0
= 53: 0
= 54: 120
= 55: 0
= 56: 120
= 57: 0
= 58: 59520 (99.20%)
= 59: 0
= 60: 120
= 61: 0
= 62: 120
= 63: 0
= 64: 0
= 65: 0
= 66: 0
= 67: 0
> 68: 0
NMRA compliant: 59760 (99.60%)
isr : 23
min : 53
max : 63
ave : 57.50
< 48: 0
= 48: 0
= 49: 0
= 50: 0
= 51: 0
= 52: 0
= 53: 120
= 54: 0
= 55: 120
= 56: 0
= 57: 240
= 58: 59043 (98.40%)
= 59: 241
= 60: 0
= 61: 120
= 62: 0
= 63: 120
= 64: 0
= 65: 0
= 66: 0
= 67: 0
> 68: 0
NMRA compliant: 59764 (99.60%)
isr : 3
min : 25
max : 90
ave : 57.50
< 48: 2352
= 48: 0
= 49: 0
= 50: 0
= 51: 0
= 52: 0
= 53: 0
= 54: 198
= 55: 960
= 56: 1849
= 57: 6489
= 58: 6554 (10.92%)
= 59: 20937
= 60: 17559
= 61: 1059
= 62: 174
= 63: 91
= 64: 99
= 65: 857
= 66: 272
= 67: 214
> 68: 344
NMRA compliant: 55407 (92.33%)
#include <soc/sens_reg.h>
#include <soc/sens_struct.h>
int local_adc1_read(int channel)
{
uint16_t adc_value;
SENS.sar_read_ctrl.sar1_dig_force = 0; // switch SARADC into RTC channel
SENS.sar_meas_wait2.force_xpd_sar = SENS_FORCE_XPD_SAR_PU; // adc_power_on
SENS.sar_meas_wait2.force_xpd_amp = SENS_FORCE_XPD_AMP_PD; // channel is set in the convert function
// disable FSM, it's only used by the LNA.
SENS.sar_meas_ctrl.amp_rst_fb_fsm = 0;
SENS.sar_meas_ctrl.amp_short_ref_fsm = 0;
SENS.sar_meas_ctrl.amp_short_ref_gnd_fsm = 0;
SENS.sar_meas_wait1.sar_amp_wait1 = 1;
SENS.sar_meas_wait1.sar_amp_wait2 = 1;
SENS.sar_meas_wait2.sar_amp_wait3 = 1;
//set controller
SENS.sar_read_ctrl.sar1_dig_force = false; //RTC controller controls the ADC, not digital controller
SENS.sar_meas_start1.meas1_start_force = true; //RTC controller controls the ADC,not ulp coprocessor
SENS.sar_meas_start1.sar1_en_pad_force = true; //RTC controller controls the data port, not ulp coprocessor
SENS.sar_touch_ctrl1.xpd_hall_force = true; // RTC controller controls the hall sensor power,not ulp coprocessor
SENS.sar_touch_ctrl1.hall_phase_force = true; // RTC controller controls the hall sensor phase,not ulp coprocessor
//start conversion
SENS.sar_meas_start1.sar1_en_pad = (1 << channel); //only one channel is selected.
while (SENS.sar_slave_addr1.meas_status != 0);
SENS.sar_meas_start1.meas1_start_sar = 0;
SENS.sar_meas_start1.meas1_start_sar = 1;
while (SENS.sar_meas_start1.meas1_done_sar == 0);
adc_value = SENS.sar_meas_start1.meas1_data_sar; // set adc value!
SENS.sar_meas_wait2.force_xpd_sar = SENS_FORCE_XPD_SAR_PD; // adc power off return adc_value;
return adc_value;
}
int channel = digitalPinToAnalogChannel(pin);
pour faire la conversion.analogRead = 1699
adc1_read = 1699
analogRead = 1702
adc1_read = 1700
analogRead = 1703
adc1_read = 1699
analogRead = 1702
adc1_read = 1701
analogRead = 1711
adc1_read = 1702
analogRead = 1702
adc1_read = 1696
analogRead = 1703
adc1_read = 1699
analogRead = 1703
adc1_read = 1687
analogRead = 1706
adc1_read = 1688
analogRead = 1706
adc1_read = 1699
analogRead = 1695
adc1_read = 1833
analogRead = 2631
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 4095
adc1_read = 4095
analogRead = 3509
adc1_read = 2702
analogRead = 2734
adc1_read = 2731
analogRead = 2745
adc1_read = 2739
analogRead = 2736
adc1_read = 2644
analogRead = 2734
adc1_read = 2741
analogRead = 2715
adc1_read = 2736
analogRead = 2735
adc1_read = 2731
analogRead = 2736
adc1_read = 2733
analogRead = 2740
adc1_read = 2737
analogRead = 2733
adc1_read = 2731
analogRead = 2431
adc1_read = 1472
analogRead = 1472
adc1_read = 1477
analogRead = 1480
adc1_read = 1598
analogRead = 1583
adc1_read = 1565
analogRead = 1579
adc1_read = 1591
analogRead = 1581
adc1_read = 1577
analogRead = 1585
adc1_read = 1575
analogRead = 1584
adc1_read = 1582
analogRead = 1575
adc1_read = 1267
analogRead = 688
adc1_read = 644
analogRead = 645
adc1_read = 645
analogRead = 589
adc1_read = 639
analogRead = 647
adc1_read = 642
analogRead = 625
adc1_read = 640
analogRead = 654
adc1_read = 645
analogRead = 646
adc1_read = 640
analogRead = 479
adc1_read = 0
analogRead = 0
adc1_read = 0
analogRead = 0
adc1_read = 0
analogRead = 0
adc1_read = 0
analogRead = 0
adc1_read = 0
analogRead = 0
adc1_read = 0
analogRead = 0
adc1_read = 0
analogRead = 0
adc1_read = 0
analogRead = 0
adc1_read = 73
analogRead = 87
adc1_read = 80
analogRead = 79
adc1_read = 81
analogRead = 78
adc1_read = 85
analogRead = 80
adc1_read = 80
analogRead = 80
adc1_read = 99
analogRead = 80
adc1_read = 80
analogRead = 81
adc1_read = 80
analogRead = 82
adc1_read = 82
analogRead = 80
adc1_read = 85
analogRead = 80
adc1_read = 80
analogRead = 80
adc1_read = 84
analogRead = 75
adc1_read = 80
analogRead = 80
adc1_read = 80#include <soc/sens_reg.h>
#include <soc/sens_struct.h>
int canal = digitalPinToAnalogChannel(36);
void setup() {
Serial.begin(115200);
Serial.println("LaBox ");
}
void loop() {
// put your main code here, to run repeatedly:
Serial.print("adc1_read = ");
Serial.println(local_adc1_read (canal));
delay(500);
Serial.print("analogRead = ");
Serial.println(analogRead(36)); // debug value
delay(500);
}
#include <soc/sens_reg.h>
#include <soc/sens_struct.h>
int local_adc1_read(int channel)
{
uint16_t adc_value;
SENS.sar_read_ctrl.sar1_dig_force = 0; // switch SARADC into RTC channel
SENS.sar_meas_wait2.force_xpd_sar = SENS_FORCE_XPD_SAR_PU; // adc_power_on
SENS.sar_meas_wait2.force_xpd_amp = SENS_FORCE_XPD_AMP_PD; // channel is set in the convert function
// disable FSM, it's only used by the LNA.
SENS.sar_meas_ctrl.amp_rst_fb_fsm = 0;
SENS.sar_meas_ctrl.amp_short_ref_fsm = 0;
SENS.sar_meas_ctrl.amp_short_ref_gnd_fsm = 0;
SENS.sar_meas_wait1.sar_amp_wait1 = 1;
SENS.sar_meas_wait1.sar_amp_wait2 = 1;
SENS.sar_meas_wait2.sar_amp_wait3 = 1;
//set controller
SENS.sar_read_ctrl.sar1_dig_force = false; //RTC controller controls the ADC, not digital controller
SENS.sar_meas_start1.meas1_start_force = true; //RTC controller controls the ADC,not ulp coprocessor
SENS.sar_meas_start1.sar1_en_pad_force = true; //RTC controller controls the data port, not ulp coprocessor
SENS.sar_touch_ctrl1.xpd_hall_force = true; // RTC controller controls the hall sensor power,not ulp coprocessor
SENS.sar_touch_ctrl1.hall_phase_force = true; // RTC controller controls the hall sensor phase,not ulp coprocessor
//start conversion
SENS.sar_meas_start1.sar1_en_pad = (1 << channel); //only one channel is selected.
while (SENS.sar_slave_addr1.meas_status != 0);
SENS.sar_meas_start1.meas1_start_sar = 0;
SENS.sar_meas_start1.meas1_start_sar = 1;
while (SENS.sar_meas_start1.meas1_done_sar == 0);
adc_value = SENS.sar_meas_start1.meas1_data_sar; // set adc value!
SENS.sar_meas_wait2.force_xpd_sar = SENS_FORCE_XPD_SAR_PD; // adc power off return adc_value;
return adc_value;
}
... vérifier que les timings DCC sont bons avec la lecture analogique débranchée (UNDEFINED_PIN sur le troisième argument de beginMain() dans Labox.ino...) ...
D:\Documents\Arduino\libraries\LaBox\src\hmi\hmi.cpp:
728 {
729 _HMIDEBUG_FCT_PRINTLN("hmi::readVoltage().. Begin");
730: voltage = (float) (analogRead(PIN_VOLTAGE_MES) * HMI_VoltageK);
731 #ifdef _HMIDEBUG_SIMUL
732 voltage = ((float)random(175, 185)) / 10;
...
744 {
745 _HMIDEBUG_FCT_PRINTLN("hmi::readCurrent().. Begin");
746: //current = analogRead(PIN_CURRENT_MES) * HMI_CurrentK ;
747 // DB : remplacé par une moyenne de 50 mesures
748 float base = 0;
749 for (int j = 0; j < 50; j++)
750 {
751: float val = (float) analogRead(PIN_CURRENT_MES);
752 base += val;
753 }
Je suppose donc que notre ami trimarco232 n'inclut pas de lecture analogique du courant dans sa génération ultra-précise du DCC en PWM.non, je n'en suis pas là ; toutefois les interruptions n'ont lieu qu'à chaque bit dcc, cad. 116µs minimum, ce qui laisse beaucoup + de temps d'y faire des choses ...
(...)
Bonjour,
pour ceux que ça intéresse, l'analyse logique à 10 balles :
- acheter un clone salae ... + les petites pinces qui vont bien (que j'ai soudées pour qu'elles aillent mieux) + des rallonges dupont de qualité
- télécharger et installer le logiciel salae, c'est juste pour avoir le driver
- télécharger et installer PulseView ; on peut voir les bits à ce stade
- télécharger "sigrok-DCC-Protocoll" ; extraire le dossier "DCC" et l'ajouter dans le repertoire "decoders" ; chez-moi :C:\Program Files\sigrok\PulseView\share\libsigrokdecode\decoders
- dans la config du decoder, dans "01 or 10", choisir "10"
(aucune raison que le sniffer à base d'ESP32 ne fonctionne pas parfaitement)
(... !)c'est pour cette raison, entre autres IDE exotiques, que je me coltine windows :-\ aussi
J'aimerai bien mais sur Mac, point de soft possible :-\
@Trimarco : dans ton analyse, tu exclu le bit de fin de paquet du préambule suivant..oui, je n'avais pas non plus encore incorporé, au stade où j'ai remis le projet dans une boîte, le calcul de la cheksum :-\
... pour ceux que ça intéresse, l'analyse logique à 10 balles ...
Dans tout ça il faut largement moduler les "vérités" qui sont lancées ici ou là...si c'est le railcom, c'est dans la norme
(...)
la centrale insère systématiquement une perturbation (ou un signal à destination d'un autre dispositif, or de la norme DCC)
vous voulez un coup de main pour quelques tests, n'hésitez pas.(hs) j'ai une centrale à faire avancer, mais pour le coup de main il faudrait + que quelques tests ... (hs\)
Non ce n'est pas le cutout...j'ai bien entendu vérifié ;)Des précisions seraient utiles : quelle marque, quel modèle ? quel contexte ?
Current mode :2
Running time :2910592840
Valid bits :19398649
Glitch :0
Rejected pair :3
Invalid packets :0
Valid packets :408783
Dropped packets :0
Idle packets :37162
Filtered packets :334457
Processed packets :37162
(...)généralement 55 sur le premier et 56 sur le second.ce qui pourait très bien s'expliquer par un dead time de commande des mosfets qui serait de 1/2µs
410281220:1:56:56
410281336:1:56:56
410281452:1:56:56
410281560:1:56:56
410281672:1:56:56
410281788:1:56:56
410281896:1:56:56
410282008:1:56:56
410282120:1:56:56
410282240:1:56:56
410282344:1:56:56
410282456:1:56:56
410282568:1:56:56
410282684:1:56:56
410282796:1:56:56
410282912:1:56:56
410283024:1:56:56
410283132:1:56:56
410283340:0:104:105
410283548:0:104:105
410283756:0:104:105
410283968:0:104:105
410284176:0:104:105
410284384:0:104:105
410284592:0:104:105
410284704:1:56:56
410284816:1:56:56
410285028:0:104:105
410285136:1:56:56
410285348:0:104:105
410285556:0:104:105
410285668:1:56:56
410285876:0:104:105
410286084:0:104:105
410286196:1:56:56
410286308:1:56:56
410286520:0:104:105
410286632:1:56:56
410286840:0:104:105
410287048:0:104:105
410287168:1:56:56
410287368:0:104:105
410287580:0:104:105
410287796:0:104:105
410287996:0:104:105
410288108:1:56:56
410288220:1:56:56
410288332:1:56:56
410288444:1:56:56
410288556:1:56:56
410288668:1:56:56
410288780:1:56:56
410288896:1:56:56
410289008:1:56:56
410289120:1:56:56
410289232:1:56:56
410289344:1:56:56
410289456:1:56:56
410289568:1:56:56
410289680:1:56:56
410289796:1:56:56
410289904:1:56:56
410290020:1:56:56
15188460:1:56:61
15188560:1:56:61
15188680:1:56:61
15188796:1:56:61
15188912:1:56:61
15189032:1:56:61
15189148:1:56:61
15189268:1:56:61
15189384:1:56:61
15189500:1:56:61
15189616:1:56:61
15189736:1:56:61
15189852:1:56:61
15189972:1:56:61
15190088:1:56:61
15190212:1:56:61
15190416:0:104:108
15190628:0:104:108
15190840:0:104:108
15191056:0:104:108
15191264:0:104:108
15191384:1:56:61
15191596:0:104:108
15191808:0:104:108
15191924:1:56:61
15192136:0:104:108
15192348:0:104:108
15192564:0:104:108
15192676:1:56:61
15192796:1:56:61
15192912:1:56:61
15193032:1:56:61
15193148:1:56:61
15193264:1:56:61
15193476:0:104:108
15193592:1:56:61
15193804:0:103:108
15193924:1:56:61
15194040:1:56:61
15194156:1:56:61
15194276:1:56:61
15194488:0:104:108
15194604:1:56:61
15194816:0:104:108
15194932:1:56:61
15195152:0:104:108
15195356:0:104:108
15195572:0:103:108
15195688:1:56:61
15195900:0:104:108
15196016:1:56:61
15196132:1:56:61
15196252:1:56:61
15196780:R:30:496
15196840:R:496:56
15196896:1:56:61
15197012:1:56:61
15197128:1:56:61
15197248:1:56:61
15197364:1:56:61
15197480:1:56:61
15197600:1:56:61
15197716:1:56:61
15197844:1:56:61
15197952:1:56:61
15198068:1:56:61
15198184:1:56:61
15198304:1:56:61
15198420:1:56:61
15198536:1:56:61
15198656:1:56:61A Semaphore that is given in an ISR and waited for in the delay function is one good way to implement shorter than a tick delays/periods. If the operation to be done is simple/quick enough, it could even be done in the ISR.
This works well for delays on the order of a 100us or longer (depending on the speed of your processor). Note that the actual delay in the function will be a bit longer than the timer setting as you have the ISR processing delay, and the subsequent task switch (and possible additional delays if a higher priority task becomes ready)
This doesn’t work well for short (like 5us) delays where you really need a precise value. That isn’t the time frame that an RTOS is aimed at. For that you either need “hardware” to do it, or you disable interrupts and do precisely timed stand alone code.
Si effectivement on arrive pas à générer un signal stable directement avec l'ESP, oui il faut confier ça à un composant externe. Plutot qu'un FPGA j'aurais tendance à garder un petit CPU 8 bits facilement sourçable et que tout le monde sait programmer....
Donc trois bits de perdus à chaque trame....qui peut mieux faire ?
il m'a semblé que le RMT ne permet pas de générer le cutout du railcom
En revanche, en émission, il possède un mode à buffer CIRCULAIRE qui permet d'injecter un flux en continu dans le système...avec une interruption levée quand une fraction du buffer est consommée (ce qui permet de le recharger).
Je n'ai pas essayé ce mode....mais ça doit le faire.
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "Arduino.h"
#include "esp32-hal.h"#define NR_OF_IDLE_BITS 40
///////////////////////////////////////////////////////////////////////////////
// The NMRA DCC Signal is sent as a square wave with each half having
// identical timing (or nearly identical). Packet Bytes have a minimum of 11
// preamble ONE bits in order to be considered valid by the decoder. For
// RailCom support it is recommended to have at least 16 preamble bits. For the
// Programming Track it is required to have a longer preamble of at least 22
// bits. Packet data follows immediately after the preamble bits, between the
// packet bytes a DCC ZERO is sent. After the last byte of packet data a DCC
// ONE is sent.
//
// DCC ZERO:
// ----------------
// | 96 |
// ---| usec | 96 ---
// | usec |
// ----------------
// DCC ONE:
// --------
// | 58 |
// ---| usec | 58 ---
// | usec |
// --------
//
// The timing can be adjusted via menuconfig with the above being the default
// values when using the APB clock.
// Une trame IDLE est émise quand il n’y a pas de trame de commande à envoyer,
// de façon à alimenter continuellement la voie :
// 111111111111 0 11111111 0 00000000 0 11111111 1
//
///////////////////////////////////////////////////////////////////////////////
int IDLE_pattern[NR_OF_IDLE_BITS] = {1,1,1,1,1,1,1,1,1,1,1,1, 0, 1,1,1,1,1,1,1,1, 0, 0,0,0,0,0,0,0,0, 0, 1,1,1,1,1,1,1,1, 1};
rmt_data_t idle_data[NR_OF_IDLE_BITS];
rmt_obj_t* rmt_send = NULL;et les 2 variables idle_data (les formes de bits à émettre et rmt_send, pointeur nécessaires au driver.void setup()
{
Serial.begin(115200);
Serial.println("init RMT pin33");
if ((rmt_send = rmtInit(33, true, RMT_MEM_64)) == NULL) // init sur DCC pin = 33
{
Serial.println("init sender failed\n");
}
/**
* Sets the clock/divider of timebase the nearest tick to the supplied value in nanoseconds
* return the real actual tick value in ns
*/
float realTick = rmtSetTick(rmt_send, 1000); // a calculer pour 1 uS
Serial.printf("real tick set to: %fns\n", realTick);
int i=0;
/*
* Preparation du jeu d'essai : une trame IDLE
*/
for (i=0;i<NR_OF_IDLE_BITS; i++) {
if (IDLE_pattern[i]==0) { // UN
idle_data[i].level0 = 1;
idle_data[i].duration0 = 96;
idle_data[i].level1 = 0;
idle_data[i].duration1 = 96;
} else { // ZERO
idle_data[i].level0 = 1;
idle_data[i].duration0 = 58;
idle_data[i].level1 = 0;
idle_data[i].duration1 = 58;
}
}
pinMode(32, OUTPUT);
digitalWrite(32, HIGH);
Serial.println("loop");
// Send the data
rmtLoop(rmt_send, idle_data, NR_OF_IDLE_BITS);
} int val = analogRead(36);
Serial.print(val); Serial.print('-');
linecount++;
if (linecount > 50) {
Serial.println();
linecount = 0;
}
delay(25);
Donc toutes les 25 millisecondes, une mesure de tension a lieu avec analogRead et un Serial.print suit dans la foulée, de quoi perturber notre trame IDLE émise par RMT si le driver RMT est influencé dans l'environnement freeRTOS.20:58:24.995 -> Bit Count/4 sec=29294 (Zeros=8055, Ones=21239), Glitches=0
20:58:24.995 -> Valid Packets=733, NMRA out of spec=0, Checksum Errors=0, Lost pkts=0, Long pkts=0
20:58:25.029 -> 0 half-bit length (us): 95.5 (95-96) delta < 1
20:58:25.029 -> 1 half-bit length (us): 57.5 (57-59) delta < 2
20:58:25.029 -> --
20:58:25.029 -> Idle 11111111 00000000
Mais je suis bien au fait qu'il existe ...
Bonjour à tous et merci à Thierry,
j'ai probablement mal cherché mais je n'ai pas vu de config.h ou d'exemple.
Il y en a eu un exemple en mars mais il est très générique. Et j'imagine que pour faire tourner LaBox avec DCC-EX, il faut préciser quelques détails et comment s'y prendre.
Dominique, tu as peut-être les éléments nécessaires ?
// To obtain a starting copy of config.h please copy the file config.example.h which is
// shipped with the code and may be updated as new features are added.
//
// If config.h is not found, config.example.h will be used with all defaults.
/*
* SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* NOTE: this is not the original header file from the soc component. It is a stripped-down copy to support mocking.
*/ets Jun 8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
flash read err, 1000
ets_main.c 371
ets Jun 8 2016 00:22:57
rst:0x10 (RTCWDT_RTC_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:1344
load:0x40078000,len:13864
load:0x40080400,len:3608
entry 0x400805f0
<* License GPLv3 fsf.org (c) dcc-ex.com *>
<* Platform: ESP32 *>
<* LCD0:DCC++ EX v4.2.4 rc1 *>
<* LCD1:Lic GPLv3 *>
Start wifi
........................................<* Could not connect to Wifi SSID freebox_CKIHWJ *>
<* Forcing one more Wifi restart *>
E (22645) wifi:sta is connecting, return error
........................................<* Wifi STA mode FAIL. Will revert to AP mode *>
<* Wifi AP SSID DCC_0689F0 PASS xxx mon pw xxx *>
<* Wifi AP IP 192.168.4.1 *>
<* Server will be started on port 2560 *>
End wifi
<* CurrentPin=A0, Offset=2695, TripValue=1000 *>
<* Channel 0 DCC signal for MAIN start *>
<iDCC-EX V-4.2.4 rc1 / ESP32 / ESP32 G-PORTX-HAL-20220830>
<* LCD3:Ready *>
<p0>
<* LCD2:Power Off *>
ets Jun 8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
flash read err, 1000
ets_main.c 371
ets Jun 8 2016 00:22:57
rst:0x10 (RTCWDT_RTC_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:1344
load:0x40078000,len:13864
load:0x40080400,len:3608
entry 0x400805f0
<* License GPLv3 fsf.org (c) dcc-ex.com *>
<* Platform: ESP32 *>
<* LCD0:DCC++ EX v4.2.4 rc1 *>
<* LCD1:Lic GPLv3 *>
Start wifi
E (483) wifi_init_default: netstack cb reg failed with 12289
........................................<* Could not connect to Wifi SSID VIDEOFUTUR_ED5939_2.4G *>
<* Forcing one more Wifi restart *>
E (20513) wifi:sta is connecting, return error
........................................<* Wifi STA mode FAIL. Will revert to AP mode *>
<* Wifi AP SSID DCC_0689F0 PASS 2932003454 *>
<* Wifi AP IP 192.168.4.1 *>
<* Server will be started on port 2560 *>
End wifi
<* CurrentPin=A0, Offset=168, TripValue=1000 *>
<* Channel 0 DCC signal for MAIN start *>
<iDCC-EX V-4.2.4 rc1 / ESP32 / ESP32 G-PORTX-HAL-20220830>
<* LCD3:Ready *>
<p0>
<* LCD2:Power Off *>ets Jun 8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
flash read err, 1000
ets_main.c 371
ets Jun 8 2016 00:22:57
rst:0x10 (RTCWDT_RTC_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:1344
load:0x40078000,len:13864
load:0x40080400,len:3608
entry 0x400805f0
<* License GPLv3 fsf.org (c) dcc-ex.com *>
<* Platform: ESP32 *>
<* LCD0:DCC++ EX v4.2.4 rc1 *>
<* LCD1:Lic GPLv3 *>
Start wifi
E (4555) wifi_init_default: netstack cb reg failed with 12308
<* Wifi AP SSID DCC_0689F0 PASS PASS_0689F0 *>
<* Wifi AP IP 192.168.4.1 *>
<* Server will be started on port 2560 *>
End wifi
<* CurrentPin=A0, Offset=169, TripValue=1000 *>
<* Channel 0 DCC signal for MAIN start *>
<iDCC-EX V-4.2.4 rc1 / ESP32 / ESP32 G-PORTX-HAL-20220830>
<* LCD3:Ready *>
<p0>
<* LCD2:Power Off *>
SSID DCC_0689F0 PASS PASS_0689F0
Un grand BRAVO à toi, Thierry !
Quel progrès et quel boulot, surtout avec toutes ces explications.
Je vais tester dès que possible, avec impatience.
Apparemment c'est compliqué voire impossible de communiquer en Wifi à partir de HTML.
Just to be clear.. the brake output is not used in dcc-ex 4.x but will be used on 5.x if you wish to run DC locos as well as DCC.
Brake is also required should we ever support the RailCom cutout.
Il est là dans la réponse 339
https://forum.locoduino.org/index.php?topic=922.msg12063#msg12063 (https://forum.locoduino.org/index.php?topic=922.msg12063#msg12063)
Mais je regarde la dernière version qui apporte des améliorations... sous réserve de coquille que nous n'aurions pas vue...
La voici, la version 0.4 du 14-06-2021 qui intègre l'ampli de ligne Can MCP2564 à la place su support pour la petite carte qui n'existe plus.
et la BOM
voir les pièces jointes
Bonjour,
IC1 est un pont L6203.
Par exemple :
https://fr.aliexpress.com/item/33003883508.html
A noter qu'un article est en cours de rédaction.
Avec la possibilité d'un circuit imprimé déjà équipé de la plupart des petits composants (CMS soudés)
Le soft restera compatible.
Cette version du circuit utilise un module d'interface pour le CAN : le CJMCU-230 (attention certains ont une sérigraphie inversée)
https://fr.aliexpress.com/item/32635274058.html
Les nouvelles versions du circuit utilisent un composant CMS dédié, le MCP2562 soudé par JLCPCB. Ou par soi-même si on acquiert le circuit nu.
le MCP2562 assure la même fonction que le module qui comporte un SN65HVD230.
Concernant, le mode LaBox (STA ou PA), je ne saurais vous répondre, je ne sais pas de quoi il s'agit.
Merci pour votre aide,
Bonsoir,
pouvez vous nous poster votre config.h
et la capture du (re)démarrage de l'ESP32 après un reset sur le serial.
mode:DIO, clock div:1
load:0x3fff0030,len:1344
load:0x40078000,len:13964
load:0x40080400,len:3600
entry 0x400805f0
LaBox 0.9.3
...Server IP address: 192.168.1.44 (Livebox-DBAC) connected ! connectWifi achieved.
Ino executing on core 1
Throttles command receivers executing on core 0
begin achieved
Signal started for Main track on pin 33
Main track DCC ESP32 started.
beginMain achivied with pin 33
*** LaBox LIBRARY : 0.9.3
VERSION DCC++ : 2.0.0
COMPILED : Nov 12 2023 11:47:31
ENABLE(PWM): 32
CURRENT: 36
Throttles ------------------
0 : Serial
1 : JMRI
2 : ThrottleWifi: Z21 - 1 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) ip:0.0.0.0
3 : ThrottleWifi: Z21 - 2 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) ip:0.0.0.0
4 : ThrottleWifi: Z21 - 3 WifiPort: 21105 WifiProtocol: UDP (Z21 converter : ) ip:0.0.0.0
5 : ThrottleWifi: WiThrottle - 1 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 ip:0.0.0.0
6 : ThrottleWifi: WiThrottle - 2 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 ip:0.0.0.0
7 : ThrottleWifi: WiThrottle - 3 WifiPort: 44444 WifiProtocol: TCP (WiThrottle converter) start:60 end:62 ip:0.0.0.0
... mais avez vous tenté d'envoyer <1> via le serial monitor à 115200 bauds ?
0 From Throttle : 1
0 Message From Throttle :
Throttle 0 <1>
<1> parse command
DCCpp PowerOn Main
<p1>Bonsoir,Bonsoir,
je pense que vous êtes tombé dans le piège suivant :
il faut un pont ou un jumper entre les pointes des deux flèches du schéma joint.
un pont de soudure au dos convient.
A suivre pour le Wifi.
PS : ce n'est pas le config.h que vous avez utilisé que vous nous avez envoyé.
/**********************************************************************
Config.h
COPYRIGHT (c) 2013-2016 Gregg E. Berman
Adapted for DcDcc by Thierry PARIS
Part of DCC++ BASE STATION for the Arduino/*
* © 2022 Paul M. Antoine
* © 2021 Neil McKechnie
* © 2020-2023 Harald Barth
* © 2020-2021 Fred Decker
* © 2020-2021 Chris Harlow
* © 2023 Nathan Kellenicki
*
* This file is part of CommandStation-EX
*
* This is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
ne pas confondre DCCpp et DCC-EX :-\
Et merci pour le partage de ton application de pilotage.
D'après les datasheet respectives, il me semble que le brake est possible sur le L6203.
Il existe bien un état SINK1 - SINK2
Je vous propose de changer votre fusil d'épaule :D
Installer le logiciel CommandStation-EX-LaBox de cette façon : Télécharger la version (actuelle 2.3.0).
https://github.com/Locoduino/CommandStation-EX-LaBox (https://github.com/Locoduino/CommandStation-EX-LaBox)
....
Bonsoir,
on revient au config.h
vous avez choisi le mode AP (Point d’Accès) et non le mode station ?
#define WIFI_SSID "LaBox230"
#define WIFI_PASSWORD "12345678"
Vous connectez votre smartphone sur ce réseau avant de démarrer Z21 ?
Vous pouvez regarder ce que dit le serial monitor après un reset de l'ESP32 ?