4G module EC200A NetworkInfo acquirement and MQTT connection from Xu_Yanghang

it is OK

APP_Framework/Framework/connection/4g/adapter_4g.c

@@ -130,12 +130,19 @@ int Adapter4GTest(void)
     /* Using Public TCP server to  test 4G Socket connection */
     uint8 server_addr[64] = "xyheqmx.e3.luyouxia.net";
     uint8 server_port[64] = "13333";
+    uint8 client_id[64] = "quectel";
+    uint8 username[64] = "test";
+    uint8 password[64] = "test123456";
+    uint8 topic_pub[64] = "/reply";
+    uint8 topic_sub[64] = "/get";
 
     adapter->socket.socket_id = 0;
 
     AdapterDeviceOpen(adapter);
     AdapterDeviceControl(adapter, OPE_INT, &baud_rate);
 
+    AdapterDeviceNetstat(adapter);
+
     AdapterDeviceConnect(adapter, CLIENT, server_addr, server_port, IPV4);
 
     while (1) {
@@ -144,8 +151,19 @@ int Adapter4GTest(void)
         printf("4G recv msg %s\n", recv_msg);
         memset(recv_msg, 0, 256);
     }
+
+    /*
+    AdapterDeviceMqttConnect(adapter, server_addr, server_port, client_id, username, password);
+
+    while (1) {
+        AdapterDeviceMqttSend(adapter, topic_pub, send_msg, strlen(send_msg));
+        AdapterDeviceMqttRecv(adapter, topic_sub, recv_msg, 256);
+        printf("4G mqtt recv msg %s\n", recv_msg);
+        memset(recv_msg, 0, 256);
+    }
+    */
 #endif
 
     return 0;    
 }
-PRIV_SHELL_CMD_FUNCTION(Adapter4GTest, a EC200T or EC200A adpter sample, PRIV_SHELL_CMD_FUNC_ATTR);
+PRIV_SHELL_CMD_FUNCTION(Adapter4GTest, a EC200T or EC200A adapter sample, PRIV_SHELL_CMD_FUNC_ATTR);

APP_Framework/Framework/connection/4g/ec200a/Makefile

@@ -7,7 +7,7 @@ ifeq ($(CONFIG_ADD_NUTTX_FEATURES),y)
 endif
 
 ifeq ($(CONFIG_ADD_XIZI_FEATURES),y)
-    SRC_FILES := ec200a.c
+    SRC_FILES := ec200a.c ec200a_mqtt.c
 
     include $(KERNEL_ROOT)/compiler.mk
 

APP_Framework/Framework/connection/4g/ec200a/SConscript

@@ -4,7 +4,7 @@ import os
 cwd = GetCurrentDir()
 src = []
 if GetDepend(['ADAPTER_EC200A']):
-    src += ['ec200a.c']
+    src += ['ec200a.c', 'ec200a_mqtt.c']
 group = DefineGroup('connection 4g ec200a', src, depend = [], CPPPATH = [cwd])
 
 Return('group')

APP_Framework/Framework/connection/4g/ec200a/ec200a.c

@@ -22,7 +22,7 @@
 #include <at_agent.h>
 
 #define EC200A_AT_MODE_CMD          "+++"
-#define EC200A_GET_QCCID_CMD         "AT+QCCID\r\n"
+#define EC200A_GET_QCCID_CMD        "AT+QCCID\r\n"
 #define EC200A_GET_CPIN_CMD         "AT+CPIN?\r\n"
 #define EC200A_GET_CREG_CMD         "AT+CREG?\r\n"
 #define EC200A_CFG_TCP_CMD          "AT+QICSGP"
@@ -42,6 +42,11 @@
 
 #define TRY_TIMES 10
 
