Add MKS Fast Upload support

esp3d/src/core/espcmd/ESP201.cpp

@@ -107,7 +107,9 @@ bool Commands::ESP201(const char* cmd_params, level_authenticate_type auth_type,
                     if (!Hal::analogWrite(pin, value)) {
                         output->printERROR ("Invalid value!");
                         response = false;
-                    } else output->printMSG ("ok");
+                    } else {
+                        output->printMSG ("ok");
+                    }
                 } else {
                     output->printERROR ("Invalid parameter!");
                     response = false;

esp3d/src/core/espcmd/ESP401.cpp

@@ -22,6 +22,7 @@
 #include "../esp3doutput.h"
 #include "../settings_esp3d.h"
 #include "../../modules/authentication/authentication_service.h"
+#include "../../modules/serial/serial_service.h"
 #ifdef SENSOR_DEVICE
 #include "../../modules/sensor/sensor.h"
 #endif //SENSOR_DEVICE
@@ -135,6 +136,9 @@ bool Commands::ESP401(const char* cmd_params, level_authenticate_type auth_type,
                     esp3d_sensor.setInterval(sval.toInt());
                     break;
 #endif //SENSOR_DEVICE
+                case ESP_BAUD_RATE:
+                    serial_service.updateBaudRate(sval.toInt());
+                    break;
                 default:
                     break;
                 }

esp3d/src/core/espcmd/ESP800.cpp

@@ -137,6 +137,23 @@ bool Commands::ESP800(const char* cmd_params, level_authenticate_type auth_type,
     } else {
         output->print("none");
     }
+    if(plain) {
+        output->printLN("");
+    } else {
+        output->print("\"");
+    }
+    //Serial protocol
+    if (plain) {
+        output->print("Serial protocol:");
+    } else {
+        output->print(",\"serialprotocol\":\"");
+    }
+#if COMMUNICATION_PROTOCOL ==  MKS_SERIAL
+    output->print("MKS");
+#endif //COMMUNICATION_PROTOCOL ==  MKS_SERIAL 
+#if COMMUNICATION_PROTOCOL ==  RAW_SERIAL
+    output->print("RAW");
+#endif //COMMUNICATION_PROTOCOL ==  RAW_SERIAL 
     if(plain) {
         output->printLN("");
     } else {

esp3d/src/include/version.h

@@ -22,7 +22,7 @@
 #define _VERSION_ESP3D_H
 
 //version and sources location
-#define FW_VERSION "3.0.0.a79"
+#define FW_VERSION "3.0.0.a80"
 #define REPOSITORY "https://github.com/luc-github/ESP3D/tree/3.0"
 
 #endif //_VERSION_ESP3D_H

esp3d/src/modules/http/handles/handle-mks-files.cpp

@@ -0,0 +1,50 @@
+/*
+ handle-mks-files.cpp - ESP3D http handle
+
+ Copyright (c) 2014 Luc Lebosse. All rights reserved.
+
+ This code is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This code is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with This code; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "../../../include/esp3d_config.h"
+#if defined (HTTP_FEATURE) && (COMMUNICATION_PROTOCOL == MKS_SERIAL)
+#include "../http_server.h"
+#if defined (ARDUINO_ARCH_ESP32)
+#include <WebServer.h>
+#endif //ARDUINO_ARCH_ESP32
+#if defined (ARDUINO_ARCH_ESP8266)
+#include <ESP8266WebServer.h>
+#endif //ARDUINO_ARCH_ESP8266
+#include "../../mks/mks_service.h"
+#include "../../authentication/authentication_service.h"
+
+void HTTP_Server::handleMKSUpload ()
+{
+    level_authenticate_type auth_level = AuthenticationService::authenticated_level();
+    if (auth_level == LEVEL_GUEST) {
+        _upload_status = UPLOAD_STATUS_NONE;
+        _webserver->send (401, "text/plain", "Wrong authentication!");
+        return;
+    }
+    if ( (_upload_status == UPLOAD_STATUS_FAILED) || (_upload_status == UPLOAD_STATUS_CANCELLED) ) {
+        _webserver->send (500, "text/plain", "Upload failed!");
+        _upload_status = UPLOAD_STATUS_NONE;
+        return;
+    }
+    //no error
+    _webserver->send (200, "text/plain", "{\"status\":\"ok\"}");
+    _upload_status = UPLOAD_STATUS_NONE;
+}
+
+#endif //HTTP_FEATURE && (COMMUNICATION_PROTOCOL == MKS_SERIAL)

esp3d/src/modules/http/handles/upload-mks-files.cpp

@@ -0,0 +1,114 @@
+/*
+ upload-mks-files.cpp - ESP3D http handle
+
+ Copyright (c) 2014 Luc Lebosse. All rights reserved.
+
+ This code is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This code is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with This code; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "../../../include/esp3d_config.h"
+#if defined (HTTP_FEATURE) && (COMMUNICATION_PROTOCOL == MKS_SERIAL)
+#include "../http_server.h"
+#if defined (ARDUINO_ARCH_ESP32)
+#include <WebServer.h>
+#endif //ARDUINO_ARCH_ESP32
+#if defined (ARDUINO_ARCH_ESP8266)
+#include <ESP8266WebServer.h>
+#endif //ARDUINO_ARCH_ESP8266
+#include "../../mks/mks_service.h"
+#include "../../authentication/authentication_service.h"
+//MKS files uploader handle
+void HTTP_Server::MKSFileupload ()
+{
+    static uint32_t fragmentID = 0;
+    static uint8_t buf2send[MKS_FRAME_DATA_MAX_SIZE];
+    static size_t buf2sendlen = 0;
+    //get authentication status
+    level_authenticate_type auth_level= AuthenticationService::authenticated_level();
+    //Guest cannot upload - only admin
+    if (auth_level == LEVEL_GUEST) {
+        pushError(ESP_ERROR_AUTHENTICATION, "Upload rejected", 401);
+        _upload_status=UPLOAD_STATUS_FAILED;
+    } else {
+        HTTPUpload& upload = _webserver->upload();
+        if (upload.status == UPLOAD_FILE_START) {
+            buf2sendlen = 0;
+            log_esp3d("Starting upload");
+            _upload_status= UPLOAD_STATUS_ONGOING;
+            size_t fileSize = 0 ;
+            String filename = upload.filename;
+            String sfilename = "s"+filename;
+            if (_webserver->hasArg(sfilename)) {
+                fileSize = _webserver->arg(sfilename).toInt();
+            } else if (_webserver->hasHeader("Content-Length")) {
+                fileSize = _webserver->header("Content-Length").toInt();
+            }
+            fragmentID = 0;
+            if (MKSService::sendFirstFragment(filename.c_str(), fileSize)) {
+                MKSService::uploadMode();
+            }
+        }  else if(upload.status == UPLOAD_FILE_WRITE) {
+            if (_upload_status == UPLOAD_STATUS_ONGOING) {
+                uint currentsize = upload.currentSize;
+                uint8_t * currentBuffer = upload.buf;
+                while ((currentsize > 0) &&(_upload_status == UPLOAD_STATUS_ONGOING)) {
+                    while ((buf2sendlen<MKS_FRAME_DATA_MAX_SIZE) && currentsize > 0) {
+                        buf2send[buf2sendlen]=currentBuffer[0];
+                        buf2sendlen++;
+                        currentsize--;
+                        currentBuffer++;
+                    }
+                    if (buf2sendlen == MKS_FRAME_DATA_MAX_SIZE) {
+                        log_esp3d("Send %d chars in Fragment %d", buf2sendlen, fragmentID);
+                        if (MKSService::sendFragment(buf2send,buf2sendlen,fragmentID)) {
+                            buf2sendlen=0;
+                            fragmentID++;
+                        } else {
+                            _upload_status=UPLOAD_STATUS_FAILED;
+                            pushError(ESP_ERROR_FILE_WRITE, "File write failed");
+                        }
+
+                    }
+                    Hal::wait(0);
+                }
+            }
+
+        } else if(upload.status == UPLOAD_FILE_END) {
+            if (_upload_status == UPLOAD_STATUS_ONGOING) {
+                log_esp3d("Upload end");
+                fragmentID=MKSService::getFragmentID(fragmentID,true);
+                log_esp3d("Send %d chars in Fragment %d", buf2sendlen, fragmentID);
+                if(MKSService::sendFragment(buf2send,buf2sendlen,fragmentID)) {
+                    _upload_status=UPLOAD_STATUS_SUCCESSFUL;
+                } else {
+                    _upload_status=UPLOAD_STATUS_FAILED;
+                    pushError(ESP_ERROR_FILE_CLOSE, "File close failed");
+                }
+                MKSService::commandMode();
+            }
+        } else {
+            //error
+            _upload_status=UPLOAD_STATUS_FAILED;
+            pushError(ESP_ERROR_FILE_WRITE, "File write failed");
+        }
+
+    }
+    if(_upload_status == UPLOAD_STATUS_FAILED) {
+        cancelUpload();
+        //TBC need to do that
+        //MKSService::sendFragment(nullptr,0,MKSService::getFragmentID(fragmentID, true));
+        MKSService::commandMode();
+    }
+}
+#endif //HTTP_FEATURE && (COMMUNICATION_PROTOCOL == MKS_SERIAL)

esp3d/src/modules/http/http_server.cpp

@@ -58,6 +58,10 @@ void HTTP_Server::init_handlers()
     //FileSystememptyConstChar
     _webserver->on ("/files", HTTP_ANY, handleFSFileList, FSFileupload);
 #endif //FILESYSTEM_FEATURE
+#if COMMUNICATION_PROTOCOL == MKS_SERIAL
+    //MKS_SERIAL
+    _webserver->on ("/upload", HTTP_ANY, handleMKSUpload, MKSFileupload);
+#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL
 #ifdef SD_DEVICE
     //SD
     _webserver->on ("/sdfiles", HTTP_ANY, handleSDFileList, SDFileupload);
@@ -199,14 +203,16 @@ bool HTTP_Server::begin()
     }
 
     init_handlers();
-#ifdef AUTHENTICATION_FEATURE
     //here the list of headers to be recorded
-    //Autrization is already added
+    //Autorization is already added
-    const char * headerkeys[] = {"Cookie"} ;
-    size_t headerkeyssize = sizeof (headerkeys) / sizeof (char*);
     //ask server to track these headers
-    _webserver->collectHeaders (headerkeys, headerkeyssize );
+#ifdef AUTHENTICATION_FEATURE
+    const char * headerkeys[] = {"Cookie","Content-Length"} ;
+#else
+    const char * headerkeys[] = {"Content-Length"} ;
 #endif
+    size_t headerkeyssize = sizeof (headerkeys) / sizeof (char*);
+    _webserver->collectHeaders (headerkeys, headerkeyssize );
     _webserver->begin();
 #ifdef AUTHENTICATION_FEATURE
     AuthenticationService::begin(_webserver);

esp3d/src/modules/http/http_server.h

@@ -93,6 +93,10 @@ private:
     static void handleSDFileList ();
     static bool StreamSDFile(const char* filename, const char * contentType);
 #endif //SD_DEVICE
+#if COMMUNICATION_PROTOCOL == MKS_SERIAL
+    static void MKSFileupload ();
+    static void handleMKSUpload ();
+#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL
 };
 
 #endif //_HTTP_SERVER_H

esp3d/src/modules/mks/mks_service.cpp

@@ -28,8 +28,7 @@
 #include "../telnet/telnet_server.h"
 #include "../http/http_server.h"
 #include "../network/netconfig.h"
-
+#include "../serial/serial_service.h"
-#define MKS_FRAME_DATA_MAX_SIZE  (MKS_FRAME_SIZE - 5 - 4)
 
 //Flag Pins
 #define ESP_FLAG_PIN        0
@@ -91,18 +90,21 @@
 #define ERROR_STATE     0x1
 #define SUCCESS_STATE   0x2
 
-
-
 #define NB_HOTSPOT_MAX  15
 
 //Timeouts
 #define FRAME_WAIT_TO_SEND_TIMEOUT  2000
+#define ACK_TIMEOUT  5000
 #define NET_FRAME_REFRESH_TIME  10000
 
+#define UPLOAD_BAUD_RATE    1958400
+
 bool MKSService::_started = false;
-char MKSService::_frame[MKS_FRAME_SIZE] = {0};
+uint8_t MKSService::_frame[MKS_FRAME_SIZE] = {0};
 char MKSService::_moduleId[22] = {0};
 uint8_t MKSService::_uploadStatus = UNKNOW_STATE;
+long MKSService::_commandBaudRate = 115200;
+bool MKSService::_uploadMode = false;
 
 bool MKSService::isHead(const char c)
 {
@@ -131,9 +133,125 @@ bool MKSService::begin()
     _started = true;
     //max size is 21
     strncpy(_moduleId,NetConfig::hostname(), 21);
+    commandMode(true);
     return true;
 }
 
+void MKSService::commandMode(bool fromSettings)
+{
+    if (fromSettings) {
+        _commandBaudRate= Settings_ESP3D::read_uint32(ESP_BAUD_RATE);
+    }
+    log_esp3d("Cmd Mode");
+    _uploadMode = false;
+    serial_service.updateBaudRate(_commandBaudRate);
+
+}
+void MKSService::uploadMode()
+{
+    log_esp3d("Upload Mode");
+    _uploadMode = true;
+    serial_service.updateBaudRate(UPLOAD_BAUD_RATE);
+}
+
+uint MKSService::getFragmentID(uint32_t fragmentNumber, bool isLast)
+{
+    log_esp3d("Fragment: %d %s",fragmentNumber, isLast?" is last":"" );
+    if (isLast) {
+        fragmentNumber |= (1 << 31);
+    } else {
+        fragmentNumber &= ~(1 << 31);
+    }
+    log_esp3d("Fragment is now: %d",fragmentNumber);
+    return fragmentNumber;
+}
+
+bool MKSService::sendFirstFragment(const char* filename, size_t filesize)
+{
+    uint fileNameLen = strlen(filename);
+    uint dataLen = fileNameLen + 5;
+    clearFrame();
+    //Head Flag
+    _frame[MKS_FRAME_HEAD_OFFSET] = MKS_FRAME_HEAD_FLAG;
+    //Type Flag
+    _frame[MKS_FRAME_TYPE_OFFSET] = MKS_FRAME_DATA_FIRST_FRAGMENT_TYPE;
+    //Fragment size
+    _frame[MKS_FRAME_DATALEN_OFFSET] = dataLen & 0xff;
+    _frame[MKS_FRAME_DATALEN_OFFSET + 1] = dataLen >> 8;
+    //FileName size
+    _frame[MKS_FRAME_DATA_OFFSET] = strlen(filename);
+    //File Size
+    _frame[MKS_FRAME_DATA_OFFSET+1] = filesize & 0xff;
+    _frame[MKS_FRAME_DATA_OFFSET+2] = (filesize >> 8) & 0xff;
+    _frame[MKS_FRAME_DATA_OFFSET+3] = (filesize >> 16) & 0xff;
+    _frame[MKS_FRAME_DATA_OFFSET+4] = (filesize >> 24) & 0xff;
+    //Filename
+    strncpy((char *)&_frame[MKS_FRAME_DATA_OFFSET+ 5], filename, fileNameLen);
+    //Tail Flag
+    _frame[dataLen + 4] = MKS_FRAME_TAIL_FLAG;
+    log_esp3d("Filename: %s  Filesize: %d",filename, filesize );
+    for (uint i =0; i< dataLen + 5 ; i++) {
+        log_esp3d("%c %x",_frame[i],_frame[i]);
+    }
+    _uploadStatus = UNKNOW_STATE;
+    if (canSendFrame()) {
+        ESP3DOutput output(ESP_SERIAL_CLIENT);
+        _uploadStatus = UNKNOW_STATE;
+        if (output.write(_frame,dataLen + 5) == (dataLen + 5)) {
+            log_esp3d("First fragment Ok");
+            sendFrameDone();
+            return true;
+        }
+    }
+    log_esp3d("Failed");
+    sendFrameDone();
+    return false;
+}
+
+
+bool MKSService::sendFragment(const uint8_t * dataFrame, const size_t dataSize,uint fragmentID)
+{
+    uint dataLen = dataSize + 4;
+    log_esp3d("Fragment datalen:%d",dataSize);
+    //Head Flag
+    _frame[MKS_FRAME_HEAD_OFFSET] = MKS_FRAME_HEAD_FLAG;
+    //Type Flag
+    _frame[MKS_FRAME_TYPE_OFFSET] = MKS_FRAME_DATA_FRAGMENT_TYPE;
+    //Fragment size
+    _frame[MKS_FRAME_DATALEN_OFFSET] = dataLen & 0xff;
+    _frame[MKS_FRAME_DATALEN_OFFSET + 1] = dataLen >> 8;
+    //Fragment ID
+    _frame[MKS_FRAME_DATA_OFFSET ] = fragmentID & 0xff;
+    _frame[MKS_FRAME_DATA_OFFSET + 1] = (fragmentID >> 8) & 0xff;
+    _frame[MKS_FRAME_DATA_OFFSET + 2] = (fragmentID >> 16) & 0xff;
+    _frame[MKS_FRAME_DATA_OFFSET + 3] = (fragmentID >> 24) & 0xff;
+    //data
+    if ((dataSize>0) && (dataFrame!=nullptr)) {
+        memcpy(&_frame[MKS_FRAME_DATA_OFFSET+ 4], dataFrame, dataSize);
+    }
+    if (dataSize<MKS_FRAME_DATA_MAX_SIZE) {
+        clearFrame(dataLen + 4);
+    }
+    //Tail Flag
+    _frame[dataLen + 4] = MKS_FRAME_TAIL_FLAG;
+    /* for (uint i =0; i< dataLen + 5 ; i++) {
+             log_esp3d("%c %x",_frame[i],_frame[i]);
+         }*/
+    if (canSendFrame()) {
+        ESP3DOutput output(ESP_SERIAL_CLIENT);
+        _uploadStatus = UNKNOW_STATE;
+        if (output.write(_frame,MKS_FRAME_SIZE) == MKS_FRAME_SIZE) {
+            log_esp3d("Ok");
+            sendFrameDone();
+            return true;
+        }
+        log_esp3d("Error with size sent");
+    }
+    log_esp3d("Failed");
+    sendFrameDone();
+    return false;
+}
+
 void MKSService::sendWifiHotspots()
 {
 
@@ -188,7 +306,7 @@ void MKSService::sendWifiHotspots()
         }
         if (canSendFrame()) {
             ESP3DOutput output(ESP_SERIAL_CLIENT);
-            if (output.write((const uint8_t *)_frame,dataOffset+5) == (dataOffset+5)) {
+            if (output.write(_frame,dataOffset+5) == (dataOffset+5)) {
                 log_esp3d("Ok");
                 sendFrameDone();
             } else {
@@ -202,6 +320,7 @@ void MKSService::sendWifiHotspots()
     }
     //Restore mode
     WiFi.mode((WiFiMode_t)currentmode);
+    sendFrameDone();
 }
 
 void MKSService::handleFrame(const uint8_t type, const uint8_t * dataFrame, const size_t dataSize )
@@ -304,6 +423,24 @@ void MKSService::messageException(const uint8_t * dataFrame, const size_t dataSi
     }
 }
 
+bool MKSService::waitForAck()
+{
+    uint32_t timestart = millis();
+    bool res=true;
+    while ((_uploadStatus==UNKNOW_STATE)&&((millis()-timestart)<ACK_TIMEOUT)) {
+        serial_service.handle();
+        Hal::wait(10);
+    }
+    if (_uploadStatus!=SUCCESS_STATE) {
+        res=false;
+    }
+    if(_uploadStatus==UNKNOW_STATE) {
+        log_esp3d("Ack timeout");
+    }
+    _uploadStatus=UNKNOW_STATE;
+    return res;
+}
+
 void MKSService::messageWiFiConfig(const uint8_t * dataFrame, const size_t dataSize )
 {
     String ssid;
@@ -383,14 +520,15 @@ void MKSService::messageWiFiConfig(const uint8_t * dataFrame, const size_t dataS
 
 bool MKSService::canSendFrame()
 {
-    //log_esp3d("Is board ready for frame?");
+    log_esp3d("Is board ready for frame?");
-    digitalWrite(ESP_FLAG_PIN, HIGH);
+    digitalWrite(ESP_FLAG_PIN, BOARD_READY_FLAG_VALUE);
     uint32_t startTime = millis();
     while( (millis() - startTime) <  FRAME_WAIT_TO_SEND_TIMEOUT) {
         if (digitalRead(BOARD_FLAG_PIN) == BOARD_READY_FLAG_VALUE) {
-            // log_esp3d("Yes");
+            log_esp3d("Yes");
             return true;
         }
+        Hal::wait(0);
     }
     log_esp3d("Time out no board answer");
     return false;
@@ -398,12 +536,15 @@ bool MKSService::canSendFrame()
 
 void MKSService::sendFrameDone()
 {
-    digitalWrite(ESP_FLAG_PIN, LOW);
+    digitalWrite(ESP_FLAG_PIN, !BOARD_READY_FLAG_VALUE);
 
 }
 
 bool MKSService::sendGcodeFrame(const char* cmd)
 {
+    if (_uploadMode) {
+        return false;
+    }
     String tmp = cmd;
     if (tmp.endsWith("\n")) {
         tmp[tmp.length()-1]='\0';
@@ -428,7 +569,7 @@ bool MKSService::sendGcodeFrame(const char* cmd)
 
     if (canSendFrame()) {
         ESP3DOutput output(ESP_SERIAL_CLIENT);
-        if (output.write((const uint8_t *)_frame,strlen(tmp.c_str())+7) == (strlen(tmp.c_str())+7)) {
+        if (output.write(_frame,strlen(tmp.c_str())+7) == (strlen(tmp.c_str())+7)) {
             log_esp3d("Ok");
             sendFrameDone();
             return true;
@@ -445,6 +586,9 @@ bool MKSService::sendNetworkFrame()
     size_t dataOffset = 0;
     String s;
     static uint32_t lastsend  = 0;
+    if (_uploadMode) {
+        return false;
+    }
     if ((millis() - lastsend)> NET_FRAME_REFRESH_TIME) {
         lastsend = millis();
         log_esp3d("Network frame preparation");
@@ -487,7 +631,7 @@ bool MKSService::sendNetworkFrame()
             dataOffset = MKS_FRAME_DATA_OFFSET + 9;
             //////////////////////////////////
             //Wifi_name Segment
-            strcpy(&_frame[dataOffset], s.c_str());
+            strcpy((char *)&_frame[dataOffset], s.c_str());
             dataOffset+=s.length();
             //////////////////////////////////
             //Wifi_key_len Segment
@@ -496,7 +640,7 @@ bool MKSService::sendNetworkFrame()
             dataOffset++;
             //////////////////////////////////
             //Wifi_key Segment
-            strcpy(&_frame[dataOffset], s.c_str());
+            strcpy((char *)&_frame[dataOffset], s.c_str());
             dataOffset+=s.length();
         } else if (NetConfig::getMode() == ESP_WIFI_AP) {
             log_esp3d("AP Mode");
@@ -522,7 +666,7 @@ bool MKSService::sendNetworkFrame()
             dataOffset = MKS_FRAME_DATA_OFFSET + 9;
             //////////////////////////////////
             //Wifi_name Segment
-            strcpy(&_frame[dataOffset], s.c_str());
+            strcpy((char *)&_frame[dataOffset], s.c_str());
             dataOffset+=s.length();
             //////////////////////////////////
             //Wifi_key_len Segment
@@ -531,7 +675,7 @@ bool MKSService::sendNetworkFrame()
             dataOffset++;
             //////////////////////////////////
             //Wifi_key Segment
-            strcpy(&_frame[dataOffset], s.c_str());
+            strcpy((char *)&_frame[dataOffset], s.c_str());
             dataOffset+=s.length();
         } else {
             //not supported
@@ -559,7 +703,7 @@ bool MKSService::sendNetworkFrame()
         //////////////////////////////////
         //Cloud host Segment
         //Use ESP3D IP instead
-        strcpy(&_frame[dataOffset], s.c_str());
+        strcpy((char *)&_frame[dataOffset], s.c_str());
         dataOffset+=s.length();
         //////////////////////////////////
         //Cloud host port Segment
@@ -575,7 +719,7 @@ bool MKSService::sendNetworkFrame()
         dataOffset++;
         //////////////////////////////////
         //Module id  Segment
-        strcpy(&_frame[dataOffset], _moduleId);
+        strcpy((char *)&_frame[dataOffset], _moduleId);
         dataOffset+=strlen(_moduleId);
         //////////////////////////////////
         //FW version len Segment
@@ -583,7 +727,7 @@ bool MKSService::sendNetworkFrame()
         dataOffset++;
         //////////////////////////////////
         //FW version  Segment
-        strcpy(&_frame[dataOffset], "ESP3D_" FW_VERSION);
+        strcpy((char *)&_frame[dataOffset], "ESP3D_" FW_VERSION);
         dataOffset+=strlen(FW_VERSION)+6;
         //////////////////////////////////
         //Tail Segment
@@ -597,7 +741,7 @@ bool MKSService::sendNetworkFrame()
         log_esp3d("Size of data in frame %d ", dataOffset-4);
         if (canSendFrame()) {
             ESP3DOutput output(ESP_SERIAL_CLIENT);
-            if (output.write((const uint8_t *)_frame,dataOffset+1) == (dataOffset+1)) {
+            if (output.write(_frame,dataOffset+1) == (dataOffset+1)) {
                 log_esp3d("Ok");
                 sendFrameDone();
                 return true;
@@ -610,9 +754,9 @@ bool MKSService::sendNetworkFrame()
     return false;
 }
 
-void MKSService::clearFrame()
+void MKSService::clearFrame(uint start)
 {
-    memset(_frame, 0, sizeof(_frame));
+    memset(&_frame[start], 0, sizeof(_frame)-start);
 }
 void MKSService::handle()
 {

esp3d/src/modules/mks/mks_service.h

@@ -22,6 +22,7 @@
 #define _MKS_SERVICES_H
 
 #define MKS_FRAME_SIZE  1024
+#define MKS_FRAME_DATA_MAX_SIZE  (MKS_FRAME_SIZE - 5 - 4)
 
 class MKSService
 {
@@ -40,18 +41,26 @@ public:
     static bool isTail(const char c);
     static bool isFrame(const char c);
     static bool isCommand(const char c);
+    static bool waitForAck();
+    static bool sendFirstFragment(const char* filename, size_t filesize);
+    static bool sendFragment(const uint8_t * dataFrame, const size_t dataSize,uint fragmentID);
+    static uint getFragmentID(uint32_t fragmentNumber, bool isLast=false);
+    static void commandMode(bool fromSettings=false);
+    static void uploadMode();
 private:
     static uint8_t _uploadStatus;
+    static long _commandBaudRate;
     static void sendWifiHotspots();
     static void messageWiFiControl(const uint8_t * dataFrame, const size_t dataSize);
     static void messageException(const uint8_t * dataFrame, const size_t dataSize);
     static void messageWiFiConfig(const uint8_t * dataFrame, const size_t dataSize);
-    static void clearFrame();
+    static void clearFrame(uint start=0);
     static bool canSendFrame();
     static void sendFrameDone();
     static bool _started;
-    static char _frame[MKS_FRAME_SIZE];
+    static uint8_t _frame[MKS_FRAME_SIZE];
     static char _moduleId[22];
+    static bool _uploadMode;
 };
 
 

esp3d/src/modules/network/netconfig.cpp

@@ -236,6 +236,7 @@ bool NetConfig::begin()
     end();
     int8_t espMode =Settings_ESP3D::read_byte(ESP_RADIO_MODE);
     ESP3DOutput output(ESP_ALL_CLIENTS);
+    log_esp3d("Starting Network");
     if (espMode != NO_NETWORK) {
         if (Settings_ESP3D::isVerboseBoot()) {
             output.printMSG("Starting Network");
@@ -259,6 +260,7 @@ bool NetConfig::begin()
     _hostname = Settings_ESP3D::read_string(ESP_HOSTNAME);
     _mode = espMode;
     if (espMode == NO_NETWORK) {
+        output.printMSG("Disable Network");
         WiFi.mode(WIFI_OFF);
         ESP3DGlobalOutput::display_IP();
         if (Settings_ESP3D::isVerboseBoot()) {
@@ -271,6 +273,7 @@ bool NetConfig::begin()
     }
 #if defined (WIFI_FEATURE)
     if ((espMode == ESP_WIFI_AP) || (espMode == ESP_WIFI_STA)) {
+        output.printMSG("Setup wifi");
         res = WiFiConfig::begin();
         //in case STA failed and fallback to AP mode
         if (WiFi.getMode() == WIFI_AP) {

esp3d/src/modules/network/netservices.cpp

@@ -86,9 +86,6 @@ bool NetServices::begin()
     String hostname = Settings_ESP3D::read_string(ESP_HOSTNAME);
     ESP3DOutput output(ESP_ALL_CLIENTS);
     end();
-#if COMMUNICATION_PROTOCOL == MKS_SERIAL
-    MKSService::begin();
-#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL
 #ifdef TIMESTAMP_FEATURE
     if (WiFi.getMode() != WIFI_AP) {
         if(!timeserver.begin()) {
@@ -303,6 +300,9 @@ bool NetServices::begin()
         output.printMSG("Failed start camera streaming server");
     }
 #endif //CAMERA_DEVICE
+#if COMMUNICATION_PROTOCOL == MKS_SERIAL
+    MKSService::begin();
+#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL
     if (!res) {
         end();
     }

esp3d/src/modules/serial/serial_service.cpp

@@ -51,7 +51,7 @@ SerialService serial_service;
 TaskHandle_t _hserialtask= nullptr;
 #endif //ARDUINO_ARCH_ESP32 
 
-const long SupportedBaudList[] = {9600, 19200, 38400, 57600, 74880, 115200, 230400, 250000, 500000, 921600};
+const long SupportedBaudList[] = {9600, 19200, 38400, 57600, 74880, 115200, 230400, 250000, 500000, 921600, 1958400};
 
 #define TIMEOUT_SERIAL_FLUSH 1500
 //Constructor

esp3d/src/modules/wifi/wificonfig.cpp

@@ -118,6 +118,7 @@ bool WiFiConfig::ConnectSTA2AP()
     uint8_t dot = 0;
     wl_status_t status = WiFi.status();
     ESP3DOutput output(ESP_ALL_CLIENTS);
+    log_esp3d("Connecting");
 #if COMMUNICATION_PROTOCOL != MKS_SERIAL
     if (!Settings_ESP3D::isVerboseBoot()) {
         output.printMSG("Connecting");
@@ -142,6 +143,7 @@ bool WiFiConfig::ConnectSTA2AP()
             }
             msg_out+=".";
             msg= msg_out;
+            log_esp3d("...");
             dot++;
             break;
         }
@@ -163,6 +165,7 @@ bool WiFiConfig::ConnectSTA2AP()
  */
 bool WiFiConfig::StartSTA()
 {
+    log_esp3d("StartSTA");
 #if defined (ARDUINO_ARCH_ESP32)
     esp_wifi_start();
 #endif //ARDUINO_ARCH_ESP32
@@ -248,7 +251,7 @@ bool WiFiConfig::StartAP()
     IPAddress ip(IP);
     IPAddress mask(DEFAULT_AP_MASK_VALUE);
     //Set static IP
-
+    log_esp3d("Use: %s / %s / %s", ip.toString().c_str(),ip.toString().c_str(),mask.toString().c_str());
     if (!WiFi.softAPConfig(ip, ip, mask)) {
         output.printERROR("Set IP to AP failed");
     } else {
@@ -263,6 +266,7 @@ bool WiFiConfig::StartAP()
             stmp +=" is started not protected by passord";
         }
         output.printMSG(stmp.c_str());
+        log_esp3d("%s",stmp.c_str());
         //must be done after starting AP not before
 #if defined (ARDUINO_ARCH_ESP32)
         WiFi.setSleep(false);
@@ -271,6 +275,7 @@ bool WiFiConfig::StartAP()
         return true;
     } else {
         output.printERROR("Starting AP failed");
+        log_esp3d("Starting AP failed");
         return false;
     }
 }
@@ -287,17 +292,21 @@ bool WiFiConfig::begin()
 {
     bool res = false;
     end();
+    log_esp3d("Starting Wifi Config");
     if (Settings_ESP3D::isVerboseBoot()) {
         ESP3DOutput output(ESP_ALL_CLIENTS);
         output.printMSG("Starting WiFi");
     }
     int8_t wifiMode =Settings_ESP3D::read_byte(ESP_RADIO_MODE);
     if (wifiMode == ESP_WIFI_AP) {
+        log_esp3d("Starting AP mode");
         res = StartAP();
     } else if (wifiMode == ESP_WIFI_STA) {
+        log_esp3d("Starting STA");
         res = StartSTA();
         //AP is backup mode
         if(!res) {
+            log_esp3d("Starting AP mode in safe mode");
             res = StartAP();
         }
     }