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

Base for MKS Serial protocol on MKS WIFI

Browse Source
This commit is contained in:
Luc 2020-12-17 20:29:58 +01:00
parent dac3e0b716
commit 21002cf62a
14 changed files with 422 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
esp3d/configuration.h
View File

@ -37,6 +37,11 @@
//SERIAL_COMMAND_FEATURE: allow to send command by serial
#define SERIAL_COMMAND_FEATURE
//COMMUNICATION_PROTOCOL: to communicate with printer or TFT
//RAW_SERIAL standard serial
//MKS_SERIAL Mks protocol
#define COMMUNICATION_PROTOCOL MKS_SERIAL
//AUTHENTICATION_FEATURE: protect pages by login password
//#define AUTHENTICATION_FEATURE
@ -126,7 +131,7 @@
//ESP_SD_NATIVE 1 //esp32 / esp8266
//ESP_SDIO 2 //esp32 only
//ESP_SDFAT 3 //esp8266 (same as native) / esp32
#define SD_DEVICE ESP_SD_NATIVE
//#define SD_DEVICE ESP_SD_NATIVE
//SDIO mode
#define SD_ONE_BIT_MODE true
@ -135,7 +140,7 @@
//ESP_NO_SD
//ESP_DIRECT_SD
//ESP_SHARED_SD
#define SD_DEVICE_CONNECTION ESP_DIRECT_SD
//#define SD_DEVICE_CONNECTION ESP_DIRECT_SD
//pin if reader has insert detection feature
//let -1 or comment if none
@ -185,13 +190,13 @@
#define CAPTIVE_PORTAL_FEATURE
//OTA_FEATURE: this feature is arduino update over the air
//#define OTA_FEATURE
#define OTA_FEATURE
//WEB_UPDATE_FEATURE: allow to flash fw using web UI
#define WEB_UPDATE_FEATURE
//SD_UPDATE_FEATURE: allow to flash/configure fw using SD
#define SD_UPDATE_FEATURE
//#define SD_UPDATE_FEATURE
//NOTIFICATION_FEATURE : allow to push notifications
#define NOTIFICATION_FEATURE
@ -247,7 +252,7 @@
//DEBUG_OUTPUT_SERIAL2 3
//DEBUG_OUTPUT_TELNET 4
//DEBUG_OUTPUT_WEBSOCKET 5
//#define ESP_DEBUG_FEATURE DEBUG_OUTPUT_SERIAL0
#define ESP_DEBUG_FEATURE DEBUG_OUTPUT_TELNET
#ifdef ESP_DEBUG_FEATURE
#define DEBUG_BAUDRATE 115200

BIN
esp3d/esp3d.ino.generic.bin Normal file
View File

Binary file not shown.

3
esp3d/src/core/debug_esp3d.cpp
View File

@ -44,6 +44,7 @@ const char * pathToFileName(const char * path)
void initDebug()
{
#if (ESP_DEBUG_FEATURE == DEBUG_OUTPUT_SERIAL0) || (ESP_DEBUG_FEATURE == DEBUG_OUTPUT_SERIAL1)||(ESP_DEBUG_FEATURE == DEBUG_OUTPUT_SERIAL2)
#ifdef ARDUINO_ARCH_ESP8266
DEBUG_OUTPUT_SERIAL.begin(DEBUG_BAUDRATE, SERIAL_8N1, SERIAL_FULL, (ESP_DEBUG_TX_PIN == -1)?1:ESP_DEBUG_TX_PIN);
#if ESP_DEBUG_RX_PIN != -1
@ -53,6 +54,8 @@ void initDebug()
#if defined(ARDUINO_ARCH_ESP32)
DEBUG_OUTPUT_SERIAL.begin (DEBUG_BAUDRATE, SERIAL_8N1, ESP_DEBUG_RX_PIN, ESP_DEBUG_TX_PIN);
#endif //ARDUINO_ARCH_ESP32
#endif // (ESP_DEBUG_FEATURE == DEBUG_OUTPUT_SERIAL0) || (ESP_DEBUG_FEATURE == DEBUG_OUTPUT_SERIAL1)||(ESP_DEBUG_FEATURE == DEBUG_OUTPUT_SERIAL2)
}
//Telnet

4
esp3d/src/core/debug_esp3d.h
View File

