Shown below is the code that was used to interface between the ArxRobot mobile application and the 3DoT board itself. This relies heavily on the custom command IDs and the command handler functions that correspond to them. The main component of this block of code would be the MOVE command, which will drive MarioBot forward, as well as implementing our steering mechanism. Various additional features of our game logic are included as well. This is also important as it ties all the functional and game code together.

ArxRobot App + Driving + Steering

ArxRobot ArxRobot;       // instantiated as ArxRobot at end of class header
Servo servoA;
Motor motorA;       // motorA object 
Motor motorB;       // motorB object
Neotimer myTimer = Neotimer(2000);      // delay for testing
Neotimer hitTimer = Neotimer(2000);     // delay for when hit with green shell
Neotimer boostTimer = Neotimer(1500);   // delay for boost turn on 
#define loadSwitch 15
#define MOVE         0x01
#define setTotalLaps 0x44     // command IDs
#define useItem      0x45     // 0x00 --> 0x3F are used for built-in commands
#define startRace    0x46     // custom commands can use 0x40 --> 0x5F
#define gameMode     0x47
#define raceClass 0x48
#define updateMushroom 0x49
#define updateHeart  0x50
#define updateGreenShell 0x51
#define updateLapsRemaining 0x52
#define updateLapsCompleted   0x53
int lapCounter;
int lapTotal;
int maxLapCount = 2;
unsigned long startTime;
unsigned long totalTime;
const uint8_t CMD_LIST_SIZE = 11; // total number of commands
//angles have been experimentally adjusted based on servo orientation 
// param array includes 4 indexes     
// param[0] = motorA direction ; 
//0x01 = FORWARD , 0x02 = BACKWARD , 0x04 = Slider Released
// param[1] = motorA speed
// param[2] = motorB direction 
// param[3] = motorB speed
// COMMAND HANDLERS

bool moveHandler (uint8_t cmd, uint8_t param[], uint8_t n)
{
    int pwm;
    if( raceSpeedFast == TRUE){
        pwm = 255;
    }else{
        pwm = 100;
    }

//    
//    Serial.print(param[0]);
//    Serial.print(" , ");
//    Serial.print(param[1]);
//    Serial.print(" , ");
//    Serial.print(param[2]);
//    Serial.print(" , ");
//    Serial.println(param[3]);

    if (param[0] == 0x02 && param[2]==0x01 && moveEnabled == TRUE){   //turns servo left
      //servoA.write(120);
      servoA.write(120); // denil's servo
      motorA.go(1,pwm);
      motorB.go(1,255);

      // when we have chassis, include differential steering
      return false;
    }    

    if (param[0] == 0x01 && param[2]==0x02 && moveEnabled == TRUE){   //turns servo right
      servoA.write(60);
      //servoA.write(0); denils servo
      motorA.go(1,255);
      motorB.go(1,pwm);
      // when we have chassis, include differential steering
    return false;
    }
    if (param[0]==0x04 && param[2]==0x04 && moveEnabled == TRUE){     // nothing "stall"
      servoA.write(90);
      //servoA.write(60); / denil's servo
    }
    if (param[0] == 1 && param[2] == 1 && moveEnabled == TRUE) {  //go straight
      motorA.go(1, 255);
      motorB.go(1, 255);
    }

}  // moveHandler

bool setTotalLapsHandler(uint8_t cmd, uint8_t param[], uint8_t n){
    Serial.print("Lap Count: ");
    Serial.println(param[0]);
    maxLaps = param[0];
    return false;  
}//setTotalLapsHandler

bool useItemHandler(uint8_t cmd, uint8_t param[], uint8_t n){
  if(param[0] == TRUE){
    Serial.println("Item Stored");
  }

  if(param[0] == FALSE){
    Serial.println("Item used");
    myTimer.start();
  }
  return false; 
} // use item

bool startRaceHandler(uint8_t cmd, uint8_t param[], uint8_t n){
  if(param[0] == TRUE){
    Serial.println("Race Started");
    moveEnabled = TRUE;
  }

  if(param[0] == FALSE){
    Serial.println("Race NOT Started");
    moveEnabled = FALSE;
  }
  return false; 
} // begin race

bool gameModeHandler(uint8_t cmd, uint8_t param[], uint8_t n){
  if(param[0] == TRUE){
    Serial.println("Multiplayer");
  }

  if(param[0] == FALSE){
    Serial.println("Time Attack");
  }
   return false; 
} // change game mode

bool updateLapsCompletedHandler(uint8_t cmd, uint8_t param[], uint8_t n){
    //param[0] = lapCounter; 
    param[0] = maxLapCount;
    return false;   
} // update lap count

//
//bool updateMushroomHandler(uint8_t cmd, uint8_t param[], uint8_t n){
//  if(item == "m"){
//    param[0] = TRUE;
//  }

//  else{
//    param[0] = FALSE;
//  }
//  return false;
//} // display mushroom
//
//bool updateHeartHandler(uint8_t cmd, uint8_t param[], uint8_t n){
//  if(item == "h"){
//    param[0] = TRUE;
//  }
//  else{
//    param[0] = FALSE;
//  }
//  return false;
//} // display hearts
//

