Revision 81:637a87eb8170, committed 2019-03-23

Comitter:

ocomeni

Date:

Sat Mar 23 16:28:34 2019 +0000

Parent:

80:e8f0e92e3ac9

Child:

82:10072c1794d3

Commit message:

first data queue/dequeue implemented for internet configuration.

Changed in this revision

--- a/source/ATCmdManager.cpp	Thu Mar 21 22:17:28 2019 +0000
+++ b/source/ATCmdManager.cpp	Sat Mar 23 16:28:34 2019 +0000
@@ -7,12 +7,12 @@
                            events::EventQueue &event_queue, WiFiManager *wifi, 
                            MemoryPool<wifi_cmd_message_t, 16> *aT2WiFimPool, 
                            Queue<wifi_cmd_message_t, 16>      *aT2WiFiCmdQueue, 
-                           MemoryPool<wifi_cmd_message_t, 16> *wiFi2ATmPool, 
-                           Queue<wifi_cmd_message_t, 16>      *wiFi2ATCmdQueue, 
+                           MemoryPool<at_resp_message_t, 16>  *wiFi2ATmPool, 
+                           Queue<at_resp_message_t, 16>       *wiFi2ATCmdQueue, 
                            MemoryPool<wifi_data_msg_t, 4>     *aT2WiFiDatamPool, 
                            Queue<wifi_data_msg_t, 4>          *aT2WiFiDataQueue, 
-                           MemoryPool<wifi_data_msg_t, 4>     *wiFi2ATDatamPool, 
-                           Queue<wifi_data_msg_t, 4>          *wiFi2ATDataQueue, 
+                           MemoryPool<at_data_msg_t, 4>       *wiFi2ATDatamPool, 
+                           Queue<at_data_msg_t, 4>            *wiFi2ATDataQueue, 
                            bool debug)
     :
     _serial(tx, rx, DEFAULT_BAUD_RATE),
@@ -40,6 +40,7 @@
     _parser.debug_on(debug);
     _parser.set_delimiter("\r\n");
     _parser.send("+STARTUP");
+    _parser.oob("AT\n", callback(this, &ATCmdManager::_oob_ok_hdlr));
     _parser.oob("ATE0", callback(this, &ATCmdManager::_oob_echo_off));
     _parser.oob("ATE1", callback(this, &ATCmdManager::_oob_echo_on));
     _parser.oob("AT+UMRS", callback(this, &ATCmdManager::_oob_uart_setup));
@@ -52,11 +53,14 @@
     _parser.oob("AT+CGMR", callback(this, &ATCmdManager::_oob_get_fw_ver));
     _parser.oob("AT+UWSC=", 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+UDDRP", callback(this, &ATCmdManager::_oob_setupInternetConnection));
+ 
 
     //_parser.oob("ATE0", callback(this, &ATCmdManager::_oob_startup_hdlr));
     printf("\n --- ATCmdManager constructor completed ---\n");
-    
+    at_resp = AT_RESP_NONE;
+    dataMode = AT_CMD_DATA_MODE;
     //AT+UMRS=230400,2,8,1,1,1
     // AT+UBTLE
 }
@@ -65,11 +69,75 @@
 void ATCmdManager::runMain(){
     while(true){
         _process_oob(UBLOX_ODIN_W2_RECV_TIMEOUT, true);
-        wait_ms(MAIN_LOOP_WAIT_TIME_MS); // allow BTLE to be
+        wait_ms(MAIN_LOOP_WAIT_TIME_MS); // allow BTLE/WiFi some time 
+        processResponses();
     }
     
 }
 
+void ATCmdManager::processResponses(){
+        dequeueATresponse();
+        switch(at_resp){
+            case AT_RESP_NONE:
+                // IDLE response state
+                break;
+            case AT_SCAN_RESP:
+                // AT_SCAN_RESP response state
+                _smutex.lock();
+                printf("\n [ATCMD MAN] WIFI SCAN RESPONSE RECEIVED!!\n");
+                _parser.send("OK\n");
+                _smutex.unlock();
+                at_resp = AT_RESP_NONE;
+                break;
+            case AT_DETAILED_SCAN_RESP:
+                // AT_DETAILED_SCAN_RESP response state
+                _smutex.lock();
+                printf("\n [ATCMD MAN] WIFI DETAILED SCAN RESPONSE RECEIVED!!\n");
+                _parser.send("OK\n");
+                _smutex.unlock();
+                at_resp = AT_RESP_NONE;
+                break;
+            case AT_CONNECT_RESP:  
+                // AT_CONNECT_RESP response state 
+                _smutex.lock();
+                printf("\n [ATCMD MAN] WIFI CONNECT RESPONSE RECEIVED!!\n");
+                _parser.send("OK\n");
+                _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");
+                _parser.send("OK\n");
+                _smutex.unlock();
+                at_resp = AT_RESP_NONE;
+                break;
+            case AT_HTTPS_RESP:  
+                // AT_HTTPS_RESP response state 
+                _smutex.lock();
+                printf("\n [ATCMD MAN] WIFI HTTPS RESPONSE RECEIVED!!\n");
+                _parser.send("OK\n");
+                _smutex.unlock();
+                at_resp = AT_RESP_NONE;
+                break;
+            case AT_HTTP_RESP:  
+                // AT_HTTP_RESP response state 
+                _smutex.lock();
+                printf("\n [ATCMD MAN] WIFI HTTP RESPONSE RECEIVED!!\n");
+                _parser.send("OK\n");
+                _smutex.unlock();
+                at_resp = AT_RESP_NONE;
+                break;
+            default:
+                // UNKNOWN response state
+                at_resp = AT_RESP_NONE;
+                break;
+        }
+}
+
+
+
 
 // OOB processing
 void ATCmdManager::_process_oob(uint32_t timeout, bool all){
@@ -85,6 +153,12 @@
 void ATCmdManager::_oob_startup_hdlr(){
 }
 
+void ATCmdManager::_oob_ok_hdlr(){
+    _smutex.lock();
+    _parser.send("OK\n");
+    _smutex.unlock();
+}
+
 
 void ATCmdManager::_oob_bleRole_hdlr(){
 }
@@ -111,6 +185,12 @@
     //if(_parser.recv("=%d,%d,%d,%d,%d,%d", &uOpts[0], &uOpts[1], &uOpts[2], &uOpts[3], &uOpts[4], &uOpts[5])) {
     if(_parser.scanf("=%d,%d,%d,%d,%d,%d", &uOpts[0], &uOpts[1], &uOpts[2], &uOpts[3], &uOpts[4], &uOpts[5]) >0) {
         printf("\nATCmdParser: Uart Options=%d,%d,%d,%d,%d,%d\n", uOpts[0], uOpts[1], uOpts[2], uOpts[3], uOpts[4], uOpts[5]);
+       //AT+UMRS=230400,2,8,1,1,1
+        printf("\n Changing Baud Rate to %d\n", uOpts[0]);
+
+        _serial.set_baud(uOpts[0]);
+        printf("\n Baud Rate now %d\n", uOpts[0]);
+
     } else {
         printf("\nATCmdParser: Retrieving Uart Options failed");
     }
@@ -154,12 +234,15 @@
         {
             case 0:
                 printf("\nATCmdParser: Command Mode request received");
+                dataMode = AT_CMD_DATA_MODE;
                 break;
             case 1:
                 printf("\nATCmdParser: Data Mode request received");
+                dataMode = AT_STD_DATA_MODE;
                 break;
             case 2:
                 printf("\nATCmdParser: Extended data Mode request received");
+                dataMode = AT_EXT_DATA_MODE;
                 break;
             default:
                 printf("\nATCmdParser: ERROR - UNKNOWN DATA MODE RECEIVED!!! \n");
@@ -236,13 +319,17 @@
             return "Unknown";
     }
 }