@ -65,8 +65,8 @@ extern Telnet_Server telnet_debug;
#define DEBUG_ESP3D_NETWORK_INIT telnet_debug.begin(DEBUG_ESP3D_OUTPUT_PORT, true);
#define DEBUG_ESP3D_NETWORK_HANDLE telnet_debug.handle();
#define DEBUG_ESP3D_NETWORK_END telnet_debug.end();
#define log_esp3d(format, ...) telnet_debug.printf("[ESP3D][%s:%u] %s(): " format "\r\n", pathToFileName(__FILE__), __LINE__, __FUNCTION__, ##__VA_ARGS__)
#define log_esp3dS(format, ...) telnet_debug.printf(format "\r\n", ##__VA_ARGS__)
#define log_esp3d(format, ...) if(telnet_debug.isConnected())telnet_debug.printf("[ESP3D][%s:%u] %s(): " format "\r\n", pathToFileName(__FILE__), __LINE__, __FUNCTION__, ##__VA_ARGS__)
#define log_esp3dS(format, ...) if(telnet_debug.isConnected())telnet_debug.printf(format "\r\n", ##__VA_ARGS__)
#endif // DEBUG_OUTPUT_TELNET
//Telnet

9
esp3d/src/core/esp3doutput.cpp
View File

@ -489,6 +489,15 @@ void ESP3DGlobalOutput::display_progress(uint8_t v)
#endif //DISPLAY_DEVICE
}
void ESP3DGlobalOutput::display_Disconnected()
{
#ifdef DISPLAY_DEVICE
esp3d_display.SetStatus("Disconnected");
#else
#endif //DISPLAY_DEVICE
}
void ESP3DGlobalOutput::display_IP(bool force)
{
#ifdef DISPLAY_DEVICE

1
esp3d/src/core/esp3doutput.h
View File

@ -111,6 +111,7 @@ public:
static void SetStatus(const char * status);
static void display_progress(uint8_t v);
static void display_IP(bool force = false);
static void display_Disconnected();
};
#endif //_ESP3DOUTPUT_H

4
esp3d/src/core/settings_esp3d.cpp
View File

@ -185,9 +185,13 @@ bool Settings_ESP3D::begin()
bool Settings_ESP3D::isVerboseBoot(bool fromsettings)
{
#if COMMUNICATION_PROTOCOL != MKS_SERIAL
if(fromsettings) {
_isverboseboot = read_byte (ESP_VERBOSE_BOOT);
}
#else
_isverboseboot = false;
#endif //#if COMMUNICATION_PROTOCOL == MKS_SERIAL
return _isverboseboot;
}

4
esp3d/src/include/defines.h
View File

@ -38,6 +38,10 @@
#define USE_SERIAL_1 2
#define USE_SERIAL_2 3
//Communication protocols
#define RAW_SERIAL 0
#define MKS_SERIAL 1
//Display
#define OLED_I2C_SSD1306 1
#define OLED_I2C_SSDSH1106 2

298
esp3d/src/modules/mks/mks_service.cpp Normal file
View File

