ChTheo/E502_ADC_BF_PC_companion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

working receiving data and dumping it to file. Also implemented simple python plotter of that data.

Browse Source
This commit is contained in:
Theodor Chikin
2025-07-17 19:09:57 +03:00
parent 16c92aa730
commit 068b026473
4 changed files with 445 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
BF_companion
View File

Binary file not shown.

532
main.c
View File

@ -67,8 +67,61 @@
#include "l502_BF_enums.h" #include "l502_BF_enums.h"
#include "l502_fpga_regs.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 #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 //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 //for real work with Radar
//X502_SetSyncMode(hnd, X502_SYNC_DI_SYN1_FALL); //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: //for debug purposes:
X502_SetSyncMode(hnd, X502_SYNC_INTERNAL); X502_SetRefFreq(hnd, X502_REF_FREQ_2000KHZ);
X502_SetSyncStartMode(hnd, X502_SYNC_INTERNAL); //start ADC samping after executing X502_StreamsStart() 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; 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) { int main(int argc, char** argv) {
@ -523,6 +800,68 @@ int main(int argc, char** argv) {
ver = X502_GetLibraryVersion(); ver = X502_GetLibraryVersion();
printf("Версия библиотеки: %d.%d.%d\n", (ver >> 24)&0xFF, (ver>>16)&0xFF, (ver>>8)&0xFF); 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); 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) { if (err == X502_ERR_OK) {
// настраиваем параметры модуля // // настраиваем параметры модуля //
err = f_setup_params(hnd); 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 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("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; 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); //BF_exec_cmd_simple(hnd, 0x8003U, 0, 1);
printf("setup ADC\n"); //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 //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 //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 //BF_exec_cmd_simple(hnd, 0x8006, L502_REGS_IOHARD_OUTSWAP_BFCTL, 1); //reaf fpga reg
uint32_t streams_enable_Err = 0; 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); printf("Streams start err: %d \n", streams_enable_Err);
uint32_t streams_start_Err = 0; uint32_t streams_start_Err = 0;
streams_start_Err = X502_StreamsStart(hnd); streams_start_Err = X502_StreamsStart(hnd);
@ -643,7 +992,7 @@ int main(int argc, char** argv) {
uint32_t waiting_cnt = 1; uint32_t waiting_cnt = 1;
waiting_cnt = 1000; waiting_cnt = 100000;
printf("\nwaiting %d ...", waiting_cnt); printf("\nwaiting %d ...", waiting_cnt);
while(--waiting_cnt){;} while(--waiting_cnt){;}
//for(uint32_t timeout = 100000000; timeout; --timeout){;} //for(uint32_t timeout = 100000000; timeout; --timeout){;}
@ -660,7 +1009,9 @@ int main(int argc, char** argv) {
printf("receiving data...\n"); 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 = 0;
uint32_t ready_cnt_Err = 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("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); 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"); printf("\n\nreceived data:\n");
int values_in_line = 0; 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,}; char bin_str_val[9] = {0,};
uin32_t_to_bin(inp_buff[i], bin_str_val); uin32_t_to_bin(inp_buff[i], bin_str_val);
printf(" 0x%08X,", inp_buff[i]); printf(" 0x%08X,", inp_buff[i]);
fprintf(logfile_ptr, "0x%08X \n", inp_buff[i]);
//printf(" 0b%s,", bin_str_val); //printf(" 0b%s,", bin_str_val);
++values_in_line; ++values_in_line;
if (values_in_line == 10){ if (values_in_line == 10){
@ -691,109 +1055,54 @@ int main(int argc, char** argv) {
printf("\n"); 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);
//uint16_t cmd_code = 0x80001U; for (int i = 0; i < ready_cnt; ++i){
uint16_t cmd_code = 0x8001; //read ADC data char bin_str_val[9] = {0,};
uint32_t par = 87; uin32_t_to_bin(inp_buff[i], bin_str_val);
const uint32_t snd_data[] = {1,1,2,2,3,4,5,56,67,23,1}; printf(" 0x%08X,", inp_buff[i]);
uint32_t snd_size = 0; fprintf(logfile_ptr, "0x%08X \n", inp_buff[i]);
uint32_t rcv_data[100] = {0,}; //printf(" 0b%s,", bin_str_val);
uint32_t rcv_size = 100; ++values_in_line;
uint32_t tout = 1; if (values_in_line == 10){
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("\n");
printf("TX rcv_size: %u\n", rcv_size); values_in_line = 0;
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, uint32_t process_data_Err = 0;
cmd_code, uint32_t adc_data_size = ready_cnt;
par, X502_Raw_User_Data_Parser(inp_buff, inp_values_N,
snd_data, adc_data, adc_chans_N, adc_readouts_N,
snd_size, &LFSM_res_tmp, &LFSM_res,
rcv_data, &FFT_res_tmp, &FFT_res);
rcv_size, //process_data_Err = X502_ProcessData(hnd, inp_buff, ready_cnt, X502_PROC_FLAGS_VOLT, adc_data, &adc_data_size, NULL, NULL);
tout, uint64_t data_sum = 0;
&recvd_size); for (int i = 0; i < ready_cnt; ++i){
data_sum += inp_buff[i];
if (i % 1000 == 1){
printf("\n======================\n\n"); //printf(" %e\n", adc_data[i]);
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"); }
*/
*/ }
//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; f_out = 1;
struct timespec time_started; struct timespec time_started;

2
makefile
View File

@ -45,6 +45,6 @@ endif
all: all:
$(CC) main.c $(FLAGS) -ll502api -le502api -lx502api -o BF_companion $(CC) main.c $(FLAGS) -ll502api -le502api -lx502api -g -o BF_companion
clean: clean:
-rm BF_companion -rm BF_companion

33
plotter.py
View File

@ -15,21 +15,34 @@ if __name__ == "__main__":
main() main()
else: else:
f = open(argv[1], "rt") f = open(argv[1], "rt")
f.readline() data = {}
X = [] values_N = 0
Y = []
for line in f: for line in f:
print(line)
#print(line, len(line))
len_line = len(line)
try: try:
i, x, y = line.split() if (len_line >= 11):
x = float(x) if (line[:2] == "0x"):
y = float(y) values_N += 1
X.append(x) header = line[2:4]
Y.append(y) 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: except ValueError:
pass pass
except IndexError:
pass
f.close() f.close()
print("data samples:",len(X)) # print("data samples:",len(data["X"]))
chart = go.Figure() 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() chart.show()