Handling Störmeldungen WinCC flexibel

Markus

Administrator
Teammitglied
Beiträge
6.301
Reaktionspunkte
2.317
Zuviel Werbung?
-> Hier kostenlos registrieren
hallo,

wie werden störungen eurer meinung nach vernünftig gehandelt?

also bisher habe ich das meist so gelöst:

Störmeldebereich mit einigen bool.
wenn eine störung auftritt setzt die sps das entsprecheden bit und in der visu erscheint der text.
wenn die taste "störung quittieren" gedrückt wird, dann wird der ganze bereich mit den störbits wieder mit "0" überschrieben.


funktioniert so ganz gut, aber ich finde es unnötig zusätzlich zur "ACK" taste bei der meldung noch eine weitere taste zu haben/drücken zu müssen.


jetzt habe ich mir in winccflexible mal die möglichkeit angeschaut störmeldebits in der sps von der visu zu resetten. d.h. wenn ich die ack taste drücke verschwindet nicht nur der text, es wird auch das bit in der sps gelöscht.

aber das handling dafür finde ich recht doof, oder ich habe es vielleicht nicht richtig verstanden...


meine lösung: (die ich für zu umständlich halte)

Code:
      L     "test".RESET                // Variable in der die Resetbits sind
      L     MW    42                    // Wert letzter Zyklus
      <>I   
      SPBN  RES1
      L     "test".ERROR                // Variable in der die Störmeldungen sind
      L     "test".RESET
      XOW                               // Störungsbit + Resetbit ? 
      L     "test".ERROR
      UW    
      T     "test".ERROR                // Wenn beide "1" dann Störung löschen
RES1: NOP   0
      L     "test".RESET                // Wert letzter Zyklus aktualisieren
      T     MW    42

Das muss doch einfacher gehen?!
Bitte sagt mir das ichs nicht begriffen habe und es wesentlich einfacher geht.




Nur so - Ansteuerung der Störbits:

Code:
      U     M     40.0                  // Störung blablabla
      S     DB1.DBX    1.0
      U     M     40.1                  // Störung blablabla
      S     DB1.DBX    1.1
      U     M     40.2                  // Störung blablabla
      S     DB1.DBX    1.2
 
Störmeldungen

Hi,
ist da die Handhabung nicht wie beim ProTool? D.h. jede Störmeldung
hat auch ein entspr. Quittierbit für die SPS. Wenn man ACK betätigt, wird
halt dieses Bit gesetzt, das Weitere macht dein Programm, genauso wie
du es machst (oberes Beispiel). Und das Quittierbit muss auch
resetet werden, oder?

Gruss:Vladi
 
Zuviel Werbung?
-> Hier kostenlos registrieren
meine das quittier bit wird von der visu resetet.
deswegen auch die zyklische abfrage auf wertänderung - weil die visu ja erst 1-2s später resetet...

aber die idee ist gut, wenn ich das quittierbit auch in der sps resete, dann kann ich mir die 7 zeilen mit der wertänderung sparen...

finde das handling aber immer noch beschissen, muss für so eine blöde quittierfunktion seitenweise code schreiben wenn ich nicht gerade nur 16 störungen habe.

wäre doch viel einfacher wenn ich der quittierfunktion in der visu das eigene störbit übergeben könnte. dann wird beim drücken von "ack" genau dieses resetet und gut ist...
das wäre praktikabel und schnell angebunden.

die anbindung ist sowieso der letzte dreck, bereichzeiger gibts nicht mehr und wenn ich die visu symbolisch haben will, dann habe ich die einzelnen störmeldungen nicht mehr symbolisch - siehe mein beispiel oben. andersrum ist es wohl das kleinere übel wenn ich die meldungen im db bitweise symbolisch mache und in der visu worte anbinde die es nicht gibt.

man was könnte ich sch wieder kotzen! es gibt unter den unzähligen systemen aus den letzten jahren auch viele von siemens. aber bei winccflex könnte man wieder meinen dieses vertrottelte entwicklerpack von siemens macht es zum ersten mal!

:sw9: :sm8: :sw22:
 
okn also wenn man es so macht wie vladi schreibt kann man den code etwas kürzen.

Code:
      L     "test".ERROR
      L     "test".RESET
      XOW   
      L     "test".ERROR                // TAK
      UW    
      T     "test".ERROR
      L     0
      T     "test".RESET


aber die funktion von diesem quittiersystem habe ich jetzt immer noch nicht begriffen.

also szenario:

1. störmeldekontakt geht weg

un störmeldekontakt
s störung_1


2. in wincc flexible kommte eine meldung mit dem status "k" (kommend)


3. der bediener drückt auf quittieren, ohne der fehler selbst zu beseitigen
(das macht ja jeder die ersten 100 mal)


