/*
* === FUNCTION ======================================================================
* Name: simcom_atcmd_queue_fun_append
* Description: add a group of at cmd to queue
* Input:
* atCmdEntity[]:: at cmd group, can implemnt a function
* Output:
* Return:
* eat_bool::
* author: Jumping create at 2014-1-13
* =====================================================================================
*/
eat_bool simcom_atcmd_queue_fun_append(AtCmdEntity atCmdEntity[],u8 funCount)
{
u8 i = 0;
eat_bool ret = FALSE;
ret = simcom_atcmd_queue_fun_set(funCount);
if(!ret)
return FALSE;
for ( i=0; i<funCount; i++) {
eat_bool ret = FALSE;
ret = simcom_atcmd_queue_append(atCmdEntity[i]);
if (!ret){
break;
}
}
if(i != funCount){ /* error is ocur */
for ( i=funCount; i > 0; i--) {
simcom_atcmd_queue_tail_out();
}
eat_trace("ERROR: add to queue is error!,%d",funCount);
return FALSE;
}
eat_trace("INFO: funFirst:%d funLast:%d", s_atCmdEntityQueue.funFirst, s_atCmdEntityQueue.funLast);
return TRUE;
}
/*
* save setting to flash
*/
eat_bool setting_save(void)
{
FS_HANDLE fh; //File handle
eat_fs_error_enum fs_Op_ret;
UINT writedLen;
eat_trace("setting_save");
fh = eat_fs_Open(SETITINGFILE_NAME, FS_CREATE_ALWAYS | FS_READ_WRITE);
if (fh < EAT_FS_NO_ERROR)
{
eat_trace("eat_fs_Open():Create File Fail,and Return Error is %x", fh);
return EAT_FALSE;
}
else
{
eat_trace("eat_fs_Open():Create File Success,and FileHandle is %x", fh);
fs_Op_ret = (eat_fs_error_enum) eat_fs_Write(fh, &setting, sizeof(SETTING), &writedLen);
if (EAT_FS_NO_ERROR != fs_Op_ret)
{
eat_trace(
"eat_fs_Write():eat_fs_Write File Fail,and Return Error is %d,Readlen is %d",
fs_Op_ret, writedLen);
eat_fs_Close(fh);
return EAT_FALSE;
}
else
{
eat_trace("eat_fs_Write:eat_fs_Write File Success");
eat_fs_Close(fh);
}
}
return EAT_TRUE;
}
/*
* === FUNCTION ======================================================================
* Name: simcom_atcmd_queue_fun_set
* Description: set at cmd func's range,from current id
* Input:
* count:: the count of this at cmd func
* Output:
* Return:
* eat_bool::
* author: Jumping create at 2014-1-17
* =====================================================================================
*/
eat_bool simcom_atcmd_queue_fun_set(u8 funCount)
{
u8 i = 0;
u8 first = MAX(s_atCmdEntityQueue.current,s_atCmdEntityQueue.funFirst);
u8 freeCount = 0;
if (s_atCmdEntityQueue.funLast != s_atCmdEntityQueue.funFirst){
eat_trace("ERROR: fun is exist!");
return FALSE; /* just one func exist */
}
if(simcom_atcmd_queue_is_empty()){
freeCount = AT_CMD_QUEUE_COUNT;
}
else {
freeCount = (first - s_atCmdEntityQueue.last + AT_CMD_QUEUE_COUNT) % AT_CMD_QUEUE_COUNT;
}
if(funCount > freeCount) {
eat_trace("ERROR: the queue is full! %d,%d,%d",first,funCount,freeCount);
return FALSE; /* the space is poor */
}
s_atCmdEntityQueue.funFirst = s_atCmdEntityQueue.last;
s_atCmdEntityQueue.funLast = (s_atCmdEntityQueue.last + funCount - 1 + AT_CMD_QUEUE_COUNT) % AT_CMD_QUEUE_COUNT;
eat_trace("INFO: the at cmd func's range is %d-%d", s_atCmdEntityQueue.funFirst, s_atCmdEntityQueue.funLast);
return TRUE;
}
/*
* === 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 ----- */
}
}
}
eat_bool setting_initial(void)
{
FS_HANDLE fh;
FS_HANDLE seekRet;
eat_fs_error_enum fs_Op_ret;
UINT readLen;
setting.addr_type = ADDR_TYPE_IP;
setting.addr.ipaddr[0] = 120;
setting.addr.ipaddr[1] = 25;
setting.addr.ipaddr[2] = 157;
setting.addr.ipaddr[3] = 233;
fh = eat_fs_Open(SETITINGFILE_NAME, FS_READ_ONLY);
if (fh < EAT_FS_NO_ERROR)
{
LOG_ERROR("Create File Fail,and Return Error is %x", fh);
return EAT_FALSE;
}
else
{
seekRet = eat_fs_Seek(fh, 0, EAT_FS_FILE_BEGIN);
if (0 > seekRet)
{
LOG_ERROR("eat_fs_Seek():Seek File Pointer Fail");
eat_fs_Close(fh);
return EAT_FALSE;
}
else
{
eat_trace("eat_fs_Seek():Seek File Pointer Success");
}
eat_trace("eat_fs_Open():Create File Success,and FileHandle is %x", fh);
fs_Op_ret = (eat_fs_error_enum) eat_fs_Read(fh, &setting, sizeof(SETTING), &readLen);
if (EAT_FS_NO_ERROR != fs_Op_ret)
{
LOG_ERROR("eat_fs_Read() Fail,and Return Error: %d,Readlen is %d", fs_Op_ret, readLen);
eat_fs_Close(fh);
return EAT_FALSE;
}
else
{
eat_fs_Close(fh);
}
}
return EAT_TRUE;
}
/*
* === FUNCTION ======================================================================
* Name: app_at_cmd_envelope
* Description: at cmd deal with thread
* Input:
* data::
* Output:
* Return:
* void::
* author: Jumping create at 2014-1-13
* =====================================================================================
*/
void app_at_cmd_envelope(void *data)
{
EatEvent_st event;
while(EAT_TRUE)
{
eat_get_event_for_user(EAT_USER_1, &event);
switch(event.event)
{
case EAT_EVENT_TIMER :
switch ( event.data.timer.timer_id ) {
case EAT_TIMER_1: /* dealy to excute at cmd */
eat_trace("INFO: EAT_TIMER_1 expire!");
eat_timer1_handler();
break;
case EAT_TIMER_2: /* at cmd time over */
eat_trace("FATAL: at cmd rsp is overtime");
break;
default:
break;
} /* ----- end switch ----- */
break;
case EAT_EVENT_MDM_READY_RD:
eat_modem_ready_read_handler();
break;
case EAT_EVENT_MDM_READY_WR:
if (s_atCmdWriteAgain){
u16 lenAct = 0;
u16 len = strlen(s_atCmdWriteAgain);
lenAct = eat_modem_write(s_atCmdWriteAgain,len);
eat_mem_free(s_atCmdWriteAgain);
if(lenAct<len){
eat_trace("FATAL: modem write buffer is overflow!");
}
}
break;
case EAT_EVENT_USER_MSG:
AtCmdDelayExe(0);
break;
default:
break;
}
}
}
/*
* === FUNCTION ======================================================================
* Name: simcom_atcmd_queue_fun_out
* Description: delete a group of at cmd from queue
* Input:
* Output:
* Return:
* eat_bool::
* author: Jumping create at 2014-1-13
* =====================================================================================
*/
static eat_bool simcom_atcmd_queue_fun_out(void)
{
u8 i = 0;
if (s_atCmdEntityQueue.funLast == 0) /* no at cmd func */
return FALSE;
for ( i=s_atCmdEntityQueue.funFirst ;i<=s_atCmdEntityQueue.funLast ; i++) {
AtCmdEntity* atCmdEnt = NULL;
atCmdEnt = &(s_atCmdEntityQueue.atCmdEntityArray[i]);
if(atCmdEnt->p_atCmdStr){
eat_mem_free(atCmdEnt->p_atCmdStr);
atCmdEnt->p_atCmdStr = NULL;
}
atCmdEnt->p_atCmdCallBack = NULL;
}
if(s_atCmdEntityQueue.current != s_atCmdEntityQueue.funLast){
eat_trace("WARNING: at cmd func over did not at last!");
s_atCmdEntityQueue.current = s_atCmdEntityQueue.funLast;
}
s_atCmdEntityQueue.current = (s_atCmdEntityQueue.current + 1) % AT_CMD_QUEUE_COUNT;
s_atCmdEntityQueue.funLast = 0;
s_atCmdEntityQueue.funFirst = 0;
return TRUE;
}
static AtCmdRsp AtCmdCb_cpin(u8* pRspStr)
{
AtCmdRsp rspValue = AT_RSP_WAIT;
u8 *rspStrTable[ ] = {"ERROR","+CPIN: READY","+CPIN: SIM PIN","+CPIN: "};
s16 rspType = -1;
u8 i = 0;
u8 *p = pRspStr;
while(p) {
/* ignore \r \n */
while ( AT_CMD_CR == *p || AT_CMD_LF == *p)
{
p++;
}
for (i = 0; i < sizeof(rspStrTable) / sizeof(rspStrTable[0]); i++)
{
if (!strncmp(rspStrTable[i], p, strlen(rspStrTable[i])))
{
rspType = i;
break;
}
}
p = (u8*)strchr(p,0x0a);
}
switch (rspType)
{
case 0: /* ERROR */
rspValue = AT_RSP_ERROR;
break;
case 1: /* READY */
rspValue = AT_RSP_STEP+3;
break;
case 2: /* need sim pin */
rspValue = AT_RSP_STEP+1;
break;
default:
break;
}
if(rspValue == AT_RSP_ERROR){
eat_trace("at+cpin? return AT_RSP_ERROR");
if(p_gsmInitCb) {
p_gsmInitCb(EAT_FALSE);
p_gsmInitCb = NULL;
}
}
return rspValue;
}
/*
* === FUNCTION ======================================================================
* Name: AtCmdDelayExe
* Description: dealy 10ms to execute at cmd
* Input:
* Output:
* Return:
* eat_bool::
* author: Jumping create at 2014-1-13
* =====================================================================================
*/
static eat_bool AtCmdDelayExe(u16 delay)
{
eat_bool ret = FALSE;
eat_trace("INFO: at cmd delay execute,%d",delay);
if (delay == 0){
delay = AT_CMD_EXECUTE_DELAY;
}
ret = eat_timer_start(EAT_TIMER_1,delay);
if (ret)
s_atExecute = 1;
return ret;
}
eat_bool eat_timer_process(void)
{
static int index = 0;
char* at_cmd = init_at[index++].cmd;
eat_modem_write(at_cmd , strlen(at_cmd));
eat_trace("index=%d,AT:%s",index, at_cmd);
if( index >= sizeof(init_at)/sizeof(eat_at_st))
{
return EAT_FALSE;
}
return EAT_TRUE;
}
void app_main(void *data)
{
EatEvent_st event;
EatEntryPara_st *para;
event_handler_func func = NULL;
APP_InitRegions();//Init app RAM
APP_init_clib();
para = (EatEntryPara_st*)data;
memcpy(&app_para, para, sizeof(EatEntryPara_st));
eat_trace(" App Main ENTRY update:%d result:%d", app_para.is_update_app,app_para.update_app_result);
if(app_para.is_update_app && app_para.update_app_result)
{
eat_update_app_ok();
}
eat_trace(" app_main ENTRY");
//event_register_handler(EAT_EVENT_TIMER, timer_proc);
//event_register_handler(EAT_EVENT_KEY, key_proc);
event_register_handler(EAT_EVENT_MDM_READY_RD, (event_handler_func)mdm_rx_proc);
//event_register_handler(EAT_EVENT_MDM_READY_WR, mdm_tx_proc);
//event_register_handler(EAT_EVENT_INT, int_proc);
//event_register_handler(EAT_EVENT_UART_READY_RD, uart_rx_proc);
//event_register_handler(EAT_EVENT_UART_READY_WR, uart_tx_proc);
//event_register_handler(EAT_EVENT_UART_SEND_COMPLETE, uart_send_complete_proc);
//event_register_handler(EAT_EVENT_USER_MSG, user_msg_proc);
event_register_handler(EAT_EVENT_ADC, (event_handler_func)adc_event_proc);
while(EAT_TRUE)
{
eat_get_event(&event);
eat_trace("%s-%d:msg %x", __FILE__, __LINE__,event.event);
func = EventHandlerTable[event.event];
if(event.event < EAT_EVENT_NUM && func != NULL)
{
(*func)(&event);
}
}
}
/*
* === FUNCTION ======================================================================
* Name: simcom_atcmd_queue_append
* Description: append a entity at the last of at cmd queue
* Input:
* atCmdEntity:: at cmd entity
* Output:
* Return:
* FALSE: some error is ocur
* TRUE: append success
* author: Jumping create at 2014-1-13
* =====================================================================================
*/
eat_bool simcom_atcmd_queue_append(AtCmdEntity atCmdEntity)
{
/* get first index */
u8 first = MAX(s_atCmdEntityQueue.current,s_atCmdEntityQueue.funFirst);
if (atCmdEntity.p_atCmdStr == NULL){
eat_trace("ERROR: at cmd str is null!");
return FALSE;
}
if (atCmdEntity.p_atCmdCallBack == NULL) /* set default callback function */
atCmdEntity.p_atCmdCallBack = AtCmdCbDefault;
if((s_atCmdEntityQueue.last + 1) % AT_CMD_QUEUE_COUNT == first){
eat_trace("ERROR: at cmd queue is full!");
return FALSE; /* the queue is full */
}
else{
u8* pAtCmd = NULL; ;//= eat_mem_alloc(atCmdEntity.cmdLen);
pAtCmd = eat_mem_alloc(atCmdEntity.cmdLen);
if (!pAtCmd){
eat_trace("ERROR: memory alloc error!");
return FALSE;
}
memcpy(pAtCmd,atCmdEntity.p_atCmdStr,atCmdEntity.cmdLen);
s_atCmdEntityQueue.atCmdEntityArray[s_atCmdEntityQueue.last].cmdLen = atCmdEntity.cmdLen;
s_atCmdEntityQueue.atCmdEntityArray[s_atCmdEntityQueue.last].p_atCmdStr = pAtCmd;
s_atCmdEntityQueue.atCmdEntityArray[s_atCmdEntityQueue.last].p_atCmdCallBack = atCmdEntity.p_atCmdCallBack;
if(simcom_atcmd_queue_is_empty() && s_atExecute == 0) /* add first at cmd and execute it */
eat_send_msg_to_user(0, EAT_USER_1, EAT_FALSE, 1, 0, NULL);
s_atCmdEntityQueue.last = (s_atCmdEntityQueue.last + 1) % AT_CMD_QUEUE_COUNT;
return TRUE;
}
}
eat_bool eat_modem_data_parse(u8* buffer, u16 len, u8* param1, u8* param2)
{
eat_bool ret_val = EAT_FALSE;
u8* buf_ptr = NULL;
/*param:%d,extern_param:%d*/
buf_ptr = (u8*)strstr((const char *)buffer,"param");
if( buf_ptr != NULL)
{
sscanf((const char *)buf_ptr, "param:%d,extern_param:%d",(int*)param1, (int*)param2);
eat_trace("data parse param1:%d param2:%d",*param1, *param2);
ret_val = EAT_TRUE;
}
return ret_val;
}
/*
* === FUNCTION ======================================================================
* Name: eat_timer1_handler
* Description: 1 timer timeout handler
* Input:
* Output:
* Return:
* void::
* author: Jumping create at 2014-1-14
* =====================================================================================
*/
static void eat_timer1_handler(void)
{
u8* pCmd = s_atCmdEntityQueue.atCmdEntityArray[s_atCmdEntityQueue.current].p_atCmdStr;
u16 len = s_atCmdEntityQueue.atCmdEntityArray[s_atCmdEntityQueue.current].cmdLen;
s_atExecute = 0;
if(pCmd){
u16 lenAct = 0;
eat_trace("DEBUG:at cmd is:%d,%s",s_atCmdEntityQueue.current,pCmd);
if (!strncmp(AT_CMD_DELAY, pCmd, strlen(AT_CMD_DELAY))) { /* delay some seconds to run next cmd */
u32 delay;
sscanf(pCmd,AT_CMD_DELAY"%d",&delay);
simcom_atcmd_queue_head_out();
AtCmdDelayExe(delay);
return;
}
lenAct = eat_modem_write(pCmd,len);
if(lenAct<len){
eat_trace("ERROR: modem write buffer is overflow!");
if(s_atCmdWriteAgain == NULL){
s_atCmdWriteAgain = eat_mem_alloc(len-lenAct);
if (s_atCmdWriteAgain)
memcpy(s_atCmdWriteAgain,pCmd+lenAct,len-lenAct);
else
eat_trace("ERROR: mem alloc error!");
}
else
eat_trace("FATAL: EAT_EVENT_MDM_READY_WR may be lost!");
}
else{
eat_trace("WrToModem:%s",pCmd);
AtCmdOverTimeStart();
}
}
}
//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_rx_proc(const EatEvent_st* event)
{
u16 len;
EatUart_enum uart = event->data.uart.uart;
len = eat_uart_read(uart, rx_buf, EAT_UART_RX_BUF_LEN_MAX);
if(len != 0)
{
rx_buf[len] = '\0';
eat_trace("[%s] uart(%d) rx: %s", __FUNCTION__, uart, rx_buf);
#if defined(EAT_AT_TEST)
if (uart == eat_uart_app)
{
eat_modem_write(rx_buf, len);
}
else
#endif
{
eat_uart_write(uart, rx_buf, len);
}
}
}
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;
}
}
}
static AtCmdRsp AtCmdCb_creg(u8* pRspStr)
{
AtCmdRsp rspValue = AT_RSP_WAIT;
u8 *rspStrTable[ ] = {"ERROR","+CREG: "};
s16 rspType = -1;
u8 n = 0;
u8 stat = 0;
u8 i = 0;
u8 *p = pRspStr;
static count = 0;
while(p) {
/* ignore \r \n */
while ( AT_CMD_CR == *p || AT_CMD_LF == *p)
{
p++;
}
for (i = 0; i < sizeof(rspStrTable) / sizeof(rspStrTable[0]); i++)
{
if (!strncmp(rspStrTable[i], p, strlen(rspStrTable[i])))
{
rspType = i;
if (rspType == 1){
sscanf(p+strlen(rspStrTable[rspType]),"%d,%d",&n,&stat);
}
break;
}
}
p = (u8*)strchr(p,0x0a);
}
switch (rspType)
{
case 0: /* ERROR */
rspValue = AT_RSP_ERROR;
break;
case 1: /* +CREG */
if(1 == stat){ /* registered */
rspValue = AT_RSP_STEP+2;
}
else if(2 == stat){ /* searching */
if (count == 3){
eat_trace("at+creg? return AT_RSP_ERROR");
rspValue = AT_RSP_ERROR;
}
else {
rspValue = AT_RSP_STEP-1;
count++;
}
}
else
rspValue = AT_RSP_ERROR;
break;
default:
break;
}
eat_trace("at+creg? return %d",rspValue);
if(rspValue == AT_RSP_ERROR){
if(p_gsmInitCb) {
p_gsmInitCb(EAT_FALSE);
p_gsmInitCb = NULL;
}
}
return rspValue;
}
static void mdm_data_process_single_channel(void)
{
s32 offset = 0;
s32 data_len = 0;
char* substr;
char len_buf[8] = {0};
char tmp[64];
//eat_trace("L%d offset=%d, w_offset=%d r_offset=%d total=%d",__LINE__, offset, w_offset, r_offset,g_data_counter );
while(w_offset!=r_offset)
{
if(w_offset>r_offset)
{
substr = "+IPD,";
offset = bytepos(&g_buf[r_offset],w_offset-r_offset, substr , 0);
eat_trace("L%d offset=%d, w_offset=%d r_offset=%d total=%d",__LINE__, offset, w_offset, r_offset,g_data_counter );
if(offset != -1)
{
r_offset += offset+5; //+IPD,400:data
substr = ":";
offset = bytepos(&g_buf[r_offset],w_offset-r_offset, substr, 0);
eat_trace("L%d offset=%d, w_offset=%d r_offset=%d",__LINE__, offset, w_offset, r_offset);
memset(tmp,0,64);
if(offset != -1)
{
memset(len_buf,0,8);
memcpy(len_buf, &g_buf[r_offset], offset);
data_len = atoi(len_buf);
r_offset += offset+1; //:
eat_trace("L%d datalen=%d last_len=%d",__LINE__,data_len, w_offset-r_offset);
memset(tmp,0,64);
if(data_len<w_offset-r_offset)
{
//两个数据包在一起处理
//eat_uart_write(eat_uart_app, &g_buf[r_offset], data_len);
r_offset += data_len;
g_data_counter += data_len;
sprintf(tmp, "RECV:%d,%d\r\n",g_data_counter, data_len);
eat_uart_write(eat_uart_app, tmp, strlen(tmp));
eat_trace("L%d total=%d", __LINE__,g_data_counter );
continue;
}else if( data_len == w_offset-r_offset)
{
//eat_uart_write(eat_uart_app, &g_buf[r_offset], data_len);
g_data_counter += data_len;
sprintf(tmp, "RECV:%d,%d\r\n",g_data_counter, data_len);
eat_uart_write(eat_uart_app, tmp, strlen(tmp));
eat_trace("L%d total=%d", __LINE__,g_data_counter );
r_offset = 0;
w_offset = 0;
}
else
{
eat_trace("L%d calc data len ERROR!!!! w_offset=%d, r_offset=%d",__LINE__,w_offset,r_offset);
eat_trace("last data=%s",&g_buf[r_offset+data_len]);
w_offset=0;
r_offset=0;
}
}else
{
eat_trace("L%d finds tring ERROR!!!! w_offset=%d, r_offset=%d",__LINE__,w_offset,r_offset);
w_offset=0;
r_offset=0;
}
}else
{
r_offset = 0;
w_offset = 0;
}
}else
{
eat_trace("L%d w_offset=%d, r_offset=%d",__LINE__,w_offset,r_offset);
}
}
}
static void uart_send_complete_proc(const EatEvent_st* event)
{
eat_trace("[%s] uart(%d) send complete", __FUNCTION__, event->data.uart.uart);
}
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);
}
}
}
static AtCmdRsp AtCmdCb_cgatt(u8* pRspStr)
{
AtCmdRsp rspValue = AT_RSP_WAIT;
u8 *rspStrTable[ ] = {"ERROR","+CGATT: 1","+CGATT: 0"};
s16 rspType = -1;
u8 i = 0;
u8 *p = pRspStr;
static count = 0;
while(p) {
/* ignore \r \n */
while ( AT_CMD_CR == *p || AT_CMD_LF == *p)
{
p++;
}
for (i = 0; i < sizeof(rspStrTable) / sizeof(rspStrTable[0]); i++)
{
if (!strncmp(rspStrTable[i], p, strlen(rspStrTable[i])))
{
rspType = i;
break;
}
}
p = (u8*)strchr(p,AT_CMD_LF);
}
switch (rspType)
{
case 0: /* ERROR */
rspValue = AT_RSP_ERROR;
break;
case 1: /* attached */
rspValue = AT_RSP_FUN_OVER;
eat_trace("at+cgatt? return AT_RSP_OK");
if(p_gsmInitCb) {
p_gsmInitCb(TRUE);
p_gsmInitCb = NULL;
}
break;
case 2: /* detached */
if (count == 5){
eat_trace("at+cgatt? return AT_RSP_ERROR");
rspValue = AT_RSP_ERROR;
if(p_gsmInitCb){
p_gsmInitCb(FALSE);
p_gsmInitCb = NULL;
}
}
else
rspValue = AT_RSP_STEP-1;
count ++;
break;
default:
rspValue = AT_RSP_WAIT;
break;
}
return rspValue;
}
