sparrow-kit/HARDWARE/4G_SIM7600/sim7600.c.orig

#include "sim7600.h"
#include <stdio.h>
#include <string.h>
#include "fifo.h"
#include "usart.h"
#include "stdlib.h"
#include "timer4.h"

#define ATC_RSP_FINISH 1
#define ATC_RSP_WAIT 0
#define AT_MAX_RESPONSE_TIME 300

#define HTTP_HEADER_CONTENT_TYPE "application/json"
#define MAX_HTTP_SIZE 1000

u8 g_iemi_buf[16];

struct module_buffer {
    u8 *buffer;
    u16 length;
};
struct module_buf {
    u8 *buf;
    u16 length;
};

static struct module_buffer *module_send_data_buffer = NULL;
static module_tcp_connected_callback tcp_connect_cb = NULL;
static module_tcp_sent_callback tcp_sent_cb = NULL;
static module_tcp_recv_callback tcp_recv_cb = NULL;
static module_tcp_disconnected_callback tcp_disconnected_cb = NULL;
static module_http_callback s_http_cb = NULL;

static char s_http_buffer[MAX_HTTP_SIZE];
typedef s8 (*AT_cmdHandle)(BOOL *urc, char* buf);
// 信号强度
static u8 s_csq_value = 0;

typedef struct {
    char *name;
    AT_cmdHandle at_cmd_handler;
} AtcHandlerType;

static s8 at_handler(BOOL *urc, char* buf);
static s8 ate_handler(BOOL *urc, char* buf);
static s8 csq_handler(BOOL *urc, char* buf);
static s8 cpin_handler(BOOL *urc, char *buf);
//static s8 reg_handler(BOOL *urc, char *buf);
//static s8 creg_handler(BOOL *urc, char *buf);
static s8 getip_handler(BOOL *urc, char *buf);

// net open handler
static s8 net_open_handler(BOOL *urc, char* buf);
static s8 net_close_handler(BOOL *urc, char* buf);
static s8 gsn_handler(BOOL *urc, char* buf);

// http handler
static s8 http_send_handler(BOOL *urc, char*buf);
static s8 http_read_handler(BOOL *urc, char*buf);
static s8 cch_open_handle(BOOL *urc, char*buf);
static s8 cch_send_handle(BOOL *urc, char*buf);

// tcp handle.
static s8 tcp_connect_handle(BOOL *urc, char*buf);
static s8 ipsend_handle(BOOL *urc, char*buf);
static s8 urc_handle(BOOL *urc, char *buf);
static s8 tcp_closed_handle(BOOL *urc, char *buf);
static s8 tcp_disconnect_handle(BOOL *urc, char *buf);

// AT Command table
AtcHandlerType atCmdTable[ ] = {
    // 打开或关闭AT指令回显
    {"ATE", ate_handler},
    // 设置本地流量控制
    {"AT+IFC",  at_handler},
    // 输入PIN码
    {"AT+CPIN",   cpin_handler},
    // 查询信号强度
    {"AT+CSQ",  csq_handler},
    // 获取序列号ID
    {"AT+CGSN", gsn_handler},
    // 设置 TCP/IP 应用模式
    // 0: 非透传
    // 1: 命令模式
    {"AT+CIPMODE", at_handler},
    // 打开SOCKET
    {"AT+NETOPEN", net_open_handler},

    {"AT+NETCLOSE", net_close_handler},
    // 查询注册网络状态
    {"AT+CREG", at_handler},
    // 注册 信息
    {"AT+CPSI?", at_handler},
    {"AT+IPADDR", getip_handler},
    // http
    {"AT+CHTTPACT", http_send_handler},


    // tcp
    // 建立tcp连接
    {"AT+CIPOPEN", tcp_connect_handle},
    // 向远端tcp或udp连接发送数据
    {"AT+CIPSEND", ipsend_handle},
    // 关闭tcp或ucp连接
    {"AT+CIPCLOSE", tcp_closed_handle},
    // 设置收到消息时是否显示远程IP和端口
    {"AT+CIPSRIP", at_handler},
    // 在CIPCLOSE指令后调用，关闭所有网络链接
    {"AT+NETCLOSE", at_handler},
		{"AT+CCHSET", at_handler},
		{"AT+CCHSTART", at_handler},
		{"AT+CCHOPEN", cch_open_handle},
		{"AT+CCHSEND", cch_send_handle},
		{"AT+CCHCLOSE", at_handler}, // TODO: consider response after OK.
		{"AT+CCHSTOP", at_handler},
};
AtcHandlerType urc_table[] = {
    {"+IPCLOSE:", tcp_disconnect_handle}
};

