ProTool Meldungsnummer auslesen

HolleHonig

Level-2
Beiträge
118
Reaktionspunkte
6
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,
ich steh grad vor folgender Aufgabe:
Betriebs- und Störmeldungen werden von der Steuerung(314C-2) per zugehörigem DB in mein mit ProTool projektiertes TP170B übertragen. Am TP erscheint dann die Meldung mit zugehöriger Meldenummer. (ich verwende das Meldebitverfahren)
Nun soll ich diese Meldenummer per Pin to Pin bitcodiert (über 8 Digitalausgänge der Steuerung) an einen Leitstand übertragen. Als Beispiel: Meldung 23 ( bitcodiert 0001 0111) wird durch DB125.dbx3.6 ausgelöst. Bis daher alles kein Problem.
Mein Problem bei der ganzen Sache ist, daß ich ca 100 Meldungen habe und diese Nummern ja irgendwie mit dem auslösenden Bit verknüpfen muss. Ich könnte jetzt hergehen, und jedes einzelne Bit abfragen und bei "true" den zugehörigen Wert in eine Variable schreiben, die ich dann zum Schluss auswerte. Bei ca. 100 Meldungen bläht es mir aber meinen FC dermaßen auf.
Jetzt meine Frage:
Gibt es eine Möglichkeit, die Verknüpfung von dem Bit, das die Meldung auslöst zu der Meldenummer, die nachher mit ProTool angezeigt wird, irgendwie auszulesen und zu verarbeiten?

Ich hoffe, ich hab mein Problem halbwegs verständlich rübergebracht und warte jetzt auf eure Hife.
Danke schon im voraus!
 
Zuletzt bearbeitet:
Möglichkeiten gibt es mehrere, hier mal Eine in groben Zügen schnell zusammengesucht:

STM 1-2000 wird abgefragt und löst Sammelstörung Aus

Code:
      AUF   "STOERMELDUNGEN DB"
      L     P#0.0                       //Störmeldungen beginnen in meinem DB bei DBW0
      T     #pointer_1               //DWORD
      L     0
      T     #ergebnis                //WORD
      L     125                         //Anzahl der Wörter mit Störmeldungen in deinem Störmelde-DB
