Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Alle beschikbare gegevens kunnen via restAPI call's bij de DSMR-logger worden opgevraagd. De restAPI's zijn verdeeld in drie groepen. Informatie die met de hardware en firmware te maken heeft (/dev), informatie die met de Slimme Meter te maken heeft (/sm) en historische gegevens die, aan de hand van de door de Slimme Meter afgegeven gegevens, door de DSMR-logger in bestanden worden opgeslagen (/hist).
Een restAPI kan op verschillende manieren worden aangeroepen.
Geeft dit als output:
configuration.yaml:
geeft dit resultaat:
Heeft iemand een werkend Home-Assistant yaml bestand dat hij wil delen?
De source van deze code kun je op vinden.
Veel andere systemen hebben hun eigen manier om restAPI's op te vragen. Lees hiervoor de betreffende documentatie.
fetch(APIGW+"v2/dev/time")
.then(response => response.json())
.then(json => {
//console.log("parsed .., data is ["+ JSON.stringify(json)+"]");
data = json.devtime;
for( let field in data )
{
//console.log("dev/time: field["+field+"], value["+data[field]+"]");
if (field == "time")
{
//console.log("Got new time ["+data[field]+"]");
document.getElementById('theTime').innerHTML = data[field];
}
}
})
.catch(function(error) {
var p = document.createElement('p');
p.appendChild(
document.createTextNode('Error: ' + error.message)
);
}); curl http://dsmr-api.local/api/v2/dev/time{
"devtime": {
"timestamp": "230104142233W",
"time": "04-01-2023 14:22:17",
"time_rev": "2023-01-04 14:22:17",
"epoch": 1672838537,
"uptime": "1(d)-22:27(H:m)",
"uptime_secs": 167241
}
}### configuration.yaml
### DSMRloggerAPI
<<help>>Voor de DSMRlogger32 firmware zijn de volgende bibliotheken nodig:
Deze library is een uitbreiding op de arduino-dsmr van Matthijs Kooijman. Je kunt de dsmr2Lib library hier downloaden.
Deze is door Rop Gonggrijp ontwikkeld. Installatie via de Library Manager. Je kunt meer informatie over deze bibliotheek vinden.
Installatie via de Library Manager.
Je kunt meer over deze door Tzapu ontwikkelde, bibliotheek vinden.
De DSMRlogger32 firmware is getest met version 0.15.0 van deze bibliotheek maar nieuwere versies zullen waarschijnlijk ook werken.
Deze bibliotheek is door Juraj Andrassy ontwikkeld. Installatie via de Library Manager.
Je kunt meer informatie over deze bibliotheek vinden.
De firmware is getest met version 1.2.2 maar nieuwere versies zullen waarschijnlijk ook werken.
Let op:
De installatie van deze bibliotheek gaat net als de andere bibliotheken. Een update kan echter pas geïnstalleerd worden als éérst de map TelnetStream-master uit de map Libraries wordt verwijderd!
William Greiman heeft deze bibliotheek ontwikkeld met in het achterhoofd minimaal gebruik van resources (dus: een bibliotheek die weinig geheugen gebruikt).
Installatie via de Library Manager.
Meer informatie over deze bibliotheek kun je vinden.
De DSMR-logger Firmware is getest met Version1.3.0 maar nieuwere versies zullen waarschijnlijk ook werken.
Onderdeel van SSD1306Ascii.
Door Adafruit ontwikkelde bibliotheek om NeoPixels aan te sturen. Installatie via de Library Manager.
Nick O'Leary (knolleary) heeft deze bibliotheek ontwikkeld.
Installatie via de Library Manager. Getest met versie 2.7.0
Je kunt meer informatie over deze bibliotheek vinden.
Ontwikkeld door Benoit Blanchon.
Installatie via de Library Manager. Getest met versie 16.19.3.
vind je meer informatie over deze library.
Je kunt de bibliotheek downloaden. Pas op! voor gebruik van het LittleFS moet je versie gebruiken!
Onderstaande libraries zijn onderdeel van de ESP8266 Core en moeten dus niet handmatig geïnstalleerd worden!
FS
SPIFFS
WiFi
WebServer
HTTPUpdateServer
ESPmDNS
WiFiUpd
esp_heap_caps
HardwareSerial
De DSMRlogger32 firmware staat hier https://github.com/mrWheel/DSMRlogger32. Er zijn twee manieren om de firmware te clonen.
download de repository als een .zip file
gebruik git
Als je niet handig bent met git raad ik je aan de repository als een .zip file te downloaden.
Ga naar de .
Klik op de groene knop [<> Code] ..
.. en selecteer [Download ZIP]
Er volgt een scherm als dit:
Bewaar het .zip bestand op een plek op je computer waar je hem terug kunt vinden.
Unzip het DSMRlogger32-main.zip bestand in de ArduinoIDE Sketchbook Location.
Rename de map
Ga verder naar .
Om de repository met git te kunnen clonen moet je er éérst voor zorgen dat je git op je systeem hebt staan. Hoe je dat moet doen valt buiten de scope van deze documentatie maar kun je alles vinden over hoe je dit, voor jouw systeem, moet doen.
Voor nu ga ik ervan uit dat je git op je systeem hebt staan en dat je weet hoe je ermee moet werken.
Ga naar de Arduino Sketchbook location (de map waar al je Sketches in staan, ) en toets het volgende commando in:
That's it!
In Sketchbook location staat hierna een nieuwe map met de naam DSMRlogger32.
Start de ArduinoIDE opnieuw op en klik op het open icoon.
Selecteer in het drop-down menu "Open" ..
In het pop-up window dat nu verschijnt navigeer je naar de map "DSMRlogger32" ..
.. en selecteer je de sketch DSMRlogger32.ino.
Er verschijnt een nieuw editor window met de firmware van de DSMRlogger32!
Versie 5 van de DSMR-logger32 hardware maakt gebruik van een ESP32-WROVER processor. Deze processor zit op de printplaat van de DSMR-logger32 gesoldeerd en moet dus, op de printplaat, geflashed worden.
Overtuig je ervan dat alle tabbladen aanwezig zijn!
Om de firmware naar de DSMR-logger32 te kunnen flashen moet deze eerst voor deze versie van de DSMR-logger32 geschikt worden gemaakt.
Dit doe je door in de DSMRlogger32.ino (het eerste tabblad) de #define's aan te passen.
Door de twee slashes (
Met de Update Server is het mogelijk om firmware en het bestand systeem naar een DSMR-logger32 te flashen.
Je kunt de Update Server op twee manieren opstarten:
Door op de knop [Update Firmware] in de FSmanager te klikken
Door in de browser de volgende URL in te toetsen: http://dsmr-esp32.local/update of: http://<hetIPadresVanDeDSMRlogger>/update
DSMRlogger32-main




#define#definesVervolgens moeten de Boards settings als volgt worden ingesteld:
Board
"ESP32 WROVER Module"
Upload Speed
"230400" of "460800" (use lower speed if needed)
Flash Frequency
"40MHz" (sometimes 80MHz is to fast)
Flash Mode
"QIO" (sometimes "QIO" is too fast, use "DIO" in stead)
Partition Scheme
"Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS)"
Klik nu op het Verify icon.
Onderin de Arduino IDE verschijnen meldingen met betrekking tot de voorgang van het compileren. Als het compileren succesvol is (en er dus geen compilatie fouten zijn opgetreden) zie je de volgende meldingen:
De waarden van "Sketch uses" en "Global variables use" kunnen anders zijn dan wat in bovenstaand plaatje staat. Dat is geen reden voor ongerustheid.
De volgende stap is het daadwerkelijk uploaden (flashen) van de firmware naar de DSMR-logger32.
Pas op! Koppel de DSMR-logger32 los van de Slimme Meter vóórdat je de DSMR-logger32 op de programmer aansluit!!
Sluit de FTDI-programmer aan op de Program-header van de DSMR-logger32
Als de FTDI programmer niet zelf de DSMR-logger32 in flash-mode kan zetten, voer dan de volgende vier handelingen uit:
Druk de FLASH knop in en houd deze ingedrukt
Druk op de RESET knop
Laat de RESET knop los
Laat de FLASH knop los
De DSMR-logger32 staat nu in Flash-mode en blijft in die mode tot er gegevens vanaf de programmer naar de DSMR-logger32 zijn overgebracht óf tot je nog een keer op de RESET knop drukt.
Vergeet niet in de Arduino IDE de Port te selecteren waarop je de FTDI programmer hebt aangesloten en druk op het Compile and Upload icoon.
Bij het Over The Air flashen van de firmware of data-map kan (moet) de DSMR-logger32 gewoon op de Slimme Meter aangesloten blijven.
Alle instellingen voor de DSMRlogger32 firmware blijven gelijk aan de bedrade methode van flashen.
Vervolgens moet je niet op het Compile & Upload-Icoon
klikken maar in het[Sketch]drop-down menu de keuze Upload Compiled Binary selecteren.
De firmware wordt nu gecompileerd en in de Arduino Sketch map waar de DSMRlogger32 firmware ook staat neergezet. Het bestand heet DSMRlogger32.ino.bin.
Als de firmware gecompileerd is klik je op de DSMR-logger32 pagina op het icoontje.
In de FSmanager klik je op de knop [Update Firmware]
Er verschijnt nu een scherm waarin je een firmware bestand (de naam eindigt op .ino.bin) kunt kiezen door op de bovenste knop [Choose File] te klikken.
Selecteer uit het popUp scherm dat nu verschijnt het binary file dat je wilt uploaden ..
.. klik op [Choose] (of [Open]) en daarna op de knop [Flash Firmware]
Let op! De firmware heeft áltijd ".ino." in de naam en eindigt áltijd op ".bin"!
Na enige tijd krijg je de melding dat de upload is geslaagd en dat de DSMR-logger32 opnieuw opstart.


Om (nieuwe) firmware te flashen moet je op de knop [Choose file] onder de kop "Firmware:" klikken.
Er verschijnt nu een drop-down window waar je de gewenste firmware kunt selecteren.
Klik vervolgens op [Update Firmware]
Om een nieuw bestands systeem op de DSMR-logger te flashen klik je op de knop [Choose file] onder de kop "FileSystem:".
Er verschijnt nu een drop-down window waar je het gewenste .spiffs.bin bestand systeem kunt selecteren.
Klik vervolgens op de knop [Update FileSystem]
Om de firmware op de DSMR-logger32 te krijgen moeten een aantal stappen worden ondernomen. Hieronder staat welke stappen dat zijn.
Dit hoofdstuk is alleen van belang als je zelf de firmware wilt compileren. In de meeste gevallen kun je volstaan met het flashen van de pré compiled binaries en het standaard spiffs.bin bestand. Zie "Pré Compiled Binaries Uploaden".
Nieuwe DSMRlogger32 firmware kan via de web-interface van de DSMR-logger "Over the Air" geflashed worden maar mocht dat, om de één of andere reden niet lukken dan kunnen de pré compiled binaries ook bedraad geflashed worden.
git clone https://github.com/mrWheel/DSMRlogger32.git



Op github staan van de major releases binaries van zowel de firmware als van het SPIFFS bestand systeem.
Klik op "releases" en download het meest recente of door jou gewenste DSMRlogger32.ino.bin bestand (deze staan onder iedere release beschrijving bij "Assets").
Bij een gewone firmware update is het meestal niet nodig ook het bestand system opnieuw te downloaden en te flashen.
Onder iedere release beschrijving staan de bijbehorende "Assets".
Ga nu op de DSMR-logger naar de FSmanager (door op het icoon te klikken) en klik vervolgens op de knop [Update Firmware].
Klik nu op de bovenste [Choose File] knop
Selecteer in het popup-window het zojuist gedownloade DSMRlogger32.ino.bin file:
Klik op [Open] of [Select] en klik vervolgens op de knop [Flash Firmware].
Na enige tijd verschijnt het volgende scherm:
.. waarna, na enige tijd, het hoofdscherm van de DSMR-logger32 weer verschijnt.
Alleen als in de beschrijving van een release staat dat ook het bestand system opnieuw geflashed moet worden moet u dit doen. In veel gevallen zal volstaan om eventueel een bepaald bestand naar de DSMR-logger32 te uploaden. Ook dit zal dan expliciet in de release beschrijving staan.
Espressif heeft voor zijn ESP-boards een (helaas alleen Windows) tool ontwikkeld dat het bedraad flashen erg eenvoudig maakt.
De tool kun je hier downloaden.
Pak het .zip file uit (unzip) en start het door op het mapje te klikken:
Klik nu op "flash_download_tools.exe" en selecteer [esp32 DownloadTool] in het volgende scherm:
Selecteer de vier bin bestanden.
DSMRlogger32.ino.bootloader.binmoet op adres 0x1000 starten
DSMRlogger32.ino.partitions moet op adres 0x8000 starten
DSMRlogger32.ino.bin bestand moet op adres 0x10000 starten
DSMRlogger32.spiffs.bin op adres 0x22500 starten
Selecteer de COM poort waar de DSMR-logger32 op is aangesloten, zet de DSMR-logger32 in flash mode en klik op [START].
Na enige tijd krijg je de melding dat alles goed is gegaan.
Debug Level
"None"
Erase Flash
"Disabled" (First Time only: "Enabled")
Port
Bedraad: "Serial Port"





















Documentation about the DSMR-logger for ESP32
Mijn .
In dit gitbook vind je alle informatie over de DSMRlogger32 firmware voor de DSMR-logger32.
Je vindt hier de documentatie van de DSMRlogger32 hardware en firmware voor versie 5 van de DSMR-logger. Deze DSMR-logger is "Plug-And-Play" en alleen in bijzondere gevallen moet er, via de GUI, iets aan de instellingen aangepast worden (bijvoorbeeld als je een hele oude Slimme Meter hebt of als je een zgn. "Enkel Fase" Slimme Meter hebt). Deze documentatie is ook voor de gebruikers en makers die meer willen dan alleen de DSMR-logger aansluiten op hun Slimme Meter. De meeste gebruikers zullen voldoende hebben aan alleen dit hoofdstuk.
De DSMR-logger32 is een hardware en software systeem waarmee de Slimme Meter kan worden uitgelezen. De uitgelezen data (oftewel telegrammen) worden in de DSMR-logger32 opgeslagen en kunnen met behulp van gestandaardiseerde restAPI call's worden opgevraagd.
Deze versie van de DSMRlogger32 firmware kan overweg met vrijwel alle, mij bekende, Slimme Meters (DSMR 2+, DSMR3+, DSMR4+, DSMR5+ en de Belgische varianten hiervan).
Meer informatie
beschrijft het eerste idee achter de Slimme Meter uitlezer.
In kun je de ontwikkeling van de hardware en firmware vinden.
staat een introductie van de DSMRloggerAPI firmware
In dit document worden de volgende begrippen gebruikt:
Een volledige beschrijving van dit project kun je vinden.





De DSMRlogger32 firmware kun je op github vinden
Voor de meeste mensen is het gebruik van de twee binaries het eenvoudigste. Deze binaries kun je binnenkort hier vinden.
DSMR
Dutch Smart Meter Requirements. De DSMR specificatie is een afgeleide van de NTA 8130-normering. De DSMR-logger32 (versie 5) is ontworpen voor de DSMR 4.0 of hoger. DSMR 4.0 geeft aan dat de Slimme Meter op de P1-poort 5 volt bij 100mA moet kunnen leveren (zie pagina 8 en 9 van de specificatie). Vanaf DSMR 5.0+ moet de Slimme Meter 250mA op de P1 poort kunnen leveren. De DSMR-logger32 (ESP32) gebruikt tijdens het opstarten kortstondig tot wel 800mA. Voor de DSMR-logger32 zul je bijna altijd een externe voeding nodig hebben!
DSMR-logger32
de Hardware (Let op! Streepje tussen DSMR en logger)
DSMR-logger32 v5 (of Versie 5)
Versie 5 van de Hardware. Deze hardware is de basis van dit project.
DSMRlogger32
De firmware voor de DSMR-logger32. Deze firmware maakt intensief gebruik van restAPI's. Let op! De firmware heeft geen streepje (-) tussen "DSMR" en "logger"
ESP32-WROVER-E
Een ESP32 processor met 4MB Flash Geheugen en 4MB SPI-RAM (of SPRAM). Deze processor van Espressif wordt gebruikt in de DSMR-logger32

De hardware is behoorlijk aangepast ten opzichte van de voorgaande versies.
De drie belangrijkste aanpassingen zijn de secondaire P1 poort, de Watchdog en de mogelijkheid om een shield op de DSMR-logger32 te plaatsen. Iets minder belangrijk, maar wel erg informatief zijn de drie Neopixels. Twee worden bestuurd door de ESP32 de derde wordt bestuurd door de Watchdog (ATtiny85).




Als optie kan een 0.96" of 1.3" OLED display worden aangesloten.
Let er wél op dat er twee versies van deze schermen worden aangeboden die op het eerste gezicht helemaal hetzelfde lijken, maar waarvan de GND en Vcc aansluitingen omgewisseld zijn! Bij één en dezelfde leverancier kom je beide versies tegen. Controleer dus áltijd hoe jouw versie op de DSMR-logger32 moet worden aangesloten!
VCC GND SCL SDA
GND VCC SCL SDA
En om de verwarring compleet te maken zijn er ook OLED schermpjes (ik ben dit tot nu toe alleen bij de 1.3" tegen gekomen) waarop de opdruk aan de bovenkant niet overeenkomt met de daadwerkelijke aansluitingen.
Dit type OLED scherm heeft aan de bovenkant de opdruk "1" (naast VDD) en "4" (naast SDA) maar aan de onderkant een mogelijkheid om "1" en "2" om te draaien door twee 0 ohm weerstandjes op de gewenste plek te solderen. Bij sommige schermpjes zijn deze weerstandjes zodanig geplaatst dat de opdruk aan de bovenkant overeen komt met de werkelijke aansluiting .. maar soms dus ook niet. Opletten dus!
Daarom heeft de DSMR-logger32 géén verbindingen naar het OLED schermpje voor GND en VCC. Afhankelijk van de aansluitingen op jouw OLED schermpje moet je de volgende draadbruggen solderen.
De I2C bus [SCL-SDA] zijn wél standaard doorverbonden. Heeft jouw OLED schermpje daar óók een andere volgorde voor (ben ik nog niet tegen gekomen) dan kun je aan de onderkant van het PCB twee spoortjes (zie zwarte kruisjes) doorsnijden en op het patch gebied tussen SDA, SCL en I2C1, I2C2 de voor jou werkende doorverbindingen maken..
Er zijn drie manieren om de DSMR-logger32 van voedingsspanning te voorzien. Er mag altijd maar één van de drie geselecteerd worden door een jumper te plaatsen.
In het linker plaatje is de Slimme Meter als spanningsbron geselecteerd. In het middelste plaatje komt de spanning van het shield af. Wordt de jumper in het midden geplaatst, zoals in het rechter plaatje, dan moet er een externe USB voeding (5 volt) op de Power Jack worden aangesloten.
Zie ook de Onderdelen Lijst.



De DSMRlogger32 heeft de mogelijkheid om meterstanden en instellingen via de browser te veranderen.
Je start de DSMR-editor door in het hoofdscherm op het icoontje te klikken.
Terug: Terug naar het hoofdscherm van de DSMR-logger.
Meterstanden: Hier kunnen, per maand, de meterstanden worden ingevoerd. Er kan gekozen worden tussen de meterstanden van de gebruikte energie, de opgewekte energie en het gas verbruik.
Settings: Hier kunnen bepaalde parameters die specifiek zijn voor jouw Slimme Meter worden ingevoerd.
System: Voor jouw DSMR-logger specifieke parameters.
Herstel: ingevoerde veranderingen die nog niet zijn opgeslagen worden teniet gedaan.
Opslaan: de ingevoerde gegevens worden opgeslagen.
Het muteren van de maanden tabel is nog niet helemaal zoals het zou moeten zijn. Het is vrij lastig omdat de software zeker moet zijn dat de jaar/maand gegevens, van boven naar beneden, aflopen en aansluiten en ook de meterstanden moeten een steeds lagere waarde hebben. Wordt niet aan voorgaande inter-validatie voldaan, dan kleurt het vakje waar de fout is ontdekt rood en worden de gegevens niet opgeslagen.
Klik na iedere verandering op [Opslaan] (of in ieder geval toch zo vaak mogelijk!
Sommige browser vertalen decimale punten in komma's! Dit is erg verwarrend want de vertaling terug doen ze dan weer niet. Bij het invullen/veranderen van de meterstanden moet een decimale punt (".") gebruikt worden, anders wordt de invoer als ongeldig aangemerkt en niet opgeslagen!
Zet deze rubriek op "1" als je een DSMR 2+ of DSMR 3+ Slimme Meter hebt. Deze instelling wordt pas actief nadat de DSMR-logger opnieuw is opgestart.
Voer hier het Type in van de meter die op de betreffende MBus is aangesloten. Het Type van Gas meters is "003". Als in jouw installatie de Gas meter is aangesloten op MBus-ID2 voer je bij de rubriek**"MBus-2 Type meter"**een "3" in. Bij MBus-ID's waar niets op is aangesloten voer je het beste een "0" in.
Voer een 1 in als de aangesloten Slimme Meter wél fase informatie afgeeft, voer anders een 0 (nul) in. Of jouw Slimme Meter Fase Informatie af geeft kun je zien door naar een telegram te kijken. Geeft jouw Slimme Meter Fase Informatie dan zie je rubrieken met een naam waar _l1, _l2 en _l3 achter staat. Je hebt een Slimme meter die géén fase info afgeeft als de grafieken leeg blijven.
De default Hostname is DSMR-ESP32. De documentatie gaat ook uit van deze default hostname. Mocht je de hostname hier veranderen dan moet je bij het lezen van de documentatie overal "DSMR-ESP32" vervangen door de door jou ingevoerde hostname.
De standaard index pagina is "DSMRindex.html". Mocht je zelf een GUI schrijven dan kun je hier de naam van de index pagina van jouw GUI invullen (nadat je jouw .html pagina naar het bestand systeem hebt ge-upload).
Standaard staat er ook een DSMRindexEDGE.html pagina op het bestand systeem. Deze is gelijk aan de DSMRindex.html pagina maar hij haalt de javascript en css bestanden uit de github repository zodat aanpassingen (uitbreidingen of verbeteringen) automatisch door de DSMR-logger gebruikt worden.
Je kunt alternatieve GUI's eenvoudig uitproberen door in de FSmanager op deze bestanden te klikken.
Een nieuw ingevoerde index pagina wordt pas actief na het opnieuw opstarten van de DSMR-logger ([ReBoot] knop in de FSmanager).
Soms is het handig om de DSMR-logger iedere dag automatisch te re-booten. Door deze optie op "1" te zetten gebeurt dat iedere ochtend.
Het is mogelijk om, binnen grenzen, de hoeveelheid historie die je per uur, dag of maand wilt opslaan in het betreffende RING bestand, aan te passen.
Je kunt slechts één van deze RING-bestanden per keer aanpassen. Om dat te doen moet je zowel het aantal veranderen alsook de rubriek "Historie aanpassen" op "1" zetten en op [Opslaan] klikken.
Default interval is 10. Dit betekent dat er iedere tien seconden een telegram wordt gelezen en verwerkt. De minimum waarde is 2 seconden.
Hier kun je invoeren óf en wat voor OLED schermpje op de DSMR-logger is aangesloten.
Voer een 0 (nul) in als er geen OLED scherm is aangesloten
Voer een 1 in als het scherm van het type SDD1306 is
Voer een 2 in als het scherm van het type SH1106 is
Voer 0 (nul) in om het scherm standaard te gebruiken
Voet 1 in als je het scherm "op zijn kop" gebruikt.
Dit is het topic waarmee de MQTT berichten naar de broker worden verstuurd. Standaard is het Top Topic "DSMR-ESP32".
Hier kun je opgeven hoe vaak de DSMR-logger een bericht naar de MQTT broker moet sturen. Voer je hier '0' (nul) in dan worden er géén berichten naar de MQTT broker verstuurd. Een waarde kleiner dan de Telegram Lees Interval zorgt ervoor dat na ieder gelezen telegram een bericht naar de MQTT broker wordt verstuurd.
Met de FSmanager is het mogelijk bestanden op het bestand systeem (SPIFFS) van de DSMR-logger te plaatsen of ze ervan te verwijderen. Ook kan de inhoud van bestanden die aanwezig zijn op het bestand systeem worden getoond (dit is niet mogelijk met .html bestanden omdat deze direct door de browser geïnterpreteerd -en dus uitgevoerd- worden).
Daarnaast kent de FSmanager nog de volgende functies:
Starten van de Update Server [Update Firmware]
Rebooten van de DSMR-logger[Reboot]
Formatteren van het SPIFFS [Format FileSYS]
Soms blijft het scherm leeg. Klik dan op de knop[List File System]
Met de knop[Exit FSmanager] keer je terug naar het hoofdscherm.
Er zijn verschillende manieren om de FSmanager te starten:
Vanuit het DSMR-logger hoofdscherm door op het icoon te klikken
Door in de browser de volgende URL in te toetsen
http://dsmr-esp32.local/FSmanager
of:
http://<ipAdresVanDeLogger>/FSmanager
De FSmanager heeft de mogelijkheid om het bestand systeem te formatteren. Deze functie is alleen nodig als het bestand systeem problemen vertoont. Normaal gesproken is deze functie nooit nodig en daarom is de knop ook uitgeschakeld. Om de knop te activeren moet het bestand met de naam !doNotFormat(het eerste teken is een uitroep-teken) ge-delete worden. De inhoud van het bestand is niet belangrijk. Zodra dit bestand afwezig is wordt de [Format FileSYS] knop geactiveerd.
Pas op! Door het bestand systeem te formatteren raak je álle bestanden die op het bestand systeem staan kwijt! Maak zo nodig eerst kopiëren van belangrijke bestanden.
Na iedere herstart zal de DSMRlogger32 firmware controleren of het bestand systeem correct geformatteerd is. In dat geval plaatst het automatisch een bestand met de naam !doNotFormat in de root directory.












De Graphical User Interface (GUI) van de DSMR-logger32 kun je bereiken door de URL
"http://dsmr-esp32.local/"
in de adresbalk van je browser in te toetsen:
http://dsmr-esp32.localMocht je bij Systeem Settings een andere HostName ingevoerd hebben, dan verandert deze URL natuurlijk in "<Hostname>.local".
Veel browser vinden het niet fijn als je een "niet-geëncrypte" site bezoekt en vragen dan eerst of je dat wel echt wil ...
... omdat we weten waar we mee bezig zijn kun je in dit geval met een gerust hart op de knop [Continue to site] klikken.
Bij het opstarten van de DSMR-logger32 kun je, aan de hand van de NeoPixels zien wat hij "aan het doen is".
Na een [Reset] of bij het aansluiten van de spanning zal de DSMR-logger32 een aantal stappen uitvoeren. Als eerste zal de NEO-WD Blauw worden en de twee andere Neopixels zullen snel blinken in verschillende kleuren. Daarna worden NEO-1 en NEO-2 kortstondig rood.
De Watchdog stuurt NEO-WD aan en het verloop is altijd als volgt:
Bij de eerste keer opstarten, als je met de credentials hebt ge-reset óf als je de DSMR-logger32 naar een lokatie verplaatst waar hij geen verbinding met het ingevoerde/bekende WiFi AccessPoint kan maken, zullen de Neopixels als volgt gaan branden:
Afhankelijk van hoe snel je met het selecteren van je WiFi AP bent zal de NEO-WD in "normale operatie" komen (stap 3/4) en langzaam Groen pulseren. Duurt het selecteren en bewaren van je WiFi credentials te lang dan zal de NEO-WD eerst langzaam en daarna snel in Rood pulseren waarna de ESP32 wordt ge-reset en deze weer met de normale opstart procedure start.
Als de externe voeding of de voeding van de Slimme Meter niet voldoende vermogen levert (minimaal 500mA) dan zal dat te zien zijn aan de NeoPixels die dan als volgt branden/knipperen:
Bij het opstarten zullen de NeoPixels als volgt branden/pulseren:
Als de hele opstart procedure (goed) is doorlopen hoort de NEO-WD langzaam in het groen te pulseren. Zolang de Watchdog regelmatig een heartbeat van de ESP32 ontvangt zal dat het geval zijn. Dat de ESP32 een heartbeat verstuurt kun je zien omdat NEO-1 dan héél even Wit oplicht.
Iedere keer dat de DSMR-logger een telegram verwerkt zal NEO-2 even fel groen oplichten.
GET http://dsmr-esp32.local/api/v2/sm/info
Geeft systeem een JSON string met informatie van de Slimme Meter, zoals ID's en Serie nummers, terug.
{
"info": {
"identification": "XMX5LBGGFB2410065887",
"p1_version": "50",
"equipment_id": "4530303336303033373839373339363136",
"electricity_tariff": "0002",
"mbus1_device_type": 3,
"mbus1_equipment_id_tc": "4730303339303031363532303530323136"
}
}GET http://dsmr-esp32.local/api/v2/sm/actual
Geeft de actuele meterstanden van de Slimme Meter terug in een JSON string.
GET http://dsmr-esp32.local/api/v2/sm/fields
Geeft een JSON string met alle velden die door de DSMRlogger32 firmware kunnen worden terug gegeven.
\
Let op!
Niet iedere Slimme Meter geeft ook al deze velden terug. Als de Slimme meter een veld niet terug geeft heeft
"value"
de waarde
"-"
.
GET http://dsmr-esp32.local/api/v2/sm/fields/<fieldName>
Geeft een JSON string met informatie over één veld terug. Bijvoorbeeld:
http://dsmr-esp32.local/api/v2/sm/fields/current_l2
GET http://dsmr-esp32.local/api/v2/sm/telegram
Geeft een telegram terug precies zo als de Slimme Meter die ook afgeeft, dus inclusief "\r\n" line endings en inclusief de CheckSum!



Rood langzaam pulserend
60 seconden géén heartbeat ontvangen. 30 seconden vóór reset ESP32. De pulse duur is ongeveer twee seconden (aan-uit-aan). Wordt er weer een heartbeat ontvangen dan veranderd de status terug naar stap 3.
Rood snel pulserend
75 seconden géén heartbeat ontvangen. 15 seconden vóór reset ESP32. De pulse duur is ongeveer een halve seconde (aan-uit-aan). Wordt er weer een heartbeat ontvangen dan verandert de status terug naar stap 3.
Rood snel knipperend
Te lang geen heartbeat ontvangen. De Watchdog gaat over tot het resetten van de ESP32.
fel Wit
De Watchdog reset de ESP32.
AccessPoint opgestart
Selecteer dit AP en voer de credentials van je WiFi netwerk in en druk op [Save]
(off)
Blauw
Blauw
(off)
Rood
Blauw/Groen
Connectie met WiFi
Groen
Groen
Groen
Normale verwerking
Fout situatie
Terug naar stap 1
Start WiFi
3
(off)
Groen
Blauw
Verbonden met WiFi
4
Groen
Groen
Blauw
Normale verwerking. Watchdog nog in opstart fase.
5
Groen
Groen
Groen
Normale verwerking. Watchdog ontvangt heartbeats.
x
Rood
Groen
Groen
Bij het ontvangen van een onvolledig Telegram zal NEO-2 kortstondig Rood oplichten. Bij een volgend, volledig, telegram wordt NEO-2 weer Groen.
Blauw pulserend
Na een reset zal de NEO-WD 30 seconden in deze staat verkeren zodat de ESp32 genoeg tijd heeft om op te starten.
off
ongeveer 50 milli seconden.
Groen pulserend
Normale verwerking. Zolang de ESP32 heartbeat pulsen geeft zal de Watchdog in deze staat blijven. De pulse duur is ongeveer 10 seconden (aan-uit-aan).
Rood
Rood
Blauw
Start verwerking (na initieel knipperen van NEO-1 en NEO-2).
(off)
Wit
1
Blink all colors
Blink all colors
Blauw
Standaard opstart sequence
2
(off)
Rood
1
(off)
Rood
Blauw
Start verwerking (na initieel knipperen van NEO-1 en NEO-2).
2
(off)
Blauw


Blauw/Groen
Blauw
Blauw
{
"actual": {
"timestamp": "230102141705W",
"energy_delivered_tariff1": 6225.879,
"energy_delivered_tariff2": 8884.998,
"energy_returned_tariff1": 1184.409,
"energy_returned_tariff2": 2601.907,
"power_delivered": 1.12,
"power_returned": 0,
"voltage_l1": 235,
"voltage_l2": 234,
"voltage_l3": 232,
"current_l1": 0,
"current_l2": 0,
"current_l3": 3,
"power_delivered_l1": 0.195,
"power_delivered_l2": 0.164,
"power_delivered_l3": 0.76,
"power_returned_l1": 0,
"power_returned_l2": 0,
"power_returned_l3": 0,
"mbus1_delivered": 4961.589,
"mbus2_delivered": 0,
"mbus3_delivered": 0,
"mbus4_delivered": 0,
"gas_delivered": 4961.589
}
}Met onderstaande code kun je met een ESP8266 gegevens uit de DSMR-logger32 ophalen en verder verwerken.
{
"fields": {
"identification": "XMX5LBGGFB2410065887",
"p1_version": "50",
"timestamp": "230102141815W",
"equipment_id": "4540404446404044474849474449464146",
"energy_delivered_tariff1": 6225.879,
"energy_delivered_tariff2": 8885.021,
"energy_returned_tariff1": 1184.409,
"energy_returned_tariff2": 2601.907,
"electricity_tariff": "0002",
"power_delivered": 1.35,
"power_returned": 0,
"electricity_failures": 15,
"electricity_long_failures": 2,
"electricity_failure_log": "(2)(0-0:96.7.19)(200210104719W)(0000014540*s)(220324214948W)(0000007370*s)",
"electricity_sags_l1": 18,
"electricity_sags_l2": 15,
"electricity_sags_l3": 20,
"electricity_swells_l1": 247,
"electricity_swells_l2": 205,
"electricity_swells_l3": 249,
"voltage_l1": 234,
"voltage_l2": 234,
"voltage_l3": 233,
"current_l1": 0,
"current_l2": 1,
"current_l3": 3,
"power_delivered_l1": 0.191,
"power_delivered_l2": 0.394,
"power_delivered_l3": 0.763,
"power_returned_l1": 0,
"power_returned_l2": 0,
"power_returned_l3": 0,
"mbus1_device_type": 3,
"mbus1_equipment_id_tc": "4730303339303031363532303530323136",
"mbus1_delivered": 4961.589,
"mbus2_delivered": 0,
"mbus3_delivered": 0,
"mbus4_delivered": 0
}
}{
"fields": {
"timestamp": "230102145809W",
"current_l2": 3
}
}/XMX5LABCDE2410065447
1-3:0.2.8(50)
0-0:1.0.0(210610104031S)
0-0:96.1.1(4530304446303033373839312345678906)
1-0:1.8.1(004491.266*kWh)
1-0:1.8.2(006065.310*kWh)
1-0:2.8.1(000788.990*kWh)
1-0:2.8.2(001809.893*kWh)
0-0:96.14.0(0002)
1-0:1.7.0(00.037*kW)
1-0:2.7.0(00.000*kW)
0-0:96.7.21(00011)
0-0:96.7.9(00001)
1-0:99.97.0(1)(0-0:96.7.19)(200210104719W)(0000014540*s)
1-0:32.32.0(00010)
1-0:52.32.0(00007)
1-0:72.32.0(00009)
1-0:32.36.0(00000)
1-0:52.36.0(00000)
1-0:72.36.0(00000)
0-0:96.13.0()
1-0:32.7.0(238.0*V)
1-0:52.7.0(238.0*V)
1-0:72.7.0(238.0*V)
1-0:31.7.0(002*A)
1-0:51.7.0(000*A)
1-0:71.7.0(003*A)
1-0:21.7.0(00.598*kW)
1-0:41.7.0(00.102*kW)
1-0:61.7.0(00.000*kW)
1-0:22.7.0(00.000*kW)
1-0:42.7.0(00.000*kW)
1-0:62.7.0(00.663*kW)
0-1:24.1.0(003)
0-1:96.1.0(4730305559303031363839312345678906)
0-1:24.2.1(210610104007S)(03845.376*m3)
!344A
//==== edit "myCredentials_org.h" ========
//==== and save it as "myCredentials.h" ==
#include "myCredentials.h"
#include <ESP8266WiFi.h>
const char *ssid = _WIFI_SSID;
const char *password = _WIFI_PASSWRD;
//------ [ArduinoJson@6.19.3]
#include <ArduinoJson.h>
//-- if you need more fields make this JsonDocument bigger
StaticJsonDocument<350> dsmrDoc;
//-- if you need more fields make this JsonDocument bigger
StaticJsonDocument<150> filter;
#define _READINTERVAL 30000
const char *DSMRprotocol = "http://";
const char *DSMRserverIP = _DSMR_IP_ADDRESS;
const char *DSMRrestAPI = "/api/v2/sm/actual";
String payload;
int httpResponseCode;
uint32_t lastRead = 0;
//--- catch specific fields for further processing -------
//--- these are just an example! see readDsmrLogger() ----
String timeStamp;
float energyDelivered, pwrDelivered;
float energyReturned, pwrReturned;
float gasDelivered;
bool firstCall = true;
//--------------------------------------------------------------------------
bool dsmrGETrequest()
{
WiFiClient DSMRclient;
payload = "";
Serial.print("DSMRclient.connect("); Serial.print(DSMRserverIP);
Serial.println(", 80)");
if (!DSMRclient.connect(DSMRserverIP, 80))
{
Serial.println(F("error connecting to DSMRlogger "));
payload = "{\"actual\":[{\"name\":\"httpresponse\", \"value\":\"error connecting\"}]}";
return false;
}
//-- send request
DSMRclient.print(F("GET "));
DSMRclient.print(DSMRrestAPI);
DSMRclient.println(" HTTP/1.1");
DSMRclient.print(F("Host: "));
DSMRclient.println(DSMRserverIP);
DSMRclient.println(F("Connection: close"));
DSMRclient.println();
delay(500);
DSMRclient.setTimeout(900);
DSMRclient.find("\r\n\r\n"); // skip everything up-until data seperator
deserializeJson(dsmrDoc, DSMRclient, DeserializationOption::Filter(filter));
// Free resources
DSMRclient.stop();
if (firstCall)
{
Serial.print("dsmrDoc::");
serializeJsonPretty(dsmrDoc, Serial);
Serial.println();
}
firstCall = false;
return true;
} // dsmrGETrequest()
//--------------------------------------------------------------------------
void readDsmrLogger()
{
int fieldNr = 0;
dsmrGETrequest();
//-- store the fields you are interested in ----------
timeStamp = dsmrDoc["actual"]["timestamp"].as<const char*>();
energyDelivered = dsmrDoc["actual"]["energy_delivered_tariff1"].as<float>()
+ dsmrDoc["actual"]["energy_delivered_tariff2"].as<float>();
pwrDelivered = dsmrDoc["actual"]["power_delivered"].as<float>();
energyReturned = dsmrDoc["actual"]["energy_returned_tariff1"].as<float>()
+ dsmrDoc["actual"]["energy_returned_tariff2"].as<float>();
pwrReturned = dsmrDoc["actual"]["power_returned"].as<float>();
gasDelivered = dsmrDoc["actual"]["gas_delivered"].as<float>();
if (firstCall)
{
Serial.println();
Serial.println(F("==== Start parsing payload ======================="));
for (JsonPair p : dsmrDoc["actual"].as<JsonObject>())
{
Serial.print(p.key().c_str()); Serial.print("\t: ");
if (p.value().is<int>()) Serial.println(p.value().as<int>());
else if (p.value().is<float>()) Serial.println(p.value().as<float>());
else if (p.value().is<const char*>()) Serial.println(p.value().as<const char*>());
else Serial.println("unknown type");
}
Serial.println(F("=================================================="));
}
} // readDsmrLogger()
//--------------------------------------------------------------------------
void setup()
{
Serial.begin(115200);
while(!Serial) { /* wait a bit */ }
Serial.println("");
Serial.println(F("\r\n***************************************"));
Serial.println(F("And then it all begins ..."));
Serial.println(F("***************************************\r\n"));
//-- The filter: it contains "true" for each value we want to capture
filter["actual"]["timestamp"] = true;
filter["actual"]["power_delivered"] = true;
filter["actual"]["power_returned"] = true;
filter["actual"]["gas_delivered"] = true;
filter["actual"]["energy_delivered_tariff1"] = true;
filter["actual"]["energy_delivered_tariff2"] = true;
filter["actual"]["energy_returned_tariff1"] = true;
filter["actual"]["energy_returned_tariff2"] = true;
Serial.print("filterDoc::");
serializeJsonPretty(filter, Serial);
Serial.println();
WiFi.begin(ssid, password);
Serial.println(F("Connecting"));
while(WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print(F("Connected to WiFi network with IP Address: "));
Serial.println(WiFi.localIP());
lastRead = millis() + _READINTERVAL;
Serial.println(F("\r\nStart reading ..."));
} // setup()
//--------------------------------------------------------------------------
void loop()
{
if ((millis() - lastRead) > _READINTERVAL)
{
lastRead = millis();
Serial.print(F("\r\nread API/v2 from DSMR-logger @"));
Serial.println(_DSMR_IP_ADDRESS);
readDsmrLogger();
Serial.println(F("\r\nCaptured fields ==============================="));
Serial.print(F("timestamp : ")); Serial.println(timeStamp);
Serial.print(F("energyDelivered : ")); Serial.println(energyDelivered);
Serial.print(F("pwrDelivered : ")); Serial.println(pwrDelivered);
Serial.print(F("energyReturned : ")); Serial.println(energyReturned);
Serial.print(F("pwrReturned : ")); Serial.println(pwrReturned);
Serial.print(F("gasDelivered : ")); Serial.println(gasDelivered);
Serial.println(F("\r\n"));
}
} // loop()



GET http://dsmr-esp32.local/api/v2/dev/info
Deze restAPI geeft informatie terug van de DSMR-logger
{
"devinfo": {
"author": "Willem Aandewiel (www.aandewiel.nl)",
"fwversion": "v5.0.2 (22-12-2022)",
"compiled": "Dec 24 2022 10:42:31",
"hostname": "DSMR-ESP32",
"ipaddress": "192.168.12.143",
"macaddress": "8C:4B:14:81:FF:B0",
"indexfile": "DSMRindex.html",
"free_heap": 229604,
"min_free_heap": 4087619,
"psram_size": 4191755,
"free_psram_size": 4057915,
"used_psram_size": 133840,
"chip_model": "ESP32-D0WDQ5",
"sdk_version": "v4.4.2",
"cpu_freq": 240,
"sketch_size": 1207712,
GET http://dsmr-esp32.local/api/v2/dev/time
Deze restAPI geeft de systeem tijd van de DSMR-logger
GET http://dsmr-esp32.local/api/v2/dev/settings
Deze restAPI geeft alle, door de gebruiker muteerbare, Slimme Meter settingen terug
POST http://dsmr-esp32.local/api/v2/settings/{"name":"<settingVeld>","value":"<nieuweWaarde>"}
type: String
maxlen: 29
Opmerking:
Characters
type: float
min: 0
max: 10
decimalen: 5
type: float
min: 0
max: 10
Decimalen: 5
type: float
min: 0
max: 10
Decimalen: 5
type: float
min: 0
max: 10
Decimalen: 5
type: float
min: 0
max: 10
Decimalen: 5
type: float
min: 0
max: 100
Decimalen: 2
type: float
min: 0
max: 100
Decimalen: 2
type: Integer
min: 1
max: 60
Opmerking:
type: String
maxlen: 49
Opmerking:
Characters
type: String
maxlen: 100
Opmerking:
Characters
type: Integer
min: 0
max: 9999
type: String
maxlen: 39
Opmerking:
Characters
type: String
maxlen: 29
Opmerking:
Characters
type: String
maxlen: 20
Opmerking:
Characters
type: Integer
min: 0
max: 600
Opmerking: Seconden
De restAPI's voor het opvragen van historische gegevens hebben dit formaat:
of:
of:
GET http://dsmr-esp32.local/api/v2/hist/actual
{
"store": {
"44": [
{
"actual": {
"timestamp": "230102153122W",
"power_delivered_l1": 0.379,
"power_delivered_l2": 0.135,
"power_delivered_l3": 0.415,
"power_returned_l1": 0,
"power_returned_l2": 0,
"power_returned_l3": 0,
"gas_delivered": 5310.339
}
}
],
"45": [
{
"actual": {
"timestamp": "230102153126W",
GET http://dsmr-esp32.local/api/v2/hist/hours
Geeft een JSON string met de historische gegevens over de afgelopen 24 uur terug.
GET http://dsmr-esp32.local/api/v2/hist/days
Geeft een JSON string met alle gegevens over de afgelopen dagen terug.
GET http://dsmr-esp32.local/api/v2/hist/months
Geeft een JSON string met alle gegevens van de afgelopen maanden terug.
/api/v2/hist/{actual|hours|days|months}/api/v2/hist/{actual|hours|days|months}{/asc|/desc}/api/v2/hist/{actual|hours|days|months}/<recs>{/asc|/desc}



Opmerking:
Euro's per maand
Opmerking:
Euro's per maand
Seconden
Default: DSMRindex.html
indien '0' worden er géén berichten verstuurd
er wordt nooit vaker een bericht verstuurd dan tlgrm_interval
{
"devtime": {
"timestamp": "230102130942W",
"time": "02-01-2023 13:09:49",
"time_rev": "2023-01-0002 13:09:",
"epoch": 1672661389,
"uptime": "3(d)-02:06(H:m)",
"uptime_secs": 266808
}
}{
"system": [
{
"name": "hostname", "value": "DSMR-ESP32", "type": "s", "maxlen": 29
},
{
"name": "index_page", "value": "DSMRindex.html", "type": "s", "maxlen": 49
},
{
"name": "daily_reboot", "value": 0, "type": "i", "min": 1, "max": 1
},
{
"name": "no_hour_slots", "value": 121, "type": "i", "min": 49, "max": 190
},
{
"name": "no_day_slots", "value": 32, "type": "i", "min": 15, "max": 155
},
{
"name": "no_month_slots", "value": 2, "type": "i", "min": 2, "max": 5
},
{
"name": "alter_ring_slots", "value": 0, "type": "i", "min": 0, "max": 1
},
{
"name": "tlgrm_interval", "value": 5, "type": "i", "min": 2, "max": 60
},
{
"name": "oled_type", "value": 2, "type": "i", "min": 0, "max": 2
},
{
"name": "oled_screen_time", "value": 3, "type": "i", "min": 0, "max": 300
},
{
"name": "oled_flip_screen", "value": 1, "type": "i", "min": 0, "max": 1
},
{
"name": "neo_brightness", "value": 75, "type": "i", "min": 10, "max": 250
},
{
"name": "mqtt_broker", "value": "192.168.12.250", "type": "s", "maxlen": 100
},
{
"name": "mqtt_broker_port", "value": 1883, "type": "1", "min": 1, "max": 9999
},
{
"name": "mqtt_user", "value": "", "type": "s", "maxlen": 39
},
{
"name": "mqtt_passwd", "value": "", "type": "s", "maxlen": 39
},
{
"name": "mqtt_toptopic", "value": "DSMR-DEV32", "type": "s", "maxlen": 20
},
{
"name": "mqtt_interval", "value": 10, "type": "i", "min": 0, "max": 600
}
]
}{"name":"<settingVeld>","value":"<nieuweWaarde>"}{
"hours": [
{
"recnr": 0,
"recid": "22122815",
"slot": 113,
"edt1": 6198.015,
"edt2": 9157.279,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5047.048
},
{
"recnr": 1,
"recid": "22122816",
"slot": 114,
"edt1": 6199.161,
"edt2": 9161.557,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5049.235
},
{
"recnr": 2,
"recid": "22122817",
"slot": 115,
"edt1": 6200.28,
"edt2": 9165.792,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5051.459
},
{
"recnr": 3,
"recid": "22122818",
"slot": 116,
"edt1": 6201.412,
"edt2": 9170.153,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5053.669
},
{
"recnr": 4,
"recid": "22122819",
"slot": 117,
"edt1": 6202.533,
"edt2": 9174.56,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5055.86
},
.
.
.
{
"recnr": 118,
"recid": "23010213",
"slot": 110,
"edt1": 6331.18,
"edt2": 9661.992,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5305.721
},
{
"recnr": 119,
"recid": "23010214",
"slot": 111,
"edt1": 6332.962,
"edt2": 9668.602,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5309.217
},
{
"recnr": 120,
"recid": "23010215",
"slot": 112,
"edt1": 6333.831,
"edt2": 9671.759,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5310.865
}
]
}{
"days": [
{
"recnr": 0,
"recid": "22120223",
"slot": 0,
"edt1": 6059.023,
"edt2": 8676.882,
"ert1": 1183.884,
"ert2": 2600.835,
"gdt": 4809.171
},
{
"recnr": 1,
"recid": "22120323",
"slot": 1,
"edt1": 6074.667,
"edt2": 8676.882,
"ert1": 1183.884,
"ert2": 2600.835,
"gdt": 4814.832
},
{
"recnr": 2,
"recid": "22120423",
"slot": 2,
"edt1": 6091.162,
"edt2": 8676.882,
"ert1": 1183.884,
"ert2": 2600.835,
"gdt": 4821.213
},
.
.
.
{
"recnr": 29,
"recid": "22123123",
"slot": 29,
"edt1": 6288.5,
"edt2": 9500.478,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5223.111
},
{
"recnr": 30,
"recid": "23010123",
"slot": 30,
"edt1": 6315.821,
"edt2": 9604.45,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5276.099
},
{
"recnr": 31,
"recid": "23010215",
"slot": 31,
"edt1": 6333.831,
"edt2": 9671.759,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5310.865
}
]
}{
"months": [
{
"recnr": 0,
"recid": "21013123",
"slot": 16,
"edt1": 4027.753,
"edt2": 5345.965,
"ert1": 706.531,
"ert2": 1609.39,
"gdt": 3426.986
},
{
"recnr": 1,
"recid": "21022823",
"slot": 17,
"edt1": 4160.245,
"edt2": 5526.37,
"ert1": 710.812,
"ert2": 1622.42,
"gdt": 3569.993
},
.
.
.
{
"recnr": 22,
"recid": "22113023",
"slot": 13,
"edt1": 6056.715,
"edt2": 8656.669,
"ert1": 1183.884,
"ert2": 2600.787,
"gdt": 4800.665
},
{
"recnr": 23,
"recid": "22123123",
"slot": 14,
"edt1": 6288.5,
"edt2": 9500.478,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5223.111
},
{
"recnr": 24,
"recid": "23010215",
"slot": 15,
"edt1": 6333.831,
"edt2": 9671.759,
"ert1": 1183.1,
"ert2": 2600.5,
"gdt": 5310.865
}
]
}Behalve met de GUI kun je de DSMR-logger32 ook bereiken via het telnet protocol (poort 23). De meeste UNIX varianten (waaronder MacOS) kennen de standaard telnet client. Windows gebruikers moeten een programma zoals Putty installeren.
Telnet is een onbeveiligd protocol dat geen gebruik maakt van een gebruikersnaam en/of wachtwoord.
Start in een terminal window de telnet client als volgt op:
telnet <ip-adres-DSMR-logger32>of met:
telnet DSMR-ESP32.localAls de verbinding lukt zie je dit:
Als je nu op de[Enter] toets drukt krijg je een menu te zien:
De menu-keuzen waar een asterisk (*) voor staat werken alleen als je de letter als HOOFDLETTER intoetst. De meeste opties spreken voor zich.
Je sluit de telnet client af door de toetscombinatie [Control]+"]" in te toetsen:
Toets achter "telnet>" de letter "q" in en druk op [Enter].
Home Assistant kan op twee manieren gegevens uit de DSMR-logger32 (met de DSMRlogger32 firmware) ophalen.
Om de gegevens door middel van de restAPI's uit de DSMR-logger32 te halen moet het configuration.yaml bestand er ongeveer als volgt uit zien:
Heeft iemand een werkend YAML bestand dat met restAPI's werkt????
Trying 192.168.2.13...
Connected to 192.168.2.13.
Escape character is '^]'.
[11:02:52] processSlimmemeter ( 86): telegramCount=[87930] telegramErrors=[0]
[Time----] Function------------(line):
[11:02:52] processTelegram ( 17): Telegram[87931]=>tlgrmData.timestamp[230109110250W]
[11:02:53] processTelegram ( 136): prevHour[11] -- lastHour[11]
[11:03:02] processSlimmemeter ( 86): telegramCount=[87931] telegramErrors=[0]
[Time----] Function------------(line):
[11:03:02] processTelegram ( 17): Telegram[87932]=>tlgrmData.timestamp[230109110300W]
[11:03:03] processTelegram ( 136): prevHour[11] -- lastHour[11]
[11:03:03] sendMQTTData ( 157): MQTTinterval [30]Commands are (*X only uppercase):
B - Board Info
*E - erase file from Filesystem
F - force Reboot Watchdog
I - Identify by blinking NeoPixels
L - List Filesystem
P - No Parsing (show RAW data from Smart Meter)
*R - Reboot
S - Show Settings
*U - Update Filesystem (save Data-files)
V - Toggle Verbose 1
*W - Force Re-Config WiFi
*Y - Stop zending heartbeat pulses
*Z - Zero Counters and sysLog
D - Display Day table from Filesystem
H - Display Hour table from Filesystem
M - Display Month table from FilesystemZ
Het aantal reboots en verwerkte telegrammen wordt op 0 (nul) gezet. Ook het systeemLog wordt leeg gemaakt.
v of V
Met de letter "v" verhoog je de verbositeit van off naar 1 naar 2 en weer terug naar off. Hoe hoger de verbositeit hoe meer logging gegevens je te zien krijgt.
f of F
Hiermee reboot je de Watchdog. Dit kan handig zijn als je (bijvoorbeeld) een lange update wilt doen en daar zo veel mogelijk tijd voor wilt krijgen. Na een reboot van de Watchdog duurt het ongeveer twee minuten voordat de Watchdog de ESP32 reset als deze geen heartbeats ontvangt.
R
Hiermee wordt na twee seconden de DSMR-logger32 ge-restart.
U
De RING bestanden worden direct ge-update.
W
De WiFi credentials worden verwijderd. Na een restart moeten deze opnieuw ingevoerd worden via het WiFi AP portal (net zoals bij de eerste keer opstarten van de DSMR-logger32). Connect to AP [DSMR-ESP32] and go to ip address shown in the AP-name
Y
De ESP32 stuurt hierna geen heartbeats meer naar de Watchdog. Na enige tijd (ongeveer 90 seconden) zal de Watchdog de ESP32 restarten. Door (binnen 90 seconden) een "y" of "Y" in te toetsen zullen er weer heartbeats naar de ESP32 worden gestuurd.
Met onderstaande code kun je met een ESP32 gegevens uit de DSMR-logger32 ophalen en verder verwerken.
telnet>telnet> q
Connection closed.//==== edit "myCredentials_org.h" ========
//==== and save it as "myCredentials.h" ==
#include "myCredentials.h"
#include <WiFi.h>
#include <HTTPClient.h>
const char *ssid = _WIFI_SSID;
const char *password = _WIFI_PASSWRD;
//------ [ArduinoJson@6.19.3]
#include <ArduinoJson.h>
//-- if you need more fields make this JsonDocument bigger
StaticJsonDocument<350> dsmrDoc;
//-- if you need more fields make this JsonDocument bigger
StaticJsonDocument<150> filter;
#define _READINTERVAL 30000
const char *DSMRprotocol = "http://";
const char *DSMRserverIP = _DSMR_IP_ADDRESS;
const char *DSMRrestAPI = "/api/v2/sm/actual";
String payload;
int httpResponseCode;
uint32_t lastRead = 0;
//--- catch specific fields for further processing -------
//--- these are just an example! see readDsmrLogger() ----
String timeStamp;
float energyDelivered, pwrDelivered;
float energyReturned, pwrReturned;
float gasDelivered;
bool firstCall = true;
//--------------------------------------------------------------------------
bool dsmrGETrequest()
{
HTTPClient DSMRclient;
// Your IP address with path or Domain name with URL path
DSMRclient.begin(String(DSMRprotocol) + String(DSMRserverIP)+String(DSMRrestAPI));
// Send HTTP GET request
httpResponseCode = DSMRclient.GET();
payload = "";
if (httpResponseCode > 0)
{
deserializeJson(dsmrDoc, DSMRclient.getString(), DeserializationOption::Filter(filter));
if (firstCall)
{
Serial.print("dsmrDoc::");
serializeJsonPretty(dsmrDoc, Serial);
Serial.println();
}
firstCall = false;
}
else
{
payload = "{\"actual\":[{\"name\":\"httpresponse\", \"value\": "+String(httpResponseCode)+"}]}";
// Free resources
DSMRclient.end();
Serial.print("HTTP Response code: ");
Serial.println(httpResponseCode);
return false;
}
// Free resources
DSMRclient.end();
return true;
} // dsmrGETrequest()
//--------------------------------------------------------------------------
void readDsmrLogger()
{
int fieldNr = 0;
dsmrGETrequest();
//-- store the fields you are interested in ----------
timeStamp = dsmrDoc["actual"]["timestamp"].as<const char*>();
energyDelivered = dsmrDoc["actual"]["energy_delivered_tariff1"].as<float>()
+ dsmrDoc["actual"]["energy_delivered_tariff2"].as<float>();
pwrDelivered = dsmrDoc["actual"]["power_delivered"].as<float>();
energyReturned = dsmrDoc["actual"]["energy_returned_tariff1"].as<float>()
+ dsmrDoc["actual"]["energy_returned_tariff2"].as<float>();
pwrReturned = dsmrDoc["actual"]["power_returned"].as<float>();
gasDelivered = dsmrDoc["actual"]["gas_delivered"].as<float>();
if (firstCall)
{
Serial.println();
Serial.println(F("==== Start parsing payload ======================="));
for (JsonPair p : dsmrDoc["actual"].as<JsonObject>())
{
Serial.print(p.key().c_str()); Serial.print("\t: ");
if (p.value().is<int>()) Serial.println(p.value().as<int>());
else if (p.value().is<float>()) Serial.println(p.value().as<float>());
else if (p.value().is<const char*>()) Serial.println(p.value().as<const char*>());
else Serial.println("unknown type");
}
Serial.println(F("=================================================="));
}
} // readDsmrLogger()
//--------------------------------------------------------------------------
void setup()
{
Serial.begin(115200);
while(!Serial) { /* wait a bit */ }
Serial.println("");
Serial.println(F("\r\n***************************************"));
Serial.println(F("And then it all begins ..."));
Serial.println(F("***************************************\r\n"));
//-- The filter: it contains "true" for each value we want to capture
filter["actual"]["timestamp"] = true;
filter["actual"]["power_delivered"] = true;
filter["actual"]["power_returned"] = true;
filter["actual"]["gas_delivered"] = true;
filter["actual"]["energy_delivered_tariff1"] = true;
filter["actual"]["energy_delivered_tariff2"] = true;
filter["actual"]["energy_returned_tariff1"] = true;
filter["actual"]["energy_returned_tariff2"] = true;
Serial.print("filterDoc::");
serializeJsonPretty(filter, Serial);
Serial.println();
WiFi.begin(ssid, password);
Serial.println(F("Connecting"));
while(WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print(F("Connected to WiFi network with IP Address: "));
Serial.println(WiFi.localIP());
lastRead = millis() + _READINTERVAL;
Serial.println(F("\r\nStart reading ..."));
} // setup()
//--------------------------------------------------------------------------
void loop()
{
if ((millis() - lastRead) > _READINTERVAL)
{
lastRead = millis();
Serial.print(F("\r\nread API/v2 from DSMR-logger @"));
Serial.println(_DSMR_IP_ADDRESS);
readDsmrLogger();
Serial.println(F("\r\nCaptured fields ==============================="));
Serial.print(F("timestamp : ")); Serial.println(timeStamp);
Serial.print(F("energyDelivered : ")); Serial.println(energyDelivered);
Serial.print(F("pwrDelivered : ")); Serial.println(pwrDelivered);
Serial.print(F("energyReturned : ")); Serial.println(energyReturned);
Serial.print(F("pwrReturned : ")); Serial.println(pwrReturned);
Serial.print(F("gasDelivered : ")); Serial.println(gasDelivered);
Serial.println(F("\r\n"));
}
} // loop()
//==== edit "myCredentials_org.h" ========
//==== and save it as "myCredentials.h" ==
#include "myCredentials.h"
#include <ArduinoHttpClient.h> // tested with version 0.4.0
#include <Ethernet.h>
#include <SPI.h>
//------ [ArduinoJson@6.19.3]
#include <ArduinoJson.h>
//-- if you need more fields make this JsonDocument bigger
StaticJsonDocument<350> dsmrDoc;
//-- if you need more fields make this JsonDocument bigger
StaticJsonDocument<150> filter;
#define _READINTERVAL 30000
const char *DSMRprotocol = "http://";
const char *DSMRserverIP = _DSMR_IP_ADDRESS;
const char *DSMRrestAPI = "/api/v2/sm/actual";
String payload;
int httpResponseCode;
uint32_t lastRead = 0;
//--- catch specific fields for further processing -------
//--- these are just an example! see readDsmrLogger() ----
String timeStamp;
float energyDelivered, pwrDelivered;
float energyReturned, pwrReturned;
float gasDelivered;
bool firstCall = true;
//--------------------------------------------------------------------------
bool dsmrGETrequest()
{
EthernetClient ETHclient;
HttpClient DSMRclient = HttpClient(ETHclient, DSMRserverIP, 80);
payload = "";
Serial.println(F("making GET request"));
DSMRclient.get(DSMRrestAPI);
// read the response code and body of the response
httpResponseCode = DSMRclient.responseStatusCode();
if (httpResponseCode <= 0)
{
Serial.print(F("http Response Code: "));
Serial.println(httpResponseCode);
return false;
}
payload = DSMRclient.responseBody();
deserializeJson(dsmrDoc, payload, DeserializationOption::Filter(filter));
// Free resources
DSMRclient.stop();
if (firstCall)
{
Serial.print("dsmrDoc::");
serializeJsonPretty(dsmrDoc, Serial);
Serial.println();
}
firstCall = false;
return true;
} // dsmrGETrequest()
//--------------------------------------------------------------------------
void readDsmrLogger()
{
int fieldNr = 0;
dsmrGETrequest();
//-- store the fields you are interested in ----------
timeStamp = dsmrDoc["actual"]["timestamp"].as<const char*>();
energyDelivered = dsmrDoc["actual"]["energy_delivered_tariff1"].as<float>()
+ dsmrDoc["actual"]["energy_delivered_tariff2"].as<float>();
pwrDelivered = dsmrDoc["actual"]["power_delivered"].as<float>();
energyReturned = dsmrDoc["actual"]["energy_returned_tariff1"].as<float>()
+ dsmrDoc["actual"]["energy_returned_tariff2"].as<float>();
pwrReturned = dsmrDoc["actual"]["power_returned"].as<float>();
gasDelivered = dsmrDoc["actual"]["gas_delivered"].as<float>();
if (firstCall)
{
Serial.println();
Serial.println(F("==== Start parsing payload ======================="));
for (JsonPair p : dsmrDoc["actual"].as<JsonObject>())
{
Serial.print(p.key().c_str()); Serial.print("\t: ");
if (p.value().is<int>()) Serial.println(p.value().as<int>());
else if (p.value().is<float>()) Serial.println(p.value().as<float>());
else if (p.value().is<const char*>()) Serial.println(p.value().as<const char*>());
else Serial.println("unknown type");
}
Serial.println(F("=================================================="));
}
} // readDsmrLogger()
//--------------------------------------------------------------------------
void setup()
{
Serial.begin(115200);
while(!Serial) { /* wait a bit */ }
Serial.println("");
Serial.println(F("\r\n***************************************"));
Serial.println(F("And then it all begins ..."));
Serial.println(F("***************************************\r\n"));
//-- The filter: it contains "true" for each value we want to capture
filter["actual"]["timestamp"] = true;
filter["actual"]["power_delivered"] = true;
filter["actual"]["power_returned"] = true;
filter["actual"]["gas_delivered"] = true;
filter["actual"]["energy_delivered_tariff1"] = true;
filter["actual"]["energy_delivered_tariff2"] = true;
filter["actual"]["energy_returned_tariff1"] = true;
filter["actual"]["energy_returned_tariff2"] = true;
Serial.print("filterDoc::");
serializeJsonPretty(filter, Serial);
Serial.println();
// Initialize Ethernet library
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
if (!Ethernet.begin(mac))
{
Serial.println(F("Failed to configure Ethernet"));
return;
}
delay(1000);
lastRead = millis() + _READINTERVAL;
Serial.println(F("\r\nStart reading ..."));
} // setup()
//--------------------------------------------------------------------------
void loop()
{
if ((millis() - lastRead) > _READINTERVAL)
{
lastRead = millis();
Serial.print(F("\r\nread API/v2 from DSMR-logger @"));
Serial.println(_DSMR_IP_ADDRESS);
readDsmrLogger();
Serial.println(F("\r\nCaptured fields ==============================="));
Serial.print(F("timestamp : ")); Serial.println(timeStamp);
Serial.print(F("energyDelivered : ")); Serial.println(energyDelivered);
Serial.print(F("pwrDelivered : ")); Serial.println(pwrDelivered);
Serial.print(F("energyReturned : ")); Serial.println(energyReturned);
Serial.print(F("pwrReturned : ")); Serial.println(pwrReturned);
Serial.print(F("gasDelivered : ")); Serial.println(gasDelivered);
Serial.println(F("\r\n"));
}
} // loop()Om de gegevens via een MQTT broker uit de DSMR-logger32 te halen moet het configuration.yaml bestand er ongeveer zo uit zien:
(met dank aan Henk Elzing)
##################################
# uitbreiding configuratie.yaml #
##################################
# koppeling met de DSMR-logger32 #
# via restAPI's #
##################################Download en installeer de meest actuele versie van de Arduino Integrated Development Environment (IDE) voor het Operating Systeem (OS) waar jouw Desktop of Laptop computer (er zijn versies voor Windows, Linux en Mac) mee werkt. Je kunt de Software hier downloaden.
Let op! De Arduino IDE v1.9.x (Beta) is NIET geschikt om deze firmware mee te compileren. Tot v1.9.x zorgt de IDE ervoor dat alle tab-bladen (.ino files) achter elkaar worden geplakt tot één source file waarna van alle functies in dit gecombineerde file zgn. prototypes worden gemaakt voordat deze aan de compiler (als één file dus) wordt aangeboden. De Arduino IDE is eigenlijk de enige IDE (voor zover ik weet) die dit doet en is als zodanig dus een beetje vreemd. v1.9.x (Beta) doet dit voor AVR processoren wel maar helaas (nog) niet voor de ESP32 processor familie.
Na het downloaden moet je het ontvangen bestand uitpakken (unzip of untar) en installeren. Dat installeren is per OS anders maar staat duidelijk op de website van Arduino aangegeven. Eenmaal geïnstalleerd kun je direct met de Arduino IDE aan de slag.
Om de IDE met de ESP32 microprocessor te kunnen gebruiken moeten we nog wat stappen uitvoeren.
Mijn DSMR-logger32 doet het niet als ik hem op de Slimme Meter aansluit. Er zijn Slimme Meters die 'zeggen' DSMR Versie 4 te volgen maar toch geen 5 volt met voldoende stroom leveren. Bouwers van de DSMR-logger32 hebben problemen gemeld met de KAIFA MA105A en MA105C en met de KAIFA MA304. Kijk bijvoorbeeld en . Dit probleem is op te lossen door de DSMR-logger32 op een externe (bijvoorbeeld USB) voeding aan te sluiten.
Het blijkt dat de ESP32 bij het opstarten en verbinden met het WiFi netwerk, kortstondig meer stroom vraagt dan de (meeste?) slimme meters kunnen leveren. Met veel Slimme Meters blijkt het noodzakelijk om een externe 5volt (USB) voeding te gebruiken!
Heb je al een DSMR-logger versie 4 met de DSMRloggerAPI firmware in gebruik en je stapt over naar de DSMR-logger32 dan wil je uiteraard je historisch data meenemen. Dat kán, maar je moet daar wel de juiste procedure voor volgen omdat de RING bestanden van de DSMRlogger32 firmware nét iets anders zijn dan die van de DSMRloggerAPI firmware.
Helaas blijkt de ESP32 geen verbinding te kunnen maken met Technicolor modems (van Ziggo). Of het probleem in het modem zit of in de Arduino esp32 core is mij niet bekend. Zie ook op github.
Als het een type is dat de TX en RX signalen op 3v3 levert (bijvoorbeeld ) dan kán het wel, maar moet je de 5 Volt output niet op de DSMR-logger32 aansluiten. De overige aansluitingen maak je zoals in het plaatje hieronder. Áls je de rode draad als voeding wilt gebruiken, dan moet je deze verbinden met de 5v testpin naast de 5Volt Ext. jack connector.
We doen een update als we de firmware willen vervangen met een nieuwere versie van dezelfde firmware (dus we vervangen DSMRlogger32 door een nieuwere versie van DSMRlogger32).
We doen een upgrade als we de ene firmware vervangen door een andere (dus we vervangen bijvoorbeeld DSMRlogger32 door DSMRlogger64).
Update
Bij een update zal de lay-out van de data-bestanden niet veranderen en kun je volstaan met het opnieuw flashen van de firmware.
Voor de data-map (SPIFFS) kun je twee wegen bewandelen.
1) Je haalt m.b.v. de FSmanager de .html en .js bestanden op uit de data-map en zet deze in SPIFFS
2) Je haalt met de FSmanager de RINGxxxx.csv bestanden op en zet deze in de data-map, waarna je met het ESP32Sketch Data Upload tool de data-map naar SPIFFS kunt overzetten.
Upgrade
Bij een upgrade moet je zowel de firmware als de data-map opnieuw naar de DSMR-logger32 flashen.
Uiteraard kun je ook in dit geval éérst de RINGxxxx.csv bestanden uit de DSMR-logger32 halen en ergens op je computer bewaren.
Ik zie mijn gasverbruik niet op de DSMR-logger Waarschijnlijk zit je gasmeter niet op kanaal 1 aangesloten. Kijk in een Telegram op welk kanaal je gasmeter wél is aangesloten en pas dit aan in .
Wat zijn de maten van de DSMR-logger32?
De buitenmaten zijn 80mm x 78mm.
De hoogte van de DSMR-logger32 is ongeveer 20mm (bovenkant RJ12 connectoren) of ~18mm (bovenkant OLED scherm (indien geplaatst).
De middenconnector van de DC plug is positief:
Omdat deze voeding ook voor de (secundaire) P1 poort gebruikt wordt moet deze 5 volt zijn!
Wat is het verschil tussen RJ10 en RJ12? Hier bestaat nogal wat verwarring over op het internet. Het is niet helemaal duidelijk wat de juiste benaming van deze Registered Jack stekkers is. De meest gehanteerde benamingen zijn:
RJ11 en RJ12 zijn even breed en passen in dezelfde female connector, maar bij de eerste maken alleen de 4 binnenste contacten verbinding terwijl bij de RJ12 alle 6 de contacten verbinding maken. Ook de RJ10 stekker past in een RJ12 female connector maar ook dan worden alleen de binnenste 4 contacten met elkaar verbonden.
In die gevallen waarbij een externe voeding nodig is omdat de Slimme Meter niet genoeg stroom levert voor de DSMR-logger én de Slimme Meter géén telegrammen verstuurt als er een externe voeding wordt gebruikt, zijn zowel de RJ11 als de RJ10 stekkers de oplossing.
In de Arduino IDE moet bij “Instellingen” de volgende URL worden ingevoerd achter “Additional Boards Manager URL’s:” (zie blauw gekleurde regel)
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Lees vooral de uitleg in het README.md bestand en de uitgebreide documentatie op hun website!
Er kunnen meer additional board manager URL’s worden ingevuld. Je moet ze dan achter elkaar zetten en scheiden door een komma (,).
Nadat de preferences zijn geupdate moet je in de Arduino IDE de Boards Manager opstarten:
Nadat de Boards Manager is opgestart (dat duurt even) moet je in de selectie-balk "esp32" intoetsen.
Klik nu op [Install] of selecteer de gewenst versie en klik op [Update].
De DSMRlogger32 firmware is met versie 2.0.5 van de ESP32 core getest.
Let op! De DSMRlogger32 firmware is getest met versie 2.0.5 van de Arduino/ESP32 core. Nieuwere versies zullen zeer waarschijnlijk ook werken, maar bij problemen is het het beste om deze versie te gebruiken.
Om het mogelijk te maken de "data" map van de DSMRlogger32 firmware naar de DSMR-loggr32 te uploaden, moet eerst een extensie in de Arduino IDE worden geïnstalleerd.
Ga hiervoor naar .
Ga vervolgens naar en selecteer het nieuwste esp32fs.zip bestand.
Maak een map tools aan in je Arduino Projecten map (als die map nog niet bestaat) en ga in de map "tools" staan.
Pak nu het
##################################
# uitbreiding configuratie.yaml #
##################################
# koppeling met de DSMR-logger32 #
# via MQTT broker #
##################################
mqtt:
sensor:
- state_topic: "DSMR-ESP32"
name: "Gebruik"
device_class: "energy"
unit_of_measurement:'kWh'
value_template: "{{ value_json.power_delivered | round(3) }}"
- state_topic: "DSMR-ESP32"
name: "Gebruik l1"
device_class: "power"
unit_of_measurement: 'W'
value_template: "{{ (value_json.power_delivered_l1 | float * 1000.0) | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Gebruik l2"
device_class: "power"
unit_of_measurement: 'W'
value_template: "{{ (value_json.power_delivered_l2 | float * 1000.0) | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Gebruik l3"
device_class: "power"
unit_of_measurement: 'W'
value_template: "{{ (value_json.power_delivered_l3 | float * 1000.0) | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Gas gebruik"
device_class: "gas"
unit_of_measurement: 'm³'
value_template: "{{ value_json.gas_delivered | round(3) }}"
- state_topic: "DSMR-ESP32"
name: "Spanning-L1"
device_class: "voltage"
unit_of_measurement: 'V'
value_template: "{{ value_json.voltage_l1 | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Spanning-L2"
device_class: "voltage"
unit_of_measurement: 'V'
value_template: "{{ value_json.voltage_l2 | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Spanning-L3"
device_class: "voltage"
unit_of_measurement: 'V'
value_template: "{{ value_json.voltage_l3 | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Stroom-L1"
device_class: "current"
unit_of_measurement: 'A'
value_template: "{{ value_json.current_l1 | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Stroom-L2"
device_class: "current"
unit_of_measurement: 'A'
value_template: "{{ value_json.current_l2 | round(1) }}"
- state_topic: "DSMR-ESP32"
name: "Stroom-L3"
device_class: "current"
unit_of_measurement: 'A'
value_template: "{{ value_json.current_l3 | round(1) }}"



Copyright © 2022 - 2023 Willem Aandewiel
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
toolsESP32FStooltoolesp32fs.jarStart nu de Arduino IDE (opnieuw) op en kijk of onder [Tools] het ESP32 Sketch Data Upload tool verschijnt!
Als je deze aanklikt verschijnt er een pop-up window waarin je kunt kiezen wat voor Filesysteem je wilt uploaden.
Voor de DSMR-logger32 moet dat "SPIFFS" zijn!
Zorg ervoor dat de juiste Seriële poort is geselecteerd én (belangrijk) dat de Serial Monitor uit staat!

1
Download de drie DSMRloggerAPI RING bestanden naar je bureau computer. * RINGhours.csv * RINGdays.csv * RINGmonths.csv
2
Upload nu het RINGhours.csv bestand naar de DSMR-logger32 en voer direct de volgende stap uit!
3
Druk in de FSmanager op de knop [Reboot]
4
Wacht tot de DSMR-logger32 volledig is opgestart en de drie NeoPixels groen zijn.
5
Herhaal de stappen 2, 3 en 4 voor de twee andere bestanden.




In de volgende vier hoofdstukken wordt beschreven wat je moet doen om zélf de DSMRlogger32 firmware te compileren en naar de DSMR-logger32 te flashen.
Source
DSMRloggerESP32_v5/DSMRloggerESP32_v5.kicad_sch
Date
Thursday, 12 January 2023
Tool
Eeschema (6.0.2-0)
Als de DSMR-logger32 voor het eerst op de P1 poort van de Slimme Meter wordt aangesloten, of als je in de Telnet User Interface de letter "W" hebt ingetoetst, zijn de credentials van je WiFi Access Point nog niet/niet meer bekend.
De DSMR-logger32 zal nu een eigen AccessPoint opstarten. Heb je een OLED-schermpje op je DSMR-logger32 aangesloten dan staat er op het OLED schermpje dat er een AccessPoint is opgestart (AP mode active) en dat je daar verbinding mee moet maken. Maar ook zonder OLED schermpje kun je aan de NEOpixels zien dat er een AccessPoint is opgestart. NEO-1 zal namelijk fel wit branden (NEO-2 is uit).
Met je computer/mobiel/tablet, ga je naar Netwerk Instellingen en kijk je welke WiFi Access Points (AP) er allemaal zijn.
Als daar een WiFi AP met de naam DSMR-ESP32-xx:yy:zz tussen staat maak je daar verbinding mee (er hoeft geen wachtwoord te worden ingevoerd). Er kunnen nu twee dingen gebeuren:
Er verschijnt een popUp window met de optie om je WiFi netwerk te configureren (klik op [Configure WiFi]).;
Of er gebeurt niets.
Ga dan met je browser naar http://192.168.4.1/ waarna er een (popUp) window verschijnt waarin je je WiFi netwerk kunt configureren (klik op [Configure WiFi]).
Nu volgt er een scherm met alle WiFi netwerken die in de buurt gevonden zijn. Selecteer jouw WiFi netwerk en voer het bijbehorende wachtwoord in.
Druk vervolgens op [Save].
De DSMR-logger32 zal rebooten en verbinding maken met jouw WiFi router (zie: ).
Als de DSMR-logger32 nog steeds geen verbinding met jouw WiFi netwerk kan maken dan start hij weer zijn eigen AP op (NEO-1 brandt weer fel wit, NEO-2 is uit) en dan zul je de WiFi procedure opnieuw moeten uitvoeren.
Als de DSMR-logger32 normaal is opgestart en de drie NeoPixels branden groen, ga dan met je browser naar:
http://DSMR-ESP32.local/ of http://<IPadresVanDeDSMRlogger>
In de browser verschijnt nu de de hoofd-pagina van de DSMR-logger32 met daarin de actuele data uit je Slimme Meter.
Je kunt met telnet DSMR-ESP32.local of met telnet <IPadresVanDeDSMRlogger> inloggen op je DSMR-logger32 en volgen waar hij mee bezig is (zie ).
Om te bepalen welk IP is uitgegeven aan de ESP door de DHCP server, kun je in je router kijken, of dit opzoeken met bijv. de Fing app of met nmap.
Het is mogelijk om de DSMR-logger32 permanent als Access Point te gebruiken. De DSMR-logger32 wordt dan niet op je eigen netwerk aangesloten maar blijft zelf een AP. Je kunt de GUI benaderen door op je PC of tablet het AP (DSMR-ESP32-xx:yy:zz) te kiezen (zoals hiervoor beschreven). Het IP address waar je in AP mode naar toe moet browsen is http://192.168.4.1 Je kunt deze mode activeren door tijdens het opstarten de [Flash] knop in te drukken en ingedrukt te houden tot de NEOpixels niet meer blinken. Wil je niet iedere keer de [Flash] knop in te moeten drukken bij het opstarten, dan kun je in Settings (klik op het houweeltje) ...
... op klik op System ...
... waarna je de waarde van run als AccessPoint in een 1 kunt veranderen.
Vergeet vervolgens niet om op [Opslaan] te klikken! Druk nu op de [Reset] knop van de DSMR-logger32 en deze zal vervolgens altijd als AP opstarten (tot je de waarde weer terug zet naar 0 uiteraard.
Onderstaande tabel geeft de gegevens weer zoals deze door gebruikers worden gemeld. Om de lijst zo compleet mogelijk te maken verzoek ik iedere maker/gebruiker om deze gegevens met ons te delen!
Het blijkt dat de ESP32 bij het opstarten en verbinden met het WiFi netwerk, kortstondig meer stroom vraagt dan de (meeste?) slimme meters kunnen leveren. Met veel Slimme Meters blijkt het noodzakelijk om een externe 5volt (USB) voeding te gebruiken!
Merk SM
Type
Nu je een ArduinoIDE hebt waarmee je ESP32’s kunt programmeren (flashen) zul je ontdekken dat er door briljante mensen software is ontwikkeld die je kunt gebruiken om complexe projecten te realiseren, zonder dat je zelf het wiel hoeft uit te vinden.
Deze software wordt veelal in de vorm van een bibliotheek aangeboden en je hoeft zo’n bibliotheek alleen maar te installeren om er gebruik van te kunnen maken.
Hier vind je de officiële instructies voor het installeren van bibliotheken met de ArduinoIDE.
Stel je wilt je ESP32 benaderen met een telnet client zodat je vanaf je Desktop of Laptop op de ESP32 kunt inloggen. Je hebt op de ESP32 dan een telnet server nodig. Met wat Googelen naar "ESP32 telnet" blijken hier een aantal bibliotheken voor te bestaan.
Als voorbeeld nemen we TelnetStream van Juraj Andrassy. Zijn telnet implementatie kun je vanaf deze pagina als bibliotheek downloaden.
Om de bibliotheek te installeren klik je op de groene [Clone or download] (of [<> Code]) knop en selecteer je [Download ZIP].
Onthoud waar je het zip-file bewaard hebt!
Ga nu naar de Arduino IDE en selecteer:
[Sketch]=>[Include Library] =>[Add .ZIP Library]
Er verschijnt een selectie window waar je het bestand selecteert dat zojuist gedownload hebt.
Klik op [Choose].
De bibliotheek is nu geïnstalleerd en klaar om gebruikt te worden. De meeste bibliotheken komen met een aantal voorbeeld programma’s waarmee je kunt leren hoe je de bibliotheek kunt gebruiken.
Verreweg de eenvoudigste manier om een bibliotheek te installeren is via de Library Manager.
Na het klikken op "Manage Libraries.." verschijnt er een pop-up window van de Library Manager. Voer in de zoekbalk de gewenste bibliotheek in.
.. en klik op [Install] of [Update].
De bibliotheek is nu geïnstalleerd.
Juraj Andrassy is erg summier met zijn uitleg maar gelukkig is er een map met voorbeelden (nou ja, één voorbeeld).
(sorry, het plaatje is een beetje verknipt)
Klik je nu op[TelnetStreamTest]dan wordt dit voorbeeld programma in de Arduino IDE geladen.
Installeer op dezelfde manier de andere bibliotheken die voor de DSMRlogger32firmware nodig zijn.
Externe Voeding
DSMR Versie
Pré 40
Fase Info
Opm.
Landys
E350
JA
5.0
OK!
Landys
E350
?
2.2+
Yes
OK
Landys
E350
?
4.0
ok
Landys
E360
J
5.0
OK!
Landys
ZCF110
JA
4.2
OK
Landys
ZCM110
?
4.2
ok
Landys
ZCF120ABd
?
2.2+
Yes
No
OK GUI geeft géén actueel verbruik
ISKRA
AM550
JA
5.0+
OK!
ISKRA
MT382
?
2.2+
Yes
OK
ISKRA
ME382
?
2.2+
Yes
ok
KAIFA
E0026
?
?
?
KAIFA
MA304
JA
?
OK!
KAIFA
MA105C
JA
?
OK!
KAIFA
MA340C
JA
?
OK!
Kamstrup
162
JA
2.2
Yes
No
OK
Kamstrup
382
?
2.2
Yes
?
Sagemcom
XS210
?
5.0
ok ESMR5
Sagemcom
T210-D
?
5.0
OK! ESMR5
Sagemcom
S211
?
?
No
OK!
Seconia
T211
?
?
No
OK!



1
10uF
C_Polarized
Capacitor_SMD:C_1206_3216 Metric_Pad1.33x1.80mm_ HandSolder
D101, D102, D201,
3
WS2812B
WS2812B
LED_SMD:LED_WS2812B_ PLCC4_5.0x5.0mm_P3.2mm
J101, J107
2
RJ12 femaile connector
Conn_01x 06_Male
Connector_RJ:RJ12_Amphenol_ 54601
J102, J103
2
PWR-IN/OUT
Conn_01x 03_Male
Connector_PinHeader_2.54mm: PinHeader_1x03_P2.54mm_ Vertical
J106,
1
I2C OLED
Conn_01x 04_Female
Connector_PinSocket_2.54mm: PinSocket_1x04_P2.54mm_ Vertical
J201,
1
Jack-DC
Jack-DC
MyNewLibrary:BarrelJack_ Wuerth_AaWMod
J202,
1
FTDI 3v3
Conn_01x 06_Male
Connector_PinHeader_2.54mm: PinHeader_1x06_P2.54mm_ Vertical
J207,
1
Enable WD
Conn_01x 02_Male
Connector_PinHeader_2.54mm: PinHeader_1x02_P2.54mm_ Vertical
J208,
1
Shield-POWER
Conn_01x 06_Female
Connector_PinSocket_2.54mm: PinSocket_1x06_P2.54mm_ Vertical
J210, J211
2
Shield-Ext1/Ext2
Conn_01x 10_Female
Connector_PinSocket_2.54mm: PinSocket_1x10_P2.54mm_ Vertical
Q101, Q102, Q201, Q202,
4
BC848
BC848
Package_TO_SOT_SMD:SOT-23
R101, R107, R108,
3
4k7
R
Resistor_SMD:R_1206_3216 Metric_Pad1.30x1.75mm_ HandSolder
R102, R105,
2
1k
R
Resistor_SMD:R_1206_3216 Metric_Pad1.30x1.75mm_ HandSolder
R103,
1
2k2
R
Resistor_SMD:R_1206_3216 Metric_Pad1.30x1.75mm_ HandSolder
R104, R201, R202, R203,
4
10k
R
Resistor_SMD:R_1206_3216 Metric_Pad1.30x1.75mm_ HandSolder
R106,
1
330R
R
Resistor_SMD:R_1206_3216 Metric_Pad1.30x1.75mm_ HandSolder
R109, R111,
2
470R
R
Resistor_SMD:R_1206_3216 Metric_Pad1.30x1.75mm_ HandSolder
R110,
1
100R
R
Resistor_SMD:R_1206_3216 Metric_Pad1.30x1.75mm_ HandSolder
SW101, SW102
2
RESET FLASH
SW_Push
Button_Switch_SMD:SW_SPST_ CK_RS282G05A3
U101,
1
ESP32-WROVER-B/E
MyNewLibrary:ESP32-WROVER- B-E_(PSRAM)
U102,
1
6N137
Package_DIP:DIP-8_W7.62mm
U201,
1
TC1262-33
Package_TO_SOT_SMD: SOT-223-3_TabPin2
U202,
1
ATtiny85-20P
Package_DIP:DIP-8_W7.62mm
C101, C202, C204
3
10nF
C_Small
Capacitor_SMD:C_1206_3216 Metric_Pad1.33x1.80mm_ HandSolder
C102, C107,
2
1nF
C_Small
Capacitor_SMD:C_1206_3216 Metric_Pad1.33x1.80mm_ HandSolder
C103, C104, C105, C106, C201, C205, C206
7
100nF
C_Small
Capacitor_SMD:C_1206_3216 Metric_Pad1.33x1.80mm_ HandSolder
C203,






















