# Handling Störmeldungen WinCC flexibel



## Markus (26 Januar 2007)

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)


```
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:


```
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
```


----------



## vladi (26 Januar 2007)

*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


----------



## Markus (26 Januar 2007)

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:


----------



## Markus (26 Januar 2007)

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


```
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?


----------



## Ralle (26 Januar 2007)

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.


```
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
```


----------



## Onkel Dagobert (26 Januar 2007)

Hallo Markus,



Markus schrieb:


> ..
> 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:


```
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


----------



## Markus (26 Januar 2007)

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...


----------



## Onkel Dagobert (26 Januar 2007)

Hallo Markus,



Markus schrieb:


> 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.



Markus schrieb:


> ..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.



Markus schrieb:


> ..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.



Markus schrieb:


> ..
> @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).



Markus schrieb:


> ..^^^^^^^^ 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


----------



## volker (26 Januar 2007)

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.


----------



## Markus (26 Januar 2007)

volker schrieb:


> 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.
> ...


 
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...


----------



## Onkel Dagobert (26 Januar 2007)

Hallo Volker,



volker schrieb:


> also ich handhabe da so, das ich der ack-taste ein bit zuordne.
> dieses bit setzt im ag die störung zurück.


Gleicht das nicht einem Sammelreset? Oder wie unterscheidest du die einzelnen Störungen beim quittieren?


Gruß, Onkel


----------



## volker (26 Januar 2007)

Markus schrieb:


> 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.


----------



## volker (26 Januar 2007)

im ag unterscheide ich die nicht. dort werden alle resettet.


----------



## Markus (26 Januar 2007)

so jetzetle...  

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:


```
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...  

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


----------



## Maxl (26 Januar 2007)

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:

```
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


----------



## Markus (26 Januar 2007)

@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 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...


----------



## Ralle (26 Januar 2007)

@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..." , auch wegen der Zykluszeit.


----------



## Markus (26 Januar 2007)

Ralle schrieb:


> ...außerden wird der BAustein oft verwendet, da liegt dann schon "in der Kürze die W..." , 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


```
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)


```
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...


----------



## Ralle (27 Januar 2007)

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 , find ich saudämlich.

Noch was meckern muß, bin damit mal reingefallen:


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


```
L     4; // Ein DWORD pro Durchlauf
      *ID   ;
      ITD   ; 
      SLD   3; // Anpassung Pointerformat
```
sonst gibts irgendwann bei großen Datenbausteinen Probleme!


----------



## Markus (27 Januar 2007)

Ralle schrieb:


> geht zwar, besser aber
> 
> 
> ```
> ...


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


```
+     L#-1; // Beginne ab Adresse 0
      SLD   5; // Anpassung Pointerformat // Ein DWORD pro Durchlauf
```
 
loop müsste dint sein...

   

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


----------



## Ralle (27 Januar 2007)

Ich mag eigentlich nicht, wenn dann von außen auf einen IDB zugegriffen wird. Wenn man am FB mal was ändert, geht das schnell in die Hose, die Adressen verschieben sich evtl. usw.

SLD 5 ???


----------



## Markus (27 Januar 2007)

da gebe ich dir vollkommen recht. aber da ich in diesem fall den fb zu 90% nicht ändern werden, zumindest nicht die structur am anfang, nehme ich mir in diesem fall die bequemlichkeit der einfach db generierung beim aufruf raus...

wenn ich den fb ändere ist fraglich ob ich wirklich mehr als 128 störmeldungen rein machen soll, ich rufe bei mehr bedarf ggf. weitere instanzen auf.
und alle anderen erweiterungen kommen hinten dran.

und wenn es doch mal sein muss, dann muss ich halt vor dem generieren des neuen idbs alle fc,fb... symbolisch in ne quelle schieben, und diese nach der generierung des fb wieder rückübersetzen...


sld5 --> (*4 = sld2) + sld3...  

bei schrittweite INT --> sld 4


----------



## Markus (27 Januar 2007)

der code in dem baustein ist seit meiner letzten erweiterung eigentlich sinnlos...


```
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
```
 
das macht nur sinn wenn die Zeilen


```
L     #SPS; 
      UD    ; // Wenn der Fehler nicht mehr ansteht wird der Status "gegangen" an die VISU weitergegeben
```
 
