Wemos D1 met ESP Easy uitlezen smartmeter lukt niet

Ik probeer mijn slimme meter (ISKRA ME382) uit te lezen met een Wemos D1 met daarop espeasy 2.0. Als omzetter gebruik ik deze schakeling:

http://compuron.nl/IoT/meter/P1I.png

Wat ik ook probeer, er komt geen data op de Wemos. Ik kan hem benaderen via wifi en ook in domoticz zie ik hem in de log. Hij verbreekt telkens de verbinding omdat er geen dataflow is. Ook in Putty gebeurt er niets. Ik heb in espeasy de Communication - P1 Wifi Gateway geselecteerd en de omzetter op pen D5 maar ook de Communication - Serial Server. Deze leest standaard de rx pin maar er kan ook een GPIO pin worden toegekend, maar op beide geen dataflow.

Mijn vraag: klopt de schakeling wel voor deze meter? Ik zou graag de dataflow testen op de wemos om te kijken of er ook data verschijnt in Putty. Kan ik daar de TX van een bijvoorbeeld een seriele kabel op aansluiten?

Ik heb ook een Smile P1 maar die heb ik vernaggelt omdat de software update procedure op de Domoticx site niet klopte. Ik weet niet of daar nog wat mee te doen is :)

Waar rook is, is stroom
mel

Golden Member

Dit zou gewoon moeten werken...5 volt is de enable lijn, dat klopt.Zet die 3V3 lijn eens op 5 volt , en kijk dan nog eens.

[Bericht gewijzigd door mel op 27 november 2019 17:33:15 (30%)]

u=ir betekent niet :U bent ingenieur..

Je kan aan die data-out gewoon een serial kabel hangen.
(wel richting de computer, dus meter tx, computer rx)
115200 8N1.

als je dan de request lijn hoog maakt, zou de data moeten gaan stromen.

kijk uit met die 5V richting wemos, esp's zijn geen 5v apparaten.

Volgens mij moet je of de voeding van je meter (pin1 en pin6)gebruiken ofwel de voeding uit je D1 voor de verschillende functies.
Als ik naar het bijgevoegde schemaatje kijk zie ik:
DataRequest (pin 2) activeren door er 5 volt uit pin 1 op te zetten werkt alleen als de data-ground (pin3) ook verbonden is met power-ground (pin6). De voeding (1 en 6) hangt immers los van de datapoorten, er moet immers een stroompad zijn.
Hetzelfde geldt voor de data-out. Pin 5 is in staat om stroom te 'slikken', maar dan moet er wel stroom kunnen lopen. Via de basis van die transistor gaat dat niet lukken, dus zie je ook geen spannings-variaties (=data). Hang de data-GND en de Power_GND allebei aan jouw D1 GND (zo te zien heb je dat gedaan). Vervolgens hang je een 1k weerstand tussen de +5V van je meter (pin1) of aan je D1 3.3V. De basis van de transistor komt dan rechtstreeks op het knooppunt 1k/Data (5). Als er nu data komt gaat er stroom lopen door de 1k en het spanningsverschil komt op de basis van de tor... Op de collector van de tor zou je dan data moeten krijgen.
Het kan zijn dat het dan nog niet werkt omdat de polariteit van de data door de transistor wordt omgekeerd.... Als dat fout gaat zou je de hele transistor kunnen weglaten en je D1 rechtstreeks op het knooppunt 1k/Data kunnen aansluiten. In dat geval moet je beslist wel die 1k weerstand aan je D1 3.3V hangen en niet op de +5V uit de meter.

Bedankt voor de antwoorden. Ik heb de 3.3V op 5V gezet maar helaas geen resultaat.

@Soldeersmurf: het is echter zo dat die kabeltjes maar 4 aders hebben (2,3,4 en 5) dus 1 en 6 worden niet gebruikt evenals pin 4. Ook op de stekker van de smile p1 zit een 4 aderige kabel. Ik heb nog wel een paar 6 aderige rj11 liggen anders moet ik dat eens proberen.

Ik heb nog een USB naar TTL adapter liggen, kan ik daar ook een datastroom mee opwekken? De pc ziet hem als com 7 dus die werkt in ieder geval.

Waar rook is, is stroom

Volgens mij heeft die ISKRA ME382 DSMR 2.2 protocol, en dan heb je 9600,7,E,1 nodig.

En dan vraag ik me af of die ESP8266 overweg kan met 7 bits, moet ik even de datasheet doorlezen.