struct at_cmd_entity {
    char at_name[20];
    char at_cmd[128];
};

static s8 s_module_status = MODULE_OFF_LINE;
static struct FIFO  s_at_fifo;
static u8 s_at_status = ATC_RSP_FINISH;
static struct at_cmd_entity *s_current_at_command = NULL;

// 发送at指令
static void send_at_command(const char* cmd) {
    Usart2_Send_Data((u8*)cmd, strlen(cmd));
}
// urc 处理函数
static s8 urc_handle(BOOL *urc, char* buf) {
    // //printf("urc handler: %s\n", buf);
    return 0;
}
// at指令返回处理函数
static s8 at_handler(BOOL *urc, char *buf) {
    char *rep_str[] = {"OK", "ERROR"};
    s8 res = -1;
    char *p;
    u8 i = 0;
    p = (char *)buf;
    while ( 'r' == *p || '\n' == *p) {
        p++;
    }
    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:
        s_at_status = ATC_RSP_FINISH;
        break;
    case 1:
        s_at_status = ATC_RSP_FINISH;
        break;
    default:
        break;
    }
    return s_at_status;
}

// CPIN指令返回处理函数
static s8 cpin_handler(BOOL *urc, char *buf) {
    char *rep_str[] = {"OK", "ERROR", "+CPIN: "};
    s8 res = -1;
    char *p;
    u8 i = 0;
    p = (char *)buf;
    while ( 'r' == *p || '\n' == *p) {
        p++;
    }
    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:
        //s_at_status = ATC_RSP_FINISH;
        break;
    case 1:
        //s_at_status = ATC_RSP_FINISH;
        break;
    case 2:
        // 返回ready说明正常
        if(strstr(p, "READY")!=NULL)
        {
            s_at_status = ATC_RSP_FINISH;
        }
        break;
    default:
        break;
    }
    return s_at_status;
}

static s8 csq_handler(BOOL *urc, char *buf) {
    char *rep_str [] = {"OK", "ERROR", "+CSQ: "};
    s8 res = -1;
    char *p;
    u8  i = 0;
    p= (char *)buf;

    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:
        p = strstr(p, "+CSQ: ");
        s_csq_value = atoi(p + strlen("+CSQ: "));
        s_at_status = ATC_RSP_FINISH;
        break;
    case 1:
        s_at_status = ATC_RSP_FINISH;
        break;
    case 2:
        PRINTF("csq:%s\r\n", p);
        s_csq_value = atoi(p + sizeof("+CSQ: "));
        s_at_status = ATC_RSP_FINISH;
        break;
    default:
        break;
    }

    return s_at_status;

}

static s8 getip_handler(BOOL *urc, char *buf) {

    char *rep_str[ ] = {"OK", "ERROR", "+IPADDR: ", "+IP ERROR: "};
    s8 res = -1;
    char *p;
    u8  i = 0;
    p= (char *)buf;
    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:  // OK
    {
        s_at_status = ATC_RSP_FINISH;
        s_module_status = MODULE_GET_IP;
    }
    break;

    case 1: // ERROR
    {

    }
    break;

    case 2:
    {
        s_at_status = ATC_RSP_FINISH;
        s_module_status = MODULE_GET_IP;
    }
    break;
    case 3: // +IP ERROR:
    {
        PRINTF("Net\r\n");
    }
    break;
    default:
        break;
    }
    return s_at_status;
}

