GitHub-Proxy/ESP3D
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/luc-github/ESP3D.git synced 2025-08-16 12:26:00 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add MKS Fast Upload support

Browse Source
This commit is contained in:
Luc 2021-01-07 16:24:36 +01:00
parent 4a1f1c72e8
commit 4c4ff06518
14 changed files with 397 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
esp3d/src/core/espcmd/ESP201.cpp
View File

@ -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;

4
esp3d/src/core/espcmd/ESP401.cpp
View File

@ -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;
}

17
esp3d/src/core/espcmd/ESP800.cpp
View File

@ -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 {

2
esp3d/src/include/version.h
View File

@ -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

50
esp3d/src/modules/http/handles/handle-mks-files.cpp Normal file
View File

@ -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)

114
esp3d/src/modules/http/handles/upload-mks-files.cpp Normal file
View File

@ -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)

16
esp3d/src/modules/http/http_server.cpp
View File

@ -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);

4
esp3d/src/modules/http/http_server.h
View File

@ -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

186
esp3d/src/modules/mks/mks_service.cpp
View File

@ -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<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?");
digitalWrite(ESP_FLAG_PIN, HIGH);
log_esp3d("Is board ready for frame?");
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()
{

13
esp3d/src/modules/mks/mks_service.h
View File

@ -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;
};

3
esp3d/src/modules/network/netconfig.cpp
View File

@ -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) {

6
esp3d/src/modules/network/netservices.cpp
View File

@ -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();
}

2
esp3d/src/modules/serial/serial_service.cpp
View File

@ -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

11
esp3d/src/modules/wifi/wificonfig.cpp
View File

@ -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();
}
}