From 7f9c8e3561cc4ce440d363f8a3213f7e66b2da3d Mon Sep 17 00:00:00 2001 From: TD-er Date: Fri, 2 Oct 2020 16:58:03 +0200 Subject: [PATCH] [ESPEasySerial] Make GPIO pins selectabel on ESP32 --- lib/ESPEasySerial/ESPEasySerial_ESP32.cpp | 41 ++++--- .../ESPEasySerial_ESP8266_noSWserial.cpp | 42 +++---- lib/ESPEasySerial/ESPeasySerial.h | 94 ++++++++------- lib/ESPEasySerial/ESPeasySerial_ESP8266.cpp | 42 +++---- lib/ESPEasySerial/library.json | 2 +- lib/ESPEasySerial/library.properties | 2 +- lib/SerialDevices/SensorSerial.cpp | 8 +- lib/SerialDevices/SensorSerial.h | 2 +- lib/SerialDevices/jkSDS011.cpp | 4 +- lib/SerialDevices/jkSDS011.h | 2 +- platformio_esp32_envs.ini | 2 +- platformio_esp82xx_base.ini | 2 +- src/WebServer_DevicesPage.ino | 4 +- src/_C018.ino | 17 +-- src/_P044_P1WifiGateway.ino | 6 +- src/_P049_MHZ19.ino | 7 +- src/_P052_SenseAir.ino | 8 +- src/_P053_PMSx003.ino | 3 +- src/_P056_SDS011-Dust.ino | 3 +- src/_P065_DRF0299_MP3.ino | 2 +- src/_P071_Kamstrup401.ino | 3 +- src/_P075_Nextion.ino | 7 +- src/_P078_Eastron.ino | 2 +- src/_P082_GPS.ino | 9 +- src/_P085_AcuDC243.ino | 9 +- src/_P087_SerialProxy.ino | 5 +- src/_P093_MitsubishiHP.ino | 7 +- src/_P094_CULReader.ino | 5 +- src/_Plugin_Helper_serial.ino | 107 ++++++++++++------ src/src/DataStructs/SettingsStruct.cpp | 2 +- src/src/DataStructs/SettingsStruct.h | 4 +- src/src/Helpers/Modbus_RTU.cpp | 8 +- src/src/Helpers/Modbus_RTU.h | 6 +- src/src/PluginStructs/P044_data_struct.cpp | 4 +- src/src/PluginStructs/P044_data_struct.h | 3 +- src/src/PluginStructs/P087_data_struct.cpp | 4 +- src/src/PluginStructs/P087_data_struct.h | 3 +- src/src/PluginStructs/P094_data_struct.cpp | 7 +- src/src/PluginStructs/P094_data_struct.h | 3 +- 39 files changed, 286 insertions(+), 205 deletions(-) diff --git a/lib/ESPEasySerial/ESPEasySerial_ESP32.cpp b/lib/ESPEasySerial/ESPEasySerial_ESP32.cpp index de819513b..9fdafa5ee 100644 --- a/lib/ESPEasySerial/ESPEasySerial_ESP32.cpp +++ b/lib/ESPEasySerial/ESPEasySerial_ESP32.cpp @@ -6,19 +6,26 @@ // **************************************** #ifdef ESP32 -ESPeasySerial::ESPeasySerial(int receivePin, int transmitPin, bool inverse_logic, int serialPort) +ESPeasySerial::ESPeasySerial( + ESPEasySerialPort port, + int receivePin, + int transmitPin, + bool inverse_logic, + unsigned int buffSize) : _receivePin(receivePin), _transmitPin(transmitPin), _inverse_logic(inverse_logic) { - switch (serialPort) { - case 0: _serialtype = ESPeasySerialType::serialtype::serial0; break; - case 1: _serialtype = ESPeasySerialType::serialtype::serial1; break; - case 2: _serialtype = ESPeasySerialType::serialtype::serial2; break; + switch (port) { + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial1: + case ESPEasySerialPort::serial2: + _serialtype = port; + break; default: - _serialtype = ESPeasySerialType::getSerialType(receivePin, transmitPin); + _serialtype = ESPeasySerialType::getSerialType(port, receivePin, transmitPin); } switch (_serialtype) { - case ESPeasySerialType::serialtype::sc16is752: + case ESPEasySerialPort::sc16is752: { ESPEasySC16IS752_Serial::I2C_address addr = static_cast(receivePin); ESPEasySC16IS752_Serial::SC16IS752_channel ch = static_cast(transmitPin); @@ -84,9 +91,9 @@ void ESPeasySerial::end() { HardwareSerial * ESPeasySerial::getHW() { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: return &Serial; - case ESPeasySerialType::serialtype::serial1: return &Serial1; - case ESPeasySerialType::serialtype::serial2: return &Serial2; + case ESPEasySerialPort::serial0: return &Serial; + case ESPEasySerialPort::serial1: return &Serial1; + case ESPEasySerialPort::serial2: return &Serial2; default: break; } @@ -95,9 +102,9 @@ HardwareSerial * ESPeasySerial::getHW() { const HardwareSerial * ESPeasySerial::getHW() const { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: return &Serial; - case ESPeasySerialType::serialtype::serial1: return &Serial1; - case ESPeasySerialType::serialtype::serial2: return &Serial2; + case ESPEasySerialPort::serial0: return &Serial; + case ESPEasySerialPort::serial1: return &Serial1; + case ESPEasySerialPort::serial2: return &Serial2; default: break; } return nullptr; @@ -105,12 +112,12 @@ const HardwareSerial * ESPeasySerial::getHW() const { bool ESPeasySerial::isValid() const { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial2: + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial2: return true; - case ESPeasySerialType::serialtype::serial1: + case ESPEasySerialPort::serial1: return _transmitPin != -1 && _receivePin != -1; - case ESPeasySerialType::serialtype::sc16is752: + case ESPEasySerialPort::sc16is752: return _i2cserial != nullptr; // FIXME TD-er: Must perform proper check for GPIO pins here. diff --git a/lib/ESPEasySerial/ESPEasySerial_ESP8266_noSWserial.cpp b/lib/ESPEasySerial/ESPEasySerial_ESP8266_noSWserial.cpp index bb14fdd5c..4dd9e408b 100644 --- a/lib/ESPEasySerial/ESPEasySerial_ESP8266_noSWserial.cpp +++ b/lib/ESPEasySerial/ESPEasySerial_ESP8266_noSWserial.cpp @@ -7,10 +7,10 @@ // No SoftwareSerial // Only support HW serial on Serial 0 .. 1 // **************************************** -ESPeasySerial::ESPeasySerial(int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize) +ESPeasySerial::ESPeasySerial(ESPEasySerialPort port, int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize) : _receivePin(receivePin), _transmitPin(transmitPin) { - _serialtype = ESPeasySerialType::getSerialType(receivePin, transmitPin); + _serialtype = ESPeasySerialType::getSerialType(port, receivePin, transmitPin); if (isValid()) { getHW()->pins(transmitPin, receivePin); @@ -24,7 +24,7 @@ ESPeasySerial::~ESPeasySerial() { void ESPeasySerial::begin(unsigned long baud, SerialConfig config, SerialMode mode) { _baud = baud; - if (_serialtype == ESPeasySerialType::serialtype::serial0_swap) { + if (_serialtype == ESPEasySerialPort::serial0_swap) { // Serial.swap() should only be called here and only once. if (!_serial0_swap_active) { Serial.begin(baud, config, mode, _transmitPin); @@ -46,7 +46,7 @@ void ESPeasySerial::end() { return; } - if (_serialtype == ESPeasySerialType::serialtype::serial0_swap) { + if (_serialtype == ESPEasySerialPort::serial0_swap) { if (_serial0_swap_active) { Serial.end(); Serial.swap(); @@ -59,10 +59,10 @@ void ESPeasySerial::end() { HardwareSerial * ESPeasySerial::getHW() { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial0_swap: return &Serial; - case ESPeasySerialType::serialtype::serial1: return &Serial1; - case ESPeasySerialType::serialtype::software: break; + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: return &Serial; + case ESPEasySerialPort::serial1: return &Serial1; + case ESPEasySerialPort::software: break; default: break; } return nullptr; @@ -70,10 +70,10 @@ HardwareSerial * ESPeasySerial::getHW() { const HardwareSerial * ESPeasySerial::getHW() const { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial0_swap: return &Serial; - case ESPeasySerialType::serialtype::serial1: return &Serial1; - case ESPeasySerialType::serialtype::software: break; + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: return &Serial; + case ESPEasySerialPort::serial1: return &Serial1; + case ESPEasySerialPort::software: break; default: break; } return nullptr; @@ -81,10 +81,10 @@ const HardwareSerial * ESPeasySerial::getHW() const { bool ESPeasySerial::isValid() const { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: return !_serial0_swap_active; - case ESPeasySerialType::serialtype::serial0_swap: return _serial0_swap_active; - case ESPeasySerialType::serialtype::serial1: return true; // Must also check RX pin? - case ESPeasySerialType::serialtype::software: return false; + case ESPEasySerialPort::serial0: return !_serial0_swap_active; + case ESPEasySerialPort::serial0_swap: return _serial0_swap_active; + case ESPEasySerialPort::serial1: return true; // Must also check RX pin? + case ESPEasySerialPort::software: return false; default: break; } return false; @@ -163,17 +163,17 @@ bool ESPeasySerial::hasOverrun(void) { void ESPeasySerial::swap(uint8_t tx_pin) { if (isValid()) { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial0_swap: + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: // isValid() also checks for correct swap active state. _serial0_swap_active = !_serial0_swap_active; getHW()->swap(tx_pin); - if (_serialtype == ESPeasySerialType::serialtype::serial0) { - _serialtype = ESPeasySerialType::serialtype::serial0_swap; + if (_serialtype == ESPEasySerialPort::serial0) { + _serialtype = ESPEasySerialPort::serial0_swap; } else { - _serialtype = ESPeasySerialType::serialtype::serial0; + _serialtype = ESPEasySerialPort::serial0; } break; default: diff --git a/lib/ESPEasySerial/ESPeasySerial.h b/lib/ESPEasySerial/ESPeasySerial.h index f9d10fc78..788df79b7 100644 --- a/lib/ESPEasySerial/ESPeasySerial.h +++ b/lib/ESPEasySerial/ESPeasySerial.h @@ -96,39 +96,43 @@ # define ESP32_SER2_RX 16 #endif // ifndef ESP32_SER2_RX + +// Keep value assigned as it is used in scripts and stored in the Settings.TaskDevicePort +enum class ESPEasySerialPort { + not_set = 0, + sc16is752 = 1, + serial0 = 2, + serial0_swap = 3, + serial1 = 4, + serial2 = 5, + software = 6, + + MAX_SERIAL_TYPE +}; + + struct ESPeasySerialType { - // Keep value assigned as it is used in scripts - enum serialtype { - software = 0, - sc16is752 = 1, - serial0, - serial0_swap, - serial1, - serial2, - - MAX_SERIAL_TYPE - }; - static bool getSerialTypePins(ESPeasySerialType::serialtype serType, int& rxPin, int& txPin) { + static bool getSerialTypePins(ESPEasySerialPort serType, int& rxPin, int& txPin) { rxPin = -1; txPin = -1; switch (serType) { #ifdef ESP32 - case ESPeasySerialType::serialtype::serial0: rxPin = ESP32_SER0_RX; txPin = ESP32_SER0_TX; return true; - case ESPeasySerialType::serialtype::serial1: rxPin = ESP32_SER1_RX; txPin = ESP32_SER1_TX; return true; - case ESPeasySerialType::serialtype::serial2: rxPin = ESP32_SER2_RX; txPin = ESP32_SER2_TX; return true; + case ESPEasySerialPort::serial0: rxPin = ESP32_SER0_RX; txPin = ESP32_SER0_TX; return true; + case ESPEasySerialPort::serial1: rxPin = ESP32_SER1_RX; txPin = ESP32_SER1_TX; return true; + case ESPEasySerialPort::serial2: rxPin = ESP32_SER2_RX; txPin = ESP32_SER2_TX; return true; #endif // ifdef ESP32 #ifdef ESP8266 - case ESPeasySerialType::serialtype::serial0: rxPin = 3; txPin = 1; return true; - case ESPeasySerialType::serialtype::serial0_swap: rxPin = 13; txPin = 15; return true; - case ESPeasySerialType::serialtype::serial1: rxPin = -1; txPin = 2; return true; + case ESPEasySerialPort::serial0: rxPin = 3; txPin = 1; return true; + case ESPEasySerialPort::serial0_swap: rxPin = 13; txPin = 15; return true; + case ESPEasySerialPort::serial1: rxPin = -1; txPin = 2; return true; # ifndef DISABLE_SOFTWARE_SERIAL - case ESPeasySerialType::serialtype::software: rxPin = 14; txPin = 12; return true; + case ESPEasySerialPort::software: rxPin = 14; txPin = 12; return true; # endif // DISABLE_SOFTWARE_SERIAL #endif // ifdef ESP8266 - case ESPeasySerialType::serialtype::sc16is752: rxPin = -1; txPin = -1; return true; + case ESPEasySerialPort::sc16is752: rxPin = -1; txPin = -1; return true; default: break; @@ -137,58 +141,64 @@ struct ESPeasySerialType { } #ifdef ESP32 - static ESPeasySerialType::serialtype getSerialType(int receivePin, int transmitPin) { + static ESPEasySerialPort getSerialType(ESPEasySerialPort typeHint, int receivePin, int transmitPin) { + if (typeHint != ESPEasySerialPort::not_set) { + return typeHint; + } if ((receivePin == ESP32_SER0_RX) && (transmitPin == ESP32_SER0_TX)) { - return serialtype::serial0; // UART0 + return ESPEasySerialPort::serial0; // UART0 } // Serial1 on ESP32 uses default pins connected to flash // So must make sure to set them to other pins. if ((receivePin == ESP32_SER1_RX) && (transmitPin == ESP32_SER1_TX)) { - return serialtype::serial1; // UART1 + return ESPEasySerialPort::serial1; // UART1 } if ((receivePin == ESP32_SER2_RX) && (transmitPin == ESP32_SER2_TX)) { - return serialtype::serial2; // UART2 + return ESPEasySerialPort::serial2; // UART2 } if ((receivePin >= 0x48) && (receivePin <= 0x57)) { - return serialtype::sc16is752; // I2C address range of SC16IS752 + return ESPEasySerialPort::sc16is752; // I2C address range of SC16IS752 } - return serialtype::MAX_SERIAL_TYPE; + return ESPEasySerialPort::MAX_SERIAL_TYPE; } #endif // ESP32 #ifdef ESP8266 - static ESPeasySerialType::serialtype getSerialType(int receivePin, int transmitPin) { + static ESPEasySerialPort getSerialType(ESPEasySerialPort typeHint, int receivePin, int transmitPin) { + if (typeHint != ESPEasySerialPort::not_set) { + return typeHint; + } if ((receivePin == 3) && (transmitPin == 1)) { - return serialtype::serial0; // UART0 + return ESPEasySerialPort::serial0; // UART0 } // ESP8266 if ((receivePin == 13) && (transmitPin == 15)) { - return serialtype::serial0_swap; // UART0 remapped using Serial.swap() + return ESPEasySerialPort::serial0_swap; // UART0 remapped using Serial.swap() } if ((receivePin == -1) && (transmitPin == 2)) { // Serial1 uses UART1, TX pin is GPIO2. // UART1 can not be used to receive data because normally // it's RX pin is occupied for flash chip connection. - return serialtype::serial1; + return ESPEasySerialPort::serial1; } if ((receivePin >= 0x48) && (receivePin <= 0x57)) { - return serialtype::sc16is752; // I2C address range of SC16IS752 + return ESPEasySerialPort::sc16is752; // I2C address range of SC16IS752 } if ((receivePin == -1) && (transmitPin == -1)) { // No pins set, so no serial type - return serialtype::MAX_SERIAL_TYPE; + return ESPEasySerialPort::MAX_SERIAL_TYPE; } - return serialtype::software; + return ESPEasySerialPort::software; } #endif // ESP8266 @@ -205,7 +215,8 @@ public: // Serial0 swapped RX: 13 TX: 15 // Serial1: RX: -- TX: 2 (TX only) // SC16IS752: Rx: I2C addr TX: channel (A = 0, B = 1) - ESPeasySerial(int receivePin, + ESPeasySerial(ESPEasySerialPort port, + int receivePin, int transmitPin, bool inverse_logic = false, unsigned int buffSize = 64, @@ -228,11 +239,12 @@ public: // Pins set in the constructor will be used as override when not given when calling begin() // @param inverse_logic can be used to set the logic in the constructor which will then be used in the call to begin. // This makes the call to the constructor more in line with the constructor of SoftwareSerial. - // @param serialPort can be a helper to suggest the set serial port. (is needed to define Serial1) - ESPeasySerial(int receivePin, + // buffsize is for compatibility reasons. ESP32 cannot set the buffer size. + ESPeasySerial(ESPEasySerialPort port, + int receivePin, int transmitPin, bool inverse_logic = false, - int serialPort = -1); + unsigned int buffSize = 64); virtual ~ESPeasySerial(); // If baud rate is set to 0, it will perform an auto-detect on the baudrate @@ -328,7 +340,7 @@ public: } bool useGPIOpins() const { - return _serialtype != ESPeasySerialType::serialtype::sc16is752; + return _serialtype != ESPEasySerialPort::sc16is752; } private: @@ -345,14 +357,14 @@ private: #endif // ifdef ESP8266 bool isI2Cserial() const { - return _serialtype == ESPeasySerialType::serialtype::sc16is752; + return _serialtype == ESPEasySerialPort::sc16is752; } ESPEasySC16IS752_Serial *_i2cserial = nullptr; #if !defined(DISABLE_SOFTWARE_SERIAL) && defined(ESP8266) bool isSWserial() const { - return _serialtype == ESPeasySerialType::serialtype::software; + return _serialtype == ESPEasySerialPort::software; } ESPeasySoftwareSerial *_swserial = nullptr; @@ -366,7 +378,7 @@ private: static bool _serial0_swap_active; #endif // ESP8266 - ESPeasySerialType::serialtype _serialtype = ESPeasySerialType::serialtype::MAX_SERIAL_TYPE; + ESPEasySerialPort _serialtype = ESPEasySerialPort::MAX_SERIAL_TYPE; int _receivePin; int _transmitPin; unsigned long _baud = 0; diff --git a/lib/ESPEasySerial/ESPeasySerial_ESP8266.cpp b/lib/ESPEasySerial/ESPeasySerial_ESP8266.cpp index 512cb9d26..886d26674 100644 --- a/lib/ESPEasySerial/ESPeasySerial_ESP8266.cpp +++ b/lib/ESPEasySerial/ESPeasySerial_ESP8266.cpp @@ -40,27 +40,27 @@ bool ESPeasySerial::_serial0_swap_active = false; #if !defined(DISABLE_SOFTWARE_SERIAL) && defined(ESP8266) -ESPeasySerial::ESPeasySerial(int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize, bool forceSWserial) +ESPeasySerial::ESPeasySerial(ESPEasySerialPort port, int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize, bool forceSWserial) : _i2cserial(nullptr), _swserial(nullptr), _receivePin(receivePin), _transmitPin(transmitPin) { - _serialtype = ESPeasySerialType::getSerialType(receivePin, transmitPin); + _serialtype = ESPeasySerialType::getSerialType(port, receivePin, transmitPin); if (forceSWserial) { switch (_serialtype) { - case ESPeasySerialType::serialtype::sc16is752: + case ESPEasySerialPort::sc16is752: break; default: - _serialtype = ESPeasySerialType::serialtype::software; + _serialtype = ESPEasySerialPort::software; break; } } switch (_serialtype) { - case ESPeasySerialType::serialtype::software: + case ESPEasySerialPort::software: { _swserial = new ESPeasySoftwareSerial(receivePin, transmitPin, inverse_logic, buffSize); break; } - case ESPeasySerialType::serialtype::sc16is752: + case ESPEasySerialPort::sc16is752: { ESPEasySC16IS752_Serial::I2C_address addr = static_cast(receivePin); ESPEasySC16IS752_Serial::SC16IS752_channel ch = static_cast(transmitPin); @@ -124,11 +124,11 @@ void ESPeasySerial::end() { HardwareSerial * ESPeasySerial::getHW() { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial0_swap: return &Serial; - case ESPeasySerialType::serialtype::serial1: return &Serial1; - case ESPeasySerialType::serialtype::software: break; - case ESPeasySerialType::serialtype::sc16is752: break; + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: return &Serial; + case ESPEasySerialPort::serial1: return &Serial1; + case ESPEasySerialPort::software: break; + case ESPEasySerialPort::sc16is752: break; default: break; } return nullptr; @@ -136,11 +136,11 @@ HardwareSerial * ESPeasySerial::getHW() { const HardwareSerial * ESPeasySerial::getHW() const { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial0_swap: return &Serial; - case ESPeasySerialType::serialtype::serial1: return &Serial1; - case ESPeasySerialType::serialtype::software: break; - case ESPeasySerialType::serialtype::sc16is752: break; + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: return &Serial; + case ESPEasySerialPort::serial1: return &Serial1; + case ESPEasySerialPort::software: break; + case ESPEasySerialPort::sc16is752: break; default: break; } return nullptr; @@ -148,11 +148,11 @@ const HardwareSerial * ESPeasySerial::getHW() const { bool ESPeasySerial::isValid() const { switch (_serialtype) { - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial0_swap: - case ESPeasySerialType::serialtype::serial1: return true; // Must also check RX pin? - case ESPeasySerialType::serialtype::software: return _swserial != nullptr; - case ESPeasySerialType::serialtype::sc16is752: return _i2cserial != nullptr; + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: + case ESPEasySerialPort::serial1: return true; // Must also check RX pin? + case ESPEasySerialPort::software: return _swserial != nullptr; + case ESPEasySerialPort::sc16is752: return _i2cserial != nullptr; default: break; } return false; diff --git a/lib/ESPEasySerial/library.json b/lib/ESPEasySerial/library.json index e5fd6607e..7d3a00f14 100644 --- a/lib/ESPEasySerial/library.json +++ b/lib/ESPEasySerial/library.json @@ -1,6 +1,6 @@ { "name": "ESPeasySerial", - "version": "2.0.2", + "version": "2.0.4", "keywords": [ "serial", "io", "softwareserial", "hardwareserial" ], diff --git a/lib/ESPEasySerial/library.properties b/lib/ESPEasySerial/library.properties index 1eb971c3b..01df919f8 100644 --- a/lib/ESPEasySerial/library.properties +++ b/lib/ESPEasySerial/library.properties @@ -1,5 +1,5 @@ name=ESPeasySerial -version=2.0.2 +version=2.0.4 author=Gijs Noorlander maintainer=Gijs Noorlander sentence=Wrapper for SoftwareSerial, SC16IS752 I2C to UART bridge and HardwareSerial for ESP8266 and ESP32. diff --git a/lib/SerialDevices/SensorSerial.cpp b/lib/SerialDevices/SensorSerial.cpp index b405f9392..676483dbf 100644 --- a/lib/SerialDevices/SensorSerial.cpp +++ b/lib/SerialDevices/SensorSerial.cpp @@ -26,14 +26,14 @@ #include #ifdef ESP32 -SensorSerial::SensorSerial(int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize) : - ESPeasySerial(receivePin, transmitPin, inverse_logic) +SensorSerial::SensorSerial(ESPEasySerialPort port, int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize) : + ESPeasySerial(port, receivePin, transmitPin, inverse_logic) {} #endif #ifdef ESP8266 -SensorSerial::SensorSerial(int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize) : - ESPeasySerial(receivePin, transmitPin, inverse_logic, buffSize) +SensorSerial::SensorSerial(ESPEasySerialPort port, int receivePin, int transmitPin, bool inverse_logic, unsigned int buffSize) : + ESPeasySerial(port, receivePin, transmitPin, inverse_logic, buffSize) {} #endif diff --git a/lib/SerialDevices/SensorSerial.h b/lib/SerialDevices/SensorSerial.h index 4e83c6faf..f8688c4b5 100644 --- a/lib/SerialDevices/SensorSerial.h +++ b/lib/SerialDevices/SensorSerial.h @@ -34,7 +34,7 @@ class SensorSerial : public ESPeasySerial { public: - SensorSerial(int receivePin, int transmitPin = -1, bool inverse_logic = false, unsigned int buffSize = 64); + SensorSerial(ESPEasySerialPort port, int receivePin, int transmitPin = -1, bool inverse_logic = false, unsigned int buffSize = 64); void begin(long speed); diff --git a/lib/SerialDevices/jkSDS011.cpp b/lib/SerialDevices/jkSDS011.cpp index c5b9bec80..cca2d322d 100644 --- a/lib/SerialDevices/jkSDS011.cpp +++ b/lib/SerialDevices/jkSDS011.cpp @@ -25,7 +25,7 @@ //#ifdef ESP8266 // Needed for precompile issues. #include "jkSDS011.h" -CjkSDS011::CjkSDS011(int16_t pinRX, int16_t pinTX) +CjkSDS011::CjkSDS011(ESPEasySerialPort port, int16_t pinRX, int16_t pinTX) { _sws = ! ( pinRX < 0 || pinRX == 3 ); _pm2_5 = NAN; @@ -38,7 +38,7 @@ CjkSDS011::CjkSDS011(int16_t pinRX, int16_t pinTX) _command.SetPacketLength(19); _working_period = -1; _sleepmode_active = false; - _serial = new (std::nothrow) ESPeasySerial(pinRX, pinTX); + _serial = new (std::nothrow) ESPeasySerial(port, pinRX, pinTX); if (_serial != nullptr) _serial->begin(9600); } diff --git a/lib/SerialDevices/jkSDS011.h b/lib/SerialDevices/jkSDS011.h index 55e47c0e3..37cf4704e 100644 --- a/lib/SerialDevices/jkSDS011.h +++ b/lib/SerialDevices/jkSDS011.h @@ -35,7 +35,7 @@ class CjkSDS011 { public: - CjkSDS011(int16_t pinRX, int16_t pinTX); + CjkSDS011(ESPEasySerialPort port, int16_t pinRX, int16_t pinTX); virtual ~CjkSDS011(); void Process(); diff --git a/platformio_esp32_envs.ini b/platformio_esp32_envs.ini index 5b9997766..7308b08e6 100644 --- a/platformio_esp32_envs.ini +++ b/platformio_esp32_envs.ini @@ -9,7 +9,7 @@ [esp32_common] extends = common, core_esp32_2_0_0 lib_ignore = ESP8266WiFi, ESP8266Ping, ESP8266WebServer, ESP8266HTTPUpdateServer, ESP8266mDNS, IRremoteESP8266, ESPEasy_ESP8266Ping, ESP32_ping, HeatpumpIR -lib_deps = https://github.com/TD-er/ESPEasySerial.git#v2.0.3, Adafruit ILI9341, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO +lib_deps = https://github.com/TD-er/ESPEasySerial.git#v2.0.4, Adafruit ILI9341, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO board_build.f_flash = 80000000L board_build.flash_mode = dout board_upload.maximum_size = 1900544 diff --git a/platformio_esp82xx_base.ini b/platformio_esp82xx_base.ini index 08f42368c..913c62d04 100644 --- a/platformio_esp82xx_base.ini +++ b/platformio_esp82xx_base.ini @@ -52,7 +52,7 @@ extends = common board_build.f_cpu = 80000000L build_flags = ${debug_flags.build_flags} ${mqtt_flags.build_flags} -DHTTPCLIENT_1_1_COMPATIBLE=0 build_unflags = -DDEBUG_ESP_PORT -lib_deps = https://github.com/TD-er/ESPEasySerial.git#v2.0.3, Adafruit ILI9341, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO +lib_deps = https://github.com/TD-er/ESPEasySerial.git#v2.0.4, Adafruit ILI9341, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO lib_ignore = ${esp82xx_defaults.lib_ignore}, IRremoteESP8266, HeatpumpIR, SD(esp8266), SDFS, LittleFS(esp8266) board = esp12e monitor_filters = esp8266_exception_decoder diff --git a/src/WebServer_DevicesPage.ino b/src/WebServer_DevicesPage.ino index 4dd388d0b..b9b3a3519 100644 --- a/src/WebServer_DevicesPage.ino +++ b/src/WebServer_DevicesPage.ino @@ -10,6 +10,8 @@ # include "src/Helpers/_CPlugin_SensorTypeHelper.h" # include "src/Helpers/StringGenerator_GPIO.h" +#include + void handle_devices() { checkRAM(F("handle_devices")); @@ -585,7 +587,7 @@ void handle_devicess_ShowAllTasksTable(byte page) // fallthrough case DEVICE_TYPE_SERIAL: { - addHtml(serialHelper_getGpioDescription(Settings.TaskDevicePin1[x], Settings.TaskDevicePin2[x], F("
"))); + addHtml(serialHelper_getGpioDescription(static_cast(Settings.TaskDevicePort[x]), Settings.TaskDevicePin1[x], Settings.TaskDevicePin2[x], F("
"))); if (showpin3) { html_BR(); } diff --git a/src/_C018.ino b/src/_C018.ino index b19a0e9ff..9d6702b99 100644 --- a/src/_C018.ino +++ b/src/_C018.ino @@ -49,7 +49,7 @@ struct C018_data_struct { autobaud_success = false; } - bool init(const int8_t serial_rx, const int8_t serial_tx, unsigned long baudrate, + bool init(const uint8_t port, const int8_t serial_rx, const int8_t serial_tx, unsigned long baudrate, bool joinIsOTAA, taskIndex_t sampleSet_Initiator, int8_t reset_pin) { if ((serial_rx < 0) || (serial_tx < 0)) { // Both pins are needed, or else no serial possible @@ -72,7 +72,7 @@ struct C018_data_struct { _baudrate = baudrate; // FIXME TD-er: Make force SW serial a proper setting. - C018_easySerial = new (std::nothrow) ESPeasySerial(serial_rx, serial_tx, false, 64, C018_FORCE_SW_SERIAL); + C018_easySerial = new (std::nothrow) ESPeasySerial(static_cast(port), serial_rx, serial_tx, false, 64); if (C018_easySerial != nullptr) { myLora = new rn2xx3(*C018_easySerial); @@ -341,11 +341,11 @@ private: // First set the baud rate low enough to even trigger autobaud when 9600 baud is active C018_easySerial->begin(600); - C018_easySerial->write(0x00); + C018_easySerial->write(static_cast(0x00)); // Set to desired baud rate. C018_easySerial->begin(_baudrate); - C018_easySerial->write(0x55); + C018_easySerial->write(static_cast(0x55)); C018_easySerial->println(); delay(100); @@ -429,6 +429,7 @@ struct C018_ConfigStruct uint8_t sf = 7; uint8_t frequencyplan = RN2xx3_datatypes::Freq_plan::TTN_EU; uint8_t joinmethod = C018_USE_OTAA; + uint8_t serialPort = 0; }; @@ -579,7 +580,9 @@ bool CPlugin_018(CPlugin::Function function, struct EventStruct *event, String& // Show serial port selection addFormPinSelect(formatGpioName_RX(false), F("taskdevicepin1"), rxpin); addFormPinSelect(formatGpioName_TX(false), F("taskdevicepin2"), txpin); - serialHelper_webformLoad(rxpin, txpin, true); + + // FIXME TD-er: Add port selector + serialHelper_webformLoad(ESPEasySerialPort::not_set, rxpin, txpin, true); addFormNumericBox(F("Baudrate"), F(C018_BAUDRATE_LABEL), baudrate, 2400, 115200); addUnit(F("baud")); @@ -653,7 +656,7 @@ bool CPlugin_018(CPlugin::Function function, struct EventStruct *event, String& customConfig->sf = getFormItemInt(F("sf"), customConfig->sf); customConfig->frequencyplan = getFormItemInt(F("frequencyplan"), customConfig->frequencyplan); customConfig->joinmethod = getFormItemInt(F("joinmethod"), customConfig->joinmethod); - serialHelper_webformSave(customConfig->rxpin, customConfig->txpin); + serialHelper_webformSave(customConfig->serialPort, customConfig->rxpin, customConfig->txpin); SaveCustomControllerSettings(event->ControllerIndex, (byte *)customConfig.get(), sizeof(C018_ConfigStruct)); } break; @@ -760,7 +763,7 @@ bool C018_init(struct EventStruct *event) { LoadCustomControllerSettings(event->ControllerIndex, (byte *)customConfig.get(), sizeof(C018_ConfigStruct)); customConfig->validate(); - if (!C018_data.init(customConfig->rxpin, customConfig->txpin, customConfig->baudrate, + if (!C018_data.init(customConfig->serialPort, customConfig->rxpin, customConfig->txpin, customConfig->baudrate, (customConfig->joinmethod == C018_USE_OTAA), SampleSetInitiator, customConfig->resetpin)) { diff --git a/src/_P044_P1WifiGateway.ino b/src/_P044_P1WifiGateway.ino index d81b75a45..e969e288d 100644 --- a/src/_P044_P1WifiGateway.ino +++ b/src/_P044_P1WifiGateway.ino @@ -11,6 +11,7 @@ #include "_Plugin_Helper.h" #include "src/PluginStructs/P044_data_struct.h" +#include #define PLUGIN_044 #define PLUGIN_ID_044 44 @@ -103,9 +104,10 @@ boolean Plugin_044(byte function, struct EventStruct *event, String& string) int rxPin; int txPin; - ESPeasySerialType::getSerialTypePins(ESPeasySerialType::serial0, rxPin, txPin); + // FIXME TD-er: Must use proper pin settings and standard ESPEasySerial wrapper + ESPeasySerialType::getSerialTypePins(ESPEasySerialPort::serial0, rxPin, txPin); byte serialconfig = serialHelper_convertOldSerialConfig(P044_SERIAL_CONFIG); - task->serialBegin(rxPin, txPin, P044_BAUDRATE, serialconfig); + task->serialBegin(ESPEasySerialPort::not_set, rxPin, txPin, P044_BAUDRATE, serialconfig); task->startServer(P044_WIFI_SERVER_PORT); if (!task->isInit()) { diff --git a/src/_P049_MHZ19.ino b/src/_P049_MHZ19.ino index a507a03ee..5b048d716 100644 --- a/src/_P049_MHZ19.ino +++ b/src/_P049_MHZ19.ino @@ -136,11 +136,11 @@ struct P049_data_struct : public PluginTaskData_base { modelA_detected = false; } - bool init(const int16_t serial_rx, const int16_t serial_tx, bool setABCdisabled) { + bool init(ESPEasySerialPort port, const int16_t serial_rx, const int16_t serial_tx, bool setABCdisabled) { if (serial_rx < 0 || serial_tx < 0) return false; reset(); - easySerial = new (std::nothrow) ESPeasySerial(serial_rx, serial_tx); + easySerial = new (std::nothrow) ESPeasySerial(port, serial_rx, serial_tx); if (easySerial == nullptr) { return false; } @@ -628,12 +628,13 @@ bool P049_performInit(struct EventStruct *event) { bool success = false; const int16_t serial_rx = CONFIG_PIN1; const int16_t serial_tx = CONFIG_PIN2; + const ESPEasySerialPort port = static_cast(CONFIG_PORT); P049_data_struct *P049_data = static_cast(getPluginTaskData(event->TaskIndex)); if (nullptr == P049_data) { return success; } - if (P049_data->init(serial_rx, serial_tx, PCONFIG(0) == ABC_disabled)) { + if (P049_data->init(port, serial_rx, serial_tx, PCONFIG(0) == ABC_disabled)) { success = true; addLog(LOG_LEVEL_INFO, F("MHZ19: Init OK ")); diff --git a/src/_P052_SenseAir.ino b/src/_P052_SenseAir.ino index 831939eb6..18e14e85f 100644 --- a/src/_P052_SenseAir.ino +++ b/src/_P052_SenseAir.ino @@ -109,8 +109,8 @@ struct P052_data_struct : public PluginTaskData_base { modbus.reset(); } - bool init(const int16_t serial_rx, const int16_t serial_tx) { - return modbus.init(serial_rx, serial_tx, 9600, P052_MODBUS_SLAVE_ADDRESS); + bool init(const ESPEasySerialPort port, const int16_t serial_rx, const int16_t serial_tx) { + return modbus.init(port, serial_rx, serial_tx, 9600, P052_MODBUS_SLAVE_ADDRESS); } bool isInitialized() const { @@ -456,6 +456,7 @@ boolean Plugin_052(byte function, struct EventStruct *event, String& string) { case PLUGIN_INIT: { const int16_t serial_rx = CONFIG_PIN1; const int16_t serial_tx = CONFIG_PIN2; + const ESPEasySerialPort port = static_cast(CONFIG_PORT); initPluginTaskData(event->TaskIndex, new (std::nothrow) P052_data_struct()); P052_data_struct *P052_data = static_cast(getPluginTaskData(event->TaskIndex)); @@ -464,7 +465,8 @@ boolean Plugin_052(byte function, struct EventStruct *event, String& string) { return success; } - if (P052_data->init(serial_rx, serial_tx)) { + + if (P052_data->init(port, serial_rx, serial_tx)) { /* // ABC functionality disabled for now, due to a bug in the firmware. // See https://github.com/letscontrolit/ESPEasy/issues/759 diff --git a/src/_P053_PMSx003.ino b/src/_P053_PMSx003.ino index 8d742e90f..2fab03267 100644 --- a/src/_P053_PMSx003.ino +++ b/src/_P053_PMSx003.ino @@ -220,6 +220,7 @@ boolean Plugin_053(byte function, struct EventStruct *event, String& string) { int rxPin = CONFIG_PIN1; int txPin = CONFIG_PIN2; + const ESPEasySerialPort port = static_cast(CONFIG_PORT); int resetPin = CONFIG_PIN3; String log = F("PMSx003 : config "); @@ -245,7 +246,7 @@ boolean Plugin_053(byte function, struct EventStruct *event, String& string) log = F("PMSx003: using software serial"); addLog(LOG_LEVEL_INFO, log); } - P053_easySerial = new (std::nothrow) ESPeasySerial(rxPin, txPin, false, 96); // 96 Bytes buffer, enough for up to 3 packets. + P053_easySerial = new (std::nothrow) ESPeasySerial(port, rxPin, txPin, false, 96); // 96 Bytes buffer, enough for up to 3 packets. if (P053_easySerial == nullptr) { break; } diff --git a/src/_P056_SDS011-Dust.ino b/src/_P056_SDS011-Dust.ino index 35ffc36fb..883cdb139 100644 --- a/src/_P056_SDS011-Dust.ino +++ b/src/_P056_SDS011-Dust.ino @@ -110,7 +110,8 @@ boolean Plugin_056(byte function, struct EventStruct *event, String& string) delete Plugin_056_SDS; const int16_t serial_rx = CONFIG_PIN1; const int16_t serial_tx = CONFIG_PIN2; - Plugin_056_SDS = new CjkSDS011(serial_rx, serial_tx); + const ESPEasySerialPort port = static_cast(CONFIG_PORT); + Plugin_056_SDS = new CjkSDS011(port, serial_rx, serial_tx); String log = F("SDS : Init OK ESP GPIO-pin RX:"); log += serial_rx; log += F(" TX:"); diff --git a/src/_P065_DRF0299_MP3.ino b/src/_P065_DRF0299_MP3.ino index eae4db9e3..b669c66ad 100644 --- a/src/_P065_DRF0299_MP3.ino +++ b/src/_P065_DRF0299_MP3.ino @@ -101,7 +101,7 @@ boolean Plugin_065(byte function, struct EventStruct *event, String& string) #pragma GCC diagnostic pop - P065_easySerial = new (std::nothrow) ESPeasySerial(-1, CONFIG_PIN1); // no RX, only TX + P065_easySerial = new (std::nothrow) ESPeasySerial(CONFIG_PORT, -1, CONFIG_PIN1); // no RX, only TX if (P065_easySerial != nullptr) { P065_easySerial->begin(9600); Plugin_065_SetVol(PCONFIG(0)); // set default volume diff --git a/src/_P071_Kamstrup401.ino b/src/_P071_Kamstrup401.ino index 65cf5beb4..c30df8e0f 100644 --- a/src/_P071_Kamstrup401.ino +++ b/src/_P071_Kamstrup401.ino @@ -95,8 +95,9 @@ boolean Plugin_071(byte function, struct EventStruct *event, String& string) { PIN_KAMSER_RX = CONFIG_PIN1; PIN_KAMSER_TX = CONFIG_PIN2; + const ESPEasySerialPort port = static_cast(CONFIG_PORT); - ESPeasySerial kamSer(PIN_KAMSER_RX, PIN_KAMSER_TX, false); // Initialize serial + ESPeasySerial kamSer(port, PIN_KAMSER_RX, PIN_KAMSER_TX, false); // Initialize serial pinMode(PIN_KAMSER_RX,INPUT); pinMode(PIN_KAMSER_TX,OUTPUT); diff --git a/src/_P075_Nextion.ino b/src/_P075_Nextion.ino index ea4a36f5a..2fa27f3cf 100644 --- a/src/_P075_Nextion.ino +++ b/src/_P075_Nextion.ino @@ -54,11 +54,11 @@ struct P075_data_struct : public PluginTaskData_base { - P075_data_struct(int rx, int tx, uint32_t baud) : rxPin(rx), txPin(tx), baudrate(baud) { + P075_data_struct(ESPEasySerialPort port, int rx, int tx, uint32_t baud) : rxPin(rx), txPin(tx), baudrate(baud) { if (baudrate < 9600 || baudrate > 115200) { baudrate = 9600; } - easySerial = new (std::nothrow) ESPeasySerial(rx, tx, false, RXBUFFSZ); + easySerial = new (std::nothrow) ESPeasySerial(port, rx, tx, false, RXBUFFSZ); if (easySerial != nullptr) { easySerial->begin(baudrate); easySerial->flush(); @@ -235,7 +235,8 @@ boolean Plugin_075(byte function, struct EventStruct *event, String& string) if(BaudCode > P075_B115200) BaudCode = P075_B9600; const uint32_t BaudArray[4] = {9600UL, 38400UL, 57600UL, 115200UL}; - initPluginTaskData(event->TaskIndex, new (std::nothrow) P075_data_struct(CONFIG_PIN1, CONFIG_PIN2, BaudArray[BaudCode])); + const ESPEasySerialPort port = static_cast(CONFIG_PORT); + initPluginTaskData(event->TaskIndex, new (std::nothrow) P075_data_struct(port, CONFIG_PIN1, CONFIG_PIN2, BaudArray[BaudCode])); P075_data_struct* P075_data = static_cast(getPluginTaskData(event->TaskIndex)); if (nullptr != P075_data) { P075_data->loadDisplayLines(event->TaskIndex); diff --git a/src/_P078_Eastron.ino b/src/_P078_Eastron.ino index 1f85ab3d4..d24dfcc94 100644 --- a/src/_P078_Eastron.ino +++ b/src/_P078_Eastron.ino @@ -213,7 +213,7 @@ boolean Plugin_078(byte function, struct EventStruct *event, String& string) delete Plugin_078_SoftSerial; Plugin_078_SoftSerial=NULL; } - Plugin_078_SoftSerial = new (std::nothrow) ESPeasySerial(CONFIG_PIN1, CONFIG_PIN2); + Plugin_078_SoftSerial = new (std::nothrow) ESPeasySerial(CONFIG_PORT, CONFIG_PIN1, CONFIG_PIN2); if (Plugin_078_SoftSerial == nullptr) { break; } diff --git a/src/_P082_GPS.ino b/src/_P082_GPS.ino index aa9eb86da..569ee649d 100644 --- a/src/_P082_GPS.ino +++ b/src/_P082_GPS.ino @@ -84,13 +84,13 @@ struct P082_data_struct : public PluginTaskData_base { } } - bool init(const int16_t serial_rx, const int16_t serial_tx) { + bool init(ESPEasySerialPort port, const int16_t serial_rx, const int16_t serial_tx) { if (serial_rx < 0) { return false; } reset(); gps = new (std::nothrow) TinyGPSPlus(); - P082_easySerial = new (std::nothrow) ESPeasySerial(serial_rx, serial_tx); + P082_easySerial = new (std::nothrow) ESPeasySerial(port, serial_rx, serial_tx); if (P082_easySerial != nullptr) { P082_easySerial->begin(9600); } @@ -390,6 +390,7 @@ boolean Plugin_082(byte function, struct EventStruct *event, String& string) { if (P082_TIMEOUT < 100) { P082_TIMEOUT = P082_DEFAULT_FIX_TIMEOUT; } + const ESPEasySerialPort port = static_cast(CONFIG_PORT); const int16_t serial_rx = CONFIG_PIN1; const int16_t serial_tx = CONFIG_PIN2; const int16_t pps_pin = CONFIG_PIN3; @@ -401,9 +402,9 @@ boolean Plugin_082(byte function, struct EventStruct *event, String& string) { return success; } - if (P082_data->init(serial_rx, serial_tx)) { + if (P082_data->init(port, serial_rx, serial_tx)) { success = true; - serialHelper_log_GpioDescription(serial_rx, serial_tx); + serialHelper_log_GpioDescription(port, serial_rx, serial_tx); if (pps_pin != -1) { // pinMode(pps_pin, INPUT_PULLUP); diff --git a/src/_P085_AcuDC243.ino b/src/_P085_AcuDC243.ino index 9688b35bb..b876fd37a 100644 --- a/src/_P085_AcuDC243.ino +++ b/src/_P085_AcuDC243.ino @@ -70,9 +70,9 @@ struct P085_data_struct : public PluginTaskData_base { modbus.reset(); } - bool init(const int16_t serial_rx, const int16_t serial_tx, int8_t dere_pin, + bool init(ESPEasySerialPort port, const int16_t serial_rx, const int16_t serial_tx, int8_t dere_pin, unsigned int baudrate, uint8_t modbusAddress) { - return modbus.init(serial_rx, serial_tx, baudrate, modbusAddress, dere_pin); + return modbus.init(port, serial_rx, serial_tx, baudrate, modbusAddress, dere_pin); } bool isInitialized() const { @@ -321,6 +321,7 @@ boolean Plugin_085(byte function, struct EventStruct *event, String& string) { case PLUGIN_INIT: { const int16_t serial_rx = CONFIG_PIN1; const int16_t serial_tx = CONFIG_PIN2; + const ESPEasySerialPort port = static_cast(CONFIG_PORT); initPluginTaskData(event->TaskIndex, new (std::nothrow) P085_data_struct()); P085_data_struct *P085_data = static_cast(getPluginTaskData(event->TaskIndex)); @@ -329,10 +330,10 @@ boolean Plugin_085(byte function, struct EventStruct *event, String& string) { return success; } - if (P085_data->init(serial_rx, serial_tx, P085_DEPIN, + if (P085_data->init(port, serial_rx, serial_tx, P085_DEPIN, p085_storageValueToBaudrate(P085_BAUDRATE), P085_DEV_ID)) { - serialHelper_log_GpioDescription(serial_rx, serial_tx); + serialHelper_log_GpioDescription(port, serial_rx, serial_tx); success = true; } else { clearPluginTaskData(event->TaskIndex); diff --git a/src/_P087_SerialProxy.ino b/src/_P087_SerialProxy.ino index 295cf8945..012336260 100644 --- a/src/_P087_SerialProxy.ino +++ b/src/_P087_SerialProxy.ino @@ -167,6 +167,7 @@ boolean Plugin_087(byte function, struct EventStruct *event, String& string) { case PLUGIN_INIT: { const int16_t serial_rx = CONFIG_PIN1; const int16_t serial_tx = CONFIG_PIN2; + const ESPEasySerialPort port = static_cast(CONFIG_PORT); initPluginTaskData(event->TaskIndex, new (std::nothrow) P087_data_struct()); P087_data_struct *P087_data = static_cast(getPluginTaskData(event->TaskIndex)); @@ -175,11 +176,11 @@ boolean Plugin_087(byte function, struct EventStruct *event, String& string) { return success; } - if (P087_data->init(serial_rx, serial_tx, P087_BAUDRATE)) { + if (P087_data->init(port, serial_rx, serial_tx, P087_BAUDRATE)) { LoadCustomTaskSettings(event->TaskIndex, P087_data->_lines, P87_Nlines, 0); P087_data->post_init(); success = true; - serialHelper_log_GpioDescription(serial_rx, serial_tx); + serialHelper_log_GpioDescription(port, serial_rx, serial_tx); } else { clearPluginTaskData(event->TaskIndex); } diff --git a/src/_P093_MitsubishiHP.ino b/src/_P093_MitsubishiHP.ino index fc42cfc66..1a3671a39 100644 --- a/src/_P093_MitsubishiHP.ino +++ b/src/_P093_MitsubishiHP.ino @@ -33,8 +33,8 @@ static const uint8_t INFOMODE[] = { }; struct P093_data_struct : public PluginTaskData_base { - P093_data_struct(const int16_t serialRx, const int16_t serialTx) : - _serial(new (std::nothrow) ESPeasySerial(serialRx, serialTx)), + P093_data_struct(const ESPEasySerialPort port, const int16_t serialRx, const int16_t serialTx) : + _serial(new (std::nothrow) ESPeasySerial(port, serialRx, serialTx)), _state(NotConnected), _fastBaudRate(false), _readPos(0), @@ -739,7 +739,8 @@ boolean Plugin_093(byte function, struct EventStruct *event, String& string) { } case PLUGIN_INIT: { - initPluginTaskData(event->TaskIndex, new (std::nothrow) P093_data_struct(CONFIG_PIN1, CONFIG_PIN2)); + const ESPEasySerialPort port = static_cast(CONFIG_PORT); + initPluginTaskData(event->TaskIndex, new (std::nothrow) P093_data_struct(port, CONFIG_PIN1, CONFIG_PIN2)); success = getPluginTaskData(event->TaskIndex) != nullptr; break; } diff --git a/src/_P094_CULReader.ino b/src/_P094_CULReader.ino index 707fe3b39..4dd3b5349 100644 --- a/src/_P094_CULReader.ino +++ b/src/_P094_CULReader.ino @@ -169,6 +169,7 @@ boolean Plugin_094(byte function, struct EventStruct *event, String& string) { case PLUGIN_INIT: { const int16_t serial_rx = CONFIG_PIN1; const int16_t serial_tx = CONFIG_PIN2; + const ESPEasySerialPort port = static_cast(CONFIG_PORT); initPluginTaskData(event->TaskIndex, new (std::nothrow) P094_data_struct()); P094_data_struct *P094_data = static_cast(getPluginTaskData(event->TaskIndex)); @@ -177,12 +178,12 @@ boolean Plugin_094(byte function, struct EventStruct *event, String& string) { return success; } - if (P094_data->init(serial_rx, serial_tx, P094_BAUDRATE)) { + if (P094_data->init(port, serial_rx, serial_tx, P094_BAUDRATE)) { LoadCustomTaskSettings(event->TaskIndex, P094_data->_lines, P94_Nlines, 0); P094_data->post_init(); success = true; - serialHelper_log_GpioDescription(serial_rx, serial_tx); + serialHelper_log_GpioDescription(port, serial_rx, serial_tx); } else { clearPluginTaskData(event->TaskIndex); } diff --git a/src/_Plugin_Helper_serial.ino b/src/_Plugin_Helper_serial.ino index e9880ade0..cbc7d4981 100644 --- a/src/_Plugin_Helper_serial.ino +++ b/src/_Plugin_Helper_serial.ino @@ -2,15 +2,15 @@ struct ESPeasySerialType; -static String serialHelper_getSerialTypeLabel(ESPeasySerialType::serialtype serType) { +static String serialHelper_getSerialTypeLabel(ESPEasySerialPort serType) { int portnr = 0; switch (serType) { - case ESPeasySerialType::serialtype::software: return F("SoftwareSerial"); - case ESPeasySerialType::serialtype::sc16is752: return F("I2C Serial"); - case ESPeasySerialType::serialtype::serial0_swap: return F("HW Serial0 swap"); - case ESPeasySerialType::serialtype::serial0: portnr = 0; break; - case ESPeasySerialType::serialtype::serial1: portnr = 1; break; - case ESPeasySerialType::serialtype::serial2: portnr = 2; break; + case ESPEasySerialPort::software: return F("SoftwareSerial"); + case ESPEasySerialPort::sc16is752: return F("I2C Serial"); + case ESPEasySerialPort::serial0_swap: return F("HW Serial0 swap"); + case ESPEasySerialPort::serial0: portnr = 0; break; + case ESPEasySerialPort::serial1: portnr = 1; break; + case ESPEasySerialPort::serial2: portnr = 2; break; default: return ""; } @@ -19,19 +19,19 @@ static String serialHelper_getSerialTypeLabel(ESPeasySerialType::serialtype serT return label; } -void serialHelper_log_GpioDescription(int config_pin1, int config_pin2) { +void serialHelper_log_GpioDescription(ESPEasySerialPort typeHint, int config_pin1, int config_pin2) { if (loglevelActiveFor(LOG_LEVEL_DEBUG)) { String log = F("Serial : "); - log += serialHelper_getGpioDescription(config_pin1, config_pin2, " "); + log += serialHelper_getGpioDescription(typeHint, config_pin1, config_pin2, " "); addLog(LOG_LEVEL_DEBUG, log); } } -static String serialHelper_getGpioDescription(int config_pin1, int config_pin2, const String& newline) { +static String serialHelper_getGpioDescription(ESPEasySerialPort typeHint, int config_pin1, int config_pin2, const String& newline) { String result; result.reserve(20); - switch (ESPeasySerialType::getSerialType(config_pin1, config_pin2)) { - case ESPeasySerialType::serialtype::sc16is752: + switch (ESPeasySerialType::getSerialType(typeHint, config_pin1, config_pin2)) { + case ESPEasySerialPort::sc16is752: { result += formatToHex(config_pin1); result += newline; @@ -39,11 +39,11 @@ static String serialHelper_getGpioDescription(int config_pin1, int config_pin2, result += config_pin2 == 0 ? F("A") : F("B"); return result; } - case ESPeasySerialType::serialtype::software: - case ESPeasySerialType::serialtype::serial0_swap: - case ESPeasySerialType::serialtype::serial0: - case ESPeasySerialType::serialtype::serial1: - case ESPeasySerialType::serialtype::serial2: + case ESPEasySerialPort::software: + case ESPEasySerialPort::serial0_swap: + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial1: + case ESPEasySerialPort::serial2: { result += F("RX: "); result += formatGpioLabel(config_pin1, false); @@ -71,8 +71,14 @@ int8_t serialHelper_getTxPin(struct EventStruct *event) { return CONFIG_PIN2; } -ESPeasySerialType::serialtype serialHelper_getSerialType(struct EventStruct *event) { +ESPEasySerialPort serialHelper_getSerialType(struct EventStruct *event) { + ESPEasySerialPort serialType = static_cast(CONFIG_PORT); + if (serialType != ESPEasySerialPort::not_set) { + return serialType; + } + return ESPeasySerialType::getSerialType( + serialType, serialHelper_getRxPin(event), serialHelper_getTxPin(event)); } @@ -131,16 +137,26 @@ void serialHelper_webformLoad(struct EventStruct *event) { // See issue #2343 and Pull request https://github.com/letscontrolit/ESPEasy/pull/2352 // For now P020 and P044 have been reverted to make them work again. void serialHelper_webformLoad(struct EventStruct *event, bool allowSoftwareSerial) { - serialHelper_webformLoad(serialHelper_getRxPin(event), serialHelper_getTxPin(event), allowSoftwareSerial); + + serialHelper_webformLoad(static_cast(CONFIG_PORT), serialHelper_getRxPin(event), serialHelper_getTxPin(event), allowSoftwareSerial); } -void serialHelper_webformLoad(int rxPinDef, int txPinDef, bool allowSoftwareSerial) { +void serialHelper_webformLoad(ESPEasySerialPort port, int rxPinDef, int txPinDef, bool allowSoftwareSerial) { // Field for I2C addr & RX are shared // Field for channel and TX are shared serialHelper_addI2CuartSelectors(rxPinDef, txPinDef); + #ifdef ESP8266 + // Script to show GPIO pins for SoftwareSerial or I2C addresses for the I2C to UART bridge html_add_script(F( - "function serialPortChanged(elem) {var style = elem.value == 0 ? '' : 'none';var i2cstyle = elem.value == 1 ? '' : 'none';document.getElementById('tr_taskdevicepin1').style.display = style;document.getElementById('tr_taskdevicepin2').style.display = style;document.getElementById('tr_i2cuart_addr').style.display = i2cstyle;document.getElementById('tr_i2cuart_ch').style.display = i2cstyle;}"), + "function serialPortChanged(elem) {var style = elem.value == 6 ? '' : 'none';var i2cstyle = elem.value == 1 ? '' : 'none';document.getElementById('tr_taskdevicepin1').style.display = style;document.getElementById('tr_taskdevicepin2').style.display = style;document.getElementById('tr_i2cuart_addr').style.display = i2cstyle;document.getElementById('tr_i2cuart_ch').style.display = i2cstyle;}"), false); + #endif + #ifdef ESP32 + // Script to show GPIO pins for HW serial ports or I2C addresses for the I2C to UART bridge + html_add_script(F( + "function serialPortChanged(elem) {var style = (elem.value == 2 || elem.value == 4 || elem.value == 5) ? '' : 'none';var i2cstyle = elem.value == 1 ? '' : 'none';document.getElementById('tr_taskdevicepin1').style.display = style;document.getElementById('tr_taskdevicepin2').style.display = style;document.getElementById('tr_i2cuart_addr').style.display = i2cstyle;document.getElementById('tr_i2cuart_ch').style.display = i2cstyle;}"), + false); + #endif String options[NR_ESPEASY_SERIAL_TYPES]; int ids[NR_ESPEASY_SERIAL_TYPES]; @@ -148,9 +164,9 @@ void serialHelper_webformLoad(int rxPinDef, int txPinDef, bool allowSoftwareSeri int index = 0; - for (int i = 0; (index < NR_ESPEASY_SERIAL_TYPES) && (i < ESPeasySerialType::serialtype::MAX_SERIAL_TYPE); ++i) { + for (int i = 0; (index < NR_ESPEASY_SERIAL_TYPES) && (i < static_cast(ESPEasySerialPort::MAX_SERIAL_TYPE)); ++i) { int rxPin, txPin; - ESPeasySerialType::serialtype serType = static_cast(i); + ESPEasySerialPort serType = static_cast(i); if (ESPeasySerialType::getSerialTypePins(serType, rxPin, txPin)) { String option; @@ -158,19 +174,24 @@ void serialHelper_webformLoad(int rxPinDef, int txPinDef, bool allowSoftwareSeri option = serialHelper_getSerialTypeLabel(serType); switch (serType) { - case ESPeasySerialType::serialtype::software: + case ESPEasySerialPort::software: { if (!allowSoftwareSerial) { attr[index] = F("disabled"); } break; } - case ESPeasySerialType::serialtype::sc16is752: + case ESPEasySerialPort::sc16is752: { break; } - default: + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: + case ESPEasySerialPort::serial1: + case ESPEasySerialPort::serial2: { + #ifdef ESP8266 + // Show pins for ports with fixed pins option += ": "; option += formatGpioLabel(rxPin, false); option += ' '; @@ -180,8 +201,13 @@ void serialHelper_webformLoad(int rxPinDef, int txPinDef, bool allowSoftwareSeri option += ' '; option += formatGpioDirection(gpio_output); option += "RX"; + #endif break; } + + default: + break; + } options[index] = option; ids[index] = i; @@ -190,7 +216,7 @@ void serialHelper_webformLoad(int rxPinDef, int txPinDef, bool allowSoftwareSeri } addFormSelector_script(F("Serial Port"), F("serPort"), NR_ESPEASY_SERIAL_TYPES, options, ids, NULL, - static_cast(ESPeasySerialType::getSerialType(rxPinDef, txPinDef)), + static_cast(ESPeasySerialType::getSerialType(port, rxPinDef, txPinDef)), F("serialPortChanged(this)")); // Script to toggle GPIO visibility when changing selection. html_add_script(F("document.getElementById('serPort').onchange();"), false); @@ -203,42 +229,51 @@ void serialHelper_webformLoad(int rxPinDef, int txPinDef, bool allowSoftwareSeri } } -void serialHelper_webformSave(int8_t &rxPin, int8_t &txPin) { +void serialHelper_webformSave(byte& port, int8_t &rxPin, int8_t &txPin) { int serialPortSelected = getFormItemInt(F("serPort"), -1); if (serialPortSelected < 0) return; - ESPeasySerialType::serialtype serType = static_cast(serialPortSelected); + ESPEasySerialPort serType = static_cast(serialPortSelected); + port = serialPortSelected; switch (serType) { - case ESPeasySerialType::serialtype::software: + case ESPEasySerialPort::software: break; - case ESPeasySerialType::serialtype::sc16is752: + case ESPEasySerialPort::sc16is752: rxPin = getFormItemInt(F("i2cuart_addr"), rxPin); txPin = getFormItemInt(F("i2cuart_ch"), txPin); break; - default: + case ESPEasySerialPort::serial0: + case ESPEasySerialPort::serial0_swap: + case ESPEasySerialPort::serial1: + case ESPEasySerialPort::serial2: { + #ifdef ESP8266 + // Ports with a fixed pin layout, so load the defaults. int tmprxPin, tmptxPin; if (ESPeasySerialType::getSerialTypePins(serType, tmprxPin, tmptxPin)) { rxPin = tmprxPin; txPin = tmptxPin; } + #endif break; } + default: + break; } } void serialHelper_webformSave(struct EventStruct *event) { - serialHelper_webformSave(CONFIG_PIN1, CONFIG_PIN2); + serialHelper_webformSave(CONFIG_PORT, CONFIG_PIN1, CONFIG_PIN2); } void serialHelper_plugin_init(struct EventStruct *event) { - ESPeasySerialType::serialtype serType = serialHelper_getSerialType(event); + ESPEasySerialPort serType = serialHelper_getSerialType(event); - if (serType == ESPeasySerialType::serialtype::serial0) { + if (serType == ESPEasySerialPort::serial0) { Settings.UseSerial = false; // Disable global Serial port. } #ifdef ESP8266 - if (serType == ESPeasySerialType::serialtype::serial0_swap) { + if (serType == ESPEasySerialPort::serial0_swap) { Settings.UseSerial = false; // Disable global Serial port. } #endif diff --git a/src/src/DataStructs/SettingsStruct.cpp b/src/src/DataStructs/SettingsStruct.cpp index 07b32b895..fa33452ad 100644 --- a/src/src/DataStructs/SettingsStruct.cpp +++ b/src/src/DataStructs/SettingsStruct.cpp @@ -321,7 +321,7 @@ void SettingsStruct_tmpl::clearTask(taskIndex_t task) { TaskDevicePluginConfigLong[task][cv] = 0; } OLD_TaskDeviceSendData[task] = false; - TaskDeviceGlobalSync[task] = false; + OLD_TaskDeviceGlobalSync[task] = false; TaskDeviceDataFeed[task] = 0; TaskDeviceTimer[task] = 0; TaskDeviceEnabled[task] = false; diff --git a/src/src/DataStructs/SettingsStruct.h b/src/src/DataStructs/SettingsStruct.h index 14a2bda04..6ab4dbc21 100644 --- a/src/src/DataStructs/SettingsStruct.h +++ b/src/src/DataStructs/SettingsStruct.h @@ -178,8 +178,8 @@ class SettingsStruct_tmpl boolean TaskDevicePin1Inversed[N_TASKS]; float TaskDevicePluginConfigFloat[N_TASKS][PLUGIN_CONFIGFLOATVAR_MAX]; long TaskDevicePluginConfigLong[N_TASKS][PLUGIN_CONFIGLONGVAR_MAX]; - boolean OLD_TaskDeviceSendData[N_TASKS]; - boolean TaskDeviceGlobalSync[N_TASKS]; + byte OLD_TaskDeviceSendData[N_TASKS]; + byte OLD_TaskDeviceGlobalSync[N_TASKS]; byte TaskDeviceDataFeed[N_TASKS]; // When set to 0, only read local connected sensorsfeeds unsigned long TaskDeviceTimer[N_TASKS]; boolean TaskDeviceEnabled[N_TASKS]; diff --git a/src/src/Helpers/Modbus_RTU.cpp b/src/src/Helpers/Modbus_RTU.cpp index 1e3431e8d..a187d519d 100644 --- a/src/src/Helpers/Modbus_RTU.cpp +++ b/src/src/Helpers/Modbus_RTU.cpp @@ -35,16 +35,16 @@ void ModbusRTU_struct::reset() { _reads_nodata = 0; } -bool ModbusRTU_struct::init(const int16_t serial_rx, const int16_t serial_tx, int16_t baudrate, byte address) { - return init(serial_rx, serial_tx, baudrate, address, -1); +bool ModbusRTU_struct::init(const ESPEasySerialPort port, const int16_t serial_rx, const int16_t serial_tx, int16_t baudrate, byte address) { + return init(port, serial_rx, serial_tx, baudrate, address, -1); } -bool ModbusRTU_struct::init(const int16_t serial_rx, const int16_t serial_tx, int16_t baudrate, byte address, int8_t dere_pin) { +bool ModbusRTU_struct::init(const ESPEasySerialPort port, const int16_t serial_rx, const int16_t serial_tx, int16_t baudrate, byte address, int8_t dere_pin) { if ((serial_rx < 0) || (serial_tx < 0)) { return false; } reset(); - easySerial = new (std::nothrow) ESPeasySerial(serial_rx, serial_tx); + easySerial = new (std::nothrow) ESPeasySerial(port, serial_rx, serial_tx); if (easySerial == nullptr) { return false; } easySerial->begin(baudrate); diff --git a/src/src/Helpers/Modbus_RTU.h b/src/src/Helpers/Modbus_RTU.h index a84ac167e..ab04cc10f 100644 --- a/src/src/Helpers/Modbus_RTU.h +++ b/src/src/Helpers/Modbus_RTU.h @@ -50,12 +50,14 @@ struct ModbusRTU_struct { void reset(); - bool init(const int16_t serial_rx, + bool init(const ESPEasySerialPort port, + const int16_t serial_rx, const int16_t serial_tx, int16_t baudrate, byte address); - bool init(const int16_t serial_rx, + bool init(const ESPEasySerialPort port, + const int16_t serial_rx, const int16_t serial_tx, int16_t baudrate, byte address, diff --git a/src/src/PluginStructs/P044_data_struct.cpp b/src/src/PluginStructs/P044_data_struct.cpp index 8d492f417..ae668547f 100644 --- a/src/src/PluginStructs/P044_data_struct.cpp +++ b/src/src/PluginStructs/P044_data_struct.cpp @@ -203,12 +203,12 @@ bool P044_Task::validP1char(char ch) { return false; } -void P044_Task::serialBegin(int16_t rxPin, int16_t txPin, +void P044_Task::serialBegin(const ESPEasySerialPort port, int16_t rxPin, int16_t txPin, unsigned long baud, byte config) { serialEnd(); if (rxPin >= 0) { - P1EasySerial = new (std::nothrow) ESPeasySerial(rxPin, txPin); + P1EasySerial = new (std::nothrow) ESPeasySerial(port, rxPin, txPin); if (nullptr != P1EasySerial) { #if defined(ESP8266) diff --git a/src/src/PluginStructs/P044_data_struct.h b/src/src/PluginStructs/P044_data_struct.h index 8f5f0df22..13b845a9c 100644 --- a/src/src/PluginStructs/P044_data_struct.h +++ b/src/src/PluginStructs/P044_data_struct.h @@ -70,7 +70,8 @@ struct P044_Task : public PluginTaskData_base { */ static bool validP1char(char ch); - void serialBegin(int16_t rxPin, + void serialBegin(const ESPEasySerialPort port, + int16_t rxPin, int16_t txPin, unsigned long baud, byte config); diff --git a/src/src/PluginStructs/P087_data_struct.cpp b/src/src/PluginStructs/P087_data_struct.cpp index 2b101b3bd..c2b8a3ac0 100644 --- a/src/src/PluginStructs/P087_data_struct.cpp +++ b/src/src/PluginStructs/P087_data_struct.cpp @@ -17,12 +17,12 @@ void P087_data_struct::reset() { } } -bool P087_data_struct::init(const int16_t serial_rx, const int16_t serial_tx, unsigned long baudrate) { +bool P087_data_struct::init(ESPEasySerialPort port, const int16_t serial_rx, const int16_t serial_tx, unsigned long baudrate) { if ((serial_rx < 0) && (serial_tx < 0)) { return false; } reset(); - easySerial = new (std::nothrow) ESPeasySerial(serial_rx, serial_tx); + easySerial = new (std::nothrow) ESPeasySerial(port, serial_rx, serial_tx); if (isInitialized()) { easySerial->begin(baudrate); diff --git a/src/src/PluginStructs/P087_data_struct.h b/src/src/PluginStructs/P087_data_struct.h index d0e6cf44c..81620785e 100644 --- a/src/src/PluginStructs/P087_data_struct.h +++ b/src/src/PluginStructs/P087_data_struct.h @@ -46,7 +46,8 @@ public: void reset(); - bool init(const int16_t serial_rx, + bool init(ESPEasySerialPort port, + const int16_t serial_rx, const int16_t serial_tx, unsigned long baudrate); diff --git a/src/src/PluginStructs/P094_data_struct.cpp b/src/src/PluginStructs/P094_data_struct.cpp index 626eaab5f..982a51eca 100644 --- a/src/src/PluginStructs/P094_data_struct.cpp +++ b/src/src/PluginStructs/P094_data_struct.cpp @@ -18,12 +18,15 @@ void P094_data_struct::reset() { } } -bool P094_data_struct::init(const int16_t serial_rx, const int16_t serial_tx, unsigned long baudrate) { +bool P094_data_struct::init(ESPEasySerialPort port, + const int16_t serial_rx, + const int16_t serial_tx, + unsigned long baudrate) { if ((serial_rx < 0) && (serial_tx < 0)) { return false; } reset(); - easySerial = new (std::nothrow) ESPeasySerial(serial_rx, serial_tx); + easySerial = new (std::nothrow) ESPeasySerial(port, serial_rx, serial_tx); if (isInitialized()) { easySerial->begin(baudrate); diff --git a/src/src/PluginStructs/P094_data_struct.h b/src/src/PluginStructs/P094_data_struct.h index 36107c383..ce86f05c8 100644 --- a/src/src/PluginStructs/P094_data_struct.h +++ b/src/src/PluginStructs/P094_data_struct.h @@ -63,7 +63,8 @@ public: void reset(); - bool init(const int16_t serial_rx, + bool init(ESPEasySerialPort port, + const int16_t serial_rx, const int16_t serial_tx, unsigned long baudrate);