Serielle Schnittstelle hängt sich nach einiger Zeit auf

[klabue]

Hallo,

über einen USB zu MBUS - umsetzer lese ich einen Stomzähler wie folgt aus:

Code: Alles auswählen

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import time, sys
import os
import serial
import mysql.connector as mariadb
imp = 0
Empfang = []
ser = serial.Serial('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 2400, 8, 'E', 1, 5.0)


try:
    vgl_Sek = 0
    vgl_Min = 0
    stop = 0
    while True :
        Sek = int(time.strftime('%S'))
        Min = int(time.strftime('%M'))
        Std = int(time.strftime('%M'))
        Tag = int(time.strftime('%d'))
        Mon = int(time.strftime('%m'))
        Jahr = int(time.strftime('%Y'))
        localtime = time.localtime(time.time())

        if Sek != 10 and Sek != 30 and Sek != 50 and imp ==1:
            imp = 0
            
        if ((Sek == 10 or Sek == 30 or Sek == 50) and imp == 0):                      
            imp = 1
            ser.write(bytearray([0x10, 0x7B, 0x01, 0x7C, 0x16]))
            Wirkarbeit = 0.0
            Akt_P_L1 = 0.0
            U_L1 = 0.0
            U_L2 = 0.0
            U_L3 = 0.0

            i = 0
            Empfang.clear()
            gelesen = 0
            while (i<253):#253
                Empfangsfach = ser.read()
                if Empfangsfach:
                    Empfang.append(format(ord(Empfangsfach)))
                    i = i+1
                    gelesen = 1
                #else:
                if gelesen == 0:
            print("Gelesen = " + str(gelesen))
            print("i = " + str(i))
            if gelesen == 1 and i >= 252:                
                ii = 0
                while (ii < (i - 9)):
                #Wirkarbeit einlesen
                    if Empfang[ii] == '132' and Empfang[ii+1] == '16' and Empfang[ii+2] == '131':#0x84, 0x10, 0x83
                        #print(Empfang[ii], Empfang[ii+1], Empfang[ii+2] )
                        Wirkarbeit = ((((((int(Empfang[ii+7]) * 256) + int(Empfang[ii+6])) * 256) +
                                    int(Empfang[ii+5])) * 256) + int(Empfang[ii+4]))/1000
                    #erg = int(Empfang[ii+6])*256
                        print(Wirkarbeit)
                #Altuelle Wirkleistung auslesen
                    if Empfang[ii] == '4' and Empfang[ii+1] == '171' and Empfang[ii+2] == '255' and Empfang[ii+3] == '129':#0x04, 0xAB, 0xFF, 0x81
                        #print(Empfang[ii], Empfang[ii+1], Empfang[ii+2] )
                        Akt_P_L1 = ((((((int(Empfang[ii+8]) * 256) + int(Empfang[ii+7])) * 256) +
                                int(Empfang[ii+6])) * 256) + int(Empfang[ii+5]))/1000
                    #erg = int(Empfang[ii+6])*256
                        print(Akt_P_L1)
    
                 #U_L1
                    if Empfang[ii] == '2' and Empfang[ii+1] == '253' and Empfang[ii+2] == '201' and Empfang[ii+3] == '255' and Empfang[ii+4] == '129':#0x02, 0xFD, 0xC9, 0xFF, 0x81
                        #print(Empfang[ii], Empfang[ii+1], Empfang[ii+2] )
                        U_L1 = (int(Empfang[ii+7]) * 256) + int(Empfang[ii+6])
                    #erg = int(Empfang[ii+6])*256
                        print(U_L1)
                 #U_L2
                    if Empfang[ii] == '2' and Empfang[ii+1] == '253' and Empfang[ii+2] == '201' and Empfang[ii+3] == '255' and Empfang[ii+4] == '130':#0x02, 0xFD, 0xC9, 0xFF, 0x82
                        #print(Empfang[ii], Empfang[ii+1], Empfang[ii+2] )
                        U_L2 = (int(Empfang[ii+7]) * 256) + int(Empfang[ii+6])
                    #erg = int(Empfang[ii+6])*256
                        print(U_L2)
                 #U_L3
                    if Empfang[ii] == '2' and Empfang[ii+1] == '253' and Empfang[ii+2] == '201' and Empfang[ii+3] == '255' and Empfang[ii+4] == '131':#0x02, 0xFD, 0xC9, 0xFF, 0x83
                        #print(Empfang[ii], Empfang[ii+1], Empfang[ii+2] )
                        U_L3 = (int(Empfang[ii+7]) * 256) + int(Empfang[ii+6])
                    #erg = int(Empfang[ii+6])*256
                        print(U_L3)
                        break
                    ii = ii+1
                #print(erg)

            #a = hex(ord(Empfang[44]))

            #ser.close() 
        if Sek == 0 and vgl_Min != Min and i >= 252:                
            add_zaehler(localtime, Wirkarbeit)
            vgl_Min = Min
        
        
        
        
except KeyboardInterrupt:
    # Programm wird beendet wenn CTRL+C gedrückt wird.
    print('Temperaturmessung wird beendet')
except Exception as e:
    print(str(e))
    sys.exit(1)
finally:
    # Das Programm wird hier beendet, sodass kein Fehler in die Console geschrieben wird.
    print('Programm wird beendet.')
    print("i = " + str(i) + " ii = " + str(ii))
    print(localtime)
    sys.exit(0)

Das Programm funktioniert soweit. Nach einiger Zeit (mehrere Stunden) jedoch werden keine Werte mehr vom Zähler eingelesen.

Anhand des Flackerns der LED auf dem MBUS - Umsetzer sieht man, dass das Sendetelegramm abgeschickt wird und der Zähler auch antwortet. Die Variable "Empfangsfach" ist jedoch leer.

Auch ein Neustart des Programms hilft nichts, erst, wenn der Umsetzer einmal vom UDB getrennt wurde, läuft die Kommunikation wieder.

Hat jemand eine Idee, woran das liegt?

[__deets__]

Was ist UDB? Meinst du USB?

Der Code ist zwar fürchterlich, aber das sollte keinen Einfluss auf die Zuverlässigkeit der seriellen Kommunikation haben. Wenn es da Probleme gibt, liegen die auf Hardware oder OS Ebene. Dazu kannst du mal einen Blick in die log files werfen. Ich bekomme zb gelegentlich Meldungen wie hier beschrieben: https://superuser.com/questions/1254898 ... due-to-emi

Du kannst probieren, andere Kabel zu nehmen (die Qualität von USB Kabeln schwankt überraschend stark), und letztlich alles andere durch tauschen, Computer (ich nehme mal an einen Pi?) inklusive.

Workarounds könnten das disablen und wieder re-enablen des USB Host Treibers sein, damit der Bus quasi resettet wird. Oder auch ein device reset, wie zb hier https://askubuntu.com/questions/645/how ... mmand-line Beschrieben.

Zu guter letzt hat der Pi (wenn’s denn einer ist) einen eingebauten UART, der mit einem entsprechenden wandler genauso funktioniert. Und robuster ist.

[__blackjack__]

@klabue: Das hat einen Syntaxfehler weil da an einer Stelle ein ``if gelesen == 0:`` steht, das da sicher so nicht hingehört‽

Wenn `Empfangsfach` eine leere Bytekette ist, dann gab es eine Zeitüberschreitung. Da der Code das aber einfach ignoriert und gar nichts spezielles macht, sondern einfach im nächsten Schleifendurchlauf wieder `read()` aufruft, könnte man sich einfach das Argument für Timeouts sparen und auch den Test ob `Empfangsfach` etwas enthält.

Die Zeilen nach dem Muster ``Sek = int(time.strftime("%S"))`` sind falsch. Wenn man die Bestandteile von *einem* Zeitpunkt haben will, darf man diesen Zeitpunkt nur einmal ermitteln, statt für jeden Bestandteil erneut, weil wärend diese Zeilen ausgeführt werden ja Zeit vergeht, und sich damit jeder Bestandteil auf einen leicht unterschiedlichen Zeitpunkt bezieht, und dadurch am Ende einzelne Werte deutlich abweichen können. Wenn die Sekunde Beispielsweise um 1:00:59 ermittelt wurde, also 59 ist, und die Minute dann aber schon über die Sekundengrenze gesprungen ist bevor die Minute um 1:01:00 ermittelt wird, dann weichen die bestandteile fast eine ganze Minute von der tatsächlichen Uhrzeit ab. Und das setzt sich bei den grösseren Bestandteilen fort. Die Wahrscheinlichkeit sinkt zwar, dafür steigt aber die Zeitabweichung deutlich wenn es dann doch passiert.

Es wird ja auch `localtime` betimmt, was all diese Zeitpunktteile beinhaltet und das für ein und den selben Zeitpunkt. Zudem ist das nicht so unsinnig umständlich als erst eine Zeichenkette mit der ganzen Zahl zu erstellen, nur um die dann wieder in eine ganze Zahl zu wandeln.

Allerdings sind diese Funktionen aus `time` veraltet seit dem es das `datetime`-Modul gibt, was man hier verwenden würde um den Zeitpunkt zu ermitteln.

Sonstige Anmerkungen: `os` und `mysql.connector` werden importiert, aber nirgends verwendet.

Es werden einige Namen definiert die nirgends verwendet werden. `vgl_Sek`, `stop`, `Tag`, `Mon`, `Jahr` beispielsweise.

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (PascalCase).

Namen sollten keine kryptischen Abkürzungen enthalten, oder gar nur daraus bestehen.

Serielle Verbindungen die man öffnet, sollte man auch wieder schliessen. Die ``with``-Anweisung bietet sich hier an.

`imp` nimmt nur die Werte 0 und 1 an. Falls das tatsächlich ein Flag ist, sollte man keine Zahlen für `True` und `False` verwenden. Das gilt auch für `gelesen`, wobei das Flag offensichtlich unsinnig ist, da das nach der ``while``-Schleife garantiert `True` ist, ein prüfen also keinen Sinn macht.

Auch der Test auf ``i >= 252`` macht keinen Sinn nach der ``while``-Schleife. Das ist auch immer wahr an der Stelle.

Wenn man eine leere Liste braucht, legt man eine neue leere Liste an, statt eine Liste immer wiederzuverwenden und zu leeren. Einfach eine neue Liste zu verwenden ist sicherer und auch klarer, weil der Leser dann weiss, das dass keine Auswirkungen irgendwo anders haben kann, wo es vielleicht noch eine Referenz auf die Liste gibt. Dann muss `Empfang` auch nicht so verdammt weit von dem Ort der tatsächlichen Verwendung definiert werden, und der Code-Abschnitt liesse sich auch leichter in eine Funktion heraus ziehen.

Viele Bedingungen bei ``while`` und ``if`` haben unnötige Klammern um den gesamten Ausdruck der Bedigung.

Statt Teilausdrücke mit vergleichen gegen immer den gleichen Wert zu verwenden, kann man das kürzer mit ``in`` oder ``not in`` und einer Liste der Vergleichswerte lösen.

`Wirkarbeit` & Co werden vor dem Lesen der Daten definiert, aber erst danach tatsächlich benötigt.

`empfangsfach` ist ein komischer Name für eine Bytekette.

Es ist unsinnig Bytewerte in Zeichenketten mit der Dezimaldarstellung umzuwandeln und mit Zeichenketten von Dezimaldarstellungen zu vergleichen und dann die Darstellungen wieder in ganze Zahlen umzuwandeln um damit zu rechnen. Dieser Umweg über Zeichenkettendarstellungen ist unnötig, verwirrend, und kompliziert.

Wenn man mit Zahlen arbeiten würde, könnte man beispielsweise auch gleich die Hexadezimaldarstellung für den Vergleich nehmen, und müsste das nicht als Kommentar dazu schreiben.

Letztlich kann man, wenn man sich den `timeout` bei der Verbindung spart, auch einfach 254 Bytes lesen lassen und gut ist.

Die ``while``-Schleife mit `ii` ist auch sehr umständlich und hat eine Abbruchbedingung die problematisch ist, denn was passiert wenn die letzte Bytefolge nicht gefunden wird? Oder gefunden wird bevor alle anderen gefunden wurden?

`bytes`-Objekte haben eine `index()`-Methode um eine Bytesequenz zu finden.

Der Code für die einzelnen Werte unterscheidet sich nur geringfügig, das kann/sollte man in eine Funktion heraus ziehen.

Die Ausnahmebehandlung sollte sich den `Exception`-Fall sparen in dem Informationen aus dem Traceback unterdrückt werden. Und das ``finally`` macht nicht wirklich Sinn, der Code darin kann einfach am Programmende stehen.

Zwischenstand (ungetestet):

Code: Alles auswählen

#!/usr/bin/env python3
from datetime import datetime as DateTime

from serial import Serial, PARITY_EVEN


def search_value(data, prefix, length):
    """Search `data` for given `prefix` and extract `length` bytes as little
    endian integer value.

    If `prefix` can't be be found or there are not engougth data bytes
    following, the value 0 is returned.

    The function ignores one byte between the prefix and the bytes of the value.
    """
    result = 0
    try:
        index = data.index(prefix) + len(prefix) + 1
    except IndexError:
        pass
    else:
        value_bytes = data[index : index + length]
        if len(value_bytes) == length:
            result = int.from_bytes(value_bytes, "little")

    return result


def main():
    now = None
    try:
        with Serial(
            "/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0",
            2400,
            parity=PARITY_EVEN,
        ) as connection:
            imp = False  # TODO Needs a better name.
            vgl_minute = 0
            wirkarbeit = aktuelle_wirkleistung = 0
            spannungen = []
            while True:
                now = DateTime.now()

                if now.second not in [10, 30, 50] and imp:
                    imp = False

                if now.second in [10, 30, 50] and not imp:
                    imp = True
                    connection.write(b"\x10\x7B\x01\x7C\x16")
                    empfang = connection.read(254)

                    wirkarbeit = (
                        search_value(empfang, b"\x84\x10\x83", 4) / 1000
                    )
                    aktuelle_wirkleistung = (
                        search_value(empfang, b"\x04\xAB\xFF\x81", 4) / 1000
                    )
                    spannungen = [
                        search_value(
                            empfang, b"\x02\xFD\xC9\xFF%c" % (0x81 + i), 2
                        )
                        for i in range(3)
                    ]

                    print(wirkarbeit)
                    print(aktuelle_wirkleistung)
                    print(spannungen)

                if now.second == 0 and vgl_minute != now.minute:
                    add_zaehler(now, wirkarbeit)
                    vgl_minute = now.minute

    except KeyboardInterrupt:
        # Programm wird beendet wenn CTRL+C gedrückt wird.
        print("Temperaturmessung wird beendet")

    print("Programm wird beendet.")
    print(now)


if __name__ == "__main__":
    main()

[klabue]

@__blackjack__

Dass das Finden der Werte (wirkarbeit, aktuelle Wirkleistung und Spannungen) so einfach ist, hätte ich nicht gedacht. Dass man den String auch als Ganzes einlesen kann, wusste ich. Ich bin allerdings darauf gestoßen, dass die ASCII - Zeichen direkt umgewandelt werden (z.B. 2C als ",").
Mal sehen, ob das Script jetzt durchläuft, ohne sich aufzuhängen

ps:

Die Syntax - Fehler waren deshalb, da ich nicht den kompletten Code angefügt habe.
Außerdem wird die Wirkarbeit in die Datenbank geschrieben.

[__blackjack__]

@klabue: Da wird nichts umgewandelt. Wenn man ein `bytes`-Objekt in eine Zeichenkette umwandelt, werden druckbare ASCII-Zeichen als solche dargestellt. b"\x2c" und b"," sind genau der gleiche Wert. Das ist ein Byte mit dem Wert 44 (dezimal):

Code: Alles auswählen

In [175]: b","[0]                                                               
Out[175]: 44

In [176]: b"\x2C"[0]                                                            
Out[176]: 44

In [177]: b"," == b"\x2C"                                                       
Out[177]: True

In [178]: len(b",")                                                             
Out[178]: 1

In [179]: len(b"\x2C")                                                          
Out[179]: 1

[Sirius3]

@__blackjack__: warum verwendest Du nicht "partition"?

@klabue: wie ist das genaue Format der Frames, denn nach irgendwelchen Bytes zu suchen, halte ich nicht für sehr stabil.

Statt in einer busy-Loop ständig die Uhrzeit abzufragen, würde ich mit sleep arbeiten:

Code: Alles auswählen

#!/usr/bin/env python3
import time
from serial import Serial, PARITY_EVEN

def search_value(data, prefix, length):
    """Search `data` for given `prefix` and extract `length` bytes as little
    endian integer value.

    If `prefix` can't be be found or there are not engougth data bytes
    following, the value 0 is returned.

    The function ignores one byte between the prefix and the bytes of the value.
    """
    value_bytes = data.partition(prefix)[:length]
    if len(value_bytes) == length:
        result = int.from_bytes(value_bytes, "little")
    else:
        result = 0
    return result


def read_data():
    connection.write(b"\x10\x7B\x01\x7C\x16")
    empfang = connection.read(254)

    wirkarbeit = search_value(empfang, b"\x84\x10\x83", 4) / 1000
    aktuelle_wirkleistung = search_value(empfang, b"\x04\xAB\xFF\x81", 4) / 1000
    spannungen = [
        search_value(empfang, b"\x02\xFD\xC9\xFF%c" % (0x81 + i), 2)
        for i in range(3)
    ]
    return wirkarbeit, aktuelle_wirkleistung, spannungen


def main():
    try:
        with Serial(
            "/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0",
            2400,
            parity=PARITY_EVEN,
        ) as connection:
            wirkarbeit = aktuelle_wirkleistung = 0
            spannungen = []
            while True:
                now = time.time()
                time.sleep(-(now % -10))
                now = time.time()
                seconds = round(now) % 60
                if seconds in [10, 30, 50]:
                    wirkarbeit, aktuelle_wirkleistung, spannungen = read_data()
                elif seconds == 0:
                    add_zaehler(wirkarbeit)

    except KeyboardInterrupt:
        # Programm wird beendet wenn CTRL+C gedrückt wird.
        pass
    print("Temperaturmessung wird beendet")


if __name__ == "__main__":
    main()

[__blackjack__]

@Sirius3: Ich sehe nicht wie `partition()` da helfen soll. Es fehlt da bei Dir noch ein magischer Zugriff auf den Index 2, weil man ja das dritte Element haben woll, die ersten beiden werden erstellt, aber dann weggeworfen. Also ``value_bytes = data.partition(prefix)[2][1 : length + 1]`` müsste es ja dann heissen. Das verschleiert IMHO eher das was da gemacht werden soll als den Index zu suchen an dem der Präfix beginnt.

[klabue]

Leider hängt sich die Schnittstelle immer noch auf. Mal sehen, ob in der Logdatei was steht. Sonst muss ich sehen, ob ich den USB-Prort in Python aus und wieder einschalten kann.

[klabue]

@_deets_:
Das es an dem USB Kabel liegt ist unwahrscheinlich, das Sendetelegramm geht ja raus und der Zähler antwortet

[__deets__]

Das ist aus deiner Beschreibung nicht klar genug, was da genau wie verbunden ist. Klar ist aber, dass nichts in deinem Code dieses Verhalten erklaert, egal wie gut oder schlecht der ist.

[derElch]

@klabue:
Welche Kabellänge ist zwischen Serialadapter und USB Port am PC? Ist vielleicht sogar noch eine Verlängerung dazwischen? Ich hatte teilweise unerklärliches Verhalten vor einigen Jahren mit Verlängerungen. Die USB Spec ist bei 5m aus. Vielleicht mit einer aktiven Verlängerung schon probiert, wenn überhaupt eine angesteckt ist?

Ist eines davon USB2 und ein anderes USB3? Hier hatte ich auch schon Probleme. War damals eine NI Datenkarte (USB2) auf einen neuen Rechner mit USB3.

[klabue]

Hallo,
in journalctl steht folgender Eintrag:

raspberrypi kernel: ch341-uart ttyUSB0: usb_serial_generic_read_bulk_callback - urb stopped: -32
Das USB-Kabel ist ca. 1m Lang

[__deets__]

Joa. Wie ich schon sagte. Ein Problem in USB Hard oder Software das nichts mit deiner Software zu tun hat. Ich würde auf den UART des Pi wechseln (den guten, mit ausgeschaltetem Bluetooth), um möglichst viele Variablen auszuschließen. Auch 1m Kabel können schlecht sein. Lohnt also auch das mal zu tauschen, zumindest eine kleine Chance auf Verbesserung gibt es.

[DeaD_EyE]

Vorsicht! Der UART des RPi verträgt nur 3,3V und alles darüber erzeugt Magic Smoke -> Elektroschrott.
Teste einen anderen ttyUSB-Adapter. Am besten die von FTDI und keine Fakes.
Manchmal sind USB-Geräte nicht für den Dauerbetrieb geeignet.
Ich hatte so ein Problem mal mir einem ADSB-Empfänger, der einen Bug in der Firmware hatte und sich nach ein paar Stunden Dauerbetrieb verabschiedet hat.

Jegliches drumherum arbeiten hat das Problem nicht im Ansatz gelöst.

[klabue]

Ich habe einen MBus Adapter von Aliexpress

[__deets__]

Den einen, den es da gibt, meinst du?

Der USB Chip ist der übliche billige China Klon der besseren von FTDI - wie deadeye ja schon anmerkte, sind die vorzuziehen.

[klabue]

Welcher taugt denn was?

[__deets__]

Kein Ahnung. Müsste ich genauso recherchieren wie du. Pro-Tipp: je billiger, desto eher nicht.

[DeaD_EyE]

Entgegenwirken kann man dem, wenn man z.B. bei den zertifizierten Händlern in Deutschland kauft: https://ftdichip.com/sales-network/western-europe/
Ansonsten bei Amazon kaufen und hoffen. Irgendwas kaufen hilft aber auch nicht, du musst schon genau wissen welchen Pegel der tty hat.

Hier mal ein Beispiel von einem RS232 Stecker + FTDI USB:
https://www.amazon.de/gp/product/B006AA04K0/?th=1

Ausgabe von dmesg:

Code: Alles auswählen

[ 3011.756858] usb 1-1: new full-speed USB device number 5 using xhci_hcd
[ 3011.902436] usb 1-1: New USB device found, idVendor=0403, idProduct=6001, bcdDevice= 6.00
[ 3011.902442] usb 1-1: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[ 3011.902445] usb 1-1: Product: FT232R USB UART
[ 3011.902446] usb 1-1: Manufacturer: FTDI
[ 3011.902448] usb 1-1: SerialNumber: A10LDIAZ
[ 3011.940240] usbcore: registered new interface driver ftdi_sio
[ 3011.940253] usbserial: USB Serial support registered for FTDI USB Serial Device
[ 3011.940311] ftdi_sio 1-1:1.0: FTDI USB Serial Device converter detected
[ 3011.940337] usb 1-1: Detected FT232RL
[ 3011.940667] usb 1-1: FTDI USB Serial Device converter now attached to ttyUSB0

...

[ 3055.435678] usb 1-1: USB disconnect, device number 5
[ 3055.436596] ftdi_sio ttyUSB0: FTDI USB Serial Device converter now disconnected from ttyUSB0
[ 3055.436694] ftdi_sio 1-1:1.0: device disconnected

RS232 hat Pegel von -15V bis -3V für eine logische 0 und +3V bis +15V für eine logische 1.

Eine Übersicht der verfügbaren FTDI-Produkte gibt es hier: https://ftdichip.com/product-category/p ... le-series/
Ich habe z.B. regelmäßig diesen hier verwendet: https://ftdichip.com/products/ttl-232r-3v3-pcb/ (3,3V Pegel, 921600 Baud keine Probleme)

[__deets__]

@DeadEye: er hat ein kombiniertes Geraet, in dem der Chip verbaut ist. Sowas zb: https://de.aliexpress.com/item/1005002440696079.html