static s8 ate_handler(BOOL *urc, char* buf)
{
    char *rep_str[ ] = {"OK","ERROR", "ATE"};
    s8 res = -1;
    char *p;
    u8  i = 0;
    p= (char *)buf;
    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:  // OK
    {
        s_at_status  = ATC_RSP_FINISH;
    }
    break;

    case 1: // ERROR
    {
        s_at_status = ATC_RSP_FINISH;
    }
    break;

    case 2: // ATE
    {
        //printf("open");
    }
    break;

    default:
        break;
    }
    return s_at_status;
}
static s8 gsn_handler(BOOL *urc, char*buf)
{
    char *rep_str[ ] = {"OK","ERROR"};
    s8 res = -1;
    char *p;
    u8  i = 0;
    static u8 flag = 0;
    p= (char *)buf;
    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    if(flag == 0)
    {
        memcpy(g_iemi_buf, p, 15);
        g_iemi_buf[15] = 0;
        PRINTF("g_iemi_buf:%s", g_iemi_buf);
        flag = 1;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:  // OK
    {
        s_at_status  = ATC_RSP_FINISH;
    }
    break;

    case 1: // ERROR
    {
        s_at_status = ATC_RSP_FINISH;
    }
    break;

    default:
        s_at_status = ATC_RSP_FINISH;
        break;
    }
    return s_at_status;
}


static s8 net_open_handler( BOOL *urc, char* buf)
{
    char *rep_str[ ] = {"OK","ERROR", "+NETOPEN: "};
    s8 res = -1;
    char *p;
    u8  i = 0;
    p= (char *)buf;

    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:  // OK
    {

    }
    break;

    case 1: // ERROR
    {
        s_at_status = ATC_RSP_FINISH;
        s_module_status = MODULE_GET_IP;
    }
    break;

    case 2:
    {
        s_at_status = ATC_RSP_FINISH;
        s_module_status = MODULE_GET_IP;
    }
    break;
    default:
        break;
    }

    return s_at_status;
}
static s8 net_close_handler( BOOL *urc, char* buf)
{
    char *rep_str[ ] = {"OK","ERROR", "+NETCLOSE: ", "+IP ERROR: "};
    s8 res = -1;
    char *p;
    u8  i = 0;
    p= (char *)buf;

    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:  // OK
    {
        //s_at_status = ATC_RSP_FINISH;
    }
    break;

    case 1: // ERROR
    {
        // s_at_status = ATC_RSP_FINISH;
    }
    break;

    case 2:
    {
        s_at_status = ATC_RSP_FINISH;
    }
    break;
    case 3: // +IP ERROR
    {
        s_at_status = ATC_RSP_FINISH;
    }
    break;
    default:
        break;
    }

    return s_at_status;
}

static s8 tcp_connect_handle(BOOL *urc, char*buf)
{
    char *rep_str[ ] = {"+CCHOPEN", "ERROR", "OK"};
    s8 res = -1;
    char *p;
    u8  i = 0;
    p= (char *)buf;
    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }
    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:  // CONNECT OK.
    {
        if(tcp_connect_cb != NULL)
        {
            tcp_connect_cb(0, 0);
        }
        s_at_status = ATC_RSP_FINISH;
    }
    break;
    case 1: // ERROR
    {
        //tcp_connect_cb(conn, 1);
        s_at_status = ATC_RSP_FINISH;
    }
    break;
    case 2:
    {

    }
    break;

    default:
        break;
    }

    return s_at_status;
}

