mehrere dict nacheinander nach Keys durchsuchen.

[__blackjack__]

@kiaralle: Das geht nicht weil die Funktion dann auf der Zeichenkette die Methode `values()` aufruft und so eine Methode haben Zeichenketten nicht. An der Stelle müsstest Du halt das Wörterbuch übergeben und keine Zeichenkette.

Die Funktion verwendet die *Schlüssel* überhaupt gar nicht, warum gibt es die dann überhaupt? Und was soll bei einem `error_code` mit dem Wert "01" ausgegeben werden? Da werden ja *zwei* Meldungen ausgegeben, die nicht so klingen, als hätten sie etwas miteinander zu tun‽

[Dennis89]

Das funktioniert so nicht, dein Wörterbuch hat den Name `srs_skm`. Der name `model` ist jetzt einem String "srs_skm" zugewiesen. Das ist aber *nicht* das Wörterbuch, das sind zwei vollkommen unterschiedliche Objekte.
`model` ist ein String und `srs_skm` ist dein Wörterbuch und an die Funktion musst du ein Wörterbuch als erstes Argument übergeben.

[sparrow]

@kiaralle: Warum machst du das so kompliziert? Warum brauchst du eine verschachtelte Datenstruktur? Das kann man machen. Aber ich würde sie separat definieren und als Konstanten definieren.

Code: Alles auswählen

INIT_ERROR_TO_TEXT = {
    "00": "der Geber hat keinen fehler erkannt",
    "01": "Abgleichdaten fehlerhaft",
    "02": "interner Winkeloffset fehlerhaft",
    "03": "Tabelle über Datenfeldpartitionierung zerstört",
    "04": "analoge Grenzwerte nicht verfügbar",
    "05": "interner i2c-Bus nicht funktionsfähig",
    "06": "interner Checksummenfehler",
}

PROTOCOL_ERROR_TO_TEXT = {
    "07": "Geberreset durch Programmüberwachung aufgetreten",
    "09": "Parityfehler",
    "0a": "checksumme der übertragenen daten ist falsch",
    "0B": "unbekannter Befehlscode",
    "0c": "anzahl der übertragenen daten ist falsch",
    "0d": "übertragenes Befehlsargument ist unzulässig",
}

DATA_ERROR_TO_TEXT = {
    "0e": "das selektierte datenfeld darf nicht beschrieben werden",
    "0f": "falscher Zugriffscode",
    "10": "angegebenes datenfeld in seiner größe nicht veränderbar",
    "11": "angegebene Wortadresse außerhalb datenfeld",
    "12": "Zugriff auf nicht existierendes datenfeld",
}

POSITION_ERROR_TO_TEXT = {
    "01": "Analogsignale außerhalb Spezifikation",
    "1f": "Drehzahl zu hoch, keine Positionsbildung möglich",
    "20": "Position Singleturn unzuverlässig",
    "21": "Positionsfehler multiturn",
    "22": "Positionsfehler multiturn",
    "23": "Positionsfehler multiturn",
}

(ungetested aus C&P)

So musst du da auch nicht wild drin suchen sondern einfach, wenn du gerade im Positions-Kontext bist:

Code: Alles auswählen

def process_position():
    ...
    error_code = "1f"
    error_text = POSITION_ERROR_TO_TEXT.get(error_code, f"unknown error: {error_code}")

[Pedroski55]

Ist alles ein Bißchen Wirr, vielleicht hilft dir dies:

Code: Alles auswählen

