Diff: lifiReceiver.cpp

Revision:

11:8ffa8a36126f

Parent:

3:ae1f53883bc0

Child:

12:df54493ec7e4

diff -r 4561736ca355 -r 8ffa8a36126f lifiReceiver.cpp
--- a/lifiReceiver.cpp	Fri Apr 05 08:31:05 2019 +0000
+++ b/lifiReceiver.cpp	Sat Apr 06 04:17:35 2019 +0000
@@ -25,10 +25,13 @@
 };
 
 enum receiver_state {
-    IDLE = 0, //waiting for sync
-    SYNC, //synced, waiting for STX
-    START, //STX received
-    DATA //receiving DATA
+    IDLE_STATE = 0, //waiting for sync
+    SYNC_STATE, //synced, waiting for STX
+    START_STATE, //STX received
+    LENGTH_LSB_STATE,
+    LENGTH_MSB_STATE,
+    DATA_STATE, //receiving DATA
+    END_STATE
 };
 
 
@@ -86,6 +89,8 @@
     // no auxiliary security header
     int rx_frame_index  ;
     int rx_frame_size  ;
+    uint16_t length;
+    uint16_t received_data_count;
 };// __attribute__((packed));
 
 static RX_VARS rx_vars[LIFI_MIMO_CHANNEL_NUM] ;
@@ -98,18 +103,18 @@
 #if RX_DEBUG_BIN
     printf("\t %d[%4x] ",channel+1, *detected_word );
 #endif
