JongYong Park / Mbed 2 deprecated NUCLEO-F767_LIFI_4CH_os2_v2

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed

lifiReceiver.cpp@26:26474003e443, 2019-04-09 (annotated)

Committer:
JongYongPark
Date:
Tue Apr 09 12:06:34 2019 +0000
Revision:
26:26474003e443
Parent:
20:6a8e86d7d504
Child:
27:19ee6e15ba5e
working version again

Who changed what in which revision?

UserRevisionLine numberNew contents of line
JongYongPark 0:488aa8153e15 1 #include "app.h"
JongYongPark 0:488aa8153e15 2 //#include "../arduino.h"
JongYongPark 0:488aa8153e15 3 //#include "mbed.h"
JongYongPark 0:488aa8153e15 4 //#include <string>
JongYongPark 0:488aa8153e15 5
JongYongPark 0:488aa8153e15 6 #include "lifiTranceiver.h"
JongYongPark 0:488aa8153e15 7 #include "lifiTranceiverLocal.h"
JongYongPark 0:488aa8153e15 8
JongYongPark 0:488aa8153e15 9 //#define USE_SLOW_TXRX_DEMO
JongYongPark 0:488aa8153e15 10 //#define USE_SERIAL_COMMAND
JongYongPark 0:488aa8153e15 11
JongYongPark 0:488aa8153e15 12 //// OLED를 활성화 시키면 FreeRTOS가 정상 동작 안한다. 이문제는 다음에 해결하기로 하자.
JongYongPark 0:488aa8153e15 13 //// 한글 입력이 잘 되네.
JongYongPark 0:488aa8153e15 14
JongYongPark 0:488aa8153e15 15 // TODO 1 : ADCREF 3.3 Volt - Done
JongYongPark 0:488aa8153e15 16 // TODO 2 : Check Max/Max ADC
JongYongPark 0:488aa8153e15 17 ///////////////////////////////////////////////////////
JongYongPark 0:488aa8153e15 18 ///////// HEADER //////////////////////////////////////
JongYongPark 0:488aa8153e15 19
JongYongPark 0:488aa8153e15 20 enum op_mode {
JongYongPark 26:26474003e443 21 OP_HF, OP_LF, OP_PLOT_ADC, OP_RESERVED
JongYongPark 0:488aa8153e15 22 };
JongYongPark 0:488aa8153e15 23
JongYongPark 0:488aa8153e15 24 enum receiver_state {
JongYongPark 26:26474003e443 25 IDLE_STATE = 0, //waiting for sync
JongYongPark 26:26474003e443 26 SYNC_STATE, //synced, waiting for STX
JongYongPark 26:26474003e443 27 START_STATE, //STX received
JongYongPark 26:26474003e443 28 LENGTH_LSB_STATE,
JongYongPark 26:26474003e443 29 LENGTH_MSB_STATE,
JongYongPark 26:26474003e443 30 DATA_STATE, //receiving DATA
JongYongPark 26:26474003e443 31 END_STATE
JongYongPark 0:488aa8153e15 32 };
JongYongPark 0:488aa8153e15 33
JongYongPark 0:488aa8153e15 34 ///////////////////////////////////////////////////////
JongYongPark 0:488aa8153e15 35 //////////// GLOBAL VARIABLES //////////////////////
JongYongPark 26:26474003e443 36 int waiting_count_for_all_channel_finished =0 ;
JongYongPark 0:488aa8153e15 37 unsigned char incomingByte;
JongYongPark 0:488aa8153e15 38 int lines = 0;
JongYongPark 0:488aa8153e15 39 int chars = 0;
JongYongPark 0:488aa8153e15 40
JongYongPark 0:488aa8153e15 41 ////////////
JongYongPark 0:488aa8153e15 42
JongYongPark 0:488aa8153e15 43 //manechester decoder state variable
JongYongPark 0:488aa8153e15 44 //long shift_reg = 0;
JongYongPark 0:488aa8153e15 45 //
JongYongPark 0:488aa8153e15 46 //int oldValue = 0 ;
JongYongPark 0:488aa8153e15 47 //int steady_count = 0 ;
JongYongPark 0:488aa8153e15 48 //int dist_last_sync = 0 ;
JongYongPark 0:488aa8153e15 49 //unsigned int detected_word = 0;
JongYongPark 0:488aa8153e15 50 //int new_word = 0;
JongYongPark 0:488aa8153e15 51 //int old_edge_val = 0 ;
JongYongPark 0:488aa8153e15 52 //int probe_adc_high = 0;
JongYongPark 0:488aa8153e15 53 //int probe_adc_low = 0;
JongYongPark 0:488aa8153e15 54 //int probe_adc_gap = 0;
JongYongPark 0:488aa8153e15 55
JongYongPark 0:488aa8153e15 56 struct RX_VARS {
JongYongPark 26:26474003e443 57 int sensorValue;
JongYongPark 26:26474003e443 58 int oldValue;
JongYongPark 26:26474003e443 59 int edge_val;
JongYongPark 26:26474003e443 60 int steady_count;
JongYongPark 26:26474003e443 61 int dist_last_sync;
JongYongPark 26:26474003e443 62 unsigned int detected_word;
JongYongPark 26:26474003e443 63 int new_word;
JongYongPark 26:26474003e443 64 long shift_reg;
JongYongPark 26:26474003e443 65 int old_edge_val;
JongYongPark 26:26474003e443 66 int probe_adc_high;
JongYongPark 26:26474003e443 67 int probe_adc_low;
JongYongPark 26:26474003e443 68 int probe_adc_gap;
JongYongPark 26:26474003e443 69 enum receiver_state frame_state;
JongYongPark 26:26474003e443 70 uint8_t rx_frame_buffer[FRAME_BUFFER_SIZE];
JongYongPark 26:26474003e443 71 //////////// keep received message
JongYongPark 26:26474003e443 72 bool is_valid;
JongYongPark 26:26474003e443 73 bool is_received;
JongYongPark 26:26474003e443 74 // uint8_t rx_frame_buffer_save[FRAME_BUFFER_SIZE];
JongYongPark 26:26474003e443 75 int probe_adc_high_received;
JongYongPark 26:26474003e443 76 int probe_adc_low_received;
JongYongPark 26:26474003e443 77 int probe_adc_gap_received;
JongYongPark 26:26474003e443 78 ///////////
JongYongPark 26:26474003e443 79 // no auxiliary security header
JongYongPark 26:26474003e443 80 int rx_frame_index;
JongYongPark 26:26474003e443 81 int rx_frame_size;
JongYongPark 26:26474003e443 82 uint16_t pdu_length;
JongYongPark 26:26474003e443 83 uint16_t pdu_length_count;
JongYongPark 26:26474003e443 84 // uint16_t pdu_length_save;
JongYongPark 26:26474003e443 85 // uint16_t pdu_length_count_save;
JongYongPark 26:26474003e443 86 uint16_t frame_length;
JongYongPark 26:26474003e443 87 // uint16_t frame_length_save;
JongYongPark 14:07669aafe0e4 88 };
JongYongPark 14:07669aafe0e4 89 // __attribute__((packed));
JongYongPark 0:488aa8153e15 90
JongYongPark 26:26474003e443 91 struct RX_VARS_RECEIVED {
JongYongPark 26:26474003e443 92 int probe_adc_high;
JongYongPark 26:26474003e443 93 int probe_adc_low;
JongYongPark 26:26474003e443 94 int probe_adc_gap;
JongYongPark 26:26474003e443 95 uint8_t rx_frame_buffer[FRAME_BUFFER_SIZE];
JongYongPark 26:26474003e443 96 //////////// keep received message
JongYongPark 26:26474003e443 97 bool is_valid;
JongYongPark 26:26474003e443 98 bool is_received;
JongYongPark 26:26474003e443 99 ///////////
JongYongPark 26:26474003e443 100 int rx_frame_size;
JongYongPark 26:26474003e443 101 uint16_t pdu_length;
JongYongPark 26:26474003e443 102 uint16_t pdu_length_count;
JongYongPark 26:26474003e443 103 uint16_t frame_length;
JongYongPark 26:26474003e443 104 };
JongYongPark 26:26474003e443 105
JongYongPark 14:07669aafe0e4 106 static RX_VARS rx_vars[LIFI_MIMO_CHANNEL_NUM];
JongYongPark 26:26474003e443 107 static RX_VARS_RECEIVED rx_vars_received[LIFI_MIMO_CHANNEL_NUM];
JongYongPark 26:26474003e443 108
JongYongPark 26:26474003e443 109 void LifiRx_CopyAdcInfo_FromReceivedFrame(int channel, int high, int low)
JongYongPark 26:26474003e443 110 {
JongYongPark 26:26474003e443 111 rx_vars_received[channel].probe_adc_high = high ;
JongYongPark 26:26474003e443 112 rx_vars_received[channel].probe_adc_low = low ;
JongYongPark 26:26474003e443 113 rx_vars_received[channel].probe_adc_gap = high - low ;
JongYongPark 26:26474003e443 114 }
JongYongPark 26:26474003e443 115
JongYongPark 26:26474003e443 116 void LifiRx_CopyData_FromReceivedFrame(int channel)
JongYongPark 26:26474003e443 117 {
JongYongPark 26:26474003e443 118 rx_vars_received[channel].is_received = rx_vars[channel].is_received ;
JongYongPark 26:26474003e443 119 rx_vars_received[channel].is_valid = rx_vars[channel].is_valid ;
JongYongPark 26:26474003e443 120
JongYongPark 26:26474003e443 121 rx_vars_received[channel].rx_frame_size = rx_vars[channel].rx_frame_size ;
JongYongPark 26:26474003e443 122 rx_vars_received[channel].pdu_length = rx_vars[channel].pdu_length ;
JongYongPark 26:26474003e443 123 rx_vars_received[channel].pdu_length_count = rx_vars[channel].pdu_length_count ;
JongYongPark 26:26474003e443 124 rx_vars_received[channel].frame_length = rx_vars[channel].frame_length ;
JongYongPark 26:26474003e443 125
JongYongPark 26:26474003e443 126 memcpy( rx_vars_received[channel].rx_frame_buffer, rx_vars[channel].rx_frame_buffer, FRAME_BUFFER_SIZE) ;
JongYongPark 26:26474003e443 127 }
JongYongPark 26:26474003e443 128
JongYongPark 26:26474003e443 129 void LifiRx_CopyAll_FromReceivedFrame(int channel)
JongYongPark 26:26474003e443 130 {
JongYongPark 26:26474003e443 131 LifiRx_CopyAdcInfo_FromReceivedFrame(channel, rx_vars[channel].probe_adc_high, rx_vars[channel].probe_adc_low );
JongYongPark 26:26474003e443 132 LifiRx_CopyData_FromReceivedFrame(channel);
JongYongPark 26:26474003e443 133 }
JongYongPark 26:26474003e443 134
JongYongPark 26:26474003e443 135 void print_frame_data(uint8_t* frame, int length)
JongYongPark 26:26474003e443 136 {
JongYongPark 26:26474003e443 137 printf(" frame (%d) = ",length);
JongYongPark 26:26474003e443 138 for(int i=0; i < length; i++) {
JongYongPark 26:26474003e443 139 // https://simple.wikipedia.org/wiki/ASCII
JongYongPark 26:26474003e443 140 if(frame[i] >= 0x20 && frame[i] <= 0x7E ) {
JongYongPark 26:26474003e443 141 //printf("[%d]%c_%02x ",i,frame[i],frame[i]);
JongYongPark 26:26474003e443 142 printf("%c",frame[i]);
JongYongPark 26:26474003e443 143 } else {
JongYongPark 26:26474003e443 144 //printf("[%d]_%02x ",i,frame[i]);
JongYongPark 26:26474003e443 145 printf(" x%02x ",frame[i]);
JongYongPark 26:26474003e443 146 }
JongYongPark 26:26474003e443 147 }
JongYongPark 26:26474003e443 148 }
JongYongPark 26:26474003e443 149
JongYongPark 26:26474003e443 150 void print_pdu_data(uint8_t* frame, int length)
JongYongPark 26:26474003e443 151 {
JongYongPark 26:26474003e443 152 printf(" pdu (%d) = ",length);
JongYongPark 26:26474003e443 153 for(int i=0; i < length; i++) {
JongYongPark 26:26474003e443 154 // https://simple.wikipedia.org/wiki/ASCII
JongYongPark 26:26474003e443 155 if(frame[i] >= 0x20 && frame[i] <= 0x7E ) {
JongYongPark 26:26474003e443 156 printf("%c",frame[i]);
JongYongPark 26:26474003e443 157 } else {
JongYongPark 26:26474003e443 158 printf(" ");
JongYongPark 26:26474003e443 159 }
JongYongPark 26:26474003e443 160 }
JongYongPark 26:26474003e443 161 }
JongYongPark 0:488aa8153e15 162
JongYongPark 14:07669aafe0e4 163 inline int is_a_word_4ch(int channel, long * manchester_word,
JongYongPark 26:26474003e443 164 int time_from_last_sync, unsigned int * detected_word)
JongYongPark 26:26474003e443 165 {
JongYongPark 0:488aa8153e15 166 #if RX_DEBUG_BIN
JongYongPark 26:26474003e443 167 printf("\t %d[%4x] ",channel+1, *detected_word );
JongYongPark 0:488aa8153e15 168 #endif
JongYongPark 26:26474003e443 169 if (time_from_last_sync >= 20
JongYongPark 26:26474003e443 170 || rx_vars[channel].frame_state == IDLE_STATE) { // we received enough bits to test the sync
JongYongPark 26:26474003e443 171 if (((*manchester_word) & START_STOP_MASK) == (START_STOP_MASK)) { // testing first position
JongYongPark 26:26474003e443 172 (*detected_word) = ((*manchester_word) >> 2) & 0xFFFF;
JongYongPark 0:488aa8153e15 173
JongYongPark 26:26474003e443 174 if (rx_vars[channel].frame_state == IDLE_STATE) {
JongYongPark 26:26474003e443 175 if ((*detected_word) == SYNC_SYMBOL_MANCHESTER) {
JongYongPark 26:26474003e443 176 return 2;
JongYongPark 26:26474003e443 177 }
JongYongPark 26:26474003e443 178 }
JongYongPark 26:26474003e443 179 return 1;
JongYongPark 26:26474003e443 180 // byte with correct framing
JongYongPark 26:26474003e443 181 } else if (rx_vars[channel].frame_state != IDLE_STATE
JongYongPark 26:26474003e443 182 && time_from_last_sync == 20) {
JongYongPark 26:26474003e443 183 (*detected_word) = ((*manchester_word) >> 2) & 0xFFFF;
JongYongPark 26:26474003e443 184 return 1;
JongYongPark 26:26474003e443 185 }
JongYongPark 26:26474003e443 186 }
JongYongPark 26:26474003e443 187 return 0;
JongYongPark 0:488aa8153e15 188 }
JongYongPark 0:488aa8153e15 189
JongYongPark 14:07669aafe0e4 190 inline int insert_edge_4ch(int channel, long * manchester_word, int edge,
JongYongPark 26:26474003e443 191 int edge_period, int * time_from_last_sync,
JongYongPark 26:26474003e443 192 unsigned int * detected_word)
JongYongPark 26:26474003e443 193 {
JongYongPark 26:26474003e443 194 int new_word = 0;
JongYongPark 26:26474003e443 195 int is_a_word_value = 0;
JongYongPark 26:26474003e443 196 int sync_word_detect = 0;
JongYongPark 26:26474003e443 197 if (((*manchester_word) & 0x01) != edge) { //mak sure we don't have same edge ...
JongYongPark 26:26474003e443 198 if (edge_period > (LIFI_RX_SAMPLE_PER_SYMBOL + 1)) {
JongYongPark 26:26474003e443 199 unsigned char last_bit = (*manchester_word) & 0x01;
JongYongPark 26:26474003e443 200 (*manchester_word) = ((*manchester_word) << 1) | last_bit; // signal was steady for longer than a single symbol,
JongYongPark 26:26474003e443 201 (*time_from_last_sync) += 1;
JongYongPark 26:26474003e443 202 is_a_word_value = is_a_word_4ch(channel, manchester_word,
JongYongPark 26:26474003e443 203 (*time_from_last_sync), detected_word);
JongYongPark 26:26474003e443 204 if (is_a_word_value > 0) { //found start stop framing
JongYongPark 26:26474003e443 205 new_word = 1;
JongYongPark 26:26474003e443 206 (*time_from_last_sync) = 0;
JongYongPark 26:26474003e443 207 if (is_a_word_value > 1) {
JongYongPark 26:26474003e443 208 sync_word_detect = 1; //we detected framing and sync word in manchester format
JongYongPark 0:488aa8153e15 209 #if RX_DEBUG_BIN
JongYongPark 26:26474003e443 210 printf("\n%dS",channel+1);
JongYongPark 0:488aa8153e15 211 #endif
JongYongPark 26:26474003e443 212 }
JongYongPark 26:26474003e443 213 }
JongYongPark 26:26474003e443 214 }
JongYongPark 26:26474003e443 215 /////////////////////////////
JongYongPark 26:26474003e443 216 //storing edge value in word
JongYongPark 26:26474003e443 217 if (edge < 0) {
JongYongPark 26:26474003e443 218 (*manchester_word) = ((*manchester_word) << 1) | 0x00; // signal goes down
JongYongPark 0:488aa8153e15 219 #if RX_DEBUG_BIN
JongYongPark 26:26474003e443 220 printf("%d[0]",channel+1);
JongYongPark 0:488aa8153e15 221 #endif
JongYongPark 26:26474003e443 222 } else {
JongYongPark 26:26474003e443 223 (*manchester_word) = ((*manchester_word) << 1) | 0x01; // signal goes up
JongYongPark 0:488aa8153e15 224 #if RX_DEBUG_BIN
JongYongPark 26:26474003e443 225 printf("%d[1]",channel+1);
JongYongPark 0:488aa8153e15 226 #endif
JongYongPark 26:26474003e443 227 }
JongYongPark 26:26474003e443 228 /////////////////////////////////////
JongYongPark 26:26474003e443 229 (*time_from_last_sync) += 1;
JongYongPark 26:26474003e443 230 is_a_word_value = is_a_word_4ch(channel, manchester_word,
JongYongPark 26:26474003e443 231 (*time_from_last_sync), detected_word);
JongYongPark 26:26474003e443 232 if (sync_word_detect == 0 && is_a_word_value > 0) { //if sync word was detected at previous position, don't take word detection into account
JongYongPark 26:26474003e443 233 new_word = 1;
JongYongPark 26:26474003e443 234 (*time_from_last_sync) = 0;
JongYongPark 0:488aa8153e15 235 #if RX_DEBUG_BIN
JongYongPark 26:26474003e443 236 printf("%dD",channel+1);
JongYongPark 0:488aa8153e15 237 #endif
JongYongPark 26:26474003e443 238 }
JongYongPark 26:26474003e443 239 } else {
JongYongPark 26:26474003e443 240 new_word = -1;
JongYongPark 0:488aa8153e15 241 #if RX_DEBUG_BIN
JongYongPark 26:26474003e443 242 printf("%d_",channel+1);
JongYongPark 0:488aa8153e15 243 #endif
JongYongPark 26:26474003e443 244 }
JongYongPark 26:26474003e443 245 return new_word;
JongYongPark 0:488aa8153e15 246 }
JongYongPark 0:488aa8153e15 247
JongYongPark 26:26474003e443 248 void sample_signal_edge_4ch(int channel, int sensorValue)
JongYongPark 26:26474003e443 249 {
JongYongPark 26:26474003e443 250 rx_vars[channel].sensorValue = sensorValue;
JongYongPark 26:26474003e443 251 //int sensorValue = analogRead(SENSOR_PIN_PORT); // this is too slow and should be replaced with interrupt-driven ADC
JongYongPark 26:26474003e443 252 //t sensorValue = LifiRx_AdcRead(0); // read result of previously triggered conversion
JongYongPark 26:26474003e443 253 //ADC_start_conversion(SENSOR_PIN); // start a conversion for next loop
JongYongPark 0:488aa8153e15 254
JongYongPark 0:488aa8153e15 255 #if RX_DEBUG_ANALOG_SENSOR_VALUE
JongYongPark 26:26474003e443 256 printf(" adc:%d ",rx_vars[channel].sensorValue);
JongYongPark 0:488aa8153e15 257 #endif
JongYongPark 26:26474003e443 258 if ((rx_vars[channel].sensorValue - rx_vars[channel].oldValue)
JongYongPark 26:26474003e443 259 > LIFI_RX_EDGE_THRESHOLD) {
JongYongPark 26:26474003e443 260 rx_vars[channel].edge_val = 1;
JongYongPark 26:26474003e443 261
JongYongPark 26:26474003e443 262 #if CHECK_EDGE_WITH_DEBUG_LED
JongYongPark 26:26474003e443 263 if( int LifiRx_GetDebugLed() == 0 ) printf("\n Edge Detect Fail (Up / 0) !!!");
JongYongPark 0:488aa8153e15 264 #endif
JongYongPark 0:488aa8153e15 265
JongYongPark 0:488aa8153e15 266 #if RX_DEBUG_EDGE
JongYongPark 26:26474003e443 267 printf("%d/ %d-%d",channel+1,rx_vars[channel].sensorValue,rx_vars[channel].oldValue);
JongYongPark 0:488aa8153e15 268 #endif
JongYongPark 26:26474003e443 269 if (rx_vars[channel].probe_adc_high < rx_vars[channel].sensorValue)
JongYongPark 26:26474003e443 270 rx_vars[channel].probe_adc_high = rx_vars[channel].sensorValue;
JongYongPark 26:26474003e443 271 } else if ((rx_vars[channel].oldValue - rx_vars[channel].sensorValue)
JongYongPark 26:26474003e443 272 > LIFI_RX_EDGE_THRESHOLD) {
JongYongPark 26:26474003e443 273 rx_vars[channel].edge_val = -1;
JongYongPark 26:26474003e443 274
JongYongPark 26:26474003e443 275 #if CHECK_EDGE_WITH_DEBUG_LED
JongYongPark 26:26474003e443 276 if( int LifiRx_GetDebugLed() == 1 ) printf("\n Edge Detect Fail (Down / 1) !!!");
JongYongPark 26:26474003e443 277 #endif
JongYongPark 0:488aa8153e15 278
JongYongPark 0:488aa8153e15 279 #if RX_DEBUG_EDGE
JongYongPark 26:26474003e443 280 printf("%d| %d-%d",channel+1,rx_vars[channel].oldValue,rx_vars[channel].sensorValue);
JongYongPark 26:26474003e443 281 #endif
JongYongPark 26:26474003e443 282 if (rx_vars[channel].probe_adc_low > rx_vars[channel].sensorValue)
JongYongPark 26:26474003e443 283 rx_vars[channel].probe_adc_low = rx_vars[channel].sensorValue;
JongYongPark 26:26474003e443 284 } else {
JongYongPark 26:26474003e443 285 #if RX_DEBUG_EDGE
JongYongPark 26:26474003e443 286 printf("%d=",channel+1);
JongYongPark 0:488aa8153e15 287 #endif
JongYongPark 26:26474003e443 288 rx_vars[channel].edge_val = 0;
JongYongPark 26:26474003e443 289 }
JongYongPark 26:26474003e443 290
JongYongPark 26:26474003e443 291 /////////////
JongYongPark 26:26474003e443 292 rx_vars[channel].oldValue = rx_vars[channel].sensorValue;
JongYongPark 26:26474003e443 293 if (rx_vars[channel].edge_val == 0
JongYongPark 26:26474003e443 294 || rx_vars[channel].edge_val == rx_vars[channel].old_edge_val
JongYongPark 26:26474003e443 295 || (rx_vars[channel].edge_val != rx_vars[channel].old_edge_val
JongYongPark 26:26474003e443 296 && rx_vars[channel].steady_count < 2)) {
JongYongPark 26:26474003e443 297 if (rx_vars[channel].steady_count < (4 * LIFI_RX_SAMPLE_PER_SYMBOL)) {
JongYongPark 26:26474003e443 298 #if RX_DEBUG_EDGE
JongYongPark 26:26474003e443 299 printf("%d+",channel+1);
JongYongPark 26:26474003e443 300 #endif
JongYongPark 26:26474003e443 301 rx_vars[channel].steady_count++;
JongYongPark 26:26474003e443 302 }
JongYongPark 26:26474003e443 303 } else {
JongYongPark 26:26474003e443 304
JongYongPark 26:26474003e443 305 #if RX_DEBUG_EDGE
JongYongPark 26:26474003e443 306 if(rx_vars[channel].edge_val == 1) printf("%dH",channel+1);
JongYongPark 26:26474003e443 307 else if(rx_vars[channel].edge_val == -1) printf("%dL",channel+1);
JongYongPark 26:26474003e443 308 #endif
JongYongPark 26:26474003e443 309 //inline int insert_edge_4ch(int channel, long * manchester_word, int edge, int edge_period, int * time_from_last_sync, unsigned int * detected_word)
JongYongPark 26:26474003e443 310 rx_vars[channel].new_word = insert_edge_4ch(channel,
JongYongPark 26:26474003e443 311 &rx_vars[channel].shift_reg, rx_vars[channel].edge_val,
JongYongPark 26:26474003e443 312 rx_vars[channel].steady_count,
JongYongPark 26:26474003e443 313 &(rx_vars[channel].dist_last_sync),
JongYongPark 26:26474003e443 314 &rx_vars[channel].detected_word);
JongYongPark 26:26474003e443 315 if (rx_vars[channel].dist_last_sync > (8 * LIFI_RX_SAMPLE_PER_SYMBOL)) { // limit dist_last_sync to avoid overflow problems
JongYongPark 26:26474003e443 316 rx_vars[channel].dist_last_sync = 32;
JongYongPark 0:488aa8153e15 317 #if RX_DEBUG_FRAME
JongYongPark 0:488aa8153e15 318 // println("\t %dRESET avoid overlow ",channel+1);
JongYongPark 0:488aa8153e15 319 #endif
JongYongPark 26:26474003e443 320 }
JongYongPark 14:07669aafe0e4 321
JongYongPark 0:488aa8153e15 322 // if(new_word >= 0) {
JongYongPark 0:488aa8153e15 323 #if RX_DEBUG_FRAME
JongYongPark 0:488aa8153e15 324 // println("\t %dRESET COUNTER ",channel+1);
JongYongPark 0:488aa8153e15 325 #endif
JongYongPark 26:26474003e443 326 rx_vars[channel].steady_count = 0;
JongYongPark 0:488aa8153e15 327 // }
JongYongPark 26:26474003e443 328 }
JongYongPark 26:26474003e443 329 rx_vars[channel].old_edge_val = rx_vars[channel].edge_val;
JongYongPark 14:07669aafe0e4 330
JongYongPark 26:26474003e443 331 #if (USE_MBED_OS5 && USE_LIFI_RX_CHECK_QUEUE)
JongYongPark 26:26474003e443 332 if((rx_vars[channel].new_word == 1) && (channel == LIFI_ACTUAL_MAX_CHANNEL_NUM_INDEX)) {
JongYongPark 26:26474003e443 333 //printf("!");
JongYongPark 26:26474003e443 334 // https://os.mbed.com/forum/bugs-suggestions/topic/28244/?page=1#comment-53612
JongYongPark 26:26474003e443 335 lifi_tx_check_queue.call(LifiRx_LoopOOK);
JongYongPark 26:26474003e443 336 }
JongYongPark 26:26474003e443 337 #endif
JongYongPark 0:488aa8153e15 338 }
JongYongPark 0:488aa8153e15 339
JongYongPark 18:2f7b820324c3 340 int add_byte_to_frame_v1(int channel,uint8_t * rx_frame_buffer, int * rx_frame_index, int * rx_frame_size, enum receiver_state * frame_state,unsigned char data)
JongYongPark 16:c551ee1092f5 341 {
JongYongPark 16:c551ee1092f5 342 if(data == SYNC_SYMBOL/* && (*rx_frame_index) < 0*/) {
JongYongPark 16:c551ee1092f5 343 (*rx_frame_index) = 0 ;
JongYongPark 16:c551ee1092f5 344 (*rx_frame_size) = 0 ;
JongYongPark 16:c551ee1092f5 345 (*frame_state) = SYNC_STATE ;
JongYongPark 16:c551ee1092f5 346 #if RX_DEBUG_FRAME
JongYongPark 16:c551ee1092f5 347 printf("\n%dSYNC ",channel+1);
JongYongPark 16:c551ee1092f5 348 #endif
JongYongPark 16:c551ee1092f5 349 return 0 ;
JongYongPark 16:c551ee1092f5 350 }
JongYongPark 16:c551ee1092f5 351 if((*frame_state) != IDLE_STATE) { // we are synced
JongYongPark 16:c551ee1092f5 352 rx_frame_buffer[*rx_frame_index] = data ;
JongYongPark 16:c551ee1092f5 353 (*rx_frame_index) ++ ;
JongYongPark 16:c551ee1092f5 354 if(data == STX) {
JongYongPark 16:c551ee1092f5 355 #if RX_DEBUG_FRAME
JongYongPark 16:c551ee1092f5 356 printf("%dSTART ",channel+1);
JongYongPark 16:c551ee1092f5 357 #endif
JongYongPark 16:c551ee1092f5 358 (*frame_state) = START_STATE ;
JongYongPark 16:c551ee1092f5 359 return 0 ;
JongYongPark 16:c551ee1092f5 360 } else if(data == ETX) {
JongYongPark 16:c551ee1092f5 361 #if RX_DEBUG_FRAME
JongYongPark 16:c551ee1092f5 362 printf("%dEND IDLE ",channel+1);
JongYongPark 16:c551ee1092f5 363 #endif
JongYongPark 16:c551ee1092f5 364 (*rx_frame_size) = (*rx_frame_index) ;
JongYongPark 16:c551ee1092f5 365 (*rx_frame_index) = -1 ;
JongYongPark 16:c551ee1092f5 366 (*frame_state) = IDLE_STATE ;
JongYongPark 16:c551ee1092f5 367
JongYongPark 16:c551ee1092f5 368 return 1 ;
JongYongPark 16:c551ee1092f5 369 } else if((*rx_frame_index) >= FRAME_BUFFER_SIZE) { //frame is larger than max size of frame ...
JongYongPark 16:c551ee1092f5 370 #if RX_DEBUG_FRAME
JongYongPark 16:c551ee1092f5 371 printf("%dIDLE - over FRAME_BUFFER_SIZE ",channel+1);
JongYongPark 16:c551ee1092f5 372 #endif
JongYongPark 16:c551ee1092f5 373 (*rx_frame_index) = -1 ;
JongYongPark 16:c551ee1092f5 374 (*rx_frame_size) = -1 ;
JongYongPark 16:c551ee1092f5 375 (*frame_state) = IDLE_STATE ;
JongYongPark 16:c551ee1092f5 376 return -1 ;
JongYongPark 16:c551ee1092f5 377 } else {
JongYongPark 16:c551ee1092f5 378 #if RX_DEBUG_FRAME
JongYongPark 16:c551ee1092f5 379 printf("%dD=%c[%x] ",channel+1,data,data);
JongYongPark 16:c551ee1092f5 380 #endif
JongYongPark 16:c551ee1092f5 381 (*frame_state) = DATA_STATE ;
JongYongPark 16:c551ee1092f5 382 }
JongYongPark 16:c551ee1092f5 383 return 0 ;
JongYongPark 16:c551ee1092f5 384 }
JongYongPark 16:c551ee1092f5 385 return -1 ;
JongYongPark 16:c551ee1092f5 386 }
JongYongPark 16:c551ee1092f5 387
JongYongPark 18:2f7b820324c3 388 int add_byte_to_frame(int channel, uint8_t * rx_frame_buffer,
JongYongPark 26:26474003e443 389 int * rx_frame_index, int * rx_frame_size,
JongYongPark 26:26474003e443 390 enum receiver_state * frame_state, unsigned char data)
JongYongPark 26:26474003e443 391 {
JongYongPark 26:26474003e443 392 if (data == SYNC_SYMBOL/* && (*rx_frame_index) < 0*/) {
JongYongPark 26:26474003e443 393 (*rx_frame_index) = 0;
JongYongPark 26:26474003e443 394 (*rx_frame_size) = 0;
JongYongPark 26:26474003e443 395 (*frame_state) = SYNC_STATE;
JongYongPark 0:488aa8153e15 396 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 397 printf("\n%dSYNC ",channel+1);
JongYongPark 0:488aa8153e15 398 #endif
JongYongPark 26:26474003e443 399 return 0;
JongYongPark 26:26474003e443 400 }
JongYongPark 26:26474003e443 401 if ((*frame_state) != IDLE_STATE) { // we are synced
JongYongPark 26:26474003e443 402 rx_frame_buffer[*rx_frame_index] = data;
JongYongPark 26:26474003e443 403 (*rx_frame_index)++;
JongYongPark 11:8ffa8a36126f 404
JongYongPark 26:26474003e443 405 if ((*frame_state) == SYNC_STATE) {
JongYongPark 26:26474003e443 406 if (data == STX) {
JongYongPark 0:488aa8153e15 407 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 408 printf("%dSTART ",channel+1);
JongYongPark 0:488aa8153e15 409 #endif
JongYongPark 26:26474003e443 410 (*frame_state) = START_STATE;
JongYongPark 26:26474003e443 411 return 0;
JongYongPark 26:26474003e443 412 } else if (data == SYNC_SYMBOL) {
JongYongPark 26:26474003e443 413 // do nothing
JongYongPark 26:26474003e443 414 } else {
JongYongPark 26:26474003e443 415 printf("\n Error # got wrong data after SYNC. it should be STX");
JongYongPark 26:26474003e443 416 (*frame_state) = IDLE_STATE;
JongYongPark 26:26474003e443 417 return -1;
JongYongPark 26:26474003e443 418 }
JongYongPark 11:8ffa8a36126f 419
JongYongPark 26:26474003e443 420 } else if ((*frame_state) == START_STATE) {
JongYongPark 26:26474003e443 421 (*frame_state) = LENGTH_LSB_STATE;
JongYongPark 26:26474003e443 422 rx_vars[channel].pdu_length = data;
JongYongPark 16:c551ee1092f5 423 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 424 printf("%dLENGTH_LSB(%d) ",channel+1,data);
JongYongPark 16:c551ee1092f5 425 #endif
JongYongPark 26:26474003e443 426 } else if ((*frame_state) == LENGTH_LSB_STATE) {
JongYongPark 11:8ffa8a36126f 427
JongYongPark 26:26474003e443 428 (*frame_state) = LENGTH_MSB_STATE;
JongYongPark 26:26474003e443 429 rx_vars[channel].pdu_length = rx_vars[channel].pdu_length + (data << 8);
JongYongPark 26:26474003e443 430 rx_vars[channel].pdu_length_count = 0;
JongYongPark 26:26474003e443 431 rx_vars[channel].frame_length = rx_vars[channel].pdu_length + LIFI_FRAME_HEADER_SIZE;
JongYongPark 16:c551ee1092f5 432 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 433 printf("%dLENGTH_MSB(%d) length=%d ",channel+1,data, rx_vars[channel].pdu_length);
JongYongPark 16:c551ee1092f5 434 #endif
JongYongPark 16:c551ee1092f5 435
JongYongPark 26:26474003e443 436 } else if ((*frame_state) == LENGTH_MSB_STATE) {
JongYongPark 11:8ffa8a36126f 437
JongYongPark 11:8ffa8a36126f 438 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 439 printf("%dD=%c[%x] ",channel+1,data,data);
JongYongPark 11:8ffa8a36126f 440 #endif
JongYongPark 26:26474003e443 441 (*frame_state) = DATA_STATE;
JongYongPark 26:26474003e443 442 rx_vars[channel].pdu_length_count++;
JongYongPark 11:8ffa8a36126f 443
JongYongPark 26:26474003e443 444 } else if ((*frame_state) == DATA_STATE) {
JongYongPark 26:26474003e443 445 rx_vars[channel].pdu_length_count++;
JongYongPark 26:26474003e443 446 // when ETX
JongYongPark 26:26474003e443 447 if (rx_vars[channel].pdu_length_count
JongYongPark 26:26474003e443 448 > rx_vars[channel].pdu_length) {
JongYongPark 26:26474003e443 449
JongYongPark 26:26474003e443 450 rx_vars[channel].pdu_length_count--; // ETX is not included on data length
JongYongPark 26:26474003e443 451 //// rx_vars[channel].pdu_length_count_save = rx_vars[channel].pdu_length_count;
JongYongPark 26:26474003e443 452 // rx_vars[channel].pdu_length_save = rx_vars[channel].pdu_length;
JongYongPark 26:26474003e443 453 //// rx_vars[channel].frame_length_save = rx_vars[channel].frame_length;
JongYongPark 18:2f7b820324c3 454
JongYongPark 26:26474003e443 455 if (data == ETX) {
JongYongPark 17:847e9b792c72 456 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 457 printf("%dEND IDLE ",channel+1);
JongYongPark 17:847e9b792c72 458 #endif
JongYongPark 26:26474003e443 459 (*rx_frame_size) = (*rx_frame_index);
JongYongPark 26:26474003e443 460 (*rx_frame_index) = -1;
JongYongPark 26:26474003e443 461 (*frame_state) = IDLE_STATE;
JongYongPark 26:26474003e443 462 return 1;
JongYongPark 26:26474003e443 463 } else {
JongYongPark 26:26474003e443 464 printf("\n CH(%d) Error : got wrong data (0x%2x). it should be ETX (0x03)",channel,data);
JongYongPark 26:26474003e443 465 print_frame_data(rx_vars[channel].rx_frame_buffer, rx_vars[channel].frame_length);
JongYongPark 26:26474003e443 466 (*frame_state) = IDLE_STATE;
JongYongPark 26:26474003e443 467 return -1;
JongYongPark 26:26474003e443 468 }
JongYongPark 26:26474003e443 469 }
JongYongPark 26:26474003e443 470 // normal DATA
JongYongPark 26:26474003e443 471 else {
JongYongPark 0:488aa8153e15 472 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 473 printf("%dD=%c[%x] ",channel+1,data,data);
JongYongPark 26:26474003e443 474 #endif
JongYongPark 26:26474003e443 475 }
JongYongPark 26:26474003e443 476 } else if ((*rx_frame_index) >= FRAME_BUFFER_SIZE) { //frame is larger than max size of frame ...
JongYongPark 26:26474003e443 477 #if RX_DEBUG_FRAME
JongYongPark 26:26474003e443 478 printf("%dIDLE - over FRAME_BUFFER_SIZE ",channel+1);
JongYongPark 0:488aa8153e15 479 #endif
JongYongPark 26:26474003e443 480 (*rx_frame_index) = -1;
JongYongPark 26:26474003e443 481 (*rx_frame_size) = -1;
JongYongPark 26:26474003e443 482 (*frame_state) = IDLE_STATE;
JongYongPark 26:26474003e443 483 return -1;
JongYongPark 26:26474003e443 484 } else {
JongYongPark 26:26474003e443 485 printf("\n CH(%d) Error : unknown state (%d)", channel+1 , *frame_state);
JongYongPark 26:26474003e443 486 (*frame_state) = IDLE_STATE;
JongYongPark 26:26474003e443 487 return 1;
JongYongPark 26:26474003e443 488 }
JongYongPark 26:26474003e443 489 return 0; // normal
JongYongPark 26:26474003e443 490 }
JongYongPark 26:26474003e443 491 return -1; // error
JongYongPark 0:488aa8153e15 492 }
JongYongPark 0:488aa8153e15 493
JongYongPark 0:488aa8153e15 494 int counter = 0;
JongYongPark 0:488aa8153e15 495
JongYongPark 26:26474003e443 496 void setup_ADC()
JongYongPark 26:26474003e443 497 {
JongYongPark 0:488aa8153e15 498 //
JongYongPark 0:488aa8153e15 499 // if( (m_op_mode != OP_HW_TEST) && (m_op_mode != OP_PLOT_ADC))
JongYongPark 0:488aa8153e15 500 // {
JongYongPark 0:488aa8153e15 501 // //analogReference(INTERNAL); // internal reference is 1.1v, should give better accuracy for the mv range of the led output.
JongYongPark 0:488aa8153e15 502 // Timer1.initialize(LIFI_RX_SYMBOL_PERIOD_US/LIFI_RX_SAMPLE_PER_SYMBOL); //1200 bauds oversampled by factor 4
JongYongPark 0:488aa8153e15 503 // Timer1.attachInterrupt(sample_signal_edge);
JongYongPark 0:488aa8153e15 504 // }
JongYongPark 0:488aa8153e15 505 }
JongYongPark 0:488aa8153e15 506
JongYongPark 0:488aa8153e15 507 // the setup routine runs once when you press reset:
JongYongPark 0:488aa8153e15 508
JongYongPark 0:488aa8153e15 509 //bool isValidNumber(string str)
JongYongPark 0:488aa8153e15 510 //{
JongYongPark 0:488aa8153e15 511 // bool isNum=true;
JongYongPark 0:488aa8153e15 512 // for(byte i=0; i<str.length(); i++) {
JongYongPark 0:488aa8153e15 513 // //isNum = isDigit(str.charAt(i)) || str.charAt(i) == '+' || str.charAt(i) == '.' || str.charAt(i) == '-';
JongYongPark 0:488aa8153e15 514 //// isNum = isDigit(str.charAt(i)); // || str.charAt(i) == '+' || str.charAt(i) == '.' || str.charAt(i) == '-';
JongYongPark 0:488aa8153e15 515 // if(!isNum) return false;
JongYongPark 0:488aa8153e15 516 // }
JongYongPark 0:488aa8153e15 517 // return isNum;
JongYongPark 0:488aa8153e15 518 //}
JongYongPark 0:488aa8153e15 519
JongYongPark 26:26474003e443 520 bool rx_loop_ook_4ch(int channel)
JongYongPark 26:26474003e443 521 {
JongYongPark 26:26474003e443 522 int i;
JongYongPark 26:26474003e443 523 bool got_all_frame = false;
JongYongPark 26:26474003e443 524 unsigned char received_data;
JongYongPark 26:26474003e443 525 //unsigned char received_data_print ;
JongYongPark 26:26474003e443 526 //int nb_shift ;
JongYongPark 26:26474003e443 527 int byte_added = 0;
JongYongPark 26:26474003e443 528 bool valid_chars;
JongYongPark 26:26474003e443 529 if (rx_vars[channel].new_word == 1) {
JongYongPark 26:26474003e443 530 received_data = 0;
JongYongPark 26:26474003e443 531 for (i = 0; i < 16; i = i + 2) { //decoding Manchester
JongYongPark 26:26474003e443 532 received_data = received_data << 1;
JongYongPark 26:26474003e443 533 if (((rx_vars[channel].detected_word >> i) & 0x03) == 0x01) {
JongYongPark 26:26474003e443 534 received_data |= 0x01;
JongYongPark 26:26474003e443 535 } else {
JongYongPark 26:26474003e443 536 received_data &= ~0x01;
JongYongPark 26:26474003e443 537 }
JongYongPark 26:26474003e443 538 }
JongYongPark 26:26474003e443 539 received_data = received_data & 0xFF;
JongYongPark 0:488aa8153e15 540 #if RX_DEBUG_MAIN_LOOP
JongYongPark 26:26474003e443 541 // printf("%dRx:%c[%x]",channel+1,(unsigned char) received_data,received_data & 0xFF);
JongYongPark 0:488aa8153e15 542 #endif
JongYongPark 26:26474003e443 543 rx_vars[channel].new_word = 0;
JongYongPark 26:26474003e443 544
JongYongPark 26:26474003e443 545 // return 1 from add_byte_to_frame() means got ETX
JongYongPark 16:c551ee1092f5 546 #if LIFI_PACKET_USE_LENGTH
JongYongPark 26:26474003e443 547 if ((byte_added = add_byte_to_frame(channel,
JongYongPark 26:26474003e443 548 rx_vars[channel].rx_frame_buffer,
JongYongPark 26:26474003e443 549 &rx_vars[channel].rx_frame_index,
JongYongPark 26:26474003e443 550 &rx_vars[channel].rx_frame_size, &rx_vars[channel].frame_state,
JongYongPark 26:26474003e443 551 received_data)) > 0)
JongYongPark 16:c551ee1092f5 552 #else
JongYongPark 26:26474003e443 553 if ((byte_added = add_byte_to_frame_v1(channel,
JongYongPark 26:26474003e443 554 rx_vars[channel].rx_frame_buffer,
JongYongPark 26:26474003e443 555 &rx_vars[channel].rx_frame_index,
JongYongPark 26:26474003e443 556 &rx_vars[channel].rx_frame_size, &rx_vars[channel].frame_state,
JongYongPark 26:26474003e443 557 received_data)) > 0)
JongYongPark 16:c551ee1092f5 558 #endif
JongYongPark 26:26474003e443 559 {
JongYongPark 26:26474003e443 560 valid_chars = true;
JongYongPark 26:26474003e443 561 // 여기서 ETX를 0으로 변경해 버린다.
JongYongPark 26:26474003e443 562 //rx_vars[channel].rx_frame_buffer[rx_vars[channel].rx_frame_size - 1] = '\0';
JongYongPark 0:488aa8153e15 563 #if RX_DEBUG_MAIN_LOOP
JongYongPark 26:26474003e443 564 //printf("%dAdc[Max=%d Min=%d]",channel+1,rx_vars[channel].probe_adc_high,rx_vars[channel].probe_adc_low);
JongYongPark 0:488aa8153e15 565 #endif
JongYongPark 26:26474003e443 566
JongYongPark 26:26474003e443 567 LifiRx_CopyAdcInfo_FromReceivedFrame( channel, rx_vars[channel].probe_adc_high , rx_vars[channel].probe_adc_low);
JongYongPark 0:488aa8153e15 568
JongYongPark 26:26474003e443 569 rx_vars[channel].probe_adc_high = 0;
JongYongPark 26:26474003e443 570 rx_vars[channel].probe_adc_low = 1024;
JongYongPark 18:2f7b820324c3 571 #if 1
JongYongPark 18:2f7b820324c3 572 // for (int i = 1; i < (rx_vars[channel].rx_frame_size - 1); i++) {
JongYongPark 18:2f7b820324c3 573 // if ((rx_vars[channel].rx_frame_buffer[i] < ' ')
JongYongPark 18:2f7b820324c3 574 // || (rx_vars[channel].rx_frame_buffer[i] > '~')) {
JongYongPark 18:2f7b820324c3 575 // valid_chars = false0;
JongYongPark 18:2f7b820324c3 576 // break;
JongYongPark 18:2f7b820324c3 577 // } else {
JongYongPark 18:2f7b820324c3 578 // }
JongYongPark 18:2f7b820324c3 579 // }
JongYongPark 26:26474003e443 580 valid_chars = true;
JongYongPark 26:26474003e443 581 #else
JongYongPark 26:26474003e443 582 // only valid when char is charactor
JongYongPark 26:26474003e443 583 for (int i = 1; i < (rx_vars[channel].rx_frame_size - 1); i++) {
JongYongPark 26:26474003e443 584 if ((rx_vars[channel].rx_frame_buffer[i] < ' ')
JongYongPark 26:26474003e443 585 || (rx_vars[channel].rx_frame_buffer[i] > '~')) {
JongYongPark 26:26474003e443 586 valid_chars = false;
JongYongPark 26:26474003e443 587 break;
JongYongPark 26:26474003e443 588 } else {
JongYongPark 26:26474003e443 589 }
JongYongPark 26:26474003e443 590 }
JongYongPark 18:2f7b820324c3 591 #endif
JongYongPark 26:26474003e443 592 // printf("\n=============");
JongYongPark 26:26474003e443 593 // print_frame_data(rx_vars[channel].rx_frame_buffer,rx_vars[channel].frame_length_save);
JongYongPark 14:07669aafe0e4 594
JongYongPark 26:26474003e443 595 // memcpy(rx_vars[channel].rx_frame_buffer_save, rx_vars[channel].rx_frame_buffer, FRAME_BUFFER_SIZE);
JongYongPark 26:26474003e443 596 rx_vars[channel].is_received = true;
JongYongPark 26:26474003e443 597 printf(" *** Channel[%d] Rx Finished !!! *** ", channel +1 );
JongYongPark 26:26474003e443 598 if (valid_chars) {
JongYongPark 0:488aa8153e15 599 // //println(&(rx_frame_buffer[1]));
JongYongPark 0:488aa8153e15 600 // //stringReceive = string(&(rx_frame_buffer[1]));
JongYongPark 0:488aa8153e15 601 // //stringReceive = stringReceive.toUpperCase();
JongYongPark 0:488aa8153e15 602 // //println(stringReceive);
JongYongPark 0:488aa8153e15 603 // printf("\nMSG(ch_%d)[%s]",channel, rx_vars[channel].rx_frame_buffer);
JongYongPark 26:26474003e443 604 rx_vars[channel].is_valid = true;
JongYongPark 26:26474003e443 605 } else {
JongYongPark 0:488aa8153e15 606 // printf("\nMSG_Invalid(ch_%d)[%s]",channel, rx_vars[channel].rx_frame_buffer);
JongYongPark 26:26474003e443 607 rx_vars[channel].is_valid = false;
JongYongPark 26:26474003e443 608 }
JongYongPark 26:26474003e443 609 // http://www.java2s.com/Tutorial/Cpp/0160__Structure/Usememcpytoduplicatestructures.htm
JongYongPark 26:26474003e443 610 //memcpy((void*) &rx_vars_received[channel], (void*) &rx_vars[channel], sizeof( struct RX_VARS));
JongYongPark 26:26474003e443 611 //memcpy( &rx_vars_received[channel], &rx_vars[channel], sizeof( struct RX_VARS));
JongYongPark 26:26474003e443 612 //memcpy((void*) & (rx_vars_received[channel]), (void*) &(rx_vars[channel]), sizeof(rx_vars[channel]));
JongYongPark 26:26474003e443 613
JongYongPark 26:26474003e443 614 LifiRx_CopyData_FromReceivedFrame(channel);
JongYongPark 26:26474003e443 615 got_all_frame = true;
JongYongPark 26:26474003e443 616 }
JongYongPark 26:26474003e443 617 //if(frame_state != IDLE_STATE) println(received_data, HEX);
JongYongPark 26:26474003e443 618 }
JongYongPark 26:26474003e443 619 return got_all_frame;
JongYongPark 0:488aa8153e15 620 }
JongYongPark 26:26474003e443 621
JongYongPark 26:26474003e443 622
JongYongPark 18:2f7b820324c3 623
JongYongPark 18:2f7b820324c3 624 void print_channel_data(int channel)
JongYongPark 18:2f7b820324c3 625 {
JongYongPark 26:26474003e443 626 #if RX_DEBUG_MAIN_LOOP
JongYongPark 26:26474003e443 627 printf("\nMSG(%d) valid=%d, [len:%d/%d/%d] Adc[Max=%d Min=%d Gap=%d]",
JongYongPark 26:26474003e443 628 channel,
JongYongPark 26:26474003e443 629 rx_vars[channel].is_valid,
JongYongPark 26:26474003e443 630 rx_vars[channel].pdu_length_count, //rx_vars[channel].pdu_length_count_save,
JongYongPark 26:26474003e443 631 rx_vars[channel].pdu_length, //rx_vars[channel].pdu_length_save,
JongYongPark 26:26474003e443 632 rx_vars[channel].frame_length, //rx_vars[channel].frame_length_save,
JongYongPark 26:26474003e443 633 rx_vars[channel].probe_adc_high,
JongYongPark 26:26474003e443 634 rx_vars[channel].probe_adc_low,
JongYongPark 26:26474003e443 635 rx_vars[channel].probe_adc_gap);
JongYongPark 26:26474003e443 636 //// print_frame_data(rx_vars[channel].rx_frame_buffer_save,rx_vars[channel].pdu_length);
JongYongPark 26:26474003e443 637 // print_pdu_data(rx_vars[channel].rx_frame_buffer_save + LIFI_RX_FRAME_DATA_OFFSET,rx_vars[channel].pdu_length_save);
JongYongPark 26:26474003e443 638 // print_frame_data(rx_vars[channel].rx_frame_buffer_save,rx_vars[channel].frame_length_save);
JongYongPark 18:2f7b820324c3 639
JongYongPark 26:26474003e443 640 print_pdu_data(rx_vars[channel].rx_frame_buffer + LIFI_RX_FRAME_DATA_OFFSET,rx_vars[channel].pdu_length);
JongYongPark 26:26474003e443 641 print_frame_data(rx_vars[channel].rx_frame_buffer,rx_vars[channel].frame_length);
JongYongPark 26:26474003e443 642 #endif
JongYongPark 18:2f7b820324c3 643 }
JongYongPark 0:488aa8153e15 644
JongYongPark 26:26474003e443 645 void print_channel_received_data(int channel)
JongYongPark 26:26474003e443 646 {
JongYongPark 26:26474003e443 647 #if RX_DEBUG_MAIN_LOOP
JongYongPark 26:26474003e443 648 printf("\nMSG(%d) valid=%d, [len:%d/%d/%d] Adc[Max=%d Min=%d Gap=%d]",
JongYongPark 26:26474003e443 649 channel,
JongYongPark 26:26474003e443 650 rx_vars_received[channel].is_valid,
JongYongPark 26:26474003e443 651 rx_vars_received[channel].pdu_length_count,
JongYongPark 26:26474003e443 652 rx_vars_received[channel].pdu_length,
JongYongPark 26:26474003e443 653 rx_vars_received[channel].frame_length,
JongYongPark 26:26474003e443 654 rx_vars_received[channel].probe_adc_high,
JongYongPark 26:26474003e443 655 rx_vars_received[channel].probe_adc_low,
JongYongPark 26:26474003e443 656 rx_vars_received[channel].probe_adc_gap);
JongYongPark 26:26474003e443 657 // print_frame_data(rx_vars[channel].rx_frame_buffer_save,rx_vars[channel].pdu_length);
JongYongPark 26:26474003e443 658 print_pdu_data(rx_vars_received[channel].rx_frame_buffer + LIFI_RX_FRAME_DATA_OFFSET,rx_vars_received[channel].pdu_length);
JongYongPark 26:26474003e443 659 print_frame_data(rx_vars_received[channel].rx_frame_buffer,rx_vars_received[channel].frame_length);
JongYongPark 14:07669aafe0e4 660
JongYongPark 14:07669aafe0e4 661 #endif
JongYongPark 0:488aa8153e15 662 }
JongYongPark 0:488aa8153e15 663
JongYongPark 26:26474003e443 664 void print_4ch_message()
JongYongPark 26:26474003e443 665 {
JongYongPark 26:26474003e443 666 // int channel = LIFI_CHANNEL_1;
JongYongPark 26:26474003e443 667 // for (; channel <= LIFI_ACTUAL_MAX_CHANNEL_NUM_INDEX; channel++) {
JongYongPark 26:26474003e443 668 // if (rx_vars[channel].is_received == false)
JongYongPark 26:26474003e443 669 // return;
JongYongPark 26:26474003e443 670 // }
JongYongPark 26:26474003e443 671 #if RX_DEBUG_MAIN_LOOP
JongYongPark 26:26474003e443 672 printf("\n----------------");
JongYongPark 26:26474003e443 673 #endif
JongYongPark 26:26474003e443 674 print_channel_data(LIFI_CHANNEL_1);
JongYongPark 26:26474003e443 675
JongYongPark 26:26474003e443 676 rx_vars[LIFI_CHANNEL_1].is_received = false;
JongYongPark 26:26474003e443 677
JongYongPark 26:26474003e443 678 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_2)) {
JongYongPark 26:26474003e443 679 print_channel_data(LIFI_CHANNEL_2);
JongYongPark 26:26474003e443 680 rx_vars[LIFI_CHANNEL_2].is_received = false;
JongYongPark 26:26474003e443 681 }
JongYongPark 26:26474003e443 682 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_3)) {
JongYongPark 26:26474003e443 683 print_channel_data(LIFI_CHANNEL_3);
JongYongPark 26:26474003e443 684 rx_vars[LIFI_CHANNEL_3].is_received = false;
JongYongPark 26:26474003e443 685 }
JongYongPark 26:26474003e443 686 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_4)) {
JongYongPark 26:26474003e443 687 print_channel_data(LIFI_CHANNEL_4);
JongYongPark 26:26474003e443 688 rx_vars[LIFI_CHANNEL_4].is_received = false;
JongYongPark 26:26474003e443 689 }
JongYongPark 26:26474003e443 690 }
JongYongPark 26:26474003e443 691 int LifixRx_FinishedChannlCount()
JongYongPark 26:26474003e443 692 {
JongYongPark 26:26474003e443 693 int channel = LIFI_CHANNEL_1;
JongYongPark 26:26474003e443 694 int got_frame_count = 0;
JongYongPark 26:26474003e443 695 for (; channel <= LIFI_ACTUAL_MAX_CHANNEL_NUM_INDEX; channel++) {
JongYongPark 26:26474003e443 696 if (rx_vars[channel].is_received == true) got_frame_count++;
JongYongPark 26:26474003e443 697 }
JongYongPark 26:26474003e443 698 return got_frame_count;
JongYongPark 26:26474003e443 699 }
JongYongPark 26:26474003e443 700
JongYongPark 26:26474003e443 701 int LifixRx_PrintUnfinishedChannl()
JongYongPark 26:26474003e443 702 {
JongYongPark 26:26474003e443 703 int channel = LIFI_CHANNEL_1;
JongYongPark 26:26474003e443 704 int got_frame_count = 0;
JongYongPark 26:26474003e443 705 for (; channel <= LIFI_ACTUAL_MAX_CHANNEL_NUM_INDEX; channel++) {
JongYongPark 26:26474003e443 706 if (rx_vars[channel].is_received == true) ;//printf("CH[%d] Finished ooo", channel + 1);
JongYongPark 26:26474003e443 707 else printf("\n CH[%d]XXX", channel + 1);
JongYongPark 26:26474003e443 708 }
JongYongPark 26:26474003e443 709 return got_frame_count;
JongYongPark 26:26474003e443 710 }
JongYongPark 26:26474003e443 711
JongYongPark 26:26474003e443 712 bool LifixRx_FinishedFromAllChannel()
JongYongPark 26:26474003e443 713 {
JongYongPark 26:26474003e443 714 int channel = LIFI_CHANNEL_1;
JongYongPark 26:26474003e443 715 for (; channel <= LIFI_ACTUAL_MAX_CHANNEL_NUM_INDEX; channel++) {
JongYongPark 26:26474003e443 716 if (rx_vars[channel].is_received == false) {
JongYongPark 26:26474003e443 717 //waiting_count_for_all_channel_finished++;
JongYongPark 26:26474003e443 718 return false;
JongYongPark 26:26474003e443 719 }
JongYongPark 26:26474003e443 720 }
JongYongPark 26:26474003e443 721 //waiting_count_for_all_channel_finished = 0;
JongYongPark 26:26474003e443 722 return true;
JongYongPark 26:26474003e443 723 }
JongYongPark 0:488aa8153e15 724
JongYongPark 26:26474003e443 725 void LifiRx_LoopOOK()
JongYongPark 26:26474003e443 726 {
JongYongPark 26:26474003e443 727 static uint64_t loop_count = 0;
JongYongPark 26:26474003e443 728 int finished_channel = 0;
JongYongPark 26:26474003e443 729 //printf("!");
JongYongPark 26:26474003e443 730 // for 1 channel, it works well.
JongYongPark 26:26474003e443 731 // data corrupted when open 2 channels
JongYongPark 26:26474003e443 732 // LIFI_RX_SYMBOL_PERIOD_SEC (0.01) = works well for 2 channels *********
JongYongPark 26:26474003e443 733 rx_loop_ook_4ch(LIFI_CHANNEL_1);
JongYongPark 26:26474003e443 734 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_2))
JongYongPark 26:26474003e443 735 rx_loop_ook_4ch(LIFI_CHANNEL_2);
JongYongPark 26:26474003e443 736 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_3))
JongYongPark 26:26474003e443 737 rx_loop_ook_4ch(LIFI_CHANNEL_3);
JongYongPark 26:26474003e443 738 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_4))
JongYongPark 26:26474003e443 739 rx_loop_ook_4ch(LIFI_CHANNEL_4);
JongYongPark 26:26474003e443 740
JongYongPark 26:26474003e443 741
JongYongPark 26:26474003e443 742 // if(LifixRx_FinishedFromAllChannel()){
JongYongPark 26:26474003e443 743 // print_4ch_message();
JongYongPark 26:26474003e443 744 // loop_count = 0;
JongYongPark 26:26474003e443 745 // }
JongYongPark 26:26474003e443 746 // else {
JongYongPark 26:26474003e443 747 // loop_count++;
JongYongPark 26:26474003e443 748 // if(loop_count > 2 )
JongYongPark 26:26474003e443 749 // {
JongYongPark 26:26474003e443 750 // LifixRx_PrintUnFinishedChannl();
JongYongPark 26:26474003e443 751 // print_4ch_message();
JongYongPark 26:26474003e443 752 // LifiRx_Init();
JongYongPark 26:26474003e443 753 // loop_count = 0;
JongYongPark 26:26474003e443 754 // }
JongYongPark 26:26474003e443 755 // }
JongYongPark 26:26474003e443 756
JongYongPark 26:26474003e443 757 finished_channel = LifixRx_FinishedChannlCount();
JongYongPark 26:26474003e443 758 if( finished_channel == LIFI_ACTUAL_MAX_CHANNEL_NUM ) {
JongYongPark 26:26474003e443 759 print_4ch_message();
JongYongPark 26:26474003e443 760 loop_count = 0;
JongYongPark 26:26474003e443 761 }
JongYongPark 26:26474003e443 762 // 4 channel 에서 하나의 유효한 channel 에서 데이타를 받으면 나머지는 어디서 문제가 발생했는지 알 수 있다.
JongYongPark 26:26474003e443 763 else if(finished_channel >= 1 ) {
JongYongPark 26:26474003e443 764 loop_count++;
JongYongPark 26:26474003e443 765 if(loop_count > 1000 ) {
JongYongPark 26:26474003e443 766 printf("\nHERE 1 Finished channel count (%d)",finished_channel);
JongYongPark 26:26474003e443 767 LifixRx_PrintUnfinishedChannl();
JongYongPark 26:26474003e443 768 print_4ch_message();
JongYongPark 26:26474003e443 769 LifiRx_Init();
JongYongPark 26:26474003e443 770 loop_count = 0;
JongYongPark 26:26474003e443 771 }
JongYongPark 26:26474003e443 772 }
JongYongPark 26:26474003e443 773 // else
JongYongPark 26:26474003e443 774 // {
JongYongPark 26:26474003e443 775 // loop_count++;
JongYongPark 26:26474003e443 776 // if(loop_count > 10000000 )
JongYongPark 26:26474003e443 777 // {
JongYongPark 26:26474003e443 778 // printf("\nHERE 2 Finished(%d)",finished_channel);
JongYongPark 26:26474003e443 779 // LifixRx_PrintUnfinishedChannl();
JongYongPark 26:26474003e443 780 // print_4ch_message();
JongYongPark 26:26474003e443 781 // LifiRx_Init();
JongYongPark 26:26474003e443 782 // loop_count = 0;
JongYongPark 26:26474003e443 783 // }
JongYongPark 26:26474003e443 784 // }
JongYongPark 0:488aa8153e15 785 }
JongYongPark 0:488aa8153e15 786
JongYongPark 0:488aa8153e15 787 // the loop routine runs over and over again forever:
JongYongPark 0:488aa8153e15 788
JongYongPark 26:26474003e443 789 void LifiRx_SampleSignalEdge()
JongYongPark 26:26474003e443 790 {
JongYongPark 26:26474003e443 791 int sensorValue, sensorValue2, sensorValue3, sensorValue4;
JongYongPark 0:488aa8153e15 792
JongYongPark 26:26474003e443 793 sensorValue = LifiRx_AdcRead(LIFI_CHANNEL_1);
JongYongPark 26:26474003e443 794 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_2))
JongYongPark 26:26474003e443 795 sensorValue2 = LifiRx_AdcRead(LIFI_CHANNEL_2);
JongYongPark 26:26474003e443 796 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_3))
JongYongPark 26:26474003e443 797 sensorValue3 = LifiRx_AdcRead(LIFI_CHANNEL_3);
JongYongPark 26:26474003e443 798 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_4))
JongYongPark 26:26474003e443 799 sensorValue4 = LifiRx_AdcRead(LIFI_CHANNEL_4);
JongYongPark 0:488aa8153e15 800
JongYongPark 26:26474003e443 801 sample_signal_edge_4ch(LIFI_CHANNEL_1, sensorValue);
JongYongPark 26:26474003e443 802 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_2))
JongYongPark 26:26474003e443 803 sample_signal_edge_4ch(LIFI_CHANNEL_2, sensorValue2);
JongYongPark 26:26474003e443 804 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_3))
JongYongPark 26:26474003e443 805 sample_signal_edge_4ch(LIFI_CHANNEL_3, sensorValue3);
JongYongPark 26:26474003e443 806 if (Lifi_IsChannelAvailable(LIFI_CHANNEL_4))
JongYongPark 26:26474003e443 807 sample_signal_edge_4ch(LIFI_CHANNEL_4, sensorValue4);
JongYongPark 0:488aa8153e15 808 }
JongYongPark 0:488aa8153e15 809
JongYongPark 26:26474003e443 810 void LifiRx_Init()
JongYongPark 26:26474003e443 811 {
JongYongPark 26:26474003e443 812 rx_vars[LIFI_CHANNEL_1].rx_frame_index = -1;
JongYongPark 26:26474003e443 813 rx_vars[LIFI_CHANNEL_2].rx_frame_index = -1;
JongYongPark 26:26474003e443 814 rx_vars[LIFI_CHANNEL_3].rx_frame_index = -1;
JongYongPark 26:26474003e443 815 rx_vars[LIFI_CHANNEL_4].rx_frame_index = -1;
JongYongPark 26:26474003e443 816 rx_vars[LIFI_CHANNEL_1].rx_frame_size = -1;
JongYongPark 26:26474003e443 817 rx_vars[LIFI_CHANNEL_2].rx_frame_size = -1;
JongYongPark 26:26474003e443 818 rx_vars[LIFI_CHANNEL_3].rx_frame_size = -1;
JongYongPark 26:26474003e443 819 rx_vars[LIFI_CHANNEL_4].rx_frame_size = -1;
JongYongPark 26:26474003e443 820 rx_vars[LIFI_CHANNEL_1].frame_state = IDLE_STATE;
JongYongPark 26:26474003e443 821 rx_vars[LIFI_CHANNEL_2].frame_state = IDLE_STATE;
JongYongPark 26:26474003e443 822 rx_vars[LIFI_CHANNEL_3].frame_state = IDLE_STATE;
JongYongPark 26:26474003e443 823 rx_vars[LIFI_CHANNEL_4].frame_state = IDLE_STATE;
JongYongPark 0:488aa8153e15 824
JongYongPark 26:26474003e443 825 rx_vars[LIFI_CHANNEL_1].is_received = false;
JongYongPark 26:26474003e443 826 rx_vars[LIFI_CHANNEL_2].is_received = false;
JongYongPark 26:26474003e443 827 rx_vars[LIFI_CHANNEL_3].is_received = false;
JongYongPark 26:26474003e443 828 rx_vars[LIFI_CHANNEL_4].is_received = false;
JongYongPark 14:07669aafe0e4 829 }