Edit: yep, ESP8266 moet met 7bits en even parity overweg kunnen.

Zoals Soldeersmurf al zei:

De data lijn van de meter is een open collector uitgang. Die kan alleen naar massa trekken, dus dan moet je ergens een pull-up voorzien om de lijn weer hoog te krijgen.

Dus je moet een extra weerstand toevoegen van de data (pin 5) naar +3V3.

Zo'n USB naar TTL adapter kun je niet aan je D1 hangen. Voor PC gebruik gaat dat wel werken. Beschouw je D1 maar als de lijn-kant van zo'n adapter, maar met het verschil dat die adapter 5 V signaalspanning heeft ne je D1 3.3 V. Zoals ik al opmerkte kun je of de voeding uit de meter (pin 1 en 6) gebruiken ofwel je D1 voeding.

mel

Golden Member

Pen 1 en 6 zitten bij de meeste meters gewoon "loos"dus niet aangesloten.

u=ir betekent niet :U bent ingenieur..

Ik heb de extra weerstand toegevoegd zoals in dat schema van skysoft en ook de parameters verandert (7,E,1, 9600) maar helaas nog geen resultaat. Ik begin te twijfelen of de wemos wel goed werkt. Ik heb hem nieuw uit de verpakking gehaald en werkt kwa wifi wel goed.

Heb ik wel de juiste GPIO pin? in sommige schema's wordt D5 gebruikt maar ik ben ook andere tegengekomen. Ik kan in de .ino van de sketch geen poort vinden. Daarom gebruikte ik in plaats van de P1 sketch ook de serial server want die zit standaard op de RX en dan moet ik in principe resultaat zien.

Waar rook is, is stroom
Een WOK is ook maar een vergiet zonder gaatjes

Wat soldeersmurf al zei:

5 direct naar D5 en pullup R2 van 10k.

Een simpel programmaatje dat D5 leest en print op de console is toch zo gemaakt? D5 met Weerstand naar + of - en kijken of het werkt.

Een scoop blijft toch een onmisbaar instrument he...

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Ik zou de link van Skysoft nog even goed doorlezen, ik zag iets van 115200 baud...

Op 28 november 2019 21:25:36 schreef K7Jz:
5 direct naar D5 en pullup R2 van 10k.

Een simpel programmaatje dat D5 leest en print op de console is toch zo gemaakt? D5 met Weerstand naar + of - en kijken of het werkt.

Mijn programmeer kennis is helaas minimaal ;) maar je tip met de pull up zal ik zeker proberen.

Ik heb inmiddels de wemos geflasht naar de nieuwste versie van Espeasy en die heeft nu ook de mogelijkheid om een GPIO pin te selecteren. Vanavond weer even verder prutsen.

@marcob: aan de hand van die handleiding heb ik dit ook opgezet. Mooie site is dat met veel info!

Waar rook is, is stroom

Update: ik heb de verbinding nu rechtstreeks met een pullup van 10K. Nu knippert er ook elke 10 seconden een led dus dat is positief. Vervolgens een scope aangesloten en die laat een keurige databurst zien die niet geinverteerd is. Dus je kunt zeggen dat de wemos wel signaal krijgt uit de meter maar er kennelijk (door mijn fouten?) niets mee doet. Putty reageert niet en ook domoticz zegt dat hij geen signaal ontvangt. En omdat dat gebeurt verbreekt hij ook de verbinding om die vervolgens weer te herstellen.

Ik heb D5 aan GPIO 14. Als ik een andere GPIO pin gebruik knippert de led niet meer. Ook als ik in espeasy een andere GPIO kies reageert de led niet. Ik ga er dus van uit dat GPIO 14 standaard wordt aangestuurd door deze sketch.

Waar rook is, is stroom

Post je sketch eens.

Welke led knippert? Zit je gewoon de led te voeden vanuit de P1? ;)

Software is ESP_Easy_mega-20191123_normal_ESP8266_4M1M.bin met daarin de sketch Communication - P1 Wifi Gateway

De led die knippert is de SCK. Die knippert als P1 Wifi Gateway enabled is maar niet als ik bijvoorbeeld serial server inschakel dus ik denk niet dat het door de voedingsspanning komt (alhoewel dat goed mogelijk was natuurlijk)

Ik heb al verscheidene espeasy projectjes gemaakt en bijna allemaal zonder gedoe maar deze weet me wel te boeien :-)