-bool  ATCmdManager::queueWiFiCommand(wifi_cmd_t cmd){
-    wifi_cmd_message_t *wifiCmd = _aT2WiFimPool->alloc();
-    wifiCmd->wifi_cmd            = cmd;
-    _aT2WiFiCmdQueue->put(wifiCmd);
-    return true;
+
+bool ATCmdManager::setNextResponse(at_cmd_resp_t resp)
+{
+     if(at_resp == AT_RESP_NONE){
+        at_resp = resp;
+        return true; // success
+    }
+    return false; // wiFiManager busy
 }
 
+
 void ATCmdManager::_oob_scanWiFiNetworks(){
     _smutex.lock();
     printf("\n Received scanWiFiNetworks command!!\n");
@@ -251,56 +338,95 @@
     wifi_cmd_t cmd = WIFI_CMD_SCAN;
     // queue next command
     queueWiFiCommand(cmd);
-    bool success;
-    success = wiFiManager->setNextCommand(cmd);
-    if(success){
-        printf("\n scan command successfully sent to wiFiManager!!\n");
-    }
-    else {
-        printf("\n ERROR: Failed to send scan command wiFiManager!!\n");
-    }
-    return;
-    /* call WiFi Scan in 20 ms */
-    //_event_queue.call_in(
-    //    20, wiFiManager,
-    //    &WiFiManager::scanNetworks);
-    //return;
-    WiFiAccessPoint       *ap;
-    nsapi_size_or_error_t count;
-    //count = wiFiManager->scanNetworks();
-    if (count <= 0) {
-        _smutex.lock();
-        printf("scan() failed with return value: %d\n", count);
-        _smutex.unlock();
-        return;
-    }
-    /* Limit number of network arbitrary to 15 */
-    count = count < 15 ? count : 15;
-    ap = new WiFiAccessPoint[count];
-    count = wiFiManager->getAvailableAPs(ap, count);
-    if (count <= 0) {
-        printf("scan() failed with return value: %d\n", count);
-        return;
-    }
-
-    for (int i = 0; i < count; i++) {
-        printf("Network: %s secured: %s BSSID: %hhX:%hhX:%hhX:%hhx:%hhx:%hhx RSSI: %hhd Ch: %hhd\n", ap[i].get_ssid(),
-               sec2str(ap[i].get_security()), ap[i].get_bssid()[0], ap[i].get_bssid()[1], ap[i].get_bssid()[2],
-               ap[i].get_bssid()[3], ap[i].get_bssid()[4], ap[i].get_bssid()[5], ap[i].get_rssi(), ap[i].get_channel());
-    }
-    printf("%d networks available.\n", count);
-
-    delete[] ap;
-    
+    return;    
 }
 
 void ATCmdManager::_oob_connect2WiFiNetwork()
 {
-    wiFiManager->connect();
+    wifi_cmd_t cmd = WIFI_CMD_CONNECT;
+    // queue next command
+    queueWiFiCommand(cmd);
+    return;
 }
 
 
 void ATCmdManager::_oob_disconnectWiFiNetwork()
 {
-    wiFiManager->disconnect();
+    wifi_cmd_t cmd = WIFI_CMD_DISCONNECT;
+    // queue next command
+    queueWiFiCommand(cmd);
+    return;
+}
+
+void ATCmdManager::_oob_setupInternetConnection()
+{
+    char url[200];
+    int n;
+    internet_config_t internet_config;
+    _smutex.lock();
+    n = _parser.scanf("=%1d,%200[^,],%1d", &internet_config.peer_id, 
+                                      url,
+                                     &internet_config.connectionScheme);
+    if(n>0) 
+    {
+        internet_config.url = url;
+        printf("peer_id = %1d, url = %s, connScheme = %1d\n", internet_config.peer_id, 
+                                                          internet_config.url.c_str(), 
+                                                          internet_config.connectionScheme);
+        // package and send on wifi data queue
+        wifi_data_msg_t data_msg;
+        data_msg.wifi_cmd = WIFI_CMD_INTERNET_CONFIG;
+        data_msg.dataLen = sizeof(internet_config) + internet_config.url.length();
+        memcpy(data_msg.buffer,&internet_config, data_msg.dataLen);
+        queueWiFiDataRequest(data_msg);
+    } else {
+        printf("\n[ATCMD MAN]: internet configuration failed %d fields parsed \n", n);
+        printf("\npeer_id = %d, url = %s, connScheme = %d\n", internet_config.peer_id, 
+                                                          url, 
+                                                          internet_config.connectionScheme);
+    }
+    _parser.send("OK\n");
+    _smutex.unlock();
 }
+
+bool  ATCmdManager::queueWiFiCommand(wifi_cmd_t cmd){
+    wifi_cmd_message_t *wifiCmd = _aT2WiFimPool->alloc();
+    wifiCmd->wifi_cmd            = cmd;
+    _aT2WiFiCmdQueue->put(wifiCmd);
+    return true;
+}
+
+bool  ATCmdManager::dequeueATresponse(){
+    if(at_resp != AT_RESP_NONE) return false; // busy
+    osEvent evt = _wiFi2ATCmdQueue->get(0);
+    if(evt.status == osEventMessage){
+        at_resp_message_t *resp = (at_resp_message_t*)evt.value.p;
+        setNextResponse(resp->at_resp);
+        _wiFi2ATmPool->free(resp);
+    }
+    return true;
+}
+
+bool  ATCmdManager::queueWiFiDataRequest(wifi_data_msg_t data_req){
+    wifi_data_msg_t *wifiData = _aT2WiFiDatamPool->alloc();
+    wifiData->wifi_cmd        = data_req.wifi_cmd;
+    wifiData->dataLen        = data_req.dataLen;
+    memcpy(wifiData->buffer, data_req.buffer, data_req.dataLen);
+    _aT2WiFiDataQueue->put(wifiData);
+    printf("[ATCMD MAN] queued data size = %d : wifi_cmd = %d\n", data_req.dataLen, data_req.wifi_cmd);
+    return true;
+}
+
+bool  ATCmdManager::dequeueATdataResponse(){
+    if(at_resp != AT_RESP_NONE) return false; // busy
+    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);
+    }
+    return true;
+}
+
+
+