+extern int Ec200aMqttConnect(struct Adapter *adapter, const char *ip, const char *port, const char *client_id, const char *username, const char *password);
+extern int Ec200aMqttDisconnect(struct Adapter *adapter);
+extern int Ec200aMqttSend(struct Adapter *adapter, const char *topic, const void *buf, size_t len);
+extern int Ec200aMqttRecv(struct Adapter *adapter, const char *topic, void *buf, size_t len);
+
 static void Ec200aPowerSet(void)
 {
 #ifdef ADAPTER_EC200A_USING_PWRKEY
@@ -261,6 +266,7 @@ static int Ec200aConnect(struct Adapter *adapter, enum NetRoleType net_role, con
 
     /*step6: serial write "AT+QICLOSE", close socket connect before open socket*/
     memset(ec200a_cmd, 0, sizeof(ec200a_cmd));
+    
     sprintf(ec200a_cmd, EC200A_CLOSE_SOCKET_CMD, adapter->socket.socket_id);
     for(try = 0; try < TRY_TIMES; try++){
         ret = AtCmdConfigAndCheck(adapter->agent, ec200a_cmd, EC200A_OK_REPLY);
@@ -376,8 +382,138 @@ out:
     return -1;
 }
 
-static int Ec200aNetstat() {
+static void extractCarrierInfo(const char *response, struct NetworkInfo *networkInfo)
+{
+    const char *delimiter = "\"";
+    const char *token;
 
+    token = strtok(response, delimiter);
+    token = strtok(NULL, delimiter);
+
+    if (strcmp(token, "CHINA MOBILE") == 0) {
+        networkInfo->carrier_type = CARRIER_CHINA_MOBILE;
+    } else if (strcmp(token, "CHN-UNICOM") == 0) {
+        networkInfo->carrier_type = CARRIER_CHINA_UNICOM;
+    } else if (strcmp(token, "CHN-CT") == 0) {
+        networkInfo->carrier_type = CARRIER_CHINA_TELECOM;
+    } else {
+        networkInfo->carrier_type = CARRIER_UNKNOWN;
+    }
+}
+
+static int Ec200aNetstat(struct Adapter *adapter) {
+    char result[64] = {0};
+
+    struct NetworkInfo info = {
+        .carrier_type = CARRIER_UNKNOWN,
+        .signal_strength = 0,
+        .ip_address = "192.168.1.1"
+    };
+    
+    int ret = 0;
+    int try = 0;
+
+    AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B);
+
+    /*step1: serial write "+++", quit transparent mode*/
+    PrivTaskDelay(1500); //before +++ command, wait at least 1s
+    ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "+++");
+    PrivTaskDelay(1500); //after +++ command, wait at least 1s
+
+    /*step2: serial write "AT+CCID", get SIM ID*/
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, EC200A_GET_QCCID_CMD, EC200A_OK_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    /*step3: serial write "AT+CPIN?", check SIM status*/
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, EC200A_GET_CPIN_CMD, EC200A_READY_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    /*step4: serial write "AT+CREG?", check whether registered to GSM net*/
+    PrivTaskDelay(1000); //before CREG command, wait 1s
+
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, EC200A_GET_CREG_CMD, EC200A_CREG_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    /*step5: serial write "AT+COPS?", get carrier type*/
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtGetNetworkInfoReply(adapter->agent, EC200A_GET_COPS_CMD, result);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+    extractCarrierInfo(result, &info);
+    adapter->network_info.carrier_type = info.carrier_type;
+
+    /*step6: serial write "AT+CSQ", get carrier type*/
+    memset(result, 0, sizeof(result));
+    
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtGetNetworkInfoReply(adapter->agent, EC200A_GET_CSQ_CMD, result);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+    if (sscanf(result, "AT+CSQ\n+CSQ: %d", &info.signal_strength) == 1) {
+        printf("Signal Strength: %d\n", info.signal_strength);
+        adapter->network_info.signal_strength = info.signal_strength;
+    } else {
+        printf("Failed to parse signal strength\n");
+        goto out;
+    }
+
+    /*step7: serial write "AT+CSQ", get carrier type*/
+    memset(result, 0, sizeof(result));
+    
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtGetNetworkInfoReply(adapter->agent, EC200A_GET_POP_IP, result);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+    if (sscanf(result, "AT+CGPADDR=1\n+CGPADDR: 1,\"%15[^\"]\"", info.ip_address) == 1) {
+        printf("IP Address: %s\n", info.ip_address);
+        strcpy(adapter->network_info.ip_address, info.ip_address);
+    } else {
+        printf("Failed to parse IP address\n");
+        goto out;
+    }
+
+    return 0;
+
+out:
+    ADAPTER_DEBUG("Ec200a get netstat failed. Power down\n");
+    ret = AtCmdConfigAndCheck(adapter->agent, EC200A_CLOSE, EC200A_OK_REPLY);
+    return -1;
 }
 
 static const struct IpProtocolDone ec200a_done = 
@@ -396,6 +532,10 @@ static const struct IpProtocolDone ec200a_done =
     .send = Ec200aSend,
     .recv = Ec200aRecv,
     .disconnect = Ec200aDisconnect,
+    .mqttconnect = Ec200aMqttConnect,
+    .mqttdisconnect = Ec200aMqttDisconnect,
+    .mqttsend = Ec200aMqttSend,
+    .mqttrecv = Ec200aMqttRecv,
 };
 
 AdapterProductInfoType Ec200aAttach(struct Adapter *adapter)

