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

old commented mess was deleted. Implemented SEMITRANSPARENT (puts data to the TX_buff and then sends it) and TRANSPARENT (sends data by hdma directly) modes

Browse Source
This commit is contained in:
Theodor Chikin
2025-10-02 16:22:38 +03:00
parent 8303e2c488
commit 0ddc00750c
9 changed files with 5341 additions and 5572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

428
src/l502_user_process.c
View File

@ -122,6 +122,9 @@ volatile uint32_t send_size = 0;
volatile uint8_t TX_buff_state = TX_DONE; //FILLING, TODO_TX, TRANSMITTING, TX_DONE, BUFF_READY,
volatile uint32_t tx_val = 0;
volatile uint32_t size_processed = 0;
//int f_sport_test(void);
void l502_stream_init(void);
@ -161,6 +164,8 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
передачу. Иначе возвращаем 0, чтобы на обработку этих данных функцию
вызвали бы позже */
++streams_cnt[0];
//*
size_processed = 0;
@ -173,21 +178,20 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
}
TX_buff_state = FILLING;
}
/*
for (int i = 0; i < TX_BUFF_SIZE; ++i){
TX_buff[i] = 0x00000000;
}
*/
//for (int i = 0; i < dbg_sport_rx_copy; ++i){
// dbg_sport_rx_copy[i] = data[i];
//}
//*
//simple transparent mode
if (Proc_state.mode == TRANSPARENT){
TX_buff_state = TX_BUFF_OFF;
if (hdma_send_req_rdy()){
hdma_send_req_start(data, size, 0);
return size;
}else{
return 0;
}
}
//simple transparent mode
if (Proc_state.mode == SEMITRANSPARENT){
//++Proc_state.average_N;
if (TX_buff_state == FILLING){
@ -197,6 +201,7 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
//;
TX_buff[TX_buff_I] = data[data_I];
}
size_processed = data_I;
TX_buff_state = TODO_TX;
//tx_val = 0;
@ -206,6 +211,11 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
}
//TX_buff_I = TX_BUFF_SIZE;
if (Proc_state.mode == WORK){
}
if (Proc_state.mode == AVG){
while(++data_I < size ){
uint32_t word = data[data_I];
@ -233,29 +243,32 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
for (uint32_t i = 0; ((TX_buff_I < TX_BUFF_SIZE) && (i < AVG_BUFF_SIZE)); i++){
// uint32_t i = 0;
// while ((TX_buff_I < TX_BUFF_SIZE) && (i < AVG_BUFF_SIZE)){
TX_buff[TX_buff_I++] = AVG_buff[i];
//TX_buff[TX_buff_I++] = 0xB0000000 + Proc_state.average_N;
//TX_buff[TX_buff_I++] = AVG_buff[i];
TX_buff[TX_buff_I++] = 0xB0000000 + Proc_state.average_N;
//TX_buff[TX_buff_I++] = 0xC1000000;
}
//clear AVG_buff:
for (uint32_t i = 0; i < AVG_BUFF_SIZE; i++ ){
AVG_buff[i] = 0xC2321123;
}
TX_buff_state = TODO_TX;
/*
for (uint32_t i = 0; i < TX_BUFF_SIZE; ++i){
TX_buff_shadow[i] = TX_buff[i];
}
hdma_send_req_start(TX_buff_shadow, TX_buff_I, 0);
hdma_send_req_start(TX_marker, 10, 0);
//TX_buff_state = TODO_TX;
hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
return size;
// for (uint32_t i = 0; i < TX_BUFF_SIZE; ++i){
// TX_buff_shadow[i] = TX_buff[i];
// }
// hdma_send_req_start(TX_buff_shadow, TX_buff_I, 0);
// hdma_send_req_start(TX_marker, 10, 0);
// hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
//TX_buff_state = TRANSMITTING;
TX_buff_state = TX_DONE;
*/
// TX_buff_state = TX_DONE;
}else{ //
Proc_state.AVG_state = STEP_RUNNING;
@ -281,317 +294,40 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
}
}
}
/*
if (Proc_state.mode == AVG){
data_I = 0;
//TX_buff_I = 0;
Proc_state.AVG_buff_I = 0;
if (Proc_state.AVG_buff_active == A){
while((data_I < size )&& (Proc_state.AVG_buff_I < (AVG_BUFF_SIZE - 10))){
uint32_t word = data[data_I];
//uint32_t avg_word = AVG_buff_A[Proc_state.AVG_buff_I++];
//AVG_buff_A[Proc_state.AVG_buff_I] = (avg_word & 0x007FFFFF) + (word & 0x007FFFFF);
//AVG_buff_A[Proc_state.AVG_buff_I] = 0xDD000000 | (word & 0x00FFFFFF);
AVG_buff_A[Proc_state.AVG_buff_I] = word;
//AVG_buff[Proc_state.AVG_buff_I++] = data[data_I++];
//AVG_buff[Proc_state.AVG_buff_I] = data[data_I];
//uint32_t word = data[data_I];
//AVG_buff[Proc_state.AVG_buff_I] = word;
//AVG_buff_A[Proc_state.AVG_buff_I] = 0xDD000000 | (Proc_state.AVG_buff_I & 0x00FFFFFF);
Proc_state.AVG_buff_I++;
data_I++;
}
//Proc_state.AVG_buff_I++;
//AVG_buff_A[Proc_state.AVG_buff_I] = 0xDD000000 | (Proc_state.AVG_buff_I & 0x00FFFFFF);
//data_I++;
//Proc_state.AVG_buff_I = 0;
}else{
while((data_I < size )&& (Proc_state.AVG_buff_I < (AVG_BUFF_SIZE - 10))){
//uint32_t word = data[data_I];
AVG_buff_B[Proc_state.AVG_buff_I] = 0xDE000000 | (Proc_state.AVG_buff_I & 0x00FFFFFF);
Proc_state.AVG_buff_I++;
data_I++;
}
// Proc_state.AVG_buff_I++;
// AVG_buff_B[Proc_state.AVG_buff_I] = 0xDD000000 | (Proc_state.AVG_buff_I & 0x00FFFFFF);
}
}
*/
/*/
if (Proc_state.mode == AVG){
uint32_t data_I = 0;
while((data_I < size )&& (TX_buff_I < (TX_BUFF_SIZE - 1))){
// TX_buff[TX_buff_I++] = data[data_I++];
uint32_t word = data[data_I++];
TX_buff[TX_buff_I++] = (word & 0x00FFFFFF);// | 0xDE000000;
//TX_buff[TX_buff_I++] = ((word & 0x00FFFFFF) | 0xDE000000);
//TX_buff[TX_buff_I++] = 0xADEFDEED;
}
}
//*/
//*
// if (Proc_state.mode == AVG){
//TX_buff_I = 10;
/*
uint32_t data_I = 0;
uint8_t new_cycle_started = 0;
uint8_t cycle_cont = 1;
while ((data_I < size) && (Proc_state.AVG_buff_I < AVG_BUFF_SIZE) && cycle_cont ){
uint32_t word = data[data_I];
uint32_t val = word & 0x00FFFFFF;
uint8_t header = (uint8_t)(word >> 24);
*/
/*
if (header == 0x00){
Proc_state.digital_word_prev = Proc_state.digital_word_curr;
Proc_state.digital_word_curr = word;
DY_SYN_2_value_prev = DY_SYN_2_value;
if (word & 0b1 << 17){
DY_SYN_2_value = 1;
}else{
DY_SYN_2_value = 0;
}
if ((DY_SYN_2_value == 1)&& (DY_SYN_2_value_prev == 0)){ //new cycle started
new_cycle_started = 1;
}
}
//*/
/*
if (header == 0xD0){ //it`s first channel
if (new_cycle_started){
new_cycle_started = 0;
++Proc_state.average_N;
if (Proc_state.average_N >= Proc_state.average_N_max){
Proc_state.mode == AVG_DONE;
cycle_cont = 0; //break averaging cycle
Proc_state.AVG_buff_I = 0;
}
}else{
if (Proc_state.AVG_buff_I < AVG_BUFF_SIZE){
AVG_buff[Proc_state.AVG_buff_I] =(word & 0x00FFFFFF);// | 0xDE000000;
//uint32_t tmp = AVG_buff[Proc_state.AVG_buff_I];
//tmp += val;
//tmp &= 0x0FFFFFFF;
//AVG_buff[Proc_state.AVG_buff_I] = tmp | (0x40000000 & 0xF0000000); //set header (first 4 bits) to 0x4 -- average (0x4 -- average)
Proc_state.AVG_buff_I++;
}
}
}
data_I++;
//*/
// AVG_buff[Proc_state.AVG_buff_I] = 0xDDDDDDDD;
//TX_buff[TX_buff_I++] = data[data_I];
//TX_buff[TX_buff_I++] = 0xEEEEEEEE;
// data_I++;
// Proc_state.AVG_buff_I++;
//}
// if (Proc_state.AVG_buff_I == AVG_BUFF_SIZE){
/* if (Proc_state.AVG_buff_I >= 10){
Proc_state.AVG_buff_I = 10;
Proc_state.mode == AVG_DONE;
}
*/
// }
/*
if(Proc_state.mode == AVG_DONE){ //TODO:
if (Proc_state.TX_buff_state == 0){
Proc_state.TX_buff_state = 1; //0 --ready, 1 -- filling, 2 -- ready to send
// Proc_state.AVG_buff_state = 1; //0 -- ready, 1 -- blocked,
uint32_t max_I = TX_BUFF_SIZE;
if (max_I > AVG_BUFF_SIZE){
max_I = AVG_BUFF_SIZE;
}
for (uint32_t I = 0; I < max_I; ++I){
if (TX_buff_I < TX_BUFF_SIZE){
++TX_buff_I;
}
TX_buff[TX_buff_I] = AVG_buff[I];
AVG_buff[I] = 0;
}
Proc_state.TX_buff_state = 2; //0 --ready, 1 -- filling, 2 -- ready to send
}
Proc_state.mode = Proc_state.mode_next;
}
//*/
/*
uint32_t radar_word_I = 0;
//uint32_t TX_buff_I = 0;
uint32_t word_prev = 0;
uint32_t digital_word_prev = 0;
for (int data_I = 0; (data_I < size) && (TX_buff_I < TX_BUFF_SIZE); ++data_I){
uint32_t word = data[data_I];
uint32_t val = word & 0x00FFFFFF;
uint8_t header = (uint8_t)(word >> 24);
//11010000
if (((header & 0b10000000) == 0b10000000)){ //it`s ADC word
if (header == 0XD0){ //phy channel № 1 in common mode
//TX_buff[TX_buff_I++] = ((0b01100000 & LFSM_val_ON) << 24) & val;
TX_buff[TX_buff_I++] = 0xD0ADEFEA;
//TX_buff[TX_buff_I++] = word;
}else if (header == 0xD1){//phy channel № 2 in common mode
TX_buff[TX_buff_I++] = word;
//TX_buff[TX_buff_I++] = ((0b01100000 & LFSM_val_OFF) << 24) & val;
//TX_buff[TX_buff_I++] = 0xD0ADEFEB;
}else{
//TX_buff[TX_buff_I++] = word;
TX_buff[TX_buff_I++] = word;
//TX_buff[TX_buff_I++] = 0xD0AAAAAA;
}
} else if ( header == 0b00000000){ //it`s digital
//if ((word & 0x2200) == 0x2200){
TX_buff[TX_buff_I++] = word;
//TX_buff[TX_buff_I++] = 0xAD000000;
//detect rise on DI_SYN2 -- start of chirp
if (word & 0b1 << 17){
DY_SYN_2_value = 1;
}else{
DY_SYN_2_value = 0;
}
if ((DY_SYN_2_value == 1)&& (DY_SYN_2_value_prev == 0)){
TX_buff[TX_buff_I++] = 0xAD000000;
}
DY_SYN_2_value_prev = DY_SYN_2_value;
digital_word_prev = word;
} else{
// TX_buff[TX_buff_I++] = word;
}
word_prev = word;
// }else if ((header & 0b00000000) == ){
// }else if ((header & 0b00000000) == ){
// }else if ((header & 0b00000000) == ){
// }else if ((header & 0b00000000) == ){
// }else if ((header & 0b00000000) == ){
}
*/
//stream_in_buf_free(size);
/*
//int i = 0;
//uint8_t
//while
for (int i = 0; i < LFSM_DATALEN; ++i){
uint32_t msg;
if (i % 2){
msg = (LFSM_val_ON << 24) + data[i];
}else{
msg = (LFSM_val_OFF << 24) + data[i];
}
LFSM_data[i] = msg;
}
*/
if (hdma_send_req_rdy()) {
//if (1){
//streams_cnt[0]
/*
if (Proc_state.TX_buff_state == 2){
hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
}else if(0){
if (TX_buff_state == TX_BUFF_OFF){
hdma_send_req_start(data, size, 0);
return size;
}else{
hdma_send_req_start(TX_buff, TX_buff_I, 0);
TX_buff_I = 0;
//hdma_send_req_start(data, size, 0);
if (TX_buff_state == TODO_TX){
for (uint32_t i = 0; i < TX_BUFF_SIZE; ++i){
TX_buff_shadow[i] = TX_buff[i];
}
hdma_send_req_start(TX_buff_shadow, TX_buff_I, 0);
//hdma_send_req_start(TX_marker, 10, 0);
//hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
//TX_buff_state = TRANSMITTING;
TX_buff_state = TX_DONE;
//}else{
// hdma_send_req_start(data, size, 0);
}
//hdma_send_req_start(data, size, 0);
//streams_cnt[0] = hdma_send_req_start(LFSM_data, LFSM_DATALEN, 0);
return size_processed;
//return data_I; //number of really processed words
}
*/
/*
if (Proc_state.mode == AVG_DONE){
uint32_t send_size = Proc_state.AVG_buff_I;
// uint32_t send_size = AVG_BUFF_SIZE;
hdma_send_req_start(AVG_buff, send_size, 0);
Proc_state.mode = AVG;
return send_size;
}
//*/
/*
if (Proc_state.mode == AVG){
send_size = Proc_state.AVG_buff_I;
//send_size = TX_buff_I;
//send_size = AVG_BUFF_SIZE - 500;
dbg_receive_value = send_size;
if (Proc_state.AVG_buff_active == A){
hdma_send_req_start(AVG_buff_A, send_size, 0);
Proc_state.AVG_buff_active == B;
}else{
hdma_send_req_start(AVG_buff_B, send_size, 0);
Proc_state.AVG_buff_active = A;
}
return send_size;
}else{
hdma_send_req_start(TX_buff, TX_buff_I, 0);
TX_buff_I_shadow = TX_buff_I;
dbg_receive_value = TX_buff_I;
TX_buff_I = 0;
return TX_buff_I_shadow;
}
*/
if (TX_buff_state == TODO_TX){
for (uint32_t i = 0; i < TX_BUFF_SIZE; ++i){
TX_buff_shadow[i] = TX_buff[i];
}
hdma_send_req_start(TX_buff_shadow, TX_buff_I, 0);
hdma_send_req_start(TX_marker, 10, 0);
// hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
//TX_buff_state = TRANSMITTING;
TX_buff_state = TX_DONE;
//}else{
// hdma_send_req_start(data, size, 0);
}
//hdma_send_req_start(data, size, 0);
//streams_cnt[0] = hdma_send_req_start(LFSM_data, LFSM_DATALEN, 0);
return size;
//return data_I; //number of really processed words
}
//return data_I; //number of really processed words
@ -728,6 +464,8 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
// } t_l502_bf_cmd;
//*
case 0x8001:{ //L502_BF_USR_CMD_CODE_ECHO
@ -805,9 +543,10 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
case 0x8007:{ //start data processing: No dataprocessing. Just copy data to output buffer
TX_buff_I = 0;
TX_buff_state = TX_BUFF_OFF;
Proc_state.mode = TRANSPARENT;
Proc_state.mode_next = TRANSPARENT;
Proc_state.LFSM_state = CYCLE_UNKNOWN;
@ -874,6 +613,39 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
break;
}
case 0x800B:{// SEMITRANSPARENT mode
TX_buff_I = 0;
Proc_state.mode = SEMITRANSPARENT;
Proc_state.mode_next = SEMITRANSPARENT;
Proc_state.LFSM_state = CYCLE_UNKNOWN;
Proc_state.average_N_max = 10;
// Proc_state.average_N_max = cmd->param;
Proc_state.average_N = 1;
Proc_state.TX_buff_I = 0;
Proc_state.TX_buff_state = 0;
Proc_state.AVG_state = 0;
Proc_state.AVG_buff_I = 0;
Proc_state.AVG_buff_state = 0;
Proc_state.FFT_buff_I = 0;
Proc_state.FFT_buff_state = 0;
Proc_state.digital_word_prev = 0;
Proc_state.digital_word_curr = 0;
Proc_state.AVG_buff_active = A;
TX_buff_state = TX_DONE;
for (uint32_t i = 0; i < TX_BUFF_SIZE; ++i){
TX_buff[i] = 0;
}
// l502_cmd_done(cmd-> param, NULL, 0);
l502_cmd_done(TX_buff_I, NULL, 0);
break;
}

3
src/l502_user_process.h
View File

@ -45,6 +45,7 @@ enum cycle_state {
enum hdma_TX_state {
TX_BUFF_OFF,
FILLING,
TODO_TX,
TRANSMITTING,
@ -56,10 +57,12 @@ enum hdma_TX_state {
enum dataprocessor_state {
OFF,
TRANSPARENT,
SEMITRANSPARENT,
AVG,
AVG_DONE,
FFT,
FFT_DONE,
WORK,
};
/*