-    if(time_from_last_sync >= 20  || rx_vars[channel].frame_state == IDLE) { // we received enough bits to test the sync
+    if(time_from_last_sync >= 20  || rx_vars[channel].frame_state == IDLE_STATE) { // we received enough bits to test the sync
         if(((*manchester_word) & START_STOP_MASK) == (START_STOP_MASK)) { // testing first position
             (*detected_word) = ((*manchester_word) >> 2) & 0xFFFF;
 
-            if(rx_vars[channel].frame_state == IDLE) {
+            if(rx_vars[channel].frame_state == IDLE_STATE) {
                 if((*detected_word) == SYNC_SYMBOL_MANCHESTER) {
                     return 2 ;
                 }
             }
             return 1 ;
             // byte with correct framing
-        } else if(rx_vars[channel].frame_state != IDLE && time_from_last_sync == 20) {
+        } else if(rx_vars[channel].frame_state != IDLE_STATE && time_from_last_sync == 20) {
             (*detected_word)= ((*manchester_word) >> 2) & 0xFFFF;
             return 1 ;
         }
@@ -251,47 +256,102 @@
     if(data == SYNC_SYMBOL/* && (*rx_frame_index) < 0*/) {
         (*rx_frame_index) = 0 ;
         (*rx_frame_size) = 0 ;
-        (*frame_state) = SYNC ;
+        (*frame_state) = SYNC_STATE ;
 #if RX_DEBUG_FRAME
         printf("\n%dSYNC ",channel+1);
 #endif
         return 0 ;
     }
-    if((*frame_state) != IDLE) { // we are synced
+    if((*frame_state) != IDLE_STATE) { // we are synced
         rx_frame_buffer[*rx_frame_index] = data ;
         (*rx_frame_index) ++ ;
-        if(data == STX) {
+
+        if((*frame_state) == SYNC_STATE ){
+            if(data == STX) {
 #if RX_DEBUG_FRAME
             printf("%dSTART ",channel+1);
 #endif
-            (*frame_state) = START ;
-            return 0 ;
-        } else if(data == ETX) {
+                (*frame_state) = START_STATE ;
+                return 0 ;
+            }
+            else if(data == SYNC_SYMBOL){
+                // do nothing
+            }
+            else{
+                printf("\n Error # got wrong data after SYNC. it should be STX");
+            }
+
+        }
+        else if((*frame_state) == START_STATE ){
+
+#if RX_DEBUG_FRAME
+            printf("%dLENGTH_LSB ",channel+1);
+#endif
+            (*frame_state) = LENGTH_LSB_STATE ;
+            rx_vars[channel].length = data;
+        }
+        else if((*frame_state) == LENGTH_LSB_STATE ){
+
+#if RX_DEBUG_FRAME
+            printf("%dLENGTH_MSB ",channel+1);
+#endif
+            (*frame_state) = LENGTH_MSB_STATE ;
+            rx_vars[channel].length = rx_vars[channel].length + (data << 8 );
+        }
+        else if((*frame_state) == LENGTH_MSB_STATE ){
+
+#if RX_DEBUG_FRAME
+             printf("%dD=%c[%x] ",channel+1,data,data);
+#endif
+            (*frame_state) = DATA_STATE ;
+            rx_vars[channel].received_data_count = 1;
+
+        }
+        else if((*frame_state) == DATA_STATE ){
+
+#if RX_DEBUG_FRAME
+            printf("%dD=%c[%x] ",channel+1,data,data);
+#endif
+//            (*frame_state) = DATA_STATE ;
+            rx_vars[channel].received_data_count++;
+
+            if(rx_vars[channel].received_data_count >= rx_vars[channel].length )
+            {
+                (*frame_state) = END_STATE ;
+            }
+        }
+        else if((*frame_state) == END_STATE ){
+            if(data == ETX) {
 #if RX_DEBUG_FRAME
             printf("%dEND IDLE ",channel+1);
 #endif
-            (*rx_frame_size) = (*rx_frame_index) ;
-            (*rx_frame_index) = -1 ;
-            (*frame_state) = IDLE ;
+                (*rx_frame_size) = (*rx_frame_index) ;
+                (*rx_frame_index) = -1 ;
+                (*frame_state) = IDLE_STATE ;
 
-            return 1 ;
-        } else if((*rx_frame_index) >= FRAME_BUFFER_SIZE) { //frame is larger than max size of frame ...
+                return 1 ;
+            }
+            else
+            {
+                printf("\n Error # got wrong data. it should be ETX");
+                return 1;
+            }
+        }
+        else if((*rx_frame_index) >= FRAME_BUFFER_SIZE) { //frame is larger than max size of frame ...
 #if RX_DEBUG_FRAME
             printf("%dIDLE - over FRAME_BUFFER_SIZE ",channel+1);
 #endif
             (*rx_frame_index) = -1 ;
             (*rx_frame_size) = -1 ;
-            (*frame_state) = IDLE ;
+            (*frame_state) = IDLE_STATE ;
             return -1 ;
         } else {
-#if RX_DEBUG_FRAME
-            printf("%dD=%c[%x] ",channel+1,data,data);
-#endif
-            (*frame_state) = DATA ;
+            printf("\n Error # unknown state");
+            return 1;
         }
-        return 0 ;
+        return 0 ;  // normal
     }
-    return -1 ;
+    return -1 ;  // error
 }
 
 int counter = 0;
@@ -382,7 +442,7 @@
                 rx_vars[channel].is_valid   = false;
             }
         }
-        //if(frame_state != IDLE) println(received_data, HEX);
+        //if(frame_state != IDLE_STATE) println(received_data, HEX);
     }
 }
 
@@ -394,25 +454,25 @@
     }
 #if RX_DEBUG_MAIN_LOOP    
     printf("\n{{{");