--- a/source/ATCmdManager.h	Thu Mar 21 22:17:28 2019 +0000
+++ b/source/ATCmdManager.h	Sat Mar 23 16:28:34 2019 +0000
@@ -19,12 +19,12 @@
                  events::EventQueue &event_queue, WiFiManager *wifi, 
                  MemoryPool<wifi_cmd_message_t, 16> *aT2WiFimPool, 
                  Queue<wifi_cmd_message_t, 16> *aT2WiFiCmdQueue, 
-                 MemoryPool<wifi_cmd_message_t, 16> *wiFi2ATmPool, 
-                 Queue<wifi_cmd_message_t, 16> *wiFi2ATCmdQueue, 
+                 MemoryPool<at_resp_message_t, 16> *wiFi2ATmPool, 
+                 Queue<at_resp_message_t, 16> *wiFi2ATCmdQueue, 
                  MemoryPool<wifi_data_msg_t, 4> *aT2WiFiDatamPool, 
                  Queue<wifi_data_msg_t, 4> *aT2WiFiDataQueue, 
-                 MemoryPool<wifi_data_msg_t, 4> *wiFi2ATDatamPool, 
-                 Queue<wifi_data_msg_t, 4> *wiFi2ATDataQueue, 
+                 MemoryPool<at_data_msg_t, 4> *wiFi2ATDatamPool, 
+                 Queue<at_data_msg_t, 4> *wiFi2ATDataQueue, 
                  bool debug = false);
 public:
     void runMain();
@@ -42,15 +42,15 @@
     ATCmdParser _parser;
     SMDevicePeripheral *blePeripheral;
     WiFiManager *wiFiManager;
-   
-    
+    at_cmd_resp_t at_resp;
+    at_data_mode_t dataMode;
     /*  Queue and memory pool for AT to Wifi commands */
     MemoryPool<wifi_cmd_message_t, 16> *_aT2WiFimPool;
     Queue<wifi_cmd_message_t, 16> *_aT2WiFiCmdQueue;
     
     /*  Queue and memory pool for WiFi to AT commands */
-    MemoryPool<wifi_cmd_message_t, 16> *_wiFi2ATmPool;
-    Queue<wifi_cmd_message_t, 16> *_wiFi2ATCmdQueue;
+    MemoryPool<at_resp_message_t, 16> *_wiFi2ATmPool;
+    Queue<at_resp_message_t, 16> *_wiFi2ATCmdQueue;
     
     /*  Queue and memory pool for AT to WiFi data */
     MemoryPool<wifi_data_msg_t, 4> *_aT2WiFiDatamPool;
@@ -58,14 +58,18 @@
     
     
     /*  Queue and memory pool for WiFi to AT data */
-    MemoryPool<wifi_data_msg_t, 4> *_wiFi2ATDatamPool;
-    Queue<wifi_data_msg_t, 4> *_wiFi2ATDataQueue;
+    MemoryPool<at_data_msg_t, 4> *_wiFi2ATDatamPool;
+    Queue<at_data_msg_t, 4> *_wiFi2ATDataQueue;
+    
+    //pointer to response data - should be deleted after processing
+    at_data_msg_t *resp_data;
 
     
     // OOB processing
     void _process_oob(uint32_t timeout, bool all);
     // OOB message handlers
     void _oob_startup_hdlr();
+    void _oob_ok_hdlr();
     void _oob_bleRole_hdlr();
     void _oob_wifiMode_err();
     void _oob_conn_already();
@@ -82,8 +86,15 @@
     void _oob_scanWiFiNetworks();
     void _oob_connect2WiFiNetwork();
     void _oob_disconnectWiFiNetwork();
+    void _oob_setupInternetConnection();
     const char * sec2str(nsapi_security_t sec);
     bool  queueWiFiCommand(wifi_cmd_t cmd);
