static int event_mod_ready_rd(const EatEvent_st* event)
{
u8 buf[256] = {0};
u16 len = 0;
len = eat_modem_read(buf, 256);
if (!len)
{
LOG_ERROR("modem received nothing.");
return -1;
}
LOG_DEBUG("modem recv: %s", buf);
if(get_manager_ATcmd_state())
{
set_manager_ATcmd_state(EAT_FALSE);
cmd_get_AT(buf);
}
if (modem_IsCallReady(buf))
{
//diag_check(); // because diagnosis is not accurate, remove it
fsm_run(EVT_CALL_READY);
}
if(modem_IsCCIDOK(buf))
{
cmd_SimInfo(buf + 9);//str(AT+CCID\r\n) = 9
}
return 0;
}
/*
* === FUNCTION ======================================================================
* Name: eat_modem_ready_read_handler
* Description: read data handler from modem
* Input:
* Output:
* Return:
* void::
* author: Jumping create at 2014-1-14
* =====================================================================================
*/
static void eat_modem_ready_read_handler(void)
{
u16 len = eat_modem_read(modem_read_buf,MODEM_READ_BUFFER_LEN);
if (len > 0) {
AtCmdRsp atCmdRsp = AT_RSP_ERROR;
memset(modem_read_buf+len,0,MODEM_READ_BUFFER_LEN-len);
/* global urc check */
global_urc_handler(modem_read_buf,len);
/* at cmd rsp check */
eat_trace("ReFrModem:%s,%d",modem_read_buf,len);
if (s_atCmdEntityQueue.atCmdEntityArray[s_atCmdEntityQueue.current].p_atCmdCallBack){
atCmdRsp = s_atCmdEntityQueue.atCmdEntityArray[s_atCmdEntityQueue.current].p_atCmdCallBack(modem_read_buf);
eat_trace("INFO: callback return %d,%d",s_atCmdEntityQueue.current,atCmdRsp);
switch ( atCmdRsp ) {
case AT_RSP_ERROR:
eat_trace("ERROR: at cmd execute error, initial at cmd queue!");
simcom_atcmd_queue_init();
AtCmdOverTimeStop();
break;
case AT_RSP_CONTINUE:
case AT_RSP_FINISH:
simcom_atcmd_queue_head_out();
AtCmdDelayExe(0);
AtCmdOverTimeStop();
break;
case AT_RSP_FUN_OVER:
simcom_atcmd_queue_fun_out();
AtCmdDelayExe(0);
AtCmdOverTimeStop();
break;
case AT_RSP_WAIT:
break;
default:
if(atCmdRsp>=AT_RSP_STEP_MIN && atCmdRsp<=AT_RSP_STEP_MAX) {
s8 step = s_atCmdEntityQueue.current + atCmdRsp - AT_RSP_STEP;
eat_trace("DEBUG: cur %d,step %d",s_atCmdEntityQueue.current,step);
if(step<=s_atCmdEntityQueue.funLast && step>= s_atCmdEntityQueue.funFirst){
s_atCmdEntityQueue.current = step;
AtCmdDelayExe(0);
AtCmdOverTimeStop();
}
else{
eat_trace("ERROR: return of AtCmdRsp is error!");
}
}
break;
} /* ----- end switch ----- */
}
}
}
//Read data from Modem
void mdm_rx_proc(void)
{
u8 buf[2048];
u8 param1,param2;
u16 len = 0;
len = eat_modem_read(buf, 2048);
if(len > 0)
{
//Get the testing parameter
if(eat_modem_data_parse(buf,len,¶m1,¶m2))
{
eat_module_test_adc(param1, param2);
}
else
{
eat_trace("From Mdm:%s",buf);
}
}
}
static void mdm_rx_proc(const EatEvent_st* event)
{
u16 len = 0;
do
{
len = eat_modem_read(rx_buf, EAT_UART_RX_BUF_LEN_MAX );
if( len > 0)
{
rx_buf[len] = '\0';
if(len<50)
eat_trace("[%s] uart(%d) rx from modem: %s", __FUNCTION__, eat_uart_app, rx_buf);
add_mdm_data_to_buf(rx_buf, len);
}
}while(len==EAT_UART_RX_BUF_LEN_MAX );//从modem过来数据未读完
#ifdef EAT_TCP_MULIT_CHANNEL
mdm_data_process();
#else
mdm_data_process_single_channel();
#endif
}
static void uart_ready_wr_proc(void)
{
u16 len;
#if defined(EAT_AT_TEST)
eat_uart_write(eat_uart_app, &rx_buf[wr_uart_offset], wr_uart_len);
do
{
len = eat_modem_read(rx_buf, EAT_UART_RX_BUF_LEN_MAX );
if(len>0)
{
rx_buf[len] = '\0';
//eat_trace("[%s] uart(%d) rx from modem: %s", __FUNCTION__, eat_uart_app, rx_buf);
wr_uart_offset = eat_uart_write(eat_uart_app, rx_buf, len);
if(wr_uart_offset<len)
{
wr_uart_len = len - wr_uart_offset;
break;
}
}
}while(len==EAT_UART_RX_BUF_LEN_MAX );
#endif
}
int event_mod_ready_rd(const EatEvent_st* event)
{
u8 buf[256] = {0};
u16 len = 0;
u8* buf_ptr = NULL;
len = eat_modem_read(buf, 256);
LOG_DEBUG("modem recv: %s", buf);
if (!len)
{
LOG_ERROR("modem receive nothing");
return -1;
}
buf_ptr = (u8*) strstr((const char *) buf, "+CGATT: 1");
if (buf_ptr != NULL)
{
socket_init();
eat_timer_stop(TIMER_AT_CMD);
}
return 0;
}
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;
}
}
}
