Revision 95:290859010c8c, committed 2019-04-17

Comitter:

ocomeni

Date:

Wed Apr 17 18:11:45 2019 +0000

Parent:

94:fb4414aff957

Child:

96:f5ed273881af

Commit message:

response format for the following command implemented:; - AT+UWSCA; - AT+UNSTAT=0; - AT+UWSSTAT

Changed in this revision

--- a/source/ATCmdManager.cpp	Sun Apr 14 17:03:02 2019 +0000
+++ b/source/ATCmdManager.cpp	Wed Apr 17 18:11:45 2019 +0000
@@ -54,12 +54,15 @@
     _parser.oob("AT+CPWROFF", callback(this, &ATCmdManager::_oob_reboot));
     _parser.oob("AT+CGMR", callback(this, &ATCmdManager::_oob_get_fw_ver));
     _parser.oob("AT+UWSCAN", callback(this, &ATCmdManager::_oob_scanWiFiNetworks));
-    _parser.oob("AT+UWSCA=", callback(this, &ATCmdManager::_oob_connect2WiFiNetwork));
-    _parser.oob("AT+UWSCD=", callback(this, &ATCmdManager::_oob_disconnectWiFiNetwork));
+    _parser.oob("AT+UWSCA=", callback(this, &ATCmdManager::_oob_WiFiStationConfigurationAction));
+    //_parser.oob("AT+UWSCD=", callback(this, &ATCmdManager::_oob_disconnectWiFiNetwork));
     _parser.oob("AT+UDDRP", callback(this, &ATCmdManager::_oob_setupInternetConnection));
     _parser.oob("AT+UWSC=0,2", callback(this, &ATCmdManager::_oob_setWiFiSSID));
     _parser.oob("AT+UWSC=0,8", callback(this, &ATCmdManager::_oob_setWiFiPWD));
     _parser.oob("AT+UWSC=0,5", callback(this, &ATCmdManager::_oob_setWiFiSecurity));
+    _parser.oob("AT+UNSTAT=", callback(this, &ATCmdManager::_oob_getNetworkStatus));
+    _parser.oob("AT+UWSSTAT", callback(this, &ATCmdManager::_oob_WiFiNetworkStatus));
+    
     //_parser.oob("AT+UWSC=0,5", callback(this, &ATCmdManager::_oob_sendHttpMessage));
  
     printf("\n --- ATCmdManager constructor completed ---\n");