@ -0,0 +1,298 @@
/*
mks_service.cpp - mks communication service functions class
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 COMMUNICATION_PROTOCOL == MKS_SERIAL
#include "mks_service.h"
#include "../../core/settings_esp3d.h"
#include "../../core/esp3doutput.h"
#include "../network/netconfig.h"
#include "../wifi/wificonfig.h"
#define MKS_FRAME_DATA_MAX_SIZE (MKS_FRAME_SIZE - 5 - 4)
//Flag Pins
#define ESP_FLAG_PIN 0
#define BOARD_FLAG_PIN 4
//Flag pins values
#define BOARD_READY_FLAG_VALUE LOW
//Frame offsets
#define MKS_FRAME_HEAD_OFFSET 0
#define MKS_FRAME_TYPE_OFFSET 1
#define MKS_FRAME_DATALEN_OFFSET 2
#define MKS_FRAME_DATA_OFFSET 4
//Frame flags
#define MKS_FRAME_HEAD_FLAG (char)0xa5
#define MKS_FRAME_TAIL_FLAG (char)0xfc
//Network states
#define MKS_FRAME_NETWORK_OK_STATE (char)0x0a
#define MKS_FRAME_NETWORK_FAIL_STATE (char)0x05
#define MKS_FRAME_NETWORK_ERROR_STATE (char)0x0e
//Network modes
#define MKS_FRAME_NETWORK_AP_MODE (char)0x01
#define MKS_FRAME_NETWORK_STA_MODE (char)0x02
#define MKS_FRAME_NETWORK_APSTA_MODE (char)0x03
//Cloud states
#define MKS_FRAME_CLOUD_BINDED_STATE (char)0x12
#define MKS_FRAME_CLOUD_NOT_BINDED_STATE (char)0x13
#define MKS_FRAME_CLOUD_DISCONNECTED_STATE (char)0x10
#define MKS_FRAME_CLOUD_DISABLED_STATE (char)0x00
//Data types
#define MKS_FRAME_DATA_NETWORK_TYPE (char)0x0
#define MKS_FRAME_DATA_COMMAND_TYPE (char)0x1
#define MKS_FRAME_DATA_FIRST_FRAGMENT_TYPE (char)0x2
#define MKS_FRAME_DATA_FRAGMENT_TYPE (char)0x3
#define MKS_FRAME_DATA_HOTSPOTS_LIST_TYPE (char)0x4
#define MKS_FRAME_DATA_STATIC_IP_TYPE (char)0x5
#define CLOUD_HOST_ADDRESS "baizhongyun.cn"
#define CLOUD_HOST_PORT 12345
#define CLOUD_SERVICE_PORT 8080
//Timeouts
#define FRAME_WAIT_TO_SEND_TIMEOUT 2000
#define NET_FRAME_REFRESH_TIME 10000
bool MKSService::_started = false;
char MKSService::_frame[MKS_FRAME_SIZE] = {0};
char MKSService:: _moduleId[21] = {0};
bool MKSService::begin()
{
//setup the pins
pinMode(BOARD_FLAG_PIN, INPUT);
pinMode(ESP_FLAG_PIN, OUTPUT);
_started = true;
strcpy(_moduleId,"12345");
return true;
}
bool MKSService::canSendFrame()
{
log_esp3d("Is board ready for frame?");
digitalWrite(ESP_FLAG_PIN, HIGH);
uint32_t startTime = millis();
while( (millis() - startTime) < FRAME_WAIT_TO_SEND_TIMEOUT) {
if (digitalRead(BOARD_FLAG_PIN) == BOARD_READY_FLAG_VALUE) {
log_esp3d("Yes");
return true;
}
}
log_esp3d("Time out no board answer");
return false;
}
bool MKSService::sendNetworkFrame()
{
size_t dataOffset = 0;;
String s;
static uint32_t lastsend = 0;
if ((millis() - lastsend)> NET_FRAME_REFRESH_TIME) {
lastsend = millis();
log_esp3d("Network frame preparation");
//Prepare
clearFrame();
_frame[MKS_FRAME_HEAD_OFFSET] = MKS_FRAME_HEAD_FLAG;
_frame[MKS_FRAME_TYPE_OFFSET] = MKS_FRAME_DATA_NETWORK_TYPE;
if (NetConfig::getMode() == ESP_WIFI_STA) {
log_esp3d("STA Mode");
if(WiFi.status() == WL_CONNECTED) {
///////////////////////////////////
//IP Segment
//IP value
IPAddress ip = NetConfig::localIPAddress();
_frame[MKS_FRAME_DATA_OFFSET] = ip[0];
_frame[MKS_FRAME_DATA_OFFSET + 1] = ip[1];
_frame[MKS_FRAME_DATA_OFFSET + 2] = ip[2];
_frame[MKS_FRAME_DATA_OFFSET + 3] = ip[3];
log_esp3d("IP %d.%d.%d.%d", _frame[MKS_FRAME_DATA_OFFSET],_frame[MKS_FRAME_DATA_OFFSET + 1],_frame[MKS_FRAME_DATA_OFFSET + 2],_frame[MKS_FRAME_DATA_OFFSET + 3]);
//////////////////////////////////
//State Segment
//Connected state (OK)
_frame[MKS_FRAME_DATA_OFFSET + 6] = MKS_FRAME_NETWORK_OK_STATE;
} else {
///////////////////////////////////
//IP Segment
//No need - bytes are already cleared
//////////////////////////////////
//State Segment
//Connected state (Disconnected)
_frame[MKS_FRAME_DATA_OFFSET + 6] = MKS_FRAME_NETWORK_FAIL_STATE;
}
//////////////////////////////////
//Mode Segment
_frame[MKS_FRAME_DATA_OFFSET + 7] = MKS_FRAME_NETWORK_STA_MODE;
//////////////////////////////////
//Wifi_name_len Segment
s = Settings_ESP3D::read_string(ESP_STA_SSID);
_frame[MKS_FRAME_DATA_OFFSET + 8] = s.length();
dataOffset = MKS_FRAME_DATA_OFFSET + 9;
//////////////////////////////////
//Wifi_name Segment
strcpy(&_frame[dataOffset], s.c_str());
dataOffset+=s.length();
//////////////////////////////////
//Wifi_key_len Segment
s = Settings_ESP3D::read_string(ESP_STA_PASSWORD);
_frame[dataOffset] = s.length();
dataOffset++;
//////////////////////////////////
//Wifi_key Segment
strcpy(&_frame[dataOffset], s.c_str());
dataOffset+=s.length();
} else if (NetConfig::getMode() == ESP_WIFI_AP) {
log_esp3d("AP Mode");
///////////////////////////////////
//IP Segment
//IP value
IPAddress ip = NetConfig::localIPAddress();
_frame[MKS_FRAME_DATA_OFFSET] = ip[0];
_frame[MKS_FRAME_DATA_OFFSET + 1] = ip[1];
_frame[MKS_FRAME_DATA_OFFSET + 2] = ip[2];
_frame[MKS_FRAME_DATA_OFFSET + 3] = ip[3];
//////////////////////////////////
//State Segment
//Connected state (OK)
_frame[MKS_FRAME_DATA_OFFSET + 6] = MKS_FRAME_NETWORK_OK_STATE;
//////////////////////////////////
//Mode Segment
_frame[MKS_FRAME_DATA_OFFSET + 7] = MKS_FRAME_NETWORK_AP_MODE;
//////////////////////////////////
//Wifi_name_len Segment
String s = Settings_ESP3D::read_string(ESP_AP_SSID);
_frame[MKS_FRAME_DATA_OFFSET + 8] = s.length();
dataOffset = MKS_FRAME_DATA_OFFSET + 9;
//////////////////////////////////
//Wifi_name Segment
strcpy(&_frame[dataOffset], s.c_str());
dataOffset+=s.length();
//////////////////////////////////
//Wifi_key_len Segment
s = Settings_ESP3D::read_string(ESP_AP_PASSWORD);
_frame[dataOffset] = s.length();
dataOffset++;
//////////////////////////////////
//Wifi_key Segment
strcpy(&_frame[dataOffset], s.c_str());
dataOffset+=s.length();
} else {
//not supported
log_esp3d("Mode not supported : %d ", NetConfig::getMode());
return false;
}
//////////////////////////////////
//Cloud Services port Segment
//hard coded
_frame[MKS_FRAME_DATA_OFFSET +4] = CLOUD_SERVICE_PORT & 0xff;
_frame[MKS_FRAME_DATA_OFFSET +5] = (CLOUD_SERVICE_PORT>> 8 ) & 0xff;
log_esp3d("Cloud port: %d", CLOUD_SERVICE_PORT);
//////////////////////////////////
//Cloud State Segment
//hard coded as disabled in upstream FW
_frame[dataOffset] = MKS_FRAME_CLOUD_DISABLED_STATE;
dataOffset++;
//////////////////////////////////
//Cloud host len Segment
//hard coded
_frame[dataOffset] = strlen(CLOUD_HOST_ADDRESS);
dataOffset++;
//////////////////////////////////
//Cloud host Segment
//hard coded
strcpy(&_frame[dataOffset], CLOUD_HOST_ADDRESS);
dataOffset+=strlen(CLOUD_HOST_ADDRESS);
//////////////////////////////////
//Cloud host port Segment
//hard coded
_frame[dataOffset] = CLOUD_HOST_PORT & 0xff;
dataOffset++;
_frame[dataOffset] = (CLOUD_HOST_PORT>> 8 ) & 0xff;
dataOffset++;
//////////////////////////////////
//Module id len Segment
//???
_frame[dataOffset] = strlen(_moduleId);
dataOffset++;
//////////////////////////////////
//Module id Segment
//???
strcpy(&_frame[dataOffset], _moduleId);
dataOffset+=strlen(_moduleId);
//////////////////////////////////
//FW version len Segment
//???
_frame[dataOffset] = strlen(FW_VERSION);
dataOffset++;
//////////////////////////////////
//FW version Segment
//???
strcpy(&_frame[dataOffset], FW_VERSION);
dataOffset+=strlen(FW_VERSION);
//////////////////////////////////
//Tail Segment
_frame[dataOffset] = MKS_FRAME_TAIL_FLAG;
//////////////////////////////////
//Data len Segment
//Calculated from above
_frame[MKS_FRAME_DATALEN_OFFSET] = (dataOffset-4) & 0xff;
_frame[MKS_FRAME_DATALEN_OFFSET+1] = ((dataOffset-4) >> 8) & 0xff;
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)) {
log_esp3d("Ok");
return true;
}
}
log_esp3d("Failed");
}
return false;
}
void MKSService::clearFrame()
{
memset(_frame, 0, sizeof(_frame));
}
void MKSService::handle()
{
if (_started ) {
sendNetworkFrame();
}
//network frame every 10s
}
void MKSService::end()
{
_started = false;
}
#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL

47
esp3d/src/modules/mks/mks_service.h Normal file
View File

@ -0,0 +1,47 @@
/*
mks_service.cpp - mks communication service functions class
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
*/
#ifndef _MKS_SERVICES_H
#define _MKS_SERVICES_H
#define MKS_FRAME_SIZE 1024
class MKSService
{
public:
static bool begin();
static bool sendNetworkFrame();
static void handle();
static void end();
static bool started()
{
return _started;
}
private:
static void clearFrame();
static bool canSendFrame();
static bool _started;
static char _frame[MKS_FRAME_SIZE];
static char _moduleId[21];
};
#endif //_SERIAL_SERVICES_H

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

