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

fixed transmitting to PC via HDMA. Clue: copy data to shadow array and check if it was sent via hdma_send_done()

Browse Source
This commit is contained in:
Theodor Chikin
2025-08-13 18:27:27 +03:00
parent 9213985c9c
commit 99cc783f82
10 changed files with 10644 additions and 9124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/l502_stream.c
View File

@ -29,8 +29,11 @@
#include "l502_user_process.h"
volatile uint32_t TX_buff[TX_BUFF_SIZE] __attribute__((section(".sdram_noinit")));
volatile uint32_t TX_buff_shadow[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 AVG_buff_B[AVG_BUFF_SIZE] __attribute__((section(".sdram_noinit")));
//volatile uint32_t FFT_buff[FFT_BUFF_SIZE] __attribute__((section(".sdram_noinit")));

247
src/l502_user_process.c
View File

@ -44,7 +44,7 @@ uint32_t streams_cnt[4] = {0,};
//#define LFSM_DATALEN 1024
volatile uint32_t dbg_receive_value = 1234321;
//#pragma section("sdram_noinit", NO_INIT)
@ -83,10 +83,15 @@ struct dataprocess_typedef {
extern volatile uint32_t TX_buff[]; //size: TX_BUFF_SIZE
extern volatile uint32_t TX_buff_shadow[]; //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 AVG_buff_B[]; //size: AVG_BUFF_SIZE
//extern volatile uint32_t FFT_buff[]; //size: FFT_BUFF_SIZE
volatile uint32_t TX_marker[10] = {0xFE00000F,0xFE0000F0, 0xFE000F00, 0xFE00F000, 0xFE0F0000,0xFEF00000, 0xFE0F0000,0xFE00F000, 0xFE000F00, 0xFE0000F0};
volatile struct dataprocessor_dypedef{
uint8_t mode;
uint8_t mode_next;
@ -97,7 +102,9 @@ volatile struct dataprocessor_dypedef{
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_state;
uint8_t AVG_buff_state;
uint8_t AVG_buff_active;
uint32_t FFT_buff_I;
uint8_t FFT_buff_state;
uint32_t digital_word_prev;
@ -112,7 +119,8 @@ volatile uint32_t TX_buff_I_shadow = 123321;
volatile uint32_t data_I = 0;
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;
//int f_sport_test(void);
void l502_stream_init(void);
@ -153,6 +161,18 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
передачу. Иначе возвращаем 0, чтобы на обработку этих данных функцию
вызвали бы позже */
++streams_cnt[0];
//clear TX_buff
if (TX_buff_state == TX_DONE){
for (int i = 0; i < TX_BUFF_SIZE; ++i){
//TX_buff[i] = 0x00000123;
TX_buff[i] = tx_val++ | 0xEE000000;
//TX_buff[i] = size;
}
TX_buff_state = FILLING;
}
/*
for (int i = 0; i < TX_BUFF_SIZE; ++i){
TX_buff[i] = 0x00000000;
@ -168,30 +188,141 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
//*
//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++];
//++Proc_state.average_N;
if (TX_buff_state == FILLING){
data_I = 0;
TX_buff_I = 0;
while((++data_I < size )&& (++TX_buff_I < TX_BUFF_SIZE)){
//;
TX_buff[TX_buff_I] = data[data_I];
}
TX_buff_state = TODO_TX;
//tx_val = 0;
}
//TX_buff_state = DUMMY;
}
//TX_buff_I = TX_BUFF_SIZE;
if (Proc_state.mode == AVG){
while(++data_I < size ){
uint32_t word = data[data_I];
uint32_t val = word & 0x00FFFFFF;
uint8_t header = (uint8_t)(word >> 24);
if (header == 0x00){ //digital_channel. switches LFSM state machine
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
//data[data_I] = 0xB00000000;
Proc_state.average_N ++;
Proc_state.AVG_buff_I = 0;
Proc_state.LFSM_state = CYCLE_STARTED;
//if (Proc_state.average_N >= Proc_state.average_N_max){ //whole average ended
if (1){
Proc_state.AVG_state = FULLY_COMPLETED;
//averaging completed => copy average results to TX_buff and start avg again
TX_buff_I = 0;
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++] = 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);
// hdma_send_req_start(TX_buff, TX_BUFF_SIZE, 0);
//TX_buff_state = TRANSMITTING;
TX_buff_state = TX_DONE;
}else{ //
Proc_state.AVG_state = STEP_RUNNING;
Proc_state.AVG_buff_I = 0;
}
}
}else if(header == 0xD0){ //first phy channel
// if (Proc_state.AVG_state == STEP_RUNNING){
// if (Proc_state.LFSM_state == CYCLE_STARTED){
if (1){
if (1){
// AVG_buff[Proc_state.AVG_buff_I++] = 0xC0000000 | (0x00FFFFFF & (AVG_buff[Proc_state.AVG_buff_I] + val));
AVG_buff[Proc_state.AVG_buff_I++] = 0xC0000000 | val;
//AVG_buff[Proc_state.AVG_buff_I++] = 0xC0000000;
if (Proc_state.AVG_buff_I >= AVG_BUFF_SIZE){
Proc_state.AVG_state = STEP_COMPLETED;
}
}
}
}
}
}
/*
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++;
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);
}
//Proc_state.AVG_buff_I = 0;
}
*/
/*/
@ -417,22 +548,51 @@ uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
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);
//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 size;
//return data_I; //number of really processed words
}
//return data_I; //number of really processed words
return 0;
}
@ -497,6 +657,8 @@ uint32_t usr_out_proc_data(uint32_t* data, uint32_t size) {
@param[in] size Размер переданных данных в 32-битных словах
****************************************************************************/
void hdma_send_done(uint32_t* addr, uint32_t size) {
TX_buff_state = TX_DONE;
++streams_cnt[3];
stream_in_buf_free(size);
@ -646,18 +808,21 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
Proc_state.mode = TRANSPARENT;
Proc_state.mode_next = TRANSPARENT;
Proc_state.LFSM_state = 0;
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){
@ -668,24 +833,26 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
l502_cmd_done(TX_buff_I, NULL, 0);
break;
}
case 0x8008:{ //get data from SPORT_RX copied arr
case 0x8008:{ //AVG mode
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.LFSM_state = CYCLE_UNKNOWN;
Proc_state.average_N_max = 3;
// Proc_state.average_N_max = cmd->param;
Proc_state.average_N = 1;
Proc_state.average_N = 0;
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;
@ -700,8 +867,8 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
l502_cmd_done(TX_buff_I_shadow, NULL, 0);
break;
}
case 0x800A:{ //get data from SPORT_RX copied arr
l502_cmd_done(cmd-> param, NULL, 0);
case 0x800A:{ //return uint32_t value stored in dbg_receive_value
l502_cmd_done(dbg_receive_value, NULL, 0);
break;
}
@ -709,8 +876,30 @@ void usr_cmd_process(t_l502_bf_cmd *cmd) {
case 0x8010:{ //L502_BF_USR_CMD_CODE_ECHO
//uint32_t test_res = f_sport_test();
case 0x8010:{ //flush HDMA TX buffer
int number_of_free_tx_descriptors = hdma_send_req_rdy();
hdma_send_stop();
hdma_send_start();
l502_cmd_done(number_of_free_tx_descriptors, NULL, 0);
break;
}
case 0x8011:{ //L502_BF_USR_CMD_CODE_ECHO
l502_cmd_done(cmd-> param, NULL, 0);
break;
}
case 0x8012:{ //L502_BF_USR_CMD_CODE_ECHO
l502_cmd_done(cmd-> param, NULL, 0);
break;
}
case 0x8013:{ //L502_BF_USR_CMD_CODE_ECHO
l502_cmd_done(cmd-> param, NULL, 0);
break;
}
case 0x8014:{ //L502_BF_USR_CMD_CODE_ECHO
l502_cmd_done(cmd-> param, NULL, 0);
break;
}
case 0x8015:{ //L502_BF_USR_CMD_CODE_ECHO
l502_cmd_done(cmd-> param, NULL, 0);
break;
}

30
src/l502_user_process.h
View File

@ -17,13 +17,41 @@
//#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
#define TX_BUFF_SIZE 10000
#ifndef L502_USER_PROCESS_H_
#define L502_USER_PROCESS_H_
enum buff_switch{
A = 0,
B = 1,
};
enum avg_state {
STOPPED,
STEP_RUNNING,
STEP_COMPLETED,
FULLY_COMPLETED,
ENDED,
};
enum cycle_state {
CYCLE_UNKNOWN,
CYCLE_STARTED,
CYCLE_RUNNING,
};
enum hdma_TX_state {
FILLING,
TODO_TX,
TRANSMITTING,
TX_DONE,
BUFF_READY,
DUMMY,
};
enum dataprocessor_state {
OFF,