+    bool  dequeueATresponse();
+    bool  queueWiFiDataRequest(wifi_data_msg_t cmd);
+    bool  dequeueATdataResponse();
+    void  processResponses();
+    bool  setNextResponse(at_cmd_resp_t resp);
+
     
     /**
     * Allows timeout to be changed between commands

--- a/source/WiFiManager.cpp	Thu Mar 21 22:17:28 2019 +0000
+++ b/source/WiFiManager.cpp	Sat Mar 23 16:28:34 2019 +0000
@@ -5,44 +5,95 @@
 WiFiManager::WiFiManager(wifi_config_t wifi_config, WiFiInterface *wifi, 
                          MemoryPool<wifi_cmd_message_t, 16> *aT2WiFimPool, 
                          Queue<wifi_cmd_message_t, 16> *aT2WiFiCmdQueue, 
-                         MemoryPool<wifi_cmd_message_t, 16> *wiFi2ATmPool, 
-                         Queue<wifi_cmd_message_t, 16> *wiFi2ATCmdQueue, 
+                         MemoryPool<at_resp_message_t, 16> *wiFi2ATmPool, 
+                         Queue<at_resp_message_t, 16> *wiFi2ATCmdQueue, 
                          MemoryPool<wifi_data_msg_t, 4> *aT2WiFiDatamPool, 
                          Queue<wifi_data_msg_t, 4> *aT2WiFiDataQueue, 
-                         MemoryPool<wifi_data_msg_t, 4> *wiFi2ATDatamPool, 
-                         Queue<wifi_data_msg_t, 4> *wiFi2ATDataQueue) 
+                         MemoryPool<at_data_msg_t, 4> *wiFi2ATDatamPool, 
+                         Queue<at_data_msg_t, 4> *wiFi2ATDataQueue) 
 :
- wifi_config(wifi_config),
- network(wifi),
- _aT2WiFimPool(aT2WiFimPool),
- _aT2WiFiCmdQueue(aT2WiFiCmdQueue)
+     wifi_config(wifi_config),
+     network(wifi),
+    _aT2WiFimPool(aT2WiFimPool),
+    _aT2WiFiCmdQueue(aT2WiFiCmdQueue),
+    
+    _wiFi2ATmPool(wiFi2ATmPool),
+    _wiFi2ATCmdQueue(wiFi2ATCmdQueue),
+    
+    _aT2WiFiDatamPool(aT2WiFiDatamPool),
+    _aT2WiFiDataQueue(aT2WiFiDataQueue),
+    
+    _wiFi2ATDatamPool(wiFi2ATDatamPool),
+    _wiFi2ATDataQueue(wiFi2ATDataQueue)
 
 {
  lastScanCount = 0;
  wifiCmd = WIFI_CMD_NONE;
+ internet_config.connectionScheme = ALWAYS_CONNECTED; // set default connection scheme
+ is_connected = false;
 }
 
 WiFiManager::~WiFiManager()
 {
 }
   
+bool WiFiManager::queueATresponse(at_cmd_resp_t resp){
+    at_resp_message_t *atResp  = _wiFi2ATmPool->alloc();
+    atResp->at_resp            = resp;
+    _wiFi2ATCmdQueue->put(atResp);
+    return true;
+}
+
+
+bool WiFiManager::queueWiFiDataResponse(at_data_msg_t at_resp){
+    at_data_msg_t *atData = _wiFi2ATDatamPool->alloc();
+    atData->at_resp        = at_resp.at_resp;
+    atData->dataLen        = at_resp.dataLen;
+    memcpy(atData->buffer, at_resp.buffer, at_resp.dataLen);
+    _wiFi2ATDataQueue->put(atData);
+    return true;
+}
+
 
 
 void WiFiManager::runMain(){
+    nsapi_error_t error;
     while(true){
         dequeueWiFiCommands();
+        dequeueATdataResponse();
         switch(wifiCmd){
             case WIFI_CMD_NONE:
                 // IDLE STATE
                 break;
             case WIFI_CMD_SCAN:
-                nsapi_error_t error;
                 error = scanNetworks();
                 wifiCmd = WIFI_CMD_NONE;
+                queueATresponse(AT_SCAN_RESP);
+                break;
+            case WIFI_CMD_DETAILED_SCAN:
+                nsapi_size_or_error_t cnt_err;
+                cnt_err = getAvailableAPs(lastScanCount);
+                wifiCmd = WIFI_CMD_NONE;
+                queueATresponse(AT_DETAILED_SCAN_RESP);
                 break;
             case WIFI_CMD_CONNECT:
+                error = connect();
+                wifiCmd = WIFI_CMD_NONE;
+                queueATresponse(AT_CONNECT_RESP);
                 break;
             case WIFI_CMD_DISCONNECT:
+                error = disconnect();
+                wifiCmd = WIFI_CMD_NONE;
+                queueATresponse(AT_DISCONNECT_RESP);
+                break;
+            case WIFI_CMD_CONFIG:
+                set_WIFI_CONFIG();
+                wifiCmd = WIFI_CMD_NONE;
+                queueATresponse(AT_CONFIG_RESP);
+            case WIFI_CMD_INTERNET_CONFIG:
+                set_internet_config();
+                wifiCmd = WIFI_CMD_NONE;
+                queueATresponse(AT_INTERNET_CONFIG_RESP);
                 break;
             case WIFI_CMD_SEND_HTTPS_REQ:
                 break;
@@ -57,7 +108,8 @@
 }
 
 bool  WiFiManager::dequeueWiFiCommands(){
-    osEvent evt = _aT2WiFiCmdQueue->get();
+    if(wifiCmd != WIFI_CMD_NONE) return false; // busy
+    osEvent evt = _aT2WiFiCmdQueue->get(0);
     if(evt.status == osEventMessage){
         wifi_cmd_message_t *cmd = (wifi_cmd_message_t*)evt.value.p;
         setNextCommand(cmd->wifi_cmd);
@@ -67,6 +119,18 @@
 }
 
 
+bool WiFiManager::dequeueATdataResponse(){
+    if(wifiCmd != WIFI_CMD_NONE) return false; // busy
+    osEvent evt = _aT2WiFiDataQueue->get(0);
+    if(evt.status == osEventMessage){
+        data_msg = (wifi_data_msg_t*)evt.value.p;
+        setNextCommand(data_msg->wifi_cmd);
+        //_wiFi2ATDatamPool->free(data_msg);
+    }
+    return true;
+}
+
+
 bool WiFiManager::setNextCommand(wifi_cmd_t cmd)
 {
     printf("\n [WIFI-MAN] About to set next WiFi manager command \n");
@@ -77,6 +141,25 @@
     return false; // wiFiManager busy
 }
 
+const char * WiFiManager::sec2str(nsapi_security_t sec)
+{
+    switch (sec) {
+        case NSAPI_SECURITY_NONE:
+            return "None";
+        case NSAPI_SECURITY_WEP:
+            return "WEP";
+        case NSAPI_SECURITY_WPA:
+            return "WPA";
+        case NSAPI_SECURITY_WPA2:
+            return "WPA2";
+        case NSAPI_SECURITY_WPA_WPA2:
+            return "WPA/WPA2";
+        case NSAPI_SECURITY_UNKNOWN:
+        default:
+            return "Unknown";
+    }
+}
+
 
 nsapi_size_or_error_t WiFiManager::scanNetworks()
 {
@@ -88,14 +171,50 @@
 }
 
 
-nsapi_size_or_error_t WiFiManager::getAvailableAPs(WiFiAccessPoint * res, 
-                                                   nsapi_size_t count)
+//nsapi_size_or_error_t WiFiManager::getAvailableAPs(WiFiAccessPoint * res, 
+//                                                   nsapi_size_t ncount)
+nsapi_size_or_error_t WiFiManager::getAvailableAPs(nsapi_size_t ncount)
 {
-    count = network->scan(res, count);
+    WiFiAccessPoint       *ap;
+    nsapi_size_or_error_t count;
+    count = ncount;
+    //count = wiFiManager->scanNetworks();
+    if (count <= 0) {
+        //_smutex.lock();
+        printf("[WIFI-MAN] scan() failed with return value: %d\n", count);
+        //_smutex.unlock();
+        return;
+    }
+    /* Limit number of network arbitrary to 15 */
+    count = count < 15 ? count : 15;
+    ap = new WiFiAccessPoint[count];
+    count = network->scan(ap, count);
+    if (count <= 0) {
+        printf("[WIFI-MAN] scan() failed with return value: %d\n", count);
+        return;
+    }
+
+    for (int i = 0; i < count; i++) {
+        printf("[WIFI-MAN]: %s secured: %s BSSID: %hhX:%hhX:%hhX:%hhx:%hhx:%hhx RSSI: %hhd Ch: %hhd\n", ap[i].get_ssid(),
+               sec2str(ap[i].get_security()), ap[i].get_bssid()[0], ap[i].get_bssid()[1], ap[i].get_bssid()[2],
+               ap[i].get_bssid()[3], ap[i].get_bssid()[4], ap[i].get_bssid()[5], ap[i].get_rssi(), ap[i].get_channel());
+    }
+    printf("[WIFI-MAN]  %d networks available.\n", count);
+
+    delete[] ap;
     return count;
 }
 
 
