program Lotir
‘ 12F675 à 4MHz
‘ émet un octet à 19200bps
‘ un octet: 0,52ms
‘ x8 pour faire comme Milou: 4ms
‘===================================================================== SYMBOLES
symbol PinTxJPM = GPIO.4 ‘ pour SoftTransmitJPM
‘==================================================================== VARIABLES
‘à 9600bps le temps bit theorique est de 104 µs
’97 est le milieu de la fourchette d’acceptation par le PC: 92-102
‘const TempsBit as longword = 86 ‘pour 9600bps
‘à 19200bps le temps bit theorique est de 52 µs
const TempsBit as longword = 36 ‘pour 19200bps
‘=================================================================== PROCEDURES
sub procedure SoftTransmitJPM (dim X as byte) ‘************** soft transmit JPM
‘moins encombrant en ROM que le soft_transmit de MikroElectronika
‘envoi du caractère X sur le port SoftTx, à 9600bps.
dim N as byte
ClearBit(INTCON, GIE)
PinTxJPM = 0 ‘bit de start
delay_us(TempsBit) ‘à régler et tester
for N = 0 to 7 ‘envoi des 8 bits de l’octet, LSB en premier
PinTxJPM = (X and 1)
delay_us(TempsBit)
X = X >> 1
next N
‘2 bits de stop
PinTxJPM = 1
delay_us(TempsBit)
delay_us(TempsBit)
SetBit(INTCON,GIE)
end sub
main: ‘=================================================================== MAIN
CMCON = 7
OSCCAL = 36 ‘calibration horloge
TRISIO = %11101110
‘Soft_UART_Init(GPIO, 1, 0, 19200, 0) ‘ port, Rx, Tx, baud, inverted ‘KO
‘============================================================ boucle permanente
while true
 » test
‘ SoftTransmitJPM(0)
‘ SoftTransmitJPM(%01010101) ’85 ‘0x55
‘ SoftTransmitJPM(%10101010) ‘170 0xAA
‘ SoftTransmitJPM(255)
‘ Delay_ms(1)
‘normal
SoftTransmitJPM(71)
Delay_ms(4)
wend
end.

