File content as of revision 3:990f8380da21:

#include "mbed.h"
#include "C12832.h"
#include "LM75B.h"
#include "MMA7660.h"
#include "FXOS8700CQ.h"

//OUTPUTS

DigitalOut lr(PTB22), lg(PTE26), lb(PTB21);
PwmOut xr(D5), xg(D9), xb(D8);
C12832 lcd(D11, D13, D12, D7, D10);

//INPUTS

LM75B temp(D14, D15);
MMA7660 accel(D14, D15);
FXOS8700CQ magAccel(D14, D15, FXOS8700CQ_SLAVE_ADDR1);

InterruptIn sw2_int(SW2), sw3_int(SW3), up_int(A2), down_int(A3), left_int(A4), right_int(A5), fire_int(D4);
DigitalIn   sw2(SW2),     sw3(SW3),     up(A2),     down(A3),     left(A4),     right(A5),     fire(D4);

AnalogIn pot1(A0), pot2(A1);

//INTERRUPT FLAGS

uint16_t flags;
#define SW2_DOWN   0x0001
#define SW2_UP     0x0002
#define SW3_UP     0x0004
#define SW3_DOWN   0x0008
#define UP_UP      0x0010
#define UP_DOWN    0x0020
#define DOWN_UP    0x0040
#define DOWN_DOWN  0x0080
#define LEFT_UP    0x0100
#define LEFT_DOWN  0x0200
#define RIGHT_UP   0x0400
#define RIGHT_DOWN 0x0800
#define FIRE_UP    0x1000
#define FIRE_DOWN  0x2000

//COMMS

Serial pc(USBTX, USBRX);

//INTERRUPT HANDLERS

void sw2Down(){ flags |= SW2_DOWN; }
void sw2Up()  { flags |= SW2_UP; }

void sw3Down(){ flags |= SW3_DOWN; }
void sw3Up()  { flags |= SW3_UP; }

void upDown(){ flags |= UP_DOWN; }
void upUp()  { flags |= UP_UP; }

void downDown(){ flags |= DOWN_DOWN; }
void downUp()  { flags |= DOWN_UP; }

void leftDown(){ flags |= LEFT_DOWN; }
void leftUp()  { flags |= LEFT_UP; }

void rightDown(){ flags |= RIGHT_DOWN; }
void rightUp()  { flags |= RIGHT_UP; }

void fireDown(){ flags |= FIRE_DOWN; }
void fireUp()  { flags |= FIRE_UP; }

/*
Return the state of a requested pin
*/
void readDigitalIn() {
    bool val;
    switch(pc.getc()) {
        case '2': val=sw2; break;
        case '3': val=sw3; break;
        case 'u': val=up; break;
        case 'd': val=down; break;
        case 'l': val=left; break;
        case 'r': val=right; break;
        case 'f': val=fire; break;
        default: return;
    }
    pc.printf(val?"t;":"f;");
}

/*
Return the state of a requested potentiometer
*/
void readPot() {
    float val;
    switch(pc.getc()) {
        case '1': val=pot1; break;
        case '2': val=pot2; break;
        default: return;
    }
    pc.printf("%6.4f;",val);
}

//BLOCK LEVEL READ & WRITE

void sendData(void* data, int len) {
    for(char* c = (char*)data;len--;)
        pc.putc(*(c++));
}

void readData(void* data, int len) {
    char* c = (char*)data;
    while(len>0) {
        *c = pc.getc();
        c++;
        len--;
    }
}

//PRETTY WAITING LEDS (Modified from Fred Barnes)

Ticker waitTicker;
int ctr;

uint8_t brilvl(int offset) {
    if(offset>311) offset-=312;
    if (offset < 52) return (uint8_t)(offset * 5);
    if (offset < 156) return 255;
    if (offset < 208) return (uint8_t)((207 - offset) * 5);
    return 0;
}

void waitTick() {
    ctr++;//
//    if (ctr > 311) {
//        ctr -= 312;
//    }
//    xr = brilvl(  ctr  )/255.0;
//    xg = brilvl(ctr+104)/255.0;
//    xb = brilvl(ctr+208)/255.0;
    xr = 1;
    xg = 1;
    xb = 0;
}

void cleanup() {
    lr = lg = lb = 1;
    xr = xg = xb = 1;
    temp.read();
    lcd.cls();
    pc.putc('+');
}

