diff --git a/BF_companion b/BF_companion index 87443e8..e6a5c29 100755 Binary files a/BF_companion and b/BF_companion differ diff --git a/main.c b/main.c index 8902329..ec0505e 100644 --- a/main.c +++ b/main.c @@ -67,8 +67,61 @@ #include "l502_BF_enums.h" #include "l502_fpga_regs.h" +typedef enum { + unknown = 0x00, + ADC_data =0x01, + USR_data, + DIN_data, + FFT_val_re, + FFT_val_im, + FFT_val_f, + LFSM_val_ON, + LFSM_val_OFF, + LFSM_val_X, + USR_msg, + LFSM_started, +} BF_msg_parsed_type; + +typedef struct BF_msg_parsed_typedef { + BF_msg_parsed_type type; + uint8_t chan; + uint8_t flags; + uint8_t raw_header; + uint32_t raw_data; + uint32_t raw_value; + int value_int; + double value; +}; + +typedef struct LFSM_typedef{ //Linear Frequency Sweep Modulation + int * X; + int * Y_on; //intensity while Mach-Zander modulator is "opened" + int * Y_off;//intensity while Mach-Zander modulator is "closed" + int ID; + uint8_t rcv_state; + int max_N; //max number of data points + int curr_I; + uint8_t description; +}; + +typedef struct FFT_res_typedef{ + + int * vals_Re; + int * vals_Im; + int * vals_F; + int values_N; + uint8_t rcv_state; + int max_N; + //int timestamp; + int ID; + uint8_t description; + int curr_I; //current index of value and corresponding frequency +} ; + +const int FFT_length = 1000; + // количество используемых логических каналов // -#define ADC_LCH_CNT 1 +#define ADC_LCH_CNT 4 // частота сбора АЦП в Гц// #define ADC_FREQ 2000000 @@ -91,11 +144,11 @@ // номера используемых физических каналов // -static uint32_t f_channels[ADC_LCH_CNT] = {0}; +static uint32_t f_channels[ADC_LCH_CNT] = {0, 0, 1, 0}; // режимы измерения для каналов // -static uint32_t f_ch_modes[ADC_LCH_CNT] = {X502_LCH_MODE_COMM}; +static uint32_t f_ch_modes[ADC_LCH_CNT] = {X502_LCH_MODE_COMM, X502_LCH_MODE_COMM,X502_LCH_MODE_COMM,X502_LCH_MODE_COMM}; // диапазоны измерения для каналов // -static uint32_t f_ch_ranges[ADC_LCH_CNT] = {X502_ADC_RANGE_1}; +static uint32_t f_ch_ranges[ADC_LCH_CNT] = {X502_ADC_RANGE_1, X502_ADC_RANGE_1,X502_ADC_RANGE_1,X502_ADC_RANGE_1}; @@ -304,19 +357,26 @@ int32_t f_setup_params(t_x502_hnd hnd) { + //double f_din = DIN_FREQ; + //err = X502_SetDinFreq(hnd, &f_din); + //printf(); + //set ADC sample frequency from internal generator with frequency 2 MHz - //X502_SetRefFreq(hnd, X502_REF_FREQ_2000KHZ); + X502_SetRefFreq(hnd, X502_REF_FREQ_2000KHZ); //=======================================================// //for real work with Radar //X502_SetSyncMode(hnd, X502_SYNC_DI_SYN1_FALL); - //X502_SetSyncStartMode(hnd, X502_SYNC_DI_SYN2_RISE); //start ADC samping by external trigger + //X502_SetSyncStartMode(hnd, X502_SYNC_DI_SYN2_RISE); //start ADC sampling by external trigger //=======================================================// //for debug purposes: - X502_SetSyncMode(hnd, X502_SYNC_INTERNAL); - X502_SetSyncStartMode(hnd, X502_SYNC_INTERNAL); //start ADC samping after executing X502_StreamsStart() + X502_SetRefFreq(hnd, X502_REF_FREQ_2000KHZ); + X502_SetSyncMode(hnd, X502_SYNC_DI_SYN1_FALL); + //X502_SetSyncMode(hnd, X502_SYNC_INTERNAL); + //X502_SetSyncStartMode(hnd, X502_SYNC_INTERNAL); //start ADC samping after executing X502_StreamsStart() + X502_SetSyncStartMode(hnd, X502_SYNC_DI_SYN2_RISE); //start ADC sampling by external trigger @@ -499,6 +559,223 @@ uint32_t BF_exec_cmd_with_arr(t_x502_hnd hnd, uint16_t cmd_code, uint32_t cmd_pa return BF_cmd_receive_code; } +long int X502_Raw_User_Data_Parser(uint32_t *inp_buff, uint32_t inp_values_N, + double *adc_data, uint32_t *adc_chans_N, uint32_t *adc_readouts_N, + struct LFSM_typedef ** LFSM_data, struct LFSM_typedef ** LFSM_data_done, + struct FFT_res_typedef ** FFT_data, struct FFT_res_typedef ** FFT_data_done){ + long int return_res = 0; + //printf("inp_values_N: %d, adc_chans_N: %d, adc_readouts_N: %d, user_data_chans_N: %d, user_data_readouts_N: %d\n", inp_values_N, adc_chans_N, adc_readouts_N, user_data_chans_N, user_data_readouts_N); + + /* + for (int I = 0; I < adc_readouts_N; ++I){ + adc_data[I] = 0.0; + } + for (int I = 0; I < user_data_readouts_N; ++I){ + user_data[I] = 0.0; + } +*/ + + /* + (*(*(*(*(*(*(*(*FFT_data))))))))-> values_N = 0; + (*FFT_data)-> ID = 0; + (*FFT_data)-> description = 0; + (*FFT_data)-> curr_I = 0; //current index of value and corresponding frequency + + for (int I = 0; I < adc_readouts_N; ++I){ + (*FFT_data)->vals_Re [I] = 0; + (*FFT_data)-> vals_Im [I] = 0; + (*FFT_data)-> vals_F [I] = 0; + } + +*/ + + + struct BF_msg_parsed_typedef BF_msg; + for (uint32_t inp_buff_I = 0; inp_buff_I < inp_values_N; ++inp_buff_I){ + + BF_msg.raw_data = inp_buff[inp_buff_I]; + BF_msg.raw_header = (uint8_t) (BF_msg.raw_data >> 24); + + BF_msg.flags = 0; + BF_msg.type = 0; + BF_msg.chan = 0; + //BF_msg.raw_data = 0; + BF_msg.raw_value = BF_msg.raw_data & 0xFFFFFF; + BF_msg.value_int = 0; + BF_msg.value = 0; + + if (BF_msg.raw_header & 0b10000000){ // ADC data + BF_msg.type = ADC_data; + BF_msg.chan = BF_msg.raw_header & 0b00001111; + BF_msg.flags = (BF_msg.raw_header >> 4); + BF_msg.value_int = BF_msg.raw_value & 0x7FFFFF; + if (BF_msg.raw_value & 0x800000){ // if first bit is nonzero -- it is negative value + BF_msg.value_int *= -1; + } + BF_msg.value = 0.0;// TODO conversion from int to double with respect to ADC channel voltage range + + + }else if (BF_msg.raw_header & 0b01000000){ //user data (FFT,) + if (BF_msg.raw_header & 0x0F == FFT_val_re){ + BF_msg.type = FFT_val_re; + }else if (BF_msg.raw_header & 0x0F == FFT_val_im){ + BF_msg.type = FFT_val_im; + }else if (BF_msg.raw_header & 0x0F == FFT_val_f){ + BF_msg.type = FFT_val_f; + }else{ + BF_msg.type = USR_data; + } + BF_msg.chan = 0; + //BF_msg.chan == BF_msg.raw_header & 0b00111111; + BF_msg.value_int = BF_msg.raw_value & 0x7FFFFF; + if (BF_msg.raw_value & 0x800000){ // if first bit is nonzero -- it is negative value + BF_msg.value_int *= -1; + } + if (! (((*FFT_data)-> rcv_state) & (0b1 << 7 ))){ + if (BF_msg.type == FFT_val_re){ + (*FFT_data)->rcv_state |= 0b1 << 0; + (*FFT_data)-> vals_Re[(*FFT_data)->curr_I] = BF_msg.value_int; + }else if (BF_msg.type == FFT_val_im){ + (*FFT_data)->rcv_state |= 0b1 << 1; + (*FFT_data)-> vals_Im[(*FFT_data)->curr_I] = BF_msg.value_int; + }else if (BF_msg.type == FFT_val_f){ + (*FFT_data)->rcv_state |= 0b1 << 2; + (*FFT_data)-> vals_F[(*FFT_data)->curr_I] = BF_msg.value_int; + } + if ((*FFT_data)-> rcv_state == 0b111){ + (*FFT_data)-> rcv_state = 0; + ++(*FFT_data)->curr_I; + if ((*FFT_data)->curr_I >= (*FFT_data)->max_N){ + (*FFT_data)-> rcv_state |= 0b1 << 7; + printf("received more FFT values than allowed. <========================== ERROR\n"); + + } + } + } + }else if (BF_msg.raw_header & 0b01100000){ //user data LFSM) + if (BF_msg.raw_header & 0x0F == LFSM_val_ON){ + BF_msg.type = LFSM_val_ON; + }else if (BF_msg.raw_header & 0x0F == LFSM_val_OFF){ + BF_msg.type = LFSM_val_OFF; + }else if (BF_msg.raw_header & 0x0F == LFSM_val_X){ + BF_msg.type = LFSM_val_X; + }else{ + BF_msg.type = USR_data; + } + BF_msg.chan = 0; + //BF_msg.chan == BF_msg.raw_header & 0b00111111; + BF_msg.value_int = BF_msg.raw_value & 0x7FFFFF; + if (BF_msg.raw_value & 0x800000){ // if first bit is nonzero -- it is negative value + BF_msg.value_int *= -1; + } + if (! (((*LFSM_data) -> rcv_state) & (0b1 << 7 ))){ + if (BF_msg.type == LFSM_val_ON){ + (*LFSM_data) ->rcv_state |= 0b1 << 0; + (*LFSM_data) -> Y_on[(*LFSM_data) ->curr_I] = BF_msg.value_int; + }else if (BF_msg.type == LFSM_val_OFF){ + (*LFSM_data) ->rcv_state |= 0b1 << 1; + (*LFSM_data) -> Y_off[(*LFSM_data) ->curr_I] = BF_msg.value_int; + }else if (BF_msg.type == LFSM_val_X){ + (*LFSM_data) ->rcv_state |= 0b1 << 2; + (*LFSM_data) -> X[(*LFSM_data) ->curr_I] = BF_msg.value_int; + } + if ((*LFSM_data) -> rcv_state == 0b011){ + (*LFSM_data) -> rcv_state = 0; + ++(*LFSM_data) ->curr_I; + if ((*LFSM_data) ->curr_I >= (*LFSM_data) ->max_N){ + (*LFSM_data) -> rcv_state |= 0b1 << 7; + printf("received more LFSM values than allowed. <========================== ERROR\n"); + } + } + } + + }else if (BF_msg.raw_header & 0b01100000 == 0b01100000){ //user message + BF_msg.type = USR_msg; + BF_msg.chan = BF_msg.raw_header & 0b00011111; + BF_msg.value_int = BF_msg.raw_value & 0x7FFFFF; + if (BF_msg.raw_value & 0x800000){ // if first bit is nonzero -- it is negative value + BF_msg.value_int *= -1; + } + printf("Received USR msg: 0x%06H\n", BF_msg.raw_value); + + //}else if (raw_header & 0b01100000 == 0b01100000){ // + }else if (BF_msg.raw_header & 0b01101010 == 0b01101010){ //new Frequency Sweep Started. So save old (*FFT_data)to FFT_data_done and start working with new FFT_data + //FFT + printf("Received: new LFSM started. msg payload: 0x%06H\n", BF_msg.raw_value); + (*FFT_data)-> rcv_state = 0xFF; // data filled + int FFT_last_ID = (*FFT_data)-> ID; + int FFT_points_max_N = (*FFT_data)-> max_N; + struct FFT_res_typedef ** FFT_tmp = *FFT_data_done; + *FFT_data_done = *FFT_data; + *FFT_data = *FFT_tmp; + + + //(*FFT_data)-> values_N = 0; + (*FFT_data)-> rcv_state = 0; + (*FFT_data)-> ID = FFT_last_ID + 1; + (*FFT_data)-> max_N = FFT_points_max_N; + (*FFT_data)-> description = 0; + (*FFT_data)-> curr_I = 0; //current index of value and corresponding frequency + + for (int I = 0; I < (*FFT_data)-> max_N; ++I){ + (*FFT_data)->vals_Re [I] = 0; + (*FFT_data)-> vals_Im [I] = 0; + (*FFT_data)-> vals_F [I] = 0; + } + free(FFT_tmp); + free(FFT_last_ID); + free(FFT_points_max_N); + + //LFSM + (*LFSM_data) -> rcv_state = 0xFF; // data filled + int LFSM_last_ID = (*LFSM_data) -> ID; + int LFSM_points_max_N = (*LFSM_data) -> max_N; + struct LFSM_typedef ** LFSM_tmp = *LFSM_data_done; + *LFSM_data_done = *LFSM_data; + *LFSM_data = *LFSM_tmp; + + + //(*LFSM_data) -> values_N = 0; + (*LFSM_data) -> rcv_state = 0; + (*LFSM_data) -> ID = LFSM_last_ID + 1; + (*LFSM_data) -> max_N = LFSM_points_max_N; + (*LFSM_data) -> description = 0; + (*LFSM_data) -> curr_I = 0; //current index of value and corresponding frequency + for (int I = 0; I < (*LFSM_data) -> max_N; ++I){ + (*LFSM_data) -> X [I] = 0; + (*LFSM_data) -> Y_on [I] = 0; + (*LFSM_data) -> Y_off [I] = 0; + } + free(LFSM_tmp); + free(LFSM_last_ID); + free(LFSM_points_max_N); + + + + + + + + + }else{ + BF_msg.type = unknown; + BF_msg.chan = 0; + BF_msg.value_int = BF_msg.raw_value & 0x7FFFFF; + if (BF_msg.raw_value & 0x800000){ // if first bit is nonzero -- it is negative value + BF_msg.value_int *= -1; + } + } + } +} + + + + + + + + + int main(int argc, char** argv) { @@ -523,6 +800,68 @@ int main(int argc, char** argv) { ver = X502_GetLibraryVersion(); printf("Версия библиотеки: %d.%d.%d\n", (ver >> 24)&0xFF, (ver>>16)&0xFF, (ver>>8)&0xFF); +//* + uint32_t inp_buff[2] = {0,}; + double adc_data[1] = {0,}; + double user_data[1] = {0,}; + uint32_t inp_values_N = 0; + uint32_t adc_chans_N = 1; + uint32_t adc_readouts_N= 2; + uint32_t user_data_chans_N = 3; + uint32_t user_data_readouts_N = 4; + //uint32_t FFT_data_readouts_N = 5; + + + + struct FFT_res_typedef FFT_res_tmp; + FFT_res_tmp.max_N = 1000; + FFT_res_tmp.vals_Re = malloc(FFT_res_tmp.max_N * sizeof(int)); + FFT_res_tmp.vals_Im = malloc(FFT_res_tmp.max_N *sizeof(int)); + FFT_res_tmp.vals_F = malloc(FFT_res_tmp.max_N * sizeof(int)); + FFT_res_tmp.curr_I = 0; + FFT_res_tmp.description = 0; + FFT_res_tmp.rcv_state = 0; + FFT_res_tmp.ID = 0; + + struct FFT_res_typedef FFT_res; + FFT_res.ID = 0; + + + struct LFSM_typedef LFSM_res_tmp; + LFSM_res_tmp.max_N = 1000; + LFSM_res_tmp.X = malloc(LFSM_res_tmp.max_N * sizeof(int)); + LFSM_res_tmp.Y_on = malloc(LFSM_res_tmp.max_N *sizeof(int)); + LFSM_res_tmp.Y_off = malloc(LFSM_res_tmp.max_N * sizeof(int)); + LFSM_res_tmp.curr_I = 0; + LFSM_res_tmp.description = 0; + LFSM_res_tmp.rcv_state = 0; + LFSM_res_tmp.ID = 0; + + struct LFSM_typedef LFSM_res; + LFSM_res.ID = 0; + + + + + + + + +/* + X502_Raw_User_Data_Parser(inp_buff, inp_values_N, + adc_data, adc_chans_N, adc_readouts_N, + &LFSM_res_tmp, &LFSM_res, + &FFT_res_tmp, &FFT_res); + */ +//*/ + +/* + X502_Raw_User_Data_Parser(inp_buff, inp_values_N, + adc_data, adc_chans_N, adc_readouts_N, + user_data, user_data_chans_N, user_data_readouts_N); +*/ + + ////******* Получение списка устройств и выбор, с каким будем работать *****************// hnd = f_dev_select_open(argc, argv); @@ -557,6 +896,8 @@ int main(int argc, char** argv) { } + X502_StreamsStop(hnd); //stop all streams. We need it because we can connect to module that is already sampling. And sampling blocks any setup trials. + if (err == X502_ERR_OK) { // настраиваем параметры модуля // err = f_setup_params(hnd); @@ -571,6 +912,14 @@ int main(int argc, char** argv) { uint32_t bf_firmware_load_state = X502_BfLoadFirmware(hnd, BF_firmware_filename); //load firmware from l502-BFfirmware0.ldr file to BlackFin printf("load state: %u \n", bf_firmware_load_state); + printf("setup module again"); + if (err == X502_ERR_OK) { + // настраиваем параметры модуля // + err = f_setup_params(hnd); + if (err != X502_ERR_OK) + fprintf(stderr, "Ошибка настройки модуля: %s!", X502_GetErrorString(err)); + } + uint32_t BF_cmd_receive_code = 0; @@ -621,8 +970,8 @@ int main(int argc, char** argv) { //BF_exec_cmd_simple(hnd, 0x8003U, 0, 1); - printf("setup ADC\n"); - BF_exec_cmd_with_arr(hnd, 0x8003U, 0, NULL, 0, 1); //setup ADC. Values in array are configuring functions return codes + //printf("setup ADC\n"); + //BF_exec_cmd_with_arr(hnd, 0x8003U, 0, NULL, 0, 1); //setup ADC. Values in array are configuring functions return codes //some delay to allow ADC to acquire some data @@ -630,7 +979,7 @@ int main(int argc, char** argv) { //BF_exec_cmd_simple(hnd, 0x8006, L502_REGS_IOHARD_OUTSWAP_BFCTL, 1); //reaf fpga reg uint32_t streams_enable_Err = 0; - streams_enable_Err = X502_StreamsEnable(hnd, X502_STREAM_ADC ); + streams_enable_Err = X502_StreamsEnable(hnd, X502_STREAM_ADC | X502_STREAM_DIN ); printf("Streams start err: %d \n", streams_enable_Err); uint32_t streams_start_Err = 0; streams_start_Err = X502_StreamsStart(hnd); @@ -643,7 +992,7 @@ int main(int argc, char** argv) { uint32_t waiting_cnt = 1; - waiting_cnt = 1000; + waiting_cnt = 100000; printf("\nwaiting %d ...", waiting_cnt); while(--waiting_cnt){;} //for(uint32_t timeout = 100000000; timeout; --timeout){;} @@ -660,7 +1009,9 @@ int main(int argc, char** argv) { printf("receiving data...\n"); - uint32_t inp_buff[1024] = {0,}; + uint32_t *inp_buff = malloc(1024*100*1024*2*4); + double *adc_data = malloc(1024*1024*sizeof(double)); + //uint32_t inp_buff[1024*2048] = {0,}; uint32_t ready_cnt = 0; uint32_t ready_cnt_Err = 0; @@ -674,13 +1025,26 @@ int main(int argc, char** argv) { printf("Ready count: %d, Err: %d \n", ready_cnt, ready_cnt_Err); printf("Recv Err code (<0 -- err, >= 0 -- number of received words(32bit)): %d\n", recv_Err_code); + if (recv_Err_code > 0){ + ready_cnt = recv_Err_code; + } + + FILE *logfile_ptr; + time_t seconds; + time(&seconds); + char logfilename[] = " "; + sprintf(&logfilename, "received_data_%ld.csv", seconds); + logfile_ptr = fopen(logfilename, "w"); + printf("dumping to file: %c\n", logfilename); printf("\n\nreceived data:\n"); int values_in_line = 0; - for (int i = 0; i < 1024; ++i){ + //for (int i = 0; i < 1024; ++i){ + for (int i = 0; i < ready_cnt; ++i){ char bin_str_val[9] = {0,}; uin32_t_to_bin(inp_buff[i], bin_str_val); printf(" 0x%08X,", inp_buff[i]); + fprintf(logfile_ptr, "0x%08X \n", inp_buff[i]); //printf(" 0b%s,", bin_str_val); ++values_in_line; if (values_in_line == 10){ @@ -691,109 +1055,54 @@ int main(int argc, char** argv) { printf("\n"); + printf("\n\nget counters of calls of SPORT_RX, SPORT_TX, HDMA_RX, HDMA_TX\n"); + BF_exec_cmd_with_arr(hnd, 0x8005U, 100, NULL, 0, 1); + //fprintf(logfile_ptr, "value number; time, sec; adc_value, V\n"); + int data_receive_trys_counter = 1000; + while(--data_receive_trys_counter){ + ready_cnt_Err = X502_GetRecvReadyCount(hnd, &ready_cnt); + recv_Err_code = X502_Recv(hnd, inp_buff, ready_cnt, 10); + printf("\n\nget counters of calls of SPORT_RX, SPORT_TX, HDMA_RX, HDMA_TX\n"); + BF_exec_cmd_with_arr(hnd, 0x8005U, 100, NULL, 0, 1); + if (ready_cnt){ + printf("Ready count: %d, Err: %d \n", ready_cnt, ready_cnt_Err); + for (int i = 0; i < ready_cnt; ++i){ + char bin_str_val[9] = {0,}; + uin32_t_to_bin(inp_buff[i], bin_str_val); + printf(" 0x%08X,", inp_buff[i]); + fprintf(logfile_ptr, "0x%08X \n", inp_buff[i]); + //printf(" 0b%s,", bin_str_val); + ++values_in_line; + if (values_in_line == 10){ + printf("\n"); + values_in_line = 0; + } + } - - - - - - -/* - //uint16_t cmd_code = 0x80001U; - uint16_t cmd_code = 0x8001; //read ADC data - uint32_t par = 87; - const uint32_t snd_data[] = {1,1,2,2,3,4,5,56,67,23,1}; - uint32_t snd_size = 0; - uint32_t rcv_data[100] = {0,}; - uint32_t rcv_size = 100; - uint32_t tout = 1; - uint32_t recvd_size = 0; - - - - printf("TX cmd_code: 0x%X\n", cmd_code); - printf("TX tout: %u\n", tout); - printf("TX par: %u\n", par); - printf("TX snd_data size: %u\n", snd_size); - for (int i = 0; i < snd_size; ++i){ - printf(" %u,", snd_data[i]); - } - printf("\n"); - printf("TX rcv_size: %u\n", rcv_size); - - - BF_cmd_receive_code = X502_BfExecCmd (hnd, - cmd_code, - par, - snd_data, - snd_size, - rcv_data, - rcv_size, - tout, - &recvd_size); - - - printf("\n======================\n\n"); - printf("RX received code dec: %u hex: 0x%3X, %d\n", BF_cmd_receive_code, BF_cmd_receive_code,BF_cmd_receive_code); - printf("RX recvd_size: %u\n", recvd_size); - printf("RX received_data:\n" ); - for (int i = 0; i < recvd_size; ++i){ - printf(" %0X,", rcv_data[i]); - } - printf("\n\n\n\n"); - - - - - - cmd_code = 0x8002; - par = 87; - //snd_data[] = {1,1,2,2,3,4,5,56,67,23,1}; - snd_size = 11; - //rcv_data[13] = {0,}; - rcv_size = 13; - tout = 1; - recvd_size = 0; - - - - printf("TX cmd_code: 0x%X\n", cmd_code); - printf("TX tout: %u\n", tout); - printf("TX par: %u\n", par); - printf("TX snd_data size: %u\n", snd_size); - for (int i = 0; i < snd_size; ++i){ - printf(" %u,", snd_data[i]); - } - printf("\n"); - printf("TX rcv_size: %u\n", rcv_size); - - - BF_cmd_receive_code = X502_BfExecCmd (hnd, - cmd_code, - par, - snd_data, - snd_size, - rcv_data, - rcv_size, - tout, - &recvd_size); - - - printf("\n======================\n\n"); - printf("RX received code dec: %u hex: 0x%3X, %d\n", BF_cmd_receive_code, BF_cmd_receive_code,BF_cmd_receive_code); - printf("RX recvd_size: %u\n", recvd_size); - printf("RX received_data:\n" ); - for (int i = 0; i < recvd_size; ++i){ - printf(" %u,", rcv_data[i]); - } - printf("\n"); - -*/ - + /* + uint32_t process_data_Err = 0; + uint32_t adc_data_size = ready_cnt; + X502_Raw_User_Data_Parser(inp_buff, inp_values_N, + adc_data, adc_chans_N, adc_readouts_N, + &LFSM_res_tmp, &LFSM_res, + &FFT_res_tmp, &FFT_res); + //process_data_Err = X502_ProcessData(hnd, inp_buff, ready_cnt, X502_PROC_FLAGS_VOLT, adc_data, &adc_data_size, NULL, NULL); + uint64_t data_sum = 0; + for (int i = 0; i < ready_cnt; ++i){ + data_sum += inp_buff[i]; + if (i % 1000 == 1){ + //printf(" %e\n", adc_data[i]); + } + } + */ + } + //printf("try: %04d, words ready: %06d, receive_error_code: %05d, data_sum: %d \n", data_receive_trys_counter, ready_cnt, recv_Err_code, data_sum); + } + fclose(logfile_ptr); @@ -806,13 +1115,6 @@ int main(int argc, char** argv) { -// // запуск синхронного ввода-вывода // -// if (err == X502_ERR_OK) { -// err = X502_StreamsStart(hnd); -// if (err != X502_ERR_OK) -// fprintf(stderr, "Ошибка запуска сбора данных: %s!\n", X502_GetErrorString(err)); -// } - f_out = 1; struct timespec time_started; diff --git a/makefile b/makefile index 6c16bb5..2ec8ae0 100644 --- a/makefile +++ b/makefile @@ -45,6 +45,6 @@ endif all: - $(CC) main.c $(FLAGS) -ll502api -le502api -lx502api -o BF_companion + $(CC) main.c $(FLAGS) -ll502api -le502api -lx502api -g -o BF_companion clean: -rm BF_companion diff --git a/plotter.py b/plotter.py index e747066..15711fa 100755 --- a/plotter.py +++ b/plotter.py @@ -15,21 +15,34 @@ if __name__ == "__main__": main() else: f = open(argv[1], "rt") - f.readline() - X = [] - Y = [] + data = {} + values_N = 0 for line in f: + print(line) + #print(line, len(line)) + len_line = len(line) try: - i, x, y = line.split() - x = float(x) - y = float(y) - X.append(x) - Y.append(y) + if (len_line >= 11): + if (line[:2] == "0x"): + values_N += 1 + header = line[2:4] + value = line[4:10] + if not(header in data): + data[header] = [] + data[header + "_N"] = [] + data[header + "_hex"] = [] + data[header].append(int(value,16)) + data[header + "_hex"].append(value) + data[header + "_N"].append(values_N) except ValueError: pass + except IndexError: + pass f.close() - print("data samples:",len(X)) +# print("data samples:",len(data["X"])) chart = go.Figure() - chart.add_trace(go.Scatter(x=X, y=Y)) + for key, val in data.items(): + if (key.count("_N") + key.count("_hex")) == 0: + chart.add_trace(go.Scatter(x=data[key+"_N"], y=data[key], name=key, mode="lines+markers", text=data[key+"_hex"])) chart.show()