778 lines
25 KiB
C
778 lines
25 KiB
C
/***************************************************************************//**
|
||
@addtogroup user_process
|
||
@{
|
||
@file l502_user_process.c
|
||
|
||
Файл содержит простейший вариант реализации пользовательских функций, в котором
|
||
потоки данных передаются без изменения и никакие пользовательские команды не
|
||
обрабатываются. Пользователь может изменить этот файл и добавить здесь свою
|
||
обработку.
|
||
*******************************************************************************/
|
||
|
||
|
||
|
||
#include "l502_stream.h"
|
||
#include "l502_hdma.h"
|
||
#include "l502_sport_tx.h"
|
||
#include "l502_cmd.h"
|
||
|
||
#include <stdlib.h>
|
||
|
||
#include "l502_defs.h" // import defines of constants
|
||
#include "l502_params.h"
|
||
#include "l502_stream.h"
|
||
#include "l502_user_process.h"
|
||
|
||
|
||
|
||
uint32_t streams_cnt[4] = {0,};
|
||
|
||
|
||
|
||
#define LFSM_val_ON 0b01100111
|
||
#define LFSM_val_OFF 0b01101000
|
||
#define LFSM_val_X 0b01101001
|
||
|
||
//#define TX_BUFF_SIZE 1024*1024
|
||
//#define TX_BUFF_SIZE 1000
|
||
|
||
#define LFSM_BUFF_SIZE 1000
|
||
|
||
#define LFSM_DATALEN 1024
|
||
|
||
#define dbg_sport_rx_copy_size 10
|
||
//#define LFSM_DATALEN 1024
|
||
|
||
|
||
volatile uint32_t dbg_receive_value = 1234321;
|
||
|
||
|
||
//#pragma section("sdram_noinit", NO_INIT)
|
||
//#include "l502_sdram_noinit.h"
|
||
//__attribute__((section(".sdram_noinit"), far))
|
||
//static volatile uint32_t dbg_sport_rx_copy[TX_BUFF_SIZE];
|
||
//uint32_t dbg_sport_rx_copy[TX_BUFF_SIZE];// = {0,};
|
||
uint32_t dbg_sport_rx_copy[dbg_sport_rx_copy_size];// = {0,};
|
||
//*
|
||
|
||
//#include "l502_sdram_noinit.h"
|
||
//static volatile uint32_t LFSM_data[LFSM_DATALEN] = {0,};
|
||
|
||
//#include "l502_sdram_noinit.h"
|
||
//static volatile uint32_t TX_buff[TX_BUFF_SIZE];
|
||
//static volatile uint32_t TX_buff[TX_BUFF_SIZE] __attribute__((section(".sdram_noinit")));
|
||
//static volatile uint32_t TX_buff[10000] __attribute__((section(".sdram_noinit")));
|
||
//static volatile uint32_t TX_buff[10000];
|
||
|
||
//static volatile uint32_t
|
||
|
||
// = {0,};
|
||
|
||
|
||
|
||
uint32_t streams_succes_flag = 0;
|
||
|
||
/*
|
||
struct dataprocess_typedef {
|
||
uint8_t config = 0;
|
||
uint32_t datapoints_max_N = 0;
|
||
uint32_t datapoint_curr_I = 0;
|
||
uint32_t data_raw;
|
||
};
|
||
*/
|
||
|
||
|
||
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 uint64_t FFT_buff[]; //size: FFT_BUFF_SIZE
|
||
|
||
extern volatile int64_t twiddle_re[]; //size: TWIDDLE_L
|
||
extern volatile int64_t twiddle_im[]; //size: TWIDDLE_L
|
||
|
||
|
||
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;
|
||
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;
|
||
uint32_t AVG_buff_I_last;
|
||
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;
|
||
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;
|
||
|
||
volatile uint8_t TX_buff_state = TX_DONE; //FILLING, TODO_TX, TRANSMITTING, TX_DONE, BUFF_READY,
|
||
volatile uint32_t tx_val = 0;
|
||
|
||
uint32_t some_i = 0;
|
||
|
||
volatile uint32_t size_processed = 0;
|
||
|
||
//int f_sport_test(void);
|
||
void l502_stream_init(void);
|
||
|
||
//struct LFSM_typedef{
|
||
// uint8_t
|
||
//};
|
||
|
||
uint8_t LFSM_started = 0;
|
||
|
||
|
||
uint8_t DY_SYN_2_value = 0;
|
||
uint8_t DY_SYN_2_value_prev = 0;
|
||
|
||
|
||
|
||
uint32_t dataprocessor(uint32_t* AVG_buff, uint32_t AVG_buff_I_max, uint64_t* FFT_buff, uint8_t mode){
|
||
uint32_t FFT_buff_I = 0;
|
||
if (mode == TRANSPARENT){
|
||
uint32_t i = 0;
|
||
while ((FFT_buff_I < FFT_BUFF_SIZE) && (i < AVG_BUFF_SIZE)){
|
||
FFT_buff[FFT_buff_I++] = AVG_buff[i++];
|
||
}
|
||
}else if (mode == FFT){
|
||
//uint32_t i = 0;
|
||
//void FFT_fp(int64_t* inp, uint32_t inp_L, int64_t* buf)
|
||
for (uint32_t i = 0; i < FFT_INP_DATA_L; ++i){
|
||
AVG_buff[i] = FP_acc;
|
||
}
|
||
FFT_fp(AVG_buff, FFT_INP_DATA_L, FFT_buff);
|
||
|
||
}else if (mode == FLUSH_TWIDDLES){
|
||
uint32_t i = 0;
|
||
FFT_buff_I = 0;
|
||
while ((FFT_buff_I < FFT_BUFF_SIZE) && (i < TWIDDLE_L)){
|
||
FFT_buff[FFT_buff_I++] = twiddle_re[i++];
|
||
}
|
||
|
||
|
||
}
|
||
|
||
return FFT_buff_I;
|
||
}
|
||
|
||
|
||
/***************************************************************************//**
|
||
@brief Обработка принятого массива данных АЦП/DIN.
|
||
|
||
Функция вызывается каждый раз, когда обнаружены новые данные от
|
||
АЦП/цифровых входов, пришедшие по SPORT0.
|
||
|
||
Функция должна обработать данные и вернуть количество обработанных данных,
|
||
однако эти данные все еще считаются использованными (не могут быть переписаны
|
||
новыми пришедшими данными) до тех пор пока не будет вызвана функция
|
||
stream_in_buf_free()).
|
||
|
||
Если функция вернет значение меньше чем size, то функция будут вызванна при
|
||
следующем проходе еще раз с указателем на необработанные данные.
|
||
|
||
В текущей реализации просто запускается передача данных по HDMA в ПК
|
||
|
||
@param[in] data Указатель на массив с принятыми данными
|
||
@param[in] size Количество принятых данных в 32-битных словах
|
||
@return Функция возвращает количество обработанных данных (от 0 до size).
|
||
На эти данные не будет вызываться повторно usr_in_proc_data(),
|
||
но они считаются еще используемыми
|
||
*******************************************************************************/
|
||
uint32_t usr_in_proc_data(uint32_t* data, uint32_t size) {
|
||
/* если есть свободные дескрипторы на передачу по HDMA - ставим блок на
|
||
передачу. Иначе возвращаем 0, чтобы на обработку этих данных функцию
|
||
вызвали бы позже */
|
||
++streams_cnt[0];
|
||
//*
|
||
size_processed = 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;
|
||
}
|
||
|
||
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){
|
||
data_I = 0;
|
||
TX_buff_I = 0;
|
||
while((data_I + 1 < size )&& (TX_buff_I + 1 < TX_BUFF_SIZE)){
|
||
//;
|
||
TX_buff[TX_buff_I] = data[data_I];
|
||
|
||
TX_buff_I++;
|
||
data_I++;
|
||
}
|
||
size_processed = data_I;
|
||
|
||
TX_buff_state = TODO_TX;
|
||
//tx_val = 0;
|
||
}
|
||
//TX_buff_state = DUMMY;
|
||
|
||
}
|
||
//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];
|
||
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.AVG_buff_I = 0;
|
||
Proc_state.LFSM_state = CYCLE_STARTED;
|
||
if (Proc_state.average_N >= Proc_state.average_N_max){ //whole average ended
|
||
//Proc_state.average_N = 0;
|
||
//if (1){
|
||
Proc_state.AVG_state = FULLY_COMPLETED;
|
||
|
||
|
||
for(uint32_t i = 0; i < FFT_BUFF_SIZE; i++){
|
||
FFT_buff[i] = 0;
|
||
}
|
||
|
||
uint32_t FFT_res_size = dataprocessor(AVG_buff, Proc_state.AVG_buff_I_last, FFT_buff, FFT);
|
||
// uint32_t FFT_res_size = dataprocessor(AVG_buff, Proc_state.AVG_buff_I_last, FFT_buff, FLUSH_TWIDDLES);
|
||
// uint32_t FFT_res_size = dataprocessor(AVG_buff, Proc_state.AVG_buff_I_last, FFT_buff, TRANSPARENT);
|
||
|
||
|
||
|
||
//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++];
|
||
while ((TX_buff_I < TX_BUFF_SIZE) && (i < FFT_BUFF_SIZE)){
|
||
TX_buff[TX_buff_I++] = 0xFF000000 | ((uint32_t)FFT_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] = 0xE0000000;
|
||
}
|
||
|
||
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;
|
||
Proc_state.average_N = 0;
|
||
|
||
//hdma_send_req_start(TX_buff, TX_buff_I, 0);
|
||
//return data_I;
|
||
|
||
}else{ //
|
||
Proc_state.AVG_state = STEP_RUNNING;
|
||
Proc_state.average_N ++;
|
||
//Proc_state.AVG_buff_I = 0;
|
||
}
|
||
}
|
||
|
||
}else if(header == 0xD0){ //first phy channel
|
||
if (Proc_state.AVG_state == STEP_RUNNING){
|
||
// if (1){
|
||
// if (Proc_state.LFSM_state == CYCLE_STARTED){
|
||
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/Proc_state.average_N_max + AVG_buff[Proc_state.AVG_buff_I]) & 0xFFFFFF);
|
||
// AVG_buff[Proc_state.AVG_buff_I] = 0xC0000000 | some_i++;
|
||
// AVG_buff[Proc_state.AVG_buff_I] = 0xC0000000 | val;
|
||
//AVG_buff[Proc_state.AVG_buff_I++] = 0xC0000000;
|
||
Proc_state.AVG_buff_I_last = Proc_state.AVG_buff_I;
|
||
Proc_state.AVG_buff_I++;
|
||
if (Proc_state.AVG_buff_I >= AVG_BUFF_SIZE){
|
||
Proc_state.AVG_state = STEP_COMPLETED;
|
||
}
|
||
}
|
||
}
|
||
}else{
|
||
//AVG_buff[Proc_state.AVG_buff_I] = 0xC1000000;
|
||
Proc_state.AVG_buff_I_last = Proc_state.AVG_buff_I;
|
||
Proc_state.AVG_buff_I++;
|
||
if (Proc_state.AVG_buff_I >= AVG_BUFF_SIZE){
|
||
Proc_state.AVG_state = STEP_COMPLETED;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//*/
|
||
|
||
|
||
if (hdma_send_req_rdy()) {
|
||
//if (1){
|
||
|
||
|
||
|
||
if (TX_buff_state == TX_BUFF_OFF){
|
||
hdma_send_req_start(data, size, 0);
|
||
return size;
|
||
}else{
|
||
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
|
||
|
||
|
||
}
|
||
}
|
||
//return data_I; //number of really processed words
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/***************************************************************************//**
|
||
@brief Обработка принятого массива с данными ЦАП/DOUT
|
||
|
||
Функция вызывается каждый раз, когда обнаружены новые данные, принятые от
|
||
ПК по HDMA.
|
||
Функция должна обработать данные и вернуть количество обработанных данных,
|
||
однако эти данные все еще считаются использованными (не могут быть переписаны
|
||
новыми пришедшими данными) до тех пор пока не будет вызвана функция
|
||
stream_out_buf_free()).
|
||
|
||
Если функция вернет значение меньше чем size, то функция будут
|
||
вызвана после еще раз с указателем на необработанные данные.
|
||
|
||
В текущей реализации просто запускается передача данных по SPORT
|
||
для вывода на ЦАП/цифровые выходы.
|
||
|
||
@param[in] data Указатель на массив с принятыми данными
|
||
@param[in] size Количество принятых данных в 32-битных словах
|
||
@return Функция возвращает количество обработанных данных (от 0 до size).
|
||
На эти данные не будет вызываться повторно usr_out_proc_data(),
|
||
но они считаются еще используемыми
|
||
******************************************************************************/
|
||
uint32_t usr_out_proc_data(uint32_t* data, uint32_t size) {
|
||
|
||
/* если есть свободные дескрипторы на передачу по HDMA - ставим блок на
|
||
передачу. Иначе возвращаем 0, чтобы на обработку этих данных функцию
|
||
вызвали бы позже */
|
||
++streams_cnt[2];
|
||
|
||
if (sport_tx_req_rdy()) {
|
||
|
||
/* за один раз можем передать в SPORT не более
|
||
SPORT_TX_REQ_SIZE_MAX слов */
|
||
if (size > SPORT_TX_REQ_SIZE_MAX)
|
||
size = SPORT_TX_REQ_SIZE_MAX;
|
||
|
||
sport_tx_start_req(data, size);
|
||
|
||
return size;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/****************************************************************************//**
|
||
@brief Обработка завершения передачи по HostDMA
|
||
|
||
Функция вызывается из обработчика прерывания, когда завершилась передача
|
||
блока данных по HDMA в ПК, поставленного до этого на передачу с
|
||
помощью hdma_send_req_start().
|
||
|
||
@param[in] addr Адрес слова, сразу за последним переданным словом
|
||
@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);
|
||
}
|
||
|
||
|
||
|
||
/***************************************************************************//**
|
||
@brief Обработка завершения передачи по SPORT
|
||
|
||
Функция вызывается из обработчика прерывания при завершении передачи блока данных
|
||
по SPORT'у на цифровые выходы/ЦАП, поставленного до этого на передачу с
|
||
помощью sport_tx_start_req().
|
||
|
||
|
||
@param[in] addr Адрес слова, сразу за последним переданным словом
|
||
@param[in] size Размер переданных данных в 32-битных словах */
|
||
void sport_tx_done(uint32_t* addr, uint32_t size) {
|
||
++streams_cnt[1];
|
||
|
||
stream_out_buf_free(size);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/****************************************************************************//**
|
||
@brief Обработка пользовательских команд.
|
||
|
||
Функция вызывается при приеме команды от ПК с кодом большим или равным
|
||
#L502_BF_CMD_CODE_USER.
|
||
|
||
По завершению обработки необходимо обязательно вызвать
|
||
l502_cmd_done(), указав код завершения команды и
|
||
при необходимости передать данные с результатом
|
||
|
||
@param[in] cmd Структура с описанием принятой команды
|
||
******************************************************************************/
|
||
|
||
|
||
void usr_cmd_process(t_l502_bf_cmd *cmd) {
|
||
switch (cmd->code){
|
||
|
||
|
||
/*
|
||
Command template
|
||
case 0x800?:{
|
||
|
||
l502_cmd_done(rcv_code, rcv_data, rcv_data_length); //void l502_cmd_done (int32_t result, uint32_t *data, uint32_t size)
|
||
break;
|
||
}
|
||
*/
|
||
// typedef struct {
|
||
// uint16_t code; /**< Код команды из #t_l502_bf_cmd_code */
|
||
// uint16_t status; /**< Статус выполнения - в обработчике не изменяется */
|
||
// uint32_t param; /**< Параметр команды */
|
||
// int32_t result; /**< Код результата выполнения команды */
|
||
// uint32_t data_size; /**< Количество данных, переданных с командой или возвращенных с ответом в 32-битных словах */
|
||
// uint32_t data[L502_BF_CMD_DATA_SIZE_MAX]; /**< Данные, передаваемые с командой и/или в качестве результата */
|
||
// } t_l502_bf_cmd;
|
||
|
||
|
||
//*
|
||
|
||
|
||
|
||
case 0x8001:{ //L502_BF_USR_CMD_CODE_ECHO
|
||
l502_cmd_done(cmd-> param, NULL, 0);
|
||
break;
|
||
}
|
||
|
||
case 0x8002:{ //L502_BF_USR_CMD_CODE_DATA_ECHO
|
||
uint32_t rcv_data[cmd->data_size];
|
||
for (uint32_t I = 0; I < (cmd -> data_size); ++I){
|
||
//rcv_data[I] = (cmd-> data)[I];
|
||
rcv_data[I] = I;
|
||
}
|
||
l502_cmd_done(cmd-> param, rcv_data, cmd->data_size);
|
||
break;
|
||
}
|
||
case 0x8003:{ //configure ADC
|
||
uint32_t err_codes[15] = {0,};
|
||
err_codes[0] = params_set_lch_cnt(1);
|
||
//err_codes[1] = params_set_lch(1, 1, L502_LCH_MODE_COMM, L502_ADC_RANGE_5, 1, 0);// chan index 1, chan 1, mode L502_LCH_MODE_COMM (=1),range L502_ADC_RANGE_5 (=1), avg, flags
|
||
err_codes[1] = params_set_lch(0, 0, L502_LCH_MODE_COMM, L502_ADC_RANGE_5, 1, 0);// chan index 1, chan 1, mode L502_LCH_MODE_COMM (=1),range L502_ADC_RANGE_5 (=1), avg, flags
|
||
err_codes[2] = params_set_adc_freq_div(1);
|
||
err_codes[3] = params_set_ref_freq(2000000);
|
||
err_codes[4] = params_set_adc_interframe_delay(0);
|
||
err_codes[5] = params_set_sync_mode (L502_SYNC_INTERNAL);
|
||
err_codes[6] = params_set_sync_start_mode (L502_SYNC_INTERNAL);
|
||
//err_codes[7] = params_set_din_freq_div;
|
||
//err_codes[8] = params_set_dac_freq_div;
|
||
|
||
err_codes[9] = sport_in_set_step_size(1024);
|
||
|
||
//L502_BF_PARAM_ADC_COEF
|
||
//err_codes[10] = fpga_reg_write(f_regaddr_k[range], ??);
|
||
//err_codes[11] = fpga_reg_write(f_regaddr_offs[range], ??);
|
||
err_codes[12] = configure();
|
||
|
||
|
||
|
||
|
||
uint32_t err_codes_sum = 0;
|
||
for (int i = 0; i < 15; ++i){
|
||
err_codes_sum += err_codes[i];
|
||
}
|
||
l502_cmd_done(err_codes_sum, err_codes, 15);
|
||
break;
|
||
}
|
||
case 0x8004:{ //start streams
|
||
uint32_t err_codes[5] = {0,};
|
||
l502_stream_init();
|
||
err_codes[0] = stream_enable(L502_STREAM_ADC | L502_STREAM_DIN); //bitmask
|
||
err_codes[1] = stream_out_preload();
|
||
err_codes[2] = streams_start();
|
||
//hdma_send_start();
|
||
l502_cmd_done(0, err_codes, 5);
|
||
break;
|
||
}
|
||
case 0x8005:{ //get some data from adc buff. Or simple flag, raised inside usr_in_proc_data()
|
||
|
||
uint32_t streams_sum = streams_cnt[0] + streams_cnt[1] + streams_cnt[2] + streams_cnt[3];
|
||
l502_cmd_done(streams_sum, streams_cnt, 4);
|
||
break;
|
||
}
|
||
|
||
case 0x8006:{ //get data from SPORT_RX copied arr
|
||
uint32_t sport_rx_nonzero_sum = 0;
|
||
|
||
for (int i = 0; i < dbg_sport_rx_copy_size; ++i){
|
||
if (dbg_sport_rx_copy[i]){
|
||
++sport_rx_nonzero_sum;
|
||
}
|
||
}
|
||
l502_cmd_done(sport_rx_nonzero_sum, dbg_sport_rx_copy, 1024);
|
||
break;
|
||
}
|
||
|
||
|
||
|
||
|
||
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;
|
||
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;
|
||
}
|
||
case 0x8008:{ //AVG mode
|
||
TX_buff_I = 0;
|
||
|
||
Proc_state.mode = AVG;
|
||
Proc_state.mode_next = AVG;
|
||
Proc_state.LFSM_state = CYCLE_UNKNOWN;
|
||
Proc_state.average_N_max = 1;
|
||
// Proc_state.average_N_max = cmd->param;
|
||
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;
|
||
}
|
||
|
||
// l502_cmd_done(cmd-> param, NULL, 0);
|
||
l502_cmd_done(TX_buff_I, NULL, 0);
|
||
|
||
break;
|
||
}
|
||
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:{ //return uint32_t value stored in dbg_receive_value
|
||
l502_cmd_done(dbg_receive_value, NULL, 0);
|
||
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;
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
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;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
case 0x8002:{
|
||
cmd-> result = cmd->param * 2;
|
||
uint32_t data[] = {0,1,2,3,4,5,6,5,4,3,2,1,0};
|
||
l502_cmd_done(cmd-> param*3, data, 13);
|
||
break;}
|
||
case 0x8001:{
|
||
//cmd-> result = cmd->param * 2;
|
||
uint32_t data[] = {6,5,4,3,2,1,0,1,2,3,4,5,6};
|
||
l502_cmd_done(cmd-> param*75, data, 13);
|
||
break;}
|
||
*/
|
||
|
||
default: {
|
||
l502_cmd_done(1, NULL, 0);
|
||
}
|
||
}
|
||
//l502_cmd_done(1, 1, 1);
|
||
//l502_cmd_done(L502_BF_ERR_UNSUP_CMD, NULL, 0);
|
||
}
|
||
|
||
/** @} */
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|