File content as of revision 4:13e3e375c0d3:

#include "mbed.h"
#include "USBSerial.h"
#include "MODSERIAL.h"
#include "InterruptIn.h"

// Constants
#define LEDON       0               // Low active for LEDs - turns LED on
#define LEDOFF      1               // Low active for LEDs - turns LED off
#define TRUE        1
#define FALSE       0


// Error return values
#define ERR_NONE                0   // Success
#define ERR_CDC_BAD_CMD         1   // First byte of PC to USB board needs to be 0xBB, 0xCC, 0xDD or 0xEE;
#define ERR_CDC_NO_TX_ENDMARK   2   // message for no endmark on message to PC
#define ERR_UART_NOT_WRITEABLE  3   // UART has no buffer space
#define ERR_UART_NO_TX_ENDMARK  4   // message for UART has no 0x7E end-mark
#define ERR_UART_NO_RX_ENDMARK  5   // message received from UART has no end-mark
#define ERR_I2C_NOT_WRITEABLE   6   // UART has no buffer space
#define ERR_I2C_NO_TX_ENDMARK   7   // message for UART has no 0x7E end-mark
#define ERR_I2C_NO_RX_ENDMARK   8   // message received from UART has no end-mark
#define ERR_NOT_IMPLEMENTED     255 // method has not yet been implemented


// I2C addresses
#define PROX        (0x29 << 1)     // default I2C address of VL6180X, shift into upper 7 bits
#define EEPROM      (0xA0)          // default I2C address of EEPROM, already shifted

// UART-RFID baud rate
#define RFIDBAUD    115200          // RFID-FE board default rate = 115.2Kbps

// Peripherals
USBSerial cdc;                      // CDC Class USB<>Serial adapter.  Needs custom INF, but uses existing Windows drivers.
MODSERIAL uart(PTA2, PTA1);         // UART port connected to RFID-FE board
I2C i2c(PTB1, PTB0);                // I2C port connected to VL6180X and EEPROM - note addresses above)

// GPIO signals
DigitalOut led_err(PTC1);           // Red LED shows error condition (active low)
DigitalOut led_com(PTC2);           // Yellow LED shows communication activity (active low)
DigitalOut rfid_int(PTD4);          // RFID FE power control (active high)
DigitalOut rfid_isp(PTD5);          // RFID FE In-System Programming (active high)
DigitalOut rfid_rst(PTD6);          // RFID FE Reset (active high)
DigitalOut rfid_pwr(PTE30);         // RFID power switch on USB board (active high for prototype 1, low for all others)
DigitalIn rfid_hot(PTE0);           // RFID over-current detection on USB board power switch (active low)
InterruptIn prox_int(PTD7);         // Proximity sensor interrupt (active low)

// buffers & variables
uint8_t cdc_buffer_rx[32];          // buffers for cdc (USB-Serial port on PC)
uint8_t cdc_buffer_tx[32];
uint8_t uart_buffer_rx[32];         // buffers for uart (RFID-FE board)
uint8_t uart_buffer_tx[32];
char i2c_buffer[264];               // buffer for I2C devices - Proximity sensor and EEPROM - up to 256 bytes data payload for EEPROM, up to 4 for proximity
int i, j;                           // index variables
int status = 0x00;                  // return value

int prox_irq(void)
{
    return 0;
}

int init_periph(void)
{
    // Set up peripherals
    // RFID
    uart.baud(RFIDBAUD);                                            // RFID-FE baud rate
    
    rfid_int = 0;                                                   // RFID FE power control (active high)
    rfid_isp = 0;                                                   // RFID FE In-System Programming (active high)
    rfid_rst = 1;                                                   // RFID FE Reset (active high)
    rfid_pwr = 1;                                                   // RFID power switch on USB board (active high for prototype 1, low for all others)
    wait(0.25);                                                     // wait 250ms before...
    rfid_rst = 0;                                                   // ... taking RFID out of reset
        
    // Prox
    i2c.frequency(400000);                                          // I2C speed = 400Kbps
    prox_int.mode(PullUp);                                          // pull up proximity sensor interrupt at MCU
    
    
    return 0;
}

/*
RFID messages are as defined in the RFID-FE manual.
 */