@ -107,6 +107,29 @@ bool NetConfig::isHostnameValid (const char * hostname)
return true;
}
/**
* Get IP Integer what ever is enabled
*/
IPAddress NetConfig::localIPAddress()
{
IPAddress current_ip = 0;
#if defined( WIFI_FEATURE)
if (WiFi.getMode() == WIFI_STA) {
current_ip = WiFi.localIP();
} else if (WiFi.getMode() == WIFI_AP) {
current_ip = WiFi.softAPIP();
}
#endif //WIFI_FEATURE
#if defined (ETH_FEATURE)
if (EthConfig::started()) {
current_ip = ETH.localIP();
}
#endif //ETH_FEATURE
return current_ip;
}
/**
* Get IP string what ever is enabled
*/
@ -153,14 +176,16 @@ void NetConfig::onWiFiEvent(WiFiEvent_t event)
case WIFI_EVENT_STAMODE_DISCONNECTED: {
if(_started) {
output.printMSG ("Disconnected");
ESP3DGlobalOutput::SetStatus("Disconnected");
ESP3DGlobalOutput::display_Disconnected();
//_needReconnect2AP = true;
}
}
break;
case WIFI_EVENT_STAMODE_GOT_IP: {
ESP3DGlobalOutput::display_IP();
#if COMMUNICATION_PROTOCOL != MKS_SERIAL
output.printMSG (WiFi.localIP().toString().c_str());
#endif //#if COMMUNICATION_PROTOCOL == MKS_SERIAL
}
break;
case WIFI_EVENT_SOFTAPMODE_STACONNECTED: {

1
esp3d/src/modules/network/netconfig.h
View File

@ -64,6 +64,7 @@ public:
return _started;
}
static String localIP();
static IPAddress localIPAddress();
private :
static String _hostname;
static void onWiFiEvent(WiFiEvent_t event);

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