s8 ipsend_handle(BOOL *urc, char*buf)
{
    char *rep_str[ ] = {"+CCHSEND:", "ERROR", ">", "OK", "+CCH_PEER_CLOSED:"};
    s8 res = -1;
    char *p;
    u8  i = 0;
    p= (char *)buf;

    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:  //+CCHSEND:
    {
        if(module_send_data_buffer != NULL)
        {
            if(module_send_data_buffer->buffer != NULL)
            {
                free(module_send_data_buffer->buffer);
                module_send_data_buffer->buffer = NULL;
            }
        }
        free(module_send_data_buffer);
        module_send_data_buffer = NULL;
        s_at_status = ATC_RSP_FINISH;
        if(tcp_sent_cb != NULL)
        {
            tcp_sent_cb(0,0);
        }
    }
    break;

    case 1: //ERROR
    {
        if(tcp_sent_cb != NULL)
        {
            tcp_sent_cb(0,-1);
        }
        s_at_status = ATC_RSP_FINISH;
    }
    break;

    case 2: // >
    {
        struct fifo_data* tcp_data_buffer = fifo_get_data(&s_at_fifo);
        //printf("sending.....,%p,\n", module_send_data_buffer);
        if(tcp_data_buffer != NULL)
        {
            Usart2_Send_Data(tcp_data_buffer->buf, tcp_data_buffer->length);
            if(tcp_data_buffer->buf != NULL)
            {
                free(tcp_data_buffer->buf);
                tcp_data_buffer->buf = NULL;
            }
            free(tcp_data_buffer);
            tcp_data_buffer = NULL;
        }

    }
    break;

    case 3: //OK
    {

    }
    break;

    case 4: //+CCH_PEER_CLOSED
    {
        if(tcp_sent_cb != NULL)
        {
            tcp_sent_cb(0,-1);
        }
        s_at_status = ATC_RSP_FINISH;
    }
    break;

    default:
        break;
    }
    return s_at_status;
}
static void show_package(u8 *buf, u16 len) {
    int i = 0;
    PRINTF("Package length: %d\ncontent is: \n", len);

    for (i = 0; i < len; i++)
    {
        PRINTF("%02x ",(uint8_t)buf[i]);
    }

    PRINTF("\n");
}
static int8_t cch_open_handle(bool *urc, char*buf)
{
	// TODO: deal with urc
	char *rep_str[ ] = {"+CCHOPEN", "OK", "ERROR"};
	int8_t res = -1;
	char *p;
	uint8_t  i = 0;
	p= (char *)buf;

	while ( '\r' == *p || '\n' == *p)
	{
		p++;
	}

	for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
	{
		if (strstr( p,rep_str[i]))
	    {
			res = i;
	        break;
	    }
	}

	switch (res)
	{
		case 0:  // +CCHOPEN
	    {
	    	s_at_status = ATC_RSP_FINISH;
	    }
	    break;
	    case 1: // OK
	    {

	    }
	    break;

	    case 2:
	    {
	    	s_at_status = ATC_RSP_FINISH;
	    }
	    break;

	    default:
	    break;
	}
	return s_at_status;
}
static int8_t cch_send_handle(bool *urc, char*buf)
{
	char *rep_str[ ] = {"+CCHRECV", ">", "OK", "ERROR", "+CCHSEND:", "+CCH_PEER_CLOSED:"};
	int8_t res = -1;
	char *p;
	uint8_t  i = 0;
	static  uint16_t s_http_data_len = 0;
	p= (char *)buf;
	
	while ( '\r' == *p || '\n' == *p)
	{
		p++;
	}

	for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
	{
		if (strstr( p,rep_str[i]))
	    {
			res = i;
	        break;
	    }
	}
	
	switch (res)
	{
		case 0:  // +HTTPSRECV:
	    {
	    	// check response length.
	    	p = strstr(p, "+CCHRECV: DATA,1,");
	    	p = p + strlen("+CCHRECV: DATA,1,");
	    	int response_len = atoi(p);
	    	if(response_len>1000)
	    	{
	    		printf("response size is illegal:%d!\n", response_len);
	    		if(s_http_cb != NULL)
	    		{
	    			s_http_cb(NULL);
	    		}
	    		s_at_status = ATC_RSP_FINISH;
	    		return -1;
	    	}
			p = strstr(p, "\r\n");
			p = p + strlen("\r\n");
			memcpy(s_http_buffer + s_http_data_len, p, response_len);
			s_http_data_len += response_len;		
	    }
	    break;
	    case 1: // >
	    {
			struct fifo_data* http_post_data;
	        http_post_data = fifo_get_data(&s_at_fifo);
	        if(http_post_data != NULL)
	        {
	        	printf("sending.....\n");
	        	usart2_send(http_post_data->buf, http_post_data->length);
	        	if(http_post_data->buf != NULL)
	        	{
	        		myfree(http_post_data->buf);
	        		http_post_data->buf = NULL;
	        	}
	        	myfree(http_post_data);
	        	http_post_data = NULL;
	        }
	    }
	    break;

	    case 2:
	    {

	    }
	    break;

	    case 3:
	    {
			//TODO: consider error situation.
	        s_at_status = ATC_RSP_FINISH;
	    }
	    break;

	    case 4:
	    {

	    }
	    break;
			
		case 5:
		{
			// check http protocol.
			char* http_response_buffer = NULL;
			const char * version = "HTTP/1.1 ";
			printf("receive:%s\n", s_http_buffer);
			p = strstr(s_http_buffer, version);
	        if (p == NULL)
	        {
	        	printf("Invalid version in %s\n", p);
	        	if(s_http_cb != NULL)
	        	{
	        		s_http_cb(NULL);
	        	}
	        	s_at_status = ATC_RSP_FINISH;
	        	return -1;
	        }

	        // check http status.
	        int http_status = atoi(p + strlen(version));
	        if(http_status != 200)
	        {
	        	printf("Invalid version in %s\n", p);
	        	if(s_http_cb != NULL)
	        	{
	        		s_http_cb(NULL);
	        	}
	        	s_at_status = ATC_RSP_FINISH;
	        	return -1;
	        }

	        http_response_buffer = (char *)strstr(p, "\r\n\r\n") + 4;
			s_http_data_len = 0;
	        s_at_status = ATC_RSP_FINISH;
	        if(s_http_cb != NULL)
	        {
	        	s_http_cb(http_response_buffer);
	        }
		}
    
		default:
	    break;
	}
	return s_at_status;
}
static s8 http_send_handler(BOOL *urc, char *buf) {
    char *rep_str[] = {"+CHTTPACT: REQUEST", "+CHTTPACT: DATA,", "ERROR", "+CHTTPACT: 0"};
    int8_t res = -1;
    char *p;
    uint8_t  i = 0;
    static  uint16_t s_http_data_len = 0;
    p= (char *)buf;

    while ( '\r' == *p || '\n' == *p)
    {
        p++;
    }

    for (i = 0; i < sizeof(rep_str) / sizeof(rep_str[0]); i++)
    {
        if (strstr( p,rep_str[i]))
        {
            res = i;
            break;
        }
    }

    switch (res)
    {
    case 0:
    {
        struct fifo_data* http_post_data;
        http_post_data = fifo_get_data(&s_at_fifo);
        if(http_post_data != NULL)
        {
            PRINTF("sending Data:%s\r\n", http_post_data->buf);
            Usart2_Send_Data(http_post_data->buf, http_post_data->length);
            if(http_post_data->buf != NULL)
            {
                free(http_post_data->buf);
                http_post_data->buf = NULL;
            }
            free(http_post_data);
            http_post_data = NULL;
        }
    }
    break;
    case 1: // get response
    {
        p = strstr(p, "+CHTTPACT: DATA,");
        p = p + strlen("+CHTTPACT: DATA,");
        int response_len = atoi(p);
        PRINTF("response size is :%d!\n", response_len);
        if(response_len>10000)
        {
            //printf("response size is illegal:%d!\n", response_len);
            if(s_http_cb != NULL)
            {
                s_http_cb(NULL);
            }
            s_at_status = ATC_RSP_WAIT;
            return s_at_status;
        }
        p = strstr(p, "\r\n");
        p = p + strlen("\r\n");
        memcpy(s_http_buffer + s_http_data_len, p,response_len);
        s_http_data_len += response_len;
    }
    break;
    case 2: //error
        s_at_status = ATC_RSP_FINISH;
        break;
    case 3:
    {
        char *http_response_buffer = NULL;
        const char *version = "http/1.1 ";
        PRINTF("http recive:%s\n", s_http_buffer);
        p = strstr(s_http_buffer, version);
        if (p == NULL) {
            PRINTF("Invalid version in %s\n", p);
            if(s_http_cb != NULL) {
                s_http_cb(NULL);
            }
            s_at_status = ATC_RSP_WAIT;
            return s_at_status;
        }
        // check http response code
        int http_status = atoi(p + strlen(version));
        if(http_status != 200) {
            PRINTF("response code error is %d, not 200", http_status);
            if(s_http_cb != NULL) {
                s_http_cb(NULL);
            }
            s_at_status = ATC_RSP_WAIT;
            return s_at_status;
        }
        http_response_buffer = (char *)strstr(p, "\r\n\r\n") + 4;
        PRINTF("get http response:%s", http_response_buffer);
        s_http_data_len = 0;
        s_at_status = ATC_RSP_FINISH;
        if(s_http_cb != NULL)
        {
            s_http_cb(http_response_buffer);
        }
    }
    break;
    default:
        break;
    }
    return s_at_status;
}



