TIA Allgeime Diskusion -> TIA V14 SCL Lesen und Schreiben von Daten in DB´s

MathiasKoch35

Level-1
Beiträge
11
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Miteinander,

ich habe zwar einige Themen zum o.g. Thema gefunden, aber keines dieser Beiträge befriedigt mich persönlich ;)

Zur Zeit beschäftige ich mich im TIA Portal V14 und versuche meine eigenen Grundprojekte in dieses zu Migrieren. Mit der Siemens eigenen Migrationsfunktion habe ich es aufgegeben. Funktioniert genau so gut, wie damals die Migration von S5 auf S7 :rolleyes:

Zurück zum Thema. Mir geht es hauptsächlich um das Thema Datenbausteine und SCL..

Hier mal ein kleiner Auszug aus einem meiner Bausteine.

Code:
VAR_INPUT
    Scheibenkl_DB: BLOCK_DB;    //Datenbaustein  
    Mkm_TeileProt_DB: BLOCK_DB; //Datenbaustein   
    Messsystem_DB: BLOCK_DB;    //Datenbaustein
    MessHardw_DB: BLOCK_DB;     //Datenbaustein 
END_VAR

~~~~~~~~~~

 IF Scheibenkl_DB.DX[(tmp_schleife*60+1),0] = TRUE THEN                IF Scheibenkl_DB.DD[(tmp_schleife*60+2)] = REAL_TO_DWORD(tmp_istwert) THEN  
                    
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+4)]:= Scheibenkl_DB.DD[(tmp_schleife*60+2)]; // Übrgabe Scheibensollwert
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+12)]:= Scheibenkl_DB.DD[(tmp_schleife*60+10)]; // Übrgabe Scheiben OTG
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+16)]:= Scheibenkl_DB.DD[(tmp_schleife*60+6)]; // Übrgabe Scheiben UTG         
                    // Übergabe Abweichung (Zeilenanzeige)
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+8)]:= REAL_TO_DWORD( DWORD_TO_REAL(Mkm_TeileProt_DB.DD[(tmp_50_abweichung+0)]) - DWORD_TO_REAL(Mkm_TeileProt_DB.DD[(tmp_50_abweichung+4)]) );
                    
                    tmp_Toleranzgrenze:= DWORD_TO_REAL(Scheibenkl_DB.DD[(tmp_schleife*60+10)]) - DWORD_TO_REAL(Scheibenkl_DB.DD[(tmp_schleife*60+2)]);
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+28)]:= REAL_TO_DWORD(tmp_Toleranzgrenze);                    
                    tmp_Balken_Grenze:= (tmp_Toleranzgrenze + (tmp_Toleranzgrenze*100/50)); 
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+20)]:= REAL_TO_DWORD(tmp_Balken_Grenze); 
                    
                    tmp_Toleranzgrenze:= DWORD_TO_REAL(Scheibenkl_DB.DD[(tmp_schleife*60+2)]) - DWORD_TO_REAL(Scheibenkl_DB.DD[(tmp_schleife*60+10)]);
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+32)]:= REAL_TO_DWORD(tmp_Toleranzgrenze); 
                    tmp_Balken_Grenze:= (tmp_Toleranzgrenze + (tmp_Toleranzgrenze*100/50));
                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+24)]:= REAL_TO_DWORD(tmp_Balken_Grenze); 


                    Mkm_TeileProt_DB.DD[(tmp_50_abweichung+36)]:= Mkm_TeileProt_DB.DD[(tmp_50_abweichung+8)];


                END_IF;

Ganz bewusst geht es mir dabei um die Ehemals einfache Funktion, dass ich Variabel Daten von einem DB in einen anderen DB schreiben konnte.

Warum hat Siemens das ist TIA fas unmöglich gemacht. Da liest man was von PEEK und POKE. Aber mal einfach geht es nicht mehr.


Oder hat jemand eine zündende Idee ?


Grüße
Matze. K.
 
Ich bin mir nicht ganz sicher, ob ich dich richtig verstanden habe und ob das das ist was du meinst,

aber du kannst in SCl immer noch auf DB Daten zugreifen. Z.B. "Mkm_TeileProt".DD(tmp_50_abweichung) würde immer noch einen Wert in einem Array ansprechen.

