750 lines
23 KiB
C
750 lines
23 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
|
||
|
||
|
||
|
||
|
||
|
||
//#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 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;
|
||
|
||
|
||
|
||
//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;
|
||
/***************************************************************************//**
|
||
@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];
|
||
/*
|
||
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){
|
||
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 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()) {
|
||
|
||
//streams_cnt[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);
|
||
//streams_cnt[0] = hdma_send_req_start(LFSM_data, LFSM_DATALEN, 0);
|
||
//return size;
|
||
}
|
||
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) {
|
||
++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;
|
||
|
||
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
|
||
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:{ //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
|
||
l502_cmd_done(cmd-> param, NULL, 0);
|
||
break;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
case 0x8010:{ //L502_BF_USR_CMD_CODE_ECHO
|
||
//uint32_t test_res = f_sport_test();
|
||
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);
|
||
}
|
||
|
||
/** @} */
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|