Multiple WiFi to a WiFi AP using ESP_NOW

January 2023 LCD display added to output/receiver ESP8266

Multi_WiFi_to_WiFi_AP

This project takes the positions of model trains collected from multiple WiFi sources and uses ESP_NOW to combine these into a single WiFi Access Point. A smart device can then be used to display the location of model trains.

Note: There are two separate pieces of code:
1. LDR_ESP_NOW that reads the sensors, controls the signals and generates an ESP_NOW signal to transfer the train status to the ESP_NOW receiver, and
2. ESP_NOW_WiFi that receives the train status over ESP_NOW and acts as an Access Point to be read by a Smart Device.

Summary of LDR_ESP_NOW features

Include File: LDR_ESP_NOW.h
Constructor: LDR_ESP_NOW train;
Public Methods: train.begin(broadcastAddress);**
train_loc = train.monitor_train(); //returns train position
train.send_status(board_number*16+train_loc );++

** Requires receiver address EG uint8_t broadcastAddress[6] = {0xBC, 0xDD, 0xC2, 0xBA, 0xF3, 0x7F};
++ For multiple boards/senders/transmitters requires board number EG uint8_t board_number = 2;

%% For simulation use #define TESTING 1

Summary of ESP_NOW_WiFi features.

Include Files: ESP_NOW_WiFi.h and index.h for HTML template
Constructor: ESP_NOW_WiFi trains;
Public Methods: trains.begin(ssid,password );**
train_loc = trains.monitor_train(); //Returns ESP_NOW data
trains.WiFi_message(train_mess); //Text message via ESP_SSE

**Requires ssid and password EG. const char* ssid = "Monitor_Trains"; const char* password = "12345678";

-------------------------------------------------------------

Background

I have a very small model train layout. As a "fun" project I wish to use several sensor circuit to detect the position of trains. The results from several circuits would be combined by a WiFi circuit that could be interrogated by a smart device.

A previous project https://sites.google.com/site/johnkneenprojects/model_trains/wifi/ldr_esp_wifi_sse used LDR sensors to monitor the location of a model train on a short section of track. The results were read by an ESP8266 and transferred via WiFi_SSE (Server Send Events) to a smart device/client. The basic circuit is shown below.

The left hand diagram is a block diagram of the ldr_esp_wifi_sse project while the right hand photo shows the ESP8266 Hardware. The top wires interface with 8 LDR sensors placed in the track and the bottom wires go to 4 sets of RED-AMBER-GREEN signals. For the ldr_esp_wifi_sse project the ESP8266 generates a WiFi_SSE signal to be monitored by a smart phone.

For the Multi_WiFi_to_WiFi_AP project (this project) the ESP8266 will output ESP_NOW signals. There will be no change in the hardware. If there is no hardware, and also to aid testing a simulation or testing mode will be included.

For this project it is proposed to have many WiFi chips monitoring different sections of the layout and passing their results to a central WiFi station that will in turn pass the combined readings to a smart device.

---------------------------------------

Getting Started

Since the project will build on project https://sites.google.com/site/johnkneenprojects/model_trains/wifi/ldr_esp_wifi_sse it is probably sensible to reload the project ldr_esp_wifi_sse and verify that everything is operational. Without any sensors the smart device should display:

The final project will split the operation into two:

1. The multiple sending ESP8266s will basically read the LDRs and control the signals (code LDR_ESP_NOW), while

2. The receiver ESP8266 or Web Server will send the results using WiFi SSE to the smart device (Code ESP_NOW_WiFi).

To transfer the data from the senders to the receiver the protocol ESP_NOW will be used.

My approach to the project is to save two copies of the code ldr_esp_wifi_sse. The sender code will have the WiFi SSE code replaced with ESP_Now (send) while the receiver code will have the LDR monitoring functions replaced with ESP_Now (receive) code. This is illustrated below.

---------------------------------------------

Step 0: The Receiver MAC Address

