TIA Einschränkungen beim Programmieren

EinsNull

Level-1
Beiträge
51
Reaktionspunkte
2
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo alle zusammen,

gleich vorweg: Ich möchte und will mich an die Restriktionen des Tia Portals halten. Also zum Beispiel das Thema "optimierte Datenbausteine" und optimierter Zugriff".

Ich versuche mich derzeit an der Umstellung vom classic auf Tia und versuche dabei auch nach Möglichkeit die 1200 gleich mit ein zu beziehen.

Leider bin ich nun schon mehrmals (wahrscheinlich hauptsächlich wegen der Vorbelastung aus classic) auf Probleme gestoßen.

Thema 1: Bitmeldungen: In classic haben wir einen DB mit sehr vielen Bool Variablen mit der Beschriftung "Fehler001", "Fehler002", ...
Da ich aber in WinCC (flex) unbedingt ein "Word" benutzen soll, das aber nicht deklariert ist (Thema optimierte Bausteine) kann ich also auch nicht darauf zugreifen. Also muss ich meine Variablen auf Word umstellen und per Slice beschreiben. Leider ist aber aus meiner Sicht nach 16 bit die ganze (symbolische) Zuordnung dahin.

Thema 2: Ebenfalls indirekt verknüpft mit Thema 1, man kann auch nicht mal eben von einer Struktur aus 8 Word mal eben in ein Array of Word mit Länge 8 kopieren. Das gleiche gilt für 8 Bit nach 1 Byte. Genauso auch in die entsprechende andere Richtung.

Thema 3: indirekte Programmierung und Schleifen. Ich selber vertrete die Meinung dass Programme unbedingt einfach geschrieben werden müssen. Allerdings meine ich auch, dass in Standard Bausteinen niemand was zu suchen hat. Sprich wenn ich einen fertigen und getesteten Baustein für eine Standard Anwendung habe, muss Keiner den Fehler im Baustein selber suchen (weil er ja funktioniert).

Also warum soll ich dann nicht in solchen Bausteinen mit Schleifen und zur Laufzeit ermittelten Adressen (oder im Sinne von Tia mit Namen) arbeiten? Warum kann ich das nur mit Arrays machen? Und warum kann ich dann nicht von einer Struktur mit gleichem Aufbau in ein Arry kopieren?

So nun habe ich mal meinen Frust hierzu nieder geschrieben, so zu sagen als therapeutischen Mittel. Ich möchte hier nicht eine der zahllosen Diskussionen über Tia ist toll oder eben nicht lostreten, noch über meine Auffassung zum Thema indirekte Programmierung.

Als mehr möchte ich einen Anstoß geben zur Problembeseitigung auf Seite der Entwickler bei BigS und bei mir und natürlich allen Anderen die die gleichen Probleme plagen wie mich.

Ach jetzt gehts mir doch gleich besser. ;)
 
Zum Thema 2:
Du kannst bei FB's mit optimierten DB auf Variablen eine AT-Sicht erstellen, wenn Du bei den betroffenen Variablen die Remanenz auf "Im IDB setzen" einstellst. Damit kannst Du dann zwischen gleichen Strukturen kopieren.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Als mehr möchte ich einen Anstoß geben zur Problembeseitigung auf Seite der Entwickler bei BigS und bei mir und natürlich allen Anderen die die gleichen Probleme plagen wie mich.

Träum weiter, das hab ich auch mal geglaubt. Denen sind wir einfach nur Scheißegal, die haben irgendeine Agenda, ausgearbeitet auf 20 Jahre und ab gehts.

PS: Im übrigen, die gleichen Probleme, die du beschreibst hab ich auch und eine gute Lösung gibt es wahrscheinlich im Moment nicht, das gibt eine "vollsymbolische Programmierung" wahrscheinlich einfach nicht her.
Zu kurz gesprungen und in der Sch... gelandet, was nun??? :confused:
 
Words aus einer Struktur in ein Array kopieren funktioniert doch ganz einfach. Hin
Code:
#wordArray[0] := #testStruct.word0;
#wordArray[1] := #testStruct.word1;
...
und zurück
Code:
#testStruct.word0 := #wordArray[0];
#testStruct.word1 := #wordArray[1];
...
Da reißt man sich doch kein Bein bei aus die 8 Zeilen hinzuschreiben. Vor allem kannst du so ein Code 1:1 in anderen IEC Umgebungen wie Codesys verwenden.

Gleiches gilt für die Bitzuweisungen in ein Word oder Doppelwort. Sowas funktioniert auch mit Bitmaskierungen und Wortverknüpfungen mittels UND und ODER. Dann ist so ein Baustein ebenfalls 1:1 auf andere IEC Umgebungen übertragbar. Du kannst dir ja einen Standard-FC in die Bibliothek legen, mit 16 Bool Eingängen und einem Word Ausgang, oder 32 Bool Eingängen und einem Dword Ausgang.
 