Hier de sketch die standaard in de espeasy flash file zit:

#ifdef USES_P044
//#################################### Plugin 044: P1WifiGateway ########################################
//
// based on P020 Ser2Net, extended by Ronald Leenes romix/-at-/macuser.nl
//
// designed for combo
// Wemos D1 mini (see http://wemos.cc) and
// P1 wifi gateway shield (see https://circuits.io/circuits/2460082)
// see http://romix.macuser.nl for kits
//#######################################################################################################

#define PLUGIN_044
#define PLUGIN_ID_044 44
#define PLUGIN_NAME_044 "Communication - P1 Wifi Gateway"
#define PLUGIN_VALUENAME1_044 "P1WifiGateway"

#define P044_STATUS_LED 12
#define P044_BUFFER_SIZE 1024
#define P044_NETBUF_SIZE 128
#define P044_DISABLED 0
#define P044_WAITING 1
#define P044_READING 2
#define P044_CHECKSUM 3
#define P044_DONE 4

boolean Plugin_044_init = false;
boolean serialdebug = false;
char* Plugin_044_serial_buf = nullptr;
unsigned int bytes_read = 0;
boolean CRCcheck = false;
unsigned int currCRC = 0;
int checkI = 0;

WiFiServer *P1GatewayServer = nullptr;
WiFiClient P1GatewayClient;

// Fixme TD-er: Reverted to old implementation for now.
// This one has been reverted in https://github.com/letscontrolit/ESPEasy/pull/2352
// Since both plugins (P020 and P044) are almost identical in handling serial data.
// However that version of P044 had a number of other fixes which may be very useful anyway.

boolean Plugin_044(byte function, struct EventStruct *event, String& string)
{
boolean success = false;
static byte connectionState = 0;
static int state = P044_DISABLED;

switch (function)
{

case PLUGIN_DEVICE_ADD:
{
Device[++deviceCount].Number = PLUGIN_ID_044;
Device[deviceCount].Type = DEVICE_TYPE_SINGLE;
Device[deviceCount].Custom = true;
Device[deviceCount].TimerOption = false;
break;
}

case PLUGIN_GET_DEVICENAME:
{
string = F(PLUGIN_NAME_044);
break;
}

case PLUGIN_GET_DEVICEVALUENAMES:
{
strcpy_P(ExtraTaskSettings.TaskDeviceValueNames[0], PSTR(PLUGIN_VALUENAME1_044));
break;
}

case PLUGIN_WEBFORM_LOAD:
{
addFormNumericBox(F("TCP Port"), F("p044_port"), ExtraTaskSettings.TaskDevicePluginConfigLong[0]);
addFormNumericBox(F("Baud Rate"), F("p044_baud"), ExtraTaskSettings.TaskDevicePluginConfigLong[1]);
addFormNumericBox(F("Data bits"), F("p044_data"), ExtraTaskSettings.TaskDevicePluginConfigLong[2]);

byte choice = ExtraTaskSettings.TaskDevicePluginConfigLong[3];
String options[3];
options[0] = F("No parity");
options[1] = F("Even");
options[2] = F("Odd");
int optionValues[3] = { 0, 2, 3 };
addFormSelector(F("Parity"), F("p044_parity"), 3, options, optionValues, choice);

addFormNumericBox(F("Stop bits"), F("p044_stop"), ExtraTaskSettings.TaskDevicePluginConfigLong[4]);

// FIXME TD-er: Why isn't this using the normal pin selection functions?
addFormPinSelect(F("Reset target after boot"), F("taskdevicepin1"), Settings.TaskDevicePin1[event->TaskIndex]);

addFormNumericBox(F("RX Receive Timeout (mSec)"), F("p044_rxwait"), Settings.TaskDevicePluginConfig[event->TaskIndex][0]);

success = true;
break;
}

case PLUGIN_WEBFORM_SAVE:
{
ExtraTaskSettings.TaskDevicePluginConfigLong[0] = getFormItemInt(F("p044_port"));
ExtraTaskSettings.TaskDevicePluginConfigLong[1] = getFormItemInt(F("p044_baud"));
ExtraTaskSettings.TaskDevicePluginConfigLong[2] = getFormItemInt(F("p044_data"));
ExtraTaskSettings.TaskDevicePluginConfigLong[3] = getFormItemInt(F("p044_parity"));
ExtraTaskSettings.TaskDevicePluginConfigLong[4] = getFormItemInt(F("p044_stop"));
Settings.TaskDevicePluginConfig[event->TaskIndex][0] = getFormItemInt(F("p044_rxwait"));

success = true;
break;
}

case PLUGIN_INIT:
{
pinMode(P044_STATUS_LED, OUTPUT);
digitalWrite(P044_STATUS_LED, 0);

LoadTaskSettings(event->TaskIndex);
if ((ExtraTaskSettings.TaskDevicePluginConfigLong[0] != 0) && (ExtraTaskSettings.TaskDevicePluginConfigLong[1] != 0))
{
#if defined(ESP8266)
byte serialconfig = 0x10;
#endif
#if defined(ESP32)
uint32_t serialconfig = 0x8000010;
#endif
serialconfig += ExtraTaskSettings.TaskDevicePluginConfigLong[3];
serialconfig += (ExtraTaskSettings.TaskDevicePluginConfigLong[2] - 5) << 2;
if (ExtraTaskSettings.TaskDevicePluginConfigLong[4] == 2)
serialconfig += 0x20;
#if defined(ESP8266)
Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], (SerialConfig)serialconfig);
#endif
#if defined(ESP32)
Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], serialconfig);
#endif
if (P1GatewayServer)
{
P1GatewayServer->close();
delete P1GatewayServer;
}
P1GatewayServer = new WiFiServer(ExtraTaskSettings.TaskDevicePluginConfigLong[0]);
P1GatewayServer->begin();