entfernt werden....


ansonsten würde es völlig ausreichen einfach zu schreiben

l sps
t visu

ohne reset ohne alles erfüllt den selben zweck...

wenn ich will das meine visu mir sagt wann der fehler gegangen ist, dann darf ich nichts irgendwie selbshalten.
der gehler quittiert sich quasi sps seitig slber sobald er wieder weg ist und in der visu muss ich dann wirklich nur noch "das poup wegklicken"...


so was macht mehr sinn?

alle drei zustände richtig zu haben (kommen, gehen, quittieren)

oder nicht zulassen das fehlerbits selbständig zurückgesetzt werden können?

bei letzterm ist mir rein gefühlsmäsig wohler, aber dann habe ich das problem das ich der zeitstempel vom zustand "gegangen" der selbe ist wie der von "quittiert"...


----------



## Ralle (27 Januar 2007)

@Markus

Also ich laß nicht zu, daß sich Fehler selbst quittieren. Da interessiert mich eigentlich nicht, wann der Fehler von selbst geht (macht er meist eh nicht), sondern wann er beseitigt und quittiert wirde. Die allermeisten Fehler haben ja eine konkrete Ursache, der evtl. auch nachgegangen werden sollte. Allerdings kennst du das sicher auch, Anruf: "Wir haben einen Fehler an Station 17, die bleibt stehen!" (das ist schon viel Info!). Rückfrage: "Welcher Fehler, welche Störmeldenummer"? Antwort: "Keine Ahnung, wir quittieren immer gleich, muß ich nochmal nachsehen gehen". :???:


----------



## Markus (27 Januar 2007)

naja ich finde es zb bei wertüberschreitungen (temperaturen) ganz interessant wann der fehler ging.

habe mich bis jetzt dazu entschlossen das das fehlerbit nach dem gehen des fehlers wieder weg geht.

aber den sammelfehler der die station sperrt, der wird gesetzt und muss manuell quittiert werden.

dann habe in der historie sauber die zeitstempel

fehler gekommen
fehler gegangen
fehler text """ gelesen """ und QUITTIERT <-- aber das sagtest du ja bereits...


----------



## Onkel Dagobert (28 Januar 2007)

@Ralle,



Ralle schrieb:


> ..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 , ...


In einem Wort? Wieso das denn eigentlich? Man kann doch die Bits so anlegen dass sie in zwei aufeinanderfolgenden Bereichen liegen, wie in Protool.

Gruß, Onkel


----------



## Ralle (28 Januar 2007)

@Onkel Dagobert

Ah, jetzt sehe ich, wie du das gemacht hast. Wir haben die Störmeldungen wortweise angelegt, daraus folgt dann, daß immer 8 Bit STM und 8 Bit Quitt in einem Wort stecken.  Könnten man also ändern. So ist das, wenn man in irgenetwas neu einsteigt, kann man später noch so allerhand optimieren.
Allerdings sind wir so wenigstens flexibel, was die Anzahl der Störungen betrifft, ohne unser System umzuwerfen Aber mit Markus Baustein zusammen, werde ich das mal überdenken .


----------



## steuerung (12 September 2011)

Markus schrieb:


> naja ich finde es zb bei wertüberschreitungen (temperaturen) ganz interessant wann der fehler ging.
> 
> habe mich bis jetzt dazu entschlossen das das fehlerbit nach dem gehen des fehlers wieder weg geht.
> 
> ...



was macht´s du denn wenn eine Störung nur ein paar SPS-Zyklen da ist?
die HMI würde das ja nicht mitbekommen das ein Fehler ansteht aber dein Sammelfehler in der SPS steht nocht an!

würde das auch gerne mit den richtigen Zeitstempeln machen, aber für dieses Problem hab ich noch keine saubere Lösung gefunden.

Gruß


----------



## Markus (12 September 2011)

die fehlerbits für die visu stehen min 2s an.
signale werden über ein schieberegister "ausschaltverzögert"


----------



## epy (13 September 2011)

Hab diesen FC im Einsatz.
Ist auf WinCC flex abgestimmt.
Erst die Störungs-DW dann die selbe Anzahl Quitt-DW.
Quittierung erfolgt aus der SPS.
Vielleicht hift es ja weiter.:wink:


----------

