VAR_INPUT
I_DB_Nummer : BLOCK_DB ; //Bewegungsanwahl, Störungen, Daten
END_VAR
VAR_OUTPUT
error : WORD ;
END_VAR
VAR
flag_bild : BOOL ;
flag_active : BOOL ;
flag_init : BOOL ;
new_pic : INT ;
old_pic : INT ;
l_cnt : WORD ;
l_byte_nr : DWORD ;
pdb : ARRAY [0 .. 7 ] OF WORD ;
pps : ARRAY [0 .. 7 ] OF DWORD ;
perr : ARRAY [0 .. 7 ] OF WORD ;
END_VAR
VAR_TEMP
scratch : WORD ;
l_tmp32 : DWORD ;
l_snr : WORD ;
l_sbnr : WORD ;
l_s_cnt : BYTE ;
l_t_cnt : BYTE ;
l_fb_if : WORD ;
l_loop : BYTE ;
l_la : BOOL ;
Graph_51 : BOOL ;
END_VAR
BEGIN
NETWORK
TITLE =
AUF #I_DB_Nummer;
L 0;
T #error;
U DBX 24.3;
U DBX 25.0;
SPB bild; // bild ist aktiv
U #flag_bild;
SPB abwa;
BEA ;
//###
abwa: SET ;
R #flag_bild;
L W#16#0; // loeschmuster
T DBW 22;
BEA ;
//###
// bild aktiv
bild: U #flag_bild;
SPB nzyk;
//###
// erste zyklus des bewegungsbildes
L -1;
T #new_pic;
T #old_pic;
SET ;
R #flag_active;
S #flag_bild;
L W#16#0; // loeschmuster
T DBW 10;
BEA ;
//###
// n te zyklus des bildes!
nzyk: NOP 0;
L 1; // kennung bild ist aktiv
T #error;
L DBW 16;
L 1; //1-20 wird 0-19
-I ;
T #new_pic;
L #old_pic; // bild-nr 0 - 19
==I ;
SPB old;
//###
// neue bild-nr angewaehlt
TAK ;
T #old_pic; // schalte die bild-nr um
SET ;
R #flag_active;
R #flag_init;
L B#16#0; // loeschmuster
T DBW 10;
BEA ;
//####
// wir haben noch die alte bild-nr!
old: NOP 0;
// ist die bild-nr bereits aktiv?
U #flag_active;
SPB acti;
// hier noch keine active bild-nr. die zeiger sind noch nicht errechnet!
L 2; // kennung zeigerzyklus
T #error;
// zuerst hole die daten aus db106
// die schleife ueber mehrere zyklen initialisieren, aber nur einmal!
U #flag_init;
SPB zykl;
// schleifen initialisierung
L 0;
T #l_cnt;
SET ;
S #flag_init;
//================================================================================ =
// ab hier die globale schleife
//================================================================================ =
zykl: NOP 0;
AUF #I_DB_Nummer; // oeffne den BEWE-DB
L #old_pic;
L 32;
*I ;
T #l_byte_nr; // bytenummer im BEWE-DB
L #l_cnt; // schleifenzaehler 0-7
L 4;
*I ;
L #l_byte_nr;
+I ;
L 100; // offset 100 da db105 + 106 aus der stdbdf
+I ; // zu einem BEWE-DB zusammengefasst wurden
SLD 3;
LAR1 ;
L DBW [AR1,P#0.0]; // hole die s_nr
T #l_snr;
L DBW [AR1,P#2.0]; // hole die sk_db_nr
T #l_sbnr;
// ablegen der db nummer im db array
L P##pdb;
LAR1 ;
L #l_cnt;
SLW 1; // fuer wort
SLD 3;
+AR1 ;
L #l_sbnr;
T DIW [AR1,P#0.0];
// ist die nummer belegt?
L 0;
==I ;
SPB F_06; // db nummer ist 0
// teste nun den sdb
L #l_sbnr;
T #scratch;
AUF DB [#scratch]; // oeffne den sdb
// test ob dies ein g7 db ist!
L DBLG;
L 40;
<D ;
SPB F_01; // db nicht lange genug
-D ;
SLD 3;
T #l_tmp32; // offset auf pre_cnt im sdb
LAR1 ;
L DBW [AR1,P#38.0]; // addr. g7_id1+2
L '7G';
<>I ;
SPB F_01; // kein g7 db
// test ob mindesten v4.0
SET ;
R #Graph_51;
L DBB [AR1,P#36.0]; // addr fb_mark
L 60; // Graph 5.1
==I ;
= #Graph_51;
SPB WEIT;
L DBB [AR1,P#36.0]; // addr fb_mark
L 39; // bis einschliesslich fb v3.9
>I ;
SPB F_02;
L DBB [AR1,P#37.0]; // addr g7_release
L 40; // mind g7 v4
<I ;
SPB F_03;
// ermittle die art der bausteinparameter des sb
WEIT: U #Graph_51;
SPBN MMM;
L DBB [AR1,P#25.0]; // addr fb_if
T #l_fb_if;
SPA NNN;
MMM: L DBW [AR1,P#30.0]; // addr fb_if
T #l_fb_if;
NNN: L W#16#FB; // fb_if_cisc
==I ;
SPB ifok;
[COLOR=Red][B]POP[/B][/COLOR] ;
L W#16#FC; // fb_if_risc
<>I ;
SPB F_04;
// hier entweder maximal oder standard fb interface, kein
// minimal zugelassen
ifok: NOP 0;
// hole die anzahl schritte aus dem schrittbaustein
L DBB [AR1,P#12.0]; // offset s_cnt
T #l_s_cnt;
// hole die anzahl transitionen aus dem schrittbaustein
L DBB [AR1,P#9.0]; // offset t_cnt
T #l_t_cnt;
// hier nun die schleife ueber alle schritte um die anwenderschrittnummer zu finden
// ermittle den anfang der schritte:
// algorithmus:
// laenge der sb parameter + ( lange transition * ( t_cnt + 1 ) )
UN #Graph_51; // Kein Graph 5.1 FB
SPB ALT;
+ 2;
L 17;
*I ;
UN L 10.0; // Anzahl der Schritt ist gerade
SPB BER;
L -1; // bei ungeraden vom Ergebniss eins abziehen
+I ;
SPA BER; // Sprung zur Berechnung
ALT: + 1; // eins dazu fuer t0
L 16; // laenge einer transition
*I ;
+ 10; // offset ueber die sb parameter
BER: SLD 3;
LAR1 ; // p#G7S[0].0
L #l_s_cnt; // schleifenzaehler
lop: T #l_loop;
+AR1 P#32.0; // schritt++ damit wird s0 uebersprungen!
L DBW [AR1,P#2.0]; // offset auf sno
L #l_snr;
==I ;
SPB fond;
L #l_loop;
LOOP lop; // dec l_loop und springe wenn l_loop <> 0
// hier nicht gefunden!
SPA F_05;
// hier gefunden
fond: NOP 0;
// ar1 zeigt hier auf den schritt
TAR1 #l_tmp32;
// ablegen des zeigers im db array
L P##pps;
LAR1 ;
L #l_cnt;
SLW 2; // fuer doppelwort
SLD 3;
+AR1 ;
L #l_tmp32;
T DID [AR1,P#0.0];
//===
// schleifenende
//===
SPA F_00; // kein fehler ablegen
//--------------------
cont: L #l_cnt;
+ 1;
T #l_cnt;
L 8;
<I ;
BEB ;
L 0;
T #l_cnt;
SET ;
S #flag_active;
BEA ;
//-------------------------------
// fehlerbehandlung
F_00: L 0; // kein fehler
SPA F_xx;
F_01: L W#16#8001; // baustein ist kein g7 baustein
SPA F_xx;
F_02: L W#16#8002; // fb groesser v3.9
SPA F_xx;
F_03: L W#16#8003; // g7 nicht v4, keine permanenten interlocks
SPA F_xx;
F_04: L W#16#8004; // minimal fb interface
SPA F_xx;
F_05: L W#16#8005; // schrittnummer nicht gefunden
SPA F_xx;
F_06: L W#16#8006; // baustein nummer in 106/107 nicht belegt!
SPA F_xx;
F_xx: NOP 0;
T #scratch;
// ablegen des fehlers im db array
L P##perr;
LAR1 ;
L #l_cnt;
SLW 1; // fuer wort
SLD 3;
+AR1 ;
L #scratch;
T DIW [AR1,P#0.0];
SPA cont;
//###
acti: NOP 0;
// hier sind nun die werte ermittelt. nun abholung und akutalisierung
// und dies in einem zyklus fuer alle 12 anzeigen!
L 3; // kennung aktualisierung
T #error;
// schleifen counter init!
L 0;
T #l_loop;
Loo: NOP 0;
CLR ;
= #l_la; // reset des interlock merkers
// test ob fehlerhaft oder nicht
L P##perr;
LAR1 ;
L #l_loop;
SLD 1; // fuer wort
SLD 3;
+AR1 ;
L DIW [AR1,P#0.0]; // lade die fehlernummer
L 0;
<>I ;
SPB nodb;
// teste den db
L P##pdb;
LAR1 ;
L #l_loop;
SLD 1; // fuer wort
SLD 3;
+AR1 ; // zeigt nun auf die db nummer
L DIW [AR1,P#0.0]; // lade die db nummer
T #scratch;
L 0;
==I ;
SPB nodb;
AUF DB [#scratch]; // und oeffne den sdb
L P##pps;
LAR1 ;
L #l_loop;
SLD 2; // fuer doppelwort
SLD 3;
+AR1 ;
L DID [AR1,P#0.0]; // lade zeiger auf den schritt
LAR1 ;
// U DBX [AR1,P#1.1] // hole das LA bit
// achtung LA wird nur dann gesetzt, wenn der schritt auch aktiv ist! nicht wenn
// der schritt nicht bearbeitet wird. aus diesem grund muss bei permanenter bearbeitung
// das LS bit verwendet werden, das direkt das ergebnis des interlock repraesentiert!
U DBX [AR1,P#1.6]; // hole das LS bit
// NOT // negiere das ergebnis, nur bei LA notwendig!!!!
= #l_la; // und wir haben den interlock aktiv heureka!!!!!!!
nodb: NOP 0;
// und nun das ablegen der information im anzeige db
AUF #I_DB_Nummer;
L P#10.0; // anfangsbereich
LAR1 ;
L #l_loop; // 0-8
+AR1 ;
// hier habe ich endlich die bitnummer
U #l_la;
= DBX [AR1,P#0.0]; // und lege ab
L #l_loop;
+ 1;
T #l_loop;
L 8;
<I ;
SPB Loo;
//------------------------------------------------
BEA ;
END_FUNCTION_BLOCK