@hucki: Danke, ich habe bis jetzt immer aufgehört zu lesen, wenn es um nicht optimierte Bausteine ging und meine ersten Versuche mit AT waren kläglich gescheitert, aber ja es stimmt. Damit kann man schon etwas mehr machen.

@ralle: Man wird ja noch träumen dürfen. ;) Aber davon abgesehen glaube ich fest daran, wenn genug Leute aus (vor allem grösseren Firmen) da bei BigS Rabatz machen doch noch etwas gehen kann. (Nicht gehen geht ja schon)

@thomas: Sicherlich hast Du recht, man kann diese Struktur einzeln umschaufeln. Aber wenn ich 2000 bools so umlegen soll, dann weiss ich noch nicht ganz was das ganze mit dem optimieren bringen soll. ;)
An der Sache mit den einzelnen Bausteinen zum umkopieren bin ich auch schon dran. Wie würde denn z.B. ein Baustein zum bitweisen rücksetzen in einem byte aussehen?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Words aus einer Struktur in ein Array kopieren funktioniert doch ganz einfach. Hin
Code:
#wordArray[0] := #testStruct.word0;
#wordArray[1] := #testStruct.word1;
...
und zurück
Code:
#testStruct.word0 := #wordArray[0];
#testStruct.word1 := #wordArray[1];
...
Da reißt man sich doch kein Bein bei aus die 8 Zeilen hinzuschreiben. Vor allem kannst du so ein Code 1:1 in anderen IEC Umgebungen wie Codesys verwenden.

Gleiches gilt für die Bitzuweisungen in ein Word oder Doppelwort. Sowas funktioniert auch mit Bitmaskierungen und Wortverknüpfungen mittels UND und ODER. Dann ist so ein Baustein ebenfalls 1:1 auf andere IEC Umgebungen übertragbar. Du kannst dir ja einen Standard-FC in die Bibliothek legen, mit 16 Bool Eingängen und einem Word Ausgang, oder 32 Bool Eingängen und einem Dword Ausgang.

Nein Thomas, er/ich will z.Bsp. 1600 Einzelbits auf True abprüfen, die alle als Bits in einem DB deklariert sind, damit man auf die Bits vollsymbolisch zugreifen kann.
Mit Peek_DWord bekommt man das mit einer 25-er Schleife hin (wie indirekte Adressierung mit DWORD in Classik), aber nur bei nicht optimierten Baussteinen. Was also tun?
Die Slice-Zugriffe haben zusätzlich auch das Problem, das da null Symbolik dabei ist, also für Fremde wieder ein Problem. Gleiches gilt auch oft für Arrays.
 
Zum Thema 2:
Du kannst bei FB's mit optimierten DB auf Variablen eine AT-Sicht erstellen, wenn Du bei den betroffenen Variablen die Remanenz auf "Im IDB setzen" einstellst. Damit kannst Du dann zwischen gleichen Strukturen kopieren.

Wenn ich das richtig getestet habe, geht das mit AT z.Bsp. nicht von 32 Einzel-Bits auf ein Word, sondern nur anders herum?
 
@ralle: Man wird ja noch träumen dürfen. ;) Aber davon abgesehen glaube ich fest daran, wenn genug Leute aus (vor allem grösseren Firmen) da bei BigS Rabatz machen doch noch etwas gehen kann. (Nicht gehen geht ja schon)

Natürlich darfst du das ;-)
Aber ich hatte auch einmal diese romantischen Vorstellungen und spätestens nach dem Desaster mit der Einführung von WinCCFlex dachte ich, nun haben die vielleicht mal etwas begriffen. Die bekamen Feuer ohne Ende von ihren Kunden, aber nach der Einführung von TIA ist mein Fazit: Nichts dazugelernt, gar nichts, Leider!
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich mache das hier erst seit 2010, da lief Flex und Step7 soweit ich das sagen kann. Darum hab ich diesen Schock auch erst jetzt bekommen. Aber deine Aussage deckt sich mit dem was ich so gehört habe mittlerweile.

Wenn ich das richtig getestet habe, geht das mit AT z.Bsp. nicht von 32 Einzel-Bits auf ein Word, sondern nur anders herum?

Weil ich mich grade über das Thema nochmal her mache.AT Ansicht.jpg

Leider geht das mit AT nur in FBs, FCs dürfen nicht optimiert sein.
 
Ich mache das hier erst seit 2010, da lief Flex und Step7 soweit ich das sagen kann. Darum hab ich diesen Schock auch erst jetzt bekommen. Aber deine Aussage deckt sich mit dem was ich so gehört habe mittlerweile.