@ -72,6 +72,10 @@ DNSServer dnsServer;
#ifdef CAMERA_DEVICE
#include "../camera/camera.h"
#endif //CAMERA_DEVICE
#if COMMUNICATION_PROTOCOL == MKS_SERIAL
#include "../mks/mks_service.h"
#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL
bool NetServices::_started = false;
bool NetServices::_restart = false;
@ -82,6 +86,9 @@ 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()) {
@ -302,7 +309,9 @@ bool NetServices::begin()
end();
}
Hal::wait(1000);
#if COMMUNICATION_PROTOCOL != MKS_SERIAL
output.printMSG(NetConfig::localIP().c_str());
#endif //#if COMMUNICATION_PROTOCOL == MKS_SERIAL
_started = res;
return _started;
}
@ -313,6 +322,9 @@ void NetServices::end()
return;
}
_started = false;
#if COMMUNICATION_PROTOCOL == MKS_SERIAL
MKSService::end();
#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL
#ifdef CAMERA_DEVICE
esp3d_camera.end();
#endif //CAMERA_DEVICE
@ -373,6 +385,9 @@ void NetServices::end()
void NetServices::handle()
{
if (_started) {
#if COMMUNICATION_PROTOCOL == MKS_SERIAL
MKSService::handle();
#endif //COMMUNICATION_PROTOCOL == MKS_SERIAL
#ifdef MDNS_FEATURE
#if defined(ARDUINO_ARCH_ESP8266)
MDNS.update();

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

@ -118,10 +118,12 @@ bool WiFiConfig::ConnectSTA2AP()
uint8_t dot = 0;
wl_status_t status = WiFi.status();
ESP3DOutput output(ESP_ALL_CLIENTS);
#if COMMUNICATION_PROTOCOL != MKS_SERIAL
if (!Settings_ESP3D::isVerboseBoot()) {
output.printMSG("Connecting");
output.flush();
}
#endif //#if COMMUNICATION_PROTOCOL == MKS_SERIAL
while (status != WL_CONNECTED && count < 40) {
switch (status) {