-    printf("\nMSG valid=%d, (ch_%d)[%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_1].is_valid, LIFI_CHANNEL_1, rx_vars[LIFI_CHANNEL_1].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_1].probe_adc_high_received,rx_vars[LIFI_CHANNEL_1].probe_adc_low_received, rx_vars[LIFI_CHANNEL_1].probe_adc_gap_received);
+    printf("\nMSG valid=%d, (ch_%d)[len:%d/%d][%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_1].is_valid, rx_vars[LIFI_CHANNEL_1].received_data_count, rx_vars[LIFI_CHANNEL_1].length, LIFI_CHANNEL_1, rx_vars[LIFI_CHANNEL_1].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_1].probe_adc_high_received,rx_vars[LIFI_CHANNEL_1].probe_adc_low_received, rx_vars[LIFI_CHANNEL_1].probe_adc_gap_received);
 #endif    
     rx_vars[LIFI_CHANNEL_1].is_received = false;
     
     if(Lifi_IsChannelAvailable(LIFI_CHANNEL_2)) {
 #if RX_DEBUG_MAIN_LOOP   
-        printf("\nMSG valid=%d, (ch_%d)[%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_2].is_valid, LIFI_CHANNEL_2, rx_vars[LIFI_CHANNEL_2].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_2].probe_adc_high_received,rx_vars[LIFI_CHANNEL_2].probe_adc_low_received, rx_vars[LIFI_CHANNEL_2].probe_adc_gap_received);
+        printf("\nMSG valid=%d, (ch_%d)[len:%d/%d][%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_2].is_valid, rx_vars[LIFI_CHANNEL_2].received_data_count, rx_vars[LIFI_CHANNEL_2].length, LIFI_CHANNEL_2, rx_vars[LIFI_CHANNEL_2].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_2].probe_adc_high_received,rx_vars[LIFI_CHANNEL_2].probe_adc_low_received, rx_vars[LIFI_CHANNEL_2].probe_adc_gap_received);
 #endif   
         rx_vars[LIFI_CHANNEL_2].is_received = false;
     }
     if(Lifi_IsChannelAvailable(LIFI_CHANNEL_3)) {
 #if RX_DEBUG_MAIN_LOOP   
-       printf("\nMSG valid=%d, (ch_%d)[%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_3].is_valid, LIFI_CHANNEL_3, rx_vars[LIFI_CHANNEL_3].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_3].probe_adc_high_received,rx_vars[LIFI_CHANNEL_3].probe_adc_low_received, rx_vars[LIFI_CHANNEL_3].probe_adc_gap_received);
+       printf("\nMSG valid=%d, (ch_%d)[len:%d/%d][%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_3].is_valid, rx_vars[LIFI_CHANNEL_3].received_data_count, rx_vars[LIFI_CHANNEL_3].length, LIFI_CHANNEL_3, rx_vars[LIFI_CHANNEL_3].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_3].probe_adc_high_received,rx_vars[LIFI_CHANNEL_3].probe_adc_low_received, rx_vars[LIFI_CHANNEL_3].probe_adc_gap_received);
 #endif   
         rx_vars[LIFI_CHANNEL_3].is_received = false;
     }
     if(Lifi_IsChannelAvailable(LIFI_CHANNEL_4)) {
 #if RX_DEBUG_MAIN_LOOP   
-        printf("\nMSG valid=%d, (ch_%d)[%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_4].is_valid, LIFI_CHANNEL_4, rx_vars[LIFI_CHANNEL_4].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_4].probe_adc_high_received,rx_vars[LIFI_CHANNEL_4].probe_adc_low_received, rx_vars[LIFI_CHANNEL_4].probe_adc_gap_received);
+        printf("\nMSG valid=%d, (ch_%d)[len:%d/%d][%s] Adc[Max=%d Min=%d Gap=%d]", rx_vars[LIFI_CHANNEL_4].is_valid,rx_vars[LIFI_CHANNEL_4].received_data_count, rx_vars[LIFI_CHANNEL_4].length, LIFI_CHANNEL_4, rx_vars[LIFI_CHANNEL_4].rx_frame_buffer_received,rx_vars[LIFI_CHANNEL_4].probe_adc_high_received,rx_vars[LIFI_CHANNEL_4].probe_adc_low_received, rx_vars[LIFI_CHANNEL_4].probe_adc_gap_received);
 #endif   
         rx_vars[LIFI_CHANNEL_4].is_received = false;
     }