+void WiFiManager::set_WIFI_CONFIG()
+{
+    wifi_config_t *wifi_cfg= (wifi_config_t *) data_msg->buffer;
+    set_WIFI_SSID(wifi_cfg->ssid);
+    set_WIFI_PASSWORD(wifi_cfg->pass);
+    set_WIFI_SECURITY(wifi_cfg->security);
+    free_DataMsg();
+}
+
 void WiFiManager::set_WIFI_SSID(char * wifi_ssid)
 {
     strcpy(wifi_config.ssid, wifi_ssid);
@@ -114,6 +233,66 @@
 }
 
 
+
+void WiFiManager::set_internet_config()
+{
+    internet_config_t *internet_cfg  = (internet_config_t *) data_msg->buffer;
+    internet_config.peer_id          = internet_cfg->peer_id;
+    internet_config.url              = internet_cfg->url;
+    internet_config.connectionScheme = internet_cfg->connectionScheme;
+    free_DataMsg();
+    printf("[WIFI MAN] Internet configuration setup completed\n"); 
+    printf("peer_id = %1d, url = %s, connScheme = %1d\n", internet_config.peer_id, 
+                                                      internet_config.url.c_str(), 
+                                                      internet_config.connectionScheme);
+}
+
+void WiFiManager::free_DataMsg()
+{
+    // free memory after processing
+    _aT2WiFiDatamPool->free(data_msg);
+}
+
+
+void WiFiManager::status_callback(nsapi_event_t status, intptr_t param)
+{
+    //if (status == NSAPI_EVENT_CONNECTION_STATUS_CHANGE) {
+    //}
+    switch(param) {
+        case NSAPI_STATUS_LOCAL_UP:
+            printf("[WIFI-MAN] Local IP address set!\r\n");
+            printf("[WIFI-MAN] IP address: %s\n", network->get_ip_address());
+            break;
+        case NSAPI_STATUS_GLOBAL_UP:
+            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);
+            is_connected = true;
+            break;
+        case NSAPI_STATUS_DISCONNECTED:
+            printf("No connection to network!\r\n");
+            printf("\n [WIFI-MAN] No connection to network!\n");
+            is_connected = false;
+            //queueATresponse(AT_DISCONNECT_RESP);
+            // attempt reconnection if always connected scheme is set
+            if(internet_config.connectionScheme == ALWAYS_CONNECTED)
+            {
+                nsapi_error_t error;
+                error = scanNetworks();
+                queueATresponse(WIFI_RECONNECT_INFO);
+            }
+            break;
+        case NSAPI_STATUS_CONNECTING:
+            printf("Connecting to network!\r\n");
+            break;
+        default:
+            printf("Not supported");
+            break;
+    }
+}
+
+
+
    //     NSAPI_STATUS_LOCAL_UP           = 0,        /*!< local IP address set */
    //     NSAPI_STATUS_GLOBAL_UP          = 1,        /*!< global IP address set */
    //     NSAPI_STATUS_DISCONNECTED       = 2,        /*!< no connection to network */
@@ -123,16 +302,20 @@
 nsapi_error_t WiFiManager::connect()
 {
     nsapi_error_t error;
-    printf("\n [WIFI-MAN] About to connect to WiFi networks\n");
+    printf("\n [WIFI-MAN] About to connect to WiFi network\n");
+    network->attach(callback(this, &WiFiManager::status_callback));
     error = network->set_blocking(false);
     if(error)
     {
         printf("\n [WIFI-MAN] Could not set non-blocking mode for Wifi -- aborting!! - \n");
         return error;
     }
+    printf("[WIFI-MAN] Connecting to network %s\n", wifi_config.ssid);
     error = network->connect(wifi_config.ssid,
                      wifi_config.pass,
                      wifi_config.security);
+    return error;
+    /*
     if(error)
     {
         printf("\n [WIFI-MAN] Could not connect to Wifi -- aborting!! - \n");
@@ -151,8 +334,10 @@
         printf("\n [WIFI-MAN] Error connecting to Wifi -- %d!! - \n", conn_status);
         return conn_status;
     }
-    printf("\n [WIFI-MAN] Connect to WiFi network completed - \n");
+    printf("[WIFI-MAN] Connected to the network %s\n", wifi_config.ssid);
+    printf("[WIFI-MAN] IP address: %s\n", network->get_ip_address());
     return conn_status;
+    */
 }
 
 