int main() {  
    //SETUP
    pc.baud(9600);
    
    lr = lg = lb = 1;
    
    sw2_int.mode (PullUp);
    sw2_int.fall(&sw2Down);
    sw2_int.rise(&sw2Up);
    
    sw3_int.mode (PullUp);
    sw3_int.fall(&sw3Down);
    sw3_int.rise(&sw3Up);
    
    up_int.mode (PullUp);
    up_int.fall(&upDown);
    up_int.rise(&upUp);
    up_int.disable_irq();
    
    down_int.mode (PullUp);
    down_int.fall(&downDown);
    down_int.rise(&downUp);
    
    left_int.mode (PullUp);
    left_int.fall(&leftDown);
    left_int.rise(&leftUp);
    
    right_int.mode (PullUp);
    right_int.fall(&rightDown);
    right_int.rise(&rightUp);
    
    fire_int.mode (PullUp);
    fire_int.fall(&fireDown);
    fire_int.rise(&fireUp);
    
    //Pretty wait
    ctr=0;
    lcd.locate(0,0);
    lcd.printf("Awaiting connection...");
    waitTicker.attach(&waitTick,0.02);
    while(pc.getc()!='-');
    waitTicker.detach();
    cleanup();
    
    union {
        float f;
        int i;
        char c[4];
    } val;
    
    for(;;) {
        //Check if any interrupts fired
        if(flags&SW2_UP) {
            flags&=!SW2_UP;
            pc.printf("!2u");
        }
        if(flags&SW2_DOWN) {
            flags&=!SW2_DOWN;
            pc.printf("!2d");
        }
        if(flags&SW3_UP) {
            flags&=!SW3_UP;
            pc.printf("!3u");
        }
        if(flags&SW3_DOWN) {
            flags&=!SW3_DOWN;
            pc.printf("!3d");
        }
        if(flags&UP_UP) {
            flags&=!UP_UP;
            pc.printf("!uu");
        }
        if(flags&UP_DOWN) {
            flags&=!UP_DOWN;
            pc.printf("!ud");
        }
        if(flags&DOWN_UP) {
            flags&=!DOWN_UP;
            pc.printf("!du");
        }
        if(flags&DOWN_DOWN) {
            flags&=!DOWN_DOWN;
            pc.printf("!dd");
        }
        if(flags&LEFT_UP) {
            flags&=!LEFT_UP;
            pc.printf("!lu");
        }
        if(flags&LEFT_DOWN) {
            flags&=!LEFT_DOWN;
            pc.printf("!ld");
        }
        if(flags&RIGHT_UP) {
            flags&=!RIGHT_UP;
            pc.printf("!ru");
        }
        if(flags&RIGHT_DOWN) {
            flags&=!RIGHT_DOWN;
            pc.printf("!rd");
        }
        if(flags&FIRE_UP) {
            flags&=!FIRE_UP;
            pc.printf("!fu");
        }
        if(flags&FIRE_DOWN) {
            flags&=!FIRE_DOWN;
            pc.printf("!fd");
        }
        
        //Check for host requests
        if(pc.readable()) {
            char cmd = pc.getc();
            switch(cmd) {
                case 'R': { //read digital input
                    readDigitalIn();
                    break;
                }
                case 'p': {
                    readPot();
                    break;
                }
                case 't': { //read temp
                    float t = temp.read();
                    sendData(&t,4);
                    break;
                }
                case 'a': {//read shield accel
                    float x, y, z;
                    x = accel.x();
                    y = accel.y();
                    z = accel.z();
                    sendData(&x,4);
                    sendData(&y,4);
                    sendData(&z,4);
                    break;
                }
                case 'l': { //shield led
                    float r, g, b;
                    readData(&r,4);
                    readData(&g,4);
                    readData(&b,4);
                    xr = 1.0f-r; xg = 1.0f-g; xb = 1.0f-b;
                    break;
                }
                case 'L': { // board led
                    char raw = pc.getc();
                    char r = ((raw>>2)&1)?0:1;
                    char g = ((raw>>1)&1)?0:1;
                    char b = (raw&1)?0:1;
                    lr = r; lg = g; lb = b;
                    break;
                }
                case 'M': { //read board magno
                    SRAWDATA m, a;
                    magAccel.get_data(&a,&m);
                    sendData(&m.x,2);
                    sendData(&m.y,2);
                    sendData(&m.z,2);
                    break;
                }
                case 'A': { //read board accel
                    SRAWDATA m, a;
                    magAccel.get_data(&a,&m);
                    sendData(&a.x,2);
                    sendData(&a.y,2);
                    sendData(&a.z,2);
                    break;
                }
                case 'P': { //set lcd position
                    unsigned char x, y;
                    x = pc.getc();
                    y = pc.getc();
                    lcd.locate(x,y);
                    break;
                }
                case 'S': { //print lcd text
                    char buff[256];
                    unsigned char len = pc.getc();
                    char * j= buff;
                    while(len>0) {
                        *j++=pc.getc();
                        len--;
                    }
                    *j=0;
                    lcd.printf(buff);
                    break;
                }
                case 'D': { //set lcd pixel
                    char x = pc.getc();
                    char y = pc.getc();
                    char c = pc.getc();
                    lcd.pixel(x,y,c);
                    break;
                }
                case 'C': { //clear lcd
                    lcd.cls();
                    break;
                }
                case '-': { //reconnection
                    cleanup(); break;
                }
                default: break;
            }
        }
    }
}