Revision 84:7c7add00f4bf, committed 2019-03-28

Comitter:

ocomeni

Date:

Thu Mar 28 22:13:06 2019 +0000

Parent:

83:9c271a50a70b

Child:

85:9f896e1e041c

Commit message:

internet configuration issues fixed.

Changed in this revision

--- a/mbed_app.json	Tue Mar 26 23:33:51 2019 +0000
+++ b/mbed_app.json	Thu Mar 28 22:13:06 2019 +0000
@@ -17,7 +17,15 @@
         },
         "overrides": {
             "lse_available": false 
-        }    
+        }    ,
+        "uart1_tx": {
+            "help": "UART1 TX pin",
+            "value": "NC"
+        },
+        "uart1_rx": {
+            "help": "UART1 RX pin",
+            "value": "NC"
+        }
     },
     "macros": [
         "MBEDTLS_MPI_MAX_SIZE=1024",
@@ -27,7 +35,8 @@
         "MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES",
         "MBED_HEAP_STATS_ENABLED=1",
         "MBED_STACK_STATS_ENABLED=1",
-        "MBED_MEM_TRACING_ENABLED=1"
+        "MBED_MEM_TRACING_ENABLED=1",
+        "DEBUG_ISR_STACK_USAGE=1"
     ],
     "target_overrides": {
          "*": {
@@ -42,7 +51,9 @@
       },
         "MTB_UBLOX_ODIN_W2": {
             "target.features_add": ["BLE"],
-            "target.extra_labels_add": ["CORDIO", "CORDIO_BLUENRG"]
+            "target.extra_labels_add": ["CORDIO", "CORDIO_BLUENRG"],
+            "uart1_tx": "D1",
+            "uart1_rx": "D0"
         }
      }
 }

--- a/source/ATCmdManager.cpp	Tue Mar 26 23:33:51 2019 +0000
+++ b/source/ATCmdManager.cpp	Thu Mar 28 22:13:06 2019 +0000
@@ -1,7 +1,8 @@
 #include "ATCmdManager.h"
 #include "common_config.h"
 #include "common_types.h"
-
+#include "http_request.h"
+//#include "mbed_memory_status.h"
 
 ATCmdManager::ATCmdManager(PinName tx, PinName rx, SMDevicePeripheral *blePeripheral, 
                            events::EventQueue &event_queue, WiFiManager *wifi, 
@@ -58,7 +59,7 @@
     _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+UWSC=0,5", callback(this, &ATCmdManager::_oob_sendHttpMessage));
+    //_parser.oob("AT+UWSC=0,5", callback(this, &ATCmdManager::_oob_sendHttpMessage));
  
 //AT+UWSC=0,2,<SSID>
 //AT+UWSC=0,8,<PWD>
@@ -89,58 +90,74 @@
                 break;
             case AT_SCAN_RESP:
                 // AT_SCAN_RESP response state
-                _smutex.lock();
+                //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI SCAN RESPONSE RECEIVED!!\n");
                 _parser.send("OK\n");
-                _smutex.unlock();
+                //////_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_DETAILED_SCAN_RESP:
                 // AT_DETAILED_SCAN_RESP response state
-                _smutex.lock();
+                //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI DETAILED SCAN RESPONSE RECEIVED!!\n");
                 _parser.send("OK\n");
-                _smutex.unlock();
+                //////_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_CONNECT_RESP:  
                 // AT_CONNECT_RESP response state 
-                _smutex.lock();
+                //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI CONNECT RESPONSE RECEIVED!!\n");
                 _parser.send("OK\n");
-                _smutex.unlock();
+                //////_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_DISCONNECT_RESP:  
                 // AT_DISCONNECT_RESP response state 
-                _smutex.lock();
+                //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI DISCONNECT RESPONSE RECEIVED!!\n");
                 _parser.send("OK\n");
-                _smutex.unlock();
+                //////_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
             case AT_CONFIG_RESP:  
                 // AT_CONFIG_RESP response state 
-                _smutex.lock();
+                //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI CONFIG RESPONSE RECEIVED!!\n");
                 _parser.send("OK\n");
-                _smutex.unlock();
+                //////_smutex.unlock();
+                at_resp = AT_RESP_NONE;
+                break;
+            case AT_INTERNET_CONFIG_RESP:  
+                // AT_CONFIG_RESP response state 
+                //////_smutex.lock();
+                printf("\n [ATCMD MAN] WIFI INTERNET_CONFIG RESPONSE RECEIVED!!\n");
+                _parser.send("OK\n");
+                //////_smutex.unlock();
+                at_resp = AT_RESP_NONE;
+                break;
+            case AT_HTTPS_RESP:  
+                // AT_HTTP_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();
+                //////_smutex.lock();
                 printf("\n [ATCMD MAN] WIFI HTTP RESPONSE RECEIVED!!\n");
                 _parser.send("OK\n");
-                _smutex.unlock();
+                //////_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
             default:
                 // UNKNOWN response state
-                _smutex.lock();
+                //////_smutex.lock();
                 printf("\n [ATCMD MAN] UNKNOWN RESPONSE RECEIVED!!\n");
                 _parser.send("OK\n");
-                _smutex.unlock();
+                //////_smutex.unlock();
                 at_resp = AT_RESP_NONE;
                 break;
         }