4. winccflexible setzt das quittierbit auf "1"
gleichzeitig wird der status der störung auf "kq" (kommend-quittiert) geändert.


5. Das Bit wird in obigem programm ausgewertet und setzt das bit störung_1 zurück.


6. im nächsten sps zyklus wird das bit störung_1 aber wieder auf "1" gesetzt. winccflexible zeigt aber wieterhin status "kq" an und ein weiteres drücken der "ack" taste setzt das quittierbit nicht erneut.

so nun sagt winccflex die störung sei quittiert, aber sie steht noch an, und ich bekomme das störbit in der sps nicht mehre resetet.

also wenn ich die störung behebe und der störmeldekontakt wieder da ist, dann bleibt störung_1 ja auf "1" weil das bit gesetzt wurde.
da beim drücken auf die "ack" taste kein weiteres mal das quittierbit gesetzt wird kann ich mit dieser funktion die störung quasi nie zurücksetzten!

muss ich jetzt etwa sps-seitig noch ein handling schreiben das mir das quittierbit speichert und das störbit erst dann resetet wenn die störung behoben wurde?

mal erhrlich was soll der schwachsinn?
ich denke ich bin nicht der einzige der störmeldungen projektiert.
bisher habe ich das immer anders gemacht, siehe oben.
jetzt dachte ich "machen wir es mal professionell" mit dieser coolen quittierbit funktion.
macht das von euch wer erfolgreich in der praxis?

wenn ja, dann sagt mir bitte das ich zu doof dazu bin und das meine ansicht über diese beschissene undurchdachte unnötig komplizierte funktion vollig falsch ist.

also macht es hier jeder ala old school und löscht den störspeicher beim quittieren mit 0 ab, oder setzt irgendjemand diese tolle quittierbitfunktion ein?
 
Ich mach das mit jeder Störmeldung extra, hab das einen kleinen Baustein für Störmeldungen, da gehen alle drei Bit (Störbit, Quitt-OP, Quitt-SPS) rein. Die Ack-Taste am OP geht (so vorhanden) zentral in die Steuerung und resetet alle Störungen. Am OP wird ja nur die resettet, die gerade im Bild ist, also muß der Bediener alle einzeln resetten, bei einem TP gibts kein zentrales Ack, von Haus aus. Dafür bekommt der Bediener einen extra Button, Reset All, dann werden über SPS-Quitt alle Störungen vom OP geputzt. Der Stör-FC ist recht übersichtlich, das werden die Bits entsprechend gesetzt und rückgesetzt.

Code:
FUNCTION FC 110 : VOID
TITLE =Störmeldung
//
{ S7_language := '7(1) Deutsch (Deutschland)  12.01.2007  12:07:37' }
AUTHOR : Ralle
FAMILY : SYSTEM
NAME : STM_SYS
VERSION : 1.3


VAR_INPUT
  Stoermeldung : BOOL ;    
  Freigabe : BOOL ;    
  Ack : BOOL ;    //Quitt Fehler
END_VAR
VAR_IN_OUT
  Stoerbit : BOOL ;    
  Quittierbit_OP : BOOL ;    
  Quittierbit_SPS : BOOL ;    
END_VAR
BEGIN
NETWORK
TITLE =Funktion zum auswerten der Störungen

      UN    #Freigabe; 
      R     #Stoerbit; 
      R     #Quittierbit_OP; 
      R     #Quittierbit_SPS; 
      BEB   ; 
NETWORK
TITLE =Störung

      U(    ; 
      U(    ; 
      O     #Quittierbit_OP; 
      O     #Quittierbit_SPS; 
      )     ; 
      R     #Stoerbit; 
      U     #Stoermeldung; 
      S     #Stoerbit; 
      U     #Stoerbit; 
      )     ; 
      NOT   ; 
      UN    #Stoermeldung; 
      UN    #Quittierbit_SPS; 
      R     #Quittierbit_OP; 
NETWORK
TITLE =Ack

      U     #Ack; 
      =     #Quittierbit_SPS; 
END_FUNCTION
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Markus,

..
5. Das Bit wird in obigem programm ausgewertet und setzt das bit störung_1 zurück.

6. im nächsten sps zyklus wird das bit störung_1 aber wieder auf "1" gesetzt...

Ich glaube, hier liegt der Hund begraben. Das eigentliche Störbit darf nicht zurückgesetzt werden, solange die Störung noch ansteht!


Und so mache ich es:

Code:
FUNCTION "ALARM_QUITT" : VOID
TITLE =
VERSION : 0.1
 
