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

implemented transparent mode and simplest AVG mode: no average, identical to transparent

Browse Source
This commit is contained in:
Theodor Chikin
2025-07-22 17:45:22 +03:00
parent 1555adc25b
commit d446e010f8
20 changed files with 9855 additions and 9689 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/l502_stream.c
View File

@ -29,6 +29,9 @@
#include "l502_user_process.h"
volatile uint32_t TX_buff[TX_BUFF_SIZE] __attribute__((section(".sdram_noinit")));
//volatile uint32_t RAW_data_buff[RAW_DATA_BUFF_SIZE] __attribute__((section(".sdram_noinit")));
volatile uint32_t AVG_buff[AVG_BUFF_SIZE] __attribute__((section(".sdram_noinit")));
//volatile uint32_t FFT_buff[FFT_BUFF_SIZE] __attribute__((section(".sdram_noinit")));
/** Размер буфера на прием данных по SPORT0 в 32-битных словах */
@ -99,8 +102,6 @@ static void f_stream_in_set_overflow(void) {
g_stream_in_state = IN_STREAM_OV_ALERT;
}
volatile uint32_t TX_buff[100000] __attribute__((section(".sdram_noinit")));
/** @brief Начальная инициализация параметров для синхронных потоков */

275
src/l502_user_process.c
View File