// ================ programme Lotir-demo (balise intelligente) ======================
// Ce NodeMCU/ESP-12, installé à poste fixe, reçoit les signaux des émetteurs embarqués via le port série,
// les traite, puis envoie les commandes appropriées à la centrale DCC (par exemple: siffler).
// Il fonctionne en mode station vis-à-vis de la centrale DCC.
// Pour les tesst il fonctionne en mode station vis à vis d’un PC.
// Pour le paramétrage il fonctionne en mode point d’accès pour les smartphones et tablettes.
// ==================================================================================
#include <ESP8266WiFi.h>
#include <WiFiUDP.h>
#include <EEPROM.h>
// informations remontées au PC pour affichage
#define sp Serial.print
#define spl Serial.println
// personnalisation du module
#define EEPROM_SIZE 256
int EEPROMcentraleAddress = 0; // n° de la centrale DCC
byte centrale; // n° de la centrale DCC
int EEPROMtableAddress = 1; //table d’action
const byte LED = LED_BUILTIN; // NodeMCU
//const byte LED = 16; // NodeMCU
//const byte LED = 2; // LED externe ESP-01 (impossible de commander la LED interne)
byte AdresseLocale; // …c’est l’adresse de l’engin moteur associé
char NbEssais; // vérification de la connexion toutes les X ms
char reseau = 0; // réseau auquel on est connecté
// commandes reçues du PC en UDP
int NbMots;
String Mots[8];
// tables d’action: le numéro du module émetteur IR étant dificile à modifier, la table indique
// pour le n° du module qui passe, l’adresse DCC associée, fonction à activer, durée avant reset, etc
unsigned int tableAction[5][4];
// gestion des octets reçus sur le port série
byte DernierOctet, compte, precedente;
unsigned long previousMillis = 0;
const long interval = 1000;
bool EnableTransmission = true;
// remise à zéro de la fonction activée
byte derniereAction;
unsigned long previousMillis2 = 0;
unsigned long interval2 = 2000;
bool EnableResetAction = false;
// transmission des paquets UDP vers la centrale ou le PC pour tests
char PaquetUDP[16]; // paquets transmis vers la centrale
// mode point d’accès pour les détecteurs
#define AP_SSID « lotir »
#define AP_PASS « 12345678 »
// mode station vers le PC + Packet Sender pour test
#define WIFI_SSID2 « Livebox-9052 »
#define WIFI_PASS2 « 00112233445566778899AABBCC »
// #define IP_CENTRALE {192,168,1,10}
// pour récupération des paquets UDP
const uint16_t PORT = 50000; // Port d’écoute UDP
const uint16_t BUFFER_SIZE = 64; // Taille du tampon de réception
char buffer[BUFFER_SIZE]; // Tampon de réception
uint16_t len = 0;// Taille du paquet reçu;
// pour envoi des paquetsUDP
char MessageUDP[32];
IPAddress IP_CENTRALE;
// instanciation du serveur UDP
WiFiUDP udp;
void setup() { // =================================================================================== setup
pinMode (LED, OUTPUT);
digitalWrite (LED, HIGH); // Led connectée au plus
Serial.begin(19200);
spl();
EEPROM.begin(EEPROM_SIZE);
EEPROM.get (0, centrale);
EEPROM.get (1, tableAction);
// —————————————————————————– démarrage du point d’accès
WiFi.mode(WIFI_AP_STA);
IPAddress local_IP(192,168,4,1); // adresse IP du point d’accès
IPAddress gateway(192,168,4,1);
IPAddress subnet(255,255,255,0);
WiFi.softAPConfig(local_IP, gateway, subnet); // fixe l’adresse IP du point d’accès
//WiFi.softAPConfig({192,168,4,1},{192,168,4,1},{255,255,255,0}); // ou directement
WiFi.softAP(AP_SSID, AP_PASS); // démarrage du point d’accès
sp(« adresse IP sur réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
// ————————————————— connexion en mode station à la centrale DCC choisie
if (centrale == 1) {connexionCentrale(« DR5000-D0007142″, »12345678 »,{192,168,16,254});} // réseau HO d’en haut
if (centrale == 2) {connexionCentrale(« DR5000-3717″, »12345678 »,{192,168,16,254});} // réseau N
if (centrale == 3) {connexionCentrale(« MiniDCC », »amfn2019″,{192,168,16,254});} // réseau HO d’en bas
if (centrale == 4) {connexionCentrale(« MiniDCC », »amfn2019″,{192,168,1,1});} // réseau personnel
// —————————————– si pas de connexion à la centrale, connexion au réseau local
if(WiFi.status() != WL_CONNECTED){ // pas connecté:
spl(« pas de connexion à la centrale »);
sp(« tentative de connection à « ); spl(WIFI_SSID2); delay(100);
// pour simplifier, utilisation de la même adresse MAC (sinon bloquage par la box)
const uint8_t mac[6] = {0x2C, 0x3A, 0xE8, 0x26, 0xA3, 0x54}; // « 2c:3a:e8:26:a3:54 »
// changement de l’adresse MAC cf: https://circuits4you.com/2017/12/31/how-to-change-esp8266-mac-address/
sp(« ancienne adresse MAC: « ); sp(WiFi.macAddress()); // adresse MAC en cours
wifi_set_macaddr(0, const_cast<uint8*>(mac)); //changement MAC address pour Livebox
sp( » nouvelle adresse MAC: « ); spl(WiFi.macAddress());
// tentative de connexion au réseau local
WiFi.begin(WIFI_SSID2, WIFI_PASS2);
NbEssais = 20;
while (WiFi.status() != WL_CONNECTED && NbEssais > 0 ){ delay(500); sp(« . »); NbEssais–;}
if (WiFi.status() == WL_CONNECTED){
reseau = 2;
spl(«  »); sp(« connecté à « ); sp(WIFI_SSID2); // <<<<<<<<<< prendre la vraie valeur
sp( » avec l’ip « ); spl(WiFi.localIP());
delay(100);
// cligner 10 fois
for (char I=1; I<=10; I++){digitalWrite(LED,LOW); delay(200); digitalWrite(LED,HIGH); delay(200);}
}
else {sp( » aucune connection! »);} // problème!
}
// —————————————————– démarrer l’écoute PC/smartphone pour le paramétrage
udp.begin(50000); // démarrer l’écoute sur port 50000
}
// ============================================================================== connexion à une centrale
void connexionCentrale(char ssid[20], char pass[20], IPAddress IPcentrale) {
sp(« tentative de connection à « ); spl(ssid); // tentative de connexion à la centrale
WiFi.begin(ssid, pass);
NbEssais = 10;
while (WiFi.status() != WL_CONNECTED && NbEssais > 0 ){ delay(500); sp(« . »); NbEssais–;}
if(WiFi.status() == WL_CONNECTED){ // si connecté:
reseau = 1; // réseau de la centrale
spl(«  »); sp(« connecté à « ); sp(ssid); // <<<<<<<<<< prendre la vraie valeur
sp( » avec l’ip « ); spl(WiFi.localIP());
IP_CENTRALE = IPcentrale; // pour envoi
delay(100);
// cligner 5 fois
for (char I=1; I<=5; I++){digitalWrite(LED,LOW); delay(200); digitalWrite(LED,HIGH); delay(200);}
}
}
void loop() { // =================================================================================== loop
if (Serial.available() > 0) { ReceptionSerie(); } // réception des octets IR sur port série
if (udp.parsePacket() > 0) { readPacket(); } // réception des paquets UDP pour test et paramétrage
// timer de blocage des re-transmissions
if (millis() – previousMillis >= interval) { // ré-autoriser la lecture après 1s
EnableTransmission = true;
digitalWrite (LED, HIGH); // extinction mouchard
}
// timer de remise à zéro de la fonction activée (avertisseur)
if (millis() – previousMillis2 >= interval2) { // envoyer après 2s
if( EnableResetAction == true) {
CommandeFonction(tableAction[derniereAction][1], tableAction[derniereAction][2], false); // commande loco, fonction, off
EnableResetAction = false;
}
}
}
// ===================================================================================== sous programmes
void ReceptionSerie(){ // ——————————– réception des octets un par un sur port série
byte OctetBalise, vidage;
OctetBalise = Serial.read(); //réception d’un caractère
// attente de recevoir 3 octets identiques à la suite
if (OctetBalise != DernierOctet) { // nouvel octet
DernierOctet = OctetBalise;
compte = 1;
}
else { // même octet
compte++;
if ( compte == 3 ) { // transmission si N octets successifs identiques
// mais ne transmettre le résultat qu’une seule fois par seconde (train arrêté sur balise)
// sauf si c’est une autre balise (balises rapprochées)
if (EnableTransmission || (OctetBalise != precedente)) { // transmission
EnableTransmission = false;
digitalWrite (LED, LOW); // allumage LED pour test
precedente = OctetBalise; // mémorisation de la balise
Action(OctetBalise); // déclenchement de l’action programmée
}
else { while(Serial.available () > 0){vidage = Serial.read();} } //vidage du buffer de réception
previousMillis = millis(); // relancement tempo
DernierOctet = 255; // réinitialisation
}
}
}
// ———————————————————- déclenchement de l’action définie dans la table
void Action(char module) {
unsigned int tempo;
for(int i=0; i<=5; i++) { // lecture de la table
if (module == tableAction[i][0]) { // module qu’on vient de voir passer
//sp (« detection module « ); spl(module,DEC);
tempo = tableAction[i][3]; // 0 = off, 1 = on, autre = reset après x ms
if (tempo == 0) {
CommandeFonction(word(tableAction[i][1]), tableAction[i][2], false); // loco, fonction, off
}
if (tempo == 1) {
CommandeFonction(word(tableAction[i][1]), tableAction[i][2], true); // loco, fonction, on
}
if (tempo > 1) {
CommandeFonction(word(tableAction[i][1]), tableAction[i][2], true); // loco, fonction, off
// remise à zéro après timer
derniereAction = i;
interval2 = tempo;
previousMillis2 = millis();
EnableResetAction = true;
}
break; // au cas où la table serait redondante
}
}
}
// ——————————————————————— réception des commandes reçues du PC
void TraitementParametres(){
char reponse[40];
unsigned int Ligne, Module, Adresse, Fonction, Tempo; // ligne, module, adresse, fonction, tempo
if (Mots[0] == « ? ») { // ——————————————— commande ?
repondre (« commandes: q, s, i, t, c »);
repondre (« interrogation: q ligne »);
repondre (« prog: s ligne mod. #dcc fonc. tempo »);
repondre (« (re)init: i »);
repondre (« test: t ligne »);
repondre (« centrale: c ?|centrale »);
}

if (Mots[0] == « q ») { // —————————————————– query ligne
Ligne = Mots[1].toInt();
Module = tableAction [Ligne][0];
Adresse = tableAction [Ligne][1];
Fonction = tableAction [Ligne][2];
Tempo = tableAction [Ligne][3];
sprintf(reponse, « lig=%u, mod=%u, adr=%u, fonc=%u, tempo=%u », Ligne, Module, Adresse, Fonction, Tempo);
//spl(reponse);
repondre (reponse);
}

if (Mots[0] == « s ») { // —————————————————– set action
Ligne = Mots[1].toInt();
Module = Mots[2].toInt();
Adresse = Mots[3].toInt();
Fonction = Mots[4].toInt();
Tempo = Mots[5].toInt();
tableAction[Ligne][0] = Module;
tableAction[Ligne][1] = Adresse;
tableAction[Ligne][2] = Fonction;
tableAction[Ligne][3] = Tempo;
EEPROM.put (EEPROMtableAddress, tableAction);
EEPROM.commit();
repondre (« ok »);
}

if (Mots[0] == « i ») { // ————————————————— init table
unsigned int Temp[5][4] = {
{71, 67, 3, 2000}, // ligne 0: Jouef
{71, 80, 2, 2000 }, // ligne 1: Roco
{71, 72, 4, 2000}, // ligne 2: Bachmann
{3, 3, 2, 1000}, // ligne 3: décodeur JPM2. n° module = adresse DCC
{6, 7, 8, 1000} // ligne 4: dispo
};
EEPROM.put (EEPROMtableAddress, Temp);
EEPROM.commit();
EEPROM.get (EEPROMtableAddress, tableAction);
repondre (« ok »);
}

if (Mots[0] == « t ») { // ———————————————————- test
Ligne = Mots[1].toInt();
CommandeFonction(tableAction[Ligne][1], tableAction[Ligne][2], true); // commande loco, fonction, on
// remise à zéro après timer
derniereAction = Ligne;
previousMillis2 = millis();
EnableResetAction = true;
}

if (Mots[0] == « c ») { // ———————————————————- centrale
if (Mots[1] == « ? ») {
//sprintf(reponse, « c=%d, ssid=%s », centrale, WiFi.SSID());
sprintf(reponse, « c=%d », centrale);
repondre(reponse);
}
else {
centrale = Mots[1].toInt();
EEPROM.put (EEPROMcentraleAddress, centrale);
EEPROM.commit();
// EEPROM.get (EEPROMcentraleAddress, tableAction);
repondre (« ok, redemarrer »);
}
}
}
// —————————————————————————————— commandes DCC
void CommandeFonction(word loco, char fonction, bool etat){
char CheckSum;
MessageUDP[0] = 10; // longueur LSB = 0x0A
MessageUDP[1] = 0x00; // longueur MSB
MessageUDP[2] = 0x40; // header LSB(0x40)
MessageUDP[3] = 0x00; // header MSB
MessageUDP[4] = 0xE4; CheckSum = 0xE4; // X-header
MessageUDP[5] = 0xF8; CheckSum = CheckSum ^ MessageUDP[5]; // commande de fonction
MessageUDP[6] = loco >> 8; CheckSum = CheckSum ^ MessageUDP[6]; // adresse DCC MSB
MessageUDP[7] = loco & 127; CheckSum = CheckSum ^ MessageUDP[7]; // adresse DCC LSB
// DB3 = TTNNNNNN où TT = off/on/toggle/n.a. NNNNNN = fonction
MessageUDP[8] = fonction; // 00NNNNNNN
if (etat != 0) {MessageUDP[8] = MessageUDP[8] + 64; } // toggle traité comme on
CheckSum = CheckSum ^ MessageUDP[8];
//ajout de la checksum
MessageUDP[9] = CheckSum;
if (reseau == 2) {sendPacketL(MessageUDP, 10, udp.remoteIP(),{50000});} // envoi au PC / Packet Sender
else {sendPacketL(MessageUDP, 10, IP_CENTRALE,{21105});} // envoi à la centrale
}
/*
void CommandeVitesse(word loco, char sens, char cran) {
char CheckSum;
MessageUDP[0] = 10; // longueur LSB = 0x0A
MessageUDP[1] = 0x00; // longueur MSB
MessageUDP[2] = 0x40; // header LSB(0x40)
MessageUDP[3] = 0x00; // header MSB
MessageUDP[4] = 0xE4; CheckSum = 0xE4; // X-header
MessageUDP[5] = 0x13; CheckSum = CheckSum ^ MessageUDP[5]; // 128 steps
MessageUDP[6] = loco >> 8; CheckSum = CheckSum ^ MessageUDP[6]; // adresse DCC MSB
MessageUDP[7] = loco & 127; CheckSum = CheckSum ^ MessageUDP[7]; // adresse DCC LSB
// DB3 = Cran, If SensAvant Then DB3 = DB3 + 128, Arrêt urgent non traité
MessageUDP[8] = cran + 128 * sens ; CheckSum = CheckSum ^ MessageUDP[8];
//ajout de la checksum
MessageUDP[9] = CheckSum;
//sendPacketL(MessageUDP, 10, {192,168,1,10},{50000}); // envoi au PC / Packet Sender
//sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
sendPacketL(MessageUDP, 10, IP_CENTRALE,{21105}); // envoi à la centrale
}
*/
// ================================================================= récupération et affichage d’un paquet UDP
void readPacket() {
len = udp.available();
udp.read(buffer, len); // Mise en tampon du paquet
//AffichageMessage();
ReceptionCommandesPC(); //TraitementParametres();
// tous les paquets arrivent sur le même port 50000
//if (udp.remoteIP()[3] == 10){TraitementParametres();} // paquets en provenance du PC (192.168.1.10)
//else{TraitementMessage();} // paquets en provenance des Milous
}
// ==================================================================================== envoi d’un paquet UDP
void sendPacketL(const char content[], char longueur, IPAddress ip, uint16_t port) { // avec longueur
udp.beginPacket(ip, port);
udp.write(content, longueur);
udp.endPacket();
}
void sendPacketZ(char content[], IPAddress ip, uint16_t port) { // avec zéro à la fin
udp.beginPacket(ip, port);
udp.write(content);
udp.endPacket();
}
void repondre(char texte[]) {
sendPacketZ(texte, udp.remoteIP(), 50000);
delay(100);
}
// ============================================================================ traitement des messages Milou
void TraitementMessage(){
//AffichageMessage(); // pour test
// le numéro du train peut être calculé d’après l’adresse IP du détecteur, ou contenue dans le message
sp(« loco « ); sp(buffer[0],DEC); sp ( » balise « ); spl (buffer[1],DEC); // d’après le message
}
// ============================================================================== traitement des messages PC
void ReceptionCommandesPC() { //TraitementParametres(){
// AffichageMessage(); // pour test
for(int i=0; i<len; i++) {
if(buffer[i]==32) { // espace -> nouveau mot
if ( NbMots < 8) {++NbMots;} // sécurité
}
else {Mots[NbMots] = Mots[NbMots] + buffer[i];} // autre caractère -> concaténation
}
// traitement du message
//for(int i=0; i<=NbMots; i++){spl(Mots[i]);} // affichage
TraitementParametres(); //ReceptionCommandesPC(); // traitement de la commande
// reset
Mots[0]= » »; Mots[1]= » »; Mots[2]= » »; Mots[3]= » »; Mots[4]= » »;
Mots[5]= » »; Mots[6]= » »; Mots[7]= » »; NbMots = 0;
}
// ================================================================================== affichage d’un message
void AffichageMessage() {
sp(« reçu « ); sp(len); sp( » octets de « ); sp(udp.remoteIP());
sp(« : »); sp(udp.remotePort());
sp( » soit: « );
for(int i=1; i<=len; i++) {PrtHex(buffer[i-1]); sp( » « );} spl(«  »);
}
// ======================================================================= affichage en hexadécimal amélioré
void PrtHex(char X) {
if (X<16){sp(« 0 »);} sp(X,HEX);
}

// balise 19200bps // émission d’un octet sur 8 ports à tour de rôle

void setup() { // put your setup code here, to run once:
Serial.begin(19200);
for (int i=2; i<=9; i++) { // ports 2 à 9
pinMode(i,OUTPUT); digitalWrite(i, LOW);
}
}

void loop() { // put your main code here, to run repeatedly:
envoi(2,55); // 0x37
envoi(3,113); // 0x71
envoi(4,126); // 0x1A
envoi(5,200); // 0xC8
envoi(6,56); // 0x38
envoi(7,114); // 0x72
envoi(8,127); // 0x7F
envoi(9,201); // 0xC9
}

void envoi(int port, int octet) {
digitalWrite(port,HIGH);
Serial.write(octet);
Serial.flush();
digitalWrite(port,LOW);
}

/* =============== Module Infrarouge de LOcalisation Universel V5 (;-)) ===============
Ce module tente de se connecter au réseau RASCAR s’il est disponible (mode fonctionnement normal)
sinon il se connecte à la box du réseau local (mode maintenance)
En mode fonctionnement normal: il lit des octets sur le port série à 19200 bps, les traite,
et retransmet des paquets UDP sur le réseau « rascar » à l’adresse 192.168.4.1 port 50000
En mode maintenance il communique avec un PC à l’adresse 192.168.1.10 port 50000
Il peut alors recevoir des commandes de paramétrage en UDP, ou charger un nouveau programme en OTA.
(Pour OTA, une taille mémoire de 1Mo est nécessaire).
https://www.aranacorp.com/fr/utilisation-de-leeprom-avec-lesp8266/
https://github.com/esp8266/Arduino/blob/master/libraries/EEPROM/EEPROM.h
*///============================================================================
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
#include <EEPROM.h>
// informations remontées au PC pour affichage
#define sp Serial.print
#define spl Serial.println
// personnalisation du module
#define EEPROM_SIZE 4096
int EEPROMaddress = 0; // un seul octet à mémoriser…
byte AdresseDCC; // …c’est l’adresse de l’engin moteur associé
// divers
const byte LED = LED_BUILTIN; // LED externe (impossible de commander la LED interne de l’ESP-01)
char NbEssais = 20; // 20 essais de connexion à 500ms
char Reseau = 0; // réseau auquel on est connecté: Rascar ou local
// gestion des octets reçus sur le port série
byte DernierOctet, compte, precedente;
unsigned long previousMillis = 0;
const long interval = 1000;
bool EnableTransmission = true;
// transmission des paquets UDP vers Rascar
char PaquetUDP[16]; // paquets transmis vers Rascar
// récupération des paquets UDP provenant du PC
const uint16_t PORT = 50000; // Port d’écoute UDP
const uint16_t BUFFER_SIZE = 32; // Taille du tampon de réception
char buffer[BUFFER_SIZE]; // Tampon de réception
uint16_t len = 0;// Taille du paquet reçu;
// transmission des paquets au PC
char reponse[10] = « Milou5 # « ; // paquet – à compléter – transmis au PC
// instanciation du serveur UDP
WiFiUDP udp;
// ==================================================================================================== SETUP
void setup() {
pinMode (LED, OUTPUT);
digitalWrite (LED, HIGH); // Led connectée au plus
Serial.begin(19200); // on démarre le port série
EEPROM.begin(EEPROM_SIZE); // eeprom
AdresseDCC = EEPROM.read(0); // lecture de l’adresse du module
delay(10); // On attend « un peu » que le buffer soit prêt
// connexion au réseau rascar, ou sinon au réseau local
NbEssais = 20; setup_sta1(); // tentative de connexion au réseau rascar (mode opérationnel)
if (NbEssais == 0) { // rascar indisponible (non activé)
NbEssais = 20; setup_sta2(); // tentative de connexion au réseau local (pour test et mise au point)
}
if(WiFi.status() == WL_CONNECTED){
udp.begin(PORT); // démarrage de l’écoute
sp(« à l’écoute sur le port « ); spl(PORT);
delay(100);
if (Reseau == 2){ // connexion au PC
reponse[8] = AdresseDCC;
sendPacket ( reponse, 9, {192,168,1,10},{50000});
} // envoi au PC / Packet Sender
}
else {sp( » aucune connection! »);} // problème!
} // fin de setup

void setup_sta1(){ // =============================================== connexion au gestionnaire des messages
const char sta1_ssid[] = « rascar »;
const char sta1_password[] = « 12345678 »;
// demande d’une adresse IP précise ou utilisation des valeurs par défaut
//WiFi.config({192,168,4,100},{192,168,4,1},{192,168,4,1},{255,255,255,0}); // IP, DNS, gateway, subnet
// Initialisation de la connection WiFi
WiFi.begin(sta1_ssid, sta1_password);
// attente de connexion
spl(«  »);sp(« tentative de connexion à « );sp(sta1_ssid);sp( » « );
//while (WiFi.status() != WL_CONNECTED && NbEssais > 0 ){ delay(500); sp(NbEssais,DEC); NbEssais–;}
while (WiFi.status() != WL_CONNECTED && NbEssais > 0 ){ delay(500); sp(« . »); NbEssais–;}
if(WiFi.status() == WL_CONNECTED){ // si connecté:
Reseau = 1; // réseau rascar
// Affichage des informations
spl(«  »); sp(« connecté à « ); sp(sta1_ssid); // <<<<<<<<<< prendre la vraie valeur
sp( » avec l’ip « ); spl(WiFi.localIP());
delay(100);
// cligner 3 fois
for (char I=1; I<=3; I++){digitalWrite(LED,LOW); delay(200); digitalWrite(LED,HIGH); delay(200);}
}
else {spl(«  »);sp(« échec de la connection à « );sp(sta1_ssid);}
delay(500);
}
void setup_sta2(){ // ============================================= connexion à la box en mode station
const char sta2_ssid[] = « Livebox-9052 »;
const char sta2_password[] = « MotDePasse »;
// pour simplifier les test, utilisation de la même adresse MAC (sinon bloquée par la box)
const uint8_t mac[6] = {0x2C, 0x3A, 0xE8, 0x26, 0xA3, 0x54}; // « 2c:3a:e8:26:a3:54 »
// changement de l’adresse MAC cf: https://circuits4you.com/2017/12/31/how-to-change-esp8266-mac-address/
spl(«  »); sp(« ancienne adresse MAC: « ); sp(WiFi.macAddress()); // adresse MAC en cours
wifi_set_macaddr(0, const_cast<uint8*>(mac)); //changement MAC address pour Livebox
sp( » nouvelle adresse MAC: « ); spl(WiFi.macAddress());
// demande d’une adresse IP précise
WiFi.config({192,168,1,100},{192,168,1,1},{192,168,1,1},{255,255,255,0}); // IP, DNS, gateway, subnet
// Initialisation de la connection WiFi
WiFi.begin(sta2_ssid, sta2_password);
sp(« tentative de connexion à « ); sp(sta2_ssid);sp( » « );
// attente de connexion
//while (WiFi.status() != WL_CONNECTED && NbEssais >0 ){ delay(500);sp(NbEssais,DEC); NbEssais–;}
while (WiFi.status() != WL_CONNECTED && NbEssais >0 ){ delay(500);sp(« . »); NbEssais–;}
//spl(NbEssais,DEC); // test
if(WiFi.status() == WL_CONNECTED){ // si connecté:
Reseau = 2; // réseau local
// pour OTA
ArduinoOTA.setHostname(« milou5 »); // nom du module
ArduinoOTA.begin(); // initialisation de l’OTA
// Affichage des informations
spl(«  »);sp(« Connecté à « ); sp(sta2_ssid); // <<<<<<<<<< prendre la vraie valeur
sp( » avec l’ip « ); spl(WiFi.localIP());
delay(500);
// cligner 6fois
for (char I=1; I<=6; I++){digitalWrite(LED,LOW); delay(200); digitalWrite(LED,HIGH); delay(200);}
}
else {spl(«  »);sp(« échec de la connection à « );sp(sta2_ssid);}
}
// ===================================================================================================== LOOP
void loop() {
// gestion de l’OTA
ArduinoOTA.handle();
// réception des paquets UDP pour test et paramétrage
if (udp.parsePacket() > 0) { readPacket(); }
// réception des octets balise sur port série
if (Serial.available() > 0) {ReceptionSerie();}
//else { while(Serial.available () > 0){Serial.read();} } //vidage du buffer de réception série
// timer de blocage des re-transmissions
if (millis() – previousMillis >= interval) { // ré-autoriser la lecture après 1s
EnableTransmission = true;
digitalWrite (LED, HIGH); // extinction mouchard
}
}
// ================================================================ récupération et affichage d’un paquet UDP
void readPacket() { // lecture d’un paquet en provenance du PC
len = udp.available();
udp.read(buffer, len); // Mise en tampon du paquet
TraitementMessagePC(); // traitement du paquet
}
// ==================================================================================== envoi d’un paquet UDP
void sendPacket(const char content[], char nbchar, IPAddress ip, uint16_t port) { // avec longueur
//void sendPacket(char content[], IPAddress ip, uint16_t port) { // avec zéro à la fin
if (Reseau == 2) {
sp(« envoi de « );sp(nbchar,DEC);sp( » octets à « );sp(ip);sp(« : »);spl(port); delay(10);
}
udp.beginPacket(ip, port);
udp.write(content, nbchar);
udp.endPacket();
}
// ===================================================================================== sous programmes
void ReceptionSerie(){ // ——————————– réception des octets un par un sur port série
byte OctetBalise, vidage;
OctetBalise = Serial.read(); //réception d’un caractère
// attente de recevoir 3 octets identiques à la suite
if (OctetBalise != DernierOctet) { // nouvel octet
DernierOctet = OctetBalise;
compte = 1;
}
else { // même octet
compte++;
if ( compte == 3 ) { // transmission si N octets successifs identiques
// mais ne transmettre le résultat qu’une seule fois par seconde (train arrêté sur balise)
// sauf si c’est une autre balise (balises rapprochées)
if (EnableTransmission || (OctetBalise != precedente)) { // transmission
PaquetUDP[0] = AdresseDCC;
PaquetUDP[1] = OctetBalise; // numéro de la balise
if (Reseau == 1){sendPacket(PaquetUDP, 2, {192,168,4,1},{50000});}// envoi à rascar
if (Reseau == 2){sendPacket(PaquetUDP, 2, {192,168,1,10},{50000});}// envoi au PC
EnableTransmission = false;
digitalWrite (LED, LOW); // allumage LED pour test
precedente = OctetBalise; // mémorisation de la balise
}
else { while(Serial.available () > 0){vidage = Serial.read();} } //vidage du buffer de réception
previousMillis = millis(); // relancement tempo
DernierOctet = 255; // réinitialisation
}
}
}
// ============================================================== traitement des messages en provenance du PC
void TraitementMessagePC(){ // messages de paramétrage du module
// deux types de messages sont actuellement possibles:
// – deux octets « >N » où N est l’adresse DCC de la locomotive associée
// – n’importe quoi d’autre provoque la relecture et l’envoi de l’adresse
//AffichageMessage(); // test
if ((buffer[0] == ‘>’) && (len == 2)) { // message de changement d’addresse DCC
AdresseDCC = buffer[1];
EEPROM.write(EEPROMaddress, AdresseDCC); // ou: EEPROM.put(EEPROMaddress, AdresseDCC);
EEPROM.commit();
// relecture de l’adresse DCC
AdresseDCC = EEPROM.read(0); // ou EEPROM.get(EEPROMaddress, AdresseDCC);
}
// dans les deux cas, retransmission de l’adresse
reponse[8] = AdresseDCC;
if (Reseau == 2){sendPacket ( reponse, 9, {192,168,1,10},{50000});} // envoi au PC / Packet Sender
}
// =================================================================================== affichage d’un message
void AffichageMessage() {
sp(« reçu « ); sp(len); sp( » octets de « ); sp(udp.remoteIP()); // <<< remote IP irrelevant
sp(« : »); sp(udp.remotePort());
sp( » soit: « );
for(int i=1; i<=len; i++) {sp(buffer[i-1]); sp( » « );} spl(«  »);
}
// ======================================================================= impression en hexadécimal amélioré
void PrtHex(char X) {
if (X<16){sp(« 0 »);} sp(X,HEX);
}

// ========================== programme Rascar_annonce ==============================
// Ce NodeMCU /ESP-12 fonctionne en mode point d’accès pour les détecteurs embarqués,
// et en même temps mode station vis-à-vis de la centrale DCC.
// Le programme reçoit les paquets UDP envoyés par les détecteurs embarqués,
// les traite, puis déclenche une action (par exemple: annnonce d’entrée en gare)
// ou pour tests, au PC avec Packet Sender
// ==================================================================================
#include <ESP8266WiFi.h>
#include <WiFiUDP.h>
// informations remontées au PC pour affichage
#define sp Serial.print
#define spl Serial.println
// commandes reçues sur port série
int NbMots;
String Mots[5];
// mode point d’accès pour les détecteurs embarqués
#define AP_SSID « rascar »
#define AP_PASS « 12345678 »
// mode station vers la centrale. PC + Packet Sender pour test
#define WIFI_SSID « Livebox-xxxx »
#define WIFI_PASS « abcdefg »
// pour récupération des paquets UDP
const uint16_t PORT = 50000; // Port d’écoute UDP
const uint16_t BUFFER_SIZE = 512; // Taille du tampon de réception
char buffer[BUFFER_SIZE]; // Tampon de réception
uint16_t len = 0;// Taille du paquet reçu;
// instanciation du serveur UDP
WiFiUDP udp;
void setup() { // =================================================================================== setup
Serial.begin(19200);
spl();
// —————————————————————— démarrage du point d’accès
WiFi.mode(WIFI_AP_STA);
IPAddress local_IP(192,168,4,1); // adresse IP du point d’accès
IPAddress gateway(192,168,4,1);
IPAddress subnet(255,255,255,0);
WiFi.softAPConfig(local_IP, gateway, subnet); // fixe l’adresse IP du point d’accès
//WiFi.softAPConfig({192,168,4,1},{192,168,4,1},{255,255,255,0}); // ou directement
WiFi.softAP(AP_SSID, AP_PASS); // démarrage du point d’accès
sp(« adresse IP du réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
// ———————————————————— mode station sur la centrale DCC
// pour simplifier, utilisation de la même adresse MAC (sinon bloquée par la box)
const uint8_t mac[6] = {0x2C, 0x3A, 0xE8, 0x26, 0xA3, 0x54}; // « 2c:3a:e8:26:a3:54 »
// changement de l’adresse MAC cf: https://circuits4you.com/2017/12/31/how-to-change-esp8266-mac-address/
spl(«  »); sp(« ancienne adresse MAC: « ); sp(WiFi.macAddress()); // adresse MAC en cours
wifi_set_macaddr(0, const_cast<uint8*>(mac)); //changement MAC address pour Livebox
sp( » nouvelle adresse MAC: « ); spl(WiFi.macAddress());
// ————————————————————————- connexion au PC
WiFi.begin(WIFI_SSID, WIFI_PASS); // connexion au réseau local domestique
sp(« connection à « ); spl(WIFI_SSID);
while (WiFi.status() != WL_CONNECTED) {
delay(100);
sp(« . »);
}
udp.begin(50000); // démarre l’écoute sur port 50000
spl(); spl(« Connecté! »);
sp(« adresse IP sur réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
sp(« adresse IP sur réseau « ); sp(WIFI_SSID); sp( » : « ); spl(WiFi.localIP());
spl(«  »);
}
void loop() { // =================================================================================== loop
if (udp.parsePacket() > 0) { readPacket(); } // réception des paquets UDP pour test
if (Serial.available() > 0) { ReceptionSerie(); } // réception des commandes sur port série
}
// ===================================================================================== sous programmes
void ReceptionSerie(){ // —————— réception des octets un par un sur port série, pour tests
char X;
X = Serial.read(); //réception d’un caractère
switch (X){ // ********************** trois cas: space, line feed, ou autre caractère
case (32):{++NbMots;} break; // ********************************************* espace
case 10: { // **************************************************** LF = fin de message
if (Mots[0] == « ? ») { // ——————————————— commande ?
spl(« commande ? »);
sp(« adresse IP sur réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
sp(« adresse IP sur réseau « ); sp(WIFI_SSID); sp( » : « ); spl(WiFi.localIP());
sp(«  »);
}
if(Mots[0] == « ! ») { // ———————- tests de communication – commande !
spl(« commande ! »);
// sendPacket(« test », 4, {192,168,4,100},50000); // test
sendPacket(« test », 4, {192,168,1,10},21105); // envoi au PC / Packet Sender
}
// ————————————————————- fin de commande, reset
Mots[0]= » »; Mots[1]= » »; Mots[2]= » »; Mots[3]= » »;
NbMots = 0;
break; // fin de LF
}
default:{ // ****************************************** autre caractère: concaténation
Mots[NbMots] = Mots[NbMots] + X;};
break;
}
}
// ==================================================================== récupération et affichage d’un paquet
void readPacket() {
len = udp.available();
udp.read(buffer, len); // Mise en tampon du paquet
TraitementMessage(); // traitement du paquet
}
// ==================================================================================== envoi d’un paquet UDP
void sendPacket(const char content[], int longueur, IPAddress ip, uint16_t port) { // avec longueur en INT
//void sendPacket(char content[], IPAddress ip, uint16_t port) { // avec zéro à la fin
sp(« envoi de « ); sp(longueur); sp( » octets à « ); sp(ip); sp(« : »); spl(port); delay(10);
udp.beginPacket(ip, port);
udp.write(content, longueur);
udp.endPacket();
}
// ================================================================================= traitement des messages
void TraitementMessage(){
AffichageMessage(); // pour test
// le numéro du train peut être calculé d’après l’adresse IP du détecteur, ou contenue dans le message
//sp(« le train « ); spl(udp.remoteIP()[3]); spl(«  »); // d’après l’adresse IP du détecteur
sp(« train « ); sp(buffer[0],DEC); sp ( » balise « ); spl (buffer[1],DEC); spl(«  »); // d’après le message
// yapuka activer le dispositif d’annonce!
spl(« retransmission… »); delay(10);
sendPacket(« retransmission », 14, {192,168,1,10},50000); // envoi au PC / Packet Sender pour test
delay(10);
}
// ================================================================================== affichage d’un message
void AffichageMessage() {
sp(« reçu « ); sp(len); sp( » octets de « ); sp(udp.remoteIP());
sp(« : »); sp(udp.remotePort());
sp( » soit: « );
for(int i=1; i<=len; i++) {PrtHex(buffer[i-1]); sp( » « );} spl(«  »);
}
// ======================================================================= affichage en hexadécimal amélioré
void PrtHex(char X) {
if (X<16){sp(« 0 »);} sp(X,HEX);
}

// ============================ programme Rascar_sifflet ==============================
// Ce NodeMCU /ESP-12 fonctionne en mode point d’accès pour les détecteurs embarqués,
// et en même temps mode station vis-à-vis de la centrale DCC.
// Le programme reçoit les paquets UDP envoyés par les détecteurs embarqués,
// les traite, puis envoie les commandes UDP appropriées à la centrale DCC (par exemple: siffler).
// ou pour tests, au PC avec Packet Sender
// Seule la partie traitement du message diffère de Rascar_annonce
// ==================================================================================
#include <ESP8266WiFi.h>
#include <WiFiUDP.h>
// informations remontées au PC pour affichage
#define sp Serial.print
#define spl Serial.println
const byte LED = LED_BUILTIN; // NodeMCU
//const byte LED = 2; // LED externe ESP-01 (impossible de commander la LED interne)
char NbEssais; // vérification de la connexion toutes les 500ms
char Reseau = 0; // réseau auquel on est connecté
// commandes reçues sur port série
int NbMots;
String Mots[5];
// mode point d’accès pour les détecteurs embarqués
#define AP_SSID « rascar »
#define AP_PASS « 12345678 »
// mode station vers la centrale MiniDCC
// #define WIFI_SSID1 « MiniDCC »
// #define WIFI_PASS1 « amfn2019 »
// #define IP_CENTRALE 192,168,1,1
// mode station vers la centrale DR5000
#define WIFI_SSID1 « DR5000-B0000763 »
#define WIFI_PASS1 « 12345678 »
#define IP_CENTRALE 192,168,16,254
// ou mode station vers PC + Packet Sender pour test
#define WIFI_SSID2 « Livebox-xxxx »
#define WIFI_PASS2 « abcdefg »
// #define IP_CENTRALE 192,168,1,10
// pour récupération des paquets UDP
const uint16_t PORT = 50000; // Port d’écoute UDP
const uint16_t BUFFER_SIZE = 512; // Taille du tampon de réception
char buffer[BUFFER_SIZE]; // Tampon de réception
uint16_t len = 0;// Taille du paquet reçu;
// pour envoi des messages à la centrale
char MessageUDP[32];
// instanciation du serveur UDP
WiFiUDP udp;
void setup() { // =================================================================================== setup
Serial.begin(19200);
spl();
// —————————————————————— démarrage du point d’accès
WiFi.mode(WIFI_AP_STA);
IPAddress local_IP(192,168,4,1); // adresse IP du point d’accès
IPAddress gateway(192,168,4,1);
IPAddress subnet(255,255,255,0);
WiFi.softAPConfig(local_IP, gateway, subnet); // fixe l’adresse IP du point d’accès
//WiFi.softAPConfig({192,168,4,1},{192,168,4,1},{255,255,255,0}); // ou directement
WiFi.softAP(AP_SSID, AP_PASS); // démarrage du point d’accès
sp(« adresse IP du réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
// ———————————————- connexion en mode station à la centrale DCC
sp(« tentative de connection à « ); spl(WIFI_SSID1); // tentative de connexion à la centrale
WiFi.begin(WIFI_SSID1, WIFI_PASS1);
NbEssais = 20;
while (WiFi.status() != WL_CONNECTED && NbEssais > 0 ){ delay(500); sp(NbEssais,DEC); NbEssais–;}
// ————————————————————– si connecté à la centrale
if(WiFi.status() == WL_CONNECTED){ // si connecté:
Reseau = 1; // réseau rascar
spl(«  »); sp(« connecté à « ); sp(WIFI_SSID1); // <<<<<<<<<< prendre la vraie valeur
sp( » avec l’ip « ); spl(WiFi.localIP());
delay(100);
// cligner 5 fois
for (char I=1; I<=5; I++){digitalWrite(LED,LOW); delay(200); digitalWrite(LED,HIGH); delay(200);}
}
// —————————- si pas de connexion à la centrale, se connecter au réseau local
else {
spl( » pas de connexion à la centrale »);
sp(« tentative de connection à « ); spl(WIFI_SSID2); delay(100);
// pour simplifier, utilisation de la même adresse MAC (sinon bloquée par la box)
const uint8_t mac[6] = {0x2C, 0x3A, 0xE8, 0x26, 0xA3, 0x54}; // « 2c:3a:e8:26:a3:54 »
// changement de l’adresse MAC cf: https://circuits4you.com/2017/12/31/how-to-change-esp8266-mac-address/
sp(« ancienne adresse MAC: « ); sp(WiFi.macAddress()); // adresse MAC en cours
wifi_set_macaddr(0, const_cast<uint8*>(mac)); //changement MAC address pour Livebox
sp( » nouvelle adresse MAC: « ); spl(WiFi.macAddress());
// tentative de connexion au réseau local
WiFi.begin(WIFI_SSID2, WIFI_PASS2);
NbEssais = 20;
while (WiFi.status() != WL_CONNECTED && NbEssais > 0 ){ delay(500); sp(NbEssais,DEC); NbEssais–;}
if (WiFi.status() == WL_CONNECTED){
Reseau = 2;
spl(«  »); sp(« connecté à « ); sp(WIFI_SSID2); // <<<<<<<<<< prendre la vraie valeur
sp( » avec l’ip « ); spl(WiFi.localIP());
delay(100);
// cligner 10 fois
for (char I=1; I<=10; I++){digitalWrite(LED,LOW); delay(200); digitalWrite(LED,HIGH); delay(200);}
}
else {sp( » aucune connection! »);} // problème!
}
// ————————————————————————- connexion au PC
udp.begin(50000); // démarre l’écoute sur port 50000 (messages des milous)
//spl(« Prêt! »);
//sp(« adresse IP sur réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
//sp(« adresse IP sur réseau « ); sp(WIFI_SSID); sp( » : « ); spl(WiFi.localIP());
//spl(«  »);
}
void loop() { // =================================================================================== loop
if (udp.parsePacket() > 0) { readPacket(); } // réception des paquets UDP pour test
if (Serial.available() > 0) { ReceptionSerie(); } // réception des commandes sur port série
}
// ===================================================================================== sous programmes
void ReceptionSerie(){ // —————— réception des octets un par un sur port série, pour tests
char X;
X = Serial.read(); //réception d’un caractère
switch (X){ // ********************** trois cas: space, line feed, ou autre caractère
case (32):{++NbMots;} break; // ********************************************* espace
case 10: { // **************************************************** LF = fin de message
if (Mots[0] == « ? ») { // ——————————————— commande ?
spl(« commande ? »);
spl(« programme Rascar-sifflet »);
//sp(« adresse IP sur réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
//sp(« adresse IP sur réseau « ); sp(WIFI_SSID); sp( » : « ); spl(WiFi.localIP());
sp(«  »);
}
if(Mots[0] == « ! ») { // ———————- tests de communication – commande !
spl(« commande ! »);
// sendPacket(« test », 4, {192,168,4,100},50000); // test
sendPacket(« test », 4, {192,168,1,10},21105); // envoi au PC / Packet Sender
}
// ————————————————————- fin de commande, reset
Mots[0]= » »; Mots[1]= » »; Mots[2]= » »; Mots[3]= » »;
NbMots = 0;
break; // fin de LF
}
default:{ // ****************************************** autre caractère: concaténation
Mots[NbMots] = Mots[NbMots] + X;};
break;
}
}
// ==================================================================== récupération et affichage d’un paquet
void readPacket() {
len = udp.available();
udp.read(buffer, len); // Mise en tampon du paquet
//ne garder que les paquets provenant des milous, et pas de la centrale
if (udp.remotePort() == 50000) {TraitementMessage();} // traitement du paquet
}
// ==================================================================================== envoi d’un paquet UDP
void sendPacket(const char content[], int longueur, IPAddress ip, uint16_t port) { // avec longueur en INT
//void sendPacket(char content[], IPAddress ip, uint16_t port) { // avec zéro à la fin
sp(« envoi de « ); sp(longueur); sp( » octets à « ); sp(ip); sp(« : »); spl(port); delay(10);
udp.beginPacket(ip, port);
udp.write(content, longueur);
udp.endPacket();
}
// ================================================================================= traitement des messages
void TraitementMessage(){
AffichageMessage(); // pour test
// le numéro du train peut être calculé d’après l’adresse IP du détecteur, ou contenue dans le message
//sp(« le train « ); spl(udp.remoteIP()[3]); spl(«  »); // d’après l’adresse IP du détecteur
sp(« Milou « ); sp(buffer[0],DEC); sp ( » balise « ); spl (buffer[1],DEC); // d’après le message
// envoi d’une commande à la centrale en UDP
if (buffer[0] == 70 && buffer[1] == 201) { // milou 70 => loco 67
spl(« envoi d’une commande F11 à la loco 67 »);
CommandeFonction(67 , 11 , 0 ); // loco, fonction, état
delay(200);
CommandeFonction(67 , 11 , 1 ); // loco, fonction, état
}
}
// ================================================================================== affichage d’un message
void AffichageMessage() {
sp(« reçu « ); sp(len); sp( » octets de « ); sp(udp.remoteIP());
sp(« : »); sp(udp.remotePort());
sp( » soit: « );
for(int i=1; i<=len; i++) {PrtHex(buffer[i-1]); sp( » « );} spl(«  »);
}
// ==================================================================================== envoi d’un paquet UDP
void sendPacketL(const char content[], char longueur, IPAddress ip, uint16_t port) { // avec longueur
udp.beginPacket(ip, port);
udp.write(content, longueur);
udp.endPacket();
}
void sendPacketZ(char content[], IPAddress ip, uint16_t port) { // avec zéro à la fin
udp.beginPacket(ip, port);
udp.write(content);
udp.endPacket();
}
// =========================================================== envoi d’un message à la centrale au format Z21
void CommandeFonction(word loco, char fonction, bool etat){
char CheckSum;
MessageUDP[0] = 10; // longueur LSB = 0x0A
MessageUDP[1] = 0x00; // longueur MSB
MessageUDP[2] = 0x40; // header LSB(0x40)
MessageUDP[3] = 0x00; // header MSB
MessageUDP[4] = 0xE4; CheckSum = 0xE4; // X-header
MessageUDP[5] = 0xF8; CheckSum = CheckSum ^ MessageUDP[5]; // commande de fonction
MessageUDP[6] = loco >> 8; CheckSum = CheckSum ^ MessageUDP[6]; // adresse DCC MSB
MessageUDP[7] = loco & 127; CheckSum = CheckSum ^ MessageUDP[7]; // adresse DCC LSB
// DB3 = TTNNNNNN où TT = off/on/toggle/n.a. NNNNNN = fonction
MessageUDP[8] = fonction; // 00NNNNNNN
if (etat != 0) {MessageUDP[8] = MessageUDP[8] + 64; } // toggle traité comme on
CheckSum = CheckSum ^ MessageUDP[8];
//ajout de la checksum
MessageUDP[9] = CheckSum;
//sendPacketL(MessageUDP, 10, {192,168,1,10},{50000}); // envoi au PC / Packet Sender
//sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
sendPacketL(MessageUDP, 10, {IP_CENTRALE},{21105}); // envoi à la centrale
}
// ======================================================================= affichage en hexadécimal amélioré
void PrtHex(char X) {
if (X<16){sp(« 0 »);} sp(X,HEX);
}

// =========================================================
// lit sur le port série les commandes reçues de RegleurZ21
// et renvoie les paquets UDP appropriés
// =========================================================
// tester le nombre de stations connectées:
// https://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/soft-access-point-examples.html
// https://www.tala-informatique.fr/wiki/index.php/Esp8266_wifi
// https://arduino-esp8266.readthedocs.io/en/latest/reference.html
// https://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/soft-access-point-class.html?highlight=mac%20address#mac-as-a-string
#include <ESP8266WiFi.h>
#include <WiFiUDP.h>
#include <ArduinoOTA.h> // pour OTA
// pour affichage:
#define sp Serial.print
#define spl Serial.println
// entrées-sorties
const byte LED = 2; // LED interne
// pour récupération des paquets UDP
const uint16_t PORT = 21105; // 50000; // Port d’écoute UDP
const uint16_t BUFFER_SIZE = 64; // Taille du tampon de réception
char buffer[BUFFER_SIZE]; // Tampon de réception
uint16_t len = 0;// Taille du paquet reçu;
// pour envoi UDP
char MessageUDP[32];

// commandes reçues sur port série
int NbMots;
String Mots[5];
int X; byte Y; int xxx;
// mode point d’accès pour les détecteurs embarqués
#define AP_SSID « rascar »
#define AP_PASS « 12345678 »
// mode station vers le PC + Packet Sender pour test
// #define WIFI_SSID « Livebox-xxxx »
// #define WIFI_PASS « abcdefg »
// #define IP_CENTRALE 192,168,1,10
// mode station vers la centrale MiniDCC
// #define WIFI_SSID « MiniDCC »
// #define WIFI_PASS « amfn2019 »
// #define IP_CENTRALE 192,168,1,1
// mode station vers la centrale DR5000
#define WIFI_SSID « DR5000-B0000763 »
#define WIFI_PASS « 12345678 »
#define IP_CENTRALE {192,168,16,254}
char NbEssais = 20; // 10 essais à 500ms de connexion au réseau domestique
// instanciation du serveur UDP
WiFiUDP udp;
void setup() { // =================================================================================== setup
Serial.begin(19200);
spl();
// —————————————————————— démarrage du point d’accès
WiFi.mode(WIFI_AP_STA);
IPAddress local_IP(192,168,4,1); // adresse IP du point d’accès
IPAddress gateway(192,168,4,1);
IPAddress subnet(255,255,255,0);
WiFi.softAPConfig(local_IP, gateway, subnet); // fixe l’adresse IP du point d’accès
//WiFi.softAPConfig({192,168,4,1},{192,168,4,1},{255,255,255,0}); // ou directement
WiFi.softAP(AP_SSID, AP_PASS); // démarrage du point d’accès
sp(« adresse IP du réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
// ———————————————————— mode station sur la centrale DCC
// pour simplifier, utilisation de la même adresse MAC (sinon bloquée par la box)
const uint8_t mac[6] = {0x2C, 0x3A, 0xE8, 0x26, 0xA3, 0x54}; // « 2c:3a:e8:26:a3:54 »
// changement de l’adresse MAC cf: https://circuits4you.com/2017/12/31/how-to-change-esp8266-mac-address/
spl(«  »); sp(« ancienne adresse MAC: « ); sp(WiFi.macAddress()); // adresse MAC en cours
wifi_set_macaddr(0, const_cast<uint8*>(mac)); //changement MAC address pour Livebox
sp( » nouvelle adresse MAC: « ); spl(WiFi.macAddress());
// ————————————————————————- connexion au réseau
WiFi.begin(WIFI_SSID, WIFI_PASS); // connexion au réseau local domestique
sp(« connection à « ); spl(WIFI_SSID);
while (WiFi.status() != WL_CONNECTED) {
delay(100);
sp(« . »);
}
//udp.begin(50000); // démarre l’écoute sur port 50000
udp.begin(21105); // démarre l’écoute sur port 21105 (Z21)
spl(); spl(« Connecté! »);
sp(« adresse IP sur réseau « ); sp(AP_SSID); sp( » : « ); spl(WiFi.softAPIP());
sp(« adresse IP sur réseau « ); sp(WIFI_SSID); sp( » : « ); spl(WiFi.localIP());
spl(«  »);
}
// ===================================================================================================== LOOP
void loop() {
ArduinoOTA.handle(); // gestion OTA
if (udp.parsePacket() > 0) { readPacket(); } // réception des paquets
if (Serial.available() > 0) {ReceptionCommande();};
}
// ==================================================================== récupération et affichage d’un paquet
void readPacket() {
len = udp.available();
udp.read(buffer, len);
TraitementMessage(); // traitement du paquet UDP
}
// ==================================================================================== envoi d’un paquet UDP
void sendPacketL(const char content[], char longueur, IPAddress ip, uint16_t port) { // avec longueur
udp.beginPacket(ip, port);
udp.write(content, longueur);
udp.endPacket();
}
void sendPacketZ(char content[], IPAddress ip, uint16_t port) { // avec zéro à la fin
udp.beginPacket(ip, port);
udp.write(content);
udp.endPacket();
}
// ============================================================================== traitement des messages UDP
void TraitementMessage(){
// affichage du message en hexadécimal
sp(« reçu « ); sp(len); sp( » octets de « ); sp(udp.remoteIP());
sp(« : »); sp(udp.remotePort());
sp( » soit: « );
for(int i=1; i<=len; i++) {PrtHex(buffer[i-1]); sp( » « );} spl(«  »);
// affichage en clair
sp(buffer);
// réponse
sendPacketZ(« message recu », udp.remoteIP(), udp.remotePort()); // envoi au PC / Packet Sender
}
// ============================================================================== réception des commandes
void ReceptionCommande(){ // décompose en mots séparés par un seul espace
char X, CheckSum, Port, I;
X = Serial.read(); //réception d’un caractère
switch (X){ // ********************** trois cas: space, line feed, ou autre caractère

case (32):{++NbMots;} break; // ********************************************* espace

case 10: { // ******************************************************* fin de message

if (Mots[0] == « ? ») { // ——————————————— commande ?
spl (« commandes (séparation par un seul espace): »); delay(10);
spl ( » udp valeur1 valeur2 valeur3 (envoi d’octets en UDP) »); delay(10);
spl ( » vit adresse sens cran (message Z21) »); delay(10);
spl ( » fonc adresse fonction 0/1 (message Z21) »); delay(10);

spl ( » loco adresse (message Z21 get loco mode) »); delay(10);
spl ( » trackon (message Z21 set track power on) »); delay(10);
spl ( » trackoff (message Z21 set track power off) »); delay(10);

spl ( » test port (par clignotement) »); delay(10);
spl ( » xxx valeur (écriture dans la variable xxx) »); delay(10);
spl ( » nnn valeur (test numérique) »); delay(10);
}

if (Mots[0] == « trackon ») { // —————————– commande set track power on
spl (« commande set track power on »);
const char MessageUDP[] = {0x07,0x00,0x40,0x00,0x21,0x81,0xA0};
//sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
//sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
sendPacketL(MessageUDP, 7, IP_CENTRALE,{21105}); // envoi à la centrale
}

if (Mots[0] == « trackoff ») { // —————————– commande set track power off
spl (« commande set track power off »);
const char MessageUDP[] = {0x07,0x00,0x40,0x00,0x21,0x80,0xA1};
//const char MessageUDP[] = {0x06,0x00,0x40,0x00,0x80,0x80};
//sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
sendPacketL(MessageUDP, 7, IP_CENTRALE,{21105}); // envoi à la centrale
}

if (Mots[0] == « loco ») { // —————————– commande get loco mode
sp (« commande loco « );
spl (Mots[1].toInt(),DEC);
MessageUDP[0] = 6; // longueur LSB = 0x06
MessageUDP[1] = 0x00; // longueur MSB
MessageUDP[2] = 0x60; // header LSB(0x60)
MessageUDP[3] = 0x00; // header MSB
MessageUDP[4] = 0x00; // MSB adresse loco
MessageUDP[5] = Mots[1].toInt(); //LSB adresse loco
sendPacketL(MessageUDP, 6, {192,168,1,1},{21105}); // envoi à la centrale
}

if (Mots[0] == « vit ») { // —————————– commande de vitesse (loco, sens, cran)
sp (« vitesse loco « );
sp (Mots[1].toInt(),DEC);
sp ( » sens « );
sp (Mots[2].toInt(),DEC);
sp ( » cran « );
spl (Mots[3].toInt(),DEC);
spl(« envoi du paquet »);
CommandeVitesse(Mots[1].toInt() , Mots[2].toInt() , Mots[3].toInt() ); // loco, sens, cran
}

if (Mots[0] == « fonc ») { // —————————– commande des fonctions
sp (« fonction loco « ); sp (Mots[1].toInt(),DEC);
sp ( » F »); sp (Mots[2].toInt(),DEC);
sp ( » « );
spl (Mots[3].toInt(),DEC);
spl(« envoi du paquet »);
CommandeFonction(Mots[1].toInt() , Mots[2].toInt() , Mots[3].toInt() ); // loco, fonction, état
//’E4 F8 set loco function (commande fonctions)
// If (O(11) And 192) = 0 Then ‘TTNNNNNN
// Prt Z21.RTB4, vbBlack, (O(11) And 31) &  » off »
// Else ‘par exemple 0B
// Prt Z21.RTB4, vbBlack, (O(11) And 31) &  » on »
/*
MessageUDP[0] = 10; // longueur LSB = 0x0A
MessageUDP[1] = 0x00; // longueur MSB
MessageUDP[2] = 0x40; // header LSB(0x40)
MessageUDP[3] = 0x00; // header MSB
MessageUDP[4] = 0xE4; CheckSum = 0xE4; // X-header
MessageUDP[5] = 0xF8; CheckSum = CheckSum ^ MessageUDP[5]; // commande de fonction
MessageUDP[6] = 0x00; // adresse DCC MSB – CheckSum pas modifiée par 0
MessageUDP[7] = Mots[1].toInt(); CheckSum = CheckSum ^ MessageUDP[7]; // adresse DCC LSB
// DB3 = TTNNNNNN où TT = off/on/toggle/n.a. NNNNNN = fonction
MessageUDP[8] = Mots[2].toInt(); // 00NNNNNNN
if (Mots[3].toInt() != 0) {MessageUDP[8] = MessageUDP[8] + 64; } // toggle traité comme on
CheckSum = CheckSum ^ MessageUDP[8];
//ajout de la checksum
MessageUDP[9] = CheckSum;
//sendPacketL(MessageUDP, 10, {192,168,1,10},{50000}); // envoi au PC / Packet Sender
sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
*/
}

if (Mots[0] == « udp ») { // —————————– commande udp pour tests
spl (« commande udp… »);
MessageUDP[0] = Mots[1].toInt();
MessageUDP[1] = Mots[2].toInt();
MessageUDP[2] = Mots[3].toInt();
sendPacketL(MessageUDP, 3, {192,168,1,10},{50000}); // envoi au PC / Packet Sender
}

if (Mots[0] == « test ») { // commande test pour clignotement (recherche) d’un port
Port = Mots[1].toInt();
sp (« commande port « ); spl (Port,DEC);
pinMode(Port, OUTPUT);
for (I=1; I<=10; I++){digitalWrite(Port,HIGH); delay(200); digitalWrite(Port,LOW); delay(200);}
}

if (Mots[0] == « xxx ») { // ——————- d’affectation d’une valeur à une variable
if (Mots[1] == « ? ») { // lecture
sp(« valeur: « ); spl(xxx,DEC);
}
else { // écriture
xxx = Mots[1].toInt();spl(« ok »);
sp(« écrit « ); sp(xxx,DEC); sp( » dans xxx « );
}
}

if (Mots[0] == « nnn ») { // ——————————– commande nnn pour numérique
sp (« commande nnn »);
Y = Mots[1].toInt();
sp ( » paramètre: « ); sp (Y);
Y = 2 * Y;
sp (« . Vérif x 2 = « ); spl (Y,DEC);
}

// ————————————————————- fin de commande, reset
//for (NbMots=0; NbMots<=5; NbMots++){ Mots[NbMots]= » »; }; // plante !?
Mots[0]= » »; Mots[1]= » »; Mots[2]= » »; Mots[3]= » »;
NbMots = 0;
//spl(« ok »);
break; // fin de LF
}
default:{ // *************************************************************** concaténation
Mots[NbMots] = Mots[NbMots] + X;};
break;
}
}
void CommandeVitesse(word loco, char sens, char cran) {
char CheckSum;
MessageUDP[0] = 10; // longueur LSB = 0x0A
MessageUDP[1] = 0x00; // longueur MSB
MessageUDP[2] = 0x40; // header LSB(0x40)
MessageUDP[3] = 0x00; // header MSB
MessageUDP[4] = 0xE4; CheckSum = 0xE4; // X-header
MessageUDP[5] = 0x13; CheckSum = CheckSum ^ MessageUDP[5]; // 128 steps
MessageUDP[6] = loco >> 8; CheckSum = CheckSum ^ MessageUDP[6]; // adresse DCC MSB
MessageUDP[7] = loco & 127; CheckSum = CheckSum ^ MessageUDP[7]; // adresse DCC LSB
// DB3 = Cran, If SensAvant Then DB3 = DB3 + 128, Arrêt urgent non traité
MessageUDP[8] = cran + 128 * sens ; CheckSum = CheckSum ^ MessageUDP[8];
//ajout de la checksum
MessageUDP[9] = CheckSum;
//sendPacketL(MessageUDP, 10, {192,168,1,10},{50000}); // envoi au PC / Packet Sender
//sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
sendPacketL(MessageUDP, 10, IP_CENTRALE,{21105}); // envoi à la centrale
}
void CommandeFonction(char loco, char fonction, bool etat){
char CheckSum;
MessageUDP[0] = 10; // longueur LSB = 0x0A
MessageUDP[1] = 0x00; // longueur MSB
MessageUDP[2] = 0x40; // header LSB(0x40)
MessageUDP[3] = 0x00; // header MSB
MessageUDP[4] = 0xE4; CheckSum = 0xE4; // X-header
MessageUDP[5] = 0xF8; CheckSum = CheckSum ^ MessageUDP[5]; // commande de fonction
MessageUDP[6] = loco >> 8; CheckSum = CheckSum ^ MessageUDP[6]; // adresse DCC MSB
MessageUDP[7] = loco & 127; CheckSum = CheckSum ^ MessageUDP[7]; // adresse DCC LSB
// DB3 = TTNNNNNN où TT = off/on/toggle/n.a. NNNNNN = fonction
MessageUDP[8] = fonction; // 00NNNNNNN
if (etat != 0) {MessageUDP[8] = MessageUDP[8] + 64; } // toggle traité comme on
CheckSum = CheckSum ^ MessageUDP[8];
//ajout de la checksum
MessageUDP[9] = CheckSum;
//sendPacketL(MessageUDP, 10, {192,168,1,10},{50000}); // envoi au PC / Packet Sender
//sendPacketL(MessageUDP, 10, {192,168,1,1},{21105}); // envoi à la centrale
sendPacketL(MessageUDP, 10, IP_CENTRALE,{21105}); // envoi à la centrale
}
// ======================================================================= impression en hexadécimal amélioré
void PrtHex(char X) {
if (X<16){sp(« 0 »);} sp(X,HEX);
}