info_dict = {    
    "initialisierung": {
        "00" :"der Geber hat keinen fehler erkannt",
        "01" :"abgleichdaten fehlerhaft",
        "02" :"interner Winkeloffset fehlerhaft",
        "03" :"tabelle über datenfeldpartitionierung zerstört",
        "04" :" analoge grenzwerte nicht verfügbar",
        "05" :"interner i2c-Bus nicht funktionsfähig",
        "06" :"interner checksummenfehler"             
        },  
    "protokoll": {
        "07":" geberreset durch Programmüberwachung aufgetreten",
        "09":" Parityfehler",
        "0a":" checksumme der übertragenen daten ist falsch",
        "0B" :"unbekannter Befehlscode",
        "0c" :"anzahl der übertragenen daten ist falsch",
        "0d" :"übertragenes Befehlsargument ist unzulässig",
        },  
    "daten": {
        "0e" :"das selektierte datenfeld darf nicht beschrieben werden",
        "0f":"falscher Zugriffscode",
        "10":"angegebenes datenfeld in seiner größe nicht veränderbar",
        "11":" angegebene Wortadresse außerhalb datenfeld",
        "12" :"Zugriff auf nicht existierendes datenfeld"
        },       
    "position": {
        "01":"Analogsignale außerhalb Spezifikation",
        "1f":"drehzahl zu hoch, keine Positionsbildung möglich",
        "20":"Position Singleturn unzuverlässig",
        "21":"Positionsfehler multiturn",
        "22":"Positionsfehler multiturn",
        "23":"Positionsfehler multiturn"
        },   
    "andere": {
        "1c":"Betragsüberwachung der Analogsignale (Prozessdaten)",
        "1d":"Senderstrom kritisch (Verschmutzung, Senderbruch)",
        "1e":"gebertemperatur kritisch",
        "08":"überlauf des Zählers"
        }
    }

# von dieser Liste hol dir die Keys für info_dict
# benutze for loop wenn es hilft
fehlerbereiche=["initialisierung", "protokoll", "daten", "position", "andere"]

key = fehlerbereiche[0] # hier key = "initialisierung",

for f in info_dict[key].keys():
    print(f, info_dict[key][f])

Ergibt:

00 der Geber hat keinen fehler erkannt
01 abgleichdaten fehlerhaft
02 interner Winkeloffset fehlerhaft
03 tabelle über datenfeldpartitionierung zerstört
04 analoge grenzwerte nicht verfügbar
05 interner i2c-Bus nicht funktionsfähig
06 interner checksummenfehler

[Pedroski55]

Oder so:

Code: Alles auswählen

# oder
key = fehlerbereiche[0]
subkey = '01'

def hol_den_fehler(key, subkey):
    for f in info_dict[key].keys():
        if subkey == f:
            print(f, info_dict[key][f])
            return f + ': ' + info_dict[key][f]
            
res = hol_den_fehler("initialisierung", "01")

[sparrow]

@Pedroski55: Es ist falsch, über die Keys eines Dicts zu iterieren um einen passenden Schlüssel zu finden. Die dicts sind ja gerade dazu da, _über den Schlüssel_ den Zugrif auf den Wert zu erhalten.

[Sirius3]

@Pedroski55: `key` und `subkey` werden definiert aber nie benutzt. Konstanten schreibt man komplett groß und vergibt sprechende Namen; also statt `info_dict` `ERROR_DESCRIPTIONS`. Die for-Schleife ist überflüssig, weil man über den Schlüssel auch direkt auf den Wert zugreifen kann, was Du ja selbst auch ständig tust.
Strings stückelt man nicht mit + zusammen sondern nutzt f-Strings.
Wenn der Schlüssel nicht gefunden wird, gibst Du implizit None zurück, das sollte man aber explizit tun, oder besser eine Exception werfen, z.B. den KeyError, der automatisch generiert wird, wenn ein Schlüssel nicht gefunden wird.

Code: Alles auswählen

def get_error_description(area, error_code):
    description = ERROR_DESCRIPTIONS[area][error_code]
    return f"{error_code}: {description}"

result = get_error_description("initialisierung", "01")

[noisefloor]

@Pedroski55: das Konstrukt

Code: Alles auswählen

for f in info_dict[key].keys():
    print(f, info_dict[key][f])

ist auch unnötig kompliziert, weil unnötig viele Zugriffe auf das Wörterbuch erfolgen. Einfacher & besser:

Code: Alles auswählen