APP_Framework/Framework/connection/4g/ec200a/ec200a_mqtt.c

@@ -17,26 +17,230 @@
  * @author AIIT XUOS Lab
  * @date 2024.1.5
  */
+#include <adapter.h>
+#include <at_agent.h>
 
+#define EC200A_GET_QCCID_CMD           "AT+QCCID\r\n"
+#define EC200A_GET_CPIN_CMD            "AT+CPIN?\r\n"
+#define EC200A_GET_CREG_CMD            "AT+CREG?\r\n"
+#define EC200A_CLOSE                   "AT+QPOWD\r\n"
+#define EC200A_SET_MQTT_MODE_CMD       "AT+QMTCFG=\"recv/mode\",0,0,1\r\n"
+#define EC200A_SET_MQTT_SERVER_CMD     "AT+QMTOPEN=0,"
+#define EC200A_SET_MQTT_CONNECT_CMD    "AT+QMTCONN=0,"
+#define EC200A_SET_MQTT_DISCONN_CMD    "AT+QMTDISC=0\r\n"
+#define EC200A_SET_MQTT_PUBEX_CMD      "AT+QMTPUBEX=0,0,0,0,"
+#define EC200A_SET_MQTT_SUB_CMD        "AT+QMTSUB=0,1,"
 
-static int Ec200aMqttOpen() {
+#define EC200A_OK_REPLY                "OK"
+#define EC200A_READY_REPLY             "READY"
+#define EC200A_CREG_REPLY              ",1"
+#define EC200A_PUBEX_REPLY             ">"
 
+#define TRY_TIMES 10
+
+int Ec200aMqttConnect(struct Adapter *adapter, const char *ip, const char *port, const char *client_id, const char *username, const char *password) {
+    int ret = 0;
+    int try = 0;
+    uint8_t ec200a_cmd[64];
+
+    AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B);
+
+    /*step1: serial write "+++", quit transparent mode*/
+    PrivTaskDelay(1500); //before +++ command, wait at least 1s
+    ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "+++");
+    PrivTaskDelay(1500); //after +++ command, wait at least 1s
+
+    /*step2: serial write "AT+CCID", get SIM ID*/
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, EC200A_GET_QCCID_CMD, EC200A_OK_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    /*step3: serial write "AT+CPIN?", check SIM status*/
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, EC200A_GET_CPIN_CMD, EC200A_READY_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    /*step4: serial write "AT+CREG?", check whether registered to GSM net*/
+    PrivTaskDelay(1000); //before CREG command, wait 1s
+
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, EC200A_GET_CREG_CMD, EC200A_CREG_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+     /*step5: serial write "AT+QMTCFG=", config mqtt params*/
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, EC200A_SET_MQTT_MODE_CMD, EC200A_OK_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    /*step6: serial write "AT+OPEN=", config mqtt ip and port*/
+    memset(ec200a_cmd, 0, sizeof(ec200a_cmd)); 
+    strcpy(ec200a_cmd, EC200A_SET_MQTT_SERVER_CMD);
+    strcat(ec200a_cmd, "\"");
+    strcat(ec200a_cmd, ip);
+    strcat(ec200a_cmd, "\",");
+    strcat(ec200a_cmd, port);
+    strcat(ec200a_cmd, "\r\n");
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, ec200a_cmd, EC200A_OK_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    /*step7: serial write "AT+QMTCONN=", config mqtt connection*/
+    PrivTaskDelay(1000); //before mqtt connect command, wait 1s
+
+    memset(ec200a_cmd, 0, sizeof(ec200a_cmd)); 
+    strcpy(ec200a_cmd, EC200A_SET_MQTT_CONNECT_CMD);
+    strcat(ec200a_cmd, "\"");
+    strcat(ec200a_cmd, client_id);
+    strcat(ec200a_cmd, "\",\"");
+    strcat(ec200a_cmd, username);
+    strcat(ec200a_cmd, "\",\"");
+    strcat(ec200a_cmd, password);
+    strcat(ec200a_cmd, "\"\r\n");
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, ec200a_cmd, EC200A_OK_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+
+    ADAPTER_DEBUG("Ec200a mqtt connect done\n");
+
+    return 0;
+
+out:
+    ADAPTER_DEBUG("Ec200a mqtt connect failed. Power down\n");
+    ret = AtCmdConfigAndCheck(adapter->agent, EC200A_CLOSE, EC200A_OK_REPLY);
+    return -1;
 }
 