u8 inquire_signal_quality(void)
{
    add_send_at_command("AT+CSQ", "AT+CSQ\r\n");
    return s_csq_value;
}


// void module_tcp_connect(u16 fd, uint32_t ip, u16 port)
// {
// 	char connect_buf[80];
// 	u8 ip1, ip2, ip3, ip4;
// 	ip1 = ((u8*)(&ip))[0];
// 	ip2 = ((u8*)(&ip))[1];
// 	ip3 = ((u8*)(&ip))[2];
// 	ip4 = ((u8*)(&ip))[3];
// 	// AT+CCHSET.
// 	add_send_at_command("AT+CCHSET", "AT+CCHSET=1\r\n");

// 	// AT+CCHSTART.
// 	add_send_at_command("AT+CCHSTART", "AT+CCHSTART\r\n");

// 	// AT+CCHOPEN.
// 	sprintf(connect_buf, "AT+CCHOPEN=%d,\"%d.%d.%d.%d\",%d, 2\r\n", 1, ip1, ip2, ip3, ip4, port);
// 	//printf("tcp connecting:%s\n", connect_buf);
// 	add_send_at_command("AT+CCHOPEN_TLS", connect_buf);
// }

static s8 tcp_closed_handle(BOOL *urc, char *buf)
{
    if(tcp_disconnected_cb != NULL)
    {
        tcp_disconnected_cb(0, -1);
    }
    return -1;
}
static s8 tcp_disconnect_handle(BOOL *urc, char *buf)
{
    if(tcp_disconnected_cb != NULL)
    {
        tcp_disconnected_cb(0, -1);
    }
    return -1;
}
void register_module_tcp_connect_callback(u16 fd, module_tcp_connected_callback connect_cb)
{
    tcp_connect_cb = connect_cb;
}

