MBus mit Arduino, wer hat’s schon gemacht ?

[Carstene]

Ich habe ein neues Winterprojekt und würde gerne unsere neuen Gaszähler, welcher das MBusprotokoll unterstützt, mit dem Arduino auslesen.

da ist keine Adapter von UART auf MBus gibt habe ich immer Bucht einen USB-Adapter gekauft und hinter dem parallel/seriell-Chip die Leiterbahnen geöffnet und die PIN auf einen Stecker gebracht.

Das sieht jetzt so aus
image.jpg

Heute Nachmittag habe ich mich im Keller verkrochen und habe auch mal ausprobiert was da so auf dieser Datenleitung passiert. Dafür meinen alten Oszi aus dem Keller geholt und das ganze Gelumpe mal zusammengesteckt.
Das Ergebnis kann sich sehen lassen!
Das DatenProtokoll läuft in etwa 6 mS.
Schön zu erkennen sind die zwei Protokolle (warum eigentlich zwei?) zu Anfang und die Antworten vom Wasserzähler, gefolgt vom Datenpaket.

349167BE-0BA2-4F37-B837-F7159597A5BC.jpeg
Das was man auf dem Oszi sehen kann ist das abgegriffene Signal nach dem PL2303, welche Serie auf den im Bus geht (das Daten Signal was über die Transistoren nachher auf dem Bus liegt). D.h. noch läuft die Datenübertragung vom Laptop per USB

nur wie bekomme ich dieses nun einem Arduino verklickert ?

Ich habe jetzt noch nicht viel gesucht aber vielleicht weiß jemand von einer Bibliothek für den Arduino
Gefunden habe ich bisher das hier, leider für einen Raspberry
http://blog.bubux.de/m-bus-wasserzaehler/
In wie weit lässt sich sowas auf den Arduino übertragen?
Grüsse
Carsten

[Carstene]

Nunja.....

Nach einigen Tagen Knobelei kann ich zumindest mal selbst eine Antwort geben

Diesen Code habe ich nach längerer Suche im Netz gefunden. Es mussten einige Bibliotheken installiert werden.
Damit kann der Arduino dem Gaszähler allerhand Parameter entlocken.

Diese habe ich nur zum Teil entschlüsselt - bisher. Das werde ich zu gegebener Zeit noch mit zu diesen Beiträgen anhängen

// --------------------------------------------------------
// Arduino MBUS reader
//
// Part of the OpenEnergyMonitor.org project
// Licence: GPL
// Author: Trystan Lea
// --------------------------------------------------------

#define DIF  0
#define DIFE 1
#define VIF  2
#define VIFE 3
#define DATA 4

#include <CustomSoftwareSerial.h>
CustomSoftwareSerial* customSerial;               // Declare serial
byte address = 16;

byte bid = 0;
byte bid_end = 255;
byte bid_checksum = 255;
byte len = 0;
byte valid = 0;
byte checksum = 0;
byte type = DIF;
byte data_count = 0;
byte data_len = 0;

byte cmd[10];
byte cmdi = 0;
byte page = 0;

byte data[255];