VAR_INPUT
  EVENT : BOOL ; //Signal, welches die Störung verursacht (1==Störung)
  EVENT_NEGIEREN : BOOL ; //Signal vom Eingang "EVENT" wird negiert (0==Störung)
  QUITT_PLS : BOOL ; //Quittierungs-Signal aus SPS-Programm
  STOERMELDUNG : POINTER ; //Störmeldebit im Störmeldebereich
  STOERMELDEBEREICH : POINTER ; //Störmeldebereich
  QUITTIERMELDEBEREICH_HMI : POINTER ; //Quittierbereich von HMI (wird von HMI gesetzt)
  QUITTIERMELDEBEREICH_SPS : POINTER ; //Quittierbereich von SPS (wird von SPS gesetzt)
END_VAR
VAR_TEMP
  TEMP_AR1 : DWORD ; 
  OFFSET : DWORD ; //Adresse des Störmeldebits == Offset in allen Datenbereichen
  TEMP_INT : INT ; 
END_VAR
BEGIN
NETWORK
TITLE =
 
//****************************************************************************
//*** AR1 sichern
//****************************************************************************
      TAR1  #TEMP_AR1; 
      SET   ; 
      SAVE  ; 
 
//****************************************************************************
//*** AR2 auf Störmeldebit und DB öffnen
//****************************************************************************
      L     P##STOERMELDUNG; 
      LAR2  ; 
      L     W [AR2,P#0.0]; 
      T     #TEMP_INT; 
      AUF   DB [#TEMP_INT]; 
      L     D [AR2,P#2.0]; 
      LAR2  ; 
 
//****************************************************************************
//*** Bitnummer im Störmeldebereich ermitteln
//****************************************************************************
      L     P##STOERMELDEBEREICH; 
      LAR1  ; 
      L     D [AR1,P#2.0]; 
      LAR1  ; 
      UD    DW#16#FFFFFF; // Bereichskennung eliminieren
      L     L#-1; 
      *D    ; 
      TAR2  ; 
      UD    DW#16#FFFFFF; // Bereichskennung eliminieren
      +D    ; 
      T     #OFFSET; // Bit-Offset ohne Bereichskennung
 
//****************************************************************************
//*** Störung von SPS aus zurücksetzen und an HMI quittieren
//****************************************************************************
      U     #QUITT_PLS; 
      R      [AR2,P#0.0]; 
      U     #QUITT_PLS; 
      L     P##QUITTIERMELDEBEREICH_SPS; 
      LAR1  ; 
      L     D [AR1,P#2.0]; 
      LAR1  ; 
      L     #OFFSET; 
      +AR1  ; 
      =      [AR1,P#0.0]; 
 
//****************************************************************************
//*** Störung von HMI aus zurücksetzen
//****************************************************************************
      L     P##QUITTIERMELDEBEREICH_HMI; 
      LAR1  ; 
      L     D [AR1,P#2.0]; 
      LAR1  ; 
      L     #OFFSET; 
      +AR1  ; 
      U      [AR1,P#0.0]; 
      R      [AR2,P#0.0]; 
 
//****************************************************************************
//*** Störung setzen
//****************************************************************************
      X     #EVENT; 
      X     #EVENT_NEGIEREN; 
      S      [AR2,P#0.0]; 
 
//****************************************************************************
//*** AR1-Register wiederherstellen
//****************************************************************************
      LAR1  #TEMP_AR1; 
      BE    ; 
 
END_FUNCTION

Die Quittiermeldebereiche sind nichtsymbolische Bereiche im DB (macht Änderungen erheblich einfacher). Der Störmeldebereich ist natürlich mit Symbolen angelegt.
Wichtig ist dass das Setzen der Störung Vorrang hat!

Gruß, Onkel
 
danke euch beiden soweit.
aber könnte das nich einfach sein? wieso darf ich das bit nicht reseten?
wieso wird das quittierbit nicht immer wieder beim drücken von ack gesetzt solange die störung noch ansteht?


danke für die bausteine, aber jede störung für sich?
darin sehe ich einen extrem großen aufwand, oder schätze ich das falsch ein?

@dagobert
wenn du sagst das du die störmeldebits symbolisch anlegst, dann hast du die bereiche in winccflex aber nicht symbolisch, oder gibts da auch einen trick?




also meine bisherige lösung sah einfach so aus



u bedingung_störung_1
s störung_1(dbx0.0)

u bedingugn_störung_2
s störung_3(dbx0.1)

^^diese störbits werden irgendwo im programm z.b. als inout-parameter oder wahlweise zentral im stör fb gesetzt.



// sammelstörung?

l dbd 0
l dbd 4
ow
l dbd 8
ow
l dbd 12
ow
l l#0
<>d
= störung aktiv



// reset

u taste quittieren
spbn res0

l l#0
t dbd 0
t dbd 4
t dbd 8
t dbd 12

res0: nop 0



^^^^^^^^ ist das zu naiv?
da ich in dem komplexen handling mit den 3 bits pro störung keinen zusätzlichen nutzen (geschweige denn eine vereinfachung) feststellen kann werde ich das wohl wieder so machen...
 
Hallo Markus,

danke euch beiden soweit.
aber könnte das nich einfach sein? wieso darf ich das bit nicht reseten?
wieso wird das quittierbit nicht immer wieder beim drücken von ack gesetzt solange die störung noch ansteht?...
Gute Frage, habe jedoch keine Antwort dafür. Aber wenn man's weiß ist es doch kein Problem.

..danke für die bausteine, aber jede störung für sich?..
Der Vorteil ist dass der Bediener weiß, was er quittiert. Bei mehreren Störmeldungen und Sammelquittierung weiß man das meist nicht so richtig. Bei WnCCFlex gibt es auch die Möglichkeit, die Meldungen zu Quittiergruppen zusammen zu fassen. Dann werden wohl alle anstehenden Meldungen einer Gruppe zusammen quittiert. Habe es jedoch noch nicht getestet.

..darin sehe ich einen extrem großen aufwand, oder schätze ich das falsch ein?..
Naja, es hält sich in Grenzen. Bei meiner Lösung mit den Pointern muss man zumindest nicht jedes einzelne Quittierbit anfassen. Das sehe ich schon mal als großen Vorteil an.

..
@dagobert
wenn du sagst das du die störmeldebits symbolisch anlegst, dann hast du die bereiche in winccflex aber nicht symbolisch, oder gibts da auch einen trick?..
In WinCCFlex habe ich nur die Meldenummern (Bitmeldungen).

..^^^^^^^^ ist das zu naiv?
da ich in dem komplexen handling mit den 3 bits pro störung keinen zusätzlichen nutzen (geschweige denn eine vereinfachung) feststellen kann werde ich das wohl wieder so machen...
Bei Geräten, wo man eine ordentlich Quittiertaste hatte, hatte ich es auch immer so gemacht, zumindest so ähnlich.


Gruß, Onkel
 
Zuviel Werbung?
-> Hier kostenlos registrieren
also ich handhabe da so, das ich der ack-taste ein bit zuordne.
dieses bit setzt im ag die störung zurück.

ein sammelreset am op projektiere ich nicht, da ich möchte, dass der bediener auch alle störungen die aufgelaufen sind sieht.

kommt zwar öfter vor, dass die jungs einfach blind alle störungen quittieren ohne die zu lesen, aber da kann ich ja dann nix für.
 
also ich handhabe da so, das ich der ack-taste ein bit zuordne.
dieses bit setzt im ag die störung zurück.

ein sammelreset am op projektiere ich nicht, da ich möchte, dass der bediener auch alle störungen die aufgelaufen sind sieht.

kommt zwar öfter vor, dass die jungs einfach blind alle störungen quittieren ohne die zu lesen, aber da kann ich ja dann nix für.

du redest jetzt aber nur von op´s die eine hw quittier taste haben, oder?


habe inzwischen eine für mich halbwegs praktikable lösung gefunden.
bin aber noch nicht ganz zufrieden, werden mich später weiter damit beschäftigen, muss nur schnell noch was anderes erledigen...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
du redest jetzt aber nur von op´s die eine hw quittier taste haben, oder?
ja. grundsätzlich erstmal schon.

beim tp bin ich mir jetzt nicht sicher wie das war. wir setzen fast nur panels mit tasten ein.
aber wenn man das quittierungswort auswertet und dieses auf ein bit legt, sollte das eigentlich den gleichen effekt haben.
 
so jetzetle... :ROFLMAO:

ich denke ich habe ein gutes ergebniss erreicht:

in winccflexible wird wie gehabt jeder störmeldung aus einer variable ein bit zugewiesen. und je ein bit aus einer anderen variable bei "quittvariable lesen"


der code im fb sieht im groben so aus:

Code:
           L     "test".ERROR_SPS            // Eingehende Fehler (SPS) 
      L     "test".ERROR_VISU
      OW                                // Selbsthaltung
      T     "test".ERROR_VISU           // Fehlerbit für VISU
      L     "test".RESET
      UW    
      T     "test".RESET                // Quittierungsbit erst reseten wenn der Fehler weg ist
      L     "test".ERROR_VISU
      XOW                               // Fehlerbit + Quittierungsbit setzten Fehlerbit zurück
      L     "test".ERROR_SPS
      OW                                // Aber nicht wenn der Fehler noch ansteht!
      L     "test".ERROR_SPS
      UW                                // Wenn der Fehler nicht mehr ansteht wird der Status "gegangen" an die VISU weitergegeben
      T     "test".ERROR_VISU
      L     0                           // Fehlersignale von der SPS auf 0 schreiben 
      T     "test".ERROR_SPS            // Wenn sie noch aktiv sind kommen sie im nächsten Zyklus wieder rein

in wirklickeit gibt es das symbol ERROR_SPS nicht, dieser bereich ist bitweise symbolisch.

im sps programm kann ich nun an beliebigen stellen die bits von ERROR_SPS setzen oder mit "=" schreiben, wie es gerade kommt...
den rest machen die paar zeilen code da oben.

weiter unten im fb werden dann noch alle ERROR_VISU verodert und bei ungleich "0" gibts ne sammelstörung.

habe jetzt alles überall symbolisch und habe die einfachheit und maximale flexibilität die ich haben will.

danke für eure bausteine, der zündende funke kahm von dort... :)



...mal abwarten wie lange es geht bis wir den code auf gewissen supportseiten wieder finden... :cool:

abschliessend kann ich nur sagen:
"Man muss WinCC flexible nicht verstehen, man muss nur stärker sein als WinCC flexible!"



// edit 26.01.07 code geändert
status "gegangen" wird an visu weitergegeben
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Hab mich auch schon mit der Thematik auseinandergesetzt. Dabei ist folgende Lösung rausgekommen:

WinCCflexible arbeitet mit Meldeklassen (Fehler, Meldungen, System usw.). Bei diesen lässt sich nicht einstellen, ob die Meldungen quittiert werden müssen oder nicht!
Ich erstelle eine neue Meldeklasse "Alarm", bei der ich die Quittierpflicht ausschalte. Meine Störmeldungen werden nun alle der Meldeklasse "Alarm" zugeordnet. Damit ist das Thema SPS-Quittierung vom Tisch.

Störmeldungen, welche wirkich vom Bediener quittiert werden müssen, werden auf der SPS mit SR-Gliedern programmiert.

Markus schrieb:
ich denke ich habe ein gutes ergebniss erreicht:

in winccflexible wird wie gehabt jeder störmeldung aus einer variable ein bit zugewiesen. und je ein bit aus einer anderen variable bei "quittvariable lesen"

Achtung: "Quittiervariable lesen" ist die Variable, welche das Bediengerät beschreibt, wenn am OP die Taste "ACK" gedrückt wird. Das Quittierbit von der SPS ist üblicherweise die Variable "Quittiervariable schreiben" - hier lässt sich nur die Störmeldevariable auswählen (zumindest wenn man als Störmeldevariable ein INT-Array verwendet).


Bei ProTool hab ich es immer so gelöst:
z.B. 10 Wörter Störmeldebereich (ab DB21.DBW0)
10 Wörter Quittierung SPS (ab DB21.DBW20)

Die Quittierung wurde immer doppelwortweise beschrieben:
Code:
L    DB21.DBD    0
INVD
T    DB21.DBD   20
 
L    DB21.DBD    4
INVD
T    DB21.DBD   24
usw.


Ach ja: Die Taste ACK am OP hat eigentlich nur die Funktion, das Popup-Fenster am Bediengerät wegzuklicken. Seit einiger Zeit ist das Popup-Fenster generell nicht mehr vorhanden.


mfg
Maxl
 
@maxl

ich habe bald nen fertigen fb, dann poste ich den mal.
aber erst am montag oder vielleicht morgen - drausen wartet das wochenende mit bier und weibern auf mich...


unterschied zwischen quitt lesen und schreiben ist bekannt.
ich will (und kann inzwischen) mit der ack taste der visu genau das störbit zurücksetzten dessen störung im fenster markiert ist.

die ack taste ist also (zumindest in meinem fall) nicht nur zum das popup wegklicken, sondern auch um das störbit in der sps zu reseten. es gibt keine weiteren taster oder buttons...

die pupups gibts bei flexbile nach wie vor und zwar mit wesentlich mehr möglichkeiten.
mach die anzeige(n) in die seite vorlage und setze bei den bildern wo die einblendung gewüsncht ist das bit "vorlage verwenden".

nebenbei - dieses "frame" welches man noch von prottol kennt, verwendet man bei einer sauberen projektierung mit flexible auch nicht mehr. man macht die dinge die auf allen seiten sein sollen auf die vorlage...
hat viele vorteile, zb wenn man eine seit mit einer kurve drucken will und den restlichen kram nicht mit auf dem papier haben will...
 
@Markus

Den Bustein nutze ich ja nicht nur zum quittieren einer Störung, sondern auch zum Melden dieser Störung, ein Störbit braucht man ja eh. Es gibt noch einen Baustein mit Zeitverzögerung, per Takt und Hochzählen in 100ms-Schritten. Außerdem sind NW2 und 3 in jedem Baustein, der einen Fehler meldet drin. muß halt immer 3 Bits an die Bausteine antragen. Ich habe die Bits voll symbolisch, STM_001, SPS-Quitt_001, OP_Quitt_001 usw., dadurch kann man Störnummern ganz einfach symbolisch ändern.
Störungen, deren Ursache noch besteht, bleiben bestehen. Mit Pointern wollte ich nicht so sehtr rumhantieren, außerden wird der BAustein oft verwendet, da liegt dann schon "in der Kürze die W..." :ROFLMAO:, auch wegen der Zykluszeit.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
...außerden wird der BAustein oft verwendet, da liegt dann schon "in der Kürze die W..." :ROFLMAO:, auch wegen der Zykluszeit.

jepp! so sehe ich das auch, und deshalb ist mir die lösung mit einem baustein pro meldung zuviel... - abgesehen davon das ich nicht will das der baustein oft verwendet wird (tipperei)...


ist noch nicht sauber getestet - das mache ich heute wirklich nicht mehr, aber hier das erste ergebniss:


// Aufruf

Code:
      U     M     40.0            // Bedingung die eine Störung setzt
      S     "Stoerung".NR_1
 
      U     M     40.1
      L     S5t#5s
      SE    T10                   // Wenn es benötigt wird mit der Verzögerung      
      S     "Stoerung".NR_2
 
      U     M     40.2           // Bedingung die eine Störung mit = ansteuert
      =     "Stoerung".NR_3
 
      CALL  "Stoerung_Meldung" , "Stoerung"


// Quelle FB90 (Stoerung_Meldung)

Code:
FUNCTION_BLOCK "Stoerung_Meldung"
TITLE =
AUTHOR : 'M.Uhl'
VERSION : 0.1
 
VAR
  AKTIV : BOOL ; 
  res_01 : BOOL ; 
  res_02 : BOOL ; 
  res_03 : BOOL ; 
  res_04 : BOOL ; 
  res_05 : BOOL ; 
  res_06 : BOOL ; 
  res_07 : BOOL ; 
  NR_9 : BOOL ; 
  NR_10 : BOOL ; 
  NR_11 : BOOL ; 
  NR_12 : BOOL ; 
  NR_13 : BOOL ; 
  NR_14 : BOOL ; 
  NR_15 : BOOL ; 
  NR_16 : BOOL ; 
  NR_1 : BOOL ; 
  NR_2 : BOOL ; 
  NR_3 : BOOL ; 
  NR_4 : BOOL ; 
  NR_5 : BOOL ; 
  NR_6 : BOOL ; 
  NR_7 : BOOL ; 
  NR_8 : BOOL ; 
  NR_25 : BOOL ; 
  NR_26 : BOOL ; 
  NR_27 : BOOL ; 
  NR_28 : BOOL ; 
  NR_29 : BOOL ; 
  NR_30 : BOOL ; 
  NR_31 : BOOL ; 
  NR_32 : BOOL ; 
  NR_17 : BOOL ; 
  NR_18 : BOOL ; 
  NR_19 : BOOL ; 
  NR_20 : BOOL ; 
  NR_21 : BOOL ; 
  NR_22 : BOOL ; 
  NR_23 : BOOL ; 
  NR_24 : BOOL ; 
  NR_41 : BOOL ; 
  NR_42 : BOOL ; 
  NR_43 : BOOL ; 
  NR_44 : BOOL ; 
  NR_45 : BOOL ; 
  NR_46 : BOOL ; 
  NR_47 : BOOL ; 
  NR_48 : BOOL ; 
  NR_33 : BOOL ; 
  NR_34 : BOOL ; 
  NR_35 : BOOL ; 
  NR_36 : BOOL ; 
  NR_37 : BOOL ; 
  NR_38 : BOOL ; 
  NR_39 : BOOL ; 
  NR_40 : BOOL ; 
  NR_57 : BOOL ; 
  NR_58 : BOOL ; 
  NR_59 : BOOL ; 
  NR_60 : BOOL ; 
  NR_61 : BOOL ; 
  NR_62 : BOOL ; 
  NR_63 : BOOL ; 
  NR_64 : BOOL ; 
  NR_49 : BOOL ; 
  NR_50 : BOOL ; 
  NR_51 : BOOL ; 
  NR_52 : BOOL ; 
  NR_53 : BOOL ; 
  NR_54 : BOOL ; 
  NR_55 : BOOL ; 
  NR_56 : BOOL ; 
  NR_73 : BOOL ; 
  NR_74 : BOOL ; 
  NR_75 : BOOL ; 
  NR_76 : BOOL ; 
  NR_77 : BOOL ; 
  NR_78 : BOOL ; 
  NR_79 : BOOL ; 
  NR_80 : BOOL ; 
  NR_65 : BOOL ; 
  NR_66 : BOOL ; 
  NR_67 : BOOL ; 
  NR_68 : BOOL ; 
  NR_69 : BOOL ; 
  NR_70 : BOOL ; 
  NR_71 : BOOL ; 
  NR_72 : BOOL ; 
  NR_89 : BOOL ; 
  NR_90 : BOOL ; 
  NR_91 : BOOL ; 
  NR_92 : BOOL ; 
  NR_93 : BOOL ; 
  NR_94 : BOOL ; 
  NR_95 : BOOL ; 
  NR_96 : BOOL ; 
  NR_81 : BOOL ; 
  NR_82 : BOOL ; 
  NR_83 : BOOL ; 
  NR_84 : BOOL ; 
  NR_85 : BOOL ; 
  NR_86 : BOOL ; 
  NR_87 : BOOL ; 
  NR_88 : BOOL ; 
  NR_105 : BOOL ; 
  NR_106 : BOOL ; 
  NR_107 : BOOL ; 
  NR_108 : BOOL ; 
  NR_109 : BOOL ; 
  NR_110 : BOOL ; 
  NR_111 : BOOL ; 
  NR_112 : BOOL ; 
  NR_97 : BOOL ; 
  NR_98 : BOOL ; 
  NR_99 : BOOL ; 
  NR_100 : BOOL ; 
  NR_101 : BOOL ; 
  NR_102 : BOOL ; 
  NR_103 : BOOL ; 
  NR_104 : BOOL ; 
  NR_121 : BOOL ; 
  NR_122 : BOOL ; 
  NR_123 : BOOL ; 
  NR_124 : BOOL ; 
  NR_125 : BOOL ; 
  NR_126 : BOOL ; 
  NR_127 : BOOL ; 
  NR_128 : BOOL ; 
  NR_113 : BOOL ; 
  NR_114 : BOOL ; 
  NR_115 : BOOL ; 
  NR_116 : BOOL ; 
  NR_117 : BOOL ; 
  NR_118 : BOOL ; 
  NR_119 : BOOL ; 
  NR_120 : BOOL ; 
  VISU_001_016 : WORD ; 
  VISU_017_032 : WORD ; 
  VISU_033_048 : WORD ; 
  VISU_049_064 : WORD ; 
  VISU_065_080 : WORD ; 
  VISU_081_096 : WORD ; 
  VISU_097_112 : WORD ; 
  VISU_113_128 : WORD ; 
  RESET_001_016 : WORD ; 
  RESET_017_032 : WORD ; 
  RESET_033_048 : WORD ; 
  RESET_049_064 : WORD ; 
  RESET_065_080 : WORD ; 
  RESET_081_096 : WORD ; 
  RESET_097_112 : WORD ; 
  RESET_113_128 : WORD ; 
END_VAR
VAR_TEMP
  SPS : DWORD ; 
  VISU : DWORD ; 
  RESET : DWORD ; 
  LOOP : INT ; 
  Offset : INT ; 
  SM_Aktiv : DWORD ; 
END_VAR
BEGIN
NETWORK
TITLE =Auswertung
//   
      L     L#0; 
      T     #SM_Aktiv; // Überwachung Sammelstörung initialisieren
      L     4; // 4 mal durch die Schleife (4x4 DWORD)
LOOP: T     #LOOP; 
      L     #LOOP; 
      +     -1; // Beginne ab Adresse 0
      L     4; // Ein DWORD pro Durchlauf
      *I    ; 
      SLD   3; // Anpassung Pointerformat
      T     #Offset; 
      L     P##NR_9; 
      LAR1  ; 
      L     #Offset; 
      +AR1  ; 
      L     DID [AR1,P#0.0]; 
      T     #SPS; // Fehlerbits aus dem SPS Programm
      L     P##VISU_001_016; 
      LAR1  ; 
      L     #Offset; 
      +AR1  ; 
      L     DID [AR1,P#0.0]; 
      T     #VISU; // Fehlerbits an die Visu
      L     P##RESET_001_016; 
      LAR1  ; 
      L     #Offset; 
      +AR1  ; 
      L     DID [AR1,P#0.0]; 
      T     #RESET; // Resetbits von der Visu
 
      L     #SPS; // Eingehende Fehler (SPS) 
      L     #VISU; 
      OD    ; // Selbsthaltung
      T     #VISU; // Fehlerbit für VISU
      L     #RESET; 
      UD    ; 
      T     #RESET; // Quittierungsbit erst reseten wenn der Fehler weg ist
      L     #VISU; 
      XOD   ; // Fehlerbit + Quittierungsbit setzten Fehlerbit zurück
      L     #SPS; 
      OD    ; // Aber nicht wenn der Fehler noch ansteht!
      L     #SPS; 
      UD    ; // Wenn der Fehler nicht mehr ansteht wird der Status "gegangen" an die VISU weitergegeben
      T     #VISU; 
      L     #SM_Aktiv; 
      OD    ; 
      T     #SM_Aktiv; // Sammelstörung erfassen
      L     P##NR_9; 
      LAR1  ; 
      L     #Offset; 
      +AR1  ; 
      L     L#0; // Fehlersignale von der SPS auf 0 schreiben 
      T     DID [AR1,P#0.0]; // Wenn sie noch aktiv sind kommen sie im nächsten Zyklus wieder rein
      L     P##VISU_001_016; 
      LAR1  ; 
      L     #Offset; 
      +AR1  ; 
      L     #VISU; // Fehlerbits an die Visu
      T     DID [AR1,P#0.0]; 
      L     P##RESET_001_016; 
      LAR1  ; 
      L     #Offset; 
      +AR1  ; 
      L     #RESET; // Resetbits von der Visu
      T     DID [AR1,P#0.0]; 
      L     #LOOP; 
      LOOP  LOOP; 
      L     #SM_Aktiv; 
      L     L#0; 
      <>D   ; 
      =     #AKTIV; // Sammelstörung ausgeben
END_FUNCTION_BLOCK


// Anbindung WinCC flexible


Störung Nr "1"
Text "Störung-1"
Störvariable "VISU_001_016 : WORD"
Bitnummer "0"
Quittiervariable "RESET_001_016 : WORD"
Bitnummer "0"


Störung Nr "2"
Text "Störung-2"
Störvariable "VISU_001_016 : WORD"
Bitnummer "1"
Quittiervariable "RESET_001_016 : WORD"
Bitnummer "1"

Störung Nr "3"
Text "Störung-3"
Störvariable "VISU_001_016 : WORD"
Bitnummer "2"
Quittiervariable "RESET_001_016 : WORD"
Bitnummer "2"


Meiner Meinung nach die einfachste, komfortabelste und sauberste Lösung. Man könnte jetzt noch die Funktion "Quittieren von der SPS" einbauen...

// edit
ok ar sichern fehlt auch noch...
 
Zuletzt bearbeitet:
Wenn der Baustein so funktioniert, wärs nicht schlecht, Sammelquittierung über extra Taste würde ich auf jeden Fall vorsehen, muß man ja dann nicht unbedingt nutzen. Außerdem würde ich einen extra Baustein für die Störmeldungen vorsehen, keinen Instanz-DB und am FC als Input die max. Anzahl der Störmeldungen, die behandelt werden sollen. Laß mal dein Ergebnis sehen :-D, wenns soweit ist.

PS: Stimmt das so mit deinen Worten für WinCCFlex? Die Belegung ist etwas anders als bei ProTool, nicht drei getrennte Bereiche, zwei sind miteinander vermischt :twisted:. Das Störbit und das "Quittierbit schreiben" (SPS-Quitt) liegen immer uin einem Wort :confused:, find ich saudämlich.

Noch was meckern muß, bin damit mal reingefallen:

Code:
      L     4; // Ein DWORD pro Durchlauf
      *I    ; 
      SLD   3; // Anpassung Pointerformat
geht zwar, besser aber

Code:
      L     4; // Ein DWORD pro Durchlauf
      *ID   ;
      ITD   ; 
      SLD   3; // Anpassung Pointerformat
sonst gibts irgendwann bei großen Datenbausteinen Probleme!
 
Zuletzt bearbeitet:
geht zwar, besser aber

Code:
      L     4; // Ein DWORD pro Durchlauf
      *ID   ;
      ITD   ; 
      SLD   3; // Anpassung Pointerformat

sonst gibts irgendwann bei großen Datenbausteinen Probleme!

ups! wie konnte das passieren? solche speicherverschwendung ist eigentlich garnicht meine art....

Code:
      +     L#-1; // Beginne ab Adresse 0
      SLD   5; // Anpassung Pointerformat // Ein DWORD pro Durchlauf

loop müsste dint sein...

:ROFLMAO: :ROFLMAO: :ROFLMAO:

im test lief der baustein gut, auch getrennte variablen für störung und quittierung geht.
finde das mit dem idb eigentlich eine saubere schnelle sache.

das mit der sps-seitigen quittierung mache ich noch rein...

call fb , stoerung_station_1

call fb , stoerung_station_2

....

s stoerung_station_1.nr_1
 
Zurück
Oben