1308 lines
40 KiB
C++
1308 lines
40 KiB
C++
/*
|
|
* ____ _ ______ _____ _____
|
|
/ __ \ | | | ____| __ \ | __ \
|
|
| | | |_ __ ___ _ __ | | | |__ | | | | | |__) |__ _ ___ ___
|
|
| | | | '_ \ / _ \ '_ \ | | | __| | | | | | _ // _` |/ __/ _ \
|
|
| |__| | |_) | __/ | | | | |____| |____| |__| | | | \ \ (_| | (_| __/
|
|
\____/| .__/ \___|_| |_| |______|______|_____/ |_| \_\__,_|\___\___|
|
|
| |
|
|
|_|
|
|
Open LED Race
|
|
An minimalist cars race for LED strip
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Current Version by:
|
|
LucaBuka (https://gitlab.com/lucabuka)
|
|
Gerardo Barbarov (gbarbarov AT singulardevices DOT com)
|
|
Angel Maldonado (https://gitlab.com/angeljmc)
|
|
|
|
Basen on an original idea and 2 players code by:
|
|
Gerardo Barbarov for Arduino day Seville 2019
|
|
https://github.com/gbarbarov/led-race
|
|
|
|
Public Repository for this code:
|
|
https://gitlab.com/open-led-race/olr-arduino
|
|
|
|
*/
|
|
|
|
/**
|
|
* ____________HARDWARE CONFIGURATION____________________
|
|
* __ __
|
|
* __ Compile-time settings (PIN_LED, PIN_AUDIO, etc) __
|
|
* __ are defined in [olr-settings.h] file __
|
|
* ______________________________________________________
|
|
*/
|
|
|
|
|
|
char const softwareId[] = "A4P0"; // A4P -> A = Open LED Race, 4P0 = Game ID (4P = 4 Players, 0=Type 0)
|
|
char const version[] = "0.9.9";
|
|
|
|
#include "open-led-race.h"
|
|
|
|
#include <Adafruit_NeoPixel.h>
|
|
#include <EEPROM.h>
|
|
#include "olr-lib.h"
|
|
#include "olr-controller.h"
|
|
#include "olr-param.h"
|
|
#include "SoftTimer.h"
|
|
#include "SerialCommand.h"
|
|
|
|
|
|
/*------------------------------------------------------*/
|
|
int win_music[] = {
|
|
2637, 2637, 0, 2637,
|
|
0, 2093, 2637, 0,
|
|
3136
|
|
};
|
|
/*------------------------------------------------------*/
|
|
|
|
|
|
static race_t race;
|
|
static car_t cars[ MAX_PLAYERS ];
|
|
static controller_t switchs[ MAX_PLAYERS ];
|
|
static track_t tck;
|
|
char tracksID[ NUM_TRACKS ][2] ={"U","M","B","I","O"};
|
|
|
|
static int countdown_phase=1;
|
|
static bool countdown_new_phase=true;
|
|
|
|
static int const eeadrInfo = 0;
|
|
|
|
// non blocking delays
|
|
SoftTimer startRace_delay = SoftTimer(); // Autostart, Countdown
|
|
SoftTimer demoMode_delay = SoftTimer(); // Activate Demo Mode on inactivity
|
|
SoftTimer telemetry_delay = SoftTimer(0); // Send Telemetry data
|
|
|
|
static byte s_motor=0;
|
|
static int t_beep=0;
|
|
static int f_beep=0;
|
|
|
|
|
|
char cmd[REC_COMMAND_BUFLEN]; // Stores command received by ReadSerialComand()
|
|
SerialCommand serialCommand = SerialCommand(cmd, REC_COMMAND_BUFLEN, EOL, &Serial); // get complete command from serial
|
|
char txbuff[TX_COMMAND_BUFLEN];
|
|
|
|
Adafruit_NeoPixel track;
|
|
|
|
static uint32_t car_color[]={
|
|
COLOR1,
|
|
COLOR2,
|
|
COLOR3,
|
|
COLOR4
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
*
|
|
*/
|
|
void setup() {
|
|
|
|
Serial.begin(115200);
|
|
randomSeed( analogRead(A6) + analogRead(A7) );
|
|
controller_setup( );
|
|
param_load( &tck.cfg );
|
|
|
|
// For SK6812 use NEO_RGBW, else NEO_GRB
|
|
// (NEO_RGBW for strips with white color leds)
|
|
track = Adafruit_NeoPixel( tck.cfg.track.nled_total, PIN_LED, NEO_RGBW + NEO_KHZ800 );
|
|
|
|
// First 2 controllers always active (Red, Green)
|
|
race.numcars = 2;
|
|
|
|
// Calculate actual players number
|
|
if( controller_isActive( DIGITAL_CTRL[CTRL_3] ) || param_option_is_active(&tck.cfg, PLAYER_3_OPTION) || param_option_is_active(&tck.cfg, PLAYER_4_OPTION) ) {
|
|
++race.numcars;
|
|
}
|
|
if( controller_isActive( DIGITAL_CTRL[CTRL_4] ) || param_option_is_active(&tck.cfg, PLAYER_4_OPTION)) {
|
|
++race.numcars;
|
|
}
|
|
|
|
// Check if DEMO mode is configured
|
|
race.demo_mode = param_option_is_active(&tck.cfg, DEMO_MODE_OPTION);
|
|
|
|
// enum ctr_type current_mode = (race.demo_mode == true) ? DEMO_MODE : DIGITAL_MODE;
|
|
// !!! Eliminare var current_mode ...mettere if contratto direttamente in f() call
|
|
|
|
// Initialize Controllers for very player
|
|
//set_controllers_mode(race.numcars, current_mode ) ;
|
|
set_controllers_mode(race.numcars, (race.demo_mode == true) ? DEMO_MODE : DIGITAL_MODE ) ;
|
|
|
|
// Initialize car for every player
|
|
init_cars(race.numcars);
|
|
|
|
track.begin();
|
|
strip_clear( &tck , false);
|
|
|
|
// Check Box before Physic/Sound to allow user to have Box and Physics with no sound
|
|
if(controller_isActive( DIGITAL_CTRL[CTRL_2]) || param_option_is_active(&tck.cfg, BOX_MODE_OPTION) ) { //push switch 2 on reset for activate boxes (pit lane)
|
|
box_init( &tck );
|
|
track_configure( &tck, tck.cfg.track.nled_total - tck.cfg.track.box_len );
|
|
draw_box_entrypoint( &tck );
|
|
} else{
|
|
track_configure( &tck, 0 );
|
|
}
|
|
|
|
if( controller_isActive( DIGITAL_CTRL[CTRL_1]) || param_option_is_active(&tck.cfg, SLOPE_MODE_OPTION) ) { // push switch 1 on reset for activate physics
|
|
ramp_init( &tck );
|
|
draw_ramp( &tck );
|
|
track.show();
|
|
delay(2000);
|
|
if ( controller_isActive( DIGITAL_CTRL[CTRL_1] ) ) { //retain push switch on reset for activate FX sound
|
|
s_motor=1;
|
|
tone(PIN_AUDIO,100);}
|
|
}
|
|
|
|
race.network_race = false; // always starts in standalone mode
|
|
race.demo_mode_on_received = false;
|
|
race.demo_mode_off_received = false;
|
|
|
|
race.cfg.startline = tck.cfg.race.startline; // always true for Standalone mode
|
|
race.cfg.nlap = tck.cfg.race.nlap; // NUMLAP;
|
|
race.cfg.nrepeat = tck.cfg.race.nrepeat; // always 1 for Standalone mode
|
|
race.cfg.finishline = tck.cfg.race.finishline; // always true for Standalone mode
|
|
|
|
startRace_delay.start(0); // first race starts with no delay
|
|
race.phase = READY; // READY is the first status for Standalone mode
|
|
|
|
// last_activity_millis = millis();
|
|
|
|
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
void loop() {
|
|
|
|
// look for commands received on serial
|
|
ack_t ack = manageSerialCommand();
|
|
if(ack.rp != NOTHING){
|
|
sendResponse(&ack);
|
|
}
|
|
|
|
// Exit DEMO mode when a Player touch a controller
|
|
if( race.demo_mode_off_received || (race.demo_mode && players_actity(race.numcars)) ){
|
|
exit_demo_mode();
|
|
}
|
|
// If demo_mode option is set in board configuration
|
|
// -> Enter demo mode after INACTIVITY_TIMEOUT_DELAY sec
|
|
if( race.demo_mode_on_received || (param_option_is_active(&tck.cfg, DEMO_MODE_OPTION) && race.demo_mode==false && ready_for_demo_mode()) ) {
|
|
activate_demo_mode();
|
|
}
|
|
|
|
|
|
// PLEASE NOTE:
|
|
// DO NOT call "track.show()" in the loop() while in configuration mode !!!
|
|
// It would mess up with Serial communication (receives only 2 bytes - if the
|
|
// string sent by the host is longer, it gets lost)
|
|
// In other phases (READY, RACING, etc) ONLY 2 bytes are guaranteed to be
|
|
// succesfully received - So "Enter Configuration Mode" command is just one byte (@)
|
|
|
|
switch(race.phase) {
|
|
|
|
case CONFIG:
|
|
{
|
|
if( race.newcfg ) { // Exit_Config command received
|
|
race.newcfg = false;
|
|
countdownReset();
|
|
startRace_delay.start(0);
|
|
// for Standalone mode, gets into READY status
|
|
// for Network races gets into CONFIGURATION OK status
|
|
race.phase = ( race.network_race == false ) ? READY : CONFIG_OK;
|
|
send_phase( race.phase );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CONFIG_OK: // OLR Network only
|
|
{
|
|
; // In a Relay Race the configuration is sent (via 'C' command) by the
|
|
// Host ("Nerwork Client" program running on another Computer)
|
|
// When the board reach the CONFIG_OK status...it does nothing but wait for
|
|
// the next Command coming form the Host.
|
|
// Same thing for the IDLE status (reached at the end of a relay race)
|
|
// In other words, in Network mode (Relay races), some Status changes comes from the Host
|
|
}
|
|
break;
|
|
|
|
case READY:
|
|
{
|
|
bool goOn=false;
|
|
|
|
if( race.cfg.startline ) { // Standalone: Always true - Network mode: only racetrack where race starts
|
|
|
|
if(param_option_is_active(&tck.cfg,AUTOSTART_MODE_OPTION) || race.demo_mode ) { // Autostart parameters ON
|
|
if(startRace_delay.elapsed()) goOn=true; // Automatically start Countdown after a defined Delay
|
|
// Note: In DemoMode always use AutoStart
|
|
} else { // Autostart OFF:
|
|
int pstart=0; // Wait for every controller be active (button pressed) to start Countdown
|
|
strip_clear( &tck, true );
|
|
for( int i = 0; i < race.numcars; ++i) {
|
|
if (controller_getStatus(cars[i].ct)==false) {
|
|
track.setPixelColor(i,cars[i].color);
|
|
pstart++;
|
|
}
|
|
}
|
|
track.setPixelColor(LED_SEMAPHORE , ((millis()/5)%64)*0x010100 );
|
|
track.show();
|
|
// if every controller activated -> Ready for Countdown
|
|
if (pstart==race.numcars) goOn=true;
|
|
};
|
|
}
|
|
|
|
if(goOn || (!race.cfg.startline)) { // Standalone mode is Ready for Countdown __OR__ Network mode and Race does not starts here
|
|
for( int i = 0; i < race.numcars; ++i) {
|
|
car_resetPosition( &cars[i], true );
|
|
cars[i].repeats = 0;
|
|
cars[i].st = CAR_WAITING; // Network race -> cleanup status of previous race
|
|
}
|
|
tck.ledcoin = COIN_RESET;
|
|
race.phase = COUNTDOWN;
|
|
if(race.network_race != true) send_phase( race.phase );
|
|
|
|
srand((unsigned long) analogRead(A6) + analogRead(A7)); // used in demo_mode (see olr_controllers.h)
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case COUNTDOWN:
|
|
{
|
|
if( race.cfg.startline ) { // Standalone: Always true - Network mode: only racetrack where race starts
|
|
// Countdown: semaphore and tones
|
|
if(start_race_done()) { // Countdown done
|
|
for( int i = 0; i < race.numcars; ++i ) {
|
|
cars[i].st = CAR_ENTER;
|
|
}
|
|
race.phase = RACING;
|
|
send_phase( race.phase );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RACING:
|
|
{
|
|
strip_clear( &tck, true );
|
|
|
|
if( box_isactive( &tck ) ) {
|
|
if( tck.ledcoin == COIN_RESET ) {
|
|
tck.ledcoin = COIN_WAIT;
|
|
tck.ledtime = millis() + random(2000,7000);
|
|
}
|
|
if( tck.ledcoin > 0 )
|
|
draw_coin( &tck );
|
|
else if( millis() > tck.ledtime )
|
|
tck.ledcoin = random( 20, tck.cfg.track.nled_aux - 20 );
|
|
|
|
} else {
|
|
if ( param_option_is_active(&tck.cfg, BATTERY_MODE_OPTION) ) { // Battery Mode ON
|
|
if( tck.ledcoin == COIN_RESET ) {
|
|
tck.ledcoin = COIN_WAIT;
|
|
tck.ledtime = millis() + random(3000,8000);
|
|
}
|
|
if( tck.ledcoin > 0 )
|
|
draw_coin( &tck );
|
|
else if( millis() > tck.ledtime )
|
|
tck.ledcoin = random( LED_SEMAPHORE+4, tck.cfg.track.nled_main - 60); //valid zone from random charge (semaphore to 1 meter before to start-finish position
|
|
}
|
|
}
|
|
|
|
for( int i = 0; i < race.numcars; ++i ) {
|
|
run_racecycle( &cars[i], i );
|
|
if( cars[i].st == CAR_FINISH ) {
|
|
race.phase = COMPLETE;
|
|
race.winner = (byte) i;
|
|
send_phase( race.phase );
|
|
break;
|
|
}
|
|
}
|
|
|
|
track.show();
|
|
if (s_motor==1) tone(PIN_AUDIO,f_beep+int(cars[0].speed*440*1)+int(cars[1].speed*440*2)+int(cars[2].speed*440*3)+int(cars[3].speed*440*4));
|
|
if (t_beep>0) {t_beep--;} else {f_beep=0;};
|
|
|
|
|
|
// Send Telemetry data
|
|
if(telemetry_delay.elapsed()) {
|
|
print_cars_positions( cars );
|
|
telemetry_delay.start(TELEMETRY_DELAY);
|
|
}
|
|
// ----------------
|
|
}
|
|
break;
|
|
|
|
case COMPLETE :
|
|
{
|
|
strip_clear( &tck, false );
|
|
track.show();
|
|
draw_winner( &tck, cars[race.winner].color );
|
|
sound_winner( &tck, race.winner );
|
|
strip_clear( &tck, false );
|
|
track.show();
|
|
|
|
startRace_delay.start(NEWRACE_DELAY);
|
|
|
|
// for Standalone mode, gets into READY status
|
|
// for Network races gets into IDLE statue
|
|
race.phase = ( race.network_race == false ) ? READY : IDLE;
|
|
}
|
|
break;
|
|
|
|
case IDLE: // OLR Network only
|
|
{
|
|
; // -- see comment in CONFIG_OK status
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
sprintf( txbuff, "SwErr-01");
|
|
printdebug( txbuff, WARNING );
|
|
break;
|
|
}
|
|
|
|
} // switch race.phase
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
void set_controllers_mode(uint8_t numctrl, enum ctr_type mode ) {
|
|
for( uint8_t i = 0; i < numctrl; ++i) {
|
|
//enum ctr_type mode;
|
|
controller_init( &switchs[i], mode, DIGITAL_CTRL[i] );
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
void init_cars(uint8_t numcars ) {
|
|
for( uint8_t i = 0; i < numcars; ++i) {
|
|
car_init( &cars[i], &switchs[i], car_color[i] );
|
|
}
|
|
}
|
|
|
|
bool players_actity(uint8_t numcars ) {
|
|
for( uint8_t i = 0; i < numcars; ++i) {
|
|
if(controller_isActive(DIGITAL_CTRL[i]))
|
|
return(true);
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
/*
|
|
* Check if Controllers (players) were incative for more than INACTIVITY_TIMEOUT_DELAY sec
|
|
*/
|
|
bool ready_for_demo_mode(void) {
|
|
if(players_actity(race.numcars)){
|
|
demoMode_delay.start((unsigned long) INACTIVITY_TIMEOUT_DELAY * 1000); // Reset timeout when somebody is using controllers
|
|
}
|
|
return (demoMode_delay.elapsed());
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
void activate_demo_mode(void){
|
|
race.demo_mode = true;
|
|
race.demo_mode_on_received = false; // reset flag
|
|
set_controllers_mode(race.numcars, DEMO_MODE ) ;
|
|
race.winner=0; // force a fake winner (used in Status=Complete by draw_winner())
|
|
race.phase = COMPLETE;
|
|
|
|
sprintf(txbuff, "%c%d%c", 'M', 1 , EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
void exit_demo_mode(void){
|
|
race.demo_mode = false;
|
|
race.demo_mode_off_received = false; // reset flag
|
|
set_controllers_mode(race.numcars, DIGITAL_MODE ) ;
|
|
race.winner=0; // force a fake winner (used in Status=Complete by draw_winner())
|
|
race.phase = COMPLETE;
|
|
|
|
sprintf(txbuff, "%c%d%c", 'M', 0 , EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
}
|
|
|
|
void send_phase( int phase ) {
|
|
sprintf(txbuff, "R%d%c",phase,EOL);
|
|
serialCommand.sendCommand(txbuff);
|
|
}
|
|
|
|
|
|
void run_racecycle( car_t *car, int caridx ) {
|
|
struct cfgtrack const* cfg = &tck.cfg.track;
|
|
|
|
// if( car->st == CAR_COMING ) { // OLR Network only
|
|
// // To be implemented
|
|
// }
|
|
|
|
if( car->st == CAR_ENTER ) {
|
|
// Standalone mode => On Race start the Speed get RESET (speed=0)
|
|
// Network race => Car speed set when receiving the Car_Enter Serial command
|
|
(race.network_race == true) ? car_resetPosition( car, false ) : car_resetPosition( car, true );
|
|
|
|
if( car->repeats < race.cfg.nrepeat )
|
|
car->st = CAR_RACING;
|
|
else
|
|
car->st = CAR_GO_OUT;
|
|
}
|
|
|
|
if( car->st == CAR_RACING ) {
|
|
update_track( &tck, car );
|
|
car_updateController( car );
|
|
draw_car( &tck, car );
|
|
|
|
if( car->nlap == race.cfg.nlap
|
|
&& !car->leaving
|
|
&& car->dist > ( cfg->nled_main*car->nlap - race.circ.outtunnel ) ) {
|
|
car->leaving = true;
|
|
car->st = CAR_LEAVING;
|
|
}
|
|
|
|
if( car->nlap > race.cfg.nlap ) {
|
|
++car->repeats;
|
|
car->st = CAR_GO_OUT;
|
|
}
|
|
|
|
if( car->repeats >= race.cfg.nrepeat
|
|
&& race.cfg.finishline ) {
|
|
car->st = CAR_FINISH;
|
|
}
|
|
}
|
|
|
|
if( car->st == CAR_LEAVING ) { // OLR Network only
|
|
car->st = CAR_RACING;
|
|
sprintf( txbuff, "r%d%c", caridx + 1, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
}
|
|
|
|
if( car->st == CAR_GO_OUT ) { // OLR Network only
|
|
car->st = CAR_WAITING;
|
|
//map car number in 3 higher bits and car speed in 5 lower bits
|
|
byte const speed = car->speed * 10;
|
|
byte const data = (caridx + 1) << 5 | ( 0b00011111 & speed );
|
|
sprintf( txbuff, "s%c%c", data, EOL );
|
|
serialCommand.sendCommand(txbuff);;
|
|
car_resetPosition( car, true );
|
|
car->trackID = NOT_TRACK;
|
|
}
|
|
|
|
if ( car->st == CAR_FINISH ){
|
|
car->trackID = NOT_TRACK;
|
|
sprintf( txbuff, "w%d%c", caridx + 1, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
|
|
car_resetPosition(car, true);
|
|
}
|
|
}
|
|
|
|
|
|
int get_relative_position( car_t* car ) {
|
|
enum{
|
|
MIN_RPOS = 0,
|
|
MAX_RPOS = 99,
|
|
};
|
|
struct cfgtrack const* cfg = &tck.cfg.track;
|
|
int trackdist = 0;
|
|
int pos = 0;
|
|
|
|
switch ( car->trackID ){
|
|
case TRACK_MAIN:
|
|
trackdist = (int)car->dist % cfg->nled_main;
|
|
pos = map(trackdist, 0, cfg->nled_main -1, MIN_RPOS, MAX_RPOS);
|
|
break;
|
|
case TRACK_AUX:
|
|
trackdist = (int)car->dist_aux;
|
|
pos = map(trackdist, 0, cfg->nled_aux -1, MIN_RPOS, MAX_RPOS);
|
|
break;
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
|
|
void print_cars_positions( car_t* cars ) {
|
|
|
|
bool outallcar = true;
|
|
for( int i = 0; i < race.numcars; ++i)
|
|
outallcar &= cars[i].st == CAR_WAITING;
|
|
|
|
if ( outallcar ) return;
|
|
|
|
for( int i = 0; i < race.numcars; ++i ) {
|
|
int const rpos = get_relative_position( &cars[i] );
|
|
sprintf( txbuff, "p%d%s%d,%d,%d%c", i + 1, tracksID[cars[i].trackID], cars[i].nlap, rpos,(int)cars[i].battery, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* non-blocking
|
|
*/
|
|
boolean start_race_done( ) {
|
|
if(countdown_new_phase){
|
|
countdown_new_phase=false;
|
|
startRace_delay.start(CONTDOWN_PHASE_DURATION);
|
|
strip_clear( &tck , true);
|
|
switch(countdown_phase) {
|
|
case 1:
|
|
tone(PIN_AUDIO,400);
|
|
track.setPixelColor(LED_SEMAPHORE, track.Color(255,0,0));
|
|
break;
|
|
case 2:
|
|
tone(PIN_AUDIO,600);
|
|
track.setPixelColor(LED_SEMAPHORE, track.Color(0,0,0));
|
|
track.setPixelColor(LED_SEMAPHORE-1, track.Color(255,255,0));
|
|
break;
|
|
case 3:
|
|
tone(PIN_AUDIO,1200);
|
|
track.setPixelColor(LED_SEMAPHORE-1, track.Color(0,0,0));
|
|
track.setPixelColor(LED_SEMAPHORE-2, track.Color(0,255,0));
|
|
break;
|
|
case 4:
|
|
startRace_delay.start(CONTDOWN_STARTSOUND_DURATION);
|
|
tone(PIN_AUDIO,880);
|
|
track.setPixelColor(LED_SEMAPHORE-2, track.Color(0,0,0));
|
|
track.setPixelColor(0, track.Color(255,255,255));
|
|
break;
|
|
case 5:
|
|
noTone(PIN_AUDIO);
|
|
countdownReset(); // reset for next countdown
|
|
return(true);
|
|
}
|
|
track.show();
|
|
}
|
|
if(startRace_delay.elapsed()) {
|
|
noTone(PIN_AUDIO);
|
|
countdown_new_phase=true;
|
|
countdown_phase++;
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
void countdownReset() {
|
|
countdown_phase=1;
|
|
countdown_new_phase=true;
|
|
}
|
|
|
|
|
|
void sound_winner( track_t* tck, byte winner ) {
|
|
int const msize = sizeof(win_music) / sizeof(int);
|
|
for (int note = 0; note < msize; note++) {
|
|
tone(PIN_AUDIO, win_music[note],200);
|
|
delay(230);
|
|
noTone(PIN_AUDIO);
|
|
}
|
|
}
|
|
|
|
|
|
void strip_clear( track_t* tck, bool show_settings ) {
|
|
struct cfgtrack const* cfg = &tck->cfg.track;
|
|
for( int i=0; i < cfg->nled_main; i++)
|
|
track.setPixelColor( i, track.Color(0,0,0) );
|
|
|
|
for( int i=0; i < cfg->nled_aux; i++)
|
|
track.setPixelColor( cfg->nled_main+i, track.Color(0,0,0) );
|
|
|
|
if(show_settings) {
|
|
if( ramp_isactive( tck ))
|
|
draw_ramp( tck );
|
|
if( box_isactive( tck ) )
|
|
draw_box_entrypoint( tck );
|
|
}
|
|
}
|
|
|
|
|
|
void draw_coin( track_t* tck ) {
|
|
struct cfgtrack const* cfg = &tck->cfg.track;
|
|
track.setPixelColor( 1 + cfg->nled_main + cfg->nled_aux - tck->ledcoin,COLOR_COIN );
|
|
}
|
|
|
|
void draw_winner( track_t* tck, uint32_t color) {
|
|
struct cfgtrack const* cfg = &tck->cfg.track;
|
|
for(int i=16; i < cfg->nled_main; i=i+(8 * cfg->nled_main / 300 )){
|
|
track.setPixelColor( i , color );
|
|
track.setPixelColor( i-16 ,0 );
|
|
track.show();
|
|
}
|
|
}
|
|
|
|
void draw_car_tail( track_t* tck, car_t* car ) {
|
|
struct cfgtrack const* cfg = &tck->cfg.track;
|
|
|
|
switch ( car->trackID ){
|
|
case TRACK_MAIN:
|
|
for(int i=0; i<= car->nlap; ++i )
|
|
track.setPixelColor( ((word)car->dist % cfg->nled_main) + i, car->color );
|
|
break;
|
|
case TRACK_AUX:
|
|
for(int i=0; i<= car->nlap; ++i )
|
|
track.setPixelColor( (word)(cfg->nled_main + cfg->nled_aux - car->dist_aux) + i, car->color);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void draw_car( track_t* tck, car_t* car ) {
|
|
struct cfgtrack const* cfg = &tck->cfg.track;
|
|
struct cfgbattery const* battery = &tck->cfg.battery;
|
|
|
|
switch ( car->trackID ){
|
|
case TRACK_MAIN:
|
|
for(int i=0; i<=1; ++i )
|
|
track.setPixelColor( ((word)car->dist % cfg->nled_main) - i, car->color );
|
|
// uint8_t carlenght = car->nlap < 6 ? car->nlap : 6; // Max cartatail lenght = 7
|
|
// for(int i=0; i<= carlenght; ++i )
|
|
// track.setPixelColor( ((word)car->dist % cfg->nled_main) + i, car->color );
|
|
if(param_option_is_active(&tck->cfg, BATTERY_MODE_OPTION)){ // Battery Mode ON
|
|
if ( car->charging==1 ) {
|
|
track.setPixelColor( ((word)car->dist % cfg->nled_main) - 2, 0x010100 * 50*(millis()/(201-2*(byte)car->battery)%2));
|
|
} else if (car->battery <= battery->min)
|
|
if ((millis()%100)>50) track.setPixelColor( ((word)car->dist % cfg->nled_main) - 2, WARNING_BLINK_COLOR );
|
|
}
|
|
break;
|
|
case TRACK_AUX:
|
|
for(int i=0; i<=1; ++i )
|
|
track.setPixelColor( (word)(cfg->nled_main + cfg->nled_aux - car->dist_aux) + i, car->color);
|
|
if(param_option_is_active(&tck->cfg, BATTERY_MODE_OPTION)){ // Battery Mode ON
|
|
|
|
if ( car->charging==1 ) {
|
|
track.setPixelColor( (word)(cfg->nled_main + cfg->nled_aux - car->dist_aux) + 2, 0x010100 * 50*(millis()/(201-2*(byte)car->battery)%2));
|
|
} else if (car->battery <= battery->min)
|
|
if ((millis()%100)>50)
|
|
track.setPixelColor( (word)(cfg->nled_main + cfg->nled_aux - car->dist_aux) + 2, WARNING_BLINK_COLOR);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Display on LED Strip current values for Slope and Pitlane
|
|
*
|
|
*/
|
|
void show_cfgpars_onstrip(){
|
|
strip_clear( &tck, true );
|
|
track.show();
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
*/
|
|
void draw_ramp( track_t* _tck ) {
|
|
struct cfgramp const* r = &_tck->cfg.ramp;
|
|
byte dist = 0;
|
|
byte intensity = 0;
|
|
for( int i = r->init; i <= r->center; ++i ) {
|
|
dist = r->center - r->init;
|
|
intensity = ( 32 * (i - r->init) ) / dist;
|
|
track.setPixelColor( i, track.Color( intensity,0,intensity ) );
|
|
}
|
|
for( int i = r->center; i <= r->end; ++i ) {
|
|
dist = r->end - r->center;
|
|
intensity = ( 32 * ( r->end - i ) ) / dist;
|
|
track.setPixelColor( i, track.Color( intensity,0,intensity ) );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
*/
|
|
void draw_box_entrypoint( track_t* _tck ) {
|
|
struct cfgtrack const* cfg = &_tck->cfg.track;
|
|
int out = cfg->nled_total - cfg->box_len; // Pit lane exit (race start)
|
|
int in = out - cfg->box_len; // Pit lane Entrance
|
|
track.setPixelColor(in ,COLOR_BOXMARKS );
|
|
track.setPixelColor(out ,COLOR_BOXMARKS );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Check Serial to see if there is a command ready to be processed
|
|
*
|
|
*/
|
|
ack_t manageSerialCommand() {
|
|
|
|
ack_t ack = { .rp = NOTHING, .type = '\0' };
|
|
|
|
int clen = serialCommand.checkSerial();
|
|
if(clen == 0) return ack; // No commands received
|
|
|
|
if(clen < 0) { // Error receiving command
|
|
sprintf( txbuff, "Error reading serial command:[%d]",clen);
|
|
printdebug( txbuff, WARNING );
|
|
}
|
|
|
|
// clen > 0 ---> Command with length=clen ready in cmd[]
|
|
ack.rp=NOK;
|
|
|
|
|
|
// Debug only
|
|
//if(race.network_race == true) {
|
|
// sprintf( txbuff, "Recv cmd:%s", cmd);
|
|
// printdebug( txbuff, WARNING );
|
|
//}
|
|
|
|
|
|
switch (cmd[0]) {
|
|
|
|
case '#': // Handshake
|
|
{
|
|
ack.type = cmd[0];
|
|
sprintf( txbuff, "#%c", EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
ack.rp = NOTHING;
|
|
}
|
|
break;
|
|
|
|
case '@' : // Enter "Configuration Mode" status
|
|
{
|
|
ack.type = cmd[0];
|
|
if(race.phase != CONFIG) {// Ignore command if Board already in "Configure Mode"
|
|
race.phase = CONFIG;
|
|
enter_configuration_mode();
|
|
}
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
case '*' : // Exit "Configure Mode"
|
|
{
|
|
ack.type = cmd[0];
|
|
if(race.phase == CONFIG) { // Ignore command if Board is not in "Configure Mode"
|
|
race.newcfg = true;
|
|
}
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
case 'R' : // Set Race Phase
|
|
{
|
|
ack.type = cmd[0];
|
|
uint8_t const phase = atoi( cmd + 1);
|
|
/**
|
|
* Reintrodotto momentaneamente R1=enter config per testare RelayRace con Networkclient esistente
|
|
// Does not accept anymore R=1 as Enter Configuration / Use command @ instead
|
|
if( 0 > phase || RACE_PHASES <= phase || phase == CONFIG) return ack;
|
|
race.phase = (enum phases) phase;
|
|
ack.rp = OLR_OK;
|
|
**/
|
|
// Codice vecchio con R1=Enter Configuration
|
|
if( 0 > phase || RACE_PHASES <= phase) return ack;
|
|
race.phase = (enum phases) phase;
|
|
ack.rp = OLR_OK;
|
|
if ( race.phase == CONFIG ) { // accept R1 as a EnterConfigurationMode command - DEPRECATED
|
|
enter_configuration_mode();
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 'u' : // Car Enter the Circuit - // OLR Network only
|
|
{
|
|
ack.type = cmd[0];
|
|
byte const data = cmd[1];
|
|
byte const ncar = 0b00000111 & ( data >> 5 );
|
|
byte const speed = 0b00011111 & data;
|
|
if( 0 >= ncar || race.numcars < ncar) return ack;
|
|
cars[ncar-1].st = CAR_ENTER;
|
|
cars[ncar-1].speed = (float) speed / 10;
|
|
ack.rp = OLR_OK;
|
|
ack.rp = NOTHING;
|
|
if( false ) {
|
|
sprintf( txbuff, "%s %d, %s %d, %s %d", "CAR: ", ncar, "STATUS: ", cars[ncar-1].st, "SPEED: ", (int)(cars[ncar-1].speed * 10) );
|
|
printdebug( txbuff, LOG );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 't' : // Car Coming into the Circuit - // OLR Network only
|
|
{
|
|
ack.type = cmd[0];
|
|
byte const ncar = atoi( cmd + 1);
|
|
if( 0 >= ncar || race.numcars < ncar) return ack;
|
|
cars[ncar-1].st = CAR_COMING;
|
|
ack.rp = OLR_OK;
|
|
if ( false ) {
|
|
sprintf( txbuff, "%s %d, %s %d", "CAR: ", ncar, "STATUS: ", cars[ncar-1].st);
|
|
printdebug( txbuff, LOG );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'w' : // Car Wins the race - OLR Network only
|
|
// Standalone mode: Board _NEVER_ receives a 'w' command !!!
|
|
{ // Network mode: 1) Command "w" sent by the Board where the race ends
|
|
// 2) Every other participant (Board) receives 'w' command
|
|
ack.type = cmd[0];
|
|
byte const ncar = atoi( cmd + 1);
|
|
if( 0 >= ncar || race.numcars < ncar) return ack;
|
|
if( race.network_race && (!race.cfg.finishline)) {
|
|
race.winner = (byte) ncar-1; // Set the Winner
|
|
}
|
|
ack.rp = NOTHING;
|
|
}
|
|
break;
|
|
|
|
|
|
case 'C' : //Parse race configuration -> C1,2,3,0
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"C");
|
|
if( !pch ) return ack;
|
|
|
|
pch = strtok (pch, "," );
|
|
if( !pch ) return ack;
|
|
int startline = atoi( pch );
|
|
|
|
pch = strtok (NULL, ",");
|
|
if( !pch ) return ack;
|
|
int nlap = atoi( pch );
|
|
|
|
pch = strtok (NULL, ",");
|
|
if( !pch ) return ack;
|
|
int nrepeat = atoi( pch );
|
|
|
|
pch = strtok (NULL, ",");
|
|
if( !pch ) return ack;
|
|
int finishline = atoi( pch );
|
|
|
|
int err = race_configure( &tck, startline, nlap, nrepeat, finishline);
|
|
if( err ) return ack;
|
|
|
|
race.cfg.startline = tck.cfg.race.startline;
|
|
race.cfg.nlap = tck.cfg.race.nlap;
|
|
race.cfg.nrepeat = tck.cfg.race.nrepeat;
|
|
race.cfg.finishline = tck.cfg.race.finishline;
|
|
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
|
|
case 'T' : //Parse Track configuration -> Track length
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"T");
|
|
if( !pch ) return ack;
|
|
|
|
int nled = atoi( cmd + 1 );
|
|
int err = tracklen_configure( &tck, nled);
|
|
if( err ) return ack;
|
|
track_configure( &tck, 0);
|
|
if( err ) return ack;
|
|
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
case 'B' : //Parse BoxLenght Configuration -> Blen,perm
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"B");
|
|
if( !pch ) return ack;
|
|
|
|
pch = strtok (pch, "," );
|
|
if( !pch ) return ack;
|
|
int boxlen = atoi( pch );
|
|
|
|
pch = strtok (NULL, "," );
|
|
if( !pch ) return ack;
|
|
int boxperm = atoi( pch );
|
|
|
|
int err = boxlen_configure( &tck, boxlen, boxperm );
|
|
if( err ) return ack;
|
|
|
|
ack.rp = OLR_OK;
|
|
|
|
// Force Pitlane ON, so "show_cfgpars_onstrip()"
|
|
// will show the new values, even if AlwaysON=false
|
|
box_init(&tck);
|
|
show_cfgpars_onstrip();
|
|
}
|
|
break;
|
|
|
|
case 'A' : // Parse Ramp configuration -> Astart,center,end,high,perm
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"A");
|
|
if( !pch ) return ack;
|
|
|
|
pch = strtok (pch, "," );
|
|
if( !pch ) return ack;
|
|
int init = atoi( pch );
|
|
|
|
pch = strtok (NULL, "," );
|
|
if( !pch ) return ack;
|
|
int center = atoi( pch );
|
|
|
|
pch = strtok (NULL, "," );
|
|
if( !pch ) return ack;
|
|
int end = atoi( pch );
|
|
|
|
pch = strtok (NULL, ",");
|
|
if( !pch ) return ack;
|
|
int high = atoi( pch );
|
|
|
|
pch = strtok (NULL, ",");
|
|
if( !pch ) return ack;
|
|
int slopeperm = atoi( pch );
|
|
|
|
uint8_t err = ramp_configure( &tck, init, center, end, high, slopeperm );
|
|
if( err ) return ack;
|
|
ack.rp =OLR_OK;
|
|
|
|
// Force Ramp ON, so "show_cfgpars_onstrip()"
|
|
// will show the new values, even if AlwaysON=false
|
|
ramp_init(&tck);
|
|
|
|
show_cfgpars_onstrip();
|
|
}
|
|
break;
|
|
|
|
case 'E' : // Parse Battery configuration -> Edelta,min,boost,active
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"E");
|
|
if( !pch ) return ack;
|
|
|
|
pch = strtok (pch, "," );
|
|
if( !pch ) return ack;
|
|
uint8_t delta = atoi( pch );
|
|
|
|
pch = strtok (NULL, "," );
|
|
if( !pch ) return ack;
|
|
uint8_t min = atoi( pch );
|
|
|
|
pch = strtok (NULL, "," );
|
|
if( !pch ) return ack;
|
|
uint8_t boost = atoi( pch );
|
|
|
|
pch = strtok (NULL, ",");
|
|
if( !pch ) return ack;
|
|
uint8_t active = atoi( pch );
|
|
|
|
uint8_t err = battery_configure( &tck, delta, min, boost, active );
|
|
if( err ) return ack;
|
|
ack.rp = OLR_OK;
|
|
|
|
}
|
|
break;
|
|
|
|
case 'G' : // Parse Autostart configuration -> Gautostart
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"G");
|
|
if( !pch ) return ack;
|
|
|
|
uint8_t autostart = atoi( cmd + 1 );
|
|
uint8_t err = autostart_configure( &tck, autostart);
|
|
if( err ) return ack;
|
|
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
case 'M' : // Parse DEMO mode configuration
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"M");
|
|
if( !pch ) return ack;
|
|
|
|
uint8_t demo = atoi( cmd + 1 );
|
|
|
|
uint8_t err = demo_configure( &tck, demo);
|
|
if( err ) return ack;
|
|
ack.rp = OLR_OK;
|
|
|
|
if(demo == 0) {
|
|
race.demo_mode_off_received = true;
|
|
} else if( race.demo_mode){
|
|
race.demo_mode_on_received = true;
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 'P' : // Parse Player 3/4 configuration -> P[2|3|4]
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"P");
|
|
if( !pch ) return ack;
|
|
|
|
uint8_t players_n = atoi( cmd + 1 );
|
|
uint8_t err = players_n_configure( &tck, players_n);
|
|
if( err ) return ack;
|
|
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'K': // Parse Physic simulation parameters
|
|
{
|
|
ack.type = cmd[0];
|
|
|
|
char * pch = strtok (cmd,"K");
|
|
if( !pch ) return ack;
|
|
|
|
pch = strtok (pch, "," );
|
|
if( !pch ) return ack;
|
|
float kgp = atof( pch );
|
|
|
|
pch = strtok (NULL, "," );
|
|
if( !pch ) return ack;
|
|
float kfp = atof( pch );
|
|
|
|
int err = physic_configure( &tck, kgp, kfp );
|
|
if( err ) return ack;
|
|
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
case 'H' : // Tunnel configuration - // OLR Network only
|
|
{
|
|
ack.type = cmd[0];
|
|
uint8_t const dtunnel = atoi( cmd + 1);
|
|
if( 0 >= dtunnel || 254 < dtunnel) return ack;
|
|
race.circ.outtunnel = dtunnel;
|
|
ack.rp = OLR_OK;
|
|
if ( false ) { //VERBOSE
|
|
sprintf( txbuff, "%s %d", "TUNNEL: ", race.circ.outtunnel );
|
|
printdebug( txbuff, LOG );
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case 'D' : // Load Default Parameters and store them in from EEPROM
|
|
{
|
|
ack.type = cmd[0];
|
|
param_setdefault( &tck.cfg );
|
|
EEPROM.put( eeadrInfo, tck.cfg ); // Save immediately
|
|
|
|
ack.rp = OLR_OK;
|
|
|
|
// Update box/slope active in current Track Struct with values
|
|
// just loaded (for show_cfgpars_onstrip())
|
|
struct cfgparam const* cfg = &tck.cfg;
|
|
tck.boxactive = param_option_is_active(&tck.cfg, BOX_MODE_OPTION);
|
|
tck.rampactive = param_option_is_active(&tck.cfg, SLOPE_MODE_OPTION);
|
|
|
|
show_cfgpars_onstrip();
|
|
}
|
|
break;
|
|
|
|
case ':' : // Set board Unique Id
|
|
{
|
|
struct brdinfo* info = &tck.cfg.info;
|
|
ack.type = cmd[0];
|
|
if( strlen(cmd + 1) > LEN_UID ) return ack;
|
|
strcpy( info->uid, cmd + 1 );
|
|
|
|
sprintf( txbuff, "%s%s%c", "$", cmd + 1, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
sprintf( txbuff, "%s%s%c", "$", info->uid, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
|
|
EEPROM.put( eeadrInfo, tck.cfg ); // Save immediately
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
case '$': // Get Board UID
|
|
{
|
|
sprintf( txbuff, "%s%s%c", "$", tck.cfg.info.uid, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
ack.rp = NOTHING;
|
|
}
|
|
break;
|
|
|
|
case '?' : // Get Software Id
|
|
{
|
|
sprintf( txbuff, "%s%s%c", "?", softwareId, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
ack.rp = NOTHING;
|
|
}
|
|
break;
|
|
|
|
case '%' : // Get Software Version
|
|
{
|
|
sprintf( txbuff, "%s%s%c", "%", version, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
ack.rp = NOTHING;
|
|
}
|
|
break;
|
|
|
|
case 'n' : // Set "Network Race" mode (Relay race)
|
|
{
|
|
ack.type = cmd[0];
|
|
race.network_race = true;
|
|
race.phase = COMPLETE; // Immediatly ends the current race (if any)
|
|
race.winner=0; // Set a fake winner (used in Status=Complete by draw_winner())
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
case 'Q': // Get current configuration Info
|
|
{
|
|
struct cfgparam const* cfg = &tck.cfg;
|
|
sprintf( txbuff, "%s:%d,%d,%d,%d,%d,%d,%d.%03d,%d.%03d,%d%c", "QTK",
|
|
cfg->track.nled_total,
|
|
cfg->track.nled_main,
|
|
cfg->track.nled_aux,
|
|
cfg->track.init_aux,
|
|
cfg->track.box_len,
|
|
//cfg->track.box_alwaysOn,
|
|
param_option_is_active(&tck.cfg, BOX_MODE_OPTION),
|
|
(int)cfg->track.kg, (int)(cfg->track.kg*1000)%1000, // std arduino sprintf() missing %f
|
|
(int)cfg->track.kf, (int)(cfg->track.kf*1000)%1000, // std arduino sprintf() missing %f
|
|
param_option_is_active(&tck.cfg, AUTOSTART_MODE_OPTION),
|
|
EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
|
|
sprintf( txbuff, "%s:%d,%d,%d,%d,%d%c", "QRP",
|
|
cfg->ramp.init,
|
|
cfg->ramp.center,
|
|
cfg->ramp.end,
|
|
cfg->ramp.high,
|
|
//cfg->ramp.alwaysOn,
|
|
param_option_is_active(&tck.cfg, SLOPE_MODE_OPTION),
|
|
EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
|
|
sprintf( txbuff, "%s:%d,%d,%d,%d%c", "QBT",
|
|
cfg->battery.delta,
|
|
cfg->battery.min,
|
|
cfg->battery.speed_boost_scaler,
|
|
param_option_is_active(&tck.cfg, BATTERY_MODE_OPTION),
|
|
EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
|
|
sprintf( txbuff, "%s:%d,%d,%d,%d,%d,%d,%d,%d%c", "QRC",
|
|
cfg->race.startline,
|
|
cfg->race.nlap,
|
|
cfg->race.nrepeat,
|
|
cfg->race.finishline,
|
|
param_option_is_active(&tck.cfg, PLAYER_3_OPTION),
|
|
param_option_is_active(&tck.cfg, PLAYER_4_OPTION),
|
|
param_option_is_active(&tck.cfg, DEMO_MODE_OPTION),
|
|
//race.demo_mode,
|
|
race.network_race,
|
|
EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
|
|
ack.rp = NOTHING;
|
|
}
|
|
break;
|
|
|
|
case 'W': // Write configuration to EEPROM
|
|
{
|
|
ack.type = cmd[0];
|
|
EEPROM.put( eeadrInfo, tck.cfg );
|
|
ack.rp = OLR_OK;
|
|
}
|
|
break;
|
|
|
|
} // switch
|
|
|
|
return(ack);
|
|
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
void sendResponse( ack_t *ack) {
|
|
if(ack->type=='\0'){
|
|
sprintf(txbuff, "%s%c", ack->rp==OLR_OK? "OK":"NOK" , EOL );
|
|
} else {
|
|
sprintf(txbuff, "%c%s%c", ack->type, ack->rp==OLR_OK? "OK":"NOK" , EOL );
|
|
}
|
|
serialCommand.sendCommand(txbuff);
|
|
}
|
|
|
|
/*
|
|
* Send Log/Warning/Error messages to host
|
|
*/
|
|
void printdebug( const char * msg, int errlevel ) {
|
|
char header [5];
|
|
sprintf(header, "!%d,",errlevel);
|
|
Serial.print(header);
|
|
Serial.print(msg);
|
|
Serial.print(EOL);
|
|
}
|
|
|
|
|
|
/*
|
|
* reset race parameters
|
|
* stop sound
|
|
*/
|
|
void enter_configuration_mode(){
|
|
noTone(PIN_AUDIO);
|
|
strip_clear( &tck, false );
|
|
track.show();
|
|
}
|
|
|
|
|
|
|
|
void param_load( struct cfgparam* cfg ) {
|
|
|
|
/**
|
|
// Ignore EEPROM params during development of a new version of the [cfgparam]
|
|
param_setdefault( &tck.cfg );
|
|
sprintf( txbuff, "%s%c", "Temporary....DEFAULT PAREMETRS LOADED ", EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
return;
|
|
**/
|
|
|
|
EEPROM.get( eeadrInfo, tck.cfg );
|
|
|
|
// sprintf( txbuff, "%s:%d%c", "EEPROM-v", tck.cfg.ver, EOL );
|
|
// serialCommand.sendCommand(txbuff);
|
|
|
|
if ( tck.cfg.ver != CFGPARAM_VER ) { // [cfgparam.ver] read form EEPROM != [#define CFGPARAM_VER] in the code
|
|
// Each time a new version of the code modify the [cfgparam] struct, [#define CFGPARAM_VER] is also
|
|
// changed to force the code enter here.
|
|
// The previous values stored in EEPROM are invalid and need to be reset-to-default and
|
|
// stored in the EEPROM again with the new "structure"
|
|
param_setdefault( &tck.cfg );
|
|
EEPROM.put( eeadrInfo, tck.cfg );
|
|
sprintf( txbuff, "%s:%d%c", "DEFAULT->EEPROM-v)", tck.cfg.ver, EOL );
|
|
serialCommand.sendCommand(txbuff);
|
|
}
|
|
|
|
}
|