for key, value in info_dict[key].items():
    print(f'{key} : {value}

Gruß, noisefloor

[snafu]

Oder mit ``starmap`` als Einzeiler:

Code: Alles auswählen

print(*starmap("{} : {}".format, info_dict[key].items()), sep="\n")

[DeaD_EyE]

Verschachtelte Definition => flache Struktur:

Code: Alles auswählen

from enum import StrEnum

ErrorCategory = StrEnum(
    "ErrorCategory", ["initialisierung", "protokoll", "daten", "position", "andere"]
)

ERRORS_BY_CATEGORY = {
    ErrorCategory.initialisierung: {
        "00": "der Geber hat keinen fehler erkannt",
        "01": "abgleichdaten fehlerhaft",
        "02": "interner Winkeloffset fehlerhaft",
        "03": "tabelle über datenfeldpartitionierung zerstört",
        "04": " analoge grenzwerte nicht verfügbar",
        "05": "interner i2c-Bus nicht funktionsfähig",
        "06": "interner checksummenfehler",
    },
    ErrorCategory.protokoll: {
        "07": " geberreset durch Programmüberwachung aufgetreten",
        "09": " Parityfehler",
        "0a": " checksumme der übertragenen daten ist falsch",
        "0B": "unbekannter Befehlscode",
        "0c": "anzahl der übertragenen daten ist falsch",
        "0d": "übertragenes Befehlsargument ist unzulässig",
    },
    ErrorCategory.daten: {
        "0e": "das selektierte datenfeld darf nicht beschrieben werden",
        "0f": "falscher Zugriffscode",
        "10": "angegebenes datenfeld in seiner größe nicht veränderbar",
        "11": " angegebene Wortadresse außerhalb datenfeld",
        "12": "Zugriff auf nicht existierendes datenfeld",
    },
    ErrorCategory.position: {
        "01": "Analogsignale außerhalb Spezifikation",
        "1f": "drehzahl zu hoch, keine Positionsbildung möglich",
        "20": "Position Singleturn unzuverlässig",
        "21": "Positionsfehler multiturn",
        "22": "Positionsfehler multiturn",
        "23": "Positionsfehler multiturn",
    },
}

ERRORS_FLAT = {
    error_code: (error_category, error_message)
    for error_category in ERRORS
    for error_code, error_message in ERRORS_BY_CATEGORY[error_category].items()
}

error_category, error_message = ERRORS_FLAT["0d"]
print(f"{error_category.title()}: {error_message}")

Einfacher wäre die Definition der Fehler in einer ini-Datei und mithilfe des ConfigParsers kann mnan die Datei einlesen.
Hier ein Beispiel mit einer Fake-Datei:

Code: Alles auswählen

from io import StringIO
from configparser import ConfigParser


fake_datei = StringIO(
    """
[initialisierung]
00 = der Geber hat keinen fehler erkannt
01 = abgleichdaten fehlerhaft
02 = interner Winkeloffset fehlerhaft
03 = tabelle über datenfeldpartitionierung zerstört
04 = analoge grenzwerte nicht verfügbar
05 = interner i2c-Bus nicht funktionsfähig
06 = interner checksummenfehler

[protokol]
07 = geberreset durch Programmüberwachung aufgetreten
09 = Parityfehler
0a = checksumme der übertragenen daten ist falsch
0B = unbekannter Befehlscode
0c = anzahl der übertragenen daten ist falsch
0d = übertragenes Befehlsargument ist unzulässig

[daten]
0e = das selektierte datenfeld darf nicht beschrieben werden
0f = falscher Zugriffscode
10 = angegebenes datenfeld in seiner größe nicht veränderbar
11 = angegebene Wortadresse außerhalb datenfeld
12 = Zugriff auf nicht existierendes datenfeld

[position]
01 = Analogsignale außerhalb Spezifikation
1f = drehzahl zu hoch, keine Positionsbildung möglich
20 = Position Singleturn unzuverlässig
21 = Positionsfehler multiturn
22 = Positionsfehler multiturn
23 = Positionsfehler multiturn
"""
)

error_config = ConfigParser()
error_config.read_file(fake_datei)


ERRORS_NESTED = {
    category: {
        error_code: error_message
        for error_code, error_message in error_config[category].items()
    }
    for category in error_config.sections()
}
ERRORS_FLAT = {
    error_code: (error_category, error_message)
    for error_category in ERRORS_NESTED
    for error_code, error_message in ERRORS_NESTED[error_category].items()
}

ERRORS_NESTED und ERRORS_FLAT könnte man sicherlich noch vereinfachen.
Flache Strukturen sind einfacher zu handeln.

Als Mensch hat man aber keine Lust z.B. für jeden Fehler Kategorie und Nachricht einzeln anzugeben. Deswegen der Kompromiss mit Hilfe der ini-Datei.


Wenn man das als verschachtelte Schleife macht, ist es einfacher zu verstehen.

Code: Alles auswählen

from collections import defaultdict

ERRORS_NESTED = defaultdict(dict)
for category in error_config:
    for error_code, error_message in error_config[category].items():
        ERRORS_NESTED[category][error_code] = error_message

# wieder in dict umwandeln
ERRORS_NESTED = dict(ERRORS_NESTED)

ERRORS_FLAT = {}
for category in error_config:
    for error_code, error_message in error_config[category].items():
        ERRORS_FLAT[error_code] = (category, error_message)

[__blackjack__]

Ich frage mich (und den OP) auch immer noch ob das mit dem Fehlercode der in mehr als einer Kategorie auftaucht tatsächlich real ist, oder einfach ein Tippfehler und wir hier viel zu kompliziert heran gehen, und es am Ende nicht eine einfache Abbildung von Fehlercode auf Nachricht tut.

[kiaralle]

So bin wieder da. Gartenarbeit ging vor.
Ich seit hier irgendwie auf Droge
Macht mal langsam, ich komme sonnst nicht mit.

Der Fehler "01" ist kein Schreibfehler. Er taucht wirklich zweimal auf. Ich denke mal der erste bezieht sich aber auf einen Fehler, woraus dann der andere folgt.
Da es mehrere Gebertypen gibt, gibt es dann auch mehrere "Fehlertabellen"
Hab noch nicht geprüft ob die sich unterscheiden. Denke aber schon.

Ich muss die Infos von euch erst mal verarbeiten.

Danke

[kiaralle]

Nach langem lesen und denken bin ich auf folgende Lösung gekommen.
Ich als Schrauber muss es verstehen können, deshalb dieser Weg.
ich rufe meine sick_error.py über mein Haupt-Code auf.
Da ich aktuell 4 Gebertypen habe, jede seine eignen Fehlertabelle, rufe ich je nach Gebertyp separat auf. Hier nur zwei Typen integriert.
Ist in euren Augen eventuell nicht optimal, aber ich verstehe aktuell nicht mehr und ich komme erst einmal zurecht.
Nur bekomme ich bei dem Fehler "01" der ja 2x vorhanden ist nicht beide Fehler zurück. Nur den letzten. der erste geht verloren, wird vom letzten überschrieben.
Wie kann ich beide Fehlermeldungen zusammen setzen?
Und kann man ermitteln, aus welchen Bereich der Fehler kommt?
Also initialisierung, protokoll....?
Die Dokumentation über Dictionary gibt da nichts her.

Gruß Ralf

Code: Alles auswählen

import sick_error

fehlercode = "01"
model = 34 # Den Gebertyp lese ich aus dem Geber heraus

if model == 34:
    print("Model ID: SRS-50-Serie gefunden\n")
    print(sick_error.srs_errors(fehlercode))

    
if model == 39:
    print("Model ID: SRM-50-Serie gefunden\n")    
        print(sick_error.srm_errors(fehlercode))
 

Code: Alles auswählen

#sick_error.py

srs = {
    "initialisierung": {
        "00": "der Geber hat keinen Fehler erkannt",
        "01": "Abgleichdaten fehlerhaft",
        "02": "interner Winkeloffset fehlerhaft",
        "03": "Tabelle über Datenfeldpartitionierung zerstört",
        "04": "analoge Grenzwerte nicht verfügbar",
        "05": "interner i2c-Bus nicht funktionsfähig",
        "06": "interner Checksummenfehler",
    },
    "protokoll": {
        "07": "Geberreset durch Programmüberwachung aufgetreten",
        "09": "Parityfehler",
        "0a": "Checksumme der übertragenen Daten ist falsch",
        "0B": "unbekannter Befehlscode",
        "0c": "Anzahl der übertragenen Daten ist falsch",
        "0d": "übertragenes Befehlsargument ist unzulässig",
    },
    "daten": {
        "0e": "das selektierte Datenfeld darf nicht beschrieben werden",
        "0f": "falscher Zugriffscode",
        "10": "angegebenes Datenfeld in seiner Größe nicht veränderbar",
        "11": "angegebene Wortadresse außerhalb Datenfeld",
        "12": "Zugriff auf nicht existierendes Datenfeld",
    },
    "position": {
        "01": "Analogsignale außerhalb Spezifikation",
        "1f": "Drehzahl zu hoch, keine Positionsbildung möglich",
        "20": "Position Singleturn unzuverlässig",
        "21": "Positionsfehler Multiturn",
        "22": "Positionsfehler Multiturn",
        "23": "Positionsfehler Multiturn",
    },
    "andere" : {
        "1c":"Betragsüberwachung der Analogsignale (Prozessdaten)",
        "1d":"Senderstrom kritisch (Verschmutzung, Senderbruch)",
        "1e":"Gebertemperatur kritisch",
        "08":"überlauf des Zählers",
        },
}


srm = {
    "initialisierung": {
        "00": "der Geber hat keinen Fehler erkannt",
        "01": "Abgleichdaten fehlerhaft",
        "02": "interner Winkeloffset fehlerhaft",
        "03": "Tabelle über Datenfeldpartitionierung zerstört",
        "04": "analoge Grenzwerte nicht verfügbar",
        "05": "interner i2c-Bus nicht funktionsfähig",
        "06": "interner Checksummenfehler",
    },
    "protokoll": {
        "07": "Geberreset durch Programmüberwachung aufgetreten",
        "09": "Parityfehler",
        "0a": "Checksumme der übertragenen Daten ist falsch",
        "0B": "unbekannter Befehlscode",
        "0c": "Anzahl der übertragenen Aaten ist falsch",
        "0d": "übertragenes Befehlsargument ist unzulässig",
    },
    "daten": {
        "0e": "das selektierte Datenfeld darf nicht beschrieben werden",
        "0f": "falscher Zugriffscode",
        "10": "angegebenes Datenfeld in seiner Größe nicht veränderbar",
        "11": "angegebene Wortadresse außerhalb Datenfeld",
        "12": "Zugriff auf nicht existierendes Datenfeld",
    },
    "position": {
        "01": "Analogsignale außerhalb Spezifikation",
        "1f": "Drehzahl zu hoch, keine Positionsbildung möglich",
        "20": "Position Singleturn unzuverlässig",
    },
    "andere" : {
        "1c":"Betragsüberwachung der Analogsignale (Prozessdaten)",
        "1d":"Senderstrom kritisch (Verschmutzung, Senderbruch)",
        "1e":"Gebertemperatur kritisch",
        "08":"überlauf des Zählers",
        }, 
}


def srm_errors(error_code):
    
    for sector in srm.values():
        if error_code in sector:
            fehlermeldung = (f"Fehlercode {error_code} :{sector[error_code]}\n")
    return fehlermeldung
        
def srs_errors(error_code):
    for sector in srs.values():
        if error_code in sector:   
            fehlermeldung = (f"Fehlercode {error_code} :{sector[error_code]}\n")
    return fehlermeldung
                   

[sparrow]

Verstehe ich nicht.
Ich habe dich in einem vorherigen Post gefragt, ob du weißt, in welchem Kontext du gerade bist. Also ob du gerade in Initialisierung, Position, Daten, etc. bist. Du hast gesagt, dass du das an der Stelle weißt.
Wenn dem so ist: Warum willst du denn da alle Fehlercodes abrufen? Auch die, die gerade gar nicht relevant sind?

Ich frage mal anders: Wenn du Schrauber bist (das beziehen Leute ja meist auf Autos) und es vorne beim Bremsen quietscht, kommst du doch auch nicht auf die Idee den Luftdruck des Reserverats zu prüfen, oder? Das würdest du in einem anderen Kontext tun (zum Beispiel bei der Inspektion) aber nicht bei der Ursachenforschung für das Quietschen beim Bremsen.

Warum prüfst du dann die Fehler des Initialisierung-Kontext wenn eigentlich nur die der Positionen auftreten können?

[noisefloor]

Hallo,

Ich als Schrauber muss es verstehen können, deshalb dieser Weg.

Nein, das ist Quatsch bzw. eine Ausrede gegenüber die selber. Du musst als Programmierer deines eigenen Codes verstehen, was du dir da programmierst. Das gilt immer, egal auf welchem Level man programmiert.

Nur bekomme ich bei dem Fehler "01" der ja 2x vorhanden ist nicht beide Fehler zurück. Nur den letzten. der erste geht verloren, wird vom letzten überschrieben.

Dann liegt der Fehler in deinem Code. Wenn du mehr als ein Ergebnis bekommen könntest, dann musst du halt das Ergebnis in eine Datenstruktur speichern, die mehr als ein Element haben kann. Also kein String, kein Integer, kein Float, sondern z.B. eine Liste, ein Tupel oder ein Dict.

Und kann man ermitteln, aus welchen Bereich der Fehler kommt?

Du fragst den Fehler doch explizit ab, also _weißt_ du, woher der Fehler kommt. Du musst es halt in der Ergebnisdatenstruktur mit speichern. Wenn dein Geber "01" ohne Kontext liefert, d.h. der Geber sagt dir nicht, ob das aus der Initialisierung oder der Position kommt, dann geht das natürlich nicht. Aber dann wäre die Fehlercodeimplementierung deines Gebers schrottig und die solltest dich nach anderen Gebern umsehen.

Gruß, noisefloor

[kiaralle]

Du fragst den Fehler doch explizit ab, also _weißt_ du, woher der Fehler kommt. Du musst es halt in der Ergebnisdatenstruktur mit speichern. Wenn dein Geber "01" ohne Kontext liefert, d.h. der Geber sagt dir nicht, ob das aus der Initialisierung oder der Position kommt, dann geht das natürlich nicht. Aber dann wäre die Fehlercodeimplementierung deines Gebers schrottig und die solltest dich nach anderen Gebern umsehen.

Oh wie recht du hast. Der Geber sagt mir es ja nichts, deshalb macht es ja keine Sinn danach zu suchen.
Ich erhalte nur die Antwort "Geberadresse --- Register --- Value --- Checksum"

Dann liegt der Fehler in deinem Code. Wenn du mehr als ein Ergebnis bekommen könntest, dann musst du halt das Ergebnis in eine Datenstruktur speichern, die mehr als ein Element haben kann. Also kein String, kein Integer, kein Float, sondern z.B. eine Liste, ein Tupel oder ein Dict.

Das mach ich. Damit habe ich wenigstens beide "01"Fehler zusammen.
Und wenn der Geber sowieso die letzten 4 Fehler intern speichern kann, dann speichere ich alle Fehler in eine Liste, ein Tupel oder ein Dict.
Das bekomme ich hin

Danke

[kiaralle]

@sparrow

Warum prüfst du dann die Fehler des Initialisierung-Kontext wenn eigentlich nur die der Positionen auftreten können?

Auch du hast hier recht.
Die ganze Unterteilung könnte ich mir sparen. Nur stand dies so gesplittet in der Doku er Geber.
Ich könnte beide Fehler in einem zusammen fassen und das Problem wäre keins mehr.

Ich denke nach

[sparrow]

Die Unterteilung ist auch in Ordnung. Die ist auch gar nicht das Problem. Die ist sogar wichtig.
Wenn du weißt, dass _jetzt in diesem Kontext_ nur Fehler für die Initialisierung auftreten können, dann prüfst du nur, ob für die ein Text da ist.
Wie das geht - inklusive "Es gibt kein passendes Mapping" steht in meinem Post weiter vorne im Thread.

[kiaralle]

@sparrow

Das funktioniert.

Code: Alles auswählen

error_code = "01"
error_text = srs["initialisierung"].get(error_code, f"unknown error: {error_code}")
print(error_text)

Abgleichdaten fehlerhaft

Nur muss man dann ja wissen woher der Fehler kommt. Und das genau sagt mir der Geber nicht.

Aber trotzdem Danke, wieder was gelernt.