File content as of revision 17:b2329b2cafa8:

#include "robot.h"
#include <sstream>

int mode = 0;
const int MANUAL_MODE = 0;
const int LINE_FOLLOW_MODE = 1;

volatile double leftspeed;
volatile double rightspeed;

char received[80];
int r_index;
int sensors[5];

// GAINS
//////////////////////////////
float k_p = 0.0;
float k_i = 0.0;
float k_d = 0.0;
//////////////////////////////

/*
 * This function will be called at approximately 20 Hz when the control mode is LINE_FOLLOW_MODE
 */
void line_follow_loop(){
    led4 = 1;

    // set these variables to control the robot
    leftspeed = 0.0;
    rightspeed = 0.0;

    // set mode to MANUAL_MODE when the end is detected
    // mode = MANUAL_MODE
    
    wait_ms(10);

    led4 = 0;
}


// INPUT COMMANDS
// l:<float>    set left wheel speed (only effective in MANUAL_MODE)
// r:<float>    set right wheel speed (only effective in MANUAL_MODE)
// c:<int>      change mode
// g:<p|i|d>:<float>
//              change gains

// OUTPUT MESSAGES
// p:<float>    line position
// s:<int>,<int>,<int>,<int>,<int>
//              light sensor values
// m:<int>      mode

int parse_command(const char* cmd)
{
    if(cmd[1]==':'){
        // left motor
        if(cmd[0]=='l'){
            if(mode==MANUAL_MODE){
                leftspeed = atof(&cmd[2]);
            }
        // right motor
        }else if(cmd[0]=='r'){
            if(mode==MANUAL_MODE){
                rightspeed = atof(&cmd[2]);
            }
        // mode
        }else if(cmd[0]=='c'){
            mode = atoi(&cmd[2]);
        // gains
        }else if(cmd[0]=='g'){
            if(cmd[2]=='p'){
                k_p = atof(&cmd[4]);
            }else if(cmd[2]=='i'){
                k_i = atof(&cmd[4]);
            }else if(cmd[2]=='d'){
                k_d = atof(&cmd[4]);
            }
            xbee.printf("gains p:%f, i:%f, d:%f\n", k_p, k_i, k_d);
        }else{
            xbee.printf("%s\n",cmd); 
        }
    }else{
        xbee.printf("%s\n",cmd);
    }
    return 0;
}

void Rx_interrupt()
{
    // assume recursive interrupt is not possible
    led2 = 1;
    char read;
    
    while(xbee.readable()){
        read = xbee.getc();
        if(read=='\n'){
            received[r_index]='\0'; // put a null character at the end
            parse_command(received);
            r_index=0;
        } else {
            if(r_index >= 80){
                r_index=0;
            }
            received[r_index]=read;
            r_index++;
        }
    }
    
    led2=0;
    
    return;
}

int main() {
    
    xbee.attach(&Rx_interrupt, Serial::RxIrq);
    xbeeReset = 0;
    wait(2);
    xbeeReset = 1;
    pi.sensor_auto_calibrate();
    r_index = 0;
    received[0] = '\0';
    mode = MANUAL_MODE;

    while(1){

        led1 = 1;
        wait_ms(50);
        if(mode==LINE_FOLLOW_MODE){
            line_follow_loop();
        }

        // reversing these is more intuitive
        // pi.left_motor(leftspeed);
        // pi.right_motor(rightspeed);
        __disable_irq();
        pi.left_motor(rightspeed);
        pi.right_motor(leftspeed);
        __enable_irq();

        led1 = 0;
        wait_ms(50);
        pi.sensor_reading(sensors);
        int* s = sensors;
        __disable_irq();
        xbee.printf("s:%i,%i,%i,%i,%i\n", s[0], s[1], s[2], s[3], s[4]);
        __enable_irq();
        __disable_irq();
        xbee.printf("p:%f\n", pi.line_position());
        __enable_irq();
        __disable_irq();
        xbee.printf("m:%d\n", mode);
        __enable_irq();
    }

    return 0;
}