Andriy Makukha / Mbed 2 deprecated football_project_wo_output

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

Fork of football_project by MZJ

proto_code.cpp@67:5650f461722a, 2016-02-11 (annotated)

Committer:
AntonLS
Date:
Thu Feb 11 17:47:28 2016 +0000
Revision:
67:5650f461722a
Parent:
66:18c214707b0c
Child:
70:bd4b1e19a0c6
Radio message arch like old cones. Static or Auto node IDs.  Missed ack detect. Dark alert fix. Fixes cone death.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
elmbed 17:d8b901d791fd 1 #include <TA.h>
elmbed 17:d8b901d791fd 2 #include <types.h>
elmbed 62:9b34dc1b265d 3 #include "DataStore.hh"
elmbed 17:d8b901d791fd 4
elmbed 17:d8b901d791fd 5 #define RED p3
elmbed 17:d8b901d791fd 6 #define GREEN p5
elmbed 17:d8b901d791fd 7 #define BLUE p6
elmbed 17:d8b901d791fd 8
elmbed 17:d8b901d791fd 9 #define ENABLE_1 p4
elmbed 17:d8b901d791fd 10 #define ENABLE_2 p7
elmbed 17:d8b901d791fd 11 #define ENABLE_3 p8
elmbed 17:d8b901d791fd 12
elmbed 17:d8b901d791fd 13 #define DEBUG_BAUD 57600 //57600
elmbed 17:d8b901d791fd 14
elmbed 17:d8b901d791fd 15 #define TRILAT_CONE 99
elmbed 17:d8b901d791fd 16
elmbed 17:d8b901d791fd 17 #define DEBOUNCE_MS 100
AntonLS 46:28c29ef61276 18 #define LIGHTS TOUCHLIGHTS
AntonLS 46:28c29ef61276 19 #define FAKEOUT 0x08
AntonLS 46:28c29ef61276 20 #define FAIL_QUICK 0x10
AntonLS 46:28c29ef61276 21 #define SILENT 0x20
elmbed 17:d8b901d791fd 22 #define GRACE_PERIOD 3000
elmbed 17:d8b901d791fd 23
elmbed 58:fb2198ceb412 24 #define NEED_CONSOLE_OUTPUT 1 /* Set this if you need //////////////////////DEBUG messages on the console;
elmbed 17:d8b901d791fd 25 * it will have an impact on code-size and power consumption. */
elmbed 17:d8b901d791fd 26
elmbed 17:d8b901d791fd 27 #define LOOPBACK_MODE 0 // Loopback mode
elmbed 17:d8b901d791fd 28
elmbed 17:d8b901d791fd 29 #if NEED_CONSOLE_OUTPUT
elmbed 17:d8b901d791fd 30 #define DEBUG(...) { printf(__VA_ARGS__); }
elmbed 17:d8b901d791fd 31 #else
elmbed 17:d8b901d791fd 32 #define DEBUG(...) /* nothing */
elmbed 17:d8b901d791fd 33 #endif /* #if NEED_CONSOLE_OUTPUT */
elmbed 17:d8b901d791fd 34
elmbed 17:d8b901d791fd 35 extern int random(int numberone, int numbertwo);
elmbed 61:dd7002ceea96 36 extern bool is_master;
elmbed 17:d8b901d791fd 37
elmbed 58:fb2198ceb412 38 extern uint8_t* datastore_get_cones();
elmbed 58:fb2198ceb412 39 extern uint8_t* datastore_get_masks();
elmbed 58:fb2198ceb412 40 extern uint16_t* datastore_get_times();
elmbed 58:fb2198ceb412 41
elmbed 17:d8b901d791fd 42 unsigned long millis();
elmbed 17:d8b901d791fd 43 unsigned long micros();
elmbed 17:d8b901d791fd 44
elmbed 17:d8b901d791fd 45 TA ta;
elmbed 17:d8b901d791fd 46
elmbed 18:affef3a7db2a 47 static bool active_cones[NUM_CONES + 1]; // + 1 so we can be 1 based like the cone numbers are
elmbed 17:d8b901d791fd 48
elmbed 28:8e74ddc4f70f 49 const static int CONTROL_CONE = 1;
elmbed 28:8e74ddc4f70f 50
elmbed 61:dd7002ceea96 51 static Mode_t mode = PATTERN_M;
elmbed 18:affef3a7db2a 52 static patternState_t state_p = IDLE_P;
elmbed 18:affef3a7db2a 53 static inputState_t state_i = IDLE_I;
elmbed 61:dd7002ceea96 54
elmbed 23:26f27c462976 55 State_t state = IDLE;
elmbed 61:dd7002ceea96 56
elmbed 17:d8b901d791fd 57
elmbed 18:affef3a7db2a 58 static Message m1 = { 'm',0,2 };
elmbed 17:d8b901d791fd 59
elmbed 18:affef3a7db2a 60 static Message *m = &m1;
elmbed 18:affef3a7db2a 61 static Message m2 = { 'm',0,2 };
elmbed 18:affef3a7db2a 62 static Message *m_in = &m2;
elmbed 17:d8b901d791fd 63
elmbed 18:affef3a7db2a 64 static uint8_t active_cone = 0;
elmbed 38:76e49d045a3b 65 static unsigned long timeout = 10000L;
elmbed 18:affef3a7db2a 66 static uint8_t mask = 0x07;
elmbed 18:affef3a7db2a 67 static uint8_t fakeout = 0;
elmbed 18:affef3a7db2a 68 static uint8_t fail_quick = 0;
elmbed 18:affef3a7db2a 69 static uint8_t index = 0;
elmbed 18:affef3a7db2a 70 static bool new_state = false;
elmbed 18:affef3a7db2a 71 static bool tag_start = false; // flag to indicate we should wait for the user to activate the first station before going through the sequence
elmbed 18:affef3a7db2a 72
elmbed 17:d8b901d791fd 73 static bool in_menu = false;
elmbed 17:d8b901d791fd 74 static bool warning = false;
elmbed 17:d8b901d791fd 75 static bool penalty = false;
elmbed 17:d8b901d791fd 76 static bool logging = false;
elmbed 17:d8b901d791fd 77
elmbed 17:d8b901d791fd 78 // course setup (probably should make some of these persistant settings)
elmbed 18:affef3a7db2a 79 static uint8_t active_sequence = 0;
elmbed 18:affef3a7db2a 80 static uint8_t station = 1;
elmbed 18:affef3a7db2a 81 static uint8_t cone = 0;
elmbed 18:affef3a7db2a 82 static uint16_t ltime = 0;
elmbed 17:d8b901d791fd 83
elmbed 17:d8b901d791fd 84 volatile bool triggered;
elmbed 17:d8b901d791fd 85 volatile bool pin;
elmbed 17:d8b901d791fd 86 volatile bool ping = false;
elmbed 18:affef3a7db2a 87
elmbed 17:d8b901d791fd 88 static volatile bool captured = false;
elmbed 17:d8b901d791fd 89 static volatile unsigned long ping_timer = 0;
elmbed 17:d8b901d791fd 90 static volatile unsigned long dist_timeout = 0;
elmbed 17:d8b901d791fd 91
elmbed 58:fb2198ceb412 92 // These pointers are allocated in DataStore
elmbed 58:fb2198ceb412 93 static uint8_t *cone_table = NULL;
elmbed 58:fb2198ceb412 94 static uint8_t *mask_table = NULL;
elmbed 58:fb2198ceb412 95 static uint16_t *time_table = NULL;
elmbed 17:d8b901d791fd 96
elmbed 17:d8b901d791fd 97 // pointer to active table
elmbed 61:dd7002ceea96 98 static uint8_t *cones = NULL;
elmbed 61:dd7002ceea96 99 static uint8_t *masks = NULL;
elmbed 61:dd7002ceea96 100 static uint16_t *times = NULL;
elmbed 17:d8b901d791fd 101
elmbed 17:d8b901d791fd 102 static bool lonely = false;
elmbed 17:d8b901d791fd 103
elmbed 17:d8b901d791fd 104 // Function prototypes
elmbed 17:d8b901d791fd 105 void spin();
elmbed 17:d8b901d791fd 106 patternState_t stateFromCone(uint8_t cone);
elmbed 17:d8b901d791fd 107 void printSplit(unsigned long timer);
elmbed 17:d8b901d791fd 108 uint8_t getRandomCone(void);
elmbed 17:d8b901d791fd 109 void clearCones(void);
elmbed 17:d8b901d791fd 110 void powerupCones(uint8_t sound);
elmbed 17:d8b901d791fd 111 void failCones(void);
elmbed 17:d8b901d791fd 112 void resetSensors(void);
elmbed 17:d8b901d791fd 113 void successCones(void);
elmbed 17:d8b901d791fd 114 void find_cones(void);
elmbed 17:d8b901d791fd 115 void printMsAsSeconds(unsigned long number);
elmbed 17:d8b901d791fd 116 void spinButtons(void);
elmbed 17:d8b901d791fd 117 uint8_t checkButtons(void);
elmbed 17:d8b901d791fd 118 Event getInputEvent(void);
elmbed 17:d8b901d791fd 119 void getRadioInput(char *ibuffer, int size);
elmbed 62:9b34dc1b265d 120 void interpret_master(char parameter, int value);
elmbed 62:9b34dc1b265d 121 void interpret_slave(char parameter, int value);
elmbed 23:26f27c462976 122
elmbed 23:26f27c462976 123 extern "C" void writeToPhone(char *format, ...);
elmbed 17:d8b901d791fd 124
AntonLS 39:b1f864b71318 125 static const int active_colour = 0x00FF00; /// 0x00FF;
AntonLS 39:b1f864b71318 126 static const int warn_colour = 0xFFA500; /// 0xF050;
AntonLS 52:060fdec99780 127 static const int fail_colour = 0xFF0000; /// 0x0000FF;
AntonLS 39:b1f864b71318 128 static const int touch_colour = 0x0000FF; /// 0x005050;
AntonLS 39:b1f864b71318 129 static const int success_colour = 0x00FF00; /// 0xFFFF;
AntonLS 39:b1f864b71318 130 static const int pen_colour = 0xFFFF00; /// 0x10FF;
AntonLS 39:b1f864b71318 131 static const int idle_colour = 0xFF0000; /// 0x00;
AntonLS 54:2878d62714d6 132 static const int batt_colour = 0xFFFF00;
elmbed 38:76e49d045a3b 133
elmbed 17:d8b901d791fd 134 char local_input[50] = {0};
elmbed 17:d8b901d791fd 135
elmbed 23:26f27c462976 136 static void master_setup()
elmbed 17:d8b901d791fd 137 {
elmbed 28:8e74ddc4f70f 138 ta.initialize(NODE_ID);
elmbed 17:d8b901d791fd 139
elmbed 17:d8b901d791fd 140 uint16_t sent = 0;
elmbed 17:d8b901d791fd 141 uint16_t lost = 0;
elmbed 17:d8b901d791fd 142 unsigned long start = micros();
elmbed 58:fb2198ceb412 143
elmbed 17:d8b901d791fd 144 m->command = 'p';
elmbed 17:d8b901d791fd 145 m->value = 0;
elmbed 17:d8b901d791fd 146 m->cone = 0;
elmbed 17:d8b901d791fd 147
elmbed 17:d8b901d791fd 148 int i;
elmbed 23:26f27c462976 149
elmbed 28:8e74ddc4f70f 150 for(i = 1; i < NUM_CONES + 1; ++i)
elmbed 28:8e74ddc4f70f 151 {
AntonLS 66:18c214707b0c 152 active_cones[i] = true; /// false;
elmbed 28:8e74ddc4f70f 153 }
elmbed 17:d8b901d791fd 154
elmbed 28:8e74ddc4f70f 155 unsigned long time = 0;
elmbed 17:d8b901d791fd 156
elmbed 58:fb2198ceb412 157 cone_table = datastore_get_cones();
elmbed 58:fb2198ceb412 158 mask_table = datastore_get_masks();
elmbed 58:fb2198ceb412 159 time_table = datastore_get_times();
elmbed 18:affef3a7db2a 160
elmbed 18:affef3a7db2a 161 ta.post_color(0xFF0000);
elmbed 40:dec5270e03e9 162
AntonLS 48:4c9551c826e9 163 srand( rndHW() );
elmbed 17:d8b901d791fd 164 }
elmbed 61:dd7002ceea96 165
elmbed 23:26f27c462976 166 static void slave_setup()
elmbed 23:26f27c462976 167 {
elmbed 28:8e74ddc4f70f 168 ta.initialize(NODE_ID);
elmbed 23:26f27c462976 169 }
elmbed 61:dd7002ceea96 170
elmbed 23:26f27c462976 171
elmbed 23:26f27c462976 172 void setup()
elmbed 23:26f27c462976 173 {
elmbed 61:dd7002ceea96 174 if (is_master)
elmbed 61:dd7002ceea96 175 {
elmbed 61:dd7002ceea96 176 master_setup();
elmbed 61:dd7002ceea96 177 }
elmbed 61:dd7002ceea96 178 else
elmbed 61:dd7002ceea96 179 {
elmbed 61:dd7002ceea96 180 slave_setup();
elmbed 61:dd7002ceea96 181 }
elmbed 23:26f27c462976 182 }
elmbed 23:26f27c462976 183
elmbed 23:26f27c462976 184 static void slave_loop()
elmbed 23:26f27c462976 185 {
elmbed 23:26f27c462976 186 static unsigned long start = 0;
elmbed 23:26f27c462976 187 static unsigned long timeout;
elmbed 23:26f27c462976 188 static bool process_next_as_time = false;
elmbed 23:26f27c462976 189 static bool process_next_as_mask = false;
elmbed 23:26f27c462976 190 static unsigned long timer;
elmbed 23:26f27c462976 191 static State_t last_state = IDLE;
elmbed 28:8e74ddc4f70f 192 static int counter = 0;
elmbed 23:26f27c462976 193
AntonLS 46:28c29ef61276 194 ta.spin();
AntonLS 46:28c29ef61276 195
elmbed 23:26f27c462976 196 if(last_state != state)
elmbed 23:26f27c462976 197 {
elmbed 23:26f27c462976 198 if(state == ACTIVE_TARGET)
AntonLS 53:c1c3e65b4542 199 SL_DEBUG("State is ACTIVE_TARGET\r\n");
elmbed 23:26f27c462976 200 if(state == IDLE)
AntonLS 53:c1c3e65b4542 201 SL_DEBUG("State is IDLE\r\n");
elmbed 23:26f27c462976 202 if(state == FAIL)
AntonLS 53:c1c3e65b4542 203 SL_DEBUG("State is FAIL\r\n");
elmbed 23:26f27c462976 204 if(state == SUCCESS)
AntonLS 53:c1c3e65b4542 205 SL_DEBUG("State is SUCCESS\r\n");
elmbed 23:26f27c462976 206 }
elmbed 23:26f27c462976 207 last_state = state;
AntonLS 31:a6110950f385 208
elmbed 23:26f27c462976 209 char message = 'n';
elmbed 23:26f27c462976 210 timer = millis() - start;
elmbed 23:26f27c462976 211
elmbed 23:26f27c462976 212 if(ta.recieve(m_in))
elmbed 23:26f27c462976 213 {
elmbed 28:8e74ddc4f70f 214 //ta.beep(1000);
elmbed 28:8e74ddc4f70f 215
elmbed 23:26f27c462976 216 message = m_in->command;
elmbed 23:26f27c462976 217 switch(m_in->command)
elmbed 23:26f27c462976 218 {
elmbed 23:26f27c462976 219 case 't':
AntonLS 52:060fdec99780 220 timeout = m_in->value;
elmbed 23:26f27c462976 221 //serial.printf("timeout: ");
elmbed 23:26f27c462976 222 //serial.printf("%d\n",timeout);
elmbed 23:26f27c462976 223 break;
elmbed 23:26f27c462976 224 case 'm':
elmbed 23:26f27c462976 225 //serial.printf("config bits: ");
elmbed 23:26f27c462976 226 mask = m_in->value;
elmbed 23:26f27c462976 227 ta.setMask(mask);// & LIGHTS);
elmbed 23:26f27c462976 228 //serial.printf("%s\n",byte_to_binary(mask));
elmbed 23:26f27c462976 229 fakeout = mask & FAKEOUT;
elmbed 23:26f27c462976 230
elmbed 23:26f27c462976 231 //if(fakeout)
elmbed 23:26f27c462976 232 // serial.printf("fakeout!");
elmbed 23:26f27c462976 233
elmbed 23:26f27c462976 234 fail_quick = mask & FAIL_QUICK;
elmbed 23:26f27c462976 235 break;
elmbed 23:26f27c462976 236 default: break;
elmbed 23:26f27c462976 237 }
elmbed 23:26f27c462976 238 }
elmbed 23:26f27c462976 239
elmbed 23:26f27c462976 240 if(message == 'x')
elmbed 23:26f27c462976 241 {
AntonLS 46:28c29ef61276 242 ta.resetTouch();
elmbed 23:26f27c462976 243 }
elmbed 23:26f27c462976 244
elmbed 23:26f27c462976 245 if(message == 'f')
elmbed 23:26f27c462976 246 { // Fail
elmbed 23:26f27c462976 247 //serial.printf("Fail!\n");
AntonLS 53:c1c3e65b4542 248 SL_DEBUG("FAIL\r\n");
AntonLS 46:28c29ef61276 249 /// ta.post_color(fail_colour);
AntonLS 46:28c29ef61276 250 ta.pulse(25,200,3000,fail_colour);
elmbed 23:26f27c462976 251 state = FAIL;
elmbed 23:26f27c462976 252 }
elmbed 23:26f27c462976 253
elmbed 23:26f27c462976 254 if(message == 's')
elmbed 23:26f27c462976 255 { // Success
elmbed 23:26f27c462976 256 //serial.printf("Success!\n");
AntonLS 52:060fdec99780 257 ta.post_color(success_colour);
elmbed 23:26f27c462976 258 ta.beep(1500);
elmbed 23:26f27c462976 259 state = SUCCESS;
elmbed 23:26f27c462976 260 }
elmbed 23:26f27c462976 261
elmbed 23:26f27c462976 262 if(message == 'g')
elmbed 23:26f27c462976 263 { // This cone is the active target, GO!
elmbed 23:26f27c462976 264 start = millis();
elmbed 23:26f27c462976 265 warning = false;
elmbed 23:26f27c462976 266 penalty = false;
AntonLS 46:28c29ef61276 267 /// ta.post_color(active_colour);
AntonLS 46:28c29ef61276 268 ta.pulse(50,750,~0L,active_colour);
elmbed 23:26f27c462976 269 state = ACTIVE_TARGET;
elmbed 23:26f27c462976 270 //serial.printf("fakeout, fail_quick\n");
elmbed 23:26f27c462976 271 //serial.printf("%d",fakeout);
elmbed 23:26f27c462976 272 //serial.printf(", ");
elmbed 23:26f27c462976 273 //serial.printf("%d\n",fail_quick);
elmbed 23:26f27c462976 274 }
elmbed 23:26f27c462976 275
elmbed 23:26f27c462976 276 if(message == 'q')
elmbed 23:26f27c462976 277 { // Quit
AntonLS 53:c1c3e65b4542 278 SL_DEBUG("Clear!\r\n");
elmbed 23:26f27c462976 279 ta.pulse_off();
AntonLS 52:060fdec99780 280 // ta.mask_color(idle_colour);
elmbed 23:26f27c462976 281 state = IDLE;
elmbed 23:26f27c462976 282 }
elmbed 23:26f27c462976 283
elmbed 23:26f27c462976 284 if(message != 'n')
elmbed 23:26f27c462976 285 {
elmbed 23:26f27c462976 286 //serial.printf("%d",message);
elmbed 23:26f27c462976 287 //serial.printf(", ");
elmbed 23:26f27c462976 288 //serial.printf("%d\n",m_in->value);
elmbed 23:26f27c462976 289 }
elmbed 23:26f27c462976 290
elmbed 23:26f27c462976 291 if(message == 'u')
elmbed 23:26f27c462976 292 { // powerup noise
elmbed 23:26f27c462976 293 ta.powerup(m_in->value);
elmbed 23:26f27c462976 294 }
elmbed 23:26f27c462976 295
elmbed 23:26f27c462976 296 if(message == 'z')
elmbed 23:26f27c462976 297 {
elmbed 23:26f27c462976 298 m->value = m_in->value;
elmbed 23:26f27c462976 299 m->command = 'z';
elmbed 28:8e74ddc4f70f 300 m->cone = 1;
AntonLS 67:5650f461722a 301 //// ta.send(m);
AntonLS 67:5650f461722a 302 ta.send_immediate(m);
elmbed 23:26f27c462976 303 }
elmbed 23:26f27c462976 304
elmbed 23:26f27c462976 305 timer = millis() - start;
elmbed 23:26f27c462976 306
elmbed 23:26f27c462976 307 switch(state)
elmbed 23:26f27c462976 308 {
elmbed 23:26f27c462976 309 case ACTIVE_TARGET:
elmbed 23:26f27c462976 310 if(ta.activated() || ((timer > timeout) && (fakeout)))
elmbed 23:26f27c462976 311 {
elmbed 23:26f27c462976 312 m->command = 'd';
elmbed 23:26f27c462976 313 m->cone = CONTROL_CONE;
elmbed 23:26f27c462976 314 ta.send(m);
AntonLS 46:28c29ef61276 315 /// ta.post_color(success_colour);
elmbed 23:26f27c462976 316 ta.pulse_off();
elmbed 23:26f27c462976 317 state = IDLE;
elmbed 23:26f27c462976 318 //serial.printf("Done!\n");
elmbed 23:26f27c462976 319 }
elmbed 23:26f27c462976 320 else if(timer > timeout && !penalty)
elmbed 23:26f27c462976 321 {
AntonLS 53:c1c3e65b4542 322 SL_DEBUG("PEN\r\n");
elmbed 23:26f27c462976 323 //serial.printf("Penalty!\n");
elmbed 23:26f27c462976 324 penalty = true;
AntonLS 66:18c214707b0c 325 ta.pulse(50,600,~0L,pen_colour);
AntonLS 46:28c29ef61276 326 /// ta.post_color(pen_colour);
elmbed 23:26f27c462976 327 }
elmbed 23:26f27c462976 328 else if(timer > ((timeout*3)/4) && !warning)
elmbed 23:26f27c462976 329 {
AntonLS 53:c1c3e65b4542 330 SL_DEBUG("WARN\r\n");
elmbed 23:26f27c462976 331 //serial.printf("Warning!\n");
elmbed 23:26f27c462976 332 warning = true;
AntonLS 66:18c214707b0c 333 ta.pulse(50,750,~0L,warn_colour);
AntonLS 46:28c29ef61276 334 /// ta.post_color(warn_colour);
elmbed 23:26f27c462976 335 }
elmbed 23:26f27c462976 336 break;
elmbed 23:26f27c462976 337 case IDLE:
AntonLS 52:060fdec99780 338 bool act = ta.activated();
AntonLS 54:2878d62714d6 339 if( ta.batteryLow && !ta.isPulsing() ) // Temporary feature until batt-low-to-and-in-app.
AntonLS 54:2878d62714d6 340 { // Note: There's no in-a-run slave cone state--Can trigger during a run.
AntonLS 54:2878d62714d6 341 ta.pulse( 75, 500, 1000L, batt_colour );
AntonLS 54:2878d62714d6 342 ta.batteryLow = false;
AntonLS 54:2878d62714d6 343
AntonLS 54:2878d62714d6 344 } else if( !ta.isPulsing() )
AntonLS 54:2878d62714d6 345 ta.post_color(act?touch_colour:idle_colour);
elmbed 23:26f27c462976 346 break;
elmbed 23:26f27c462976 347 default:
elmbed 23:26f27c462976 348 break;
elmbed 23:26f27c462976 349 }
elmbed 23:26f27c462976 350 }
elmbed 23:26f27c462976 351
elmbed 23:26f27c462976 352 static void master_loop()
elmbed 23:26f27c462976 353 {
elmbed 23:26f27c462976 354 static Mode_t last_mode = mode;
elmbed 28:8e74ddc4f70f 355 static int counter = 0;
elmbed 23:26f27c462976 356
elmbed 23:26f27c462976 357 if (last_mode != mode)
elmbed 23:26f27c462976 358 {
elmbed 61:dd7002ceea96 359 if (mode == FREEFORM_M)
AntonLS 52:060fdec99780 360 {
AntonLS 48:4c9551c826e9 361 srnd( rndHW() );
elmbed 38:76e49d045a3b 362 writeToPhone("RR.\r\n");
AntonLS 52:060fdec99780 363 }
elmbed 61:dd7002ceea96 364 if (mode == PATTERN_M)
elmbed 38:76e49d045a3b 365 writeToPhone("SP.\r\n");
elmbed 23:26f27c462976 366 }
elmbed 23:26f27c462976 367
elmbed 23:26f27c462976 368 last_mode = mode;
elmbed 23:26f27c462976 369
elmbed 23:26f27c462976 370 ta.spin();
elmbed 23:26f27c462976 371 //spinButtons();
elmbed 38:76e49d045a3b 372 //if((logging || micros() < dist_timeout) && ta.recieve(m_in))
elmbed 38:76e49d045a3b 373 // writeToPhone("CMD: %c",m_in->command);
elmbed 38:76e49d045a3b 374 // else
elmbed 23:26f27c462976 375 spin();
elmbed 23:26f27c462976 376 }
elmbed 17:d8b901d791fd 377
elmbed 17:d8b901d791fd 378 void loop()
elmbed 17:d8b901d791fd 379 {
elmbed 61:dd7002ceea96 380 if (is_master)
elmbed 61:dd7002ceea96 381 {
elmbed 61:dd7002ceea96 382 master_loop();
elmbed 61:dd7002ceea96 383 }
elmbed 61:dd7002ceea96 384 else
elmbed 61:dd7002ceea96 385 {
elmbed 61:dd7002ceea96 386 slave_loop();
elmbed 61:dd7002ceea96 387 }
elmbed 17:d8b901d791fd 388 }
elmbed 17:d8b901d791fd 389
elmbed 23:26f27c462976 390 static void getNext()
elmbed 17:d8b901d791fd 391 {
elmbed 61:dd7002ceea96 392 if(mode == FREEFORM_M)
elmbed 17:d8b901d791fd 393 {
elmbed 40:dec5270e03e9 394 active_cone = getRandomCone();
AntonLS 52:060fdec99780 395
elmbed 60:d1fad57e8bfb 396 if(Dbg)
elmbed 60:d1fad57e8bfb 397 {
elmbed 60:d1fad57e8bfb 398 writeToPhone("GN_AC: %d\r\n", active_cone);
elmbed 60:d1fad57e8bfb 399 }
elmbed 60:d1fad57e8bfb 400
elmbed 17:d8b901d791fd 401 mask = 0x07;
elmbed 17:d8b901d791fd 402 ta.setMask(mask & LIGHTS);
AntonLS 46:28c29ef61276 403 timeout = ~0;
elmbed 38:76e49d045a3b 404
elmbed 17:d8b901d791fd 405 return;
elmbed 17:d8b901d791fd 406 }
elmbed 17:d8b901d791fd 407
elmbed 17:d8b901d791fd 408 active_cone = cones[index];
elmbed 17:d8b901d791fd 409 mask = masks[index];
elmbed 17:d8b901d791fd 410 fakeout = mask & FAKEOUT;
elmbed 17:d8b901d791fd 411 fail_quick = mask & FAIL_QUICK;
elmbed 17:d8b901d791fd 412 timeout = times[index];
elmbed 17:d8b901d791fd 413 index++;
AntonLS 66:18c214707b0c 414
AntonLS 66:18c214707b0c 415 if( Dbg ) writeToPhone("%d %x %d\r\n", active_cone, mask, timeout);
AntonLS 66:18c214707b0c 416
elmbed 58:fb2198ceb412 417 writeToPhone("Next cone is %u\r\n", active_cone); // PROTOCOL
elmbed 17:d8b901d791fd 418 }
elmbed 61:dd7002ceea96 419
elmbed 23:26f27c462976 420 static void spin()
elmbed 17:d8b901d791fd 421 {
elmbed 17:d8b901d791fd 422 static patternState_t last_state = START_P;
elmbed 17:d8b901d791fd 423 static uint8_t last_cone = 255;
elmbed 17:d8b901d791fd 424 static unsigned long start;
elmbed 17:d8b901d791fd 425 static unsigned long timer;
elmbed 17:d8b901d791fd 426 static bool first; // first should be true when we first enter a state (even if we just exited the same state)
elmbed 17:d8b901d791fd 427 char command = 'n';
elmbed 17:d8b901d791fd 428 unsigned long value = 0;
elmbed 17:d8b901d791fd 429
elmbed 17:d8b901d791fd 430 m_in->command = 0;
elmbed 17:d8b901d791fd 431 m_in->value = 0;
elmbed 17:d8b901d791fd 432 m_in->cone = 0;
elmbed 17:d8b901d791fd 433
elmbed 17:d8b901d791fd 434 if(ta.recieve(m_in))
elmbed 17:d8b901d791fd 435 {
elmbed 60:d1fad57e8bfb 436 if(Dbg)
elmbed 60:d1fad57e8bfb 437 {
elmbed 60:d1fad57e8bfb 438 writeToPhone("SR: %d '%c'\r\n", m_in->cone, m_in->command);
elmbed 60:d1fad57e8bfb 439 }
elmbed 60:d1fad57e8bfb 440
elmbed 17:d8b901d791fd 441 command = m_in->command;
elmbed 17:d8b901d791fd 442 value = m_in->value;
elmbed 17:d8b901d791fd 443 }
elmbed 17:d8b901d791fd 444
elmbed 17:d8b901d791fd 445 first = false;
elmbed 17:d8b901d791fd 446
elmbed 17:d8b901d791fd 447 if(last_state != state_p || new_state)
elmbed 17:d8b901d791fd 448 {
elmbed 17:d8b901d791fd 449 if(state_p == START_P)
AntonLS 39:b1f864b71318 450 writeToPhone("State is START\r\n"); // PROTOCOL
elmbed 17:d8b901d791fd 451 if(state_p == WAITING_P)
AntonLS 39:b1f864b71318 452 writeToPhone("State is WAITING\r\n"); // PROTOCOL
elmbed 17:d8b901d791fd 453 if(state_p == ACTIVE_TARGET_P)
AntonLS 39:b1f864b71318 454 writeToPhone("State is ACTIVE_TARGET\r\n"); // PROTOCOL
elmbed 17:d8b901d791fd 455 if(state_p == IDLE_P)
AntonLS 39:b1f864b71318 456 writeToPhone("State is IDLE\r\n"); // PROTOCOL
elmbed 17:d8b901d791fd 457 if(state_p == FAIL_P)
AntonLS 39:b1f864b71318 458 writeToPhone("State is FAIL\r\n"); // PROTOCOL
elmbed 17:d8b901d791fd 459 if(state_p == SUCCESS_P)
AntonLS 39:b1f864b71318 460 writeToPhone("State is SUCCESS\r\n"); // PROTOCOL
elmbed 17:d8b901d791fd 461
elmbed 17:d8b901d791fd 462 first = true;
elmbed 17:d8b901d791fd 463 new_state = false;
elmbed 17:d8b901d791fd 464 }
elmbed 17:d8b901d791fd 465
elmbed 17:d8b901d791fd 466 last_state = state_p;
elmbed 17:d8b901d791fd 467 last_cone = active_cone;
elmbed 17:d8b901d791fd 468
elmbed 17:d8b901d791fd 469 timer = millis() - start;
elmbed 17:d8b901d791fd 470
elmbed 17:d8b901d791fd 471 switch(state_p)
elmbed 17:d8b901d791fd 472 {
elmbed 17:d8b901d791fd 473 case IDLE_P:
AntonLS 30:c60b0d52b067 474 ta.setMask( DEFTOUCHMASK );
elmbed 17:d8b901d791fd 475 if(!in_menu)
AntonLS 54:2878d62714d6 476 {
AntonLS 54:2878d62714d6 477 if( ta.batteryLow && !ta.isPulsing() ) // Temporary feature until batt-low-in-app.
AntonLS 54:2878d62714d6 478 {
AntonLS 54:2878d62714d6 479 ta.pulse( 75, 500, 1000L, batt_colour );
AntonLS 54:2878d62714d6 480 ta.batteryLow = false;
AntonLS 54:2878d62714d6 481
AntonLS 54:2878d62714d6 482 } else if( !ta.isPulsing() )
AntonLS 54:2878d62714d6 483 ta.post_color((ta.activated())?touch_colour:idle_colour);
AntonLS 54:2878d62714d6 484 }
elmbed 17:d8b901d791fd 485 break;
elmbed 17:d8b901d791fd 486
elmbed 17:d8b901d791fd 487 case START_P:
elmbed 38:76e49d045a3b 488 clearCones();
elmbed 17:d8b901d791fd 489 tag_start = false;
elmbed 38:76e49d045a3b 490 ta.post_color(idle_colour);
elmbed 17:d8b901d791fd 491 index = 0;
elmbed 17:d8b901d791fd 492 getNext();
elmbed 17:d8b901d791fd 493
elmbed 17:d8b901d791fd 494 if(timeout == 0)
elmbed 17:d8b901d791fd 495 { // timeout of 0 means wait indefinitely for the first cone to be activated, then start the rest of the sequence
elmbed 17:d8b901d791fd 496 timeout = ~0;
elmbed 17:d8b901d791fd 497 tag_start = true;
AntonLS 39:b1f864b71318 498 // DEBUG("Activate cone "); // May use this again in future.
AntonLS 39:b1f864b71318 499 // DEBUG("%d",active_cone);
AntonLS 39:b1f864b71318 500 // DEBUG(" to start.\n");
AntonLS 66:18c214707b0c 501 if( Dbg ) writeToPhone("ACS: %d\r\n", active_cone);
elmbed 17:d8b901d791fd 502 }
elmbed 17:d8b901d791fd 503
elmbed 17:d8b901d791fd 504 start = millis();
elmbed 17:d8b901d791fd 505 state_p = stateFromCone(active_cone);
elmbed 17:d8b901d791fd 506 if(active_cone == 0)
elmbed 17:d8b901d791fd 507 { // in this case stateFromCone returns SUCCESS_P, but really there was no course sequence
elmbed 17:d8b901d791fd 508 DEBUG("\n");
elmbed 17:d8b901d791fd 509 DEBUG("Empty course sequence!\n");
elmbed 38:76e49d045a3b 510 writeToPhone("ECS\r\n");
elmbed 17:d8b901d791fd 511 ta.post_color(0x0000FF);
elmbed 17:d8b901d791fd 512 state_p = IDLE_P;
elmbed 17:d8b901d791fd 513 break;
elmbed 17:d8b901d791fd 514 }
elmbed 17:d8b901d791fd 515 break;
elmbed 17:d8b901d791fd 516
elmbed 17:d8b901d791fd 517 case WAITING_P:
elmbed 17:d8b901d791fd 518 if(first)
elmbed 17:d8b901d791fd 519 {
elmbed 17:d8b901d791fd 520 m->command = 'm';
elmbed 17:d8b901d791fd 521 m->value = mask;
elmbed 17:d8b901d791fd 522 m->cone = active_cone;
elmbed 17:d8b901d791fd 523 ta.send(m);
AntonLS 52:060fdec99780 524
AntonLS 67:5650f461722a 525 //// wait_ms(50);
AntonLS 52:060fdec99780 526 /// wait_ms(300);
elmbed 17:d8b901d791fd 527 m->command = 't';
elmbed 17:d8b901d791fd 528 m->value = (uint32_t)timeout;
elmbed 17:d8b901d791fd 529 ta.send(m);
AntonLS 52:060fdec99780 530
AntonLS 67:5650f461722a 531 //// wait_ms(50);
AntonLS 52:060fdec99780 532 /// wait_ms(300);
elmbed 17:d8b901d791fd 533 m->command = 'g';
elmbed 17:d8b901d791fd 534 ta.send(m);
elmbed 17:d8b901d791fd 535
elmbed 60:d1fad57e8bfb 536 if(Dbg)
elmbed 60:d1fad57e8bfb 537 {
elmbed 60:d1fad57e8bfb 538 writeToPhone("ACW: %d\r\n", active_cone);
elmbed 60:d1fad57e8bfb 539 }
elmbed 17:d8b901d791fd 540 }
elmbed 17:d8b901d791fd 541
elmbed 38:76e49d045a3b 542 ta.post_color(( ta.activated())?touch_colour:idle_colour);
elmbed 17:d8b901d791fd 543
elmbed 17:d8b901d791fd 544 DEBUG("Waiting: %d %d %c\n", m_in->cone, active_cone, command);
elmbed 17:d8b901d791fd 545
elmbed 17:d8b901d791fd 546 if((m_in->cone == active_cone && command == 'd' ) || ((timer >= timeout) && fakeout))
elmbed 17:d8b901d791fd 547 {
elmbed 17:d8b901d791fd 548 if((timer >= timeout) && !fakeout)
elmbed 17:d8b901d791fd 549 {
AntonLS 52:060fdec99780 550 writeToPhone("Timesplit penalty! "); // PROTOCOL
elmbed 17:d8b901d791fd 551 }
AntonLS 52:060fdec99780 552 printSplit(timer); // PROTOCOL
elmbed 17:d8b901d791fd 553 getNext();
elmbed 17:d8b901d791fd 554 start = millis();
elmbed 17:d8b901d791fd 555
elmbed 17:d8b901d791fd 556 state_p = stateFromCone(active_cone);
elmbed 17:d8b901d791fd 557
elmbed 17:d8b901d791fd 558 if(state_p == WAITING_P)
elmbed 17:d8b901d791fd 559 {
elmbed 60:d1fad57e8bfb 560 if(Dbg)
elmbed 60:d1fad57e8bfb 561 {
elmbed 60:d1fad57e8bfb 562 writeToPhone("NSW\r\n");
elmbed 60:d1fad57e8bfb 563 }
elmbed 60:d1fad57e8bfb 564
elmbed 17:d8b901d791fd 565 new_state = true;
elmbed 60:d1fad57e8bfb 566 }
elmbed 17:d8b901d791fd 567 }
elmbed 61:dd7002ceea96 568 else if(~timeout != 0 && mode == PATTERN_M && timer >= (timeout + ((fail_quick)?0:GRACE_PERIOD)))
elmbed 17:d8b901d791fd 569 {
elmbed 60:d1fad57e8bfb 570 if(Dbg)
elmbed 60:d1fad57e8bfb 571 {
elmbed 60:d1fad57e8bfb 572 writeToPhone("FW\r\n");
elmbed 60:d1fad57e8bfb 573 }
elmbed 17:d8b901d791fd 574 state_p = FAIL_P;
elmbed 17:d8b901d791fd 575 }
elmbed 17:d8b901d791fd 576 break;
elmbed 17:d8b901d791fd 577
elmbed 17:d8b901d791fd 578 case ACTIVE_TARGET_P:
elmbed 17:d8b901d791fd 579 if(first)
elmbed 17:d8b901d791fd 580 {
elmbed 17:d8b901d791fd 581 ta.setMask(mask);
elmbed 17:d8b901d791fd 582
elmbed 17:d8b901d791fd 583 warning = false;
elmbed 17:d8b901d791fd 584 penalty = false;
AntonLS 46:28c29ef61276 585 /// ta.post_color(active_colour);
AntonLS 46:28c29ef61276 586 ta.pulse(50,750,~0L,active_colour);
AntonLS 46:28c29ef61276 587 //if(!(mask & SILENT))ta.pulse(50,750,~0L,active_colour);
elmbed 17:d8b901d791fd 588 }
elmbed 17:d8b901d791fd 589 if(timer >= timeout)
elmbed 17:d8b901d791fd 590 {
elmbed 17:d8b901d791fd 591 if(!penalty)
elmbed 17:d8b901d791fd 592 {
AntonLS 46:28c29ef61276 593 /// ta.post_color(pen_colour);
AntonLS 46:28c29ef61276 594 ta.pulse(50,325,~0L,pen_colour);
elmbed 17:d8b901d791fd 595
elmbed 17:d8b901d791fd 596 penalty = true;
elmbed 17:d8b901d791fd 597 }
elmbed 38:76e49d045a3b 598 ta.post_color(pen_colour);
elmbed 17:d8b901d791fd 599 }
elmbed 17:d8b901d791fd 600 else if(timer > ((timeout*3)/4) && !warning)
elmbed 17:d8b901d791fd 601 {
elmbed 17:d8b901d791fd 602 warning = true;
AntonLS 46:28c29ef61276 603 /// ta.post_color(warn_colour);
AntonLS 46:28c29ef61276 604 ta.pulse(50,750,~0L,warn_colour);
elmbed 17:d8b901d791fd 605 }
elmbed 17:d8b901d791fd 606
elmbed 17:d8b901d791fd 607 if(ta.activated() || ((timer >= timeout) && fakeout))
elmbed 17:d8b901d791fd 608 {
elmbed 17:d8b901d791fd 609 if((timer >= timeout) && !fakeout)
AntonLS 52:060fdec99780 610 writeToPhone("Timesplit penalty! "); // PROTOCOL
AntonLS 52:060fdec99780 611 printSplit(timer); // PROTOCOL
AntonLS 52:060fdec99780 612
elmbed 38:76e49d045a3b 613 ta.post_color(success_colour);
elmbed 17:d8b901d791fd 614 getNext();
elmbed 17:d8b901d791fd 615 start = millis();
elmbed 17:d8b901d791fd 616 state_p = stateFromCone(active_cone);
elmbed 17:d8b901d791fd 617
elmbed 17:d8b901d791fd 618 if(state_p == ACTIVE_TARGET_P)
elmbed 17:d8b901d791fd 619 new_state = true;
elmbed 17:d8b901d791fd 620 ta.pulse_off();
elmbed 17:d8b901d791fd 621
elmbed 17:d8b901d791fd 622 }
elmbed 61:dd7002ceea96 623 else if(~timeout != 0 && mode == PATTERN_M && timer >= (timeout + ((fail_quick)?0:GRACE_PERIOD)))
elmbed 17:d8b901d791fd 624 {
elmbed 17:d8b901d791fd 625 state_p = FAIL_P;
elmbed 17:d8b901d791fd 626 ta.pulse_off();
elmbed 17:d8b901d791fd 627 }
elmbed 17:d8b901d791fd 628 //DEBUG.println(timeout + ((fail_quick)?0:GRACE_PERIOD));
elmbed 17:d8b901d791fd 629 //DEBUG.println(timeout);
elmbed 17:d8b901d791fd 630
elmbed 17:d8b901d791fd 631 break;
elmbed 17:d8b901d791fd 632
elmbed 17:d8b901d791fd 633 case FAIL_P:
elmbed 17:d8b901d791fd 634 if(first)
elmbed 17:d8b901d791fd 635 {
elmbed 17:d8b901d791fd 636 start = millis();
elmbed 17:d8b901d791fd 637 DEBUG("\n");
elmbed 17:d8b901d791fd 638 DEBUG("Timeout\n");
elmbed 17:d8b901d791fd 639 //ta.post_color();
AntonLS 46:28c29ef61276 640 ta.pulse(25,200,3000,fail_colour);
AntonLS 46:28c29ef61276 641 /// ta.post_color(fail_colour);
elmbed 17:d8b901d791fd 642
elmbed 17:d8b901d791fd 643 failCones();
elmbed 17:d8b901d791fd 644 //ta.fail();
elmbed 17:d8b901d791fd 645 }
elmbed 17:d8b901d791fd 646 else if(timer > 3000)
elmbed 17:d8b901d791fd 647 {
elmbed 17:d8b901d791fd 648 DEBUG("Clear!\n");
elmbed 17:d8b901d791fd 649 state_p = IDLE_P;
elmbed 17:d8b901d791fd 650 clearCones();
elmbed 17:d8b901d791fd 651 }
elmbed 17:d8b901d791fd 652 break;
elmbed 17:d8b901d791fd 653 case SUCCESS_P:
elmbed 17:d8b901d791fd 654 if(first)
elmbed 17:d8b901d791fd 655 {
elmbed 17:d8b901d791fd 656 start = millis();
elmbed 17:d8b901d791fd 657 DEBUG("\n");
elmbed 17:d8b901d791fd 658 DEBUG("Done!\n");
elmbed 38:76e49d045a3b 659 ta.post_color(success_colour);
elmbed 17:d8b901d791fd 660 ta.beep(1500);
elmbed 17:d8b901d791fd 661 successCones();
elmbed 17:d8b901d791fd 662 //ta.success();
elmbed 17:d8b901d791fd 663 }
elmbed 17:d8b901d791fd 664 else if(timer > 1500)
elmbed 17:d8b901d791fd 665 {
elmbed 17:d8b901d791fd 666 DEBUG("Clear!\n");
elmbed 17:d8b901d791fd 667 state_p = IDLE_P;
elmbed 17:d8b901d791fd 668 clearCones();
elmbed 17:d8b901d791fd 669 }
elmbed 17:d8b901d791fd 670 break;
elmbed 17:d8b901d791fd 671
elmbed 17:d8b901d791fd 672 default:
elmbed 38:76e49d045a3b 673 ta.post_color(idle_colour);
elmbed 17:d8b901d791fd 674 break;
elmbed 17:d8b901d791fd 675 }
elmbed 17:d8b901d791fd 676 }
elmbed 18:affef3a7db2a 677
elmbed 17:d8b901d791fd 678 void getRadioInput(char *ibuffer, int size)
elmbed 17:d8b901d791fd 679 {
elmbed 17:d8b901d791fd 680 static int i = 0;
elmbed 17:d8b901d791fd 681 int buffer_counter = 0;
elmbed 17:d8b901d791fd 682 static char parameter = '_';
elmbed 17:d8b901d791fd 683 static char buffer[MAX_LEN + 1];
elmbed 17:d8b901d791fd 684 int value = 0;
elmbed 17:d8b901d791fd 685 char *endp = NULL;
AntonLS 45:1eb335c00cb2 686
elmbed 17:d8b901d791fd 687 // listen for commands coming over bluetooth
elmbed 17:d8b901d791fd 688 while (buffer_counter < size)
elmbed 17:d8b901d791fd 689 {
elmbed 17:d8b901d791fd 690 char ch = ibuffer[buffer_counter++];
elmbed 17:d8b901d791fd 691
elmbed 17:d8b901d791fd 692 if((ch == '\r' || ch == ';' || ch == '\n') && parameter != '_')
elmbed 17:d8b901d791fd 693 {
elmbed 17:d8b901d791fd 694 if(i > 1)
elmbed 17:d8b901d791fd 695 {
AntonLS 41:dee3fd34e37a 696 buffer[i-1] = 0;
elmbed 17:d8b901d791fd 697 if(parameter == 'l')
elmbed 17:d8b901d791fd 698 value = strtoul(buffer, &endp, 2);
AntonLS 41:dee3fd34e37a 699 else if(parameter == 'B')
AntonLS 41:dee3fd34e37a 700 value = strtoul(buffer, &endp, 16);
AntonLS 41:dee3fd34e37a 701 else
AntonLS 41:dee3fd34e37a 702 value = atoi(buffer);
elmbed 17:d8b901d791fd 703 }
elmbed 18:affef3a7db2a 704
elmbed 62:9b34dc1b265d 705 if (is_master)
elmbed 62:9b34dc1b265d 706 {
elmbed 62:9b34dc1b265d 707 interpret_master(parameter, value);
elmbed 62:9b34dc1b265d 708 }
elmbed 62:9b34dc1b265d 709 else
elmbed 62:9b34dc1b265d 710 {
elmbed 62:9b34dc1b265d 711 interpret_slave(parameter, value);
elmbed 62:9b34dc1b265d 712 }
elmbed 62:9b34dc1b265d 713
elmbed 17:d8b901d791fd 714 DEBUG("After interp: '%c'\r\n", parameter);
elmbed 17:d8b901d791fd 715 parameter = '_';
elmbed 17:d8b901d791fd 716 buffer[0] = 0;
elmbed 17:d8b901d791fd 717 i=0;
elmbed 17:d8b901d791fd 718 }
elmbed 17:d8b901d791fd 719 else
elmbed 17:d8b901d791fd 720 {
elmbed 17:d8b901d791fd 721 if(i==0)
elmbed 17:d8b901d791fd 722 parameter = ch;
elmbed 17:d8b901d791fd 723 else
elmbed 17:d8b901d791fd 724 buffer[i-1] = ch;
elmbed 17:d8b901d791fd 725 i++;
elmbed 17:d8b901d791fd 726 }
elmbed 17:d8b901d791fd 727
elmbed 17:d8b901d791fd 728 if(ch == '_' || ch == '\r' || ch == ';' || ch == '\n')
elmbed 17:d8b901d791fd 729 {
elmbed 17:d8b901d791fd 730 parameter = '_';
elmbed 17:d8b901d791fd 731 buffer[0] = 0;
elmbed 17:d8b901d791fd 732 i=0;
elmbed 17:d8b901d791fd 733 }
elmbed 17:d8b901d791fd 734 }
elmbed 17:d8b901d791fd 735 }
elmbed 17:d8b901d791fd 736
elmbed 62:9b34dc1b265d 737 static void interpret_slave(char parameter, int value)
elmbed 62:9b34dc1b265d 738 {
elmbed 62:9b34dc1b265d 739 switch(parameter)
elmbed 62:9b34dc1b265d 740 {
elmbed 62:9b34dc1b265d 741 case 'M':
elmbed 62:9b34dc1b265d 742 datastore_set_master();
AntonLS 66:18c214707b0c 743 SL_DEBUG("Power Cycle\r\n");
elmbed 62:9b34dc1b265d 744 break;
elmbed 62:9b34dc1b265d 745 case 's':
AntonLS 66:18c214707b0c 746 SL_DEBUG("MS: %d\r\n", datastore_is_master());
AntonLS 66:18c214707b0c 747 SL_DEBUG("RP: %d\r\n", read_params());
elmbed 62:9b34dc1b265d 748 break;
elmbed 62:9b34dc1b265d 749 }
elmbed 62:9b34dc1b265d 750 }
elmbed 62:9b34dc1b265d 751
elmbed 62:9b34dc1b265d 752 static void interpret_master(char parameter, int value)
elmbed 17:d8b901d791fd 753 {
elmbed 18:affef3a7db2a 754 int remainder;
elmbed 18:affef3a7db2a 755 uint16_t split;
elmbed 18:affef3a7db2a 756 uint16_t t;
elmbed 18:affef3a7db2a 757 uint8_t c;
elmbed 18:affef3a7db2a 758 uint8_t l;
elmbed 18:affef3a7db2a 759 int last;
elmbed 18:affef3a7db2a 760 int middle;
elmbed 18:affef3a7db2a 761 uint8_t length;
elmbed 18:affef3a7db2a 762 uint8_t offset;
elmbed 18:affef3a7db2a 763 int i;
elmbed 18:affef3a7db2a 764 uint8_t v;
elmbed 18:affef3a7db2a 765 uint16_t val;
elmbed 17:d8b901d791fd 766
elmbed 58:fb2198ceb412 767 DEBUG("data\r\n");
elmbed 58:fb2198ceb412 768
elmbed 17:d8b901d791fd 769 switch(parameter)
elmbed 17:d8b901d791fd 770 {
elmbed 17:d8b901d791fd 771 case 'f':
elmbed 17:d8b901d791fd 772 if(lonely)
elmbed 17:d8b901d791fd 773 {
elmbed 18:affef3a7db2a 774 writeToPhone("Sorry, no other cones detected, please try detecting cones first.\r\n");
elmbed 17:d8b901d791fd 775 break;
elmbed 17:d8b901d791fd 776 }
elmbed 18:affef3a7db2a 777
elmbed 18:affef3a7db2a 778 writeToPhone("Entered freeform\r\n");
elmbed 61:dd7002ceea96 779 mode = FREEFORM_M;
elmbed 17:d8b901d791fd 780 state_p = START_P;
elmbed 17:d8b901d791fd 781 clearCones();
elmbed 18:affef3a7db2a 782 //find_cones();
elmbed 17:d8b901d791fd 783 break;
elmbed 17:d8b901d791fd 784 case 'p':
elmbed 17:d8b901d791fd 785 if(value == 0)
elmbed 17:d8b901d791fd 786 {
elmbed 18:affef3a7db2a 787 writeToPhone("\r\n");
elmbed 18:affef3a7db2a 788 writeToPhone("Running pattern %d\r\n", active_sequence + 1);
elmbed 18:affef3a7db2a 789
elmbed 61:dd7002ceea96 790 mode = PATTERN_M;
elmbed 17:d8b901d791fd 791 state_p = START_P;
elmbed 17:d8b901d791fd 792 active_cone = 0;
elmbed 18:affef3a7db2a 793
elmbed 17:d8b901d791fd 794 clearCones();
elmbed 17:d8b901d791fd 795 }
elmbed 17:d8b901d791fd 796 else
elmbed 17:d8b901d791fd 797 {
elmbed 18:affef3a7db2a 798 writeToPhone("Selected pattern %d\r\n", value);
elmbed 18:affef3a7db2a 799
elmbed 17:d8b901d791fd 800 if(value <= SEQUENCES && value > 0)
elmbed 17:d8b901d791fd 801 {
elmbed 17:d8b901d791fd 802 active_sequence = value - 1;
elmbed 17:d8b901d791fd 803 cones = (uint8_t*)cone_table + (value-1)*STATIONS;
elmbed 17:d8b901d791fd 804 times = (uint16_t*)time_table + (value-1)*STATIONS;
elmbed 17:d8b901d791fd 805 masks = (uint8_t*)mask_table + (value-1)*STATIONS;
elmbed 58:fb2198ceb412 806
elmbed 60:d1fad57e8bfb 807 if (Dbg)
elmbed 58:fb2198ceb412 808 {
elmbed 60:d1fad57e8bfb 809 for (int i = 0; i < STATIONS; ++i)
elmbed 60:d1fad57e8bfb 810 {
elmbed 60:d1fad57e8bfb 811 writeToPhone("PS: %d %x %d\r\n", cones[i], masks[i], times[i]);
elmbed 60:d1fad57e8bfb 812 }
elmbed 58:fb2198ceb412 813 }
elmbed 17:d8b901d791fd 814 }
elmbed 17:d8b901d791fd 815 else
elmbed 17:d8b901d791fd 816 {
AntonLS 41:dee3fd34e37a 817 writeToPhone("This pattern is not available. Please select a value between 1 and %d\r\n", SEQUENCES);
elmbed 17:d8b901d791fd 818 }
elmbed 17:d8b901d791fd 819 }
elmbed 17:d8b901d791fd 820 break;
AntonLS 41:dee3fd34e37a 821 case 'P':
AntonLS 41:dee3fd34e37a 822 if(value != 0)
AntonLS 41:dee3fd34e37a 823 {
AntonLS 41:dee3fd34e37a 824 if(value <= SEQUENCES && value > 0)
AntonLS 41:dee3fd34e37a 825 {
AntonLS 41:dee3fd34e37a 826 active_sequence = value - 1;
AntonLS 41:dee3fd34e37a 827 cones = (uint8_t*)cone_table + (value-1)*STATIONS;
AntonLS 41:dee3fd34e37a 828 times = (uint16_t*)time_table + (value-1)*STATIONS;
AntonLS 41:dee3fd34e37a 829 masks = (uint8_t*)mask_table + (value-1)*STATIONS;
AntonLS 41:dee3fd34e37a 830
AntonLS 41:dee3fd34e37a 831 // Side effect: Also sets current station to 1:
AntonLS 41:dee3fd34e37a 832 station = 1;
AntonLS 41:dee3fd34e37a 833 }
AntonLS 41:dee3fd34e37a 834 else
AntonLS 41:dee3fd34e37a 835 {
AntonLS 41:dee3fd34e37a 836 writeToPhone("Only from 1 to %d\r\n", SEQUENCES);
AntonLS 41:dee3fd34e37a 837 }
AntonLS 41:dee3fd34e37a 838 }
AntonLS 41:dee3fd34e37a 839 else // P; or P0;
AntonLS 41:dee3fd34e37a 840 {
AntonLS 41:dee3fd34e37a 841 writeToPhone("Nothing done\r\n");
AntonLS 41:dee3fd34e37a 842 }
AntonLS 41:dee3fd34e37a 843 break;
elmbed 17:d8b901d791fd 844 case 's':
AntonLS 41:dee3fd34e37a 845 writeToPhone("Selected station %d\r\n", value);
AntonLS 41:dee3fd34e37a 846 case 'S':
elmbed 17:d8b901d791fd 847 station = value;
elmbed 17:d8b901d791fd 848 break;
elmbed 17:d8b901d791fd 849 case 'd':
elmbed 18:affef3a7db2a 850 if(value == 0){
elmbed 17:d8b901d791fd 851 logging = false;
elmbed 17:d8b901d791fd 852 m->value = 0;
elmbed 17:d8b901d791fd 853 dist_timeout = micros() + 2000000;
elmbed 17:d8b901d791fd 854 }
elmbed 18:affef3a7db2a 855 if(value == 1){
elmbed 17:d8b901d791fd 856 logging = true;
elmbed 17:d8b901d791fd 857 m->value = 1;
elmbed 17:d8b901d791fd 858 }
elmbed 17:d8b901d791fd 859 m->command = 'd';
elmbed 17:d8b901d791fd 860 m->cone = TRILAT_CONE;
elmbed 17:d8b901d791fd 861 ta.send(m);
elmbed 18:affef3a7db2a 862 //Serial.print("Sent d");
elmbed 18:affef3a7db2a 863 //Serial.println(value);
elmbed 17:d8b901d791fd 864 break;
elmbed 17:d8b901d791fd 865 case 'c':
AntonLS 41:dee3fd34e37a 866 writeToPhone("Station %d will be cone %d\r\n", station, value);
AntonLS 41:dee3fd34e37a 867 case 'C':
elmbed 17:d8b901d791fd 868 c = value;
elmbed 18:affef3a7db2a 869 if(station <= STATIONS && station > 0)cones[station-1] = c;
elmbed 17:d8b901d791fd 870 break;
elmbed 17:d8b901d791fd 871 case 't':
elmbed 17:d8b901d791fd 872 t = (uint16_t)value;
elmbed 17:d8b901d791fd 873 remainder = t%1000;
AntonLS 19:afcbb425b3cf 874 writeToPhone("Station %d split time is: %d.%03d seconds.\r\n", station, t/1000, remainder);
AntonLS 41:dee3fd34e37a 875 case 'T':
AntonLS 41:dee3fd34e37a 876 t = (uint16_t)value;
AntonLS 41:dee3fd34e37a 877 // remainder = t%1000;
AntonLS 19:afcbb425b3cf 878 /// if(remainder < 100)writeToPhone("0");
AntonLS 19:afcbb425b3cf 879 /// if(remainder < 10)writeToPhone("0");
AntonLS 19:afcbb425b3cf 880 /// writeToPhone("%d seconds.\r\n",remainder);
elmbed 18:affef3a7db2a 881 if(station <= STATIONS && station > 0)times[station-1] = t;
elmbed 17:d8b901d791fd 882 break;
elmbed 17:d8b901d791fd 883 case 'l':
AntonLS 41:dee3fd34e37a 884 // l = 0;
elmbed 17:d8b901d791fd 885 l = (uint8_t)value;
elmbed 17:d8b901d791fd 886 masks[station-1] = l;
AntonLS 19:afcbb425b3cf 887 writeToPhone( "Station %d config bits: ", station );
AntonLS 19:afcbb425b3cf 888 writeBitsToPhone( l );
AntonLS 19:afcbb425b3cf 889 writeToPhone( "\r\n" );
elmbed 17:d8b901d791fd 890 break;
AntonLS 41:dee3fd34e37a 891 case 'B': // After setting bits, echo back station data.
AntonLS 41:dee3fd34e37a 892 l = (uint8_t)value;
AntonLS 41:dee3fd34e37a 893 masks[station-1] = l;
AntonLS 45:1eb335c00cb2 894 writeToPhone( "%c%02u;C%02u;T%05u;B%02x\r\n", (1==station) ? 'P' : 'S',
AntonLS 41:dee3fd34e37a 895 (1==station) ? active_sequence +1 : station,
AntonLS 41:dee3fd34e37a 896 cones[station-1], times[station-1], l );
AntonLS 41:dee3fd34e37a 897 break;
elmbed 17:d8b901d791fd 898 case 'q':
elmbed 17:d8b901d791fd 899 state_p = IDLE_P;
elmbed 17:d8b901d791fd 900 new_state = true; // force state reporting, even if we're already in IDLE
AntonLS 46:28c29ef61276 901 ta.pulse_off(); /// //
AntonLS 46:28c29ef61276 902 clearCones(); /// //
elmbed 17:d8b901d791fd 903 break;
elmbed 17:d8b901d791fd 904 case 'r':
elmbed 18:affef3a7db2a 905 //Serial.println(F(""));
AntonLS 39:b1f864b71318 906 // writeToPhone("Current pattern is %d:\r\n", active_sequence+1);
AntonLS 39:b1f864b71318 907 writeToPhone("Pattern is %d:\r\n", active_sequence+1); // PROTOCOL optimization
elmbed 18:affef3a7db2a 908 for(int i=0; i<STATIONS; i++){
AntonLS 39:b1f864b71318 909 // writeToPhone("Station %d: cone %d, ", i+1, cones[i]);
AntonLS 45:1eb335c00cb2 910 writeToPhone("S%02u,C%02u", i+1, cones[i]); // PROTOCOL optimization
elmbed 17:d8b901d791fd 911 split = times[i];
AntonLS 39:b1f864b71318 912 // printMsAsSeconds(split); // Removed for PROTOCOL optimization
elmbed 18:affef3a7db2a 913 //Serial.print(F("s timeout, lights: "));
AntonLS 39:b1f864b71318 914 // writeToPhone("s timeout, config bits: ");
AntonLS 45:1eb335c00cb2 915 writeToPhone(",T%05u", split); // PROTOCOL optimization
elmbed 17:d8b901d791fd 916 l = masks[i];
elmbed 17:d8b901d791fd 917 /*
elmbed 18:affef3a7db2a 918 if(l<0b10000000)
elmbed 18:affef3a7db2a 919 writeToPhone("0");
elmbed 18:affef3a7db2a 920 if(l<0b1000000)
elmbed 18:affef3a7db2a 921 writeToPhone("0");
elmbed 18:affef3a7db2a 922 if(l<0b100000)
elmbed 18:affef3a7db2a 923 writeToPhone("0");
elmbed 18:affef3a7db2a 924 if(l<0b10000)
elmbed 18:affef3a7db2a 925 writeToPhone("0");
elmbed 18:affef3a7db2a 926 if(l<0b1000)
elmbed 18:affef3a7db2a 927 writeToPhone("0");
elmbed 18:affef3a7db2a 928 if(l<0b100)
elmbed 18:affef3a7db2a 929 writeToPhone("0");
elmbed 18:affef3a7db2a 930 if(l<0b10)
elmbed 18:affef3a7db2a 931 writeToPhone("0");
elmbed 18:affef3a7db2a 932 */
AntonLS 39:b1f864b71318 933 // writeBitsToPhone( l, 3 ); // Removed for PROTOCOL optimization
AntonLS 39:b1f864b71318 934 writeToPhone(",B%02x", l); // PROTOCOL optimization
AntonLS 19:afcbb425b3cf 935 writeToPhone( "\r\n" );
elmbed 18:affef3a7db2a 936 //Serial.println(l, BIN);
elmbed 17:d8b901d791fd 937 }
elmbed 17:d8b901d791fd 938 break;
elmbed 17:d8b901d791fd 939 case 'u':
elmbed 17:d8b901d791fd 940 // let any pending messages clear
elmbed 18:affef3a7db2a 941 while(ta.get_buffer_size()){
elmbed 17:d8b901d791fd 942 ta.spin();
elmbed 17:d8b901d791fd 943 }
elmbed 18:affef3a7db2a 944 if(value == 1){
elmbed 18:affef3a7db2a 945 writeToPhone("Course leader!\r\n");
elmbed 17:d8b901d791fd 946 powerupCones(value);
elmbed 17:d8b901d791fd 947 ta.powerup(value);
elmbed 17:d8b901d791fd 948 }
elmbed 18:affef3a7db2a 949 if(value == 2){
elmbed 18:affef3a7db2a 950 writeToPhone("Split leader!\r\n");
elmbed 17:d8b901d791fd 951 powerupCones(value);
elmbed 18:affef3a7db2a 952 //ta.powerup(value);
elmbed 17:d8b901d791fd 953 }
elmbed 18:affef3a7db2a 954 if(value > 10 && value < 5000){
elmbed 17:d8b901d791fd 955 ta.beep(value);
elmbed 17:d8b901d791fd 956 }
elmbed 17:d8b901d791fd 957 break;
elmbed 17:d8b901d791fd 958 case 'w':
elmbed 58:fb2198ceb412 959 if(value > 0 && value <= SEQUENCES)
elmbed 58:fb2198ceb412 960 {
elmbed 17:d8b901d791fd 961 length = STATIONS;
elmbed 17:d8b901d791fd 962 offset = (value - 1) * STATIONS;
elmbed 62:9b34dc1b265d 963 datastore_write_pattern(value-1);
elmbed 18:affef3a7db2a 964 writeToPhone("Saved sequence %d\r\n", value);
elmbed 17:d8b901d791fd 965 }
elmbed 58:fb2198ceb412 966 else
elmbed 58:fb2198ceb412 967 {
elmbed 58:fb2198ceb412 968 datastore_write_patterns();
elmbed 18:affef3a7db2a 969 writeToPhone("Saved all sequences.\r\n");
elmbed 17:d8b901d791fd 970 }
elmbed 17:d8b901d791fd 971 break;
elmbed 17:d8b901d791fd 972 case 'x':
elmbed 17:d8b901d791fd 973 resetSensors();
AntonLS 46:28c29ef61276 974 ta.resetTouch();
elmbed 17:d8b901d791fd 975 break;
AntonLS 66:18c214707b0c 976 #ifdef D
elmbed 62:9b34dc1b265d 977 case '5': // DEBUG CODE!
elmbed 62:9b34dc1b265d 978 write_test_pattern();
elmbed 62:9b34dc1b265d 979 datastore_write_patterns();
elmbed 62:9b34dc1b265d 980 break;
AntonLS 66:18c214707b0c 981 #endif
elmbed 17:d8b901d791fd 982 case 'z':
elmbed 17:d8b901d791fd 983 find_cones();
elmbed 17:d8b901d791fd 984 break;
elmbed 17:d8b901d791fd 985 }
elmbed 17:d8b901d791fd 986 }
elmbed 23:26f27c462976 987
elmbed 23:26f27c462976 988 static patternState_t stateFromCone(uint8_t cone)
elmbed 17:d8b901d791fd 989 {
elmbed 17:d8b901d791fd 990 if(cone == 0 || index == STATIONS)
elmbed 17:d8b901d791fd 991 return SUCCESS_P;
elmbed 17:d8b901d791fd 992 if(cone == 1)
elmbed 17:d8b901d791fd 993 return ACTIVE_TARGET_P;
elmbed 17:d8b901d791fd 994
elmbed 17:d8b901d791fd 995 return WAITING_P;
elmbed 17:d8b901d791fd 996 }
elmbed 17:d8b901d791fd 997
elmbed 23:26f27c462976 998 static void printSplit(unsigned long timer)
elmbed 17:d8b901d791fd 999 {
elmbed 17:d8b901d791fd 1000 if(tag_start)
elmbed 17:d8b901d791fd 1001 {
AntonLS 48:4c9551c826e9 1002 writeToPhone( "Sequence started at cone %u (", active_cone ); // PROTOCOL
AntonLS 48:4c9551c826e9 1003 printMsAsSeconds(timer); // PROTOCOL
AntonLS 48:4c9551c826e9 1004 writeToPhone( " seconds).\r\n" ); // PROTOCOL
elmbed 17:d8b901d791fd 1005 tag_start = false;
elmbed 17:d8b901d791fd 1006 }
elmbed 17:d8b901d791fd 1007 else
elmbed 17:d8b901d791fd 1008 {
AntonLS 48:4c9551c826e9 1009 writeToPhone( "Target cone is: %u, ", active_cone ); // PROTOCOL
AntonLS 48:4c9551c826e9 1010 printMsAsSeconds(timer); // PROTOCOL
AntonLS 48:4c9551c826e9 1011 writeToPhone( " split\r\n" ); // PROTOCOL
elmbed 17:d8b901d791fd 1012 }
elmbed 17:d8b901d791fd 1013 }
elmbed 17:d8b901d791fd 1014
elmbed 23:26f27c462976 1015 static uint8_t getRandomCone(void)
elmbed 17:d8b901d791fd 1016 {
elmbed 40:dec5270e03e9 1017 static uint8_t last_cone = 0;
AntonLS 52:060fdec99780 1018 static uint8_t ac[NUM_CONES] = {1};
AntonLS 52:060fdec99780 1019
elmbed 17:d8b901d791fd 1020 uint8_t cone;
AntonLS 48:4c9551c826e9 1021
AntonLS 54:2878d62714d6 1022 uint8_t avail = 0;
AntonLS 54:2878d62714d6 1023 for( uint8_t i=1; i<=NUM_CONES; i++ )
AntonLS 55:b3cb69d69ce8 1024 {
AntonLS 55:b3cb69d69ce8 1025 if( ((1==i) ? true : active_cones[i]) && (i != last_cone) ) ac[avail++] = i;
AntonLS 55:b3cb69d69ce8 1026 }
AntonLS 48:4c9551c826e9 1027
AntonLS 54:2878d62714d6 1028 cone = ((avail != 0) ? ac[rnd() % avail] : 0);
AntonLS 48:4c9551c826e9 1029
AntonLS 48:4c9551c826e9 1030 writeToPhone( "Target cone is %u\r\n", cone ); // PROTOCOL
elmbed 40:dec5270e03e9 1031
elmbed 40:dec5270e03e9 1032 last_cone = cone;
AntonLS 48:4c9551c826e9 1033
AntonLS 48:4c9551c826e9 1034 return cone;
elmbed 17:d8b901d791fd 1035 }
elmbed 17:d8b901d791fd 1036
elmbed 23:26f27c462976 1037 static void clearCones(void)
elmbed 17:d8b901d791fd 1038 {
elmbed 17:d8b901d791fd 1039 uint8_t i;
elmbed 17:d8b901d791fd 1040 m->command = 'q';
elmbed 17:d8b901d791fd 1041
elmbed 17:d8b901d791fd 1042 for(i=2;i<NUM_CONES+1;i++)
elmbed 17:d8b901d791fd 1043 {
elmbed 17:d8b901d791fd 1044 m->cone = i;
elmbed 17:d8b901d791fd 1045 if(active_cones[i])
elmbed 17:d8b901d791fd 1046 ta.send(m);
AntonLS 48:4c9551c826e9 1047 /// active_cones[i] = false;
elmbed 17:d8b901d791fd 1048 //ta.send("q", i);
elmbed 17:d8b901d791fd 1049 }
elmbed 17:d8b901d791fd 1050
elmbed 17:d8b901d791fd 1051 DEBUG("sent clear\r\n");
elmbed 17:d8b901d791fd 1052 }
elmbed 17:d8b901d791fd 1053
elmbed 23:26f27c462976 1054 static void powerupCones(uint8_t sound)
elmbed 17:d8b901d791fd 1055 {
elmbed 17:d8b901d791fd 1056 uint8_t i;
elmbed 17:d8b901d791fd 1057 m->command = 'u';
elmbed 17:d8b901d791fd 1058 m->value = sound;
elmbed 17:d8b901d791fd 1059
elmbed 17:d8b901d791fd 1060 if(sound == 2)
elmbed 17:d8b901d791fd 1061 {
elmbed 28:8e74ddc4f70f 1062 if(active_cone == NODE_ID)
elmbed 17:d8b901d791fd 1063 {
elmbed 17:d8b901d791fd 1064 ta.powerup(sound);
elmbed 17:d8b901d791fd 1065 }
elmbed 17:d8b901d791fd 1066 else
elmbed 17:d8b901d791fd 1067 {
elmbed 17:d8b901d791fd 1068 m->cone = active_cone;
elmbed 17:d8b901d791fd 1069 ta.send(m);
elmbed 17:d8b901d791fd 1070 }
elmbed 17:d8b901d791fd 1071 }
elmbed 17:d8b901d791fd 1072 else
elmbed 17:d8b901d791fd 1073 {
elmbed 17:d8b901d791fd 1074 for(i=2;i<NUM_CONES+1;i++)
elmbed 17:d8b901d791fd 1075 {
elmbed 17:d8b901d791fd 1076 m->cone = i;
elmbed 17:d8b901d791fd 1077 if(active_cones[i])
elmbed 17:d8b901d791fd 1078 ta.send(m);
elmbed 17:d8b901d791fd 1079 //ta.send("f", i);
elmbed 17:d8b901d791fd 1080 }
elmbed 17:d8b901d791fd 1081 }
elmbed 17:d8b901d791fd 1082 //DEBUG("sent powerup");
elmbed 17:d8b901d791fd 1083 }
elmbed 17:d8b901d791fd 1084
elmbed 23:26f27c462976 1085 static void failCones(void)
elmbed 17:d8b901d791fd 1086 {
elmbed 17:d8b901d791fd 1087 uint8_t i;
elmbed 17:d8b901d791fd 1088 m->command = 'f';
elmbed 17:d8b901d791fd 1089
elmbed 17:d8b901d791fd 1090 for(i=2;i<NUM_CONES+1;i++)
elmbed 17:d8b901d791fd 1091 {
elmbed 17:d8b901d791fd 1092 m->cone = i;
elmbed 17:d8b901d791fd 1093
elmbed 17:d8b901d791fd 1094 if(active_cones[i])
elmbed 17:d8b901d791fd 1095 ta.send(m);
elmbed 17:d8b901d791fd 1096 //ta.send("f", i);
elmbed 17:d8b901d791fd 1097 }
elmbed 17:d8b901d791fd 1098
elmbed 17:d8b901d791fd 1099 while(ta.get_buffer_size())
elmbed 17:d8b901d791fd 1100 {
elmbed 17:d8b901d791fd 1101 ta.spin();
elmbed 17:d8b901d791fd 1102 }
elmbed 17:d8b901d791fd 1103
elmbed 17:d8b901d791fd 1104 //DEBUG("sent fail\n");
elmbed 17:d8b901d791fd 1105 }
elmbed 17:d8b901d791fd 1106
elmbed 23:26f27c462976 1107 static void resetSensors(void)
elmbed 17:d8b901d791fd 1108 {
elmbed 17:d8b901d791fd 1109 uint8_t i;
elmbed 17:d8b901d791fd 1110 m->command = 'x';
elmbed 17:d8b901d791fd 1111
elmbed 17:d8b901d791fd 1112 for(i=2;i<NUM_CONES+1;i++)
elmbed 17:d8b901d791fd 1113 {
elmbed 17:d8b901d791fd 1114 m->cone = i;
elmbed 17:d8b901d791fd 1115 if(active_cones[i])
elmbed 17:d8b901d791fd 1116 ta.send(m);
elmbed 17:d8b901d791fd 1117 //ta.send("f", i);
elmbed 17:d8b901d791fd 1118 }
elmbed 17:d8b901d791fd 1119
elmbed 17:d8b901d791fd 1120 DEBUG("sent sensor reset\n");
elmbed 17:d8b901d791fd 1121 }
elmbed 17:d8b901d791fd 1122
elmbed 23:26f27c462976 1123 static void successCones(void)
elmbed 17:d8b901d791fd 1124 {
elmbed 17:d8b901d791fd 1125 uint8_t i;
elmbed 17:d8b901d791fd 1126 m->command = 's';
elmbed 17:d8b901d791fd 1127
elmbed 17:d8b901d791fd 1128 for(i=2;i<NUM_CONES+1;i++)
elmbed 17:d8b901d791fd 1129 {
elmbed 17:d8b901d791fd 1130 m->cone = i;
elmbed 17:d8b901d791fd 1131 if(active_cones[i])
elmbed 17:d8b901d791fd 1132 ta.send(m);
elmbed 17:d8b901d791fd 1133 //ta.send("s", i);
elmbed 17:d8b901d791fd 1134 }
elmbed 17:d8b901d791fd 1135
elmbed 17:d8b901d791fd 1136 while(ta.get_buffer_size())
elmbed 17:d8b901d791fd 1137 {
elmbed 17:d8b901d791fd 1138 ta.spin();
elmbed 17:d8b901d791fd 1139 }
elmbed 17:d8b901d791fd 1140 }
elmbed 17:d8b901d791fd 1141
elmbed 23:26f27c462976 1142 static void find_cones(void)
elmbed 17:d8b901d791fd 1143 {
elmbed 17:d8b901d791fd 1144 while(ta.get_buffer_size())
elmbed 23:26f27c462976 1145 {
elmbed 17:d8b901d791fd 1146 ta.spin(); // wait for all messages to leave queue
elmbed 28:8e74ddc4f70f 1147 }
elmbed 17:d8b901d791fd 1148
elmbed 23:26f27c462976 1149 ta.beep_off();
elmbed 17:d8b901d791fd 1150 uint8_t i;
elmbed 17:d8b901d791fd 1151 m->command = 'z';
elmbed 28:8e74ddc4f70f 1152
elmbed 17:d8b901d791fd 1153 lonely = true;
elmbed 17:d8b901d791fd 1154
elmbed 60:d1fad57e8bfb 1155 if(Dbg)
elmbed 60:d1fad57e8bfb 1156 {
elmbed 60:d1fad57e8bfb 1157 writeToPhone("FC\r\n");
elmbed 60:d1fad57e8bfb 1158 }
elmbed 29:ae208b014987 1159
elmbed 29:ae208b014987 1160 int retry_count = 0;
AntonLS 32:64e5d7340d82 1161
elmbed 26:40a0c775ff27 1162 for(i = 2; i < NUM_CONES + 1; ++i)
elmbed 17:d8b901d791fd 1163 {
elmbed 29:ae208b014987 1164 retry_count = 0;
elmbed 29:ae208b014987 1165 go_again:
elmbed 17:d8b901d791fd 1166 active_cones[i] = false;
elmbed 17:d8b901d791fd 1167 m->cone = i;
elmbed 17:d8b901d791fd 1168 ta.send_immediate(m);
elmbed 17:d8b901d791fd 1169
elmbed 17:d8b901d791fd 1170 unsigned long st = millis();
AntonLS 67:5650f461722a 1171 unsigned long delta = 0L;
AntonLS 67:5650f461722a 1172 /* ///
elmbed 29:ae208b014987 1173 unsigned long current = 0L;
elmbed 17:d8b901d791fd 1174
elmbed 60:d1fad57e8bfb 1175 if(Dbg)
elmbed 60:d1fad57e8bfb 1176 {
elmbed 60:d1fad57e8bfb 1177 writeToPhone("S: %lu F: %d\r\n", st, i);
elmbed 60:d1fad57e8bfb 1178 }
elmbed 23:26f27c462976 1179
elmbed 17:d8b901d791fd 1180 while(1)
elmbed 17:d8b901d791fd 1181 {
elmbed 23:26f27c462976 1182 current = millis();
elmbed 23:26f27c462976 1183 delta = current - st;
elmbed 17:d8b901d791fd 1184
elmbed 35:c1405da88d3a 1185 if(delta > 300L)
elmbed 23:26f27c462976 1186 {
elmbed 60:d1fad57e8bfb 1187 if(Dbg)
elmbed 60:d1fad57e8bfb 1188 {
elmbed 60:d1fad57e8bfb 1189 writeToPhone("FT: %d %lu\r\n", i, current);
elmbed 60:d1fad57e8bfb 1190 }
elmbed 29:ae208b014987 1191
elmbed 29:ae208b014987 1192 if (++retry_count < 3)
elmbed 29:ae208b014987 1193 {
elmbed 29:ae208b014987 1194 goto go_again;
elmbed 29:ae208b014987 1195 }
elmbed 29:ae208b014987 1196 else
elmbed 29:ae208b014987 1197 {
elmbed 29:ae208b014987 1198 break;
elmbed 29:ae208b014987 1199 }
elmbed 28:8e74ddc4f70f 1200 }
elmbed 17:d8b901d791fd 1201 if(ta.recieve(m_in))
elmbed 17:d8b901d791fd 1202 {
elmbed 17:d8b901d791fd 1203 lonely = false;
elmbed 17:d8b901d791fd 1204 active_cones[m_in->cone] = true;
elmbed 17:d8b901d791fd 1205
elmbed 60:d1fad57e8bfb 1206 if(Dbg)
elmbed 60:d1fad57e8bfb 1207 {
elmbed 60:d1fad57e8bfb 1208 writeToPhone("FS: %d\r\n", m_in->cone);
elmbed 60:d1fad57e8bfb 1209 }
elmbed 17:d8b901d791fd 1210 break;
elmbed 17:d8b901d791fd 1211 }
elmbed 17:d8b901d791fd 1212 }
elmbed 29:ae208b014987 1213
elmbed 29:ae208b014987 1214 wait_us(50);
AntonLS 67:5650f461722a 1215 */ ///
AntonLS 67:5650f461722a 1216 while( 1 ) ////
AntonLS 67:5650f461722a 1217 {
AntonLS 67:5650f461722a 1218 delta = millis() - st;
AntonLS 67:5650f461722a 1219 if( delta > 50 ) break;
AntonLS 67:5650f461722a 1220 ta.spin();
AntonLS 67:5650f461722a 1221 if( ta.recieve( m_in ) )
AntonLS 67:5650f461722a 1222 {
AntonLS 67:5650f461722a 1223 lonely = false;
AntonLS 67:5650f461722a 1224 active_cones[m_in->cone] = true;
AntonLS 67:5650f461722a 1225 DEBUG( "Reply from cone: %d, %dms\r\n", m_in->cone, delta );
AntonLS 67:5650f461722a 1226 break;
AntonLS 67:5650f461722a 1227 }
AntonLS 67:5650f461722a 1228 }
elmbed 17:d8b901d791fd 1229 }
AntonLS 52:060fdec99780 1230
AntonLS 52:060fdec99780 1231 writeToPhone("Available cones are: (1");
elmbed 17:d8b901d791fd 1232
elmbed 26:40a0c775ff27 1233 for(i = 2; i < NUM_CONES + 1; ++i)
elmbed 17:d8b901d791fd 1234 {
elmbed 17:d8b901d791fd 1235 if(active_cones[i])
elmbed 17:d8b901d791fd 1236 {
elmbed 26:40a0c775ff27 1237 writeToPhone(", %d", i);
elmbed 17:d8b901d791fd 1238 }
elmbed 17:d8b901d791fd 1239 }
elmbed 26:40a0c775ff27 1240
elmbed 26:40a0c775ff27 1241 writeToPhone(")\r\n");
elmbed 17:d8b901d791fd 1242 }
elmbed 17:d8b901d791fd 1243
elmbed 23:26f27c462976 1244 static void printMsAsSeconds(unsigned long number)
elmbed 17:d8b901d791fd 1245 {
elmbed 17:d8b901d791fd 1246 uint16_t remainder;
elmbed 17:d8b901d791fd 1247
elmbed 17:d8b901d791fd 1248 remainder = number%1000;
AntonLS 19:afcbb425b3cf 1249
AntonLS 52:060fdec99780 1250 writeToPhone( "%d.%03d", number/1000, remainder ); /// Needs to stay without CRLF.
elmbed 17:d8b901d791fd 1251 }
elmbed 17:d8b901d791fd 1252
elmbed 23:26f27c462976 1253 static void spinButtons(void)
elmbed 17:d8b901d791fd 1254 {
elmbed 17:d8b901d791fd 1255 static inputState_t last_state = IDLE_I;
elmbed 17:d8b901d791fd 1256 static bool first_i; // first should be true when we first enter a state (even if we just exited the same state)
elmbed 17:d8b901d791fd 1257 static Event event;
elmbed 17:d8b901d791fd 1258 static uint8_t sequence = 0;
elmbed 17:d8b901d791fd 1259 static unsigned long start = 0;
elmbed 17:d8b901d791fd 1260 uint8_t section = 0;
elmbed 17:d8b901d791fd 1261
elmbed 17:d8b901d791fd 1262 //uint8_t buttons;
elmbed 17:d8b901d791fd 1263
elmbed 17:d8b901d791fd 1264 //timer = millis() - start;
elmbed 17:d8b901d791fd 1265 if(millis() > 500)
elmbed 17:d8b901d791fd 1266 event = getInputEvent();
elmbed 17:d8b901d791fd 1267
elmbed 17:d8b901d791fd 1268 if(event.type == Event::press)
elmbed 17:d8b901d791fd 1269 {
elmbed 17:d8b901d791fd 1270 in_menu = true;
elmbed 17:d8b901d791fd 1271 state_i = MENU_I;
elmbed 17:d8b901d791fd 1272 }
elmbed 17:d8b901d791fd 1273
elmbed 17:d8b901d791fd 1274 first_i = false;
elmbed 17:d8b901d791fd 1275
elmbed 17:d8b901d791fd 1276 if(last_state != state_i)
elmbed 17:d8b901d791fd 1277 {
elmbed 17:d8b901d791fd 1278 //if(state_i == IDLE_I)////////////DEBUG.println(F("");
elmbed 17:d8b901d791fd 1279 //if(state_i == RUNNING_I)//////////////DEBUG.println(F("State is WAITING");
elmbed 17:d8b901d791fd 1280 // need to print menu timeout?
elmbed 17:d8b901d791fd 1281 if(state_i == MENU_I)
elmbed 17:d8b901d791fd 1282 ////DEBUG("Menu\n");
elmbed 17:d8b901d791fd 1283 if(state_i == PATTERN_SELECT_I)
elmbed 17:d8b901d791fd 1284 ////DEBUG("Choosing pattern");
elmbed 17:d8b901d791fd 1285 first_i = true;
elmbed 17:d8b901d791fd 1286 }
elmbed 17:d8b901d791fd 1287
elmbed 17:d8b901d791fd 1288 last_state = state_i;
elmbed 17:d8b901d791fd 1289
elmbed 17:d8b901d791fd 1290 if(state_i == RUNNING_I)
elmbed 17:d8b901d791fd 1291 in_menu = false;
elmbed 17:d8b901d791fd 1292
elmbed 17:d8b901d791fd 1293 switch(state_i)
elmbed 17:d8b901d791fd 1294 {
elmbed 17:d8b901d791fd 1295 case IDLE_I:
elmbed 17:d8b901d791fd 1296 // display something distinctive
elmbed 17:d8b901d791fd 1297 if(event.type == Event::tap)
elmbed 17:d8b901d791fd 1298 {
elmbed 17:d8b901d791fd 1299 state_i = RUNNING_I;
elmbed 17:d8b901d791fd 1300 //send 'p' or 'f' command as appropriate
elmbed 61:dd7002ceea96 1301 if(mode == FREEFORM_M)
elmbed 62:9b34dc1b265d 1302 interpret_master('f', 0);
elmbed 17:d8b901d791fd 1303 else
elmbed 62:9b34dc1b265d 1304 interpret_master('p', 0);
elmbed 17:d8b901d791fd 1305 }
elmbed 35:c1405da88d3a 1306
elmbed 17:d8b901d791fd 1307 break;
elmbed 17:d8b901d791fd 1308 case RUNNING_I:
elmbed 17:d8b901d791fd 1309 if(event.type == Event::finish)
elmbed 17:d8b901d791fd 1310 state_i = IDLE_I;
elmbed 17:d8b901d791fd 1311 break;
elmbed 17:d8b901d791fd 1312 case MENU_I:
elmbed 17:d8b901d791fd 1313 if(first_i)
elmbed 62:9b34dc1b265d 1314 interpret_master('q', 0);
elmbed 17:d8b901d791fd 1315 // every 3 seconds we cycle through the menu
elmbed 17:d8b901d791fd 1316 // one option per second
elmbed 17:d8b901d791fd 1317 // light changes color and stays on for 500ms
elmbed 17:d8b901d791fd 1318 section = ((millis() - start)%3000)/500;
elmbed 17:d8b901d791fd 1319
elmbed 17:d8b901d791fd 1320 if(section == 0)
elmbed 17:d8b901d791fd 1321 ta.post_color(0xFF);
elmbed 17:d8b901d791fd 1322 if(section == 1)
elmbed 17:d8b901d791fd 1323 ta.post_color(0);
elmbed 17:d8b901d791fd 1324 if(section == 2)
elmbed 17:d8b901d791fd 1325 ta.post_color(0xFF00);
elmbed 17:d8b901d791fd 1326 if(section == 3)
elmbed 17:d8b901d791fd 1327 ta.post_color(0);
elmbed 17:d8b901d791fd 1328 if(section == 4)
elmbed 17:d8b901d791fd 1329 ta.post_color(0xFF0000);
elmbed 17:d8b901d791fd 1330 if(section == 5)
elmbed 17:d8b901d791fd 1331 ta.post_color(0);
elmbed 17:d8b901d791fd 1332 if(event.type == Event::tap)
elmbed 17:d8b901d791fd 1333 {
elmbed 17:d8b901d791fd 1334 // set state here based on current light color
elmbed 17:d8b901d791fd 1335 if(section < 2)
elmbed 17:d8b901d791fd 1336 {
elmbed 61:dd7002ceea96 1337 mode = FREEFORM_M;
elmbed 17:d8b901d791fd 1338 ta.post_color(0xFF);
elmbed 17:d8b901d791fd 1339 ////////DEBUG.println(F("Freeform mode.");
elmbed 17:d8b901d791fd 1340 state_i = IDLE_I;
elmbed 17:d8b901d791fd 1341 break;
elmbed 17:d8b901d791fd 1342 }
elmbed 17:d8b901d791fd 1343
elmbed 17:d8b901d791fd 1344 if(section < 4)
elmbed 17:d8b901d791fd 1345 {
elmbed 61:dd7002ceea96 1346 mode = PATTERN_M;
elmbed 17:d8b901d791fd 1347 ta.post_color(0xFF00);
elmbed 17:d8b901d791fd 1348 ////////DEBUG.println(F("Pattern mode.");
elmbed 17:d8b901d791fd 1349 state_i = IDLE_I;
elmbed 17:d8b901d791fd 1350 break;
elmbed 17:d8b901d791fd 1351 }
elmbed 17:d8b901d791fd 1352
elmbed 17:d8b901d791fd 1353 if(section < 6)
elmbed 17:d8b901d791fd 1354 {
elmbed 17:d8b901d791fd 1355 state_i = PATTERN_SELECT_I;
elmbed 17:d8b901d791fd 1356 ta.post_color(0xFF0000);
elmbed 17:d8b901d791fd 1357 break;
elmbed 17:d8b901d791fd 1358 }
elmbed 17:d8b901d791fd 1359 }
elmbed 17:d8b901d791fd 1360 break;
elmbed 17:d8b901d791fd 1361 case PATTERN_SELECT_I:
elmbed 17:d8b901d791fd 1362 if(first_i)
elmbed 17:d8b901d791fd 1363 {
elmbed 17:d8b901d791fd 1364 sequence = active_sequence;
elmbed 61:dd7002ceea96 1365 mode = PATTERN_M;
elmbed 17:d8b901d791fd 1366 //start = millis();
elmbed 17:d8b901d791fd 1367 }
elmbed 17:d8b901d791fd 1368 if(event.type == Event::tap)
elmbed 17:d8b901d791fd 1369 {
elmbed 17:d8b901d791fd 1370 ta.beep(50);
elmbed 17:d8b901d791fd 1371 if(event.value == 1 && sequence > 0)
elmbed 17:d8b901d791fd 1372 {
elmbed 17:d8b901d791fd 1373 sequence--;
elmbed 17:d8b901d791fd 1374 }
elmbed 17:d8b901d791fd 1375
elmbed 17:d8b901d791fd 1376 if(event.value == 2 && sequence < SEQUENCES - 1)
elmbed 17:d8b901d791fd 1377 {
elmbed 17:d8b901d791fd 1378 sequence++;
elmbed 17:d8b901d791fd 1379 }
elmbed 17:d8b901d791fd 1380
elmbed 17:d8b901d791fd 1381 if(event.value == 3)
elmbed 17:d8b901d791fd 1382 {
elmbed 62:9b34dc1b265d 1383 interpret_master('p', sequence + 1);
elmbed 17:d8b901d791fd 1384 state_i = IDLE_I;
elmbed 17:d8b901d791fd 1385 }
elmbed 17:d8b901d791fd 1386
elmbed 17:d8b901d791fd 1387 if(event.value != 3)
elmbed 17:d8b901d791fd 1388 {
elmbed 17:d8b901d791fd 1389 ////DEBUG("Menu says: sequence ");
elmbed 17:d8b901d791fd 1390 ////DEBUG("%d\n",sequence + 1);
elmbed 17:d8b901d791fd 1391 }
elmbed 17:d8b901d791fd 1392 break;
elmbed 17:d8b901d791fd 1393 case TEACH_I:
elmbed 17:d8b901d791fd 1394 // not implemented yet
elmbed 17:d8b901d791fd 1395 break;
elmbed 17:d8b901d791fd 1396 default: break;
elmbed 17:d8b901d791fd 1397 }
elmbed 17:d8b901d791fd 1398 }
elmbed 17:d8b901d791fd 1399 }
elmbed 17:d8b901d791fd 1400
elmbed 23:26f27c462976 1401 static uint8_t checkButtons(void)
elmbed 17:d8b901d791fd 1402 {
elmbed 17:d8b901d791fd 1403 static unsigned long last_time = 0;
elmbed 17:d8b901d791fd 1404 //static uint8_t last = 0;
elmbed 17:d8b901d791fd 1405 static uint8_t buttons = 0;
elmbed 17:d8b901d791fd 1406
elmbed 17:d8b901d791fd 1407 // listen for commands from the buttons
elmbed 17:d8b901d791fd 1408 unsigned long time = millis();
elmbed 17:d8b901d791fd 1409 // only check every DEBOUNCE_MS to avoid jitter
elmbed 17:d8b901d791fd 1410 if(time - last_time > DEBOUNCE_MS)
elmbed 17:d8b901d791fd 1411 {
elmbed 17:d8b901d791fd 1412 last_time = time;
AntonLS 49:626e84ce5e52 1413 buttons = ta.buttons();
elmbed 17:d8b901d791fd 1414 }
elmbed 17:d8b901d791fd 1415
elmbed 17:d8b901d791fd 1416 return buttons;
elmbed 17:d8b901d791fd 1417 }
elmbed 17:d8b901d791fd 1418
elmbed 23:26f27c462976 1419 static Event getInputEvent(void)
elmbed 17:d8b901d791fd 1420 {
elmbed 17:d8b901d791fd 1421 static uint8_t last_buttons = 0;
elmbed 17:d8b901d791fd 1422 static unsigned long time1 = 0;
elmbed 17:d8b901d791fd 1423 static unsigned long time2 = 0;
elmbed 17:d8b901d791fd 1424 static unsigned long time3 = 0;
elmbed 17:d8b901d791fd 1425 unsigned long duration = 0;
elmbed 17:d8b901d791fd 1426 uint8_t buttons = 0;
elmbed 17:d8b901d791fd 1427 Event event;
elmbed 17:d8b901d791fd 1428 event.type = Event::none;
elmbed 17:d8b901d791fd 1429 event.value = 0;
elmbed 17:d8b901d791fd 1430
elmbed 17:d8b901d791fd 1431 buttons = checkButtons();
elmbed 17:d8b901d791fd 1432 uint8_t rising = buttons & ~last_buttons;
elmbed 17:d8b901d791fd 1433 uint8_t falling = ~buttons & last_buttons;
elmbed 17:d8b901d791fd 1434
elmbed 17:d8b901d791fd 1435 /*if(rising){
elmbed 17:d8b901d791fd 1436 //DEBUG.print("Rising ");
elmbed 17:d8b901d791fd 1437 //DEBUG.println(rising);
elmbed 17:d8b901d791fd 1438 }
elmbed 17:d8b901d791fd 1439 if(falling){
elmbed 17:d8b901d791fd 1440 //DEBUG.print("Falling ");
elmbed 17:d8b901d791fd 1441 //DEBUG.println(falling);
elmbed 17:d8b901d791fd 1442 }*/
elmbed 17:d8b901d791fd 1443 if(rising & 0x01)
elmbed 17:d8b901d791fd 1444 time1 = millis();
elmbed 17:d8b901d791fd 1445 if(rising & 0x02)
elmbed 17:d8b901d791fd 1446 time2 = millis();
elmbed 17:d8b901d791fd 1447 if(rising & 0x04)
elmbed 17:d8b901d791fd 1448 time3 = millis();
elmbed 17:d8b901d791fd 1449
elmbed 17:d8b901d791fd 1450 // simultaneous falling edges will cause lower values to be ignored
elmbed 17:d8b901d791fd 1451 if(falling & 0x01)
elmbed 17:d8b901d791fd 1452 {
elmbed 17:d8b901d791fd 1453 duration = millis() - time1;
elmbed 17:d8b901d791fd 1454 event.value = 1;
elmbed 17:d8b901d791fd 1455 }
elmbed 17:d8b901d791fd 1456
elmbed 17:d8b901d791fd 1457 if(falling & 0x02)
elmbed 17:d8b901d791fd 1458 {
elmbed 17:d8b901d791fd 1459 duration = millis() - time2;
elmbed 17:d8b901d791fd 1460 event.value = 2;
elmbed 17:d8b901d791fd 1461 }
elmbed 17:d8b901d791fd 1462
elmbed 17:d8b901d791fd 1463 if(falling & 0x04)
elmbed 17:d8b901d791fd 1464 {
elmbed 17:d8b901d791fd 1465 duration = millis() - time3;
elmbed 17:d8b901d791fd 1466 event.value = 3;
elmbed 17:d8b901d791fd 1467 }
elmbed 17:d8b901d791fd 1468
elmbed 17:d8b901d791fd 1469 if(duration > 0)
elmbed 17:d8b901d791fd 1470 event.type = Event::tap;
elmbed 17:d8b901d791fd 1471 if(duration > 2000)
elmbed 17:d8b901d791fd 1472 event.type = Event::press;
elmbed 17:d8b901d791fd 1473
elmbed 17:d8b901d791fd 1474 // give feedback that we've waited lng enough for a press
elmbed 17:d8b901d791fd 1475 unsigned long t = millis() - time1;
elmbed 17:d8b901d791fd 1476
elmbed 17:d8b901d791fd 1477 if(2020 > t && t > 2000 && (buttons & 0x01))
elmbed 17:d8b901d791fd 1478 ta.beep(20);
elmbed 17:d8b901d791fd 1479
elmbed 17:d8b901d791fd 1480 t = millis() - time2;
elmbed 17:d8b901d791fd 1481
elmbed 17:d8b901d791fd 1482 if(2020 > t && t > 2000 && (buttons & 0x02))
elmbed 17:d8b901d791fd 1483 ta.beep(20);
elmbed 17:d8b901d791fd 1484
elmbed 17:d8b901d791fd 1485 t = millis() - time3;
elmbed 17:d8b901d791fd 1486
elmbed 17:d8b901d791fd 1487 if(2020 > t && t > 2000 && (buttons & 0x04))
elmbed 17:d8b901d791fd 1488 ta.beep(20);
elmbed 17:d8b901d791fd 1489
elmbed 17:d8b901d791fd 1490 if(event.type != Event::none)
elmbed 17:d8b901d791fd 1491 {
elmbed 17:d8b901d791fd 1492 //DEBUG("Event: ");
elmbed 17:d8b901d791fd 1493 if(event.type == Event::tap)
elmbed 17:d8b901d791fd 1494 ////DEBUG("tap, ");
elmbed 17:d8b901d791fd 1495 if(event.type == Event::press)
elmbed 17:d8b901d791fd 1496 ////DEBUG("press, ");
elmbed 17:d8b901d791fd 1497
elmbed 17:d8b901d791fd 1498 uint8_t val = event.value;
elmbed 17:d8b901d791fd 1499 //DEBUG("%d\n",val);
elmbed 17:d8b901d791fd 1500 //////DEBUG.println(duration);
elmbed 17:d8b901d791fd 1501 }
elmbed 17:d8b901d791fd 1502
elmbed 17:d8b901d791fd 1503 last_buttons = buttons;
elmbed 17:d8b901d791fd 1504 return event;
elmbed 17:d8b901d791fd 1505 }