+int Ec200aMqttDisconnect(struct Adapter *adapter)
+{
+    int ret = 0;
 
-static int Ec200aMqttClose() {
+    AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B);
+    
+    /*step1: serial write "+++", quit transparent mode*/
+    PrivTaskDelay(1500); //before +++ command, wait at least 1s
+    ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "+++");
+    PrivTaskDelay(1500); //after +++ command, wait at least 1s
 
+    /*step2: serial write "AT+QMTDISC", close mqtt connect*/
+    ret = AtCmdConfigAndCheck(adapter->agent, EC200A_SET_MQTT_DISCONN_CMD, EC200A_OK_REPLY);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ADAPTER_DEBUG("Ec200a disconnect mqtt done\n");
+
+    return 0;
+
+out:
+    ADAPTER_DEBUG("Ec200a disconnect mqtt failed. Power down\n");
+    ret = AtCmdConfigAndCheck(adapter->agent, EC200A_CLOSE, EC200A_OK_REPLY);
+    return -1;
 }
 
-static int Ec200aMqttConnect() {
+int Ec200aMqttSend(struct Adapter *adapter, const char *topic, const void *buf, size_t len) {
+    int ret = 0;
+    int try = 0;
+    uint8_t ec200a_cmd[64];
 
+    AtSetReplyEndChar(adapter->agent, 0x3E, 0x20);
+
+    char len_str[10];
+    sprintf(len_str, "%u", len);
+    memset(ec200a_cmd, 0, sizeof(ec200a_cmd)); 
+    strcpy(ec200a_cmd, EC200A_SET_MQTT_PUBEX_CMD);
+    strcat(ec200a_cmd, "\"");
+    strcat(ec200a_cmd, topic);
+    strcat(ec200a_cmd, "\",");
+    strcat(ec200a_cmd, len_str);
+    strcat(ec200a_cmd, "\r\n");
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, ec200a_cmd, EC200A_PUBEX_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+    EntmSend(adapter->agent, buf, len);
+
+    ADAPTER_DEBUG("Ec200a mqtt send done\n");
+
+    return 0;
+
+out:
+    ADAPTER_DEBUG("Ec200a mqtt send failed. Power down\n");
+    ret = AtCmdConfigAndCheck(adapter->agent, EC200A_CLOSE, EC200A_OK_REPLY);
+    return -1;
 }
 
-static int Ec200aMqttSend() {
+int Ec200aMqttRecv(struct Adapter *adapter, const char *topic, void *buf, size_t len) {
+    int ret = 0;
+    int try = 0;
+    uint8_t ec200a_cmd[64];
 
-}
+    AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B);
 
+    memset(ec200a_cmd, 0, sizeof(ec200a_cmd)); 
+    strcpy(ec200a_cmd, EC200A_SET_MQTT_SUB_CMD);
+    strcat(ec200a_cmd, "\"");
+    strcat(ec200a_cmd, topic);
+    strcat(ec200a_cmd, "\",0\r\n");
+    
+    PrivTaskDelay(1000); //before mqtt sub topic command, wait 1s
+    for(try = 0; try < TRY_TIMES; try++){
+        ret = AtCmdConfigAndCheck(adapter->agent, ec200a_cmd, EC200A_OK_REPLY);
+        if (ret == 0) {
+            break;
+        }
+    }
+    if (ret < 0) {
+        goto out;
+    }
+    EntmRecv(adapter->agent, buf, len, 30);
 
-static int Ec200aMqttRecv() {
+    ADAPTER_DEBUG("Ec200a mqtt recv done\n");
 
+    return 0;
+
+out:
+    ADAPTER_DEBUG("Ec200a mqtt recv failed. Power down\n");
+    ret = AtCmdConfigAndCheck(adapter->agent, EC200A_CLOSE, EC200A_OK_REPLY);
+    return -1;
 }

APP_Framework/Framework/connection/adapter.c

@@ -902,3 +902,118 @@ int AdapterDeviceNetstat(struct Adapter *adapter)
     return result;
 }
 