@@ -164,17 +181,99 @@
     return true;
 }
 
+http_method ATCmdManager::str2HttpMethod(const char * methodStr)
+{
+    http_method _http_method;
+    if(strstr(methodStr, "POST")!= NULL){
+        _http_method = HTTP_POST;
+    }
+    else if(strstr(methodStr, "GET")!= NULL){
+        _http_method = HTTP_GET;
+    }
+    else{
+        _http_method = HTTP_DELETE; // unsupported method - set to HTTP_DELETE
+    }
+    return _http_method;
+}
+bool ATCmdManager::createHttpRequest()
+{
+    http_request_t http_req;
+    char s1[32];
+    char s2[32];
+    char s3[32];
+    int n = 0;
+    int pos = 0;
+    char * strPtr = (char *)&rx_buf_ptr[1];
+    char * p;
+    char * p2 = strstr(strPtr, "\r\n\r\n");
+    char * nxtPtr = strPtr;
+    char * bodyPtr = p2+4;
+    printf("\nstrPtr address= %x",strPtr);
+    printf("\np2 address= %x", p2);
+    for(int i = 0; i < 5; i++){
+        if(i == 0)// firstline scan method uri and http_ver
+        {
+            //n = sscanf(nxtPtr,"%s %s %s", &s1[0], &s2[0], &s3[0]);
+            n = sscanf(nxtPtr,"%s %s %s", s1, s2, s3);
+            printf("\nmethod = %s\nuri = %s\nhttp_ver = %s",s1, s2, s3 );
+            //http_req.method = str2HttpMethod(s1.c_str());
+            http_req.method = str2HttpMethod(s1);
+            http_req.request_URI.assign(s2);
+            http_req.http_version.assign(s3);
+        }
+        else{ // scan header pairs
+            //n = sscanf(nxtPtr,"%s %s", &s1[0], &s2[0]);
+            n = sscanf(nxtPtr,"%s %s", s1, s2);
+            p = strstr(s1,":");
+            *p = NULL;
+            //pos = s1.find(":");
+            //s1.replace(pos,1,"");
+            printf("\nname = %s value = %s",s1, s2);
+            //if(s1.find("Host")!= string::npos){
+            if(strstr(s1, "POST")!= NULL){
+                http_req.http_version.assign(s3);
+            }
+            
+            
+        }
+        nxtPtr = strstr(nxtPtr, "\r\n")+2; // goto next line
+        if(nxtPtr >= p2) break;
+    }
+    int bodyLen = edm_hdr.payloadLen -(p2+7-strPtr);
+    printf("\nLen = %d\n", bodyLen);
+    memcpy(http_req.body, bodyPtr, bodyLen);
+    // package and send on wifi data queue
+    wifi_data_msg_t data_msg;
+    data_msg.wifi_cmd = WIFI_CMD_SEND_HTTPS_REQ;
+    data_msg.dataLen = sizeof(http_req) + http_req.request_URI.length() +
+                       http_req.http_version.length() + 
+                       http_req.hostName.length() +
+                       http_req.AcceptVal.length() +
+                       http_req.contentType.length() +
+                       http_req.contentLen.length();
+    memcpy(data_msg.buffer,&http_req, data_msg.dataLen);
+    // queue next data request
+    queueWiFiDataRequest(data_msg);
+    return true;
+}
 // OOB processing
 void ATCmdManager::_process_oob(uint32_t timeout, bool all){
     set_timeout(timeout);
     static int cnt = 0;
+    int start;
     if(dataMode == AT_EXT_DATA_MODE)
     {
         int n;
         if(cnt++ % 10 == 0)printf("In EDM mode\n");
+        uint8_t edm[EDM_HDR_LEN];
+        
         // Poll for edm packets
         do{
-            n = _parser.read((char *)&edm_hdr, EDM_HDR_LEN);
+            n = _parser.read((char *)edm, EDM_HDR_LEN);
+            edm_hdr.startByte = edm[0];
+            edm_hdr.payloadLen = edm[1]*256 + edm[2];
+            edm_hdr.payloadID = edm[3]*256 + edm[4];
+            start = Kernel::get_ms_count();
             if(n == -1) break; // break if it times out
             printf("%d bytes read!\n", n);
             if(n==5)
@@ -217,27 +316,15 @@
                             printf("DATA_EVENT received!\n");
                             break;
                         case DATA_COMMAND:
-                            char s1[100];
                             printf("DATA_COMMAND received!\n");
-                            int n = 0;
-                            int cnt = 0;
-                            int len = 0;
-                            char * strPtr = (char *)&rx_buf_ptr[1];
-                            char * p2 = strstr(strPtr, "\r\n\r\n");
-                            char * nxtPtr = strPtr;
-                            printf("\nstrPtr address= %x",strPtr);
-                            printf("\np2 address= %x", p2);
-                            while(1){
-                                n = sscanf(nxtPtr,"%s[^:]", s1);
-                                len = strlen(s1);
-                                if(n<=0) break;
-                                printf("\ns[%d] = %s len = %d, n = %d",cnt++,s1, len, n );
-                                if(cnt==20) break;
-                                nxtPtr = strstr(nxtPtr, s1)+len;
-                                printf("\nxtPtr address= %x p2 addr = %x",nxtPtr, p2);
-                                if(nxtPtr > p2) break;
+                            if(createHttpRequest() == true){
+                                _parser.send("OK");
                             }
-                            
+                            else{
+                                _parser.send("NACK");
+                            }
+                            int stop = Kernel::get_ms_count();
+                            printf("\n Time Elapsed = %d\n", stop-start);
                             break;
                         case AT_REQUEST:
                             printf("AT_REQUEST received!\n");
@@ -276,9 +363,9 @@
 }
 
 void ATCmdManager::_oob_ok_hdlr(){
-    _smutex.lock();
+    //_smutex.lock();
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 
@@ -326,28 +413,28 @@
 
 void ATCmdManager::_oob_echo_off()
 {
-    _smutex.lock();
+    //_smutex.lock();
     printf("\n Received ATEO OOB command!!\n");
     printf("\n turning echo OFF!!\n");
     _parser.debug_on(false);
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 
 void ATCmdManager::_oob_echo_on()
 {
-    _smutex.lock();
+    //_smutex.lock();
     printf("\n Received ATE1 OOB command!!\n");
     printf("\n turning echo ON!!\n");
     _parser.debug_on(true);
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 
 void ATCmdManager::_oob_data_mode(){
-    _smutex.lock();
+    //_smutex.lock();
     printf("\n Received EDM mode command!!\n");
     if(_parser.scanf("%d", &dataMode) >0) {
         printf("\nATCmdParser: Data mode=%d\n", dataMode);
@@ -373,12 +460,12 @@
         printf("\nATCmdParser: Retrieving Uart Options failed\n");
     }
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 void ATCmdManager::_oob_get_mac_addr(){
     int bleOrWifi;
-    _smutex.lock();
+    //_smutex.lock();
     if(_parser.scanf("=%d", &bleOrWifi) >0) {
         switch(bleOrWifi)
         {
@@ -396,30 +483,30 @@
         printf("\nATCmdParser: Retrieving Uart Options failed");
     }
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 void ATCmdManager::_oob_get_ble_role(){
-    _smutex.lock();
+    //_smutex.lock();
     printf("\n Received get BLE role command!!\n");
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 void ATCmdManager::_oob_ena_ble_peri(){
-    _smutex.lock();
+    //_smutex.lock();
     printf("\n Received enable BLE Peripheral command!!\n");
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 void ATCmdManager::_oob_reboot(){
-    _smutex.lock();
+    //_smutex.lock();
     printf("\n Received reboot command!!\n");
     _parser.send("OK\n");
     _parser.send("System Resetting....\n");
     system_reset();
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 const char * ATCmdManager::sec2str(nsapi_security_t sec)
@@ -452,10 +539,10 @@
 
 
 void ATCmdManager::_oob_scanWiFiNetworks(){
-    _smutex.lock();
+    //_smutex.lock();
     printf("\n Received scanWiFiNetworks command!!\n");
     _parser.send("OK\n");
-    _smutex.unlock();
+    //_smutex.unlock();
     wifi_cmd_t cmd = WIFI_CMD_SCAN;
     // queue next command
     queueWiFiCommand(cmd);
@@ -481,32 +568,57 @@
 
 void ATCmdManager::_oob_setupInternetConnection()
 {
-    char url[200];
+    ////print_memory_info();
+    char str[200]; // = (char *) malloc(200);
+    char url[60]; // = (char *) malloc(60);
     int n;
+    //internet_config_t *internet_config = (internet_config_t *) malloc(sizeof(internet_config_t));
     internet_config_t internet_config;
-    _smutex.lock();
-    n = _parser.scanf("=%1d,%199[^,],%1d", &internet_config.peer_id, 
+    printf("sizeof internet_config_t = %d\n", sizeof(internet_config_t));
+    //internet_config->url;
+    //internet_config->url;
+    //_smutex.lock();
+    n = ReadBytes((uint8_t *)str, 199);
+    str[n]=NULL;
+    printf("\n read string = %s , n = %d\n", str, n);
+    n = sscanf(str, "=%1d,%199[^,],%1d", &internet_config.peer_id, 
                                       url,
                                      &internet_config.connectionScheme);
+    strncpy(internet_config.url, url, strlen(url)+1);
+    printf("\n read string = %s , n = %d -- strlen(url) = %d\n", internet_config.url, n, strlen(url));
     if(n>0) 
     {
-        internet_config.url = url;
+        //printf("before assign - still ok\n");
+        //internet_config.url.append(url);
+        //printf("after assign - still ok\n");
+        //print_all_thread_info();
+        //print_memory_info();
+        //internet_config->url->assign(url);
+        ////print_memory_info();
         printf("peer_id = %1d, url = %s, connScheme = %1d\n", internet_config.peer_id, 
-                                                          internet_config.url.c_str(), 
+                                                          internet_config.url, ///->c_str(), 
                                                           internet_config.connectionScheme);
+        //print_memory_info();
         // package and send on wifi data queue
-        wifi_data_msg_t data_msg;
+        wifi_data_msg_t data_msg; // = (wifi_data_msg_t *) malloc(sizeof(wifi_data_msg_t));
         data_msg.wifi_cmd = WIFI_CMD_INTERNET_CONFIG;
-        data_msg.dataLen = sizeof(internet_config) + internet_config.url.length();
+        data_msg.dataLen = sizeof(internet_config_t); // + strlen(internet_config.url);
+        printf("\n url size = %d url str = %s\n",strlen(internet_config.url), internet_config.url );
         memcpy(data_msg.buffer,&internet_config, data_msg.dataLen);
+        //print_memory_info();
+        //free(internet_config->url);
+        //free(internet_config);
+        //free(str);
+        //free(url);
         // queue next data request
         queueWiFiDataRequest(data_msg);
+        print_memory_info();
         _parser.send("OK\n");
     } else {
         printf("\n[ATCMD MAN]: internet configuration failed %d fields parsed \n", n);
         _parser.send("NAK\n");
     }
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 wifi_config_t ATCmdManager::init_wifi_config()
@@ -553,7 +665,7 @@
 {
     int n;
     wifi_config_t wifi_cfg = init_wifi_config();
-    _smutex.lock();
+    //_smutex.lock();
     n = readStringBytes((uint8_t *)wifi_cfg.ssid, 32);
     printf("[ATCMD MAN]: number of bytes read = %d\n", n);
     if(n>0) 
@@ -570,14 +682,14 @@
         printf("\n[ATCMD MAN]: wifi configuration failed  \n");
         _parser.send("NAK\n");
     }
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 void ATCmdManager::_oob_setWiFiPWD()
 {
     int n;
     wifi_config_t wifi_cfg = init_wifi_config();
-    _smutex.lock();
+    //_smutex.lock();
     //n = _parser.scanf("%31[^\r\n]", wifi_cfg.pass);
     n = readStringBytes((uint8_t *)wifi_cfg.pass, 32);
     if(n>0) 
@@ -594,14 +706,14 @@
         printf("\n[ATCMD MAN]: wifi configuration failed  \n");
         _parser.send("NAK\n");
     }
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 void ATCmdManager::_oob_setWiFiSecurity()
 {
     int n;
     wifi_config_t wifi_cfg = init_wifi_config();
-    _smutex.lock();
+    //_smutex.lock();
     n = _parser.scanf(",%d", &wifi_cfg.security);
     if(n>0) 
     {
@@ -617,15 +729,15 @@
         printf("\n[ATCMD MAN]: wifi configuration failed  \n");
         _parser.send("NAK\n");
     }
-    _smutex.unlock();
+    //_smutex.unlock();
 }
 
 
 void ATCmdManager::_oob_sendHttpMessage()
 {
     int n;
-    http_post_request_t http_post_request;
-    _smutex.lock();
+    http_request_t http_post_request;
+    //_smutex.lock();
     /*
     n = _parser.scanf(",%d", &wifi_cfg.security);
     if(n>0) 
@@ -643,7 +755,7 @@
         _parser.send("NAK\n");
     }
     */
-    _smutex.unlock();
+    //_smutex.unlock();
 
 }
 
@@ -672,6 +784,7 @@
     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);
+    //free(&data_req);
     return true;
 }
 

--- a/source/ATCmdManager.h	Tue Mar 26 23:33:51 2019 +0000
+++ b/source/ATCmdManager.h	Thu Mar 28 22:13:06 2019 +0000
@@ -7,13 +7,13 @@
 #include "BleManager.h"
 #include "WiFiManager.h"
 
-#define MAIN_LOOP_WAIT_TIME_MS 1000 // milliseconds
+#define MAIN_LOOP_WAIT_TIME_MS 100 // milliseconds
 #define NUM_UART_OPTIONS       6
 #ifndef UBLOX_ODIN_W2_MISC_TIMEOUT
 #define UBLOX_ODIN_W2_MISC_TIMEOUT    2000
 #endif
 
-
+extern void print_memory_info();
 class ATCmdManager {
 public:
     ATCmdManager(PinName tx, PinName rx, SMDevicePeripheral *blePeripheral, 
@@ -104,6 +104,8 @@
     int   ReadBytes(uint8_t *buf, int maxBytes);
     int   readStringBytes(uint8_t *buf, int maxBytes);
     bool  validate(edm_header_t edm_header);
+    bool  createHttpRequest();
+    http_method str2HttpMethod(const char * methodStr);
 
     
     /**

--- a/source/WiFiManager.cpp	Tue Mar 26 23:33:51 2019 +0000
+++ b/source/WiFiManager.cpp	Thu Mar 28 22:13:06 2019 +0000
@@ -31,6 +31,7 @@
  wifiCmd = WIFI_CMD_NONE;
  internet_config.connectionScheme = ALWAYS_CONNECTED; // set default connection scheme
  is_connected = false;
+ chunkNum = 0;
 }
 
 WiFiManager::~WiFiManager()
@@ -97,6 +98,8 @@
                 queueATresponse(AT_INTERNET_CONFIG_RESP);
                 break;
             case WIFI_CMD_SEND_HTTPS_REQ:
+                createHttpsRequest();
+                wifiCmd = WIFI_CMD_NONE;
                 break;
             case WIFI_CMD_SEND_HTTP_REQ:
                 break;
@@ -243,12 +246,12 @@
 {
     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;
+    strncpy(internet_config.url,internet_cfg->url, strlen(internet_cfg->url)+1);
     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.url, 
                                                       internet_config.connectionScheme);
 }
 
@@ -372,19 +375,97 @@
 
 
 */
+void WiFiManager::return_response(HttpResponse* res) {
+    
+    //queueWiFiDataResponse(at_data_msg_t at_data_resp);
+    printf("Status: %d - %s\n", res->get_status_code(), res->get_status_message().c_str());
+    printf("Headers:\n");
+    at_data_msg_t at_data_resp; 
+    //at_data_resp = &at_data;
+    at_data_resp.dataLen = sizeof(res); // start with minimum size of response
+    for (size_t ix = 0; ix < res->get_headers_length(); ix++) {
+        printf("\t%s: %s\n", res->get_headers_fields()[ix]->c_str(), res->get_headers_values()[ix]->c_str());
+        at_data_resp.dataLen+= res->get_headers_fields()[ix]->size();
+        at_data_resp.dataLen+= res->get_headers_values()[ix]->size();
+    }
+    at_data_resp.dataLen+= res->get_body_length();
+    printf("\nBody (%lu bytes):\n\n%s\n", res->get_body_length(), res->get_body_as_string().c_str());
+    //printf("WIFI MAN]: wifi_cfg.security = %s\n", sec2str(wifi_cfg.security));
+    // package and send on wifi data queue
+    
+    at_data_resp.at_resp = AT_HTTPS_RESP;
+    //at_data_resp.at_data_resp = sizeof(wifi_config_t);
+    memcpy(at_data_resp.buffer, res, at_data_resp.dataLen);
+    queueWiFiDataResponse(at_data_resp);
 
-void WiFiManager::createHttpsRequest(http_method method,
-                                     const char* url,
-                                     Callback<void(const char *at, uint32_t length)> body_callback)
+}
+
+
+void WiFiManager::body_callback(const char *at, uint32_t length) {
+    
+    printf("\n Chunked response: Chunk %d : Total Bytes = %d\n", chunkNum , length);
+    //device->printf("\n Try Print Header as string:\n\n ");
+    //device->printf("recv %d [%.*s]\n", length, strstr((char *)at, "\r\n")-(char *)at, (char *)at);
+    //if(false)
+    //if(chunkNum < 2)
+    //for(int i=0; i < length; i++){
+    //    
+    //putc((uint8_t)at[i]);
+        //int resp = write( (const uint8_t *)at, (int) length, &completed, SERIAL_EVENT_TX_COMPLETE);
+    //}
+    //if(false)
+    if(chunkNum < 2)
+    for (size_t ix = 0; ix < length; ix++) {
+        printf("%02X: ", (uint8_t)at[ix]);
+        if((ix % 32) == 0 and ix)
+        printf("\n");
+    }
+    printf("\n\n");
+    chunkNum++;
+    //device->printf("\nBody (%lu bytes):\n\n%s\n", res->get_body_length(), res->get_body_as_string().c_str());
+}
+
+void WiFiManager::createHttpsRequest()
 {
-    https_request = new HttpsRequest(network, SSL_CA_PEM, method, url, body_callback);
+    
+    //http_method method,
+    //Callback<void(const char *at, uint32_t length)> body_callback = 0
+    printf("\n[WIFI MAN] Http Request received:");
+    http_req_cfg = (http_request_t *) data_msg->buffer;
+    strncat(internet_config.url, http_req_cfg->request_URI.c_str(), strlen(http_req_cfg->request_URI.c_str()+1));
+    printf("\n[WIFI MAN] server url = %s\n", internet_config.url);
+    //printf("\n[WIFI MAN] server url = %s\n", internet_config.url.c_str());
+    //const char* url = internet_config.url;
+                                           
+    //https_request = new HttpsRequest(network, 
+    http_request = new HttpRequest(network, 
+                                     //SSL_CA_PEM, 
+                                     http_req_cfg->method, 
+                                     internet_config.url,
+                                     callback(this, &WiFiManager::body_callback));
+    setHttpHeader("Host", http_req_cfg->hostName);
+    setHttpHeader("Accept", http_req_cfg->AcceptVal);
+    setHttpHeader("Content-Type", http_req_cfg->contentType);
+    setHttpHeader("Content-Length", http_req_cfg->contentLen);
+    int bodyLen;
+    sscanf(http_req_cfg->contentLen.c_str(), "%d", &bodyLen);
+    http_response = https_request->send(http_req_cfg->body, bodyLen);
+    free_DataMsg();
+    if (!http_response) {
+        printf("HttpRequest failed (error code %d)\n", https_request->get_error());
+        return;
+    }
+
+    printf("\n----- HTTPS POST response -----\n");
+    return_response(http_response);
 }
 
 void WiFiManager::createHttpRequest(http_method method,
                                     const char* url,
                                     Callback<void(const char *at, uint32_t length)> body_callback)
 {
-    http_request = new HttpRequest(network, method, url, body_callback);;
+    http_request = new HttpRequest(network, 
+                                   method, url, body_callback);;
 }
 
 void WiFiManager::setHttpHeader(string key, string value)

--- a/source/WiFiManager.h	Tue Mar 26 23:33:51 2019 +0000
+++ b/source/WiFiManager.h	Thu Mar 28 22:13:06 2019 +0000
@@ -41,8 +41,11 @@
     HttpsRequest* https_request;
     HttpRequest* http_request;
     HttpResponse* http_response;
+    http_request_t *http_req_cfg;
     nsapi_size_or_error_t lastScanCount;
     wifi_cmd_t  wifiCmd;
+    //at_data_msg_t *at_data_resp;
+    int         chunkNum;
     /*  Queue and memory pool for AT to Wifi commands */
     MemoryPool<wifi_cmd_message_t, 16> *_aT2WiFimPool;
     Queue<wifi_cmd_message_t, 16> *_aT2WiFiCmdQueue;
@@ -71,10 +74,7 @@
     void                  set_internet_config();
     nsapi_error_t         connect();
     nsapi_error_t         disconnect();
-    void                  createHttpsRequest(http_method method,
-                                           const char* url,
-                                           Callback<void(const char *at, uint32_t length)> body_callback = 0
-                                           );
+    void                  createHttpsRequest();
     void                  createHttpRequest(http_method method,
                                           const char* url,
                                           Callback<void(const char *at, uint32_t length)> body_callback = 0
@@ -90,6 +90,8 @@
     bool                  queueWiFiDataResponse(at_data_msg_t at_resp);
     const char *          sec2str(nsapi_security_t sec);    
     void                  free_DataMsg();
+    void                  body_callback(const char *at, uint32_t length);
+    void                  return_response(HttpResponse* res);
 
     /**
     * Allows timeout to be changed between commands

--- a/source/common_config.h	Tue Mar 26 23:33:51 2019 +0000
+++ b/source/common_config.h	Thu Mar 28 22:13:06 2019 +0000
@@ -9,7 +9,7 @@
 #define WIFI_THREAD_PRIORITY osPriorityRealtime
 #define ATCMD_THREAD_PRIORITY osPriorityRealtime
 #ifndef UBLOX_ODIN_W2_RECV_TIMEOUT
-#define UBLOX_ODIN_W2_RECV_TIMEOUT    2000
+#define UBLOX_ODIN_W2_RECV_TIMEOUT    100
 #endif
 
 const uint8_t hello_msg[] = {0xaa,0x00,0x96,0x00,0x36,0x00,0x50,0x4f

--- a/source/common_types.h	Tue Mar 26 23:33:51 2019 +0000
+++ b/source/common_types.h	Thu Mar 28 22:13:06 2019 +0000
@@ -4,10 +4,18 @@
 #include <string>
 #include "ble/BLE.h"
 #include "SecurityManager.h"
+#include "http_request.h"
 #include "common_config.h"
 #define BLE_MAX_DEVICE_NAME_LEN 10
 #define MAX_SSID_LEN 32
 #define MAX_PASSKEY_LEN 32
+#define EDM_START_BYTE       0xAA
+#define EDM_STOP_BYTE        0x55
+#define EDM_HDR_LEN          5
+#define MAX_EDM_PAYLOAD_LEN  (4096-1)
+#define MIN_EDM_PAYLOAD_LEN (2)
+#define MAX_HTTP_HEADER_LINES
+#define MAX_URL_LEN          100
 
 /** ble configuration structure
 */
@@ -111,11 +119,15 @@
 } at_data_msg_t;
 
 typedef struct {
+    http_method   method;       /* POST/GET etc... */
+    string        request_URI;  /* request URI/path */
+    string        http_version; /* http verstion HTTP/1.1 */
     string        hostName;     /* host name */
+    string        AcceptVal;    /* types accepted */
     string        contentType;  /* content type */
-    int           bodyLen;      /* body length     */
+    string        contentLen;   /* content length as string   */
     uint8_t       body[900];    /* body     */
-} http_post_request_t;
+} http_request_t;
 
 typedef struct {
     uint8_t       startByte;   /* start Byte 0xAA */
@@ -132,12 +144,8 @@
 typedef struct {
     uint8_t       peer_id          ;  /* peer id */
     conn_scheme_t connectionScheme;   /* connection scheme     */
-    string        url;          /* body     */
+    //string     *  url;          /* body     */
+    char        url[MAX_URL_LEN];          /* body     */
 } internet_config_t;
 
-#define EDM_START_BYTE       0xAA
-#define EDM_STOP_BYTE        0x55
-#define EDM_HDR_LEN          5
-#define MAX_EDM_PAYLOAD_LEN  (4096-1)
-#define MIN_EDM_PAYLOAD_LEN (2)
 #endif  // __COMMON_TYPES_H__
\ No newline at end of file

--- a/source/main-https.cpp	Tue Mar 26 23:33:51 2019 +0000
+++ b/source/main-https.cpp	Thu Mar 28 22:13:06 2019 +0000
@@ -76,18 +76,26 @@
 //unsigned char rt_stk[1024];
 //unsigned char hp_stk[1024];
 //unsigned char lp_stk[1024];
-unsigned char btle_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]);
+
+#ifdef USE_MAIN_THREAD_STACK
+// using main thread stack
+unsigned char btle_stk[1024];
+unsigned char wifi_stk[8*1024];
+unsigned char atcmd_stk[4*1024];
 Thread btle_thread(BTLE_THREAD_PRIORITY, 1024, &btle_stk[0]);
-Thread wifi_thread(WIFI_THREAD_PRIORITY, 4*1024, &wifi_stk[0]);
+Thread wifi_thread(WIFI_THREAD_PRIORITY, 8*1024, &wifi_stk[0]);
 Thread atcmd_thread(ATCMD_THREAD_PRIORITY, 4*1024, &atcmd_stk[0]);
-
+#else
+// using global heap
+Thread btle_thread(BTLE_THREAD_PRIORITY, 2*1024);
+Thread wifi_thread(WIFI_THREAD_PRIORITY, 8*1024);
+Thread atcmd_thread(ATCMD_THREAD_PRIORITY, 8*1024);
+#endif
 
 /* create a semaphore to synchronize the threads */
 Semaphore sync_sema;
@@ -391,11 +399,15 @@
 #define SKIP_WIFI_SCAN_DEMO
 #define BLE_STOP_START_ADV_SCAN_DEMO
 #define SKIP_WIFI_CONNECT_DEMO
+#define PAUSE_SECONDS   2
 int main() {
+    //print_all_thread_info();
+    //print_heap_and_isr_stack_info();
     reset_counter++;
     print_memory_info();
     printf("\r\n ++++++ PROGRAM STARTING -- reset count = %d ++++++ \r\n", reset_counter);
     device = new RawSerial(USBTX, USBRX, DEFAULT_BAUD_RATE);
+    //device = new RawSerial(PA_9, PA_10, DEFAULT_BAUD_RATE);
     
     printf("*** HELLO MESSAGE *** \n %s", (char *)&hello_msg[6]);
     setupDefaultWiFiConfig();
@@ -417,8 +429,8 @@
     peripheral->run();
     btle_thread.start(callback(&queue, &EventQueue::dispatch_forever));
     print_memory_info();
-    printWaitAbortKeyPress(120);
-    peripheral->stopAdvertising();
+    printWaitAbortKeyPress(PAUSE_SECONDS);
+    //peripheral->stopAdvertising();
 
 #ifndef DISABLE_WIFI // comment out wifi part
     int start = Kernel::get_ms_count();
@@ -450,8 +462,8 @@
     printWait(2); // lets wait for a minute before turning BLE back on
     device->printf("\n ++++++ restarting BLE ++++++ \n\n");
 #endif  /// endif DISABLE_WIFI
-    printWaitAbortKeyPress(60);
-    peripheral->startAdvertising();
+    printWaitAbortKeyPress(PAUSE_SECONDS);
+    //peripheral->startAdvertising();
 #ifdef ENABLE_UART_BACKGRND_DEMO
     for(int i=0;i<255;i++)
     {
@@ -473,7 +485,7 @@
 #endif 
 
     device->printf("\r\n++++++ Press key for Wifi demo test ++++++ \r\n");
-    printWaitAbortKeyPress(120);
+    printWaitAbortKeyPress(PAUSE_SECONDS);
 #ifndef SKIP_WIFI_SCAN_DEMO
     device->printf("\r\n++++++ Test WiFi Manager Network Scan ++++++ \r\n");
     int count;