static void app_main(void *data)
{
EatUartConfig_st uart_config;
EatEvent_st event;
int event_num = 0;
APP_InitRegions(); //APP RAM initialize
APP_init_clib(); //C library initialize
if(eat_uart_open(eat_uart_app ) == EAT_FALSE)
{
eat_trace("[%s] uart(%d) open fail!", __FUNCTION__, eat_uart_app);
}
uart_config.baud = EAT_UART_BAUD_115200;
uart_config.dataBits = EAT_UART_DATA_BITS_8;
uart_config.parity = EAT_UART_PARITY_NONE;
uart_config.stopBits = EAT_UART_STOP_BITS_1;
if(EAT_FALSE == eat_uart_set_config(eat_uart_app, &uart_config))
{
eat_trace("[%s] uart(%d) set config fail!", __FUNCTION__, eat_uart_app);
}
//eat_uart_set_send_complete_event(eat_uart_app, EAT_TRUE);
eat_timer_start(EAT_TIMER_1, 10000);
while(1)
{
event_num = eat_get_event_num();
get_event:
if(event_num>0)
{
eat_get_event(&event);
eat_trace("[%s] event_id=%d", __FUNCTION__, event.event);
if (event.event == EAT_EVENT_NULL || event.event >= EAT_EVENT_NUM)
{
eat_trace("[%s] invalid event type", __FUNCTION__, event.event);
continue;
}
switch (event.event)
{
case EAT_EVENT_TIMER :
{
//Restart timer
if(event.data.timer.timer_id == EAT_TIMER_2)
{
eat_timer_start(EAT_TIMER_2, 50);
}else
{
if(eat_timer_process())
eat_timer_start(event.data.timer.timer_id, 6000);
else
eat_timer_start(EAT_TIMER_2, 50);
}
// eat_trace("Timer test 1, timer ID:%d", event.data.timer.timer_id);
}
break;
case EAT_EVENT_MDM_READY_RD:
mdm_rx_proc(&event);
break;
case EAT_EVENT_MDM_READY_WR:
eat_trace("[%s] uart(%d) event :%s", __FUNCTION__, event.data.uart, "EAT_EVENT_MDM_READY_WR");
break;
case EAT_EVENT_UART_READY_RD:
uart_rx_proc(&event);
break;
case EAT_EVENT_UART_READY_WR:
eat_trace("[%s] uart(%d) event :%s", __FUNCTION__, event.data.uart, "EAT_EVENT_UART_READY_WR");
uart_ready_wr_proc();
break;
case EAT_EVENT_UART_SEND_COMPLETE:
uart_send_complete_proc(&event);
break;
default:
break;
}
event_num = eat_get_event_num();
if(event_num>0)
goto get_event;
else
eat_sleep(50);
}else
{
eat_sleep(50);
}
}
}
void app_main(void *data)
{
EatEvent_st event;
u16 len = 0;
EatUartConfig_st uart_config;
eat_bool ret;
APP_InitRegions();//Init app RAM
APP_init_clib(); //C library initialize, second step
#if 0
if(eat_uart_open(EAT_UART_1 ) == EAT_FALSE)
{
eat_trace("[%s] uart(%d) open fail!", __FUNCTION__, EAT_UART_1);
}
uart_config.baud = EAT_UART_BAUD_115200;
uart_config.dataBits = EAT_UART_DATA_BITS_8;
uart_config.parity = EAT_UART_PARITY_NONE;
uart_config.stopBits = EAT_UART_STOP_BITS_1;
if(EAT_FALSE == eat_uart_set_config(EAT_UART_1, &uart_config))
{
eat_trace("[%s] uart(%d) set config fail!", __FUNCTION__, EAT_UART_1);
}
#endif
log_0("app_main ENTRY");
Gpio_init();
ret = eat_mem_init(s_memPool,EAT_MEM_MAX_SIZE);
if (!ret)
log_0("ERROR: eat memory initial error!");
eat_timer_start(TIMER_SOFT_RESET,600000);
at_cluster();
while(EAT_TRUE)
{
eat_get_event(&event);
log_2("MSG id%x", event.event);
switch(event.event)
{
case EAT_EVENT_TIMER :
{
EatTimer_enum timer_id = event.data.timer.timer_id;
timer_hdlr(timer_id);
}
break;
case EAT_EVENT_INT :
log_0("INTERRUPT IS COMING");
if(get_key())/*donw = 1 */
key_hdlr();
break;
case EAT_EVENT_USER_MSG:
{
u8 data = event.data.user_msg.data[0];
set_debounce(data);
}
break;
case EAT_EVENT_KEY:
{
eat_bool press = event.data.key.is_pressed;
log_0("power key");
pwrkey_hdlr(press);
}
break;
case EAT_EVENT_MDM_READY_WR:
break;
case EAT_EVENT_UART_READY_RD:
log_2("EAT_EVENT_UART_READY_RD");
break;
case EAT_EVENT_MDM_READY_RD:
{
len = 0;
/* boot info(such as:RDY ;+CFUN: 1 ;+CPIN: READY)
* will be sent to here(main task);
*/
len = eat_modem_read(buf, 2048); /*necessary:Read it out*/
buf[len] = 0;
log_2("main task buf (%s)",buf);
#if 0
if(core_is_ready(buf))
{
eat_trace("core is ready");
eat_timer_start(TIMER_SOFT_RESET,600000);
at_cluster();
}
#endif
}
break;
case EAT_EVENT_UART_SEND_COMPLETE :
break;
default:
break;
}
}
}