+
+/**
+ * @description: Connect to a certain mqtt server
+ * @param adapter - adapter device pointer
+ * @param ip - connect ip
+ * @param port - connect port
+ * @param client_id - client id
+ * @param username - client username
+ * @param password - client password
+ * @return success: 0 , failure: other
+ */
+int AdapterDeviceMqttConnect(struct Adapter *adapter, const char *ip, const char *port, const char *client_id, const char *username, const char *password)
+{
+    if (!adapter)
+        return -1;
+        
+    if (PRIVATE_PROTOCOL == adapter->net_protocol) {
+        printf("AdapterDeviceMqttConnect not suuport private_protocol, please use join\n");
+        return -1;
+    } else if (IP_PROTOCOL == adapter->net_protocol) {
+        struct IpProtocolDone *ip_done = (struct IpProtocolDone *)adapter->done;
+    
+        if (NULL == ip_done->mqttconnect)
+            return -1;
+    
+        return ip_done->mqttconnect(adapter, ip, port, client_id, username, password);
+    } else {
+        printf("AdapterDeviceMqttConnect net_protocol %d not support\n", adapter->net_protocol);
+        return -1;
+    }
+}
+
+/**
+ * @description: Adapter disconnect from mqtt server 
+ * @param adapter - adapter device pointer
+ * @return success: 0 , failure: other
+ */
+int AdapterDeviceMqttDisconnect(struct Adapter *adapter)
+{
+    if (!adapter)
+        return -1;
+        
+    if (PRIVATE_PROTOCOL == adapter->net_protocol) {
+        printf("AdapterDeviceMqttDisconnect not suuport private_protocol, please use join\n");
+        return -1;
+    } else if (IP_PROTOCOL == adapter->net_protocol) {
+        struct IpProtocolDone *ip_done = (struct IpProtocolDone *)adapter->done;
+    
+        if (NULL == ip_done->mqttdisconnect)
+            return -1;
+    
+        return ip_done->mqttdisconnect(adapter);
+    } else {
+        printf("AdapterDeviceMqttDisconnect net_protocol %d not support\n", adapter->net_protocol);
+        return -1;
+    }
+}
+
+/**
+ * @description: Send data to mqtt server
+ * @param adapter - adapter device pointer
+ * @param topic - publish topic
+ * @param buf - data buffer
+ * @param len - data length
+ * @return length of data written
+ */
+ssize_t AdapterDeviceMqttSend(struct Adapter *adapter, const char *topic, const void *buf, size_t len)
+{
+    if (!adapter)
+        return -1;
+
+    if (PRIVATE_PROTOCOL == adapter->net_protocol) {
+        printf("AdapterDeviceMqttSend not support private_protocol, please use join\n");
+        return -1;
+    } else if (IP_PROTOCOL == adapter->net_protocol) {
+        struct IpProtocolDone *ip_done = (struct IpProtocolDone *)adapter->done;
+    
+        if (NULL == ip_done->mqttsend)
+            return -1;
+    
+        return ip_done->mqttsend(adapter, topic, buf, len);
+    } else {
+        printf("AdapterDeviceMqttSend net_protocol %d not support\n", adapter->net_protocol);
+        return -1;
+    }
+}
+
+/**
+ * @description: Receice data from mqtt server
+ * @param adapter - adapter device pointer
+ * @param topic - subscribe topic
+ * @param buf - buffer to save data
+ * @param len - buffer length
+ * @return gotten data length
+ */
+ssize_t AdapterDeviceMqttRecv(struct Adapter *adapter, const char *topic, void *buf, size_t len)
+{
+    if (!adapter)
+        return -1;
+
+    if (PRIVATE_PROTOCOL == adapter->net_protocol) {
+        printf("AdapterDeviceMqttRecv not support private_protocol, please use join\n");
+        return -1;;
+    } else if (IP_PROTOCOL == adapter->net_protocol) {
+        struct IpProtocolDone *ip_done = (struct IpProtocolDone *)adapter->done;
+    
+        if (NULL == ip_done->mqttrecv)
+            return -1;
+    
+        return ip_done->mqttrecv(adapter, topic, buf, len);
+    } else {
+        printf("AdapterDeviceMqttRecv net_protocol %d not support\n", adapter->net_protocol);
+        return -1;
+    }
+}