--- a/source/WiFiManager.h	Thu Mar 21 22:17:28 2019 +0000
+++ b/source/WiFiManager.h	Sat Mar 23 16:28:34 2019 +0000
@@ -22,19 +22,53 @@
     WiFiManager(wifi_config_t wifi_config, WiFiInterface *wifi, 
                 MemoryPool<wifi_cmd_message_t, 16> *aT2WiFimPool, 
                 Queue<wifi_cmd_message_t, 16> *aT2WiFiCmdQueue, 
-                MemoryPool<wifi_cmd_message_t, 16> *wiFi2ATmPool, 
-                Queue<wifi_cmd_message_t, 16> *wiFi2ATCmdQueue, 
+                MemoryPool<at_resp_message_t, 16> *wiFi2ATmPool, 
+                Queue<at_resp_message_t, 16> *wiFi2ATCmdQueue, 
                 MemoryPool<wifi_data_msg_t, 4> *aT2WiFiDatamPool, 
                 Queue<wifi_data_msg_t, 4> *aT2WiFiDataQueue, 
-                MemoryPool<wifi_data_msg_t, 4> *wiFi2ATDatamPool, 
-                Queue<wifi_data_msg_t, 4> *wiFi2ATDataQueue); 
+                MemoryPool<at_data_msg_t, 4> *wiFi2ATDatamPool, 
+                Queue<at_data_msg_t, 4> *wiFi2ATDataQueue); 
     ~WiFiManager();
+    void                  runMain();
+    void                  status_callback(nsapi_event_t status, intptr_t param);
+    
+
+
+private:
+    wifi_config_t     wifi_config;
+    internet_config_t internet_config;
+    WiFiInterface *network;
+    HttpsRequest* https_request;
+    HttpRequest* http_request;
+    HttpResponse* http_response;
+    nsapi_size_or_error_t lastScanCount;
+    wifi_cmd_t  wifiCmd;
+    /*  Queue and memory pool for AT to Wifi commands */
+    MemoryPool<wifi_cmd_message_t, 16> *_aT2WiFimPool;
+    Queue<wifi_cmd_message_t, 16> *_aT2WiFiCmdQueue;
+    
+    /*  Queue and memory pool for WiFi to AT commands */
+    MemoryPool<at_resp_message_t, 16> *_wiFi2ATmPool;
+    Queue<at_resp_message_t, 16> *_wiFi2ATCmdQueue;
+    
+    /*  Queue and memory pool for AT to WiFi data */
+    MemoryPool<wifi_data_msg_t, 4> *_aT2WiFiDatamPool;
+    Queue<wifi_data_msg_t, 4> *_aT2WiFiDataQueue;
+    wifi_data_msg_t *data_msg;
+    
+    /*  Queue and memory pool for WiFi to AT data */
+    MemoryPool<at_data_msg_t, 4> *_wiFi2ATDatamPool;
+    Queue<at_data_msg_t, 4> *_wiFi2ATDataQueue;
+
+    bool is_connected;
+    
     nsapi_size_or_error_t scanNetworks();
-    nsapi_size_or_error_t getAvailableAPs(WiFiAccessPoint * res, 
-                                          nsapi_size_t count);
+    nsapi_size_or_error_t getAvailableAPs(nsapi_size_t count);
     void                  set_WIFI_SSID(char * wifi_ssid);
     void                  set_WIFI_PASSWORD(char * wifi_pass);
     void                  set_WIFI_SECURITY(nsapi_security_t wifi_security);
+    void                  set_WIFI_CONFIG();
+    void                  set_internet_config();
     nsapi_error_t         connect();
     nsapi_error_t         disconnect();
     void                  createHttpsRequest(http_method method,
@@ -51,36 +85,12 @@
     void                  sendHttpRequest(const char * body, int bodyLen);
     bool                  setNextCommand(wifi_cmd_t cmd);
     bool                  dequeueWiFiCommands();
-    void                  runMain();
-    
-
+    bool                  queueATresponse(at_cmd_resp_t resp);
+    bool                  dequeueATdataResponse();
+    bool                  queueWiFiDataResponse(at_data_msg_t at_resp);
+    const char *          sec2str(nsapi_security_t sec);    
+    void                  free_DataMsg();
 
-private:
-    wifi_config_t wifi_config;
-    WiFiInterface *network;
-    HttpsRequest* https_request;
-    HttpRequest* http_request;
-    HttpResponse* http_response;
-    nsapi_size_or_error_t lastScanCount;
-    wifi_cmd_t  wifiCmd;
-    /*  Queue and memory pool for AT to Wifi commands */
-    MemoryPool<wifi_cmd_message_t, 16> *_aT2WiFimPool;
-    Queue<wifi_cmd_message_t, 16> *_aT2WiFiCmdQueue;
-    
-    /*  Queue and memory pool for WiFi to AT commands */
-    MemoryPool<wifi_cmd_message_t, 16> *_wiFi2ATmPool;
-    Queue<wifi_cmd_message_t, 16> *_wiFi2ATCmdQueue;
-    
-    /*  Queue and memory pool for AT to WiFi data */
-    MemoryPool<wifi_data_msg_t, 4> *_aT2WiFiDatamPool;
-    Queue<wifi_data_msg_t, 4> *_aT2WiFiDataQueue;
-    
-    
-    /*  Queue and memory pool for WiFi to AT data */
-    MemoryPool<wifi_data_msg_t, 4> wiFi2ATDatamPool;
-    Queue<wifi_data_msg_t, 4> wiFi2ATDataQueue;
-
-    
     /**
     * Allows timeout to be changed between commands
     *

--- a/source/common_types.h	Thu Mar 21 22:17:28 2019 +0000
+++ b/source/common_types.h	Sat Mar 23 16:28:34 2019 +0000
@@ -1,6 +1,7 @@
 #ifndef __COMMON_TYPES_H__
 #define __COMMON_TYPES_H__
 #include <mbed.h>
+#include <string>
 #include "ble/BLE.h"
 #include "SecurityManager.h"
 #include "common_config.h"
@@ -37,22 +38,85 @@
 typedef enum wifi_cmd
 {
   WIFI_CMD_NONE,
+  WIFI_CMD_CONFIG,
+  WIFI_CMD_INTERNET_CONFIG,
   WIFI_CMD_SCAN,
+  WIFI_CMD_DETAILED_SCAN,
   WIFI_CMD_CONNECT,
   WIFI_CMD_DISCONNECT,
   WIFI_CMD_SEND_HTTPS_REQ,
   WIFI_CMD_SEND_HTTP_REQ
 }wifi_cmd_t;
 
+typedef enum at_cmd_resp
+{
+  AT_RESP_NONE,
+  AT_SCAN_RESP,
+  AT_DETAILED_SCAN_RESP,
+  AT_CONNECT_RESP,
+  AT_DISCONNECT_RESP,
+  WIFI_RECONNECT_INFO,
+  WIFI_DISCONNECT_INFO,
+  AT_CONFIG_RESP,
+  AT_INTERNET_CONFIG_RESP,
+  AT_HTTPS_RESP,
+  AT_HTTP_RESP
+}at_cmd_resp_t;
+
+
+typedef enum at_data_mode
+{
+  AT_CMD_DATA_MODE,
+  AT_STD_DATA_MODE,
+  AT_EXT_DATA_MODE
+}at_data_mode_t;
+
+typedef enum conn_scheme
+{
+  INVALID_SCHEME,
+  ALWAYS_CONNECTED,
+  EXTERNAL_CONNECT
+}conn_scheme_t;
+
 
 typedef struct {
     wifi_cmd_t    wifi_cmd;   /* wifi command */
 } wifi_cmd_message_t;
 
 typedef struct {
+    at_cmd_resp_t    at_resp;   /* AT response */
+} at_resp_message_t;
+
+typedef struct {
     wifi_cmd_t    wifi_cmd;              /* wifi data command */
-    uint8_t       Buffer[TX_BUFFER_LEN]; /* buffer length     */
+    int           dataLen;              /* size of data in buffer */
+    uint8_t       buffer[TX_BUFFER_LEN]; /* buffer length     */
 } wifi_data_msg_t;
 