// --------------------------------------------------------
// Setup
// --------------------------------------------------------
void setup() {
  Serial.begin(115200);
  Serial.println("Arduino MBUS reader");
  Serial.println("- a: set mbus address to 100");
  Serial.println("- n: normalize");
  Serial.println("- r: request data");
  Serial.println("- c: application reset");
  Serial.println("- i: set id 1234");
  Serial.println("- b: set baudrate 4800");
  Serial.println("- p: select page eg: p1");
  Serial.println();
  customSerial = new CustomSoftwareSerial(9,10);
  customSerial->begin(2400, CSERIAL_8E1);
}
// --------------------------------------------------------
// Parse command
// --------------------------------------------------------
void parse_cmd()
{
  // for (byte c=0; c<cmdi; c++) Serial.print((char)cmd[c]);

  switch(cmd[0])
  {
    case 'p':
      Serial.println("Command sent: page");
      page = 0;
      if (cmdi==2) page = cmd[1]-48;
      if (cmdi==3) page = (cmd[1]-48)*10 + (cmd[2]-48);
      Serial.print("Page: ");
      Serial.println(page);
      mbus_request(100,page);
      break;
    case 'r':
      Serial.println("Command sent: request data");
      mbus_request_data(100);
      break;
    case 'n':
      Serial.println("Command sent: normalize");
      mbus_normalize(100);
      break;
    case 'c':
      Serial.println("Command sent: application reset");
      mbus_application_reset(100);
      break;
    case 'i':
      Serial.println("Command sent: set id");
      mbus_set_id(100);
      break;
    case 'b':
      Serial.println("Command sent: set baudrate");
      // B8 Baudrate 300
      // B9 Baudrate 600
      // BA Baudrate 1200
      // BB Baudrate 2400
      // BC Baudrate 4800
      // BD Baudrate 9600
      mbus_set_baudrate(100,0xBC);
      break;
    case 'a':
      Serial.println("Command sent: set address 100");
      // Address 1-250, 254,255 broadcast, 0 unconfigured
      mbus_set_address(254,100);
      break;

  }

  bid = 0;
}

// --------------------------------------------------------
// Parse returned frame
// --------------------------------------------------------
void parse_frame()
{
  byte bid = 0;
  for (byte i=0; i<(len+6); i++)
  {
    byte val = data[i];

    Serial.print(i);
    Serial.print("\t");
    Serial.print(val);
    Serial.print("\t");
    Serial.print(val,HEX);
    Serial.print("\t");
    
    if (bid==0 && val==0x68) {
      Serial.print("START");
      valid = 1;
      checksum = 0;
      type = DIF;
    }

    if (valid && bid==1) {
      len = val;
      bid_end = len+4+2-1;
      bid_checksum = bid_end-1;
      Serial.print("LEN");
    }
    if (valid && bid==2) {
      if (val==len) {
        Serial.print("LEN");
      } else valid = 0;
    }

    if (valid && bid==3) {
      if (val==0x68) {
        Serial.print("START");
      } else valid = 0;
    }
    
    if (valid)
    {
      if (bid==4) Serial.print("C FIELD");
      if (bid==5) Serial.print("ADDRESS");
      if (bid==6) Serial.print("CI FIELD");
      if (bid==7 || bid==8 || bid==9 || bid==10) Serial.print("ID");
      if (bid==11 || bid==12) Serial.print("MID");
      if (bid==13) Serial.print("Gen");
      if (bid==14) Serial.print("Media");
      if (bid==15) Serial.print("Access");
      if (bid==16) Serial.print("Access");
      if (bid==17 || bid==18) Serial.print("Signature");
      
      if (bid>18) {
        if (type==DIF) {
          Serial.print("DIF ");
          if (val>=0x80) type=DIFE; else type=VIF;
          data_count = 0;

          byte data_field = val & 0x0F; // AND logic
          
          switch (data_field) {
            case 0: data_len = 0; break;
            case 1: data_len = 1; break;      
            case 2: data_len = 2; break;  
            case 3: data_len = 3; break;
            case 4: data_len = 4; break;                  
            case 5: data_len = 4; break;  
            case 6: data_len = 6; break;  
            case 7: data_len = 8; break;
            case 8: data_len = 0; break;
            case 9: data_len = 1; break;
            case 10: data_len = 2; break;
            case 11: data_len = 3; break;
            case 12: data_len = 4; break;
            case 13: data_len = 0; break;
            case 14: data_len = 6; break;
            case 15: data_len = 0; break;        
          }
                      
          Serial.print(data_len);
        }

        else if (type==DIFE) {
          Serial.print("DIFE");
          if (val>=0x80) type=DIFE; else type=VIF;
        }

        else if (type==VIF) {
          Serial.print("VIF ");
          if (val>=0x80) type=VIFE; else type=DATA;

          if (val==0x06) Serial.print("Energy kWh");
          if (val==0x13) Serial.print("Volume Flow 0.001m3");
          if (val==0x14) Serial.print("Volume Flow 0.01m3");

          if (val==0x5b) Serial.print("Flow Temp C");
          if (val==0x59) Serial.print("Flow Temp 0.01C");
          if (val==0x5f) Serial.print("Return Temp C");
          if (val==0x5d) Serial.print("Return Temp 0.01C");
          if (val==0x3b) Serial.print("Volume Flow mm3/h (averaged)");
          if (val==0x3e) Serial.print("Volume Flow m3/h (averaged)");
          if (val==0x2b) Serial.print("Power W (averaged)");
          if (val==0x2c) Serial.print("Power kW (averaged)");
          if (val==0x22) Serial.print("Power 100 J/h (averaged)");
          if (val==0x6D) Serial.print("TIME & DATE");

          if (val==0x70) Serial.print("Duration seconds (averaged)");
          if (val==0x74) Serial.print("Duration seconds (actual)");        
          if (val==0x75) Serial.print("Duration minutes (actual)");
          if (val==0x78) Serial.print("Fab No");
          if (val==0x79) Serial.print("Enhanced");
          
        }

        else if (type==VIFE) {
          Serial.print("VIFE");
          if (val>=0x80) type=VIFE; else type=DATA;
        }

        else if (type==DATA) {
          Serial.print("DATA");
          data_count++;
          if (data_count==data_len) {
            type=DIF;
          }
        }
        
      }

      if (bid>3 && bid<bid_checksum) checksum += val;
    }

    if (valid && bid==bid_checksum) {
      if (val==checksum) {
        Serial.print("CHECKSUM VALID");
      } else {
        Serial.print("CHECKSUM INVALID");
        valid = 0;
      }
    }
    
    if (valid && bid==bid_end && val==0x16) Serial.print("END");

    Serial.println();
    bid++;
  }
  
}