Auf Realadresse hat man aber idR keinen Zugriff weil das alles Symbolisch abläuft, es sei denn man stellt es ein.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Miteinander,
Warum hat Siemens das ist TIA fas unmöglich gemacht. Da liest man was von PEEK und POKE. Aber mal einfach geht es nicht mehr.

Das hat mit TIA nix zu tun. Das ist nur bei den 1500ern so das man PEEK POKE benötigt. Die 300/400er gehen immernoch alterwürdig (andere Klammern)
Aber was genau gefällt dir denn an Peek und Poke nicht?
Und wozu überhaupt noch diese Absolutadressierung? Das sieht doch eher so aus als wäre das optimal mit in Array angeordneten Objekten lösbar und auch lesbarer dann?

mfG René
 
Okay, stimmt, ich beziehe mich hier auf dem Wechsel von Step 7 uns S7-300 / auf / TIA S7-1500 .... Das mal vorab....

Im Prinzip geht es mir darum..... Ich schreibe einen Baustein in SCL. Von außen an dem Baustein möchte ich Variabel einstellen können die DB´s

Im Baustein möchte ich dann die Variable Datenbausteine von einem in den anderen Lesen / Schreiben können. An sich habe ich mit PEEK kein Problem. In dem Befehl macht es ja noch sinn, das ich mit PEEK_WORD oder PEEK_DWORD,,,, lesen kann. Aber auf der Gegenseite kann ich es nicht gleich wieder mit POKE weitergeben, da es da nicht in WORD, DWORD, us.w. angegeben wird.

Vielleicht habe ich auch nur einen Gedankenfehler und mich irgendwie verrannt.

Es sei mal am Rande gesagt, das ich in Step7 fit, und schon viele Jahre im Maschinenbau unterwegs bin, aber mit TIA tue ich mich echt schwer und stehe hier absolut am Anfang..
 
Im Baustein möchte ich dann die Variable Datenbausteine von einem in den anderen Lesen / Schreiben können. An sich habe ich mit PEEK kein Problem. In dem Befehl macht es ja noch sinn, das ich mit PEEK_WORD oder PEEK_DWORD,,,, lesen kann. Aber auf der Gegenseite kann ich es nicht gleich wieder mit POKE weitergeben, da es da nicht in WORD, DWORD, us.w. angegeben wird.

Da wäre dann POKE_BLK für dich sinnvoll.
Das sieht dann so aus.
Code:
POKE_BLK(area_src:=16#84,
         dbNumber_src:=5,
         byteOffset_src:=10,
         area_dest:=16#84,
         dbNumber_dest:=5,
         byteOffset_dest:=8, 
         count:=2); // Grösse des Bereiches Bei DWORD natürlich dann 4 Byte
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Da wäre dann POKE_BLK für dich sinnvoll.
Das sieht dann so aus.

Das wäre ja im Prinzip wie der SCF20 (BLKMOV) !?

Wenn ich das dann Viele male aufrufe, "POKE_BLK", frisst dass dann nicht etliches an Speicher ?
Jedenfalls werde ich das mit POKE_BLK mal ausprobieren für direktes weitergeben von Daten. Vielen Dank für den Tip.

Was mache ich in dem Fall z.B. In einem DB REAL-Wert lesen / verrechnen / In einen anderen DB speichern ?

Lesen mit --> #test_real := DWORD_TO_REAL(PEEK_DWORD(area := 16#84, dbNumber := 20, byteOffset := 0));
verrechnen ! Plus, Minus, Mal, Geteil

Und wie schreibe ich das wieder in einen anderen DB ?
 
Ja POKE_BLK ist wie ein Blockmove, nur muss man halt keinen Pointer zusammenbasteln sondern kann direkt mit offsets arbeiten.