void register_module_tcp_sent_callback(u16 fd, module_tcp_sent_callback sent_callback)
{
    tcp_sent_cb = sent_callback;
}

void register_module_tcp_recv_callback(u16 fd, module_tcp_recv_callback recv_callback)
{
    tcp_recv_cb = recv_callback;
}

void register_module_tcp_disconnected_callback(u16 fd, module_tcp_disconnected_callback tcp_disconnected_callback)
{
    tcp_disconnected_cb = tcp_disconnected_callback;
}



// fifo 定时检测
static s8 at_fifo_check(void *arg)
{

    static s8 wait_response_tick = 0;

    if(s_module_status == MODULE_START)
    {
        PRINTF("start send AT\r\n")
        send_at_command("AT\r\n");
    }
    else if(MODULE_INIT ==s_module_status|| MODULE_INIT_DONE == s_module_status)
    {
        if ((NULL == s_current_at_command))
        {
            if ((!FIFO_isEmpty(&s_at_fifo)) &&(s_at_status == ATC_RSP_FINISH))
            {
                s_current_at_command = (struct at_cmd_entity*)malloc(sizeof(struct at_cmd_entity));
                if (FIFO_Get(&s_at_fifo, s_current_at_command->at_name,  s_current_at_command->at_cmd))
                {
                    s_at_status = ATC_RSP_WAIT;
                    send_at_command(s_current_at_command->at_cmd);
                }
            }
            else
            {
                PRINTF("fifo is empty or the previous at command not complete!\r\n");
            }
        }
        else
        {
            // PRINTF("sending:%s",  s_current_at_command->at_cmd);

            //send
            //send_at_command(s_current_at_command->at_cmd);
            if(wait_response_tick > (s8)AT_MAX_RESPONSE_TIME)
            {

            }
            wait_response_tick++;

        }
    }
    return 0;
}

