//#define INBETRIEBNAHME 1 //#define PA_WECHSEL 1 /*@m********************** G.T.S.E. mbH Castrop-Rauxel *********************** * * * Modulname.......: 5335WINS.A * * Projekt.........: MQS-Ablauf Quelltext * * Quellenangabe...: -- * * Status..........: freigegeben am 04.04.2011 von Wolfgang Fehlandt * * * * Erstellungsdatum: 10.03.2011 von: Wolfgang Fehlandt * * Änderungsdatum..: 01.04.2011 von: Wolfgang Fehlandt * * Änderungsdatum..: 04.04.2011 von: Wolfgang Fehlandt * * * * Änderungsdatum..: 03.07.2011 von: Wolfgang Fehlandt * * Prüfauftraganwahl geändert * * - Merken in welcher Darstellung * * - Zurück zum Hauptmenue * * - ggf. dyn. stoppen * * - neuen Auftrag laden * * - neuen Auftrag aktivieren * * - alten Auftrag freigeben * * - zurück in Ursprungsdarstellung * * * * Änderungsdatum..: 08.07.2011 von: Wolfgang Fehlandt * * OperatinMode auch bei neuem Produkt * * merken * * Änderungsdatum..: 09.07.2011 von: Wolfgang Fehlandt * * Color Glider & Scann OK&NOK korregiert * * Glider NOK bei halben Teilen in BOX * * * * Änderungsdatum..: 16.07.2011 von: Wolfgang Fehlandt * * RTT plausibilit't wenn Init nicht OK * * Es darf nach dem Drehen nicht die * * Nestnummer oder hintereinander 2 gerade* * oder 2 ungerade nester folgen * * * * Änderungsdatum..: 23.05.2016 von: Wolfgang Fehlandt * * Changing case 58 ForceCorrection * * * * * * * * * * Beschreibung....: Doppel C-Gestell mit 8-Stationen Rundtisch fuer Keiper * * Schwingspiegelscanner ueber PA aktivieren * * Gleiterabfrage ueber PA aktivieren * * * * Bemerkungen.....: Keiper SHANGHAI * * * * * ***************************************************************************@m*/ #include "function.h" #include "mqs_iorecorder.h" #include "kes.h" #include "io_5335.h" #include "MQS_KEYENCE_BARCODE.H" /*----------------------------------------------------------------------------- lokale Defines 123456789o123456789o123456789o12 -----------------------------------------------------------------------------*/ #define ANZAHL_PROGRAMME 20 #define NAME_TEIL_1 " #01 PQ-34 " #define NAME_TEIL_2 " #02 spare " #define NAME_TEIL_3 " #03 spare " #define NAME_TEIL_4 " #04 spare " #define NAME_TEIL_5 " #05 Alpha beta " #define NAME_TEIL_6 " #06 spare " #define NAME_TEIL_7 " #07 spare " #define NAME_TEIL_8 " #08 spare " #define NAME_TEIL_9 " #09 X156 " #define NAME_TEIL_10 " #10 spare " #define NAME_TEIL_11 " #11 spare " #define NAME_TEIL_12 " #12 K6 " #define NAME_TEIL_13 " #13 5AT " #define NAME_TEIL_14 " #14 spare " #define NAME_TEIL_15 " #15 CQAC " #define NAME_TEIL_16 " #16 V362 " #define NAME_TEIL_17 " #17 spare " #define NAME_TEIL_18 " #18 spare " #define NAME_TEIL_19 " #19 spare " #define NAME_TEIL_20 " #20 spare " #define NAME_TEIL_XX "xx Teilefamilie frei " #define NAME_TEIL_MFU "MFU " #define OPERATING_MODE_UPPER_LOWER 1 #define OPERATING_MODE_UPPER 2 #define OPERATING_MODE_LOWER 3 #define OPERATING_MODE_EXIT 4 #define KEIN_ZYKLUS 0 #define MAX_MILLIVOLT 10000l #define ABLAUF_FLAG_ABLAUF_AKTIV 0x00001 #define ABLAUF_FLAG_NEUE_WARNUNGEN 0x00002 #define ABLAUF_FLAG_VORGELADEN 0x00004 #define ABLAUF_FLAG_FEHLER_QUITTIEREN 0x00008 #define ABLAUF_FLAG_FREIGABE_LADEN_EIN 0x00010 /* Achtung !! Nicht der aktuelle Zustand, sondern nur Flag*/ #define ABLAUF_FLAG_LADEFREIGABE_CHECK 0x00020 #define ABLAUF_FLAG_CHECK_OVERLOAD 0x00040 #define ABLAUF_FLAG_KRITISCHER_ABBRUCH 0x00080 #define ABLAUF_FLAG_ANLAGE_KALIBRIERT 0x00100 #define ABLAUF_FLAG_WEGGEBER_KALIBRIERT 0x00200 #define ABLAUF_FLAG_WEGGEBER_KALIBRIEREN 0x00400 #define ABLAUF_FLAG_PRESSE_OT_AOT 0x00800 #define ABLAUF_FLAG_NICHT_EINDREHEN 0x01000 #define ABLAUF_FLAG_READ_SCANNER 0x02000 #define ABLAUF_FLAG_DONT_READ_SCANNER 0x04000 #define ABLAUF_FLAG_ABLAUF_STOPPEN 0x08000 #define ABLAUF_FLAG_ABLAUF_SAMMELFEHLER 0x10000 #define ABLAUF_FLAG_TERMINATE_PROGRAMME 0x20000 #define TIPPEN_TIPPEN 1 #define TIPPEN_EINZELSCHUSS 2 /*------------------------------------------------------------------------------ Betriebsarten ------------------------------------------------------------------------------*/ #define BETRIEBSART_EINRICHTEN 0x0001 #define BETRIEBSART_EINMANN 0x0002 #define BETRIEBSART_ZWEIMANN 0x0004 #define BETRIEBSART_DAUERLAUF 0x0008 /*------------------------------------------------------------------------------ Initiatoren ------------------------------------------------------------------------------*/ #define INI_HYDRAULIK_EIN 0x0001 #define INI_ENERGIE_EIN 0x0002 #define INI_PRESSE_AUF 0x0004 #define INI_TAUMEL_FIXIERT 0x0008 #define INI_KALIB_EIN 0x0010 #define INI_HYDRAULIK_AUS 0x0040 #define INI_ENERGIE_AUS 0x0080 #define INI_PRESSE_AB 0x0100 #define INI_IST_KALIBRIERT 0x0400 #define INI_BETR_EINRICHTEN 0x1000 #define INI_BETR_EINMANN 0x2000 #define INI_BETR_ZWEIMANN 0x4000 #define INI_BETR_DAUERLAUF 0x8000 #define INI_STEP 25 #define INI_LAST_STEP 26 #define INI_OFFSET_KRAFT 27 /*------------------------------------------------------------------------------ Timer ------------------------------------------------------------------------------*/ #define TIMER_ZYKLUSZEIT 1 #define TIMER_HALTEZEIT 2 #define TIMER_VERWEILZEIT 3 #define TIMER_DELAY 4 #define TIMER_ENERGIE_AUSZEIT 5 #define TIMER_LADEZEIT 6 #define TIMER_MAX_STILLSTANDZEIT 7 #define TIMER_LICHTSCHUTZ 8 #define TIMER_BLINKLICHTER 9 #define TIMER_ARBEITSTAKT 10 #define TIMER_ENERGIE_AUS 11 #define TIMER_MAX_ENTLADEZEIT 12 #define TIMER_UEBERWACHUNG 13 #define TIMER_BLINKLICHT_3 14 #define TIMER_BLINKLICHT_4 15 #define TIMER_KUEHLGERAET_AUS 16 #define TIMER_PNEUMATIK_EIN 17 #define TIMER_FETTEN_1 18 #define TIMER_FETTEN_2 19 /*------------------------------------------------------------------------------ Zeiten ------------------------------------------------------------------------------*/ #define ZYKLUSZEIT 10000l #define VERWEILZEIT 2500l #define ENERGIE_AUSZEIT 30000l #define DELAY_HYDRAULIK 40l #define MAX_ENTLADEZEIT 10000l #define TIME_KUEHLGERAET_AUS 300000l /* 14.05.06 Saw 5Min */ #define TIME_UEBERWACHUNG 5000l /* 16.02.04 Saw Rox Fehler Zeitverzoegert */ #define FETTEN_IMPULSLAENGE_1 1000 #define FETTEN_IMPULSLAENGE_2 1500 #define BEWERTUNG_SCHLECHT (BEWERTUNG_AUSSCHUSS BOR BEWERTUNG_NACHARBEIT) /*------------------------------------------------------------------------------ Korrekturwertberechnung #define ALLE_MERKMALE 0 #define FLAG_KORR_GENERAL_RESET 0x0002 #define FLAG_KORR_SKIP_COUNTER_RESET 0x0004 #define FLAG_KORR_SKIP_COUNTER_NOCHANGE 0x0008 #define FLAG_KORR_EINZELWERT_KORREKTUR 0x0010 #define FLAG_KORR_TREND_IST_MESSWERT 0x0020 #define FLAG_KORR_BERECHNUNG_NEW_INIT 0x8000 ------------------------------------------------------------------------------*/ #define MERKMAL_TEILEKONTROLLE 1 #define KORREKTUR_MERKMAL_KRAFT 5 #define DELTA_U_VORDRUCK 50l /* mV */ #define OFFSET_N_VORKRAFT 500l /* N */ #define MAX_VORKRAFTKORREKTUR 400 /* Prozent */ #define MAX_ANZAHL_KALIBRIERHUEBE 10 #define RESTSPANNUNG 500l #define POSITION_ONLY_GLIDER_CHECK 12000l // hier in µm /*------------------------------------------------------------------------------ anlagenspezifische Maschinenparameter ------------------------------------------------------------------------------*/ #define MASCH_PAR_VORDRUCK 1 #define MASCH_PAR_AOT 2 #define MASCH_PAR_SG 3 #define MASCH_PAR_ANZAHL_IMPULSE 4 #define MASCH_PAR_GLIDER_CHECK 5 #define MASCH_PAR_BARCODE_LABEL_EXIST 6 #define MASCH_PAR_FETTEN_EIN 7 #define MASCH_PAR_MAX_LADEZEIT 8 // nicht in neue Voegaben #define MASCH_PAR_MAX_STILLSTANDZEIT 9 // nicht in neue Voegaben #define MASCH_PAR_TESTAUSGABEN 10 #define MASCH_PAR_KRAFTKORREKTUR 11 #define MASCH_PAR_MAX_KRAFTKORREKTUR 12 #define MASCH_PAR_LADESTROM_IN_PROZENT 13 #define MASCH_PAR_DREHTISCH_AUS 14 #define MASCH_PAR_OHNE_ENERGIE 15 // todo #define MASCH_PAR_TIPPBETRIEB 16 #define MASCH_PAR_ARBEITSTAKT 17 #define MASCH_PAR_ANZ_BIS_TAKTENDE 18 #define MASCH_PAR_VORGABE_ELEKTRODE_OBEN 19 #define MASCH_PAR_VORGABE_ELEKTRODE_UNTEN 20 #define MASCH_PAR_VORGABE_ELEKTRODE_WKZ 21 #define MASCH_PAR_WARNUNG_ELEKTRODE_OBEN 22 #define MASCH_PAR_WARNUNG_ELEKTRODE_WKZ 23 #define MASCH_PAR_NEST_NUMMER_WELDED 24 // wird fuer SQL Datenbank gebraucht, Nummer darf NICHT geaendert werden #define MASCH_PAR_MACHINE_NUMMER_WELDED 25 // wird fuer SQL Datenbank gebraucht, Nummer darf NICHT geaendert werden #define MASCH_PAR_RESEULT_PART_WELDED 26 // wird fuer SQL Datenbank gebraucht, Nummer darf NICHT geaendert werden #define MASCH_PAR_RTT_ROTATION 27 #define MASCH_PAR_MFU 28 /*------------------------------------------------------------------------------ Trigger ------------------------------------------------------------------------------*/ #define TRIGGER_MP_TIPPBETRIEB 1 #define TRIGGER_TASTE_QUITTIERUNG 2 #define TRIGGER_TEIL_IN_NIO_BOX_1 3 #define TRIGGER_TEIL_IN_NIO_BOX_2 4 #define TRIGGER_ENERGIE_AUS 5 #define TRIGGER_ENERGIE_EIN 6 #define TRIGGER_TAUMEL_FIXIEREN 7 //#define TRIGGER_HYDRAULIK_AUS 8 #define TRIGGER_TASTE_TEST 9 #define TRIGGER_LICHTSCHRANKE_1_FREI 10 #define TRIGGER_LICHTSCHRANKE_2_FREI 11 #define TRIGGER_START_TRIGGER_1 12 #define TRIGGER_START_TRIGGER_2 13 #define TRIGGER_TASTE_TRIGGER_1 14 #define TRIGGER_TASTE_TRIGGER_2 15 #define TRIGGER_STOPP_TRIGGER_1 16 #define TRIGGER_STOPP_TRIGGER_2 17 #define TRIGGER_TASTE_PA_WECHSEL 18 #define TRIGGER_OBERELEKTRODE_EINGEBAUT 19 #define TRIGGER_OBERELEKTRODE_AUSGEBAUT 20 #define TRIGGER_PULS_GREASING_VALVE_1 21 #define TRIGGER_PULS_GREASING_VALVE_2 22 #define TRIGGER_READ_SCANNER 23 #define TRIGGER_KALIB_SCANNER 24 #define TRIGGER_RESET_PARTS_ON_TABLE 25 #define TRIGGER_BARCODE_RECEIVED 90 #define TRIGGER_BARCODE_KALIB_IO 91 #define TRIGGER_BARCODE_KALIB_NIO 92 #define TASTE_TEST ' ' /*------------------------------------------------------------------------------ Fehler die waehrend des Ablaufes auftreten koennen 123456789o123456789o123456789o12 ------------------------------------------------------------------------------*/ #define A_FEHLER_ELEKTRODENWECHSEL 0x00000001l /* China Bit 1 in AktuelleFehler_1 */ /*------------------------------------------------------------------------------ fuer anlagenspezifische Fehlermeldungen ------------------------------------------------------------------------------*/ #define FEHLER_VORKRAFT_NIO 51 #define FEHLER_LADEZEIT_UEBERWACHUNG 52 #define FEHLER_PLAUSIBILITAET_SCHUETZ 53 #define FEHLER_PLAUSIBILITAET_LADEFREIGABE 54 #define FEHLER_LADEUEBERWACHUNG 55 #define FEHLER_SCHUTZKLAPPE 56 #define FEHLER_PRESSE_UNTER_UT 57 #define FEHLER_FREI_58 58 #define FATALER_FEHLER_ANLAGE_STOP_1 59 #define FATALER_FEHLER_ANLAGE_STOP_2 60 #define FEHLER_TEILEKONTROLLE_NIO 61 #define FEHLER_KRAFT_UNDODER_ENERGIE_NIO 62 #define INFO_ELEKTRODENWECHSEL 63 #define FEHLER_FREI_64 64 #define FEHLER_FREI_65 65 #define FEHLER_SCHWEISSKRAFT_NIO_95 66 #define FEHLER_ENERGIE_NICHT_GELADEN_95 67 #define FEHLER_KEINE_STROMAUSLOESUNG 68 #define FEHLER_ZYKLUSZEIT_UEBERSCHRITTEN 69 #define FEHLER_BEI_PRESSE_AB 70 // Frei #define FEHLER_WEGGEBER_NICHT_KALIBRIERT 71 // Frei #define FEHLER_PLAUSIBILITAET_NIEDERHALTER 72 // Todo #define FEHLER_FIXIERUNG_NICHT_OBEN 73 #define FEHLER_POSITION_AOT 74 // Todo #define FEHLER_MAX_NIO 75 // Todo #define INFO_MP_TIPPBETRIEB_AKTIV 76 #define FEHLER_ENERGIE_NICHT_EIN 77 #define FEHLER_KRAFTKALIBRIERUNG_MAX_ANZ 78 #define FEHLER_SCHWEISSSTELLE_UNBEKANNT 79 #define FEHLER_HYDRAULIK_NICHT_EIN 80 #define FEHLER_NICHT_KALIBRIERT 81 #define FEHLER_PRESSE_AB_SG 82 #define FEHLER_ELEKTRODE_FEHLT 83 #define FEHLER_RTT_GLEICHES_NEST 84 #define FEHLER_RTT_NHALTER_NICHT_OBEN 85 #define FEHLER_RTT_FIXIERUNG_NICHT_OBEN 86 #define FEHLER_RTT_PRESSE_NICHT_OT_AOT 87 #define FEHLER_WKZ_NICHT_IN_POS 88 #define FEHLER_PLAUSI_GLEITER_NICHT_LOW 89 #define FEHLER_MESSUNG_ERROR_HW 90 #define FEHLER_MESSUNG_KRAFT_NIO 91 #define FEHLER_MESSUNG_ENERGIE_NIO 92 #define FEHLER_MESSUNG_TIMEOUT_QUITTIERUNG 93 #define FEHLER_MESSUNG_QUITTIERUNG_HIGH 94 #define FEHLER_MESSUNG_UNBEKANNT 95 #define FEHLER_KALIBRIERUNG_VORKRAFT 101 #define FEHLER_MAX_KRAFTKORREKTUR 102 #define FEHLER_ENERGIE_ENTLADEZEIT 103 #define FEHLER_ENERGIE_AUSZEIT 104 #define FEHLER_ELEKTRODENWECHSEL 105 #define FEHLER_MAX_KRAFTKORREKTUR_10V 106 // Frei #define FEHLER_FEDERPAKET_NIO_UT 107 #define FEHLER_FEDERPAKET_NIO_OT 108 #define FEHLER_GLEITER_NIO 109 #define FEHLER_RTT_2_MAL_UNGERADES_NEST 110 #define FEHLER_RTT_2_MAL_GERADES_NEST 111 #define TIME_DELAY_UEBERWACHUNG_F_LOW_1 0x0001 #define TIME_DELAY_UEBERWACHUNG_F_LOW_2 0x0002 #define TIME_DELAY_UEBERWACHUNG_F_LOW_3 0x0004 #define TIME_DELAY_UEBERWACHUNG_F_LOW_4 0x0008 #define TIME_DELAY_UEBERWACHUNG_F_LOW_5 0x0010 #define TIME_DELAY_UEBERWACHUNG_F_LOW_6 0x0020 #define TIME_DELAY_UEBERWACHUNG_F_LOW_7 0x0040 #define TIME_DELAY_UEBERWACHUNG_W_LOW_1 0x0080 #define TIME_DELAY_UEBERWACHUNG_W_LOW_2 0x0100 #define TIME_DELAY_UEBERWACHUNG_W_LOW_3 0x0200 #define TIME_DELAY_UEBERWACHUNG_F_HIGH_1 0x0400 #define TIME_DELAY_UEBERWACHUNG_W_HIGH_1 0x0800 #define REGISTER_FEHLER_TEILEKONTROLLE 0b100 #define KALIB_DATEI "KALIB.ENV" /*------------------------------------------------------------------------------ Zaehler verwalten ------------------------------------------------------------------------------*/ #define FILE_NAME_COUNTER "COUNTER.DAT" #define COUNTER_OFFSET_TOTAL (-1) #define COUNTER_OFFSET_IO 0 #define COUNTER_OFFSET_NIO 1 #define COUNTER_OFFSET_AB 2 #define COUNTER_INDEX_OBEN 1 #define COUNTER_INDEX_UNTEN 2 #define COUNTER_INDEX_TOTAL 35 #define COUNTER_INDEX_TOTAL_IO 36 #define COUNTER_INDEX_TOTAL_NIO 37 #define COUNTER_INDEX_VORGABE_OBEN 38 #define COUNTER_INDEX_VORGABE_UNTEN 39 #define COUNTER_INDEX_VORGABE_TOOL 40 #define COUNTER_INDEX_WARNUNG_OBEN 41 #define COUNTER_INDEX_WARNUNG_UNTEN 42 #define COUNTER_INDEX_WARNUNG_TOOL 43 #define COUNTER_INDEX_REPAIR_BIN 50 #define MAX_COUNTER 43 #define INI_FIRST_COUNTER 51 #define START_INI_RTT 40 #define IniInstruction_CCW 48 #define IniInstruction_CW 49 #define ZYKLUS_10_TEILEKONTROLLE 10 #define SCAN_UNGERADE_NESTER 0x0001 #define SCAN_GERADE_NESTER 0x0002 #define CREATE_UNGERADE_NESTER 0x0004 #define CREATE_GERADE_NESTER 0x0008 #define COPY_UNGERATE_TO_GERADE_NESTER 0x0010 #define BILD_NAME_KALIB_STATUS "KALIB_STATUS" #define BILD_BILD_DAUMEN_IO "\\MQSWIN\\DATA\\IMAGES\\DAUMEN_IO.PNG" #define BILD_BILD_DAUMEN_NIO "\\MQSWIN\\DATA\\IMAGES\\DAUMEN_NIO.PNG" #define ENV_RTT 10 #define RTT_FLAG_TEIL_VORHANDEN 0x00001 #define RTT_FLAG_ID_OK 0x00002 #define RTT_FLAG_ID_NOK 0x00004 #define RTT_FLAG_ID_GLIDER_OK 0x00008 #define RTT_FLAG_ID_GLIDER_NOK 0x00010 #define RTT_FLAG_WELDING_OK 0x00020 #define RTT_FLAG_WELDING_NOK 0x00040 #define RTT_FLAG_PART_CONTROL_NOK 0x00080 #define RTT_FLAG_UB_WELDED_OK 0x00100 #define RTT_FLAG_MUSS_LEER_SEIN 0x10000 #define TRIGGER_NR_MOUSE_GREASING_1 1 #define TRIGGER_NR_MOUSE_GREASING_2 2 #define TRIGGER_NR_MOUSE_READ_SCANNER 3 #define TRIGGER_NR_MOUSE_KALIB_SCANNER 4 #define TRIGGER_NR_FREE_5 5 #define TRIGGER_NR_FREE_6 6 #define TRIGGER_NR_FREE_7 7 #define TRIGGER_NR_FREE_8 8 #define TRIGGER_NR_FREE_9 9 #define TRIGGER_NR_RESET_PARTS_ON_TURNTABLE 10 /*@f********************** G.T.S.E. mbH Castrop-Rauxel *********************** * * * Funktionsname...: init * * * * Kurzerklaerung...: Initialisierungsfunktion * * * * Beschreibung....: Initiallisirungen fuer Ablaufsteuerung vornehmen * * * * Bemerkungen.....: Keine * * * * Returns.........: VOID * * * ***************************************************************************@f*/ init () begin int PlausiFehler ; int HardwareIndex ; int BarcodeBit ; int Parameterreihe ; int CodeType ; int ScanAnzahl ; int LesezeitMS ; long IniInstruction ; long LastOperatingMode ; long OperatingMode ; long LastPaNummer ; long PaNummer ; long Stoerung ; long FehlerNr ; long DestNest ; long DestValue ; long FromNest ; long FromValue ; long LastNestNr ; long Ini ; long RTTStep ; long ScannerMode ; long QuellNest ; long ZielNest ; long DebugFlag ; long OffsetKraft ; long OffsetVorKraft ; // long OffsetSpannung ; // long OffsetSpannungVordruck ; // long FaktorDruckGeber ; long SpannungEnergie1ImpulsPA1 ; long SpannungEnergie1ImpulsPA2 ; long OldPosition ; long AktuellePosition ; long LongValue ; long AktuelleFehler ; long AktuelleFehler_1 ; long LastFehler ; long AktuelleWarnungen ; long LastWarnungen ; long ArbeitsTakt ; unsigned int AktuelleInis ; unsigned int LastInis ; // long Eilkraft ; // long SpannungDruckVergleich ; // long SpannungVordruckVergleich ; long SpannungEnergieSoll ; long EnergieIstWert ; // long SpannungEnergieMin ; // long TZwischenImpulsen ; long LadeStrom ; long HelpVal ; long CounterIndexInitiator ; long MaxCounterIndex ; long MP_BarcodeLabelExist ; long MP_TurntableTurnsCCW ; long MP_Mfu ; long MP_PositionAOT ; long MP_PositionOT ; long MP_PositionSG ; long MP_FettenAktiv_UB ; long MP_FettenAktiv_LB ; long MP_MaxKraftKorrektur ; int MP_Vorkraft ; int MP_KraftKorrektur ; int MP_Tippbetrieb ; int MP_TippbetriebOn ; int MP_GliderCheck ; int MP_OhneEnergie ; int MP_CountElektrodeOben ; int MP_CountElektrodeUnten ; int MP_CountElektrodeWkz ; int MP_AnzahlNestWechsel ; int MP_AnzahlMaschWechsel ; int Testausgaben ; //Auch MP_ int MP_OhneDrehtisch ; int ElektrodenWechsel ; int Handle ; int TimeFlag ; int FehlerNummer ; int Start ; int Lampe1 ; int Lampe2 ; int BlinkLicht ; int RestTakte ; int LichtSchutzFrei ; int i ; int k ; int von ; int anz ; int KalibCount ; int Ret ; int PA1 ; int PA2 ; int PA1Wahl ; int PA2Wahl ; int Input ; int Anzahl ; int FirstTime ; int DoNotWeld ; int AktPaNr ; int ZustandsTest ; // int TeileKontrolle ; int ZyklusStep ; int OldZyklusStep ; int AnzahlSchweissImpulse ; int SchweissStelle ; int SchweissImpuls ; int AktuellerZyklus ; int Bewertung ; int BewertungZyklus ; int Statistik ; int BetriebsartAktiv ; int BetriebsartGewaehlt ; int AblaufFlag ; // int Eilgang ; int AktScreen ; // int Kraftaufnehmer ; int KraftKalibrierungen ; int KalibFlag ; int NestNr ; int NestVor ; int NestNach ; int CounterIndex ; int AktTaste ; int RTTTakten ; /* int AktuelleWarnungen ;*/ /* int LastWarnungen ;*/ int RegisterNIO ; int RegisterLabelNIO ; int RegisterTK ; int RegisterGleiter ; int AnzahlImpulseMaschpar ; int FehlerIO ; int HaltNachNTakte ; int OldScreen ; int TriggerOberelektrode ; int LampenFlag ; int LadeStromProzent ; // long IN47 ; // long IN48 ; long AktFehlerKanal ; long Eingang ; long Fault ; long Warnung ; long HuellKurve ; long RetImpuls ; long NIOFlag ; long EingriffSeite2Erfolgt ; long AktPaNummer ; /*----------------------------------------------------------------------------- Initialisierungen -----------------------------------------------------------------------------*/ // OffsetSpannung = 0l ; // OffsetSpannungVordruck= 0l ; ZyklusStep = 0 ; BetriebsartAktiv = 0 ; BetriebsartGewaehlt = 0 ; MP_MaxKraftKorrektur = 0 ; MP_OhneDrehtisch = 0 ; MP_Tippbetrieb = FALSE ; MP_TippbetriebOn = FALSE ; MP_GliderCheck = 0x0 ; AblaufFlag = 0x0000 ; AktuelleFehler = 0x0000l ; AktuelleFehler_1 = 0x0000l ; LastFehler = 0xffff ; AktuelleWarnungen = 0x0000l ; LastWarnungen = 0xffff ; AktuelleInis = 0x0000 ; LastInis = 0x5a5a ; PA1 = ERROR ; PA2 = ERROR ; PA1Wahl = ERROR ; PA2Wahl = ERROR ; LastPaNummer = ERROR ; LastOperatingMode = ERROR ; FirstTime = TRUE ; RTTTakten = FALSE ; RestTakte = 0 ; Lampe1 = LOW ; Lampe2 = LOW ; RegisterNIO = 0 ; RegisterTK = 0 ; RegisterGleiter = 0 ; RegisterLabelNIO = 0b0000 ; Bewertung = 0x0000 ; Statistik = FALSE ; DoNotWeld = FALSE ; Fault = 0 ; TimeFlag = 0x0000 ; HaltNachNTakte = 0 ; ElektrodenWechsel = FALSE ; TriggerOberelektrode = 0 ; LampenFlag = 0 ; CounterIndexInitiator = 1 ; AblaufFlag = ABLAUF_FLAG_FEHLER_QUITTIEREN ; /*----------------------------------------------------------------------------- Trigger fuer MP_Tippbetrieb setzen -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_MP_TIPPBETRIEB , TRIGGER_TYPE_IO , IN_TASTE_NEXT_STEP , TRIGGER_PEGEL_POS_EDGE ) ; /*----------------------------------------------------------------------------- Trigger fuer Fehler loeschen -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_TASTE_QUITTIERUNG , TRIGGER_TYPE_IO , IN_TASTE_STOERUNG_QUITTIEREN, TRIGGER_PEGEL_POS_EDGE ) ; /*----------------------------------------------------------------------------- Trigger fuer Fehler loeschen -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_TEIL_IN_NIO_BOX_1 , TRIGGER_TYPE_IO , IN_NIO_BOX_1 , TRIGGER_PEGEL_NEG_EDGE ) ; SetTrigger (TRIGGER_TEIL_IN_NIO_BOX_2 , TRIGGER_TYPE_IO , IN_NIO_BOX_2 , TRIGGER_PEGEL_NEG_EDGE ) ; /*----------------------------------------------------------------------------- Trigger fuer Energie Aus setzen -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_ENERGIE_AUS , TRIGGER_TYPE_IO , IN_ENERGIE_SCHUETZ_EIN , TRIGGER_PEGEL_NEG_EDGE ) ; /*----------------------------------------------------------------------------- Trigger fuer Energie EIN setzen WF 19.08.03 -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_ENERGIE_EIN , TRIGGER_TYPE_IO , IN_ENTLADE_SCHUETZ_EIN , TRIGGER_PEGEL_POS_EDGE ) ; /*----------------------------------------------------------------------------- Trigger Taumel fixieren in BA Einrichten -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_TAUMEL_FIXIEREN , TRIGGER_TYPE_IO , IN_TASTE_FIXIERUNG_TAUMELHERZ, TRIGGER_PEGEL_POS_EDGE ) ; /*----------------------------------------------------------------------------- Trigger definieren (Fuer Testfunction) -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_TASTE_TEST , TRIGGER_TYPE_KEY , TASTE_TEST , TRIGGER_PEGEL_TRUE ) ; /*----------------------------------------------------------------------------- Trigger definieren (LichtSchranke wird frei) -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_LICHTSCHRANKE_1_FREI , TRIGGER_TYPE_IO , IN_LICHTSCHRANKE_1_FREI , TRIGGER_PEGEL_POS_EDGE ) ; SetTrigger (TRIGGER_LICHTSCHRANKE_2_FREI , TRIGGER_TYPE_IO , IN_LICHTSCHRANKE_2_FREI , TRIGGER_PEGEL_POS_EDGE ) ; SetTrigger (TRIGGER_START_TRIGGER_1 , TRIGGER_TYPE_IO , IN_START_TRIGGER_ST_1 , TRIGGER_PEGEL_POS_EDGE ) ; SetTrigger (TRIGGER_STOPP_TRIGGER_1 , TRIGGER_TYPE_IO , IN_START_TRIGGER_ST_1 , TRIGGER_PEGEL_NEG_EDGE ) ; SetTrigger (TRIGGER_STOPP_TRIGGER_2 , TRIGGER_TYPE_IO , IN_START_TRIGGER_ST_2 , TRIGGER_PEGEL_NEG_EDGE ) ; SetTrigger (TRIGGER_TASTE_TRIGGER_1 , TRIGGER_TYPE_IO , IN_START_TASTER_ST_1 , TRIGGER_PEGEL_POS_EDGE ) ; SetTrigger (TRIGGER_START_TRIGGER_2 , TRIGGER_TYPE_IO , IN_START_TRIGGER_ST_2 , TRIGGER_PEGEL_POS_EDGE ) ; SetTrigger (TRIGGER_TASTE_TRIGGER_2 , TRIGGER_TYPE_IO , IN_START_TASTER_ST_2 , TRIGGER_PEGEL_POS_EDGE ) ; /*----------------------------------------------------------------------------- Trigger fuer Pruefauftragwechsel -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_TASTE_PA_WECHSEL , TRIGGER_TYPE_IO , IN_TASTE_AUFTRAG_WECHSELN , TRIGGER_PEGEL_POS_EDGE ) ; /*----------------------------------------------------------------------------- Trigger fuer Oberelektrodewechsel -----------------------------------------------------------------------------*/ SetTrigger (TRIGGER_OBERELEKTRODE_AUSGEBAUT, TRIGGER_TYPE_IO , IN_ELEKTRODE_EINGEBAUT , TRIGGER_PEGEL_NEG_EDGE ) ; SetTrigger (TRIGGER_OBERELEKTRODE_EINGEBAUT, TRIGGER_TYPE_IO , IN_ELEKTRODE_EINGEBAUT , TRIGGER_PEGEL_POS_EDGE ) ; //----------------------------------------------------------------------------- //Trigger auf Barcode empfangen //----------------------------------------------------------------------------- SetTrigger (TRIGGER_BARCODE_RECEIVED , TRIGGER_TYPE_PROTOKOLL , KEYENCE_BARCODE_TRIGGER_DATA_RECEIVED , TRIGGER_ANSCHLUSS_KEYENCE_BARCODE ) ; //----------------------------------------------------------------------------- //Trigger auf Kalibrierung IO //----------------------------------------------------------------------------- SetTrigger (TRIGGER_BARCODE_KALIB_IO , TRIGGER_TYPE_PROTOKOLL , KEYENCE_BARCODE_TRIGGER_KALIB_IO , TRIGGER_ANSCHLUSS_KEYENCE_BARCODE ) ; //----------------------------------------------------------------------------- //Trigger auf Kalibrierung NIO //----------------------------------------------------------------------------- SetTrigger (TRIGGER_BARCODE_KALIB_NIO , TRIGGER_TYPE_PROTOKOLL , KEYENCE_BARCODE_TRIGGER_KALIB_NIO , TRIGGER_ANSCHLUSS_KEYENCE_BARCODE ) ; //----------------------------------------------------------------------------- //Mousetrigger //----------------------------------------------------------------------------- SetTrigger (TRIGGER_PULS_GREASING_VALVE_1, TRIGGER_TYPE_MOUSE, TRIGGER_NR_MOUSE_GREASING_1 ,TRIGGER_MOUSE_PRESSED); SetTrigger (TRIGGER_PULS_GREASING_VALVE_2, TRIGGER_TYPE_MOUSE, TRIGGER_NR_MOUSE_GREASING_2 ,TRIGGER_MOUSE_PRESSED); SetTrigger (TRIGGER_READ_SCANNER , TRIGGER_TYPE_MOUSE, TRIGGER_NR_MOUSE_READ_SCANNER ,TRIGGER_MOUSE_PRESSED); SetTrigger (TRIGGER_KALIB_SCANNER , TRIGGER_TYPE_MOUSE, TRIGGER_NR_MOUSE_KALIB_SCANNER ,TRIGGER_MOUSE_PRESSED); SetTrigger (TRIGGER_RESET_PARTS_ON_TABLE , TRIGGER_TYPE_MOUSE, TRIGGER_NR_RESET_PARTS_ON_TURNTABLE ,TRIGGER_MOUSE_PRESSED); /*----------------------------------------------------------------------------- Neue Programmvorgaben setzen -----------------------------------------------------------------------------*/ Request (REQUEST_PARAMETER, REQUEST_NEW_PARAMETER_SET,0,0,0,0); /*----------------------------------------------------------------------------- gespeicherte Zaehlerstaende laden -----------------------------------------------------------------------------*/ Request (KES_FUNCTION,KES_REQUEST_COUNTER, KES_COUNTER_LOAD_FILE, FILE_NAME_COUNTER,0,0); // Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_SET_DEBUG, 1, 0, 0, 0) ; end /* funktion */ /*@f********************** G.T.S.E. mbH Castrop-Rauxel *********************** * * * Funktionsname...: main * * * * Kurzerklaerung...: Ablaufprocedure * * * * Beschreibung....: Keine * * * * Bemerkungen.....: Keine * * * * Returns.........: VOID * * * ***************************************************************************@f*/ main () begin /*------------------------------------------------------------------------------ Toggle BIT für Taktzeitanalyse, Ausschalten wenn Analyse beendet! if (IO_TestOut (OUT_X_TEST_TAKT) == HIGH) begin IO_Out (OUT_X_TEST_TAKT, LOW); end else begin IO_Out (OUT_X_TEST_TAKT, HIGH); end ------------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------- Funktionen nur einmal ausfuehren, dann nur noch auf variable zugreifen -----------------------------------------------------------------------------*/ AktTaste = GetKey () ; // if (AktTaste == ',') // FirstTime = TRUE ; // if (AktTaste == '=') // ChangeGaugeProgramme ((Provide (PROVIDE_PRUEFAUTRAG_NUMMER,ERROR,0) == PA1) ? PA2 : PA1) ; /*----------------------------------------------------------------------------- Funktionen nur einmal ausfuehren, dann nur noch auf variable zugreifen -----------------------------------------------------------------------------*/ AktScreen = GetScreen () ; /*----------------------------------------------------------------------------- Pruefauftrag wechseln -----------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_TASTE_PA_WECHSEL) == TRUE) begin if (AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV) begin StatusLineSet ("the cycle has to be finished, than push again",0,0); end else begin StartTimer (TIMER_DELAY, 3000l); while ((IO_In (IN_TASTE_AUFTRAG_WECHSELN) == HIGH) AND (GetTimer (TIMER_DELAY))); if (GetTimer (TIMER_DELAY) == 0) begin if (!(AblaufFlag BAND ABLAUF_FLAG_TERMINATE_PROGRAMME)) FirstTime = TRUE ; end else begin ChangeGaugeProgramme ((Provide (PROVIDE_PRUEFAUTRAG_NUMMER,ERROR,0) == PA1) ? PA2 : PA1) ; AblaufFlag BAND= NEG (ABLAUF_FLAG_VORGELADEN) ; end end end /*------------------------------------------------------------------------------ Neue Vorgaben laden, wenn Grundstellung ------------------------------------------------------------------------------*/ if (!(AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV)) begin /*------------------------------------------------------------------------------ erste oder externe PA Anwahl ------------------------------------------------------------------------------*/ if (FirstTime) begin FirstTime = FALSE; OldScreen = AktScreen ; // WF 03.07.2011 aktuelle Darstellung merken DynamicScreen (FALSE) ; // WF 03.07.2011 dynamisierung stoppen SetScreen (SCREEN_MAINMENUE); // WF 03.07.2011 Hauptmenue anspringen while (GetScreen () != SCREEN_MAINMENUE) Wait (100); // WF 03.07.2011 warten bis Hauptmenue do begin Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_RESET, 0, 0, 0, 0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_CAPTION, "operating mode", 0,0,0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_DESCR , "please choose", INPUT_WINDOW_TEXT_SIZE_16,0,0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM , "upper bracket and lower bracket" , 1,0,0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM , "upper bracket only" , 2,0,0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM , "lower bracket only" , 3,0,0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM , "leave programm" , 4,0,0) ; Request (REQUEST_INPUT_WINDOW , INPUT_WINDOW_START , INPUT_WINDOW_TYPE_SELECT, 1 , INPUT_WINDOW_START_WAIT , 0) ; OperatingMode = Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_GET_LAST_INPUT , 0l, 0l, 0l, 0) ; if (Testausgaben) _TestFunction ("OperatingMode = %ld",OperatingMode,0,0,0,0); if ((OperatingMode >= OPERATING_MODE_UPPER_LOWER) AND (OperatingMode < OPERATING_MODE_EXIT)) begin // AblaufFlag BOR= ABLAUF_FLAG_WEGGEBER_KALIBRIEREN ; // AblaufFlag BAND= NEG (ABLAUF_FLAG_WEGGEBER_KALIBRIERT) ; /*----------------------------------------------------------------------------- // Neue Programmvorgaben setzen -----------------------------------------------------------------------------*/ // Request (REQUEST_PARAMETER, REQUEST_NEW_PARAMETER_SET,0,0,0,0); // if (PA1 == PA2) // begin // PA2 = ERROR ; // end // if (PA1 != ERROR) // begin // FreeGaugeProgramme (PA1) ; // PA1 = ERROR; // end // if (PA2 != ERROR) // begin // FreeGaugeProgramme (PA2) ; // PA2 = ERROR ; // end Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_RESET, 0, 0, 0, 0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_CAPTION, "part selection", 0,0,0) ; Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_DESCR , "please choose", INPUT_WINDOW_TEXT_SIZE_16,0,0) ; for (i = 1; i <= ANZAHL_PROGRAMME; ++i) begin switch (i) begin case 1: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_1 , i,0,0) ; break; case 2: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_2 , i,0,0) ; break; case 3: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_3 , i,0,0) ; break; case 4: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_4 , i,0,0) ; break; case 5: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_5 , i,0,0) ; break; case 6: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_6 , i,0,0) ; break; case 7: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_7 , i,0,0) ; break; case 8: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_8 , i,0,0) ; break; case 9: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_9 , i,0,0) ; break; case 10: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_10 , i,0,0) ; break; case 11: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_11 , i,0,0) ; break; case 12: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_12 , i,0,0) ; break; case 13: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_13 , i,0,0) ; break; case 14: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_14 , i,0,0) ; break; case 15: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_15 , i,0,0) ; break; case 16: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_16 , i,0,0) ; break; case 17: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_17 , i,0,0) ; break; case 18: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_18 , i,0,0) ; break; case 19: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_19 , i,0,0) ; break; case 20: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_20 , i,0,0) ; break; default: Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_XX , i,0,0) ; break; end end Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_SET_ITEM ,NAME_TEIL_MFU , i,0,0) ; Request (REQUEST_INPUT_WINDOW , INPUT_WINDOW_START , INPUT_WINDOW_TYPE_SELECT, (AktPaNummer <= 0) ? 1 : AktPaNummer, INPUT_WINDOW_START_WAIT , 0) ; PaNummer = Request (REQUEST_INPUT_WINDOW, INPUT_WINDOW_GET_LAST_INPUT , 0l, 0l, 0l, 0) ; if (Testausgaben) _TestFunction ("PaNummer = %ld",PaNummer,0,0,0,0); if (PaNummer > 0) begin /*--------------------------------------------------------------------------------------------------------- Wurde ein anderes Produkt gewählt ?? ---------------------------------------------------------------------------------------------------------*/ if (PaNummer != LastPaNummer) begin /*--------------------------------------------------------------------------------------------------------- Wenn ja, laden und nachher ggf. falls vorhanden die Aufträge des letzten Produktes freigeben ---------------------------------------------------------------------------------------------------------*/ switch (OperatingMode) begin case OPERATING_MODE_UPPER_LOWER: PA1Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) - 1 , 0,0,0); PA2Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) , 0,0,0); break; case OPERATING_MODE_UPPER: PA1Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) - 1 , 0,0,0); PA2Wahl = PA1Wahl; break; case OPERATING_MODE_LOWER: PA1Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) , 0,0,0); PA2Wahl = PA1Wahl; break; end if (PA1Wahl == ERROR) begin switch (OperatingMode) begin case OPERATING_MODE_UPPER_LOWER: case OPERATING_MODE_UPPER: StatusLineSet ("!! ERROR loading application\\for UPPER bracket !!",2,4); break; case OPERATING_MODE_LOWER: StatusLineSet ("!! ERROR loading application\\for LOWER bracket !!",2,4); break; end Wait (2000); end if ((PA2Wahl == ERROR) AND (OperatingMode == OPERATING_MODE_UPPER_LOWER)) begin StatusLineSet ("!! ERROR loading application\\for LOWER bracket !!",2,4); Wait (2000); end StatusLineSet ("",ERROR,ERROR); /*--------------------------------------------------------------------------------------------------------- Neuer Auftrag fehlerfrei eingelesen ---------------------------------------------------------------------------------------------------------*/ if ((PA1Wahl != ERROR) AND (PA2Wahl != ERROR)) begin AblaufFlag BOR= ABLAUF_FLAG_WEGGEBER_KALIBRIEREN ; AblaufFlag BAND= NEG (ABLAUF_FLAG_WEGGEBER_KALIBRIERT) ; /*--------------------------------------------------------------------------------------------------------- Neue Programmvorgaben setzen ---------------------------------------------------------------------------------------------------------*/ Request (REQUEST_PARAMETER, REQUEST_NEW_PARAMETER_SET,0,0,0,0); /*--------------------------------------------------------------------------------------------------------- Teiletypen merken ---------------------------------------------------------------------------------------------------------*/ LastPaNummer = PaNummer ; LastOperatingMode = OperatingMode ; // WF 08.07.2011 /*--------------------------------------------------------------------------------------------------------- und ersten aktivieren ---------------------------------------------------------------------------------------------------------*/ ChangeGaugeProgramme (PA1Wahl) ; Wait (500); /*--------------------------------------------------------------------------------------------------------- letzte Darstellung aufrufen ---------------------------------------------------------------------------------------------------------*/ SetScreen (OldScreen) ; Wait (500); /*--------------------------------------------------------------------------------------------------------- und altes Produkt, falls vorhanden freigeben ---------------------------------------------------------------------------------------------------------*/ if (PA1 == PA2) begin PA2 = ERROR ; end if (PA1 != ERROR) begin FreeGaugeProgramme (PA1) ; PA1 = ERROR; end if (PA2 != ERROR) begin FreeGaugeProgramme (PA2) ; PA2 = ERROR ; end end end else begin /*--------------------------------------------------------------------------------------------------------- es wurde kein anderes Produkt gewählt ... ---------------------------------------------------------------------------------------------------------*/ if (OperatingMode != LastOperatingMode) begin /*--------------------------------------------------------------------------------------------------------- ... aber eine neue Betriebsart !! ---------------------------------------------------------------------------------------------------------*/ switch (OperatingMode) begin /*--------------------------------------------------------------------------------------------------------- wenn nun Oberteil und Unterteil geschweiss werden sollen... ---------------------------------------------------------------------------------------------------------*/ case OPERATING_MODE_UPPER_LOWER: // upper und lower soll gewschweißt werden /*--------------------------------------------------------------------------------------------------------- ...zuvor jedoch nur das Oberteil geschweißt wurde, muß das Unterteil geladen werden ---------------------------------------------------------------------------------------------------------*/ if (LastOperatingMode == OPERATING_MODE_UPPER) begin #ifdef PA_WECHSEL _TestFunction ("M 1",0,0,0,0,0); #endif PA2Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) , 0,0,0); PA1Wahl = PA1 ; PA1 = ERROR ; // freizugeben ist nichts PA2 = ERROR ; // freizugeben ist nichts end else begin #ifdef PA_WECHSEL _TestFunction ("M 2",0,0,0,0,0); #endif /*--------------------------------------------------------------------------------------------------------- ...zuvor jedoch nur das UNTERTEIL geschweißt wurde, muß das Oberteil geladen werden ---------------------------------------------------------------------------------------------------------*/ PA1Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) - 1 , 0,0,0); PA2Wahl = PA1 ; PA1 = ERROR ; // freizugeben ist nichts PA2 = ERROR ; // freizugeben ist nichts end break; /*--------------------------------------------------------------------------------------------------------- wenn nur Oberteil geschweiss werden soll... ---------------------------------------------------------------------------------------------------------*/ case OPERATING_MODE_UPPER: /*--------------------------------------------------------------------------------------------------------- ...zuvor jedoch das Oberteil und das Unterteil geschweißt wurde, muß das Unterteil freigegeben werden ---------------------------------------------------------------------------------------------------------*/ if (LastOperatingMode == OPERATING_MODE_UPPER_LOWER) begin #ifdef PA_WECHSEL _TestFunction ("M 3",0,0,0,0,0); #endif PA1Wahl = PA1 ; PA2Wahl = PA1 ; PA1 = ERROR ; end else begin #ifdef PA_WECHSEL _TestFunction ("M 4",0,0,0,0,0); #endif /*--------------------------------------------------------------------------------------------------------- ...zuvor jedoch nur das UNTERTEIL geschweißt wurde, muß das Oberteil geladen werden und das Unterteil freigegeben werden ---------------------------------------------------------------------------------------------------------*/ PA1Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) - 1 , 0,0,0); PA2Wahl = PA1Wahl ; PA1 = ERROR ; end break; /*--------------------------------------------------------------------------------------------------------- wenn nur Unterteil geschweiss werden soll... ---------------------------------------------------------------------------------------------------------*/ case OPERATING_MODE_LOWER: /*--------------------------------------------------------------------------------------------------------- ...zuvor jedoch das Oberteil und das Unterteil geschweißt wurde, muß das Unterteil freigegeben werden ---------------------------------------------------------------------------------------------------------*/ if (LastOperatingMode == OPERATING_MODE_UPPER_LOWER) begin #ifdef PA_WECHSEL _TestFunction ("M 5",0,0,0,0,0); #endif PA1Wahl = PA2 ; PA2Wahl = PA2 ; PA2 = ERROR ; end else begin #ifdef PA_WECHSEL _TestFunction ("M 6",0,0,0,0,0); #endif /*--------------------------------------------------------------------------------------------------------- ...zuvor jedoch nur das Oberteil geschweißt wurde, muß das Unterteil geladen werden und das Obertei freigegeben werden ---------------------------------------------------------------------------------------------------------*/ PA1Wahl = Request (REQUEST_PALIST,PALIST_LOAD,(PaNummer * 2) , 0,0,0); PA2Wahl = PA1Wahl ; PA2 = ERROR; end break; end // switch (OperatingMode) #ifdef PA_WECHSEL _TestFunction ("Geladen =PA1 = %d PA2 = %d Wahl = %d %d",PA1,PA2,PA1Wahl,PA2Wahl,0); #endif if (PA1 == PA2) begin PA2 = ERROR ; end if (PA1 != ERROR) begin FreeGaugeProgramme (PA1) ; PA1 = ERROR; end if (PA2 != ERROR) begin FreeGaugeProgramme (PA2) ; PA2 = ERROR ; end /*--------------------------------------------------------------------------------------------------------- und ersten aktivieren ---------------------------------------------------------------------------------------------------------*/ if (PA1Wahl != ERROR) ChangeGaugeProgramme (PA1Wahl) ; else begin if (PA2Wahl != ERROR) ChangeGaugeProgramme (PA2Wahl) ; end Wait (500); /*----------------------------------------------------------------------------- Neue Programmvorgaben setzen -----------------------------------------------------------------------------*/ Request (REQUEST_PARAMETER, REQUEST_NEW_PARAMETER_SET,0,0,0,0); /*--------------------------------------------------------------------------------------------------------- Teiletypen merken ---------------------------------------------------------------------------------------------------------*/ LastOperatingMode = OperatingMode ; /*--------------------------------------------------------------------------------------------------------- letzte Darstellung aufrufen ---------------------------------------------------------------------------------------------------------*/ SetScreen (OldScreen) ; Wait (500); /*--------------------------------------------------------------------------------------------------------- und altes Produkt, falls vorhanden freigeben ---------------------------------------------------------------------------------------------------------*/ end // end // else kein anderes Produkt end // if (PANummer > 0) end else begin if (OperatingMode == OPERATING_MODE_EXIT) // TerminateProgramme() ; begin AblaufFlag BOR= ABLAUF_FLAG_TERMINATE_PROGRAMME; end end end while (((PA1Wahl == ERROR) OR (PA2Wahl == ERROR)) AND (!(AblaufFlag BAND ABLAUF_FLAG_TERMINATE_PROGRAMME)) ) ; PA1 = PA1Wahl ; PA2 = PA2Wahl ; #ifndef PA_WECHSEL if (Testausgaben) #endif _TestFunction ("Geladen =PA1 = %d PA2 = %d",PA1,PA2,0,0,0); StatusLineReset() ; /*----------------------------------------------------------------------------- Ablauf gemaess Pruefplan initialisieren -----------------------------------------------------------------------------*/ ResetCycle(); /*----------------------------------------------------------------------------- Zyklusverwaltung initialisieren -----------------------------------------------------------------------------*/ SetCycle (ERROR, ERROR); ChangeGaugeProgramme (PA2Wahl) ; /*----------------------------------------------------------------------------- Ablauf gemaess Pruefplan initialisieren -----------------------------------------------------------------------------*/ ResetCycle(); /*----------------------------------------------------------------------------- Zyklusverwaltung initialisieren -----------------------------------------------------------------------------*/ SetCycle (ERROR, ERROR); ChangeGaugeProgramme (PA1Wahl) ; end // if (FirstTime) /*------------------------------------------------------------------------------ Vorgaben laden aus Installationsdatei siehe GLA_INST.EXE ------------------------------------------------------------------------------*/ if (Request (REQUEST_PARAMETER, REQUEST_NEW_PARAMETER,0,0,0,0)) begin AblaufFlag BAND= NEG (ABLAUF_FLAG_VORGELADEN) ; AktPaNr = Provide (PROVIDE_PRUEFAUTRAG_NUMMER,ERROR,0); LadeStromProzent = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_LADESTROM_IN_PROZENT); LadeStrom = 10000l * LadeStromProzent / 100l ; // SetModul (MFB2_12BIT_DAC_MODUL, DAC_KANAL_LADESTROM, LadeStrom) ; Request (KES_FUNCTION, KES_SET_ANALOG_OUT, DAC_KANAL_LADESTROM , LadeStrom, 0,0); /* 1 */ MP_Vorkraft = Provide (PROVIDE_MASCHINENPARAMETER, ERROR, MASCH_PAR_VORDRUCK) ; Request (KES_FUNCTION, KES_SET_DATA, KES_SET_VORKRAFT ,MP_Vorkraft * 1000 , 0,0); /*------------------------------------------------------------------------------ Pruefauftrag 1 ------------------------------------------------------------------------------*/ AblaufFlag BAND= NEG (ABLAUF_FLAG_FREIGABE_LADEN_EIN); IO_Out (OUT_FREIGABE_LADEN, LOW); ChangeGaugeProgramme (PA2) ; Request (KES_FUNCTION, KES_SET_CURRENT_KES_IMPULS , 1,1,1,0); //saw 09.05.11 Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, 0,0,0); Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, KES_VORGABE_ENERGIE_MIN_ALL, 0, 0) ; SpannungEnergie1ImpulsPA2 = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_ENERGIE_OUT,KES_GET_VALUE_RAW,0,0); /* 7 */ MP_FettenAktiv_LB = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_FETTEN_EIN ) ; ChangeGaugeProgramme (PA1) ; Request (KES_FUNCTION, KES_SET_CURRENT_KES_IMPULS, 1,1,1,0); //saw 09.05.11 Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, 0,0,0); Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, KES_VORGABE_ENERGIE_MIN_ALL, 0, 0) ; SpannungEnergie1ImpulsPA1 = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_ENERGIE_OUT,KES_GET_VALUE_RAW,0,0); /*------------------------------------------------------------------------------ Vorgaben laden aus Installationsdatei siehe GLA_INST.EXE ------------------------------------------------------------------------------*/ /* 2 */ MP_PositionAOT = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_AOT ) ; /* 3 */ MP_PositionSG = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_SG ) ; Request (KES_FUNCTION, KES_SET_MOVE_PARAMETER , MOVE_PARAMETER_OT , MP_PositionAOT * 1000l + 1000l, 0 , 0) ; Request (KES_FUNCTION, KES_SET_MOVE_PARAMETER , MOVE_PARAMETER_AOT , MP_PositionAOT * 1000l , 0 , 0) ; Request (KES_FUNCTION, KES_SET_AUTO_WECHSEL_EIL_SG, AUTO_WECHSEL_EIL_SG_POSITION, MP_PositionSG * 1000l , 0 , 0) ; /* 5 */ MP_GliderCheck = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_GLIDER_CHECK ) ; /* 6 */ MP_BarcodeLabelExist = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_BARCODE_LABEL_EXIST ) ; /* 7 */ MP_FettenAktiv_UB = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_FETTEN_EIN ) ; /* */ /* 10 */ Testausgaben = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_TESTAUSGABEN ) ; /* 11 */ MP_KraftKorrektur = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_KRAFTKORREKTUR ) ; /* 12 */ MP_MaxKraftKorrektur = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_MAX_KRAFTKORREKTUR ) * 1000l ; /* 14 */ MP_OhneDrehtisch = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_DREHTISCH_AUS ) ; /* 15 */ MP_OhneEnergie = Provide (PROVIDE_MASCHINENPARAMETER , ERROR,MASCH_PAR_OHNE_ENERGIE ) ; /* 16 */ MP_Tippbetrieb = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_TIPPBETRIEB ) ; /* 17 */ ArbeitsTakt = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_ARBEITSTAKT ) ; /* 18 */ HaltNachNTakte = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_ANZ_BIS_TAKTENDE ) ; /* 19 */ MP_CountElektrodeOben = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_VORGABE_ELEKTRODE_OBEN ) ; /* 20 */ MP_CountElektrodeUnten= Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_VORGABE_ELEKTRODE_UNTEN ) ; /* 21 */ MP_CountElektrodeWkz = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_VORGABE_ELEKTRODE_WKZ ) ; Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_SET_COUNTER,COUNTER_INDEX_VORGABE_OBEN , MP_CountElektrodeOben , 0); Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_SET_COUNTER,COUNTER_INDEX_VORGABE_UNTEN , MP_CountElektrodeUnten, 0); Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_SET_COUNTER,COUNTER_INDEX_VORGABE_TOOL , MP_CountElektrodeWkz , 0); /* 22 */ MP_AnzahlMaschWechsel = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_WARNUNG_ELEKTRODE_OBEN ) ; /*CHINA Warnungen getauscht*/ /* */ Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_SET_COUNTER,COUNTER_INDEX_WARNUNG_OBEN ,MP_AnzahlMaschWechsel,0); /* */ Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_SET_COUNTER,COUNTER_INDEX_WARNUNG_UNTEN ,MP_AnzahlMaschWechsel,0); /* 23 */ MP_AnzahlNestWechsel = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_WARNUNG_ELEKTRODE_WKZ ) ; /*CHINA Warnungen getauscht*/ /* */ Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_SET_COUNTER,COUNTER_INDEX_WARNUNG_TOOL ,MP_AnzahlNestWechsel,0); /* 12 */ MP_TurntableTurnsCCW = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_RTT_ROTATION ) ; /* 28 */ MP_Mfu = Provide (PROVIDE_MASCHINENPARAMETER , ERROR, MASCH_PAR_MFU ) ; /*------------------------------------------------------------------------------------------------------------------- Aktuelle Einstellungen ausgeben --------------------------------------------------------------------------------------------------------------------*/ if (Testausgaben) _TestFunction ("REQUEST_NEW_PARAMETER" , 0 , 0,0,0,0); if (Testausgaben) _TestFunction ("Position AOT = %ld" , MP_PositionAOT , 0,0,0,0); if (Testausgaben) _TestFunction ("Position SG = %ld" , MP_PositionSG , 0,0,0,0); // if (Testausgaben) _TestFunction ("Anzahl Impulse = %ld" , MP_AnzahlImpulse , 0,0,0,0); if (Testausgaben) _TestFunction ("Tippbetrieb = %ld" , MP_Tippbetrieb , 0,0,0,0); // if (Testausgaben) _TestFunction ("Ladezeit = %ld" , MP_MaxLadeZeit , 0,0,0,0); // if (Testausgaben) _TestFunction ("Stillstandzeit = %ld" , MP_MaxStillstandZeit , 0,0,0,0); // if (Testausgaben) _TestFunction ("Ohne Energie = %ld" , MP_OhneEnergie , 0,0,0,0); // if (Testausgaben) _TestFunction ("Mit Eilgang = %ld" , MP_MitEilgang , 0,0,0,0); // if (Testausgaben) _TestFunction ("Handbetrieb = %ld" , MP_Handbetrieb , 0,0,0,0); if (Testausgaben) _TestFunction ("MFU Ein = %ld" , MP_Mfu , 0,0,0,0); // if (Testausgaben) _TestFunction ("MFU Zeit = %ld s" , MP_MFUZeit , 0,0,0,0); if (MP_TurntableTurnsCCW) begin IniInstruction = IniInstruction_CCW ; Request (REQUEST_INITIATOR, IniInstruction_CW,REQUEST_INITIATOR_Hide,0,0,0); end else begin IniInstruction = IniInstruction_CW ; Request (REQUEST_INITIATOR, IniInstruction_CCW,REQUEST_INITIATOR_Hide,0,0,0); end ScannerMode = 0; if (MP_OhneDrehtisch == FALSE) begin if (MP_BarcodeLabelExist) begin ScannerMode BOR= SCAN_UNGERADE_NESTER ; end else begin ScannerMode = CREATE_UNGERADE_NESTER ; end ScannerMode BOR= COPY_UNGERATE_TO_GERADE_NESTER ; end else begin ScannerMode = CREATE_GERADE_NESTER ; ScannerMode = CREATE_UNGERADE_NESTER ; end if (MP_Mfu) begin ScannerMode = CREATE_GERADE_NESTER ; ScannerMode BOR= CREATE_UNGERADE_NESTER ; end AnzahlImpulseMaschpar = Provide (PROVIDE_MASCHINENPARAMETER, ERROR, MASCH_PAR_ANZAHL_IMPULSE) ; /*----------------------------------------------------------------------------- Wenn Energie eingeschaltet ist -----------------------------------------------------------------------------*/ if (IO_TestOut (OUT_ENERGIE_EIN) == HIGH) begin /*----------------------------------------------------------------------------- Kleinste Energie ausstellen -----------------------------------------------------------------------------*/ //saw 09.05.11 Ret = Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, KES_VORGABE_ENERGIE_MIN, 0, 0) ; Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, KES_VORGABE_ENERGIE_MIN_ALL, 0, 0) ; /*----------------------------------------------------------------------------- Energie ueberladen ? ----------------------------------------------------------------------------*/ HelpVal = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_ENERGIE,0 ,0,0); if (Testausgaben) _TestFunction ("\nEnergieIstWert = %ld",HelpVal,0,0,0,0); /*----------------------------------------------------------------------------- Energie groesser der kleinsten ? -----------------------------------------------------------------------------*/ if (Request (KES_FUNCTION, KES_CHECK_VORGABE_ENERGIE, 100 , CHECK_VORGABE_MIN, CHECK_ENERGIE_MIN ,0)) begin IO_Out (OUT_FREIGABE_LADEN, LOW) ; IO_Out (OUT_ENERGIE_EIN , LOW) ; end /* if (EnergieIstWert > Request (REQUEST_U_E_MIN_MV, 0,0,0,0,0)) */ end /* if (IO_TestOut (OUT_ENERGIE_EIN) == HIGH) */ Request (KES_FUNCTION, KES_SET_OUT_VORKRAFT, 100l,0, 0, 0) ; end /* if (PrgStatusFlag (MODE_READ_ONLY, 0) BAND PROGRAMM_STATUS_NEUE_VORGABEN) */ end /* if (FirstTime)*/ /*----------------------------------------------------------------------------- Betriebsart kontrollieren -----------------------------------------------------------------------------*/ BetriebsartGewaehlt = (IO_In (IN_BETRIEBSART_DAUERLAUF ) << 3) BOR (IO_In (IN_BETRIEBSART_ZWEIMANN ) << 2) BOR (IO_In (IN_BETRIEBSART_EINMANN ) << 1) BOR (IO_In (IN_BETRIEBSART_EINRICHTEN ) ) ; if (AblaufFlag BAND ABLAUF_FLAG_TERMINATE_PROGRAMME) begin StatusLineSet ("operation was shut down by user leave programm",0,0) ; Wait (2000); StatusLineReset (); Wait (2000); BetriebsartGewaehlt = 0 ; end /*----------------------------------------------------------------------------- Betriebsart gewechselt ? -----------------------------------------------------------------------------*/ if (BetriebsartGewaehlt != BetriebsartAktiv) begin Wait (1000) ; /*----------------------------------------------------------------------------- Betriebsart kontrollieren -----------------------------------------------------------------------------*/ BetriebsartGewaehlt = (IO_In (IN_BETRIEBSART_DAUERLAUF ) << 3) BOR (IO_In (IN_BETRIEBSART_ZWEIMANN ) << 2) BOR (IO_In (IN_BETRIEBSART_EINMANN ) << 1) BOR (IO_In (IN_BETRIEBSART_EINRICHTEN ) ) ; if (BetriebsartGewaehlt != BetriebsartAktiv) begin BetriebsartAktiv = BetriebsartGewaehlt ; Lampe1 = LOW ; Lampe2 = LOW ; AktuelleInis BAND= NEG(INI_BETR_EINRICHTEN ) ; AktuelleInis BAND= NEG(INI_BETR_EINMANN ) ; AktuelleInis BAND= NEG(INI_BETR_ZWEIMANN ) ; AktuelleInis BAND= NEG(INI_BETR_DAUERLAUF ) ; IO_Out (OUT_QUITTIERUNG_START , LOW); IO_Out (OUT_UEBERBRUECKUNG_SCHUTZKLAPPE , LOW); switch (BetriebsartAktiv) begin case BETRIEBSART_DAUERLAUF : AktuelleInis BOR= INI_BETR_DAUERLAUF ; break; case BETRIEBSART_EINMANN : AktuelleInis BOR= INI_BETR_EINMANN ; break; case BETRIEBSART_ZWEIMANN : AktuelleInis BOR= INI_BETR_ZWEIMANN ; break; case BETRIEBSART_EINRICHTEN: AblaufFlag BOR= ABLAUF_FLAG_ABLAUF_STOPPEN ; AktuelleInis BOR= INI_BETR_EINRICHTEN ; SetScreen (SCREEN_USERMASK_1) ; /* kein break */ /*------------------------------------------------------------------------------ Spannungen fuer Energie im Einrichten auf 0 setzen ------------------------------------------------------------------------------*/ Request (KES_FUNCTION,KES_SET_OUT_VORGABE_ENERGIE, 0,0, 0, 0) ; default: /*----------------------------------------------------------------------------- Energie aus -----------------------------------------------------------------------------*/ IO_Out (OUT_ENERGIE_EIN, LOW ) ; break; end /* switch (BetriebsartAktiv) */ /*----------------------------------------------------------------------------- !!!!!!!!!!!!!!!!!!!!!! -----------------------------------------------------------------------------*/ Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_STOP_TRIGGER, HARDWARE_INDEX_1, 0, 0, 0) ; Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_STOP_KALIB , HARDWARE_INDEX_1, KEYENCE_BARCODE_KALIB_REIHENNUMMER_1, 0, 0) ; Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_SET_DEBUG , FALSE, 0, 0, 0) ; end end /* if (BetriebsartGewaehlt != BetriebsartAktiv) */ /*----------------------------------------------------------------------------- Abfragen, die IMMER stattfinden muessen -----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------- NOT_AUS -----------------------------------------------------------------------------*/ if ((IO_In (IN_NOT_HALT ) == LOW ) OR (IO_In (IN_SICHERHEITS_TUER ) == LOW ) ) begin AblaufFlag BOR= ABLAUF_FLAG_ABLAUF_STOPPEN; end else begin if (IO_In (IN_STEUERSPANNUNG_IO) == HIGH) IO_Out (OUT_UEBERBRUECKUNG_SCHUTZKLAPPE, IO_In (IN_OHNE_SCHUTZEINRICHTUNG)); IO_Out (OUT_FREIGABE_PROP_VENTIL , IO_TestOut (OUT_HYDRAULIK_EIN) ); IO_Out (OUT_DRUCKLUFT_EIN , IO_TestOut (OUT_HYDRAULIK_EIN) ); end if (IO_In (IN_SCHUTZKLAPPE) == LOW) Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHUTZKLAPPE,0, 0,0); /*----------------------------------------------------------------------------- Interne Notabschaltung, wenn IO_LADEUEBERWACHUNG kommt -----------------------------------------------------------------------------*/ if (IO_In (IN_LADEUEBERWACHUNG) == LOW) begin /*----------------------------------------------------------------------------- !!! kritischer Fehler setzen, und Ablauf stoppen !!! -----------------------------------------------------------------------------*/ AblaufFlag BOR= ABLAUF_FLAG_KRITISCHER_ABBRUCH ; AblaufFlag BOR= ABLAUF_FLAG_ABLAUF_STOPPEN; Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_LADEUEBERWACHUNG,0, 0,0); end /*----------------------------------------------------------------------------- !!! wurde kritischer Fehler gesetzt, dann Ablauf stoppen !!! -----------------------------------------------------------------------------*/ if (AblaufFlag BAND ABLAUF_FLAG_KRITISCHER_ABBRUCH) begin /*----------------------------------------------------------------------------- ResetFlag setzen -----------------------------------------------------------------------------*/ AblaufFlag BOR= ABLAUF_FLAG_ABLAUF_STOPPEN; Request (REQUEST_ERROR_EXTERN,ERROR_SET, FATALER_FEHLER_ANLAGE_STOP_1,0, 0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET, FATALER_FEHLER_ANLAGE_STOP_1,0, 0,0); end /*----------------------------------------------------------------------------- ResetFlag gesetzt, dann alles abbrechen -----------------------------------------------------------------------------*/ if (AblaufFlag BAND ABLAUF_FLAG_ABLAUF_STOPPEN) begin if (Testausgaben) _TestFunction ("Ablauf Stoppen",0,0,0,0,0); /*----------------------------------------------------------------------------- Zuendimpulsfreigabe zuruecksetzen -----------------------------------------------------------------------------*/ IO_Out (OUT_ZUENDIMPULS , LOW) ; IO_Out (OUT_FREIGABE_ZUENDIMPULS, LOW) ; /*----------------------------------------------------------------------------- Ladefreigabe zuruecksetzen -----------------------------------------------------------------------------*/ IO_Out (OUT_FREIGABE_LADEN , LOW) ; /*----------------------------------------------------------------------------- Energieschuetz aus -----------------------------------------------------------------------------*/ IO_Out (OUT_ENERGIE_EIN , LOW); /*----------------------------------------------------------------------------- Hydraulik aus -----------------------------------------------------------------------------*/ IO_Out (OUT_HYDRAULIK_EIN , LOW); /*------------------------------------------------------------------------------ Spannungen fuer Energie immer auf 0V setzen ------------------------------------------------------------------------------*/ SpannungEnergieSoll = 0; Request (KES_FUNCTION,KES_SET_OUT_VORGABE_ENERGIE, 0,0, 0, 0) ; /*----------------------------------------------------------------------------- Alle Ventile abschalten -----------------------------------------------------------------------------*/ IO_Out (OUT_S1_AUFWAERTS , LOW); IO_Out (OUT_S2_ABWAERTS , LOW); IO_Out (OUT_S3_SICHERHEIT , LOW); IO_Out (OUT_S4_KLEINE_PUMPE , LOW); IO_Out (OUT_S5_DIFFERENTIAL , LOW); IO_Out (OUT_S6_GROSSE_PUMPE , LOW); IO_Out (OUT_NIEDERHALTER_AUF, HIGH); IO_Out (OUT_NIEDERHALTER_AB , LOW); IO_Out (OUT_FIXIERUNG_TAUMEL_EIN , LOW); IO_Out (OUT_FIXIERUNG_TAUMEL_AUS , HIGH); IO_Out (OUT_UEBERBRUECKUNG_SCHUTZKLAPPE , LOW); ZyklusStep = 0 ; AblaufFlag BAND= NEG (ABLAUF_FLAG_ABLAUF_AKTIV ) ; AblaufFlag BAND= NEG (ABLAUF_FLAG_ABLAUF_STOPPEN) ; end /* */ /*----------------------------------------------------------------------------- Heizung Hydraulik Ein -----------------------------------------------------------------------------*/ if ((BetriebsartAktiv != 0) AND (IO_In(IN_STOERUNG_OEL_TEMPERATUR_25C)== LOW) ) begin IO_Out(OUT_HEIZUNG_HYDRAULIK, HIGH); end /*----------------------------------------------------------------------------- Heizung Hydraulik Aus -----------------------------------------------------------------------------*/ if ((BetriebsartAktiv == 0) OR ((IO_In(IN_WARNUNG_OEL_TEMPERATUR_35C )== HIGH) AND (IO_In(IN_STOERUNG_OEL_TEMPERATUR_25C)== HIGH) ) OR (IO_In (IN_NOT_HALT )== LOW ) ) begin IO_Out(OUT_HEIZUNG_HYDRAULIK, LOW); end /*----------------------------------------------------------------------------- Hydraulik Aus -----------------------------------------------------------------------------*/ if ((BetriebsartAktiv == 0) OR (IO_In(IN_STOERUNG_OEL_TEMPERATUR_65C)== LOW) OR (IO_In(IN_STOERUNG_OEL_TEMPERATUR_25C)== LOW) OR (IO_In (IN_NOT_HALT )== LOW) ) begin if (!(AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV)) // WF MS 16.03.2010 begin if (Testausgaben) _TestFunction ("Hydraulik aus",0,0,0,0,0); IO_Out(OUT_HYDRAULIK_EIN, LOW); end end /*----------------------------------------------------------------------------- Funktionen unterscheiden, je nach Betriebsart -----------------------------------------------------------------------------*/ switch (BetriebsartAktiv) begin case BETRIEBSART_EINMANN : case BETRIEBSART_ZWEIMANN : case BETRIEBSART_DAUERLAUF : /*----------------------------------------------------------------------------- Energie ausschalten -----------------------------------------------------------------------------*/ if (IO_In (IN_TASTE_ENERGIE_AUS) == LOW) begin /*------------------------------------------------------------------------------ Energie aus ------------------------------------------------------------------------------*/ IO_Out (OUT_FREIGABE_LADEN , LOW) ; IO_Out (OUT_ENERGIE_EIN , LOW) ; end else begin /*----------------------------------------------------------------------------- Energie einschalten, wenn aus und Hydraulik ein -----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------- Energie Ein Wenn keine Stoerung, kein Ablauf und kein Abbruch -----------------------------------------------------------------------------*/ if ((AktuelleFehler == 0x00) AND /*China*/ (AktuelleFehler_1 == 0x00) AND (AblaufFlag BAND ABLAUF_FLAG_WEGGEBER_KALIBRIERT ) AND (!(AblaufFlag BAND ABLAUF_FLAG_WEGGEBER_KALIBRIEREN)) AND (!(AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV )) AND (!(AblaufFlag BAND ABLAUF_FLAG_KRITISCHER_ABBRUCH )) ) begin /*----------------------------------------------------------------------------- Energie einschalten, wenn aus und Hydraulik ein -----------------------------------------------------------------------------*/ if ((IO_TestOut (OUT_ENERGIE_EIN ) == LOW ) AND (IO_TestOut (OUT_HYDRAULIK_EIN) == HIGH ) ) begin if (IO_In(IN_TASTE_ENERGIE_EIN) == HIGH) begin StartTimer (TIMER_VERWEILZEIT,VERWEILZEIT); do begin Input = IO_In (IN_TASTE_ENERGIE_EIN); end while ((Input == HIGH) AND (GetTimer (TIMER_VERWEILZEIT) > 0l)); /*----------------------------------------------------------------------------- Energieschuetz ein -----------------------------------------------------------------------------*/ if (Input == HIGH) begin /*----------------------------------------------------------------------------- Ist noch geladen ? -----------------------------------------------------------------------------*/ EnergieIstWert = Request (KES_FUNCTION, KES_GET_ANALOG_IN,ADC_KANAL_ENERGIE,0,0,0) ; if (EnergieIstWert < RESTSPANNUNG) begin IO_Out (OUT_ENERGIE_EIN, HIGH) ; StartTimer (TIMER_DELAY, 500l) ; while (GetTimer (TIMER_DELAY)) ; IO_Out (OUT_FREIGABE_ENERGIE_EIN, HIGH ) ; /* CB 12.04.06 Reihenfolge getauscht Energie_Ein mit Freigabe_Energie */ end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ENERGIE_ENTLADEZEIT,0, 0,0); end end /* if (Input == HIGH) */ end /* if (IO_In(IN_TASTE_ENERGIE_EIN) == HIGH) */ end /*if (IO_TestOut (OUT_ENERGIE_EIN) == LOW) */ /*----------------------------------------------------------------------------- Start ? -----------------------------------------------------------------------------*/ Start = FALSE ; Input = FALSE ; switch (BetriebsartAktiv) begin case BETRIEBSART_EINMANN: //_TestFunction ("Check Start",0,0,0,0,0); if ((GetTrigger (TRIGGER_START_TRIGGER_1) == TRUE) OR (GetTrigger (TRIGGER_START_TRIGGER_2) == TRUE) ) begin Start = TRUE; end break; case BETRIEBSART_ZWEIMANN: if (GetTrigger (TRIGGER_START_TRIGGER_1)) Lampe1 = HIGH; if (GetTrigger (TRIGGER_START_TRIGGER_2)) Lampe2 = HIGH; if (GetTrigger (TRIGGER_STOPP_TRIGGER_1)) Lampe1 = LOW ; if (GetTrigger (TRIGGER_STOPP_TRIGGER_2)) Lampe2 = LOW ; //2012-11-20 Saw if ((IO_In (IN_START_TRIGGER_ST_1) == HIGH) AND // (IO_In (IN_START_TRIGGER_ST_2) == HIGH) ) if (((Lampe1) == HIGH) AND ((Lampe2) == HIGH) ) begin Start = TRUE; end break; case BETRIEBSART_DAUERLAUF: if ((GetTrigger (TRIGGER_START_TRIGGER_1) == TRUE) OR (GetTrigger (TRIGGER_START_TRIGGER_2) == TRUE) ) begin AblaufFlag BAND= NEG (ABLAUF_FLAG_NEUE_WARNUNGEN); Start = TRUE; end break; end if (GetTimer (TIMER_BLINKLICHTER) == 0) begin StartTimer (TIMER_BLINKLICHTER,500l); if (Lampe1) IO_Out (OUT_LAMPE_DREHIMPULS_ST1 , !IO_TestOut (OUT_LAMPE_DREHIMPULS_ST1)); else IO_Out (OUT_LAMPE_DREHIMPULS_ST1 , LOW); if (Lampe2) IO_Out (OUT_LAMPE_DREHIMPULS_ST2 , !IO_TestOut (OUT_LAMPE_DREHIMPULS_ST2)); else IO_Out (OUT_LAMPE_DREHIMPULS_ST2 , LOW); end if (Start) begin if (IO_TestOut (OUT_HYDRAULIK_EIN) == HIGH) begin if (IO_TestOut (OUT_ENERGIE_EIN) == HIGH) begin if (IO_In (IN_SCHUTZKLAPPE) == HIGH) begin if (AblaufFlag BAND ABLAUF_FLAG_WEGGEBER_KALIBRIERT) begin if (IO_In (IN_ELEKTRODE_EINGEBAUT) == HIGH) begin ZyklusStep = 1 ; StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; AblaufFlag BOR= ABLAUF_FLAG_ABLAUF_AKTIV ; IO_Out (OUT_QUITTIERUNG_START, HIGH) ; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ELEKTRODE_FEHLT,0, 0,0); end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_NICHT_KALIBRIERT,0, 0,0); end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHUTZKLAPPE,0, 0,0); end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ENERGIE_NICHT_EIN,0, 0,0); end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_HYDRAULIK_NICHT_EIN,0, 0,0); end end end else begin if ((GetTrigger (TRIGGER_START_TRIGGER_1) == TRUE) OR (GetTrigger (TRIGGER_START_TRIGGER_2) == TRUE) ) begin if (AblaufFlag BAND ABLAUF_FLAG_WEGGEBER_KALIBRIEREN) begin if (IO_TestOut (OUT_HYDRAULIK_EIN) == HIGH) begin if (IO_In (IN_ELEKTRODE_EINGEBAUT) == HIGH) begin ZyklusStep = 50 ; SchweissStelle = 0 ; AblaufFlag BOR= ABLAUF_FLAG_ABLAUF_AKTIV ; StartTimer (TIMER_ZYKLUSZEIT,ZYKLUSZEIT) ; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ELEKTRODE_FEHLT,0, 0,0); end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_HYDRAULIK_NICHT_EIN,0, 0,0); end end end end end /* if (IO_In (IN_TASTE_ENERGIE_AUS) == HIGH) */ // Request (101, ZyklusStep, 0,0,0,0); /* kein break */ case BETRIEBSART_EINRICHTEN: /* und teilweise Automatik */ /*----------------------------------------------------------------------------- Hydraulik Aus -----------------------------------------------------------------------------*/ if (IO_In (IN_TASTE_HYDRAULIK_AUS) == LOW) begin if (IO_TestOut (OUT_HYDRAULIK_EIN) == HIGH) StartTimer (TIMER_KUEHLGERAET_AUS, TIME_KUEHLGERAET_AUS); /*------------------------------------------------------------------------------ Hydraulik und Energie aus ------------------------------------------------------------------------------*/ IO_Out (OUT_FREIGABE_LADEN , LOW) ; IO_Out (OUT_ENERGIE_EIN , LOW) ; IO_Out (OUT_HYDRAULIK_EIN , LOW) ; if (AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV) AblaufFlag BOR= ABLAUF_FLAG_ABLAUF_STOPPEN; end /*----------------------------------------------------------------------------- Kein Ablauf aktiv -----------------------------------------------------------------------------*/ if (!(AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV)) begin begin /*----------------------------------------------------------------------------- Hydraulik Ein -----------------------------------------------------------------------------*/ if ((IO_In(IN_TASTE_HYDRAULIK_EIN) == HIGH ) AND (AktuelleFehler == 0x00) AND (AktuelleFehler_1 == 0x00) AND (!(AblaufFlag BAND ABLAUF_FLAG_KRITISCHER_ABBRUCH)) AND (IO_In(IN_NOT_HALT) == HIGH ) ) begin IO_Out (OUT_HYDRAULIK_EIN , HIGH); IO_Out (OUT_KUEHLGERAET_EIN, HIGH); end end /* else if (IO_In(IN_TASTE_HYDRAULIK_AUS)) */ end /* if (!(AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV)) */ /*----------------------------------------------------------------------------- Nur im Einrichten -----------------------------------------------------------------------------*/ if (BetriebsartAktiv == BETRIEBSART_EINRICHTEN) begin /*---------------------------------------------------------------------------- Bewegungen Presse auf und ab wenn kein NOT-Aus und Hydraulik ein -----------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_SET_OUT_VORKRAFT, 100l,0, 0, 0) ; // SetModul (MFB2_12BIT_DAC_MODUL, DAC_DRUCK, Request (REQUEST_U_F_SOLLWERT_MV, 0, 0,0,0,0) + OffsetSpannungVordruck); if ((IO_In (IN_NOT_HALT ) == HIGH) AND (IO_TestOut (OUT_HYDRAULIK_EIN) == HIGH) ) begin /*---------------------------------------------------------------------------- Presse auf -----------------------------------------------------------------------------*/ while ((IO_In (IN_TASTE_PRESSE_AUF ) == HIGH) AND (IO_In (IN_TASTE_PRESSE_AB ) == LOW ) AND (IO_In (IN_PRESSE_OT ) == LOW ) ) begin IO_Out (OUT_S1_AUFWAERTS , HIGH); IO_Out (OUT_S3_SICHERHEIT , HIGH); StartTimer (TIMER_DELAY,DELAY_HYDRAULIK); while (GetTimer (TIMER_DELAY)); IO_Out (OUT_S4_KLEINE_PUMPE , HIGH); end /*----------------------------------------------------------------------------- Bewegung stoppen ------------------------------------------------------------------------------*/ IO_Out (OUT_S4_KLEINE_PUMPE , LOW); IO_Out (OUT_S3_SICHERHEIT , LOW); IO_Out (OUT_S1_AUFWAERTS , LOW); /*---------------------------------------------------------------------------- Presse ab -----------------------------------------------------------------------------*/ while ((IO_In (IN_TASTE_PRESSE_AB ) == HIGH) AND (IO_In (IN_TASTE_PRESSE_AUF ) == LOW ) ) begin if (IO_In (IN_UNTER_UT) == LOW) begin IO_Out (OUT_S2_ABWAERTS , HIGH); IO_Out (OUT_S3_SICHERHEIT , HIGH); StartTimer (TIMER_DELAY,DELAY_HYDRAULIK); while (GetTimer (TIMER_DELAY)); IO_Out (OUT_S4_KLEINE_PUMPE , HIGH); end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_PRESSE_UNTER_UT,0, 0,0); AblaufFlag BAND= NEG ABLAUF_FLAG_ABLAUF_AKTIV; end end /*----------------------------------------------------------------------------- Bewegung stoppen ------------------------------------------------------------------------------*/ IO_Out (OUT_S4_KLEINE_PUMPE , LOW); IO_Out (OUT_S2_ABWAERTS , LOW); IO_Out (OUT_S3_SICHERHEIT , LOW); end /* if (IO_In (IN_NOT_HALT) == HIGH) */ /*----------------------------------------------------------------------------- RTT Takten ------------------------------------------------------------------------------*/ if ((IO_In (IN_TASTE_DREHTISCH_DREHEN) == HIGH) AND (RTTStep == 0)) begin if (MP_OhneDrehtisch) begin StatusLineSet ("turntable switched off \\ see machine parameters '-'",2,4); Wait (2000); StatusLineSet ("",ERROR,ERROR); end RTTTakten = TRUE ; end /*----------------------------------------------------------------------------- Niederhalter Auf / Ab ------------------------------------------------------------------------------*/ if (IO_In (IN_TASTE_NIEDERHALTER_AUF) == HIGH) begin IO_Out (OUT_NIEDERHALTER_AUF , HIGH); IO_Out (OUT_NIEDERHALTER_AB , LOW); end else begin if (IO_In (IN_TASTE_NIEDERHALTER_AB) == HIGH) begin IO_Out (OUT_NIEDERHALTER_AUF , LOW); IO_Out (OUT_NIEDERHALTER_AB , HIGH); end end /*----------------------------------------------------------------------------- Fixierung Taumel Ein / Aus durch Trigger ------------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_TAUMEL_FIXIEREN) == HIGH) begin if (IO_TestOut (OUT_FIXIERUNG_TAUMEL_EIN) == HIGH) begin IO_Out (OUT_FIXIERUNG_TAUMEL_EIN , LOW ); IO_Out (OUT_FIXIERUNG_TAUMEL_AUS , HIGH); end else begin IO_Out (OUT_FIXIERUNG_TAUMEL_EIN , HIGH); IO_Out (OUT_FIXIERUNG_TAUMEL_AUS , LOW ); end end /*------------------------------------------------------------------------------ Elektrodenwechsel quittieren ------------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_OBERELEKTRODE_AUSGEBAUT)) begin ++TriggerOberelektrode; end if (GetTrigger (TRIGGER_OBERELEKTRODE_EINGEBAUT)) begin ++TriggerOberelektrode; end /* LongValue = TriggerOberelektrode; _TestFunction ("\n TriggerOberelektrode=%ld",LongValue,0l,0l,0l,4l); */ IO_Out (OUT_BLASLUFT, IO_TestOut (OUT_NIEDERHALTER_AB)) ; /*------------------------------------------------------------------------------ Nur in der Usermask 5 ------------------------------------------------------------------------------*/ if (AktScreen == SCREEN_USERMASK_5) begin /*------------------------------------------------------------------------------ Fetten Puls 1 ------------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_PULS_GREASING_VALVE_1) == TRUE) begin if (GetTimer (TIMER_FETTEN_1) == 0) StartTimer(TIMER_FETTEN_1,FETTEN_IMPULSLAENGE_1 ); end /*------------------------------------------------------------------------------ Fetten Puls 2 ------------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_PULS_GREASING_VALVE_2) == TRUE) begin if (GetTimer (TIMER_FETTEN_2) == 0) StartTimer(TIMER_FETTEN_2,FETTEN_IMPULSLAENGE_2 ); end /*------------------------------------------------------------------------------ Scanner Testlesen starten ------------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_READ_SCANNER) == TRUE) begin Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_SET_DEBUG , TRUE , 0, 0, 0) ; Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_GET_VERSION , HARDWARE_INDEX_1, 0, 0, 0) ; Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_START_TRIGGER, HARDWARE_INDEX_1, 0, 0, 0) ; end /*------------------------------------------------------------------------------ Trigger empfangen ------------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_BARCODE_RECEIVED) == TRUE) begin _TestFunction ("BarCode received",0,0,0,0,0); HardwareIndex = Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_GET_VALUE , BARCODE_READ_HARDWARE_INDEX , 0, 0, 0) ; Parameterreihe = Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_GET_VALUE , BARCODE_READ_PARAMETER_REIHE , 0, 0, 0) ; CodeType = Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_GET_VALUE , BARCODE_READ_CODE_TYPE , 0, 0, 0) ; ScanAnzahl = Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_GET_VALUE , BARCODE_READ_SCAN_ANZAHL , 0, 0, 0) ; LesezeitMS = Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_GET_VALUE , BARCODE_READ_LESEZEIT_MS , 0, 0, 0) ; _TestFunction ("----------------------------------------------",0,0,0,0,0) ; _TestFunction ("GetLast1 Data HwIndex (%d) Parameterreihe (%d)",HardwareIndex,Parameterreihe,0,0,0) ; _TestFunction ("GetLast2 CodeType (%d) ScanAnzahl (%d) LesezeitMS (%d)",CodeType ,ScanAnzahl,LesezeitMS ,0,0) ; _TestFunction ("----------------------------------------------",0,0,0,0,0) ; Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_SET_DEBUG, FALSE, 0, 0, 0) ; end if (GetTrigger (TRIGGER_KALIB_SCANNER) == TRUE) begin Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_START_KALIB, HARDWARE_INDEX_1, KEYENCE_BARCODE_KALIB_REIHENNUMMER_1, 0, 0) ; end if (GetTrigger (TRIGGER_BARCODE_KALIB_IO) == TRUE) _TestFunction ("Kalib OK",0,0,0,0,0); if (GetTrigger (TRIGGER_BARCODE_KALIB_NIO) == TRUE) _TestFunction ("Kalib NOK",0,0,0,0,0); if (GetTrigger (TRIGGER_RESET_PARTS_ON_TABLE) == TRUE) begin for (HelpVal = 1; HelpVal <= 8; ++HelpVal) PutEnvironment (ENV_RTT + HelpVal, 0) ; end end end /* if (BetriebsartAktiv == BETRIEBSART_EINRICHTEN) */ break; default: break; end /* switch (BetriebsartAktiv) */ /*----------------------------------------------------------------------------- Ablauf Automatikzyklus -----------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------- Statuswerte ausgeben in den analogen Werten MQSWin ausgeben ---------------------------------------------------------------------------------------------*/ // Request (KES_FUNCTION_DARST_TASTER,KES_ABLAUF_VALUE,KES_ABLAUF_VALUE_SET ,KES_ABLAUF_VALUE_1 ,ZyklusStep ,0); // Request (KES_FUNCTION_DARST_TASTER,KES_ABLAUF_VALUE,KES_ABLAUF_VALUE_SET ,KES_ABLAUF_VALUE_2 ,RTTStep ,0); NestNr = 1 + (IO_PortIn (15) >> 1) BAND 0x7; if (AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV) begin /*----------------------------------------------------------------------------- MP_Tippbetrieb ? -----------------------------------------------------------------------------*/ if ((MP_Tippbetrieb == TIPPEN_TIPPEN) AND (MP_TippbetriebOn == TRUE ) ) begin /*----------------------------------------------------------------------------- Schrittkette weitergelaufen ? -----------------------------------------------------------------------------*/ if (OldZyklusStep != ZyklusStep) begin /*----------------------------------------------------------------------------- wenn ja, dann einfrieren (naechten Schritt Speichern) aktuellen Schritt auf 0 setzen -----------------------------------------------------------------------------*/ if (ZyklusStep != 0) begin OldZyklusStep = ZyklusStep; ZyklusStep = 0 ; if (Testausgaben)_TestFunction ("\t\t\t\t\t\t Zyklus:von %3.3d nach %3.3d",OldZyklusStep, ZyklusStep,0,0,0); end else begin /*----------------------------------------------------------------------------- warten auf Trigger MP_Tippbetrieb -----------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_MP_TIPPBETRIEB) == TRUE) begin ZyklusStep = OldZyklusStep; end end end end /*----------------------------------------------------------------------------- Ohne MP_Tippbetrieb -----------------------------------------------------------------------------*/ else begin if (OldZyklusStep != ZyklusStep) begin if (Testausgaben)_TestFunction ("\t\t\t\t\t\t Zyklus:von %3.3d nach %3.3d",OldZyklusStep, ZyklusStep,0,0,0); end end if (IO_In (IN_TASTE_HALT_AM_TAKTENDE) == HIGH) begin if (RestTakte == 0) begin RestTakte = (MP_Mfu == 0) ? HaltNachNTakte : 1 ; end end switch (ZyklusStep) begin /*----------------------------------------------------------------------------- Tisch eingetaktet -----------------------------------------------------------------------------*/ case 1: IO_Out (OUT_NIEDERHALTER_AUF , HIGH) ; IO_Out (OUT_NIEDERHALTER_AB , LOW ) ; IO_Out (OUT_FIXIERUNG_TAUMEL_EIN , LOW ) ; IO_Out (OUT_FIXIERUNG_TAUMEL_AUS , HIGH) ; /* Saw 10.05 */ NestNr = 1 + (IO_PortIn (15) >> 1) BAND 0x7; if ((IO_In (IN_NIEDERHALTER_OBEN ) == HIGH) AND (IO_In (IN_FIXIERUNG_TAUMEL ) == LOW) ) begin if (!(AblaufFlag BAND ABLAUF_FLAG_NICHT_EINDREHEN)) begin HelpVal = FALSE; if ((ScannerMode BAND SCAN_GERADE_NESTER) AND (!(NestNr BAND 0x1)) ) begin HelpVal = TRUE; end else begin if ((ScannerMode BAND SCAN_UNGERADE_NESTER) AND (NestNr BAND 0x1 ) ) begin /* ??saw */ HelpVal = TRUE; end end ZielNest = (NestNr + 4) ; if (ZielNest > 8) ZielNest-=8 ; /*----------------------------------------------------------------------------- Scanner Checken -----------------------------------------------------------------------------*/ if (HelpVal == TRUE) begin if (Testausgaben) _TestFunction ("Step 1 Lese Scannen Nest %d",ZielNest,0,0,0,0); if (AblaufFlag BAND ABLAUF_FLAG_READ_SCANNER) begin AblaufFlag BAND= NEG (ABLAUF_FLAG_READ_SCANNER) ; if ((GetTrigger(TRIGGER_BARCODE_RECEIVED) == FALSE) OR (RegisterLabelNIO BAND 0b1000000 ) ) begin if (Testausgaben) _TestFunction ("Step 1 Kein Barcode erkannt",0,0,0,0,0); ZyklusStep = 20; RegisterLabelNIO BOR= 0b1000000 ; end else begin HelpVal = GetEnvironment (ENV_RTT + ZielNest); HelpVal BOR= RTT_FLAG_ID_OK; PutEnvironment (ENV_RTT + ZielNest, HelpVal); Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_LIST, BARCODE_LIST_PUSH, ZielNest , 0, 0) ; // Aktuellen Barcode als Index 5 der Liste einfuegen // RegisterLabelNIO BAND= NEG(0b10000000); end end else begin if (AblaufFlag BAND ABLAUF_FLAG_DONT_READ_SCANNER) begin HelpVal = GetEnvironment (ENV_RTT + ZielNest); HelpVal BOR= RTT_FLAG_ID_NOK; PutEnvironment (ENV_RTT + ZielNest, HelpVal); AblaufFlag BAND= NEG (ABLAUF_FLAG_DONT_READ_SCANNER) ; // RegisterLabelNIO BAND= NEG(0b10000000); end else begin /*----------------------------------------------------------------------------- Wenn nicht lesen, dann fuer eventuelles Teil vor Presse, ein nicht gelesen setzen -----------------------------------------------------------------------------*/ if (IO_In (IN_TEIL_IN_SCAN_FETT_POSITION == HIGH)) _TestFunction ("WHY ????????????????????????????!",0,0,0,0,0); // DoNotWeld = TRUE; // todo ?????????? ; end end Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_STOP_TRIGGER, HARDWARE_INDEX_1, 0, 0, 0) ; end else begin HelpVal = FALSE; if ((ScannerMode BAND CREATE_GERADE_NESTER) AND (!(NestNr BAND 0x1)) ) begin HelpVal = TRUE; end else begin if ((ScannerMode BAND CREATE_UNGERADE_NESTER) AND (NestNr BAND 0x1 ) ) begin HelpVal = TRUE; end end if ((IO_In (IN_TEIL_IN_SCAN_FETT_POSITION) == LOW) AND (MP_Mfu == LOW)) HelpVal = FALSE; if (HelpVal) begin // Variante 2 Text fuer Barcode setzen mit SPRINT BUFFER if (MP_OhneDrehtisch) begin ZielNest = NestNr ; end if (Testausgaben) _TestFunction ("Pos 1 generiere TeileIdend fuer Nest %d",ZielNest,0,0,0,0); HelpVal = GetEnvironment (ENV_RTT + ZielNest); HelpVal BOR= RTT_FLAG_ID_OK; PutEnvironment (ENV_RTT + ZielNest, HelpVal); Request (REQUEST_SPRINT_TYPE, SPRINT_TYPE_DATETIME, "yy.MM.dd hh:mm:ss", 0, 0, 0) ; Request (REQUEST_SPRINT_VAL_ADD, ZielNest, "-%d", 0, 0, 0) ; Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_LIST, BARCODE_LIST_MANUELL_SET_LAST_DATA , BARCODE_CODE_TYPE_CODE128, BARCODE_LIST_LAST_DATA_SET_SPRINT, 0) ; Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_LIST, BARCODE_LIST_PUSH, ZielNest , 0, 0) ; // Aktuellen Barcode als Index 5 der Liste einfuegen end end if (IO_In (IN_FEDERPAKET_GEDRUECKT) == HIGH) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_FEDERPAKET_NIO_OT,0, 0,0); ZyklusStep = 99; end if (ZyklusStep != 20) begin RTTTakten = TRUE ; RegisterTK = RegisterTK >> 1 ; RegisterNIO = RegisterNIO >> 1 ; RegisterGleiter = RegisterGleiter >> 1 ; RegisterLabelNIO = RegisterLabelNIO >> 1 ; end end if (ZyklusStep != 20) begin StartTimer (TIMER_ARBEITSTAKT, ArbeitsTakt); AblaufFlag BAND= NEG(ABLAUF_FLAG_NICHT_EINDREHEN) ; ++ZyklusStep; end end else begin /*----------------------------------------------------------------------------- Zykluszeitueberwachung -----------------------------------------------------------------------------*/ if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin if (IO_In (IN_NIEDERHALTER_OBEN) == LOW) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_NHALTER_NICHT_OBEN,0, 0,0); end if (IO_In (IN_FIXIERUNG_TAUMEL) == HIGH) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_FIXIERUNG_NICHT_OBEN,0, 0,0); end ZyklusStep = 98 ; end /*if ((GetTimer (TIMER_ZYKLUSZEIT) == 0)*/ end break; case 2: /*----------------------------------------------------------------------------- Tisch eingetaktet -----------------------------------------------------------------------------*/ if (RTTTakten == FALSE) begin /*----------------------------------------------------------------------------- Saw 10.05 Tisch in Position -----------------------------------------------------------------------------*/ if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin if (Testausgaben)_TestFunction ("Nest = %d", NestNr ,0,0,0,0); if (Testausgaben)_TestFunction ("RegisterTK = %x", RegisterTK ,0,0,0,0); if (Testausgaben)_TestFunction ("RegisterNIO = %x", RegisterNIO ,0,0,0,0); if (Testausgaben)_TestFunction ("RegisterGleiter = %x", RegisterGleiter ,0,0,0,0); if (Testausgaben)_TestFunction ("RegisterLabelNIO = %x", RegisterLabelNIO ,0,0,0,0); IO_Out (OUT_QUITTIERUNG_START, LOW) ; if (MP_OhneDrehtisch OR MP_Mfu) begin ++ZyklusStep; end else begin /*----------------------------------------------------------------------------- Beide Lichtschranken frei, dann neuer Start -----------------------------------------------------------------------------*/ if (Bewertung BAND BEWERTUNG_SCHLECHT) begin Bewertung = 0x0000 ; ZyklusStep = 30 ; RegisterNIO BOR= 0b010 ; end else begin if (RegisterNIO BAND 0x1) begin OldScreen = GetScreen (); ZyklusStep = 35 ; end else begin if (RegisterTK BAND 0x1) begin if ((PA1 != PA2) AND (IO_In (IN_NEST_BIT_0) == HIGH)) begin ZyklusStep = 35 ; end else begin ZyklusStep = 40 ; end end else begin if (RegisterGleiter BAND 0x1) begin if ((PA1 != PA2) AND (IO_In (IN_NEST_BIT_0) == HIGH)) begin ZyklusStep = 35 ; end else begin ZyklusStep = 45 ; end end else begin if (RegisterLabelNIO BAND 0x01) begin ZyklusStep = 47 ; end else begin ++ZyklusStep; end end end end end end end else begin /*----------------------------------------------------------------------------- Beide Lichtschranken frei, dann neuer Start -----------------------------------------------------------------------------*/ if ((GetTrigger (TRIGGER_LICHTSCHRANKE_1_FREI) == TRUE) OR (GetTrigger (TRIGGER_LICHTSCHRANKE_2_FREI) == TRUE) ) begin if ((IO_In (IN_LICHTSCHRANKE_1_FREI) == HIGH) AND (IO_In (IN_LICHTSCHRANKE_2_FREI) == HIGH) AND (IO_In (IN_SCHUTZKLAPPE ) == HIGH) ) begin RTTTakten = TRUE; end end end end break; case 3: //_TestFunction ("case3 ",0,0,0,0,0); /* Saw 10.05 */ NestNr = 1 + (IO_PortIn (15) >> 1) BAND 0x7; if ((IO_In (IN_START_TRIGGER_ST_1) == LOW) AND (IO_In (IN_START_TRIGGER_ST_2) == LOW) ) begin IO_Out (OUT_QUITTIERUNG_START , LOW); CounterIndex = NestNr * 4; /*--------------------------------------------------------------------------------------------- Nest in Maschinenparameter eintragen ----------------------------------------------------------------------------------------------*/ ChangeData (CHANGE_MASCHPAR_WERT, NestNr, MASCH_PAR_NEST_NUMMER_WELDED); /*--------------------------------------------------------------------------------------------- Teileidentnummern kopieren ----------------------------------------------------------------------------------------------*/ if (ScannerMode BAND COPY_UNGERATE_TO_GERADE_NESTER) begin if (NestNr BAND 0x1) begin QuellNest = (NestNr - 2) ; if (QuellNest <= 0) QuellNest += 8 ; ZielNest = (NestNr - 3) ; if (ZielNest <= 0) ZielNest += 8; if (Testausgaben) _TestFunction ("Step 3 Kopieren von Nest %d nach %d",QuellNest, ZielNest,0,0,0); Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_LIST, BARCODE_LIST_COPY, QuellNest, ZielNest, TRUE) ; end end /*----------------------------------------------------------------------------- Scanner anstossen und Fetten einleiten -----------------------------------------------------------------------------*/ ZielNest = (NestNr - 4) ; if (ZielNest <= 0) ZielNest += 8; HelpVal = GetEnvironment (ENV_RTT + ZielNest); PlausiFehler = FALSE; if ((IO_In (IN_TEIL_IN_SCAN_FETT_POSITION) == HIGH) AND (MP_Mfu == LOW)) begin if (ScannerMode BAND COPY_UNGERATE_TO_GERADE_NESTER) begin if (!(NestNr BAND 0x1)) begin if ((HelpVal BAND RTT_FLAG_MUSS_LEER_SEIN) OR (HelpVal == 0)) begin PlausiFehler = TRUE ; if (HelpVal BAND RTT_FLAG_MUSS_LEER_SEIN) _TestFunction ("Plausibility ERROR Tool No %d has to be empty, NOK ",ZielNest,0,0,0,0); if (HelpVal == 0) _TestFunction ("Plausibility ERROR Tool No %d has to be empty, Vollfahren",ZielNest,0,0,0,0); end end end if (PlausiFehler == FALSE) begin HelpVal BOR= RTT_FLAG_TEIL_VORHANDEN ; HelpVal BAND= NEG(RTT_FLAG_MUSS_LEER_SEIN) ; PutEnvironment (ENV_RTT + ZielNest, HelpVal) ; /*----------------------------------------------------------------------------- Fetten ?? -----------------------------------------------------------------------------*/ HelpVal = FALSE; if ((MP_FettenAktiv_UB) AND (ZielNest BAND 0x1)) begin HelpVal = TRUE; end if ((MP_FettenAktiv_LB) AND (!(ZielNest BAND 0x1)) ) begin HelpVal = TRUE; end if (MP_OhneDrehtisch OR MP_Mfu) begin HelpVal = FALSE; end if (HelpVal) begin StartTimer (TIMER_FETTEN_1, FETTEN_IMPULSLAENGE_1); StartTimer (TIMER_FETTEN_2, FETTEN_IMPULSLAENGE_2); end /*----------------------------------------------------------------------------- Scannen -----------------------------------------------------------------------------*/ HelpVal = FALSE; if ((ScannerMode BAND SCAN_GERADE_NESTER) AND (!(NestNr BAND 0x1)) ) begin HelpVal = TRUE; end else begin if ((ScannerMode BAND SCAN_UNGERADE_NESTER) AND (NestNr BAND 0x1 ) ) begin HelpVal = TRUE; end end /*----------------------------------------------------------------------------- Scanner anstossen -----------------------------------------------------------------------------*/ if (HelpVal == TRUE) begin if (Testausgaben) _TestFunction ("Step 3 Starte Scannen Nest %d",NestNr,0,0,0,0); Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_START_TRIGGER, HARDWARE_INDEX_1, 0, 0, 0) ; AblaufFlag BOR= ABLAUF_FLAG_READ_SCANNER ; end end else begin ZyklusStep = 110; end end else begin if (MP_Mfu) begin PutEnvironment (ENV_RTT + ZielNest , RTT_FLAG_TEIL_VORHANDEN); end else begin if (HelpVal BAND RTT_FLAG_TEIL_VORHANDEN) begin PlausiFehler = TRUE; ZyklusStep = 120 ; _TestFunction ("Plausifehler Teil Fehlt HelpVal = %x Zielnest %d ",HelpVal,ZielNest,0,0,0); end end if (PlausiFehler == FALSE) begin HelpVal BAND= NEG(RTT_FLAG_MUSS_LEER_SEIN) ; PutEnvironment (ENV_RTT + ZielNest, HelpVal) ; end end if (PlausiFehler == FALSE) begin IO_Out (OUT_BLASLUFT, MP_GliderCheck); if (AblaufFlag BAND ABLAUF_FLAG_VORGELADEN) begin MP_TippbetriebOn = TRUE ; AblaufFlag BAND= NEG (ABLAUF_FLAG_VORGELADEN) ; StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; ++ZyklusStep ; end else begin if (NestNr BAND 0x01) begin ChangeGaugeProgramme (PA1); end else begin ChangeGaugeProgramme (PA2); end Request (KES_FUNCTION, KES_SET_CURRENT_KES_IMPULS, 1,1,1,0); Bewertung = 0x0000 ; SchweissImpuls = 1 ; SchweissStelle = 1 ; AnzahlSchweissImpulse = Request (KES_GET_DATA, KES_GET_ANZ_KES_IMPULS, 0,0,0,0); /* Request (REQUEST_TIME,0,0,0,0,0); */ if (AnzahlSchweissImpulse) begin AktuellerZyklus = 0 ; /*------------------------------------------------------------------------------ Spannungen fuer angewaehlte Energie anlegen ------------------------------------------------------------------------------*/ // Request (KES_FUNCTION,KES_SET_OUT_VORGABE_ENERGIE, 100,0, 0, 0) ; // AblaufFlag BOR= ABLAUF_FLAG_FREIGABE_LADEN_EIN ; StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; ++ZyklusStep ; MP_TippbetriebOn = TRUE ; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHWEISSSTELLE_UNBEKANNT,0, 0,0); end end /*--------------------------------------------------------------------------------------------- Teileidentnummern zu aktuellem Nest holen ----------------------------------------------------------------------------------------------*/ if (Testausgaben) _TestFunction ("Step 3 Bilde TeileIdentNummer aus Nest %d Pa = %d",NestNr,Provide (PROVIDE_PRUEFAUFTRAG_NUMMER,ERROR,ERROR),0,0,0); Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_LIST, BARCODE_COPY_SPRINT , NestNr , 0, 0) ; // Request (INPUT_PARTNUMBER_SPRINT, 0, 0, 0, 0, 0) ; InputPartNumberFormat ("",INPUT_PARTNUMBER_SPRINT,INPUT_PARTNUMBER_SPRINT); // InputPartNumber(); end end break; /*----------------------------------------------------------------------------- Presse abwaerts -----------------------------------------------------------------------------*/ case 4: if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin /* WerkzeugFunktion = Provide (PROVIDE_WERKZEUGFUNKTIONS_NR,ERROR,1);*/ /*----------------------------------------------------------------------------- Plausibilitaet Gleiter Oben vor AB !!! -----------------------------------------------------------------------------*/ if ((IO_In (IN_KUNSTSTOFFGLEITER_VORHANDEN) == LOW ) OR (MP_GliderCheck == 0 ) ) begin if (IO_In (IN_FIXIERUNG_TAUMEL) == LOW) begin // IO_Out (OUT_S3_SICHERHEIT , HIGH); // IO_Out (OUT_S2_ABWAERTS , HIGH); // IO_Out (OUT_S5_DIFFERENTIAL , HIGH); // IO_Out (OUT_S6_GROSSE_PUMPE, HIGH); // IO_Out (OUT_S4_KLEINE_PUMPE, HIGH); // StartTimer (TIMER_DELAY, DELAY_HYDRAULIK); /*----------------------------------------------------------------------------- MovePress -----------------------------------------------------------------------------*/ AktuellePosition = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_WEG, 0, 0, 0);/*10*/ // Saw while (GetTimer (TIMER_DELAY)); /* Saw 10.05 */ NestNr = 1 + (IO_PortIn (15) >> 1) BAND 0x7; Ret = OK ; StartTimer (TIMER_DELAY,3000l); HelpVal = GetEnvironment (ENV_RTT + NestNr) ; if (HelpVal == 0) DoNotWeld = TRUE; if (Testausgaben)_TestFunction ("Zeile 2521 DoNotWeld = %d",DoNotWeld,0,0,0,0); Request (KES_FUNCTION, KES_SET_OUT_VORGABE_KRAFT, 100l,KES_VORGABE_KRAFT_MAX, 0, 0) ; if ((DoNotWeld == TRUE ) OR (RegisterGleiter BAND 0b100) OR (RegisterLabelNIO BAND 0b100) ) begin // DoNotWeld = FALSE ; /*----------------------------------------------------------------------------- Befehl MovePresse - Fahre Presse nur bis Schleichgangpos -----------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK , MOVE_TYP_POSITION_ABS, POSITION_ONLY_GLIDER_CHECK,0) ; do begin Wait (10); HelpVal = Request (KES_FUNCTION, KES_QUERY_MOVE_STATUS, 0, 0, 0, 0) ; if ((GetTimer (TIMER_DELAY ) == 0 ) OR (IO_In (IN_SCHUTZKLAPPE) == LOW) ) begin Ret = ERROR ; HelpVal = MOVE_STATUS_ERROR ; end end while (HelpVal == MOVE_STATUS_MOVING) ; end else begin /*------------------------------------------------------------------------------ Spannungen fuer angewaehlte Energie anlegen ------------------------------------------------------------------------------*/ //Saw 09.05.11 Request (KES_FUNCTION,KES_SET_OUT_VORGABE_ENERGIE, 100,0, 0, 0) ; Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, KES_VORGABE_ENERGIE_MIN_ALL, 0, 0) ; AblaufFlag BOR= ABLAUF_FLAG_FREIGABE_LADEN_EIN ; Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK , MOVE_TYP_COMPLETE_DOWN,0,0) ; if (IO_In (IN_SCHUTZKLAPPE) == HIGH) begin IO_Out (OUT_FIXIERUNG_TAUMEL_EIN , HIGH) ;//CF IO_Out (OUT_FIXIERUNG_TAUMEL_AUS , LOW) ; end do begin Wait (10); HelpVal = Request (KES_FUNCTION, KES_QUERY_MOVE_TYPE, 0, 0, 0, 0) ; if ((GetTimer (TIMER_DELAY ) == 0 ) OR (IO_In (IN_SCHUTZKLAPPE) == LOW) ) begin Ret = ERROR ; HelpVal = ERROR ; end end while (HelpVal == MOVE_KATEGORIE_AUTOMATIK_EIL_AB); end Request (KES_FUNCTION, KES_SET_DATA , KES_SET_OFFSET_KRAFT_AUSGABE, OffsetVorKraft , SET_OFFSET_ABS, 0) ; Request (KES_FUNCTION, KES_SET_OUT_VORKRAFT, 100l,0, 0, 0) ; if (Ret == OK) begin /*China Vork.o.Funktion SetModul (MFB2_12BIT_DAC_MODUL, DAC_DRUCK, Request (REQUEST_U_F_SOLLWERT_MV,0,0,0,0,0)+ OffsetSpannungVordruck); */ IO_Out (OUT_NIEDERHALTER_AUF, LOW); IO_Out (OUT_NIEDERHALTER_AB , HIGH); StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; ++ZyklusStep ; OldPosition = 0x7fffff ; end else begin LongValue = Ret ; _TestFunction ("\nRet=(%ld)",LongValue,0l,0l,0l,4l); _TestFunction ("ERROR_DOWNWARD",0,0,0,0,5l); Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK , MOVE_TYP_STOP,0,0) ; if (IO_In (IN_SCHUTZKLAPPE) == LOW) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHUTZKLAPPE,0, 0,0); ZyklusStep = 95 ; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_PRESSE_AB_SG,0, 0,0); ZyklusStep = 104 ; end end end else begin /*----------------------------------------------------------------------------- Zykluszeitueberwachung -----------------------------------------------------------------------------*/ if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_FIXIERUNG_NICHT_OBEN,0, 0,0); ZyklusStep = 98 ; end /*if ((GetTimer (TIMER_ZYKLUSZEIT) == 0)*/ end end else begin /*----------------------------------------------------------------------------- Zykluszeitueberwachung -----------------------------------------------------------------------------*/ if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_PLAUSI_GLEITER_NICHT_LOW,0, 0,0); ZyklusStep = 98 ; end /*if ((GetTimer (TIMER_ZYKLUSZEIT) == 0)*/ end end else begin /*----------------------------------------------------------------------------- Zykluszeitueberwachung -----------------------------------------------------------------------------*/ if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_WKZ_NICHT_IN_POS,0, 0,0); ZyklusStep = 98 ; end /*if ((GetTimer (TIMER_ZYKLUSZEIT) == 0)*/ end break; case 5: if (IO_In (IN_SCHUTZKLAPPE) == HIGH) begin AktuellePosition = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_WEG, 0, 0, 0) ; if (AktuellePosition == OldPosition) begin if (IO_In (IN_UNTER_UT) == LOW) begin IO_Out (OUT_UEBERBRUECKUNG_SCHUTZKLAPPE, HIGH) ; IO_Out (OUT_FIXIERUNG_TAUMEL_EIN , HIGH) ; IO_Out (OUT_FIXIERUNG_TAUMEL_AUS , LOW) ; StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; ++ZyklusStep ; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_PRESSE_UNTER_UT,0, 0,0); AblaufFlag BAND= NEG ABLAUF_FLAG_ABLAUF_AKTIV; ZyklusStep = 0; end end else begin /*----------------------------------------------------------------------------- Zykluszeitueberwachung -----------------------------------------------------------------------------*/ StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin ZyklusStep = 98 ; end /*if ((GetTimer (TIMER_ZYKLUSZEIT) == 0)*/ OldPosition = AktuellePosition ; /* StartTimer (TIMER_DELAY,50l) ; while (GetTimer (TIMER_DELAY)) ; */ end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHUTZKLAPPE,0, 0,0); ZyklusStep = 95; end break; /*----------------------------------------------------------------------------- Vordruck Erreicht ? (Wenn kein Vordruck abgefragt wird, dann gilt Druck fuer aktuellen Impuls bzw. Zyklus (Bedingte compilierung) -----------------------------------------------------------------------------*/ case 6: if (DoNotWeld OR (RegisterGleiter BAND 0b100) OR (RegisterLabelNIO BAND 0b100)) begin DoNotWeld = FALSE; AblaufFlag BOR= ABLAUF_FLAG_CHECK_OVERLOAD ; ZyklusStep = 101; StartTimer (TIMER_DELAY,1000l); while (GetTimer (TIMER_DELAY)); end else begin if (Request (KES_FUNCTION, KES_CHECK_VORKRAFT, 80l, CHECK_VORGABE_MIN, CHECK_VORGABE_VALUE, 0) == TRUE) /*90l Saw*/ begin MP_TippbetriebOn = TRUE ; /*---------------------------------------------------------------------------- Teilekontrolle -----------------------------------------------------------------------------*/ LongValue = GetEnvironment (NestNr) ; /*----------------------------------------------------------------------------- und fuer Nest zuweisen -----------------------------------------------------------------------------*/ ChangeData (CHANGE_GEOMETRISCHE_KONSTANTE,LongValue, 1); /*---------------------------------------------------------------------------- Teilekontrolle IO ? -----------------------------------------------------------------------------*/ if (StartCycle (ZYKLUS_10_TEILEKONTROLLE) BAND BEWERTUNG_SCHLECHT) begin HelpVal = GetEnvironment (ENV_RTT + NestNr); HelpVal BAND= NEG(RTT_FLAG_ID_GLIDER_OK) ; HelpVal BAND= NEG(RTT_FLAG_ID_OK) ; HelpVal BOR= RTT_FLAG_PART_CONTROL_NOK ; PutEnvironment (ENV_RTT + NestNr, RTT_FLAG_PART_CONTROL_NOK); RegisterTK BOR= REGISTER_FEHLER_TEILEKONTROLLE ; RegisterLabelNIO BAND= NEG(0b100) ; AblaufFlag BOR= ABLAUF_FLAG_CHECK_OVERLOAD ; ZyklusStep = 101; end else begin Request (KES_FUNCTION, KES_SET_DATA , KES_SET_OFFSET_KRAFT_AUSGABE, OffsetKraft , SET_OFFSET_ABS, 0) ; Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l,0, 0, 0) ; Request (KES_FUNCTION, KES_SET_OUT_VORGABE_KRAFT , 100l,0, 0, 0) ; StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; ++ZyklusStep; end end /* if (GetModul (MFB2_14BIT_ADC_MODUL, ADC_KANAL_DRUCK) */ else begin /*----------------------------------------------------------------------------- Zykluszeitueberwachung -----------------------------------------------------------------------------*/ if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_VORKRAFT_NIO,0, 0,0); ZyklusStep = 98 ; end /*if ((GetTimer (TIMER_ZYKLUSZEIT) == 0)*/ end end /* if ((RegisterGleiter BAND 0b100) OR (RegisterLabelNIO BAND 0b100)) */ /*----------------------------------------------------------------------------- immer Testen ob Gleiter vorhanden, wenn aktiv -----------------------------------------------------------------------------*/ if (MP_GliderCheck) begin ZielNest = NestNr + 1; if (ZielNest > 8) ZielNest -= 8; HelpVal = GetEnvironment (ENV_RTT + ZielNest); HelpVal BAND= NEG (RTT_FLAG_ID_GLIDER_OK ) ; HelpVal BAND= NEG (RTT_FLAG_ID_GLIDER_NOK) ; if (HelpVal BAND RTT_FLAG_TEIL_VORHANDEN) begin if (IO_In (IN_KUNSTSTOFFGLEITER_VORHANDEN) == LOW) begin if (Testausgaben)_TestFunction ("CheckGlider Register Label = %x",RegisterLabelNIO,0,0,0,0); if (!(RegisterLabelNIO BAND 0b10000)) begin RegisterGleiter BOR= 0b1000 ; end HelpVal BOR= RTT_FLAG_ID_GLIDER_NOK ; end else begin HelpVal BOR= RTT_FLAG_ID_GLIDER_OK; end PutEnvironment (ENV_RTT + ZielNest, HelpVal); end end IO_Out (OUT_BLASLUFT, LOW); break; /*----------------------------------------------------------------------------- Schweissdruck Erreicht ? -----------------------------------------------------------------------------*/ case 7: if (Request (KES_FUNCTION, KES_CHECK_VORGABE_KRAFT, 95, CHECK_VORGABE_MIN, CHECK_VORGABE_VALUE,0) == TRUE) begin StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT) ; ++ZyklusStep ; end else begin if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHWEISSKRAFT_NIO_95,0, 0,0); ZyklusStep = 98 ; end end /* else (GetModul (MFB2_14BIT_ADC_MODUL, ADC_KANAL_DRUCK) */ break; /*----------------------------------------------------------------------------- Energie geladen ? -----------------------------------------------------------------------------*/ case 8: // WF 19.05.2016 von 95 auf 97 % erhoeht if ((Request (KES_FUNCTION, KES_CHECK_VORGABE_ENERGIE, 97,CHECK_VORGABE_MIN,0,0) == TRUE) OR (IO_TestOut (OUT_ENERGIE_EIN) == LOW) ) begin /*----------------------------------------------------------------------------- Schweissen durchfuehren -----------------------------------------------------------------------------*/ ZyklusStep = (MP_Tippbetrieb == TIPPEN_EINZELSCHUSS) ? 9 : 10; end else begin if ((GetTimer (TIMER_ZYKLUSZEIT) == 0) AND (MP_Tippbetrieb == FALSE)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ENERGIE_NICHT_GELADEN_95,0, 0,0); ZyklusStep = 98 ; end end break; /*----------------------------------------------------------------------------- Schweissen per Tippen anstossen -----------------------------------------------------------------------------*/ case 9: Request (REQUEST_ERROR_EXTERN,ERROR_SET, INFO_MP_TIPPBETRIEB_AKTIV,0, 0,0); if ((IO_In (IN_TASTE_NEXT_STEP) == HIGH) OR (SchweissImpuls > 1)) begin ZyklusStep = 10 ; DynamicScreen (FALSE); Request (REQUEST_ERROR_EXTERN,ERROR_RESET, INFO_MP_TIPPBETRIEB_AKTIV,0, 0,0); end else begin Request (KES_FUNCTION, KES_CHECK_VORGABE_KRAFT , 95,CHECK_VORGABE_MIN,CHECK_VORGABE_VALUE, 0) ; Request (KES_FUNCTION, KES_CHECK_VORGABE_ENERGIE, 98,CHECK_VORGABE_MIN,CHECK_VORGABE_VALUE, 0) ; StartCycle (Request (KES_FUNCTION , KES_GET_CURRENT_SPC_ZYKLUS , CURRENT_ZYKLUS_KRAFT_ENERGIE , 0, 0, 0)) ; end break; case 10: /*----------------------------------------------------------------------------- alles OK ? -----------------------------------------------------------------------------*/ begin StartTimer (TIMER_DELAY , 100l); while (GetTimer (TIMER_DELAY )); /*----------------------------------------------------------------------------- Druck und Energie aufnehmen Zyklus 2/5/7/9/12/15/17/19 -----------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_CHECK_VORGABE_KRAFT , 95,CHECK_VORGABE_MIN,CHECK_VORGABE_VALUE, 0) ; Request (KES_FUNCTION, KES_CHECK_VORGABE_ENERGIE, 95,CHECK_VORGABE_MIN,CHECK_VORGABE_VALUE, 0) ; BewertungZyklus = StartCycle (Request (KES_FUNCTION , KES_GET_CURRENT_SPC_ZYKLUS , CURRENT_ZYKLUS_KRAFT_ENERGIE , 0, 0, 0)) ; Bewertung BOR= BewertungZyklus ; /*----------------------------------------------------------------------------- Druck oder Energie NIO ? -----------------------------------------------------------------------------*/ if (BewertungZyklus BAND (BEWERTUNG_AUSSCHUSS BOR BEWERTUNG_NACHARBEIT )) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_KRAFT_UNDODER_ENERGIE_NIO, TRUE,0,0); ZyklusStep = 15; end else begin /*----------------------------------------------------------------------------- Schwei en durchf_hren -----------------------------------------------------------------------------*/ IO_Out (OUT_FREIGABE_LADEN , LOW) ; ++ZyklusStep ; end end break; case 11: /*----------------------------------------------------------------------------- Schweissen durchfuehren -----------------------------------------------------------------------------*/ if (IO_In (IN_FEDERPAKET_GEDRUECKT) == HIGH) begin HuellKurve = 0x0000; BewertungZyklus = 0; /*----------------------------------------------------------------------------- Schweissablauf durchfuehren -----------------------------------------------------------------------------*/ RetImpuls = Request (KES_FUNCTION,KES_START_ZUENDIMPULS,0,0,0,0); Ret = RetImpuls ; switch (Ret) begin case OK: if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = OK",0,0,0,0,0); RetImpuls = OK; break; case MESSUNG_HUELLKURVE_NIO: if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = MESSUNG_HUELLKURVE_NIO",0,0,0,0,0); RetImpuls = OK ; break; case MESSUNG_HUELLKURVE_NOT_AVAIL: if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = MESSUNG_HUELLKURVE_NOT_AVAIL",0,0,0,0,0); RetImpuls = OK ; break; case MESSUNG_ERROR_HW: Ret = ERROR; if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = MESSUNG_ERROR_HW",0,0,0,0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_MESSUNG_ERROR_HW,0,0,0); break; case MESSUNG_ERROR_KRAFT_NIO: Ret = ERROR; if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = MESSUNG_ERROR_KRAFT_NIO",0,0,0,0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_MESSUNG_KRAFT_NIO,0,0,0); break; case MESSUNG_ERROR_ENERGIE_NIO: Ret = ERROR; if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = MESSUNG_ERROR_ENERGIE_NIO",0,0,0,0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_MESSUNG_ENERGIE_NIO,0,0,0); break; case MESSUNG_ERROR_TIMEOUT_QUITTIERUNG: Ret = ERROR; if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = MESSUNG_ERROR_TIMEOUT_QUITTIERUNG",0,0,0,0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_MESSUNG_TIMEOUT_QUITTIERUNG,0,0,0); break; case MESSUNG_ERROR_QUITTIERUNG_HIGH: Ret = ERROR; if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS Ret = MESSUNG_ERROR_QUITTIERUNG_HIGH",0,0,0,0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_MESSUNG_QUITTIERUNG_HIGH,0,0,0); break; default: if (Testausgaben) _TestFunction ("KES_START_ZUENDIMPULS unbekannter Rueckgabewert Ret = %ld",Ret,0,0,0,0); Ret = ERROR; Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_MESSUNG_UNBEKANNT,0,0,0); break; end /* switch (); */ /*----------------------------------------------------------------------------- Bei Verletzung oder nicht vorhandensein der Huellkurve, dieses auswerten -----------------------------------------------------------------------------*/ switch (Ret) begin case MESSUNG_HUELLKURVE_NIO: case MESSUNG_HUELLKURVE_NOT_AVAIL: break; end if (RetImpuls == OK) begin BewertungZyklus = StartCycle (Request (KES_FUNCTION , KES_GET_CURRENT_SPC_ZYKLUS , CURRENT_ZYKLUS_DATA , 0, 0, 0)) ; end /*----------------------------------------------------------------------------- Bewertung fuer Kraft und Energie zur aktuellen Scheissstelle abholen, und abhaengig davon, ob geschweisst wurde oder nicht -----------------------------------------------------------------------------*/ BewertungZyklus BOR= StartCycle (Request (KES_FUNCTION , KES_GET_CURRENT_SPC_ZYKLUS , CURRENT_ZYKLUS_KRAFT_ENERGIE , 0, 0, 0)) ; /*----------------------------------------------------------------------------- Bewertete Ergbeniss Abholen Stromhoehe, Stromflaeche, Absenkweg Corente Superfische-Corente Abbasamento -----------------------------------------------------------------------------*/ Bewertung BOR= BewertungZyklus; if (Ret != ERROR) begin if (SchweissImpuls < Request (KES_FUNCTION, KES_GET_DATA, KES_GET_ANZ_KES_IMPULS,0, 0, 0)) begin if (SchweissImpuls < AnzahlImpulseMaschpar) begin ++SchweissImpuls ; if (Testausgaben) _TestFunction ("NaechsterImpuls = %ld",SchweissImpuls,0,0,0,0); Request (KES_FUNCTION, KES_SET_CURRENT_KES_IMPULS, -1, -1, SchweissImpuls,0) ; HelpVal = Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, 0, 0, 0) ; if (Testausgaben) _TestFunction ("SetVorgabeEnergie %ld % Ret = %ld", 100l,HelpVal, 0, 0, 0) ; AblaufFlag BOR= ABLAUF_FLAG_FREIGABE_LADEN_EIN ; Request (KES_FUNCTION, KES_SET_DATA , KES_SET_OFFSET_KRAFT_AUSGABE,OffsetKraft,SET_OFFSET_ABS,0); HelpVal = Request (KES_FUNCTION, KES_SET_OUT_VORGABE_KRAFT, 100l, 0, 0, 0) ; if (Testausgaben) _TestFunction ("SetVorgabeKraft %ld % Ret = %ld", 100l,HelpVal, 0, 0, 0) ; ZyklusStep = 7; end end end else begin Bewertung BOR= BEWERTUNG_GES_NIO ; end if (ZyklusStep == 11) begin if (MP_OhneDrehtisch) begin Compute(); end else begin //Compute(); Statistik = TRUE ; end /*----------------------------------------------------------------------------- Drehtisch: ab Zaehler um 1 veringern -----------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_ADD_COUNTER,CounterIndex + COUNTER_OFFSET_AB,-1,0); /*----------------------------------------------------------------------------- Total: Zaehler um 1 erhoehen -------------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,CounterIndex + COUNTER_OFFSET_TOTAL,1,0); Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,COUNTER_INDEX_TOTAL ,1,0); /*----------------------------------------------------------------------------- Maschine: Zaehler um 1 veringern -------------------------------------------------------------------------------*/ Ret = Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_GET_COUNTER,COUNTER_INDEX_OBEN ,0,0); if ( Ret > 0 ) /* China Zaehler nicht unter 0 */ begin Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,COUNTER_INDEX_OBEN ,-1,0); end Ret = Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_GET_COUNTER,COUNTER_INDEX_UNTEN ,0,0); if ( Ret > 0 ) /* China Zaehler nicht unter 0 */ begin Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,COUNTER_INDEX_UNTEN ,-1,0); end HelpVal = GetEnvironment (ENV_RTT + NestNr); HelpVal BAND= NEG (RTT_FLAG_WELDING_OK) ; HelpVal BAND= NEG (RTT_FLAG_WELDING_NOK) ; if (!(Bewertung BAND BEWERTUNG_SCHLECHT)) begin HelpVal = RTT_FLAG_WELDING_OK; /*----------------------------------------------------------------------------- IO Zaehler um 1 erhoehen ------------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,CounterIndex + COUNTER_OFFSET_IO,1,0); Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,COUNTER_INDEX_TOTAL_IO ,1,0); /*----------------------------------------------------------------------------- externe Anzeigetafel um 1 erhoehen if (NestNr BAND 0x01) begin IO_Out (OUT_SCORE_BOARD_COUNTER, HIGH); end else begin IO_Out (OUT_SCORE_BOARD_COUNTER, LOW ); end ------------------------------------------------------------------------------*/ end else begin HelpVal = RTT_FLAG_WELDING_NOK ; /*----------------------------------------------------------------------------- NIO Zaehler um 1 erhoehen ------------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,CounterIndex + COUNTER_OFFSET_NIO,1,0); Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,COUNTER_INDEX_TOTAL_NIO ,1,0); end /* Saw 10.05 */ NestNr = 1 + (IO_PortIn (15) >> 1) BAND 0x7; PutEnvironment (ENV_RTT + NestNr, HelpVal); /*------------------------------------------------------------------------------ Spannungen fuer kleinste Energie anlegen ------------------------------------------------------------------------------*/ HelpVal= Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 100l, KES_VORGABE_ENERGIE_MIN_ALL, 0, 0) ; if (Testausgaben) _TestFunction ("Ausgabe %ld %% der min Energie Ret = %d", 100l, HelpVal, 0, 0, 0) ; if (Testausgaben) _TestFunction ("NACHALTEZEIT laeuft",0,0,0,0,0); if (Testausgaben) _TestFunction ("Setze ersten Impulse",0,0,0,0,0); SchweissImpuls = 1; Request (KES_FUNCTION, KES_SET_CURRENT_KES_IMPULS, -1, -1, SchweissImpuls,0) ; ZyklusStep = 101 ; end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_FEDERPAKET_NIO_UT,0, 0,0); ZyklusStep = 99; end break; case 15: AblaufFlag BOR= ABLAUF_FLAG_CHECK_OVERLOAD ; ZyklusStep = 101 ; break; case 20: if (NestNr BAND 0x01) begin ChangeGaugeProgramme (PA1); end else begin ChangeGaugeProgramme (PA2); end StatusLineSet ("invalid part, barcode label wrong, replce part",0,0); ++ZyklusStep ; break; case 21: if (IO_In (IN_LICHTSCHRANKE_2_FREI) == LOW) begin ++ZyklusStep; end break; case 22: if (IO_In (IN_LICHTSCHRANKE_2_FREI ) == HIGH) begin StatusLineReset(); StartTimer (TIMER_DELAY,5000l); ++ZyklusStep; end break; case 23: /*----------------------------------------------------------------------------- Scanner anstossen -----------------------------------------------------------------------------*/ StatusLineSet ("wait 5s to check again or push START 1/2 to go over",0,0); if (GetTimer (TIMER_DELAY) == 0) begin Request (MQS_KEYENCE_BARCODE_FUNCTION, KEYENCE_BARCODE_START_TRIGGER, HARDWARE_INDEX_1, 0, 0, 0) ; AblaufFlag BOR= ABLAUF_FLAG_READ_SCANNER ; StartTimer (TIMER_DELAY,2000l); StatusLineReset(); ++ZyklusStep ; end else begin if ((IO_In (IN_START_TASTER_ST_1) == HIGH) OR (IO_In (IN_START_TASTER_ST_2) == HIGH) ) begin IO_Out (OUT_QUITTIERUNG_START, LOW); AblaufFlag BOR= ABLAUF_FLAG_DONT_READ_SCANNER; StatusLineReset(); ZyklusStep = 25; end end break; case 24 : if (GetTimer (TIMER_DELAY) == 0) begin ZyklusStep = 1; end break; case 25: if (IO_In (IN_START_TASTER_ST_1) == LOW) begin if (IO_In (IN_START_TRIGGER_ST_1) == HIGH) begin IO_Out (OUT_QUITTIERUNG_START, HIGH); ZyklusStep = 1; end end if (IO_In (IN_START_TASTER_ST_2) == LOW) begin if (IO_In (IN_START_TRIGGER_ST_2) == HIGH) begin IO_Out (OUT_QUITTIERUNG_START, HIGH); ZyklusStep = 1; end end break; case 30: StatusLineSet ("reset NG part",0,0); ++ZyklusStep ; break; case 31: if (GetTrigger (TRIGGER_TASTE_QUITTIERUNG)) begin StatusLineReset (); ZyklusStep = 2; end break; case 35: OldScreen = GetScreen (); SetScreen (SCREEN_USERMASK_4); StatusLineSet ("take out the NG part",0,0); NIOFlag = 0x00 ; ++ZyklusStep ; break; case 36: if (GetTrigger (TRIGGER_TEIL_IN_NIO_BOX_1)) begin NIOFlag BOR= 0x1 ; end if (GetTrigger (TRIGGER_TEIL_IN_NIO_BOX_2)) begin NIOFlag BOR= 0x2 ; end if (NIOFlag == 0x3) begin RegisterNIO BAND= NEG(0x1); StatusLineReset (); SetScreen (OldScreen) ; ZyklusStep = 3; Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_ADD_COUNTER,COUNTER_INDEX_REPAIR_BIN ,1,0); end /*----------------------------------------------------------------------------- falls NIO Rutsche nicht alles erkannt hat -----------------------------------------------------------------------------*/ if ((IO_In (IN_OHNE_SCHUTZEINRICHTUNG) == HIGH) AND (IO_In (IN_TASTE_NEXT_STEP ) == HIGH) ) begin NIOFlag = 0x3; end break; case 40: // StatusLineSet ("parts are not weldet, push START 1 quit",0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_TEILEKONTROLLE_NIO,0, 0,0); ++ZyklusStep ; break; case 41: if ((GetTrigger (TRIGGER_TASTE_QUITTIERUNG))OR (IO_In (IN_START_TASTER_ST_1) == HIGH) OR (IO_In (IN_START_TASTER_ST_2) == HIGH) ) begin RegisterTK BAND= NEG (0x1); StatusLineReset (); Request (REQUEST_ERROR_EXTERN,ERROR_RESET, FEHLER_TEILEKONTROLLE_NIO,0, 0,0); ZyklusStep = 49; end break; case 45: // StatusLineSet ("glider is missing, reset fault ",0,0); Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_GLEITER_NIO,0, 0,0); ++ZyklusStep ; break; case 46: if ((GetTrigger (TRIGGER_TASTE_QUITTIERUNG))OR (IO_In (IN_START_TASTER_ST_1) == HIGH) OR (IO_In (IN_START_TASTER_ST_2) == HIGH) ) begin RegisterGleiter BAND= NEG(0x1); StatusLineReset (); Request (REQUEST_ERROR_EXTERN,ERROR_RESET, FEHLER_GLEITER_NIO,0, 0,0); ZyklusStep = 3; end break; case 47: StatusLineSet ("invalid barcode label",0,0); ++ZyklusStep ; break; case 48: if (GetTrigger (TRIGGER_TASTE_QUITTIERUNG)) begin RegisterLabelNIO BAND= NEG(0x1); StatusLineReset (); ZyklusStep = 3; end break; case 49: if (IO_In (IN_START_TASTER_ST_1) == LOW) begin if (IO_In (IN_START_TRIGGER_ST_1) == HIGH) begin ZyklusStep = 3; IO_Out (OUT_QUITTIERUNG_START, HIGH); Wait (50); end end if (IO_In (IN_START_TASTER_ST_2) == LOW) begin if (IO_In (IN_START_TRIGGER_ST_2) == HIGH) begin ZyklusStep = 3; IO_Out (OUT_QUITTIERUNG_START, HIGH); Wait (50); end end break; case 50: if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin Request (REQUEST_FEEDBACK_SET_MODE, ALLE_MERKMALE, REQUEST_FB_MODE_GENERAL_RESET,0,0,0) ; KalibFlag = 0 ; KalibCount = 0 ; OldPosition = 0x7fffff ; KraftKalibrierungen = 0 ; OffsetVorKraft = 0l ; OffsetKraft = 0 ; Request (KES_FUNCTION,KES_SET_DATA,KES_SET_OFFSET_KRAFT_AUSGABE,OffsetKraft,SET_OFFSET_ABS,0); Request (KES_FUNCTION, KES_SET_OUT_VORKRAFT, 100l,0, 0, 0) ; IO_Out (OUT_S2_ABWAERTS , HIGH); IO_Out (OUT_S3_SICHERHEIT , HIGH); IO_Out (OUT_S5_DIFFERENTIAL , LOW); StartTimer (TIMER_DELAY,DELAY_HYDRAULIK); while (GetTimer (TIMER_DELAY)); IO_Out (OUT_S4_KLEINE_PUMPE , HIGH); ++ZyklusStep ; end break; case 51: if (IO_In (IN_SCHUTZKLAPPE) == HIGH) begin AktuellePosition = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_WEG, 0, 0, 0); if (AktuellePosition == OldPosition) begin IO_Out (OUT_UEBERBRUECKUNG_SCHUTZKLAPPE, HIGH); ZyklusStep = ((MP_Vorkraft == 0) OR (MP_KraftKorrektur == 0)) ? 55 : 52 ; StartTimer (TIMER_DELAY , 500l); end else begin OldPosition = AktuellePosition ; StartTimer (TIMER_DELAY,200l) ; while (GetTimer (TIMER_DELAY)); end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHUTZKLAPPE,0, 0,0); ZyklusStep = 104 ; end break; case 52: if (GetTimer (TIMER_DELAY) == 0) begin if (Request (KES_FUNCTION, KES_CHECK_VORKRAFT, 100l, CHECK_VORGABE_MIN, CHECK_VORGABE_VALUE, 0) == TRUE) begin ZyklusStep = 55 ; end else begin if (OffsetVorKraft < MP_MaxKraftKorrektur) begin OffsetVorKraft += OFFSET_N_VORKRAFT; Request (KES_FUNCTION, KES_SET_DATA , KES_SET_OFFSET_KRAFT_AUSGABE,OffsetVorKraft,SET_OFFSET_ABS,0); Request (KES_FUNCTION, KES_SET_OUT_VORKRAFT, 100l ,0, 0, 0) ; StartTimer (TIMER_DELAY,100l); if (Testausgaben) _TestFunction ("VorKraftOffset = %ld MP_MaxKraftKorrektur %ld",OffsetVorKraft,MP_MaxKraftKorrektur,0,0,1); end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_KALIBRIERUNG_VORKRAFT,0, 0,0); ZyklusStep = 65 ; end end end break; case 55: begin StartTimer (TIMER_DELAY, 1000l) ; while (GetTimer (TIMER_DELAY) > 0l) ; if (KalibCount == 0) begin Wait (2000) ; Request (KES_FUNCTION, KES_KALIB_WEG, 0, 0, 0, 0) ; end KalibFlag = KalibFlag BOR (1 << (NestNr-1)) ; if (MP_OhneDrehtisch) KalibFlag = 0xff ; ++KalibCount; if (NestNr BAND 0x01) begin ChangeGaugeProgramme (PA1); end else begin ChangeGaugeProgramme (PA2); end StartTimer (TIMER_DELAY, 500l ) ; while (GetTimer (TIMER_DELAY) > 0l) ; /*----------------------------------------------------------------------------- Tasterwert zum Nest sichern -----------------------------------------------------------------------------*/ LongValue = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_WEG, 0, 0, 0) ; LongValue *= -10l ; // Vorzeichen drehen, da Formel -kg(1) und auf 1/10 µm AblaufFlag BOR= ABLAUF_FLAG_WEGGEBER_KALIBRIERT ; /* Saw 10.05.11 */ NestNr = 1 + (IO_PortIn (15) >> 1) BAND 0x7; if (Testausgaben) _TestFunction ("Tasterwert = %ld",LongValue,0,0,0,1); PutEnvironment (NestNr,LongValue); /*----------------------------------------------------------------------------- KalibFlag sichern -----------------------------------------------------------------------------*/ PutEnvironment (0, KalibFlag); SetScreen (AktScreen) ; if ((MP_KraftKorrektur == 0) OR (KalibCount > 1)) begin ZyklusStep = 65 ; end else begin ZyklusStep = 57 ; end StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT); end break; /*----------------------------------------------------------------------------- Kraft entlasten -----------------------------------------------------------------------------*/ case 56: Request (KES_FUNCTION, KES_SET_OUT_VORGABE_KRAFT, 0l,0, 0, 0) ; StartTimer (TIMER_DELAY,1000l) ; ++ZyklusStep ; break; /*----------------------------------------------------------------------------- Pause abwarten -----------------------------------------------------------------------------*/ case 57: if (GetTimer (TIMER_DELAY) == 0) begin SelectMeasurement (KORREKTUR_MERKMAL_KRAFT ,0); SetScreen (SCREEN_USERMASK_10); Request(REQUEST_BITMAP, BILD_NAME_KALIB_STATUS , BILD_BILD_DAUMEN_IO , REQUEST_BITMAP_Hide, 0, 0); /*----------------------------------------------------------------------------- Spannung Kraft anlegen -----------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_SET_OUT_VORGABE_KRAFT, 100,0, 0, 0) ; StartTimer (TIMER_DELAY,2000l) ; ++ZyklusStep ; end break; case 58: if (GetTimer (TIMER_DELAY) == 0) begin // WF 23.05.2016 Request (REQUEST_SPRINT_TYPE, SPRINT_TYPE_DATETIME, "yy.MM.dd hh:mm:ss-K", 0, 0, 0) ; // WF 23.05.2016 InputPartNumberFormat ("",INPUT_PARTNUMBER_SPRINT,INPUT_PARTNUMBER_SPRINT); // WF 23.05.2016 Request (REQUEST_FEEDBACK_SET_MODE, ALLE_MERKMALE, REQUEST_FB_MODE_GENERAL_RESET,0,0,0) ; Request (KES_FUNCTION, KES_GET_VALUE,KES_GET_VALUE_KRAFT, 0, 0, 0) ; StartCycle (Request (KES_FUNCTION , KES_GET_CURRENT_SPC_ZYKLUS , CURRENT_ZYKLUS_KRAFT_ENERGIE , 0, 0, 0)) ; //WF 23.05.2016 HelpVal = Request (REQUEST_FEEDBACK_COMPUTE, 0,0,0,0,0); // WF 23.05.2016 if ((Compute() BAND BEWERTUNG_KORREKTUR) AND (MP_KraftKorrektur != 0)) if ((HelpVal) AND (MP_KraftKorrektur != 0)) begin Request(REQUEST_BITMAP, BILD_NAME_KALIB_STATUS , BILD_BILD_DAUMEN_NIO , REQUEST_BITMAP_Draw, 0, 0); LongValue = Provide (PROVIDE_KORREKTURWERT , ERROR, KORREKTUR_MERKMAL_KRAFT); OffsetKraft += LongValue ; if (Testausgaben) _TestFunction ("Korrwert = %ld N Offset Kraft %ld",LongValue,OffsetKraft,0,0,0); Request (REQUEST_INITIATOR,INI_OFFSET_KRAFT,REQUEST_INITIATOR_SetTextFormat,"F corr.:%+ld N",OffsetKraft,0); /*----------------------------------------------------------------------------- max. Kraftkorrektur erreicht ? -----------------------------------------------------------------------------*/ if (OffsetKraft > MP_MaxKraftKorrektur) begin OffsetKraft = 0l ; AktuelleFehler BOR= FEHLER_MAX_KRAFTKORREKTUR ; ZyklusStep = 99; end else begin if (KraftKalibrierungen < MAX_ANZAHL_KALIBRIERHUEBE) begin ++KraftKalibrierungen ; ZyklusStep = 56; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_KRAFTKALIBRIERUNG_MAX_ANZ,0, 0,0); ZyklusStep = 99; end end end else begin Request(REQUEST_BITMAP, BILD_NAME_KALIB_STATUS , BILD_BILD_DAUMEN_IO , REQUEST_BITMAP_Draw, 0, 0); Wait (2000); SetScreen (SCREEN_BALKEND); ZyklusStep = 65; end StartTimer (TIMER_DELAY,2000l); while (GetTimer (TIMER_DELAY)); // WF 23.05.2016 DeleteLastPart (0); DeleteLastCycle(0); Request (KES_FUNCTION,KES_SET_DATA,KES_SET_OFFSET_KRAFT_AUSGABE,OffsetKraft,SET_OFFSET_ABS,0); end break; case 65: Request (REQUEST_FEEDBACK_SET_MODE, ALLE_MERKMALE, REQUEST_FB_MODE_GENERAL_RESET,0,0,0) ; StartTimer (TIMER_ZYKLUSZEIT, ZYKLUSZEIT); SetScreen (AktScreen) ; ZyklusStep = 70; break; case 70: Request (KES_FUNCTION, KES_SET_OUT_VORGABE_KRAFT, 0l,0, 0, 0) ; /*----------------------------------------------------------------------------- Bewegung stoppen ------------------------------------------------------------------------------*/ IO_Out (OUT_S4_KLEINE_PUMPE , LOW); StartTimer (TIMER_DELAY,DELAY_HYDRAULIK); while (GetTimer (TIMER_DELAY)); IO_Out (OUT_S5_DIFFERENTIAL , LOW); IO_Out (OUT_S2_ABWAERTS , LOW); HelpVal = Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK, MOVE_TYP_STOP, 0,0) ; StartTimer (TIMER_DELAY,DELAY_HYDRAULIK); while (GetTimer (TIMER_DELAY)); /*----------------------------------------------------------------------------- Auf AOT positionieren ------------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK, MOVE_TYP_COMPLETE_UP, MOVE_TARGET_AOT,0) ; HelpVal = FALSE ; do begin if ((IO_In (IN_PRESSE_OT) == HIGH) AND (HelpVal == FALSE)) begin HelpVal = TRUE ; Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK, MOVE_TYP_STOP, 0l,0) ; end end while (Request (KES_FUNCTION, KES_QUERY_MOVE_STATUS, 0, 0, 0, 0) == MOVE_STATUS_MOVING) ; /*----------------------------------------------------------------------------- Sind alle Nester kalibiert ? -----------------------------------------------------------------------------*/ if ((KalibFlag == 0xff) OR (AktuelleFehler != 0x00) OR (AktuelleFehler_1 != 0x00) ) begin if ((AktuelleFehler == 0x00) AND (AktuelleFehler_1 == 0x00) ) begin AblaufFlag BOR= ABLAUF_FLAG_ANLAGE_KALIBRIERT ; AblaufFlag BAND= NEG (ABLAUF_FLAG_WEGGEBER_KALIBRIEREN) ; SetScreen (SCREEN_USERMASK_1) ; end AblaufFlag BAND= NEG (ABLAUF_FLAG_ABLAUF_AKTIV) ; ZyklusStep = 0; end else begin ++ZyklusStep; RTTTakten = TRUE; end break; case 71: if (RTTTakten == FALSE) begin if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin ++ZyklusStep; end end // else // begin // if ((GetTrigger (TRIGGER_LICHTSCHRANKE_1_FREI) == TRUE) OR // (GetTrigger (TRIGGER_LICHTSCHRANKE_2_FREI) == TRUE) ) // begin // if ((IO_In (IN_LICHTSCHRANKE_1_FREI) == HIGH) AND // (IO_In (IN_LICHTSCHRANKE_2_FREI) == HIGH) AND // (IO_In (IN_SCHUTZKLAPPE ) == HIGH) ) // begin // RTTTakten = TRUE; // end // end // end // end break; case 72: if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin IO_Out (OUT_S3_SICHERHEIT , HIGH); IO_Out (OUT_S2_ABWAERTS , HIGH); IO_Out (OUT_S5_DIFFERENTIAL , HIGH); StartTimer (TIMER_DELAY, DELAY_HYDRAULIK); while (GetTimer (TIMER_DELAY)); Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK , MOVE_TYP_COMPLETE_DOWN,0,0) ; StartTimer (TIMER_DELAY,3000l); do begin Wait (10); HelpVal = Request (KES_FUNCTION, KES_QUERY_MOVE_TYPE, 0, 0, 0, 0) ; if ((GetTimer (TIMER_DELAY ) == 0 ) OR (IO_In (IN_SCHUTZKLAPPE) == LOW) ) begin HelpVal = ERROR ; Ret = ERROR ; Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK , MOVE_TYP_STOP,0,0) ; end end while (HelpVal == MOVE_KATEGORIE_AUTOMATIK_EIL_AB); Request (KES_FUNCTION, KES_SET_OUT_VORKRAFT, 100l,0, 0, 0) ; if ((Ret == OK) AND (IO_In (IN_SCHUTZKLAPPE) == HIGH)) begin ++ZyklusStep ; OldPosition = 0x7fffff ; end else begin LongValue = Ret ; if (Testausgaben) _TestFunction ("\nRet=(%ld)",LongValue,0l,0l,0l,4l); if (IO_In (IN_SCHUTZKLAPPE) == LOW) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHUTZKLAPPE,0, 0,0); ZyklusStep = 95; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET,FEHLER_PRESSE_AB_SG,0, 0,0); ZyklusStep = 104; end end end break; case 73: if (IO_In (IN_SCHUTZKLAPPE) == HIGH) begin AktuellePosition = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_WEG, 0, 0, 0) ; if (AktuellePosition == OldPosition) begin IO_Out (OUT_UEBERBRUECKUNG_SCHUTZKLAPPE, HIGH); ZyklusStep = 55; end else begin OldPosition = AktuellePosition ; Wait (200); end end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHUTZKLAPPE,0, 0,0); ZyklusStep = 104; end break; case 95: AblaufFlag BOR= ABLAUF_FLAG_NICHT_EINDREHEN; ZyklusStep = 101; break; case 96: Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ENERGIE_NICHT_EIN,0, 0,0); ZyklusStep = 15; break; case 97: /* Stromausloesung nicht erfolgt */ Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_KEINE_STROMAUSLOESUNG,0, 0,0); ZyklusStep = 15; break; case 98: /* ZyklusZeitueberwachng */ Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ZYKLUSZEIT_UEBERSCHRITTEN,0, 0,0); case 99: /* ABBRUCH */ /*----------------------------------------------------------------------------- Bei Fehler Energie zuruecksetzen -----------------------------------------------------------------------------*/ IO_Out (OUT_FREIGABE_ZUENDIMPULS, LOW) ; Request (KES_FUNCTION, KES_SET_OUT_VORGABE_ENERGIE, 0, 0, 0, 0) ; ZyklusStep = 101; AblaufFlag BOR= ABLAUF_FLAG_CHECK_OVERLOAD ; RegisterTK BOR= REGISTER_FEHLER_TEILEKONTROLLE ; IO_Out (OUT_QUITTIERUNG_START, LOW) ; break; case 101: IO_Out (OUT_NIEDERHALTER_AUF , HIGH); IO_Out (OUT_NIEDERHALTER_AB , LOW); /*----------------------------------------------------------------------------- Bewegung stoppen ------------------------------------------------------------------------------*/ IO_Out (OUT_S4_KLEINE_PUMPE , LOW); IO_Out (OUT_S5_DIFFERENTIAL , LOW); StartTimer (TIMER_DELAY,100l); while (GetTimer (TIMER_DELAY)); Request (KES_FUNCTION, KES_SET_OUT_VORGABE_KRAFT, 0l,0, 0, 0) ; /*----------------------------------------------------------------------------- Auf AOT positionieren ------------------------------------------------------------------------------*/ HelpVal = Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK, MOVE_TYP_STOP , 0 ,0) ; HelpVal = Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK, MOVE_TYP_COMPLETE_UP, MOVE_TARGET_AOT,0) ; HelpVal = FALSE; do begin if (IO_In (IN_PRESSE_OT) == HIGH) begin if (HelpVal == FALSE) begin HelpVal = TRUE; Request (KES_FUNCTION, KES_MOVE_ZYLINDER, MOVE_KATEGORIE_AUTOMATIK, MOVE_TYP_STOP, 0l,0) ; end end end while (Request (KES_FUNCTION, KES_QUERY_MOVE_STATUS, 0, 0, 0, 0) == MOVE_STATUS_MOVING) ; IO_Out (OUT_FIXIERUNG_TAUMEL_EIN , LOW); IO_Out (OUT_FIXIERUNG_TAUMEL_AUS , HIGH); //todo Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_POSITION_AOT,0, 0,0); MP_TippbetriebOn = FALSE ; ++ZyklusStep; break; case 102: if (AblaufFlag BAND ABLAUF_FLAG_CHECK_OVERLOAD) begin /*----------------------------------------------------------------------------- Energie ueberladen ? -----------------------------------------------------------------------------*/ // EnergieIstWert = (GetModul (MFB2_14BIT_ADC_MODUL, ADC_KANAL_ENERGIE) - 0l) ;/*China Korrektur-Wert*/ EnergieIstWert = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_ENERGIE, KES_GET_VALUE_RAW ,0,0); if (NestNr BAND 0x1) begin LongValue = SpannungEnergie1ImpulsPA1 ; if (Testausgaben) _TestFunction ("Overload pa1 set %ld mv actual %d mv",LongValue,EnergieIstWert,0,0,0); end else begin LongValue = SpannungEnergie1ImpulsPA2 ; if (Testausgaben) _TestFunction ("Overload pa2 set %ld mv actual %d mw",LongValue,EnergieIstWert,0,0,0); end // AblaufFlag BAND= NEG (ABLAUF_FLAG_CHECK_OVERLOAD) ; if (EnergieIstWert <= LongValue) begin AblaufFlag BAND= NEG (ABLAUF_FLAG_CHECK_OVERLOAD) ; StatusLineReset (); end else begin IO_Out (OUT_FREIGABE_LADEN, LOW); StatusLineSet ("CAPACITER OVERLOAD",0,0); if (Testausgaben) _TestFunction ("EnergieIstwert %ld mv",EnergieIstWert,0,0,0,13); end end else begin ++ZyklusStep ; end break; case 103: /*------------------------------------------------------------------------------ WF MS 04.11.04 Dauerlauf bei Warnungswechsel und Stoerung abbrechen ------------------------------------------------------------------------------*/ Ret = ERROR; if ((AktuelleFehler != 0x00 ) OR /*China*/ (AktuelleFehler_1 != 0x00 ) )/*OR Saw 17.05.11 (AblaufFlag BAND ABLAUF_FLAG_NEUE_WARNUNGEN ) )*/ begin Ret = ERROR; end else begin if ((BetriebsartAktiv == BETRIEBSART_DAUERLAUF ) AND (!(AblaufFlag BAND ABLAUF_FLAG_NICHT_EINDREHEN)) ) begin Ret = OK; end end if (Ret == OK) begin if (GetTimer (TIMER_ARBEITSTAKT) == 0) begin if (IO_In (IN_LICHTSCHRANKE_2_FREI) == HIGH) begin if (EingriffSeite2Erfolgt OR MP_Mfu) begin EingriffSeite2Erfolgt = FALSE ; if (RestTakte) begin --RestTakte; if (RestTakte == 0) begin ZyklusStep = 5 ; end end ZyklusStep = (ZyklusStep != 5) ? 1 : 104; end end end end else begin ++ZyklusStep ; end break; case 104: ZyklusStep = 0 ; AblaufFlag BAND= NEG (ABLAUF_FLAG_ABLAUF_AKTIV ) ; if (IO_In (IN_FEDERPAKET_GEDRUECKT) == HIGH) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_FEDERPAKET_NIO_OT,0, 0,0); end break; case 110: StatusLineSet ("illegal part in scann position \\ remove part",2,4); ++ZyklusStep ; break; case 111: if ((IO_In (IN_LICHTSCHRANKE_1_FREI) == LOW) OR (IO_In (IN_LICHTSCHRANKE_2_FREI) == LOW) ) begin ++ZyklusStep; end break; case 112: if ((IO_In (IN_LICHTSCHRANKE_1_FREI ) == HIGH) AND (IO_In (IN_LICHTSCHRANKE_2_FREI ) == HIGH) ) begin StatusLineSet("",ERROR,ERROR); ++ZyklusStep; end break; case 113: if (IO_In (IN_TEIL_IN_SCAN_FETT_POSITION) == LOW) begin ZyklusStep = 3; end else begin ZyklusStep = 110; end break; case 120: StatusLineSet ("missing part in scann positionflip part\\flip part\\press fault accept" ,2,4); ++ZyklusStep ; break; case 121: if ((IO_In (IN_LICHTSCHRANKE_1_FREI) == LOW) OR (IO_In (IN_LICHTSCHRANKE_2_FREI) == LOW) ) begin ++ZyklusStep; end break; case 122: if (GetTrigger (TRIGGER_TASTE_QUITTIERUNG)) begin if ((IO_In (IN_LICHTSCHRANKE_1_FREI ) == HIGH) AND (IO_In (IN_LICHTSCHRANKE_2_FREI ) == HIGH) ) begin StatusLineSet("",ERROR,ERROR); ++ZyklusStep; end end break; case 123: if (IO_In (IN_TEIL_IN_SCAN_FETT_POSITION) == LOW) begin ZyklusStep = 120; // ZielNest = (NestNr - 4) ; // if (ZielNest <= 0) // ZielNest += 8; // PutEnvironment (ENV_RTT + ZielNest , 0); end else begin ZyklusStep = 3; end break;; end /* switch (ZyklusStep) */ end /* if (AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV) */ else begin /*---------------------------------------------------------------------------- max. Kraftkorrektur erreicht ? -----------------------------------------------------------------------------*/ if (OffsetKraft > MP_MaxKraftKorrektur) begin OffsetKraft = MP_MaxKraftKorrektur ; Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_MAX_KRAFTKORREKTUR,0, 0,0); end /*----------------------------------------------------------------------------- Anwahl neue Kalibrierung -----------------------------------------------------------------------------*/ if (IO_In(IN_TASTE_KALIBRIEREN_EIN) == HIGH) begin StartTimer (TIMER_DELAY,VERWEILZEIT); do begin Input = IO_In(IN_TASTE_KALIBRIEREN_EIN) ; end while ((Input == HIGH) AND (GetTimer (TIMER_DELAY) > 0)); /*----------------------------------------------------------------------------- wenn 3 sekunden gedrueckt, dann zuruecksetzen -----------------------------------------------------------------------------*/ if (Input) begin AblaufFlag BOR= ABLAUF_FLAG_WEGGEBER_KALIBRIEREN ; AblaufFlag BAND= NEG (ABLAUF_FLAG_ANLAGE_KALIBRIERT ) ; AblaufFlag BAND= NEG (ABLAUF_FLAG_WEGGEBER_KALIBRIERT) ; end end /* if (IO_In(IN_TASTE_KALIBRIEREN)) */ end if (IO_In (IN_LICHTSCHRANKE_2_FREI) == LOW) begin EingriffSeite2Erfolgt = TRUE ; end /*----------------------------------------------------------------------------- Initiatoren updaten wenn EinrichteMaske -----------------------------------------------------------------------------*/ switch (AktScreen) begin case SCREEN_USERMASK_1: /*----------------------------------------------------------------------------- Energie Ein/Aus -----------------------------------------------------------------------------*/ if (IO_TestOut (OUT_ENERGIE_EIN) == HIGH) begin AktuelleInis BOR= INI_ENERGIE_EIN ; AktuelleInis BAND= NEG (INI_ENERGIE_AUS) ; end else begin AktuelleInis BOR= INI_ENERGIE_AUS ; AktuelleInis BAND= NEG (INI_ENERGIE_EIN) ; end /*----------------------------------------------------------------------------- Hydraulik Ein/Aus -----------------------------------------------------------------------------*/ if (IO_TestOut (OUT_HYDRAULIK_EIN) == HIGH) begin AktuelleInis BOR= INI_HYDRAULIK_EIN ; AktuelleInis BAND= NEG (INI_HYDRAULIK_AUS) ; end else begin AktuelleInis BOR= INI_HYDRAULIK_AUS ; AktuelleInis BAND= NEG (INI_HYDRAULIK_EIN) ; end /*----------------------------------------------------------------------------- Ist Kalibriert -----------------------------------------------------------------------------*/ if (AblaufFlag BAND ABLAUF_FLAG_ANLAGE_KALIBRIERT) begin AktuelleInis BOR= INI_IST_KALIBRIERT ; AktuelleInis BAND= NEG (INI_KALIB_EIN) ; end else begin AktuelleInis BAND= NEG (INI_IST_KALIBRIERT) ; end /*----------------------------------------------------------------------------- Kalibrieren Ein/Aus -----------------------------------------------------------------------------*/ if (AblaufFlag BAND ABLAUF_FLAG_WEGGEBER_KALIBRIEREN) begin AktuelleInis BOR= INI_KALIB_EIN ; AktuelleInis BAND= NEG (INI_IST_KALIBRIERT) ; end else begin AktuelleInis BAND= NEG (INI_KALIB_EIN) ; end /*----------------------------------------------------------------------------- Pressenzylinder OT/Aus -----------------------------------------------------------------------------*/ if (IO_In (IN_PRESSE_OT) == HIGH) begin AktuelleInis BOR= INI_PRESSE_AUF ; end else begin AktuelleInis BAND= NEG (INI_PRESSE_AUF) ; end /*----------------------------------------------------------------------------- Taumelfixierung Ein/Aus -----------------------------------------------------------------------------*/ if ((IO_TestOut (OUT_FIXIERUNG_TAUMEL_EIN) == HIGH) AND (IO_TestOut (OUT_FIXIERUNG_TAUMEL_AUS) == LOW ) ) begin AktuelleInis BOR= INI_TAUMEL_FIXIERT ; end else begin AktuelleInis BAND= NEG (INI_TAUMEL_FIXIERT) ; end /*----------------------------------------------------------------------------- Bild sichern -----------------------------------------------------------------------------*/ if (AktuelleInis != LastInis) begin LastInis = AktuelleInis ; /*----------------------------------------------------------------------------- Bild updaten -----------------------------------------------------------------------------*/ for (i = 0; i < 16; ++i) begin if (AktuelleInis BAND (1< 8) HelpVal -= 8 ; if (HelpVal < 1) HelpVal += 8; if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin LastNestNr = NestNr ; Request (REQUEST_INITIATOR, LongValue ,REQUEST_INITIATOR_SetTextFormat,"%d",HelpVal,0 ); HelpVal = GetEnvironment (ENV_RTT + HelpVal) ; if (HelpVal == 0) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColBG ,255,255,255); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,0,0,0); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,0,0,0); end else begin /*--------------------------------------------------------------------------------------------- Weiss fuellen, wenn noch nicht bewertet ---------------------------------------------------------------------------------------------*/ if (!(HelpVal BAND (RTT_FLAG_WELDING_OK BOR RTT_FLAG_WELDING_NOK))) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColBG,255,255,255); end if (HelpVal BAND RTT_FLAG_WELDING_NOK) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColBG ,255,0,0); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,255,0,0); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,255,0,0); end else begin if (HelpVal BAND RTT_FLAG_PART_CONTROL_NOK) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,255,0,0); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,255,0,0); end else begin if (HelpVal BAND RTT_FLAG_ID_GLIDER_OK) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,80,255,255); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,80,255,255); end else begin if (HelpVal BAND RTT_FLAG_ID_GLIDER_NOK) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,170,0,127); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,170,0,127); end else begin if (HelpVal BAND RTT_FLAG_WELDING_OK) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColBG ,0,170,0); if (!(HelpVal BAND RTT_FLAG_ID_OK)) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,0,170,0); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,0,170,0); end else begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,255,255,0); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,255,255,0); end end else begin if (HelpVal BAND RTT_FLAG_ID_NOK) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,255,0,255); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,255,0,255); end else begin if (HelpVal BAND RTT_FLAG_ID_OK) begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,255,255,0); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,255,255,0); end end end end end end end end end else begin Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_SetText,"?",0,0 ); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColBG ,235,235,235); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColHighLight ,235,235,235); Request (REQUEST_INITIATOR,LongValue,REQUEST_INITIATOR_ColShadow ,235,235,235); end ++LongValue ; end end break; /*----------------------------------------------------------------------------- Zaehler loeschen -----------------------------------------------------------------------------*/ case SCREEN_USERMASK_3: if (BetriebsartAktiv == BETRIEBSART_EINRICHTEN) begin if (AktTaste) begin if (Testausgaben) _TestFunction ("Key=(%lx)",AktTaste,0,0,0,0); anz = 3; von = 0; switch (AktTaste) begin case KEY_SHIFT_F1: von = 3; break; case KEY_SHIFT_F2: von = 7; break; case KEY_SHIFT_F3: von = 11; break; case KEY_SHIFT_F4: von = 15; break; case KEY_SHIFT_F5: von = 19; break; case KEY_SHIFT_F6: von = 23; break; case KEY_SHIFT_F7: von = 27; break; case KEY_SHIFT_F8: von = 31; break; case KEY_SHIFT_F9: if ((TriggerOberelektrode > 0) OR (IO_In (IN_TASTE_STOERUNG_QUITTIEREN) == HIGH)) begin TriggerOberelektrode = 0; Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_SET_COUNTER,COUNTER_INDEX_OBEN ,MP_CountElektrodeOben ,0); end break; case KEY_SHIFT_F10: Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_SET_COUNTER,COUNTER_INDEX_UNTEN,MP_CountElektrodeUnten,0); break; case KEY_STRG_F1: von = 35 ; anz = 3 ; break; end if (von) begin if (anz == 3) begin Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_SET_COUNTER,von + 3,MP_CountElektrodeWkz,0); end for (i = von; i < (von + anz); ++i) begin Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_SET_COUNTER,i,0,0); end end Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_SAVE_FILE, FILE_NAME_COUNTER,0,0); end end HelpVal = Request (KES_FUNCTION,KES_REQUEST_COUNTER, KES_COUNTER_GET_COUNTER,CounterIndexInitiator,0,0); Request (REQUEST_INITIATOR, CounterIndexInitiator + 50, REQUEST_INITIATOR_SetTextFormat, "%5d",HelpVal,0); ++CounterIndexInitiator ; if (CounterIndexInitiator > MAX_COUNTER) CounterIndexInitiator = 1; break; /*----------------------------------------------------------------------------- Zaehler loeschen -----------------------------------------------------------------------------*/ case SCREEN_USERMASK_4: if (BetriebsartAktiv == BETRIEBSART_EINRICHTEN) begin if (AktTaste == KEY_SHIFT_F1) begin Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_SET_COUNTER,COUNTER_INDEX_REPAIR_BIN,0,0); end end HelpVal = Request (KES_FUNCTION,KES_REQUEST_COUNTER, KES_COUNTER_GET_COUNTER,COUNTER_INDEX_REPAIR_BIN,0,0); Request (REQUEST_INITIATOR, 100, REQUEST_INITIATOR_SetTextFormat, "%5d",HelpVal,0); break; end /* switch (AktScreen) */ /*----------------------------------------------------------------------------- Fehler eintragen,wenn Energie nicht eingeschaltet werden darf -----------------------------------------------------------------------------*/ if (GetTimer (TIMER_ENERGIE_AUSZEIT)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ENERGIE_AUSZEIT,0, 0,0); if (GetTimer(TIMER_MAX_ENTLADEZEIT) == 0) begin EnergieIstWert = Request (KES_FUNCTION, KES_GET_ANALOG_IN,ADC_KANAL_ENERGIE,0,0,0) ; if (EnergieIstWert > RESTSPANNUNG) begin AblaufFlag BOR= ABLAUF_FLAG_KRITISCHER_ABBRUCH ; Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ENERGIE_ENTLADEZEIT,0, 0,0); end end end else begin /* if (AktuelleFehler BAND FEHLER_ENERGIE_AUSZEIT) begin */ Request (REQUEST_ERROR_EXTERN,ERROR_RESET, FEHLER_ENERGIE_AUSZEIT,0, 0,0); /* AktuelleFehler BAND= NEG(FEHLER_ENERGIE_AUSZEIT) ; AblaufFlag BOR= ABLAUF_FLAG_FEHLER_QUITTIEREN ; end*/ end /*------------------------------------------------------------------------------ Fehlermeldungen und Warnungen quittieren ------------------------------------------------------------------------------*/ if (IO_In (IN_TASTE_STOERUNG_QUITTIEREN)) AblaufFlag BOR= ABLAUF_FLAG_FEHLER_QUITTIEREN ; #include "fehler_5335.a" #include "speichern.a" /*----------------------------------------------------------------------------- AOT verwalten -----------------------------------------------------------------------------*/ AblaufFlag BAND= NEG(ABLAUF_FLAG_PRESSE_OT_AOT); if ((MP_PositionAOT) AND (AblaufFlag BAND ABLAUF_FLAG_WEGGEBER_KALIBRIERT)) begin AktuellePosition = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_WEG, 0, 0, 0) ; AktuellePosition /= 1000 ; // hier muss immer auf mm umgerechnet werden if (AktuellePosition >= MP_PositionAOT) begin AblaufFlag BOR= ABLAUF_FLAG_PRESSE_OT_AOT; end end if (IO_In (IN_PRESSE_OT) == HIGH) AblaufFlag BOR= ABLAUF_FLAG_PRESSE_OT_AOT; if (AblaufFlag BAND ABLAUF_FLAG_PRESSE_OT_AOT) begin if (IO_TestOut (OUT_NOCKE_AOT) == LOW) begin HelpVal = 50; end else begin HelpVal = 0; end IO_Out (OUT_NOCKE_AOT, HIGH); Wait (HelpVal); end else begin IO_Out (OUT_NOCKE_AOT, LOW); end /*----------------------------------------------------------------------------- Ladefreigabe einschalten und Ladezeit ueberwachen -----------------------------------------------------------------------------*/ if (AblaufFlag BAND ABLAUF_FLAG_FREIGABE_LADEN_EIN) begin SpannungEnergieSoll = Request (KES_FUNCTION, KES_GET_VALUE, KES_GET_VALUE_ENERGIE_OUT,KES_GET_VALUE_RAW ,0,0); AblaufFlag BAND= NEG(ABLAUF_FLAG_FREIGABE_LADEN_EIN); if ((IO_TestOut (OUT_FREIGABE_LADEN) == LOW ) AND (IO_TestOut (OUT_ENERGIE_EIN ) == HIGH) ) begin IO_Out (OUT_FREIGABE_LADEN, HIGH) ; AblaufFlag BOR= ABLAUF_FLAG_LADEFREIGABE_CHECK ; StartTimer (TIMER_LADEZEIT, Provide (PROVIDE_MASCHINENPARAMETER, ERROR , MASCH_PAR_MAX_LADEZEIT ) * 1000l); end else begin StartTimer (TIMER_MAX_STILLSTANDZEIT, Provide (PROVIDE_MASCHINENPARAMETER, ERROR , MASCH_PAR_MAX_STILLSTANDZEIT ) * 60000l); end end /* if (AblaufFlag BAND ABLAUF_FLAG_LADEFREIGABE_EIN) */ /*----------------------------------------------------------------------------- Ladezeit ueberwachen -----------------------------------------------------------------------------*/ if (AblaufFlag BAND ABLAUF_FLAG_LADEFREIGABE_CHECK) begin EnergieIstWert = Request (KES_FUNCTION, KES_GET_ANALOG_IN,ADC_KANAL_ENERGIE,0,0,0) ; if (GetTimer (TIMER_LADEZEIT) == 0l) begin AblaufFlag BAND= NEG (ABLAUF_FLAG_LADEFREIGABE_CHECK); /*----------------------------------------------------------------------------- Ist die Ladefreigbe noch ein bzw. die Ebergie ein ? -----------------------------------------------------------------------------*/ if ((IO_TestOut (OUT_FREIGABE_LADEN) == HIGH) AND (IO_TestOut (OUT_ENERGIE_EIN ) == HIGH) AND (SpannungEnergieSoll > 0 ) ) begin /*----------------------------------------------------------------------------- wenn nicht, dann Energie abschalten und kritischen Abbruch setzen -----------------------------------------------------------------------------*/ if (EnergieIstWert < (SpannungEnergieSoll * 95l /100l)) begin /*----------------------------------------------------------------------------- Energie ausschalten und kritischen Abbruch setzen -----------------------------------------------------------------------------*/ IO_Out (OUT_FREIGABE_LADEN, LOW) ; IO_Out (OUT_ENERGIE_EIN , LOW) ; /*----------------------------------------------------------------------------- !!! kritischer Fehler setzen, und Ablauf stoppen !!! -----------------------------------------------------------------------------*/ AblaufFlag BOR= ABLAUF_FLAG_KRITISCHER_ABBRUCH ; Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_LADEZEIT_UEBERWACHUNG,0, 0,0); end else begin StartTimer (TIMER_MAX_STILLSTANDZEIT, Provide (PROVIDE_MASCHINENPARAMETER, ERROR , MASCH_PAR_MAX_STILLSTANDZEIT ) * 60000l); end end end else begin /*----------------------------------------------------------------------------- Energie auf mindestens 95% geladen ? -----------------------------------------------------------------------------*/ if (EnergieIstWert > (SpannungEnergieSoll * 95l /100l)) begin AblaufFlag BAND= NEG (ABLAUF_FLAG_LADEFREIGABE_CHECK); StartTimer (TIMER_MAX_STILLSTANDZEIT, Provide (PROVIDE_MASCHINENPARAMETER, ERROR , MASCH_PAR_MAX_STILLSTANDZEIT ) * 60000l); end end end /* if (AblaufFlag BAND ABLAUF_FLAG_LADEFREIGABE_CHECK) */ else begin if ((ZyklusStep == 0 ) AND (IO_TestOut (OUT_FREIGABE_LADEN) == HIGH) AND (GetTimer (TIMER_MAX_STILLSTANDZEIT) == 0l ) ) begin IO_Out (OUT_FREIGABE_LADEN , LOW) ; end /* if (GetTimer (TIMER_NACHLADEZEIT) == 0l) */ end /* else if (AblaufFlag BAND ABLAUF_FLAG_LADEFREIGABE_CHECK) */ /*----------------------------------------------------------------------------- Rueckmeldung Ladefreigabe ueberwachen -----------------------------------------------------------------------------*/ if (IO_In (IN_NOT_HALT) == HIGH) begin ZustandsTest = (IO_TestOut (OUT_FREIGABE_LADEN) == HIGH) ? LOW : HIGH ; if (IO_In (IN_QUITTIERUNG_FREIGABE_LADEN) == ZustandsTest) begin StartTimer (TIMER_DELAY, 1000l); while ((GetTimer (TIMER_DELAY ) > 0 ) AND (IO_In (IN_QUITTIERUNG_FREIGABE_LADEN) == ZustandsTest) ); if (IO_In (IN_NOT_HALT) == HIGH) begin if (IO_In (IN_QUITTIERUNG_FREIGABE_LADEN) == ZustandsTest) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_PLAUSIBILITAET_LADEFREIGABE ,0, 0,0); AblaufFlag BOR= ABLAUF_FLAG_KRITISCHER_ABBRUCH ; end end end end /*----------------------------------------------------------------------------- Plausibilitaetsueberwachung Energie- /Entladeschuetz -----------------------------------------------------------------------------*/ if ((IO_In (IN_NOT_HALT ) == HIGH) AND (IO_In (IN_SICHERHEITS_TUER ) == HIGH) ) begin ZustandsTest = (IO_TestOut (OUT_ENERGIE_EIN) == HIGH) ? LOW : HIGH ; if ((IO_In (IN_ENERGIE_SCHUETZ_EIN) == ZustandsTest) OR (IO_In (IN_ENTLADE_SCHUETZ_EIN) == ZustandsTest) ) begin StartTimer (TIMER_DELAY, 1000l); while (GetTimer (TIMER_DELAY) > 0) ; if ((IO_In (IN_ENERGIE_SCHUETZ_EIN) == ZustandsTest) OR (IO_In (IN_ENTLADE_SCHUETZ_EIN) == ZustandsTest) ) begin if ((IO_In (IN_NOT_HALT ) == HIGH) AND (IO_In (IN_SICHERHEITS_TUER ) == HIGH) ) begin StartTimer (TIMER_DELAY, 1000l); while (GetTimer (TIMER_DELAY) > 0) ; AblaufFlag BOR= ABLAUF_FLAG_KRITISCHER_ABBRUCH ; Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_PLAUSIBILITAET_SCHUETZ,0, 0,0); end end end end /*----------------------------------------------------------------------------- Kuehlgeraet ausschalten, TIMER_KUEHLGERAET_AUS, wenn Hydraulik aus -----------------------------------------------------------------------------*/ if (IO_TestOut (OUT_HYDRAULIK_EIN) == LOW) begin if ((GetTimer (TIMER_KUEHLGERAET_AUS) == 0l ) AND (IO_TestOut (OUT_HYDRAULIK_EIN ) == LOW) ) begin IO_Out (OUT_KUEHLGERAET_EIN, LOW); end end /*----------------------------------------------------------------------------- Energie Auszeit und Schnellentladung ueberwachen -----------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_ENERGIE_AUS) == TRUE) begin IO_Out (OUT_FREIGABE_LADEN, LOW) ; StartTimer (TIMER_MAX_ENTLADEZEIT, MAX_ENTLADEZEIT); StartTimer (TIMER_ENERGIE_AUSZEIT, ENERGIE_AUSZEIT); Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ENERGIE_AUSZEIT,0, 0,0); end /* WF 19.08.03 */ /*----------------------------------------------------------------------------- Rueckmeldung des Entladeschuetzes beim Ein Energie -----------------------------------------------------------------------------*/ if (GetTrigger (TRIGGER_ENERGIE_EIN) == TRUE) begin StartTimer (TIMER_DELAY,250l); while (GetTimer (TIMER_DELAY)); IO_Out (OUT_FREIGABE_ENERGIE_EIN, LOW) ; end /*----------------------------------------------------------------------------- Signalleuchten -----------------------------------------------------------------------------*/ if ((AktuelleFehler) OR (AktuelleFehler_1) ) begin IO_Out (OUT_SIGNALLEUCHTE_GRUEN, LOW ) ; IO_Out (OUT_SIGNALLEUCHTE_ROT ,HIGH ) ; IO_Out (OUT_LAMPE_STOERUNG ,HIGH ) ; end else begin IO_Out (OUT_SIGNALLEUCHTE_ROT ,LOW ) ; IO_Out (OUT_LAMPE_STOERUNG ,LOW ) ; if ((AblaufFlag BAND ABLAUF_FLAG_WEGGEBER_KALIBRIERT) AND (IO_TestOut (OUT_ENERGIE_EIN ) == HIGH ) AND (IO_TestOut (OUT_HYDRAULIK_EIN) == HIGH ) ) begin IO_Out (OUT_SIGNALLEUCHTE_GRUEN,HIGH) ; if (RegisterNIO BAND 0x1) begin if (GetTimer (TIMER_BLINKLICHT_3) == 0) begin StartTimer (TIMER_BLINKLICHT_3,500l); IO_Out (OUT_SIGNALLEUCHTE_ROT,!IO_TestOut(OUT_SIGNALLEUCHTE_ROT)); IO_Out (OUT_LAMPE_STOERUNG ,!IO_TestOut(OUT_LAMPE_STOERUNG )); end end else begin IO_Out (OUT_SIGNALLEUCHTE_ROT ,LOW ) ; IO_Out (OUT_LAMPE_STOERUNG ,LOW ) ; end end else begin if ((BetriebsartAktiv == BETRIEBSART_EINRICHTEN)) begin if (GetTimer (TIMER_BLINKLICHT_3) == 0) begin StartTimer (TIMER_BLINKLICHT_3,500l); IO_Out (OUT_SIGNALLEUCHTE_GRUEN,!IO_TestOut(OUT_SIGNALLEUCHTE_GRUEN)); end end else begin IO_Out (OUT_SIGNALLEUCHTE_GRUEN, LOW ) ; end end end /*------------------------------------------------------------------------------ Gelbe Lampe bei Warnungen ------------------------------------------------------------------------------*/ IO_Out (OUT_SIGNALLEUCHTE_GELB,AktuelleWarnungen) ; /*------------------------------------------------------------------------------ Lampentest ------------------------------------------------------------------------------*/ if ((IO_In (IN_LAMPENTEST ) == HIGH)AND (!(AblaufFlag BAND ABLAUF_FLAG_ABLAUF_AKTIV ) ) ) begin LampenFlag = (IO_TestOut (OUT_SIGNALLEUCHTE_ROT ) ); LampenFlag BOR= (IO_TestOut (OUT_SIGNALLEUCHTE_GELB ) << 1l ); LampenFlag BOR= (IO_TestOut (OUT_SIGNALLEUCHTE_GRUEN ) << 2l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_DREHIMPULS_ST1 ) << 3l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_DREHIMPULS_ST2 ) << 4l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_ELEKTRODENWECHSEL) << 5l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_NIEDERHALTER_AUF ) << 6l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_NIEDERHALTER_AB ) << 7l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_HYDRAULIK_EIN ) << 8l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_ENERGIE_EIN ) << 9l ); LampenFlag BOR= (IO_TestOut (OUT_LAMPE_STOERUNG ) << 10l ); IO_Out (OUT_SIGNALLEUCHTE_ROT ,HIGH) ; IO_Out (OUT_SIGNALLEUCHTE_GELB ,HIGH) ; IO_Out (OUT_SIGNALLEUCHTE_GRUEN ,HIGH) ; IO_Out (OUT_LAMPE_DREHIMPULS_ST1 ,HIGH) ; IO_Out (OUT_LAMPE_DREHIMPULS_ST2 ,HIGH) ; IO_Out (OUT_LAMPE_ELEKTRODENWECHSEL,HIGH) ; IO_Out (OUT_LAMPE_NIEDERHALTER_AUF ,HIGH) ; IO_Out (OUT_LAMPE_NIEDERHALTER_AB ,HIGH) ; IO_Out (OUT_LAMPE_HYDRAULIK_EIN ,HIGH) ; IO_Out (OUT_LAMPE_ENERGIE_EIN ,HIGH) ; IO_Out (OUT_LAMPE_STOERUNG ,HIGH) ; StartTimer (TIMER_DELAY, 2000l); while (IO_In (IN_LAMPENTEST ) AND GetTimer (TIMER_DELAY)); IO_Out (OUT_SIGNALLEUCHTE_ROT ,LampenFlag BAND 0x0001) ; IO_Out (OUT_SIGNALLEUCHTE_GELB ,LampenFlag BAND 0x0002) ; IO_Out (OUT_SIGNALLEUCHTE_GRUEN ,LampenFlag BAND 0x0004) ; IO_Out (OUT_LAMPE_DREHIMPULS_ST1 ,LampenFlag BAND 0x0008) ; IO_Out (OUT_LAMPE_DREHIMPULS_ST2 ,LampenFlag BAND 0x0010) ; IO_Out (OUT_LAMPE_ELEKTRODENWECHSEL,LampenFlag BAND 0x0020) ; IO_Out (OUT_LAMPE_NIEDERHALTER_AUF ,LampenFlag BAND 0x0040) ; IO_Out (OUT_LAMPE_NIEDERHALTER_AB ,LampenFlag BAND 0x0080) ; IO_Out (OUT_LAMPE_HYDRAULIK_EIN ,LampenFlag BAND 0x0100) ; IO_Out (OUT_LAMPE_ENERGIE_EIN ,LampenFlag BAND 0x0200) ; IO_Out (OUT_LAMPE_STOERUNG ,LampenFlag BAND 0x0400) ; end /*----------------------------------------------------------------------------- Steuerspannung IO sonst PC SHUT-Down -----------------------------------------------------------------------------*/ if (IO_In (IN_STEUERSPANNUNG_IO) == LOW) begin ; //wird ueber ein include terminated end /*----------------------------------------------------------------------------- Steuerung Rundschalttisch -----------------------------------------------------------------------------*/ if ((RTTTakten == TRUE) AND (MP_OhneDrehtisch > 0) ) begin RTTTakten = FALSE ; end if ((RTTTakten == TRUE) OR (RTTStep != 0) ) begin if (Testausgaben) _TestFunction ("Takte %d RTTSTep %d",RTTTakten, RTTStep,0,0,0); LichtSchutzFrei = ((IO_In (IN_LICHTSCHRANKE_1_FREI ) == HIGH) AND (IO_In (IN_LICHTSCHRANKE_2_FREI ) == HIGH) AND (IO_In (IN_SCHUTZKLAPPE ) == HIGH) ) ; switch (RTTStep) begin case 0: IO_Out (OUT_UEBERBRUECKUNG_SCHUTZKLAPPE, LOW); if ((IO_In (IN_NIEDERHALTER_OBEN ) == HIGH) AND (IO_In (IN_FIXIERUNG_TAUMEL ) == LOW) AND (AblaufFlag BAND ABLAUF_FLAG_PRESSE_OT_AOT ) ) begin if (Testausgaben) _TestFunction ("------------------------------------> Takt ------------->",0,0,0,0,0); ++RTTStep ; end else begin RTTTakten = FALSE ; if (IO_In (IN_NIEDERHALTER_OBEN) == LOW) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_NHALTER_NICHT_OBEN,0, 0,0); end if (IO_In (IN_FIXIERUNG_TAUMEL) == HIGH) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_FIXIERUNG_NICHT_OBEN,0, 0,0); end if (!(AblaufFlag BAND ABLAUF_FLAG_PRESSE_OT_AOT)) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_PRESSE_NICHT_OT_AOT,0, 0,0); end end break; case 1: if (RTTTakten == FALSE) begin RTTStep = 0 ; end else begin if (BetriebsartAktiv == BETRIEBSART_EINRICHTEN) begin RTTTakten = FALSE ; end /*----------------------------------------------------------------------------- Anstarten, wenn Lichschranken und Schutzklappe frei -----------------------------------------------------------------------------*/ if (LichtSchutzFrei) begin if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin NestVor = 1 + (IO_PortIn (15) >> 1) BAND 0x7; end else begin // NestVor = 0xff ; ; end IO_Out (OUT_DREHTISCH_TAKTEN , HIGH); LastNestNr = ERROR ; IO_Out (OUT_LAMPE_DREHIMPULS_ST1 , HIGH); IO_Out (OUT_LAMPE_DREHIMPULS_ST2 , HIGH); StartTimer (TIMER_LICHTSCHUTZ, 1000); ++RTTStep ; end end break; case 2: if (IO_In (IN_DREHTISCH_IN_POSITION) == LOW) begin IO_Out (OUT_DREHTISCH_TAKTEN, LOW); if (Statistik == TRUE) begin // InputPartNumber(); if (Testausgaben) _TestFunction ("--------------------> Statistik",0,0,0,0,0); // InputPartNumber (); Bewertung = Compute (); if (Testausgaben) _TestFunction ("--------------------> Coumpute",0,0,0,0,0); if ((Bewertung BAND BEWERTUNG_KORREKTUR) AND (MP_KraftKorrektur != 0)) begin LongValue = Provide (PROVIDE_KORREKTURWERT , ERROR, KORREKTUR_MERKMAL_KRAFT); OffsetKraft += LongValue ; if (Testausgaben BAND 0x02) _TestFunction ("Korrwert = %ld N Spannung = %ld mv",LongValue,OffsetKraft,0,0,10); end Statistik = FALSE ; if (!(Bewertung BAND BEWERTUNG_SCHLECHT)) begin if ((NestNr+1) BAND 0x01) begin ChangeGaugeProgramme (PA1); end else begin ChangeGaugeProgramme (PA2); end SchweissImpuls = 1 ; SchweissStelle = 1 ; AnzahlSchweissImpulse = Request (KES_GET_DATA, KES_GET_ANZ_KES_IMPULS, 0,0,0,0); // _TestFunction ("--------------------> laden",0,0,0,0,0); if (AnzahlSchweissImpulse) begin AktuellerZyklus = 0 ; /*------------------------------------------------------------------------------ Spannungen fuer angewaehlte Energie anlegen ------------------------------------------------------------------------------*/ Request (KES_FUNCTION,KES_SET_OUT_VORGABE_ENERGIE, 100,KES_VORGABE_ENERGIE_MIN_ALL , 0, 0) ; AblaufFlag BOR= ABLAUF_FLAG_FREIGABE_LADEN_EIN ; if (IO_TestOut (OUT_ENERGIE_EIN) == HIGH) AblaufFlag BOR=ABLAUF_FLAG_VORGELADEN ; end else begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_SCHWEISSSTELLE_UNBEKANNT,0, 0,0); end end //_TestFunction ("--------------------> counter",0,0,0,0,0); /*----------------------------------------------------------------------------- Drehtisch: ab Zaehler checken ----------------------------------------------------------------------------*/ Ret = Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_GET_COUNTER,CounterIndex + COUNTER_OFFSET_AB,0,0); if (Ret == MP_AnzahlNestWechsel OR Ret <= 0 ) begin /*----------------------------------------------------------------------------- Ueberlauf, ansonsten Warngrenze -------------------------------------------------------------------------------*/ if (Ret <= 0) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ELEKTRODENWECHSEL,0, 0,0); AktuelleFehler_1 BOR= A_FEHLER_ELEKTRODENWECHSEL ; end else begin if (ElektrodenWechsel == FALSE) begin AblaufFlag BOR= ABLAUF_FLAG_NEUE_WARNUNGEN; end ElektrodenWechsel = TRUE; end end /*----------------------------------------------------------------------------- Maschine: Zaehler um 1 veringern -------------------------------------------------------------------------------*/ Ret = Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_GET_COUNTER,COUNTER_INDEX_OBEN ,0,0); if (Ret == MP_AnzahlMaschWechsel OR Ret <= 0) begin if (Ret <= 0 ) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ELEKTRODENWECHSEL,0, 0,0); AktuelleFehler_1 BOR= A_FEHLER_ELEKTRODENWECHSEL ; end else begin if (ElektrodenWechsel == FALSE) begin AblaufFlag BOR= ABLAUF_FLAG_NEUE_WARNUNGEN; end ElektrodenWechsel = TRUE; end end Ret = Request (KES_FUNCTION, KES_REQUEST_COUNTER,KES_COUNTER_GET_COUNTER,COUNTER_INDEX_UNTEN ,0,0); if (Ret == MP_AnzahlMaschWechsel OR Ret <= 0 ) begin if (Ret <= 0 ) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_ELEKTRODENWECHSEL,0, 0,0); AktuelleFehler_1 BOR= A_FEHLER_ELEKTRODENWECHSEL ; end else begin if (ElektrodenWechsel == FALSE) begin AblaufFlag BOR= ABLAUF_FLAG_NEUE_WARNUNGEN; end ElektrodenWechsel = TRUE; end end if (ElektrodenWechsel) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, INFO_ELEKTRODENWECHSEL,0, 0,0); end if (AktuelleFehler_1 BAND A_FEHLER_ELEKTRODENWECHSEL) begin SetScreen (SCREEN_USERMASK_3); end end StartTimer (TIMER_LICHTSCHUTZ, 1000l); //_TestFunction ("--------------------> save",0,0,0,0,0); /*------------------------------------------------------------------------------ Zaehler speichern ------------------------------------------------------------------------------*/ Request (KES_FUNCTION, KES_REQUEST_COUNTER, KES_COUNTER_SAVE_FILE, FILE_NAME_COUNTER,0,0); //_TestFunction ("--------------------> done",0,0,0,0,0); ++RTTStep ; end else begin if ((GetTimer (TIMER_LICHTSCHUTZ) == 0) OR (LichtSchutzFrei == FALSE)) begin if (Testausgaben) _TestFunction ("--------------------> neustart Nest nicht verlassen",0,0,0,0,0); IO_Out (OUT_DREHTISCH_TAKTEN, LOW); Wait (100); RTTStep = 1; end end break; case 3: if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin IO_Out (OUT_DREHTISCH_TAKTEN, LOW); /*------------------------------------------------------------------------------ Elektrodenwechsel Signalisieren ------------------------------------------------------------------------------*/ if ((AktScreen == SCREEN_USERMASK_3) AND (IO_In (IN_ELEKTRODENWECHSEL) == HIGH) ) begin AktuelleFehler_1 BAND= NEG (A_FEHLER_ELEKTRODENWECHSEL); ElektrodenWechsel = FALSE; IO_Out (OUT_LAMPE_ELEKTRODENWECHSEL, LOW); end //_TestFunction ("--------------------> pos 1",0,0,0,0,0); if ((ElektrodenWechsel) OR (AktuelleFehler_1 BAND A_FEHLER_ELEKTRODENWECHSEL)) begin if (GetTimer (TIMER_BLINKLICHT_4) == 0) begin StartTimer (TIMER_BLINKLICHT_4,500l); IO_Out (OUT_LAMPE_ELEKTRODENWECHSEL,!IO_TestOut(OUT_LAMPE_ELEKTRODENWECHSEL)); end end ++RTTStep; end else begin if ((GetTimer (TIMER_LICHTSCHUTZ) == 0) OR (LichtSchutzFrei == FALSE)) begin Wait (500); // WF 03.07.2011 if (IO_In (IN_DREHTISCH_IN_POSITION) == LOW) // WF 03.07.2011 begin if (Testausgaben) _TestFunction ("--------------------> neustart Nest nicht erreicht",0,0,0,0,0); IO_Out (OUT_DREHTISCH_TAKTEN, LOW); RTTStep = 1; end end end break; case 4: IO_Out (OUT_LAMPE_DREHIMPULS_ST1 , LOW); // Nun sind die Lichter aus IO_Out (OUT_LAMPE_DREHIMPULS_ST2 , LOW); Ret = OK; NestNach = 1 + (IO_PortIn (15) >> 1) BAND 0x7; /*------------------------------------------------------------------------------ wirklich gedreht ------------------------------------------------------------------------------*/ if (NestNach == NestVor) begin Ret = ERROR; AblaufFlag BAND= NEG ABLAUF_FLAG_ABLAUF_AKTIV; ZyklusStep = 0; Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_GLEICHES_NEST,0, 0,0); _TestFunction ("Error, turntabel has same toolposition after turning now %d befor %d",NestNach, NestVor,0,0,0); end /*------------------------------------------------------------------------------ wechsel Nest gerade auf ungerade erkannt ------------------------------------------------------------------------------*/ if ((NestVor BAND 0x1) AND (NestNach BAND 0x1) ) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_2_MAL_UNGERADES_NEST,0, 0,0); _TestFunction ("turntabel has again an odd toolposition after turning now %d befor %d",NestNach, NestVor,0,0,0); Ret = ERROR; end /*------------------------------------------------------------------------------ wechsel Nest gerade auf ungerade erkannt ------------------------------------------------------------------------------*/ if ((!(NestVor BAND 0x1)) AND (!(NestNach BAND 0x1)) ) begin Request (REQUEST_ERROR_EXTERN,ERROR_SET, FEHLER_RTT_2_MAL_GERADES_NEST,0, 0,0); _TestFunction ("turntabel again an even toolposition after turning now %d befor %d",NestNach, NestVor,0,0,0); Ret = ERROR; end if (Ret != ERROR) begin //_TestFunction ("-------------------->ende Takten",0,0,0,0,0); RTTTakten = FALSE ; RTTStep = 0 ; IO_Out (OUT_LAMPE_DREHIMPULS_ST1 , LOW); IO_Out (OUT_LAMPE_DREHIMPULS_ST2 , LOW); QuellNest = NestNr - 2 ; ZielNest = NestNr - 3 ; if (QuellNest < 1) QuellNest += 8; if (ZielNest < 1) ZielNest += 8 ; HelpVal = GetEnvironment (ENV_RTT + QuellNest); if (Testausgaben) _TestFunction ("Quelle %d Inhalt %x Ziel %d",QuellNest, HelpVal, ZielNest,0,0); if (HelpVal) begin if (HelpVal BAND RTT_FLAG_WELDING_OK) begin if (ScannerMode BAND COPY_UNGERATE_TO_GERADE_NESTER) begin if (NestNr BAND 0x1) begin if (Testausgaben) _TestFunction ("KOPIEREN",QuellNest, HelpVal, ZielNest,0,0); Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"put UB from pos %d\nto LB position %d",QuellNest,ZielNest ); FromNest = QuellNest ; DestNest = ZielNest ; DestValue = HelpVal BOR RTT_FLAG_ID_OK BOR RTT_FLAG_TEIL_VORHANDEN; FromValue = 0; HelpVal = 0; end end if (HelpVal != 0) begin if (Testausgaben) _TestFunction ("ENTNEHMEN %d Bewertung %x", QuellNest, HelpVal, 0,0,0); // WF 03.07.2011 if (HelpVal BAND RTT_FLAG_ID_GLIDER_NOK) begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"remove parts \n from position %d \n glider missing ",QuellNest,0 ); end else begin if (HelpVal BAND RTT_FLAG_PART_CONTROL_NOK) begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"take parts with \n part control nio \n from tool position %d",QuellNest,0 ); end else begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"take good part\n from tool position %d",QuellNest,0 ); end end FromNest = QuellNest ; FromValue = 0; end end else begin if (ScannerMode BAND COPY_UNGERATE_TO_GERADE_NESTER) begin if (NestNr BAND 0x1) begin DestNest = ZielNest ; DestValue = RTT_FLAG_MUSS_LEER_SEIN ; end end if (HelpVal BAND RTT_FLAG_PART_CONTROL_NOK) begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"take parts with \n part control nio \n from tool position %d",QuellNest,0 ); end if (HelpVal BAND RTT_FLAG_ID_NOK) begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"take part with \n invalid barcode label \n from tool position %d",QuellNest,0 ); end if (HelpVal BAND RTT_FLAG_WELDING_NOK) begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"put SCRAP PART \n from position %d \n on shute to repair bin ",QuellNest,0 ); end if (HelpVal BAND RTT_FLAG_ID_GLIDER_NOK) begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat,"remove part \n from position %d \n glider missing ",QuellNest,0 ); end FromNest = QuellNest ; FromValue = 0; end end else begin Request (REQUEST_INITIATOR, IniInstruction ,REQUEST_INITIATOR_SetTextFormat," ",QuellNest,0 ); end end else begin //_TestFunction ("------fehler---->ende Takten",0,0,0,0,0); RTTStep = 1; end break; end end // IO_Out (188, RTTStep BAND 1); // IO_Out (189, RTTStep BAND 2); // IO_Out (190, RTTStep BAND 4); IO_Out (OUT_LAMPE_NIEDERHALTER_AUF, IO_In (IN_NIEDERHALTER_OBEN )); IO_Out (OUT_LAMPE_NIEDERHALTER_AB , IO_TestOut (OUT_NIEDERHALTER_AB)); IO_Out (OUT_LAMPE_HYDRAULIK_EIN , IO_TestOut (OUT_HYDRAULIK_EIN )); IO_Out (OUT_LAMPE_ENERGIE_EIN , IO_In (IN_ENERGIE_SCHUETZ_EIN)); IO_Out (OUT_FETTEN_VENTIL_1, GetTimer (TIMER_FETTEN_1)); IO_Out (OUT_FETTEN_VENTIL_2, GetTimer (TIMER_FETTEN_2)); /*------------------------------------------------------------------------------ Update Nestverwaltung -----------------------------------------------------------------------------*/ if ((IO_In (IN_LICHTSCHRANKE_1_FREI ) == LOW) OR (IO_In (IN_LICHTSCHRANKE_2_FREI ) == LOW) OR (IO_In (IN_DREHTISCH_IN_POSITION) == LOW) ) begin if (FromNest != 0) begin PutEnvironment (ENV_RTT + FromNest, FromValue); FromNest = 0; FromValue = 0; end if (DestNest != 0) begin PutEnvironment (ENV_RTT + DestNest, DestValue); DestNest = 0; DestValue = 0; end end #include "terminate.a" #ifdef DEBUG if (AktTaste == 'C') begin for (Ini = 0; Ini <= 7; ++Ini) begin HelpVal = NestNr + Ini ; if (HelpVal > 8) HelpVal -= 8 ; if (IO_In (IN_DREHTISCH_IN_POSITION) == HIGH) begin LongValue = GetEnvironment (ENV_RTT + HelpVal) ; if (Testausgaben) _TestFunction ("Nest %d %x",HelpVal,LongValue,0,0,0); end end end #endif end /* main /*