FUNCTION_BLOCK "MStartSync" TITLE = Synchronisation Anfang neuer Sortbereich { S7_Optimized_Access := 'FALSE' } AUTHOR : AE VERSION : 0.1 //COPYRIGHT by Ingenieurbüro A.Emmert //Ortsstr.33, D-869925 Fuchstal (Germany) //Tel.: 0049(0)8243-960629 // //Version 4.12.2014: //-Entprellung ohne Antrieb! // //Version: ILS2100 / 12.01.2010 // // VAR_INPUT Sync_Nr : Int; // Aufruf für Weiche ErrQuit : Bool; // Ablaufstörung quittieren B_BT_da : Bool; // Sensor BT ist an Sychronisierstelle B_RefPunkt : Bool; // Sensor RefHaken am Referenzpunkt erkannt B_TeachPunk : Bool; // Sensor RefHaken am Teachpunkt erkannt Antrieb_aktiv : Bool; // Band ist aktiv END_VAR VAR_OUTPUT Error : Word; // Störungen übergeben END_VAR VAR_IN_OUT Antrieb_start : Bool; // Kreiselantrieb starten hStOk : Bool; // Anzeige Start n. Störung aktivieren END_VAR VAR Teil_IDX_Old : Int; // BT/MT-IDX (wird bei Auslagerung gemeldet) Teil_Ziel_Old : Int; // BT/MT bei diesem Abwurf-Ziel ausfahren/entladen Res1 : Array[1..3] of Int; // Reserve SAVE : Struct Ink_ohne_Zeit : Int; // Zeit Inkremntalgeberwert ohne Änderung [100ms] END_STRUCT; Para : Struct // Parameter Weichen_DL_DB : Int; // Einsprung Weichen-Datenliste-DB Weichen_DL_DW : Int; // Einsprung Weichen-Datenliste-DW Offset_RefPunkt : DInt; // Offset Refpunkt zu TaschenPunkt (für Teachen) Res1 : Array[1..1] of Int; // Reserve END_STRUCT; SyncPkt : "UDLStartSync"; // Fahrbereichs Daten Dyn : Struct // Dynamische Daten Status : Struct // Status TeachModus_Aktiv : Bool; // Teach-Modus ist aktiv MoreTeach : Bool; // Nächsten Teachpunkt ohne neuen Refpunkt Res02 : Bool; // Reserve Res03 : Bool; // Reserve Res04 : Bool; // Reserve Res05 : Bool; // Reserve Res06 : Bool; // Reserve Res07 : Bool; // Reserve Res10 : Bool; Res11 : Bool; Res12 : Bool; Res13 : Bool; Res14 : Bool; // Reserve Res15 : Bool; // Reserve Res16 : Bool; // Reserve Res17 : Bool; // Reserve END_STRUCT; Rueckmld : Struct RET_VAL_BLKMOV_Sync : Int; // Rückmeldung nach BLKMOV-Aufruf RET_VAL_DL_Weichen_Out : Byte; // Rückmeldung nach DatenOut-Aufruf RET_VAL_Hauptstrang_In : Byte; // Rückmeldung nach Hauptstrangdaten-In-Aufruf RET_VAL_TravelFIFO_In : Byte; // Rückmeldung nach Aufruf RET_VAL_TravelFIFO_Out : Byte; // Rückmeldung nach Aufruf RET_VAL_Teach_OUT : Byte; // Rückmeldung bei Datenlisten-Zugriff RET_VAL_Teach_IN : Byte; // Rückmeldung bei Datenlisten-Zugriff END_STRUCT; Error : "UErrStartSync"; BT_ausgewertet : Bool; // BT wurde schon ausgewertet TeachPunkt : Int; // Punkt zum Ein-Teachen Refpunkt_ausgewertet : Bool; // Referenzpunkt ausgewertet Refpunkt_ok : Bool; // Referenzpunkt erkannt Teachpunkt_ausgewertet : Bool; // Teachpunkt ausgewertet Reset : Bool; // Bereich + FIFO resetten Ink_Flag : Bool; // Laufflag bei Speicherung Ref_Flag : Bool; // Lauf-Flag bei Ref-Inkremente Teach_Flag : Bool; // Lauf-Flag bei Teach-Inkremente Ende_Flag : Bool; // Lauf-Flag bei Synchron-Ende (MT) FIFO_Flag : Bool; // Lauf-Flag bei FIFO-Wechsel (sonst Err) Stop : Bool; // Rein-Separator stoppen Max_raus : Bool; // Max_Wert wurde schon übertragen InkZelle : DInt; // Inkzelle: Sync-Sensor dauernd aktiv Ref_Ink : DInt; // Inkremente bei Referenzpunkt Teach_Ink : DInt; // Inkremente bei Teachpunkt Ende_Ink : DInt; // Inkremente bei Synchron-Ende (MT) FIFO_Ink : DInt; // Inkremente bei FIFO-Wechsel (sonst Err) END_STRUCT; Daten : "UBT_Daten"; Max_Wert : DInt; // Maximal erlaubter Zählwert Lauf_Flag : Bool; // Zähl-Lauf mit Flag ist aktiv Flag_Lauf_fertig : Bool; // Flag-Lauf wurde beendet Ohne_Lauf_fertig : Bool; // Ohne Flag-Lauf wurde beendet Ink_Wert : DInt; // Aktuelle Inkrementalwert Abstands_Ink : DInt; // Abstands-Inkremente nach Teachen Sich_Ink : DInt; // Übrige Inks, bevor dann gestoppt wird ! Reserve : Array[1..1] of Int; END_VAR VAR_TEMP Quelle : Any; // Zeiger, wo Rein-Daten sind Adresse0 : DInt; // Für indirekte Adressierung (Offset 0) Adresse2 : DInt; // Für indirekte Adressierung (Offset 0) Adresse4 : DInt; // Für indirekte Adressierung (Offset 4) Adresse8 : DInt; // Für indirekte Adressierung (Offset 8) Abwurf_DB : Int; // Abwurf-DB für 1.Rückschaltung HaupstranglistenDB : Int; // Aktueller Hauptstranglisten-DB Parameter : Word; // Parameter sB_BT_da : Bool; // Sensor BT ist an Sychronisierstelle ZSW2_ENC : Word; G1_ZSW : Word; G1_XIST1 : DWord; G1_XIST2 : DWord; // Positionswert 2, Sensor 1 STW2_ENC : Word; // Steuerwort 2, Encoder G1_STW : Word; // Steuerwort, Sensor 1 tABS_Resolution : DInt; tInk_Wert : DInt; // Aktueller Zählerwert tSpeicherung : DInt; // Speicherung des aktuellen Zählerwerts (für Neustart) tLastSingelturn_Wert : DInt; // Speicherung des letzten Zählerwerts (für Neustart) tLauf_Flag : Bool; // Zähl-Lauf mit Flag ist aktiv tFlag_Lauf_fertig : Bool; // Flag-Lauf wurde beendet tOhne_Lauf_fertig : Bool; // Ohne Flag-Lauf wurde beendet tNull_laden : Bool; // Zähler mit 0000 laden tQuit : Bool; END_VAR BEGIN NETWORK TITLE = Eingangsvariablen einlesen L #Sync_Nr; U #B_BT_da; = #sB_BT_da; NETWORK TITLE = Parameter-Übergabe L #Sync_Nr; L "MW178";//Einsprung Weichen-DL T #Para.Weichen_DL_DB;//vor Aufruf übergeben! L 0; T #Para.Weichen_DL_DW; NETWORK TITLE = Gesamt: Out-Bits zum Zurücksetzen / temp UN #Dyn.Max_raus;//Max_Wert wurde schon übertragen O #Dyn.BT_ausgewertet;//BT wurde schon ausgewertet S #Antrieb_start;//Kreiselantrieb starten U #ErrQuit; O #Dyn.Reset ;//Bereich + FIFO resetten = #tQuit ;//Für ABS-Modul NETWORK TITLE = Reset //Reset oder Tastendruck: U #ErrQuit; U "Hauptstrang_leer";//Keine Haupstrangdaten vorhanden -> Verklemm-Errors löschen U #Dyn.Error.TravelFIFO_belegt;//Travel-FIFO bleibt belegt S #Dyn.Reset;//Bereich + FIFO resetten U "Hauptstrang_leer";//Keine Haupstrangdaten vorhanden -> Verklemm-Errors löschen U #Dyn.Error.TravelFIFO_leer;//keine Daten im Travel-FIFO eingetragen (Auto-Reset!) UN #Dyn.BT_ausgewertet;//BT wurde schon ausgewertet S #Dyn.Reset;//Bereich + FIFO resetten UN #Dyn.Reset;//Bereich + FIFO resetten SPB en02; SET; R #Dyn.Reset;//Bereich + FIFO resetten R #Dyn.Error.SyncPkt_DL_Err;//Sync-Punkt-Datenliste fehlerhaft R #Dyn.Error.Undef_SyncPkt;//undefinierter Synchronpunkt R #Dyn.Error.BLKMov;//Fehler bei Block kopieren R #Dyn.Error.Sync_Sensor_aktiv;//Sync-Sensor dauernd aktiv R #Dyn.Error.TravelFIFO_Err;//Travel-FIFO fehlerhaft R #Dyn.Error.TravelFIFO_leer;//keine Daten im Travel-FIFO eingetragen R #Dyn.Error.TravelFIFO_belegt;//Travel-FIFO bleibt belegt R #Dyn.Error.Hauptstrangliste_Err;//Hauptstrangliste fehlerhaft R #Dyn.Error.Hauptstrangliste_voll;//Hauptstrangliste ist voll R #Dyn.Error.Inkgeber_Err;//Übergabeliste fehlerhaft R #Dyn.Error.Keine_Hauptstrangliste;//Keine Hauptstrangliste zum Eintragen angegeben R #Dyn.Error.Keine_TeachPktdaten;//Teach-Punkt in Datenliste nicht vorhanden ! R #Dyn.Error.TeachPkt_Datenliste_Err;//Teachdatenliste fehlerhaft R #Dyn.Error.Kein_Parameter; R #Dyn.Error.Err_Parameter; R #Dyn.Error.Inkrementalgeber;//Inkrementalgeberwert ohne Änderung SET; R #Dyn.BT_ausgewertet;//BT wurde schon ausgewertet R #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv R #Dyn.Stop;//Rein-Separator stoppen L 0; T #Dyn.InkZelle;//Inkzelle: Sync-Sensor dauernd aktiv L 0; T #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Err) T #Sich_Ink;//Übrige Inks, bevor dann gestoopt wird ! L 0;//Damit statische Werte neu aus Datenbank geholt werden ! T #SyncPkt.Sync_Nr;//Nummer des Sync-Punktes //Travel-FIFO zurücksetzen: CALL "FifoReset" ( SSDB := #SyncPkt.TravelFIFO_DB , SSDW := #SyncPkt.TravelFIFO_DW , PARA := WORD#16#0000 , //normaler FIFO RE_VAL := "MB199" ); L "MB199"; T #Dyn.Rueckmld.RET_VAL_TravelFIFO_Out; L 0;//Aufruf mit Fehler ? <>I;//Ja ! = #Dyn.Error.TravelFIFO_Err;//Error bei FIFO-Zugriff //Hauptstrang-Daten zurücksetzen: CALL "DatenResetSort" ( SSDB := #SyncPkt.Hauptstrang_DL_DB , SSDW := #SyncPkt.Hauptstrang_DL_DW , RE_VAL := "MB198" ); L #SyncPkt.Hauptstrang_DL_DB; + 1; T #HaupstranglistenDB; CALL "DatenResetSort" ( SSDB := #HaupstranglistenDB , SSDW := #SyncPkt.Hauptstrang_DL_DW , RE_VAL := "MB199" ); L "MB198"; L "MB199"; L 0;//Aufruf mit Fehler ? <>I;//Ja ! = #Dyn.Error.Hauptstrangliste_Err;//Hauptstrang-DL fehlerhaft BEA; en02: NOP 0; NETWORK TITLE = Störungen nach Außen übergeben L 0; T "MW200"; U #Dyn.Error.SyncPkt_DL_Err;//Sync-Punkt-Datenliste fehlerhaft = "M200.0"; U #Dyn.Error.Undef_SyncPkt;//undefinierter Synchronpunkt = "M200.1"; U #Dyn.Error.BLKMov;//Fehler bei Block kopieren = "M200.2"; U #Dyn.Error.Sync_Sensor_aktiv;//Sync-Sensor dauernd aktiv = "M200.3"; U #Dyn.Error.TravelFIFO_Err;//Travel-FIFO fehlerhaft = "M200.4"; U #Dyn.Error.TravelFIFO_leer;//keine Daten im Travel-FIFO eingetragen = "M200.5"; U #Dyn.Error.TravelFIFO_belegt;//Travel-FIFO bleibt belegt = "M200.6"; U #Dyn.Error.Hauptstrangliste_Err;//Hauptstrangliste fehlerhaft = "M200.7"; U #Dyn.Error.Hauptstrangliste_voll;//Hauptstrangliste ist voll = "M201.0"; U #Dyn.Error.Inkgeber_Err;//Inkrementalgeber meldet Störung = "M201.1"; U #Dyn.Error.Keine_Hauptstrangliste;//Keine Hauptstrangliste zum Eintragen angegeben = "M201.2"; U #Dyn.Error.Keine_TeachPktdaten;//Teach-Punkt in Datenliste nicht vorhanden ! = "M201.3"; U #Dyn.Error.TeachPkt_Datenliste_Err;//Teachdatenliste fehlerhaft = "M201.4"; U #Dyn.Error.Kein_Parameter; = "M201.5"; U #Dyn.Error.Err_Parameter; = "M201.6"; U #Dyn.Error.Inkrementalgeber;//Inkrementalgeberwert ohne Änderung = "M201.7"; L "MW200"; T #Error;//Schnittstelle nach Außen //Anzeige Start n. Störung aktivieren: U "Hauptstrang_leer";//Keine Haupstrangdaten vorhanden -> Verklemm-Errors löschen U(; O #Dyn.Error.TravelFIFO_leer;//keine Daten im Travel-FIFO eingetragen O #Dyn.Error.TravelFIFO_belegt;//Travel-FIFO bleibt belegt ); O #Dyn.Error.Sync_Sensor_aktiv;//Sync-Sensor dauernd aktiv O #Dyn.Error.Inkrementalgeber;//Inkrementalgeberwert ohne Änderung S #hStOk; NETWORK TITLE = Statische Sync-Parameter holen L #SyncPkt.Sync_Nr;//Nummer des Synchron-Puntes L #Sync_Nr;//Aufruf-Parameter ==I;//Identisch ? R #Dyn.Error.SyncPkt_DL_Err;//Sync-Punkt-Datenliste fehlerhaft R #Dyn.Error.Undef_SyncPkt;//undefinierter Synchronpunkt SPB en03;//Ja ! T "MW200";//Search-Daten CALL "DatenOut" ( SSDB := #Para.Weichen_DL_DB , SSDW := #Para.Weichen_DL_DW , PARA := WORD#16#0000 , SEARCHDATEN := P#M200.0 , RE_VAL := "MB199" , OUTDATEN := P#M220.0 , Position := "MW196" ); L "MB199"; T #Dyn.Rueckmld.RET_VAL_DL_Weichen_Out;//Rückmeldung bei Datenbank-Zugriff (Gefälle-DL) SPBI G_Ok; U "M199.0"; = #Dyn.Error.SyncPkt_DL_Err;//Sync-Punkt-Datenliste fehlerhaft BEB; SET; S #Dyn.Error.Undef_SyncPkt;//undefinierter Synchronpunkt BEA; //Kennung + Datenbytes G_Ok: SET; R #Dyn.Error.SyncPkt_DL_Err;//Sync-Punkt-Datenliste fehlerhaft R #Dyn.Error.Undef_SyncPkt;//undefinierter Synchronpunkt L 16#1004;//Kennung 10 + Word=04 T %LW0;//Any-Kennung, Datentyp L 40;//Datenwords speichern T %LW2;//Wiederholungen //Quelle-Pointer erzeugen: L 0;//Bei Merker = 0 ! T %LW4;//DB_Nummer L 220;//Adresse SLD 3; L 16#8300_0000;//Kennung: Merker OD; T %LD6;//Kennung, Adresse CALL BLKMOV//Datenliste-Daten speichern {blk_type := 'Variant'} ( SRCBLK := #Quelle , RET_VAL := #Dyn.Rueckmld.RET_VAL_BLKMOV_Sync , DSTBLK := #SyncPkt //#Ziel ); L #Dyn.Rueckmld.RET_VAL_BLKMOV_Sync;//Rückmeldung L 0;//Fehler vorhanden ? <>I;//Ja ! = #Dyn.Error.BLKMov;//Error bei Block kopieren BEB; L #SyncPkt.Sync_Typ;//Synchron-Punkt-Typ = 177 (StartSync) L 177;//Dieser Aufruf-FB ? ==I;//Ja ! SPB en03; SET; S #Dyn.Error.Undef_SyncPkt;//undefinierter Synchronpunkt L 0;//Synchronpunkt ungültig ! T #SyncPkt.Sync_Nr;//Nummer des Synchron-Puntes BEA; en03: NOP 0; NETWORK TITLE = Störungen quittieren UN #ErrQuit; SPB en05; SET; R #Dyn.Error.Keine_TeachPktdaten;//Teach-Punkt in Datenliste nicht vorhanden ! R #Dyn.Error.Hauptstrangliste_voll;//Hauptstrangliste ist voll R #Dyn.Error.Keine_Hauptstrangliste;//Keine Hauptstrangliste zum Eintragen angegeben R #Dyn.Error.TravelFIFO_leer;//keine Daten im Travel-FIFO eingetragen R #Dyn.Error.Inkrementalgeber;//Inkrementalgeberwert ohne Änderung //Kann nur über Reset zurückgesetzt werden: // R #Dyn.Error.SyncPkt_DL_Err //Sync-Punkt-Datenliste fehlerhaft // R #Dyn.Error.Undef_SyncPkt //undefinierter Synchronpunkt // R #Dyn.Error.BLKMov //Fehler bei Block kopieren // R #Dyn.Error.Sync_Sensor_aktiv //Sync-Sensor dauernd aktiv // R #Dyn.Error.TravelFIFO //Travel-FIFO fehlerhaft // R #Dyn.Error.TravelFIFO_belegt //Travel-FIFO bleibt belegt // R #Dyn.Error.Hauptstrangliste_Err //Hauptstrangliste fehlerhaft // R #Dyn.Error.Uebergabeliste_Err //Übergabeliste fehlerhaft // R #Dyn.Error.TeachPkt_Datenliste_Err //Teachdatenliste fehlerhaft // R #Dyn.Error.Keine_TeachPktdaten //Keine Teachdaten in Datenliste vorhanden ! // R #Dyn.Error.Err16 //werden weiter unten quittiert: // R #Dyn.Error.Sync_Sensor_aktiv //Sync-Sensor dauernd aktiv en05: NOP 0; NETWORK TITLE = Auswahl der Wegerfassung L #SyncPkt.Ink_DB;//Zähler-DB L 0;//Sinnvolle Angabe ? <=I;//Nein ! S #Dyn.Error.Kein_Parameter;//Kein Parameter zur Wegerfassung definiert SPB OK; U #SyncPkt.Parameter.InkSim;//Inkrementalgeber simulieren SPB ISim; U #SyncPkt.Parameter.ET200;//Inkremental-Geber mit Zähler-Baugruppe (ET200) SPB ET20; U #SyncPkt.Parameter.Sick_ABS_single; SPB ABS ;//Inkremental-Geber mit Zähler-Baugruppe (FM350/FM450) SPA OK; NETWORK TITLE = Inkremental-Geber über 10ms-Takte simulieren und Antrieb aktiv ISim: L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen SET; R %DBX74.1;//Überlauf R %DBX74.4;//Flag-Lauf wurde beendet R %DBX74.5;//Ohne Flag-Lauf wurde beendet UN #Antrieb_aktiv;//Antrieb ist aktiv SPB chk;//weitere Kontrollen L "MW4";//Anzahl der 10ms-Takte (letzter Zyklus) ITD; L %DBD80; +D;//10ms-Takte dazuaddieren T %DBD80; SPA chk;//weitere Kontrollen //Zähler auf 000 setzen ?: chk: UN %DBX74.6;//Zähler Zero-Load SPB new; SET; R %DBX74.6; L 0; T %DBD70;//Zählerwert zum Setzen SPA load; //Zähler neu setzen ?: new: U %DBX74.0;//Zähler Neustart R %DBX74.0; SPB load; //Zähler-Überlauf ?: L %DBD80;//Aktueller Zählerwert U %DBX75.0;//Speicherung einfrieren SPB nos; T %DBD70;//Speicherung nos: L %DBD76;//Max. Wert erreicht ? <=D;//Nein ! SPB OK; -D;//Restwert als Startwert nehmen ! T %DBD70;//Zählerwert zum Setzen UN %DBX74.3;//Umschaltung Zähl-Lauf ohne-mit-ohne Flag = %DBX74.5;//Ohne Flag-Lauf wurde beendet U %DBX74.3;//Umschaltung Zähl-Lauf ohne-mit-ohne Flag = %DBX74.4;//Flag-Lauf wurde beendet UN %DBX74.3;//Umschaltung Zähl-Lauf ohne-mit-ohne Flag = %DBX74.3; SET; S %DBX74.1;//Überlauf load: L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen L %DBD70;//Zählerwert zum Setzen T %DBD80; SPA OK; NETWORK TITLE = Inkremental-Geber mit Zähler-Baugruppe (ET200) ET20: L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe L 0;//Adresse sinnvoll ? (also ohne Zählerbaugruppe !) <=I;//Nein ! S #Dyn.Error.Err_Parameter;//Parameter für ET200 fehlerhaft SPB OK; //Zählerwert einlesen: L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe SLW 3;//Pointer erzeugen T #Adresse0; L PED[ #Adresse0]; T %DBD80; L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe + 4;//Offset 4 DWs SLW 3;//Pointer erzeugen T #Adresse4; L PED[ #Adresse4]; T %DBD4; L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe + 8; SLW 3;//Pointer erzeugen T #Adresse8; L PED[ #Adresse8]; T %DBD8;//eigentlich doppelt L %DBD80;//Aktueller Zählerwert L %DBD70;//Speicherung (Zählerwert letzter Zyklus) <>D;//ist verändert ! SPB Ok_I; UN #Antrieb_aktiv;//Antrieb ist aktiv O #ErrQuit;//Ablaufstörung quittieren SPB X_I; L #SAVE.Ink_ohne_Zeit;//Zeit Inkremntalgeberwert ohne Änderung [10ms] L "MW4";//Anzahl der 10ms-Takte (letzter Zyklus) +I;//aufaddieren T #SAVE.Ink_ohne_Zeit;//Zeit Inkremntalgeberwert ohne Änderung [10ms] L 50;//500ms ohne Änderung ? >=I;//Ja ! S #Dyn.Error.Inkrementalgeber;//Inkrementalgeberwert ohne Änderung SPA X_I; Ok_I: L 0; T #SAVE.Ink_ohne_Zeit;//Zeit Inkremntalgeberwert ohne Änderung [10ms] //Software-Gate öffnen: X_I: SET; S %DBX16.0;//SW-Gate öffnen //Zähler setzen läuft: U %DBX74.2;//Zähler setzen O %DBX74.7;//Zähler laden ist aktiv R %DBX74.5;//Ohne Flag-Lauf wurde beendet R %DBX74.4;//Flag-Lauf wurde beendet SPB LOAD_Mig; //Zähler auf 000 setzen ?: L 0; T %DBD12;//Zählerwert zum Setzen U %DBX74.6;//Zähler Zero-Load S %DBX74.2;//Zähler setzen SPB LOAD_Mig; //Zähler neu setzen ?: L %DBD70;//Speicherung T %DBD12;//Zählerwert zum Setzen U %DBX74.0;//Zähler Neustart S %DBX74.2;//Zähler setzen SPB LOAD_Mig; //Zähler-Überlauf ?: L %DBD80;//Aktueller Zählerwert L %DBD76;//Max. Wert erreicht ? <=D;//Nein ! SPB Ok_Mig; -D;//Restwert als Startwert nehmen ! T %DBD12;//Zählerwert zum Setzen UN %DBX74.3;//Umschaltung Zähl-Lauf ohne-mit-ohne Flag = %DBX74.5;//Ohne Flag-Lauf wurde beendet U %DBX74.3;//Umschaltung Zähl-Lauf ohne-mit-ohne Flag = %DBX74.4;//Flag-Lauf wurde beendet UN %DBX74.3;//Umschaltung Zähl-Lauf ohne-mit-ohne Flag = %DBX74.3; SET; S %DBX74.1;//Überlauf S %DBX74.2;//Zähler setzen LOAD_Mig: U %DBX74.2;//Zähler setzen = %DBX17.0;//Load_Val SPBN Ok_Mig; //Daten an Zähler senden: L %DBD12; T PAD[ #Adresse0]; Ok_Mig: L %DBW16; T PAW[ #Adresse4]; //Zählerstatus einlesen: L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe + 4;//Offset 4 DWs SLW 3;//Pointer erzeugen T #Adresse4; L PED[ #Adresse4]; T %DBD4; L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen U %DBX74.2;//Zähler setzen U %DBX4.0;//Zähler wird geladen (Modul-Rückmeldung) S %DBX74.7;//Zähler laden ist aktiv R %DBX74.2;//Zähler setzen U %DBX74.7;//Zähler laden ist aktiv UN %DBX4.0;//Zähler wird geladen (Modul-Rückmeldung) R %DBX74.7;//Zähler laden ist aktiv R %DBX74.6;//Zähler Zero-Load R %DBX74.0;//Zähler Neustart R %DBX74.1;//Überlauf U %DBX74.2;//Zähler setzen O %DBX74.7;//Zähler laden ist aktiv O %DBX4.0;//Zähler wird geladen (Modul-Rückmeldung) SPB Fake; L %DBD80;//Aktueller Zählerwert L 0;//Sinnvoller Wert ? <=D;//Nein ! O %DBX75.0;//Speicherung einfrieren SPB OK; L %DBD80;//Aktueller Zählerwert T %DBD70;//Speicherung SPA OK; Fake: L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen L %DBD12;//Während Neusetzen Loadwert übergeben T %DBD80; SPA OK; NETWORK TITLE = Inkremental-Geber mit Zähler-Baugruppe (ABS single) ABS: L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe L 0;//Adresse sinnvoll ? (also ohne Zählerbaugruppe !) <=I;//Nein ! S #Dyn.Error.Err_Parameter;//Parameter für ET200 fehlerhaft SPB OK; //Zählerwert einlesen: L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe SLW 3;//Pointer erzeugen T #Adresse0; L EW[ #Adresse0]; T %DBW0; T #ZSW2_ENC; L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der ET200-Zählerbaugruppe + 2 ;//Offset 2 DWs SLW 3;//Pointer erzeugen T #Adresse2; L EW[ #Adresse2]; T %DBW0; T #G1_ZSW; L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der Zählerbaugruppe + 4;//Offset 4 DWs SLW 3;//Pointer erzeugen T #Adresse4; L ED[ #Adresse4]; T %DBD4; T #G1_XIST1; L #SyncPkt.Ink_HW_Adress;//Hardware-Adresse der Zählerbaugruppe + 8; SLW 3;//Pointer erzeugen T #Adresse8; L ED[ #Adresse8]; T %DBD8; T #G1_XIST2; //Gespeicherte Werte einlesen: L %DBD80; T #tInk_Wert; L %DBD70; T #tSpeicherung; L %DBD16; T #tLastSingelturn_Wert; L %DBD20; T #tABS_Resolution; U %DBX74.3; = #tLauf_Flag; U %DBX74.4; = #tFlag_Lauf_fertig; U %DBX74.5; = #tOhne_Lauf_fertig; U %DBX74.6; = #tNull_laden; CALL "Sick_ABS_single" ( ZSW2_ENC := #ZSW2_ENC , G1_ZSW := #G1_ZSW , G1_XIST1 := #G1_XIST1 , G1_XIST2 := #G1_XIST2 , Resolution := #tABS_Resolution , MaxValue := #Max_Wert , Error_Quit := #tQuit , STW2_ENC := #STW2_ENC , G1_STW := #G1_STW , Inkgeber_Err := #Dyn.Error.Inkgeber_Err , Ink_Wert := #tInk_Wert , Last_Singelturn_Wert := #tLastSingelturn_Wert , Lauf_Flag := #tLauf_Flag , Flag_Lauf_fertig := #tFlag_Lauf_fertig , Ohne_Lauf_fertig := #tOhne_Lauf_fertig , Null_laden := #tNull_laden ); //Steuerwerte übergeben: L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen L #STW2_ENC; T PAW[ #Adresse0]; T %DBW12; L #G1_STW; T PAW[ #Adresse2]; T %DBW14; //Werte speichern: L #tInk_Wert; T %DBD80; T %DBD70; L #tLastSingelturn_Wert; T %DBD16; U #tLauf_Flag; = %DBX74.3; U #tFlag_Lauf_fertig; = %DBX74.4; U #tOhne_Lauf_fertig; = %DBX74.5; U #tNull_laden; = %DBX74.6; //Ändert sich der Inkwert ?: L %DBD80 ;//Aktueller Zählerwert L #tSpeicherung;//Speicherung (Zählerwert letzter Zyklus) <>D;//ist verändert ! SPB ok_I_Mig; UN #Antrieb_aktiv;//Antrieb ist aktiv O #ErrQuit;//Ablaufstörung quittieren SPB OK; L #SAVE.Ink_ohne_Zeit;//Zeit Inkremntalgeberwert ohne Änderung [10ms] L "MW4";//Anzahl der 10ms-Takte (letzter Zyklus) +I;//aufaddieren T #SAVE.Ink_ohne_Zeit;//Zeit Inkremntalgeberwert ohne Änderung [10ms] L 50;//500ms ohne Änderung ? >=I;//Ja ! S #Dyn.Error.Inkrementalgeber;//Inkrementalgeberwert ohne Änderung SPA OK; ok_I_Mig: L 0; T #SAVE.Ink_ohne_Zeit;//Zeit Inkremntalgeberwert ohne Änderung [10ms] NETWORK TITLE = Inkwerte holen //Daten des Inktremental-Gebers übergeben: OK: L #SyncPkt.Ink_DB; T "MW200"; AUF DB[ "MW200"];//Zähler-DB öffnen L %DBD80; T #Ink_Wert; L %DBD76; T #Max_Wert; U %DBX74.3; = #Lauf_Flag; U %DBX74.4; = #Flag_Lauf_fertig; U %DBX74.5; = #Ohne_Lauf_fertig; NETWORK TITLE = Zusatz-DWs an Travel-FIFO übergeben L #SyncPkt.TravelFIFO_DB;//Travel-FIFO: DB-Nr. L 0;//sinnvolle Angabe ? <=I;//Nein ! O(; L #SyncPkt.TravelFIFO_DW;//Einfahr-FIFO: DW-Nr. L 0;//Sinnvolle Angabe ? D; SPBN en04_Mig; -D;//Restwert übernehmen T #Dyn.Ende_Ink;//Inkremente bei Synchron-Ende (MT) UN #Lauf_Flag;//Zähl-Lauf mit Flag ist aktiv = #Dyn.Ende_Flag;//Lauf-Flag bei Synchron-Ende (MT) en04_Mig: NOP 0; NETWORK TITLE = Error: Sync-Sensor dauernd aktiv UN #sB_BT_da;//Sensor Sync ist an Sychronisierstelle O; U #Lauf_Flag;//Neuspeicherung nötig UN #Dyn.Ink_Flag; O; UN #Lauf_Flag;//Neuspeicherung nötig U #Dyn.Ink_Flag; O #ErrQuit;//Störung quittieren O #Dyn.Reset;//Bereich resetten SPB W030; U #Dyn.Error.Sync_Sensor_aktiv;//Sync-Sensor dauernd aktiv SPB En03_Mig; L #Dyn.InkZelle;//Speicherung Sensor frei L 0;//Speicherung vorhanden ? ==D;//Nein ! SPB En03_Mig; L #Ink_Wert;//Aktueller Ink-Wert L #Dyn.InkZelle;//Speicherung Sensor frei -D;//Differenz bilden L 10;//davon 10% /D; L #SyncPkt.Entprellung_B_Sync;//Falls also 10mal Entprellwert, dann >=D; S #Dyn.Error.Sync_Sensor_aktiv;//Sync-Sensor dauernd aktiv SPA En03_Mig; W030: L #Ink_Wert;//Aktueller Ink-Wert T #Dyn.InkZelle;//Speicherung Sensor frei U #Lauf_Flag; = #Dyn.Ink_Flag;//Speicherung Laufflag SET; R #Dyn.Error.Sync_Sensor_aktiv;//Sync-Sensor dauernd aktiv En03_Mig: NOP 0; NETWORK TITLE = Error: Travel-FIFO bleibt voll L #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Stop/Err) L 0;//sinnvolle Angabe ? <=D;//Nein ! O #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv O #Dyn.Error.TravelFIFO_belegt;//Travel-FIFO bleibt belegt SPB w061; U #Dyn.FIFO_Flag;//Flag bei FIFO-Wechsel (sonst Stop/Err) U #Flag_Lauf_fertig;//Flag-Lauf wurde beendet O; UN #Dyn.FIFO_Flag;//Flag bei FIFO-Wechsel (sonst Stop/Err) U #Ohne_Lauf_fertig;//Flag-Lauf wurde beendet SPB w060;//beim Ende des Lauf sind Inkremente uninteressant U #Dyn.FIFO_Flag;//Flag bei FIFO-Wechsel (sonst Stop/Err) U #Lauf_Flag;//Zähl-Lauf mit Flag ist aktiv O; UN #Dyn.FIFO_Flag;//Flag bei FIFO-Wechsel (sonst Stop/Err) UN #Lauf_Flag;//Zähl-Lauf mit Flag ist aktiv SPBN En06; L #Ink_Wert;//Aktuelle Inkrementalwert L #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Stop/Err) Sync-Sensor (in Inkremente) L 0;//sinnvoller Wert ? >D;//Nein ! S #Dyn.Error.TravelFIFO_belegt;//Travel-FIFO bleibt belegt w061: L 0; T #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Err) SET; R #Dyn.FIFO_Flag;//Flag bei FIFO-Wechsel (sonst Err) //Kontrolle, ob Daten im Travel-FIFO vorhanden: CALL "FifoOut" ( SSDB := #SyncPkt.TravelFIFO_DB , SSDW := #SyncPkt.TravelFIFO_DW , PARA := WORD#16#0000 , //Daten lesen OUTDATEN := P#M220.0 , RE_VAL := "MB199" ); L "MB199"; L 0;//Aufruf mit Fehler ? ==I;//Nein ! R #Dyn.Error.TravelFIFO_Err;//Travel-FIFO fehlerhaft SPB w062; U "M199.2";//FIFO ist leer R #Dyn.Error.TravelFIFO_Err;//Travel-FIFO fehlerhaft R #Dyn.Stop;//Rein-Separator stoppen R #Dyn.Error.TravelFIFO_belegt;//Travel-FIFO bleibt belegt SPB En06; SET; S #Dyn.Error.TravelFIFO_Err;//Travel-FIFO fehlerhaft SPA En06; //Inkremente speichern, bei denen spätestens FIFO-Zugriff erfolgen muss (sonst Stop)! w062: L #SyncPkt.Abstand_StartSep;//Abstand Start-Separator <-> Sync-Sensor (in Inkremente) L 0;//sinnvoller Wert ? <=D;//Nein ! SPB En06; TAK; /// L MD 220 //Ink-Wert des nächsten BTs beim Vereinzeln L #Ink_Wert;//Aktueller Ink-Wert +D; T #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Stop) /// U M 224.0 //Lauf-Flag des nächsten BTs beim Vereinzeln U #Lauf_Flag; = #Dyn.FIFO_Flag;//Lauf-Flag bei FIFO-Wechsel (sonst Stop) L #Max_Wert;//Maximal erlaubter Zählwert >D; SPBN En06; -D;//Restwert übernehmen T #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Stop) UN "M224.0";//Lauf-Flag des nächsten BTs beim Vereinzeln (unvertieren) = #Dyn.FIFO_Flag;//Lauf-Flag bei FIFO-Wechsel (sonst Stop) SPA En06; //Inkremente speichern, bei denen spätestens FIFO leer (sonst Err) w063: L #SyncPkt.Abstand_StartSep;//Abstand Start-Separator <-> Sync-Sensor (in Inkremente) L #Ink_Wert;//Aktueller Ink-Wert +D; T #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Err) U #Lauf_Flag; = #Dyn.FIFO_Flag;//Lauf-Flag bei FIFO-Wechsel (sonst Err) L #Max_Wert;//Maximal erlaubter Zählwert >D; SPBN En06; -D;//Restwert übernehmen T #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Err) UN #Lauf_Flag;//Zähl-Lauf mit Flag ist aktiv = #Dyn.FIFO_Flag;//Lauf-Flag bei FIFO-Wechsel (sonst Err) En06: NOP 0; NETWORK TITLE = Sync-Sensor ist aktiv U #sB_BT_da;//BT ist an Sychronisierstelle U #Antrieb_aktiv;///bei H&M UN #Dyn.BT_ausgewertet;//BT wurde schon ausgewertet UN #Dyn.Error.Sync_Sensor_aktiv;//Sync-Sensor dauernd aktiv UN #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv S #Dyn.BT_ausgewertet;//BT wurde schon ausgewertet SPB Sync; SPA Teac; NETWORK TITLE = Daten aus Travel-FIFO holen Sync: CALL "FifoOut" ( SSDB := #SyncPkt.TravelFIFO_DB , SSDW := #SyncPkt.TravelFIFO_DW , PARA := WORD#16#E100 , //Daten lesen + austragen OUTDATEN := #Daten , RE_VAL := "MB199" ); L "MB199"; T #Dyn.Rueckmld.RET_VAL_TravelFIFO_Out; L 0;//Aufruf mit Fehler ? ==I;//Nein ! R #Dyn.Error.TravelFIFO_leer;//keine Daten im Travel-FIFO eingetragen SPB X081; U "M199.2";//FIFO ist leer S #Dyn.Error.TravelFIFO_leer;//keine Daten im Travel-FIFO eingetragen SPB X080; SET; S #Dyn.Error.TravelFIFO_Err;//Travel-FIFO fehlerhaft X080: SPA En18;//Keine Reaktion ist am Besten ! L -1;//Null-Daten übergeben T #Daten.Sort_Info.Teil_IDX; L -1;//in nächsten Bereich fahren T #Daten.Sort_Info.Teil_Ziel; SPA X082; L #Teil_IDX_Old;//Letzte gültige Daten übergeben T #Daten.Sort_Info.Teil_IDX;//nicht mehr, da nur Ärger! L #Teil_Ziel_Old; T #Daten.Sort_Info.Teil_Ziel; SPA X082; //IDX und Ziel speichern (für Travel-FIFO leer,...) X081: L #Daten.Sort_Info.Teil_IDX; T #Teil_IDX_Old; L #Daten.Sort_Info.Teil_Ziel; T #Teil_Ziel_Old; //Travel-FIFO-Daten übergeben: X082: U #Dyn.Stop;//Rein-Separator stoppen SPB X083; L #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Stop) L #Ink_Wert;//Aktueller Ink-Wert -D; T #Sich_Ink;//Übrige Inks, bevor dann gestoppt wird ! X083: L 0; T #Dyn.FIFO_Ink;//Inkremente bei FIFO-Wechsel (sonst Stop) U #SyncPkt.Parameter.Kein_Sync_B; R #Dyn.BT_ausgewertet;//BT wurde schon ausgewertet NETWORK TITLE = Daten für Haupstrangdaten aufbereiten //Sync-Info: L #Ink_Wert;//Aktuelle Inkrementalwert (Start-Sync-Zähler) T #Daten.Start_Ink; U #Lauf_Flag;//Start-Flag übergeben (für evtl. Fahrsync) = #Daten.Start_Flag; //Sort-Info werden von Travel-FIFO übernommen //Quell_Info: L #SyncPkt.Sync_Nr;//Identifikation des Synchron-Punktes T #Daten.Quelle; T #Daten.letzte_Position; NETWORK TITLE = Daten in Haupstrangdaten eintragen L #SyncPkt.Hauptstrang_DL_DB;//Hauptstrang-DB T #HaupstranglistenDB;//Aktueller Hauptstrang-DB L 0;//angegeben ? ==I;//Nein ! S #Dyn.Error.Keine_Hauptstrangliste;//Keine Hauptstrangliste zum Eintragen angegeben SPB En18; UN #Lauf_Flag;//Start-Flag SPB w180; L #SyncPkt.Hauptstrang_DL_DB;//Hauptstrang-DB + 1;//DB+1 bei Flaglauf ! T #HaupstranglistenDB;//Aktueller Hauptstrang-DB w180: CALL "DatenInSort"//Hauptstrangliste mit Lauf-Flag ( SSDB := #HaupstranglistenDB , //Aktueller Hauptstrang-DB SSDW := #SyncPkt.Hauptstrang_DL_DW , INDATEN := #Daten , RE_VAL := "MB199" ); L "MB199"; T #Dyn.Rueckmld.RET_VAL_Hauptstrang_In; U "M199.2";//Hauptstrangliste ist voll S #Dyn.Error.Hauptstrangliste_voll;//Hauptstrangliste ist voll SPB En18; U "M199.7";//Eintrag richtig erfolgt SPB En18; SET; S #Dyn.Error.Hauptstrangliste_Err;//Error bei Hauptstrang-Zugriff En18: NOP 0; NETWORK TITLE = Teach-Modus aktiv ? Teac: L #Dyn.TeachPunkt;//Punkt zum Ein-Teachen L 0;//bekannt ? <>I;//Ja ! U #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv SPB en20; L 0; T #Dyn.Ref_Ink;//Inkremente bei Referenzpunkt T #Dyn.Teach_Ink;//Inkremente bei Teachpunkt T #Abstands_Ink;//Abstands-Inkremente nach Teachen SET; R #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv R #Dyn.Ref_Flag;//Lauf-Flag bei Ref-Inkremente R #Dyn.Teach_Flag;//Lauf-Flag bei Teach-Inkremente R #Dyn.Refpunkt_ausgewertet;//Referenzpunkt ausgewertet R #Dyn.Teachpunkt_ausgewertet;//Teachpunkt ausgewertet R #Dyn.Refpunkt_ok;//Referenzpunkt erkannt BEA; en20: NOP 0; NETWORK TITLE = Ref-Inkremente speichern UN #B_RefPunkt;//Sensor RefBT am Referenzpunkt erkannt R #Dyn.Refpunkt_ausgewertet;//Referenzpunkt ausgewertet U #B_RefPunkt;//Sensor RefBT am Referenzpunkt erkannt UN #Dyn.Refpunkt_ausgewertet;//Referenzpunkt ausgewertet SPBN en21; L #Ink_Wert;//Aktuelle Inkrementalwert T #Dyn.Ref_Ink;//Inkremente bei Referenzpunkt U #Lauf_Flag; = #Dyn.Ref_Flag;//Lauf-Flag bei Ref-Inkremente SET; S #Dyn.Refpunkt_ausgewertet;//Referenzpunkt ausgewertet S #Dyn.Refpunkt_ok;//Referenzpunkt erkannt L 0; T #Dyn.Teach_Ink;//Inkremente bei Teachpunkt T #Abstands_Ink;//Abstands-Inkremente nach Teachen SET; R #Dyn.Teachpunkt_ausgewertet;//Teachpunkt ausgewertet R #Dyn.Teach_Flag;//Lauf-Flag bei Teach-Inkremente en21: NOP 0; NETWORK TITLE = Teach-Inkremente speichern UN #B_TeachPunk;//Sensor RefHaken am Teachpunkt erkannt U #Antrieb_aktiv;//Antrieb aktiv R #Dyn.Teachpunkt_ausgewertet;//Teachpunkt ausgewertet UN #B_TeachPunk;//Sensor RefHaken am Teachpunkt erkannt O #Dyn.Teachpunkt_ausgewertet;//Teachpunkt ausgewertet ON #Dyn.Refpunkt_ok;//Referenzpunkt erkannt ON #Antrieb_aktiv ;//Antrieb aktiv BEB; L #Ink_Wert;//Aktuelle Inkrementalwert T #Dyn.Teach_Ink;//Inkremente bei Teachpunkt U #Lauf_Flag; = #Dyn.Teach_Flag;//Lauf-Flag bei Teach-Inkremente SET; S #Dyn.Teachpunkt_ausgewertet;//Teachpunkt ausgewertet NETWORK TITLE = Abstand ermitteln UN #Dyn.Ref_Flag;//Lauf-Flag bei Ref-Inkremente UN #Dyn.Teach_Flag;//Lauf-Flag bei Teach-Inkremente O; U #Dyn.Ref_Flag;//Lauf-Flag bei Ref-Inkremente U #Dyn.Teach_Flag;//Lauf-Flag bei Teach-Inkremente SPBN w230; //Inkremente im gleichem Lauf: L #Dyn.Teach_Ink;//Inkremente bei Teachpunkt L #Dyn.Ref_Ink;//Inkremente bei Referenzpunkt -D; T #Abstands_Ink;//Abstands-Inkremente nach Teachen SPA en23; w230: L #Max_Wert;//Max. Wert beim Zähler L #Dyn.Ref_Ink;//Inkremente bei Referenzpunkt -D; L #Dyn.Teach_Ink;//Inkremente bei Teachpunkt +D; T #Abstands_Ink; en23: NOP 0; NETWORK TITLE = Teach-Inkremente in Datenbank abspeichern L #Dyn.TeachPunkt;//Punkt zum Ein-Teachen T "MW200"; CALL "DatenOut" ( SSDB := #Para.Weichen_DL_DB , SSDW := #Para.Weichen_DL_DW , PARA := WORD#16#0000 , //Nach angegeben Datensatz suchen SEARCHDATEN := P#M200.0 , RE_VAL := "MB199" , OUTDATEN := P#M200.0 , Position := "MW196" ); L "MB199"; T #Dyn.Rueckmld.RET_VAL_Teach_OUT; U "M199.7";//Datensatz ist vorhanden SPB w240; U "M199.6";//Datensatz ist nicht vorhanden = #Dyn.Error.Keine_TeachPktdaten;//Teach-Punkt in Datenliste nicht vorhanden ! R #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv BEB; SET; R #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv S #Dyn.Error.TeachPkt_Datenliste_Err; BEA; w240: L #Abstands_Ink; L #Para.Offset_RefPunkt;//Offset Refpunkt zu SyncPunkt (für Teachen) +D; T "MD218"; CALL "DatenIn" ( SSDB := #Para.Weichen_DL_DB , SSDW := #Para.Weichen_DL_DW , INDATEN := P#M200.0 , RE_VAL := "MB199" ); UN #Dyn.Status.MoreTeach;//Nächsten Teachpunkt ohne neuen Refpunkt R #Dyn.Refpunkt_ok;//Referenzpunkt erkannt L "MB199"; T #Dyn.Rueckmld.RET_VAL_Teach_IN; U "M199.7";//Datensatz ist vorhanden SPB MORE; U "M199.6";//Datensatz ist nicht vorhanden = #Dyn.Error.Keine_TeachPktdaten;//Teach-Punkt in Datenliste nicht vorhanden ! R #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv BEB; SET; R #Dyn.Status.TeachModus_Aktiv;//Teach-Modus ist aktiv S #Dyn.Error.TeachPkt_Datenliste_Err; BEA; MORE: UN #Dyn.Status.MoreTeach;//Nächsten Teachpunkt ohne neuen Refpunkt BEB; CALL "DatenOut" ( SSDB := #Para.Weichen_DL_DB , SSDW := #Para.Weichen_DL_DW , PARA := WORD#16#FF00 , //Nach nächsten Datensatz suchen SEARCHDATEN := P#M200.0 , RE_VAL := "MB199" , OUTDATEN := P#M200.0 , Position := "MW196" ); L "MW206";//Weichentyp L 178;//Sorterweiche ? <>I;//Nein! O "M199.2" ;//Listenende erreicht! SPB TEND; L "MW200"; T #Dyn.TeachPunkt ;//Punkt zum Ein-Teachen BEA; TEND: L 0; T #Dyn.TeachPunkt; BEA; NETWORK TITLE = Ende // // BE; END_FUNCTION_BLOCK