//bool updateGreenShellHandler(uint8_t cmd, uint8_t param[], uint8_t n){
//  if(item == 's'){
//    param[0] = TRUE;
//  }
//  else{
//    param[0] = FALSE;
//  }
//  return false;
//} // display shell

bool updateLapsRemainingHandler(uint8_t cmd, uint8_t param[], uint8_t n){
    param[0] = setTotalLaps - lapCounter; 
    Serial.println(param[0]);
    return false;   
} // display laps 

bool raceClassHandler(uint8_t cmd, uint8_t param[], uint8_t n){
  if(param[0] == TRUE){
    Serial.println("100CC Race Class Set!");
  }
  if(param[0] == FALSE){
    Serial.println("50CC Race Class Set!");
  }
  return false;
} // race class

// END OF COMMAND HANDLERS

void hitByShell(){
  moveEnabled = FALSE;
  hitTimer.start();
}

void boost(){
  digitalWrite(loadSwitch, HIGH);
  boostTimer.start();
}

ArxRobot::cmdFunc_t onCommand[CMD_LIST_SIZE] = {{MOVE,moveHandler},{setTotalLaps, setTotalLapsHandler},{useItem,useItemHandler},{startRace, startRaceHandler},{gameMode,gameModeHandler},{updateLapsCompleted, updateLapsCompletedHandler},{updateLapsRemaining,updateLapsRemainingHandler},{raceClass,raceClassHandler}};

//{updateMushroom, updateMushroomHandler},{updateHeart,updateHeartHandler},{updateGreenShell,updateGreenShellHandler}, // additional handlers for testing
Packet motorPWM(MOTOR2_CURRENT_ID);  // initialize the packet properties to default values

void setup()
{
  Serial.begin(9600);               // default = 115200
  ArxRobot.begin();
  ArxRobot.setOnCommand(onCommand, CMD_LIST_SIZE);
  motorPWM.setAccuracy(1);          // change sensor accuracy from +/-2 DN to +/-1 DN    (-- this line is optional --)
  motorPWM.setSamplePeriod(500);    // change sample period from 1 second to 0.5 seconds (-- this line is optional --)
  servoA.attach(4);
  motorA.begin(AIN1,AIN2);    // pinouts of motor A
  motorB.begin(BIN1,BIN2);    // pinouts of motor B
}

void loop(){
  ArxRobot.loop();
  if(hitTimer.done()){
   Serial.println("Finished my hit timer");
   moveEnabled = TRUE;
   hitTimer.reset();
  }

  if(boostTimer.done()){
    Serial.println("Finished my boost");
    digitalWrite(loadSwitch,LOW);
  }

#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__)
    uint16_t pwm_reading = (uint16_t) OCR4D;  // read 8-bit Output Compare Register Timer 4D and cast to 16-bit signed word
    motorPWM.sendSensor(pwm_reading);
  #else
    // Timer/Counter 0 registers set by UNO Bootloader (freq. = 1 Khz)
    // Timer/Counter Control Registers TCCR0B = 0x03 (Prescaler of 64) and TCCR0A (Fast PWM, TOP = 0xFF) = 0x03
    uint16_t pwm_reading = (uint16_t) OCR0B;
    motorPWM.sendSensor(pwm_reading);
  #endif

}

Shown below is a simple sketch that will utilize a pin from the 3DoT board in order to test the new load switch that is being implemented in our design. Toggling between the HIGH and LOW states verifies the functionality of the load switch. 

Load Switch Code
// test the load switch
#define loadSwitch 12
void setup() {
// put your setup code here, to run once:
pinMode(loadSwitch,OUTPUT);
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(loadSwitch, LOW);
delay(5000);
digitalWrite(loadSwitch, HIGH);
delay(5000);
}

Shown below is the code that was created for our color sensor that will detect the various colored cards that will be used in our design. Based on each value of Red, Green, and Blue, this code will determine which color it is reading

Color Sensor Code
class ColorSensor{
uint16_t r, g, b,c;
Adafruit_TCS34725 tcs;
public:
ColorSensor(){
tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_1X);
}

char getData() {
char color;
tcs.getRawData(&r,&g,&b,&c);
//Serial.print("R: "); Serial.print(r, DEC); Serial.print(" "); //Red Value
//Serial.print("G: "); Serial.print(g, DEC); Serial.print(" "); //Green Value
//Serial.print("B: "); Serial.print(b, DEC); Serial.print(" "); //Blue Value
//Serial.println(" ");

if (r > 100 && r<300 && g > 100  && g < 300 && b > 100 && b< 300) { color = 'b'; //black } else { if (r > 900 && r < 1500 && g > 100 && g < 700 && b > 100 && b < 800) { color = 'r'; //red } else if (r > 1600 && r < 2000 && g > 800 && g < 1400 && b > 1000 && b < 1600) { color = 'k'; // pink } else if (r > 1000 && r < 1600 &&  g > 900 && g <  1400 && b > 200 && b < 800) { color = 'y'; //yellow } else if (r > 500 && r < 1500 && g > 100 && g < 600 && b > 100 && b < 800) { color = 'o'; //orange } else if (r > 300 && r < 600 && g > 400 && g < 600 && b > 500 && b < 800) { color = 'p'; //purple } else if (r > 100 && r < 900 && g > 500 && g < 1500 && b > 100 && b < 1100) {

color = 'g'; //green
}

else {
color = 'u'; // no specific color.
}e

}

