Die fertigen Images findet ihr im Release Bereich. Einfach das korrekte Image für euren ESP herunterladen, entpacken und entweder über OTA oder über einen Flasher+Kabel übertragen. Eine ausführliche Anleitung dazu findet ihr auf meiner Homepage -> eine neue Kurzanleitung nur für TinyC findet ihr hier oder hier auf dieser Seite. Welche Tasmota Features aktiviert/deaktiviert sind findet ihr im Release.
Download Statistik
ottelo.jimdofree.com
- Features
- Welches Image (Firmware Binary) für welchen ESP?
- (Factory)Image übertragen / flashen
- Passende Tasmota Scripte / TinyC Programme
- Projekte, die diese Images nutzen
- Shelly / Marstek CT002 / EcoTracker Emulation für smarte Akkus
- TinyC (löst Script ab!)
- Partitionslayout für TinyC-Images
- Tasmota Image selbst erstellen - Anleitung für ESP32 / ESP8266
- Welche Images welchen Funktionsumfang bieten, könnt ihr anhand dieser Features/Treiber erkennen
- Safeboot aktualisieren (wird i.d.R. nicht benötigt)
- Lizenz
| Feature | Was es macht | Hilfe |
|---|---|---|
| 📊 Strom zählen und anzeigen | Verbrauch und Einspeisung in Echtzeit, Diagramme für die letzten Minuten und 24 Stunden, Balken für Tage, Wochen, Monate und Jahre | Diagramme |
| 🔢 Über 140 Zähler zur Auswahl | Zähler im Menü auswählen, Lesekopf-Pins einstellen, fertig - auch für Gas- und Wasserzähler | Zähler, Gas/Wasser |
| 🔌 Schnittstellen: MQTT, Home Assistant, HTTP, Modbus TCP | Werte per MQTT (auch geglättet), in Home Assistant über die Tasmota-Integration, per HTTP (/pwr) und als Modbus-TCP-Server |
MQTT/HTTP, Modbus TCP |
| 🔋 Für viele PV-Akkus und Steuerungen | Marstek, Hoymiles, Growatt NOAH u. a. über die Emulatoren; openDTU-OnBattery, AhoyDTU und andere holen sich die Netzleistung per HTTP, MQTT oder Modbus TCP | Werte abfragen |
| ☀️ PV-Überschuss-Schalter | Schaltet ein anderes Tasmota-Gerät (z. B. Heizstab, Steckdose) bei Überschuss ein und wieder aus | PV-Schalter |
| 💾 FTP-Backup | Sichert Zählerstände und Diagrammdaten jede Nacht auf eine FRITZ!Box oder ein NAS | FTP-Backup |
| 🚗 go-e Charger: E-Auto mit PV-Überschuss laden | Das Zusatzprogramm MQTT-Push schickt die Netzleistung alle paar Sekunden per MQTT an die go-e-Wallbox, die damit nur mit Überschuss lädt | MQTT-Push |
| 🔋 Shelly / EcoTracker Emulator (Nulleinspeisung) | Der ESP gibt sich als Shelly Pro 3EM oder EcoTracker aus. Smarte Akkus (z. B. Marstek, Hoymiles, Growatt NOAH) speisen dann genau so viel ein, wie gerade verbraucht wird | EcoTracker / Shelly |
| 🔋 Marstek CT002 / CT003 Emulator (Nulleinspeisung) | Der ESP gibt sich als Marstek-Zähler CT002/CT003 aus, für Marstek-Akkus (Venus, Jupiter, B2500), mehrere Akkus gleichzeitig | Marstek CT002 |
Wichtig — Varianten-Suffix: Jedes ESP32-Image gibt es in zwei Varianten (ESP8266 nur _tas):
_tas→ klassischer Tasmota-Scripter + Google Charts (wie bisher)_tc→ TinyC VM + Browser-IDE (kein Scripter)
| Imagename | Beschreibung |
|---|---|
| ESP32 Images: | tasmota32xx_ottelo.zip |
| tasmota32_ottelo_tas / _tc | Generic ESP32, mit Ethernet Support |
| tasmota32x_ottelo_tas / _tc | ESP32 Variante z.B. c3, c6, s2, s3, solo1, p4, p4r3 (solo1, s3, p4, p4r3 mit Ethernet Support; p4r3 nur als _tc) |
| ESP8266 Images: | tasmota8266_bundle_ottelo.zip |
| Hinweis: | Ab V15.1.0 können nur die Scripte im Ordner ESP8266 verwendet werden! In den entsprechenden komprimiert Ordnern sind die Scripte ohne Kommentare, sie können 1:1 kopiert werden. |
| tasmota1m_ottelo_tas | ESP mit 1M Flash (z.B. ESP01s = Hichi v1 Lesekopf). Nur Scripter (kein UFILESYS → kein TinyC). |
| tasmota4m_ottelo_tas | ESP mit 4M+ Flash. Nur Scripter (kein _tc — ESP8266 4M hat kein I2C für den BinPlugin-Loader, und TinyC lohnt bei dem RAM kaum). Mit Shelly Pro 3EM / EcoTracker Emulation (+mDNS) als Meter für smarte Akkus (z.B. Marstek Venus / Jupiter) und für Steckdosen mit Energiemessung (mit 4M Speicher). |
| tasmota1m_energy_ottelo_tas | ESP mit 1M Flash für Steckdosen mit Energiemessung z.B. Nous A1T, Sonoff Pow R2, Gosund EP2. Nur Scripter. Web-Upgrade nur über tasmota-minimal! |
| tasmota1m_shelly_ottelo_tas | ESP mit 1M Flash. Mit Shelly Pro 3EM / EcoTracker Emulation (+mDNS) als Meter für smarte Akkus (z.B. Marstek Venus / Jupiter). Nur Scripter. Der Scriptspeicher ist auf 4096 Zeichen begrenzt (statt 8192). Für Scripte siehe, ESP8266 Scripte - Ordner komprimiert. HomeAssistant/MQTT aber weiterhin möglich. Web-Upgrade nur über tasmota-minimal! |
| tasmota1m_ct002_ottelo_tas | Wie tasmota1m_shelly, aber ohne mDNS (keine Shelly/EcoTracker-Emulation), dafür mit der Seite Marstek CT002 (/ctreg, unter Tools) zur einmaligen Anmeldung des CT002-Emulators in der Marstek-Cloud. Für das CT002-Emulator-Script (bis zu 4 Marstek-Akkus). Web-Upgrade nur über tasmota-minimal! |
| tasmota-minimal | Minimalimage, siehe Beschreibung unten oder tasmota_energy_ottelo |
Die Images sind alle gezippt. Im ZIP-Archiv befindet sich für den ESP32 immer auch das factory Image. Das wird beim erstmaligen Flashen auf einen leeren ESP32 benötigt bzw. wenn vorher noch kein Tasmota drauf war. Im ZIP-Archiv für den ESP8266 befinden sich alle Varianten gesammelt im bin.gz Format. Das .bin.gz muss immer für das Firmware-Upgrade via "Use file upload" über den Webbrowser verwendet werden, da das nicht komprimierte .bin Image sonst nicht übertragen werden kann (zu wenig Flash-Speicher). Falls es mal doch nicht passenden sollte (Fehlermeldung), dann muss vorher einmal das tasmota-minimal.bin.gz Image übertragen werden. Anschließend kann das .bin.gz Image übertragen werden. Zum erstmaligen Flashen via USB-Flasher muss die .gz entpackt werden.
Falls Tasmota bereits auf dem ESP ist, werden die Images einfach via OTA übertragen (Firmware Upgrade -> Use file upload)
Ist das nicht der Fall muss das (Factory ESP32) Image (.bin) geflasht werden z.B. mit Tasmota Web Installer
I.d.R. haben die ESP Boards eine USB-Buchse, die am PC einen COM-Port zur Verfügung stellen. Über diese wird das Image dann geflasht. Ist sowas nicht vorhanden braucht ihr einen USB-Seriell Adapter.
Die wählt ihr direkt auf eurem ESP in Tasmota aus: Tools > Edit Script oder Tools > TinyC Console > Repo
Den Sourcecode der Programme findet ihr hier.
Diese Projekte von mir laufen auf den Images hier:
| Projekt | Beschreibung | Image |
|---|---|---|
| tasmota-sml-script | Stromzähler auslesen (SML) mit Charts, Shelly / EcoTracker / CT002 Emulation für smarte Akkus | _tas (Scripte) oder _tc (TinyC Programme) |
| syrup | SYR Safe-T+ Connect Leckageschutz ohne Cloud auslesen. Das TinyC Programm hört passiv am RS-485 Servicebus des Geräts mit | _tc (ESP32) |
| Shimano-Steps-Simulator-BT-E6000 | Shimano Steps Akku BT-E6000: Akku oder Motor simulieren, Akku ohne Original-Ladegerät laden, Protokoll mitschneiden | _tc (ESP32) |
Shelly / Marstek CT002 / EcoTracker Emulation für smarte Akkus (wie z.B. Marstek Venus C,E, Jupiter, Hoymiles, Growatt NOAH 2000)
Kompatible Akku Liste
Ab V15.0.1 habe ich den Support für die Emulation des Shelly/EcoTracker inkludiert. Die Emulation ist in allen ESP32 Images inkludiert. Für den ESP8266 habe ich eine abgespeckte Firmware erstellt (tasmota1m_shelly), dort funktionieren nur die kleinen Basisscripte (_Simple.tas findet ihr im ESP8266 Ordner). Die Scripte findet ihr direkt auf euren ESP in Tasmota (DropDown) oder hier. Eine Anleitung habe ich auf meinem Blog veröffentlicht.
Für den Marstek CT002 Emulator auf dem ESP8266 (Script 2_CT002_Emulator.tas von next145, bis zu 4 Marstek-Akkus) gibt es das eigene Image tasmota1m_ct002. Es hat zusätzlich die Seite Marstek CT002 (/ctreg, unter Tools), über die der CT002 einmalig in der Marstek-Cloud angemeldet wird.
Ich habe fast alle meine Tasmota Scripte von inkl. den Ecotracker/Shelly Emulatoren auf TinyC konvertiert. Wenn ihr neu dabei seid, würde ich euch empfehlen direkt mit TinyC anzufangen statt Script.
Image-Variante wählen:
Es gibt pro ESP32-Plattform getrennte Images — *_ottelo_tas mit Scripter (wie bisher) oder *_ottelo_tc mit TinyC ohne Scripter. Beides gleichzeitig biete ich nicht an. ESP8266 gibt es nur als _tas.
Fertige TinyC Programme laden
Unter Tools > TinyC Console > Repository findet ihr eine Liste mit meinen TinyC Programmen (wie Scripte). Einfach auswählen und "Download & Load" Slot 0 wählen. Ist bereits ein Programm im Slot 0, wird es entladen und das neue geladen. Wenn zuwenig RAM frei ist schlägt das fehl und man muss 1x neustarten und dann das Programm nochmal laden.
In der Slot-Liste steht hinter dem Programmnamen seine Version (Datum und Uhrzeit). Gibt es im Repository eine neuere, erscheint daneben ein 🔄-Knopf mit dem neuen Datum: ein Klick lädt sie in denselben Slot, eure Einstellungen und Daten bleiben erhalten.
Eigene Programme schreiben
Ihr könnt eure Programme direkt auf dem ESP in Tasmota schreiben und ausführen, in einer webbasierten TinyC-IDE. In der IDE sind sehr viele Beispiele (von gemu) im DropDown Menü wählbar. Der Sourcecode und auch das kompilierte Programm wird im Dateisystem von Tasmota gespeichert. Es können sogar mehrere Programme parallel ausgeführt werden (Slots). Und ihr könnt einfach alles in C-Code schreiben, statt kompliziertes Script.
=> hier findet ihr die offizielle TinyC Hilfeseite.
=> Die neuste TinyC-IDE kann online gestartet werden via "Run IDE from repo" (aus gemus Repo) oder auf den ESP geladen werden via "Update IDE" (aus meiner Repo). Eine Kopie der TinyC-IDE, mit der ich meine Images gebaut habe, findet ihr sonst auch hier tinyc_ide.html.gz. Via File Upload auf euren ESP laden (Tools > Manage File System).
TinyC speichert Bytecode (.tcb), persist-Daten (.pvs) und /sml_meter.def im Filesystem. Default-Layout (app2880k_fs320k) hat nur 320 KB FS — bei TinyC wird's schnell eng. Gleichzeitig ist die TinyC-Firmware ~120 KB schlanker als Scripter+Charts, der App-Bereich kann also kleiner sein.
Deswegen nutzen die _tc-Images auf 4 MB-Boards das Layout esp32_partition_app1856k_fs1344k.csv: 1856 KB app0 + 1344 KB FS (statt 2880 KB / 320 KB). Siehe auch Discussion #37 und Tasmota Safeboot-Doku.
| Image | Partition |
|---|---|
tasmota32_ottelo_tc, tasmota32c3_ottelo_tc, tasmota32c6_ottelo_tc, tasmota32s2_ottelo_tc, tasmota32solo1_ottelo_tc |
app1856k_fs1344k (1024 KB mehr FS) |
tasmota32s3_ottelo_tc |
Default (16 MB Flash: app3904k_fs11584k) |
tasmota32p4_ottelo_tc |
Default (boardabhängig) |
tasmota32p4r3_ottelo_tc |
Default (16 MB Flash: app3904k_fs11584k) |
alle _tas |
Default belassen |
In meinen Tasmota Images ist ein Partition-Manager eingebaut — du brauchst kein USB-Kabel und keinen Factory-Flash, um das Layout zu ändern. Im TinyC-Build heißt der Befehl TinyCChkpt, in Builds ohne TinyC chkpt.
Befehle:
| Befehl | Wirkung |
|---|---|
TinyCChkpt |
Aktuelles Partition-Layout anzeigen |
TinyCChkpt p |
Auto-Pack: app0 auf Firmware-Größe + ~200 KB Overhead schrumpfen, Rest an FS |
TinyCChkpt p 1856 |
app0 explizit auf 1856 KB setzen, Rest an FS (FS wird formatiert!) |
TinyCChkpt p 2880 |
Zurück zum Default-Layout (wenn die laufende Firmware reinpasst) |
Praktischer Workflow (Lesegerät im Einsatz, kein Aufschrauben):
- Files via WebUI → "Manage File System" sichern.
- OTA-Upgrade auf das neue
_tc-Image (.binüber "Firmware Upgrade → Use file upload"). Das überschreibt nur app0, Partitionen bleiben unverändert. - Nach dem Reboot in der Konsole:
TinyCChkpt p 1856→ packt um, formatiert FS, rebootet automatisch. - Files wieder hochladen.
Voraussetzungen / Probleme:
- Safeboot darf nicht zu alt sein Ohne passendes Safeboot lehnt
chkpt pab. Die Version des Safeboots erkennt ihr, wenn ihr ein Update macht. Tasmota bootet dann in den Safeboot. Ab 15.x sollteTinyCChkptfunktionieren. Wie ihr das Safeboot Images aktualisiert findet ihr weiter unten. - Neue app0 ≥ laufende Firmware. Sonst meldet der Befehl
requested size too small for current firmware!und macht nichts.
Factory-Flash brauchst du nur noch, wenn:
- Das Image zu groß für die aktuell konfigurierte app0 ist,
- Ein zu altes Safeboot-Image vorhanden ist < 15.x,
- Du das Layout sauber neu aufsetzen willst (z.B. nach einem unsauberen
chkpt-Abbruch).
In der user_config_override.h findet ihr eine Liste mit Features/Treibern (#define bzw. #undef), die ich für meine ESP Tasmota Images/Firmware verwende und auf ottelo.jimdofree.com zum Download anbiete. Die hier hochgeladenen Dateien können euch dabei helfen, ein eigenes angepasstes Tasmota Image für euren ESP mit Gitpod (oder Visual Studio) zu erstellen, wenn ihr mit dem ESP ein Stromzähler über ein Lesekopf auslesen wollt (SML) oder eine smarte Steckdose mit Energiemessfunktion (SonOff, Gosund, Shelly) habt und ihr die Liniendiagramme (Google Chart Script) für den Verbrauch haben wollt. Das passende Script findet ihr in meinem anderen Repo https://github.com/ottelo9/tasmota-sml-script.
Die Dateien aus meinem Repo in euer Tasmota Projektverzeichnis (Tasmota 16.0.0) von Visual Studio Code kopieren und überschreiben!! Basis ist der offizielle Tasmota Source in der jeweiligen Release-Version. (Liste kann unvollständig sein)
A) Meine Build-Konfiguration (die braucht ihr immer)
- TasmotaProjekt/
tasmota/user_config_override.h— alle Features/Treiber (#define / #undef) + die_tas/_tc-Variantenlogik - TasmotaProjekt/
platformio_tasmota_cenv.ini— meine Build-Umgebungen (envs) mitlib_ignore, Partitionen,-D-Flags - TasmotaProjekt/
safeboot_alias.py— holt beim Kompilieren das offizielle Safeboot für die .factory Images (muss mit kopiert werden) - TasmotaProjekt/
ccache_wrapper.py— siehe ccache weiter unten (muss mit kopiert werden, auch wenn ihr ccache nicht nutzt) - Boards und Partitionstabellen bringt das offizielle Tasmota mit, eigene braucht es nicht mehr.
Bei PSRAM-Problemen auf dem S3 auf
esp32s3-qioumstellen, siehe Issue 32 (Kommentar dazu steht inplatformio_tasmota_cenv.ini)
B) Sourcen aus der gemu2015 Repo (Scripter / SML / TinyC — im offiziellen Tasmota nicht oder nur älter enthalten)
- TasmotaProjekt/tasmota/tasmota_xdrv_driver/...
- TasmotaProjekt/tasmota/tasmota_xsns_sensor/...
- TasmotaProjekt/tasmota/include/...
- TasmotaProjekt/tasmota/...
- TasmotaProjekt/lib/...
C) Meine eigenen Patches am offiziellen Tasmota-Code
- TasmotaProjekt/tasmota/
tasmota.ino—image_name-Buffer von 33 auf 64 Bytes erweitert, damit langeCODE_IMAGE_STR(z.B.ESP32-C3 TC ottelo.jimdofree.com) nicht abgeschnitten werden - TasmotaProjekt/tasmota/tasmota_xdrv_driver/
xdrv_01_9_webserver.ino— HTTP-Footer auf zwei Zeilen aufgeteilt: Zeile 1Tasmota <version> <image_name>, Zeile 2Tasmota developed by Theo Arends (Build <Datum>) - TasmotaProjekt/tasmota/tasmota_xdrv_driver/
xdrv_82_esp32_ethernet.ino— Fix für das Modul WT32-ETH01: Tasmota setzt dort einen falschen EthType, dadurch geht LAN nicht (Issue 68)
D) Zum Flashen / Ausliefern
tinyc_ide.html.gz(in meiner Script-Repo) — die TinyC-IDE, kommt nicht ins Projektverzeichnis, sondern via File Upload auf den ESP (Tools > Manage File System)make_tasmota_zips_extended.sh— packt nach dem Build die Release-ZIPs, siehe unten
Hinweis: Welche gemu2015-Commit-Version ich zuletzt übernommen habe, steht in
gemu2015 Repo Update.txt.
Eine weitere ausführliche Anleitung zum Einrichten von Tasmota und weitere Details findet ihr auf meinem Blog: https://ottelo.jimdofree.com
Zum Kompilieren unter VSC den passenden Befehl in die Console eingeben:
Die Safeboot Images (kommen in die .factory Images, wie ein Bootloader) müssen nicht mehr selbst erstellt werden: Beim Kompilieren wird das offizielle Safeboot des Chips automatisch von ota.tasmota.com geladen (safeboot_alias.py).
Bei den ESP32-Images mit Bluetooth-Funk (ESP32, C3, C6, S3, SOLO1) ist Bluetooth im SDK abgeschaltet ([bt_off] in platformio_tasmota_cenv.ini). Dafür baut PlatformIO das ESP-IDF selbst, der erste Build je Chip dauert deshalb ein paar Minuten länger.
Die einzelnen Images werden so erstellt (landen dann im Ordner build_output). Suffix _tas = Scripter, _tc = TinyC:
ESP32 (Scripter-Variante _tas):
pio run -e tasmota32_ottelo_tas (Generic ESP32)
pio run -e tasmota32s2_ottelo_tas
pio run -e tasmota32s3_ottelo_tas
pio run -e tasmota32c3_ottelo_tas
pio run -e tasmota32c6_ottelo_tas
pio run -e tasmota32solo1_ottelo_tas (für ESP32-S1 Single Core z.B. WT32-ETH01 v1.1)
pio run -e tasmota32p4_ottelo_tas
ESP32 (TinyC-Variante _tc):
pio run -e tasmota32_ottelo_tc
pio run -e tasmota32s2_ottelo_tc
pio run -e tasmota32s3_ottelo_tc
pio run -e tasmota32c3_ottelo_tc
pio run -e tasmota32c6_ottelo_tc
pio run -e tasmota32solo1_ottelo_tc
pio run -e tasmota32p4_ottelo_tc
pio run -e tasmota32p4r3_ottelo_tc (ESP32-P4 ab Revision 3, nur _tc)
ESP8266:
pio run -e tasmota1m_ottelo_tas ( = 1M Flash, nur Scripter)
pio run -e tasmota1m_energy_ottelo_tas ( = 1M Flash, nur Scripter. Update nur über minimal Image. Für SonOff POW (R2) / Gosund EP2 / SonOff Dual R3 v2 / Nous A1T)
pio run -e tasmota1m_shelly_ottelo_tas ( = 1M Flash, nur Scripter. Update nur über minimal Image. Für Shelly/EcoTracker Emu Scripte für smarte Akkus wie z.B. Marstek (Venus, Jupiter, B2500) oder Hoymiles (MS-A2))
pio run -e tasmota1m_ct002_ottelo_tas ( = wie tasmota1m_shelly ohne mDNS, plus /ctreg zur Marstek-Anmeldung für den CT002-Emulator)
pio run -e tasmota4m_ottelo_tas (>= 4M Flash, nur Scripter — kein _tc, ESP8266 4M hat kein I2C für den BinPlugin-Loader)
Um alle gleichzeitig zu erstellen (Bash + jq):
pio run $(pio project config --json-output | jq -r '.[] | .[0] | select(test("_ottelo_(tc|tas)$")) | sub("env:"; "-e ")')
PowerShell:
$envs = pio project config --json-output | jq -r '.[][0] | select(test("_ottelo_(tc|tas)$")) | sub("env:"; "-e ")'
pio run ($envs -split "`n")Wenn ihr mehrere Varianten hintereinander baut (_tas + _tc, oder mehrere Plattformen), kompiliert PlatformIO jede env komplett neu — der eingebaute build_cache_dir (PIO's eigener Object-Cache) greift nur innerhalb derselben env, weil andere -D-Flags andere Object-Hashes erzeugen.
ccache ergänzt das als zweite Stufe im Preprocessor-Mode: Files wie lwip/freertos/lvgl/esp32-arduino-core, die OTTELO_VARIANT_* gar nicht sehen, haben in beiden Builds identischen Preprocessor-Output → Cache-Hit. Bei einem Build-Paar _tas + _tc derselben Plattform werden typisch ~95 % der Files aus dem ccache wiederverwendet. Spart bei kompletten Multi-Variant-Builds 60–75 % Wallclock-Zeit.
Setup (einmalig):
-
ccache installieren:
- Linux/Gitpod/VMware-Ubuntu:
sudo apt-get install ccache - macOS:
brew install ccache - Windows:
choco install ccache(alternativ Scoop/MSYS2)
- Linux/Gitpod/VMware-Ubuntu:
-
Cache-Größe und sloppiness konfigurieren — ohne diese Settings bleibt die Hit-Rate bei 0 %, weil Tasmota
__DATE__/__TIME__/ Build-Counter in den Sources hat:ccache -M 4G ccache --set-config sloppiness=time_macros,pch_defines,include_file_mtime,include_file_ctime,locale,system_headers ccache --set-config hash_dir=false ccache --set-config compiler_check=content
Was die einzeln machen:
time_macros→__DATE__/__TIME__werden beim Hashing ignoriertpch_defines→ Header-Defines beeinflussen Hash nicht künstlichinclude_file_mtime,include_file_ctime→ Header-Zeitstempel werden ignorierthash_dir=false→ Build-Verzeichnis-Pfad geht nicht in den Hash (essenziell für_tas/_tc-Cross-Hits)compiler_check=content→ Compiler-Binary-Hash statt mtime (kein Miss nach PIO-Update)
-
Settings verifizieren:
ccache --get-config sloppiness ccache --get-config hash_dir ccache --get-config compiler_check
-
Die
ccache_wrapper.pyaus diesem Repo mit ins Tasmota-Root kopieren (nebenplatformio.ini). -
In
platformio_tasmota_cenv.iniist das Script im[env:tasmota_ottelo_base]als Pre-Hook eingetragen und wird von allen_ottelo_tas/_tc-Envs geerbt — also nichts mehr zu tun.
Funktionscheck nach einem Build:
ccache -sErwartete Zeilen nach dem ersten Build:
Cacheable calls: 384 / 384 (100 %)
Hits: 0 / 384 (0 %)
Misses: 384 / 384 (100 %)
Erwartete Zeilen nach einem zweiten Build (andere Variante derselben Plattform, z.B. _tc nach _tas):
Cacheable calls: 764 / 764 (100 %)
Hits: 380 / 764 (~50 %) ← die ~95% Cache-Hits aus dem TC-Build
Preprocessed: 380 / 380 (100 %)
Misses: 384 / 764
Im Build-Output erscheint außerdem direkt am Anfang:
[ccache_wrapper] aktiv: /usr/bin/ccache
[ccache_wrapper] patched: CCCOM, CXXCOM, SHCCCOM, SHCXXCOM
Wenn der Cache leer bleibt / 0 % Hits:
- Im Output
[ccache_wrapper]-Zeile checken — wenn die fehlt, läuft das Pre-Script nicht (Pfad/extra_scripts-Vererbung prüfen). ccache --get-config sloppinesszeigen lassen — wenntime_macrosfehlt, alle Misses durch__DATE__/__TIME__.- Für einen sauberen Cross-Env-Test (PIO-Cache stört sonst):
rm -rf .cache .pio/build ccache -C && ccache -z pio run -e tasmota32c3_ottelo_tas # Build #1: füllt ccache pio run -e tasmota32c3_ottelo_tc # Build #2: zieht aus ccache ccache -s
Hinweis zu PIO's eigenem Cache (.cache/ im Tasmota-Root):
Tasmota's platformio.ini setzt build_cache_dir = .cache — das ist PIO's eigener Object-Cache (Stufe 1), unabhängig von ccache (Stufe 2). PIO-Cache greift bei gleicher Env (z.B. zweiter Build derselben _tc-Variante), ccache zusätzlich bei Env-Wechsel (_tas ↔ _tc). Beide aktiv lassen — sie ergänzen sich.
Nach dem Bauen aller Envs liegen die Firmware-Dateien (*.bin, *.factory.bin, *.bin.gz) in Tasmota-xxx/build_output/firmware/. Das mitgelieferte make_tasmota_zips_extended.sh erstellt daraus die Release-ZIPs pro Plattform und Variante.
Verwendung:
-
Script in das Firmware-Output-Verzeichnis kopieren:
cp /pfad/zu/tasmota-sml-images/make_tasmota_zips_extended.sh \ ~/Tasmota-16.0.0/build_output/firmware/ -
Ins Verzeichnis wechseln und ausführen:
cd ~/Tasmota-16.0.0/build_output/firmware chmod +x make_tasmota_zips_extended.sh ./make_tasmota_zips_extended.sh
-
Die ZIPs landen im Unterordner
tasmota_zips/:tasmota8266_bundle_ottelo.zip— alle ESP8266-Builds gebündelt + tasmota-minimaltasmota32<board>_ottelo_tas.zip/_tc.zip— pro ESP32-Plattform jeweils zwei ZIPs (Scripter / TinyC), P4 Rev.3 nur TinyC, insgesamt 15 Stücktasmota32s3_dfr1154.zip— das Kamera-Image (DFR1154)
Verhalten bei fehlenden Builds: Wenn eine erwartete Datei fehlt (z.B. C6 oder P4 nicht gebaut), meldet das Script FEHLER: Datei fehlt: … und überspringt nur dieses eine ZIP — die anderen werden weiterhin erstellt.
- Beim Übertragen eines Images (z.B. tasmota1m_shelly_ottelo) für ESP8266 via OTA (Use file upload) bekomme ich folgenden Fehler:
Upload Failed. Not enough space.Das liegt daran, dass der ESP zu wenig Speicher hat. Verwende zuerst das tasmota-minimal.bin Image, danach kannst du dann das normale Image übertragen.
Mehr Infos bzgl. ESP32 Versionen:
https://tasmota.github.io/docs/ESP32/#esp32_1
Für weitere ESPs siehe:
https://github.com/arendst/Tasmota/blob/development/platformio_override_sample.ini bei default_envs
Features/Treiber (de)aktivieren:
https://tasmota.github.io/docs/Compile-your-build/#enabling-a-feature-in-tasmota
Hier ist eine Übersicht aller Features/Treiber:
https://github.com/arendst/Tasmota/blob/development/tasmota/my_user_config.h
Wenn beim Kompilieren eine Standard Tasmota Variante verwendet wird (z.B. -e tasmota32c3), dann werden Features/Treiber für diese Konfiguration
(siehe https://github.com/arendst/Tasmota/blob/development/platformio_tasmota_env32.ini z.B. [env:tasmota32c3]) verwendet und die deaktivierten Features,
die ihr in der user_config_override.h eingetragen habt, überschrieben und somit doch verwendet!
Wenn Features/Treiber (de)aktivieren werden sollen, dann eine eigene Variante in platformio_tasmota_cenv.ini erstellen und -DFIRMWARE_TASMOTA32 entfernen,
da wie bereits oben erwähnt, ESP32 Standard Features wie Berry usw verwendet werden (siehe FIRMWARE_TASMOTA32 in tasmota_configuration_ESP32.h).
Siehe auch https://tasmota.github.io/docs/Compile-your-build/#customize-your-build
Noch eine Info:
Die Platform (ESP32-Framework) kommt aus dem offiziellen Tasmota (platformio_tasmota32.ini), dort muss nichts angepasst werden.
Offizielle Tasmota Github Seite
UDP/HTTP/PING Tester
Ihr könnt die Emus mit meinem PowerScript Tool testen (UDP, HTTP Get, Ping):

SML Simulator
Gemu2015 hat ein SML Simulator Tool (simuliert einen x-beliebigen Stromzähler) für den Google Chrome Browser erstellt. Zum Simulieren eines Stromzählers wird ein USB Lesekopf am PC benötigt. Das Tool kann auch Zählerscripte (Meter Descriptor) erstellen und auch direkt an Tasmota senden. Wieso Google Chrome Browser? Nur Chrome unterstützt das serielle Interface.

Falls Tasmota mal ab und zu aus unbekannten Gründen neustarten (Reboots) sollte, gibt es mehrere Möglichkeiten die Ursache des Problems festzustellen.
ESP via USB mit dem PC verbinden und ein Terminalprogramm (putty oder MobaXterm) laufen (loggen) lassen bis der Reboot passiert. Tasmota gibt dann beim Crash/Reboot ein Crash Dump aus. Das könnte z.B. so aussehen:
Guru Meditation Error: Core 0 panic'ed (Stack protection fault).
Detected in task "loopTask" at 0x42023fee
Hat man das Image selbst kompiliert, so kann man in der .map Datei nach der Adresse 0x42023fee bzw. 0x42023* suchen. Die map Datei liegt unter \.pio\build\tasmota32xxx\firmware.map.
Dort findet man dann die Funktion, in der das Problem (in diesem Fall Buffer Overflow) aufgetaucht ist. Die genaue Stelle kann man nur herausfinden, wenn man die firmware.asm Datei hat.
Die wird erst erstellt, wenn man folgendes mit in die platformio_tasmota_cenv.ini einfügt:
extra_scripts = ${env:tasmota32_base.extra_scripts}
post:pio-tools/obj-dump.py
Die extrem große Datei liegt unter \.pio\build\tasmota32xxx\firmware.asm. Dort kann man dann exakt nach der Adresse suchen.
Für den C6 muss man aber noch die obj-dump.py anpassen, da der C6 dort fehlt. Ich habe einfach die Zeile vom C3 kopiert.
(1) Allgemeine Features (in beiden Varianten — _tas und _tc):
USE_COUNTER
USE_DEEPSLEEP (ESP32)
USE_HOME_ASSISTANT
USE_IMPROV
USE_LIGHT
USE_PING
USE_SML_M
USE_SML_CRC
USE_SML_AUTHKEY
USE_SPI (nur ESP32)
USE_SUNRISE
USE_TIMERS
USE_TIMERS_WEB
USE_UFILESYS (nur ESP32, ESP8266 4M+)
USE_WEBSERVER
USE_WEBCLIENT_HTTPS
USE_TLS
USE_MQTT_TLS (nur ESP32)
USE_INFLUXDB (nur ESP32)
USE_ESP32_SW_SERIAL (nur ESP32)
USE_BMP (ESP32, ESP8266 1M Energy)
USE_DS18x20 (ESP32, ESP8266 1M Energy)
SET_ESP32_STACK_SIZE 12 * 1024
UFSYS_SIZE 16384 (ESP32)
UFSYS_SIZE 8192 (ESP8266 4M+)
(2) Features für (1)Steckdosen mit Energiemessfunktion:
In allen ESP32 bzw. nur im ESP8266 (1M) Image tasmota_energy_ottelo_tas sind diese Treiber aktiv!
(1)ESP8266: z.B. SonOff POW(R2), Gosund EP2, SonOff Dual R3 v2, NousA1T
(1)ESP32: z.B. Shelly Plus Plug S
USE_ADE7953
USE_BL09XX
USE_DHT
USE_CSE7766
USE_ENERGY_MARGIN_DETECTION
USE_ENERGY_POWER_LIMIT
USE_ENERGY_SENSOR
USE_HLW8012
USE_I2C
(3) Tasmota Scripting (USE_SCRIPT) — nur in _tas-Images:
USE_SCRIPT
USE_SCRIPT_FATFS_EXT (ESP32, ESP8266 4M+)
USE_EEPROM (ESP8266 1M)
EEP_SCRIPT_SIZE 8192 (ESP8266 1M / 1M Energy)
EEP_SCRIPT_SIZE 4096 (ESP8266 1M Shelly / 1M CT002)
USE_GOOGLE_CHARTS (nicht ESP8266 1M CT002)
USE_SCRIPT_WEB_DISPLAY
USE_HTML_CALLBACK
LARGE_ARRAYS (nicht ESP8266 1M CT002)
SCRIPT_LARGE_VNBUFF (ESP32)
MAX_ARRAY_SIZE 2000 (ESP32)
USE_CW_CALC (nicht ESP8266 1M CT002)
USE_ANGLE_FUNC (ESP32, ESP8266 +4M)
USE_FEXTRACT (ESP32, ESP8266 +4M)
USE_SCRIPT_SERIAL (nur ESP32)
SCRIPT_FULL_WEBPAGE (nur ESP32)
USE_SCRIPT_TCP_SERVER (nur ESP32)
USE_SCRIPT_TASK (nur ESP32)
USE_SCRIPT_MDNS (ESP32, ESP8266 1M Shelly)
USE_SCRIPT_CT002_REGISTRATION (ESP8266 1M CT002, Seite /ctreg)
USE_SCRIPT_GLOBVARS
USE_SCRIPT_JSON_EXPORT
------------------
für Script-DropDown-Menüs:
SCRIPT_LIST_DOWNLOAD_URL "https://raw.githubusercontent.com/ottelo9/tasmota-sml-script/main/script-list-menu/scripts/"
SCRIPT_LIST "scripts.json"
(4) TinyC — nur in _tc-Images:
USE_MATTER
USE_TINYC (XDRV_124, TinyC-VM)
USE_TINYC_IDE (selbstgehostete Browser-IDE)
USE_SML_SCRIPT_CMD (entkoppelt SML_SetBaud / SML_Write vom Scripter)
------------------
Partitionslayout:
ESP32 4M / ESP32-C3 / -C6 / -S2 / -SOLO1: app1856k_fs1344k
ESP32-S3 16M: app3904k_fs11584k (Default)
ESP32-P4: Board-Default
ESP8266 4M: eigenes Schema
------------------
SML aktivieren im TC-Programm:
tasm_rule = 1; // einmalig setzen
// Meter-Descriptor liegt in /sml_meter.def
(5) Features für ESP32-Module mit LAN-Port (Ethernet/LAN):
Nur in tasmota32_ottelo_*, tasmota32solo1_ottelo_*, tasmota32s3_ottelo_*, tasmota32p4_ottelo_* und tasmota32p4r3_ottelo_* aktiviert!
USE_ETHERNET
USE_WT32_ETH01
(6) Features und Treiber die ich deaktiviert habe:
Siehe #undef FEATURE in der Datei user_config_override.h.
Safeboot ist die kleine Rettungs-Firmware, über die jedes OTA läuft. Sie muss praktisch nie erneuert werden — ein Grund wäre ein OTA, das mit Upload Failed. Not enough space. abbricht, obwohl genug Platz da ist oder wenn sie total veraltet ist.
Es wird das offizielle Safeboot von Tasmota genommen (dasselbe steckt auch in meinen .factory Images). Upgrade 2 lädt die Datei <Name aus der OTA-Url>-safeboot.bin, deshalb wird die OTA-Url dafür kurz auf das offizielle Image eures Chips gestellt.
- Firmware Upgrade öffnen und unter Use web server eure aktuelle Url notieren (die braucht ihr in Schritt 3). Dann die offizielle Url eures Chips eintragen, z.B. für den ESP32-C3:
Für andere Chips
http://ota.tasmota.com/tasmota32/release/tasmota32c3.bintasmota32c3ersetzen durchtasmota32(ESP32),tasmota32s2,tasmota32s3,tasmota32c6,tasmota32solo1,tasmota32p4odertasmota32p4r3.
⚠️ Den Knopf darunter nicht drücken, der macht das normale Firmware-Update (und würde das offizielle Tasmota installieren). Ein Speichern Button gibt es nicht, beim Verlassen wird automatisch gespeichert. - In der Console folgendes eingeben (startet Safeboot Update):
Upgrade 2 ⚠️ Danach unter Firmware Upgrade → Use web server wieder eure eigene Url aus Schritt 1 eintragen. Sonst holt das nächste normale Update das offizielle Tasmota statt meines Images.
Das Gerät startet nach Upgrade 2 normal neu. Bricht der Download ab, passiert nichts Schlimmes — das Gerät bootet weiter wie bisher und Upgrade 2 kann wiederholt werden.
Sollte ein Gerät doch mal in Safeboot hängenbleiben (reduzierte Oberfläche, kein SML), holt es http://<ip>/u4?u4=ota zurück.
Bedanken möchte ich mich besonders bei gemu2015, der das Tasmota Scripting und SML entwickelt hat und mir immer sofort bei Problemen geholfen hat. Und natürlich beim restlichen Tasmota Entwickler-Team, für das grandiose Tasmota :).
Die Images sind Builds von Tasmota und stehen damit unter der GPL-3.0.
Der zugehörige Quelltext ist das offizielle Tasmota 16.0.0 plus die Overlay-Dateien dieser Repo. Die meisten Overlays stammen aus dem Zweig universal von gemu2015/Sonoff-Tasmota; den genauen Commit nennt gemu2015 Repo Update.txt.