/**
****************************************************************************************
* @brief Handles button press after cancel the jitter.
*
* @param[in] msgid Id of the message received
* @param[in] param None
* @param[in] dest_id TASK_APP
* @param[in] src_id TASK_APP
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int app_button_timer_handler(ke_msg_id_t const msgid, void const *param,
ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
switch(msgid)
{
case APP_SYS_BUTTON_1_TIMER:
// make sure the button is pressed
if(gpio_read_pin(BUTTON1_PIN) == GPIO_LOW)
{
if(APP_IDLE == ke_state_get(TASK_APP))
{
struct app_proxr_env_tag *app_proxr_env = &app_env.proxr_ev;
if(!app_proxr_env->enabled)
{
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
#if (QN_DEEP_SLEEP_EN)
// prevent entering into deep sleep mode
sleep_set_pm(PM_SLEEP);
#endif
#if (FB_OLED)
ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);
#endif
}
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
// stop adv
app_gap_adv_stop_req();
#if (QN_DEEP_SLEEP_EN)
// allow entering into deep sleep mode
sleep_set_pm(PM_DEEP_SLEEP);
#endif
#if (FB_OLED)
ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);
#endif
}
}
break;
case APP_SYS_BUTTON_2_TIMER:
if(gpio_read_pin(BUTTON2_PIN) == GPIO_LOW)
{
buzzer_off();
}
break;
default:
ASSERT_ERR(0);
break;
}
return (KE_MSG_CONSUMED);
}
int main() {
UINT8 pinvalue;
DRVCTRL example;
drvinit(example);
pinvalue = gpio_read_pin(&example,PORTD, 1);
init_gpio(DRV_PORTB);
init_gpio(DRV_PORTD);
/* I would really like to be able to implement a
function where I could just pass a pointer to a
function that would be called when the timer
overflowed, like the one below.
*/
/* schedulePeriodicTask(timePeriod,&task); */
init_timer();
init_usart0();
init_eeprom();
while (1) {
;
}
}
int es32f0_pin_read(rt_device_t dev, rt_base_t pin)
{
int value;
const struct pin_index *index;
value = PIN_LOW;
index = get_pin(pin);
if (index == RT_NULL)
{
return value;
}
value = gpio_read_pin(index->gpio, index->pin);
return value;
}
/**
****************************************************************************************
* @brief Get led status
* @param[in] idx 1~5 -> led 1~5
* @return led on/off
* @description
* This function get led status individually.
****************************************************************************************
*/
enum led_st led_get(uint32_t idx)
{
enum gpio_pin reg;
switch(idx)
{
case 1:
reg = LED1_PIN;
break;
case 2:
reg = LED2_PIN;
break;
default:
return LED_OFF;
}
return (enum led_st)gpio_read_pin(reg);
}
/**
****************************************************************************************
* @brief Handles button press after cancel the jitter.
*
* @param[in] msgid Id of the message received
* @param[in] param None
* @param[in] dest_id TASK_APP
* @param[in] src_id TASK_APP
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int app_button_timer_handler(ke_msg_id_t const msgid, void const *param,
ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
switch(msgid)
{
case APP_SYS_BUTTON_1_TIMER:
// make sure the button is pressed
if (gpio_read_pin(BUTTON1_PIN) == GPIO_LOW)
{
if (APP_IDLE == ke_state_get(TASK_APP))
{
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE,
adv_data, sizeof(adv_data),
scan_data, sizeof(scan_data),
GAP_ADV_INTV1, GAP_ADV_INTV2);
ke_state_set(TASK_APP, APP_ADV);
#if (QN_DEEP_SLEEP_EN)
// prevent entering into deep sleep mode
sleep_set_pm(PM_SLEEP);
#endif
}
else if (APP_ADV == ke_state_get(TASK_APP))
{
// stop adv
app_gap_adv_stop_req();
ke_state_set(TASK_APP, APP_IDLE);
#if (QN_DEEP_SLEEP_EN)
// allow entering into deep sleep mode
sleep_set_pm(PM_DEEP_SLEEP);
#endif
}
}
break;
default:
ASSERT_ERR(0);
break;
}
return (KE_MSG_CONSUMED);
}
void btn_read(BTN_DEV_ST* const btn) {
// read the state of the button into a local variable
uint8_t buttonState = gpio_read_pin(btn->port, btn->pin);
// three-state machine:
// - press and hold: send "r" key (for rewind function of RetroArch)
// - press and release three times: send "ESC"
// - press and release five times: shutdown
switch (btn->state) {
case BTN_STATE_IDLE:
if (buttonState == GPIO_LOW) {
btn->duration = difftime(time(NULL ), btn->lastPress);
} else if (buttonState == GPIO_HIGH) {
btn->lastPress = time(NULL );
btn->state = BTN_STATE_PRESSED;
btn->pressedCtr += 1;
}
break;
case BTN_STATE_PRESSED:
if (buttonState == GPIO_LOW) {
btn->lastPress = time(NULL );
btn->state = BTN_STATE_RELEASED;
} else if (buttonState == GPIO_HIGH) {
btn->duration = difftime(time(NULL ), btn->lastPress);
}
break;
case BTN_STATE_RELEASED:
if (buttonState == GPIO_LOW) {
btn->duration = difftime(time(NULL ), btn->lastPress);
if (btn->duration >=2) {
btn->lastPress = time(NULL );
btn->state = BTN_STATE_IDLE;
btn->pressedCtr = 0;
}
} else if (buttonState == GPIO_HIGH) {
btn->lastPress = time(NULL );
btn->state = BTN_STATE_PRESSED;
btn->pressedCtr += 1;
}
break;
}
}
/*
****************************************************************************************
* @brief app_com_at_rx_enable_handler
* @param[in] msgid
* @param[in] param
* @param[in] dest_id
* @param[in] src_id
* @response None
* @return KE_MSG_CONSUMED or ERROR_CODE
* @description
*****************************************************************************************/
int app_com_at_rx_enable_handler(ke_msg_id_t const msgid, void const *param,
ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
switch(com_env.com_mode)
{
case COM_MODE_IDLE:
break;
case COM_MODE_TRAN:
break;
case COM_MODE_AT:
if(gpio_read_pin(COM_AT_ENABLE) == GPIO_HIGH)
{
com_env.com_mode = COM_MODE_IDLE;
if(com_env.com_conn == COM_CONN)
{
led_set(2, LED_OFF);
uint8_t bit_num = get_bit_num(app_qpps_env->char_status);
if (bit_num >= QPPS_VAL_CHAR_NUM)
{
com_env.com_mode = COM_MODE_TRAN;
com_uart_rx_start();
}
else
{
com_env.com_mode = COM_MODE_IDLE;
}
}
else
{
led_set(2, LED_OFF);
com_env.com_mode = COM_MODE_IDLE;
}
}
break;
default:
break;
}
show_com_mode(com_env.com_mode);
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @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 Main program.
* @param None
* @retval None
*/
int main(void)
{
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
// Initialize library
ge_init();
// Initialize LEDs
setup_led_gpio();
led_state = false;
led_speed = false;
// Initialize the USER button as an input
gpio_setup_pin(GE_PBTN2, GPIO_INPUT, false, false);
// Initialize PBTN1
gpio_setup_pin(GE_PBTN1, GPIO_INPUT, false, false);
// Print to serial port
printf("Hello, World!\n");
// Print Hello World
lcd_clear();
lcd_goto(0, 0);
lcd_puts("Hello, World!");
// Setup timer library
// Set minimum timestep to 1ms (number of counts referecned to
// a 72MHz clock)
timer_set_timestep(72000);
// register callback for toggling LEDs every 500ms
led_timer = timer_register(500, &toggle_led, GE_PERIODIC);
timer_start(led_timer);
// set mode to the LED demo
ui_state = LED_DEMO;
// set pwm level for PWM demo
float pwm_level = 0.0;
// setup PWM library
pwm_freq(10000.0);
// setup ADC library
// set sampling rate to 10kHz
adc_set_fs(10000);
// register callback method
adc_callback(&my_adc_callback);
// enable ADC channels
adc_enable_channels(chan_to_conv, NUM_ADC);
adc_initialize_channels();
adc_start();
// keep track of how many times the UI has looped
num_refresh = 0;
/* Infinite loop */
/**
* Handles the user interface state machine
*/
while (1) {
switch (ui_state) {
/**
* User can toggle the flashing speed of the Discovery board
* LEDs. This demos how the timer library can be used.
*/
case LED_DEMO:
//check if button depressed
if (!gpio_read_pin(GE_PBTN2)) {
if (led_speed) {
timer_set_period(led_timer, 500);
led_speed = false;
} else {
timer_set_period(led_timer, 100);
led_speed = true;
}
// wait for button to be released
while (!gpio_read_pin(GE_PBTN2));
}
break;
case PWM_DEMO:
pwm_level = pwm_level + .05;
if (pwm_level > 1.0) pwm_level = 0.0;
pwm_set(PWM_CHAN1, pwm_level);
pwm_set(PWM_CHAN2, pwm_level);
pwm_set(PWM_CHAN3, pwm_level);
pwm_set(PWM_CHAN4, pwm_level);
break;
case ADC_DEMO:
// print results every 10 refreshes
num_refresh++;
if (num_refresh >= 10) {
num_refresh = 0;
printf("%u\t%u\t%u\t%u\n", val[0], val[1], val[2], val[3]);
// printf("%u\t%u\n", val[0], val[1]);
}
break;
case USART_DEMO: ;
if (ge_uart_available()) {
uint8_t c = ge_uart_get();
printf("%c\n", c);
lcd_putc(c);
}
break;
default:
break;
}
// check whether to change state
if (!gpio_read_pin(GE_PBTN1)) {
// stop LED timer if necessary
if (ui_state == LED_DEMO) timer_stop(led_timer);
ui_state++;
if (ui_state >= NUM_STATES) ui_state = LED_DEMO;
change_state();
// wait for button to be released
while (!gpio_read_pin(GE_PBTN1));
}
delay_ms(50);
}
}
/**
****************************************************************************************
* @brief Check application whether to enter sleep mode
* @return sleep allowed status
****************************************************************************************
*/
int usr_sleep(void)
{
int32_t rt;
rt = sleep_get_pm();
// If the BLE timer queue is not NULL, prevent entering into DEEPSLEEP mode
if(rt == PM_DEEP_SLEEP && !ke_timer_empty())
{
rt = PM_SLEEP;
}
// Check Device status
if((rt >= PM_SLEEP)
&& dev_get_bf())
{
// If any devices are still working, the chip cann't enter into SLEEP/DEEPSLEEP mode.
rt = PM_IDLE;
}
if ((rt >= PM_SLEEP) && (!gpio_sleep_allowed()))
{
return PM_ACTIVE; // If CLOCK OFF & POWER DOWN is disabled, return immediately
}
#if QN_DBG_PRINT
int uart_tx_st = uart_check_tx_free(QN_DEBUG_UART);
if((rt >= PM_SLEEP) && (uart_tx_st == UART_TX_BUF_BUSY))
{
rt = PM_IDLE;
}
else if(uart_tx_st == UART_LAST_BYTE_ONGOING)
{
return PM_ACTIVE; // If CLOCK OFF & POWER DOWN is disabled, return immediately
}
#endif
#if QN_EACI
if((GPIO_LOW == gpio_read_pin(QN_EACI_GPIO_WAKEUP_QN_MCU)) // Check external wakeup source
|| (eaci_env.tx_state!=EACI_STATE_TX_IDLE) // Check EACI UART TX status
|| (eaci_env.rx_state!=EACI_STATE_RX_START)) // Check EACI UART RX status
{
rt = PM_IDLE;
}
int tx_st = uart_check_tx_free(QN_HCI_UART);
if((rt >= PM_SLEEP) && (tx_st == UART_TX_BUF_BUSY))
{
rt = PM_IDLE;
}
else if(tx_st == UART_LAST_BYTE_ONGOING)
{
return PM_ACTIVE; // If CLOCK OFF & POWER DOWN is disabled, return immediately
}
#endif
#if QN_COM
if((GPIO_LOW == gpio_read_pin(QN_EACI_GPIO_WAKEUP_QN_MCU)) // Check external wakeup source
|| (eaci_env.tx_state!=EACI_STATE_TX_IDLE) // Check EACI UART TX status
|| (eaci_env.rx_state!=EACI_STATE_RX_START)) // Check EACI UART RX status
{
rt = PM_IDLE;
}
int tx_st = uart_check_tx_free(QN_COM_UART);
if((rt >= PM_SLEEP) && (tx_st == UART_TX_BUF_BUSY))
{
rt = PM_IDLE;
}
else if(tx_st == UART_LAST_BYTE_ONGOING)
{
return PM_ACTIVE; // If CLOCK OFF & POWER DOWN is disabled, return immediately
}
#endif
return rt;
}
/**
****************************************************************************************
* @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
}
/**
****************************************************************************************
* @brief BLE main function.
*
* This function is called right after the booting process has completed.
****************************************************************************************
*/
int main(void)
{
int ble_sleep_st, usr_sleep_st;
// DC-DC
dc_dc_enable(QN_DC_DC_ENABLE);
// QN platform initialization
#if QN_NVDS_WRITE
plf_init(QN_POWER_MODE, __XTAL, QN_32K_RCO, nvds_tmp_buf, NVDS_TMP_BUF_SIZE);
#else
plf_init(QN_POWER_MODE, __XTAL, QN_32K_RCO, NULL, 0);
#endif
#if (defined(QN_9020_B1) && (!QN_PMU_VOLTAGE))
disable_patch_b1();
#endif
// System initialization, user configuration
SystemInit();
// Profiles register
#if (QN_WORK_MODE != WORK_MODE_HCI)
prf_register();
#endif
// BLE stack initialization
// Notes:
// 1. When the chip works on Network Processor Mode, UART flow control signal is used to implement sleep mode.
// UART 's flow control feature shall be enabled. Enable this feature in the uart.c file.
// 2. Controller mode does not support sleep mode.
// 3. So far client example project does not support sleep mode. It will be implemented later.
// Check to go normal work mode or test mode.
// If the input of test control pin is low level, the program will enter into test mode, otherwise the program will
// enter into work mode which is defined in the user configuration file.
#if (defined(QN_TEST_CTRL_PIN))
if(gpio_read_pin(QN_TEST_CTRL_PIN) == GPIO_HIGH)
{
#endif
// Work mode defined in the usr_config.h
ble_init((enum WORK_MODE)QN_WORK_MODE, QN_HCI_PORT, QN_HCI_RD, QN_HCI_WR, ble_heap, BLE_HEAP_SIZE, QN_BLE_SLEEP);
#if (defined(QN_TEST_CTRL_PIN))
}
else
{
// Test mode (controller mode)
ble_init((enum WORK_MODE)WORK_MODE_HCI, QN_HCI_PORT, QN_HCI_RD, QN_HCI_WR, ble_heap, BLE_HEAP_SIZE, false);
// In the test mode, the program moniter test control pin. If the input of test control ping changes to low level,
// it means work mode should be switched to the mode defined in the user configuration file.
gpio_set_interrupt(QN_TEST_CTRL_PIN, GPIO_INT_HIGH_LEVEL);
gpio_enable_interrupt(QN_TEST_CTRL_PIN);
}
#endif
set_max_sleep_duration(QN_BLE_MAX_SLEEP_DUR);
// If QN902x works on wireless SoC mode, initialize APP task
#if (QN_WORK_MODE == WORK_MODE_SOC)
app_init();
#endif
usr_init();
sleep_init();
wakeup_by_sleep_timer(__32K_TYPE);
GLOBAL_INT_START();
while(1)
{
ke_schedule();
// Checks for sleep have to be done with interrupt disabled
GLOBAL_INT_DISABLE_WITHOUT_TUNER();
// Check whether the chip can enters sleep mode
//
// Chip enter sleep condition:
// +--------+--------+--------+--------+--------+
// | USR | | | | |
// | BLE | ACTIVE | IDLE | SLEEP | DEEP |
// +--------+--------+--------+--------+--------+
// | ACTIVE | active | active | active | active |
// | IDLE | active | idle | idle | idle |
// | SLEEP | active | idle | sleep | deep |
// +--------+--------+--------+--------+--------+
// Obtain the status of the user program
usr_sleep_st = usr_sleep();
// If the user program can be sleep or deep sleep then check ble status
if(usr_sleep_st != PM_ACTIVE)
{
// Obtain the status of ble sleep mode
ble_sleep_st = ble_sleep(usr_sleep_st);
// Check if the processor clock can be gated
if(((ble_sleep_st == PM_IDLE) || (usr_sleep_st == PM_IDLE))
&& (ble_sleep_st != PM_ACTIVE))
{
// Debug
//led_set(5, LED_OFF);
//led_set(4, LED_ON); // led4 is on when enter into gating mode
enter_sleep(SLEEP_CPU_CLK_OFF,
WAKEUP_BY_ALL_IRQ_SOURCE,
NULL);
// Debug
//led_set(4, LED_OFF);
//led_set(5, LED_ON); // led5 is on when enter into active mode
}
// Check if the processor can be power down
else if((ble_sleep_st == PM_SLEEP) && (usr_sleep_st == PM_SLEEP))
{
// Debug
//led_set(5, LED_OFF);
//led_set(3, LED_ON); // led3 is on when enter into sleep mode
enter_sleep(SLEEP_NORMAL,
(WAKEUP_BY_OSC_EN | WAKEUP_BY_GPIO),
sleep_cb);
// Debug
//led_set(3, LED_OFF);
//led_set(5, LED_ON); // led5 is on when enter into active mode
}
// Check if the system can be deep sleep
else if((ble_sleep_st == PM_SLEEP) && (usr_sleep_st == PM_DEEP_SLEEP))
{
// Debug
//led_set(5, LED_OFF);
//led_set(2, LED_ON); // led2 is on when enter into deep sleep mode
enter_sleep(SLEEP_DEEP,
WAKEUP_BY_GPIO,
sleep_cb);
// Debug
//led_set(2, LED_OFF);
//led_set(5, LED_ON); // led5 is on when enter into active mode
}
}
// Checks for sleep have to be done with interrupt disabled
GLOBAL_INT_RESTORE_WITHOUT_TUNER();
}
}
int main (void)
{
SystemInit();
#if 0
if (0x00000004 & inp32(0x40000038)) {
outp32(0x40000038, 0x80000000);
}
else {
Led_flash();
while(1);
}
#endif
/* Initialize GPIO */
gpio_init(cb_gpio);
#if TEST_SLEEP_NORMAL == TRUE
// --------------------------------------------
// sleep wakeup
// --------------------------------------------
//set all pin to gpio
syscon_SetPMCR0(QN_SYSCON, 0x00000000);
syscon_SetPMCR1(QN_SYSCON, 0x00000000);
//set all gpio input
gpio_set_direction_field(GPIO_PIN_ALL, GPIO_INPUT);
gpio_write_pin_field(GPIO_PIN_ALL, (uint32_t)GPIO_HIGH);
// pin pull ( 00 : High-Z, 01 : Pull-down, 10 : Pull-up, 11 : Reserved )
syscon_SetPPCR0(QN_SYSCON, 0xAAAA5AAA); // SWD pull-down save 20uA
syscon_SetPPCR1(QN_SYSCON, 0x2AAAAAAA);
// power down BUCK needed
syscon_SetIvrefX32WithMask(QN_SYSCON, SYSCON_MASK_BUCK_BYPASS|SYSCON_MASK_BUCK_DPD, MASK_ENABLE);
// power down Flash
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_FLASH_VCC_EN, MASK_DISABLE);
// enable dbg power down
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_DBGPMUENABLE, MASK_ENABLE);
// dis sar adc buffer
syscon_SetPGCR1WithMask(QN_SYSCON, SYSCON_MASK_DIS_SAR_BUF, MASK_ENABLE);
Led_flash();
do {
delay(10);
} while (gpio_read_pin(GPIO_P14) == GPIO_HIGH);
sleep_init();
wakeup_by_sleep_timer(__32K_TYPE);
wakeup_by_gpio(GPIO_P15, GPIO_WKUP_BY_LOW);
do {
gpio_set_direction(GPIO_P01, GPIO_INPUT);
//enter_sleep(SLEEP_NORMAL, WAKEUP_BY_GPIO, Led_flash);
if (wakeup_from_sleeptimer) {
sleep_timer_set(32000);
wakeup_from_sleeptimer = 0;
#if QN_32K_RCO == TRUE
clock_32k_correction_enable(clock_32k_correction_cb);
#endif
}
#if QN_32K_RCO == TRUE
if (gpio_sleep_allowed() && !dev_get_bf())
#else
if (gpio_sleep_allowed())
#endif
enter_sleep(SLEEP_NORMAL, WAKEUP_BY_OSC_EN|WAKEUP_BY_GPIO, Led_flash);
} while(1);
#endif
#if TEST_SLEEP_DEEP == TRUE
// --------------------------------------------
// deep sleep wakeup
// --------------------------------------------
//set all pin to gpio
syscon_SetPMCR0(QN_SYSCON, 0x00000000);
syscon_SetPMCR1(QN_SYSCON, 0x00000000);
//set all gpio input
gpio_set_direction_field(GPIO_PIN_ALL, (uint32_t)GPIO_INPUT);
gpio_write_pin_field(GPIO_PIN_ALL, (uint32_t)GPIO_HIGH);
// pin pull ( 00 : High-Z, 01 : Pull-down, 10 : Pull-up, 11 : Reserved )
syscon_SetPPCR0(QN_SYSCON, 0xAAAA5AAA); // SWD pull-down save 20uA
syscon_SetPPCR1(QN_SYSCON, 0x2AAAAAAA);
// power down BUCK needed
syscon_SetIvrefX32WithMask(QN_SYSCON, SYSCON_MASK_BUCK_BYPASS|SYSCON_MASK_BUCK_DPD, MASK_ENABLE);
// power down Flash
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_FLASH_VCC_EN, MASK_DISABLE);
// enable dbg power down
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_DBGPMUENABLE, MASK_ENABLE);
// dis sar adc buffer
syscon_SetPGCR1WithMask(QN_SYSCON, SYSCON_MASK_DIS_SAR_BUF, MASK_ENABLE);
Led_flash();
do {
delay(10);
} while (gpio_read_pin(GPIO_P14) == GPIO_HIGH);
sleep_init();
do {
gpio_set_direction(GPIO_P01, GPIO_INPUT);
wakeup_by_gpio(GPIO_P15, GPIO_WKUP_BY_CHANGE);
enter_sleep(SLEEP_DEEP, WAKEUP_BY_GPIO, Led_flash);
} while(1);
#endif
#if TEST_SLEEP_CPU_CLK_OFF == TRUE
// --------------------------------------------
// clock gating
// --------------------------------------------
// Set timer 0 wakeup
timer_init(QN_TIMER0, NULL);
timer_config(QN_TIMER0, TIMER_PSCAL_DIV, TIMER_COUNT_MS(1000, TIMER_PSCAL_DIV));
timer_enable(QN_TIMER0, MASK_ENABLE);
sleep_init();
do {
enter_sleep(SLEEP_CPU_CLK_OFF, WAKEUP_BY_TIMER0, NULL);
Led_flash();
}
while(1);
#endif
}
/*
****************************************************************************************
* @brief com_wakeup_handler
* @param[in] None
* @response APP_COM_AT_RX_ENABLE_TIMER(app_com_at_rx_enable_handler)
* @return None
* @description com wake msg handler
*****************************************************************************************/
void com_wakeup_handler(void)
{
switch(com_env.com_mode)
{
case COM_MODE_IDLE:
{
// Enter COM_MODE_AT when COM_AT_ENABLE¡¡is GPIO_LOW
if (gpio_read_pin(COM_AT_ENABLE) == GPIO_LOW)
{
com_env.com_mode = COM_MODE_AT;
led_set(2, LED_ON);
com_uart_at_rx_start();
}
// Enter COM_MODE_TRAN when COM_AT_ENABLE isnot GPIO_LOW and the connection created.
else if(com_env.com_conn == COM_CONN)
{
com_env.com_mode = COM_MODE_IDLE;
led_set(2, LED_OFF);
uint8_t bit_num = get_bit_num(app_qpps_env->char_status);
if (bit_num >= QPPS_VAL_CHAR_NUM)
{
com_env.com_mode = COM_MODE_TRAN;
com_uart_rx_start();
}
}
// Enter COM_MODE_AT when connection is disconnect
else if(com_env.com_conn == COM_DISCONN)
{
com_env.com_mode = COM_MODE_IDLE;
led_set(2, LED_OFF);
}
break;
}
case COM_MODE_TRAN:
// Enter COM_MODE_AT
{
com_env.com_mode = COM_MODE_AT;
led_set(2, LED_ON);
com_uart_at_rx_start();
break;
}
case COM_MODE_AT:
// Enter COM_MODE_TRAN
{
com_env.com_mode = COM_MODE_IDLE;
led_set(2, LED_OFF);
uint8_t bit_num = get_bit_num(app_qpps_env->char_status);
if (bit_num >= QPPS_VAL_CHAR_NUM)
{
com_env.com_mode = COM_MODE_TRAN;
com_uart_rx_start();
}
break;
}
default:
break;
}
// }
ke_timer_set(APP_COM_AT_RX_ENABLE_TIMER, TASK_APP, 2);
}