Weil ich mich grade über das Thema nochmal her mache.Anhang anzeigen 27429

Leider geht das mit AT nur in FBs, FCs dürfen nicht optimiert sein.

Ja, du hast Recht auf eine Struct auf Einzelbits könnte das gehen, dann muß ich meinen DB dafür leider komplett umbauen. Aber immerhin.
 
Wie würde denn z.B. ein Baustein zum bitweisen rücksetzen in einem byte aussehen?
Ich würde nicht groß über optimierungen nachdenken, sondern es so programmieren wie es die Funktionen hergeben. Da ich es in allen anderen Sprachen immer mit Schieben und Verodern mache, würde ich es in SCL so schreiben.
Code:
FUNCTION "SetBitsInByte" : Byte
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      Bit0 : Bool;
      Bit1 : Bool;
      Bit2 : Bool;
      Bit3 : Bool;
      Bit4 : Bool;
      Bit5 : Bool;
      Bit6 : Bool;
      Bit7 : Bool;
   END_VAR

   VAR_TEMP 
      tmp : Byte;
   END_VAR

BEGIN
	#tmp := B#16#0;
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit0), N := 0);
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit1), N := 1);
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit2), N := 2);
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit3), N := 3);
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit4), N := 4);
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit5), N := 5);
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit6), N := 6);
	#tmp := #tmp OR SHL(IN := BOOL_TO_BYTE(#Bit7), N := 7);
	#SetBitsInByte := #tmp;
END_FUNCTION
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Aber wenn ich 2000 bools so umlegen soll, dann weiss ich noch nicht ganz was das ganze mit dem optimieren bringen soll.

Ich würde mir ein anderes Konzept überlegen. Wer beschreibt denn diese 2000 Bits? Warum musst du von den 2000 Bits nochmal ein Zustand generieren? Das wird doch bestimmt für eine Sammelstörmeldung oder ähnliches benötigt. Ich habe sowas noch nie benötigt, weil ich einen Baustein zur Störerfassung habe, welcher die Funktion "Sammelstörmeldung" mit beinhaltet. Dann entfällt das Problem des späteren Sammelns von unstrukturierten Einzelbits ganz einfach.
 
Wenn ich das richtig getestet habe, geht das mit AT z.Bsp. nicht von 32 Einzel-Bits auf ein Word, sondern nur anders herum?
Da musst eher Du mir weiter helfen:

Wenn Du 32 Einzelbit in einem DB hast, kannst Du doch sicher eine Struktur drumherum legen und auf diese kannst Du dann die Sicht machen, oder?
Wenn die Bits alle von irgendwo anders herkommen, sollte man sich m.M.n. Gedanken um eine andere Strukturgestaltung machen.

Aber insgesamt fehlt mir da als Hobby-Programmierer wahrscheinlich der Gesamteinblick, was da sinnvoll machbar ist und was nicht.



Leider geht das mit AT nur in FBs, FCs dürfen nicht optimiert sein.
Ist ja auch schwierig beim FC, die Remanenz auf "Im IDB setzen" einzustellen, wenn man keinen IDB hat. :p
Ich find' das bei Siemens auch mit "Codebausteinen" blöd formuliert, da ja außer FBs keine anderen Codebausteine in Frage für diese Einstellung kommen, oder?
 
@hucki
Ist schon geklärt (siehe oben), man muß eben eine Struktur nutzen. Das ist bei meinem 100 Jahre alten DB für Störmeldungen nicht der Fall, war nie nötig. Nun aber schon eher. :)
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich würde mir ein anderes Konzept überlegen. Wer beschreibt denn diese 2000 Bits? Warum musst du von den 2000 Bits nochmal ein Zustand generieren? Das wird doch bestimmt für eine Sammelstörmeldung oder ähnliches benötigt. Ich habe sowas noch nie benötigt, weil ich einen Baustein zur Störerfassung habe, welcher die Funktion "Sammelstörmeldung" mit beinhaltet. Dann entfällt das Problem des späteren Sammelns von unstrukturierten Einzelbits ganz einfach.