APP_Framework/Framework/connection/adapter.h

@@ -118,6 +118,19 @@ enum IpType
     IPV6,
 };
 
+enum CarrierType {
+    CARRIER_CHINA_MOBILE = 1,
+    CARRIER_CHINA_UNICOM,
+    CARRIER_CHINA_TELECOM,
+    CARRIER_UNKNOWN,
+};
+
+struct NetworkInfo {
+    enum CarrierType carrier_type;
+    int signal_strength;
+    char ip_address[16];
+};
+
 struct AdapterData
 {
     uint32 len;
@@ -150,6 +163,10 @@ struct IpProtocolDone
     int (*send)(struct Adapter *adapter, const void *buf, size_t len);
     int (*recv)(struct Adapter *adapter, void *buf, size_t len);
     int (*disconnect)(struct Adapter *adapter);
+    int (*mqttconnect)(struct Adapter *adapter, const char *ip, const char *port, const char *client_id, const char *username, const char *password);
+    int (*mqttdisconnect)(struct Adapter *adapter);
+    int (*mqttsend)(struct Adapter *adapter, const char *topic, const void *buf, size_t len);
+    int (*mqttrecv)(struct Adapter *adapter, const char *topic, const void *buf, size_t len);
 };
 
 struct PrivProtocolDone
@@ -186,6 +203,8 @@ struct Adapter
     enum NetRoleType net_role;
     enum AdapterStatus adapter_status;
 
+    struct NetworkInfo network_info;
+
     char buffer[ADAPTER_BUFFSIZE];
     
     void *done;
@@ -254,6 +273,18 @@ int AdapterDevicePing(struct Adapter *adapter, const char *destination);
 /*Show the net status*/
 int AdapterDeviceNetstat(struct Adapter *adapter);
 
+/*Connect to a certain mqtt server*/
+int AdapterDeviceMqttConnect(struct Adapter *adapter, const char *ip, const char *port, const char *client_id, const char *username, const char *password);
+
+/*Adapter disconnect from mqtt server*/
+int AdapterDeviceMqttDisconnect(struct Adapter *adapter);
+
+/*Send data to mqtt server*/
+ssize_t AdapterDeviceMqttSend(struct Adapter *adapter, const char *topic, const void *buf, size_t len);
+
+/*Receice data from mqtt server*/
+ssize_t AdapterDeviceMqttRecv(struct Adapter *adapter, const char *topic, void *buf, size_t len);
+
 #ifdef __cplusplus
 }
 #endif

APP_Framework/Framework/connection/adapter_agent.c

@@ -225,6 +225,43 @@ __exit:
     return ret;
 }
 
+int AtGetNetworkInfoReply(ATAgentType agent, char *cmd, char *result)
+{
+    int ret = 0;
+    if (NULL == agent || NULL == cmd) {
+        return -1;
+    }
+
+    ATReplyType reply = CreateATReply(256);
+    if (NULL == reply) {
+        printf("%s %d at_create_resp failed!\n",__func__,__LINE__);
+        ret = -1;
+        goto __exit;
+    }
+
+    ret = ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd);
+    if(ret < 0){
+        printf("%s %d ATOrderSend failed.\n",__func__,__LINE__);
+        ret = -1;
+        goto __exit;
+    }
+
+    const char *replyText = GetReplyText(reply);
+    if (replyText == NULL || replyText[0] == '\0') {
+        printf("%s %n get reply failed.\n",__func__,__LINE__);
+        ret = -1;
+        goto __exit;
+    }
+
+    strncpy(result, replyText, 63);
+    result[63] = '\0';
+    printf("[reply result: %s]\n", result);
+
+__exit:
+    DeleteATReply(reply);
+    return ret;
+}
+
 char *GetReplyText(ATReplyType reply)
 {
     return reply->reply_buffer;

APP_Framework/Framework/connection/at_agent.h

@@ -104,5 +104,6 @@ int ParseATReply(char* str, const char *format, ...);
 void DeleteATReply(ATReplyType reply);
 int ATOrderSend(ATAgentType agent, uint32_t timeout_s, ATReplyType reply, const char *cmd_expr, ...);
 int AtCmdConfigAndCheck(ATAgentType agent, char *cmd, char *check);
+int AtGetNetworkInfoReply(ATAgentType agent, char *cmd, char *result);
 
 #endif