RFManager.cpp

00001 //#include <TARGET_LPC1768/cmsis.h>
00002 #include "RFManager.h"
00003 
00004 RFManager::RFManager(PinName txPinName, PinName rxPinName):
00005         serial(txPinName, rxPinName), buf(64) {
00006 
00007     messageAvailable = false;
00008     receiveCounter = 0;
00009     shortCommandsEnabled = false;
00010     shortCommandLength = 5;
00011     longCommandLength = 12;
00012     commandLength = longCommandLength;
00013 
00014     if (rxPinName == P2_1) {
00015         serialId = 1;
00016     } else if (rxPinName == P0_11) {
00017         serialId = 2;
00018     } else if (rxPinName == P0_1) {
00019         serialId = 3;
00020     } else {
00021         serialId = 0;
00022     }
00023 
00024     serial.attach(this, &RFManager::rxHandler);
00025 }
00026 
00027 void RFManager::baud(int baudrate) {
00028     serial.baud(baudrate);
00029 }
00030 
00031 void RFManager::rxHandler(void) {
00032     // Interrupt does not work with RTOS when using standard functions (getc, putc)
00033     // https://developer.mbed.org/forum/bugs-suggestions/topic/4217/
00034 
00035     while (serial.readable()) {
00036         char c = serialReadChar();
00037 
00038         if (receiveCounter < commandLength) {
00039             if (receiveCounter == 0) {
00040                 // Do not continue before a is received
00041                 if (c == 'a') {
00042                     receiveBuffer[receiveCounter] = c;
00043                     receiveCounter++;
00044                 }
00045             } else if (c == 'a' && !shortCommandsEnabled
00046                 || c == 'a' && shortCommandsEnabled && (receiveCounter < commandLength - 1)
00047             ) {
00048                 // If a is received in the middle, assume some bytes got lost before and start from beginning
00049                 receiveCounter = 0;
00050 
00051                 receiveBuffer[receiveCounter] = c;
00052                 receiveCounter++;
00053             } else {
00054                 receiveBuffer[receiveCounter] = c;
00055                 receiveCounter++;
00056             }
00057 
00058             if (receiveCounter == commandLength) {
00059                 receiveCounter = 0;
00060 
00061                 for (unsigned int i = 0; i < commandLength; i++) {
00062                     buf.queue(receiveBuffer[i]);
00063                 }
00064 
00065                 if (!messageAvailable) {
00066                     handleMessage();
00067                     //break;
00068                 }
00069             }
00070         }
00071     }
00072 }
00073 
00074 bool RFManager::readable() {
00075     return messageAvailable;
00076 }
00077 
00078 char *RFManager::read() {
00079     messageAvailable = false;
00080     return receivedMessage;
00081 }
00082 
00083 void RFManager::send(char *sendData) {
00084     serialWrite(sendData, commandLength);
00085 }
00086 
00087 void RFManager::send(char *sendData, int length) {
00088     serialWrite(sendData, length);
00089 }
00090 
00091 void RFManager::update() {
00092     /*if (receiveCounter == commandLength) {
00093         handleMessage();
00094         _callback.call();
00095     }*/
00096 
00097     if (buf.available() >= commandLength) {
00098         handleMessage();
00099     }
00100 }
00101 
00102 void RFManager::handleMessage() {
00103     if (messageAvailable) {
00104         return;
00105     }
00106 
00107     for (unsigned int i = 0; i < commandLength; i++) {
00108         buf.dequeue(receivedMessage + i);
00109     }
00110 
00111     receivedMessage[commandLength] = '\0';
00112 
00113     /*receiveCounter = 0;
00114 
00115     memcpy(receivedMessage, receiveBuffer, sizeof(receiveBuffer));*/
00116 
00117     messageAvailable = true;
00118 }
00119 
00120 void RFManager::serialWrite(char *sendData, int length) {
00121     int i = 0;
00122 
00123     while (i < length) {
00124         if (serial.writeable()) {
00125             serial.putc(sendData[i]);
00126         }
00127         i++;
00128     }
00129 }
00130 
00131 char RFManager::serialReadChar() {
00132     if (serialId == 1) {
00133         return LPC_UART1->RBR;
00134     }
00135 
00136     if (serialId == 2) {
00137         return LPC_UART2->RBR;
00138     }
00139 
00140     if (serialId == 3) {
00141         return LPC_UART3->RBR;
00142     }
00143 
00144     return LPC_UART0->RBR;
00145 }
00146 
00147 void RFManager::setShortCommandMode(bool isEnabled) {
00148     shortCommandsEnabled = isEnabled;
00149     receiveCounter = 0;
00150 
00151     if (isEnabled) {
00152         commandLength = shortCommandLength;
00153     } else {
00154         commandLength = longCommandLength;
00155     }
00156 }