Diff: FEP.cpp

Revision:

5:9f7d2ba5e188

Parent:

4:7259654e8082

--- a/FEP.cpp	Fri Jul 14 09:20:10 2017 +0000
+++ b/FEP.cpp	Sat Jul 22 05:44:12 2017 +0000
@@ -1,154 +1,235 @@
 #include "FEP.h"
 
-FEP::FEP(PinName tx,PinName rx,int baud):serial(tx,rx,baud){
-    
+FEP::FEP(PinName tx, PinName rx, uint8_t addr, int baud):serial(tx,rx)
+{
+    FEP::serial.baud(baud);
+    FEP::_address = addr;
+}
+FEP::~FEP()
+{
+
 }
-FEP::~FEP(){
-    
+
+int FEP::rxHandler(char *data)
+{
+    int i,n;
+    char buf[FEP_LINE_LEN];
+    for(i=0,n=0; i <= FEP_LINE_LEN; i++) {
+        while(FEP::serial.readable() == 0) {
+            if(n > FEP_TIMEOUT_COUNT) return FEP_NO_RESPONSE;
+            n++;
+        }
+        n=0;
+        buf[i] = FEP::serial.getc();
+        if(i >= 1 && (buf[i-1] == '\r' && buf[i] =='\n')) {
+            for(n=0; n <= i; n++) {
+                data[n] = buf[n];
+            }
+            return 0;
+        }
+    }
+    return 1;
 }
 
-uint8_t FEP::RST(){
-    uint8_t i,response;
-    for(i=0;i<FEP_RETRY;i++){
-        serial.printf("@RST\r\n");
-        response=FEP::getResponse();
-        if(response==FEP_P0) break;
+uint8_t FEP::getResponse()
+{
+    char buf[FEP_LINE_LEN];
+    memset(buf, 0, sizeof(buf));
+    if(FEP::rxHandler(buf) == FEP_NO_RESPONSE) {
+        return FEP_NO_RESPONSE;
+    }
+    if (strlen(buf) > 4) {
+        /* the packet in buffer is not response, continue to wait */
+        return FEP::getResponse();
     }
+
+    if (strcmp(buf, "P1\r\n") == 0) {
+        return FEP::getResponse();
+    } else {
+        if (strcmp(buf, "P0\r\n") == 0) {
+            return FEP_P0;
+        } else if (strcmp(buf, "N0\r\n") == 0) {
+            return FEP_N0;
+        } else if (strcmp(buf, "N1\r\n") == 0) {
+            return FEP_N1;
+        } else if (strcmp(buf, "N2\r\n") == 0) {
+            return FEP_N2;
+        } else if (strcmp(buf, "N3\r\n") == 0) {
+            return FEP_N3;
+        } else {
+            return FEP::getResponse();
+        }
+    }
+}
+
+uint8_t FEP::puts(char *data, uint8_t len)
+{
+    uint8_t response;
+
+    FEP::serial.printf("@TXT%03uG",FEP::_address);
+    for(int i = 0; i<len; i++) {
+        FEP::serial.printf("%02x",data[i]);
+    }
+    FEP::serial.printf("H\r\n");
+    response = FEP::getResponse();
     return response;
 }
 
-uint8_t FEP::getResponse(){
-    int n,i=3;
-    char buf[256];
+uint8_t FEP::putbin(char *ary, size_t len)
+{
+    uint8_t response, j;
 
-    for(n=0; n<FEP_TIMEOUT_MS; n++) {
-        if(serial.readable()) {
-            n=0;
-            buf[i]=serial.getc();
-            if(buf[i-1]=='\r' && buf[i]=='\n') {
-                if(buf[i-3]=='P' && buf[i-2]=='1') {
-                    return FEP::getResponse();
-                } else {
-                    if(buf[i-3]=='P' && buf[i-2]=='0') {
-                        return FEP_P0;
-                    } else if(buf[i-3]=='N' && buf[i-2]=='0') {
-                        return FEP_N0;
-                    } else if(buf[i-3]=='N' && buf[i-2]=='1') {
-                        return FEP_N1;
-                    } else if(buf[i-3]=='N' && buf[i-2]=='2') {
-                        return FEP_N2;
-                    } else if(buf[i-3]=='N' && buf[i-2]=='3') {
-                        return FEP_N3;
-                    } else {
-                        i=3;
-                        continue;
-                    }
-                }
-            }
-            i++;
-        } else {
-            wait_us(10);
-            continue;
-        }
+    FEP::serial.printf("@TBN%03d%03d", FEP::_address, len);
+    for (j = 0; j < len; j++) {
+        FEP::serial.putc(ary[j]);
     }
-    return FEP_NO_RESPONSE;
-}
+    FEP::serial.putc('\r');
+    FEP::serial.putc('\n');
 
-uint8_t FEP::write_txt(char _data[],uint8_t _addr,uint8_t len){
-//    serial.printf("@TXT%03uA%sB\r\n",_addr,_data);
-    serial.printf("@TXT%03uG",_addr);
-    for(int i = 0;i<len;i++) {
-        serial.printf("%02x",_data[i]);
-    }
-    serial.printf("H\r\n");
-    return FEP::getResponse();
+    response = FEP::getResponse();
+    response = FEP::getResponse();
+    return response;
 }
 
-uint8_t FEP::readIntensity(){
-    char data[256];
-    int intensity;
-    uint16_t i=0,n;
-    serial.putc('@');
-    serial.putc('D');
-    serial.putc('B');
-    serial.putc('M');
-    serial.putc('\r');
-    serial.putc('\n');
-    for(n=0; n<FEP_TIMEOUT_MS; n++) {
-        if(serial.readable()){
-            data[i]=serial.getc();
-            i++;
-            n=0;
-        }else{
-            wait_us(10);
-            continue;
-        }
-        if(i>7) break;
-    }
-    if(data[0]=='N' && data[1]=='0'){
-        return FEP_N0;
-    }else{
-        intensity=atoi(data);
-        _intensity=abs(intensity);
-        return FEP_P0;
-    }
-}
-
-uint8_t FEP::getIntensity(){
-    return _intensity;
-}
-
-uint8_t FEP::read_txt(char *str,uint8_t len)
+void FEP::hex2dec(char *data,char *str,uint8_t len)
 {
-    uint16_t i,n,m,k;
-    char raw_data[256];
-    char data[256];
-    char intensity_c[3]={0};
-    for(k=0;k<FEP_RX_TIMEOUT_US;k++){
-        if(serial.readable()) {
-            k=0;
-            raw_data[0]=serial.getc();
-            if(raw_data[0]=='R') {
-                i=1;
-                for(k=0;k<FEP_RX_TIMEOUT_US;k++) {
-                    if(serial.readable()) {
-                        raw_data[i]=serial.getc();
-                        if(raw_data[i-1]=='\r' && raw_data[i]=='\n') {
-                            for(n=0; n<(i-10); n++) {
-                                data[n]=raw_data[n+6];
-                            }
-                            intensity_c[0]=raw_data[n+6];
-                            intensity_c[1]=raw_data[n+7];
-                            intensity_c[2]=raw_data[n+8];
-                            _intensity=abs(atoi(intensity_c));
-                            if(data[0]=='G' && data[n-1]=='H') {
-                                FEP::hex2dec(data,str,len);
-                                return FEP_RX_SUCCESS;
-                            } else {
-                                return FEP_RX_FAIL;
-                            }
-                        }
-                        i++;
-                    }else{
-                        wait_us(1);
-                        continue;
-                    }
-                }
-            }
-        }else{
-            wait_us(1);
-            continue;
-        }
-    }
-    return FEP_NO_RESPONSE;
-}
-
-void FEP::hex2dec(char data[],char *str,uint8_t len) {
     char *endptr;
     char buf[2];
-    for(int i = 0;i < len*2;i+=2) {
+    for(int i = 0; i < len*2; i+=2) {
         buf[0] = data[1+i];
         buf[1] = data[1+i+1];
         str[i/2] = (char)strtol(buf, &endptr, 16);
     }
 }
+
+int FEP::ctoi(char c)
+{
+    if('0' <= c && c <= '9') return (c-'0');
+    else return -1;
+}
+
+uint8_t FEP::gets(char *data, uint8_t len)
+{
+    char buf[FEP_LINE_LEN], sub[FEP_LINE_LEN];
+    uint8_t temp;
+    uint16_t i;
+    uint8_t data_mode;
+    size_t data_len;
+    memset(buf, 0, sizeof(buf));
+    temp = FEP::rxHandler(buf);
+    if(temp == FEP_NO_RESPONSE) {
+        return FEP_NO_RESPONSE;
+    } else if(temp == 1) {
+        return FEP_DT_ERR;
+    }
+    if (strlen(buf) >= 3) {
+        /* get command part */
+        strncpy(sub, buf, 3);
+        sub[3] = '\0';
+        if (!strcmp(sub, "RXT")) {
+            /* Subtract string from a part before the intensity  */
+            strncpy(sub, buf, strlen(buf) - 3 - 2);
+            sub[strlen(buf) - 3 - 2 + 1] = '\0';
+
+            /* Get transmitter's address */
+            temp = 0;
+            temp += FEP::ctoi(sub[3])*100;
+            temp += FEP::ctoi(sub[4])*10;
+            temp += FEP::ctoi(sub[5])*1;
+            FEP::_transmitterAddr = temp;
+            /* Store message to str */
+            data_len = strlen(buf) - 6 - 3 - 2;
+            if (data_len > len) {
+                /* received data is too long! */
+                return FEP_DT_ERR;
+            }
+            strncpy(data, buf + 6, data_len);
+
+            /* Get intensity part of string */
+            strncpy(sub, buf + strlen(buf) - 3 - 2, 3);
+            sub[3] = '\0';
+            data_mode = FEP_DT_STR;
+        } else if (!strcmp(sub, "RBN")) {
+            /* addr and length part */
+            strncpy(sub, buf + 3, 6);
+            sub[6] = '\0';
+
+            /* Get transmitter's address & data length */
+            temp = 0;
+            temp += FEP::ctoi(sub[0])*100;
+            temp += FEP::ctoi(sub[1])*10;
+            temp += FEP::ctoi(sub[2])*1;
+            FEP::_transmitterAddr = temp;
+            temp = 0;
+            temp += FEP::ctoi(sub[3])*100;
+            temp += FEP::ctoi(sub[4])*10;
+            temp += FEP::ctoi(sub[5])*1;
+            data_len = temp;
+            /* Store binary data to array */
+            if (data_len > len) {
+                /* received data is too long! */
+                return FEP_DT_ERR;
+            }
+            /* memcpy(str, buf + 9, data_len); */
+            for (i = 0; i < data_len; i++) {
+                data[i] = buf[i + 9];
+            }
+
+            /* Get intensity part of string */
+            strncpy(sub, buf + 9 + data_len, 3);
+            sub[3] = '\0';
+
+            data_mode = FEP_DT_BIN;
+        }
+
+        temp = 0;
+        temp += FEP::ctoi(sub[0])*100;
+        temp += FEP::ctoi(sub[1])*10;
+        temp += FEP::ctoi(sub[2])*1;
+        FEP::_intensity = temp;
+    }
+
+    return data_mode;
+}
+
+uint8_t FEP::getTransmitterAddr()
+{
+    return FEP::_transmitterAddr;
+}
+
+uint8_t FEP::getIntensity()
+{
+    return FEP::_intensity;
+}
+
+uint8_t FEP::read(char *data, uint8_t len)
+{
+    char str[FEP_LINE_LEN];
+    uint8_t temp;
+    temp = FEP::gets(str, (len*2+2));
+    if(temp == FEP_DT_STR) {
+        if(str[0] == 'G' && str[(len*2+2)-1] == 'H') {
+            FEP::hex2dec(str,data,len);
+            return 0;
+        } else {
+            return 1;
+        }
+    } else if(temp == FEP_DT_BIN) {
+        return FEP_DT_BIN;
+    } else if(temp == FEP_DT_ERR) {
+        return FEP_DT_ERR;
+    } else {
+        return FEP_NO_RESPONSE;
+    }
+}
+
+uint8_t FEP::reset()
+{
+    uint8_t response;
+    FEP::serial.printf("@RST\r\n");
+    response = FEP::getResponse();
+    while(response != FEP_P0) {
+        response = FEP::getResponse();
+    }
+    return response;
+}