SC02: T     #zaehler               //INT
      L     DBW [#pointer_1]            // Lade Datenwort
      L     0                           // Lade 0
      ==I                               // keine Störmeldung !!!
      SPB   NUL2                        // Ergebnis nicht hochzählen
      L     #ergebnis                   // bei Erg <> 0 Ergebnis hochzählen
      L     1                           // um 1 erhöhen
      +I    
      T     #ergebnis
 
!!!!!!!!!!!!!!!!!!!
Hier muß jetzt noch die Bit-Nummer ausgewertet werden, 
die in dem gerade bearbeiteten Datenwort gesetzt ist (Schieben 
und zählen, oder FC von der Homepage von sps-concept (glaube 
ich, such mal um Forum).
Mit dem hochgezählten "ergebnis" und der Bitnummer kannst du 
dann die Störmeldenummer berechnen
 
 
NUL2: NOP   0                           // Zeiger erhöhen aud nächstest DW
      L     #pointer_1
      L     P#2.0
      +D    
      T     #pointer_1
      L     #zaehler
      LOOP  SC02                        // Schleife solange, bis #zaehler auf 0
      L     #ergebnis                   // bei Ergebnis <> 0 liegt Fehler vor
      L     0
      <>I   
      =     "M1.0 Sammelfehler"

Geht aber ganz sicher noch optimaler.
Achtung, die Byte mit den Fehlernummern im Wort sind vertauscht, sie dir das mal in der Variablentabelle online an.
 
Zuletzt bearbeitet:
du kannst bei der auswertung nicht einfach hochzählen.

im db liegen die stm in folgeder reihenfolge vor.
dbb0 stm9-16
dbb1 stm1-8
dbb2 stm25-32
dbb3 stm17-24
usw
 
@volker: Das die Stm so liegen, das weiss ich. Da steckt auch mein Hauptproblem. Ich schaffs noch nicht, das in einer Formel, oder was auch immer, auszudrücken. Es gibt (zumindest für mich) keinen logischen zusammenhang zwischen der DB- und der STM-Nummer. Vielleicht hat einer von euch ja noch n Tip parat, wie man das lösen könnte.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Db <-> Stm

HolleHonig schrieb:
Es gibt (zumindest für mich) keinen logischen zusammenhang zwischen der DB- und der STM-Nummer.

Hallo,

nicht byteweise, sondern wortweise betrachten und Datenworte immer schön mit geraden Nummern hochzählen, schon stimmt's:

1.Störmeldung = Datenwort x, Bit 0 (1. Bit)
2.Störmeldung = Datenwort x, Bit 1
...
15.Störmeldung = Datenwort x, Bit 14
16.Störmeldung = Datenwort x, Bit 15
17.Störmeldung = Datenwort x+2, Bit 0
...
32.Störmeldung = Datenwort x+2, Bit 15
...
 
Zuletzt bearbeitet:
Es gibt natürlich einen logischen Zusammenhang, sonst funzt keine SPS :rolleyes: .

BSP:
STM18 (DB18.dbx3.2)

DB18 ab DBW0 Störmeldungen

DBW0 --> STM1-16
DBW2 --> STM17-32
...

Worte zählen:
Datenworte auf Null vergleichen und in Hilfsvar 2 hochzählen.
DBW0 = 0 --> Hilfsvar_1 erhöhen auf 1
DBW2 <> 0 --> raus zum Bitzählen

Bits zählen:
In DBW2 ist Byte 2 links und Byte 3 rechts
Du brauchst also keine Byte tauschen, wenn du mit SRW arbeitest.

Mit SRW 1 solange schieben und Hilfsvar_2 hochzählen, bist eine 1 rausgeschoben wird. Hilfsvar 2 ist bei DBX3.2 --> 3 (3x rausgeschoben)

Wenn eine Eins rausgeschoben wurde (dafür gibt es eine Sprungoperation),
dann Fehlernummer berechnen:

Hilfsvar_1*16 + Hilfsvar_2.
 
Code:
Konvertierung der Bitnummer i in die Stoermeldenummer j

j := (i xor 8) +1;


Berechnung der Bitnummer i aus der Stoermeldenummer j

i := (j-1) xor 8;


Das ist PASCAL, in AWL uebersetzen musst Du selber.
.
 
Wenn es dir nichts ausmacht, stell doch die Lösung hier rein, da können andere Nutzer sich ja was abgucken ;) :rolleyes: .
 
Das wäre schön, denn ich habe ein ähnliches Problem!

z.B.: bitposition = LN bitwert / LN 2
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Musste noch ein paar kleine Schönheitskorrekturen machen. Jetzt isses aber fertig.
Hier der Code:
Code:
      AUF   "DB-Meldungen-Stoer"
      L     P#0.0                       // Störmeldungen beginnen bei DBW0
      T     #Zeiger                     // DWORD
      L     0
      T     #Datenwort_Nummer           // WORD
      L     7                           // Anzahl der Wörter mit Störmeldungen im Störmelde-DB
M001: T     #zaehler                    // INT
      L     DBW [#Zeiger]               // Lade Datenwort
      L     0                           // Lade 0
      ==I                               // keine Störmeldung !!!
      SPB   M002
      SPA   End                         // wenn eine Störmeldung vorliegt, wird hier aus der Schleife gesprungen
M002: L     #Datenwort_Nummer           // 
      L     1                           // Datenwortnummer um 1 erhöhen
      +I    
      T     #Datenwort_Nummer
      L     #Zeiger                     // Zeiger um 2 erhöhen
      L     P#2.0                       // zeigt auf das nächste Datenwort
      +D    
      T     #Zeiger
      L     #zaehler
      LOOP  M001                        // Schleife solange, bis #zaehler auf 0
End:  L     #Datenwort_Nummer           // bei Ergebnis <> 0 liegt eine Störmeldungr vor
      L     0
      <>I   
      SPBN  M004                        // Sprung nach M004, wenn keine Störmeldung vorliegt
      L     1                           // Bitnummer mit 1 vorbelegen
      T     #Bitnummer                  // Bitnummer fängt normalerweise bei 0 an
//                                      // die Bildernummer aber bei 1
      L     DBW [#Zeiger]               // kopiere den Inhalt des  DB's
      T     #Hilfsvar_DaBa              // in eine Hilfsvariable
      L     16                          // Wort = 16 Bit
M003: T     #zaehler                    // INT
      L     #Hilfsvar_DaBa              // WORD
      SRW   1                           // Schiebe den Inhalt der Hilsvariable um 1 nach rechts
      SPP   Ende                        // War das rausgeschobene Bit = 1, dann Sprung aus der Schleife
      T     #Hilfsvar_DaBa              // Sonst neu abspeichern
      L     #Bitnummer                  // INT
      L     1                           // Bitnummer um 1 erhöhen
      +I    
      T     #Bitnummer
      L     #zaehler
      LOOP  M003                        // Schleife solange, bis #zaehler auf 0
M004: L     0                           // Nur, wenn keine Störmeldung ansteht 
      T     #Datenwort_Nummer           // Datenwortnummer und Bitnummer mit 0 belegen
      T     #Bitnummer
Ende: L     #Datenwort_Nummer           // Bildnummer berechnen
      L     16                          // (Datenwortnummer * 16) + Bitnummer
      *I    
      L     #Bitnummer
      +I    
      T     #Meldungsnummer             // INT
      T     "AB8-Fehler-Bit-Codierung"  // Ausgangsbyte zeigt Störmeldungsnummer bitcodiert an

Nochmals danke für eure Hilfe.
 
wenn du jetzt noch den deklarationsteil postest wärs schön.

oder erzeug mal eine quelle aus dem baustein.
 
Also gut, hier die Quelle.

Code:
FUNCTION_BLOCK "FB-8-Bit-Fehlercodierung"
TITLE =
VERSION : 0.1
 
VAR
  Datenwort_Nummer : WORD ; 
  zaehler : INT ; 
  Bitnummer : INT ; 
  Hilfsvar_DaBa : WORD ; 
  Meldungsnummer : INT ; 
END_VAR
VAR_TEMP
  Zeiger : DWORD ; 
END_VAR
BEGIN
NETWORK
TITLE =
      AUF   "DB-Meldungen-Stoer"; 
      L     P#0.0; // Störmeldungen beginnen bei DBW0
      T     #Zeiger; // DWORD
      L     0; 
      T     #Datenwort_Nummer; // WORD
      L     7; // Anzahl der Wörter mit Störmeldungen im Störmelde-DB
M001: T     #zaehler; // INT
      L     DBW [#Zeiger]; // Lade Datenwort
      L     0; // Lade 0
      ==I   ; // keine Störmeldung !!!
      SPB   M002; 
      SPA   End; // wenn eine Störmeldung vorliegt, wird hier aus der Schleife gesprungen
M002: L     #Datenwort_Nummer; // 
      L     1; // Datenwortnummer um 1 erhöhen
      +I    ; 
      T     #Datenwort_Nummer; 
      L     #Zeiger; // Zeiger um 2 erhöhen
      L     P#2.0; // zeigt auf das nächste Datenwort
      +D    ; 
      T     #Zeiger; 
      L     #zaehler; 
      LOOP  M001; // Schleife solange, bis #zaehler auf 0
End:  L     #Datenwort_Nummer; // bei Ergebnis <> 0 liegt eine Störmeldungr vor
      L     0; 
      <>I   ; 
      SPBN  M004; // Sprung nach M004, wenn keine Störmeldung vorliegt
      L     1; // Bitnummer mit 1 vorbelegen
      T     #Bitnummer; // Bitnummer fängt normalerweise bei 0 an
//                                      // die Bildernummer aber bei 1
      L     DBW [#Zeiger]; // kopiere den Inhalt des  DB's
      T     #Hilfsvar_DaBa; // in eine Hilfsvariable
      L     16; // Wort = 16 Bit
M003: T     #zaehler; // INT
      L     #Hilfsvar_DaBa; // WORD
      SRW   1; // Schiebe den Inhalt der Hilsvariable um 1 nach rechts
      SPP   Ende; // War das rausgeschobene Bit = 1, dann Sprung aus der Schleife
      T     #Hilfsvar_DaBa; // Sonst neu abspeichern
      L     #Bitnummer; // INT
      L     1; // Bitnummer um 1 erhöhen
      +I    ; 
      T     #Bitnummer; 
      L     #zaehler; 
      LOOP  M003; // Schleife solange, bis #zaehler auf 0
M004: L     0; // Nur, wenn keine Störmeldung ansteht 
      T     #Datenwort_Nummer; // Datenwortnummer und Bitnummer mit 0 belegen
      T     #Bitnummer; 
Ende: L     #Datenwort_Nummer; // Bildnummer berechnen
      L     16; // (Datenwortnummer * 16) + Bitnummer
      *I    ; 
      L     #Bitnummer; 
      +I    ; 
      T     #Meldungsnummer; // INT
      T     "AB8-Fehler-Bit-Codierung"; // Ausgangsbyte zeigt Störmeldungsnummer bitcodiert an
END_FUNCTION_BLOCK

Hoffentlich isses nu gut. :rolleyes:
 
habs eben mal getestet. so ganz scheint es aber nicht zu klappen.
wenn in dbw0 ein bit high ist klappts nicht.
ab dbw2 gehts.
 
Also ich muss sagen, daß das Forum hier ne echt klasse Sache ist.
Sorry, mit Dw0 hab ichs nicht getestet.
Jetzt funktionierts aber. (Hoff ich )
Code:
FUNCTION_BLOCK "FB-8-Bit-Fehlercodierung"
TITLE =
VERSION : 0.1
 
VAR
  Datenwort_Nummer : WORD ; 
  zaehler : INT ; 
  Bitnummer : INT ; 
  Hilfsvar_DaBa : WORD ; 
  Meldungsnummer : INT ; 
END_VAR
VAR_TEMP
  Zeiger : DWORD ; 
END_VAR
BEGIN
NETWORK
TITLE =
      AUF   "DB-Meldungen-Stoer"; 
      L     P#0.0; // Störmeldungen beginnen bei DBW0
      T     #Zeiger; // DWORD
      L     0; 
      T     #Datenwort_Nummer; // WORD
      L     7; // Anzahl der Wörter mit Störmeldungen im Störmelde-DB
M001: T     #zaehler; // INT
      L     DBW [#Zeiger]; // Lade Datenwort
      L     0; // Lade 0
      ==I   ; // keine Störmeldung !!!
      SPB   M002; 
      SPA   End; // wenn eine Störmeldung vorliegt, wird hier aus der Schleife gesprungen
M002: L     #Datenwort_Nummer; // 
      L     1; // Datenwortnummer um 1 erhöhen
      +I    ; 
      T     #Datenwort_Nummer; 
      L     #Zeiger; // Zeiger um 2 erhöhen
      L     P#2.0; // zeigt auf das nächste Datenwort
      +D    ; 
      T     #Zeiger; 
      L     #zaehler; 
      LOOP  M001; // Schleife solange, bis #zaehler auf 0
End:  L     1; // Bitnummer mit 1 vorbelegen
      T     #Bitnummer; // Bitnummer fängt normalerweise bei 0 an
//                                      // die Bildernummer aber bei 1
      L     DBW [#Zeiger]; // kopiere den Inhalt des  DB's
      T     #Hilfsvar_DaBa; // in eine Hilfsvariable
      L     16; // Wort = 16 Bit
M003: T     #zaehler; // INT
      L     #Hilfsvar_DaBa; // WORD
      SRW   1; // Schiebe den Inhalt der Hilsvariable um 1 nach rechts
      SPP   Ende; // War das rausgeschobene Bit = 1, dann Sprung aus der Schleife
      T     #Hilfsvar_DaBa; // Sonst neu abspeichern
      L     #Bitnummer; // INT
      L     1; // Bitnummer um 1 erhöhen
      +I    ; 
      T     #Bitnummer; 
      L     #zaehler; 
      LOOP  M003; // Schleife solange, bis #zaehler auf 0
      L     0; // Nur, wenn keine Störmeldung ansteht 
      T     #Datenwort_Nummer; // Datenwortnummer und Bitnummer mit 0 belegen
      T     #Bitnummer; 
Ende: L     #Datenwort_Nummer; // Bildnummer berechnen
      L     16; // (Datenwortnummer * 16) + Bitnummer
      *I    ; 
      L     #Bitnummer; 
      +I    ; 
      T     #Meldungsnummer; // INT
      T     "AB8-Fehler-Bit-Codierung"; // Ausgangsbyte zeigt Störmeldungsnummer 
END_FUNCTION_BLOCK

Der Sprung bei "End" war das Problem. Hab dort die Datenwortnummer auf 0 verglichen und bin bei 0 gesprungen. Das hab ich nun korrigiert.
 
Zurück
Oben