if (!Plugin_044_serial_buf)
Plugin_044_serial_buf = new char[P044_BUFFER_SIZE];

if (Settings.TaskDevicePin1[event->TaskIndex] != -1)
{
pinMode(Settings.TaskDevicePin1[event->TaskIndex], OUTPUT);
digitalWrite(Settings.TaskDevicePin1[event->TaskIndex], LOW);
delay(500);
digitalWrite(Settings.TaskDevicePin1[event->TaskIndex], HIGH);
pinMode(Settings.TaskDevicePin1[event->TaskIndex], INPUT_PULLUP);
}

Plugin_044_init = true;
}

blinkLED();

if (ExtraTaskSettings.TaskDevicePluginConfigLong[1] == 115200) {
addLog(LOG_LEVEL_DEBUG, F("P1 : DSMR version 4 meter, CRC on"));
CRCcheck = true;
} else {
addLog(LOG_LEVEL_DEBUG, F("P1 : DSMR version 4 meter, CRC off"));
CRCcheck = false;
}

state = P044_WAITING;
success = true;
break;
}

case PLUGIN_EXIT:
{
if (P1GatewayServer) {
P1GatewayServer->close();
delete P1GatewayServer;
P1GatewayServer = NULL;
}
if (Plugin_044_serial_buf) {
delete[] Plugin_044_serial_buf;
}
success = true;
break;
}

case PLUGIN_TEN_PER_SECOND:
{
if (Plugin_044_init)
{
if (P1GatewayServer->hasClient())
{
if (P1GatewayClient) P1GatewayClient.stop();
P1GatewayClient = P1GatewayServer->available();
P1GatewayClient.setTimeout(CONTROLLER_CLIENTTIMEOUT_DFLT);
addLog(LOG_LEVEL_ERROR, F("P1 : Client connected!"));
}

if (P1GatewayClient.connected())
{
connectionState = 1;
uint8_t net_buf[P044_NETBUF_SIZE];
int count = P1GatewayClient.available();
if (count > 0)
{
size_t net_bytes_read;
if (count > P044_NETBUF_SIZE)
count = P044_NETBUF_SIZE;
net_bytes_read = P1GatewayClient.read(net_buf, count);
Serial.write(net_buf, net_bytes_read);
Serial.flush(); // Waits for the transmission of outgoing serial data to complete

if (count == P044_NETBUF_SIZE) // if we have a full buffer, drop the last position to stuff with string end marker
{
count--;
// and log buffer full situation
addLog(LOG_LEVEL_ERROR, F("P1 : Error: network buffer full!"));
}
net_buf[count] = 0; // before logging as a char array, zero terminate the last position to be safe.
char log[P044_NETBUF_SIZE + 40] = {0};
sprintf_P(log, PSTR("P1 : Error: N>: %s"), (char*)net_buf);
ZERO_TERMINATE(log);
addLog(LOG_LEVEL_DEBUG, log);
}
}
else
{
if (connectionState == 1) // there was a client connected before...
{
connectionState = 0;
addLog(LOG_LEVEL_ERROR, F("P1 : Client disconnected!"));
}

while (Serial.available())
Serial.read();
}

success = true;
}
break;
}