// --------------------------------------------------------
// Loop
// --------------------------------------------------------
void loop() {

  if (Serial.available()) {
    byte c = Serial.read();

    if (c=='\n' || c=='\r') {
      if (cmdi>0) parse_cmd();
      cmdi = 0;
    } else {
      cmd[cmdi++] = c;
    }
  }

  while(customSerial->available())
  {
    byte val = (byte) customSerial->read();
    data[bid] = val;

    // Catch ACK
    if (bid==0 && val==0xE5) Serial.println("ACK");

    // Long frame start, reset checksum
    if (bid==0 && val==0x68) {
      valid = 1;
      checksum = 0;
    }

    // 2nd byte is the frame length
    if (valid && bid==1) {
      len = val;
      bid_end = len+4+2-1;
      bid_checksum = bid_end-1;
    }
    
    if (valid && bid==2 && val!=len) valid = 0;                 // 3rd byte is also length, check that its the same as 2nd byte
    if (valid && bid==3 && val!=0x68) valid = 0;                // 4th byte is the start byte again
    if (valid && bid>3 && bid<bid_checksum) checksum += val;    // Increment checksum during data portion of frame

    if (valid && bid==bid_checksum && val!=checksum) valid = 0; // Validate checksum
    if (valid && bid==bid_end && val==0x16) parse_frame();      // Parse frame if still valid

    bid++;
  }
}

// Licence: GPL v3
#define MBUS_FRAME_SHORT_START          0x10
#define MBUS_FRAME_LONG_START           0x68
#define MBUS_FRAME_STOP                 0x16

#define MBUS_CONTROL_MASK_SND_NKE       0x40
#define MBUS_CONTROL_MASK_DIR_M2S       0x40
#define MBUS_ADDRESS_NETWORK_LAYER      0xFE

#define MBUS_ACK                        0xE5 (229)

// -------------------------------------------------------------------------------------
// C_field: Control Field, Function Field
// FCB: Frame count bit
// FCV: Frame count bit valid
// ADC: Access demand (slave wants to transmit class 1 data)
// DFC: Data flow control = 1 (slave cannot accept further data)