Du könntest z.B. so arbeiten
Code:
POKE(area:=16#84,
     dbNumber:=5,
     byteOffset:=16,
     value:=REAL_TO_DWORD(2.0 * DWORD_TO_REAL(PEEK_DWORD(area:=16#84, dbNumber:=5, byteOffset:=10))));

Dass geht natürlich alles in eine Zeile, aber weder wird das Programm dadurch schneller noch wird es lesbarer.

Edit: Natürlich real wieder in DWORD um warnungen zu umgehen.
 
Zuletzt bearbeitet:
Ja POKE_BLK ist wie ein Blockmove, nur muss man halt keinen Pointer zusammenbasteln sondern kann direkt mit offsets arbeiten.

Na das ist doch mal eine wirkliche Verbesserung zum SFC20. ;)


Nach Deinem letzten Beitrag ist mir der Groschen gefallen. Man kann also mit POKE auch mehr als nur ein Byte schreiben. Das ist genau das, was mich als verwirrt hatte. Im SCL Editor und im Kontext hat mir das Programm immer nur ein Byte als mögliche value aufgezeigt. Dein Beispiel zeigt aber deutlich, das es auch mehr sein darf. Kopiert, Eingetragen und keine Fehlermeldung. Da war also der Hase begraben..

2017-04-11 16_17_56-Siemens  -  D__Arbeit_TIA_Projekte_Test_CPU_V01_Test_CPU_V01.jpg

Vielen Dank dafür ! :sm24:
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Na das ist doch mal eine wirkliche Verbesserung zum SFC20. ;)


Nach Deinem letzten Beitrag ist mir der Groschen gefallen. Man kann also mit POKE auch mehr als nur ein Byte schreiben. Das ist genau das, was mich als verwirrt hatte. Im SCL Editor und im Kontext hat mir das Programm immer nur ein Byte als mögliche value aufgezeigt. Dein Beispiel zeigt aber deutlich, das es auch mehr sein darf. Kopiert, Eingetragen und keine Fehlermeldung. Da war also der Hase begraben..

Jup Poke nimmt die Grösse der angelegten Variable als Grundlage. Eigentlich sollte PEEK das auch machen, aber bei mir hat das bei Versuchen damals nicht funktioniert weswegen ich die Grösse immer explizit angebe wenn ich was grösseres als ein Byte brauche also PEEK_WORD() PEEK_DWORD()
 
Eigentlich sollte PEEK das auch machen, aber bei mir hat das bei Versuchen damals nicht funktioniert weswegen ich die Grösse immer explizit angebe wenn ich was grösseres als ein Byte brauche also PEEK_WORD() PEEK_DWORD()

Also ich habe jetzt das Optimum gefunden.

Code:
POKE(area:= 16#84, dbNumber:= 21, byteOffset:= 0, value:= (PEEK_DWORD(area:=16#84, dbNumber:=20, byteOffset:=0)));

Stiimmt, direkt mit PEEK geht nicht... Das Programm meckert zwar nicht, aber übergibt auch nichts :rolleyes:
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Absolute Programmierung ist bei einer 1500er wirklich nur sehr selten notwendig.
Peek und Poke sollte man eigentlich vermeiden und lieber vernünftige Datenstrukturen aufbauen..

Aber nicht wenn man Bausteine schreiben möchte, die völlig unabhängig und völlig Variabel sein sollen.
Da raubt mir die neue Art und Weise des TIA´s so ein bisschen die Möglichkeiten. Meiner Meinung nach. Aber ich kann mich auch irren.
 
Aber nicht wenn man Bausteine schreiben möchte, die völlig unabhängig und völlig Variabel sein sollen.
Da raubt mir die neue Art und Weise des TIA´s so ein bisschen die Möglichkeiten. Meiner Meinung nach. Aber ich kann mich auch irren.

Ich würde schlichtweg sagen: Du irrst dich.

Beispiel eine UDT für die Verfahrparameter eines Antriebs mit:
  • Position
  • Geschwindigkeit
  • Beschleunigsrampe
  • Bremsrampe

Diese UDT kann ich für alle meine Achsen in der Anlage verwenden.
Zugriff auf die Daten erfolgt vollsymbolisch über Array-Elemente

Jetzt kommt z.B. noch das Drehmoment hinzu.
Bei vollsymbolischer Programmierung füge ich das Drehmoment einfach der UDT hinzu und lass das Programm neu übersetzen.
Der Compiler kennt die Größe und weiß wo jedes Element sitzt.
Mach das mal absolut ... An wieviel Stellen musst du irgendwelche Zugriffe, Längen, Offset oder ähnliches ändern?
Wieviele Fehler können dir dabei unterlaufen? Wie schwer sind verbogene Zeiger zu finden?

Natürlich hat die symbolische Programmierung auch Nachteile, aber zumindest in meinem Bereich überwiegen eindeutig die Vorteile.
Letztlich kann aber jeder programmieren wie er mag. Wichtig ist nur dass die Programme sauber und nachvollziehbar sind.

Gruß
Blockmove
 
Grundsätzlich: Den letzten Satz unterstreiche ich mit vollster Zustimmung. Leider denken relativ wenige Programmierer so.

In manchen aussagen könnte ich dir nicht mal das Gegenteil beweisen, da ich einfach zu wenig Erfahrung mit TIA habe. Lange habe ich vor gesträubt. Aber jetzt muss ich, um einfach mit der Zeit zu gehen.

Dein Beispiel ist absolut nachvollziehbar, weil ich es sehr oft so machen musste. In Step7 habe ich mir deshalb angewöhnt immer viel Reserve zu lassen, um solche Arbeit vorzubeugen.
Der Nachteil, viel Speicherplatz Verlust dadurch.

Dennoch finde ich noch nicht den gemeinsamen Nenner in TIA, wie ich meine SCL Bausteine so aufbaue, das sie Variabel genug sind, für das, wie ich sie benutze. Da muss ich wohl einfach mal probieren.

Gruß
Matze
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Was mir symbolisch in TIA irgendwie noch fehlt, ist der Wechsel von einem DB auf einen Anderen gleichen Inhalts, z.B. wenn man Daten in 10 DB speichert. Das geht symbolisch eigentlich nur über eine Case-Anweisung (im Bsp. mit 1 bis 10). Nicht besonders schön, aber symbolisch hab ich da noch keine bessere Idee. Ansonsten stimme ich Blockmove zu. (Im Prinzip bist du nun überflüssig mein Lieber :ROFLMAO:)
 
Bei vollsymbolischer Programmierung füge ich das Drehmoment einfach der UDT hinzu und lass das Programm neu übersetzen.
Der Compiler kennt die Größe und weiß wo jedes Element sitzt.

Natürlich hat die symbolische Programmierung auch Nachteile,

In Step7 habe ich mir deshalb angewöhnt immer viel Reserve zu lassen, um solche Arbeit vorzubeugen.

Tja schöne neue Welt ;)

Prinzipiell kontte man ja auch schon unter Step7 Classic symbolisch und mit UDTs arbeiten. Hab ich auch schon öffters gemacht.

Jetzt kommt aber das ABER:

Wenn man Anlagen der Prozessautomatisierung betreut, welche so gut wie immer laufen und immer im laufenden Betrieb stößfrei genändert/geladen werden müssen, dann funtkioniert das leider alles nicht mehr so gut!

Deshalb sind wir ganz schnell wieder auf die Variante mit den Reserven zurückgegangen. Ob man das nun symbolisch oder absolut macht, ist dann nochmal die nächste Frage. Ohne DB-rettungsverfahren funktioniert die Umbenennung der symbolischen Reserven im TIA aber leider auch nicht im laufenden Betrieb!!! Also machs gleich absolut oder man baut sich händisch noch eigene Datenrettungsmechanismen, hab ich hier schonmal in nem Betrag beschrieben, wie wir das machen.

Lange Rede kurzer Sinn:
Letztlich kann aber jeder programmieren wie er mag. Wichtig ist nur dass die Programme sauber und nachvollziehbar sind.

Aber für unsere Anlagen hier hat die symbolische OOP UDT Multiinstans-DB usw. Variante doch einige gravierende Nachteile. Am schreibtisch sieht das alles ganz toll und strukturiert aus, aber auf der Baustelle kommt dann das grosse Erwachen ;)

Also der Gute alte S5-Stil mit Merkern Timern etc. hat an manchen Stellen auch schon seinen Charm, aber um sich dort ne gute und überschaubare Strukturierung aufzubauen benötigt es schon viel Disziplin.

Aber spätestens wenn die Vollsymbolische Programmierung der nächste Instandhalter nicht versteht und trotzdem Merker und Timer dazuprogrammiert ists mit der schönen Struktur auch dahin...

Also jeder muss für sich die beste Variante nehmen.

Gruß.
F
 
Zurück
Oben