Denver / Mbed 2 deprecated denver_train_proj

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed TextLCD

main.cpp@42:b445252a772a, 2018-06-18 (annotated)

Committer:
carlosperales95
Date:
Mon Jun 18 10:16:13 2018 +0000
Revision:
42:b445252a772a
Parent:
41:4fa6aa29d1ed
Child:
44:94870081aece
Comment fix and UPTODATE

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mglmx 0:4d06a6a8e785 1 #include "mbed.h"
mglmx 3:fe7010b693a0 2 #include "TextLCD.h"
mglmx 18:aa43bb62e60f 3 #include "MCP23017.h"
mglmx 22:e4153ca757dd 4 #include <string>
mglmx 22:e4153ca757dd 5 #include <iostream>
mglmx 35:cfcfeccb959e 6 #include <vector>
mglmx 35:cfcfeccb959e 7
mglmx 35:cfcfeccb959e 8 using namespace std;
mglmx 18:aa43bb62e60f 9
mglmx 1:0ab26889af9b 10
carlosperales95 7:e2b8461d4f05 11 /******PINS AND DECLARATIONS*******/
carlosperales95 7:e2b8461d4f05 12
carlosperales95 25:a42a1ed4d8e9 13 //------PINS
mglmx 21:e6f1649add39 14
mglmx 21:e6f1649add39 15 //SWITCHES p5 - p8
mglmx 21:e6f1649add39 16 DigitalIn switch1(p5);
mglmx 21:e6f1649add39 17 DigitalIn switch2(p6);
mglmx 21:e6f1649add39 18 DigitalIn switch3(p7);
mglmx 21:e6f1649add39 19 DigitalIn switch4(p8);
carlosperales95 7:e2b8461d4f05 20
carlosperales95 10:2088b1935a93 21 //RAIL SENSORS - INT0,INT1
carlosperales95 7:e2b8461d4f05 22 //INT0 - p9
mglmx 18:aa43bb62e60f 23 InterruptIn int0(p9);
carlosperales95 7:e2b8461d4f05 24 //INT1 - p10
mglmx 18:aa43bb62e60f 25 InterruptIn int1(p10);
carlosperales95 7:e2b8461d4f05 26
carlosperales95 7:e2b8461d4f05 27 ///p11
carlosperales95 7:e2b8461d4f05 28 ///p12
carlosperales95 12:e914ca5cd44b 29
carlosperales95 7:e2b8461d4f05 30 //M0 - p13
mglmx 35:cfcfeccb959e 31 DigitalIn d21stat(p13); //Sensor right of the station
carlosperales95 7:e2b8461d4f05 32 //M1 - p14
mglmx 35:cfcfeccb959e 33 DigitalIn d22stat(p14); //Sensor left of the station
carlosperales95 7:e2b8461d4f05 34 //M2 - p15
carlosperales95 29:559eb2164488 35 DigitalIn station(p15); //Sensor in the middle of the station
carlosperales95 12:e914ca5cd44b 36
carlosperales95 7:e2b8461d4f05 37 //p16
carlosperales95 12:e914ca5cd44b 38 //p17
carlosperales95 12:e914ca5cd44b 39
carlosperales95 11:021210c59a95 40 //BUZZER - p18
carlosperales95 11:021210c59a95 41 DigitalOut buzz(p18); // buzz=0 doesn't beep, buzz=1 beeps
carlosperales95 7:e2b8461d4f05 42
carlosperales95 7:e2b8461d4f05 43 //POTENTIOMETER - p19
carlosperales95 13:dbf1ead12cee 44 AnalogIn pot(p19); //Gives float value pot.read(). Convert analog input to V with f*3.3
carlosperales95 7:e2b8461d4f05 45
carlosperales95 7:e2b8461d4f05 46 //DAT - p20
mglmx 3:fe7010b693a0 47 DigitalOut Track(p20); //Digital output bit used to drive track power via H-bridge
carlosperales95 7:e2b8461d4f05 48
carlosperales95 7:e2b8461d4f05 49 //LCD SCREEN - p21, p22, p23, p24, p25, p26
carlosperales95 11:021210c59a95 50 TextLCD lcd(p22,p21,p23,p24,p25,p26); // RS, E, A4, A5, A6, A7 // ldc.cls() to clear and printf(String up to 16char)
carlosperales95 7:e2b8461d4f05 51
carlosperales95 7:e2b8461d4f05 52 ///p27
carlosperales95 7:e2b8461d4f05 53 ///p28
mglmx 33:24ce12dec157 54 I2C i2c(p28,p27);
carlosperales95 7:e2b8461d4f05 55
carlosperales95 7:e2b8461d4f05 56 //LED1 - p29
mglmx 3:fe7010b693a0 57 DigitalOut redled(p29);
carlosperales95 7:e2b8461d4f05 58 //LED2 - p30
mglmx 3:fe7010b693a0 59 DigitalOut greenled(p30);
carlosperales95 7:e2b8461d4f05 60
carlosperales95 24:1d71dd8778c4 61 //MBED LEDS
mglmx 18:aa43bb62e60f 62 DigitalOut led1(LED1);
mglmx 18:aa43bb62e60f 63 DigitalOut led2(LED2);
mglmx 18:aa43bb62e60f 64 DigitalOut led3(LED3);
mglmx 16:2a2da0e67793 65
mglmx 16:2a2da0e67793 66 //MCP
mglmx 16:2a2da0e67793 67 MCP23017 *mcp;
carlosperales95 12:e914ca5cd44b 68
carlosperales95 24:1d71dd8778c4 69
carlosperales95 25:a42a1ed4d8e9 70 //------GLOBAL VARS
carlosperales95 25:a42a1ed4d8e9 71
carlosperales95 38:b9aba3715682 72 //......SENSOR POSITION VARS
carlosperales95 38:b9aba3715682 73
carlosperales95 42:b445252a772a 74 //Defining sensors that will be interpreted as int for the logic.
mglmx 34:c9ab2a987734 75 #define D0 0
mglmx 34:c9ab2a987734 76 #define D1 1
mglmx 34:c9ab2a987734 77 #define D2 2
mglmx 34:c9ab2a987734 78 #define D3 3
mglmx 34:c9ab2a987734 79 #define D4 4
mglmx 34:c9ab2a987734 80 #define D5 5
mglmx 34:c9ab2a987734 81 #define D6 6
mglmx 34:c9ab2a987734 82 #define D7 7
mglmx 34:c9ab2a987734 83 #define D8 8
mglmx 34:c9ab2a987734 84 #define D9 9
mglmx 34:c9ab2a987734 85 #define D10 10
mglmx 34:c9ab2a987734 86 #define D11 11
mglmx 34:c9ab2a987734 87 #define D12 12
mglmx 34:c9ab2a987734 88 #define D13 13
mglmx 34:c9ab2a987734 89 #define D21 14
mglmx 34:c9ab2a987734 90 #define D22 15
mglmx 34:c9ab2a987734 91
mglmx 41:4fa6aa29d1ed 92
carlosperales95 38:b9aba3715682 93 /**
carlosperales95 38:b9aba3715682 94 *
carlosperales95 38:b9aba3715682 95 *Position class.
carlosperales95 38:b9aba3715682 96 *
carlosperales95 38:b9aba3715682 97 *@position -
carlosperales95 38:b9aba3715682 98 *@previous_cw -
carlosperales95 38:b9aba3715682 99 *@previous_ccw -
carlosperales95 38:b9aba3715682 100 *
carlosperales95 38:b9aba3715682 101 *Position(int) -
carlosperales95 38:b9aba3715682 102 *
carlosperales95 38:b9aba3715682 103 *get_pos() -
carlosperales95 38:b9aba3715682 104 *get_prev_cw() -
carlosperales95 38:b9aba3715682 105 *get_ccw() -
carlosperales95 38:b9aba3715682 106 *add_prev_cw() -
carlosperales95 38:b9aba3715682 107 *add_ccw() -
carlosperales95 38:b9aba3715682 108 *
carlosperales95 38:b9aba3715682 109 **/
mglmx 35:cfcfeccb959e 110 class Position{
mglmx 35:cfcfeccb959e 111 private:
mglmx 35:cfcfeccb959e 112 int position;
mglmx 35:cfcfeccb959e 113 vector <int> previous_cw;
mglmx 35:cfcfeccb959e 114 vector <int> previous_ccw;
mglmx 35:cfcfeccb959e 115 public:
mglmx 35:cfcfeccb959e 116 Position(int p){
mglmx 35:cfcfeccb959e 117 position = p;
mglmx 35:cfcfeccb959e 118 }
mglmx 36:9428c72bdd58 119
mglmx 36:9428c72bdd58 120 int get_pos(){
mglmx 36:9428c72bdd58 121 return position;
mglmx 36:9428c72bdd58 122 }
mglmx 41:4fa6aa29d1ed 123
mglmx 41:4fa6aa29d1ed 124 vector<int> get_next_cw(){
mglmx 41:4fa6aa29d1ed 125 return previous_ccw;
mglmx 41:4fa6aa29d1ed 126 }
mglmx 41:4fa6aa29d1ed 127
mglmx 41:4fa6aa29d1ed 128 vector<int> get_next_ccw(){
mglmx 41:4fa6aa29d1ed 129 return previous_cw;
mglmx 41:4fa6aa29d1ed 130 }
carlosperales95 25:a42a1ed4d8e9 131
mglmx 35:cfcfeccb959e 132 vector <int> get_prev_cw(){
mglmx 35:cfcfeccb959e 133 return previous_cw;
mglmx 35:cfcfeccb959e 134 }
mglmx 35:cfcfeccb959e 135
mglmx 35:cfcfeccb959e 136 vector <int> get_prev_ccw(){
mglmx 35:cfcfeccb959e 137 return previous_ccw;
mglmx 35:cfcfeccb959e 138 }
mglmx 35:cfcfeccb959e 139
mglmx 35:cfcfeccb959e 140 void add_prev_cw(int pos){
mglmx 35:cfcfeccb959e 141 previous_cw.push_back(pos);
mglmx 35:cfcfeccb959e 142 };
mglmx 35:cfcfeccb959e 143
mglmx 35:cfcfeccb959e 144 void add_prev_ccw(int pos){
mglmx 35:cfcfeccb959e 145 previous_ccw.push_back(pos);
mglmx 35:cfcfeccb959e 146 };
mglmx 35:cfcfeccb959e 147 };
mglmx 35:cfcfeccb959e 148
carlosperales95 42:b445252a772a 149
mglmx 41:4fa6aa29d1ed 150 //Creating a vector with all the positions.
mglmx 41:4fa6aa29d1ed 151 vector<Position> positions;
mglmx 41:4fa6aa29d1ed 152
carlosperales95 42:b445252a772a 153
carlosperales95 42:b445252a772a 154 /**
carlosperales95 42:b445252a772a 155 *
carlosperales95 42:b445252a772a 156 *Train class.
carlosperales95 42:b445252a772a 157 *
carlosperales95 42:b445252a772a 158 *@Position -
carlosperales95 42:b445252a772a 159 *@going_cw -
carlosperales95 42:b445252a772a 160 *
carlosperales95 42:b445252a772a 161 *Train(int, bool) -
carlosperales95 42:b445252a772a 162 *
carlosperales95 42:b445252a772a 163 *get_next_sensors() -
carlosperales95 42:b445252a772a 164 *set_position(int) -
carlosperales95 42:b445252a772a 165 *set_goes_cw(bool) -
carlosperales95 42:b445252a772a 166 *Position get_position() -
carlosperales95 42:b445252a772a 167 *Int get_position_number() -
carlosperales95 42:b445252a772a 168 *Bool goes_cw() -
carlosperales95 42:b445252a772a 169 *
carlosperales95 42:b445252a772a 170 **/
mglmx 41:4fa6aa29d1ed 171 class Train{
mglmx 41:4fa6aa29d1ed 172 private:
mglmx 41:4fa6aa29d1ed 173 Position *position;
mglmx 41:4fa6aa29d1ed 174 bool going_cw;
mglmx 41:4fa6aa29d1ed 175 public:
mglmx 41:4fa6aa29d1ed 176 Train(int pos, bool cw){
mglmx 41:4fa6aa29d1ed 177 position = &positions[pos];
mglmx 41:4fa6aa29d1ed 178 going_cw = cw;
mglmx 41:4fa6aa29d1ed 179 }
mglmx 41:4fa6aa29d1ed 180
mglmx 41:4fa6aa29d1ed 181 vector<int> get_next_sensors(){
mglmx 41:4fa6aa29d1ed 182
mglmx 41:4fa6aa29d1ed 183 //Checking direction
mglmx 41:4fa6aa29d1ed 184 if(going_cw){
mglmx 41:4fa6aa29d1ed 185 position->get_next_cw();
mglmx 41:4fa6aa29d1ed 186 }else{
mglmx 41:4fa6aa29d1ed 187 position->get_next_ccw();
mglmx 41:4fa6aa29d1ed 188 }
mglmx 41:4fa6aa29d1ed 189 }
mglmx 41:4fa6aa29d1ed 190
mglmx 41:4fa6aa29d1ed 191 void set_position(int pos){
mglmx 41:4fa6aa29d1ed 192 position = &positions[pos]; //Taking the new position from the positions vector
mglmx 41:4fa6aa29d1ed 193 }
mglmx 41:4fa6aa29d1ed 194
mglmx 41:4fa6aa29d1ed 195 void set_goes_cw(bool cw){
mglmx 41:4fa6aa29d1ed 196 going_cw = cw;
mglmx 41:4fa6aa29d1ed 197 }
mglmx 41:4fa6aa29d1ed 198
mglmx 41:4fa6aa29d1ed 199 Position get_position(){
mglmx 41:4fa6aa29d1ed 200 return *position;
mglmx 41:4fa6aa29d1ed 201 }
mglmx 41:4fa6aa29d1ed 202
mglmx 41:4fa6aa29d1ed 203 int get_position_number(){
mglmx 41:4fa6aa29d1ed 204 return position->get_pos();
mglmx 41:4fa6aa29d1ed 205 }
mglmx 41:4fa6aa29d1ed 206
mglmx 41:4fa6aa29d1ed 207 bool goes_cw(){
mglmx 41:4fa6aa29d1ed 208 return going_cw;
mglmx 41:4fa6aa29d1ed 209 }
mglmx 41:4fa6aa29d1ed 210 };
mglmx 41:4fa6aa29d1ed 211
carlosperales95 42:b445252a772a 212
carlosperales95 38:b9aba3715682 213 //Creation of all the positions. One for every sensor on the table - Position name(mapping)
mglmx 35:cfcfeccb959e 214 Position d0(D0);
mglmx 35:cfcfeccb959e 215 Position d1(D1);
mglmx 35:cfcfeccb959e 216 Position d2(D2);
mglmx 35:cfcfeccb959e 217 Position d3(D3);
mglmx 35:cfcfeccb959e 218 Position d4(D4);
mglmx 35:cfcfeccb959e 219 Position d5(D5);
mglmx 35:cfcfeccb959e 220 Position d6(D6);
mglmx 35:cfcfeccb959e 221 Position d7(D7);
mglmx 35:cfcfeccb959e 222 Position d8(D8);
mglmx 35:cfcfeccb959e 223 Position d9(D9);
mglmx 35:cfcfeccb959e 224 Position d10(D10);
mglmx 35:cfcfeccb959e 225 Position d11(D11);
mglmx 35:cfcfeccb959e 226 Position d12(D12);
mglmx 35:cfcfeccb959e 227 Position d13(D13);
mglmx 35:cfcfeccb959e 228 Position d21(D21);
mglmx 35:cfcfeccb959e 229 Position d22(D22);
mglmx 35:cfcfeccb959e 230
mglmx 41:4fa6aa29d1ed 231
carlosperales95 25:a42a1ed4d8e9 232 //.....DCC TRAIN COMMAND VARS
carlosperales95 25:a42a1ed4d8e9 233
carlosperales95 25:a42a1ed4d8e9 234 //typical out of box default engine DCC address is 3 (at least for Bachmann trains)
carlosperales95 25:a42a1ed4d8e9 235 //Note: A DCC controller can reprogram the address whenever needed
mglmx 32:e5b732fb8e65 236 const unsigned int DCCaddressDR = 0x01; //Address for train 1 DARK-RED
mglmx 32:e5b732fb8e65 237 const unsigned int DCCaddressLR = 0x03; //Address for train 3 LIGHT-RED
carlosperales95 25:a42a1ed4d8e9 238
carlosperales95 25:a42a1ed4d8e9 239 //01DCSSSS for speed, D is direction (fwd=1 and rev=0), C is speed(SSSSC) LSB
carlosperales95 25:a42a1ed4d8e9 240 const unsigned int DCCinst_forward = 0x68; //forward half speed
mglmx 33:24ce12dec157 241 const unsigned int DCCinst_forward_slow = 0x66; //forward half speed
carlosperales95 25:a42a1ed4d8e9 242 const unsigned int DCCinst_reverse = 0x48; //reverse half speed
carlosperales95 25:a42a1ed4d8e9 243 const unsigned int DCCinst_stop = 0x50; //stop the train
carlosperales95 25:a42a1ed4d8e9 244
carlosperales95 25:a42a1ed4d8e9 245 //100DDDDD for basic headlight functions
carlosperales95 25:a42a1ed4d8e9 246 const unsigned int DCC_func_lighton = 0x90; //F0 turns on headlight function
carlosperales95 25:a42a1ed4d8e9 247 const unsigned int DCC_func_dimlight = 0x91; //F0 + F1 dims headlight
carlosperales95 25:a42a1ed4d8e9 248
carlosperales95 25:a42a1ed4d8e9 249
carlosperales95 25:a42a1ed4d8e9 250 //.....SWITCH COMMAND VARS
carlosperales95 25:a42a1ed4d8e9 251
carlosperales95 25:a42a1ed4d8e9 252 const unsigned int SWBaddress = 0x06; //Address for switch box
carlosperales95 25:a42a1ed4d8e9 253
carlosperales95 25:a42a1ed4d8e9 254 //100DDDDD where DDDDD is the switch command and 100 is constant:
carlosperales95 25:a42a1ed4d8e9 255
carlosperales95 25:a42a1ed4d8e9 256 //00001(F1 active)-00010(F2 active)-00100(F3 active)-01000(F4 active)
carlosperales95 25:a42a1ed4d8e9 257 //Example - 111111 0 00000101 0 10000000 0 10000101 1 - idle
carlosperales95 25:a42a1ed4d8e9 258 const unsigned int SWBidle = 0x80; //IDLE - Flip last activated SW.
carlosperales95 25:a42a1ed4d8e9 259 const unsigned int SWBflip_1 = 0x81; //Flip SW1
carlosperales95 25:a42a1ed4d8e9 260 const unsigned int SWBflip_2 = 0x82; //Flip SW2
carlosperales95 25:a42a1ed4d8e9 261 const unsigned int SWBflip_3 = 0x84; //Flip SW3
carlosperales95 25:a42a1ed4d8e9 262 const unsigned int SWBflip_4 = 0x88; //Flip SW4
carlosperales95 25:a42a1ed4d8e9 263
carlosperales95 40:9acc1341456a 264
mglmx 35:cfcfeccb959e 265 //Starting position and orientation of the trains
mglmx 41:4fa6aa29d1ed 266 Train DR_train(D4,true); //Position and going_cw
mglmx 41:4fa6aa29d1ed 267 Train LR_train(D10,true);
mglmx 18:aa43bb62e60f 268
carlosperales95 38:b9aba3715682 269
carlosperales95 38:b9aba3715682 270 //**************** FUNCTIONS FOR DENVER TRAIN ****************//
carlosperales95 38:b9aba3715682 271
carlosperales95 38:b9aba3715682 272
mglmx 22:e4153ca757dd 273 /**
carlosperales95 42:b445252a772a 274 *
carlosperales95 25:a42a1ed4d8e9 275 *Activates the buzzer for 0.5 seconds.
mglmx 22:e4153ca757dd 276 **/
mglmx 22:e4153ca757dd 277 void doBuzz(){
carlosperales95 25:a42a1ed4d8e9 278
mglmx 22:e4153ca757dd 279 buzz = 1;
mglmx 22:e4153ca757dd 280 wait(0.5);
mglmx 22:e4153ca757dd 281 buzz = 0;
mglmx 22:e4153ca757dd 282 }
mglmx 18:aa43bb62e60f 283
carlosperales95 42:b445252a772a 284
carlosperales95 42:b445252a772a 285 /**
carlosperales95 42:b445252a772a 286 *
carlosperales95 42:b445252a772a 287 *Method to initialize al position vectors with the positions before and after (clockwise and counter-clockwise).
carlosperales95 42:b445252a772a 288 *
carlosperales95 42:b445252a772a 289 **/
mglmx 35:cfcfeccb959e 290 void init_positions(){
mglmx 36:9428c72bdd58 291
mglmx 35:cfcfeccb959e 292
mglmx 35:cfcfeccb959e 293 d0.add_prev_cw(D1);
mglmx 35:cfcfeccb959e 294 d0.add_prev_ccw(D13);
mglmx 35:cfcfeccb959e 295
mglmx 35:cfcfeccb959e 296 d1.add_prev_cw(D22);
mglmx 35:cfcfeccb959e 297 d1.add_prev_ccw(D0);
mglmx 35:cfcfeccb959e 298
mglmx 35:cfcfeccb959e 299 d22.add_prev_cw(D2);
mglmx 35:cfcfeccb959e 300 d22.add_prev_ccw(D1);
mglmx 35:cfcfeccb959e 301
mglmx 35:cfcfeccb959e 302 d2.add_prev_cw(D21);
mglmx 35:cfcfeccb959e 303 d2.add_prev_ccw(D22);
mglmx 35:cfcfeccb959e 304
mglmx 35:cfcfeccb959e 305 d21.add_prev_cw(D3);
mglmx 35:cfcfeccb959e 306 d21.add_prev_cw(D4);
mglmx 35:cfcfeccb959e 307 d21.add_prev_ccw(D2);
mglmx 35:cfcfeccb959e 308
mglmx 35:cfcfeccb959e 309 d3.add_prev_cw(D9);
mglmx 35:cfcfeccb959e 310 d3.add_prev_ccw(D21);
mglmx 35:cfcfeccb959e 311
mglmx 35:cfcfeccb959e 312 d4.add_prev_cw(D6);
mglmx 35:cfcfeccb959e 313 d4.add_prev_ccw(D21);
mglmx 35:cfcfeccb959e 314
mglmx 35:cfcfeccb959e 315 d5.add_prev_cw(D6);
mglmx 35:cfcfeccb959e 316 d5.add_prev_ccw(D11);
mglmx 35:cfcfeccb959e 317
mglmx 35:cfcfeccb959e 318 d6.add_prev_cw(D7);
mglmx 35:cfcfeccb959e 319 d6.add_prev_ccw(D4);
mglmx 35:cfcfeccb959e 320 d6.add_prev_ccw(D5);
mglmx 35:cfcfeccb959e 321
mglmx 35:cfcfeccb959e 322 d7.add_prev_cw(D8);
mglmx 35:cfcfeccb959e 323 d7.add_prev_ccw(D6);
mglmx 35:cfcfeccb959e 324
mglmx 36:9428c72bdd58 325 d8.add_prev_cw(D9);
mglmx 36:9428c72bdd58 326 d8.add_prev_cw(D10);
mglmx 36:9428c72bdd58 327 d8.add_prev_ccw(D7);
mglmx 36:9428c72bdd58 328
mglmx 35:cfcfeccb959e 329 d9.add_prev_cw(D3);
mglmx 35:cfcfeccb959e 330 d9.add_prev_ccw(D8);
mglmx 35:cfcfeccb959e 331
mglmx 35:cfcfeccb959e 332 d10.add_prev_cw(D12);
mglmx 35:cfcfeccb959e 333 d10.add_prev_ccw(D8);
mglmx 35:cfcfeccb959e 334
mglmx 35:cfcfeccb959e 335 d11.add_prev_cw(D12);
mglmx 35:cfcfeccb959e 336 d11.add_prev_ccw(D5);
mglmx 35:cfcfeccb959e 337
mglmx 35:cfcfeccb959e 338 d12.add_prev_cw(D13);
mglmx 35:cfcfeccb959e 339 d12.add_prev_ccw(D10);
mglmx 35:cfcfeccb959e 340 d12.add_prev_ccw(D11);
mglmx 35:cfcfeccb959e 341
mglmx 35:cfcfeccb959e 342 d13.add_prev_cw(D0);
mglmx 35:cfcfeccb959e 343 d13.add_prev_ccw(D12);
mglmx 36:9428c72bdd58 344
mglmx 36:9428c72bdd58 345 //Initialize array with positions
mglmx 36:9428c72bdd58 346 positions.push_back(d0);
mglmx 36:9428c72bdd58 347 positions.push_back(d1);
mglmx 36:9428c72bdd58 348 positions.push_back(d2);
mglmx 36:9428c72bdd58 349 positions.push_back(d3);
mglmx 36:9428c72bdd58 350 positions.push_back(d4);
mglmx 36:9428c72bdd58 351 positions.push_back(d5);
mglmx 36:9428c72bdd58 352 positions.push_back(d6);
mglmx 36:9428c72bdd58 353 positions.push_back(d7);
mglmx 36:9428c72bdd58 354 positions.push_back(d8);
mglmx 36:9428c72bdd58 355 positions.push_back(d9);
mglmx 36:9428c72bdd58 356 positions.push_back(d10);
mglmx 36:9428c72bdd58 357 positions.push_back(d11);
mglmx 36:9428c72bdd58 358 positions.push_back(d12);
mglmx 36:9428c72bdd58 359 positions.push_back(d13);
mglmx 36:9428c72bdd58 360 positions.push_back(d21);
mglmx 36:9428c72bdd58 361 positions.push_back(d22);
mglmx 35:cfcfeccb959e 362 }
carlosperales95 24:1d71dd8778c4 363
mglmx 22:e4153ca757dd 364 /**
carlosperales95 24:1d71dd8778c4 365 *
carlosperales95 28:71bd4c83c05f 366 *Here we initialize the mcp that will be used to manage the interrupts.
carlosperales95 25:a42a1ed4d8e9 367 *
carlosperales95 24:1d71dd8778c4 368 **/
mglmx 18:aa43bb62e60f 369 void initialize_mcp(){
mglmx 33:24ce12dec157 370 mcp = new MCP23017(i2c,0x40); //Connect to SCL - p28 and SDA - p27 and MPC I2C address 0x40
mglmx 18:aa43bb62e60f 371
mglmx 33:24ce12dec157 372 mcp->_write(IODIRA, (unsigned char )0xff);
mglmx 33:24ce12dec157 373 mcp->_write(IODIRB, (unsigned char )0xff);
mglmx 33:24ce12dec157 374 mcp->_write(IPOLA, (unsigned char )0x00);
mglmx 33:24ce12dec157 375 mcp->_write(IPOLB, (unsigned char )0x00);
mglmx 33:24ce12dec157 376 mcp->_write(DEFVALA, (unsigned char )0xff);
mglmx 33:24ce12dec157 377 mcp->_write(DEFVALB, (unsigned char )0xff);
mglmx 33:24ce12dec157 378 mcp->_write(INTCONA, (unsigned char )0xff);
mglmx 33:24ce12dec157 379 mcp->_write(INTCONB, (unsigned char )0xff);
mglmx 33:24ce12dec157 380 mcp->_write(IOCONA, (unsigned char )0x2);
mglmx 33:24ce12dec157 381 mcp->_write(IOCONB, (unsigned char )0x2);
mglmx 33:24ce12dec157 382 mcp->_write(GPPUA, (unsigned char )0xff);
mglmx 33:24ce12dec157 383 mcp->_write(GPPUB, (unsigned char )0xff);
mglmx 33:24ce12dec157 384
mglmx 18:aa43bb62e60f 385 }
mglmx 18:aa43bb62e60f 386
carlosperales95 24:1d71dd8778c4 387 /**
carlosperales95 24:1d71dd8778c4 388 *
carlosperales95 37:bb15bea420a3 389 *Returns the number of the sensor where the train was detected.
carlosperales95 37:bb15bea420a3 390 *
carlosperales95 37:bb15bea420a3 391 **/
mglmx 34:c9ab2a987734 392 int get_sensor(unsigned int number,int interrupt){
mglmx 34:c9ab2a987734 393 int sensor = -1;
mglmx 34:c9ab2a987734 394
carlosperales95 37:bb15bea420a3 395 for(int i=0; i<8; i++){
mglmx 34:c9ab2a987734 396
mglmx 34:c9ab2a987734 397 if(~number & 1<<i){
mglmx 34:c9ab2a987734 398 sensor = i;
mglmx 34:c9ab2a987734 399 }
mglmx 34:c9ab2a987734 400 }
mglmx 34:c9ab2a987734 401
mglmx 34:c9ab2a987734 402 if(interrupt == 1){
carlosperales95 37:bb15bea420a3 403 sensor+= 8; // Sensors caught by interreupt1 are identified from 8 to 15.
mglmx 34:c9ab2a987734 404 }
mglmx 34:c9ab2a987734 405 return sensor;
mglmx 34:c9ab2a987734 406 }
mglmx 34:c9ab2a987734 407
carlosperales95 42:b445252a772a 408 /**
carlosperales95 42:b445252a772a 409 *
carlosperales95 42:b445252a772a 410 *Updates the position of the train.
carlosperales95 42:b445252a772a 411 *
carlosperales95 42:b445252a772a 412 **/
mglmx 35:cfcfeccb959e 413 void update_train_pos(int sensor){
mglmx 41:4fa6aa29d1ed 414
mglmx 35:cfcfeccb959e 415 bool found_DR = false;
mglmx 41:4fa6aa29d1ed 416 bool found_LR = false;
mglmx 41:4fa6aa29d1ed 417
mglmx 41:4fa6aa29d1ed 418 lcd.cls();
mglmx 41:4fa6aa29d1ed 419 lcd.printf("Sensor D%d DR(%d) LR(%d)",sensor,DR_train.get_next_sensors().size(),LR_train.get_next_sensors().size());
mglmx 41:4fa6aa29d1ed 420
mglmx 41:4fa6aa29d1ed 421 //Checking next sensors for DR train
mglmx 41:4fa6aa29d1ed 422 for(int i=0; i<DR_train.get_next_sensors().size(); i++){
mglmx 41:4fa6aa29d1ed 423 lcd.cls();
mglmx 41:4fa6aa29d1ed 424 lcd.printf("I am inside the for :D",sensor);
mglmx 41:4fa6aa29d1ed 425 lcd.printf("Detected!");
mglmx 41:4fa6aa29d1ed 426
mglmx 41:4fa6aa29d1ed 427 if(DR_train.get_next_sensors()[i] == sensor){ //If the sensor is one expected to visit by the train we update the position
mglmx 41:4fa6aa29d1ed 428 found_DR = true;
mglmx 41:4fa6aa29d1ed 429 DR_train.set_position(sensor);
carlosperales95 37:bb15bea420a3 430
mglmx 41:4fa6aa29d1ed 431 if(DR_train.goes_cw()){
mglmx 41:4fa6aa29d1ed 432 if(sensor == D5 || sensor == D11){
mglmx 41:4fa6aa29d1ed 433 DR_train.set_goes_cw(false); //If train goes cw and passes D5 or D11 we change orientation
mglmx 41:4fa6aa29d1ed 434 }
mglmx 41:4fa6aa29d1ed 435 }else{
mglmx 41:4fa6aa29d1ed 436 if(sensor == D9 || sensor == D3){
mglmx 41:4fa6aa29d1ed 437 DR_train.set_goes_cw(true); //If train goes ccw and passes D9 or D3 we change orientation
mglmx 41:4fa6aa29d1ed 438 }
mglmx 41:4fa6aa29d1ed 439 }
carlosperales95 37:bb15bea420a3 440
mglmx 41:4fa6aa29d1ed 441 }
mglmx 41:4fa6aa29d1ed 442 }
mglmx 41:4fa6aa29d1ed 443
mglmx 41:4fa6aa29d1ed 444 //Checking next sensors for LR train
mglmx 41:4fa6aa29d1ed 445 for(int i=0; i<LR_train.get_next_sensors().size(); i++){
mglmx 41:4fa6aa29d1ed 446 lcd.cls();
mglmx 41:4fa6aa29d1ed 447 lcd.printf("I am inside the for :D",sensor);
mglmx 41:4fa6aa29d1ed 448 if(LR_train.get_next_sensors()[i] == sensor){
mglmx 41:4fa6aa29d1ed 449
mglmx 41:4fa6aa29d1ed 450 lcd.printf("Detected!");
mglmx 41:4fa6aa29d1ed 451 found_LR = true;
mglmx 41:4fa6aa29d1ed 452 LR_train.set_position(sensor);
mglmx 41:4fa6aa29d1ed 453
mglmx 41:4fa6aa29d1ed 454 if(LR_train.goes_cw()){
mglmx 41:4fa6aa29d1ed 455 if(sensor == D5 || sensor == D11){
mglmx 41:4fa6aa29d1ed 456 LR_train.set_goes_cw(false); //If train goes cw and passes D5 or D11 we change orientation
mglmx 41:4fa6aa29d1ed 457 }
mglmx 41:4fa6aa29d1ed 458 }else{
mglmx 41:4fa6aa29d1ed 459 if(sensor == D9 || sensor == D3){
mglmx 41:4fa6aa29d1ed 460 LR_train.set_goes_cw(true); //If train goes ccw and passes D9 or D3 we change orientation
mglmx 41:4fa6aa29d1ed 461 }
mglmx 41:4fa6aa29d1ed 462 }
mglmx 41:4fa6aa29d1ed 463 }
mglmx 41:4fa6aa29d1ed 464 }
mglmx 41:4fa6aa29d1ed 465
mglmx 35:cfcfeccb959e 466
mglmx 35:cfcfeccb959e 467 if(found_DR){
mglmx 36:9428c72bdd58 468 //doBuzz();
mglmx 35:cfcfeccb959e 469 lcd.cls();
mglmx 41:4fa6aa29d1ed 470 lcd.printf("DR is at D%d",DR_train.get_position_number());
mglmx 36:9428c72bdd58 471
mglmx 35:cfcfeccb959e 472 }
mglmx 35:cfcfeccb959e 473 if(found_LR){
carlosperales95 40:9acc1341456a 474
carlosperales95 37:bb15bea420a3 475 lcd.cls();
mglmx 41:4fa6aa29d1ed 476 lcd.printf("LR is at D%d",LR_train.get_position_number());
mglmx 35:cfcfeccb959e 477 }
mglmx 35:cfcfeccb959e 478 if(!found_DR && !found_LR){
mglmx 35:cfcfeccb959e 479 lcd.cls();
mglmx 35:cfcfeccb959e 480 lcd.printf("No train before :(");
mglmx 35:cfcfeccb959e 481 }
mglmx 35:cfcfeccb959e 482 }
mglmx 35:cfcfeccb959e 483
carlosperales95 37:bb15bea420a3 484
mglmx 34:c9ab2a987734 485 /**
mglmx 34:c9ab2a987734 486 *
carlosperales95 25:a42a1ed4d8e9 487 *Method to catch interrupts 0
carlosperales95 25:a42a1ed4d8e9 488 *
carlosperales95 24:1d71dd8778c4 489 **/
mglmx 33:24ce12dec157 490 void on_int0_change(){
carlosperales95 25:a42a1ed4d8e9 491
mglmx 33:24ce12dec157 492 wait_us(2000);
mglmx 33:24ce12dec157 493 int sensor_data = mcp->_read(INTCAPA);
mglmx 34:c9ab2a987734 494 int sensor = get_sensor(sensor_data,0);
mglmx 17:0a657e338356 495 lcd.cls();
mglmx 34:c9ab2a987734 496 lcd.printf("int0 0x%x \n Sensor: %d",sensor_data,sensor);
mglmx 41:4fa6aa29d1ed 497
mglmx 36:9428c72bdd58 498
mglmx 35:cfcfeccb959e 499 update_train_pos(sensor);
mglmx 16:2a2da0e67793 500 }
mglmx 16:2a2da0e67793 501
mglmx 35:cfcfeccb959e 502
mglmx 35:cfcfeccb959e 503
carlosperales95 24:1d71dd8778c4 504 /**
carlosperales95 24:1d71dd8778c4 505 *
carlosperales95 25:a42a1ed4d8e9 506 *Method to catch interrupts 1
carlosperales95 25:a42a1ed4d8e9 507 *
carlosperales95 24:1d71dd8778c4 508 **/
mglmx 33:24ce12dec157 509 void on_int1_change(){
carlosperales95 25:a42a1ed4d8e9 510
mglmx 33:24ce12dec157 511 wait_us(2000);
mglmx 33:24ce12dec157 512 int sensor_data = mcp->_read(INTCAPB);
mglmx 34:c9ab2a987734 513 int sensor = get_sensor(sensor_data,1);
mglmx 33:24ce12dec157 514 lcd.cls();
mglmx 34:c9ab2a987734 515 lcd.printf("int1 0x%x \n Sensor: %d",sensor_data,sensor);
mglmx 35:cfcfeccb959e 516
mglmx 35:cfcfeccb959e 517 update_train_pos(sensor);
mglmx 16:2a2da0e67793 518 }
mglmx 26:5c966a0a3e8e 519
mglmx 26:5c966a0a3e8e 520
mglmx 33:24ce12dec157 521 void init() { // Clear current interrupts
mglmx 33:24ce12dec157 522 mcp->_read(GPIOA);
mglmx 33:24ce12dec157 523 mcp->_read(GPIOB); // Register callbacks
mglmx 33:24ce12dec157 524 int0.fall(&on_int0_change);
mglmx 33:24ce12dec157 525 int1.fall(&on_int1_change); // Enable interrupts on MCP
mglmx 33:24ce12dec157 526 mcp->_write(GPINTENA, (unsigned char )0xff);
mglmx 33:24ce12dec157 527 mcp->_write(GPINTENB, (unsigned char )0xff); // Ready to go!
mglmx 33:24ce12dec157 528 }
mglmx 33:24ce12dec157 529
mglmx 33:24ce12dec157 530
carlosperales95 24:1d71dd8778c4 531 /**
carlosperales95 24:1d71dd8778c4 532 *
carlosperales95 25:a42a1ed4d8e9 533 *Method to send DCC commands to train and switches.
carlosperales95 25:a42a1ed4d8e9 534 *
carlosperales95 25:a42a1ed4d8e9 535 *@address - (HEX)Address where the commands will be sent
carlosperales95 25:a42a1ed4d8e9 536 *@inst - (HEX)Number of instruction that will be commanded
carlosperales95 25:a42a1ed4d8e9 537 *@repeat_count - Number of times the command will be sent
carlosperales95 25:a42a1ed4d8e9 538 *
carlosperales95 24:1d71dd8778c4 539 **/
mglmx 1:0ab26889af9b 540 void DCC_send_command(unsigned int address, unsigned int inst, unsigned int repeat_count)
mglmx 1:0ab26889af9b 541 {
mglmx 1:0ab26889af9b 542 unsigned __int64 command = 0x0000000000000000; // __int64 is the 64-bit integer type
mglmx 1:0ab26889af9b 543 unsigned __int64 temp_command = 0x0000000000000000;
mglmx 1:0ab26889af9b 544 unsigned __int64 prefix = 0x3FFF; // 14 "1" bits needed at start
mglmx 1:0ab26889af9b 545 unsigned int error = 0x00; //error byte
carlosperales95 24:1d71dd8778c4 546
mglmx 1:0ab26889af9b 547 //calculate error detection byte with xor
mglmx 1:0ab26889af9b 548 error = address ^ inst;
carlosperales95 24:1d71dd8778c4 549
mglmx 1:0ab26889af9b 550 //combine packet bits in basic DCC format
mglmx 1:0ab26889af9b 551 command = (prefix<<28)|(address<<19)|(inst<<10)|((error)<<1)|0x01;
mglmx 1:0ab26889af9b 552 //printf("\n\r %llx \n\r",command);
carlosperales95 24:1d71dd8778c4 553
mglmx 1:0ab26889af9b 554 int i=0;
carlosperales95 24:1d71dd8778c4 555 //repeat DCC command lots of times
mglmx 1:0ab26889af9b 556 while(i < repeat_count) {
carlosperales95 24:1d71dd8778c4 557
mglmx 1:0ab26889af9b 558 temp_command = command;
carlosperales95 24:1d71dd8778c4 559 //loops through packet bits encoding and sending out digital pulses for a DCC command
mglmx 1:0ab26889af9b 560 for (int j=0; j<64; j++) {
carlosperales95 24:1d71dd8778c4 561
carlosperales95 24:1d71dd8778c4 562 if((temp_command&0x8000000000000000)==0) {
carlosperales95 24:1d71dd8778c4 563 //test packet bit
mglmx 1:0ab26889af9b 564 //send data for a "0" bit
mglmx 1:0ab26889af9b 565 Track=0;
mglmx 1:0ab26889af9b 566 wait_us(100);
mglmx 1:0ab26889af9b 567 Track=1;
mglmx 1:0ab26889af9b 568 wait_us(100);
mglmx 1:0ab26889af9b 569 //printf("0011");
carlosperales95 24:1d71dd8778c4 570
carlosperales95 24:1d71dd8778c4 571 }else{
carlosperales95 24:1d71dd8778c4 572
mglmx 1:0ab26889af9b 573 //send data for a "1"bit
mglmx 1:0ab26889af9b 574 Track=0;
mglmx 1:0ab26889af9b 575 wait_us(58);
mglmx 1:0ab26889af9b 576 Track=1;
mglmx 1:0ab26889af9b 577 wait_us(58);
mglmx 1:0ab26889af9b 578 //printf("01");
mglmx 1:0ab26889af9b 579 }
mglmx 1:0ab26889af9b 580 // next bit in packet
mglmx 1:0ab26889af9b 581 temp_command = temp_command<<1;
mglmx 1:0ab26889af9b 582 }
mglmx 1:0ab26889af9b 583 i++;
mglmx 0:4d06a6a8e785 584 }
mglmx 0:4d06a6a8e785 585 }
carlosperales95 11:021210c59a95 586
carlosperales95 24:1d71dd8778c4 587
carlosperales95 24:1d71dd8778c4 588 /**
carlosperales95 24:1d71dd8778c4 589 *
carlosperales95 25:a42a1ed4d8e9 590 *Method to flip the switches
carlosperales95 25:a42a1ed4d8e9 591 *
carlosperales95 25:a42a1ed4d8e9 592 *@switchId - (1-4)The ID of the switch we want to flip
carlosperales95 25:a42a1ed4d8e9 593 *@times - The number of times we want to send the command
mglmx 30:293ee760d357 594 *@activate - True if the switch is going to be activated. False if it needs to go back to rest position.
carlosperales95 25:a42a1ed4d8e9 595 *
carlosperales95 24:1d71dd8778c4 596 **/
mglmx 30:293ee760d357 597 void flipSwitch(int switchId, int times, bool activate=true){
mglmx 21:e6f1649add39 598
carlosperales95 25:a42a1ed4d8e9 599 unsigned int SWBflip = SWBidle; //IDLE - Flip last activated SW.
mglmx 21:e6f1649add39 600
mglmx 21:e6f1649add39 601 switch(switchId){
mglmx 21:e6f1649add39 602 case 1:
carlosperales95 25:a42a1ed4d8e9 603 SWBflip = SWBflip_1; //FLIP SW1
mglmx 21:e6f1649add39 604 break;
mglmx 21:e6f1649add39 605 case 2:
carlosperales95 25:a42a1ed4d8e9 606 SWBflip = SWBflip_2; //FLIP SW2
mglmx 21:e6f1649add39 607 break;
mglmx 21:e6f1649add39 608 case 3:
carlosperales95 25:a42a1ed4d8e9 609 SWBflip = SWBflip_3; //FLIP SW3
mglmx 21:e6f1649add39 610 break;
mglmx 21:e6f1649add39 611 case 4:
carlosperales95 25:a42a1ed4d8e9 612 SWBflip = SWBflip_4; //FLIP SW4
mglmx 21:e6f1649add39 613 break;
mglmx 21:e6f1649add39 614 default:
carlosperales95 24:1d71dd8778c4 615 break;
mglmx 21:e6f1649add39 616 }
carlosperales95 11:021210c59a95 617
mglmx 21:e6f1649add39 618 //Security measure not to burn the switch.
mglmx 30:293ee760d357 619 if(times <=5){
mglmx 30:293ee760d357 620 DCC_send_command(SWBaddress,SWBflip,times); //Activating switch
mglmx 30:293ee760d357 621 if(!activate){
mglmx 30:293ee760d357 622 DCC_send_command(SWBaddress,SWBidle,times); //Sending IDLE to flip back.
mglmx 30:293ee760d357 623 }
mglmx 30:293ee760d357 624 }
mglmx 21:e6f1649add39 625
mglmx 21:e6f1649add39 626 }
mglmx 21:e6f1649add39 627
mglmx 22:e4153ca757dd 628
carlosperales95 24:1d71dd8778c4 629 /**
carlosperales95 24:1d71dd8778c4 630 *
carlosperales95 29:559eb2164488 631 *Checks if any of the switches of the box has been activated.
carlosperales95 29:559eb2164488 632 *Calls necessary function and displays LCD text.
carlosperales95 25:a42a1ed4d8e9 633 *
carlosperales95 24:1d71dd8778c4 634 **/
mglmx 21:e6f1649add39 635 void checkSwitch(){
carlosperales95 24:1d71dd8778c4 636
mglmx 22:e4153ca757dd 637 if(switch1 == 1){
carlosperales95 24:1d71dd8778c4 638
mglmx 22:e4153ca757dd 639 lcd.cls();
mglmx 22:e4153ca757dd 640 lcd.printf("Switch 1 ON - SW1");
carlosperales95 25:a42a1ed4d8e9 641 flipSwitch(1,5);
carlosperales95 24:1d71dd8778c4 642
mglmx 22:e4153ca757dd 643 }else if(switch2 == 1){
carlosperales95 24:1d71dd8778c4 644
carlosperales95 24:1d71dd8778c4 645 lcd.cls();
carlosperales95 24:1d71dd8778c4 646 lcd.printf("Switch 2 ON - SW2");
carlosperales95 24:1d71dd8778c4 647 flipSwitch(2,5);
carlosperales95 24:1d71dd8778c4 648
carlosperales95 24:1d71dd8778c4 649 }else if(switch3 == 0){
carlosperales95 24:1d71dd8778c4 650
carlosperales95 24:1d71dd8778c4 651 lcd.cls();
carlosperales95 24:1d71dd8778c4 652 lcd.printf("Switch 3 ON - SW3");
carlosperales95 24:1d71dd8778c4 653 flipSwitch(3,5);
carlosperales95 24:1d71dd8778c4 654
carlosperales95 24:1d71dd8778c4 655 }else if(switch4 == 0){
carlosperales95 24:1d71dd8778c4 656
carlosperales95 24:1d71dd8778c4 657 lcd.cls();
carlosperales95 24:1d71dd8778c4 658 lcd.printf("Switch 4 ON - IDLE");
carlosperales95 24:1d71dd8778c4 659 flipSwitch(0,5);
carlosperales95 24:1d71dd8778c4 660 }
mglmx 22:e4153ca757dd 661 }
mglmx 22:e4153ca757dd 662
carlosperales95 24:1d71dd8778c4 663
carlosperales95 24:1d71dd8778c4 664
carlosperales95 11:021210c59a95 665 //**************** MAIN PROGRAM FOR DENVER TRAIN ****************//
carlosperales95 11:021210c59a95 666
mglmx 1:0ab26889af9b 667 int main()
mglmx 1:0ab26889af9b 668 {
carlosperales95 42:b445252a772a 669 //////code to keep for near future impl.
carlosperales95 42:b445252a772a 670
carlosperales95 25:a42a1ed4d8e9 671 //RISE FOR INTERRUPTS?? NOT WORKING ATM
carlosperales95 25:a42a1ed4d8e9 672 //int0.rise(&interrupt0);
carlosperales95 25:a42a1ed4d8e9 673 //int1.rise(&interrupt1);
carlosperales95 25:a42a1ed4d8e9 674
carlosperales95 25:a42a1ed4d8e9 675 //Read and display potentiometer
carlosperales95 25:a42a1ed4d8e9 676 //float f = pot.read();
carlosperales95 25:a42a1ed4d8e9 677 //float vin = f * 3.3;
carlosperales95 25:a42a1ed4d8e9 678 //lcd.printf("vin: %.4f",vin);
carlosperales95 25:a42a1ed4d8e9 679
carlosperales95 25:a42a1ed4d8e9 680 //0xFFFC //1111111111111100
carlosperales95 25:a42a1ed4d8e9 681
carlosperales95 25:a42a1ed4d8e9 682
carlosperales95 25:a42a1ed4d8e9 683 //Led routine to start main program
mglmx 2:f580707c44fa 684 led1 = 1;
mglmx 22:e4153ca757dd 685 wait(0.2);
mglmx 2:f580707c44fa 686 led1 = 0;
mglmx 22:e4153ca757dd 687 wait(0.2);
mglmx 2:f580707c44fa 688 led1 = 1;
mglmx 16:2a2da0e67793 689
carlosperales95 25:a42a1ed4d8e9 690 initialize_mcp(); //mcp initialization for interrupts before train running
mglmx 33:24ce12dec157 691 init();
mglmx 35:cfcfeccb959e 692 init_positions();
mglmx 16:2a2da0e67793 693
carlosperales95 25:a42a1ed4d8e9 694 //Train light routine to start running
mglmx 32:e5b732fb8e65 695 DCC_send_command(DCCaddressDR,DCC_func_lighton,200); // turn light on full
mglmx 32:e5b732fb8e65 696 DCC_send_command(DCCaddressDR,DCC_func_dimlight,400); //dim light
mglmx 32:e5b732fb8e65 697 DCC_send_command(DCCaddressDR,DCC_func_lighton,200); //light full again
mglmx 22:e4153ca757dd 698
carlosperales95 25:a42a1ed4d8e9 699 //LED3 Shows start of route + LCD notif
mglmx 22:e4153ca757dd 700 led3 = 1; // Entering the while
mglmx 22:e4153ca757dd 701 lcd.cls();
mglmx 22:e4153ca757dd 702 lcd.printf("Ready to start");
carlosperales95 19:ff21ba3a4dc5 703
carlosperales95 14:7bb998edd819 704 //Demo for stopping at the station
mglmx 1:0ab26889af9b 705 while(1) {
mglmx 4:50879dfb82d5 706
carlosperales95 25:a42a1ed4d8e9 707 checkSwitch(); //Checks for switch commands everytime.
carlosperales95 25:a42a1ed4d8e9 708
mglmx 33:24ce12dec157 709 if(1==0){
mglmx 33:24ce12dec157 710 //if(station == 1){ //If train is on the sensor at the middle of the station it stops and displays LCD text.
carlosperales95 14:7bb998edd819 711
mglmx 4:50879dfb82d5 712 lcd.cls();
carlosperales95 29:559eb2164488 713 lcd.printf("All aboard\n mind the gap");
mglmx 32:e5b732fb8e65 714 DCC_send_command(DCCaddressDR,DCCinst_stop,400);
carlosperales95 29:559eb2164488 715 lcd.cls();
mglmx 4:50879dfb82d5 716
mglmx 22:e4153ca757dd 717 }else{
mglmx 34:c9ab2a987734 718 DCC_send_command(DCCaddressDR,DCCinst_forward,1); // Forward half speed train addres DARK-RED
mglmx 32:e5b732fb8e65 719 DCC_send_command(DCCaddressLR,DCCinst_forward,1); // Forward half speed train address LIGHT-RED
carlosperales95 25:a42a1ed4d8e9 720 }
mglmx 1:0ab26889af9b 721 }
mglmx 3:fe7010b693a0 722 }