int rfid_msg(void)
{
    bool end_mark = FALSE;
    int i;
    uint8_t crcCount = sizeof(uart_buffer_tx);                      // use tx buffer size to start
    
    uart.txBufferFlush();                                           // clear out UART buffers
    uart.rxBufferFlush();
    
    for (int i = 0; i < sizeof(uart_buffer_tx); i++)
    {
        if (!uart.writeable()) return ERR_UART_NOT_WRITEABLE;       // if no space in uart, return error
        uart.putc(uart_buffer_tx[i]);                               // send uart message
                    
        if (uart_buffer_tx[i] == 0x7E)                              // check for rfid end mark in outbound message
        {
            crcCount = 2;                                           // two more bytes for CRC
            end_mark = TRUE;                                        // end mark was reached
        }
        if (crcCount-- == 0)                                        // end of message
        {
            if (end_mark == FALSE) return ERR_UART_NO_TX_ENDMARK;   // no end mark detected
            break;
        }
    }
    
    end_mark = FALSE;
    //wait(0.5);                                                    // debug
    while(!uart.readable());                                        // wait for data from rfid
    crcCount = sizeof(uart_buffer_rx);                              // use rx buffer size to start
    for (i = 0; i < sizeof(uart_buffer_rx); i++)
    {
        uart_buffer_rx[i] = uart.getc();                            // read a character
//        cdc.printf("%d, 0x%X\n\r", i, uart_buffer_rx[i]);         // debug
                
        if (uart_buffer_rx[i] == 0x7E)                              // check for rfid end mark in inbound message
        {
            crcCount = 2;                                           // two more bytes for crc
            end_mark = TRUE;                                        // end mark was reached
        }
        if (crcCount-- == 0)                                        // end of message
        {
            if (end_mark == FALSE) return ERR_UART_NO_RX_ENDMARK;  
            break;
        }
    }
    return ERR_NONE;
}


/*
I2C-prox messages = 0xCC, r/w, number of data bytes, index (2 bytes), data bytes, 0x7E, 0xXX, 0xXX - last two are fillers where CRC goes for RFID

Multiple registers can be read or written with single prox_msg_rd() or prox_msg_wr().  Location address increments for each byte.
 */

int prox_msg_wr()                                                   // write proximity I2C register
{
    int i2c_err;
    i2c_err = i2c.write(PROX, &i2c_buffer[3], i2c_buffer[2] + 2, 0);// I2C Address, pointer to buffer, number of bytes (for index + data), stop at end.
    return i2c_err;                                                 // 0 = ACK received, 1 = NAK/failure
}
    
int prox_msg_rd()
{
    int i2c_err;
    i2c_err = i2c.write(PROX, &i2c_buffer[3], 2, 1);                // I2C Address, pointer to buffer (just the index), index, number of bytes (2 for index), no stop at end.
    i2c_err |= i2c.read(PROX, &i2c_buffer[5], i2c_buffer[2], 0);    // I2C Address, pointer to buffer (just the data), number of data bytes, stop at end.
    return i2c_err;                                                 // 0 = ACK received, 1 = NAK/failure
}


/*
I2C-EEPROM messages = 0xEE, r/w, number of data bytes, block, address, data bytes, 0x7E, 0xXX, 0xXX - last two are fillers where CRC goes for RFID

Multiple registers can be read or written with single eeprom_msg_rd() or eeprom_msg_wr().  Location address increments for each byte.
This practically the the same as the proximity calls, except the index/location is only one byte and the block select is part of the I2C address byte.
 */

int eeprom_msg_wr()                                                 // write proximity I2C register
{
    int i2c_err;
    i2c_err = i2c.write((EEPROM || i2c_buffer[3]), &i2c_buffer[4], i2c_buffer[2] + 1, 0);  // I2C Address & block select, pointer to buffer, number of bytes (for address + data), stop at end.
    while (!i2c.write(EEPROM || i2c_buffer[3]));                     // wait until write is done (EEPROM will ACK = 1 for single byte i2c.write)
    return i2c_err;                                                 // 0 = ACK received, 1 = NAK/failure
}
    
int eeprom_msg_rd()
{
    int i2c_err;
    i2c_err = i2c.write((EEPROM || i2c_buffer[3]), &i2c_buffer[4], 1, 1);                // I2C Address & block select, pointer to buffer (just the index), index, number of bytes (for address + data), no stop at end.
    i2c_err |= i2c.read((EEPROM || i2c_buffer[3]), &i2c_buffer[5], i2c_buffer[2], 0);   // I2C Address & block select, pointer to buffer (just the data), number of data bytes, stop at end.
    return i2c_err;                                                 // 0 = ACK received, 1 = NAK/failure
}

int gpio_msg()
{
    return ERR_NONE;
}

