void app_event_accel_handler(void)
{
#if ((QN_DEEP_SLEEP_EN) && (!QN_32K_RCO))
if (sleep_env.deep_sleep)
{
sleep_env.deep_sleep = false;
// start 32k xtal wakeup timer
wakeup_32k_xtal_start_timer();
}
#endif
//QPRINTF(".");
int8_t xdat[ACCEL_FIFO_DEPTH];
//int8_t ydat[ACCEL_FIFO_DEPTH];
accel_get_X_samples(xdat, ACCEL_FIFO_DEPTH);
for(uint8_t i=0;i<ACCEL_FIFO_DEPTH;i++)
{
//fancy_pedometer(xdat[i], ydat[i]);
//basic_pedometer();
better_pedometer(xdat[i]);
}
/*if(send_packet_bool)
{
send_packet(PROTOCOL_MODE_TX2);
send_packet_bool = 0;
}*/
ke_evt_clear(1UL << EVENT_ACCEL_INT_ID);
sleep_set_pm(PM_SLEEP);
}
/**
****************************************************************************************
* @brief Handles at_enable press.
****************************************************************************************
*/
void app_event_at_enable_press_handler(void)
{
ke_evt_clear(1UL << EVENT_AT_ENABLE_PRESS_ID);
#if ((QN_DEEP_SLEEP_EN) && (!QN_32K_RCO))
if (sleep_env.deep_sleep)
{
sleep_env.deep_sleep = false;
// start 32k xtal wakeup timer
wakeup_32k_xtal_start_timer();
}
#endif
com_wakeup_handler();
}
void com_event_uart_rx_frame_handler(void)
{
uart_rx_int_enable(QN_COM_UART, MASK_DISABLE); //disable uart rx interrupt
struct app_uart_data_ind *com_data = ke_msg_alloc(APP_COM_UART_RX_DONE_IND,
TASK_APP,
TASK_APP,
com_env.com_rx_len+1);
com_data->len=com_env.com_rx_len;
memcpy(com_data->data,com_env.com_rx_buf,com_env.com_rx_len);
ke_msg_send(com_data);
ke_timer_clear(APP_COM_RX_TIMEOUT_TIMER, TASK_APP);
ke_evt_clear(1UL << EVENT_UART_RX_FRAME_ID);
}
/**
****************************************************************************************
* @brief Handles button press before key debounce.
* @return If the message was consumed or not.
****************************************************************************************
*/
void app_event_button1_press_handler(void)
{
#if ((QN_DEEP_SLEEP_EN) && (!QN_32K_RCO))
if (sleep_env.deep_sleep)
{
sleep_env.deep_sleep = false;
// start 32k xtal wakeup timer
wakeup_32k_xtal_start_timer();
}
#endif
// delay 20ms to debounce
ke_timer_set(APP_SYS_BUTTON_1_TIMER, TASK_APP, 2);
ke_evt_clear(1UL << EVENT_BUTTON1_PRESS_ID);
}
void app_com_at_command_handler(void)
{
#ifdef CATCH_LOG
QPRINTF("\r\n at_process_command:\r\n");
for(uint8_t i = 0;i < com_env.com_at_len+1;i++)
QPRINTF("0x%02x ",com_env.com_at_buf[i]);
#endif
//AT Comand length is more than 3
if(com_env.com_at_len >= 3)
{
// if it's start with "AT"
if(com_env.com_at_buf[0] == 'A' && com_env.com_at_buf[1] == 'T')
{
//Test if Enter the AT mode
if(com_env.com_at_len == 3)
{
com_pdu_send(sprintf((char *)at_command_return,"OK\r\n"),at_command_return);
}
else
{
//if it's a AT Command ,send it to at_process_command process.
if(com_env.com_at_buf[2] == '+')
{
com_env.com_at_buf[com_env.com_at_len-1] = '\0';
com_pdu_send(at_process_command(com_env.com_at_buf + 2,at_command_return),at_command_return);
}
else
{
com_pdu_send(sprintf((char *)at_command_return,"AT ERR\r\n"),at_command_return);
}
}
}
else
{
com_pdu_send(sprintf((char *)at_command_return,"AT ERR\r\n"),at_command_return);
}
}
else
{
com_pdu_send(sprintf((char *)at_command_return,"AT ERR\r\n"),at_command_return);
}
//receive continue
com_uart_at_rx_start();
ke_evt_clear(1UL << EVENT_AT_COMMAND_PROC_ID);
}
/**
****************************************************************************************
* @brief ADC sample complete handler
****************************************************************************************
*/
void app_event_adc_sample_cmp_handler(void)
{
int bas_average_adc_value = 0;
int bas_voltage;
uint8_t bas_percentage;
int i;
ke_evt_clear(1UL << EVENT_ADC_SAMPLE_CMP_ID);
// Close ADC and battery monitor
battery_monitor_enable(MASK_DISABLE);
adc_clock_off();
adc_power_off();
// Calculate average value
for(i = 0; i < BASS_SAMPLE_NUMBER; ++i)
bas_average_adc_value += usr_env.bas_reg_buf[i];
bas_average_adc_value /= BASS_SAMPLE_NUMBER;
// When enable ADC decimation, the adc value should div 4
bas_average_adc_value /= 4;
// bas voltage is 4 times
bas_voltage = 4 * ADC_RESULT_mV(bas_average_adc_value);
// Calculate the percentage of remaining battery
if(bas_voltage <= BASS_FULLY_DISCHARGED_VOLTAGE)
{
bas_percentage = 0;
}
else if(bas_voltage >= BASS_FULLY_CHARGED_VOLTAGE)
{
bas_percentage = 100;
}
else
{
bas_percentage = (uint8_t)((bas_voltage - BASS_FULLY_DISCHARGED_VOLTAGE) * 100 /
(BASS_FULLY_CHARGED_VOLTAGE - BASS_FULLY_DISCHARGED_VOLTAGE));
}
QPRINTF("battery:%dmv(%d%%) adc:%d\r\n", bas_voltage, bas_percentage, bas_average_adc_value);
// Update the percentage of remaining battery via bluetooth
app_bass_batt_level_upd_req(app_bass_env->conhdl, 0, bas_percentage);
}
/**
****************************************************************************************
* @brief After-process when one PDU has been sent.
*
****************************************************************************************
*/
void com_tx_done(void)
{
struct ke_msg * msg;
// Clear the event
ke_evt_clear(1<<EVENT_UART_TX_ID);
// Go back to IDLE state
com_env.tx_state = COM_UART_TX_IDLE;
//release current message (which was just sent)
msg = (struct ke_msg *)co_list_pop_front(&com_env.queue_tx);
// Free the kernel message space
ke_msg_free(msg);
// Check if there is a new message pending for transmission
if ((msg = (struct ke_msg *)co_list_pick(&com_env.queue_tx)) != NULL)
{
// Forward the message to the HCI UART for immediate transmission
com_uart_write(msg);
}
}
/**
****************************************************************************************
* @brief ADC sample complete handler
****************************************************************************************
*/
void app_event_adc_sample_cmp_handler(void)
{
ke_evt_clear(1UL << EVENT_ADC_SAMPLE_CMP_ID);
// CLose ADC and temp sensor
temp_sensor_enable(MASK_DISABLE);
adc_clock_off();
adc_power_off();
if(usr_env.is_temp_meas_config && usr_env.is_should_indicate)
{
usr_env.is_should_indicate = false;
app_temp_meas_indicate();
}
if (usr_env.is_temp_imeas_config)
{
app_interm_temp_notify();
}
}
void com_event_uart_rx_timeout_handler(void)
{
ke_timer_set(APP_COM_RX_TIMEOUT_TIMER, TASK_APP, COM_FRAME_TIMEOUT);
ke_evt_clear(1UL << EVENT_UART_RX_TIMEOUT_ID);
}