+typedef struct {
+    at_cmd_resp_t at_resp;              /* AT response */
+    int           dataLen;              /* size of data in buffer */
+    uint8_t       buffer[TX_BUFFER_LEN]; /* buffer length     */
+} at_data_msg_t;
+
+typedef struct {
+    string        hostName;     /* host name */
+    string        contentType;  /* content type */
+    int           bodyLen;      /* body length     */
+    uint8_t       body[900];    /* body     */
+} http_post_request_t;
+
+typedef struct {
+    string        contentType;  /* content type */
+    int           bodyLen;      /* body length     */
+    uint8_t       body[900];    /* body     */
+} http_response_t;
+
+typedef struct {
+    uint8_t       peer_id          ;  /* peer id */
+    conn_scheme_t connectionScheme;   /* connection scheme     */
+    string        url;          /* body     */
+} internet_config_t;
+
 
 #endif  // __COMMON_TYPES_H__
\ No newline at end of file

--- a/source/main-https.cpp	Thu Mar 21 22:17:28 2019 +0000
+++ b/source/main-https.cpp	Sat Mar 23 16:28:34 2019 +0000
@@ -53,21 +53,21 @@
 LEDService *ledServicePtr;
 
 /*  Queue and memory pool for AT to Wifi commands */
-MemoryPool<wifi_cmd_message_t, 16> aT2WiFimPool;
-Queue<wifi_cmd_message_t, 16> aT2WiFiCmdQueue;
+static MemoryPool<wifi_cmd_message_t, 16> aT2WiFimPool;
+static Queue<wifi_cmd_message_t, 16> aT2WiFiCmdQueue;
 
 /*  Queue and memory pool for WiFi to AT commands */
-MemoryPool<wifi_cmd_message_t, 16> wiFi2ATmPool;
-Queue<wifi_cmd_message_t, 16> wiFi2ATCmdQueue;
+static MemoryPool<at_resp_message_t, 16> wiFi2ATmPool;
+static Queue<at_resp_message_t, 16> wiFi2ATCmdQueue;
 
 /*  Queue and memory pool for AT to WiFi data */
-MemoryPool<wifi_data_msg_t, 4> aT2WiFiDatamPool;
-Queue<wifi_data_msg_t, 4> aT2WiFiDataQueue;
+static MemoryPool<wifi_data_msg_t, 4> aT2WiFiDatamPool;
+static Queue<wifi_data_msg_t, 4> aT2WiFiDataQueue;
 
 
 /*  Queue and memory pool for WiFi to AT data */
-MemoryPool<wifi_data_msg_t, 4> wiFi2ATDatamPool;
-Queue<wifi_data_msg_t, 4> wiFi2ATDataQueue;
+static MemoryPool<at_data_msg_t, 4> wiFi2ATDatamPool;
+static Queue<at_data_msg_t, 4> wiFi2ATDataQueue;
 
 
 
@@ -77,22 +77,22 @@
 //unsigned char hp_stk[1024];
 //unsigned char lp_stk[1024];
 unsigned char btle_stk[1024];
-unsigned char wifi_stk[1024];
-unsigned char atcmd_stk[1024];
+unsigned char wifi_stk[4*1024];
+unsigned char atcmd_stk[4*1024];
 
 /* creates three tread objects with different priorities */
 //Thread real_time_thread(osPriorityRealtime, 1024, &rt_stk[0]);
 //Thread high_prio_thread(osPriorityHigh, 1024, &hp_stk[0]);
 //Thread low_prio_thread(osPriorityNormal, 1024, &lp_stk[0]);
 Thread btle_thread(BTLE_THREAD_PRIORITY, 1024, &btle_stk[0]);
-Thread wifi_thread(WIFI_THREAD_PRIORITY, 1024, &wifi_stk[0]);
-Thread atcmd_thread(ATCMD_THREAD_PRIORITY, 1024, &atcmd_stk[0]);
+Thread wifi_thread(WIFI_THREAD_PRIORITY, 4*1024, &wifi_stk[0]);
+Thread atcmd_thread(ATCMD_THREAD_PRIORITY, 4*1024, &atcmd_stk[0]);
 
 
 /* create a semaphore to synchronize the threads */
 Semaphore sync_sema;
 