case PLUGIN_SERIAL_IN:
{
if (Plugin_044_init)
{
if (P1GatewayClient.connected())
{
int RXWait = Settings.TaskDevicePluginConfig[event->TaskIndex][0];
if (RXWait == 0)
RXWait = 1;
int timeOut = RXWait;
while (timeOut > 0)
{
while (Serial.available() && state != P044_DONE) {
if (bytes_read < P044_BUFFER_SIZE - 5) {
char ch = Serial.read();
digitalWrite(P044_STATUS_LED, 1);
switch (state) {
case P044_DISABLED: //ignore incoming data
break;
case P044_WAITING:
if (ch == '/') {
Plugin_044_serial_buf[0] = ch;
bytes_read=1;
state = P044_READING;
} // else ignore data
break;
case P044_READING:
if (ch == '!') {
if (CRCcheck) {
state = P044_CHECKSUM;
} else {
state = P044_DONE;
}
}
if (validP1char(ch)) {
Plugin_044_serial_buf[bytes_read] = ch;
bytes_read++;
} else if (ch=='/') {
addLog(LOG_LEVEL_DEBUG, F("P1 : Error: Start detected, discarded input."));
Plugin_044_serial_buf[0] = ch;
bytes_read = 1;
} else { // input is non-ascii
addLog(LOG_LEVEL_DEBUG, F("P1 : Error: DATA corrupt, discarded input."));
Serial.flush();
bytes_read = 0;
state = P044_WAITING;
}
break;
case P044_CHECKSUM:
checkI ++;
if (checkI == 4) {
checkI = 0;
state = P044_DONE;
}
Plugin_044_serial_buf[bytes_read] = ch;
bytes_read++;
break;
case P044_DONE:
// Plugin_044_serial_buf[bytes_read]= '\n';
// bytes_read++;
// Plugin_044_serial_buf[bytes_read] = 0;
break;
}
}
else
{
Serial.read(); // when the buffer is full, just read remaining input, but do not store...
bytes_read = 0;
state = P044_WAITING; // reset
}
digitalWrite(P044_STATUS_LED, 0);
timeOut = RXWait; // if serial received, reset timeout counter
}
delay(1);
timeOut--;
}

if (state == P044_DONE) {
if (checkDatagram(bytes_read)) {
Plugin_044_serial_buf[bytes_read] = '\r';
bytes_read++;
Plugin_044_serial_buf[bytes_read] = '\n';
bytes_read++;
Plugin_044_serial_buf[bytes_read] = 0;
P1GatewayClient.write((const uint8_t*)Plugin_044_serial_buf, bytes_read);
P1GatewayClient.flush();
addLog(LOG_LEVEL_DEBUG, F("P1 : data send!"));
blinkLED();

if (Settings.UseRules)
{
LoadTaskSettings(event->TaskIndex);
String eventString = getTaskDeviceName(event->TaskIndex);
eventString += F("#Data");
rulesProcessing(eventString);
}

} else {
addLog(LOG_LEVEL_DEBUG, F("P1 : Error: Invalid CRC, dropped data"));
}

bytes_read = 0;
state = P044_WAITING;
} // state == P044_DONE
}
success = true;
}
break;
}

}
return success;
}
void blinkLED() {
digitalWrite(P044_STATUS_LED, 1);
delay(500);
digitalWrite(P044_STATUS_LED, 0);
}
/*
validP1char
checks whether the incoming character is a valid one for a P1 datagram. Returns false if not, which signals corrupt datagram
*/
bool validP1char(char ch) {
if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '.') || (ch == '!') || (ch == ' ') || (ch == 92) || (ch == 13) || (ch == '\n') || (ch == '(') || (ch == ')') || (ch == '-') || (ch == '*') || (ch == ':') )
{
return true;
} else {
addLog(LOG_LEVEL_DEBUG, F("P1 : Error: invalid char read from P1"));
if (serialdebug) {
serialPrint(F("faulty char>"));
serialPrint(String(ch));
serialPrintln("<");
}
return false;
}
}

int FindCharInArrayRev(char array[], char c, int len) {
for (int i = len - 1; i >= 0; i--) {
if (array == c) {
return i;
}
}
return -1;
}

