diff --git a/ESP32README.md b/ESP32README.md new file mode 100644 index 000000000..1cb4e3c42 --- /dev/null +++ b/ESP32README.md @@ -0,0 +1,46 @@ +![Tasmota logo](/tools/logo/TASMOTA_FullLogo_Vector.svg) + +## ESP32 port with minimal changes +## Description: +This is my esp32 port, i try to make only minimal changes to the original source code +from Theo Arends, now again for development branch. + +## Checklist: + - [x] The pull request is done against the latest dev branch + - [x] Only relevant files were touched + - [x] Only one feature/fix was added per PR. + - [x] The code change is tested and works on core Tasmota_core_stage + - [ ] The code change pass travis tests. **Your PR cannot be merged unless tests pass** + - [x] I accept the [CLA](https://github.com/arendst/Tasmota/blob/development/CONTRIBUTING.md#contributor-license-agreement-cla). + - [x] i checked binary "tasmota.bin" to be the same in development and development_esp32 branch + +Here are the main things i have done + +- in "lib_extra_dirs" i have libesp32 directory for things missing in ESP32 framework + my "ESP32-to-ESP8266-compat" has all files that are not available in ESP32 + so you dont have to change the source code and i write code to get the informations from ESP32 +- all librarys that are not compatibel i add to lib_ignore +- all code that is not for ESP32 i put in "#ifdef ESP8266" the define is from espessif platform +- all code for ESP32 is in "#ifdef ESP32" +- SerConfu8 type uint8_t for SerialConfig list +- changed "HTTP_HEADER" to "HTTP_HEADER1", in ESP32 its an enum +- for ip adress 0 i used IPAddress(0,0,0,0) +- Special ESP.xxx call i change to ESP_xxx (ESP_rtcUserMemoryWrite, ...) and write macros for ESP8266 +- because ESP32 has only WEMOS 32 modul, i exclude all code like this: + "if (SONOFF_xxx == Settings.module)" in "#ifdef ESP8266" +- variable "sleep" i changed to "ssleep" because of standard library sleep(..) function +- all esp32 stuff is in support_esp32.ino +- in tasmota.ino i include "tasmota_compat.h" +- in tasmota_template.h i use ifdef and tasmota_templESP32.h +- defines for sensors that currently don't work, i undef in tasmota_templESP32.h +- comment fo "no warnig" in "xdrv_20_hue.ino" thats the only warning i had + +Build info + +Copy platformio_override_esp32.ini to platformio_override.ini an select your imagetype. +You can build tasmota and tasmota32 Version with one build. +If you need other versions change platformio_override.ini + +stay at home, have fun and keep good + +Jörg \ No newline at end of file diff --git a/lib/FrogmoreScd30/FrogmoreScd30.cpp b/lib/FrogmoreScd30/FrogmoreScd30.cpp index 32bbee5ba..142f33c39 100644 --- a/lib/FrogmoreScd30/FrogmoreScd30.cpp +++ b/lib/FrogmoreScd30/FrogmoreScd30.cpp @@ -24,6 +24,8 @@ SOFTWARE. #include #include +#ifdef ESP8266 + #define COMMAND_SCD30_CONTINUOUS_MEASUREMENT 0x0010 #define COMMAND_SCD30_MEASUREMENT_INTERVAL 0x4600 #define COMMAND_SCD30_GET_DATA_READY 0x0202 @@ -253,7 +255,7 @@ int FrogmoreScd30::get16BitRegCheckCRC(void* pInput, uint16_t *pData) } // gets 32 bits, (2) 16-bit chunks, and validates the CRCs -// +// int FrogmoreScd30::get32BitRegCheckCRC(void *pInput, float *pData) { uint16_t tempU16High; @@ -458,7 +460,7 @@ int FrogmoreScd30::setTemperatureOffset(float offset_degC) { return (ERROR_SCD30_INVALID_VALUE); } - + } int FrogmoreScd30::setTemperatureOffset(uint16_t offset_centiDegC) @@ -568,7 +570,7 @@ int FrogmoreScd30::readMeasurement( return (error); } - error = get32BitRegCheckCRC(&bytes[12], &tempHumidity); + error = get32BitRegCheckCRC(&bytes[12], &tempHumidity); if (error) { #ifdef SCD30_DEBUG @@ -651,3 +653,4 @@ int FrogmoreScd30::stopMeasuring(void) return (sendCommand(COMMAND_SCD30_STOP_MEASUREMENT)); } +#endif // ESP8266 diff --git a/lib/TasmotaSerial-2.4.1/src/TasmotaSerial.cpp b/lib/TasmotaSerial-2.4.1/src/TasmotaSerial.cpp index 1fad7c0f5..212992775 100644 --- a/lib/TasmotaSerial-2.4.1/src/TasmotaSerial.cpp +++ b/lib/TasmotaSerial-2.4.1/src/TasmotaSerial.cpp @@ -150,9 +150,11 @@ bool TasmotaSerial::begin(long speed, int stop_bits) { } else { Serial.begin(speed, SERIAL_8N1); } +#ifdef ESP8266 if (m_hardswap) { Serial.swap(); } +#endif // ESP8266 } else { // Use getCycleCount() loop to get as exact timing as possible m_bit_time = ESP.getCpuFreqMHz() * 1000000 / speed; diff --git a/lib/bearssl-esp8266/src/t_inner.h b/lib/bearssl-esp8266/src/t_inner.h index a7267f0df..8dca0c09b 100644 --- a/lib/bearssl-esp8266/src/t_inner.h +++ b/lib/bearssl-esp8266/src/t_inner.h @@ -2584,6 +2584,9 @@ br_cpuid(uint32_t mask_eax, uint32_t mask_ebx, #define optimistic_yield(ignored) #endif +#ifdef ESP32 +#define memcpy_P memcpy +#endif /* ==================================================================== */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.h index 99459b198..3fc8ea190 100644 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.h +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.h @@ -68,8 +68,8 @@ public: int16_t width; int16_t height; - Epd(); - ~Epd(); +// Epd(); +// ~Epd(); int Init(const unsigned char* lut); void Init(int8_t p); void SendCommand(unsigned char command); diff --git a/libesp32/ESP32-to-ESP8266-compat/README.adoc b/libesp32/ESP32-to-ESP8266-compat/README.adoc new file mode 100644 index 000000000..abf17a277 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/README.adoc @@ -0,0 +1,19 @@ +Library for ESP32 with Tasmota + +This Class is for compatibility with esp8266 code + +== License == + +This library 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 library 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 library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA diff --git a/libesp32/ESP32-to-ESP8266-compat/keywords.txt b/libesp32/ESP32-to-ESP8266-compat/keywords.txt new file mode 100644 index 000000000..3422d1305 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/keywords.txt @@ -0,0 +1,24 @@ +####################################### +# Syntax Coloring Map For Test +####################################### + +####################################### +# Datatypes (KEYWORD1) +####################################### + +A4988_ESP32Compat KEYWORD1 A4988_ESP32Compat + +####################################### +# Methods and Functions (KEYWORD2) +####################################### + +doMove KEYWORD2 +doRotate KEYWORD2 +setRPM KEYWORD2 +setSPR KEYWORD2 +setMIS KEYWORD2 +version KEYWORD2 + +####################################### +# Constants (LITERAL1) +####################################### diff --git a/libesp32/ESP32-to-ESP8266-compat/library.properties b/libesp32/ESP32-to-ESP8266-compat/library.properties new file mode 100644 index 000000000..5d5e39166 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/library.properties @@ -0,0 +1,9 @@ +name=ESP32-to-ESP8266-compat +version=0.0.2 +author=Jörg Schüler-Maroldt +maintainer=Jörg Schüler-Maroldt +sentence=Allows Tasmota to compile for esp32 +paragraph=Allows Tasmota to compile for esp32 +category=ESP32 +url= +architectures=* diff --git a/libesp32/ESP32-to-ESP8266-compat/src/AddrList.h b/libesp32/ESP32-to-ESP8266-compat/src/AddrList.h new file mode 100644 index 000000000..cc32ea232 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/AddrList.h @@ -0,0 +1,233 @@ +/* + AddrList.h - cycle through lwIP netif's ip addresses like a c++ list + Copyright (c) 2018 david gauchard. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/* + This class allows to explore all configured IP addresses + in lwIP netifs, with that kind of c++ loop: + + for (auto a: addrList) + out.printf("IF='%s' index=%d legacy=%d IPv4=%d local=%d hostname='%s' addr= %s\n", + a.iface().c_str(), + a.ifnumber(), + a.addr().isLegacy(), + a.addr().isV4(), + a.addr().isLocal(), + a.hostname().c_str(), + a.addr().toString().c_str()); + + This loop: + + while (WiFi.status() != WL_CONNECTED()) { + Serial.print('.'); + delay(500); + } + + can be replaced by: + + for (bool configured = false; !configured; ) { + for (auto iface: addrList) + if ((configured = !iface.addr().isLocal()) + break; + Serial.print('.'); + delay(500); + } + + waiting for an IPv6 global address: + + for (bool configured = false; !configured; ) { + for (auto iface: addrList) + if ((configured = ( !iface.addr().isV4() + && !iface.addr().isLocal()))) + break; + Serial.print('.'); + delay(500); + } + + waiting for an IPv6 global address, on a specific interface: + + for (bool configured = false; !configured; ) { + for (auto iface: addrList) + if ((configured = ( !iface.addr().isV4() + && !iface.addr().isLocal() + && iface.ifnumber() == STATION_IF))) + break; + Serial.print('.'); + delay(500); + } +*/ + +#ifndef __ADDRLIST_H +#define __ADDRLIST_H + +#include +#include + +#if LWIP_IPV6 +#define IF_NUM_ADDRESSES (1 + LWIP_IPV6_NUM_ADDRESSES) +#else +#define IF_NUM_ADDRESSES (1) +#endif + + +namespace esp8266 +{ + +namespace AddressListImplementation +{ + + +struct netifWrapper +{ + netifWrapper (netif* netif) : _netif(netif), _num(-1) {} + netifWrapper (const netifWrapper& o) : _netif(o._netif), _num(o._num) {} + + netifWrapper& operator= (const netifWrapper& o) + { + _netif = o._netif; + _num = o._num; + return *this; + } + + bool equal(const netifWrapper& o) + { + return _netif == o._netif && (!_netif || _num == o._num); + } + + // address properties + class IPAddress4 : public IPAddress + { + public: + bool isV6() const + { + return false; + } + bool isLocal() const + { + return false; + } + }; + IPAddress4 addr () const { return ipFromNetifNum(); } + bool isLegacy () const { return _num == 0; } + //bool isLocal () const { return addr().isLocal(); } + bool isV4 () const { return addr().isV4(); } + bool isV6 () const { return !addr().isV4(); } + String toString() const { return addr().toString(); } + + // related to legacy address (_num=0, ipv4) + IPAddress ipv4 () const { return _netif->ip_addr; } + IPAddress netmask () const { return _netif->netmask; } + IPAddress gw () const { return _netif->gw; } + + // common to all addresses of this interface + String ifname () const { return String(_netif->name[0]) + _netif->name[1]; } + const char* ifhostname () const { return _netif->hostname?: emptyString.c_str(); } + const char* ifmac () const { return (const char*)_netif->hwaddr; } + int ifnumber () const { return _netif->num; } + bool ifUp () const { return !!(_netif->flags & NETIF_FLAG_UP); } + const netif* interface () const { return _netif; } + + const ip_addr_t* ipFromNetifNum () const + { +#if LWIP_IPV6 + return _num ? &_netif->ip6_addr[_num - 1] : &_netif->ip_addr; +#else + return &_netif->ip_addr; +#endif + } + + // lwIP interface + netif* _netif; + + // address index within interface + // 0: legacy address (IPv4) + // n>0: (_num-1) is IPv6 index for netif->ip6_addr[] + int _num; +}; + + +class AddressListIterator +{ +public: + AddressListIterator (const netifWrapper& o) : netIf(o) {} + AddressListIterator (netif* netif) : netIf(netif) + { + // This constructor is called with lwIP's global netif_list, or + // nullptr. operator++() is designed to loop through _configured_ + // addresses. That's why netIf's _num is initialized to -1 to allow + // returning the first usable address to AddressList::begin(). + (void)operator++(); + } + + const netifWrapper& operator* () const { return netIf; } + const netifWrapper* operator-> () const { return &netIf; } + + bool operator== (AddressListIterator& o) { return netIf.equal(*o); } + bool operator!= (AddressListIterator& o) { return !netIf.equal(*o); } + + AddressListIterator operator++ (int) + { + AddressListIterator ret = *this; + (void)operator++(); + return ret; + } + + AddressListIterator& operator++ () + { + while (netIf._netif) + { + if (++netIf._num == IF_NUM_ADDRESSES) + { + // all addresses from current interface were iterated, + // switching to next interface + netIf = netifWrapper(netIf._netif->next); + continue; + } + if (!ip_addr_isany(netIf.ipFromNetifNum())) + // found an initialized address + break; + } + return *this; + } + + netifWrapper netIf; +}; + + +class AddressList +{ +public: + using const_iterator = const AddressListIterator; + + const_iterator begin () const { return const_iterator(netif_list); } + const_iterator end () const { return const_iterator(nullptr); } + +}; + +inline AddressList::const_iterator begin (const AddressList& a) { return a.begin(); } +inline AddressList::const_iterator end (const AddressList& a) { return a.end(); } + + +} // AddressListImplementation + +} // esp8266 + +extern AddressList addrList; + + +#endif diff --git a/libesp32/ESP32-to-ESP8266-compat/src/ESP32Wifi.cpp b/libesp32/ESP32-to-ESP8266-compat/src/ESP32Wifi.cpp new file mode 100644 index 000000000..9ce191cde --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/ESP32Wifi.cpp @@ -0,0 +1,93 @@ +/* + WiFi compat with ESP32 + + Copyright (C) 2020 Theo Arends / Jörg Schüler-Maroldt + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +// +#include "Arduino.h" +#include + +// +// Wifi +// +#ifdef WiFi +#undef WiFi +#endif + +void WiFiClass32::setSleepMode(int iSleepMode) +{ + // WIFI_MODEM_SLEEP + WiFi.setSleep(iSleepMode != WIFI_MODEM_SLEEP); +} + +int WiFiClass32::getPhyMode() +{ + return 0; // " BGN" +} + +void WiFiClass32::wps_disable() +{ +} + +void WiFiClass32::setOutputPower(int n) +{ + wifi_power_t p = WIFI_POWER_2dBm; + if (n > 19) + p = WIFI_POWER_19_5dBm; + else if (n > 18) + p = WIFI_POWER_18_5dBm; + else if (n >= 17) + p = WIFI_POWER_17dBm; + else if (n >= 15) + p = WIFI_POWER_15dBm; + else if (n >= 13) + p = WIFI_POWER_13dBm; + else if (n >= 11) + p = WIFI_POWER_11dBm; + else if (n >= 8) + p = WIFI_POWER_8_5dBm; + else if (n >= 7) + p = WIFI_POWER_7dBm; + else if (n >= 5) + p = WIFI_POWER_5dBm; + WiFi.setTxPower(p); +} + +void WiFiClass32::forceSleepBegin() +{ +} + +void WiFiClass32::forceSleepWake() +{ +} + +bool WiFiClass32::getNetworkInfo(uint8_t i, String &ssid, uint8_t &encType, int32_t &rssi, uint8_t *&bssid, int32_t &channel, bool &hidden_scan) +{ + hidden_scan = false; + return WiFi.getNetworkInfo(i, ssid, encType, rssi, bssid, channel); +} + +void wifi_station_disconnect() +{ + // erase ap: empty ssid, ... + WiFi.disconnect(true, true); +} + +void wifi_station_dhcpc_start() +{ +} + +WiFiClass32 WiFi32; diff --git a/libesp32/ESP32-to-ESP8266-compat/src/ESP8266HTTPClient.h b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266HTTPClient.h new file mode 100644 index 000000000..178911e3c --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266HTTPClient.h @@ -0,0 +1,5 @@ +// +// Compat with ESP32 +// +#include + diff --git a/libesp32/ESP32-to-ESP8266-compat/src/ESP8266WebServer.h b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266WebServer.h new file mode 100644 index 000000000..f00be7b64 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266WebServer.h @@ -0,0 +1,19 @@ +// +// Compat with ESP32 +// +#pragma once +#include + +//#define ESP8266WebServer WebServer + + +class ESP8266WebServer : public WebServer +{ +public: + ESP8266WebServer(int port) + :WebServer(port) + { + } +}; + +//#define ENC_TYPE_AUTO 0 diff --git a/libesp32/ESP32-to-ESP8266-compat/src/ESP8266WiFi.h b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266WiFi.h new file mode 100644 index 000000000..09d404e72 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266WiFi.h @@ -0,0 +1,85 @@ +/* + WiFi compat with ESP32 + + Copyright (C) 2020 Theo Arends / Jörg Schüler-Maroldt + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#pragma once +#include + +// sorry, no +#undef LWIP_IPV6 + +#define ENC_TYPE_NONE WIFI_AUTH_OPEN +#define ENC_TYPE_WEP WIFI_AUTH_WEP +#define ENC_TYPE_CCMP WIFI_AUTH_WPA2_PSK +#define ENC_TYPE_TKIP WIFI_AUTH_WPA_WPA2_PSK +#define ENC_TYPE_AUTO WIFI_AUTH_MAX + 1 + +#define WIFI_LIGHT_SLEEP 1 +#define WIFI_MODEM_SLEEP 2 + +class WiFiClass32 : public WiFiClass +{ +public: + static void hostname(const char* aHostname) + { + WiFi.setHostname(aHostname); + } + static void setSleepMode(int iSleepMode); + static int getPhyMode(); + + static void wps_disable(); + static void setOutputPower(int n); + static void forceSleepBegin(); + static void forceSleepWake(); + static bool getNetworkInfo(uint8_t i, String &ssid, uint8_t &encType, int32_t &rssi, uint8_t* &bssid, int32_t &channel, bool &hidden_scan); +}; + +void wifi_station_disconnect(); +void wifi_station_dhcpc_start(); +extern WiFiClass32 WiFi32; +#define WiFi WiFi32 + +class WiFiUDP32 : public WiFiUDP +{ + public: + size_t write(const char*s) + { + return WiFiUDP::write((const uint8_t *)s, strlen(s)); + } + size_t write(const uint8_t *buf, size_t n) + { + return WiFiUDP::write(buf, n); + } + static void stopAll() + { + + } + static void forceSleepWake() + { + + } + uint8_t beginMulticast(IPAddress interfaceAddr, IPAddress multicast, uint16_t port) + { + return WiFiUDP::beginMulticast(multicast, port); + } + void beginPacketMulticast(IPAddress multicast, uint16_t port, IPAddress interfaceAddr) + { + + } +}; + +#define WiFiUDP WiFiUDP32 diff --git a/libesp32/ESP32-to-ESP8266-compat/src/ESP8266httpUpdate.h b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266httpUpdate.h new file mode 100644 index 000000000..ace3a2eeb --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266httpUpdate.h @@ -0,0 +1,10 @@ +// +// Compat with ESP32 +// +#include +#define ESPhttpUpdate httpUpdate + +inline HTTPUpdateResult ESPhttpUpdate_update(const String& url, const String& currentVersion = "") +{ + return HTTP_UPDATE_OK; +} diff --git a/libesp32/ESP32-to-ESP8266-compat/src/ESP8266mDNS.h b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266mDNS.h new file mode 100644 index 000000000..f679ec5fa --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/ESP8266mDNS.h @@ -0,0 +1,4 @@ +// +// Compat with ESP32 +// +#include diff --git a/libesp32/ESP32-to-ESP8266-compat/src/c_types.h b/libesp32/ESP32-to-ESP8266-compat/src/c_types.h new file mode 100644 index 000000000..22f551391 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/c_types.h @@ -0,0 +1,6 @@ +#pragma once +/**/ +#include +#ifndef ICACHE_FLASH_ATTR +#define ICACHE_FLASH_ATTR +#endif diff --git a/libesp32/ESP32-to-ESP8266-compat/src/eboot_command.h b/libesp32/ESP32-to-ESP8266-compat/src/eboot_command.h new file mode 100644 index 000000000..992d014ea --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/eboot_command.h @@ -0,0 +1,3 @@ +// +// Compat with ESP32 +// diff --git a/libesp32/ESP32-to-ESP8266-compat/src/esp8266toEsp32.cpp b/libesp32/ESP32-to-ESP8266-compat/src/esp8266toEsp32.cpp new file mode 100644 index 000000000..0490991c4 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/esp8266toEsp32.cpp @@ -0,0 +1,73 @@ +/* + This library is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This library 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + + */ +// +#include "Arduino.h" +#include "lwip/apps/sntp.h" +#include +#include +#include +#include "esp8266toEsp32.h" +// ESP Stuff +struct rst_info resetInfo; + +String ESP_getResetReason(void) +{ + // CPU 0 + return String(rtc_get_reset_reason(0)); +} + +String ESP_getResetInfo(void) +{ + return String(PSTR("0")); +} + +String ESP_getBootVersion(void) +{ + return String(PSTR("Unknown")); +} + +bool ESP_rtcUserMemoryWrite(uint32_t offset, uint32_t *data, size_t size) +{ + return false; +} + +bool ESP_rtcUserMemoryRead(uint32_t offset, uint32_t *data, size_t size) +{ + return false; +} + +void ESP_reset() +{ + ESP.restart(); +} + +uint32_t ESP_getFlashChipId() +{ + return 0; +} + +String String_ESP_getChipId() +{ + uint64_t mac = ESP.getEfuseMac(); + return String(uint32_t(mac >> 32)) + String(uint32_t(mac)); +} + +/* +uint64_t ESP_getChipId() +{ + return ESP.getEfuseMac(); +} +*/ diff --git a/libesp32/ESP32-to-ESP8266-compat/src/esp8266toEsp32.h b/libesp32/ESP32-to-ESP8266-compat/src/esp8266toEsp32.h new file mode 100644 index 000000000..1071bfbd1 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/esp8266toEsp32.h @@ -0,0 +1,115 @@ +/* + This library is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This library 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + + */ +#pragma once +#ifdef ESP32 +// my debug Stuff +#define Serial_Debug1(p) Serial.printf p +#define Serial_DebugX(p) + +// +// basics +// +// dummy defines +#define SPIFFS_END (SPI_FLASH_SEC_SIZE * 200) +#define SETTINGS_LOCATION SPIFFS_END + +#include + +// +// ESP32 +// +#define ESP_flashReadHeader(offset, data, size) ESP32_flashRead(offset, data, size) +#define ESP_flashRead(offset, data, size) ESP32_flashRead(offset, data, size) +String ESP_getResetReason(void); +String ESP_getBootVersion(void); +bool ESP_rtcUserMemoryWrite(uint32_t offset, uint32_t *data, size_t size); +bool ESP_rtcUserMemoryRead(uint32_t offset, uint32_t *data, size_t size); +void ESP_reset(); +String ESP_getResetInfo(void); +uint32_t ESP_getFlashChipId(); +String String_ESP_getChipId(); + +// Analog +inline void analogWrite(uint8_t pin, int val) +{ +} + +inline void analogWriteFreq(uint32_t freq) +{ +} +inline void analogWriteRange(uint32_t range) +{ +} + +#define INPUT_PULLDOWN_16 INPUT_PULLUP + +typedef double real64_t; + +// +// Time and Timer +// +#define ETS_UART_INTR_DISABLE() +#define ETS_UART_INTR_ENABLE() + +#define getChipId() getEfuseMac() +#define ESPhttpUpdate httpUpdate +#define getFlashChipRealSize() getFlashChipSize() + +#define os_delay_us ets_delay_us +// Serial minimal type to hold the config +typedef int SerConfu8; +typedef int SerialConfig; +#define analogWrite(a, b) + +// +// WS2812 +// +#define NeoEsp8266BitBang800KbpsMethod NeoEsp32BitBang800KbpsMethod +// +// UDP +// +//#define PortUdp_writestr(log_data) PortUdp.write((const uint8_t *)(log_data), strlen(log_data)) +#define PortUdp_write(log_data, n) PortUdp.write((const uint8_t *)(log_data), n) + +// +#define wifi_forceSleepBegin() + +#undef LWIP_IPV6 + +struct rst_info +{ + int reason; +}; + +#define REASON_DEFAULT_RST 1 +#define REASON_EXT_SYS_RST 2 +#define REASON_DEEP_SLEEP_AWAKE 3 + +// memmove ... +#define memcpy_P memcpy +#define memmove_P memmove +#define strncpy_P strncpy +#define strcmp_P strcmp +#define memccpy_P memccpy +#define snprintf_P snprintf +#define sprintf_P sprintf +#define strncmp_P strncmp + +// LWIP STuff + +#define STATION_IF 0 + +#endif diff --git a/libesp32/ESP32-to-ESP8266-compat/src/ets_sys.h b/libesp32/ESP32-to-ESP8266-compat/src/ets_sys.h new file mode 100644 index 000000000..30a7e7733 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/ets_sys.h @@ -0,0 +1,3 @@ +#pragma once +#define timercallback void* +#define ets_printf(...) diff --git a/libesp32/ESP32-to-ESP8266-compat/src/gpio.h b/libesp32/ESP32-to-ESP8266-compat/src/gpio.h new file mode 100644 index 000000000..0ff47d6a2 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/gpio.h @@ -0,0 +1,2 @@ +#pragma once +#define GPIO_STATUS_W1TC_ADDRESS 0x24 diff --git a/libesp32/ESP32-to-ESP8266-compat/src/os_type.h b/libesp32/ESP32-to-ESP8266-compat/src/os_type.h new file mode 100644 index 000000000..a9e1558f5 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/os_type.h @@ -0,0 +1,6 @@ +#pragma once +#include "esp8266-compat.h" +#include +#include +typedef uint16 uint16_t; +typedef double real64_t; diff --git a/libesp32/ESP32-to-ESP8266-compat/src/osapi.h b/libesp32/ESP32-to-ESP8266-compat/src/osapi.h new file mode 100644 index 000000000..947de57cc --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/osapi.h @@ -0,0 +1,8 @@ +#pragma once +/**/ +#include +/* +#ifndef ICACHE_FLASH_ATTR +#define ICACHE_FLASH_ATTR +#endif +*/ diff --git a/libesp32/ESP32-to-ESP8266-compat/src/sntp.h b/libesp32/ESP32-to-ESP8266-compat/src/sntp.h new file mode 100644 index 000000000..2d92438d5 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/sntp.h @@ -0,0 +1,7 @@ +#pragma once +#define sntp_get_current_timestamp() SntpGetCurrentTimestamp() +#define sntp_init() SntpInit() +#define sntp_set_timezone(tz) +#define sntp_setservername(idx, name) +#define sntp_stop() + diff --git a/libesp32/ESP32-to-ESP8266-compat/src/spi_flash.h b/libesp32/ESP32-to-ESP8266-compat/src/spi_flash.h new file mode 100644 index 000000000..fffa3c3a0 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/spi_flash.h @@ -0,0 +1,4 @@ +// +// Compat with ESP32 +// +// TODO: Port it to ESP32 diff --git a/libesp32/ESP32-to-ESP8266-compat/src/twi.h b/libesp32/ESP32-to-ESP8266-compat/src/twi.h new file mode 100644 index 000000000..eaf51d122 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/twi.h @@ -0,0 +1,2 @@ +#pragma once +/**/ \ No newline at end of file diff --git a/libesp32/ESP32-to-ESP8266-compat/src/user_interface.h b/libesp32/ESP32-to-ESP8266-compat/src/user_interface.h new file mode 100644 index 000000000..ee38dfb21 --- /dev/null +++ b/libesp32/ESP32-to-ESP8266-compat/src/user_interface.h @@ -0,0 +1,24 @@ +/* + This library is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This library 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#ifndef user_interface_h +#define user_interface_h +enum wps_cb_status { + WPS_CB_ST_SUCCESS = 0, + WPS_CB_ST_FAILED, + WPS_CB_ST_TIMEOUT, + WPS_CB_ST_WEP, + WPS_CB_ST_UNK, +}; +#endif diff --git a/platformio_override_esp32.ini b/platformio_override_esp32.ini new file mode 100644 index 000000000..d2f6ae536 --- /dev/null +++ b/platformio_override_esp32.ini @@ -0,0 +1,109 @@ +; +; Example PlatformIO Project Configuration Override for ESP32 *** +; Changes done here override settings in platformio.ini *** +; +; to build Tasmota ESP32 copy to platformio_override.ini *** +; +; Please visit documentation for the options and examples +; http://docs.platformio.org/en/stable/projectconf.html +; + + +[platformio] +; *** Build/upload environment +;monitor_port = COM5 +default_envs = +; *** Uncomment the line(s) below to select version(s) + tasmota + tasmota32 +; tasmota32-minimal +; tasmota32-lite +; tasmota32-knx +; tasmota32-sensors +; tasmota32-display +; tasmota32-ir +; tasmota32-ircustom +; tasmota32-DE +; tasmota32-NL + +[env32] +; uncomment this for all other tasmota32 builds +[env:tasmota32] +framework = ${common.framework} +platform = ${common32.platform} +platform_packages = ${common32.platform_packages} +board = ${common32.board} +board_build.ldscript = ${common32.board_build.ldscript} +board_build.flash_mode = ${common32.board_build.flash_mode} +board_build.f_cpu = ${common32.board_build.f_cpu} +build_unflags = ${common32.build_unflags} +build_flags = ${common32.build_flags} +monitor_speed = ${common32.monitor_speed} +upload_port = ${common32.upload_port} +upload_resetmethod = ${common32.upload_resetmethod} +upload_speed = ${common32.upload_speed} +extra_scripts = ${common32.extra_scripts} +lib_extra_dirs = ${common32.lib_extra_dirs} +lib_ignore = ${common32.lib_ignore} + +; uncomment this for all other tasmota32 builds +;[env:tasmota32] + +[env:tasmota32-minimal] +build_flags = ${common.build_flags} -DFIRMWARE_MINIMAL +[env:tasmota32-lite] +build_flags = ${common.build_flags} -DFIRMWARE_LITE +[env:tasmota32-knx] +build_flags = ${common.build_flags} -DFIRMWARE_KNX_NO_EMULATION +[env:tasmota32-sensors] +build_flags = ${common.build_flags} -DFIRMWARE_SENSORS +[env:tasmota32-display] +build_flags = ${common.build_flags} -DFIRMWARE_DISPLAYS +[env:tasmota32-ir] +build_flags = ${common.build_flags} ${irremoteesp8266_full.build_flags} -DFIRMWARE_IR +[env:tasmota32-ircustom] +build_flags = ${common.build_flags} ${irremoteesp8266_full.build_flags} +[env:tasmota32-DE] +build_flags = ${common.build_flags} -DMY_LANGUAGE=de-DE +[env:tasmota32-NL] +build_flags = ${common.build_flags} -DMY_LANGUAGE=nl-NL + +[common32] +platform = espressif32@1.12.0 +platform_packages = +board = wemos_d1_mini32 +board_build.ldscript = esp32_out.ld +board_build.flash_mode = ${common.board_build.flash_mode} +board_build.f_cpu = ${common.board_build.f_cpu} +build_unflags = ${common.build_unflags} +monitor_speed = ${common.monitor_speed} +upload_port = ${common.upload_port} +upload_resetmethod = ${common.upload_resetmethod} +upload_speed = 921600 +extra_scripts = ${common.extra_scripts} + +build_flags = + -D BUFFER_LENGTH=128 + -D MQTT_MAX_PACKET_SIZE=1000 + -D uint32=uint32_t + -D uint16=uint16_t + -D uint8=uint8_t + -D sint8_t=int8_t + -D sint32_t=int32_t + -D sint16_t=int16_t + -D memcpy_P=memcpy + -D memcmp_P=memcmp +; -D USE_CONFIG_OVERRIDE + +lib_extra_dirs = + libesp32 + +lib_ignore = + ESP MQTT + TasmotaMqtt + ILI9488 + RA8876 + SSD3115 + cc1101 + FrogmoreScd30 + ArduinoNTPd diff --git a/tasmota/core_esp8266_timer.c b/tasmota/core_esp8266_timer.c index bf852784c..91541d227 100644 --- a/tasmota/core_esp8266_timer.c +++ b/tasmota/core_esp8266_timer.c @@ -19,6 +19,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#ifdef ESP8266 + // Use PWM from core 2.4.0 as all versions below 2.5.0-beta3 produce LED flickering when settings are saved to flash #include #if defined(ARDUINO_ESP8266_RELEASE_2_3_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_1) || defined(ARDUINO_ESP8266_RELEASE_2_4_2) @@ -109,3 +111,5 @@ void ICACHE_RAM_ATTR timer0_detachInterrupt(void) { } #endif // ARDUINO_ESP8266_RELEASE + +#endif // ESP8266 diff --git a/tasmota/core_esp8266_waveform.cpp b/tasmota/core_esp8266_waveform.cpp index a35bb7c84..1ae2d7457 100644 --- a/tasmota/core_esp8266_waveform.cpp +++ b/tasmota/core_esp8266_waveform.cpp @@ -37,6 +37,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#ifdef ESP8266 + #include #if defined(ARDUINO_ESP8266_RELEASE_2_6_1) || defined(ARDUINO_ESP8266_RELEASE_2_6_2) || defined(ARDUINO_ESP8266_RELEASE_2_6_3) || !defined(ARDUINO_ESP8266_RELEASE) #warning **** Tasmota is using a patched PWM Arduino version as planned **** @@ -341,4 +343,6 @@ static ICACHE_RAM_ATTR void timer1Interrupt() { }; -#endif // ARDUINO_ESP8266_RELEASE \ No newline at end of file +#endif // ARDUINO_ESP8266_RELEASE + +#endif // ESP8266 diff --git a/tasmota/core_esp8266_wiring_digital.c b/tasmota/core_esp8266_wiring_digital.c index 4b9ab252b..15c60503c 100644 --- a/tasmota/core_esp8266_wiring_digital.c +++ b/tasmota/core_esp8266_wiring_digital.c @@ -19,6 +19,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#ifdef ESP8266 + // Use PWM from core 2.4.0 as all versions below 2.5.0-beta3 produce LED flickering when settings are saved to flash #include #if defined(ARDUINO_ESP8266_RELEASE_2_3_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_1) || defined(ARDUINO_ESP8266_RELEASE_2_4_2) @@ -217,3 +219,5 @@ extern void attachInterrupt(uint8_t pin, voidFuncPtr handler, int mode) __attrib extern void detachInterrupt(uint8_t pin) __attribute__ ((weak, alias("__detachInterrupt"))); #endif // ARDUINO_ESP8266_RELEASE + +#endif // ESP8266 diff --git a/tasmota/core_esp8266_wiring_pwm.c b/tasmota/core_esp8266_wiring_pwm.c index 8bd24815c..19e584236 100644 --- a/tasmota/core_esp8266_wiring_pwm.c +++ b/tasmota/core_esp8266_wiring_pwm.c @@ -19,6 +19,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#ifdef ESP8266 + // Use PWM from core 2.4.0 as all versions below 2.5.0-beta3 produce LED flickering when settings are saved to flash #include #if defined(ARDUINO_ESP8266_RELEASE_2_3_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_1) || defined(ARDUINO_ESP8266_RELEASE_2_4_2) @@ -232,3 +234,5 @@ extern void analogWriteFreq(uint32_t freq) __attribute__ ((weak, alias("__analog extern void analogWriteRange(uint32_t range) __attribute__ ((weak, alias("__analogWriteRange"))); #endif // ARDUINO_ESP8266_RELEASE + +#endif // ESP8266 diff --git a/tasmota/settings.h b/tasmota/settings.h index 23a1889c0..f4c0c68a7 100644 --- a/tasmota/settings.h +++ b/tasmota/settings.h @@ -221,7 +221,7 @@ typedef struct { } EnergyUsage; -typedef struct { +typedef struct PACKED { uint8_t fnid = 0; uint8_t dpid = 0; } TuyaFnidDpidMap; @@ -229,7 +229,7 @@ typedef struct { const uint32_t settings_text_size = 699; // Settings.text_pool[size] = Settings.display_model (2D2) - Settings.text_pool (017) const uint8_t MAX_TUYA_FUNCTIONS = 16; -struct SYSCFG { +struct PACKED SYSCFG { uint16_t cfg_holder; // 000 v6 header uint16_t cfg_size; // 002 unsigned long save_flag; // 004 diff --git a/tasmota/settings.ino b/tasmota/settings.ino index 2a7e8ce31..a406b60b7 100644 --- a/tasmota/settings.ino +++ b/tasmota/settings.ino @@ -40,14 +40,14 @@ void RtcSettingsSave(void) { if (GetRtcSettingsCrc() != rtc_settings_crc) { RtcSettings.valid = RTC_MEM_VALID; - ESP.rtcUserMemoryWrite(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM)); + ESP_rtcUserMemoryWrite(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM)); rtc_settings_crc = GetRtcSettingsCrc(); } } void RtcSettingsLoad(void) { - ESP.rtcUserMemoryRead(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM)); // 0x290 + ESP_rtcUserMemoryRead(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM)); // 0x290 if (RtcSettings.valid != RTC_MEM_VALID) { memset(&RtcSettings, 0, sizeof(RTCMEM)); RtcSettings.valid = RTC_MEM_VALID; @@ -87,7 +87,7 @@ void RtcRebootSave(void) { if (GetRtcRebootCrc() != rtc_reboot_crc) { RtcReboot.valid = RTC_MEM_VALID; - ESP.rtcUserMemoryWrite(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT)); + ESP_rtcUserMemoryWrite(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT)); rtc_reboot_crc = GetRtcRebootCrc(); } } @@ -100,7 +100,7 @@ void RtcRebootReset(void) void RtcRebootLoad(void) { - ESP.rtcUserMemoryRead(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT)); // 0x280 + ESP_rtcUserMemoryRead(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT)); // 0x280 if (RtcReboot.valid != RTC_MEM_VALID) { memset(&RtcReboot, 0, sizeof(RTCRBT)); RtcReboot.valid = RTC_MEM_VALID; @@ -141,6 +141,8 @@ extern "C" { } #include "eboot_command.h" +#ifdef ESP8266 + #if defined(ARDUINO_ESP8266_RELEASE_2_3_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_1) || defined(ARDUINO_ESP8266_RELEASE_2_4_2) || defined(ARDUINO_ESP8266_RELEASE_2_5_0) || defined(ARDUINO_ESP8266_RELEASE_2_5_1) || defined(ARDUINO_ESP8266_RELEASE_2_5_2) extern "C" uint32_t _SPIFFS_end; @@ -168,6 +170,9 @@ const uint32_t SPIFFS_END = ((uint32_t)&_FS_end - 0x40200000) / SPI_FLASH_SEC_SI // Version 4.2 config = eeprom area const uint32_t SETTINGS_LOCATION = SPIFFS_END; // No need for SPIFFS as it uses EEPROM area + +#endif // ESP8266 + // Version 5.2 allow for more flash space const uint8_t CFG_ROTATES = 8; // Number of flash sectors used (handles uploads) @@ -181,6 +186,7 @@ uint8_t *settings_buffer = nullptr; */ void SetFlashModeDout(void) { +#ifdef ESP8266 uint8_t *_buffer; uint32_t address; @@ -198,10 +204,13 @@ void SetFlashModeDout(void) } } delete[] _buffer; +#endif // ESP8266 } bool VersionCompatible(void) { +#ifdef ESP8266 + if (Settings.flag3.compatibility_check) { return true; } @@ -244,6 +253,8 @@ bool VersionCompatible(void) return false; } +#endif // ESP8266 + return true; } @@ -478,6 +489,7 @@ void SettingsSave(uint8_t rotate) Settings.cfg_crc = GetSettingsCrc(); // Keep for backward compatibility in case of fall-back just after upgrade Settings.cfg_crc32 = GetSettingsCrc32(); +#ifdef ESP8266 if (ESP.flashEraseSector(settings_location)) { ESP.flashWrite(settings_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG)); } @@ -488,6 +500,9 @@ void SettingsSave(uint8_t rotate) delay(1); } } +#else // ESP32 + SettingsSaveMain(&Settings, sizeof(SYSCFG)); +#endif // ESP8266 AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_CONFIG D_SAVED_TO_FLASH_AT " %X, " D_COUNT " %d, " D_BYTES " %d"), settings_location, Settings.save_flag, sizeof(SYSCFG)); @@ -512,8 +527,7 @@ void SettingsLoad(void) uint16_t cfg_holder = 0; for (uint32_t i = 0; i < CFG_ROTATES; i++) { flash_location--; - ESP.flashRead(flash_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG)); - + ESP_flashRead(flash_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG)); bool valid = false; if (Settings.version > 0x06000000) { bool almost_valid = (Settings.cfg_crc32 == GetSettingsCrc32()); @@ -524,7 +538,7 @@ void SettingsLoad(void) if (almost_valid && (0 == cfg_holder)) { cfg_holder = Settings.cfg_holder; } // At FB always active cfg_holder valid = (cfg_holder == Settings.cfg_holder); } else { - ESP.flashRead((flash_location -1) * SPI_FLASH_SEC_SIZE, (uint32*)&_SettingsH, sizeof(SYSCFGH)); + ESP_flashReadHeader((flash_location -1) * SPI_FLASH_SEC_SIZE, (uint32*)&_SettingsH, sizeof(SYSCFGH)); valid = (Settings.cfg_holder == _SettingsH.cfg_holder); } if (valid) { @@ -540,7 +554,7 @@ void SettingsLoad(void) delay(1); } if (settings_location > 0) { - ESP.flashRead(settings_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG)); + ESP_flashRead(settings_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG)); AddLog_P2(LOG_LEVEL_NONE, PSTR(D_LOG_CONFIG D_LOADED_FROM_FLASH_AT " %X, " D_COUNT " %lu"), settings_location, Settings.save_flag); } @@ -579,6 +593,7 @@ void EspErase(uint32_t start_sector, uint32_t end_sector) void SettingsErase(uint8_t type) { +#ifdef ESP8266 /* For Arduino core and SDK: Erase only works from flash start address to SDK recognized flash end address (flashchip->chip_size = ESP.getFlashChipSize). @@ -630,6 +645,7 @@ void SettingsErase(uint8_t type) // EspErase(_sectorStart, _sectorEnd); // Arduino core and SDK - erases flash as seen by SDK EsptoolErase(_sectorStart, _sectorEnd); // Esptool - erases flash completely #endif // FIRMWARE_MINIMAL +#endif // ESP8266 } void SettingsSdkErase(void) @@ -1028,6 +1044,8 @@ void SettingsEnableAllI2cDrivers(void) void SettingsDelta(void) { if (Settings.version != VERSION) { // Fix version dependent changes + +#ifdef ESP8266 if (Settings.version < 0x06000000) { Settings.cfg_size = sizeof(SYSCFG); Settings.cfg_crc = GetSettingsCrc(); @@ -1315,6 +1333,7 @@ void SettingsDelta(void) if (Settings.version < 0x08020003) { SettingsUpdateText(SET_TEMPLATE_NAME, Settings.user_template_name); } +#endif // ESP8266 Settings.version = VERSION; SettingsSave(1); diff --git a/tasmota/support.ino b/tasmota/support.ino index 453eb4875..2a794d545 100644 --- a/tasmota/support.ino +++ b/tasmota/support.ino @@ -109,7 +109,7 @@ String GetResetReason(void) strncpy_P(buff, PSTR(D_JSON_BLOCKED_LOOP), sizeof(buff)); return String(buff); } else { - return ESP.getResetReason(); + return ESP_getResetReason(); } } @@ -1660,7 +1660,7 @@ void Syslog(void) memmove(log_data + strlen(syslog_preamble), log_data, sizeof(log_data) - strlen(syslog_preamble)); log_data[sizeof(log_data) -1] = '\0'; memcpy(log_data, syslog_preamble, strlen(syslog_preamble)); - PortUdp.write(log_data, strlen(log_data)); + PortUdp_write(log_data, strlen(log_data)); PortUdp.endPacket(); delay(1); // Add time for UDP handling (#5512) } else { diff --git a/tasmota/support_button.ino b/tasmota/support_button.ino index f30f3a287..4b41c2a74 100644 --- a/tasmota/support_button.ino +++ b/tasmota/support_button.ino @@ -119,6 +119,7 @@ void ButtonHandler(void) uint8_t button = NOT_PRESSED; uint8_t button_present = 0; +#ifdef ESP8266 if (!button_index && ((SONOFF_DUAL == my_module_type) || (CH4 == my_module_type))) { button_present = 1; if (Button.dual_code) { @@ -131,7 +132,9 @@ void ButtonHandler(void) Button.dual_code = 0; } } - else if (pin[GPIO_KEY1 +button_index] < 99) { + else +#endif // ESP8266 + if (pin[GPIO_KEY1 +button_index] < 99) { button_present = 1; button = (digitalRead(pin[GPIO_KEY1 +button_index]) != bitRead(Button.inverted_mask, button_index)); } @@ -153,6 +156,7 @@ void ButtonHandler(void) if (XdrvCall(FUNC_BUTTON_PRESSED)) { // Serviced } +#ifdef ESP8266 else if (SONOFF_4CHPRO == my_module_type) { if (Button.hold_timer[button_index]) { Button.hold_timer[button_index]--; } @@ -172,6 +176,7 @@ void ButtonHandler(void) } } } +#endif // ESP8266 else { if ((PRESSED == button) && (NOT_PRESSED == Button.last_state[button_index])) { if (Settings.flag.button_single) { // SetOption13 (0) - Allow only single button press for immediate action @@ -227,9 +232,12 @@ void ButtonHandler(void) if (!restart_flag && !Button.hold_timer[button_index] && (Button.press_counter[button_index] > 0) && (Button.press_counter[button_index] < MAX_BUTTON_COMMANDS +3)) { bool single_press = false; if (Button.press_counter[button_index] < 3) { // Single or Double press +#ifdef ESP8266 if ((SONOFF_DUAL_R2 == my_module_type) || (SONOFF_DUAL == my_module_type) || (CH4 == my_module_type)) { single_press = true; - } else { + } else +#endif // ESP8266 + { single_press = (Settings.flag.button_swap +1 == Button.press_counter[button_index]); // SetOption11 (0) if ((1 == Button.present) && (2 == devices_present)) { // Single Button with two devices only if (Settings.flag.button_swap) { // SetOption11 (0) diff --git a/tasmota/support_command.ino b/tasmota/support_command.ino index 366bc403c..133298010 100644 --- a/tasmota/support_command.ino +++ b/tasmota/support_command.ino @@ -426,7 +426,7 @@ void CmndStatus(void) "\"Hardware\":\"%s\"" "%s}}"), my_version, my_image, GetBuildDateAndTime().c_str(), - ESP.getBootVersion(), ESP.getSdkVersion(), + ESP_getBootVersion(), ESP.getSdkVersion(), GetDeviceHardware().c_str(), GetStatistics().c_str()); MqttPublishPrefixTopic_P(option, PSTR(D_CMND_STATUS "2")); @@ -448,7 +448,7 @@ void CmndStatus(void) D_JSON_PROGRAMFLASHSIZE "\":%d,\"" D_JSON_FLASHSIZE "\":%d,\"" D_JSON_FLASHCHIPID "\":\"%06X\",\"" D_JSON_FLASHMODE "\":%d,\"" D_JSON_FEATURES "\":[\"%08X\",\"%08X\",\"%08X\",\"%08X\",\"%08X\",\"%08X\",\"%08X\"]"), ESP.getSketchSize()/1024, ESP.getFreeSketchSpace()/1024, ESP.getFreeHeap()/1024, - ESP.getFlashChipSize()/1024, ESP.getFlashChipRealSize()/1024, ESP.getFlashChipId(), ESP.getFlashChipMode(), + ESP.getFlashChipSize()/1024, ESP.getFlashChipRealSize()/1024, ESP_getFlashChipId(), ESP.getFlashChipMode(), LANGUAGE_LCID, feature_drv1, feature_drv2, feature_sns1, feature_sns2, feature5, feature6); XsnsDriverState(); ResponseAppend_P(PSTR(",\"Sensors\":")); @@ -580,10 +580,10 @@ void CmndSleep(void) { if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload < 251)) { Settings.sleep = XdrvMailbox.payload; - sleep = XdrvMailbox.payload; + ssleep = XdrvMailbox.payload; WiFiSetSleepMode(); } - Response_P(S_JSON_COMMAND_NVALUE_ACTIVE_NVALUE, XdrvMailbox.command, Settings.sleep, sleep); + Response_P(S_JSON_COMMAND_NVALUE_ACTIVE_NVALUE, XdrvMailbox.command, Settings.sleep, ssleep); } @@ -646,7 +646,10 @@ void CmndRestart(void) void CmndPowerOnState(void) { - if (my_module_type != MOTOR) { +#ifdef ESP8266 + if (my_module_type != MOTOR) +#endif // ESP8266 + { /* 0 = Keep relays off after power on * 1 = Turn relays on after power on, if PulseTime set wait for PulseTime seconds, and turn relays off * 2 = Toggle relays after power on diff --git a/tasmota/support_crash_recorder.ino b/tasmota/support_crash_recorder.ino index cc9721cb4..dd0834550 100644 --- a/tasmota/support_crash_recorder.ino +++ b/tasmota/support_crash_recorder.ino @@ -17,6 +17,8 @@ along with this program. If not, see . */ +#ifdef ESP8266 + const uint32_t crash_magic = 0x53415400; // Stack trace magic number (TASx) const uint32_t crash_rtc_offset = 32; // Offset in RTC memory skipping OTA used block const uint32_t crash_dump_max_len = 31; // Dump only 31 call addresses to satisfy max JSON length of about 600 characters @@ -109,3 +111,5 @@ void CrashDump(void) ResponseJsonEnd(); } + +#endif // ESP8266 \ No newline at end of file diff --git a/tasmota/support_device_groups.ino b/tasmota/support_device_groups.ino index d350575c1..e1719f59e 100644 --- a/tasmota/support_device_groups.ino +++ b/tasmota/support_device_groups.ino @@ -20,6 +20,7 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ + #ifdef USE_DEVICE_GROUPS //#define DEVICE_GROUPS_DEBUG @@ -163,7 +164,7 @@ void SendDeviceGroupPacket(IPAddress ip, char * packet, int len, const char * la if (!ip) ip = IPAddress(239,255,255,250); for (int attempt = 1; attempt <= 5; attempt++) { if (PortUdp.beginPacket(ip, 1900)) { - PortUdp.write(packet, len); + PortUdp_write(packet, len); if (PortUdp.endPacket()) return; } delay(10); @@ -552,7 +553,7 @@ void _SendDeviceGroupMessage(uint8_t device_group_index, DevGroupMessageType mes #ifdef DEVICE_GROUPS_DEBUG AddLog_P2(LOG_LEVEL_DEBUG, PSTR("DGR: sending %u-byte device group %s packet via multicast, sequence=%u"), device_group->message_length, device_group->group_name, device_group->message[device_group->message_header_length] | device_group->message[device_group->message_header_length + 1] << 8); #endif // DEVICE_GROUPS_DEBUG - SendDeviceGroupPacket(0, device_group->message, device_group->message_length, PSTR("Multicast")); + SendDeviceGroupPacket(IPAddress(0,0,0,0), device_group->message, device_group->message_length, PSTR("Multicast")); uint32_t now = millis(); if (message_type == DGR_MSGTYP_UPDATE_MORE_TO_COME) { @@ -857,7 +858,7 @@ AddLog_P2(LOG_LEVEL_DEBUG, PSTR("DGR: Ckecking next_check_time=%u, now=%u"), nex #ifdef DEVICE_GROUPS_DEBUG AddLog_P2(LOG_LEVEL_DEBUG, PSTR("DGR: sending initial status request for group %s"), device_group->group_name); #endif // DEVICE_GROUPS_DEBUG - SendDeviceGroupPacket(0, device_group->message, device_group->message_length, PSTR("Initial")); + SendDeviceGroupPacket(IPAddress(0,0,0,0), device_group->message, device_group->message_length, PSTR("Initial")); device_group->message[device_group->message_header_length + 2] = DGR_FLAG_STATUS_REQUEST; // The reset flag is on only for the first packet - turn it off now device_group->next_ack_check_time = now + 200; } @@ -941,7 +942,7 @@ AddLog_P2(LOG_LEVEL_DEBUG, PSTR("DGR: Ckecking next_check_time=%u, now=%u"), nex #ifdef DEVICE_GROUPS_DEBUG AddLog_P2(LOG_LEVEL_DEBUG, PSTR("DGR: sending device group %s announcement"), device_group->group_name); #endif // DEVICE_GROUPS_DEBUG - SendDeviceGroupPacket(0, device_group->message, BeginDeviceGroupMessage(device_group, DGR_FLAG_ANNOUNCEMENT, true) - device_group->message, PSTR("Announcement")); + SendDeviceGroupPacket(IPAddress(0,0,0,0), device_group->message, BeginDeviceGroupMessage(device_group, DGR_FLAG_ANNOUNCEMENT, true) - device_group->message, PSTR("Announcement")); device_group->next_announcement_time = now + DGR_ANNOUNCEMENT_INTERVAL + random(10000); } if (device_group->next_announcement_time < next_check_time) next_check_time = device_group->next_announcement_time; diff --git a/tasmota/support_esp32.ino b/tasmota/support_esp32.ino new file mode 100644 index 000000000..1e2a4e0ca --- /dev/null +++ b/tasmota/support_esp32.ino @@ -0,0 +1,177 @@ +/* + support_esp32.ino - ESP32 specific code for Tasmota + + Copyright (C) 2020 Theo Arends / Jörg Schüler-Maroldt + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifdef ESP32 + +#include +#include + +void SettingsErase(uint8_t type) +{ + if (1 == type) // SDK parameter area + { + } + else if (2 == type) // Tasmota parameter area (0x0F3xxx - 0x0FBFFF) + { + } + else if (3 == type) // Tasmota and SDK parameter area (0x0F3xxx - 0x0FFFFF) + { + } + + noInterrupts(); + nvs_handle handle; + nvs_open("main", NVS_READWRITE, &handle); + nvs_erase_all(handle); + nvs_commit(handle); + nvs_close(handle); + interrupts(); + + AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION D_ERASE " t=%d"), type); +} + +void SettingsLoad(const char *sNvsName, const char *sName, void *pSettings, unsigned nSettingsLen) +{ + noInterrupts(); + nvs_handle handle; + size_t size; + nvs_open(sNvsName, NVS_READONLY, &handle); + size = nSettingsLen; + nvs_get_blob(handle, sName, pSettings, &size); + nvs_close(handle); + interrupts(); +} + +void SettingsSave(const char *sNvsName, const char *sName, const void *pSettings, unsigned nSettingsLen) +{ + nvs_handle handle; + noInterrupts(); + nvs_open(sNvsName, NVS_READWRITE, &handle); + nvs_set_blob(handle, sName, pSettings, nSettingsLen); + nvs_commit(handle); + nvs_close(handle); + interrupts(); +} + +void ESP32_flashRead(uint32_t offset, uint32_t *data, size_t size) +{ + SettingsLoad("main", "Settings", data, size); +} + +void ESP32_flashReadHeader(uint32_t offset, uint32_t *data, size_t size) +{ + SettingsLoad("main", "SettingsH", data, size); +} + +void SettingsSaveMain(const void *pSettings, unsigned nSettingsLen) +{ + SettingsSave("main", "Settings", pSettings, nSettingsLen); +} + +/* +void SettingsLoadMain(void *pSettings, unsigned nSettingsLen) +{ + SettingsLoad("main", "Settings", pSettings, nSettingsLen); +} + +void SettingsLoadMainH(void *pSettingsH, unsigned nSettingsLenH) +{ + SettingsLoad("main", "SettingsH", pSettingsH, nSettingsLenH); +} +*/ + +void SettingsLoadUpg(void *pSettings, unsigned nSettingsLen) +{ + SettingsLoad("upg", "Settings", pSettings, nSettingsLen); +} + +void SettingsLoadUpgH(void *pSettings, unsigned nSettingsLen) +{ + SettingsLoad("upg", "SettingsH", pSettings, nSettingsLen); +} + +// +// sntp emulation +// +static bool bNetIsTimeSync = false; +// +void SntpInit() +{ + bNetIsTimeSync = true; +} + +uint32_t SntpGetCurrentTimestamp(void) +{ + time_t now = 0; + if (bNetIsTimeSync || ntp_force_sync) + { + //Serial_DebugX(("timesync configTime %d\n", ntp_force_sync, bNetIsTimeSync)); + // init to UTC Time + configTime(0, 0, SettingsText(SET_NTPSERVER1), SettingsText(SET_NTPSERVER2), SettingsText(SET_NTPSERVER3)); + bNetIsTimeSync = false; + ntp_force_sync = false; + } + time(&now); + return now; +} + +// +// Crash stuff +// + +void CrashDump(void) +{ +} + +bool CrashFlag(void) +{ + return false; +} + +void CrashDumpClear(void) +{ +} +void CmndCrash(void) +{ + /* + volatile uint32_t dummy; + dummy = *((uint32_t*) 0x00000000); +*/ +} + +// Do an infinite loop to trigger WDT watchdog +void CmndWDT(void) +{ + /* + volatile uint32_t dummy = 0; + while (1) { + dummy++; + } +*/ +} +// This will trigger the os watch after OSWATCH_RESET_TIME (=120) seconds +void CmndBlockedLoop(void) +{ + /* + while (1) { + delay(1000); + } +*/ +} + +#endif // ESP32 diff --git a/tasmota/support_esptool.ino b/tasmota/support_esptool.ino index 5bb82f999..efde513fc 100644 --- a/tasmota/support_esptool.ino +++ b/tasmota/support_esptool.ino @@ -17,7 +17,10 @@ along with this program. If not, see . */ +#ifdef ESP8266 #define USE_ESPTOOL +#endif // ESP8266 + #ifdef USE_ESPTOOL /*********************************************************************************************\ * EspTool Erase function based on Version 2.8 diff --git a/tasmota/support_tasmota.ino b/tasmota/support_tasmota.ino index 8144ea351..44954ca26 100644 --- a/tasmota/support_tasmota.ino +++ b/tasmota/support_tasmota.ino @@ -210,6 +210,7 @@ void SetDevicePower(power_t rpower, uint32_t source) if (XdrvCall(FUNC_SET_DEVICE_POWER)) { // Set power state and stop if serviced // Serviced } +#ifdef ESP8266 else if ((SONOFF_DUAL == my_module_type) || (CH4 == my_module_type)) { Serial.write(0xA0); Serial.write(0x04); @@ -221,7 +222,9 @@ void SetDevicePower(power_t rpower, uint32_t source) else if (EXS_RELAY == my_module_type) { SetLatchingRelay(rpower, 1); } - else { + else +#endif // ESP8266 + { for (uint32_t i = 0; i < devices_present; i++) { power_t state = rpower &1; if (i < MAX_RELAYS) { @@ -279,9 +282,11 @@ void SetAllPower(uint32_t state, uint32_t source) void SetPowerOnState(void) { +#ifdef ESP8266 if (MOTOR == my_module_type) { Settings.poweronstate = POWER_ALL_ON; // Needs always on else in limbo! } +#endif // ESP8266 if (POWER_ALL_ALWAYS_ON == Settings.poweronstate) { SetDevicePower(1, SRC_RESTART); } else { @@ -625,7 +630,7 @@ void MqttShowState(void) ResponseAppend_P(PSTR(",\"" D_JSON_HEAPSIZE "\":%d,\"SleepMode\":\"%s\",\"Sleep\":%u,\"LoadAvg\":%u,\"MqttCount\":%u"), ESP.getFreeHeap()/1024, GetTextIndexed(stemp1, sizeof(stemp1), Settings.flag3.sleep_normal, kSleepMode), // SetOption60 - Enable normal sleep instead of dynamic sleep - sleep, loop_load_avg, MqttConnectCount()); + ssleep, loop_load_avg, MqttConnectCount()); for (uint32_t i = 1; i <= devices_present; i++) { #ifdef USE_LIGHT @@ -903,9 +908,11 @@ void Every250mSeconds(void) } if (Settings.ledstate &1 && (pin[GPIO_LEDLNK] < 99 || !(blinks || restart_flag || ota_state_flag)) ) { bool tstate = power & Settings.ledmask; +#ifdef ESP8266 if ((SONOFF_TOUCH == my_module_type) || (SONOFF_T11 == my_module_type) || (SONOFF_T12 == my_module_type) || (SONOFF_T13 == my_module_type)) { tstate = (!power) ? 1 : 0; // As requested invert signal for Touch devices to find them in the dark } +#endif // ESP8266 SetLedPower(tstate); } @@ -1213,13 +1220,14 @@ void SerialInput(void) delay(0); serial_in_byte = Serial.read(); +#ifdef ESP8266 /*-------------------------------------------------------------------------------------------*\ * Sonoff dual and ch4 19200 baud serial interface \*-------------------------------------------------------------------------------------------*/ if ((SONOFF_DUAL == my_module_type) || (CH4 == my_module_type)) { serial_in_byte = ButtonSerial(serial_in_byte); } - +#endif // ESP8266 /*-------------------------------------------------------------------------------------------*/ if (XdrvCall(FUNC_SERIAL)) { @@ -1320,7 +1328,15 @@ void GpioInit(void) if (!ValidModule(Settings.module)) { uint32_t module = MODULE; - if (!ValidModule(MODULE)) { module = SONOFF_BASIC; } + if (!ValidModule(MODULE)) { +#ifdef ESP8266 + module = SONOFF_BASIC; +#endif // ESP8266 +#ifdef ESP32 + module = WEMOS; +#endif // ESP32 + } + Settings.module = module; Settings.last_module = module; } @@ -1417,7 +1433,9 @@ void GpioInit(void) if (mpin) pin[mpin] = i; } +#ifdef ESP8266 if ((2 == pin[GPIO_TXD]) || (H801 == my_module_type)) { Serial.set_tx(2); } +#endif // ESP8266 analogWriteRange(Settings.pwm_range); // Default is 1023 (Arduino.h) analogWriteFreq(Settings.pwm_frequency); // Default is 1000 (core_esp8266_wiring_pwm.c) @@ -1462,6 +1480,7 @@ void GpioInit(void) if (XdrvCall(FUNC_MODULE_INIT)) { // Serviced } +#ifdef ESP8266 else if (YTF_IR_BRIDGE == my_module_type) { ClaimSerial(); // Stop serial loopback mode // devices_present = 1; @@ -1479,6 +1498,7 @@ void GpioInit(void) SetSerial(19200, TS_SERIAL_8N1); } #endif // USE_SONOFF_SC +#endif // ESP8266 for (uint32_t i = 0; i < MAX_PWMS; i++) { // Basic PWM control only if (pin[GPIO_PWM1 +i] < 99) { @@ -1497,10 +1517,12 @@ void GpioInit(void) if (pin[GPIO_REL1 +i] < 99) { pinMode(pin[GPIO_REL1 +i], OUTPUT); devices_present++; +#ifdef ESP8266 if (EXS_RELAY == my_module_type) { digitalWrite(pin[GPIO_REL1 +i], bitRead(rel_inverted, i) ? 1 : 0); if (i &1) { devices_present--; } } +#endif // ESP8266 } } diff --git a/tasmota/support_wifi.ino b/tasmota/support_wifi.ino index 8f022057d..dc4016b59 100644 --- a/tasmota/support_wifi.ino +++ b/tasmota/support_wifi.ino @@ -156,10 +156,10 @@ void WiFiSetSleepMode(void) // Sleep explanation: https://github.com/esp8266/Arduino/blob/3f0c601cfe81439ce17e9bd5d28994a7ed144482/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp#L255 #if defined(ARDUINO_ESP8266_RELEASE_2_4_1) || defined(ARDUINO_ESP8266_RELEASE_2_4_2) #else // Enabled in 2.3.0, 2.4.0 and stage - if (sleep && Settings.flag3.sleep_normal) { // SetOption60 - Enable normal sleep instead of dynamic sleep - WiFi.setSleepMode(WIFI_LIGHT_SLEEP); // Allow light sleep during idle times + if (ssleep && Settings.flag3.sleep_normal) { // SetOption60 - Enable normal sleep instead of dynamic sleep + WiFi.setSleepMode(WIFI_LIGHT_SLEEP); // Allow light sleep during idle times } else { - WiFi.setSleepMode(WIFI_MODEM_SLEEP); // Disable sleep (Esp8288/Arduino core and sdk default) + WiFi.setSleepMode(WIFI_MODEM_SLEEP); // Disable sleep (Esp8288/Arduino core and sdk default) } #endif WifiSetOutputPower(); @@ -709,7 +709,7 @@ void EspRestart(void) WifiShutdown(true); CrashDumpClear(); // Clear the stack dump in RTC // ESP.restart(); // This results in exception 3 on restarts on core 2.3.0 - ESP.reset(); + ESP_reset(); } #ifndef ARDUINO_ESP8266_RELEASE_2_3_0 diff --git a/tasmota/tasmota.h b/tasmota/tasmota.h index 57fdc60ff..e6861ee97 100644 --- a/tasmota/tasmota.h +++ b/tasmota/tasmota.h @@ -41,8 +41,14 @@ * Power Type \*********************************************************************************************/ +#ifdef ESP8266 typedef unsigned long power_t; // Power (Relay) type const uint32_t POWER_MASK = 0xffffffffUL; // Power (Relay) full mask +#endif // ESP8266 +#ifdef ESP32 +typedef uint64_t power_t; // Power (Relay) type +const uint64_t POWER_MASK = 0xffffffffffffffffull; // Power (Relay) full mask +#endif // ESP32 /*********************************************************************************************\ * Constants @@ -331,7 +337,7 @@ enum TasmotaSerialConfig { TS_SERIAL_5O1, TS_SERIAL_6O1, TS_SERIAL_7O1, TS_SERIAL_8O1, TS_SERIAL_5O2, TS_SERIAL_6O2, TS_SERIAL_7O2, TS_SERIAL_8O2 }; -const uint8_t kTasmotaSerialConfig[] PROGMEM = { +const SerConfu8 kTasmotaSerialConfig[] PROGMEM = { SERIAL_5N1, SERIAL_6N1, SERIAL_7N1, SERIAL_8N1, SERIAL_5N2, SERIAL_6N2, SERIAL_7N2, SERIAL_8N2, SERIAL_5E1, SERIAL_6E1, SERIAL_7E1, SERIAL_8E1, diff --git a/tasmota/tasmota.ino b/tasmota/tasmota.ino index ec06f11a0..22e33ce72 100644 --- a/tasmota/tasmota.ino +++ b/tasmota/tasmota.ino @@ -32,6 +32,7 @@ // Location specific includes #include // Arduino_Esp8266 version information (ARDUINO_ESP8266_RELEASE and ARDUINO_ESP8266_RELEASE_2_3_0) +#include "tasmota_compat.h" #include "tasmota_version.h" // Tasmota version information #include "tasmota.h" // Enumeration used in my_user_config.h #include "my_user_config.h" // Fixed user configurable options @@ -123,7 +124,7 @@ uint8_t mqtt_cmnd_blocked = 0; // Ignore flag for publish command uint8_t mqtt_cmnd_blocked_reset = 0; // Count down to reset if needed uint8_t state_250mS = 0; // State 250msecond per second flag uint8_t latching_relay_pulse = 0; // Latching relay pulse timer -uint8_t sleep; // Current copy of Settings.sleep +uint8_t ssleep; // Current copy of Settings.sleep uint8_t blinkspeed = 1; // LED blink rate uint8_t pin[GPIO_MAX]; // Possible pin configurations uint8_t active_device = 1; // Active device in ExecuteCommandPower @@ -226,7 +227,7 @@ void setup(void) syslog_level = Settings.syslog_level; stop_flash_rotate = Settings.flag.stop_flash_rotate; // SetOption12 - Switch between dynamic or fixed slot flash save location save_data_counter = Settings.save_data; - sleep = Settings.sleep; + ssleep = Settings.sleep; #ifndef USE_EMULATION Settings.flag2.emulation = 0; #else @@ -259,8 +260,13 @@ void setup(void) Settings.my_adc0 = ADC0_NONE; // Reset user defined ADC0 disabling sensors } if (RtcReboot.fast_reboot_count > Settings.param[P_BOOT_LOOP_OFFSET] +4) { // Restarted 6 times +#ifdef ESP8266 Settings.module = SONOFF_BASIC; // Reset module to Sonoff Basic // Settings.last_module = SONOFF_BASIC; +#endif // ESP8266 +#ifdef ESP32 + Settings.module = WEMOS; // Reset module to Wemos +#endif // ESP32 } AddLog_P2(LOG_LEVEL_INFO, PSTR(D_LOG_APPLICATION D_LOG_SOME_SETTINGS_RESET " (%d)"), RtcReboot.fast_reboot_count); } @@ -374,10 +380,10 @@ void loop(void) if (Settings.flag3.sleep_normal) { // SetOption60 - Enable normal sleep instead of dynamic sleep // yield(); // yield == delay(0), delay contains yield, auto yield in loop - delay(sleep); // https://github.com/esp8266/Arduino/issues/2021 + delay(ssleep); // https://github.com/esp8266/Arduino/issues/2021 } else { - if (my_activity < (uint32_t)sleep) { - delay((uint32_t)sleep - my_activity); // Provide time for background tasks like wifi + if (my_activity < (uint32_t)ssleep) { + delay((uint32_t)ssleep - my_activity); // Provide time for background tasks like wifi } else { if (global_state.wifi_down) { delay(my_activity /2); // If wifi down and my_activity > setoption36 then force loop delay to 1/3 of my_activity period @@ -386,7 +392,7 @@ void loop(void) } if (!my_activity) { my_activity++; } // We cannot divide by 0 - uint32_t loop_delay = sleep; + uint32_t loop_delay = ssleep; if (!loop_delay) { loop_delay++; } // We cannot divide by 0 uint32_t loops_per_second = 1000 / loop_delay; // We need to keep track of this many loops per second uint32_t this_cycle_ratio = 100 * my_activity / loop_delay; diff --git a/tasmota/tasmota_compat.h b/tasmota/tasmota_compat.h new file mode 100644 index 000000000..97777c566 --- /dev/null +++ b/tasmota/tasmota_compat.h @@ -0,0 +1,31 @@ +#pragma once + +#ifdef ESP32 +#include +#define PACKED __attribute((__packed__)) +// Modul +#undef MODULE +#define MODULE WEMOS // [Module] Select default model +#endif + +#ifdef ESP8266 +// ESP8266 +#define PACKED +#define ESP_rtcUserMemoryWrite(offset, data, size) ESP.rtcUserMemoryWrite(offset, data, size) +#define ESP_rtcUserMemoryRead(offset, data, size) ESP.rtcUserMemoryRead(offset, data, size) +#define ESP_getResetReason() ESP.getResetReason() +#define ESP_reset() ESP.reset() +#define ESP_getBootVersion() ESP.getBootVersion() +#define ESP_getFlashChipId() ESP.getFlashChipId() +// +// we need different ESP_flashRead for ESP32 +// +#define ESP_flashReadHeader(offset, data, size) ESP.flashRead(offset, data, size) +#define ESP_flashRead(offset, data, size) ESP.flashRead(offset, data, size) +// +// UDP +#define PortUdp_write(p,n) PortUdp.write(p, n) +// +// Serial minimal type to hold the config +#define SerConfu8 uint8_t +#endif // ESP32 diff --git a/tasmota/tasmota_template.h b/tasmota/tasmota_template.h index e21260741..dd36e3c55 100644 --- a/tasmota/tasmota_template.h +++ b/tasmota/tasmota_template.h @@ -692,11 +692,26 @@ const char kAdc0Names[] PROGMEM = /********************************************************************************************/ +#ifdef ESP8266 + #define MAX_GPIO_PIN 17 // Number of supported GPIO #define MIN_FLASH_PINS 4 // Number of flash chip pins unusable for configuration (GPIO6, 7, 8 and 11) const char PINS_WEMOS[] PROGMEM = "D3TXD4RXD2D1flashcFLFLolD6D7D5D8D0A0"; +#else // ESP32 + +// esp32 has more pins +#define USER_MODULE 255 +#define MAX_GPIO_PIN 44 // Number of supported GPIO +#define MIN_FLASH_PINS 4 // Number of flash chip pins unusable for configuration (GPIO6, 7, 8 and 11) + +const char PINS_WEMOS[] PROGMEM = "00010203040506070809101112131415161718192021222324252627282930313233343536373839"; + +#endif // ESP8266 + +/********************************************************************************************/ + typedef struct MYIO { uint8_t io[MAX_GPIO_PIN]; } myio; @@ -730,6 +745,8 @@ typedef struct MYTMPLT { /********************************************************************************************/ +#ifdef ESP8266 + // Supported hardware modules enum SupportedModules { SONOFF_BASIC, SONOFF_RF, SONOFF_SV, SONOFF_TH, SONOFF_DUAL, SONOFF_POW, SONOFF_4CH, SONOFF_S2X, SLAMPHER, SONOFF_TOUCH, @@ -2221,4 +2238,10 @@ const mytmplt kModules[MAXMODULE] PROGMEM = { } }; +#endif // ESP8266 + +#ifdef ESP32 +#include "tasmota_template_ESP32.h" +#endif // ESP32 + #endif // _TASMOTA_TEMPLATE_H_ diff --git a/tasmota/tasmota_template_ESP32.h b/tasmota/tasmota_template_ESP32.h new file mode 100644 index 000000000..3f1b2b8c6 --- /dev/null +++ b/tasmota/tasmota_template_ESP32.h @@ -0,0 +1,155 @@ +/* + tasmota_template_ESP32.h - template settings for Tasmota + + Copyright (C) 2020 Theo Arends + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef _TASMOTA_TEMPLATE_ESP32_H_ +#define _TASMOTA_TEMPLATE_ESP32_H_ + +#ifdef ESP32 + +// mqtt +#undef MQTT_LIBRARY_TYPE +#define MQTT_LIBRARY_TYPE MQTT_PUBSUBCLIENT +// Hardware has no ESP32 +#undef USE_TUYA_DIMMER +#undef USE_PWM_DIMMER +#undef USE_EXS_DIMMER +#undef USE_ARMTRONIX_DIMMERS +#undef USE_SONOFF_RF +#undef USE_SONOFF_SC +#undef USE_SONOFF_IFAN +#undef USE_SONOFF_L1 +#undef USE_SONOFF_D1 +#undef USE_RF_FLASH +// not ported +#undef USE_DISCOVERY +#undef USE_ADC_VCC // Needs to be ported +#undef USE_DEEPSLEEP +#undef USE_MY92X1 +#undef USE_TUYA_MCU +#undef USE_I2C +#undef USE_PS_16_DZ + +/********************************************************************************************/ +// Supported hardware modules +enum SupportedModules { + WEMOS, + ESP32_CAM, + MAXMODULE +}; + +const char kModuleNames[] PROGMEM = + "WeMos D1 ESP32|ESP32 CAM|" + ; + +// Default module settings +const uint8_t kModuleNiceList[MAXMODULE] PROGMEM = { + WEMOS, + ESP32_CAM +}; + +const mytmplt kModules[MAXMODULE] PROGMEM = { + { // "WeMos D1 ESP32", // Any ESP32 device like WeMos and NodeMCU hardware (ESP32) + GPIO_USER, //0 (I)O GPIO0, ADC2_CH1, TOUCH1, RTC_GPIO11, CLK_OUT1, EMAC_TX_CLK + GPIO_USER, //1 IO TXD0 GPIO1, U0TXD, CLK_OUT3, EMAC_RXD2 + GPIO_USER, //2 IO GPIO2, ADC2_CH2, TOUCH2, RTC_GPIO12, HSPIWP, HS2_DATA0, SD_DATA0 + GPIO_USER, //3 IO RXD0 GPIO3, U0RXD, CLK_OUT2 + GPIO_USER, //4 IO GPIO4, ADC2_CH0, TOUCH0, RTC_GPIO10, HSPIHD, HS2_DATA1, SD_DATA1, EMAC_TX_ER + GPIO_USER, //5 IO GPIO5, VSPICS0, HS1_DATA6, EMAC_RX_CLK + 0, //6 + 0, //7 + 0, //8 + 0, //9 + 0, //10 + 0, //11 + GPIO_USER, //12 (I)O GPIO12, ADC2_CH5, TOUCH5, RTC_GPIO15, MTDI, HSPIQ, HS2_DATA2, SD_DATA2, EMAC_TXD3 (If driven High, flash voltage (VDD_SDIO) is 1.8V not default 3.3V. Has internal pull-down, so unconnected = Low = 3.3V. May prevent flashing and/or booting if 3.3V flash is connected and pulled high. See ESP32 datasheet for more details.) + GPIO_USER, //13 IO GPIO13, ADC2_CH4, TOUCH4, RTC_GPIO14, MTCK, HSPID, HS2_DATA3, SD_DATA3, EMAC_RX_ER + GPIO_USER, //14 IO GPIO14, ADC2_CH6, TOUCH6, RTC_GPIO16, MTMS, HSPICLK, HS2_CLK, SD_CLK, EMAC_TXD2 + GPIO_USER, //15 (I)O GPIO15, ADC2_CH3, TOUCH3, MTDO, HSPICS0, RTC_GPIO13, HS2_CMD, SD_CMD, EMAC_RXD3 (If driven Low, silences boot messages from normal boot. Has internal pull-up, so unconnected = High = normal output.) + GPIO_USER, //16 IO GPIO16, HS1_DATA4, U2RXD, EMAC_CLK_OUT + GPIO_USER, //17 IO GPIO17, HS1_DATA5, U2TXD, EMAC_CLK_OUT_180 + GPIO_USER, //18 IO GPIO18, VSPICLK, HS1_DATA7 + GPIO_USER, //19 IO GPIO19, VSPIQ, U0CTS, EMAC_TXD0 + 0, //20 + 0, //21 IO GPIO21, VSPIHD, EMAC_TX_EN + GPIO_USER, //22 IO LED GPIO22, VSPIWP, U0RTS, EMAC_TXD1 + GPIO_USER, //23 IO GPIO23, VSPID, HS1_STROBE + 0, //24 + GPIO_USER, //25 IO GPIO25, DAC_1, ADC2_CH8, RTC_GPIO6, EMAC_RXD0 + GPIO_USER, //26 IO GPIO26, DAC_2, ADC2_CH9, RTC_GPIO7, EMAC_RXD1 + GPIO_USER, //27 IO GPIO27, ADC2_CH7, TOUCH7, RTC_GPIO17, EMAC_RX_DV + 0, //28 + 0, //29 + 0, //30 + 0, //31 + GPIO_USER, //32 IO GPIO32, XTAL_32K_P (32.768 kHz crystal oscillator input), ADC1_CH4, TOUCH9, RTC_GPIO9 + GPIO_USER, //33 IO GPIO33, XTAL_32K_N (32.768 kHz crystal oscillator output), ADC1_CH5, TOUCH8, RTC_GPIO8 + GPIO_USER, //34 I NO PULLUP GPIO34, ADC1_CH6, RTC_GPIO4 + GPIO_USER, //35 I NO PULLUP GPIO35, ADC1_CH7, RTC_GPIO5 + GPIO_USER, //36 I NO PULLUP GPIO36, SENSOR_VP, ADC_H, ADC1_CH0, RTC_GPIO0 + 0, //37 NO PULLUP + 0, //38 NO PULLUP + GPIO_USER //39 I NO PULLUP GPIO39, SENSOR_VN, ADC1_CH3, ADC_H, RTC_GPIO3 + }, + { //"ESP32 CAM", + GPIO_USER, //0 (I)O GPIO0, ADC2_CH1, TOUCH1, RTC_GPIO11, CLK_OUT1, EMAC_TX_CLK + GPIO_USER, //1 IO TXD0 GPIO1, U0TXD, CLK_OUT3, EMAC_RXD2 + GPIO_USER, //2 IO GPIO2, ADC2_CH2, TOUCH2, RTC_GPIO12, HSPIWP, HS2_DATA0, SD_DATA0 + GPIO_USER, //3 IO RXD0 GPIO3, U0RXD, CLK_OUT2 + GPIO_USER, //4 IO GPIO4, ADC2_CH0, TOUCH0, RTC_GPIO10, HSPIHD, HS2_DATA1, SD_DATA1, EMAC_TX_ER + GPIO_USER, //5 IO GPIO5, VSPICS0, HS1_DATA6, EMAC_RX_CLK + 0, //6 + 0, //7 + 0, //8 + 0, //9 + 0, //10 + 0, //11 + GPIO_USER, //12 (I)O GPIO12, ADC2_CH5, TOUCH5, RTC_GPIO15, MTDI, HSPIQ, HS2_DATA2, SD_DATA2, EMAC_TXD3 (If driven High, flash voltage (VDD_SDIO) is 1.8V not default 3.3V. Has internal pull-down, so unconnected = Low = 3.3V. May prevent flashing and/or booting if 3.3V flash is connected and pulled high. See ESP32 datasheet for more details.) + GPIO_USER, //13 IO GPIO13, ADC2_CH4, TOUCH4, RTC_GPIO14, MTCK, HSPID, HS2_DATA3, SD_DATA3, EMAC_RX_ER + GPIO_USER, //14 IO GPIO14, ADC2_CH6, TOUCH6, RTC_GPIO16, MTMS, HSPICLK, HS2_CLK, SD_CLK, EMAC_TXD2 + GPIO_USER, //15 (I)O GPIO15, ADC2_CH3, TOUCH3, MTDO, HSPICS0, RTC_GPIO13, HS2_CMD, SD_CMD, EMAC_RXD3 (If driven Low, silences boot messages from normal boot. Has internal pull-up, so unconnected = High = normal output.) + GPIO_USER, //16 IO GPIO16, HS1_DATA4, U2RXD, EMAC_CLK_OUT + GPIO_USER, //17 IO GPIO17, HS1_DATA5, U2TXD, EMAC_CLK_OUT_180 + GPIO_USER, //18 IO GPIO18, VSPICLK, HS1_DATA7 + GPIO_USER, //19 IO GPIO19, VSPIQ, U0CTS, EMAC_TXD0 + 0, //20 + 0, //21 IO GPIO21, VSPIHD, EMAC_TX_EN + GPIO_USER, //22 IO LED GPIO22, VSPIWP, U0RTS, EMAC_TXD1 + GPIO_USER, //23 IO GPIO23, VSPID, HS1_STROBE + 0, //24 + GPIO_USER, //25 IO GPIO25, DAC_1, ADC2_CH8, RTC_GPIO6, EMAC_RXD0 + GPIO_USER, //26 IO GPIO26, DAC_2, ADC2_CH9, RTC_GPIO7, EMAC_RXD1 + GPIO_USER, //27 IO GPIO27, ADC2_CH7, TOUCH7, RTC_GPIO17, EMAC_RX_DV + 0, //28 + 0, //29 + 0, //30 + 0, //31 + GPIO_USER, //32 IO GPIO32, XTAL_32K_P (32.768 kHz crystal oscillator input), ADC1_CH4, TOUCH9, RTC_GPIO9 + GPIO_USER, //33 IO GPIO33, XTAL_32K_N (32.768 kHz crystal oscillator output), ADC1_CH5, TOUCH8, RTC_GPIO8 + GPIO_USER, //34 I NO PULLUP GPIO34, ADC1_CH6, RTC_GPIO4 + GPIO_USER, //35 I NO PULLUP GPIO35, ADC1_CH7, RTC_GPIO5 + GPIO_USER, //36 I NO PULLUP GPIO36, SENSOR_VP, ADC_H, ADC1_CH0, RTC_GPIO0 + 0, //37 NO PULLUP + 0, //38 NO PULLUP + GPIO_USER //39 I NO PULLUP GPIO39, SENSOR_VN, ADC1_CH3, ADC_H, RTC_GPIO3 + } +}; + +#endif // ESP32 + +#endif // _TASMOTA_TEMPLATE_ESP32_H_ diff --git a/tasmota/xdrv_01_webserver.ino b/tasmota/xdrv_01_webserver.ino index 1a45434a3..4c0f6884e 100644 --- a/tasmota/xdrv_01_webserver.ino +++ b/tasmota/xdrv_01_webserver.ino @@ -48,7 +48,7 @@ enum UploadTypes { UPL_TASMOTA, UPL_SETTINGS, UPL_EFM8BB1, UPL_TASMOTASLAVE }; static const char * HEADER_KEYS[] = { "User-Agent", }; -const char HTTP_HEADER[] PROGMEM = +const char HTTP_HEADER1[] PROGMEM = "" "" "" @@ -848,7 +848,7 @@ void WSContentStart_P(const char* title, bool auth) if (title != nullptr) { char ctitle[strlen_P(title) +1]; strcpy_P(ctitle, title); // Get title from flash to RAM - WSContentSend_P(HTTP_HEADER, SettingsText(SET_FRIENDLYNAME1), ctitle); + WSContentSend_P(HTTP_HEADER1, SettingsText(SET_FRIENDLYNAME1), ctitle); } } @@ -2175,7 +2175,7 @@ void HandleInformation(void) WSContentSend_P(PSTR("}1}2 ")); // Empty line WSContentSend_P(PSTR("}1" D_ESP_CHIP_ID "}2%d"), ESP.getChipId()); - WSContentSend_P(PSTR("}1" D_FLASH_CHIP_ID "}20x%06X"), ESP.getFlashChipId()); + WSContentSend_P(PSTR("}1" D_FLASH_CHIP_ID "}20x%06X"), ESP_getFlashChipId()); WSContentSend_P(PSTR("}1" D_FLASH_CHIP_SIZE "}2%dkB"), ESP.getFlashChipRealSize() / 1024); WSContentSend_P(PSTR("}1" D_PROGRAM_FLASH_SIZE "}2%dkB"), ESP.getFlashChipSize() / 1024); WSContentSend_P(PSTR("}1" D_PROGRAM_SIZE "}2%dkB"), ESP.getSketchSize() / 1024); diff --git a/tasmota/xdrv_04_light.ino b/tasmota/xdrv_04_light.ino index 9b83a6879..21dd0f65f 100644 --- a/tasmota/xdrv_04_light.ino +++ b/tasmota/xdrv_04_light.ino @@ -1216,6 +1216,7 @@ bool LightModuleInit(void) if (XlgtCall(FUNC_MODULE_INIT)) { // serviced } +#ifdef ESP8266 else if (SONOFF_BN == my_module_type) { // PWM Single color led (White) light_type = LT_PWM1; } @@ -1234,6 +1235,7 @@ bool LightModuleInit(void) } light_type = LT_PWM2; } +#endif // ESP8266 if (light_type > LT_BASIC) { devices_present++; @@ -1701,12 +1703,12 @@ void LightAnimate(void) // or set a maximum of PWM_MAX_SLEEP if light is on or Fade is running if (Light.power || Light.fade_running) { if (Settings.sleep > PWM_MAX_SLEEP) { - sleep = PWM_MAX_SLEEP; // set a maxumum value of 50 milliseconds to ensure that animations are smooth + ssleep = PWM_MAX_SLEEP; // set a maxumum value of 50 milliseconds to ensure that animations are smooth } else { - sleep = Settings.sleep; // or keep the current sleep if it's lower than 50 + ssleep = Settings.sleep; // or keep the current sleep if it's lower than 50 } } else { - sleep = Settings.sleep; + ssleep = Settings.sleep; } if (!Light.power) { // All channels powered off @@ -1891,11 +1893,12 @@ void LightAnimate(void) bool isChannelGammaCorrected(uint32_t channel) { if (!Settings.light_correction) { return false; } // Gamma correction not activated if (channel >= Light.subtype) { return false; } // Out of range - +#ifdef ESP8266 if (PHILIPS == my_module_type) { if ((LST_COLDWARM == Light.subtype) && (1 == channel)) { return false; } // PMW reserved for CT if ((LST_RGBCW == Light.subtype) && (4 == channel)) { return false; } // PMW reserved for CT } +#endif // ESP8266 return true; } @@ -2070,6 +2073,7 @@ void calcGammaBulbs(uint16_t cur_col_10[5]) { uint16_t white_bri10 = cur_col_10[cw0] + cur_col_10[cw1]; // cumulated brightness uint16_t white_bri10_1023 = (white_bri10 > 1023) ? 1023 : white_bri10; // max 1023 +#ifdef ESP8266 if (PHILIPS == my_module_type) { // channel 1 is the color tone, mapped to cold channel (0..255) // Xiaomi Philips bulbs follow a different scheme: cur_col_10[cw1] = light_state.getCT10bits(); @@ -2079,7 +2083,9 @@ void calcGammaBulbs(uint16_t cur_col_10[5]) { } else { cur_col_10[cw0] = white_bri10_1023; // no gamma, extend to 10 bits } - } else if (Settings.light_correction) { + } else +#endif // ESP8266 + if (Settings.light_correction) { // if sum of both channels is > 255, then channels are probably uncorrelated if (white_bri10 <= 1031) { // take a margin of 8 above 1023 to account for rounding errors // we calculate the gamma corrected sum of CW + WW @@ -2631,7 +2637,9 @@ void CmndDimmerRange(void) Settings.dimmer_hw_min = parm[1]; Settings.dimmer_hw_max = parm[0]; } +#ifdef ESP8266 if (PWM_DIMMER != my_module_type) restart_flag = 2; +#endif // ESP8266 } Response_P(PSTR("{\"" D_CMND_DIMMER_RANGE "\":{\"Min\":%d,\"Max\":%d}}"), Settings.dimmer_hw_min, Settings.dimmer_hw_max); } diff --git a/tasmota/xdrv_06_snfbridge.ino b/tasmota/xdrv_06_snfbridge.ino index c8e9db67e..68365fceb 100644 --- a/tasmota/xdrv_06_snfbridge.ino +++ b/tasmota/xdrv_06_snfbridge.ino @@ -565,6 +565,7 @@ bool Xdrv06(uint8_t function) { bool result = false; +#ifdef ESP8266 if (SONOFF_BRIDGE == my_module_type) { switch (function) { case FUNC_SERIAL: @@ -582,6 +583,7 @@ bool Xdrv06(uint8_t function) break; } } +#endif // ESP8266 return result; } diff --git a/tasmota/xdrv_12_home_assistant.ino b/tasmota/xdrv_12_home_assistant.ino index e3ba4670d..3794ba072 100644 --- a/tasmota/xdrv_12_home_assistant.ino +++ b/tasmota/xdrv_12_home_assistant.ino @@ -213,7 +213,11 @@ void HAssAnnounceRelayLight(void) TryResponseAppend_P(HASS_DISCOVER_DEVICE_INFO_SHORT, unique_id, ESP.getChipId()); #ifdef USE_LIGHT - if (is_light || PWM_DIMMER == my_module_type) + if (is_light +#ifdef ESP8266 + || PWM_DIMMER == my_module_type +#endif + ) { char *brightness_command_topic = stemp1; @@ -423,10 +427,13 @@ void HAssAnnounceButtons(void) uint8_t toggle = 1; uint8_t hold = 0; +#ifdef ESP8266 if (!button_index && ((SONOFF_DUAL == my_module_type) || (CH4 == my_module_type))) { button_present = 1; - } else { + } else +#endif + { if (pin[GPIO_KEY1 + button_index] < 99) { button_present = 1; } @@ -481,8 +488,8 @@ void HAssAnnounceSensor(const char *sensorname, const char *subsensortype, const char subname[20]; mqtt_data[0] = '\0'; // Clear retained message - - // Clear or Set topic + + // Clear or Set topic NoAlNumToUnderscore(subname, MultiSubName); //Replace all non alphaumeric characters to '_' to avoid topic name issues snprintf_P(unique_id, sizeof(unique_id), PSTR("%06X_%s_%s"), ESP.getChipId(), sensorname, subname); snprintf_P(stopic, sizeof(stopic), PSTR(HOME_ASSISTANT_DISCOVERY_PREFIX "/sensor/%s/config"), unique_id); @@ -517,7 +524,7 @@ void HAssAnnounceSensor(const char *sensorname, const char *subsensortype, const case 3: snprintf_P(param1, sizeof(param1), PSTR("%s"), PressureUnit().c_str()); break; - // case 4: // Speed. Default to km/h if not set to have a graph representation under HAss + // case 4: // Speed. Default to km/h if not set to have a graph representation under HAss // case 5: // case 6: // case 7: @@ -596,8 +603,8 @@ void HAssAnnounceSensors(void) for (auto subsensor : subsensors) { snprintf_P(NewSensorName, sizeof(NewSensorName), PSTR("%s %s"), NestedName, subsensor.key); HAssAnnounceSensor(sensorname, NestedName, NewSensorName, 0, 0, 1, subsensor.key); - } - } else if (subsensor.value.is()) { + } + } else if (subsensor.value.is()) { // If there is more than a value on sensor data, 'n' entitites will be created JsonArray& subsensors = subsensor.value.as(); uint8_t subqty = subsensors.size(); diff --git a/tasmota/xdrv_13_display.ino b/tasmota/xdrv_13_display.ino index 117725024..e490d0bd1 100644 --- a/tasmota/xdrv_13_display.ino +++ b/tasmota/xdrv_13_display.ino @@ -838,7 +838,7 @@ void DisplayText(void) if (!fill) { *dp = 0; } else { - linebuf[abs(fill)] = 0; + linebuf[abs(int(fill))] = 0; } if (fill<0) { // right align diff --git a/tasmota/xsns_37_rfsensor.ino b/tasmota/xsns_37_rfsensor.ino index d58e06b66..87ce5c9d7 100644 --- a/tasmota/xsns_37_rfsensor.ino +++ b/tasmota/xsns_37_rfsensor.ino @@ -665,7 +665,7 @@ bool Xsns37(uint8_t function) RfSnsAnalyzeRawSignal(); } } - sleep = 0; + ssleep = 0; break; case FUNC_EVERY_SECOND: RfSnsEverySecond();