-Thread t;
+Thread evt_thread;
 #include "network-helper.h"
 
 /* List of trusted root CA certificates
@@ -388,13 +388,14 @@
 
 //#define DISABLE_WIFI
 #define DISABLE_WIFI_DEMO
+#define SKIP_WIFI_SCAN_DEMO
+#define BLE_STOP_START_ADV_SCAN_DEMO
+#define SKIP_WIFI_CONNECT_DEMO
 int main() {
     reset_counter++;
-    //performFreeMemoryCheck();
     print_memory_info();
     printf("\r\n ++++++ PROGRAM STARTING -- reset count = %d ++++++ \r\n", reset_counter);
     device = new RawSerial(USBTX, USBRX, DEFAULT_BAUD_RATE);
-    //ble_security_main();
     setupDefaultWiFiConfig();
     setupDefaultBleConfig();
     BLE& _ble = BLE::Instance();
@@ -408,24 +409,14 @@
 #endif
     print_memory_info();
     printf("\r\n PERIPHERAL \r\n\r\n");
-    //SMDevicePeripheral peripheral(ble, queue, peer_address);
     peripheral = new SMDevicePeripheral(_ble, queue, peer_address, ble_config);
     print_memory_info();
 
     peripheral->run();
     btle_thread.start(callback(&queue, &EventQueue::dispatch_forever));
-    //btle_thread.start(callback(peripheral, &SMDevicePeripheral::run));
-    //performFreeMemoryCheck();
-    //reportGapState();
     print_memory_info();
     printWaitAbortKeyPress(120);
-    //reportGapState();
     peripheral->stopAdvertising();
-    //queue.break_dispatch();
-    //reportGapState();
-    //btle_thread.join();
-    //performFreeMemoryCheck();
-    printf("\r\n BTLE THREAD HAS RETURNED \r\n\r\n");
 
 #ifndef DISABLE_WIFI // comment out wifi part
     int start = Kernel::get_ms_count();
@@ -445,26 +436,25 @@
     int stop = Kernel::get_ms_count();
     device->printf("\n The Wifi Network scan took %d ms or %4.1f seconds\n", (stop - start), (float)((stop - start)/1000.0));
     // run on separate thread;
-    t.start(callback(wifi_demo, network));
-    t.join(); 
+    evt_thread.start(callback(wifi_demo, network));
+    evt_thread.join(); 
     network->disconnect(); 
     delete network;
     device->printf("\n Wifi-Demo completed - restarting BLE  \n\n");
-#endif
+#endif /// endif DISABLE_WIFI_DEMO
+
 #else
     device->printf("\n Wifi Demo disabled so just waiting it out...  \n\n");
     printWait(2); // lets wait for a minute before turning BLE back on
     device->printf("\n ++++++ restarting BLE ++++++ \n\n");
-#endif
+#endif  /// endif DISABLE_WIFI
+    printWaitAbortKeyPress(60);
     peripheral->startAdvertising();
-    printWait(2);
 #ifdef ENABLE_UART_BACKGRND_DEMO
     for(int i=0;i<255;i++)
     {
         device->putc(i);
     }
-    //int n;
-    //ReadUartBytes(RxBuffer, RX_BUFFER_LEN, 4);
     reportGapState();
     device->printf("\n\n\nEnter # of expected bytes: ");
     ReadUartBytes(RxBuffer, RX_BUFFER_LEN, 4, true);
@@ -482,7 +472,7 @@
 
     device->printf("\r\n++++++ Press key for Wifi demo test ++++++ \r\n");
     printWaitAbortKeyPress(120);
-#ifdef SKIP_WIFI_SCAN_DEMO
+#ifndef SKIP_WIFI_SCAN_DEMO
     device->printf("\r\n++++++ Test WiFi Manager Network Scan ++++++ \r\n");
     int count;
     count = wiFiManager->scanNetworks();
@@ -493,6 +483,8 @@
         device->printf("\r\n++++++ Test WiFi Scan found %d networks ++++++ \r\n ++++ SUCCESS ++++\r\n", count);
     }
 #endif    
+
+#ifndef SKIP_WIFI_CONNECT_DEMO
     device->printf("\r\n++++++ Test WiFi Manager Network connect ++++++ \r\n");
     nsapi_error_t werror;
     werror = wiFiManager->connect();
@@ -513,7 +505,7 @@
             device->printf("\r\n++++++ Test WiFi disconnect SUCCESSFUL ++++++ \r\n");
         }
     }
-    
+#endif    
     //wiFiManager->runMain();
     device->printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \r\n");
     device->printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \r\n");
@@ -522,13 +514,9 @@
     device->printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \r\n");
     device->printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \r\n");
     device->printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \r\n");
-    t.start(callback(wiFiManager, &WiFiManager::runMain));
-    /* disconnect in 2 s */
-    //_event_queue.call_in(
-    //    2000, &_ble.gap(),
-    //    &Gap::disconnect, _handle, Gap::REMOTE_USER_TERMINATED_CONNECTION
-    //eventQueue.dispatch_forever();
-    wifi_thread.start(callback(&eventQueue, &EventQueue::dispatch_forever));
+    wifi_thread.start(callback(wiFiManager, &WiFiManager::runMain));
+    // dispatch event queue on event thread
+    evt_thread.start(callback(&eventQueue, &EventQueue::dispatch_forever));
     device->printf("\r\n++++++ Starting ATCmdmanager ++++++ \r\n");
     ATCmdManager *aTCmdManager = new ATCmdManager(USBTX, USBRX, peripheral, 
                                                 eventQueue, wiFiManager, 
@@ -537,8 +525,8 @@
                                                 &aT2WiFiDatamPool, &aT2WiFiDataQueue,
                                                 &wiFi2ATDatamPool, &wiFi2ATDataQueue,
                                                 true);
-    aTCmdManager->runMain();
-    //atcmd_thread.start(callback(aTCmdManager, &ATCmdManager::runMain));
+    //aTCmdManager->runMain();
+    atcmd_thread.start(callback(aTCmdManager, &ATCmdManager::runMain));
     while(1) wait(0.1);
     //performFreeMemoryCheck();