MARVEL/hpw421
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

hpw421初始版本

Browse Source
This commit is contained in:
xushaoxiang
2026-06-06 16:49:48 +08:00
commit 2339bbfd1f
3283 changed files with 860261 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
project/example/driver/adc_channel_hw/app/src/adc.c
+187
View File
@@ -0,0 +1,187 @@
/*!
* \file adc.c
*
* \brief Target adc implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "adc.h"
#include "xc_drv_adc.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
uint8_t adc_ch_buff[1000];
uint32_t adc_val_buff[500];
uint16_t adc_con = 0;
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
* @brief adc_channel_hw_demo
* @details
* @param void
* @retval void
*/
void adc_channelswitch_hw_demo(void)
{
DEBUG("ADC channelswitch hw demo\n");
uint32_t val;
uint16_t integer;
uint16_t decimal;
ADC_InitCfg_t adc_cfg;
ADC_FIFO_TypeDef_t *fifo_val = NULL;
uint8_t timer0_cnt;
uint16_t timer1_cnt;
delay_ms(500);
// Prevent GPIO6 from being connected to the op amp,
// causing GADC\pull-up invalidation problem
cpr_opa_ctrl_reg__pdbias__setf(DISABLE);
GPIO_InitCfg_t GPIO_InitCfg = {0};
GPIO_InitCfg.Mux = GPIO_Mux0;
GPIO_InitCfg.FunSel = GPIO_Dx;
GPIO_InitCfg.Pull = GPIO_NOPULL;
// Board Led1 Initialization
GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
GPIO_InitCfg.Int = NOT_INT;
GPIO_InitCfg.Pin = GPIO_20;
xc_gpio_init(&GPIO_InitCfg);
GPIO_InitCfg.Pin = GPIO_18;
xc_gpio_init(&GPIO_InitCfg);
GPIO_InitCfg.Pin = GPIO_19;
xc_gpio_init(&GPIO_InitCfg);
GPIO_InitCfg.Pin = GPIO_0;
xc_gpio_init(&GPIO_InitCfg);
xc_gpio_fun_sel(GPIO_3, UART0_TX); // 更换打印口
xc_gpio_fun_sel(GPIO_2, UART0_RX);
adc_cfg.Freq = ADC_FREQ_8M;
adc_cfg.RefVol = ADC_REF_VOL_3_3V;
adc_cfg.SampEdge = ADC_SAMPEDGE_RISE;
adc_cfg.ExtDataMode = ADC_EXT_DATA_MODE_32BIT;
adc_cfg.ExtEdgeSel = ADC_EXT_EDGE_SEL_INTER;
adc_cfg.ExtSampleNum = ADC_EXT_SAMPLE_NUM_4;
adc_cfg.ExtTriggerSel = ADC_EXT_TRIGGER_SEL_PWM0;
xc_adc_init(&adc_cfg);
timer1_cnt = 31;
timer0_cnt = 1;
xc_adc_wait_time_set(timer0_cnt, timer1_cnt);
(*(volatile uint32_t *)(0x40018000)) &= ~((uint32_t)0xf<<16);
(*(volatile uint32_t *)(0x40018000)) |= ((uint32_t)0x3<<16);
(*(volatile uint32_t *)(0x40018000)) |= ((uint32_t)0xf<<20);
(*(volatile uint32_t *)(0x40018028)) = 0x12340000;
(*(volatile uint32_t *)(0x4001802C)) = 0x00000000;
xc_adc_ch_auto_set(ADC_CHAN_CTL_CHAN_1_SET | ADC_CHAN_CTL_CHAN_2_SET |
ADC_CHAN_CTL_CHAN_3_SET | ADC_CHAN_CTL_CHAN_4_SET);
xc_adc_ch_auto_enable();
xc_adc_enable_it(ADC_INT_READ_REQ_INT_SET |ADC_INT_FIFO_ERROR_INT_SET );
NVIC_EnableIRQ(GADC_IRQn);
xc_adc_fifo_req_len_set(ADC_FIFO_CTL_READ_REQ_THRESH_LEN_8);
xc_adc_fifo_flush();
xc_adc_it_set(adc_int_get());
xc_adc_enable();
while (1) {
if (adc_con >= 500 && adc_con != 0xffff) {
fifo_val = (ADC_FIFO_TypeDef_t *)&val;
for (uint16_t i = 0; i < 500; i++) {
val = adc_val_buff[i];
integer = ((uint32_t)(fifo_val->value_1) * (3.3 * 100)) /
(1.0 * 4095) / 100;
decimal =
((uint32_t)((fifo_val->value_1 * (3.3 * 100)) / 4095) %
100);
DEBUG("i_dex1: %4d ch : %d val: %d adc_vol=%d.%02dV\n", i,
fifo_val->chanel_1, fifo_val->value_1, integer, decimal);
integer = ((uint32_t)(fifo_val->value_2) * (3.3 * 100)) /
(1.0 * 4095) / 100;
decimal =
((uint32_t)((fifo_val->value_2 * (3.3 * 100)) / 4095) %
100);
DEBUG("i_dex2: %4d ch : %d val: %d adc_vol=%d.%02dV\n", i,
fifo_val->chanel_2, fifo_val->value_2, integer, decimal);
if ((i % 2))
DEBUG("\r\n\r\n");
}
adc_con = 0xffff;
}
}
}
__RAM_CODE void ADC_channelswitch_hw_Intr_Callback(void)
{
uint32_t adc_int;
adc_int = xc_adc_it_get();
if (!(adc_int & (ADC_INT_FIFO_ERROR_INT_SET | ADC_INT_READ_REQ_INT_SET))) {
return;
}
if (adc_con >= 500) {
xc_adc_it_set(xc_adc_it_get());
return;
}
xc_adc_it_set(xc_adc_it_get());
for (int t = 0; t < ADC_FIFO_CTL_READ_REQ_THRESH_LEN_2; t++) {
adc_val_buff[adc_con] = xc_adc_data_get();
adc_con++;
}
}
__RAM_CODE void adc_intr_callback(void)
{
ADC_channelswitch_hw_Intr_Callback();
}
project/example/driver/adc_channel_hw/app/src/main.c
+110
View File
@@ -0,0 +1,110 @@
/*!
* \file main.c
*
* \brief Target main implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "main.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
void app_uart_init(void)
{
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux0;
gpio_cfg.Pull = GPIO_PULLUP;
gpio_cfg.Int = NOT_INT;
gpio_cfg.FunSel = UART0_TX;
gpio_cfg.Pin = GPIO_18;
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
xc_gpio_init(&gpio_cfg);
gpio_cfg.FunSel = UART0_RX;
gpio_cfg.Pin = GPIO_19;
gpio_cfg.Dir = GPIO_DIR_INPUT;
xc_gpio_init(&gpio_cfg);
UART_InitCfg_t uart_cfg = {0};
uart_cfg.Parity = UART_PARITY_DISABLE;
uart_cfg.StopBits = UART_STOP_1_BITS;
uart_cfg.WordLength = UART_DATA_8_BITS;
uart_cfg.BaudRate = UART_BAUDRATE_115200;
uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;
xc_uart_init(UART0_IDX, &uart_cfg);
}
void clock_init(void)
{
CLOCK_InitCfg_t clock_cfg;
clock_cfg.hfclk_src = CLOCK_HFCLK_SRC_XTAL;
clock_cfg.hfclk_in = CLOCK_HFCLK_IN_32M;
clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_RC;
if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_XTAL) {
clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32768;
} else if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_RC) {
clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32K;
}
xc_clock_init_cfg(&clock_cfg);
SysTick_Config(xc_clock_hfclk_in_get() / 100);
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
}
int main(void)
{
// Clock Initialization
clock_init();
app_uart_init();
DEBUG("__START__\n");
/*----- adc channelswitch hw Demo ----- */
adc_channelswitch_hw_demo();
while (1) {
/* main loop */
;
}
}
project/example/driver/adc_channel_hw/app/src/pga_adc.c
+613
View File
@@ -0,0 +1,613 @@
/*!
* \file pga_adc.c
*
* \brief Target pga adc implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "pga_adc.h"
#include "adc.h"
#include "ringbuffer.h"
#include "xc6xxx_hal_adc.h"
#include "xc6xxx_hal_uart.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define USER_NOISE_EN 0
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
Mic_sampling_cb m_sampling_cb;
extern void UART_SendByte(UART_TypeDef* UARTx, uint8_t Byte);
extern uint8_t adc_ch_buff[1000];
extern uint32_t adc_val_buff[500];
extern uint16_t adc_con;
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
* @return[out]
*
****************************************************************************************
*/
void adc_uart_init(void)
{
// uint8_t rxbuff[26];
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux0;
gpio_cfg.Pull = GPIO_PULLUP;
gpio_cfg.Int = NOT_INT;
gpio_cfg.Pin = GPIO_3;
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
gpio_cfg.FunSel = UART1_TX;
xc_gpio_init(&gpio_cfg);
gpio_cfg.Pin = GPIO_2;
gpio_cfg.Dir = GPIO_DIR_INPUT;
gpio_cfg.FunSel = UART1_RX;
xc_gpio_init(&gpio_cfg);
UART_InitCfg_t uart_cfg = {0};
uart_cfg.Parity = UART_PARITY_DISABLE;
uart_cfg.StopBits = UART_STOP_1_BITS;
uart_cfg.WordLength = UART_DATA_8_BITS;
uart_cfg.BaudRate = UART_BAUDRATE_1M;
uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;
xc_uart_init(XC_UART1, &uart_cfg);
UART_Enable_RxIT(XC_UART1);
NVIC_EnableIRQ(UART1_IRQn);
}
void uart_seed_data(uint8_t data) { UART_SendByte(XC_UART1, data); }
void uart_seed_buff(uint8_t *Data, uint16_t len)
{
UART_SendData(XC_UART1, Data, len);
}
// extern unsigned int filter_data(unsigned int data);
// 对采样到的ADC值进行处理
void pga_adc_rx_event_handler(uint16_t pga_adc_val)
{
#if USER_NOISE_EN
static uint8_t delay_con = 0;
static uint32_t voice_data_bk = 0;
#endif
static uint8_t freq_con = 0;
short voice_data = 0;
freq_con++;
if (freq_con < m_sampling_cb.freq_con)
return;
freq_con = 0;
#if SAMPLING_DEBUG
if (m_sampling_cb.rx_flag)
return;
m_sampling_cb.pga_adc_rx_con++;
#endif
#if REC_TEST_EN || SAMPLING_DEBUG
if (!m_sampling_cb.rec_len_time) {
#if SAMPLING_DEBUG
m_sampling_cb.rx_flag = 1;
#endif //SAMPLING_DEBUG
return;
}
#endif // REC_TEST_EN || SAMPLING_DEBUG
// voice_data = pga_adc_val;
// if (pga_adc_val > 50) pga_adc_val = pga_adc_val - 50;//平移
voice_data = pga_adc_val;
#if USER_NOISE_EN
if (pga_adc_val > 2100 || pga_adc_val < 1900) {
delay_con = 0;
} else {
delay_con++;
if (delay_con >= 50) {
delay_con = 50;
pga_adc_val = (voice_data_bk + pga_adc_val) / 2;
pga_adc_val = 1024 + pga_adc_val / 2;
}
}
voice_data_bk = voice_data = pga_adc_val;
#endif //USER_NOISE_EN
if (voice_data > 2047) {
voice_data = (((uint32_t)voice_data - 2047) * 0x7fff / 2048);
voice_data &= ~0x8000;
} else {
voice_data = (((uint32_t)2047 - voice_data) * 0x7fff / 2048);
voice_data = 0x7fff - voice_data;
voice_data |= 0x8000;
}
m_sampling_cb.mic_adc_buff[m_sampling_cb.save_buf_index]
[m_sampling_cb.pga_adc_rx_index] = voice_data;
m_sampling_cb.pga_adc_rx_index++;
if (m_sampling_cb.pga_adc_rx_index >= MIC_SAMPLING_MAX_LEN) {
m_sampling_cb.pga_adc_rx_index = 0;
m_sampling_cb.save_buf_index = !m_sampling_cb.save_buf_index;
m_sampling_cb.buf_full_flag = 1;
}
}
#if (USE_XIP == 1)
/**
* @brief mic_pga_adc_sampling_set
* @details
* @param void
* @retval void
*/
void mic_pga_adc_sampling_set(void)
{
CLOCK_HighFreq_In_Typedef uclock_freq = CLOCK_HighFreq_Get();
#if (SAMPLING_TYPE == MIC_SAMPLING_8K)
#if (ADC_FREQ_CLOCK == ADC_CLK_DIV_2)
if (uclock_freq == CLOCK_HFCLK_IN_96M) {
m_sampling_cb.freq_con = 32;
} else if (uclock_freq == CLOCK_HFCLK_IN_64M) {
m_sampling_cb.freq_con = 24;
} else {
m_sampling_cb.freq_con = 19;
}
#else
//===========ADC时钟为2/4M的时候
if (uclock_freq == CLOCK_HFCLK_IN_96M) {
m_sampling_cb.freq_con = 32;
} else if (uclock_freq == CLOCK_HFCLK_IN_64M) {
m_sampling_cb.freq_con = 21;
} else {
m_sampling_cb.freq_con = 15;
}
#endif //(ADC_FREQ_CLOCK == ADC_CLK_DIV_2)
#else // 16k采样
#if (ADC_FREQ_CLOCK == ADC_CLK_DIV_2)
if (uclock_freq == CLOCK_HFCLK_IN_96M) {
m_sampling_cb.freq_con = 18;
} else if (uclock_freq == CLOCK_HFCLK_IN_64M) {
m_sampling_cb.freq_con = 12;
} else {
m_sampling_cb.freq_con = 9;
}
#elif (ADC_FREQ_CLOCK == ADC_CLK_DIV_4)
if (uclock_freq == CLOCK_HFCLK_IN_96M) {
m_sampling_cb.freq_con = 13;
} else if (uclock_freq == CLOCK_HFCLK_IN_64M) {
m_sampling_cb.freq_con = 8;
} else {
m_sampling_cb.freq_con = 7;
}
#else
//===========ADC时钟为2的时候
if (uclock_freq == CLOCK_HFCLK_IN_96M) {
m_sampling_cb.freq_con = 16;
} else if (uclock_freq == CLOCK_HFCLK_IN_64M) {
m_sampling_cb.freq_con = 9;
} else {
m_sampling_cb.freq_con = 5;
}
#endif //(ADC_FREQ_CLOCK == ADC_CLK_DIV_2)
#endif //(SAMPLING_TYPE == MIC_SAMPLING_8K)
}
#else
/**
* @brief mic_pga_adc_sampling_set
* @details
* @param void
* @retval void
*/
void mic_pga_adc_sampling_set(void)
{
CLOCK_HighFreq_In_Typedef uclock_freq = CLOCK_HighFreq_Get();
#if (SAMPLING_TYPE == MIC_SAMPLING_8K)
if (uclock_freq == CLOCK_HFCLK_IN_96M) {
m_sampling_cb.freq_con = 32;
} else if (uclock_freq == CLOCK_HFCLK_IN_64M) {
m_sampling_cb.freq_con = 24;
} else {
m_sampling_cb.freq_con = 20;
}
//===========ADC采样率为2/4M的时候
if (uclock_freq == CLOCK_HFCLK_IN_96M)
// {
// m_sampling_cb.freq_con = 32;
// }
// else if (uclock_freq == CLOCK_HFCLK_IN_64M)
// {
// m_sampling_cb.freq_con = 21;
// }
// else
// {
// m_sampling_cb.freq_con = 20;
// }
#else
if (uclock_freq == CLOCK_HFCLK_IN_96M) {
m_sampling_cb.freq_con = 16;
} else if (uclock_freq == CLOCK_HFCLK_IN_64M) {
m_sampling_cb.freq_con = 12;
} else {
m_sampling_cb.freq_con = 10;
}
//===========ADC采样率为2/4M的时候
// if (uclock_freq == CLOCK_HFCLK_IN_96M)
// {
// m_sampling_cb.freq_con = 16;
// }
// else if (uclock_freq == CLOCK_HFCLK_IN_64M)
// {
// m_sampling_cb.freq_con = 9;
// }
// else
// {
// m_sampling_cb.freq_con = 7;
// }
#endif // (SAMPLING_TYPE == MIC_SAMPLING_8K)
}
#endif //USE_XIP == 1
/**
* @brief mic_pga_adc_sampling_set
* @details
* @param void
* @retval void
*/
uint32_t pga_adc_data_uart_byte_delay(void)
{
uint32_t delay = 0;
CLOCK_HighFreq_In_Typedef uclock_freq = CLOCK_HighFreq_Get();
#if (ADC_FREQ_CLOCK == ADC_CLK_DIV_2)
if (uclock_freq == CLOCK_HFCLK_IN_64M) {
delay = 210;
} else {
delay = 75;
}
#else
if (uclock_freq == CLOCK_HFCLK_IN_64M) {
delay = 210;
} else {
delay = 86;
}
#endif
return delay;
}
/**
* @brief pga_init
* @details
* @param void
* @retval void
*/
void pga_init(void)
{
uint32_t adc_reg = 0;
DEBUG("audio_adc_ctrl_reg0 = %x\n", *((volatile unsigned int *)(0x400001BC)));
//for(int i=0; i<0x100000; i++); //delay
adc_reg = *((volatile unsigned int *)(0x400001BC));
adc_reg &= ~(1 << 28);
adc_reg |= (1 << 28); // opa第1级增益 +20DB
adc_reg &= ~(0x0f << 24);
adc_reg |= (0x0a << 24); // opa第2级增益 +16DB //主要修改增益处（<24-27>）
adc_reg &= ~(0x7 << 21);
adc_reg |= (0x7 << 21); // BIT21-23电流大小控制，最大为000，最小为111
adc_reg &= ~(0x0F << 0); // bias寄存器 控制电流
adc_reg &= ~(0x1 << 4); // opa pd信号
adc_reg &= ~(1 << 12); // open pdbias
adc_reg |= (0x1 << 5); // 差分
adc_reg &= ~(1 << 7); // open pdbias pga第1级增益，
*((volatile unsigned int *)(0x400001BC)) = adc_reg;
DEBUG("after audio_adc_ctrl_reg0 = %x\n", *((volatile unsigned int *)(0x400001BC)));
}
/**
* @brief mic_pga_adc_demo
* @details
* @param void
* @retval void
*/
void mic_pga_adc_demo(void)
{
// DEBUG("__MIC_PGA_ADC_DEMO__\r");
adc_uart_init();
// uint16_t adc_val = 0;
adc_cfg adc_cfg;
GPIO_InitCfg_t GPIO_InitCfg = {0};
GPIO_InitCfg.Mux = GPIO_Mux0;
GPIO_InitCfg.FunSel = GPIO_Dx;
GPIO_InitCfg.Pull = GPIO_NOPULL;
// Board Led1 Initialization
GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
GPIO_InitCfg.Int = NOT_INT;
GPIO_InitCfg.Pin = 6;
xc_gpio_init(&GPIO_InitCfg);
// GPIO_InitCfg.Pin = 8;
// xc_gpio_init(&GPIO_InitCfg);
//
// GPIO_InitCfg.Pin = 9;
// xc_gpio_init(&GPIO_InitCfg);
#if SAMPLING_DEBUG || REC_TEST_EN
TIMER_BaseInitTypeDef Timer_Init;
Timer_Init.src_clk = TIMER_CLK_SRC_32M_DIV;
Timer_Init.mode = TIMER_MODE_CYCLE_COUNT;
Timer_Init.div_clk = TIMER_DIV_CLK_1MHzOr1K;
// Timer0 Config & Start
TIMER_Base_Init(XC_TIMER1, &Timer_Init);
TIMER_SetUs(XC_TIMER1,1000000); // 测试采样到的时候改成1秒，录音测试改成5秒或者其他
#endif
// pga初始化
pga_init();
/*----- Special Pin -----*/
/*< SWD 和 SWCK 引脚也可以作为 ADC 使用，
注意 PIN 脚的功能重映射 >*/
// gpio_mux_ctl(12,GPIO_Mux1);
// gpio_mux_ctl(13,GPIO_Mux1);
/*-----------------------*/
adc_cfg.Freq = ADC_FREQ_4M;
adc_cfg.RefVol = ADC_REF_VOL_3_3V;
adc_cfg.SampEdge = ADC_SAMPEDGE_FALL;
adc_cfg.ExtDataMode = ADC_DATA_MODE_32BIT;
adc_cfg.ExtEdgeSel = ADC_EXT_EDGE_SEL_INTER; // ADC_EXT_EDGE_SEL_EXTERN_RISE // ADC_EXT_EDGE_SEL_EXTERN_BOTH
adc_cfg.ExtSampleNum = ADC_SAMPLE_NUM_16;
adc_cfg.ExtTriggerSel = ADC_TRIGGER_SEL_PWM0;
ADC_Init(XC_ADC, &adc_cfg);
// 采样率设置
mic_pga_adc_sampling_set(); // ADC改动跟着改动
__ADC_ChannelSet(XC_ADC, ADC_CHANNEL13_PIN6);
__ADC_FIFO_ReqIntLenthSet(XC_ADC);
__ADC_FIFO_Flush(XC_ADC);
__ADC_Clear_IT_Flag(XC_ADC);
//=============中断=======================
ADC_Enable_IT(XC_ADC, ADC_INT_EN_READ_REQ_EN_ENABLE |
ADC_INT_EN_FIFO_ERROR_EN_ENABLE);
NVIC_EnableIRQ(GADC_IRQn);
__ADC_Enable(XC_ADC);
#if SAMPLING_DEBUG || REC_TEST_EN
TIMER_Start_IT(XC_TIMER1);
m_sampling_cb.rec_len_time = 5; // 秒
uint8_t rec_time;
rec_time = m_sampling_cb.rec_len_time;
#endif
DEBUG("start adc\n");
short voice_data = 0;
uint16_t voice_adc_rx_index = 0;
uint32_t uart_byte_delay = pga_adc_data_uart_byte_delay();
while (1) {
#if SAMPLING_DEBUG
if (m_sampling_cb.rx_flag) {
delay_ms(500);
DEBUG("sampling: %d.%dKhz\n",(m_sampling_cb.pga_adc_rx_con / rec_time) / 1000,
(m_sampling_cb.pga_adc_rx_con / rec_time) % 1000);
}
#endif
//ADC_MIC_StartGetValue(XC_ADC, ADC_CHANNEL13_PIN6,&adc_val); //轮询
if (m_sampling_cb.buf_full_flag) {
m_sampling_cb.buf_full_flag = 0;
voice_adc_rx_index = 0;
while (voice_adc_rx_index < MIC_SAMPLING_MAX_LEN) {
voice_data = m_sampling_cb.mic_adc_buff[!m_sampling_cb.save_buf_index]
[voice_adc_rx_index];
//DEBUG("%d\n",voice_data);
uart_seed_data(voice_data & 0xff);
for (uint16_t i = 0; i < uart_byte_delay; i++); // 64M延时
uart_seed_data((voice_data >> 8) & 0xff);
for (uint16_t i = 0; i < uart_byte_delay; i++); // 64M延时
voice_adc_rx_index++;
}
// m_sampling_cb.save_buf_index = !m_sampling_cb.save_buf_index;
}
}
}
void Timer1_Callback(void *context)
{
(void)context;
#if SAMPLING_DEBUG
//m_sampling_cb.rx_flag = 1;
#endif
#if REC_TEST_EN
if (m_sampling_cb.rec_len_time)
{
//DEBUG("m_sampling_cb.rec_len_time\n");
m_sampling_cb.rec_len_time--;
}
#endif
}
//=========================================PGA+ADC相关的=========================================
void ADC_MIC_StartGetValue(ADC_TypeDef* ADCx, ADC_ChannelTypeDef Channel,uint16_t *adc_val)
{
uint32_t val;
ADC_FIFO_TypeDef *fifo_val = NULL;
if (__Get_Adc_Channel() != Channel)
{
__ADC_Disable(ADCx);
__ADC_ChannelSet(ADCx, Channel);
__ADC_FIFO_ReqIntLenthSet(ADCx);
__ADC_FIFO_Flush(ADCx);
__ADC_Clear_IT_Flag(ADCx);
__ADC_Enable(ADCx);
}
val = ADCx->INT_RAW;
if(((val & ADC_INT_READ_REQ_INT_Msk) != ADC_INT_READ_REQ_INT_Msk))
{
return;
}
__ADC_Clear_IT_Flag(ADCx);
fifo_val = (ADC_FIFO_TypeDef*)&val;
for(int t=0; t< ADC_FIFO_CTL_READ_REQ_THRESH_LEN_8; t++)
{
val = ADCx->FIFO;
if(fifo_val->chanel_1 != fifo_val->chanel_2)
{
// DEBUG("channel error :%d\n",t);
continue;
}
if(fifo_val->chanel_1 != Channel)
{
// DEBUG("channel error :%d\n",t);
continue;
}
pga_adc_rx_event_handler(fifo_val->value_1);
pga_adc_rx_event_handler(fifo_val->value_2);
}
*adc_val = fifo_val->value_1;
__ADC_FIFO_Flush(ADCx);
// __ADC_Disable(ADCx);
// __ADC_ChannelSet(ADCx, Channel);
// __ADC_Clear_IT_Flag(XC_ADC);
// __ADC_Enable(XC_ADC);
}
//=================================================================================
void PGA_ADC_Intr_Callback(void)
{
uint32_t adc_int;
uint32_t val;
ADC_FIFO_TypeDef *fifo_val = NULL;
adc_int = XC_ADC->INT;
if(!(adc_int & (ADC_INT_READ_REQ_INT_Msk | ADC_INT_FIFO_ERROR_INT_Msk)))
{
return;
}
//开关ADC会影响采样率，需要重新调整
//__ADC_Disable(XC_ADC);
fifo_val = (ADC_FIFO_TypeDef*)&val;
for(int t=0; t< ADC_FIFO_CTL_READ_REQ_THRESH_LEN_8; t++)
{
val = XC_ADC->FIFO;
if(fifo_val->chanel_1 == ADC_CHANNEL13_PIN6)
{
pga_adc_rx_event_handler(fifo_val->value_1);
}
if(fifo_val->chanel_2 == ADC_CHANNEL13_PIN6)
{
pga_adc_rx_event_handler(fifo_val->value_2);
}
//if (t==7)
// __ADC_Enable(XC_ADC);
}
// __ADC_Enable(XC_ADC);
__ADC_FIFO_Flush(XC_ADC);
}
void ADC_Intr_Callback(void)
{
ADC_channelswitch_hw_Intr_Callback(); //adc硬件切换
// ADC_channelswitch_sw_Intr_Callback();//adc软件切换
// PGA_ADC_Intr_Callback(); //录音pga
}