// 模块启动
u8 module_system_start(void)
{
    s_module_status = MODULE_START;
    timer3_init(1000, 1, at_fifo_check);
    timer3_start();
    return s_module_status;
}

// 模块初始化
u8 module_system_init()
{

    Usart_Send_Str_Data("module_init!!!\r\n");
    FIFO_Init (&s_at_fifo);

    add_send_at_command("ATE", "ATE0\r\n");
    //AT+IFC=0, set no flow control.
    //add_send_at_command("AT+IFC", "AT+IFC=0\r\n");

    //AT+CPIN, query .....
    add_send_at_command("AT+CPIN", "AT+CPIN?\r\n");

    //AT+CSQ
    add_send_at_command("AT+CSQ", "AT+CSQ\r\n");

    //AT+GSN  request for the IMEI of the module.;
    add_send_at_command("AT+CGSN", "AT+CGSN\r\n");

    //AT+CREG
    //add_send_at_command("AT+CREG", "AT+CREG?\r\n");
    // AT+CGREG?
    //add_send_at_command("AT+CGREG", "AT+CGREG?\r\n");
    //AT+CIPMODE
    add_send_at_command("AT+CIPMODE", "AT+CIPMODE=0\r\n");

    //AT+NETCLOSE关闭上次开启的网络
    add_send_at_command("AT+NETCLOSE", "AT+NETCLOSE\r\n");
    //AT+NETOPEN开启网络
    add_send_at_command("AT+NETOPEN", "AT+NETOPEN\r\n");
    //AT+IPADDR获取模块IP地址
    //add_send_at_command("AT+IPADDR", "AT+IPADDR\r\n");

    s_module_status = MODULE_INIT;
    return s_module_status;
}

// 获取模块状态
s8 get_module_status()
{
    return s_module_status;
}
// 设置模块 状态
void set_module_status(s8 status)
{
    s_module_status = status;
}

void add_send_at_command(char *name_buffer, char *cmd_buffer)
{
    char at_cmd_Buff[64] = {0};
    char at_name_Buff[20] = {0};

    strcpy(at_name_Buff, name_buffer);
    strcpy(at_cmd_Buff, cmd_buffer);

    if(FIFO_Put(&s_at_fifo, at_name_Buff,  at_cmd_Buff) ==-1)
    {
        PRINTF("write fifo error!\r\n");
    }
}


