KRC4 Meldungen mit Datenbank und Variablen

  • Hallo Experten,

    ich hoffe, Ihr könnt mich schlau machen bzw. mir helfen.

    Für unsere Zustandsmeldungen verwenden wir eine Datenbank "Test.kxr" mit folgendem Aufbau:

    <?xml version="1.0" encoding="utf-8"?>
    <resources xmlns="http://www.kuka.com/schemas/kxr/2009">
    <module name="Test">
    <message key="stPalletiseS1" number="201">
    <text xml:lang="de-DEV">Sack wird palettiert (Gut-Sack)... -Station 1-</text>
    <text xml:lang="en-DEV">Bag is palletized (good-bag) ... -Station 1-</text>
    <text xml:lang="fr-DEV">Sac en cours de palettisation ...-poste 1-</text>
    <text xml:lang="nl-DEV">Zak wordt gepalletiseerd ... -Station 1-</text>
    <text xml:lang="cs-DEV">pytel paletovan ... -stanoviste 1-</text>
    </message>

    Der Aufruf im Programm erfolgt so "KCPDialog ("stPalletiseS1", #STATE, #NoDialog, 201)".

    Die Routine hat folgenden Inhalt:


    --------------------------------------------------------------------------------------------------------------------------------------------------
    GLOBAL DEF KCPDialog (stText[]:IN, Type:IN, KeyType:IN, MeldeNr:IN)

    DECL CHAR stText[]
    DECL EKrlMsgType Type
    DECL KrlMsg_T MSG
    DECL KrlMsgPar_T Parameter[3]
    DECL KrlMsgOpt_T Option
    DECL KrlMsgDlgSK_T SK[7]
    DECL enumKeyType KeyType
    INT handle, softkey, i, Lenght, MeldeNr
    BOOL bDummy

    ; Platzhalter Parameter zuweisen
    Parameter[1] = {Par_Type #Empty} ; Leer => keine Parameter-Uebergabe
    Parameter[2] = {Par_Type #Empty} ; Leer => keine Parameter-Uebergabe
    Parameter[3] = {Par_Type #Empty} ; Leer => keine Parameter-Uebergabe

    ; Modulbezeichnung definieren
    MSG.Modul[]="Test"
    ; Meldungnummer definieren
    MSG.NR=MeldeNr
    ; Meldungsverhalten definieren
    Option = {vl_stop TRUE, clear_p_reset TRUE, clear_p_SAW FALSE, log_to_DB TRUE}
    ;Meldetext
    MSG.MSG_Txt[] = stText[]

    ; Meldungstyp definieren und Meldung absetzen
    handle = Set_KrlMsg(#State,MSG, Parameter[],Option)
    --------------------------------------------------------------------------------------------------------------------------------------------------


    Dieses funktioniert einwandfrei inkl. der Sprachumschaltung.


    Jetzt wollen wir noch einen Sackzähler hinzufügen, der den aktuellen Sack auf der Palette anzeigt.


    Dieses wollte ich folgendermassen machen:


    Der Aufruf im Programm erfolgt so "KCPDialog ("stPalletiseS1", #STATE, #NoDialog, 201, nBagS[1])".


    --------------------------------------------------------------------------------------------------------------------------------------------------


    GLOBAL DEF KCPDialog (stText[]:IN, Type:IN, KeyType:IN, MeldeNr:IN, Zaehler:IN)
    DECL CHAR Zaehler
    DECL CHAR stText[]
    DECL EKrlMsgType Type
    DECL KrlMsg_T MSG
    DECL KrlMsgPar_T Parameter[3]
    DECL KrlMsgOpt_T Option
    DECL KrlMsgDlgSK_T SK[7]
    DECL enumKeyType KeyType
    INT handle, softkey, i, Lenght, MeldeNr
    BOOL bDummy

    ; Modulbezeichnung definieren
    MSG.Modul[]="VELOPACK"
    ; Meldungnummer definieren
    MSG.NR=MeldeNr
    ; Meldungsverhalten definieren
    Option = {vl_stop TRUE, clear_p_reset TRUE, clear_p_SAW FALSE, log_to_DB TRUE}
    ;Meldetext
    MSG.MSG_TxT[] = "%1 Sack%2"

    ; Vordefinierung von Parametern
    Parameter[1].Par_Type = #Key
    Parameter[1].par_txt[] = stText[] ; Parameter-Uebergabe des Meldetextes
    Parameter[2] = {Par_Type #Value, PAR_INT 0}
    Parameter[2].PAR_INT = Zaehler ; Parameter-Uebergabe des Sackzaehlers
    Parameter[3] = {Par_Type #Empty} ; Leer => keine Parameter-Uebergabe


    ; Meldungstyp definieren und Meldung absetzen
    handle = Set_KrlMsg(#State,MSG, Parameter[],Option)
    --------------------------------------------------------------------------------------------------------------------------------------------------
    Die Anzeige des Sackzählers funktioniert soweit. Es wird nur nicht der Text aus der Datenbank ausgegeben.


    Ist dieses so überhaupt möglich?


    Laut KUKA Doku sollte das doch möglich sein.
    Dort wird es doch so beschrieben:
    --------------------------------------------------------------------------------------------------------------------------------------------------
    type:
    Typ: KrlMsgParType_T
    Art des Parameters


      • #key: Der Parameter ist ein Schlüssel, nach dem in der Meldungs-Datenbank gesucht werden muss.


    text:
    Typ: CHAR
    Text des Parameters (oder Key für eine Meldungs-Datenbank)


      • Der Text kann maximal 26 Zeichen lang sein und darf nicht aus Leerzeichen bestehen.


    --------------------------------------------------------------------------------------------------------------------------------------------------
    Anhand des "#key" sollte doch der Text in der Datenabnk gefunden werden oder nicht?


    Habt Ihr damit Erfahrungen bzw. habt Ihr eine Idee warum es so nicht funktioniert?


    Vielen Dank im Voraus.

  • Schritt für Schritt zum Roboterprofi!
  • Anhand des "#key" sollte doch der Text in der Datenabnk gefunden werden oder nicht?


    Es reicht nicht nur den Key anzugeben, es muss auch der Name der Datenbank (Modul), in der der Schlüssel steht, angegeben werden.


    In deinem ersten, funktionierenden Beispiel heißt die kxr-Datei "Test", die darin enthaltene Moduldeklaration ist: <module name="Test">
    Und im Meldungsaufruf ist die Modulbezeichnung: MSG.Modul[]="Test".


    Versuch mal in deinem 2. Beispiel ebenfalls: MSG.Modul[]="Test", oder lege eine neue kxr-Datei "VELOPACK" an.


    Nach meiner Erfahrung funktioniert der Datenbankzugriff nur, wenn:


    [ltr] - die kxr-Datei mit der Modulbezeichnung beginnt (z.B. "Velopack_Sonstwas.kxr").


    - die Moduldeklaration in der kxr-Datei die Modulbezeichnung hat (z.B. <module name="Velopack">).


    - es je kxr-Datei nur eine Moduldeklaration gibt.[/ltr]


    - die Meldung mit der passenden Modulbezeichnung aufgerufen wird (z.B. MSG.Modul[]="Velopack").



    Vielleicht liegt es ja an einem dieser Punkte.


    Btw: Sollte die Deklaration von "Zaehler" nicht INT Zaehler lauten? (Geht aber wohl auch so - du schreibst ja, daß dieser Teil funktioniert)

    Einmal editiert, zuletzt von zteve ()

  • Vielen Dank für Deine Antwort.
    Das Modul (kxr-Datei) heißt auch "Test" und ist auch so deklariert. Das war nur ein Schreibfehler von mir mit dem "Velopack".
    Es heißt schon so, wie im ersten Beispiel:
    --------------------------------------------------------------------------------------------------------------------------------------------------
    ; Modulbezeichnung definieren
    MSG.Modul[]="Test"
    --------------------------------------------------------------------------------------------------------------------------------------------------


    Es funktioniert aber trotzdem nicht.
    Hat sonst noch irgendjemand eine Idee.

  • Ich hab noch einen Vorschlag zum Ausprobieren:


    Parameter[1] = {Par_Type #Key, Par_txt[] "Init"}
    Parameter[1].Par_txt[] = stText[]


    Auf diese Weise machst du das auch bei Parameter 2 - ist ein Versuch wert.



    Solltest du es nicht schon probiert haben, versuchs mal nur mit Parameter 1.
    Und teste mal mit einem Leerzeichen vor %1 (MSG.MSG_TxT[] = " %1")



    Du schreibst: "Es wird nur nicht der Text aus der Datenbank ausgegeben."


    Was wird denn ausgegeben? Ist der Platz leer oder wird %1 angezeigt....?

  • Ich habe deinen Vorschlag mal ausprobiert. Hat aber nichts geändert.

    Was mir aufgefallen ist:

    ; Vordefinierung von Parametern
    Parameter[1].Par_Type = #Key
    Parameter[1].par_txt[] = stText[] ; Parameter-Uebergabe des Meldetextes
    Parameter[2] = {Par_Type #Value, PAR_INT 0}
    Parameter[2].PAR_INT = Zaehler ; Parameter-Uebergabe des Sackzaehlers
    Parameter[3] = {Par_Type #Empty} ; Leer => keine Parameter-Uebergabe

    und den Text wie folgt ausgebe:


      • "MSG.MSG_TxT[] = "%2"", erhalte ich als Anzeige "1" (stimmt aber nicht mit dem Zähler überein.)



      • "MSG.MSG_TxT[] = "Test%2"", erhalte ich als Anzeige "Test(mit dem korrekten Zählerwert)"



      • "MSG.MSG_TxT[] = "%1"", erhalte ich als Anzeige "1"



      • "MSG.MSG_TxT[] = "Test%1"", erhalte ich als Anzeige "TestP_0"



      • "MSG.MSG_TxT[] = "Test%1 %2"", erhalte ich als Anzeige "TestP_0 (korrekten Zählerwert)"


    Parallel läuft eine Anfrage bei KUKA. Mal schauen, was die so sagen.

  • Habe ich mir fast gedacht - die Meldungssyntax verträgt % nicht als erstes Zeichen. Darum mein Vorschlag mal mit einem Leerzeichen vor % zu testen.


    Ich orakle mal: das P_0 könnte für "Parameter X hat keinen Wert, bzw. ist nicht initialisiert" stehen.


    Dann müßte nach meiner Annahme und mit meinem anderen Vorschlag:


    [ltr]Parameter[1] = {Par_Type #Key, Par_txt[] "Init"}
    Parameter[1].Par_txt[] = stText[][/ltr]


    statt "TestP_0" > "TestInit" ausgegeben werden.


    Wäre klasse, wenn du uns über die Antwort von KUKA auf dem Laufenden hältst.


    Gruß, Stefan

    Einmal editiert, zuletzt von zteve ()

  • So, da bin ich wieder. Sorry, dass es länger gedauert hat. Hatte eine Menge zu tun.


    Hier die Antwort von KUKA:
    -----------------------------------------------------------------------------------------------------------------------------



    Hier darf keiner der Parameter den DB-Schlüssel tragen.
    Der Name der Datenbank steht in Modul, der Schlüssel selbst im Meldungstext.

    Beispiel:
    [size=2] ; NOTIFY-MSG [/size]
    [size=2] USER_Handle = 0
    USER_Msg = {MODUL[] "UserDB",NR 1,MSG_TXT[] "USRMSG_01"} [/size]

    [size=2] USER_Notify_Par[1] = {PAR_TYPE #VALUE, PAR_TXT[] "Parameter1"} [/size]
    [size=2] USER_Notify_Par[2] = {PAR_TYPE #VALUE, PAR_BOOL TRUE} [/size]
    [size=2] USER_Notify_Par[3] = {PAR_TYPE #VALUE, PAR_INT 12} [/size]
    [size=2] USER_Handle = Set_KrlMsg(#Notify, USER_Msg, USER_Notify_Par[], USER_Opt) [/size]
    [size=2] WHILE (USER_Handle == -1) [/size]
    [size=2] USER_Handle = Set_KrlMsg(#Notify, USER_Msg, USER_Notify_Par[], USER_Opt) [/size]
    ENDWHILE

    Auszug aus dem KXR-File „UserDB.de.kxr
    <resources xml:lang="de" xmlns="http://www.kuka.com/schemas/kxr/2009">
    <module name="UserDB">
    <message key="USRMSG_01" number="1">
    <text>Das ist eine Hinweismeldung in deutsch mit Parametern: %1 , %2 , %3 </text>
    </message>



    </module>
    </resources>
    -----------------------------------------------------------------------------------------------------------------------------


    Habe es entsprechend so gemacht:

    Der Aufruf im Programm erfolgt so "KCPDialog ("stPalletiseS1", #STATE, #NoDialog, 201, nBagS[nStationNo])"


    ; Platzhalter Parameter zuweisen
    Parameter[1] = {Par_Type #Value, PAR_INT 0}
    Parameter[1].PAR_INT = Zaehler ; Parameter-Uebergabe des Sackzaehlers


    Die kxr-Datei entsprechend so verändert:


    <?xml version="1.0" encoding="utf-8"?>
    <resources xmlns="http://www.kuka.com/schemas/kxr/2009">
    <module name="Test">
    <message key="stPalletiseS1" number="201">
    <text xml:lang="de-DEV">Sack wird palettiert (Gut-Sack)... -Station 1- %1</text>
    <text xml:lang="en-DEV">Bag is palletized (good-bag) ... -Station 1- %1</text>
    <text xml:lang="fr-DEV">Sac en cours de palettisation ...-poste 1- %1</text>
    <text xml:lang="nl-DEV">Zak wordt gepalletiseerd ... -Station 1- %1</text>
    <text xml:lang="cs-DEV">pytel paletovan ... -stanoviste 1- %1</text>
    </message>



    und es funktioniert so.


    Vielen Dank

Erstelle ein Benutzerkonto oder melde dich an um zu kommentieren

Du musst ein Benutzerkonto haben um einen Kommentar hinterlassen zu können

Benutzerkonto erstellen
Neues Benutzerkonto für unsere Community erstellen. Geht einfach!
Neues Benutzerkonto erstellen
Anmelden
Du hast bereits ein Benutzerkonto? Melde dich hier an.
Jetzt anmelden