diff --git a/esp3d/src/core/espcmd/ESP201.cpp b/esp3d/src/core/espcmd/ESP201.cpp index dac20a24..9451db6c 100644 --- a/esp3d/src/core/espcmd/ESP201.cpp +++ b/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; diff --git a/esp3d/src/core/espcmd/ESP401.cpp b/esp3d/src/core/espcmd/ESP401.cpp index 34b02705..a075752f 100644 --- a/esp3d/src/core/espcmd/ESP401.cpp +++ b/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; } diff --git a/esp3d/src/core/espcmd/ESP800.cpp b/esp3d/src/core/espcmd/ESP800.cpp index 79ff56e0..c7cb9192 100644 --- a/esp3d/src/core/espcmd/ESP800.cpp +++ b/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 { diff --git a/esp3d/src/include/version.h b/esp3d/src/include/version.h index dade5bf2..d3fc7b18 100644 --- a/esp3d/src/include/version.h +++ b/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 diff --git a/esp3d/src/modules/http/handles/handle-mks-files.cpp b/esp3d/src/modules/http/handles/handle-mks-files.cpp new file mode 100644 index 00000000..19d646d8 --- /dev/null +++ b/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 +#endif //ARDUINO_ARCH_ESP32 +#if defined (ARDUINO_ARCH_ESP8266) +#include +#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) diff --git a/esp3d/src/modules/http/handles/upload-mks-files.cpp b/esp3d/src/modules/http/handles/upload-mks-files.cpp new file mode 100644 index 00000000..86df728e --- /dev/null +++ b/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 +#endif //ARDUINO_ARCH_ESP32 +#if defined (ARDUINO_ARCH_ESP8266) +#include +#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 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) diff --git a/esp3d/src/modules/http/http_server.cpp b/esp3d/src/modules/http/http_server.cpp index 98d40d24..35b6a760 100644 --- a/esp3d/src/modules/http/http_server.cpp +++ b/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 - const char * headerkeys[] = {"Cookie"} ; - size_t headerkeyssize = sizeof (headerkeys) / sizeof (char*); + //Autorization is already added //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); diff --git a/esp3d/src/modules/http/http_server.h b/esp3d/src/modules/http/http_server.h index 525d3bae..15444d1b 100644 --- a/esp3d/src/modules/http/http_server.h +++ b/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 diff --git a/esp3d/src/modules/mks/mks_service.cpp b/esp3d/src/modules/mks/mks_service.cpp index 2e979424..8a345194 100644 --- a/esp3d/src/modules/mks/mks_service.cpp +++ b/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" - -#define MKS_FRAME_DATA_MAX_SIZE (MKS_FRAME_SIZE - 5 - 4) +#include "../serial/serial_service.h" //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 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() { diff --git a/esp3d/src/modules/mks/mks_service.h b/esp3d/src/modules/mks/mks_service.h index d65e5c5f..ac9570b1 100644 --- a/esp3d/src/modules/mks/mks_service.h +++ b/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; }; diff --git a/esp3d/src/modules/network/netconfig.cpp b/esp3d/src/modules/network/netconfig.cpp index 33a608dd..0e3cf091 100644 --- a/esp3d/src/modules/network/netconfig.cpp +++ b/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) { diff --git a/esp3d/src/modules/network/netservices.cpp b/esp3d/src/modules/network/netservices.cpp index d9bc9a15..ce61ea43 100644 --- a/esp3d/src/modules/network/netservices.cpp +++ b/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(); } diff --git a/esp3d/src/modules/serial/serial_service.cpp b/esp3d/src/modules/serial/serial_service.cpp index 630c1312..9775b9fa 100644 --- a/esp3d/src/modules/serial/serial_service.cpp +++ b/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 diff --git a/esp3d/src/modules/wifi/wificonfig.cpp b/esp3d/src/modules/wifi/wificonfig.cpp index 7aa75e2d..c3dc9432 100644 --- a/esp3d/src/modules/wifi/wificonfig.cpp +++ b/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(); } }