Display Train State

Summary/Abstract: This project displays on the serial port the state of a model train. The project builds on a previous project,Track_Train that used 4 LDR sensors to determine the position of a model train.

Possible Audience: Hobbyists who are interested in using the serial port.

Keywords: Arduino IDE, Finite State Machine, Serial Port, PROGMEM

Required Components: The project is based on a previous project that had 4 sensors and 4 3 aspect signals (Red,Amber,Green). To use that project a micro-controller with 4 inputs and 12 outputs is required. For testing an Arduino UNO with 4 sets of LDRs and 4 sets of Red-Amber-Green signals was used.

Required Libraries: LDR_Sensor_RAG that inherits LDR_Sensor_Class so that library will be required also.

Introduction/Background

A previous project, Track_Train monitored the 4 sensors to determine the train state. That is waiting (no train present), coming the train was over the top sensor, approaching the train was between the two sensors. Knowing the position (state) of the train the program controlled 4 sets of signals. This project will use the state data to display the location of the train on the Arduino IDE Serial Monitor.

A previous project, Track_Train monitored the 4 sensors to determine the train state. That is waiting (no train present), coming the train was over the top sensor, approaching the train was between the two sensors. Knowing the position (state) of the train the program controlled 4 sets of signals. This project will use the state data to display the location of the train on the Arduino IDE Serial Monitor.

The Development Environment.

The project will be developed using the Arduino IDE.

In the Arduino IDE either:

1. Create a new project. that is file-->new and save the file as Dsp_Train_State. The IDE will give it the extension *.ino.

2. If the previous project, Track_Train is available reload (file-->open) and save as Dsp_Train_State.

If a new project was created:

1. Make copies of the required libraries. LDR_Sensor_RAG and LDR_Sensor_Class. Follow the procedure given in the page Programs

2. Duplicate the Track_Train program by loading the following code:

#include <LDR_Signals_RAG.h>
//Client file LDR_Signals_RAG.ino (Red Amber Green)//#include "LDR_Signals_RAG.h"
LDR_Signals_RAG signal0(A0,2,3,4);LDR_Signals_RAG signal1(A1,5,6,7);LDR_Signals_RAG signal2(A2,8,9,10);LDR_Signals_RAG signal3(A3,11,12,13);
enum where_is_train {waiting,coming,approaching,arriving,station,departing,leaving,going,vacant,vacant2} the_train;#define SIG0 signal0.drive_signals#define SIG1 signal1.drive_signals#define SIG2 signal2.drive_signals#define SIG3 signal3.drive_signals
#define RED_LIGHT_ON 5000L#define AMBER_LIGHT_ON 5000L #define PROBLEM 20000L#define POLARITY 1void setup() {signal0.begin(POLARITY);signal1.begin(POLARITY);signal2.begin(POLARITY);signal3.begin(POLARITY);the_train = waiting;}//Version 2: Signals are GREEN, AMBER, RED, RED in waiting statewhere_is_train train(int s0, int s1, int s2, int s3){static long start_time;switch (the_train) {case waiting : SIG0(0,0,1); SIG1(0,1,0); SIG2(1,0,0); SIG3(1,0,0); //green,amber,red,redif (s0) the_train = coming; break;case coming : // red, amber, red,redSIG0(1,0,0); //redif (!s0) { start_time = millis( ); the_train = approaching; } break;case approaching : //red,green,red,redSIG1(0,0,1); //greenSIG2(0,1,0); //amberif (s1)the_train = arriving; if ((millis( )-start_time)> PROBLEM) the_train= waiting; //false readingbreak; case arriving : //red,red,amber.redSIG1(1,0,0); //redif (!s1)the_train = station; break;case station : //red,red,green,redSIG2(0,0,1); //greenSIG3(0,1,0); //amberif (s2) the_train = departing; break; case departing : //red,red,red,amberSIG2(1,0,0); //redSIG3(0,1,0); //amberif (!s2) the_train = leaving; break;case leaving : //red,red,red,greenSIG3(0,0,1); //greenif (s3)the_train = going; break; case going : //all redSIG3(1,0,0); //redif (!s3) { the_train = vacant;start_time = millis();}break;case vacant : SIG0(0,1,0); //amberif ((millis( )- start_time) > RED_LIGHT_ON) { the_train = waiting;}break;}return the_train;} void loop() {int s0 = signal0.train_over_sensor( );int s1 = signal1.train_over_sensor( );int s2 = signal2.train_over_sensor( );int s3 = signal3.train_over_sensor( );the_train = train(s0,s1,s2,s3);}

Test Circuit

The circuit for project Track_Train is shown across. The signals are controlled by the current state the_train that are in turn determined by the sequence of inputs on sensors A0 through A3.