// SND_NKE Initialization of Slave:   BIN:0100 0000 HEX:40           (SHORT FRAME)
// SND_UD  Send User Data to Slave:   BIN:01F1 0011 HEX:53/73        (LONG/CONTROL FRAME)
// REQ_UD2 Request for Class 2 Data:  BIN:01F1 1011 HEX:5B/7B        (SHORT FRAME)
// REQ_UD1 Request for Class 1 Data:  BIN:01F1 1010 HEX:5A/7A        (SHORT FRAME)
// RSP_UD  Data Transfer from Slave:  BIN:00AD 1000 HEX:08/18/28/38  (LONG/CONTROL FRAME)
// F: FCB-Bit, A: ACD-Bit, D: DFC-bit
// -------------------------------------------------------------------------------------

// Address 1-250, 254,255 broadcast, 0 unconfigured

// CI Field
// 51h data send
// 52h selection of slaves
// 50h appliction reset

// --------------------------------------------------------------
// MBUS CONTROL FRAME
//
// C_field: Control Field, Function Field
// --------------------------------------------------------------
int mbus_scan() {
  unsigned long timer_start = 0;
  for (byte retry=1; retry<=3; retry++) {
    for (byte address = 1; address <= 20; address++) {
      mbus_normalize(address);
      timer_start = millis();
      while (millis()-timer_start<40) {
        if (customSerial->available()) {
          byte val = customSerial->read();
          if (val==0xE5) return address;
        }
      }
    }
  }
  return -1;
}

// ---------------------------------------------------------------

void mbus_normalize(byte address) {
  mbus_short_frame(address,0x40);
}

void mbus_request_data(byte address) {
  mbus_short_frame(address,0x5b);
}

void mbus_application_reset(byte address) {
  mbus_control_frame(address,0x53,0x50);
}

void mbus_request(byte address,byte telegram) {
 
  byte data[15];
  byte i=0;
  data[i++] = MBUS_FRAME_LONG_START;
  data[i++] = 0x07;
  data[i++] = 0x07;
  data[i++] = MBUS_FRAME_LONG_START;
  
  data[i++] = 0x53;
  data[i++] = address;
  data[i++] = 0x51;

  data[i++] = 0x01;
  data[i++] = 0xFF;
  data[i++] = 0x08;
  data[i++] = telegram;

  unsigned char checksum = 0;
  for (byte c=4; c<i; c++) checksum += data[c];
  data[i++] = (byte) checksum;
  
  data[i++] = 0x16;
  data[i++] = '\0';
  
  customSerial->write((char*)data);
}

void mbus_set_address(byte oldaddress, byte newaddress) {
 
  byte data[13];
 
  data[0] = MBUS_FRAME_LONG_START;
  data[1] = 0x06;
  data[2] = 0x06;
  data[3] = MBUS_FRAME_LONG_START;
  
  data[4] = 0x53;
  data[5] = oldaddress;
  data[6] = 0x51;
  
  data[7] = 0x01;         // DIF [EXT0, LSB0, FN:00, DATA 1 8BIT INT]
  data[8] = 0x7A;         // VIF 0111 1010 bus address
  data[9] = newaddress;   // DATA new address
  
  data[10] = data[4]+data[5]+data[6]+data[7]+data[8]+data[9];
  data[11] = 0x16;
  data[12] = '\0';
  
  customSerial->write((char*)data);
}

void mbus_set_baudrate(byte address, byte baudrate) {
 
  byte data[11];
  byte i=0;
  
  data[i++] = MBUS_FRAME_LONG_START;
  data[i++] = 0x03;
  data[i++] = 0x03;
  data[i++] = MBUS_FRAME_LONG_START;
  
  data[i++] = 0x53;
  data[i++] = address;
  data[i++] = baudrate;
  
  unsigned char checksum = 0;
  for (byte c=4; c<i; c++) checksum += data[c];
  data[i++] = (byte) checksum;
  
  data[i++] = 0x16;
  data[i++] = '\0';
  
  customSerial->write((char*)data);
}

