Ankündigung

Einklappen
Keine Ankündigung bisher.

Mbus Daten auswerten

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    Mbus Daten auswerten

    Hallo,

    ich würde gerne WMZ, die ich über eine IR Kopf auslesen kann mit Smarthome.py auslesen und die Daten auswerten. Sie kommunizieren über Mbus, ich habe im Netz ein Skript gefunden, dass die Zählerdaten abrufen kann:

    Code:
    har *buf;
    char in[256] = "";
    ssize_t ret_out;
    
    .... Init serielle Schnittstelle
    int fd = open ("/dev/ttyUSB0", O_RDWR | O_NOCTTY );
    set_interface_attribs (fd, B2400, 0);  // set speed to 2,400 bps, 8n1 
    (no parity)
    set_blocking (fd, 0 );                // set no blocking
    strcpy( in, 
    "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU 
    UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU"  );
    ret_out = write (fd, in, strlen(in));           // sent wakeup
    usleep ((1000 + 25) * 100);             // sleep enough to transmit plus
    buf = read_data( fd);
    // Initialisiere MBus -> ACK mit 'E5'
    in[0] = 0x10;
    in[1] = 0x40; // Init MBus
    in[2] = 0x00;
    in[3] = 0x40; // Checksumme = in[1] + in [2]
    in[4] = 0x16;
    ret_out = write (fd, in, 5);           // sent
    usleep ((1000 + 25) * 100);             // sleep enough to transmit plus
    buf = read_data( fd);
    if( buf[5] == 0xE5 ) {
    // Get Data from MBus
    in[0] = 0x10;
    in[1] = 0x5B;  // GetData
    in[2] = 0x00;
    in[3] = 0x5B;   // Checksumme = in[1] + in [2]
    in[4] = 0x16;
    ret_out = write (fd, in, 5);
    usleep ((1000 + 25) * 100);             // sleep enough to transmit plus
    buf = read_data( fd);
    // Zaehlerstand
    double waerme = ((double) toInt(&buf[26])) + (100.0 * (double) 
    toInt(&buf[27])) + (1000.0 * (double) toInt(&buf[28])) + (10000.0 * 
    (double) toInt(&buf[29]));
    //aktuelle Leistung
    double leistung = ((double) toInt(&buf[44])) + (100.0 * (double) 
    toInt(&buf[45])) + (1000.0 * (double) toInt(&buf[46])) + (10000.0 * 
    (double) toInt(&buf[47]));
    }
    
    int toInt( char *in ) {
    
    char out[2];
    int iOut = 0;
    sprintf( out, "%02x", in[0] );
    
    iOut = atoi( out );
    
    return iOut;
    Gibt es hier schon irgendwelche Ansätze?

    #2
    Hallo,
    ich stand vor dem selben Problem. Ich hab mir dann ein PlugIn geschrieben... Mein Erstes :-) Läuft aber einigermaßen stabil!
    Kann ich dir gerne zur Verfügung stellen, falls das Thema für dich noch aktuell ist.

    Grüße,
    Hannes

    Kommentar


      #3
      Hi Hannes!

      ja, ist noch aktuell - ich habe mich schon etwas angelesen, wäre aber vor Sommer sicherlich nicht dazu gekommen, also gerne her damit!

      Gruß Marco

      Kommentar


        #4
        Hallo,
        freut mich, dass ich auch mal jemanden weiterhelfen kann, hoffentlich. :-)
        also ich verwende den IR-USB-Lesekopf von volkszähler.org zum Auslesen meines SENUS PolluCom E Wärmemengenzählers.
        Vorab habe ich dem WMZ mittels MiniCom Software die Adresse "1" gegeben und mal die Verbindung unter Windows getestet und die Daten mitgelesen. Das war sehr hilfreich um die richtigen Bytes aus dem Datenstream zu finden.

        Soviel dazu, hier der Code:
        Plugin.conf
        Code:
        MBus:
            class_name: MBus
            class_path: plugins.MBus
            serialport: '/dev/ttyUSB0'
            update_cycle: 60
        Items:
        Code:
        WMZ:
        
            Energie:
                type: num
                visu_acl: rw
                knx_dpt: 9
                database: yes
        
            Volumen:
                type: num
                visu_acl: rw
                knx_dpt: 9
                database: yes
        
            Leistung:
                type: num
                visu_acl: rw
                knx_dpt: 9
                database: yes
        
            Durchfluss:
                type: num
                visu_acl: rw
                knx_dpt: 9
                database: yes
        
            Vorlauftemperatur:
                type: num
                visu_acl: rw
                knx_dpt: 9
                database: yes
        
            Ruecklauftemperatur:
                type: num
                visu_acl: rw
                knx_dpt: 9
                database: yes
        
            Differenz:
                type: num
                visu_acl: rw
                knx_dpt: 9
                database: yes
        __init__.py
        Code:
        #!/usr/bin/env python3
        # vim: set encoding=utf-8 tabstop=4 softtabstop=4 shiftwidth=4 expandtab
        #########################################################################
        # Copyright 2013 KNX-User-Forum e.V.            https://knx-user-forum.de/
        #########################################################################
        #  This file is part of SmartHome.py.    http://mknx.github.io/smarthome/
        #
        #  SmartHome.py is free software: you can redistribute it and/or modify
        #  it under the terms of the GNU General Public License as published by
        #  the Free Software Foundation, either version 3 of the License, or
        #  (at your option) any later version.
        #
        #  SmartHome.py is distributed in the hope that it will be useful,
        #  but WITHOUT ANY WARRANTY; without even the implied warranty of
        #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        #  GNU General Public License for more details.
        #
        #  You should have received a copy of the GNU General Public License
        #  along with SmartHome.py. If not, see <http://www.gnu.org/licenses/>.
        #########################################################################
        
        import logging
        import serial
        import time
        import array
        import binascii
        
        logger= logging.getLogger('MBus_Logger')
        
        
        class MBus():
        
            def __init__(self, smarthome,serialport="/dev/ttyUSB0", update_cycle="600"):
                self._sh = smarthome
                self._serialport=serialport
                self._update_cycle=int(update_cycle)
            def run(self):
                self.alive = True
                self._sh.scheduler.add('Update_WMZ', self.Update_WMZ, cycle=self._update_cycle)
        
            def stop(self):
                self.alive = False
                self._sh.scheduler.remove('Update_WMZ')
                
            def Update_WMZ(self):
                try:
                    self._port = serial.Serial(port=self._serialport, baudrate=2400, timeout=2, bytesize=serial.EIGHTBITS, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE)
                except:
                    logger.error("Could not connect!")
                    return
                
                try:
                    #wake up sequence
                    self._port.write(bytes([0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55]))
                    time.sleep(2)
                    #Init
                    self._port.write(bytes([0x10,0x40,0x01,0x41,0x16]))
                    #time.sleep(1)
                    self._port.flushInput()
                    #Check if ACK=E5
                    Signal = self._port.read(size=10)
                    logger.debug("WMZ-ACK:  " + str(Signal))
                    if str(Signal) ==   "b'\\xe5'":
                        logger.debug("Sending request")
                        #Send Request
                        self._port.write(bytes([0x10,0x5B,0x01,0x5C,0x16]))
                        time.sleep(2)
                        line = self._port.read(size=100)
                        #Energie (KW)
                        Energie=int(str(hex(line[21])).replace("0x","")) + int(str(hex(line[22])).replace("0x","")) * 100 + int(str(hex(line[23])).replace("0x","")) *10000 + int(str(hex(line[24])).replace("0x","")) *1000000  
                        self._sh.return_item("WMZ.Energie")(Energie, "MBus")
                        #Volumen (m3)
                        Volumen=int(str(hex(line[27])).replace("0x","")) + int(str(hex(line[28])).replace("0x","")) * 100 + int(str(hex(line[29])).replace("0x","")) *10000 + int(str(hex(line[30])).replace("0x","")) *1000000  
                        self._sh.return_item("WMZ.Volumen")(Volumen, "MBus")
                        #Leistung (W)
                        Leistung=int(str(hex(line[39])).replace("0x","")) + int(str(hex(line[40])).replace("0x","")) * 100 + int(str(hex(line[41])).replace("0x","")) *10000 + int(str(hex(line[42])).replace("0x","")) *1000000  
                        self._sh.return_item("WMZ.Leistung")(Leistung, "MBus")
                        #Durchfluss (m3/h)
                       Durchfluss=(int(str(hex(line[33])).replace("0x","")) + int(str(hex(line[34])).replace("0x","")) * 100 + int(str(hex(line[35])).replace("0x",""))* 10000 + int(str(hex(line[36])).replace("0x",""))* 1000000)/1000
                        self._sh.return_item("WMZ.Durchfluss")(Durchfluss, "MBus")
                        #Umwaelzpumpe (bool)
                        #ToDO
                        #Vorlauftemperatur
                        Vorlauftemperatur=int.from_bytes([line[45],line[46]], byteorder='little')/10
                        self._sh.return_item("WMZ.Vorlauftemperatur")(Vorlauftemperatur, "MBus")
                        #Ruecklauftemperatur
                        Ruecklauftemperatur=int.from_bytes([line[49],line[50]], byteorder='little')/10
                        self._sh.return_item("WMZ.Ruecklauftemperatur")(Ruecklauftemperatur, "MBus")
                        #Differenz
                        Differenz=int.from_bytes([line[53],line[54],line[55]], byteorder='little')/1000
                        self._sh.return_item("WMZ.Differenz")(Differenz, "MBus")    
                except:
                    logger.error("No response!")
                    return
        Wichtig ist noch, dass die rote Taste vor dem ersten Ausführen mal gedrückt werden muss, da der WMZ sonst nicht reagiert, vorausgesetzt du verwendest auch einen SENSUS WMZ.

        Wie gesagt, das ist mein erstes PlugIn, ich bin also für Verbesserungsvorschläge sehr dankbar.
        Vielleicht kannst du mal testen und mir eine Rückmeldung geben. Ich muss aber dazu sagen, dass der WMZ hin und wieder nicht antwortet. Konnte bisher die Ursache dafür nicht finden. Wenn länger keine Antwort kommt, muss man den WMZ per Tastendruck am Gerät wieder "aktivieren".

        Freue mich auf deine Antworten,

        Grüße,
        Hannes
        Angehängte Dateien
        Zuletzt geändert von bmx; 15.10.2022, 09:50. Grund: Umstellung auf yaml und [CODE]

        Kommentar


          #5
          Hi Hannes,

          vielen Dank - habe es ans Laufen zu bekommen. Das Forum verschluckt leider alle Einrückungen, wenn man es nicht als PHP Code einfügt. Ich habe es (anscheinend korrekt) selbst repariert:

          Code:
          #!/usr/bin/env python3
          # vim: set encoding=utf-8 tabstop=4 softtabstop=4 shiftwidth=4 expandtab
          ################################################## #######################
          # Copyright 2013 KNX-User-Forum e.V. https://knx-user-forum.de/
          ################################################## #######################
          # This file is part of SmartHome.py. http://mknx.github.io/smarthome/
          #
          # SmartHome.py is free software: you can redistribute it and/or modify
          # it under the terms of the GNU General Public License as published by
          # the Free Software Foundation, either version 3 of the License, or
          # (at your option) any later version.
          #
          # SmartHome.py is distributed in the hope that it will be useful,
          # but WITHOUT ANY WARRANTY; without even the implied warranty of
          # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
          # GNU General Public License for more details.
          #
          # You should have received a copy of the GNU General Public License
          # along with SmartHome.py. If not, see <http://www.gnu.org/licenses/>.
          ################################################## #######################
          
          import logging
          import serial
          import time
          import array
          import binascii
          
          logger= logging.getLogger('MBus_Logger')
          
          class MBus():
              def __init__(self, smarthome):
                  self._sh = smarthome
              
              def run(self):
                  self.alive = True
                  self._sh.scheduler.add('Update_WMZ', self.Update_WMZ, cycle=300)
          
              def stop(self):
                  self.alive = False
                  self._sh.scheduler.remove('Update_WMZ')
          
              def Update_WMZ(self):
                  try:
                      logger.debug("Connecting")
                      self._port = serial.Serial(port="/dev/ttyUSB0", baudrate=2400, timeout=2, bytesize=serial.EIGHTBITS, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE)
                  except:
                      logger.error("Could not connect!")
                      return
          
                  try:
                      #wake up sequence
                      logger.debug("sent wakeup")
                      self._port.write(bytes([0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55]))
                      time.sleep(2)
                      #Init
                      self._port.write(bytes([0x10,0x40,0x01,0x41,0x16]))
                      #time.sleep(1)
                      self._port.flushInput()
                      #Check if ACK=E5
                      Signal = self._port.read(size=10)
                      logger.debug("WMZ-ACK: " + str(Signal))
                      if str(Signal) == "b'\\xe5'":
                          logger.debug("Sending request")
                          #Send Request
                          self._port.write(bytes([0x10,0x5B,0x01,0x5C,0x16]))
                          time.sleep(2)
                          line = self._port.read(size=100)
                          #Energie (KW)
                          Energie=int(str(hex(line[24])+hex(line[23])+hex(line[22])+hex(line[21])).replace("0x",""))
                          self._sh.return_item("WMZ.Energie")(Energie, "MBus")
                          #Volumen (m3)
                          Volumen=int(str(hex(line[30])+hex(line[29])+hex(line[28])+hex(line[27])).replace("0x",""))
                          self._sh.return_item("WMZ.Volumen")(Volumen, "MBus")
                          #Leistung (W)
                          Leistung=int(str(hex(line[36])+hex(line[35])+hex(line[34])+hex(line[33])).replace("0x",""))
                          self._sh.return_item("WMZ.Leistung")(Leistung, "MBus")
                          #Durchfluss (m3/h)
                          Durchfluss=int(str(hex(line[42])+hex(line[41])+hex(line[40])+hex(line[39])).replace("0x",""))/1000
                          self._sh.return_item("WMZ.Durchfluss")(Durchfluss, "MBus")
                          #Vorlauftemperatur
                          Vorlauftemperatur=int.from_bytes([line[45],line[46]], byteorder='little')/10
                          self._sh.return_item("WMZ.Vorlauftemperatur")(Vorlauftemperatur, "MBus")
                          #Ruecklauftemperatur
                          Ruecklauftemperatur=int.from_bytes([line[49],line[50]], byteorder='little')/10
                          self._sh.return_item("WMZ.Ruecklauftemperatur")(Ruecklauftemperatur, "MBus")
                          #Differenz
                          Differenz=int.from_bytes([line[53],line[54],line[55]], byteorder='little')/1000
                          self._sh.return_item("WMZ.Differenz")(Differenz, "MBus")
                  except:
                      logger.error("No response!")
                  return
          Angehängte Dateien
          Zuletzt geändert von bmx; 15.10.2022, 09:47.

          Kommentar


            #6
            Hallo,
            sorry.
            Hast du die Daten vom WMZ bekommen?

            Grüße,
            Hannes
            Angehängte Dateien
            Zuletzt geändert von hannes123; 01.05.2015, 17:41.

            Kommentar


              #7
              Hallo Hannes!

              ja - habe es jetzt mit zwei Zählern laufen und es läuft seit heute Mittag ohne irgendwelche Probleme. Wenn ich es richtig sehe, dann mittelt der Zähler die Werte über die letzten 15 Minuten? Sonst wäre die Leistungsabfrage zu einem Zeitpunkt alle 10 Minuten ja sehr ungenau.

              Kommentar


                #8
                Hallo,
                ja lt. Kurzanleitung werden die Werte für Leistung und Durchfluss über 15min gemittelt. Der Mittelungsintervall kann jedoch eingestellt werden:
                https://www.netrion.de/netze/web/med...PolluCom_E.pdf

                Bei mir ist die Leistung eigentlich immer annähernd gleich, also zw. 240 - 250 W?

                Ich habe die zehn Minuten als Zykluszeit genommen, da ich nicht sicher bin ob das permanente Auslesen ev. die Lebensdauer der Batterie also des Wärmemengenzählers verkürzt.
                Habe auch schon mal überlegt, das Auslesen in der Nacht bzw. je nach Wetterlage zu deaktivieren. Geht aber leider nicht, da die Datenschnittstelle durch einen Tastendruck für eine Stunde aktiviert wird. Erfolgt in dieser Zeit eine Ablesung, wird die Datenschnittstelle für eine weitere Stunde aktiviert, usw..
                Antwortet dein WMZ auf jeden Request?

                Grüße,
                Hannes
                Zuletzt geändert von hannes123; 02.05.2015, 10:01.

                Kommentar


                  #9
                  Hallo Hannes!

                  bei mir schwankt die Leistung schon sehr realistisch (zwischen 0-500 Watt) auch Vorlauf, Rücklauf und Durchfluss erscheinen erstmal logisch. Ich hatte nun einmal das Problem dass einer der WMZ aus dem IR-Modus rausgegangen ist, mag aber auch daran liegen, dass ich noch dran rumbastel und den Pi ständig neu starte.
                  Man könnte die Ablesung in der Nacht ggf. auf 50 Minuten Intervalle ändern.

                  Kommentar


                    #10
                    Hallo Hannes,

                    ich habe noch eine Frage - da ich ja mehrere Zähler auslese, wäre es von Vorteil nicht alle Zähler mit der ID 1 zu setzen, damit man bei falsch aufgesetztem lesekopf nicht falsche Werte in die Datenbank schreibt. Ich wollte deshalb die anderen Zähler durchnummerieren, das Problem ist, dass der String anscheinend noch modifiziert werden muss:
                    Aus b'\xe5' wird anscheinen: b'\\xe5' -> nun wollte ich aus: b'\x10@\x01A\x16\x02Q\x0cy\x01' einfach b'\\x10@\x01A\x16\x02Q\x0cy\x01'

                    das scheint aber nicht zu gehen.

                    Kommentar


                      #11
                      Hallo,
                      ich nehme mal an der zweite hat die ID2, oder?
                      Also für Init müsste der Byte-String dann
                      Code:
                      ([0x10,0x40,0x02,0x42,0x16])
                      sein.
                      Für den Request wäre es
                      Code:
                      ([0x10,0x5B,0x01,0x5D,0x16])
                      .
                      Zur Info, das dritte Byte ist die Adresse in HEX, das vierte Byte ist die Checksumme. Diese errechnet sich wiederum aus dem Zweiten plus dem Dritten.

                      Frage: Wie hast du das mit dem zweiten Zähler eigentlich gelöst?

                      Grüße,
                      Hannes
                      Zuletzt geändert von bmx; 15.10.2022, 09:46. Grund: [CODE] statt [PHP]

                      Kommentar


                        #12
                        Hallo Hannes,

                        ich habe jetzt allen Zählern die ID 1 gegeben. Ich mache es über die verschiedenen USB Ports, nicht schön aber scheint so zu funktionieren:

                        Code:
                        #!/usr/bin/env python3
                        # vim: set encoding=utf-8 tabstop=4 softtabstop=4 shiftwidth=4 expandtab
                        ################################################## #######################
                        # Copyright 2013 KNX-User-Forum e.V. https://knx-user-forum.de/
                        ################################################## #######################
                        # This file is part of SmartHome.py. http://mknx.github.io/smarthome/
                        #
                        # SmartHome.py is free software: you can redistribute it and/or modify
                        # it under the terms of the GNU General Public License as published by
                        # the Free Software Foundation, either version 3 of the License, or
                        # (at your option) any later version.
                        #
                        # SmartHome.py is distributed in the hope that it will be useful,
                        # but WITHOUT ANY WARRANTY; without even the implied warranty of
                        # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
                        # GNU General Public License for more details.
                        #
                        # You should have received a copy of the GNU General Public License
                        # along with SmartHome.py. If not, see <http://www.gnu.org/licenses/>.
                        ################################################## #######################
                        
                        import logging
                        import serial
                        import time
                        import array
                        import binascii
                        
                        logger= logging.getLogger('MBus_Logger')
                        
                        class MBus():
                            def __init__(self, smarthome):
                                self._sh = smarthome
                            
                            def run(self):
                                self.alive = True
                                self._sh.scheduler.add('Update_WMZ', self.Update_WMZ, cycle=600)
                        
                            def stop(self):
                                self.alive = False
                                self._sh.scheduler.remove('Update_WMZ')
                        
                            def Update_WMZ(self):
                                try:
                                    logger.debug("Connecting USB 0")
                                    self._port = serial.Serial(port="/dev/ttyUSB0", baudrate=2400, timeout=2, bytesize=serial.EIGHTBITS, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE)
                                except:
                                    logger.error("Could not connect to USB 0!")
                                    return
                        
                                try:
                                    #wake up sequence
                                    logger.debug("sent wakeup")
                                    self._port.write(bytes([0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55]))
                                    time.sleep(2)
                                    #Init
                                    self._port.write(bytes([0x10,0x40,0x01,0x41,0x16]))
                                    #time.sleep(1)
                                    self._port.flushInput()
                                    #Check if ACK=E5
                                    Signal = self._port.read(size=10)
                                    logger.debug("WMZ-ACK: USB0 " + str(Signal))
                                    if str(Signal) == "b'\\xe5'":
                                        logger.debug("Sending request")
                                        #Send Request
                                        self._port.write(bytes([0x10,0x5B,0x01,0x5C,0x16]))
                                        time.sleep(2)
                                        line = self._port.read(size=100)
                                        #Energie (KW)
                                        Energie=int(str(hex(line[24])+hex(line[23])+hex(line[22])+hex(line[21])).replace("0x",""))
                                        self._sh.return_item("WMZ0.Energie")(Energie, "MBus")
                                        #Volumen (m3)
                                        Volumen=int(str(hex(line[30])+hex(line[29])+hex(line[28])+hex(line[27])).replace("0x",""))
                                        self._sh.return_item("WMZ0.Volumen")(Volumen, "MBus")
                                        #Leistung (W)
                                        Leistung=int(str(hex(line[36])+hex(line[35])+hex(line[34])+hex(line[33])).replace("0x",""))
                                        self._sh.return_item("WMZ0.Leistung")(Leistung, "MBus")
                                        #Durchfluss (m3/h)
                                        Durchfluss=int(str(hex(line[42])+hex(line[41])+hex(line[40])+hex(line[39])).replace("0x",""))/1000
                                        self._sh.return_item("WMZ0.Durchfluss")(Durchfluss, "MBus")
                                        #Vorlauftemperatur
                                        Vorlauftemperatur=int.from_bytes([line[45],line[46]], byteorder='little')/10
                                        self._sh.return_item("WMZ0.Vorlauftemperatur")(Vorlauftemperatur, "MBus")
                                        #Ruecklauftemperatur
                                        Ruecklauftemperatur=int.from_bytes([line[49],line[50]], byteorder='little')/10
                                        self._sh.return_item("WMZ0.Ruecklauftemperatur")(Ruecklauftemperatur, "MBus")
                                        #Differenz
                                        Differenz=int.from_bytes([line[53],line[54],line[55]], byteorder='little')/1000
                                        self._sh.return_item("WMZ0.Differenz")(Differenz, "MBus")
                                except:
                                    logger.error("No response! from USB0")
                                #wmz USB 1
                                try:
                                    logger.debug("Connecting USB 1")
                                    self._port = serial.Serial(port="/dev/ttyUSB1", baudrate=2400, timeout=2, bytesize=serial.EIGHTBITS, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE)
                                except:
                                    logger.error("Could not connect to USB 1!")
                                    return
                        
                                try:
                                    #wake up sequence
                                    time.sleep(15)
                                    logger.debug("sent wakeup")
                                    self._port.write(bytes([0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55]))
                                    time.sleep(2)
                                    #Init
                                    self._port.write(bytes([0x10,0x40,0x01,0x41,0x16]))
                                    #time.sleep(1)
                                    self._port.flushInput()
                                    #Check if ACK=E5
                                    Signal = self._port.read(size=10)
                                    logger.debug("WMZ-ACK USB1: " + str(Signal))
                                    if str(Signal) == "b'\\xe5'":
                                        logger.debug("Sending request")
                                        #Send Request
                                        self._port.write(bytes([0x10,0x5B,0x01,0x5C,0x16]))
                                        time.sleep(2)
                                        line = self._port.read(size=100)
                                        #Energie (KW)
                                        Energie=int(str(hex(line[24])+hex(line[23])+hex(line[22])+hex(line[21])).replace("0x",""))
                                        self._sh.return_item("WMZ1.Energie")(Energie, "MBus")
                                        #Volumen (m3)
                                        Volumen=int(str(hex(line[30])+hex(line[29])+hex(line[28])+hex(line[27])).replace("0x",""))
                                        self._sh.return_item("WMZ1.Volumen")(Volumen, "MBus")
                                        #Leistung (W)
                                        Leistung=int(str(hex(line[36])+hex(line[35])+hex(line[34])+hex(line[33])).replace("0x",""))
                                        self._sh.return_item("WMZ1.Leistung")(Leistung, "MBus")
                                        #Durchfluss (m3/h)
                                        Durchfluss=int(str(hex(line[42])+hex(line[41])+hex(line[40])+hex(line[39])).replace("0x",""))/1000
                                        self._sh.return_item("WMZ1.Durchfluss")(Durchfluss, "MBus")
                                        #Vorlauftemperatur
                                        Vorlauftemperatur=int.from_bytes([line[45],line[46]], byteorder='little')/10
                                        self._sh.return_item("WMZ1.Vorlauftemperatur")(Vorlauftemperatur, "MBus")
                                        #Ruecklauftemperatur
                                        Ruecklauftemperatur=int.from_bytes([line[49],line[50]], byteorder='little')/10
                                        self._sh.return_item("WMZ1.Ruecklauftemperatur")(Ruecklauftemperatur, "MBus")
                                        #Differenz
                                        Differenz=int.from_bytes([line[53],line[54],line[55]], byteorder='little')/1000
                                        self._sh.return_item("WMZ1.Differenz")(Differenz, "MBus")
                                except:
                                    logger.error("No response! from USB1")
                        
                            #wmz USB 2
                                try:
                                    logger.debug("Connecting USB 2")
                                    self._port = serial.Serial(port="/dev/ttyUSB2", baudrate=2400, timeout=2, bytesize=serial.EIGHTBITS, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE)
                                except:
                                    logger.error("Could not connect to USB 2!")
                                    return
                        
                                try:
                                    #wake up sequence
                                    time.sleep(30)
                                    logger.debug("sent wakeup")
                                    self._port.write(bytes([0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55, 0x55,0x55,0x55]))
                                    time.sleep(2)
                                    #Init
                                    self._port.write(bytes([0x10,0x40,0x01,0x41,0x16]))
                                    #time.sleep(1)
                                    self._port.flushInput()
                                    #Check if ACK=E5
                                    Signal = self._port.read(size=10)
                                    logger.debug("WMZ-ACK USB2: " + str(Signal))
                                    if str(Signal) == "b'\\xe5'":
                                        logger.debug("Sending request")
                                        #Send Request
                                        self._port.write(bytes([0x10,0x5B,0x01,0x5C,0x16]))
                                        time.sleep(2)
                                        line = self._port.read(size=100)
                                        #Energie (KW)
                                        Energie=int(str(hex(line[24])+hex(line[23])+hex(line[22])+hex(line[21])).replace("0x",""))
                                        self._sh.return_item("WMZ2.Energie")(Energie, "MBus")
                                        #Volumen (m3)
                                        Volumen=int(str(hex(line[30])+hex(line[29])+hex(line[28])+hex(line[27])).replace("0x",""))
                                        self._sh.return_item("WMZ2.Volumen")(Volumen, "MBus")
                                        #Leistung (W)
                                        Leistung=int(str(hex(line[36])+hex(line[35])+hex(line[34])+hex(line[33])).replace("0x",""))
                                        self._sh.return_item("WMZ2.Leistung")(Leistung, "MBus")
                                        #Durchfluss (m3/h)
                                        Durchfluss=int(str(hex(line[42])+hex(line[41])+hex(line[40])+hex(line[39])).replace("0x",""))/1000
                                        self._sh.return_item("WMZ2.Durchfluss")(Durchfluss, "MBus")
                                        #Vorlauftemperatur
                                        Vorlauftemperatur=int.from_bytes([line[45],line[46]], byteorder='little')/10
                                        self._sh.return_item("WMZ2.Vorlauftemperatur")(Vorlauftemperatur, "MBus")
                                        #Ruecklauftemperatur
                                        Ruecklauftemperatur=int.from_bytes([line[49],line[50]], byteorder='little')/10
                                        self._sh.return_item("WMZ2.Ruecklauftemperatur")(Ruecklauftemperatur, "MBus")
                                        #Differenz
                                        Differenz=int.from_bytes([line[53],line[54],line[55]], byteorder='little')/1000
                                        self._sh.return_item("WMZ2.Differenz")(Differenz, "MBus")
                                except:
                                    logger.error("No response! from USB2")
                                
                                return
                        Zuletzt geändert von bmx; 15.10.2022, 09:47.

                        Kommentar


                          #13
                          Eventuel gibt es eine Erklärung für Deine Leistungswerte. Ich habe bei einem Energiewert 9403 immer die Ausgabe 943 - er frisst also die 0 an der zweiten Stelle, das liegt meiner Meinung nach an dem replace("0x","") ich habe es mal testweise duch replace("0x","0") ersetzt - nun stimmt es zwar an dieser Stelle, dafür packt er mir an anderen Stellen noch fleißig Nullen hinzu.
                          Zuletzt geändert von Marcov; 08.05.2015, 08:19.

                          Kommentar


                            #14
                            Hallo,

                            ein int() wandelt das in ein Zahl um, und entfernt führende Nullen.

                            Bis bald

                            Marcus

                            Kommentar


                              #15
                              Hallo,
                              ist richtig. Hab gerade noch mal mit MiniCom den Zähler ausgelesen, da kommt was anderes raus. Das muss ich mir noch mal ansehen. Hoffentlich noch diese WE.
                              Werde dann auch noch versuchen, über die PlugIn.conf den USB-Port und die ID des Zählers zu übergeben. Sollte eigentlich nicht das Problem sein.

                              Grüße,
                              Hannes

                              Kommentar

                              Lädt...
                              X