Man muss das im Ganzen sehen. Ja es handelt sich um meine Störmeldungen. Beschrieben werden diese in meinen einzelnen Fehlerbausteinen. Damit dort und in der Visu eine 1:1 Zusammgehörigkeit vorhanden ist, Möchte ich das eben als Bool haben (hat ja auch den Vorteil dass ich im Kommentar den Fehlertext rein schreiben kann.
Aber die Visu verlangt nun mal ein Word als Trigger. Das passt nicht so ganz zusammen.

Mal so übern Tellerrand spionieren: Wie setzt du Quittierpflichtige Bitmeldungen zurück?
 
Zuletzt bearbeitet:
Ist ja auch schwierig beim FC, die Remanenz auf "Im IDB setzen" einzustellen, wenn man keinen IDB hat. :razz:
Ich find' das bei Siemens auch mit "Codebausteinen" blöd formuliert, da ja außer FBs keine anderen Codebausteine in Frage für diese Einstellung kommen, oder?

Eben! *ACK*

Aber wieso muss "AT" gespeichert werden?:confused:
 
Ich seh schon wir wollen das Selbe machen.
AT ist hier auch keine wirkliche Hilfe, das gibt einen Overkill, den ich mir ja genau sparen möchte.

Meine momentane Lösung für die 1214: Optimierung aus und Peek_DWORD in einer Schleife.

Etwas so:

Code:
//zum Start alles auf Null
#Signal_is_True := False;


//Schleife bilden
FOR #Count := 0 TO #CountDWord DO
    
    #DataDWord := PEEK_DWORD(area := 16#84, dbNumber := #DBNumber, byteOffset := (#Count * 4));
    IF #DataDWord > 0 THEN
        #Signal_is_True := True;
        EXIT;
    END_IF;
    
END_FOR;
Ich halte diese Optimierung irgendwie für ein totes Pferd, man muß es irgendwann doch für einen Baustein ausschelten und so wie ich es hier im Forum gelesen habe heißt es, ein nicht optimierter Baustein und es wird gar nicht mehr optimiert zugegriffen. Ob das so stimmt, kann ich nicht sagen, wäre aber schlimm.
 
Wenn es hier "nur" um Bit-Störmeldungen geht, dann schaut euch doch mal die Alarmfunktion von ner 1500er an.
Damit wird vieles richtig einfacher.

Gelegentlich muss man halt eben alte Gewohnheiten über Bord schmeissen.
Ich hab mir vor ein paar Jahren angewöhnt vollsymbolisch zu programmieren.
War anfangs richtig nervig, da eben eine Schleife über ein paar DW absolut programmiert einfach schnell gemacht ist.
Wenn du es symbolisch machst, dann brauchst du eben UDTs, Strukturen, Arrays ... und oft auch SCL mit AT.
Wenn ich jetzt testweise alte Projekte mit TIA migriere, dann sieht man sehr schnell, den Unterschied.
Aktuelle Programme machen fast keine Probleme ... Projekte von vor 10 Jahren schmeissen nur noch Fehlermeldungen und Warnungen.

Wir steigen jetzt um von 300 -> 1500 und da müssen eben einige Dinge überarbeitet werden.
Aber eigentlich finde ich das nicht so schlimm. Und manches macht sogar Spass.

Gruß
Dieter
 
Wenn es hier "nur" um Bit-Störmeldungen geht, dann schaut euch doch mal die Alarmfunktion von ner 1500er an.
Damit wird vieles richtig einfacher.

Gelegentlich muss man halt eben alte Gewohnheiten über Bord schmeissen.
Ich hab mir vor ein paar Jahren angewöhnt vollsymbolisch zu programmieren.
War anfangs richtig nervig, da eben eine Schleife über ein paar DW absolut programmiert einfach schnell gemacht ist.
Wenn du es symbolisch machst, dann brauchst du eben UDTs, Strukturen, Arrays ... und oft auch SCL mit AT.
Wenn ich jetzt testweise alte Projekte mit TIA migriere, dann sieht man sehr schnell, den Unterschied.
Aktuelle Programme machen fast keine Probleme ... Projekte von vor 10 Jahren schmeissen nur noch Fehlermeldungen und Warnungen.

Wir steigen jetzt um von 300 -> 1500 und da müssen eben einige Dinge überarbeitet werden.
Aber eigentlich finde ich das nicht so schlimm. Und manches macht sogar Spass.

Gruß
Dieter

Ich hab gerade eine 1214 am Wicke, k.A., ob die das kann.
Was genau meinst du mit den Alarmfunktionen der 1500-er, das was bei der 300-er die Alarm-Bausteine machten?
Da bin ich mit immer unsicher gewesen, wahrscheinlich bin ich zu festgefahren. Wenn mein Programm einen Alarm auswirft, dann sitzt der in meinem Programm als Ausgabe aus einem Baustein (Motor, Error etc.) und will dort auch quittiert werden. Nicht im HMI, denn das über die Alarm-Bausteine mitzubekommen, das hab ich noch nirgends so richtig gesehen. Außerdem kann man dann nur noch ausschließlich die Siemens-Panels nutzen, macht sich also noch abhängiger. Ich fand das Bitmeldeverfahren für meine Zwecke immer sehr gut, aber vielleicht zeigst du mit ja, das es mit der 1500-er besser geht. Ich werde mit die Bausteine auf jeden Fall mal ansehen und mal suchen, was die 1200-er da bietet.
 
Zurück
Oben