Using ESP_NOW to send messages to the receiver the talker must know its MAC (media access control) address. Each device has a unique MAC address specified by the manufacturer. To find its MAC address the following code should be run:

#include <ESP8266WiFi.h>void setup(){Serial.begin(115200);Serial.println();Serial.print("Receiver MAC Address: ");Serial.println(WiFi.macAddress());}void loop(){}

For my device the resulting MAC (media access control )address is

----------------------------------------------------------

Step 1: The "Talker" Code- LDR_ESP_NOW

The overall project consists of multiple ESP8266s spread around the model railway track. These will (i) monitor the output of LDRs to determine the position of the train, (ii) control the output of signals, and (iii) output the train status. In a previous project https://sites.google.com/site/johnkneenprojects/model_trains/wifi/ldr_esp_wifi_sse the output was sent via ESP_SSE directly to a smart device. In this project a central ESP8266 will collect the outputs of many and send the combined results to a smart device.

Each one of these devices that monitor the train(s) will be know as a "Talker" or Transmitter. Basically it will be identical to the https://sites.google.com/site/johnkneenprojects/model_trains/wifi/ldr_esp_wifi_sse except that instead of sending data to a smart device using ESP_SSE it will send the data to a central ESP8266 using ESP_NOW.

Step 1 will monitor the LDRs and control the signals on the track. Effectively step 1 takes the project ldr_esp_wifi_sse (https://sites.google.com/site/johnkneenprojects/model_trains/wifi/ldr_esp_wifi_sse) and eliminates all the ESP_SSE code. No new code is written for Step 1. Step 2 will enhance Step 1 with ESP_NOW to communicate with the central ESP8266. (The end result is that ESP_SSE code has been replaced with ESP_NOW)

The starting code becomes (given the file name LDR_ESP_NOW):

Step 1a:

#include "LDR_ESP_NOW.h";

LDR_ESP_NOW train; //no parenthesis
enum where_is_train train_loc;
void setup() {Serial.begin(115200);Serial.println("LDR_ESP_NOW - reads LDRs and Tx status vis ESP_NOW"); train.begin(); }
void loop() {static where_is_train save_loc = startup ;train_loc = train.monitor_train(); if (train_loc != save_loc) {save_loc = train_loc;Serial.println(train_loc);}}
-----------------------
Step 1b.
//Implmentation file LDR_ESP_NOW.cpp#include "LDR_ESP_NOW.h"
LDR_ESP_NOW::LDR_ESP_NOW ( ) : LDR_Ser_Sig3_Ser_Class ( ) { }
void LDR_ESP_NOW::begin ( ) {LDR_Ser_Sig3_Ser_Class::begin(1,1,4); //- external NOR gate, +ve logic 4 signalsthe_train = startup;}
//tests for next state - no other action//returns next state. enum where_is_train LDR_ESP_NOW::train_state(int s0, int s1, int s2, int s3){
switch (the_train) {case startup : the_train = waiting; break; //alwayscase waiting : if (s0) the_train = coming0; if (s3) the_train = coming1; break;case coming0 : if (!s0) the_train = approaching0; break;case approaching0 : if (s1)the_train = arriving0; break; case arriving0 : if (!s1)the_train = station0; break;case station0 : if (s2) the_train = departing0; break; case departing0 : if (!s2) the_train = leaving0; break;case leaving0 : if (s3)the_train = going0; break; case going0 : if (!s3) the_train = waiting; break;case coming1 : if (!s3) the_train = approaching1; break;case approaching1 : if (s2)the_train = arriving1; break; case arriving1 : if (!s2)the_train = station1; break;case station1 : if (s1) the_train = departing1; break; case departing1 : if (!s1) the_train = leaving1; break;case leaving1 : if (s0)the_train = going1; break; case going1 : if (!s0) the_train = waiting; break;}return the_train;}
enum where_is_train LDR_ESP_NOW::monitor_train(uint8_t test ) {//parameter test added to allow shorting sensor to ground for train detected int s0 = train_over_sensor(COMING_SEN); //shorthand for sensorsint s1 = train_over_sensor(ARRIVE_SEN);int s2 = train_over_sensor(DEPART_SEN);int s3 = train_over_sensor(GOING_SEN);if (test) { s0 =!s0; s1=!s1; s2=!s2; s3=!s3;}signal_control(COMING_SIG,s0); //control signals signal_control(ARRIVE_SIG,s1); //RED then AMBER - GREEN signal_control(DEPART_SIG,s2); signal_control(GOING_SIG,s3); return train_state(s0,s1,s2,s3); //find next state}-------------------------------------------------
Step 1c.
//Header file: LDR_ESP_NOW.h#ifndef LDR_ESP_NOW_H#define LDR_ESP_NOW_H
#include "Arduino.h"#include <LDR_Ser_Sig3_Ser_Class.h>
#define COMING_SEN 0 #define ARRIVE_SEN 1#define DEPART_SEN 5#define GOING_SEN 4#define COMING_SIG 0#define ARRIVE_SIG 1#define DEPART_SIG 2#define GOING_SIG 3
enum where_is_train {startup,waiting,coming0,approaching0,arriving0,station0,departing0,leaving0,going0,coming1,approaching1,arriving1,station1,departing1,leaving1,going1};
class LDR_ESP_NOW :public LDR_Ser_Sig3_Ser_Class {public : LDR_ESP_NOW ( ); //use default values for pins void begin( ); //use default values enum where_is_train monitor_train(uint8_t test = 0 ); private :enum where_is_train train_state(int s0, int s1, int s2, int s3);enum where_is_train the_train; }; //semi colon important#endif;

The code as given monitors the 4 sensors on the track, controls the RED-AMBER_GREEN signals and determine the state of the passing train (over or between sensors and direction).

The status of the train is given by the variable train_loc. Once the ESP_NOW code (Step2) is added it is this result that ESP_NOW will broadcast.

-----------------------------------------------------------

**Step 2: Including the ESP_NOW talker code (*.ino).**

The following features need to be added to the client code (the *ino):

1. The MAC Address of the receiver. This was determined earlier as 0xBC, 0xDD, 0xC2, 0xBA, 0xF3, 0x7F.

2. A board number to distinguish this board from others. This will be combined with the train status to give results for the complete train layout.**

The *.cpp file will be enhanced to include all the details for the implementation of ESP_NOW and the method send_status( ) that will transmit a combination of the board number and train status.

Step 2a.
//LDR_ESP_NOW.ino Client file#include "LDR_ESP_NOW.h";
uint8_t broadcastAddress[6] = {0xBC, 0xDD, 0xC2, 0xBA, 0xF3, 0x7F};uint8_t board_number = 1;
#define TESTING 1
LDR_ESP_NOW train; //no parenthesis
enum where_is_train train_loc;
void setup() {Serial.begin(115200);train.begin(broadcastAddress); //defaults to 1,1,4 for signals}
void loop() {#if TESTING//test - send a message once a secondstatic long fire_esp;static int count;if (millis( )> fire_esp + 1000) {count++;count = (count)&15;train.send_status(16+count); //board no 1fire_esp = millis( ); Serial.println(count); //testing only}#elsestatic where_is_train save_loc = startup ;where_is_train train_loc = train.monitor_train(); //parameter = 1 for testing without LDRif (train_loc != save_loc) {save_loc = train_loc;Serial.println(train_loc); //testing onlytrain.send_status(board_number*16+train_loc );}#endif }

Note: To aid testing the receiver code an option to simulate the train status is included. This is selected using the #define TESTING statement. For the final product with valid model train data TESTING would be defined as zero

** The board number will need to be defined for each board and the code re-compiled. For a commercial unit external switches might be used to define the board number.

-------------------------------

Step 2b: The Implementation File LDR_ESP_NOW.cpp

The file LDR_ESP_NOW.cpp is enhanced to include all the details of the ESP_NOW implmentation.

#include "LDR_ESP_NOW.h"
#include <ESP8266WiFi.h>#include <espnow.h>
uint8 mac_addr[6];
LDR_ESP_NOW::LDR_ESP_NOW ( ) : LDR_Ser_Sig3_Ser_Class ( ) { }
// Callback when data is sentvoid OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) {if (sendStatus == 0){Serial.println("Delivery success");}else {Serial.println("Delivery fail");}}
void LDR_ESP_NOW::begin (uint8_t mac[6] ) {int i;Serial.println();for (i=0; i<6; i++) { mac_addr[i] = mac[i]; Serial.println(mac_addr[i],HEX); }Serial.println("------");LDR_Ser_Sig3_Ser_Class::begin(1,1,4); //- external NOR gate, +ve logic 4 signalsthe_train = startup;

//set up as a WiFi stationWiFi.mode(WIFI_STA);
// Initialise ESP-NOWif (esp_now_init() != 0) {Serial.println("Error initializing ESP-NOW");return;}
// Once ESPNow is successfully Initialised, register for Send Call back to// get the status of Transmitted packetesp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);esp_now_register_send_cb(OnDataSent);
// Register peeresp_now_add_peer(mac_addr, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
}
void LDR_ESP_NOW::send_status(uint8_t train_loc ){esp_now_send(mac_addr, (uint8_t*)&train_loc, sizeof(train_loc));}
enum where_is_train LDR_ESP_NOW::train_state(int s0, int s1, int s2, int s3){
.....code as previous
return the_train;}
enum where_is_train LDR_ESP_NOW::monitor_train(uint8_t test ) {...code as previousreturn train_state(s0,s1,s2,s3); //find next state}

In summary the implementation file includes the following additions to accomodate ESP_NOW.

1. Include the libraries <ESP8266WiFi.h> and <espnow.h>

2. Specify the MAC address for the listening device. In this example an array is allocated (uint8 mac_addr[6];) for the MAC address and the actual address passed as an argument in the begin( ) method. Thus if the listener/destination is changed the MAC address need only be changed in the *.ino file.

3, Include code for a Callback Function or Interrupt Service Routine that is executed each time data is transmitter. In this example the functions prints either success or failure.

4. As part of the begin method the WiFi is set up as a station. ie WiFi.mode(WIFI_STA);

5. The library function esp_now_init() will initialise ESP-NOW and return "0" for a good result.

6. Register the Callback or interrupt service routine esp_now_register_send_cb(OnDataSent);

7. Call the function esp_now_add_peer(mac_addr, ESP_NOW_ROLE_SLAVE, 1, NULL, 0); to pair the sender and receiver.

8. To send data the function will be esp_now_send(mac_addr, (uint8_t*)&train_loc, sizeof(train_loc));. Normally the second parameter will be a data structure but in this example train_loc is actually type uint8_t that is passed from the method send_status( ).

------------------------------------------

**Step 2c: LDR_ESP_NOW header file (*.h)**

The header file has basically only two changes:

1. Parameter mac_addr is added to the begin( ) method.

2. A method send_status( ) is included to call the ESP send function

//Header file: LDR_ESP_NOW.h...code as before
class LDR_ESP_NOW :public LDR_Ser_Sig3_Ser_Class {public : LDR_ESP_NOW ( ); //use default values for pins void begin(uint8_t mac_addr[6] ); //use default values for signals enum where_is_train monitor_train(uint8_t test = 0 ); void send_status(uint8_t loc );private :enum where_is_train train_state(int s0, int s1, int s2, int s3);enum where_is_train the_train; }; //semi colon important#endif;

In the TESTING mode the status 16..31 for board 1, 32..47 for board 2 will be displayed continously on the serial monitor.

For real testing the ESP_NOW_WiFi receiver will need to be implemented (Step 4). Without the receiver there will be one status message only.

----------------------------------------------------------

Step 3: Code for the HTML Server (ESP_NOW_WiFi)**

Steps 1 and 2 implemented the code to read the track sensors and transmit the status using ESP_NOW. That program was known as LDR_ESP_NOW.

The next step is to develop the second program to be known as ESP_NOW_WiFi. This effectively will be the program LDR_ESY_WiFi_SSE code with the code that monitors the sensors etc replaced with ESP_NOW code to receive the status from LDR_ESP_NOW.

For step 3 the interface to the smart device ( that is the server portion will be implemented)

Start up code to interface with a smart device will be:

Step 3a.
// Client file ESP_NOW_WiFi.ino
#include "ESP_NOW_WiFi.h"/*This program will receive model train information from an ESP_NOW talker* and generate an HTML file that may be read by a smart device.*/
const char* ssid = "Monitor_Trains";const char* password = "12345678";
ESP_NOW_WiFi trains; //no parenthesis
void setup() {Serial.begin(115200);Serial.println("ESP_NOW_WiFi Code");trains.begin(ssid,password ); }
void loop ( ){ trains.WiFi_message("No trains present.");}

----------------------

Step 3b. //Implementation file ESP_NOW_WiFi.cpp#include "ESP_NOW_WiFi.h"#include "index.h"
#include <ESPAsyncTCP.h>#include <ESPAsyncWebServer.h>// Create AsyncWebServer object on port 80AsyncWebServer server(80);
// Create an Event Source on /eventsAsyncEventSource events("/events");

void ESP_NOW_WiFi:: begin(const char* ssid, const char* password ) { // Initialize Serial MonitorSerial.begin(115200);// Set device as a Wi-Fi APWiFi.mode(WIFI_AP);WiFi.softAP(ssid, password); // Handle Web Serverserver.on("/", HTTP_GET, [](AsyncWebServerRequest *request){request->send_P(200, "text/html", WiFi_Mess);});// Handle Web Server Eventsevents.onConnect([](AsyncEventSourceClient *client){// send event with message "hello!", id and current millis// and set reconnect delay to 1 secondclient->send("hello!", NULL, millis(), 1000);});server.addHandler(&events);server.begin( );// Initialise ESP-NOW
}void ESP_NOW_WiFi::WiFi_message(char* mess){events.send(mess,"train_state"); }

-------------------

Step 3c:
//Header file ESP_NOW_WiFi.h#ifndef ESP_NOW_WiFi_H#define ESP_NOW_WiFi_H#include "Arduino.h"
enum where_is_train {startup,waiting,coming0,approaching0,arriving0,station0,departing0,leaving0,going0, coming1,approaching1,arriving1,station1,departing1,leaving1,going1};
class ESP_NOW_WiFi { public : ESP_NOW_WiFi ( ); void begin(const char* ssid, const char* password); void WiFi_message(char* mess);
}; //semi colon important#endif;

---------------------------------

Step 3d
//index.h const char WiFi_Mess [] PROGMEM = R"(<!DOCTYPE html><HTML><HEAD><TITLE>Monitor Trains</TITLE><meta name="viewport" content="width=device-width, initial-scale=1"><link rel="icon" href="data:,"><style>html {font-family: Arial;text-align: center;}body {max-width: 400px;margin:0px auto;}</style></HEAD><BODY><H2>Monitor Trains.</H2><span id="train">Monitoring Trains!</span>
<script>if (!!window.EventSource) {var source = new EventSource('/events');
source.addEventListener('open', function(e) {console.log("Events Connected");}, false);source.addEventListener('error', function(e) {if (e.target.readyState != EventSource.OPEN) {console.log("Events Disconnected");}}, false);
source.addEventListener('train_state', function(e) {console.log("train_state", e.data);document.getElementById("train").innerHTML = e.data;}, false);}</script>

</BODY></HTML>)";

The display on a Smart Device will be:

Monitor Trains.

No trains present.

The next step is to handle the received ESP_NOW messages.

-----------------------------------------------------

Step 4. Reading ESP_NOW for train status.

Step 3 of ESP_NOW_WiFi has implemented the HTML interface to a smart device.

Step 4 will be to upgrade the code to read messages of the train status from LDR_ESP_NOW and to send a message to the smart device. Currently LDR_ESP_NOW sends an integer to indicate the train status.

Step 4a:
// Client file ESP_NOW_WiFi.ino#include "ESP_NOW_WiFi.h"/*This program will receive model train information from an ESP_NOW talker* and generate an HTML file that may be read by a smart device.*/
const char* ssid = "Monitor_Trains";const char* password = "12345678";
ESP_NOW_WiFi trains; //no parenthesis
void setup() {Serial.begin(115200);Serial.println("ESP_NOW_WiFi Code");trains.begin(ssid,password ); }
void loop ( ){
static int save_loc;int train_loc = trains.monitor_train();if (train_loc != save_loc) {
save_loc = train_loc;Serial.println(train_loc);
trains.WiFi_message("Malanda");}}
Previously the *.ino code generated the HTML message "No trains present."
The above code will read the current train location using the method monitor( ). If the train position has changed ie (train_loc != save_loc) the new location/status will be displayed on the serial monitor. For starters the HTML message will be "Malanda"
---------------------------

Step 4b: Implementation file ESP_NOW_WiFi.cpp

The implementation code must:

1.Include the relevant ESP_NOW libraries.<ESP8266WiFi.h> and <espnow.h>

2. Add the Callback function that is executed when data is received: OnDataRecv( )

3. Set the device as both a STA and AP

4. Enable ESP_NOW and set up callback vector.

Possible code will be:

//Implementation file ESP_NOW_WiFi.cpp#include "ESP_NOW_WiFi.h"#include "index.h"
#include <ESP8266WiFi.h>#include <espnow.h>
#include <ESPAsyncTCP.h>#include <ESPAsyncWebServer.h>// Create AsyncWebServer object on port 80AsyncWebServer server(80);
// Create an Event Source on /eventsAsyncEventSource events("/events");
ESP_NOW_WiFi :: ESP_NOW_WiFi ( ) { }

// Callback function that is executed when data is received
int train_position;
void OnDataRecv(uint8_t * mac, uint8_t *train_status, uint8_t len) {
Serial.println("CallBack");for (int i = 0; i<6 ; i++){Serial.print(mac[i]);if (i<5) Serial.print(':'); }Serial.print("\nBytes received: ");Serial.println(len);Serial.println(*train_status); train_position = *train_status;}
int ESP_NOW_WiFi::monitor_train( ){return train_position;}
void ESP_NOW_WiFi:: begin(const char* ssid, const char* password ) { // Initialize Serial MonitorSerial.begin(115200);// Set device as a Wi-Fi AP+Station// WiFi.mode(WIFI_STA);WiFi.mode(WIFI_AP_STA);WiFi.softAP(ssid, password); // Handle Web Serverserver.on("/", HTTP_GET, [](AsyncWebServerRequest *request){request->send_P(200, "text/html", WiFi_Mess);});// Handle Web Server Eventsevents.onConnect([](AsyncEventSourceClient *client){// send event with message "hello!", id and current millis// and set reconnect delay to 1 secondclient->send("hello!", NULL, millis(), 1000);});server.addHandler(&events);server.begin( );// Initialise ESP-NOWif (esp_now_init()) {Serial.println("Error initialising ESP-NOW");return;} else Serial.println("\nESP-NOW Initialised\n");
// Set up receiver CallBack/Interrupt to get sent informationesp_now_set_self_role(ESP_NOW_ROLE_SLAVE);esp_now_register_recv_cb(OnDataRecv);
}void ESP_NOW_WiFi::WiFi_message(char* mess){events.send(mess,"train_state"); }

----------------------------

Step 4c: The Header File

The only new method is monitor_train( ); In the implementation file monitor_train( ) returns the train_position that was read as part of the callback method.

//Header file ESP_NOW_WiFi.h#ifndef ESP_NOW_WiFi_H#define ESP_NOW_WiFi_H#include "Arduino.h"//#include <LDR_Ser_Sig3_Ser_Class.h>
enum where_is_train {startup,waiting,coming0,approaching0,arriving0,station0,departing0,leaving0,going0,coming1,approaching1,arriving1,station1,departing1,leaving1,going1};
class ESP_NOW_WiFi { public : ESP_NOW_WiFi ( ); void begin(const char* ssid, const char* password); void WiFi_message(char* mess); int monitor_train( );
}; //semi colon important#endif;

-------------------------

Step 5: A Unique HTML display

For starters a second board was programmed as a sender - the only change was to make it "Board 2".

At the receiver there will be two sets of numbers displayed on the monitor: 16 through 31 for board 1; and 32 through 47 for board 2.

The next step is to generate HTML messages for both boards. Possible code will be:

void loop ( ){ static char train_mess[200], mal_mess[40], jg_mess[40], pos_mess[40];static int save_loc;int train_loc = trains.monitor_train();if (train_loc != save_loc) {
save_loc = train_loc;Serial.println(train_loc);
switch (train_loc&15){case waiting : strcpy(pos_mess,"No trains present."); break;case coming0 : strcpy(pos_mess,"Train coming from Tolga."); break;case approaching0 : strcpy(pos_mess,"Train approaching from Tolga."); break;case arriving0 : strcpy(pos_mess,"Train arriving from Tolga."); break;case station0 : strcpy(pos_mess,"Train from Tolga in Station."); break;case departing0 : strcpy(pos_mess,"Train departing for Miller."); break;case leaving0 : strcpy(pos_mess,"Train leaving for Miller."); break;case going0 : strcpy(pos_mess,"Train going to Miller."); break;case coming1 : strcpy(pos_mess,"Train coming from Miller."); break;case approaching1 : strcpy(pos_mess,"Train approaching from Miller."); break;case arriving1 : strcpy(pos_mess,"Train arriving from Miller."); break;case station1 : strcpy(pos_mess,"Train from Miller in Station."); break;case departing1 : strcpy(pos_mess,"Train departing for Tolga."); break;case leaving1 : strcpy(pos_mess,"Train leaving for Tolga."); break;case going1 : strcpy(pos_mess,"Train going to Tolga."); break;default : strcpy(pos_mess,"Train is lost!");}strcpy(train_mess, "Malanda: ");if (train_loc/16 ==1) strcpy(mal_mess, pos_mess);strcat(train_mess,mal_mess);strcat(train_mess,"<P>Jaggan: ");if (train_loc/16 ==2) strcpy(jg_mess, pos_mess);strcat(train_mess,jg_mess);
trains.WiFi_message(train_mess);}}

The messages are very specific to my layout. Using old trains from the Atherton Tableland I have chosen give the two stations the names "Malanda" (board 1) and "Jaggan". (Board2) The trains will then be arriving from / departing to Tolga and Miller Miller in the other.

The code will send out WiFi_SSE message trains.WiFi_message(train_mess); The code will build up this message depending on the ESP_NOW data received. train_loc/16 = 1 for board 1 or Malanda and 2 for board 2 or Jaggan. The actual message given by train_loc & 15 is then appended.

With both board 1 and board 2 in TESTING mode a typical response on a Smart phone will be:

With both board 1 and Board 2 in TESTING mode a typical response on a Smart phone will be as shown**:

**Note the message does include the HTML command "<P>" for a new paragraph. Without this command the massage will be on one line.

-----------------------------------------------------------------------------------

Conclusion.

The design appears satisfactory for two simple sections of track**. The design should be tested and the display modified for additional senders.

My original design consisted of two ESP8266 monitor-WiFi boards (more to be added later) It was found that the ground on each board should be connected. Also on the second board tested a LDR was partly shaded this indicated a train always present. The value of the 4.7K resistor was increased. For a commercial product this would not be satisfactory but for a one off home project the resistors could be individually adjusted.

On my layout board1 monitors the four upper sensors on the outer track while board 2 monitors the four upper sections on the inner track, The remaining tracks include cross over points and shunting yards that will add additional complexity to the program logic.

** The design does assume that the trains are initially outside the area being monitored++. Since the project is basically a WiFi project and it is only a "fun" project this is a reasonable assumption with the locos being placed in the "no train present" section of track.

Consider the possible situation where a loco starts off between the sensors "A" and "D"

When the program starts it is testing for a train at either "A" or "D". If the loco is physically somewhere between A and D and moving towards "D" when the program starts than when the train reaches "D" the code will give the message "Coming from" rather than "Going to". After the train has passed the "D" sensor the message will be "Arriving from" rather than "No train present"
In the algorithm the program is waiting for the train to reach "C". Assuming the train is looping it will pass through "A" and "B" before reaching "C". The software is now looking for the train at "B" which happens on the next loop. It then loops for a train at "A" which happens on the next loop.

At that point the software thinks the train has left the area. Unfortunately, the train has not., it is back where it has started and will never synchronise.

There are two choices:
(i) leave software as is and ensure the train is outside the area when the program starts, or
(ii) draw up a state diagram that includes all possible starting position and implement the code. As many textbooks say this is left as an exercise for the reader. This would need to be done in a commercial product- Good luck

++ A similar situation arises if ever there was a short circuit on the track - Since the circuit boards are powered from the track a short circuit would cause the boards to reset. The possible solutions are:
(i) Ensure there will be no shorts on the track - possibly easier said than done,
(ii) power the circuit boards from a separate power supply, or
(iii) as above draw up a state diagram that includes all possible starting position and implement the code.

____________________________________________________________________________________

Appendix: Adding a Display --added January 2023

While the project was just a "fun" project to display the train locations on a Smartphone it was thought the end product could be enhanced by displaying the results on an LCD**.

A separate project has developed a library LCD_1602. This library uses I2C protocol that implies the following wiring:

To add the LCD to the project:

1. Go to the LCD_1602_Class project and compact the LCD_1602.cpp and LCD_1602.h files into a single *.zip file. It will be given the label LCD_1602.

2. As part of this project in the Arduino IDE use the sequence Sketch-> include Library -> Add *.zip Library and add the library LCD_1602.zip

3. Include the LCD_1602 library in this project (ESP_NOW_WiFi). That is:

#include <LCD_1602.h>

4. Make an object or instance of the LCD_1602 class. ie

LCD_1602 lcd; //without arguments will default to address 0x27

5. In the setup( ) function initialise the LCD and write any messages if desired. ie

lcd.begin( );
lcd.message(0,"--ESP_NOW_WiFi--");
lcd.message(1,"-Monitor Trains-");

6. Write a display routine and call this from the main program loop. For example:

void lcd_message(int loc){
if (loc/16 == 1) lcd.message(0,"Malanda ");
if (loc/16== 2) lcd.message(1,"Jaggan ");
lcd.message(loc&15);
}

void loop ( ){
......
int train_loc = trains.monitor_train();
if (train_loc != save_loc) {
lcd_message(train_loc);
..........

As given the display will be of the form:

"Malanda 3"

where "3" is the current status of the train in the outer loop. Unfortunately the LCD is limited to 16 characters so it is not possible to write the complete message "Train arriving from Tolga."

**With hindsight having a LCD would have been useful during code development.

Page updated

Google Sites

Report abuse