/**
****************************************************************************************
* @brief Restore peripheral setting after wakeup
****************************************************************************************
*/
void usr_sleep_restore(void)
{
#if QN_DBG_PRINT
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
}
/**
****************************************************************************************
* @brief Restore peripheral setting after wakeup
****************************************************************************************
*/
void usr_sleep_restore(void)
{
#if QN_DBG_PRINT
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
#if (defined(QN_ADV_WDT))
if(usr_env.adv_wdt_enable)
{
wdt_init(1007616, WDT_INT_MOD); // 30.75s
}
#endif
}
/**
****************************************************************************************
* @brief Restore peripheral setting after wakeup
****************************************************************************************
*/
void usr_sleep_restore(void)
{
#if (FB_OLED && FB_SPI_OLED)
spi_init(QN_SPI1, SPI_BITRATE(10000), SPI_8BIT, SPI_MASTER_MOD);
#endif
#if QN_DBG_PRINT
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
#if (defined(QN_ADV_WDT))
if(usr_env.adv_wdt_enable)
{
wdt_init(1007616, WDT_INT_MOD); // 30.75s
}
#endif
}
/*******************************************************************************
* Function Name : uart_write
* Description : Write data bytes to the USARTx TxBuffer.
* Input : - RdPtr: Location where the first byte is to be read
* : - Size: Number of bytes to be written
* : - Uart: Select the USART or the UART peripheral.
* Output : None
* Return : -1 if ERROR, Number of char not written (0 if OK)
*******************************************************************************/
int uart_write(const void *RdPtr, u16 Size, const _Uart_Descriptor *Uart)
{
u16 i;
char *ptr = (char *)RdPtr;
if(Size>(*Uart->Ctrl)->TxBufSize)
Size=(*Uart->Ctrl)->TxBufSize;
//
USART_ITConfig(Uart->UARTx, USART_IT_TXE, DISABLE);
//
for (i = 0 ; i < Size ; i++){
if (uart_put_char(*ptr++, Uart) == -1)
break;
}
//
if ((*Uart->Ctrl)->HwCtrl & UART_HALF_DUPLEX)
uart_tx_enable(Uart);
//
USART_ITConfig(Uart->UARTx, USART_IT_TXE, ENABLE);
//
return((int)(i));
}
/**
@brief Network receive callback function
@param[in] *arg: unused
@param[in] *data: Data received
@param[in] length: Length of data received
@return void
*/
MEMSPACE
static void tcp_data_receive_callback(void *arg, char *data, uint16_t length)
{
uint16_t current;
uint8_t byte;
// Echo debug
#if 0
for(current = 0; current < length; current++)
uart0_putc(data[current]);
#endif
// FIXME NOT WORKING
//
for(current = 0; (current < length) && queue_space(uart_send_queue); current++)
{
byte = (uint8_t)data[current];
queue_pushc(uart_send_queue, byte);
}
if(queue_empty(uart_send_queue) && tx_fifo_empty(0))
uart_tx_disable(0);
else
uart_tx_enable(0);
}
/**
****************************************************************************************
* @brief Restore peripheral setting after wakeup
****************************************************************************************
*/
void usr_sleep_restore(void)
{
#if QN_DBG_PRINT
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_115200);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
#if (defined(QN_ADV_WDT))
if(usr_env.adv_wdt_enable)
{
wdt_init(1007616, WDT_INT_MOD); // 30.75s
}
#endif
//Initialize I2C master to save time later
uint8_t i2cbuffer[3];
i2c_init(I2C_SCL_RATIO(1), i2cbuffer, 3);
//QPRINTF("SLEEP RESTORE\r\n");
//send_packet(PROTOCOL_MODE_TX2);
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Disable all peripheral clock, will be enabled in the driver initilization.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
usart_reset((uint32_t) QN_SPI1);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
#if (FB_OLED && FB_SPI_OLED)
spi_init(QN_SPI1, SPI_BITRATE(10000), SPI_8BIT, SPI_MASTER_MOD);
#endif
/// Firefly add
#if (FB_OLED)
OLED_Init(); //初始化 OLED
OLED_Clear(); //清屏 OLED
OLED_ShowString(0,0," Firefly Team ");
OLED_ShowString(0,2," Wait ... ");
// OLED_ShowString(4,4,"Please wait...");
#endif
//#if (FB_OLED)
// OLED_Init(); //初始化OLED
// delay(10000);
// OLED_Clear(); //清屏 OLED
// delay(10000);
// OLED_ShowCHinese(9,0,0);
// OLED_ShowCHinese(27,0,1);
// OLED_ShowCHinese(45,0,2);
// OLED_ShowCHinese(63,0,3);
// OLED_ShowCHinese(81,0,4);
// OLED_ShowCHinese(99,0,5);
//#endif
#if (defined(CFG_PRO_TEST))
gpio_pull_set(BUTTON1_PIN,GPIO_PULL_UP);
gpio_set_direction(BUTTON1_PIN,GPIO_INPUT);
if (gpio_read_pin(BUTTON1_PIN) == GPIO_LOW)
app_env.pro_test_flag = TRUE;
else
app_env.pro_test_flag = FALSE;
#endif
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
// Button
button_init();
#if (QN_DBG_PRINT)
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Reset SPI1 module(since the default register value was changed in bootloader)
syscon_SetCRSS(QN_SYSCON, SYSCON_MASK_USART1_RST);
syscon_SetCRSC(QN_SYSCON, SYSCON_MASK_USART1_RST);
/*
Disable all peripheral clock, will be enabled in the driver initilization.
The next function performs the equivalent effect of a collection of these functions.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
*/
syscon_SetCRSS(QN_SYSCON, SYSCON_MASK_GATING_TIMER0
| SYSCON_MASK_GATING_TIMER1
| SYSCON_MASK_GATING_TIMER2
| SYSCON_MASK_GATING_TIMER3
| SYSCON_MASK_GATING_UART0
| SYSCON_MASK_GATING_UART1
| SYSCON_MASK_GATING_SPI0
| SYSCON_MASK_GATING_SPI1
| SYSCON_MASK_GATING_SPI_AHB
| SYSCON_MASK_GATING_GPIO
| SYSCON_MASK_GATING_ADC
| SYSCON_MASK_GATING_DMA
| SYSCON_MASK_GATING_PWM);
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
// Button
button_init();
#if (QN_DBG_PRINT)
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Disable all peripheral clock, will be enabled in the driver initilization.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
usart_reset((uint32_t) QN_SPI1);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
// if pull down GPIO_P12 when power on,it will enter the test mode
#if defined(CFG_ALL_GPIO_TEST)
//set GPIO_P12 direction to GPIO_INPUT
syscon_SetPMCR0(QN_SYSCON,P12_GPIO_10_PIN_CTRL);
gpio_init(gpio_interrupt_callback);
gpio_pull_set(GPIO_P12, GPIO_PULL_UP);
gpio_set_direction_field(GPIO_P12, (uint32_t)GPIO_INPUT);
//check if it's pull down
if (gpio_read_pin(GPIO_P12) == GPIO_LOW)
{
//set a flag to enter test mode until device reset
app_env.test_flag = TRUE;
}
else
app_env.test_flag = FALSE;
#endif
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
#if defined(QN_COM_UART)
// Initialize User UART port
uart_init(QN_COM_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_COM_UART, MASK_ENABLE);
uart_rx_enable(QN_COM_UART, MASK_ENABLE);
#endif
#if (QN_DBG_PRINT)
// Initialize Debug UART port
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
// if enter test mode flag had been seted,enter a loop to test all GPIO.
#if (defined(CFG_ALL_GPIO_TEST))
if (app_env.test_flag == TRUE)
{
//get a warnning to user
QPRINTF("\r\n@@@You pull down the GPIO_level of GPIO_P12 when power on,so it will enter the test mode!");
while(1)
{
all_gpio_test();
}
}
#endif
}
int main (void)
{
SystemInit();
adc_pin_enable(AIN0, MASK_ENABLE);
adc_pin_enable(AIN1, MASK_ENABLE);
#if ADC_EXT_REF_EN==TRUE
adc_pin_enable(AIN2, MASK_ENABLE);
adc_pin_enable(AIN3, MASK_ENABLE);
#endif
#if (__AHB_CLK == 32000UL)
uart_init(QN_UART0, __USART_CLK, UART_1200);
#else
uart_init(QN_UART0, __USART_CLK, UART_115200);
#endif
uart_tx_enable(QN_UART0, MASK_ENABLE);
// ADC initialization
#if ADC_WORKING_AT_32K==TRUE
clk32k_enable(__32K_TYPE);
adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK32K_16000, ADC_INT_REF, ADC_12BIT);
#else
#if ADC_EXT_REF_EN==TRUE
adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK_1000000, ADC_EXT_REF2, ADC_12BIT);
//adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK_1000000, ADC_EXT_REF1, ADC_12BIT);
#else
adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK_1000000, ADC_INT_REF, ADC_12BIT);
#endif
#endif
// Read configuration
adc_read_configuration read_cfg;
#if ADC_TRIG_BY_GPIO == TRUE
read_cfg.trig_src = ADC_TRIG_GPIO;
syscon_SetPMCR2WithMask(QN_SYSCON, SYSCON_MASK_ADCT_PIN_SEL, ADC_GPIO15_TRIG);
// triger by gpio in single or single scan mode, connect PWM output to ADC trigger PIN
pwm_init(PWM_CH0);
pwm_config(PWM_CH0, PWM_PSCAL_DIV, PWM_COUNT_US(50, PWM_PSCAL_DIV), PWM_COUNT_US(25, PWM_PSCAL_DIV));
pwm_enable(PWM_CH0, MASK_ENABLE);
#elif ADC_TRIG_BY_TOF == TRUE
read_cfg.trig_src = ADC_TRIG_TOVF1;
// triger by timer1 overflow
timer_init(QN_TIMER1, NULL);
timer_pwm_config(QN_TIMER1, TIMER_PSCAL_DIV, TIMER_COUNT_US(100, TIMER_PSCAL_DIV), TIMER_COUNT_US(50, TIMER_PSCAL_DIV));
timer_enable(QN_TIMER1, MASK_ENABLE);
#elif ADC_TRIG_BY_SOFT == TRUE
read_cfg.trig_src = ADC_TRIG_SOFT;
#endif
#if ADC_DECIMATION_EN == TRUE
adc_decimation_enable(DECI_RATE_64, MASK_ENABLE);
#endif
#if ADC_COMPARATOR_EN == TRUE
//adc_compare_init(DECI_DATA, 2500, -2000, adc_WCMP_cb);
adc_compare_init(ADC_DATA, 600, -600, adc_WCMP_cb);
#endif
#if (ADC_TRIG_BY_GPIO==TRUE || ADC_TRIG_BY_TOF==TRUE || ADC_TRIG_BY_SOFT==TRUE)
adc_done = 0;
// modify here
read_cfg.mode = SINGLE_MOD;
read_cfg.start_ch = AIN0;
read_cfg.end_ch = AIN0;
adc_read(&read_cfg, buf, 512, adc_test_cb);
while (adc_done == 0);
#endif
#if ADC_COMPARATOR_EN == TRUE
int m = 0;
int n = 0;
for (int i = 0; i < 512; i++) {
if (buf[i] > 600) {
m++;
}
else if (buf[i] < -600) {
n++;
}
}
printf("m = %d\t n = %d\r\n", m, n);
#endif
for (int i = 0; i < 512; i++) {
printf("%d\t %d\r\n", buf[i], ADC_RESULT_mV(buf[i]));
}
int sum = 0;
for (int i = 0; i < 10; i++) {
sum += buf[511 - 2*i];
}
sum = sum / 10;
printf("average: %d\t %d\r\n", sum, ADC_RESULT_mV(sum));
#if ADC_TEMP_SENSOR_EN==TRUE
temp_sensor_enable(MASK_ENABLE);
int16_t tempv;
adc_init(ADC_DIFF_WITH_BUF_DRV, ADC_CLK_1000000, ADC_INT_REF, ADC_12BIT);
adc_done = 0;
read_cfg.trig_src = ADC_TRIG_SOFT;
read_cfg.mode = SINGLE_MOD;
read_cfg.start_ch = TEMP;
read_cfg.end_ch = TEMP;
adc_read(&read_cfg, &tempv, 1, adc_test_cb);
while (adc_done == 0);
printf("temperature: %0.1f\r\n", (float)(TEMPERATURE_X10(tempv)/10.0));
#endif
#if ADC_BATT_MONITOR_EN==TRUE
battery_monitor_enable(MASK_ENABLE);
int16_t battv;
adc_init(ADC_SINGLE_WITH_BUF_DRV, ADC_CLK_1000000, ADC_INT_REF, ADC_12BIT);
adc_done = 0;
read_cfg.trig_src = ADC_TRIG_SOFT;
read_cfg.mode = SINGLE_MOD;
read_cfg.start_ch = BATT;
read_cfg.end_ch = BATT;
adc_read(&read_cfg, &battv, 1, adc_test_cb);
while (adc_done == 0);
printf("battery voltage: %d\r\n", 4*ADC_RESULT_mV(battv));
#endif
while (1) /* Loop forever */
{
}
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Disable all peripheral clock, will be enabled in the driver initilization.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
usart_reset((uint32_t) QN_SPI1);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
// Button
button_init();
#if (QN_DBG_PRINT)
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
}