@ -82,11 +82,35 @@ struct dataprocess_typedef {
*/
//extern volatile uint32_t TX_buff[]; //size: TX_BUFF_SIZE
//extern volatile uint32_t Raw_data_buff[]; //size: RAW_DATA_BUFF_SIZE
extern volatile uint32_t Avg_buff[]; //size: AVG_BUFF_SIZE
extern volatile uint32_t TX_buff[]; //size: TX_BUFF_SIZE
//extern volatile uint32_t RAW_data_buff[]; //size: RAW_DATA_BUFF_SIZE
extern volatile uint32_t AVG_buff[]; //size: AVG_BUFF_SIZE
//extern volatile uint32_t FFT_buff[]; //size: FFT_BUFF_SIZE
volatile struct dataprocessor_dypedef{
uint8_t mode;
uint8_t mode_next;
uint8_t cycle_state;
uint8_t LFSM_state; // 0 -- waiting for it... ; 1 -- receiving LFSM data
uint16_t average_N_max;
uint16_t average_N;
uint32_t TX_buff_I;
uint8_t TX_buff_state; //0 --blocked, 1 -- filling, 2 -- ready to send
uint32_t AVG_buff_I;
uint8_t AVG_buff_state;
uint32_t FFT_buff_I;
uint8_t FFT_buff_state;
uint32_t digital_word_prev;
uint32_t digital_word_curr;
uint8_t DIN2_SYN_value_curr;
uint8_t DIN2_SYN_value_prev;
}Proc_state;
volatile uint32_t TX_buff_I = 0;
volatile uint32_t TX_buff_I_shadow = 123321;
volatile uint32_t data_I = 0;
volatile uint32_t send_size = 0;
@ -139,13 +163,160 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
// dbg_sport_rx_copy[i] = data[i];
//}
//*
//simple transparent mode
if (Proc_state.mode == TRANSPARENT){
data_I = 0;
while((data_I < size )&& (TX_buff_I < TX_BUFF_SIZE)){
TX_buff[TX_buff_I++] = data[data_I++];
}
}
if (Proc_state.mode == AVG){
data_I = 0;
//TX_buff_I = 0;
Proc_state.AVG_buff_I = 0;
while((data_I < size )&& (Proc_state.AVG_buff_I < AVG_BUFF_SIZE)){
//uint32_t word = data[data_I];
//uint32_t avg_word = AVG_buff[Proc_state.AVG_buff_I++];
//AVG_buff[Proc_state.AVG_buff_I] = (avg_word & 0x00FFFFFF) + (word & 0x00FFFFFF);
//AVG_buff[Proc_state.AVG_buff_I++] = data[data_I++];
AVG_buff[Proc_state.AVG_buff_I++] = data[data_I++];
// Proc_state.AVG_buff_I++;
// data_I++;
}
//Proc_state.AVG_buff_I = 0;
}
/*/
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 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;
@ -200,6 +371,7 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
// }else if ((header & 0b00000000) == ){
}
*/
//stream_in_buf_free(size);
@ -223,11 +395,43 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
if (hdma_send_req_rdy()) {
//streams_cnt[0]
hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
/*
if (Proc_state.TX_buff_state == 2){
hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
}else if(0){
}else{
hdma_send_req_start(TX_buff, TX_buff_I, 0);
TX_buff_I = 0;
//hdma_send_req_start(data, size, 0);
}
*/
/*
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;
//uint32_t send_size = AVG_BUFF_SIZE;
hdma_send_req_start(AVG_buff, send_size, 0);
return send_size;
}else{
hdma_send_req_start(TX_buff, TX_buff_I, 0);
TX_buff_I_shadow = TX_buff_I;
TX_buff_I = 0;
return TX_buff_I_shadow;
}
//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 size;
}
return 0;
}
@ -437,16 +641,63 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
case 0x8007:{ //start data processing
l502_cmd_done(cmd-> param, NULL, 0);
case 0x8007:{ //start data processing: No dataprocessing. Just copy data to output buffer
TX_buff_I = 0;
Proc_state.mode = TRANSPARENT;
Proc_state.mode_next = TRANSPARENT;
Proc_state.LFSM_state = 0;
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_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;
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;
}
case 0x8008:{ //get data from SPORT_RX copied arr
l502_cmd_done(cmd-> param, NULL, 0);
TX_buff_I = 0;
Proc_state.mode = AVG;
Proc_state.mode_next = AVG;
Proc_state.LFSM_state = 0;
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_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;
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;
}
case 0x8009:{ //get data from SPORT_RX copied arr
l502_cmd_done(cmd-> param, NULL, 0);
case 0x8009:{ //request TX_buff_I_shadow value (last size of TX_buff transferred to pc )
l502_cmd_done(TX_buff_I_shadow, NULL, 0);
break;
}
case 0x800A:{ //get data from SPORT_RX copied arr

34
src/l502_user_process.h
View File

@ -9,23 +9,35 @@
пользователем для написания своих алгоритмов обработки данных и реализации
пользовательских команд.
******************************************************************************/
#define TX_BUFF_SIZE 100000
#define RAW_DATA_BUFF_SIZE 100000
#define AVG_BUFF_SIZE 100000
#define FFT_BUFF_SIZE 100000
//#define TX_BUFF_SIZE 100000
#define RAW_DATA_BUFF_SIZE 1000
#define AVG_BUFF_SIZE 1000
#define FFT_BUFF_SIZE 1000
//#define L502_SPORT_IN_BUF_SIZE (2048*1024)
//#define TX_BUFF_SIZE (RAW_DATA_BUFF_SIZE + AVG_BUFF_SIZE + FFT_BUFF_SIZE + L502_SPORT_IN_BUF_SIZE) //should be large enough to fit all other buffers and raw data
#define TX_BUFF_SIZE 1000
#ifndef L502_USER_PROCESS_H_
#define L502_USER_PROCESS_H_
enum dataprocessor_state {
OFF,
TRANSPARENT,
AVG,
AVG_DONE,
FFT,
FFT_DONE,
};
struct dataprocessor_dypedef{
uint8_t dataprocessor_state state;
uint8_t dataprocessor_state state_next;
/*
struct dataprocessor_dypedef {
uint8_t state;
uint8_t state_next;
uint8_t LFSM_state; // 0 -- waiting for it... ; 1 -- receiving LFSM data
uint16_t average_N_max;
uint16_t average_N;
@ -34,11 +46,7 @@ struct dataprocessor_dypedef{
uint32_t FFT_buff_I;
};
#ifndef L502_USER_PROCESS_H_
#define L502_USER_PROCESS_H_
*/
uint32_t usr_in_proc_data(uint32_t* data, uint32_t size);