void mbus_set_id(byte address) {
 
  byte data[16];
  byte i=0;
  
  data[i++] = MBUS_FRAME_LONG_START;
  data[i++] = 0x09;
  data[i++] = 0x09;
  data[i++] = MBUS_FRAME_LONG_START;
  
  data[i++] = 0x53;
  data[i++] = address;
  data[i++] = 0x51;
  
  data[i++] = 0x0C;
  data[i++] = 0x79;
  data[i++] = 0x01; //ID1
  data[i++] = 0x02; //ID2
  data[i++] = 0x03; //ID3
  data[i++] = 0x04; //ID4
    
  unsigned char checksum = 0;
  for (byte c=4; c<i; c++) checksum += data[c];
  data[i++] = (byte) checksum;
  
  data[i++] = 0x16;
  data[i++] = '\0';
  
  customSerial->write((char*)data);
}

// ---------------------------------------------------------------

void mbus_short_frame(byte address, byte C_field) {
  byte data[6];

  data[0] = 0x10;
  data[1] = C_field;
  data[2] = address;
  data[3] = data[1]+data[2];
  data[4] = 0x16;
  data[5] = '\0';

  customSerial->write((char*)data);
}

void mbus_control_frame(byte address, byte C_field, byte CI_field)
{
  byte data[10];
  data[0] = MBUS_FRAME_LONG_START;
  data[1] = 0x03;
  data[2] = 0x03;
  data[3] = MBUS_FRAME_LONG_START;
  data[4] = C_field;
  data[5] = address;
  data[6] = CI_field;
  data[7] = data[4] + data[5] + data[6];
  data[8] = MBUS_FRAME_STOP;
  data[9] = '\0';

  customSerial->write((char*)data);
} 

der Datensatz schaut auf dem Oszi nun so aus ( ohne DC Anteil)

[Carstene]

Die bisherige Auswertung der ausgegeben Daten brachte mich bisher nicht sonderlich weit

Dennoch..... das spuckt der Arduino aus wenn man den Datensatz ausliest (so richtig erschliesst sich mir die Bedinung noch nicht)

Arduino MBUS reader
 
Zählerstand 75,xx
 
- a: set mbus address to 100
- n: normalize
- r: request data
- c: application reset
- i: set id 1234
- b: set baudrate 4800
- p: select page eg: p1
 
Command sent: request data
 
Laufende Nr        Decimal               Hexadecimal       Adressfeld           Eigene Bemerkung
0                          104                      68                        START
1                          40                        28                        LEN
2                          40                        28                        LEN
3                          104                      68                        START
4                          8                          8                          C FIELD
5                          100                      64                        ADDRESS
6                          114                      72                        CI FIELD
 
7                          XX                        XX                        ID                         Geräte ID 4 von 4
8                          XX                        XX                        ID                         Geräte ID 3 von 4
9                          XXX                      XX                        ID                         Geräte ID 2 von 4
10                        XX                        XX                        ID                         Geräte ID 1 von 4
11                        147                      93                        MID
12                        21                        15                        MID
13                        129                      81                        Gen
14                        3                          3                          Media                  Medienart (Gas(3), Wasser, Wärme)
15                        6                          6                          Access                Zählerzugriff, immer 0 bei neu anschl.
16                        0                          0                          Access
17                        0                          0                          Signature
18                        0                          0                          Signature
 
19                        13                        D                          DIF 0
20                        XXX                      XX                        VIF                    Teil der Abnehmernummer (?)
21                        17                        11                        VIFE
22                        14                        E                          DATA
23                        57                        39                        DATA
24                        51                        33                        DATA
 
25                        57                        39                        DATA
26                        53                        35                        DATA
27                        52                        34                        DATA
28                        57                        39                        DATA
29                        54                        36                        DATA
30                        51                        33                        DATA
31                        53                        35                        DATA
32                        50                        32                        DATA
33                        83                        53                        DATA
34                        76                        4C                        DATA
35                        69                        45                        DATA
36                        55                        37                        DATA
37                        12                        C                         DATA
38                        147                      93                        DATA
39                        58                        3A                        DATA
 
40                        96                        60                        DATA     In diesen 4 Werten vermute ich den 
41                        85                        55                        DATA     Verbrauchszähler, da dies die einzigen 
42                        7                          7                          DATA     Werte sind, die sich verändern
43                        0                          0                          DATA     mit Ausnahme der Checksumme
 