return color;
}

};

Shown below is the code that will keep track of the laps that have been completed. The code was created such that the order in which our banners are completed matters. Not completing the banners in the correct order will print an error to the serial monitor.

updatingLapCounter
void updateLapCounter() {
bool raceFinished;
cheated= false;
switch (banner) {
case 0:
Serial.println("Just driving");
break;
case 1:
Serial.println("in case 1");
if (banner1 ==false) {
banner1 = true;
}
else {
Serial.println("just driving");
}
break;
case 2:
Serial.println("in case 2");
if (banner1 == true){
banner2 = true;
}
else {
Serial.println("You cheated");
}

Serial.println(banner1);Serial.println(banner2); Serial.println(banner3);
break;
case 3:
Serial.println("in case 3");
if (banner2 == true) {
banner3 = true;
}
else {
Serial.println("You cheated");
}

Serial.println(banner1);Serial.println(banner2); Serial.println(banner3);
break;

case 4:
static unsigned long safetyStartTime = millis();
Serial.println("in case 4");
if (banner3 == true) {
if (data != 'b'){
lapCounter++;
Serial.println(lapCounter,DEC); /* this is where the lap counter portion of Arxrobot would be*/
banner1 = false;
banner2 = false;
banner3 = false;
banner = 0;
}
else {
if (firstLap == true) {
if (data != 'b'){
banner = 0;
firstLap = false;
}
}

else {
Serial.println("Waiting to cross");
}
}
}

else {
Serial.println("You cheated");
}

Serial.println(banner1);Serial.println(banner2); Serial.println(banner3);
break;
}
}

Shown below is the code that was created such that each color that is being used in our design is assigned a specific item or banner for our race. In addition, it includes some of the game logic that fulfills some of our level requirements. 

Determining items or banner
void splitColorSensor(){
switch(data) {
case 'b':
banner = 4;  //banner 4
break;
case 'p':
banner = 1; //banner 1
break;
case 'y':
banner = 2; //banner 2
break;
case 'o':
banner = 3; //banner 3
break;
case 'r':
unsigned long cooldownStart1;
if (firstItem == true) {
item = 'm';
firstItem = false;
cooldownStart1 = millis();
Serial.print(cooldownStart1);
}
else{
if (item == 'n') {
unsigned long cooldownTimer1 = millis()-cooldownStart1;
if (cooldownTimer1> 60000) {
cooldownStart1 = cooldownTimer1+cooldownStart1;
item = 'm';
Serial.print("item = ");Serial.print(item);
Serial.println(" ");
}
else {
Serial.print("item = ");Serial.print(item);
Serial.println(" ");
Serial.print("cool down time = ");Serial.print(cooldownTimer1);
}
}
else
{
Serial.println(" ");
Serial.print("Already holding item = ");
Serial.print(item);
}
}
break;
case 'k':
unsigned long cooldownStart2;
if (firstItem == true) {
item = 'h';
firstItem = false;
cooldownStart2 = millis();
Serial.print(cooldownStart2);
}
else{
if (item == 'n') {
unsigned long cooldownTimer2 = millis()-cooldownStart2;
if (cooldownTimer2> 60000) {
cooldownStart2 = cooldownTimer2+cooldownStart2;
item = 'h';
Serial.print("item = ");Serial.print(item);
Serial.println(" ");
}
else {
Serial.print("item = ");Serial.print(item);
Serial.println(" ");
Serial.print("cool down time = ");Serial.print(cooldownTimer2);
}
}
else
{
Serial.println(" ");
Serial.print("Already holding item = ");
Serial.print(item);
}
}
break;
case 'g':
unsigned long cooldownStart3;
if (firstItem == true) {
item = 's';
firstItem = false;
cooldownStart3 = millis();
Serial.print(cooldownStart3);
}
else{
if (item == 'n') {
unsigned long cooldownTimer3 = millis()-cooldownStart3;
if (cooldownTimer3> 60000) {
cooldownStart3 = cooldownTimer3+cooldownStart3;
item = 's';
Serial.print("item = ");Serial.print(item);
Serial.println(" ");
}
else {
Serial.print("cool down time = ");Serial.print(cooldownTimer3);
Serial.print("item = ");Serial.print(item);
Serial.println(" ");
}
}
else
{
Serial.println(" ");
Serial.print("Already holding item = ");
Serial.print(item);
}
}
break;
case 'u':
banner = 0;
break;
}
}