// 模块发送http post 请求
void module_http_post(const char *url, const char *data, module_http_callback http_cb)
{
    s_http_cb = http_cb;

    char host_name[64] = "";
    char http_path[64] = "";
    int port = 80;
    BOOL is_http  = strncmp(url, "http://",  strlen("http://"))  == 0;
    BOOL is_https = strncmp(url, "https://", strlen("https://")) == 0;

    if (is_http)
        url += strlen("http://"); // Get rid of the protocol.
    else if (is_https)
    {
        url += strlen("https://"); // Get rid of the protocol.
    }
    else
    {
        PRINTF("url is not http:// or https://")
        return;
    }

    char * path = strchr(url, '/');
    if (path == NULL)
    {
        path = strchr(url, '\0'); // Pointer to end of string.
    }

    char *colon = strchr(url, ':');
    if(colon > path) {
        colon = NULL;
    }
    if (colon == NULL) {
        memcpy(host_name, url, path - url);
    } else {
        port = atoi(colon + 1);
        if (port == 0) {
            //printf("Port error %s\n", url);
            return;
        }

        memcpy(host_name, url, colon - url);
        host_name[colon - url] = '\0';
    }

    host_name[path - url] = '\0';
    memcpy(http_path, path, strlen(url)- strlen(host_name));

    PRINTF("host_name:%s\n", host_name);
    PRINTF("http_path:%s\n", http_path);
    PRINTF("http_port:%d\n", port);

		
		// AT+CCHSET.
	add_send_at_command("AT+CCHSET", "AT+CCHSET=1\r\n");

	// AT+CCHSTART.
	add_send_at_command("AT+CCHSTART", "AT+CCHSTART\r\n");
		
    char http_url[64];
    memset(http_url, 0x0, sizeof(http_url));
    sprintf(http_url, "AT+CCHOPEN=%d,\"%s\",%d,1\r\n", 1, host_name, port);
    PRINTF("ready to http post:%s", http_url);
    add_send_at_command("AT+CCHOPEN", http_url);
    char post_headers[128] = "";
		char at_send_buffer[20] = "";
    sprintf(post_headers,
            "Content-Type:"
            HTTP_HEADER_CONTENT_TYPE
            "\r\n"
            "Content-Length: %d\r\n", strlen(data));
    struct fifo_data* http_post_data =(struct fifo_data*)malloc(sizeof(struct fifo_data));
    http_post_data->buf =(uint8_t*)malloc(512);

    int len = sprintf((char*)http_post_data->buf,
                      "POST %s HTTP/1.1\r\n"
                      "Host: %s:%d\r\n"
                      "Connection: close\r\n"
                      "User-Agent: SIM7600\r\n"
                      "%s"
                      "\r\n%s",
                      http_path, host_name, port, post_headers, data);
    http_post_data->length = len;
    PRINTF("http post:%s", http_post_data->buf);
		sprintf(at_send_buffer, "AT+CCHSEND=%d,%d\r\n", 1, len);
		add_send_at_command("AT+CCHSEND", at_send_buffer);
    fifo_put_data(&s_at_fifo, http_post_data);

		// AT+CCHCLOSE
		add_send_at_command("AT+CCHCLOSE", "AT+CCHCLOSE=1\r\n");

	// AT+CCHSTOP
		add_send_at_command("AT+CCHSTOP", "AT+CCHSTOP\r\n");
}

static s8 data_process(struct module_buf *buf)
{
    struct module_buf *data_buf = buf;
    u8 *p = data_buf->buf;
    if(strncmp((char*)data_buf->buf, "http/1.1", strlen("http/1.1")) == 0)
    {
        memcpy(s_http_buffer, p, data_buf->length);
        return 1;
    }

    else
    {
        return 0;
    }
}

// 模块返回数据处理
s8 module_data_handler(void* data)
{
    u8 urc = 0;
    struct module_buf* module_data = (struct module_buf*)data;
    if(module_data->length < 3)
    {
        PRINTF("module response not enough length!\r\n");
        if(module_data != NULL)
        {
            if(module_data->buf != NULL)
            {
                free(module_data->buf);
                module_data->buf = NULL;
            }
            free(module_data);
            module_data = NULL;
        }
        return -1;
    }

    if(MODULE_START == s_module_status)
    {
        if((strstr((char*)module_data->buf, "OK")))
        {
            Usart_Send_Str_Data("the \"at\" cmd response \"OK\"\r\n");
            s_module_status = MODULE_SYNC;
        }
    }
    if (MODULE_INIT ==s_module_status|| MODULE_INIT_DONE == s_module_status)
    {
        int i = 0;
        if (NULL != s_current_at_command)
        {
            for (i = 0; i <sizeof(atCmdTable)/sizeof(atCmdTable[0]); i++)
            {
                if(!strcmp(s_current_at_command->at_name, atCmdTable[i].name))
                {

                    s_at_status =atCmdTable[i].at_cmd_handler(&urc, (char*)module_data->buf);

                    if (ATC_RSP_FINISH ==s_at_status)
                    {
                        free(s_current_at_command);
                        s_current_at_command = NULL;
                    }

                    break;
                }
            }
        }
        else
        {
					// http response
					if(data_process(module_data)==1)
					{
						
					}
        }
    }

    if(module_data != NULL)
    {
        Usart_Send_Str_Data("free\r\n");
        if(module_data->buf != NULL)
        {
            free(module_data->buf);
            module_data->buf = NULL;
        }
        free(module_data);
        module_data = NULL;
    }

    return 0;
}