44                        92                        5C                       DATACHECKSUM VALID
45                        22                        16                        DATAEND 

Nach den bisherigen Erkenntnissen setzt sich die Abnehmernummer des Gaszählers aus folgenden Nummern zusammen (auch in dieser Reihenfolge), interessanterweise geschmischt aus HEX und DEC: 20 DEC), 10(HEX), 9(HEX), 8(HEX), 7(HEX).
Mit diesen Werten lässt sich schonmal die elfstellige Abnehmernummer ohne vorangehende Buchstaben ermitteln. Warum die HEX und DEC mischen ist mir ein Rätsel - vielleicht ist es auch Zufall

Die Zeilen 40 - 43 köööönten was mit dem Verbrauchszähler zu tun haben

Werde in den Keller gehen und diese Werte bei laufender Heizung beobachten

[Carstene]

Ich liege mit meiner Vermutung nicht weit weg
Folgendes lässt sich erkennen:

An diesem Beispiel, mit Zählwerkstand 82,59:

40                        144                      90                        DATA
41                        37                        25                        DATA
42                        8                          8                          DATA
43                        0                          0                          DATA 

Der Datensatz wird von hinten geschrieben, also 43, 42, 41, 40 ergibt 08259, diesen geteilt durch 100 (oder "mit zwei Kommastellen) = 82,59
(Muss mal schauen ob ein Wert eine Kommastelle angibt.... es gibt ja auch andere, grössere Zähler)

Nächstes Beispiel mit 82,65

40                        80                        50                        DATA
41                        38                        26                        DATA
42                        8                          8                          DATA
43                        0                          0                          DATA 

82,67

40                        112                      70                        DATA
41                        38                        26                        DATA
42                        8                          8                          DATA
43                        0                          0                          DATA 

82,69

40                        144                      90                        DATA
41                        38                        26                        DATA
42                        8                          8                          DATA
43                        0                          0                          DATA 

82,70

40                        0                          0                          DATA
41                        39                        27                        DATA
42                        8                          8                          DATA
43                        0                          0                          DATA 

82,71

40                        16                        10                        DATA
41                        39                        27                        DATA
42                        8                          8                          DATA
43                        0                          0                          DATA 

Ich denke das die Zeile 40 jeweils in 10er Schritten weiterspringt und die Zeilen 41-43 in Einzelschritten. Somit lässt sich mit diesen 40 Werten der gesamte Zähleranzeigebereich ausgeben.
Das könnte dann in vielen Jahren mal so aussehen:
99999,99

40                        144                      90                        DATA
41                        153                      99                        DATA
42                        153                      99                        DATA
43                        153                      99                        DATA 

Damit ist der Teil der Ausgabe auch entschlüsselt

Jetzt wäre natürlich interessant zu wissen was passiert wenn mehrere Geräte amBus hängen. Aber dafür müssen diese Teile erst mal kommen.... mal schauen wann das passiert

Den habe ich noch aus den letzten Tagen gefunden- Zählerstand... wer glaubst....war 75,56

40                        96                        60                        DATA
41                        85                        55                        DATA
42                        7                          7                          DATA
43                        0                          0                          DATA 

[rikus]

da ist keine Adapter von UART auf MBus gibt habe ich immer Bucht einen USB-Adapter gekauft und hinter dem parallel/seriell-Chip die Leiterbahnen geöffnet und die PIN auf einen Stecker gebracht.

Ich würde dies auch gern so wie du umsetzen! Könntest Du bitte genau zeigen, welche Leiterbahnen zu öffnen sind und wo ich RX, TX und GND abgreifen muss? Auf dem Bild von Dir erkenn ich leider nichts genau...

Lieben Dank Sven

[Carstene]

Moin Sven,

musste was suchen.... aber das ist das Teil was ich gekauft habe

https://www.ebay.de/itm/Industrial-G...YAAOSweptciNJN

in der Vergrösserung der Anzeige siehst du 3 Leiterbahnen "nach Links" Richtung Hühnerfutter-SMD gehen.

Auf dem Chip steht sein Name = suche nach Datenblatt

Ich glaube dieser Bursche sitzt da drauf:
https://docs.rs-online.com/f1f3/0900766b81451bdd.pdf

Seite 7 ( 3.1 28-LD SSOP Package) ist die Pinbelegung

Die untere Leiterbahn ist Masse und die anderen beiden demzufolge Rx/Tx (Schau also vorher in das Datenblatt)

Rx/Tx habe ich aufgetrennt .... hatte Sorge dass die dann ungenutze MBUS-Schnittstelle Störungen verursacht. Die nun entstandenen offenen Leiterbahnenden wurden alle per Kabel in diesen Stecker geführt.

Nun kann ich entweder die UART oder MBUS-Schnittstelle nutzen (durch die Nutzung der entsprechenden Pins im Stecker), oder ich brücke die Pins mit einem entsprechenden Stecker und nutze dann wieder die MBUS-Schnittstelle.

Das ist kein Hexenwerk. Nur musst schauen bei der Löterei. Das Ding ist etwa so gross wie eine Streichholzschachtel.

Dementsprechend wenig Platz zum Arbeiten hast du. daher sind die Kabel nicht alle direkt an der Trennstelle angelötet (chipseitig geht es natürlich nicht anders)

Halt mich auf dem Laufenden

Grüsse
Carsten

[Masifi]

rikus was hast du damit denn vor?

Ich habe vor längerem im Konnekting Projekt mal was mit M-Bus gemacht, aber die HW war etwas „nicht so dolle“
Möchte das nicht so stehen lassen und habe eine HW V2 ins Leben gerufen. Das wird jetzt ein KNX Gateway werden wo ein ModBus Master + M-Bus Master + 2x S0 Schnittstellen drauf sind.
ModBus war einfach, aber M-Bus ist da etwas aufwendiger. Falls du Lust hast hier etwas zusammen zu machen, dann darfst du dich gerne bei mir melden.
Das dürfen natürlich auch alle anderen bei Interesse.

[rikus]

Besten Dank für die Antworten!
Aktuell habe ich einen Gaszähler ganz ohne Schnittstelle, nicht mal Magnetimpulse. Diese Jahr wird meiner ausgetauscht wegen Ablauf der Eichfrist (16 Jahre isser nun drin). Termin habe ich noch keinen, Jahr ist ja noch lang... Der Anbieter sagte mir, er hätte dann M-Bus.

Ich frage meine ganzen Temperatursensoren über Funk 433MHz am Raspberry ab, die Thermostate ebenso über DECT an der Fritzbox und nun auch den Stromzähler über dessen Infrarotschnittstelle. Da habe ich mir was mit ESP8266 und Infrarottransistor gebaut. Demnächst würde es dann der Gaszähler sein, den ich da mit einbinden möchte.

Auf dem raspi wird alles schön in eine Datenbank geschrieben und ich kann mir die Verläufe über eine Webseite via highcharts ansehen. Also reine Anzeige, keine Steuerung.

Schönen Abend noch!

[Carstene]

Lass dir bei der Lieferung die Schnittstelle direkt mitliefern !

Die ist nciht standardmässig dabei

[rikus]

Lass dir bei der Lieferung die Schnittstelle direkt mitliefern !

Die ist nciht standardmässig dabei

Ohje, danke für den Hinweis! Sie sprachen von Kästchen an die Wand und dafür ca. 170€ pro Jahr Gebühren. Wollen die echt nur für die Schnittstelle so viel und das jährlich?
Ein Kumpel von mir hat sich einen 2. Zähler einbauen lassen, den er auslesen kann. So muss der nicht wegen Eichtermin gewechselt werden und ihm ist die genaue Eichung egal...

[Carstene]

Ich hatte mit dem Schreiben des Einbaus bei denen angerufen und um die Beilegung der Schnittstelle gebeten.
das ist ein teil was man da aufclipst und mit ner Schraube fixiert.

Habe die kabelgebundene Variante. Die kostet bisher nichts extra