File content as of revision 22:8f11d1c178ab:

#include "cardReader.h"



Serial pc(USBTX, USBRX);
/*  valueToChar(int value):
    Expects an int value what it 0 or 1.
    Returns the int value as a char.
    0 will return '0'
    1 will return '1'
    Used to read the bits in the card reader.
*/
char valueToChar(int value){
        if(value == 0){
            return '0';
        }else if(value == 1){
            return '1';
        }else{
            return NULL;    
            }
}

void sendCharacter(char ch){
        pc.putc(ch);
}
void sendCardValues(){
    pc.putc('R');//start bit
    //data
    pc.putc(cardValues[0]);
    pc.putc(cardValues[1]);
    pc.putc(cardValues[2]);
    pc.putc(cardValues[3]);
    pc.putc(cardValues[4]);
    pc.putc(cardValues[5]);
    pc.putc('C');//stop bit
    }

void sendString(char* ch){
        pc.puts(ch);
}

       
char readBit(int bitNumber){
        int value = 0;
        switch(bitNumber){
            case 1:
                value = cardBit1;
            break;
            case 2:
                value = cardBit2;
            break;
            case 3:
                 value = cardBit3;
            break;
            case 4:
                value = cardBit4;
            break;
            case 5:
                value = cardBit5;
            break;
            case 6:
                value = cardBit6;
            break;
            }
            return valueToChar(value);
}
    
void processMessage(char c){
     switch(c){
            case 'a' : //Dispense red
            {
                dispense(RED);
                sendCharacter('A');
            break;
            }
            {
            case 'b' :  //dispense green
                dispense(GREEN);
                sendCharacter('B');
            break;
            }
            {
            case 'c':   //dispense blue
                dispense(BLUE);
                sendCharacter('C');
            break;
            }
            {
            case 'C':// Read card command
                sendCharacter('R'); //Notify PC that command has been recieved
                printLCD("Reading Card");
                //read card here
                char value = ' ';
                for(int num = 1;num <= 6;num++){
                    value = readBit(num);
                   // sendCharacter('R');
                    sendCharacter(value);
                    printLCD("Bit read");
                    //wait(0.1);
                }
                sendCharacter('C'); //Tells PC that the card has been read
                printLCD("Card read done");
            break;
            }
            {
            case 'X':
                sendCharacter('X'); //Notify the PC that this is an MBED
                printLCD("Connected to PC");
            break;
            }
            {
            case 'd':   //Sort Bin
                sort(BIN);
                sendCharacter('D');
            break;
            }
            {
            
            case 'o':   //testServoredBlueLeft
                maintain(RB_LEFT);
                sendCharacter('O');
            break;
            }
            {
            
            case 'p':
                maintain(RB_CENTRE);
                sendCharacter('P');
            break;
            }
            {
            
            case 'q':
                maintain(RB_RIGHT);
                sendCharacter('O');
            break;
            }
            {
            case 's':
                maintain(GO_UP);
                sendCharacter('S');
            break;
            }
            {
            case 't':
                maintain(GO_CENTRE);
                sendCharacter('T');
            break;
            }
            {
            case 'u':
                maintain(GO_DOWN);
                sendCharacter('U');
            break;
            }
            
            {
            case 'v':
                maintain(BR_LEFT);
                sendCharacter('V');
            break;
            }
            {
            case 'w':
                maintain(BR_RIGHT);
                sendCharacter('O');
            break;
            }
            {
            case 'j':
                sort(RED);
                sendCharacter('J');
            break; 
            }
            {
            case 'k':
                sort(GREEN);
                sendCharacter('K');
            break;
            }
            {
            case 'l':
                sort(BLUE);
                sendCharacter('L');
            break;
            }
            {
            
            case '0': //Dispense all
                dispenseAll();
                sendCharacter('1');
            break;
            }
            {
            case '2':
                maintain(GO_CENTRE);
                maintain(RB_CENTRE);
                sendCharacter('3');
            break;
            }
            {
            case '4':
            lift();
            sendCharacter('5');
            break;   
            }
            {
            case 'e':
            recycle();
            sendCharacter('E');
            break;
            }
            
            
            
            
            
            
            
            
            
            
            
            
            /*case 't'://Test 180 servo
            sendCharacter('T');
            printLCD("Servo signal on");
            servoTest = true;
            break;
            case 'w'://Test 180 servo
            sendCharacter('W');
            printLCD("Servo signal off");
            servoTest = false;
            break;*/
        }
        }
        
        /*else if (operationMode){
            switch(c){
                case 'n':// Start sorting
                    sendCharacter('N'); //Confirm to PC that we are processing the instruction.
                    startSort = true; //Pulse the startSort control line to FPGA
                    wait(0.1);
                    startSort = false;
                break;
                case 'o':   //Start dispensing
                    sendCharacter('O');
                    startDispense = true; //Pulse the startDispense control line to FPGA
                    wait(0.1);
                    startDispense = false;
                break;
                case 'p':   //
                    sendCharacter('P');
                break;
                }
           }
}*/
bool checkSerial(){
    log("Checking serial");
    printLCD("");
    if(pc.readable()){
        log("serial port is readable, reading char and processing");
        char c = pc.getc();
        processMessage(c);
        return true;
    }else{
        log("serial port not readable, doing nothing");
        return false;
    }
}
bool readCharacter(){
    char c = pc.getc(); //wait for a serial character to be recieved.
    processMessage(c);  //Do something, based on the character recieved.
    return true;
}
/* Set the PC's laguage to whatever our language is
*/
void sendLanguageCharacter(){
    switch(currentLanguage){
        case ENGLISH:
        printLCD("Setting language to English");
        sendCharacter('Y');
        printLCD("Language set to English");
        break;
        
        case FRENCH:
        printLCD("Setting language to French");
        sendCharacter('Z');
        printLCD("Language set to French");
        break;
        
        case GERMAN:
        printLCD("Setting language to German");
        sendCharacter('!');
        printLCD("Language set to German");
        break;
    }
    }