@@ -83,6 +86,7 @@
 void ATCmdManager::processResponses(){
         dequeueATresponse();
         dequeueWiFidataResponse();
+        char * respStr;
         switch(at_resp){
             case AT_RESP_NONE:
                 // IDLE response state
@@ -90,34 +94,42 @@
             case AT_SCAN_RESP:
                 // AT_SCAN_RESP response state
                 printf("\n [ATCMD MAN] WIFI SCAN RESPONSE RECEIVED!!\n");
-                _smutex.lock();
-                _parser.send(OK_RESP);
-                _smutex.unlock();
+                //_smutex.lock();
+                //sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+                //_smutex.unlock();
+                respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_DETAILED_SCAN_RESP:
                 // AT_DETAILED_SCAN_RESP response state
                 printf("\n [ATCMD MAN] WIFI DETAILED SCAN RESPONSE RECEIVED!!\n");
-                _smutex.lock();
-                _parser.send(OK_RESP);
-                _smutex.unlock();
+                //_smutex.lock();
+                //sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+                //_smutex.unlock();
+                respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_CONNECT_RESP:  
                 // AT_CONNECT_RESP response state 
                 printf("\n [ATCMD MAN] WIFI CONNECT RESPONSE RECEIVED!!\n");
-                _smutex.lock();
-                _parser.send(OK_RESP);
-                _smutex.unlock();
+                //_smutex.lock();
+                //sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+                respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
+                //_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_DISCONNECT_RESP:  
                 // AT_DISCONNECT_RESP response state 
                 //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI DISCONNECT RESPONSE RECEIVED!!\n");
-                _smutex.lock();
-                _parser.send(OK_RESP);
-                _smutex.unlock();
+                //_smutex.lock();
+                //sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+                //_smutex.unlock();
+                respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_CONFIG_RESP:  
@@ -125,16 +137,34 @@
                 //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI CONFIG RESPONSE RECEIVED!!\n");
                 _smutex.lock();
-                _parser.send(OK_RESP);
+                sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
                 _smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
+            case AT_NETWORK_STATUS_RESP:  
+                // AT_CONFIG_RESP response state 
+                //////_smutex.lock();
+                printf("\n [ATCMD MAN] NETWORK STATUS RESPONSE RECEIVED!!\n");
+                respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
+                at_resp = AT_RESP_NONE;
+                break;
+            case AT_WIFI_STATUS_RESP:  
+                // AT_CONFIG_RESP response state 
+                //////_smutex.lock();
+                printf("\n [ATCMD MAN] WIFI RESPONSE RECEIVED!!\n");
+                respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
+                at_resp = AT_RESP_NONE;
+                break;
             case AT_INTERNET_CONFIG_RESP:  
                 // AT_CONFIG_RESP response state 
                 printf("\n [ATCMD MAN] WIFI INTERNET_CONFIG RESPONSE RECEIVED!!\n");
-                _smutex.lock();
-                _parser.send(OK_RESP);
-                _smutex.unlock();
+                //_smutex.lock();
+                //sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+                //_smutex.unlock();
+                respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_HTTPS_RESP:  
@@ -142,7 +172,7 @@
                 printf("\n [ATCMD MAN] WIFI HTTPS RESPONSE RECEIVED!!\n");
                 return_response();
                 _smutex.lock();
-                _parser.send(OK_RESP);
+                sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
                 _smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
@@ -151,7 +181,7 @@
                 printf("\n [ATCMD MAN] WIFI HTTPS DOWNLOAD RESPONSE RECEIVED!!\n");
                 return_response(true); // set download paramter to true
                 _smutex.lock();
-                _parser.send(OK_RESP);
+                sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
                 _smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
@@ -160,7 +190,7 @@
                 printf("\n [ATCMD MAN] WIFI HTTP RESPONSE RECEIVED!!\n");
                 return_response(); 
                 _smutex.lock();
-                _parser.send(OK_RESP);
+                sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
                 _smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
@@ -168,25 +198,27 @@
                 // AT_HTTP_RESP response state 
                 printf("\n [ATCMD MAN] WIFI HTTP RESPONSE RECEIVED!!\n");
                 return_response(true); // set download paramter to true
-                _smutex.lock();
-                _parser.send(OK_RESP);
-                _smutex.unlock();
+                //_smutex.lock();
+                //sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+                //_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_COMMAND_FAILED:  
                 // AT_HTTP_RESP response state 
                 printf("\n [ATCMD MAN] WIFI COMMAND FAILED!!\n");
-                _smutex.lock();
-                _parser.send("\r\nNACK\r\n");
-                _smutex.unlock();
-                at_resp = AT_RESP_NONE;
+                //_smutex.lock();
+                //_parser.send("\r\nNACK\r\n");
+                //_smutex.unlock();
+                char * respStr = (char *) resp_data->buffer;
+                sendAtConfirmation(respStr);
+                AT_RESP_NONE;
                 break;
             default:
                 // UNKNOWN response state
-                _smutex.lock();
+                //_smutex.lock();
                 printf("\n [ATCMD MAN] UNKNOWN RESPONSE RECEIVED!!\n");
-                _parser.send(OK_RESP);
-                _smutex.unlock();
+                sendAtConfirmation(ERROR_RESP);   //_parser.send(OK_RESP);
+                //_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
         }
@@ -417,7 +449,7 @@
                             printf("DATA_COMMAND received!\n");
                             if(createHttpRequest() == true){
                                 _smutex.lock();
-                                _parser.send(OK_RESP);
+                                sendAtConfirmation(OK_RESP);   //sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
                                 _smutex.unlock();
                             }
                             else{
@@ -467,7 +499,7 @@
 
 void ATCmdManager::_oob_ok_hdlr(){
     _smutex.lock();
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
 }
 
@@ -500,7 +532,7 @@
        //AT+UMRS=230400,2,8,1,1,1
         printf("\n Changing Baud Rate to %d\n", uOpts[0]);
 
-        _parser.send(OK_RESP);
+        sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
         wait(0.1);
         _serial.set_baud(uOpts[0]);
         wait(0.1);
@@ -523,7 +555,7 @@
     printf("\n Received ATEO OOB command!!\n");
     printf("\n turning echo OFF!!\n");
     _parser.debug_on(false);
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
 }
 
@@ -534,7 +566,7 @@
     printf("\n Received ATE1 OOB command!!\n");
     printf("\n turning echo ON!!\n");
     _parser.debug_on(true);
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
 }
 