/*
CRC16
based on code written by Jan ten Hove
https://github.com/jantenhove/P1-Meter-ESP8266
*/
unsigned int CRC16(unsigned int crc, unsigned char *buf, int len)
{
for (int pos = 0; pos < len; pos++)
{
crc ^= (unsigned int)buf[pos]; // XOR byte into least sig. byte of crc

for (int i = 8; i != 0; i--) { // Loop over each bit
if ((crc & 0x0001) != 0) { // If the LSB is set
crc >>= 1; // Shift right and XOR 0xA001
crc ^= 0xA001;
}
else // Else LSB is not set
crc >>= 1; // Just shift right
}
}

return crc;
}

/* checkDatagram
checks whether the P044_CHECKSUM of the data received from P1 matches the P044_CHECKSUM attached to the
telegram
based on code written by Jan ten Hove
https://github.com/jantenhove/P1-Meter-ESP8266
*/
bool checkDatagram(int len) {
int startChar = FindCharInArrayRev(Plugin_044_serial_buf, '/', len);
int endChar = FindCharInArrayRev(Plugin_044_serial_buf, '!', len);
bool validCRCFound = false;

if (!CRCcheck) return true;

if (serialdebug) {
serialPrint(F("input length: "));
serialPrintln(String(len));
serialPrint("Start char \\ : ");
serialPrintln(String(startChar));
serialPrint(F("End char ! : "));
serialPrintln(String(endChar));
}

if (endChar >= 0)
{
currCRC = CRC16(0x0000, (unsigned char *) Plugin_044_serial_buf, endChar - startChar + 1);

char messageCRC[5];
strncpy(messageCRC, Plugin_044_serial_buf + endChar + 1, 4);
messageCRC[4] = 0;
if (serialdebug) {
for (int cnt = 0; cnt < len; cnt++)
serialPrint(String(Plugin_044_serial_buf[cnt]));
}

validCRCFound = (strtoul(messageCRC, NULL, 16) == currCRC);
if (!validCRCFound) {
addLog(LOG_LEVEL_DEBUG, F("P1 : Error: invalid CRC found"));
}
currCRC = 0;
}
return validCRCFound;
}
#endif // USES_P044

Waar rook is, is stroom

Waar zie je het signaal niet geïnverteerd staan, na de tor, dus wat de ESP in gaat? Die tor is een inverter he, weet je dat?
Een uart signaal moet in rust '1' zijn, en pas '0' worden bij het 1e startbit van het P1 bericht uit de meter.

[Bericht gewijzigd door flipflop op 30 november 2019 12:47:41 (31%)]

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Dubbel

[Bericht gewijzigd door K7Jz op 30 november 2019 14:13:43 (97%)]

c code:


//maak deze true, dan zou je wat via de USB seriële poort binnem moeten krijgen 
boolean serialdebug = true;


if (bytes_read < P044_BUFFER_SIZE - 5) {
char ch = Serial.read();
serialPrint("have read char:"); // deze 3 regels toevoegen 
serialPrint(String(ch));
serialPrintln(".");

[Bericht gewijzigd door K7Jz op 30 november 2019 14:12:28 (13%)]

Op 30 november 2019 12:46:27 schreef flipflop:
Waar zie je het signaal niet geïnverteerd staan, na de tor, dus wat de ESP in gaat? Die tor is een inverter he, weet je dat?
Een uart signaal moet in rust '1' zijn, en pas '0' worden bij het 1e startbit van het P1 bericht uit de meter.

De tor zit er niet meer tussen op advies van soldeersmurf en K7Jz. Ik heb 5 nu rechtstreeks aan D5 met een pullup van 10K. Volgens het scope beeld is de databurst niet geinverteerd.

Waar rook is, is stroom

Bedankt voor de link ! Mqtt lukt met domoticz.

Heb je een tip om een signaal aan te bieden aan (bijvoorbeeld) GPIO 14 van de wemos om te kijken of hij zowiezo wel data wil versturen? Ik zag iets van een seriele kabel vanaf een pc maar ik weet niet hoe ik dat moet aansluiten of misschien een ander methode? Ik krijg steeds meer het idee dat die meter wel data verstuurt maar dat de wemos er niets mee doet. Ik heb wel meerdere projectjes met een esp8266 gemaakt en die werkten bijna altijd gelijk goed.

Nogmaals bedankt voor de hulp en ik ga die skectch uit de link erop zetten.

Waar rook is, is stroom