For evaluation on the workbench the following prototyping board was used. (Note the LDRs were physically too close to the GREEN Leds so were permanently low resistance (=no train). The solution was to limit the LED current by replacing the 1K ohm with 10Kohm resistors.

Adding the function display_message( );

Ultimately the display_message( ) function will be placed in the program loop( ).

For testing a Serial.write('.') is used. A dot is displayed on the Serial Monitor each time the code is executed

However the screen would become saturated with dots so a better solution is to only print a dot each time the state is changed. To do this a variable last_state of type where_is_train is created. This is declared as static which means

1. it preserves its value between each pass of loop( ) and

2. it is not known to functions outside of loop(). Further it is initialiased to an unlikely state vacant2.

In each pass of loop( ) the function train( ) is executed returning with the current state the_train. This one dot is printed each time the state changes.

Note in the setup( ) function the serial port is set to 115200 baud.

void setup() { .......... the_train = waiting; Serial.begin(115200);}//Version 2: Signals are GREEN, AMBER, RED, RED in waiting statewhere_is_train train(int s0, int s1, int s2, int s3){ ............ return the_train;} void loop() { static where_is_train last_state = vacant2; ........ the_train = train(s0,s1,s2,s3); if (the_train != last_state){ last_state = the_train; Serial.print('.'); }}

Populating the function display_message( );

The objective is to have a function to display the state on the serial monitor. A possible starting point is shown.

void display_message(where_is_train state_of_train){ Serial.println("Train location unknown!");}void loop() {........ the_train = train(s0,s1,s2,s3); if (the_train != last_state){ last_state = the_train; display_message(last_state); }}

For starters display_message( ) will just display a text message to verify operation. This code can be expanded:

const char Mess_waiting[] PROGMEM ={ "No trains present\n"};const char Mess_coming[] PROGMEM ={ "Train coming\n"};const char Mess_approach[] PROGMEM ={ "Train approaching\n"};const char Mess_arrive[] PROGMEM ={ "Train arriving\n"};const char Mess_station[] PROGMEM ={ "Train in station\n"};const char Mess_depart[] PROGMEM ={ "Train departing\n"};const char Mess_leave[] PROGMEM ={ "Train leaving\n"};const char Mess_going[] PROGMEM ={ "Train going\n"};const char Mess_vacant[] PROGMEM ={ "Train has vacated section\n"};
void response(const char * dd){char cc = pgm_read_byte(dd); while (cc != '\0'){ Serial.write(cc); dd++; cc = pgm_read_byte(dd); } } void display_message(where_is_train state_of_train){ switch (state_of_train){ case waiting: response(Mess_waiting); break; case coming: response(Mess_coming); break; case approaching: response(Mess_approach); break; case arriving: response(Mess_arrive); break; case station: response(Mess_station); break; case departing: response(Mess_depart); break; case leaving: response(Mess_leave); break; case going: response(Mess_going); break; case vacant: case vacant2: response(Mess_vacant); break; }}

In the example the argument/parameter of display_message( ) will display a different messages. These messages are defined as a number of constant characters. For example
const char Mess_waiting[] PROGMEM ={"No trains present\n"};

where the directive PROGMEM tells the compiler not to place a copy of the data into dynamic memory but the program will use the copy in Flash/ROM. This is done in the procedure/method response that uses a special function pgm_read_byte() to read a character from memory and place it into data/dynamic memory. This copy is then written to the monitor.

This technique is used to save dynamic memory.In the example given using dynamic memory for the messages would use (9 messages each approximately 18 bytes long) 138 bytes which is nearly 7% of the available dynamic memory. This technique is elaborated upon in the page ROM_Data.

Running the program gives the following results on the Arduino Serial Monitor.

Testing

The design worked on the bench as expected. Since it built on a previous project LDR_Signal_RAG the messy part of all the wiring from the sensors and signals for the model train layout was in place.

One Concluding Thought

This is only a fun project and the performance is more than adequate. However in a real embedded system it is important to have an appreciation of the performance and to identify any bottlenecks. In this example we have an appreciation of the code that we wrote - there are no delay loops or while statements waiting for something to occur. The code we wrote is non-blocking.

However the code does use the external Serial library. We know nothing of the serial library. Does it wait until the first character is sent before sending the second? The answer is no. There is a 64 character serial buffer which the Serial Library will load. However after the 64th character the library will need to wait until the first character is transmitted before loading character 65.

In this example none of the messages are anywhere near 64 characters in length but in practice we need to be aware that if we are sending messages over 64 characters in length there may be performance issues.

Page updated

Google Sites

Report abuse