File content as of revision 18:2342aa54dc9b:

#include "mbed.h"
#include "nRF24L01P.h"
#include "beep.h"

#define nrf_CE      D2
#define nrf_CSN     A3
#define spi_SCK     D13
#define spi_MOSI    D11
#define spi_MISO    D12
#define spi_IRQ     D4

#define TRANSFER_SIZE 15
#define MAX_BUFFER_SIZE 255
#define BUFFER_SIZE MAX_BUFFER_SIZE

#define DATA_PROTOCOL_BEGIN '$'
#define DATA_PROTOCOL_TOKEN ','
#define DATA_PROTOCOL_TOKEN_ ","
#define DATA_PROTOCOL_END   '*'
#define DATA_PROTOCOL_END_  "*"

nRF24L01P nrf(spi_MOSI, spi_MISO, spi_SCK, nrf_CSN, nrf_CE, spi_IRQ);    // mosi, miso, sck, csn, ce, irq

Serial pc(USBTX, USBRX);
PwmOut buzzer(D5);

typedef struct {
    int bot_id;
    int cmd_id;
    int lspeed;
    int rspeed;
} payload_t;

void beepStart();
void endBeep();
void initNRF();
void dumpRFInfo();

int readSerialUntil(char *buffer, unsigned int buf_len, char terminator);
char* inspectData(char *buffer, int buf_len);
payload_t* getPayload(char* raw_data);

int main()
{
    char buffer[BUFFER_SIZE];
    beepStart();
    pc.baud(115200);
    printf("I'm Master\r\n");
    initNRF();
    dumpRFInfo();

    memset(buffer, NULL, BUFFER_SIZE);

    while(1) {
        int result = readSerialUntil(buffer, BUFFER_SIZE, DATA_PROTOCOL_END);
        if(result>0) {
            char *data = inspectData(buffer, BUFFER_SIZE);
            if(*data == DATA_PROTOCOL_BEGIN) {
                printf("%s\r\n", data);
                payload_t *payload = getPayload(data);
                printf("BotID:%d, CmdID:%d, LSpeed:%d, RSpeed:%d\r\n", payload->bot_id, payload->cmd_id, payload->lspeed, payload->rspeed);
                free(data);
                free(payload);
            }
        }
        /*
        while(pc.readable()) {
            char inByte = pc.getc();
            if(inByteCnt > TRANSFER_SIZE+2) {
                printf("Data size overflow!\r\n");
                inByteCnt = 0;
                break;
            } else if(inByte == '\0') {
                buffer[inByteCnt] = '\0';
                printf("Command: %s\r\n", buffer);
                nrf.write(NRF24L01P_PIPE_P0, buffer, TRANSFER_SIZE);
                inByteCnt=0;
            } else {
                buffer[inByteCnt++] = inByte;
            }
        }*/
    }
}

payload_t* getPayload(char *data)
{
    int n = strlen(data);
    char _data[n+1];
    strcpy(_data, data);
    payload_t *p = (payload_t*)malloc(sizeof(payload_t));
    p->bot_id = atoi(strtok(data+1, DATA_PROTOCOL_TOKEN_));
    p->cmd_id = atoi(strtok(NULL, DATA_PROTOCOL_TOKEN_));
    p->lspeed = atoi(strtok(NULL, DATA_PROTOCOL_TOKEN_));
    p->rspeed = atoi(strtok(NULL, DATA_PROTOCOL_END_));
    return p;
}

char* inspectData(char *buffer, int buf_len)
{
    int start, end;
    for(int i=0; buffer[i-1]!=DATA_PROTOCOL_BEGIN; i++) {
        start = i;
        if(i==buf_len) return 0;
    }
    for(int i=start+1; buffer[i-1]!=DATA_PROTOCOL_END; i++) {
        end = i;
        if(i==buf_len) return 0;
    }
    int data_len = end-start+1;
    char *str = (char*)malloc(sizeof(char)*(data_len+1));
    memset(str, NULL, data_len+1);
    for(int i=0; i<data_len; i++) {
        *(str+i) = buffer[start+i];
        
        if(buffer[start+i]==DATA_PROTOCOL_BEGIN || buffer[start+i]==DATA_PROTOCOL_TOKEN || buffer[start+i]==DATA_PROTOCOL_END
            || (buffer[start+i]>='0'&&buffer[start+i]<='9') || buffer[start+i]=='+' || buffer[start+i]=='-') {
            continue;
        } else {
            //pc.putc(buffer[start+i]);
            free(str);
            return 0;
        }
    }
    return str;
}

int readSerialUntil(char *buffer, unsigned int buf_len, char term)
{
    int n=0;
    char *str = (char*)malloc(sizeof(char)*buf_len);
    memset(str, NULL, buf_len);
    Timer t;
    t.start();
    int begin = t.read_ms();
    while(t.read_ms()-begin < 100) {
        if(pc.readable()) {
            char inByte=pc.getc();
            *(str+n)=inByte;
            n++;
            if(inByte == term) {
                strcpy(buffer, str);
                free(str);
                return n;
            }
            if(n>buf_len) {
                free(str);
                return -1;
            }
        }
    }
    free(str);
    return 0;
}

void dumpRFInfo()
{
    printf( "nRF24L01+ Frequency    : %d MHz\r\n",  nrf.getRfFrequency() );
    printf( "nRF24L01+ Output power : %d dBm\r\n",  nrf.getRfOutputPower() );
    printf( "nRF24L01+ Data Rate    : %d kbps\r\n", nrf.getAirDataRate() );
    printf( "nRF24L01+ TX Address   : 0x%010llX\r\n", nrf.getTxAddress() );
    printf( "nRF24L01+ RX Address   : 0x%010llX\r\n", nrf.getRxAddress() );
}

void initNRF()
{
    nrf.setTxAddress(0xDEADBEEF0F);
    nrf.powerUp();
    nrf.setTransferSize( TRANSFER_SIZE );
    nrf.setTransmitMode();
    nrf.enable();

}

void getPayload(int id, unsigned int count, int lspeed, int rspeed, char* txData)
{
    *(txData+0) = '$';
    *(txData+1) = id/10+'0';
    *(txData+2) = id%10+'0';
    *(txData+3) = count/10000+'0';
    *(txData+4) = count/1000%10+'0';
    *(txData+5) = count/100%10+'0';
    *(txData+6) = count/10%10+'0';
    *(txData+7) = count%10+'0';
    *(txData+8) = lspeed>0?'+':'-';
    *(txData+9) = abs(lspeed)/10+'0';
    *(txData+10) = abs(lspeed)%10+'0';
    *(txData+11) = rspeed>0?'+':'-';
    *(txData+12) = abs(rspeed)/10+'0';
    *(txData+13) = abs(rspeed)%10+'0';
    *(txData+14) = '\0';
}

/*
xxyyyyyabbcddn

14 chars

xx: robot_id
yyyyy: packet_id
a: sign of lspeed
bb: lspeed
c: sign of rspeed
dd: rspeed
n: NULL 0

0100001+30+30
*/