@@ -566,7 +598,7 @@
     } else {
         printf("\nATCmdParser: Retrieving Uart Options failed\n");
     }
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
 }
 
@@ -589,28 +621,28 @@
     } else {
         printf("\nATCmdParser: Retrieving Uart Options failed");
     }
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
 }
 
 void ATCmdManager::_oob_get_ble_role(){
     _smutex.lock();
     printf("\n Received get BLE role command!!\n");
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
 }
 
 void ATCmdManager::_oob_ena_ble_peri(){
     _smutex.lock();
     printf("\n Received enable BLE Peripheral command!!\n");
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
 }
 
 void ATCmdManager::_oob_reboot(){
     _smutex.lock();
     printf("\n Received reboot command!!\n");
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _parser.send("System Resetting....\n");
     system_reset();
     _smutex.unlock();
@@ -648,7 +680,7 @@
 void ATCmdManager::_oob_scanWiFiNetworks(){
     _smutex.lock();
     printf("\n Received scanWiFiNetworks command!!\n");
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     _smutex.unlock();
     wifi_cmd_t cmd = WIFI_CMD_SCAN;
     // queue next command
@@ -656,16 +688,43 @@
     return;    
 }
 
-void ATCmdManager::_oob_connect2WiFiNetwork()
+
+
+void ATCmdManager::_oob_WiFiStationConfigurationAction()
 {
+    uint8_t if_id; // interface id for request
+    action_id_t action_id; // interface id for request
+    _parser.scanf("%d,%d", &if_id, &action_id);
     //_smutex.lock();
-    printf("\n Received WiFi Connect command!!\n");
-    _parser.send(OK_RESP);
-    wifi_cmd_t cmd = WIFI_CMD_CONNECT;
-    printf("\n About to Queue wifi cmd = %d!!\n", cmd);
-    //_smutex.unlock();
-    // queue next command
-    queueWiFiCommand(cmd);
+    printf("\n Received WiFi Configuration Action command!!\n");
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+    if(if_id == WIFI_CONFIG_ID && (uint8_t)action_id <5){
+        wifi_cmd_t cmd;
+        switch(action_id){
+            case WIFI_CONFIG_RESET:
+                break;
+            case WIFI_CONFIG_STORE:
+                break;
+            case WIFI_CONFIG_LOAD:
+                break;
+            case WIFI_CONFIG_ACTIVATE:
+                cmd = WIFI_CMD_CONNECT;
+                printf("\n About to Queue wifi cmd = %d!!\n", cmd);
+                //_smutex.unlock();
+                // queue next command
+                queueWiFiCommand(cmd);
+                break;
+            case WIFI_CONFIG_DEACTIVATE:
+                cmd = WIFI_CMD_DISCONNECT;
+                printf("\n About to Queue wifi cmd = %d!!\n", cmd);
+                //_smutex.unlock();
+                // queue next command
+                queueWiFiCommand(cmd);
+                break;
+            default:
+                break;
+        }
+    }
     return;
 }
 
@@ -674,7 +733,7 @@
 {
     _smutex.lock();
     printf("\n Received WiFi Disconnect command!!\n");
-    _parser.send(OK_RESP);
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     wifi_cmd_t cmd = WIFI_CMD_DISCONNECT;
     _smutex.unlock();
     // queue next command
@@ -723,7 +782,7 @@
         // queue next data request
         queueWiFiDataRequest(data_msg);
         print_memory_info();
-        _parser.send(OK_RESP);
+        sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     } else {
         printf("\n[ATCMD MAN]: internet configuration failed %d fields parsed \n", n);
         _parser.send("NAK\n");
@@ -789,7 +848,7 @@
         data_msg.dataLen = sizeof(wifi_config_t);
         memcpy(data_msg.buffer,&wifi_cfg, data_msg.dataLen);
         queueWiFiDataRequest(data_msg);
-        _parser.send(OK_RESP);
+        sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     } else {
         printf("\n[ATCMD MAN]: wifi configuration failed  \n");
         _parser.send("NAK\n");
@@ -813,7 +872,7 @@
         data_msg.dataLen = sizeof(wifi_config_t);
         memcpy(data_msg.buffer,&wifi_cfg, data_msg.dataLen);
         queueWiFiDataRequest(data_msg);
-        _parser.send(OK_RESP);
+        sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     } else {
         printf("\n[ATCMD MAN]: wifi configuration failed  \n");
         _parser.send("NAK\n");
@@ -837,7 +896,7 @@
         data_msg.dataLen = sizeof(wifi_config_t);
         memcpy(data_msg.buffer,&wifi_cfg, data_msg.dataLen);
         queueWiFiDataRequest(data_msg);
-        _parser.send(OK_RESP);
+        sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     } else {
         printf("\n[ATCMD MAN]: wifi configuration failed  \n");
         _smutex.lock();
@@ -848,6 +907,38 @@
 }
 
 
+
+void ATCmdManager::_oob_getNetworkStatus()
+{
+    uint8_t if_id; // interface id for request
+    _parser.scanf(",%d", &if_id);
+    //_smutex.lock();
+    printf("\n Received Get Network Status command!!\n");
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+    if(if_id == WIFI_INTERFACE_ID){
+        wifi_cmd_t cmd = WIFI_CMD_NETWORK_STATUS;
+        printf("\n About to Queue wifi cmd = %d!!\n", cmd);
+        //_smutex.unlock();
+        // queue next command
+        queueWiFiCommand(cmd);
+    }
+    return;
+}
+
+
+void ATCmdManager::_oob_WiFiNetworkStatus()
+{
+    //_smutex.lock();
+    printf("\n Received Get WiFi Network Status command!!\n");
+    sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
+    wifi_cmd_t cmd = WIFI_CMD_WIFI_STATUS;
+    printf("\n About to Queue wifi cmd = %d!!\n", cmd);
+    //_smutex.unlock();
+    // queue next command
+    queueWiFiCommand(cmd);
+    return;
+}
+
 void ATCmdManager::_oob_sendHttpMessage()
 {
     int n;
@@ -864,7 +955,7 @@
         data_msg.dataLen = sizeof(wifi_config_t);
         memcpy(data_msg.buffer,&wifi_cfg, data_msg.dataLen);
         queueWiFiDataRequest(data_msg);
-        _parser.send(OK_RESP);
+        sendAtConfirmation(OK_RESP);   //_parser.send(OK_RESP);
     } else {
         printf("\n[ATCMD MAN]: wifi configuration failed  \n");
         _parser.send("NAK\n");
@@ -927,12 +1018,10 @@
 
 bool  ATCmdManager::dequeueWiFidataResponse(){
     if(at_resp != AT_RESP_NONE) return false; // busy
-    //print_memory_info();
     osEvent evt = _wiFi2ATDataQueue->get(0);
     if(evt.status == osEventMessage){
         resp_data = (at_data_msg_t*)evt.value.p;
         setNextResponse(resp_data->at_resp);
-        //_wiFi2ATDatamPool->free(resp_data);
         print_heap_and_isr_stack_info();
     }
     return true;
@@ -941,13 +1030,39 @@
 
 void ATCmdManager::sendAtConfirmation(const char *buf)
 {
-    int len =  strlen(buf);
-    outputEDMdata((const uint8_t *) buf, len, AT_MSG_ID, CONFIRMATION_MSG_TYPE, NO_CHANNEL);
+    switch(dataMode){
+        case AT_CMD_DATA_MODE:
+            _parser.send(buf);
+            break;
+        case AT_STD_DATA_MODE:
+            _parser.send(buf);
+            break;
+        case AT_EXT_DATA_MODE:
+            int len =  strlen(buf) + 1;
+            outputEDMdata((const uint8_t *) buf, len, AT_MSG_ID, CONFIRMATION_MSG_TYPE, NO_CHANNEL);
+            break;
+        default:
+            _parser.send(buf);
+            break;
+    }
 }
 void ATCmdManager::sendAtEvent(const char *buf)
 {
-    int len =  strlen(buf);
-    outputEDMdata((const uint8_t *) buf, len, AT_MSG_ID, EVENT_MSG_TYPE, NO_CHANNEL);
+    switch(dataMode){
+        case AT_CMD_DATA_MODE:
+            _parser.send(buf);
+            break;
+        case AT_STD_DATA_MODE:
+            _parser.send(buf);
+            break;
+        case AT_EXT_DATA_MODE:
+            int len =  strlen(buf) + 1;
+            outputEDMdata((const uint8_t *) buf, len, AT_MSG_ID, EVENT_MSG_TYPE, NO_CHANNEL);
+            break;
+        default:
+            _parser.send(buf);
+            break;
+    }
 }
 
 void ATCmdManager::outputEDMdata(const uint8_t *buf, int pLen, 

--- a/source/ATCmdManager.h	Sun Apr 14 17:03:02 2019 +0000
+++ b/source/ATCmdManager.h	Wed Apr 17 18:11:45 2019 +0000
@@ -13,7 +13,8 @@
 #define UBLOX_ODIN_W2_MISC_TIMEOUT    2000
 #endif
 
-#define OK_RESP "OK\n\r"
+#define OK_RESP    "\r\nOK\r\n"
+#define ERROR_RESP "\r\nERROR\r\n"
 extern void print_memory_info();
 class ATCmdManager {
 public:
@@ -87,13 +88,15 @@
     void _oob_reboot();
     void _oob_get_fw_ver();
     void _oob_scanWiFiNetworks();
-    void _oob_connect2WiFiNetwork();
+    void _oob_WiFiStationConfigurationAction();
     void _oob_disconnectWiFiNetwork();
     void _oob_setupInternetConnection();
     void _oob_setWiFiSSID();
     void _oob_setWiFiPWD();
     void _oob_setWiFiSecurity();
     void _oob_sendHttpMessage();
+    void _oob_getNetworkStatus();
+    void _oob_WiFiNetworkStatus();
     wifi_config_t init_wifi_config();
     const char * sec2str(nsapi_security_t sec);
     bool        queueWiFiCommand(wifi_cmd_t cmd);

--- a/source/WiFiManager.cpp	Sun Apr 14 17:03:02 2019 +0000
+++ b/source/WiFiManager.cpp	Wed Apr 17 18:11:45 2019 +0000
@@ -96,10 +96,13 @@
                 wifiCmd = WIFI_CMD_NONE;
                 if(is_connected==false){
                     printf("[WIFI MAN] +++ WIFI CONNECTION TIMEOUT +++ \r\n");
-                    queueATresponse(AT_COMMAND_FAILED);
+                    //queueATresponse(AT_COMMAND_FAILED);
+                    responseString = (char *) malloc(100);
+                    sprintf(responseString, "\r\n+UUTIMEOUT\r\n");
+                    sendATresponseString(AT_COMMAND_FAILED);
                 }
                 else {
-                    queueATresponse(AT_CONNECT_RESP);
+                    sendATresponseString(AT_CONNECT_RESP);
                 }
                 break;
             case WIFI_CMD_DISCONNECT:
@@ -114,8 +117,18 @@
                 break;
             case WIFI_CMD_INTERNET_CONFIG:
                 set_internet_config();
+                queueATresponse(AT_INTERNET_CONFIG_RESP);
                 wifiCmd = WIFI_CMD_NONE;
-                queueATresponse(AT_INTERNET_CONFIG_RESP);
+                break;
+            case WIFI_CMD_NETWORK_STATUS:
+                getNetworkStatus();
+                sendATresponseString(AT_NETWORK_STATUS_RESP);
+                wifiCmd = WIFI_CMD_NONE;
+                break;
+            case WIFI_CMD_WIFI_STATUS:
+                getWiFiStatus();
+                sendATresponseString(AT_WIFI_STATUS_RESP);
+                wifiCmd = WIFI_CMD_NONE;
                 break;
             case WIFI_CMD_SEND_HTTPS_REQ:
                 printf("before call to send http request \n");
@@ -136,16 +149,16 @@
 }
 
 
-void  WiFiManager::sentATresponseString(at_cmd_resp_t at_cmd, 
-                                        const char *responseString, 
-                                        int strLen)
+void  WiFiManager::sendATresponseString(at_cmd_resp_t at_cmd)
 {
+    int strLen = strlen(responseString) + 1;
     at_data_resp = new at_data_msg_t;
     // create message pointer for response header generation
     char * msgPtr = (char *)at_data_resp->buffer;
     // set string length 
     at_data_resp->dataLen = strLen;
     memcpy(at_data_resp->buffer, responseString, strLen);
+    free(responseString);
     // package and send on wifi data queue    
     at_data_resp->at_resp = at_cmd;
     bool queueResult = true;
@@ -318,6 +331,121 @@
     delete socket;
 }
 
+
+
+void WiFiManager::getNetworkStatus(){
+    
+    responseString = (char *) malloc(MAX_RESPONSE_STRING_LEN);
+    net_stat_id_t status_id;
+    char * nextStrPtr = responseString;
+    for(int i=0; i< NumNetworkStatus;i++){
+        status_id = netStatusIds[i]; // get current status id
+        switch(status_id){
+            case IF_HW_ADDRESS:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,%s\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id,
+                                                              network->get_mac_address());
+                break;
+            case NETWORK_IF_STATUS:
+                sprintf(nextStrPtr, "\r\n%s%d,%d, %d\r\n", NETWORK_STATUS, 
+                                                           WIFI_CHANNEL,
+                                                           status_id,
+                                                           (uint8_t)is_connected);
+                break;
+            case INTERFACE_TYPE:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,%d\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id,
+                                                              WIFI_STATION);
+                break;
+            case IPv4_ADDRESS:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,%s\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id,
+                                                              network->get_ip_address());
+                break;
+            case SUBNET_MASK:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,%s\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id,
+                                                              network->get_netmask());
+                break;
+            case GATEWAY_ADDRESS:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,%s\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id,
+                                                              network->get_gateway());
+                break;
+            case PRIMARY_DNS_SERVER:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,%s\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id,
+                                                              DEFAULT_DNS_ADDRESS);
+                break;
+            case SECONDARY_DNS_SERVER:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,%s\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id,
+                                                              DEFAULT_DNS_ADDRESS);
+                break;
+            case IPv6_ADDRESS:
+                sprintf(nextStrPtr, "\r\n%s%d,%d,::\r\n", NETWORK_STATUS, 
+                                                              WIFI_CHANNEL,
+                                                              status_id);
+                break;
+            default:
+                sprintf(nextStrPtr, "\r\n%s,::\r\n", NETWORK_STATUS);
+                break;
+        }
+        nextStrPtr += strlen(nextStrPtr) +1; // progress to end of current string
+    }
+}
+
+
+
+void WiFiManager::getWiFiStatus(){
+    
+    responseString = (char *) malloc(MAX_RESPONSE_STRING_LEN);
+    wifi_stat_id_t status_id;
+    char * nextStrPtr = responseString;
+    for(int i=0; i< NumWiFiStatus;i++){
+        status_id = wifiStatusIds[i]; // get current status id
+        switch(status_id){
+            case WIFI_SSID:
+                sprintf(nextStrPtr, "\r\n%s%d,%s\r\n", WIFI_NETWORK_STATUS, 
+                                                       status_id,
+                                                       wifi_config.ssid);
+                break;
+            case WIFI_BSSID:
+                sprintf(nextStrPtr, "\r\n%s%d,%s\r\n", WIFI_NETWORK_STATUS, 
+                                                       status_id,
+                                                       network->get_mac_address());
+                break;
+            case WIFI__CURRENT_CHANNEL:
+                sprintf(nextStrPtr, "\r\n%s%d,%d\r\n", WIFI_NETWORK_STATUS, 
+                                                       status_id,
+                                                       DEFAULT_WIFI_CHANNEL);
+                break;
+            case WIFI_STA_STATUS:
+                sprintf(nextStrPtr, "\r\n%s%d,%d\r\n", WIFI_NETWORK_STATUS, 
+                                                       status_id,
+                                                       (uint8_t)is_connected);
+                break;
+            case WIFI_RSSI:
+                sprintf(nextStrPtr, "\r\n%s%d,%d\r\n", WIFI_NETWORK_STATUS, 
+                                                       status_id,
+                                                       network->get_rssi());
+                break;
+            default:
+                sprintf(nextStrPtr, "\r\n%s,::\r\n", WIFI_NETWORK_STATUS);
+                break;
+        }
+        nextStrPtr += strlen(nextStrPtr) +1; // progress to end of current string
+    }
+}
+
+
 void WiFiManager::free_DataMsg()
 {
     // free memory after processing
@@ -339,6 +467,12 @@
             printf("Global IP address set!\r\n");
             printf("[WIFI-MAN] IP address: %s\n", network->get_ip_address());
             printf("[WIFI-MAN] Connected to the network %s\n", wifi_config.ssid);
+            responseString = (char *) malloc(MAX_RESPONSE_STRING_LEN); 
+            sprintf(responseString, "\r\n%s%d,%s,%d\r\n", WIFI_LINK_ENABLED, 
+                                                          WIFI_CHANNEL,
+                                                          network->get_mac_address(),
+                                                          DEFAULT_WIFI_CHANNEL);
+            
             is_connected = true;
             break;
         case NSAPI_STATUS_DISCONNECTED:

--- a/source/WiFiManager.h	Sun Apr 14 17:03:02 2019 +0000
+++ b/source/WiFiManager.h	Wed Apr 17 18:11:45 2019 +0000
@@ -47,6 +47,7 @@
     nsapi_size_or_error_t lastScanCount;
     bool                  https_connection_active;
     TLSSocket*            socket;
+    char*                 responseString; // response string formated for Box
     wifi_cmd_t  wifiCmd;
     //at_data_msg_t *at_data_resp;
     int         chunkNum;
@@ -103,9 +104,9 @@
     bool                  createTLSconnection(const char *hostName);
     void                  printBufferInHex(uint8_t *buf, int pLen);
     void                  copyResponseHdr2Queue();
-    void                  sentATresponseString(at_cmd_resp_t at_cmd, 
-                                               const char *responseString, 
-                                               int strLen);
+    void                  sendATresponseString(at_cmd_resp_t);
+    void                  getNetworkStatus();
+    void                  getWiFiStatus();
 
 
     /**

--- a/source/common_config.h	Sun Apr 14 17:03:02 2019 +0000
+++ b/source/common_config.h	Wed Apr 17 18:11:45 2019 +0000
@@ -13,7 +13,55 @@
 #endif
 #define USE_MALLOC_FOR_COMMAND_MEMORY_POOL
 #define WIFI_CONNECT_TIMEOUT_SECS 10
+#define MAX_RESPONSE_STRING_LEN   512 // maximum response string length of 512 bytes
+#define DEFAULT_WIFI_CHANNEL      0
+#define WIFI_LINK_ENABLED         "+UUWLE:"
+#define NETWORK_STATUS            "+UNSTAT="
+#define WIFI_NETWORK_STATUS       "+UWSSTAT="
+#define WIFI_STATION              1
+#define WIFI_CONFIG_ID            0
+#define WIFI_INTERFACE_ID         0
+#define DEFAULT_DNS_ADDRESS       "0.0.0.0"
 #define PQDSZ   2  // size of Pool/Queue data structures
+
+typedef enum
+{
+  IF_HW_ADDRESS = 0,
+  NETWORK_IF_STATUS = 1,
+  INTERFACE_TYPE = 2,
+  IPv4_ADDRESS = 101,
+  SUBNET_MASK = 102,
+  GATEWAY_ADDRESS = 103,
+  PRIMARY_DNS_SERVER = 104,
+  SECONDARY_DNS_SERVER = 105,
+  IPv6_ADDRESS = 201
+}net_stat_id_t;
+
+typedef enum
+{
+  WIFI_SSID = 0,
+  WIFI_BSSID = 1,
+  WIFI__CURRENT_CHANNEL = 2,
+  WIFI_STA_STATUS = 3,
+  WIFI_RSSI = 6
+}wifi_stat_id_t;
+
+const net_stat_id_t netStatusIds[]  =  {IF_HW_ADDRESS, NETWORK_IF_STATUS, 
+                                        INTERFACE_TYPE, IPv4_ADDRESS, 
+                                        SUBNET_MASK, GATEWAY_ADDRESS, 
+                                        PRIMARY_DNS_SERVER, SECONDARY_DNS_SERVER, 
+                                        IPv6_ADDRESS};
+                                        
+                                        
+const int NumNetworkStatus    = sizeof(netStatusIds)/sizeof(uint8_t);
+
+
+const wifi_stat_id_t wifiStatusIds[] = {WIFI_SSID, WIFI_BSSID, 
+                                        WIFI__CURRENT_CHANNEL, WIFI_STA_STATUS, 
+                                        WIFI_RSSI};
+
+const int NumWiFiStatus    = sizeof(wifiStatusIds)/sizeof(uint8_t);
+
 const uint8_t hello_msg[] = {0xaa,0x00,0x96,0x00,0x36,0x00,0x50,0x4f
                             ,0x53,0x54,0x20,0x2f,0x6e,0x75,0x64,0x67
                             ,0x65,0x62,0x6f,0x78,0x2f,0x76,0x31,0x20

--- a/source/common_types.h	Sun Apr 14 17:03:02 2019 +0000
+++ b/source/common_types.h	Wed Apr 17 18:11:45 2019 +0000
@@ -45,6 +45,16 @@
 
 typedef enum
 {
+  WIFI_CONFIG_RESET,
+  WIFI_CONFIG_STORE,
+  WIFI_CONFIG_LOAD,
+  WIFI_CONFIG_ACTIVATE,
+  WIFI_CONFIG_DEACTIVATE
+}action_id_t;
+
+
+typedef enum
+{
   WIFI_CMD_NONE,
   WIFI_CMD_CONFIG,
   WIFI_CMD_INTERNET_CONFIG,
@@ -52,6 +62,8 @@
   WIFI_CMD_DETAILED_SCAN,
   WIFI_CMD_CONNECT,
   WIFI_CMD_DISCONNECT,
+  WIFI_CMD_NETWORK_STATUS,
+  WIFI_CMD_WIFI_STATUS,
   WIFI_CMD_SEND_HTTPS_REQ,
   WIFI_CMD_SEND_HTTP_REQ
 }wifi_cmd_t;
@@ -67,6 +79,8 @@
   WIFI_DISCONNECT_INFO,
   AT_CONFIG_RESP,
   AT_INTERNET_CONFIG_RESP,
+  AT_NETWORK_STATUS_RESP,
+  AT_WIFI_STATUS_RESP,
   AT_HTTPS_RESP,
   AT_HTTPS_RESP_DOWNLOAD,
   AT_HTTP_RESP,