int main() 
{
    // initialize everything
   
    wait(3.0);                                                      // debug - gives some time to start terminal program and open COM port
    
    init_periph();
    
    //cdc.printf("Starting...\n\r");                                // debug
    
    while(!cdc.readable());                                         // spin here until a message comes in from the host PC
    bool end_mark = FALSE;
    uint8_t crcCount = sizeof(cdc_buffer_rx);                       // use tx buffer size to start
    //cdc.printf("\n\rCDC Input: ");                                // debug
    for (i = 0; i < sizeof(cdc_buffer_rx); i++)
    {
        cdc_buffer_rx[i] = cdc.getc();                              // read data from USB side
                    
        //cdc.printf("%X, ",cdc_buffer_rx[i]);                      // debug

        if (cdc_buffer_rx[i] == 0x7E)                               // check for rfid end mark in outbound message
        {
            crcCount = 2;                                           // two more bytes for CRC
            end_mark = TRUE;                                        // end mark was reached
        }
        if (crcCount-- == 0)                                        // end of message
        {
            if (end_mark == FALSE) return ERR_UART_NO_TX_ENDMARK;   // no end mark detected
            break;
        }
    }

    switch(cdc_buffer_rx[0])
    {
        case 0xBB:                                                  // RFID-FE
            for (i = 0; i < sizeof(cdc_buffer_rx); i++)
            {
                uart_buffer_tx[i] = cdc_buffer_rx[i];               // copy USB message to UART for RFID
            }
            
            status = rfid_msg();                                    // send buffer to RFID and get response according to RFID board
            
            for (i = 0; i < sizeof(cdc_buffer_tx); i++)
            {
                cdc_buffer_tx[i] = uart_buffer_rx[i];               // copy RFID response back to USB buffer
            }
            
            //cdc.printf("\n\rRFID Response: ");                    // debug
            
            for (i = 0; i < sizeof(cdc_buffer_tx); i++)
            {
                cdc.putc(cdc_buffer_tx[i]);                         // send message back to PC
                    
                if (cdc_buffer_tx[i] == 0x7E)                       // check for rfid end mark in outbound message
                {
                    crcCount = 2;                                   // two more bytes for CRC
                    end_mark = TRUE;                                // end mark was reached
                }
                if (crcCount-- == 0)                                // end of message
                {
                    if (end_mark == FALSE) return ERR_CDC_NO_TX_ENDMARK; // no end mark detected
                    break;
                }
            }
            break;
        case 0xCC:            
        //I2C-prox messages = 0xCC, r/w, number of data bytes, index, data bytes, 0x7E, 0xXX, 0xXX - last two are fillers where CRC goes for RFID                                      // Proximity Sensor
            for (i = 0; i < sizeof(cdc_buffer_rx); i++)
            {
                i2c_buffer[i] = cdc_buffer_rx[i];                   // copy USB message to buffer for I2C
            }
            
            if (i2c_buffer[1] == 1)                                 // I2C read = 1
                status = prox_msg_rd();                             // read the requested data
            else if (i2c_buffer[1] == 0)                             // I2C write = 0
                status = prox_msg_wr();                             // send buffer to proximity sensor and get response
            
            for (i = 0; i < sizeof(cdc_buffer_tx); i++)
            {
                cdc_buffer_tx[i] = i2c_buffer[i];                   // copy prox response back to USB buffer
            }
            
            for (i = 0; i < sizeof(cdc_buffer_tx); i++)
            {
                cdc.putc(cdc_buffer_tx[i]);                         // send message back to PC
                    
                if (cdc_buffer_tx[i] == 0x7E)                       // check for rfid end mark in outbound message
                {
                    crcCount = 2;                                   // two more bytes for CRC
                    end_mark = TRUE;                                // end mark was reached
                }
                if (crcCount-- == 0)                                // end of message
                {
                    if (end_mark == FALSE) return ERR_CDC_NO_TX_ENDMARK; // no end mark detected
                    break;
                }
            }
            break;
        case 0xDD:                                                  // GPIO (LEDs and RFID-FE control
            gpio_msg();
            break;
        case 0xEE:                                                  // Read/write EEPROM
/*
I2C-EEPROM messages = 0xEE, r/w, number of data bytes, block, address, data bytes, 0x7E, 0xXX, 0xXX - last two are fillers where CRC goes for RFID

Multiple registers can be read or written with single eeprom_msg_rd() or eeprom_msg_wr().  Location address increments for each byte.
This practically the the same as the proximity calls, except the index/location is only one byte and the block select is part of the I2C address byte.
 */
            for (i = 0; i < sizeof(cdc_buffer_rx); i++)
            {
                i2c_buffer[i] = cdc_buffer_rx[i];                   // copy USB message to buffer for I2C
            }
            
            if (i2c_buffer[1] == 1)                                 // I2C read = 1
                status = eeprom_msg_rd();                           // read the requested data
            else if (i2c_buffer[1] == 0)                            // I2C write = 0
                status = eeprom_msg_wr();                           // write the eeprom location
            
            for (i = 0; i < sizeof(cdc_buffer_tx); i++)
            {
                cdc_buffer_tx[i] = i2c_buffer[i];                   // copy prox response back to USB buffer
            }
            
            for (i = 0; i < sizeof(cdc_buffer_tx); i++)
            {
                cdc.putc(cdc_buffer_tx[i]);                         // send message back to PC
                    
                if (cdc_buffer_tx[i] == 0x7E)                       // check for rfid end mark in outbound message
                {
                    crcCount = 2;                                   // two more bytes for CRC
                    end_mark = TRUE;                                // end mark was reached
                }
                if (crcCount-- == 0)                                // end of message
                {
                    if (end_mark == FALSE) return ERR_CDC_NO_TX_ENDMARK; // no end mark detected
                    break;
                }
            }            break;
        default:
            return ERR_CDC_BAD_CMD;
    }
}