//********************************************************************** //* //* INPA Nacharbeitsprogramm für ARS //* //* Sourcedatei ARS_70.SRC //* //********************************************************************** //* History : //* //* 13.10.2004 scho/sh V0.30 Kopie von ARS_60 und Anpassung an ARS_70 //* include inb_ars in inb_70 umbenannt //* 07.12.2004 scho V0.301 Neuer Menuepunkt bei Steuern: Rampenlogik //* Beschriftung bei beweglichen roten Balken verbessert //* 27.01.2004 scho V0.400 Ansteuerung der Rampenlogik vereinfacht //* Einige Eingabefelder ins Menue verschoben //* 04.07.2005 ss V0.410 Anzeigetexte korrigiert //* Merge der src Files BMW und Conti //* 07.07.2005 ss V0.411 Inbetriebnahme Script angepasst s. INB_70.SRC //* //* 14.07.2005 sh V0.412 Drehzahlerhöhung beim auf 250 begrenzt wegen SG SW //* 12.09.2005 ss V1.000 Erweiterung und Anpassung auf SGBD V1.000 //* 16.12.2005 ss V1.001 Motorvariante "N62_TUE2" hinzu //* 16.01.2006 sh V1.002 Motorvariante "D62M57A0" hinzu //* 17.01.2006 scho V1.100 Funktionalitaet Hoehenstandssensoren eingefuegt //* 10.04.2006 sj V1.101 Anpassung neue Versionsnummer SGBD //* 24.04.2006 an V1.102 Ausgabe PAF und DAF angepaßt //* 25.04.2006 an V1.102 Höhenstandsdarstellung geändert //* 26.04.2006 an V1.103 Parametereingabe bei Höhenst. und Sensoren eingefügt //* 26.04.2006 an V1.103 Ausgabeformat Steigungen angepasst //* 27.04.2006 sh V5.000 letzter Stand Inpa und include zusammengefasst, Versionsnummer an SGBD angepasst //* 30.08.2006 sh V5.100 Neue Motorvariante hinzu, N73H_R0, 12 Zyl. Wasserstoff //* 29.09.2006 sh V5.200 Neue Motorvariante hinzu, MSD85 (N63 8 Zylinder) //* 29.11.2006 an V5.300 Korrektur CAN Sign. Höhenstände, bei CC-Meldungsauslösung FS sperren, danach freigeben //* 08.05.2007 sh V5.400 Aenderung 5.300 war nicht referenziert //* 11.05.2007 sh V5.410 Ansteuerung Wasserstoffmotor N73 im include inb_70 korrigiert //* 19.10.2007 sh V5.500 Drehzahl bei N54 auf 800 U/min reduziert (inb_70), wegen Problemen bei der Inbetriebnahme, Kennlinienfehler //* 23.01.2008 sh V5.600 Drehzahl wieder auf 905 U/min erhöht. Identisch mit Cascade. //************************************************************************* #include "inpa.h" #include "bmw_std.h" // Titel, Version, Verantwortung, Steuergeraet string titel ="Aktive Rollstabilisierung"; // Titel Nacharbeitsprogramm string version="5.600"; // Version Nacharbeitsprogramm string origin ="BMW TI-432 Helmich"; // Verantwortung Nacharbeitsprogramm string sgbd ="ARS_70/V5.X"; // Steuergeraet string gruppe ="D_ARS"; // Gruppendatei string speicher_lesen_parameter="LAR;FLASH;UIFM;-ROMI;-ROMX;-RAMIS;-RAMIL;-RAMXX;-NVRAM"; // Moegliche Speicher-Parameter: "LAR;FLASH;UIFM;ROMI;ROMX;RAMIS;RAMIL;RAMXX;NVRAM"; // Bei Leerstring erfolgt kein Menuepunkt Speicher Lesen // allgemeine globale Variable string text_var; real zahlen_var; int ganz_zahl; bool logik_var; string job_state; // JOB_STATUS Variable int input_state; // Eingabestatus int input_state_VA; // Eingabestatus des PropVA Ventils 's_mehr_ventile_steuern' int input_state_HA; int input_ok=0; // Eingabe mit OK beendet int toggle_1; int toggle_2; int toggle_3; int toggle_4; int toggle_5; int para_lernen_4; int para_lernen_5; int para_lernen_6; // PT CAN Signale int allgemein = 0; int geschw = 0; int drehzahl = 0; int beschl = 0; int temperatur = 0; int diverses = 0; int hoehenstand = 0; int aif_nr = 0; // Ventile bestromen ANSTEUERN real strom_sv_ventil; real strom_rv_ventil; real strom_va_ventil; real strom_ha_ventil; // Steuergeraete Reset wrid nur einmal ausgefuehrt bool sg_reset_einmal = TRUE; bool sv_ein_aus = FALSE; bool rv_ein_aus = FALSE; bool ramp_mode_ein_aus = FALSE; bool PropVA_ein_aus = FALSE; bool PropHA_ein_aus = FALSE; int strom_sv_1 = 0; int strom_sv_2 = 0; int strom_sv_3 = 0; int strom_sv_4 = 0; int strom_rv_1 = 0; int strom_rv_2 = 0; int strom_rv_3 = 0; int strom_rv_4 = 0; int strom_va_1 = 0; int strom_va_2 = 0; int strom_va_3 = 0; int strom_ha_1 = 0; int strom_ha_2 = 0; int strom_ha_3 = 0; int strom_sv_mA = 0; int strom_rv_mA = 0; int strom_va_mA = 0; int strom_ha_mA = 0; int va_ramp_art = 0; int ha_ramp_art = 0; int rampenvorgabe = 0; int va_ramp_zeit = 0; int ha_ramp_zeit = 0; int va_ramp_wert = 0; int ha_ramp_wert = 0; string strom_var_va = ""; string strom_var_ha = ""; bool warnung_erfolgt = FALSE; // Ansteuervariablen zum Hoehenstandsabgleich int hs_abgleichen_1 = 0; int hs_abgleichen_2 = 0; int hs_abgleichen_3 = 0; int hs_abgleichen_4 = 0; int hs_abgleichen_5 = 0; int hs_abgleichen_6 = 0; int hs_abgleichen_7 = 0; int hs_abgleichen_8 = 0; // start of :#include "bmw_std.src" //********************************************************************** //* //* INPA Library-Funktionen BMW_STD.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* History: //* 05.05.2000 rd V0.01 Ersterstellung //* 23.06.2000 rd V0.02 Überarbeitung für E65 und E85 //* 04.07.2000 rd V0.03 Überarbeitung der Funktionen //* 08.11.2000 rd V0.04 AIF Lesen Results überarbeitet //* 01.03.2001 rd V0.05 m_status_flag neu hinzu //* 02.03.2001 rd V0.06 m_steuern_flag neu hinzu //* 18.05.2001 rd V0.07 AIF-Ausgabe verbessert //* 25.04.2002 rd V0.08 Erweiterung HS_LESEN //* 25.04.2002 rd V1.00 Freigabe //* 24.09.2002 rd V1.01 Erweiterung Ident für DS2 //* 19.11.2002 rd V1.02 FS_MODE erweitert um PCODEs //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* rd V2.00 Entfernung EldiAuftragLesen, EldiAuftragEingeben //* 30.03.2006 GA V3.00 Erweiterung auf UDS (ISO 14229) //* GA V3.00 Hinweis im Hauptfenster, wenn Simulationsmodus aktiv ist. //* 05.04.2007 GA V3.01 Abfrage auf IS_ und HS_LOESCHEN implementiert //********************************************************************** string package="3.01"; //********************************************************************** //* //* Globale Variablen //* //********************************************************************** // Umrechnungsfaktoren deutsch / englisch real m_c = 1.0; // Grad Celsius -> Fahrenheit z = x * m_c + a_c real a_c = 0.0; real m_km = 1.0; // km -> miles z = x * m_km real m_l = 1.0; // Liter -> Gallon US z = x * m_l // für Info string sgbd_ecu; string sgbd_origin; string sgbd_revision; string sgbd_package; string sgbd_sprache; string sgbd_comment; string gruppe_ecu; string gruppe_origin; string gruppe_revision; string gruppe_comment; // für Status-Menü bool m_status_flag=TRUE; // True Status-Menü wird angezeigt // für Steuern-Menü bool m_steuern_flag=TRUE; // True Steuern-Menü wird angezeigt // für FS_LESEN speichern bool fs_lesen_save_as_flag; // für IS_LESEN speichern bool is_lesen_save_as_flag; // für HS_LESEN speichern bool hs_lesen_save_as_flag; // für FS_LESEN bool fs_lesen_flag; // True wenn JOB vorhanden // für IS_LESEN bool is_lesen_flag; // True wenn JOB vorhanden // für HS_LESEN bool hs_lesen_flag; // True wenn JOB vorhanden // für IS_LOESCHEN bool is_loeschen_flag; // True wenn JOB vorhanden // für HS_LOESCHEN bool hs_loeschen_flag; // True wenn JOB vorhanden // Handle für FS_LESEN int f_ort_nr_buffer = 0; int f_ort_text_buffer = 0; // In INPA.INI wird festgelegt ob // nach FS- IS-, HS-Löschen automatisch wieder gelesen wird. bool deleteread_flag; // Wenn Ediabas im Simulationsmode läuft, dies im Hauptfenster anzeigen bool simulation_flag; // für Ident Screen, bzw. SVK Screen bei UDS (ISO 14229) int ident_typ; // 1= DS2 // 2= BMW Fast // 3= UDS (ISO 14229) // für SPEICHER_LESEN bool speicher_lesen_flag; // True wenn JOB vorhanden bool speicher_lesen_lar_flag; bool speicher_lesen_uifm_flag; bool speicher_lesen_romi_flag; bool speicher_lesen_romx_flag; bool speicher_lesen_nvram_flag; bool speicher_lesen_ramis_flag; bool speicher_lesen_ramxx_flag; bool speicher_lesen_flash_flag; bool speicher_lesen_ramil_flag; // für Speicher lesen Ausgabe string speicher_lesen_text = ""; string speicher_lesen_seg_adr_anz = ""; string speicher_lesen_adresse = "0x000000"; int speicher_lesen_anzahl = 64; //********************************************************************** //* //* Deklaration der Funktionen //* //********************************************************************** extern ScriptInit(); // befindet sich im Hauptprogramm // start of :#include "BATTERIE.SRC" //********************************************************************** //* //* INPA Library-Funktionen BATTERIE.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* History: //* 04.07.2000 rd V0.03 Ersterstellung //* 25.04.2002 rd V1.00 Freigabe //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* 01.04.2004 rd V2.01 Im Fehlerfalle delay eingebaut //* 30.03.2006 GA V3.00 Erweiterung auf UDS (ISO 14229) //********************************************************************** //********************************************************************** //* //* ShowBatteryIgnition //* //* Anzeige des Batterie- und Zündungs-Status //* //********************************************************************** ShowBatteryIgnition() { bool fehlerflag; // Fehler aufgetreten bool fehlerflag2; // Fehler aufgetreten bool zuendung; // Zündung ein/aus bool batterie; // Batterie ein/aus int wert; // allgemeine Variable ftextout("Batterie :", 0,5,1,0); ftextout("Zündung :", 0,45,1,0); INPAapiJob("UTILITY","STATUS_UBATT","",""); INP1apiResultInt(fehlerflag,wert,"STAT_UBATT",1); if ((fehlerflag!=TRUE) || (wert==0)) { batterie=FALSE; zuendung=FALSE; } else { batterie=TRUE; INPAapiJob("UTILITY","STATUS_ZUENDUNG","",""); INP1apiResultInt(fehlerflag2,wert,"STAT_ZUENDUNG",1); if ((fehlerflag2!=TRUE) || (wert==0)) zuendung=FALSE; else zuendung=TRUE; } digitalout(batterie, 0,20,"",""); if (batterie==TRUE) ftextout("ein ", 0,25,1,0); else { if (fehlerflag==TRUE) { ftextout("aus ", 0,25,1,0); } else { ftextout("--- ", 0,25,1,0); } } digitalout(zuendung, 0,62,"",""); if (zuendung==TRUE) ftextout("ein ", 0,67,1,0); else { if (fehlerflag2==TRUE) { ftextout("aus ", 0,67,1,0); } else { ftextout("--- ", 0,67,1,0); } } if ((fehlerflag!=TRUE) || (fehlerflag2!=TRUE)) { delay(2000); } } // -- EOF -- // end of :#include "BATTERIE.SRC" // start of :#include "GRP_INFO.SRC" //********************************************************************** //* //* INPA Library-Funktionen GRP_INFO.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* History: //* 04.07.2000 rd V0.03 Ersterstellung //* 25.04.2002 rd V1.00 Freigabe //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* 30.03.2006 GA V3.00 EDIABAS.INI-Abfrage ob Simulationsmode aktiv ist //* 18.10.2006 GA V3.01 Abfrage ob EDIABAS im Simulationsmodus läuft ist jetzt nicht mehr auf Pfad c:\windows\ediabas.ini beschränkt //********************************************************************** //********************************************************************** //* //* GruppenDateiInfo //* //* Versionsinformationen über Gruppendatei //* //********************************************************************** import32 "C" lib "api32.DLL::__apiGetConfig" ApiGetConfig(in:long Handle,in: string Name,out: string Buffer, returns: int ReturnedValue); GruppenDateiInfo( in: string grp, inout: string grp_ecu, inout: string grp_origin, inout: string grp_revision, inout: string grp_comment) { string CurDir; string Temp; string Puffer; int Size; long PufferSize; int ret_int; string BS; string CR; int pos1; int pos2; int simulation; int input; long Handle; int Returned; string ini_path= "??????????????????????";//Variable muß ausreichend lang vorbelegt sein! // C:\ec-apps\ediabas\bin chr( 92, BS ); // '\' chr( 13, CR ); // Pfad für EDIBAS.INI ermitteln // WERT 2 wurde durch Tests ermittelt Handle=2; ApiGetConfig(Handle,"EDIABASINIPATH",ini_path,Returned); //Abfrage, ob EDIABAS im Simulationsmodus betrieben wird. Hinweisfenster erfolgt im Hauptfenster s_main GetPrivateProfileInt("Configuration","Simulation",2,ini_path+BS+"ediabas.ini",simulation); if (simulation == 1) simulation_flag= TRUE; else simulation_flag= FALSE; Size=256; space(CurDir,Size); GetCurrentDirectory(256, CurDir, ret_int); SetCurrentDirectory("\EDIABAS\BIN", ret_int); Size=1024; space(Puffer,Size); inttolong(Size, PufferSize); XTRACT("\ediabas\ecu"+ BS + grp + ".grp", 1, Puffer, PufferSize, ret_int); grp_ecu=""; instr(pos1, 0, Puffer, "ECU:"); if (pos1 >= 0) { pos1 = pos1 + 4; instr(pos2, pos1, Puffer, CR ); if (pos2 > pos1) midstr(grp_ecu, Puffer, pos1, pos2 - pos1); } grp_origin=""; instr(pos1, 0, Puffer, "ORIGIN:"); if (pos1 >= 0) { pos1 = pos1 + 7; instr(pos2, pos1, Puffer, CR ); if (pos2 > pos1) midstr(grp_origin, Puffer, pos1, pos2 - pos1); } grp_revision=""; instr(pos1, 0, Puffer, "REVISION:"); if (pos1 >= 0) { pos1 = pos1 + 9; instr(pos2, pos1, Puffer, CR ); if (pos2 > pos1) midstr(grp_revision, Puffer, pos1, pos2 - pos1); } grp_comment=""; pos1=0; pos2=0; while ((pos1 >= 0) && (pos2 >= 0)) { instr(pos1, pos2, Puffer, "ECUCOMMENT:"); if (pos1 >= 0) { pos1 = pos1 + 11; instr(pos2, pos1, Puffer, CR ); if (pos2 > pos1) { midstr(Temp, Puffer, pos1, pos2 - pos1); grp_comment=grp_comment+Temp+","; } } } SetCurrentDirectory(CurDir, ret_int); } // -- EOF -- // end of :#include "GRP_INFO.SRC" // start of :#include "SGBDINFO.SRC" //********************************************************************** //* //* INPA Library-Funktionen SGBDINFO.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* History: //* 04.07.2000 rd V0.03 Ersterstellung //* 25.04.2002 rd V1.00 Freigabe //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* 30.03.2006 GA V3.00 Erweiterung auf UDS (ISO 14229) //********************************************************************** //********************************************************************** //* //* Deklaration der Funktionen //* //********************************************************************** extern SgbdInfo(in: string sg, inout: string sg_ecu, inout: string sg_origin, inout: string sg_revision, inout: string sg_package, inout: string sg_comment, inout: string sg_sprache); //********************************************************************** //* //* SgbdInfo //* //* Versionsinformationen über SGBD //* //********************************************************************** SgbdInfo( in: string sg, inout: string sg_ecu, inout: string sg_origin, inout: string sg_revision, inout: string sg_package, inout: string sg_comment, inout: string sg_sprache) { INPAapiJob(sg,"INFO","",""); INPAapiResultText(sg_ecu,"ECU",1,""); INPAapiResultText(sg_revision,"REVISION",1,""); INPAapiResultText(sg_package,"PACKAGE",1,""); INPAapiResultText(sg_origin,"ORIGIN",1,""); INPAapiResultText(sg_comment,"COMMENT",1,""); INPAapiResultText(sg_sprache,"SPRACHE",1,""); } // -- EOF -- // end of :#include "SGBDINFO.SRC" // start of :#include "SGBDINPA.SRC" //********************************************************************** //* //* INPA Library-Funktionen SgbdInpa.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* 12.03.2003 iS V1.05 Aufteilung der Funktionen(SgbdInpaCheck,GroupCheck) //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* 30.03.2006 GA V3.00 Erweiterung auf UDS (ISO 14229) //* GA V3.00 Gezielte Ausgabe, wenn Gruppendatei oder SGBD nicht existiert //* GA V3.00 INPA.INI, [EXTRA], SRIPTS auslesen, ob "deleteread" gesetzt, //* GA V3.00 um nach FS- IS-, HS-Löschen automatisch wieder zu lesen. //* 18.10.2006 GA V3.01 Check bezüglich auf Gruppen-Simulationsdatei, sowie "Identification error" erweitert //* 24.10.2006 GA V3.02 Überprüfung ob T_GRTB.PRG vorhanden eingebaut //********************************************************************** //********************************************************************** //* //* SgbdInpaCheck //* //* Überprüfung ob SGBD zu INPA passt //* //********************************************************************** SgbdInpaCheck() { string sgbd_version; // für Versionskontrolle string inpa_version; // für Versionskontrolle string inpa_sprache="deutsch"; // für Sprachvariante string variante="???"; // für Variantenkontrolle string err_text; // Fehlertext int errorcode; // Errorcode bool fehlerflag; // Fehlerflag string temp; string temp1; string temp2; int i; int k; int kk; // für neue VersionsnummernKontrolle int ii; int a; int aa; int i1; int i2; int i3; // für neue VersionsnummernKontrolle string sgbd_String_Lang; string sgbd_von_inpa_version; string ver_temp; string ver_temp1; string ver_temp2; string ver_temp3="--"; real Version_SGBD; real Version_INPA; string CurDir; // Zur Prüfung ob Gruppendatei exisiert int ret_int; int Size; int filecheck; string hinweis_text; settitle(titel+" Version "+version); a=0; ii=0; i3=0; kk=0; aa=0; i=0; k=0; fehlerflag=FALSE; temp1=""; temp2=""; instr(i,k,","+gruppe+",",","); while ((i >= 0) && (fehlerflag == FALSE)) { k=i+1; instr(i,k,","+gruppe+",",","); if (i >= 0) { midstr(temp,","+gruppe+",",k,i-k); INPAapiJob(temp,"INITIALISIERUNG","",""); INP1apiResultText(fehlerflag,variante,"VARIANTE",0,""); if (fehlerflag == TRUE) gruppe=temp; else { INP1apiErrorCode(errorcode); if (errorcode == 36)//Fehlende oder fehlerhafte Simulationsdatei { Size=256; space(CurDir,Size); GetCurrentDirectory(256, CurDir, ret_int); SetCurrentDirectory("\EDIABAS\SIM", ret_int); fileexist(temp+".SIM",filecheck); SetCurrentDirectory(CurDir, ret_int); if (filecheck == 0) { temp1= temp1+", "+temp+".SIM";//Fehlerhafte Simulationsdatei } else { temp2= temp2+", "+temp+".SIM";//Fehlende Simulationsdatei } } } } } instr(i,0,gruppe,"d");//erstes Zeichen ein 'd'? instr(k,0,gruppe,"D");//erstes Zeichen ein 'D'? if ((i == 0) || (k == 0)) hinweis_text= "das Steuergerät liefert einen falschen Varianten- und / oder Diagnose-Index.";// bis F01: Gruppendateien fangen mit D_... an else hinweis_text= "das Steuergerät liefert einen falschen SGBD-Index.";//gilt ab F01, Gruppendateien fangen mit G_... an if (fehlerflag == FALSE) { //Fehlende oder fehlerhafte Gruppen-Simulationsdatei if (errorcode == 36) { //Fehlerhafte Simulationsdatei if (temp1 != "") { strlen(k,temp1); instr(i,k,temp1+",",",");//letztes Zeichen ein ','? if (i != -1) k= k-1; //Zeichenlänge um 1 kürzen instr(i,0,temp1+",",",");//erstes Zeichen ein ','? if (i == 0) midstr(temp1,temp1,1,k);//Kommata vor und hinter temp1 ausschneiden temp1= "Fehlerhafte Simulationsdatei: "+temp1+CRLF; } //Fehlende Simulationsdatei if (temp2 != "") { strlen(k,temp2); instr(i,k,temp2+",",",");//letztes Zeichen ein ','? if (i != -1) k= k-1; //Zeichenlänge um 1 kürzen instr(i,0,temp2+",",",");//erstes Zeichen ein ','? if (i == 0) midstr(temp2,temp2,1,k);//Kommata vor und hinter temp2 ausschneiden temp2= "Fehlende Simulationsdatei : "+temp2+CRLF; } messagebox("Variantenkontrolle", "Fehler!"+CRLF+ temp1+//Fehlerfafte Gruppen-Simulationsdateien temp2+//Fehlende -//- "Das Programm wird abgebrochen!"); exit(); } //Gruppendatei vorhanden? Size=256; space(CurDir,Size); GetCurrentDirectory(256, CurDir, ret_int); SetCurrentDirectory("\EDIABAS\ECU", ret_int); fileexist(gruppe+".GRP",filecheck); SetCurrentDirectory(CurDir, ret_int); if (filecheck == 0)//Gruppendatei vorhanden, SGBD-, Kommunikationsfehler hier ausgeben { INP1apiErrorText(err_text);//Fehler beim Aufruf der VARIANTE? if (errorcode == 92)//92=SYS-0002: SG-Variantenbeschreibungsdatei (SGBD) nicht gefunden { //T_GRTB.PRG vorhanden? Size=256; space(CurDir,Size); GetCurrentDirectory(256, CurDir, ret_int); SetCurrentDirectory("\EDIABAS\ECU", ret_int); fileexist("T_GRTB.PRG",filecheck); SetCurrentDirectory(CurDir, ret_int); if (filecheck == 0)//T_GRTB.PRG ist vorhanden, somit fehlt die SGBD. { messagebox("Variantenkontrolle", "Fehler!"+CRLF+ err_text+". "+CRLF+ " "+CRLF+ "Das Steuergerät läßt sich zwar über die Gruppendatei: "+gruppe+".GRP"+" ansprechen,"+CRLF+ "aber zur Diagnose fehlt eine entsprechende SGBD (*.PRG) im Verzeichnis ..\EDIABAS\ECU"+CRLF+ " "+CRLF+ "Aktualisieren Sie SGBDen, Gruppendateien und INPA Scripte regelmäßig!"+CRLF+ " "+CRLF+ "Das Programm wird abgebrochen!"); } else//T_GRT.PRG fehlt { messagebox("Variantenkontrolle", "Fehler!"+CRLF+ err_text+". "+CRLF+ " "+CRLF+ "Die Datei T_GRTB.PRG fehlt im Verzeichnis ..\EDIABAS\ECU"+CRLF+ " "+CRLF+ "Aktualisieren Sie SGBDen, Gruppendateien und INPA Scripte regelmäßig!"+CRLF+ " "+CRLF+ "Das Programm wird abgebrochen!"); } } else if (errorcode == 102)//102= Identification error { instr(i,0,gruppe,"d");//erstes Zeichen ein 'd'? instr(k,0,gruppe,"D");//erstes Zeichen ein 'D'? if ((i == 0) || (k == 0)) temp1= "das Steuergerät liefert einen falschen Varianten- und / oder Diagnose-Index.";// bis F01: Gruppendateien fangen mit D_... an else temp1= "das Steuergerät liefert einen falschen SGBD-Index.";//gilt ab F01, Gruppendateien fangen mit G_... an messagebox("Variantenkontrolle", "Fehler! Aufruf über Gruppendatei : "+gruppe+".GRP"+CRLF+ err_text+". "+CRLF+ " "+CRLF+ "Sie besitzen entweder eine veraltete ..\EDIABAS\ECU\T_GRTB.PRG Datei, und / oder"+CRLF+ hinweis_text+CRLF+ " "+CRLF+ "Das Programm wird abgebrochen!"); } else //alle anderen Fehler { messagebox("Variantenkontrolle", "Fehler! Aufruf über Gruppendatei : "+gruppe+".GRP"+CRLF+ " "+CRLF+ err_text+". "+CRLF+ " "+CRLF+ " "+CRLF+ "Das Programm wird abgebrochen!"); } } else//Gruppendatei nicht vorhanden { messagebox("Variantenkontrolle", "Fehler! Gruppendatei : "+gruppe+".GRP "+CRLF+ "existiert nicht im Verzeichnis ..\EDIABAS\ECU"+CRLF+ " "+CRLF+ "Aktualisieren Sie SGBDen, Gruppendateien und INPA Scripte regelmäßig!"+CRLF+ " "+CRLF+ "Das Programm wird abgebrochen!"); } exit(); } i1=0; i2=0; instr(i1,0,","+sgbd+",",","+variante+","); if (i1 < 0) { instr(i2,0,","+sgbd+",",","+variante+"/"); if (i2 < 0) { messagebox("Variantenkontrolle", "Gesuchtes Steuergerät: '"+sgbd+"' nicht gefunden. "+CRLF+ "Gefundenes Steuergerät: '"+variante+"'. "+CRLF+ " "+CRLF+ "Sie besitzen entweder eine veraltete ..\EDIABAS\ECU\T_GRTB.PRG Datei, und / oder"+CRLF+ hinweis_text+CRLF+ " "+CRLF+ "Das Programm wird abgebrochen!"); exit(); } ver_temp3 = "--"; instr(ii,i2,sgbd+",",","); if (ii >= 0) { midstr(ver_temp3,sgbd+",",i2,ii); instr(i3,0,ver_temp3,"/"); if (i3 >= 0) { a = i2+i3+1; aa = ii-i2+i3-1; midstr(ver_temp3,sgbd+",",a,aa); } } } sgbd_String_Lang = sgbd; sgbd=variante; // // Info: Informatinon bei aufruf ohne BMW_STD.SRC // // #################################################### // # //für Info # // # string sgbd_ecu; # // # string sgbd_origin; # // # string sgbd_revision; # // # string sgbd_package; # // # string sgbd_sprache; # // # string sgbd_comment; # // # string gruppe_ecu; # // # string gruppe_origin; # // # string gruppe_revision; # // # string gruppe_comment; # // # # // # #include "SgbdInfo.src" # // #################################################### // // SgbdInfo(sgbd, sgbd_ecu, sgbd_origin, sgbd_revision, sgbd_package, sgbd_comment, sgbd_sprache); // Bitte VARIABLEN als Globale variable aktivieren und Include (siehe Block //INFO) // // //Versionskontrolle Auf 3 stellen vor / hinter dem "." instr(i3,0,ver_temp3,"V"); if(i3>=0) { instr(i2,0,ver_temp3,","); midstr(ver_temp3,ver_temp3,i3+1,i2-1); stringtoreal(ver_temp3,Version_INPA); realtostring(Version_INPA,"3.3",ver_temp3); midstr(sgbd_von_inpa_version,ver_temp3,0,2); } stringtoreal(version,Version_INPA); realtostring(Version_INPA,"3.3",version); midstr(inpa_version,version,0,2); stringtoreal(sgbd_revision,Version_SGBD); realtostring(Version_SGBD,"3.3",sgbd_revision); midstr(sgbd_version,sgbd_revision,0,2); temp=inpa_version; temp1=sgbd_version; if (ver_temp3 == "--") { // Vergleichen mit Versionsnummer INPA & SGBD if (inpa_version != sgbd_version) { messagebox("Versionskontrolle", "Nicht zusammenpassende Versionen. "+CRLF+ "Fehlfunktion ist möglich!"); } else { if (temp == "0.") { if (temp1 == "0.") { messagebox("Versionskontrolle", "Programm noch in der Entwicklungsphase. "+CRLF+ "Fehlfunktion ist möglich!"+CRLF+CRLF+ "SGBD Version: "+sgbd_revision+CRLF+ "INPA Version: "+version); } else { messagebox("Versionskontrolle", "Programm noch in der Entwicklungsphase. "+CRLF+ "Fehlfunktion ist möglich!"+CRLF+CRLF+ "INPA Version: "+version); } } else { if (temp1 == "0.") { messagebox("Versionskontrolle", "Programm noch in der Entwicklungsphase. "+CRLF+ "Fehlfunktion ist möglich!"+CRLF+CRLF+ "SGBD Version: "+sgbd_revision); } } } } else { // Vergleichen mit Versionsnummer INPA(SGBD Vorwahl) & SGBD if (sgbd_von_inpa_version != sgbd_version) { messagebox("Versionskontrolle", "Nicht zusammenpassende Versionen. "+CRLF+ "Fehlfunktion ist möglich!"+CRLF+CRLF+ "SGBD Version: "+ ver_temp3 +" (in INPA) "+CRLF+ "SGBD Version: "+ sgbd_revision +CRLF+ "INPA Version: "+ version); } else { if (temp == "0.") { if (temp1 == "0.") { messagebox("Versionskontrolle", "Programm noch in der Entwicklungsphase. "+CRLF+ "Fehlfunktion ist möglich!"+CRLF+CRLF+ "SGBD Version: "+sgbd_revision+CRLF+ "INPA Version: "+version); } else { messagebox("Versionskontrolle", "Programm noch in der Entwicklungsphase. "+CRLF+ "Fehlfunktion ist möglich!"+CRLF+CRLF+ "INPA Version: "+version); } } else { if (temp1 == "0.") { messagebox("Versionskontrolle", "Programm noch in der Entwicklungsphase. "+CRLF+ "Fehlfunktion ist möglich!"+CRLF+CRLF+ "SGBD Version: "+sgbd_revision); } } } } if (inpa_sprache != sgbd_sprache) { messagebox("Sprachvariantenkontrolle", "Nicht zusammenpassende Sprachvariante. "+CRLF+ "Fehlfunktion ist möglich!"); } } // -- EOF -- // end of :#include "SGBDINPA.SRC" // start of :#include "GRPCHECK.SRC" //********************************************************************** //* //* INPA Library-Funktionen GrpCheck.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* History: //* 12.03.2003 iS V1.05 Aufteilung der Funktionen(SgbdInpaCheck,GroupCheck) //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* 30.03.2006 GA V3.00 Erweiterung auf UDS (ISO 14229) //* 05.04.2007 GA V3.01 Abfrage auf IS_ und HS_LOESCHEN implementiert //* 20.04.2007 GA V3.02 FS-, IS-, HS_LESEN werden in einzelnen Tempdateien in ..\EDIABAS\BIN abgelegt //********************************************************************** //********************************************************************** //* //* GroupCheck //* //* Überprüfung der Gruppen-Info //* //********************************************************************** GroupCheck() { string err_text; // Fehlertext bool fehlerflag; // Fehlerflag string temp; int sgbd_saetze; // für Funktionen-Suche in SGBD string job_name; // JOBNMAE in SGBD int i; fehlerflag=FALSE; i=0; GruppenDateiInfo(gruppe, gruppe_ecu, gruppe_origin, gruppe_revision, gruppe_comment); // Vorbelegung der Flags fs_lesen_flag = FALSE; is_lesen_flag = FALSE; speicher_lesen_flag = FALSE; is_loeschen_flag = FALSE; hs_loeschen_flag = FALSE; INPAapiJob(sgbd,"_JOBS","",""); INP1apiResultSets(fehlerflag, sgbd_saetze); if (fehlerflag == FALSE) { INP1apiErrorText(err_text); messagebox("Unerwarteter Fehler", // sollte nie kommen err_text+". "+CRLF+ "Das Programm wird abgebrochen!"); exit(); } i = 1; while ( i <= sgbd_saetze) { INPAapiResultText(job_name,"JOBNAME",i,""); if (job_name == "FS_LESEN" ) fs_lesen_flag=TRUE; if (job_name == "IS_LESEN" ) is_lesen_flag=TRUE; if (job_name == "HS_LESEN" ) hs_lesen_flag=TRUE; if (job_name == "IS_LOESCHEN" ) is_loeschen_flag=TRUE; if (job_name == "HS_LOESCHEN" ) hs_loeschen_flag=TRUE; if (job_name == "SPEICHER_LESEN" ) speicher_lesen_flag=TRUE; if ((fs_lesen_flag == TRUE) && (is_lesen_flag == TRUE) && (hs_lesen_flag == TRUE) && (is_loeschen_flag == TRUE) && (hs_loeschen_flag == TRUE) && (speicher_lesen_flag) == TRUE) i = sgbd_saetze; i = i + 1; } if (speicher_lesen_parameter == "") speicher_lesen_flag = FALSE; if (speicher_lesen_flag == TRUE) { instr(i, 0, ";"+speicher_lesen_parameter+";", ";LAR;"); if ( i == -1 ) speicher_lesen_lar_flag = FALSE; else speicher_lesen_lar_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";FLASH;"); if ( i == -1 ) speicher_lesen_flash_flag = FALSE; else speicher_lesen_flash_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";UIFM;"); if ( i == -1 ) speicher_lesen_uifm_flag = FALSE; else speicher_lesen_uifm_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";ROMI;"); if ( i == -1 ) speicher_lesen_romi_flag = FALSE; else speicher_lesen_romi_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";RAMIS;"); if ( i == -1 ) speicher_lesen_ramis_flag = FALSE; else speicher_lesen_ramis_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";RAMIL;"); if ( i == -1 ) speicher_lesen_ramil_flag = FALSE; else speicher_lesen_ramil_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";NVRAM;"); if ( i == -1 ) speicher_lesen_nvram_flag = FALSE; else speicher_lesen_nvram_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";ROMX;"); if ( i == -1 ) speicher_lesen_romx_flag = FALSE; else speicher_lesen_romx_flag = TRUE; instr(i, 0, ";"+speicher_lesen_parameter+";", ";RAMXX;"); if ( i == -1 ) speicher_lesen_ramxx_flag = FALSE; else speicher_lesen_ramxx_flag = TRUE; } //IDENT-Typ ermitteln: DS2, BMW Fast oder UDS? INP1apiJob(sgbd,"IDENT","",""); INP1apiResultText(fehlerflag,temp,"ID_DATUM_KW",1,"");//Hat nur DS2 if ((fehlerflag == TRUE) && (temp != "")) { ident_typ= 1;//DS2 } else//UDS, BMW Fast { INP1apiResultText(fehlerflag,temp,"ID_SGBD_INDEX",1,""); if ((fehlerflag == TRUE) && (temp != "")) ident_typ= 3; //Hat nur UDS (ISO 14229) else ident_typ= 2; //sonst BMW Fast } } // -- EOF -- // end of :#include "GRPCHECK.SRC" // start of :#include "FS_LESEN.SRC" //********************************************************************** //* //* INPA Library-Funktionen FS_LESEN.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* History: //* 04.07.2000 rd V0.03 Ersterstellung //* 21.11.2000 rd V0.10 Umweltbedingungen als Zahl oder Text ( 0-n, Hex ) //* 02.03.2001 rd V0.11 Shadowspeicher umbenannt in Infospeicher //* 25.04.2002 rd V1.00 Erweiterung HS_LESEN //* 22.10.2002 rd V1.01 Erweiterung FS_LESEN //* V1.01 PCODE und PCODE7 Ausgabe neu //* V1.01 Fehlerbehandlung verbessert //* 19.11.2002 iS V1.02 Fehlerbehandlung F_ORT_TEXT, F_UW_ANZ, F_PCODE //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* 30.03.2006 GA V3.00 Erweiterung auf UDS (ISO 14229) //* GA V3.00 Fehlerausgaben korrigiert und erweitert //* 28.06.2006 GA V3.01 Bei UDS: Ausgabe "F_UW_DATUM_ZEIT" durch "F_UW_ZEIT" ersetzt, da Result entfällt //* 19.10.2006 GA V3.02 Bei DS2: wurde nicht angezogen da if-Bedingung nicht korrekt gewesen ist. //* GA V3.02 Result: F_UW_ZEIT von Unterprg.: fs_protokoll_uwb in fs_protokoll_uwb_uds verschoben //* GA V3.02 Result: F_EREIGNIS_DTC: Text wurde inverse ausgegeben //* 07.02.2007 GA V3.03 Result: F_EREIGNIS_DTC: Erklärender Text, was ein Ereinis DTC ist, war falsch //********************************************************************** //********************************************************************** //* //* Globale Variablen //* //********************************************************************** int _FsMode = 0x7FF; // alles ein string _FsFileMode = "w"; string _PreInfoFile = ""; string _PostInfoFile = ""; string _ApiFsJobName = "FS_LESEN"; //********************************************************************** //* //* Deklaration der Funktionen //* //********************************************************************** extern INPAapiFsMode_neu ( in: int FsMode, in: string FsFileMode, in: string PreInfoFile, in: string PostInfoFile, in: string ApiFsJobName); extern INPAapiFsLesen_neu( in: string ecu, in: string FileName); extern fs_protokoll_ort(in: int nr); extern fs_protokoll_ort_uds(in: int nr); extern fs_protokoll_PCode(in: int nr); extern fs_protokoll_PCode7(in: int nr); extern fs_protokoll_SAECode(in: int nr); extern fs_protokoll_hfk(in: int nr); extern fs_protokoll_hfk_uds(in: int nr); extern fs_protokoll_art(in: int nr); extern fs_protokoll_art_uds(in: int nr); extern fs_protokoll_art_e(in: int nr); extern fs_protokoll_uwb(in: int nr); extern fs_protokoll_uwb_uds(in: int nr); extern fs_protokoll_hex(in: int nr); extern fs_protokoll_telantwort(in: int nr); //********************************************************************** //* //* INPAapiFsMode_neu kompatibel mit INPAapiFsMode //* //********************************************************************** INPAapiFsMode_neu( in: int FsMode, in: string FsFileMode, in: string PreInfoFile, in: string PostInfoFile, in: string ApiFsJobName) { _FsMode = FsMode; _FsFileMode = FsFileMode; _PreInfoFile = PreInfoFile; _PostInfoFile = PostInfoFile; _ApiFsJobName = ApiFsJobName; INPAapiFsMode(_FsMode, _FsFileMode, _PreInfoFile, _PostInfoFile, _ApiFsJobName); if (_ApiFsJobName=="") _ApiFsJobName="FS_LESEN"; } //********************************************************************** //* //* INPAapiFsLesen_neu kompatibel mit INPAapiFsLesen //* //********************************************************************** INPAapiFsLesen_neu( in: string ecu, in: string FileName) { string _ecu; string _FileName; bool rc; int i; int k; int len; int x1; long xL; string temp1; string temp2; string temp3; string temp11; string temp12; string temp21; string temp22; int F_VERSION; string JOB_STATUS; string JOB_MESSAGE; string VARIANTE; int SETS; int UW_SETS; string FS_CODE; string F_PCODE; string F_PCODE7; string F1_VERSION; int errorcode; // EDIABAS Fehlernummer string error_text; // EDIABAS Fehlertext string errorcode_text; // EDIABAS Fehlernummer als Text string sgbd_version; // aus INFO auslesen, um bei Fehlern die Version angeben zu können _ecu = ecu; _FileName = FileName; //SGBD-Version auslesen sgbd_version= "???"; INPAapiJob(_ecu,"INFO","",""); INP1apiResultText(rc, sgbd_version, "REVISION", 1, ""); INPAapiJob(_ecu, _ApiFsJobName,"",""); INP1apiResultInt(rc, F_VERSION, "F_VERSION",1 ); INP1apiErrorCode(errorcode); //UDS: if ((rc == TRUE) && ( F_VERSION == 3 )) { getdate(temp1); gettime(temp2); INPAapiResultSets(SETS); INPAapiResultText(VARIANTE, "VARIANTE", 0, ""); INPAapiResultText(JOB_STATUS, "JOB_STATUS", SETS, ""); fileopen ( _FileName, _FsFileMode); if (_ApiFsJobName == "IS_LESEN") { filewrite( " I N F O S P E I C H E R L E S E N"); filewrite( " -----------------------------------"); } else if (_ApiFsJobName == "HS_LESEN") { filewrite( " H I S T O R I E N S P E I C H E R L E S E N"); filewrite( " ---------------------------------------------"); } else { filewrite( " F E H L E R S P E I C H E R L E S E N"); filewrite( " ---------------------------------------"); } filewrite(""); filewrite("Datum : "+temp1+" "+temp2); if (_ecu != VARIANTE) filewrite("ECU : "+_ecu); filewrite("JobStatus: "+JOB_STATUS); filewrite("Variante : "+VARIANTE+".PRG"); filewrite("Version : "+sgbd_version); filewrite( "-------------------------------------------------------------------------------"); if ( JOB_STATUS == "OKAY") { filewrite( ""); if (SETS == 1) filewrite( " >>>>>>>>>> Kein Fehler gefunden <<<<<<<<<<<"); else { inttostring(SETS-1,temp1); if ((SETS-1) < 10) temp1= " "+temp1;//Formatierung der Fehleranzahl, wenn sie kleiner 10 ist filewrite( "ERGEBNIS : "+temp1+" Fehler im Fehlerspeicher!"); if ((_FsMode & 0x100) == 0) { i=1; while ( i < SETS ) { if (_FsMode != 0) filewrite( "-------------------------------------------------------------------------------"); if ((_FsMode & 0x01) != 0) fs_protokoll_ort_uds(i); if ((_FsMode & 0x04) != 0) fs_protokoll_art_uds(i); if ((_FsMode & 0x40) != 0) fs_protokoll_hex(i); i=i+1; } } else { // Detail lesen i=1; StrArrayDelete(f_ort_nr_buffer); StrArrayDelete(f_ort_text_buffer); while ( i < SETS ) { INP1apiResultText(rc,temp1, "F_ORT_TEXT", i, ""); if (rc != TRUE) temp1="??????"; StrArrayWrite(f_ort_text_buffer,i,temp1); INP1apiResultBinary(rc,"F_HEX_CODE",i);//Fehlerort Nr. bei UDS: 3 Bytes, daher mit long arbeiten. (kein INPAapiResultText(temp1, "F_ORT_NR", i, "");....!) ...ergibt diese Lösung if (rc == TRUE) { GetBinaryDataString (temp1,len); midstr(temp1,temp1,0,6); } else { temp1= "??????"; filewrite(""); filewrite("### Fehler beim Lesen des Results: F_HEX_CODE ###"); filewrite(""); INP1apiErrorCode(errorcode); if (errorcode != 0) { inttostring(errorcode, errorcode_text); INP1apiErrorText(error_text); error_text= "Ediabas-Fehlermeldung Nr.: "+errorcode_text+": "+ error_text; ftextout(error_text ,2,0,0,0); } } StrArrayWrite(f_ort_nr_buffer,i,temp1); i=i+1; } i=1; while ( i < SETS ) { if (_FsMode != 0) filewrite( "-------------------------------------------------------------------------------"); StrArrayRead(f_ort_nr_buffer,i,FS_CODE); INPAapiJob(_ecu, _ApiFsJobName+"_DETAIL", "0x"+FS_CODE, ""); INP1apiResultSets(rc, UW_SETS); if (rc == TRUE) { INPAapiResultText(JOB_STATUS, "JOB_STATUS", UW_SETS, ""); if ( JOB_STATUS == "OKAY") { if ((_FsMode & 0x01) != 0) fs_protokoll_ort_uds(1); if ((_FsMode & 0x200) != 0) fs_protokoll_SAECode(1);//0x200 von BMW Fast für PCode genommen if ((_FsMode & 0x20) != 0) fs_protokoll_hfk_uds(1); k=1; while ( k < UW_SETS ) { filewrite( ""); if ( UW_SETS > 2 ) { inttostring(k,temp1); filewrite( temp1 + ". Umweltsatz"); } if ((_FsMode & 0x02) != 0) fs_protokoll_uwb_uds(k); k=k+1; } if ((_FsMode & 0x04) != 0) fs_protokoll_art_uds(1); if ((_FsMode & 0x04) != 0) fs_protokoll_art_e(1); if ((_FsMode & 0x40) != 0) fs_protokoll_hex(1); } else { if ((_FsMode & 0x01) != 0) { filewrite( ""); StrArrayRead(f_ort_text_buffer,i,temp2); filewrite("0x"+FS_CODE+" "+temp2); } INP1apiResultText(rc,JOB_MESSAGE, "JOB_MESSAGE", UW_SETS, ""); if (rc == TRUE) filewrite( _ApiFsJobName+"_DETAIL: JobStatus: "+JOB_STATUS+" --> "+JOB_MESSAGE) ; else filewrite( _ApiFsJobName+"_DETAIL: JobStatus: "+JOB_STATUS); fs_protokoll_telantwort(UW_SETS);//Telegrammantwort zur Fehleranalyse mit ausgeben } } else { if ((_FsMode & 0x01) != 0) { filewrite( ""); StrArrayRead(f_ort_text_buffer,i,temp2); filewrite("0x"+FS_CODE+" "+temp2); } INP1apiErrorText(temp1); filewrite( _ApiFsJobName+"_DETAIL: "+temp1); } i=i+1; } } } } filewrite( "==============================================================================="); fileclose(); } //BMW FAST: else if ((rc == TRUE) && ( F_VERSION == 2 )) { getdate(temp1); gettime(temp2); INPAapiResultSets(SETS); INPAapiResultText(VARIANTE, "VARIANTE", 0, ""); INPAapiResultText(JOB_STATUS, "JOB_STATUS", SETS, ""); fileopen ( _FileName, _FsFileMode); if (_ApiFsJobName == "IS_LESEN") { filewrite( " I N F O S P E I C H E R L E S E N"); filewrite( " -----------------------------------"); } else if (_ApiFsJobName == "HS_LESEN") { filewrite( " H I S T O R I E N S P E I C H E R L E S E N"); filewrite( " ---------------------------------------------"); } else { filewrite( " F E H L E R S P E I C H E R L E S E N"); filewrite( " ---------------------------------------"); } filewrite(""); filewrite("Datum : "+temp1+" "+temp2); if (_ecu != VARIANTE) filewrite("ECU : "+_ecu); filewrite("JobStatus: "+JOB_STATUS); filewrite("Variante : "+VARIANTE+".PRG"); filewrite("Version : "+sgbd_version); filewrite( "-------------------------------------------------------------------------------"); if ( JOB_STATUS == "OKAY") { filewrite( ""); if (SETS == 1) filewrite( " >>>>>>>>>> Kein Fehler gefunden <<<<<<<<<<<"); else { inttostring(SETS-1,temp1); if ((SETS-1) < 10) temp1= " "+temp1;//Formatierung der Fehleranzahl, wenn sie kleiner 10 ist filewrite( "ERGEBNIS : "+temp1+" Fehler im Fehlerspeicher!"); if ((_FsMode & 0x100) == 0) { i=1; while ( i < SETS ) { if (_FsMode != 0) filewrite( "-------------------------------------------------------------------------------"); if ((_FsMode & 0x01) != 0) fs_protokoll_ort(i); if ((_FsMode & 0x04) != 0) fs_protokoll_art(i); if ((_FsMode & 0x40) != 0) fs_protokoll_hex(i); i=i+1; } } else { // Detail lesen i=1; StrArrayDelete(f_ort_nr_buffer); StrArrayDelete(f_ort_text_buffer); while ( i < SETS ) { INP1apiResultText(rc,temp1, "F_ORT_TEXT", i, ""); if (rc != TRUE) temp1="????"; StrArrayWrite(f_ort_text_buffer,i,temp1); INPAapiResultInt(x1, "F_ORT_NR", i); inttohexstring(x1, 4, temp1); StrArrayWrite(f_ort_nr_buffer,i,temp1); i=i+1; } i=1; while ( i < SETS ) { if (_FsMode != 0) filewrite( "-------------------------------------------------------------------------------"); StrArrayRead(f_ort_nr_buffer,i,FS_CODE); INPAapiJob(_ecu, _ApiFsJobName+"_DETAIL", "0x"+FS_CODE, ""); INP1apiResultSets(rc, UW_SETS); if (rc == TRUE) { INPAapiResultText(JOB_STATUS, "JOB_STATUS", UW_SETS, ""); if ( JOB_STATUS == "OKAY") { if ((_FsMode & 0x01) != 0) fs_protokoll_ort(1); if ((_FsMode & 0x200) != 0) fs_protokoll_PCode(1); if ((_FsMode & 0x400) != 0) fs_protokoll_PCode7(1); if ((_FsMode & 0x20) != 0) fs_protokoll_hfk(1); k=1; while ( k < UW_SETS ) { filewrite( ""); if ( UW_SETS > 2 ) { inttostring(k,temp1); filewrite( temp1 + ". Umweltsatz"); } if ((_FsMode & 0x02) != 0) fs_protokoll_uwb(k); k=k+1; } if ((_FsMode & 0x04) != 0) fs_protokoll_art(1); if ((_FsMode & 0x04) != 0) fs_protokoll_art_e(1); if ((_FsMode & 0x40) != 0) fs_protokoll_hex(1); } else { if ((_FsMode & 0x01) != 0) { filewrite( ""); StrArrayRead(f_ort_text_buffer,i,temp2); filewrite( "0x"+FS_CODE+" "+temp2); } INP1apiResultText(rc,JOB_MESSAGE, "JOB_MESSAGE", UW_SETS, ""); if (rc == TRUE) { filewrite( _ApiFsJobName+"_DETAIL: JobStatus: "+JOB_STATUS+" --> "+JOB_MESSAGE) ; } else filewrite( _ApiFsJobName+"_DETAIL: JobStatus: "+JOB_STATUS); fs_protokoll_telantwort(UW_SETS);//Telegrammantwort zur Fehleranalyse mit ausgeben } } else { if ((_FsMode & 0x01) != 0) { filewrite( ""); StrArrayRead(f_ort_text_buffer,i,temp2); filewrite( "0x"+FS_CODE+" "+temp2); } INP1apiErrorText(temp1); filewrite( _ApiFsJobName+"_DETAIL: "+temp1); } i=i+1; } } } } filewrite( "==============================================================================="); fileclose(); } //DS2 else if (errorcode == 134)//134=SYS-0014: Result nicht gefunden: 'F_VERSION' { INPAapiFsLesen( _ecu, _FileName); } //Fehlerhafter Aufruf else { INPAapiCheckJobStatus("OKAY");//Damit der Bediener die Fehlermeldung bestätigen muß getdate(temp1); gettime(temp2); INP1apiErrorText(temp3); fileopen ( _FileName, _FsFileMode); if (_ApiFsJobName == "IS_LESEN") { filewrite( " I N F O S P E I C H E R L E S E N"); filewrite( " -----------------------------------"); } else if (_ApiFsJobName == "HS_LESEN") { filewrite( " H I S T O R I E N S P E I C H E R L E S E N"); filewrite( " ---------------------------------------------"); } else { filewrite( " F E H L E R S P E I C H E R L E S E N"); filewrite( " ---------------------------------------"); } filewrite( ""); filewrite( "Datum : "+temp1+" "+temp2); filewrite( "ECU : "+_ecu); filewrite( "JobStatus: "+JOB_STATUS+"-->"+temp3) ; filewrite( "-------------------------------------------------------------------------------"); fileclose(); } } //********************************************************************** //* //* Fehlerprotokollausgabe Fehlerort für DS2 und BMW Fast //* //********************************************************************** fs_protokoll_ort(in: int nr) { int i; int x1; bool rc; string temp1; string temp2; i=nr; filewrite( ""); INP1apiResultInt(rc,x1, "F_ORT_NR", i); if (rc == TRUE) { inttohexstring(x1, 4, temp1); } else { temp1="????"; } INP1apiResultText(rc,temp2, "F_ORT_TEXT", i, ""); if (rc == TRUE) { filewrite( "0x"+temp1+" "+temp2); } else { filewrite( "0x"+temp1+" "+"????"); } } //********************************************************************** //* //* Fehlerprotokollausgabe Fehlerort für UDS (ISO 14229) //* //********************************************************************** fs_protokoll_ort_uds(in: int nr) { int i; int len; bool rc; string temp1; string temp2; i=nr; filewrite( ""); INP1apiResultBinary(rc,"F_HEX_CODE",i);//Fehlerort Nr. bei UDS: 3 Bytes, daher mit long arbeiten. (kein INPAapiResultText(temp1, "F_ORT_NR", i, "");....!) ...ergibt diese Lösung if (rc == TRUE) { if (_ApiFsJobName == "FS_LESEN") { GetBinaryDataString (temp1,len); midstr(temp1,temp1,0,6); } else//IS_LESEN { GetBinaryDataString (temp1,len); midstr(temp1,temp1,2,6);//Byte 0, Zeichen 0 und 1 sind das severity Byte! } } else { temp1= "??????"; } INP1apiResultText(rc,temp2, "F_ORT_TEXT", i, ""); if (rc == TRUE) { filewrite( "0x"+temp1+" "+temp2); } else { filewrite( "0x"+temp1+" "+"??????"); } } //********************************************************************** //* //* Fehlerprotokollausgabe PCODE //* //********************************************************************** fs_protokoll_PCode(in: int nr) { int i; int x1; bool rc; string tempPcodeText; string tempPcodeString; string tempPcodeHex; i=nr; INP1apiResultText(rc,tempPcodeString, "F_PCODE_STRING", i,""); if (rc == TRUE) { INP1apiResultText(rc,tempPcodeText, "F_PCODE_TEXT", i, ""); if (rc == TRUE) { INP1apiResultInt(rc,x1, "F_PCODE", i); if (rc == TRUE) { inttohexstring(x1, 4, tempPcodeHex); tempPcodeHex= "0x"+tempPcodeHex; } else { tempPcodeHex = "????"; } } else { tempPcodeText = "????"; } if (tempPcodeString == "??") { filewrite( ""); filewrite( tempPcodeHex+" "+tempPcodeText); } else { if (tempPcodeString != "--") { filewrite( ""); filewrite( tempPcodeText); } } } } //********************************************************************** //* //* Fehlerprotokollausgabe PCODE7 //* //********************************************************************** fs_protokoll_PCode7(in: int nr) { int i; int x1; bool rc; string tempPcode7Text; string tempPcode7String; string tempPcode7Hex; i=nr; INP1apiResultText(rc,tempPcode7String, "F_PCODE7_STRING", i,""); if (rc == TRUE) { INP1apiResultText(rc,tempPcode7Text, "F_PCODE7_TEXT", i, ""); if (rc == TRUE) { INP1apiResultInt(rc,x1, "F_PCODE7", i); if (rc == TRUE) { inttohexstring(x1, 4, tempPcode7Hex); tempPcode7Hex= "0x"+tempPcode7Hex; } else { tempPcode7Hex = "????"; } } else { tempPcode7Text = "????"; } if (tempPcode7String == "??") { filewrite( ""); filewrite( tempPcode7Hex+" "+tempPcode7Text); } else { if (tempPcode7String != "--") { filewrite( ""); filewrite( tempPcode7Text); } } } } //********************************************************************** //* //* Fehlerprotokollausgabe SAE Code für UDS //* //********************************************************************** fs_protokoll_SAECode(in: int nr) { int i; int x1; bool rc; string tempSAECodeText; string tempSAECodeString; string tempSAECodeHex; i=nr; INP1apiResultText(rc,tempSAECodeString, "F_SAE_CODE_STRING", i,""); if (rc == TRUE) { INP1apiResultText(rc,tempSAECodeText, "F_SAE_CODE_TEXT", i, ""); if (rc == TRUE) { INP1apiResultInt(rc,x1, "F_SAE_CODE", i); if (rc == TRUE) { inttohexstring(x1, 4, tempSAECodeHex); tempSAECodeHex= "0x"+tempSAECodeHex; } else { tempSAECodeHex = "????"; } } else { tempSAECodeText = "????"; } if (tempSAECodeString == "??") { filewrite( ""); filewrite( tempSAECodeHex+" "+tempSAECodeText); } else { if (tempSAECodeString != "--") { filewrite( ""); filewrite( tempSAECodeText); } } } } //********************************************************************** //* //* Fehlerprotokollausgabe Fehlerhäufigkeit //* //********************************************************************** fs_protokoll_hfk(in: int nr) { int i; bool rc; string temp1; int f_hfk; int f_lz; i=nr; filewrite( ""); INP1apiResultInt(rc,f_hfk,"F_HFK",i); if (rc == FALSE) temp1 ="????"; if (temp1 !="-1") { inttostring(f_hfk,temp1); if (f_hfk < 10) temp1= " "+temp1;//Formatierung der Nr der Fehlerhäufigkeit, wenn sie kleiner 10 ist filewrite( "Fehlerhäufigkeit: "+ temp1); } INP1apiResultInt(rc,f_lz,"F_LZ",i); if (rc == FALSE) temp1 ="????"; if (temp1 !="-1") { inttostring(f_lz,temp1); if (f_lz < 10) temp1= " "+temp1;//Formatierung der Nr des Logistikzählers, wenn sie kleiner 10 ist filewrite( "Logistikzähler : "+ temp1); } } //********************************************************************** //* //* Fehlerprotokollausgabe Fehlerhäufigkeit für UDS //* //********************************************************************** fs_protokoll_hfk_uds(in: int nr) { int i; int x1; bool rc; string temp1; string temp2; i=nr; filewrite( ""); //FS Überlauf INP1apiResultInt(rc,x1, "F_UEBERLAUF", i); if ((rc == TRUE) && (x1==1)) { filewrite( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); if (_ApiFsJobName == "IS_LESEN") filewrite("++++++++++++++++++++++++ Infospeicher ist übergelaufen! +++++++++++++++++++++++"); else filewrite("+++++++++++++++++++++++ Fehlerspeicher ist übergelaufen! ++++++++++++++++++++++"); filewrite( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); filewrite( ""); } //Fehlerhäufigkeit INP1apiResultInt(rc,x1, "F_HFK", i); if (rc == FALSE) { temp1 ="????"; } else { if (x1 == -1) { temp1= "wird nicht unterstützt"; } else { inttostring(x1,temp1); if (x1 < 10) temp1= " "+temp1;//Formatierung der Nr der Fehlerhäufigkeit, wenn sie kleiner 10 ist } } filewrite( "Fehlerhäufigkeit: "+ temp1); //Heilungszähler INP1apiResultInt(rc,x1, "F_HLZ", i); if (rc == FALSE) { temp1 ="????"; } else { if (x1 == -1) { temp1= "wird nicht unterstützt"; } else { inttostring(x1,temp1); if (x1 < 10) temp1= " "+temp1;//Formatierung des Heilungszählers, wenn er kleiner 10 ist } } filewrite( "Heilungszähler : "+ temp1); } //********************************************************************** //* //* Fehlerprotokollausgabe Fehlerarten //* //********************************************************************** fs_protokoll_art(in: int nr) { int i; bool rc; string temp1; i=nr; filewrite( ""); INP1apiResultText(rc,temp1, "F_SYMPTOM_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); INP1apiResultText(rc,temp1, "F_READY_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); INP1apiResultText(rc,temp1, "F_VORHANDEN_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); INP1apiResultText(rc,temp1, "F_WARNUNG_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); } //********************************************************************** //* //* Fehlerprotokollausgabe erweiterte Fehlerarten //* //********************************************************************** fs_protokoll_art_e(in: int nr) { int i; int k; int F_ART_ANZ; bool rc; string temp1; string temp2; i=nr; INP1apiResultInt(rc,F_ART_ANZ, "F_ART_ANZ", i); if (rc == TRUE) { if ( F_ART_ANZ > 0 ) { k=0; while ( k < F_ART_ANZ ) { k = k + 1; inttostring(k,temp2); INP1apiResultText(rc,temp1, "F_ART"+temp2+"_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); } } } } //********************************************************************** //* //* Fehlerprotokollausgabe Fehlerarten für UDS //* //********************************************************************** fs_protokoll_art_uds(in: int nr) {//Symptome entfallen bei UDS! int i; int x1; bool rc; string temp1; i=nr; filewrite( ""); INP1apiResultText(rc,temp1, "F_READY_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); INP1apiResultText(rc,temp1, "F_VORHANDEN_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); INP1apiResultText(rc,temp1, "F_WARNUNG_TEXT", i, ""); if (rc == FALSE) temp1 ="????"; if (temp1 !="--") filewrite( " "+ temp1); //Neu bei UDS: INP1apiResultInt(rc,x1, "F_EREIGNIS_DTC", i); if (rc == TRUE) { if (x1==0) { filewrite(" Dies ist kein Ereignis DTC. Das SG ist für den Fehlerspeicheintrag (DTC) verantwortlich."); } else if (x1==1) { filewrite(" Dies ein Ereignis DTC. Das SG ist somit nicht für den Fehlereintrag (DTC) verantwortlich."); filewrite(" Z.B. falsche oder fehlende Netzwerkinformationen."); } else { filewrite(" Fehler in SGBD! In Tabelle FOrtTexte, Spalte EREIGNIS_DTC muß 0 oder 1 stehen!"); } } } //********************************************************************** //* //* Fehlerprotokollausgabe Umweltbedingungen //* //********************************************************************** fs_protokoll_uwb(in: int nr) { int i; int k; int len; int F_UW_ANZ; bool rc; string temp1; string temp2; string temp3; real realval; int pos; i=nr; /* INP1apiResultText(rc,temp1, "F_UW_ZEIT", i, "10T"); if (rc == FALSE) { temp1=" ????"; } filewrite( " Absolute Zeit " + temp1+ " s"); */ INP1apiResultText(rc,temp1, "F_UW_KM", i, "8L"); if (rc == FALSE) temp1=" ????"; if ((temp1 == "524280") && (ident_typ != 3)) temp1 = "-1";//Fehlerüberlauf für DS2 und BMW FAST, UDS liefert es von alleine temp2 = "Kilometerstand "; filewrite( " " + temp2 + temp1 + " km"); INP1apiResultInt(rc,F_UW_ANZ, "F_UW_ANZ", i); if (rc == TRUE) { if ( F_UW_ANZ > 0 ) { k=0; while ( k < F_UW_ANZ ) { k = k + 1; inttostring(k,temp2); INP1apiResultText(rc,temp3, "F_UW"+temp2+"_EINH", i, ""); if (rc == TRUE) { AnsiUpper(temp3,temp3); } else { temp3 = "????"; } if ((temp3 == "0-N") || (temp3 == "HEX")) { INP1apiResultText(rc,temp1, "F_UW"+temp2+"_TEXT", i, "-20T"); if (rc == FALSE) temp1="???? "; if (temp1 !="-- ") //"--" + 18 Zeichen { if ((_FsMode & 0x08) != 0) { INP1apiResultText(rc,temp3, "F_UW"+temp2+"_WERT", i, "28T"); if (rc == FALSE) temp3="???? "; temp1 = temp1 + " " + temp3; } if ((_FsMode & 0x10) != 0) { INP1apiResultText(rc,temp3, "F_UW"+temp2+"_EINH", i, ""); if (rc == FALSE) temp3="????"; temp1 = temp1 + " " + temp3; } filewrite( " "+ temp1); } } else { INP1apiResultText(rc,temp1, "F_UW"+temp2+"_TEXT", i, "-40T"); if (rc == FALSE) temp1="???? "; if (temp1 !="-- ") { if ((_FsMode & 0x08) != 0) { INP1apiResultText(rc,temp3, "F_UW"+temp2+"_WERT", i, "8.2R"); if (rc == FALSE) temp3=" ???? "; temp1 = temp1 + " " + temp3; } if ((_FsMode & 0x10) != 0) { INP1apiResultText(rc,temp3, "F_UW"+temp2+"_EINH", i, ""); if (rc == FALSE) temp3="????"; temp1 = temp1 + " " + temp3; } filewrite( " "+ temp1); } } } } } } //********************************************************************** //* //* Fehlerprotokollausgabe Umweltbedingungen //* //********************************************************************** fs_protokoll_uwb_uds(in: int nr) { int i; // int k; // int len; // int F_UW_ANZ; bool rc; string temp1; // string temp2; // string temp3; // real realval; // int pos; i=nr; INP1apiResultText(rc,temp1, "F_UW_ZEIT", i, "10T"); if (rc == FALSE) { temp1=" ????"; } filewrite( " Absolute Zeit " + temp1+ " s"); fs_protokoll_uwb(i); } //********************************************************************** //* //* Fehlerprotokollausgabe Hexcode //* //********************************************************************** fs_protokoll_hex(in: int nr) { string nl; int i; int x1; int x2; int x3; bool rc; string temp1; string temp2; string temp3; chr(10,nl); i=nr; filewrite( ""); INP1apiResultBinary(rc,"F_HEX_CODE", i); if (rc == TRUE) { GetBinaryDataString (temp1, x1); x2 = 0; x3 = 0; temp2=""; while ( x2 < x1 ) { midstr(temp3, temp1, x2, 2); temp2 = temp2 + temp3; x2 = x2 + 2; x3 = x3 + 1; if ( x2 < x1 ) { if ( x3 < 16 )//Leerzeichen zwischen den Bytes { if ( x3 == 8 ) temp2 = temp2 + " ";//Nach 8 Bytes zwei Leerz. dann wieder 8 Bytes schreiben else temp2 = temp2 + " "; } else { x3 = 0; temp2 = temp2 + nl + " "; } } } } else { temp2 = "????"; } filewrite( "Fehlercode: "+temp2); } //********************************************************************** //* //* Fehlerprotokollausgabe Telegrammantwort(en) //* Wird nur bei Fehlerhaften FS_LESEN_DETAIL ausgegeben //* //********************************************************************** fs_protokoll_telantwort(in: int nr) { string nl; int i; int x1; int x2; int x3; bool rc; string temp1; string temp2; string temp3; string temp4; string temp5; chr(10,nl); i=nr; filewrite( ""); if (ident_typ == 3)//3=UDS (ISO 14229) { if (_ApiFsJobName == "FS_LESEN") INP1apiResultBinary(rc,"_RESPONSE_SNAPSHOT", i); else INP1apiResultBinary(rc,"_RESPONSE_2000", i);//IS_LESEN } else//1=DS2, 2=BMW Fast { INP1apiResultBinary(rc,"_TEL_ANTWORT", i); } if (rc == TRUE) { GetBinaryDataString (temp1, x1); x2 = 0; x3 = 0; temp2=""; while ( x2 < x1 ) { midstr(temp3, temp1, x2, 2); temp2 = temp2 + temp3; x2 = x2 + 2; x3 = x3 + 1; if ( x2 < x1 ) { if ( x3 < 16 )//Leerzeichen zwischen den Bytes { if ( x3 == 8 ) temp2 = temp2 + " ";//Nach 8 Bytes zwei Leerz. dann wieder 8 Bytes schreiben else temp2 = temp2 + " "; } else { x3 = 0; temp2 = temp2 + nl + " "; } } } } else { temp2 = "????--> Zur Analyse IFH-Trace benutzen!"; } //2. Telegramm nur für UDS ausgeben if (ident_typ == 3)//3=UDS (ISO 14229) { if (_ApiFsJobName == "FS_LESEN") INP1apiResultBinary(rc,"_RESPONSE_EXTENDED_DATA", i); else INP1apiResultBinary(rc,"_RESPONSE_200X", i);//IS_LESEN if (rc == TRUE) { GetBinaryDataString (temp1, x1); x2 = 0; x3 = 0; temp4=""; while ( x2 < x1 ) { midstr(temp3, temp1, x2, 2); temp4 = temp4 + temp3; x2 = x2 + 2; x3 = x3 + 1; if ( x2 < x1 ) { if ( x3 < 16 )//Leerzeichen zwischen den Bytes { if ( x3 == 8 ) temp4 = temp4 + " ";//Nach 8 Bytes zwei Leerz. dann wieder 8 Bytes schreiben else temp4 = temp4 + " "; } else { x3 = 0; temp4 = temp4 + nl + " "; } } } } else { temp4 = "????--> Zur Analyse IFH-Trace benutzen!"; } filewrite("Telegramm-Antwort ab Service Identifier zur Analyse"); if (_ApiFsJobName == "FS_LESEN") { filewrite("Data : "+temp2); filewrite("Snapshot : "+temp4); } else//IS_LESEN { filewrite("2000 : "+temp2); filewrite("200X : "+temp4); } } else//DS2, BMW Fast { filewrite("Telegramm-"); filewrite("Antwort : "+temp2); } } // -- EOF -- // end of :#include "FS_LESEN.SRC" // start of :#include "INITEXIT.SRC" //********************************************************************** //* //* INPA Library-Funktionen INITEXIT.SRC //* //* mindestens INPA 5.0.1 //* //********************************************************************** //* Gall TI-430 //********************************************************************** //* History: //* 04.07.2000 rd V0.03 Ersterstellung //* 25.04.2002 rd V1.00 Freigabe //* 24.09.2002 rd V1.01 Scriptinit verlagert //* 12.03.2003 iS V1.01 Anpassung SgbdInpaCheck()GroupCheck(); //* 16.02.2004 rd V2.00 Umstellung auf 32-Bit Version //* 30.03.2006 GA V3.00 Erweiterung auf UDS (ISO 14229) //* GA V3.00 INPA.INI, [EXTRA], SRIPTS auslesen, ob "deleteread" gesetzt, //* GA V3.00 um nach FS- IS-, HS-Löschen automatisch wieder zu lesen. //********************************************************************** // ************************** // *** inpainit, inpaexit *** // ************************** inpainit() { bool rc; string temp; int i; INPAapiInit(); chrinit(); // Handle für FS_LESEN StrArrayCreate(rc,f_ort_nr_buffer); if (rc == FALSE) { messagebox("Unerwarteter Fehler", // sollte nie kommen "StrArrayCreate(rc,f_ort_nr_buffer). "+CRLF+ "Das Programm wird abgebrochen!"); exit(); } StrArrayCreate(rc,f_ort_text_buffer); if (rc == FALSE) { messagebox("Unerwarteter Fehler", // sollte nie kommen "StrArrayCreate(rc,f_ort_text_buffer). "+CRLF+ "Das Programm wird abgebrochen!"); exit(); } SgbdInpaCheck(); GroupCheck(); setmenu(m_main); setscreen(s_main,TRUE); //INPA.INI einlesen, //um nach FS- IS-, HS-Löschen automatisch wieder zu lesen. //hinter "SCRIPTS" muß DeleteRead stehen, um die Funktion freizuschalten ExtraScript("DeleteRead", deleteread_flag); //m FS,IS,HS zu speichern ExtraScript("SaveAs", fs_lesen_save_as_flag); is_lesen_save_as_flag=fs_lesen_save_as_flag; hs_lesen_save_as_flag=fs_lesen_save_as_flag; //INPA.INI-Einstellung, falls Funktionen gewünscht: //[EXTRA] //SCRIPTS = DeleteRead,SaveAs //Wichtig: Nach dem Komma kein Leerzeichen benutzen! ScriptInit(); } inpaexit() { INPAapiEnd(); // Handle für FS_LESEN StrArrayDestroy(f_ort_nr_buffer); StrArrayDestroy(f_ort_text_buffer); } // -- EOF -- // end of :#include "INITEXIT.SRC" // ************************** // *** Hauptmenü *** // ************************** MENU m_main() { INIT { setmenutitle("Hauptmenü"); if ((ident_typ == 1)||(ident_typ == 2)) //DS2 oder BMW FAST { setitem(2, "Ident", TRUE); } else { setitem(2, "SVK", TRUE);//ISO 14229 } if ((fs_lesen_flag == TRUE) || (is_lesen_flag == TRUE) || (hs_lesen_flag == TRUE)) { setitem( 4 , "Fehler" , TRUE); } if (m_status_flag == TRUE) { setitem( 5 , "Status" , TRUE); } if (m_steuern_flag == TRUE) { setitem( 6 , "Steuern" , TRUE); } if (speicher_lesen_flag == TRUE) { setitem( 7 , "Speicher" , TRUE); } } ITEM( 1 ,"Info") { userboxclose(1); setscreen(s_info,TRUE); } ITEM( 2 ,"Ident") { userboxclose(1); if (ident_typ == 1) setscreen(s_ident_ds2,TRUE); else if (ident_typ == 2) setscreen(s_ident,TRUE); else setscreen(s_svk_lesen,TRUE); } ITEM( 3 ,"") { userboxclose(1); setscreen(s_main,TRUE); } ITEM( 4 ,"") { userboxclose(1); if ((fs_lesen_flag == TRUE) || (is_lesen_flag == TRUE) || (hs_lesen_flag == TRUE)) { setscreen( s_fehler ,TRUE); setmenu(m_fehler); } else setscreen( s_main ,TRUE); } ITEM( 5 ,"") { userboxclose(1); if (m_status_flag == TRUE) { setscreen(s_status,TRUE); setmenu(m_status); } else setscreen( s_main ,TRUE); } ITEM( 6 ,"") { userboxclose(1); if (m_steuern_flag == TRUE) { setscreen(s_steuern,TRUE); setmenu(m_steuern); } else setscreen( s_main ,TRUE); } ITEM( 7 ,"") { userboxclose(1); if (speicher_lesen_flag == TRUE) { setscreen(s_speicher,TRUE); setmenu(m_speicher); } else setscreen( s_main ,TRUE); } ITEM( 8 ,"Auswahl") { start(); select(TRUE); } ITEM(18 ,"Gesamt") { start(); deselect(); } ITEM( 9 ,"Druck") { printscreen(); } ITEM( 10 ,"Ende") { exit(); } ITEM( 11, "KVP") { setscreen(s_info,TRUE); callwin( "kvp_edit "+titel+";"+version+";"+sgbd+": "+sgbd_ecu+";"+sgbd_revision); } ITEM( 12 ,"") { setscreen( s_main ,TRUE); } ITEM( 13 ,"") { setscreen( s_main ,TRUE); } ITEM( 14 ,"") { setscreen( s_main ,TRUE); } ITEM( 15 ,"") { setscreen( s_main ,TRUE); } ITEM( 16 ,"") { setscreen( s_main ,TRUE); } ITEM( 17 ,"") { setscreen( s_main ,TRUE); } ITEM( 19 ,"") { setscreen( s_main ,TRUE); } ITEM( 20 ,"Exit") { exit(); } } // ************************** // *** Fehlermenü *** // ************************** MENU m_fehler() { int ErrorCode; int SpeicherUnterDateiNameLaenge=0; int ReturnedValue; string CurrentDirectory; string SpeichernKommentar1=""; string SpeichernKommentar2=""; string SpeicherUnterDateiName=""; string DateiLesenZeile=""; string DateiLesenPuffer=""; bool DateiLesenEOF; string DateiName=""; int aufrufIO; string JOB_STATUS; bool fehlerflag; INIT { setmenutitle("Fehlerspeicher"); if (fs_lesen_flag == TRUE) { setitem( 1 , "FS lesen" , TRUE); setitem( 2 , "FS löschen" , TRUE); setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 3 , "IS lesen" , TRUE); if (is_loeschen_flag == TRUE) setitem( 4 , "IS löschen" , TRUE); else setitem( 4 , "" , FALSE);//Nicht alle SGs haben IS_LOESCHEN. Z.B. EPS_90.PRG setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 5 , "HS lesen" , TRUE); if (hs_loeschen_flag == TRUE) setitem( 6 , "HS löschen" , TRUE); else setitem( 6 , "" , FALSE);//Nicht alle SGs haben HS_LOESCHEN. Z.B. EPS_90.PRG setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } } ITEM( 1 ,"") { userboxclose(0); viewclose(); if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } if (fs_lesen_flag == TRUE) { userboxopen(0,8,35,5,50,"Fehlerspeicher lesen",""); userboxftextout(0,"Der Fehlerspeicher wird gelesen! ... bitte warten",1,3,0,0); INPAapiFsMode_neu(0x7FF,"w","","",""); // alles Anzeigen INPAapiFsLesen_neu(sgbd,"na_fs.tmp"); userboxclose(0); DateiName="na_fs.tmp"; viewopen(DateiName,"Fehlerspeicher lesen"); setitem( 9 , "FS drucken" , TRUE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", TRUE); } } ITEM( 2 ,"") { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } if (fs_lesen_flag == TRUE) { INPAapiJob(sgbd,"FS_LOESCHEN","",""); INP1apiResultText(fehlerflag,JOB_STATUS, "JOB_STATUS", 1, ""); if (JOB_STATUS != "OKAY") { userboxopen(0,8,35,5,50,"Fehlerspeicher löschen",""); userboxftextout(0,"Der Fehlerspeicher konnte nicht gelöscht werden!",1,3,0,0); userboxsetcolor(0,1,4); INPAapiCheckJobStatus("OKAY"); } else { userboxopen(0,8,35,5,50,"Fehlerspeicher löschen",""); userboxftextout(0,"Der Fehlerspeicher wurde gelöscht!",1,3,0,0); if (deleteread_flag == TRUE) // Aktivierung über INPA.INI, SCRIPTS = DeleteRead { delay(2000); userboxclose(0); userboxopen(0,8,35,5,50,"Fehlerspeicher lesen",""); userboxftextout(0,"Der Fehlerspeicher wird gelesen! ... bitte warten",1,3,0,0); INPAapiFsMode_neu(0x7FF,"w","","",""); // alles Anzeigen INPAapiFsLesen_neu(sgbd,"na_fs.tmp"); userboxclose(0); DateiName="na_fs.tmp"; viewopen(DateiName,"Fehlerspeicher lesen"); setitem( 9 , "FS drucken" , TRUE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", TRUE); } } } } ITEM( 3 ,"") { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } if (is_lesen_flag == TRUE) { userboxopen(0,8,35,5,50,"Infospeicher lesen",""); userboxftextout(0,"Der Infospeicher wird gelesen! ... bitte warten",1,3,0,0); INPAapiFsMode_neu(0x7FF,"w","","","IS_LESEN"); // alles Anzeigen INPAapiFsLesen_neu(sgbd,"na_fs.tmp"); userboxclose(0); DateiName="na_fs.tmp"; viewopen(DateiName,"Infospeicher lesen"); setitem( 8 , "IS drucken" , TRUE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", TRUE); } } ITEM( 4 ,"") { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } if (is_loeschen_flag == TRUE) { INPAapiJob(sgbd,"IS_LOESCHEN","",""); INP1apiResultText(fehlerflag,JOB_STATUS, "JOB_STATUS", 1, ""); if (JOB_STATUS != "OKAY") { userboxopen(0,8,35,5,50,"Infospeicher löschen",""); userboxftextout(0,"Der Infospeicher konnte nicht gelöscht werden!",1,3,0,0); userboxsetcolor(0,1,4); INPAapiCheckJobStatus("OKAY"); } else { userboxopen(0,8,35,5,50,"Infospeicher löschen",""); userboxftextout(0,"Der Infospeicher wurde gelöscht!",1,3,0,0); if (deleteread_flag == TRUE) // Aktivierung über INPA.INI, SCRIPT = deleteread { delay(2000); userboxclose(0); userboxopen(0,8,35,5,50,"Infospeicher lesen",""); userboxftextout(0,"Der Infospeicher wird gelesen! ... bitte warten",1,3,0,0); INPAapiFsMode_neu(0x7FF,"w","","","IS_LESEN"); // alles Anzeigen INPAapiFsLesen_neu(sgbd,"na_fs.tmp"); userboxclose(0); DateiName="na_fs.tmp"; viewopen(DateiName,"Infospeicher lesen"); setitem( 8 , "IS drucken" , TRUE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", TRUE); } } } } ITEM( 5 ,"") { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { userboxopen(0,8,35,5,50,"Historienspeicher lesen",""); userboxftextout(0,"Der Historienspeicher wird gelesen! ... bitte warten",1,3,0,0); INPAapiFsMode_neu(0x7FF,"w","","","HS_LESEN"); // alles Anzeigen INPAapiFsLesen_neu(sgbd,"na_fs.tmp"); userboxclose(0); DateiName="na_fs.tmp"; viewopen(DateiName,"Historienspeicher lesen"); setitem( 7 , "HS drucken" , TRUE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", TRUE); } } ITEM( 6 ,"") { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } if (hs_loeschen_flag == TRUE) { INPAapiJob(sgbd,"HS_LOESCHEN","",""); INP1apiResultText(fehlerflag,JOB_STATUS, "JOB_STATUS", 1, ""); if (JOB_STATUS != "OKAY") { userboxopen(0,8,35,5,50,"Historienspeicher löschen",""); userboxftextout(0,"Der Historienspeicher konnte nicht gelöscht werden!",1,3,0,0); userboxsetcolor(0,1,4); INPAapiCheckJobStatus("OKAY"); } else { userboxopen(0,8,35,5,50,"Historienspeicher löschen",""); userboxftextout(0,"Der Historienspeicher wurde gelöscht!",1,3,0,0); if (deleteread_flag == TRUE) // Aktivierung über INPA.INI, SCRIPT = deleteread { delay(2000); userboxclose(0); userboxopen(0,8,35,5,50,"Historienspeicher lesen",""); userboxftextout(0,"Der Historienspeicher wird gelesen! ... bitte warten",1,3,0,0); INPAapiFsMode_neu(0x7FF,"w","","","HS_LESEN"); // alles Anzeigen INPAapiFsLesen_neu(sgbd,"na_fs.tmp"); userboxclose(0); DateiName="na_fs.tmp"; viewopen(DateiName,"Historienspeicher lesen"); setitem( 7 , "HS drucken" , TRUE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", TRUE); } } } } ITEM( 7 ,"") { if (hs_lesen_flag == TRUE) { printfile(ErrorCode, DateiName, "", "",TRUE); } else { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } } } ITEM( 8 ,"") { if (is_lesen_flag == TRUE) { printfile(ErrorCode, DateiName, "", "",TRUE); } else { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } } } ITEM( 9 ,"") { if (fs_lesen_flag == TRUE) { printfile(ErrorCode, DateiName, "", "",TRUE); } else { userboxclose(0); viewclose(); if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } } } ITEM(17 ,"") { if ((hs_lesen_flag == TRUE) && (hs_lesen_save_as_flag == TRUE)) { input2text(SpeichernKommentar1,SpeichernKommentar2, "Kommentar", "Geben Sie den zu speichernden Kommentar ein", "",""); getinputstate(input_state); if (input_state==input_ok) { space(SpeicherUnterDateiName,256); strlen(SpeicherUnterDateiNameLaenge,SpeicherUnterDateiName); GetCurrentDirectory(256,CurrentDirectory,ReturnedValue); SaveAsDialogBox("",SpeicherUnterDateiName,SpeicherUnterDateiNameLaenge,SpeicherUnterDateiNameLaenge); SetCurrentDirectory(CurrentDirectory,ReturnedValue); if (SpeicherUnterDateiNameLaenge > 0) { DateiLesenPuffer=""; fileopen("na_fs.tmp","r"); fileread(DateiLesenZeile, DateiLesenEOF ); while (DateiLesenEOF == FALSE) { DateiLesenPuffer=DateiLesenPuffer+DateiLesenZeile; fileread(DateiLesenZeile, DateiLesenEOF ); if (DateiLesenEOF == FALSE) DateiLesenPuffer=DateiLesenPuffer+LF; } fileclose(); DateiName=SpeicherUnterDateiName; fileopen(DateiName,"w"); if (SpeichernKommentar1 + SpeichernKommentar2 != "") { filewrite( " K O M M E N T A R"); filewrite( " -----------------"); filewrite( ""); if (SpeichernKommentar1 != "") filewrite(SpeichernKommentar1); if (SpeichernKommentar2 != "") filewrite(SpeichernKommentar2); filewrite( "-------------------------------------------------------------"); filewrite(""); } filewrite(DateiLesenPuffer); fileclose(); viewclose(); viewopen(DateiName,"Historienspeicher speichern: "+DateiName); } } } else { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); } } } ITEM(18 ,"") { if ((is_lesen_flag == TRUE) && (is_lesen_save_as_flag == TRUE)) { input2text(SpeichernKommentar1,SpeichernKommentar2, "Kommentar", "Geben Sie den zu speichernden Kommentar ein", "",""); getinputstate(input_state); if (input_state==input_ok) { space(SpeicherUnterDateiName,256); strlen(SpeicherUnterDateiNameLaenge,SpeicherUnterDateiName); GetCurrentDirectory(256,CurrentDirectory,ReturnedValue); SaveAsDialogBox("",SpeicherUnterDateiName,SpeicherUnterDateiNameLaenge,SpeicherUnterDateiNameLaenge); SetCurrentDirectory(CurrentDirectory,ReturnedValue); if (SpeicherUnterDateiNameLaenge > 0) { DateiLesenPuffer=""; fileopen("na_fs.tmp","r"); fileread(DateiLesenZeile, DateiLesenEOF ); while (DateiLesenEOF == FALSE) { DateiLesenPuffer=DateiLesenPuffer+DateiLesenZeile; fileread(DateiLesenZeile, DateiLesenEOF ); if (DateiLesenEOF == FALSE) DateiLesenPuffer=DateiLesenPuffer+LF; } fileclose(); DateiName=SpeicherUnterDateiName; fileopen(DateiName,"w"); if (SpeichernKommentar1 + SpeichernKommentar2 != "") { filewrite( " K O M M E N T A R"); filewrite( " -----------------"); filewrite( ""); if (SpeichernKommentar1 != "") filewrite(SpeichernKommentar1); if (SpeichernKommentar2 != "") filewrite(SpeichernKommentar2); filewrite( "-------------------------------------------------------------"); filewrite(""); } filewrite(DateiLesenPuffer); fileclose(); viewclose(); viewopen(DateiName,"Infospeicher speichern: "+DateiName); } } } else { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); if (fs_lesen_save_as_flag == TRUE) setitem(19 , "FS speichern", FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } } } ITEM(19 ,"") { if ((fs_lesen_flag == TRUE) && (fs_lesen_save_as_flag == TRUE)) { input2text(SpeichernKommentar1,SpeichernKommentar2, "Kommentar", "Geben Sie den zu speichernden Kommentar ein", "",""); getinputstate(input_state); if (input_state==input_ok) { space(SpeicherUnterDateiName,256); strlen(SpeicherUnterDateiNameLaenge,SpeicherUnterDateiName); GetCurrentDirectory(256,CurrentDirectory,ReturnedValue); SaveAsDialogBox("",SpeicherUnterDateiName,SpeicherUnterDateiNameLaenge,SpeicherUnterDateiNameLaenge); SetCurrentDirectory(CurrentDirectory,ReturnedValue); if (SpeicherUnterDateiNameLaenge > 0) { DateiLesenPuffer=""; fileopen("na_fs.tmp","r"); fileread(DateiLesenZeile, DateiLesenEOF ); while (DateiLesenEOF == FALSE) { DateiLesenPuffer=DateiLesenPuffer+DateiLesenZeile; fileread(DateiLesenZeile, DateiLesenEOF ); if (DateiLesenEOF == FALSE) DateiLesenPuffer=DateiLesenPuffer+LF; } fileclose(); DateiName=SpeicherUnterDateiName; fileopen(DateiName,"w"); if (SpeichernKommentar1 + SpeichernKommentar2 != "") { filewrite( " K O M M E N T A R"); filewrite( " -----------------"); filewrite( ""); if (SpeichernKommentar1 != "") filewrite(SpeichernKommentar1); if (SpeichernKommentar2 != "") filewrite(SpeichernKommentar2); filewrite( "-------------------------------------------------------------"); filewrite(""); } filewrite(DateiLesenPuffer); fileclose(); viewclose(); viewopen(DateiName,"Fehlerspeicher speichern: "+DateiName); } } } else { userboxclose(0); viewclose(); if (fs_lesen_flag == TRUE) { setitem( 9 , "FS drucken" , FALSE); } if (is_lesen_flag == TRUE) { setitem( 8 , "IS drucken" , FALSE); if (is_lesen_save_as_flag == TRUE) setitem(18 , "IS speichern", FALSE); } if (hs_lesen_flag == TRUE) { setitem( 7 , "HS drucken" , FALSE); if (hs_lesen_save_as_flag == TRUE) setitem(17 , "HS speichern", FALSE); } } } ITEM( 10 ,"Zurück") { userboxclose(0); viewclose(); setscreen( s_main ,TRUE); setmenu( m_main ); } ITEM( 20 ,"Exit") { userboxclose(0); viewclose(); exit(); } } // ************************** // *** Speichermenü *** // ************************** MENU m_speicher() { int input_ok=0; int input_state; string text_var; INIT { setmenutitle("Speicher lesen"); if (speicher_lesen_lar_flag==TRUE) setitem( 1 , "LAR" , TRUE); if (speicher_lesen_flash_flag==TRUE) setitem( 2 , "FLASH", TRUE); if (speicher_lesen_uifm_flag==TRUE) setitem( 3 , "UIFM" , TRUE); if (speicher_lesen_romi_flag==TRUE) setitem( 4 , "ROMI" , TRUE); if (speicher_lesen_ramis_flag==TRUE) setitem( 5 , "RAMIS", TRUE); if (speicher_lesen_ramil_flag==TRUE) setitem( 6 , "RAMIL", TRUE); if (speicher_lesen_nvram_flag==TRUE) setitem( 7 , "NVRAM", TRUE); if (speicher_lesen_romx_flag==TRUE) setitem(14 , "ROMX" , TRUE); if (speicher_lesen_ramxx_flag==TRUE) setitem(15 , "RAMXX", TRUE); } ITEM( 1 ,"") { if (speicher_lesen_lar_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"LAR lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="LAR lesen"; speicher_lesen_seg_adr_anz="LAR;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 2 ,"") { if (speicher_lesen_flash_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"FLASH lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="FLASH lesen"; speicher_lesen_seg_adr_anz="FLASH;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 3 ,"") { if (speicher_lesen_uifm_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"UIFM lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="UIFM lesen"; speicher_lesen_seg_adr_anz="UIFM;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 4 ,"") { if (speicher_lesen_romi_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"ROMI lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="ROMI lesen"; speicher_lesen_seg_adr_anz="ROMI;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 5 ,"") { if (speicher_lesen_ramis_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"RAMIS lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="RAMIS lesen"; speicher_lesen_seg_adr_anz="RAMIS;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 6 ,"") { if (speicher_lesen_ramil_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"RAMIL lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="RAMIL lesen"; speicher_lesen_seg_adr_anz="RAMIL;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 7 ,"") { if (speicher_lesen_nvram_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"NVRAM lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="NVRAM lesen"; speicher_lesen_seg_adr_anz="NVRAM;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 8 ,"") { setscreen( s_speicher,TRUE); } ITEM( 9 ,"Druck") { printscreen(); } ITEM( 10 ,"Zurück") { setscreen( s_main ,TRUE); setmenu( m_main ); } ITEM( 11 ,"") { setscreen( s_speicher,TRUE); } ITEM( 12 ,"") { setscreen( s_speicher,TRUE); } ITEM( 13 ,"") { setscreen( s_speicher,TRUE); } ITEM( 14 ,"") { if (speicher_lesen_romx_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"ROMX lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="ROMX lesen"; speicher_lesen_seg_adr_anz="ROMX;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 15 ,"") { if (speicher_lesen_ramxx_flag==TRUE) { input2hexnum(speicher_lesen_adresse,speicher_lesen_anzahl,"RAMXX lesen", "Es ist darauf zu achten, "+ "daß die angegebene Adresse + Anzahl "+ "der zu lesenden Bytes die Obergrenze "+ "(FFFFFF) nicht überschreitet.", "Adresse 000000-FFFFFF","Anzahl der Bytes 1-200","000000","FFFFFF",1,200); getinputstate(input_state); if (input_state==input_ok) { speicher_lesen_text="RAMXX lesen"; speicher_lesen_seg_adr_anz="RAMXX;"+speicher_lesen_adresse; inttostring(speicher_lesen_anzahl,text_var); speicher_lesen_seg_adr_anz=speicher_lesen_seg_adr_anz+";"+text_var; setscreen(s_speicher_ausgabe,TRUE); } } else setscreen(s_speicher,TRUE); } ITEM( 16 ,"") { setscreen( s_speicher,TRUE); } ITEM( 17 ,"") { setscreen( s_speicher,TRUE); } ITEM( 18 ,"") { setscreen( s_speicher,TRUE); } ITEM( 19 ,"") { setscreen( s_speicher,TRUE); } ITEM( 20 ,"Exit") { exit(); } } // ************************** // *** Hauptscreen *** // ************************** SCREEN s_main() { string text_var; userboxclose(0); ftextout("Hauptmenü",1,0,1,0); ftextout("",3,0,0,0); if (simulation_flag == TRUE) { userboxopen(1,14,30,5,48,"Hinweis",""); userboxftextout(1,"INPA bzw. EDIABAS läuft im Simulationsmodus!",1,3,0,24); userboxsetcolor(1,0,4); } if (ident_typ != 3) { INPAapiJob(sgbd,"IDENT","",""); INPAapiCheckJobStatus("OKAY"); } LINE("","") { if (ident_typ != 3)//Nur bei DS2 und BMW Fast vorhanden { ftextout("BMW Teilenummer",1,0,0,0); ftextout(":",1,19,0,0); INPAapiResultText(text_var,"ID_BMW_NR",1,""); ftextout(text_var,1,20,0,1); ftextout("Herstelldatum",1,43,0,0); ftextout(":",1,59,0,0); if (ident_typ == 1)//DS2 { ftextout("KW / Jahr",1,68,0,0); ftextout("/",1,63,0,1); INPAapiResultText(text_var,"ID_DATUM_KW",1,""); ftextout(text_var,1,60,0,1); INPAapiResultText(text_var,"ID_DATUM_JAHR",1,""); ftextout(text_var,1,65,0,1); } else if (ident_typ == 2)//BMW FAST { INPAapiResultText(text_var,"ID_DATUM",1,""); ftextout(text_var,1,60,0,1); } } ftextout("< F1 > Information" , 4,5,0,1); if ((ident_typ == 1)||(ident_typ == 2)) //DS2 oder BMW FAST { ftextout("< F2 > Identifikation" , 6,5,0,1); } else { ftextout("< F2 > Steuergeräteverbaukennung" , 6,5,0,1);//UDS (ISO 14229) } if ((fs_lesen_flag == TRUE) || (is_lesen_flag == TRUE) || (hs_lesen_flag == TRUE)) ftextout("< F4 > Fehlerspeicher" ,10,5,0,1); if (m_status_flag == TRUE) ftextout("< F5 > Status lesen" ,12,5,0,1); if (m_steuern_flag == TRUE) ftextout("< F6 > Ansteuern" ,14,5,0,1); if (speicher_lesen_flag == TRUE) ftextout("< F7 > Speicher lesen" ,16,5,0,1); ftextout("< F8 > Auswahl" ,18,5,0,1); ftextout("< F9 > Bildschirmdruck" ,20,5,0,1); ftextout("< F10> Ende" ,22,5,0,1); ftextout(" + < F1 > KVP-Editor" , 4,45,0,1); ftextout(" + < F8 > Gesamt" ,18,45,0,1); ftextout(" + < F10> Exit" ,22,45,0,1); } } // ************************** // *** Infoscreen *** // ************************** SCREEN s_info () { int i; int slen; int pos; int pos2; int anzahl; string temp; ftextout("Information",1,0,1,0); ftextout("Nacharbeitsprogramm",4,0,0,0); ftextout(":", 4,33,0,1); ftextout(titel,4,35,0,1); ftextout("Version",5,1,0,0); ftextout(":", 5,33,0,1); ftextout(version,5,35,0,1); ftextout("Package",6,1,0,0); ftextout(":", 6,33,0,1); ftextout(package,6,35,0,1); ftextout("Verantwortung",7,1,0,0); ftextout(":", 7,33,0,1); ftextout(origin,7,35,0,1); ftextout("Gruppendatei",10,0,0,0); ftextout(":",10,33,0,1); ftextout(gruppe,10,35,0,1); ftextout("Bezeichnung",11,1,0,0); ftextout(":",11,33,0,1); ftextout(gruppe_ecu,11,35,0,1); ftextout("Version",12,1,0,0); ftextout(":",12,33,0,1); ftextout(gruppe_revision,12,35,0,1); ftextout("Verantwortung",13,1,0,0); ftextout(":",13,33,0,1); ftextout(gruppe_origin,13,35,0,1); ftextout("Identifizierbare SGBD'en",14,1,0,0); strlen(slen, gruppe_comment); anzahl=44; pos=0; if ( slen <= anzahl ) { ftextout(":",14,33,0,1); ftextout(gruppe_comment,14,35,0,1); } else { instr(pos2, anzahl, gruppe_comment, ","); if (pos2 > 0) anzahl=pos2+1; midstr(temp, gruppe_comment, pos, anzahl); ftextout(":",14,33,0,1); ftextout(temp,14,35,0,1); i=14; pos=pos+anzahl; while ( pos < slen ) { i=i+1; anzahl=75; instr(pos2, pos + anzahl, gruppe_comment, ","); if (pos2 > 0) anzahl=pos2+1-pos; midstr(temp, gruppe_comment, pos, anzahl); ftextout(temp,i,1,0,1); pos=pos+anzahl; if ( i >= 18 ) { if ( pos < slen ) ftextout(temp+" . . .",i,1,0,1); pos=slen; } } } ftextout("Steuergerätebeschreibungsdatei",21,0,0,0); ftextout(":",21,33,0,1); ftextout(sgbd,21,35,0,1); ftextout("Steuergerät",22,1,0,0); ftextout(":",22,33,0,1); ftextout(sgbd_ecu,22,35,0,1); ftextout("Version",23,1,0,0); ftextout(":",23,33,0,1); ftextout(sgbd_revision,23,35,0,1); ftextout("Package",24,1,0,0); ftextout(":",24,33,0,1); ftextout(sgbd_package,24,35,0,1); ftextout("Verantwortung",25,1,0,0); ftextout(":",25,33,0,1); ftextout(sgbd_origin,25,35,0,1); ftextout("Sprache",26,1,0,0); ftextout(":",26,33,0,1); ftextout(sgbd_sprache,26,35,0,1); if (sgbd_comment!="") { ftextout("Kommentar",27,1,0,0); ftextout(":",27,33,0,1); ftextout(sgbd_comment,27,35,0,1); } } // ************************** // *** Identscreen DS2 *** // ************************** SCREEN s_ident_ds2() { ftextout("Identifikation",1,0,1,0); ftextout("",3,0,0,0); INPAapiJob(sgbd,"IDENT","",""); INPAapiCheckJobStatus("OKAY"); LINE("","") { ftextout("BMW Teilenummer",1,0,1,0); ftextout(":",1,33,1,0); INPAapiResultText(text_var,"ID_BMW_NR",1,""); ftextout(text_var,1,35,1,1); ftextout("Hardwarenummer",4,0,1,0); ftextout(":",4,33,1,0); INPAapiResultText(text_var,"ID_HW_NR",1,""); ftextout(text_var,4,35,1,1); ftextout("Softwarenummer",7,0,1,0); ftextout(":",7,33,1,0); INPAapiResultText(text_var,"ID_SW_NR",1,""); ftextout(text_var,7,35,1,1); ftextout("Lieferant",10,0,1,0); ftextout(":",10,33,1,0); INPAapiResultText(text_var,"ID_LIEF_TEXT",1,""); ftextout(text_var,10,35,1,1); ftextout("Codier-Index",13,0,1,0); ftextout(":",13,33,1,0); INPAapiResultText(text_var,"ID_COD_INDEX",1,""); ftextout(text_var,13,35,1,1); ftextout("Diagnose-Index",16,0,1,0); ftextout(":",16,33,1,0); INPAapiResultText(text_var,"ID_DIAG_INDEX",1,""); ftextout(text_var,16,35,1,1); ftextout("Bus-Index",19,0,1,0); ftextout(":",19,33,1,0); INPAapiResultText(text_var,"ID_BUS_INDEX",1,""); ftextout(text_var,19,35,1,1); ftextout("Herstelldatum",22,0,1,0); ftextout(":",22,33,1,0); ftextout("KW / Jahr",22,55,1,0); ftextout("/",22,41,1,1); INPAapiResultText(text_var,"ID_DATUM_KW",1,""); ftextout(text_var,22,35,1,1); INPAapiResultText(text_var,"ID_DATUM_JAHR",1,""); ftextout(text_var,22,45,1,1); } } // **************************** // *** Identscreen BMW Fast *** // **************************** SCREEN s_ident() { string text_var; int ganz_zahl; string job_status="???"; // für Job_Statuskontrolle bool fehlerflag; // Fehlerflag int errorcode; // EDIABAS Fehlernummer string errorcode_text; // EDIABAS Fehlernummer string error_text; // EDIABAS Fehlertext ftextout("Identifikation",1,0,1,0); ftextout("",3,0,0,1); LINE("Identifikation","") { INPAapiJob(sgbd,"IDENT","",""); INPAapiCheckJobStatus("OKAY"); ftextout("BMW Teilenummer",1,0,0,0); ftextout(":",1,43,0,0); INPAapiResultText(text_var,"ID_BMW_NR",1,""); ftextout(text_var,1,45,0,1); ftextout("Codier-Index",3,0,0,0); ftextout(":",3,43,0,0); INPAapiResultText(text_var,"ID_COD_INDEX",1,""); ftextout(text_var,3,45,0,1); ftextout("Varianten-Index",5,0,0,0); ftextout(":",5,43,0,0); INPAapiResultText(text_var,"ID_VAR_INDEX",1,""); ftextout(text_var,5,45,0,1); ftextout("Diagnose-Index",7,0,0,0); ftextout(":",7,43,0,0); INPAapiResultText(text_var,"ID_DIAG_INDEX",1,""); ftextout(text_var,7,45,0,1); ftextout("Hardwarenummer",9,0,0,0); ftextout(":",9,43,0,0); INPAapiResultText(text_var,"ID_HW_NR",1,""); ftextout(text_var,9,45,0,1); ftextout("Softwarenummer Funktionssoftware",11,0,0,0); ftextout(":",11,43,0,0); INPAapiResultText(text_var,"ID_SW_NR_FSV",1,""); ftextout(text_var,11,45,0,1); ftextout("Softwarenummer Betriebssystem",13,0,0,0); ftextout(":",13,43,0,0); INPAapiResultText(text_var,"ID_SW_NR_OSV",1,""); ftextout(text_var,13,45,0,1); ftextout("Softwarenummer Nachrichtenkatalog",15,0,0,0); ftextout(":",15,43,0,0); INPAapiResultText(text_var,"ID_SW_NR_MCV",1,""); ftextout(text_var,15,45,0,1); ftextout("Softwarenummer (Reserve) Zur Zeit nicht benutzt",17,0,0,0); ftextout(":",17,43,0,0); INPAapiResultText(text_var,"ID_SW_NR_RES",1,""); ftextout(text_var,17,45,0,1); ftextout("Herstelldatum",19,0,0,0); ftextout(":",19,43,0,0); INPAapiResultText(text_var,"ID_DATUM",1,""); ftextout(text_var,19,45,0,1); ftextout("Lieferant",21,0,0,0); ftextout(":",21,43,0,0); INPAapiResultText(text_var,"ID_LIEF_TEXT",1,""); ftextout(text_var,21,45,0,1); } // *** AIF, Anwender-Information // *** auf 2. Seite von IDENT LINE("Anwender-Information","") { INPAapiJob(sgbd,"AIF_LESEN","",""); INP1apiResultText(fehlerflag,job_status,"JOB_STATUS",1,""); INP1apiErrorCode(errorcode); ftextout("",10,0,0,0); if ((fehlerflag == FALSE) && (errorcode == 98))//98=SYS-0008: Job nicht gefunden { ftextout("Kein Anwenderinfofeld (AIF_LESEN) vorhanden" ,3,0,0,0); } else if (((fehlerflag == FALSE) && (errorcode != 98)) || (job_status != "OKAY")) { ftextout("Fehler beim Lesen von Job: AIF_LESEN",1,0,0,0); if (errorcode != 0) { inttostring(errorcode, errorcode_text); INP1apiErrorText(error_text); error_text= "Ediabas-Fehlermeldung Nr.: "+errorcode_text+": "+ error_text; } else { error_text= "Job-Status-Fehlermeldung: "+job_status; } ftextout(error_text ,2,0,0,0); ftextout("" ,3,0,0,0); INPAapiCheckJobStatus("OKAY");//um Fehler auszugeben } else { INPAapiResultInt(ganz_zahl,"AIF_ANZ_DATEN",1); if (ganz_zahl > 18) // lange AIF ausgeben { ftextout("Fahrgestell Nr.",1,0,0,0); ftextout(":",1,43,0,0); INPAapiResultText(text_var,"AIF_FG_NR",1,""); ftextout(text_var,1,45,0,1); ftextout("Zusammenbau Nr.",3,0,0,0); ftextout(":",3,43,0,0); INPAapiResultText(text_var,"AIF_ZB_NR",1,""); ftextout(text_var,3,45,0,1); ftextout("Programmier-Datum",5,0,0,0); ftextout(":",5,43,0,0); INPAapiResultText(text_var,"AIF_DATUM",1,""); ftextout(text_var,5,45,0,1); ftextout("Datensatz Nr.",7,0,0,0); ftextout(":",7,43,0,0); INPAapiResultText(text_var,"AIF_SW_NR",1,""); ftextout(text_var,7,45,0,1); ftextout("Behörden Nr.",9,0,0,0); ftextout(":",9,43,0,0); INPAapiResultText(text_var,"AIF_BEHOERDEN_NR",1,""); ftextout(text_var,9,45,0,1); ftextout("Händler Nr.",11,0,0,0); ftextout(":",11,43,0,0); INPAapiResultText(text_var,"AIF_HAENDLER_NR",1,""); ftextout(text_var,11,45,0,1); ftextout("Tester Nr.",13,0,0,0); ftextout(":",13,43,0,0); INPAapiResultText(text_var,"AIF_SERIEN_NR",1,""); ftextout(text_var,13,45,0,1); ftextout("km-Stand",15,0,0,0); ftextout(":",15,43,0,0); INPAapiResultText(text_var,"AIF_KM",1,""); ftextout(text_var,15,45,0,1); ftextout("Programm-Stand",17,0,0,0); ftextout(":",17,43,0,0); INPAapiResultText(text_var,"AIF_PROG_NR",1,""); ftextout(text_var,17,45,0,1); ftextout("Adresse AIF",19,0,0,0); ftextout(":",19,43,0,0); INPAapiResultInt(ganz_zahl,"AIF_ADRESSE_LOW",1); inttohexstring(ganz_zahl,4,text_var); ftextout(text_var,19,45,0,1); ftextout("Anzahl freie AIF",21,0,0,0); ftextout(":",21,43,0,0); INPAapiResultText(text_var,"AIF_ANZ_FREI",1,""); ftextout(text_var,21,45,0,1); ftextout("Anzahl Daten AIF",23,0,0,0); ftextout(":",23,43,0,0); INPAapiResultText(text_var,"AIF_ANZ_DATEN",1,""); ftextout(text_var,23,45,0,1); } else //18 Byte -> kurze AIF ausgeben { ftextout("Fahrgestell Nr.",1,0,0,0); ftextout(":",1,43,0,0); INPAapiResultText(text_var,"AIF_FG_NR",1,""); ftextout(text_var,1,45,0,1); ftextout("Zusammenbau Nr.",3,0,0,0); ftextout(":",3,43,0,0); INPAapiResultText(text_var,"AIF_ZB_NR",1,""); ftextout(text_var,3,45,0,1); ftextout("Programmier-Datum",5,0,0,0); ftextout(":",5,43,0,0); INPAapiResultText(text_var,"AIF_DATUM",1,""); ftextout(text_var,5,45,0,1); ftextout("Adresse AIF",19,0,0,0); ftextout(":",19,43,0,0); INPAapiResultInt(ganz_zahl,"AIF_ADRESSE_LOW",1); inttohexstring(ganz_zahl,4,text_var); ftextout(text_var,19,45,0,1); ftextout("Anzahl freie AIF",21,0,0,0); ftextout(":",21,43,0,0); INPAapiResultText(text_var,"AIF_ANZ_FREI",1,""); ftextout(text_var,21,45,0,1); ftextout("Anzahl Daten AIF",23,0,0,0); ftextout(":",23,43,0,0); INPAapiResultText(text_var,"AIF_ANZ_DATEN",1,""); ftextout(text_var,23,45,0,1); } } } LINE("CFG Lesen","") { INPAapiJob(sgbd,"C_FG_LESEN","",""); INP1apiResultText(fehlerflag,job_status,"JOB_STATUS",1,""); INP1apiErrorCode(errorcode); ftextout("Codierdaten",0,0,0,1); ftextout("",10,0,0,0);// um auf einer neuen Seite darzustellen if ((fehlerflag == FALSE) && (errorcode == 98))//98=SYS-0008: Job nicht gefunden { ftextout("Kein Fahrgestellnummer lesen (CFG_LESEN) vorhanden " ,3,0,0,0); } else if (((fehlerflag == FALSE) && (errorcode != 98)) || (job_status != "OKAY")) { ftextout("Fehler beim Lesen von Job: C_FG_LESEN",1,0,0,0); if (errorcode != 0) { inttostring(errorcode, errorcode_text); INP1apiErrorText(error_text); error_text= "Ediabas-Fehlermeldung Nr.: "+errorcode_text+": "+ error_text; } else { error_text= "Job-Status-Fehlermeldung: "+job_status; } ftextout(error_text ,2,0,0,0); ftextout("" ,3,0,0,0); INPAapiCheckJobStatus("OKAY");//um Fehler auszugeben } else { ftextout("Fahrgestell Nr.",3,0,0,0); ftextout(":",3,43,0,0); INPAapiResultText(text_var,"FG_NR",1,""); ftextout(text_var,3,45,0,1); } INPAapiJob(sgbd,"C_AEI_LESEN","",""); INP1apiResultText(fehlerflag,job_status,"JOB_STATUS",1,""); INP1apiErrorCode(errorcode); if ((fehlerflag == FALSE) && (errorcode == 98))//98=SYS-0008: Job nicht gefunden { ftextout("Kein Codierdatenänderungsindex (C_AEI_LESEN) vorhanden" ,3,0,0,0); } else if (((fehlerflag == FALSE) && (errorcode != 98)) || (job_status != "OKAY")) { INPAapiCheckJobStatus("OKAY");//um Fehler auszugeben } else { ftextout("Codierdatenänderungsindex",6,0,0,0); ftextout(":",6,43,0,0); INPAapiResultText(text_var,"COD_AE_INDEX",1,""); ftextout(text_var,6,45,0,1); } } } // **************************************************************************** // *** Identinformationen werden über SVK_LESEN ermittelt *** // *** SVK: SteuergeräeVerbauKennung Soft- und Hardware für UDS (ISO 14229) *** // **************************************************************************** SCREEN s_svk_lesen() { string text_var; string text_var2; int ganz_zahl; string job_status="???"; // für Job_Statuskontrolle bool fehlerflag; // Fehlerflag int sets; // Anzahl sets int errorcode; // EDIABAS Fehlernummer string errorcode_text; // EDIABAS Fehlernummer string error_text; // EDIABAS Fehlertext als Text bool eingabeWeiter; int input_state; // Eingabestatus int input_ok=1; // Eingabe mit Nein beendet int i; int offset; int einheiten_anz; int pos; real realval; real realval2; long longval; long rest_long; long multiplik_long; ftextout("Steuergeräteverbaukennung Soft- und Hardware",1,0,1,0); ftextout("",2,0,0,1); LINE("Hersteller Information","") {//HERSTELLINFO_LESEN ist kein Pflichtjob! (Stand: 03.2006) INPAapiJob(sgbd,"HERSTELLINFO_LESEN","",""); INP1apiResultText(fehlerflag,job_status,"JOB_STATUS",1,""); INP1apiErrorCode(errorcode); if ((fehlerflag == FALSE) && (errorcode == 98))//98=SYS-0008: Job nicht gefunden { ftextout("Keine Herstellerinformationen vorhanden" ,1,0,0,0); ftextout("" ,2,0,0,0); } else if (((fehlerflag == FALSE) && (errorcode != 98)) || (job_status != "OKAY")) { ftextout("Fehler beim Lesen von Job: HERSTELLINFO_LESEN",1,0,0,0); if (errorcode != 0) { inttostring(errorcode, errorcode_text); INP1apiErrorText(error_text); error_text= "Ediabas-Fehlermeldung Nr.: "+errorcode_text+": "+ error_text; } else { error_text= "Job-Status-Fehlermeldung: "+job_status; } ftextout(error_text ,2,0,0,0); ftextout("" ,3,0,0,0); INPAapiCheckJobStatus("OKAY");//um Fehler auszugeben } else { ftextout("Herstelldatum",1,0,0,0); ftextout(":",1,41,0,0); INPAapiResultText(text_var,"ID_DATUM",1,""); ftextout(text_var,1,45,0,1); ftextout("Lieferant",2,0,0,0); ftextout(":",2,41,0,0); INPAapiResultText(text_var,"ID_LIEF_TEXT",1,""); ftextout(text_var,2,45,0,1); ftextout("--------------------------------------------------------------------------------------------------------------------------------",3,0,0,0); ftextout("",4,0,0,0); } } LINE("Ident","") { INPAapiJob(sgbd,"IDENT","",""); INP1apiResultText(fehlerflag,job_status,"JOB_STATUS",1,""); INP1apiErrorCode(errorcode); /* if ((fehlerflag == FALSE) && (errorcode == 98))//98=SYS-0008: Job nicht gefunden { ftextout("Kein Ident vorhanden" ,1,0,0,0); ftextout("" ,2,0,0,0); } else */if (((fehlerflag == FALSE) /*&& (errorcode != 98)*/) || (job_status != "OKAY")) { ftextout("Fehler beim Lesen von Job: IDENT",1,0,0,0); if (errorcode != 0) { inttostring(errorcode, errorcode_text); INP1apiErrorText(error_text); error_text= "Ediabas-Fehlermeldung Nr.: "+errorcode_text+": "+ error_text; } else { error_text= "Job-Status-Fehlermeldung: "+job_status; } ftextout(error_text ,2,0,0,0); ftextout("" ,3,0,0,0); INPAapiCheckJobStatus("OKAY");//um Fehler auszugeben } else { ftextout("Steuergeräte-Adresse",1,0,0,0); ftextout(":",1,41,0,0); INPAapiResultInt(ganz_zahl,"ID_SG_ADR",1); inttohexstring(ganz_zahl,4,text_var); //Führende Nullen ausblenden if (ganz_zahl <= 255) midstr(text_var,text_var,2,2); ftextout("0x"+text_var,1,45,0,1); ftextout("SGBD-Index",2,0,0,0); ftextout(":",2,41,0,0); INPAapiResultBinary("_RESPONSE",1); GetBinaryDataString (text_var,i); midstr(text_var,text_var,6,11); ftextout("0x"+text_var,2,45,0,1); ftextout("--------------------------------------------------------------------------------------------------------------------------------",3,0,0,0); ftextout("",4,0,0,0); } } LINE("SVK","") { INPAapiJob(sgbd,"SVK_LESEN","",""); //INPAapiCheckJobStatus("OKAY"); //nicht anwendbar, da es mehrere Sets gibt und JOB_STATUS im letzten steht. Daher Fehlerausgabe manuell umsetzen sets=0; INP1apiResultSets(fehlerflag,sets); if ((fehlerflag == FALSE) || (sets <= 1)) { ftextout("Fehler beim Lesen von Job: SVK_LESEN",1,0,0,0); INP1apiErrorCode(errorcode); if (errorcode != 0) { inttostring(errorcode, errorcode_text); INP1apiErrorText(error_text); error_text= "Ediabas-Fehlermeldung Nr.: "+errorcode_text+": "+ error_text; ftextout(error_text ,2,0,0,0); INPAapiResultSets(sets);//um Fehler auszugeben. Bsp.: IFH-0009: NO RESPONSE FROM CONTROLUNIT } else {//Nur möglich, da bei diesem Fehler der letzte Satz=1! INP1apiResultText(fehlerflag,job_status,"JOB_STATUS",sets,""); error_text= "Job-Status-Fehlermeldung: "+job_status; ftextout(error_text,2,0,0,0); INPAapiCheckJobStatus("OKAY");//um Fehler auszugeben. Bsp.: JOB_STATUS= ERROR_ECU_INCORRECT_LEN } ftextout("" ,3,0,0,0); } else { INPAapiResultText(text_var,"PROG_DATUM",sets,""); ftextout("Programm-Datum",0,0,0,0); ftextout(":",0,41,0,0); ftextout(text_var,0,45,0,1); INPAapiResultText(text_var,"PROG_KM",sets,""); if (text_var == "-1") text_var= "- - -"; ftextout("Programm-km",1,0,0,0); ftextout(":",1,41,0,0); ftextout(text_var,1,45,0,1); INPAapiResultText(text_var,"ANZAHL_EINHEITEN",sets,""); INPAapiResultInt(einheiten_anz,"ANZAHL_EINHEITEN",sets); ftextout("Anzahl Prozeßklassen",2,0,0,0); ftextout(":",2,41,0,0); ftextout(text_var,2,45,0,1); ftextout("Prozeßklasse",5,2,0,1); ftextout("SGBM Identifier ",5,43,0,1); ftextout("Version",5,62,0,1); i=1; offset=0; while(i<=einheiten_anz) { inttostring(i,text_var2); INPAapiResultText(text_var,"PROZESSKLASSE_TEXT",i,""); ftextout(text_var2+") "+text_var,6+offset,0,0,0); //SGBM Identifier ftextout(":",6+offset,41,0,0); INPAapiResultText(text_var,"SGBM_IDENTIFIER",i,""); ftextout(text_var,6+offset,45,0,1); //Version INPAapiResultText(text_var,"VERSION",i,""); ftextout(text_var,6+offset,62,0,1); i=i+1;//um nächsten Set zu laden offset=offset+1; } } } } // ************************** // *** Speicherscreen *** // ************************** SCREEN s_speicher() { ftextout("Speicher lesen",1,0,1,0); ftextout("",3,0,0,0); LINE("","") { if (speicher_lesen_lar_flag==TRUE) ftextout("< F1 > LAR lesen" , 4,5,0,1); if (speicher_lesen_flash_flag==TRUE) ftextout("< F2 > FLASH lesen" , 6,5,0,1); if (speicher_lesen_uifm_flag==TRUE) ftextout("< F3 > UIFM lesen" , 8,5,0,1); if (speicher_lesen_romi_flag==TRUE) ftextout("< F4 > ROMI lesen" ,10,5,0,1); if (speicher_lesen_ramis_flag==TRUE) ftextout("< F5 > RAMIS lesen" ,12,5,0,1); if (speicher_lesen_ramil_flag==TRUE) ftextout("< F6 > RAMIL lesen" ,14,5,0,1); if (speicher_lesen_nvram_flag==TRUE) ftextout("< F7 > NVRAM lesen" ,16,5,0,1); if (speicher_lesen_romx_flag==TRUE) ftextout(" + < F4 > ROMX lesen" ,10,45,0,1); if (speicher_lesen_ramxx_flag==TRUE) ftextout(" + < F5 > RAMXX lesen" ,12,45,0,1); ftextout("< F9 > Bildschirmdruck" ,20,5,0,1); ftextout("< F10> Zurück" ,22,5,0,1); ftextout(" + < F10> Exit" ,22,45,0,1); } } // ************************** // *** Speicherscreen *** // *** Ausgabe *** // ************************** SCREEN s_speicher_ausgabe() { string text_var; string job_state; ftextout(speicher_lesen_text,1,0,1,0); ftextout("",3,0,0,0); INPAapiJob(sgbd,"SPEICHER_LESEN",speicher_lesen_seg_adr_anz,""); INPAapiResultText(job_state,"JOB_STATUS",1,""); LINE("","") { ftextout("Startadresse",1,0,0,0); ftextout(":",1,18,0,1); ftextout(speicher_lesen_adresse,1,20,0,1); ftextout("Anzahl",3,0,0,0); ftextout(":",3,18,0,1); inttostring(speicher_lesen_anzahl,text_var); ftextout(text_var,3,20,0,1); ftextout("Daten",5,0,0,0); ftextout(":",5,18,0,1); if(job_state != "OKAY") ftextout(job_state,5,20,0,1); else { INPAapiResultBinary("DATEN",1); hexdump(speicher_lesen_adresse,speicher_lesen_anzahl,5,20); } } } // ************************** // *** Fehlerscreen *** // ************************** SCREEN s_fehler() { ftextout("Fehlerspeicher",1,0,1,0); ftextout("",3,0,0,0); LINE("","") { if (fs_lesen_flag == TRUE) { ftextout("< F1 > Fehlerspeicher lesen" , 4,5,0,1); ftextout("< F2 > Fehlerspeicher löschen" , 6,5,0,1); ftextout("< F9 > Fehlerspeicher drucken" ,20,5,0,1); if (fs_lesen_save_as_flag == TRUE) ftextout(" + < F9 > Fehlerspeicher speichern" ,20,45,0,1); } if (is_lesen_flag == TRUE) { ftextout("< F3 > Infospeicher lesen" , 8,5,0,1); if (is_loeschen_flag == TRUE) ftextout("< F4 > Infospeicher löschen" ,10,5,0,1); ftextout("< F8 > Infospeicher drucken" ,18,5,0,1); if (is_lesen_save_as_flag == TRUE) ftextout(" + < F8 > Infospeicher speichern" ,18,45,0,1); } if (hs_lesen_flag == TRUE) { ftextout("< F5 > Historienspeicher lesen" ,12,5,0,1); if (hs_loeschen_flag == TRUE) ftextout("< F6 > Historienspeicher löschen" ,14,5,0,1); ftextout("< F7 > Historienspeicher drucken" ,16,5,0,1); if (hs_lesen_save_as_flag == TRUE) ftextout(" + < F7 > Historienspeicher speichern",16,45,0,1); } ftextout("< F10> Zurück" ,22,5,0,1); ftextout(" + < F10> Exit" ,22,45,0,1); } } // -- EOF -- // end of :#include "bmw_std.src" // Inbetriebnahmeablauf // start of :#include "inb_70.src" //********************************************************************** // diese Datei wird als 'include' File in 'ARS_E65.SRC' aufgerufen // diese Datei wird als 'include' File in 'ARS_60.SRC' aufgerufen // diese Datei wird als 'include' File in 'ARS_70.SRC' aufgerufen // //* 16.02.2004 rd V1.00 Umstellung auf 32-Bit INPA //* ELDI-Funktionen entfernt //* 28.06.2005 sh V2.00 Kompletten Ablauf geaendert, wie unter CASCADE //* 04.07.2005 ss V2.10 Ablauf entsprechend Entwickler angepasst //* 07.07.2005 ss V2.11 Reset wieder eingefügt //* 19.07.2005 sh V2.12 Motorsteuergerät "MSV80" hinzu //* 01.12.2005 sh V2.13 Motorsteuergerät "D60M57A0" hinzu //* 05.12.2005 sh V2.14 Motorsteuergerät "MSD80" hinzu //* 16.12.2005 sh V2.15 Motorsteuergerät "N62_TUE2" hinzu //* 16.01.2006 sh V2.16 Motorsteuergerät "D62M57A0" hinzu //* 10.04.2006 sj V2.17 Motorsteuergerät "N73TU_R0" ergänzt //* 25.04.2006 an V2.18 Standwanken Ausgabe angepasst //* 26.04.2006 an V2.19 F10 zurück verschoben und Rücksprungmenü geändert //* 30.08.2006 sh V2.20 Neue Motorvariante hinzu, N73H_R0, 12 Zyl. Wasserstoff //* 39.09.2006 sh V2.21 Neue Motorvariante hinzu, MSD85 (N63 8-Zylinder) //* 11.05.2007 sh V2.22 Start/ Staop_Systemcheck für N73 Wasserstoffmotor hinzu //* 19.10.2007 sh V1.30 Drehzahl auf 800 U/min reduziert , wegen Problemen bei der Inbetriebnahme, Kennlinienfehler //* 23.01.2008 sh V1.31 Drehzahl wieder auf 905 U/min erhöht. Identisch mit Cascade. //********************************************************************** string fehler_inbetriebnahme = ""; string warnung_inbetriebnahme = ""; string zusatzinfo_inbetriebnahme = ""; string z1,z4; string leer_string = ""; string fehlertext_1; string fehlertext_2; string zusatzinfotext; // ***************************************************** // ******** Fuer Statistikfile ************* // ***************************************************** string FG_NR = ""; string FZG_TYP = "XX11"; string statistik_daten; string statistik_file = "C:\ars_doku.dat"; string Uhrzeit = "hh:mm:ss"; string Datum = "dd.mm.yyyy"; // ***************************************************** // Stringarrayvariablen // Zusatzinfo bei der Inbetriebnahme int handleStringArr_Zusatzinfo; // int s1,s4; int view_flag=0; int farbe,hintergrund; int state=0; int sets; int ErrorCode; int APIBUSY = 0; int APIREADY = 1; int APIBREAK = 2; int APIERROR = 3; // Stringarrayvariablen // konnte Stringarry erfolgreich angelegt werden bool b_handleStringArr_Zusatzinfo; // bool zuendung_ein_test = FALSE; bool fehlerspeicher_loeschen = FALSE; bool werte_va_lernen = FALSE; bool werte_ha_lernen = FALSE; bool werte_quer_lernen = FALSE; /* bool offset_werte_va = FALSE; bool offset_werte_ha = FALSE; bool offset_werte_quer = FALSE; */ bool status_leerlauf = FALSE; bool motordrehzahl_vorgeben = FALSE; bool status_erhoehte_drehzahl = FALSE; bool start_inbetriebnahme_okay = FALSE; bool inbetriebnahme= FALSE; bool status_motor_aus = FALSE; //DGF 16Jan2001 bool sg_reset = FALSE; // DGF 03Apr2001 bool ehc_bandmodus = FALSE; // wenn Fahrzeug mit EHC, dann Bandmodus setzen bool keine_luftfederung = FALSE; bool werte_va_schreiben = FALSE; // Werte schreiben VA bool werte_ha_schreiben = FALSE; // Werte schreiben HA bool werte_quer_schreiben = FALSE; // Werte schreiben Querbeschleunigungssensor bool ARS_TEST_OK = FALSE; bool WEITER = FALSE; // // externe Deklaration von Funktionen // meldung_1(in: string text) { text = text+" "; // Platzhalter fuer Text ftextout(text,7,5,1,1); // Ausgabe Text Ablaufschritte } meldung_2(in: string text) { text = text+" "; // Platzhalter fuer Text ftextout(text,10,5,1,1); // Ausgabe Text Ablaufschritte } meldung_3(in: string text) { text = text+" "; // Platzhalter fuer Text ftextout(text,13,5,1,1); // Ausgabe Text Ablaufschritte } meldung_4(in: string text) { text = text+" sec. "; // Platzhalter fuer Text ftextout(text,26,20,1,1); // Ausgabe Laufzeit dynamische Pruefung } //start DGF 16 Jan 2001 meldung_5(in: string text) { text = text+" "; // Platzhalter fuer Text ftextout(text,16,5,1,1); // Ausgabe Laufzeit dynamische Pruefung } meldung_6(in: string text) { text = text+" "; // Platzhalter fuer Text ftextout(text,19,5,1,1); // Ausgabe Laufzeit dynamische Pruefung } // ende DGF 16jan2001 meldung_7(in: string text) { text = text+" "; // Platzhalter fuer Text ftextout(text,22,5,1,1); // Ausgabe Laufzeit dynamische Pruefung } print_line(in: string text, in: int zeile, in: int spalte) { if (zeile == 1) { z1 = text; s1 = spalte; } if (zeile == 4) { z4 = text; s4 = spalte; } } delete_line(in: int zeile) { if (zeile == 1) { z1 = leer_string; } if (zeile == 4) { z4 = leer_string; } } action_box_open(in: string text1, in: string text2, in: string text3) { userboxopen(1,8,0,14,89,"Arbeitshinweis", ""); userboxftextout(1,text1,1,3,2,2); userboxftextout(1,text2,4,3,2,2); userboxftextout(1,text3,7,3,2,2); } action_box_meldung(in: string text1, in: string text2) { userboxopen(1,8,0,14,89,"Meldung", ""); userboxsetcolor(1,0,9); userboxftextout(1,text1,1,18,2,0); userboxftextout(1,text2,4,18,2,0); } // // Fehler Warnungen action_box_meldung_inbetriebnahme(in: string text1, in: string text2 ) { int i = 0; int j = 0; int count; // string zusatzinfo_text = ""; string zusatzinfo_text_action_box = ""; StrArrayGetElementCount( handleStringArr_Zusatzinfo, count ); userboxopen( 1, 4, 0, 30, 89, "Inbetriebnahme Meldungen", "" ); userboxsetcolor( 1, 0, 9 ); userboxftextout( 1, "Fehler:", 1, 1, 1, 0 ); userboxftextout( 1, text1, 3, 1, 1, 0 ); userboxftextout( 1, "Warnung:", 8, 1, 1, 0 ); userboxftextout( 1, text2, 10, 1, 1, 0 ); userboxftextout( 1, "Inbetriebnahme Zusatzinformation:", 15, 1, 1, 0 ); while( i < count ) { StrArrayRead( handleStringArr_Zusatzinfo, i, zusatzinfo_text_action_box ); userboxftextout( 1, zusatzinfo_text_action_box, j + 16 , 1, 1, 0 ); zusatzinfo_text_action_box = ""; i = i + 1; j = j + 2; } } message_box_open(in: string meldetext1,in: string meldetext2,in: string meldetext3) { userboxopen(2,8,0,14,89,"Meldung", ""); userboxsetcolor(2,1,12); userboxftextout(2,meldetext1,1,3,2,1); userboxftextout(2,meldetext2,4,3,2,1); userboxftextout(2,meldetext3,7,3,2,1); } message_box_iO() { farbe=10; // hellgruen userboxopen(2,17,0,7,89,"Meldung", ""); userboxsetcolor(2,1,farbe); userboxftextout(2,"i. O.",1,36,2,1); delay(300); } message_box_niO() { farbe=4; // rot start(); userboxopen(2,17,0,7,89,"Meldung", ""); userboxsetcolor(2,1,farbe); userboxftextout(2,"n. i. O.",1,36,2,1); delay(500); } action_box_close() { userboxclose(1); } message_box_close() { userboxclose(2); } delete_screen() { action_box_close(); message_box_close(); } endebehandlung() { bool rc; // return code vom Drucker real drehzahl = 0; string dh = ""; string sgbd_name = ""; string help_api_job0 = ""; string fg_nr = ""; int zustand=0; // noch nicht aktiviert, erst testen // INPAapiJob(sgbd,"C_FG_LESEN",";0",""); // INPAapiResultText(fg_nr,"FG_NR",1,""); gettime(Uhrzeit); getdate(Datum); statistik_daten = Datum+","+Uhrzeit+","+FZG_TYP+","+fg_nr+","+fehlertext_1+","+fehlertext_2+","+zusatzinfotext+","; //fileopen(statistik_file,"a"); if ( ARS_TEST_OK == TRUE ) { fehlertext_1=""; // Loeschen fehlertext_2=""; // Loeschen statistik_daten = statistik_daten+"i.O"; } else { PEMProtokollZeile (rc, ""); PEMProtokollZeile (rc, "ARS Inbetriebnahme und Prüfung"); PEMProtokollZeile (rc, ""); PEMProtokollZeile (rc, "Fehlertext :" + fehlertext_1); PEMProtokollZeile (rc, "Fehlertext :" + fehlertext_2); PEMProtokollZeile (rc, "Fehlertext :" + zusatzinfotext); PEMProtokollZeile (rc, ""); statistik_daten = statistik_daten+"n.i.O"; } //filewrite(statistik_daten); //fileclose(); delay(500); // *************************************************** // *** Motordrehzahl wieder zurücksetzen *** // *************************************************** INPAapiJob("D_MOTOR","INITIALISIERUNG","",""); INPAapiResultText(sgbd_name,"VARIANTE",0,""); // Satz 0 ist richtig! if (( sgbd_name == "ME9E65_6" ) || ( sgbd_name == "N73_R0" )) // Abfrage, ob 8 oder 12 Zylinder Benziner { //infobox(sgbd_name,"ENDE_SYSTEMCHECK_LLERH"); // kann zu Testzwecken aktiviert werden help_api_job0 = "ENDE_SYSTEMCHECK_LLERH"; // Jobname für 8 Zylinder oder 12 Zylinder Benziner als Variable } else { if (( sgbd_name == "MS450DS0" ) || ( sgbd_name == "ME9N62" ) || ( sgbd_name == "MSV70" ) || // 6 Zylinder, 8 Zylinder u. 6 Zyl. N52 VVT (NG6) ( sgbd_name == "ME9N62_2" ) || ( sgbd_name == "N62_TUE" ) || ( sgbd_name == "MSV80" ) || // Benziner ( sgbd_name == "MSD80" ) || ( sgbd_name == "N62_TUE2" )|| ( sgbd_name == "N73TU_R0" ) || ( sgbd_name == "MSD85" ) || ( sgbd_name == "N73H_R0" )) { //infobox(sgbd_name,"STOP_SYSTEMCHECK_LLERH"); // kann zu Testzwecken aktiviert werden help_api_job0 = "STOP_SYSTEMCHECK_LLERH"; // Jobname für 6 und 8 Zylinder Benziner als Variable } else { if (( sgbd_name == "D50M57A0" ) || ( sgbd_name == "D50M57C0" ) || ( sgbd_name == "D50M57D0" ) || // 6 oder 8 Zylinder Diesel und Euro 4 ( sgbd_name == "D51MM670" ) || ( sgbd_name == "D62M57B0" ) || ( sgbd_name == "D50M57E0" ) || // E65 und E60 ( sgbd_name == "D63MM670" ) || ( sgbd_name == "D60M57D0" ) || ( sgbd_name == "D60M57A0" ) || ( sgbd_name == "D62M57A0" )) { //infobox(sgbd_name,"ABGLEICH_VERSTELLEN"); // kann zu Testzwecken aktiviert werden help_api_job0 = "ABGLEICH_VERSTELLEN"; // Jobname für Diesel als Variable drehzahl = 0; // Leerlaufdrehzahl 660 U/min, Differenz 0 vorgeben realtostring ( drehzahl, "3.0", dh ); dh = "LLA"+";"+dh; // es müssen 2 Argumente übergeben werden, LLA;0 } } } //infobox(sgbd_name,help_api_job0); // kann zu Testzwecken aktiviert werden job_state = ""; INPAapiJob( sgbd_name, help_api_job0, dh, "" ); INPAapiResultText(job_state,"JOB_STATUS",1,""); message_box_close(); if (job_state == "OKAY") { message_box_open("Motordrehzahl zurücksetzen i.O.","",""); } else // *********** Jobstatus nicht OKAY ************* { message_box_open("Motordrehzahl zurücksetzen n.i.O.",help_api_job0,job_state); } } // // ********************************************************** // *** S c r e e n a u f b a u *** // *** Darstellung und Aktualisierung des Bildschirms *** // ********************************************************** SCREEN s_inbetriebnahme() { ftextout( "ARS Inbetriebnahme und Pruefung", 2, 5, 2, 5 ); delay ( 500 ); } // ************************** // *** Pruefscreen *** // ************************** SCREEN s_pruefung() { ftextout("ARS Dynamische Funktionspruefung",2,5,2,5); setcolor(1, 8); // gelb mit schwarzer Schrift } // **************************************************** // *** M e n ü a u f b a u *** // **************************************************** // *********************************** // *** ueber Menuepkt ANSTEUERN F6 *** // *********************************** // wird ueber F1 aktiviert in ARS_E65.SRC // MENU m_inbetriebnahme() { INIT { setmenutitle( "Auswahlmenue Funktion"); } ITEM( 1, "Info" ) { infobox("Information","Programm zur Inbetriebnahme des ARS-Systems"); } ITEM( 2, "Start" ) { setstatemachine( ARS_INBETRIEBNAHME ); } ITEM( 3, "Stop" ) { setstatemachine( F10_ABBRUCH ); } ITEM( 9, "Zurück" ) { delete_screen(); setcolor(1,0); setmenu (m_main); setscreen(s_steuern,TRUE); setmenu( m_steuern ); } ITEM( 20, "Ende" ) { exit(); } } // **************************************************** // **************************************************** // **************************************************** STATEMACHINE F10_ABBRUCH() { INIT { delete_screen(); setcolor(1,4); message_box_open("Abbruch ARS Inbetriebnahme","",""); // delay (2000); ARS_TEST_OK = FALSE; fehlertext_1 = "Abbruchtaste F10 gedrueckt"; endebehandlung(); } } // ************************************************************************ // *** S t a r t S t a t e m a c h i n e A b l a u f G E S A M T *** // *** Statemachine 1. Ebene *** // ************************************************************************* // // Aufruf in MENU 'm_inbetriebnahme' // STATEMACHINE ARS_INBETRIEBNAHME() { INIT { setstate ( ZUENDUNG ); } // Schritt 1 - Abfrage, ob Zündung Ein ZUENDUNG { // fehlerhafte Motordrehzahl verhindern meldung_1( "Zuendung Ein?" ); callstatemachine( STATUS_KL15 ); if ( zuendung_ein_test == TRUE ) { setstate ( IST_MOTOR_AUS ); } else { setstate ( PRUEFUNG_AUSWERTUNG ); } } // Schritt 2 // definiertes Druckniveau an den Ventilen herstellen IST_MOTOR_AUS { callstatemachine( MOTOR_STATUS_AUS ); // Motor ist aus // Motordrehzahl ist korrekt // d.h. KEINE fehlerhafte Motordrehzahl if ( status_motor_aus == TRUE ) { setstate ( SG_NICHT_EINSCHLAFEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 3 // vermeidet das Einschlafen des SG's am Bus SG_NICHT_EINSCHLAFEN { meldung_1( "Zuendung Ein?" ); callstatemachine( STATUS_KL15 ); if ( zuendung_ein_test == TRUE ) { setstate ( FEHLERSPEICHER_LOESCHEN_LESEN ); } else { setstate ( PRUEFUNG_AUSWERTUNG ); } } // Schritt 3b FEHLERSPEICHER_LOESCHEN_LESEN { meldung_2( "Fehlerspeicher Loeschen" ); // DGF 16Jan2001 callstatemachine( FEHLERSPEICHER ); // Programmablauf wird um 5sec verzoegert //delay (5000); if (fehlerspeicher_loeschen == TRUE) { setstate( WERTE_VA_SCHREIBEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 4 WERTE_VA_SCHREIBEN { callstatemachine( OFFSET_WERTE_VA_SCHREIBEN ); if ( werte_va_schreiben == TRUE ) { setstate( WERTE_HA_SCHREIBEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 5 WERTE_HA_SCHREIBEN { callstatemachine( OFFSET_WERTE_HA_SCHREIBEN ); if ( werte_ha_schreiben == TRUE ) { setstate( WERTE_QUERBESCHL_SCHREIBEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 6 WERTE_QUERBESCHL_SCHREIBEN { callstatemachine( QUERBESCHLEUNIGUNG_SCHREIBEN ); if ( werte_quer_schreiben == TRUE ) { setstate( OFFSET_WERTE_VA_LERNEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } ////////////////////////////////////////////////////////////////////////////////// // Beginn Sensorwerte lernen ////////////////////////////////////////////////////////////////////////////////// // Schritt 7 OFFSET_WERTE_VA_LERNEN { meldung_3( "Offsetwerte Vorderachse lernen" ); callstatemachine( OFFSET_WERTE_VA ); if ( werte_va_lernen == TRUE ) { setstate( OFFSET_WERTE_HA_LERNEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 8 OFFSET_WERTE_HA_LERNEN { meldung_5( "Offsetwerte Hinterachse lernen" ); callstatemachine( OFFSET_WERTE_HA ); if ( werte_ha_lernen == TRUE ) { setstate( OFFSET_WERTE_QUERBESCHL_LERNEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 9 OFFSET_WERTE_QUERBESCHL_LERNEN { meldung_6( "Offsetwerte Querbeschleunigung lernen" ); callstatemachine( QUERBESCHLEUNIGUNG ); if ( werte_quer_lernen == TRUE ) { // Programmablauf wird um 2sec verzoegert //delay (2000); setstate( STEUERGERAETE_RESET ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } ////////////////////////////////////////////////////////////////////////////////// // Ende Sensorwerte lernen ////////////////////////////////////////////////////////////////////////////////// // Schritt 10 STEUERGERAETE_RESET { meldung_7( "Steuergeraete Reset erfolgt" ); callstatemachine( SG_RESET ); // DGF 03.04.2001 if ( sg_reset == TRUE ) { setstate( STATUS_ABFRAGE_MOTOR ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 11 //FEHLERSPEICHER_LOESCHEN_LESEN //{ // meldung_7( "Fehlerspeicher Loeschen" ); // DGF 16Jan2001 // callstatemachine( FEHLERSPEICHER ); // Programmablauf wird um 5sec verzoegert //delay (5000); // if (fehlerspeicher_loeschen == TRUE) // { // setstate( STATUS_ABFRAGE_MOTOR ); // } // else // { // setstate( PRUEFUNG_AUSWERTUNG ); // } //} // Schritt 12 STATUS_ABFRAGE_MOTOR { callstatemachine( MOTOR_STATUS ); if ( status_leerlauf == TRUE ) { setstate( MOTORDREHZAHL_VORGEBEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 13 MOTORDREHZAHL_VORGEBEN { callstatemachine( MOTORDREHZAHL ); if ( status_erhoehte_drehzahl == TRUE ) { setstate( PRUEFUNG_STARTEN ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 14 PRUEFUNG_STARTEN { callstatemachine( STANDWANKEN ); if ( start_inbetriebnahme_okay == TRUE ) { setstate( ABFRAGE_PRUEFABLAUF ); } else { setstate( PRUEFUNG_AUSWERTUNG ); } } // Schritt 15 ABFRAGE_PRUEFABLAUF { callstatemachine( STATUS_STANDWANKEN ); setstate( PRUEFUNG_AUSWERTUNG ); } PRUEFUNG_AUSWERTUNG { callstatemachine( AUSWERTUNG ); setstate( ENDE_PRUEFUNG ); } ENDE_PRUEFUNG { endebehandlung(); // Dokumentation und Fehlerausdruck } } // Ende Statemachine "ARS_Inbetriebnahme", 1. Ebene, Pruefablauf gesamt // ********************************************************************** // ********** Statemachines ARS_Inbetriebnahme 2. Ebene ************** // ********** Aufruf Job's und Auswertungen ************** // ********************************************************************** STATEMACHINE MOTOR_STATUS_AUS() { real motor_laeuft; // int zaehler = 0; // Ausschaltzeit 30 sec. int zaehler = 30; string zaehler_txt = ""; string fehler_drehzahl_motor_wert_z = ""; int fehler_drehzahl_motor_wert ; int zaehler_fehler_motor_drehzahl = 0; INIT { setcolor(1,8); // gelb mit schwarzer Schrift action_box_open("Motor MUSS AUS sein!","",""); setstate( STATUS_MOTORDREHZAHL_NULL ); } STATUS_MOTORDREHZAHL_NULL { job_state=""; INPAapiJob( sgbd ,"STATUS_CAN_DREHZAHL_ARS", "", "" ); INPAapiResultAnalog(motor_laeuft,"STAT_DREHZAHL_MOTOR_WERT",1); analogout ( motor_laeuft, 24, 5, 0, 1500, 500, 1000, "4" ); // Plausibilitaet der Motordrehzahl abpruefen // Ergebnis liegt nur als Zeichenkette vor if ( sgbd == "ARS_e65" ) { INPAapiResultText( fehler_drehzahl_motor_wert_z, "FEHLER_DREHZAHL_MOTOR_WERT", 1, ""); stringtoint( fehler_drehzahl_motor_wert_z, fehler_drehzahl_motor_wert ); } else { if (( sgbd == "ARS_60" ) || ( sgbd == "ARS_70" )) { INPAapiResultText( fehler_drehzahl_motor_wert_z, "STAT_FEHLER_DREHZAHL_MOTOR_WERT", 1, ""); stringtoint( fehler_drehzahl_motor_wert_z, fehler_drehzahl_motor_wert ); } } // Motordrehzahl ist korrekt // d.h. KEINE fehlerhafte Motordrehzahl if ( fehler_drehzahl_motor_wert == 0 ) { // Motor ist AUS // keine Drehzahl, Wert '0' problematisch, daher 10 U/min if ( motor_laeuft < 10 ) { status_motor_aus = TRUE; action_box_close(); //delay(1500); returnstatemachine(); } // Motoer laeuft else { if ( zaehler > 0 ) // wenn Motor nach 30 sec. nicht aus ist, dann Ende { zaehler = zaehler - 1; delay(1000); setstate( STATUS_MOTORDREHZAHL_NULL ); inttostring( zaehler, zaehler_txt ); ftextout( "verbleibende Ausschaltzeit", 26, 40, 1, 1 ); meldung_4( zaehler_txt ); } else { status_motor_aus = FALSE; fehlertext_1 = "Motor wurde nicht abgeschaltet"; action_box_close(); delay(5000); returnstatemachine(); } } } // fehlerhafte Motordrehzahl else { // Wartezeit ob das Motordrehzahlsignal noch gueltig wird // maximale Wartezeit 20 sec // 20 sec = 20 * 1000 msec if ( zaehler_fehler_motor_drehzahl < 20 ) { // 1000 msec warten // 1 sec warten delay( 1000 ); zaehler_fehler_motor_drehzahl = zaehler_fehler_motor_drehzahl + 1; // Statemachine nochmal durchlaufen setstate ( STATUS_MOTORDREHZAHL_NULL ); } // Wartezeit 20 sec ist abgelaufen else { status_motor_aus = FALSE; fehlertext_1 = "Motordrehzahlsignal war ungueltig"; action_box_close(); delay(1000); returnstatemachine(); } } } } //////////////////////////////////////////////////////////////////////////////////////////////// //******************************************************************************************* // Werte werden mit dem Job ins SG geschrieben. // Uebergabe an SGBD... SG sensorwerte als --> '631;19250' //******************************************************************************************* STATEMACHINE OFFSET_WERTE_VA_SCHREIBEN() // Schritt 1 { string sensorwerte_va = "631;19250"; // Einheit [mV;mueV/bar] INIT { // Vorderachsewerte lernen // '631' --> Sensor Nullpkt. // '19250' --> Sensor Steigung INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_VA",sensorwerte_va, "" ); INPAapiResultText(job_state, "JOB_STATUS", 1, ""); if (job_state == "OKAY") { werte_va_schreiben = TRUE; //delay(500); returnstatemachine(); } else // ***** Job Status nicht OKAY *********** { werte_va_schreiben = FALSE; fehlertext_1 = "Job Status Werte VA schreiben nicht OKAY"; fehlertext_1 = job_state; returnstatemachine(); } } } //////////////////////////////////////////////////////////////////////////////////////////////// STATEMACHINE OFFSET_WERTE_HA_SCHREIBEN() // Schritt 2 { string sensorwerte_ha = "631;19250"; // Einheit [mV;mueV/bar] INIT { // Hinterachsewerte lernen // '631' --> Sensor Nullpkt. // '19250' --> Sensor Steigung INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_HA",sensorwerte_ha, "" ); INPAapiResultText(job_state, "JOB_STATUS", 1, ""); if (job_state == "OKAY") { werte_ha_schreiben = TRUE; //delay(500); returnstatemachine(); } else // ***** Job Status nicht OKAY *********** { werte_ha_schreiben = FALSE; fehlertext_1 = "Job Status Werte HA schreiben nicht OKAY"; fehlertext_1 = job_state; returnstatemachine(); } } } //////////////////////////////////////////////////////////////////////////////////////////////// STATEMACHINE QUERBESCHLEUNIGUNG_SCHREIBEN() // Schritt 3 { string sensorwert_aquer = "2500;1750"; // Einheit [mV;mV/g] INIT { // Querbeschleunigungswerte lernen // '2500' --> Sensor Nullpkt. // '1750' --> Sensor Steigung INPAapiJob( sgbd, "START_LERNEN_NEUE_WERTE_QUERBESCH",sensorwert_aquer, "" ); INPAapiResultText(job_state, "JOB_STATUS", 1, ""); if (job_state == "OKAY") { werte_quer_schreiben = TRUE; //delay(500); returnstatemachine(); } else // ***** Job Status nicht OKAY *********** { werte_quer_schreiben = FALSE; fehlertext_1 = "Job Status Werte Querbeschl. schreiben nicht OKAY"; fehlertext_1 = job_state; returnstatemachine(); } } } //////////////////////////////////////////////////////////////////////////////////////////////// STATEMACHINE OFFSET_WERTE_VA() // Schritt 4, Sensorwerte lernen { string error_job_state = "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR"; INIT { job_state=""; INPAapiJob(sgbd, "START_OFFSET_WERTE_VA", "", "" ); INPAapiResultText(job_state,"JOB_STATUS",1,""); if (job_state == "OKAY") { werte_va_lernen = TRUE; digitalout(FALSE,13,62,"","i.O."); //delay(1000); returnstatemachine(); } else // *********** Jobstatus nicht OKAY ************* { werte_va_lernen = FALSE; if (job_state == error_job_state) { fehlertext_1 = "Job Status START_OFFSET_WERTE_VA nicht OKAY"; fehlertext_2 = "Radgeschwind.(DSC), Offsetpegel oder Sensorwerte n.i.O."; returnstatemachine(); } else { fehlertext_1 = "Job Status START_OFFSET_WERTE_VA nicht OKAY"; fehlertext_2 = job_state; returnstatemachine(); } } } } //////////////////////////////////////////////////////////////////////////////////////////////// STATEMACHINE OFFSET_WERTE_HA() // Schritt 5, Sensorwerte lernen { string error_job_state = "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR"; INIT { job_state=""; INPAapiJob( sgbd, "START_OFFSET_WERTE_HA", "", "" ); INPAapiResultText(job_state,"JOB_STATUS",1,""); if (job_state == "OKAY") { werte_ha_lernen = TRUE; digitalout(FALSE,16,62,"","i.O."); //delay(1000); returnstatemachine(); } else // *********** Jobstatus nicht OKAY ************* { werte_ha_lernen = FALSE; if (job_state == error_job_state) { fehlertext_1 = "Job Status START_OFFSET_WERTE_HA nicht OKAY"; fehlertext_2 = "Radgeschwind.(DSC), Offsetpegel oder Sensorwerte n.i.O."; returnstatemachine(); } else { fehlertext_1 = "Job Status START_OFFSET_WERTE_HA nicht OKAY"; fehlertext_2 = job_state; returnstatemachine(); } } } } //////////////////////////////////////////////////////////////////////////////////////////////// STATEMACHINE QUERBESCHLEUNIGUNG() // Schritt 6, Sensorwerte lernen { string error_job_state = "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR"; INIT { job_state=""; INPAapiJob( sgbd, "START_OFFSET_QUERBESCH", "", "" ); INPAapiResultText(job_state,"JOB_STATUS",1,""); if (job_state == "OKAY") { werte_quer_lernen = TRUE; digitalout(FALSE,19,62,"","i.O."); //delay(2000); returnstatemachine(); } else // *********** Jobstatus nicht OKAY ************* { werte_quer_lernen = FALSE; if (job_state == error_job_state) { fehlertext_1 = "Job Status START_OFFSET_QUERBESCH nicht OKAY"; fehlertext_2 = "Radgeschwind.(DSC), Offsetpegel oder Sensorwerte n.i.O."; returnstatemachine(); } else { fehlertext_1 = "Job Status START_OFFSET_QUERBESCH nicht OKAY"; fehlertext_2 = job_state; returnstatemachine(); } } } } //////////////////////////////////////////////////////////////////////////////////////////////// /// STATEMACHINE SG_RESET() { INIT { INPAapiJob( sgbd, "STEUERGERAETE_RESET", "", "" ); INPAapiResultText(job_state, "JOB_STATUS", 1, ""); if (job_state == "OKAY") { sg_reset = TRUE; digitalout(FALSE,22,62,"","i.O."); // Programmablauf wird um 3sec verzoegert delay (3000); returnstatemachine(); } else // ***** Jobstatus nicht OKAY *********** { sg_reset = FALSE; fehlertext_1 = "Steuergeraete RESET NICHT OKAY"; fehlertext_2 = job_state; returnstatemachine(); } } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// STATEMACHINE FEHLERSPEICHER() { INIT { // infobox("Fehlerspeicher","loeschen"); // kann zu Testzwecken aktiviert werden INPAapiJob(sgbd,"FS_LOESCHEN","",""); INPAapiResultText(job_state, "JOB_STATUS", 1, ""); if (job_state == "OKAY") { fehlerspeicher_loeschen = TRUE; digitalout(FALSE,10,62,"","i.O."); //delay(1500); returnstatemachine(); } else // ***** Jobstatus nicht OKAY *********** { fehlerspeicher_loeschen = FALSE; fehlertext_1 = "Fehlerspeicher loeschen NICHT OKAY"; fehlertext_2 = job_state; returnstatemachine(); } } } //////////////////////////////////////////////////////////////////////////////////////////////// STATEMACHINE MOTOR_STATUS() { real motor_laeuft; int zaehler = 120; string zaehler_txt = ""; INIT { setcolor(1,8); // gelb mit schwarzer Schrift ftextout("ARS Inbetriebnahme und Prüfung", 2,5,2,5); action_box_open("Bitte den Motor starten!","",""); setstate(STATUS_MOTORDREHZAHL); } STATUS_MOTORDREHZAHL { job_state=""; INPAapiJob(sgbd, "STATUS_CAN_DREHZAHL_ARS", "", "" ); INPAapiResultAnalog(motor_laeuft,"STAT_DREHZAHL_MOTOR_WERT",1); analogout ( motor_laeuft, 26, 40, 0, 1500, 500, 1000, "4" ); if ((motor_laeuft > 500) && (motor_laeuft < 1000)) { status_leerlauf = TRUE; action_box_close(); //delay(1500); returnstatemachine(); } else { if ( zaehler > 1 ) // wenn Motor nach 2 min. nicht laeuft, dann Ende { zaehler = zaehler - 1; inttostring( zaehler, zaehler_txt ); ftextout ( "Wartezeit : ", 26, 5, 1 ,1 ); ftextout ( "sec", 26, 27, 1 ,1 ); meldung_4 ( zaehler_txt ); delay(1000); setstate(STATUS_MOTORDREHZAHL); } else { status_leerlauf = FALSE; fehlertext_1 = "Motor laeuft nicht mit Leerlaufdrehzahl"; action_box_close(); returnstatemachine(); } } } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// STATEMACHINE MOTORDREHZAHL() { real drehzahl = 0; string dh = ""; string sgbd_name = ""; string help_api_job0 = ""; int zaehler = 0; INIT { message_box_open("Automatische Drehzahlerhöhung","","Motordrehzahl wird erhöht"); setstate(MOTORDREHZAHL_VORGEBEN); } MOTORDREHZAHL_VORGEBEN { INPAapiJob("D_MOTOR","INITIALISIERUNG","",""); INPAapiResultText(sgbd_name,"VARIANTE",0,""); // Satz 0 ist richtig! // infobox("DME Steuergeraet",sgbd_name); // kann zu Testzwecken aktiviert werden // "MSV70" für 6 Zylinder N52 (NG6 VVT) // "MS450DS0" für 6 Zylinder M54 // "ME9E65_6" für 8 Zylinder N62 // "ME9N62" für 8 Zylinder N62 neu ab 09/2003 // "ME9N62_2" für 8 Zylinder N62 ab 09/2004 E53, E6x // "N73_R0" für 12 Zylinder N73 // "N73TU_R0" für 8 Zylinder N73 // "D50M57A0" für 6 Zylinder Diesel M57 E65 // "D50M57C0" für 6 Zylinder Diesel M57 E6x // "D50M57D0" für 6 Zylinder Diesel M57 E6x Euro 4 // "D50M57E0" für 6 Zylinder Diesel M57 E6x Euro 4 // "D60M57D0" für 6 Zylinder Diesel M57 E6x Euro 4 // "D62M57B0" für 6 Zylinder Diesel M57 TUE // "D51MM670" für 8 Zylinder Diesel M67 // "D62M57A0" für 6 Zylinder Diesel M57 // "N73H_R0" für 12 Zylinder E68 Wasserstoff // ****************** 8 Zylinder und 12 Zylinder Benziner ******************* if( sgbd_name == "ME9E65_6" ) // unten eingefuegt || ( sgbd_name == "N73_R0" ) || ( sgbd_name == "N73H_R0" ) ) // N62 oder N73 und Wasserstoff { help_api_job0 = "STEUERN_LL_ERH"; // Solldrehzahl 800 U/min drehzahl = 80; // Faktor 10, max. 255 = 2550 U/min realtostring ( drehzahl, "3.0", dh ); } // ****************** 8 Zylinder Benziner N73_TU**************** if( (sgbd_name == "N73TU_R0" ) || ( sgbd_name == "N73_R0" ) || ( sgbd_name == "N73H_R0" ) ) // N73 und N73 Wasserstoff { help_api_job0 = "START_SYSTEMCHECK_LLERH"; // Leerlaufdrehzahl erhöhen drehzahl = 800; // Solldrehzahl 800 U/min realtostring ( drehzahl, "3.0", dh ); } // ****************** 8 Zylinder Benziner N62 TUE ******************* if( (sgbd_name == "ME9N62" ) || ( sgbd_name == "ME9N62_2" ) || ( sgbd_name == "N62_TUE" ) || ( sgbd_name == "N62_TUE2" ) || ( sgbd_name == "MSD85" )) { help_api_job0 = "START_SYSTEMCHECK_LLERH"; // Leerlaufdrehzahl erhöhen drehzahl = 800; // Solldrehzahl 800 U/min realtostring ( drehzahl, "3.0", dh ); } // ****************** nur 6 Zylinder Benziner M54 ******************* if( sgbd_name == "MS450DS0" ) // M54, 6 Zylinder Benziner { help_api_job0 = "START_SYSTEMCHECK_LLERH"; // Leerlaufdrehzahl erhöhen drehzahl = 850; // Solldrehzahl 850 U/min realtostring ( drehzahl, "3.0", dh ); } // ****************** nur 6 Zylinder Benziner N52 (NG6 VVT) ******************* if( ( sgbd_name == "MSV70" ) || ( sgbd_name == "MSV80" ) || ( sgbd_name == "MSD80" )) { help_api_job0 = "START_SYSTEMCHECK_LLERH"; // Leerlaufdrehzahl erhöhen drehzahl = 905; // Solldrehzahl 905 U/min // drehzahl = 800; // Drehzahl auf 800 U/min reduziert, 19.10.2007 // H. Kronbeck TD-426 wird die Motordrehzahl bei den betreffenden // Varianten während der Inbetriebnahme auf 800/min absenken, // bis eine entsprechende Korrektur der Codierdaten im Steuergerät stattgefunden hat. realtostring ( drehzahl, "3.0", dh ); } // ****************** nur 6 Zylinder Diesel M57 ******************* if( ( sgbd_name == "D50M57A0" ) || ( sgbd_name == "D50M57C0" ) || ( sgbd_name == "D50M57D0" ) || // 6 Zylinder Diesel E65, E6x ( sgbd_name == "D62M57B0" ) || ( sgbd_name == "D50M57E0" ) || ( sgbd_name == "D60M57D0" ) || // E70 ( sgbd_name == "D60M57A0" ) || ( sgbd_name == "D62M57A0" ) ) { help_api_job0 = "ABGLEICH_VERSTELLEN"; // es müssen 2 Argumente übergeben werden, LLA;150 drehzahl = 250; // Leerlaufdrehzahl 660 U/min plus 267 Umdrehungen realtostring ( drehzahl, "3.0", dh ); // Solldrehzahl 927 U/min dh = "LLA"+";"+dh; } // ****************** nur 8 Zylinder Diesel M67 ******************* if( ( sgbd_name == "D51MM670" ) || ( sgbd_name == "D63MM670" ) ) // 8 Zylinder Diesel/ 8 Zylinder Diesel 03/05 { help_api_job0 = "ABGLEICH_VERSTELLEN"; // es müssen 2 Argumente übergeben werden, LLA;150 drehzahl = 85; // Leerlaufdrehzahl 660 plus 85 Umdrehungen realtostring ( drehzahl, "3.0", dh ); // Solldrehzahl 745 U/min dh = "LLA"+";"+dh; } // **************************************************************** // *** Job aus Variablen zusammensetzen und abschicken *** // **************************************************************** job_state = ""; INPAapiJob( sgbd_name, help_api_job0, dh, "" ); INPAapiResultText(job_state,"JOB_STATUS",1,""); if (job_state == "OKAY") { message_box_close(); delay(500); setstate (MOTORDREHZAHL_ABFRAGEN); } else // *********** Jobstatus nicht OKAY ************* { status_erhoehte_drehzahl = FALSE; fehlertext_1 = "Drehzahl vorgeben"; fehlertext_2 = job_state; returnstatemachine(); } } MOTORDREHZAHL_ABFRAGEN { //INPAapiJob("ARS_E65","STATUS_CAN_DREHZAHL_ARS","",""); INPAapiJob( sgbd, "STATUS_CAN_DREHZAHL_ARS", "", "" ); INPAapiResultAnalog(drehzahl,"STAT_DREHZAHL_MOTOR_WERT",1); analogout (drehzahl, 24, 5, 500, 2000, 700, 1000, "4" ); // realtostring ( drehzahl, "4.0", dh ); // infobox("aktuelle Motordrehzahl", dh); // kann zu Testzwecken aktiviert werden if ((drehzahl > 700) && (drehzahl < 1000)) { status_erhoehte_drehzahl = TRUE; message_box_close(); returnstatemachine(); } else // *********** Motor hat Drehzahl noch nicht erreicht ************* { if (zaehler < 10) // 10 sec warten { zaehler = zaehler+1; delay (1000); setstate( MOTORDREHZAHL_ABFRAGEN); } else { status_erhoehte_drehzahl = FALSE; message_box_close(); fehlertext_1 = "Erforderlche Drehzahl nicht erreicht"; returnstatemachine(); } } } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// STATEMACHINE STANDWANKEN() { INIT { message_box_open("Achtung!","Dynamische Pruefung","Fahrzeug bewegt sich"); setstate(PRUEFUNG_STARTEN); } PRUEFUNG_STARTEN { job_state=""; INPAapiJob( sgbd, "START_INBETRIEBNAHME", "", "" ); INPAapiResultText(job_state,"JOB_STATUS",1,""); if (job_state == "OKAY") { start_inbetriebnahme_okay = TRUE; //delay(1500); returnstatemachine(); } else // *********** Jobstatus nicht OKAY ************* { start_inbetriebnahme_okay = FALSE; fehlertext_1 = "Start Inbetriebnahme"; fehlertext_2 = job_state; message_box_close(); returnstatemachine(); } } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// STATEMACHINE STATUS_STANDWANKEN() { int zustand = 0; int fehler_code = 0; int zaehler = 0; int anzahl_zusatzinfo = 0; int i = 1; int warn_code_hex = 0; int length_of_string = 0; int pos = 0; int ab = 0; int aktpos = 0; int ende_von_string = 0; string zusatzinfo_ausgabe = ""; string zaehler_txt = ""; //string fehler_inbetriebnahme = ""; //string warnung_inbetriebnahme = ""; string fehler_code_txt = ""; string warn_code_hex_text = ""; string var_result_text = "STAT_INBETRIEBNAHME_ZUSATZINFO_TEXT_"; string zusatzinfotext_x = ""; string result_zusatzinfotext_x = ""; string fehlertext_zw = ""; string result_var = ""; INIT { setstate( STATUS_INBETRIEBNAHME ); } STATUS_INBETRIEBNAHME { job_state = ""; INPAapiJob( sgbd, "STATUS_INBETRIEBNAHME_ABFRAGEN", "", "" ); INPAapiResultText( job_state, "JOB_STATUS", 1, "" ); if ( job_state == "OKAY" ) { delay( 100 ); // Verzoegerungszeit setstate ( STATUS_LESEN_BYTE_1 ); } else // *********** Jobstatus nicht OKAY ************* { inbetriebnahme = FALSE; fehlertext_1 = "Status Inbetriebnahme abfragen"; fehlertext_2 = job_state; message_box_close(); delay( 1500 ); returnstatemachine(); } } STATUS_LESEN_BYTE_1 // ****** Abfrage, ob Test noch laeuft ****** { INPAapiJob( sgbd, "STATUS_INBETRIEBNAHME_ABFRAGEN", "", "" ); // Result E65: "ZUSTAND" / E60 und E70 anderer Resultname "STAT_ZUSTAND" if (sgbd == "ARS_E65") { result_var = "ZUSTAND"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_ZUSTAND"; } INPAapiResultInt( zustand, result_var, 1 ); if ( zustand == 0 ) // 0 = Pruefung laeuft, 1 = Pruefung fertig { if ( zaehler < 60 ) // max. Zeit vorgeben, dann Abbruch (1 min) { zaehler = zaehler + 1; inttostring( zaehler, zaehler_txt ); ftextout("Pruefzeit",26,40,1,1); meldung_4(zaehler_txt); delay(1000); // 1 sec warten, dann wieder lesen setstate(STATUS_LESEN_BYTE_1); // Inbetriebnahme ist fertig, Ergebnisse abfragen } else { inbetriebnahme = FALSE; fehlertext_1 = "Zeitueberschreitung Dynamische Pruefung"; message_box_close(); returnstatemachine(); } } else { INPAapiJob( sgbd, "STATUS_INBETRIEBNAHME_ABFRAGEN", "", "" ); // E65 "FA_CODE_WERT" / E60 und E70 anderer Resultname "STAT_FA_CODE_WERT" if ( sgbd == "ARS_E65" ) { result_var = "FA_CODE_WERT"; } else if (( sgbd == "ARS_60" ) || ( sgbd == "ARS_70" )) { result_var = "STAT_FA_CODE_WERT"; } INPAapiResultInt(fehler_code,result_var,1); // Fehlercode auslesen result_var = ""; if ( sgbd == "ARS_E65" ) { result_var = "WA_CODE_HEX"; } else if (( sgbd == "ARS_60" ) || ( sgbd == "ARS_70" )) { result_var = "STAT_WA_CODE_HEX"; } INPAapiResultText( warn_code_hex_text, result_var, 1, "" ); stringtoint( warn_code_hex_text, warn_code_hex ); // 0 = Pruefung i.O., 1 = Pruefung n.i.O. // if ( fehler_code == 0 ) // siehe SGBD daten[2] mit Filter verUNDen // alte Konvention bis VS1 FSV 6.3.0 // // daten[2] daten[3] // 2 Byte ---> xxxx xxxZ WWEEEEEE // alte i.o Version 'zustand = 1' // neue Konvention ab VS2 FSV 6.5.0 // daten[2] daten[3] // 2 Byte ---> Zxxx PxUO WWEE EEEE // neue i.o Version 'zustand = 128' // if ( ( fehler_code == 0 ) && (( zustand == 1 ) || ( zustand == 128 )) ) // if ( ( fehler_code == 0 ) && ( ( zustand == 1 ) || (( zustand >= 128 ) && ( zustand <= 139 )) ) ) { inttostring ( fehler_code , fehler_code_txt ); //infobox ( "Inbetriebnahme IO", fehler_code_txt ); // keine Warnungen nur Zusatzinfos vorhanden // keine Anzeige auf der Oberflaeche, die Zusatzinfo wird in die Datei // 'ARS_E65.DAT' eingetragen if ( warn_code_hex == 0 && zustand > 128 ) { if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_FEHLER_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_FEHLER_TEXT"; } INPAapiResultText( fehler_inbetriebnahme, result_var , 1, ""); fehlertext_1 = fehler_inbetriebnahme; if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_WARNUNG_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_WARNUNG_TEXT"; } INPAapiResultText( warnung_inbetriebnahme, result_var, 1, "" ); fehlertext_2 = warnung_inbetriebnahme; if (sgbd == "ARS_E65") { result_var = "ANZ_ZUSATZINFOS"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_ANZ_ZUSATZINFOS"; } INPAapiResultInt( anzahl_zusatzinfo, result_var, 1 ); zusatzinfotext = ""; // bool Varible out , int Variable out // erzeugen erfolgreich , HANDLE auf Array StrArrayCreate( b_handleStringArr_Zusatzinfo, handleStringArr_Zusatzinfo ); // Speicherplatz erfolgreich reserviert ? if ( b_handleStringArr_Zusatzinfo == FALSE ) exit(); // Zusatzinformation als string abholen INPAapiResultText( zusatzinfo_inbetriebnahme, "STAT_INBETRIEBNAHME_ZUSATZINFO_TEXT" , 1, "" ); // Länge des Zusatztextes strlen(length_of_string, zusatzinfo_inbetriebnahme); // Lesen der ersten Zusatzinfo instr(pos, ab, zusatzinfo_inbetriebnahme, "Zusatzinfo:"); aktpos = pos; ab = pos + 1; // Lesen weiterer Zusatzinfos while (ende_von_string < length_of_string) { instr(pos, ab, zusatzinfo_inbetriebnahme, "Zusatzinfo:"); // Text Zusatzinfo gefunden und zeilenweise ausgeben if ( pos != -1) { ab = pos + 1; ende_von_string = pos-2; midstr(zusatzinfo_ausgabe, zusatzinfo_inbetriebnahme, aktpos, ende_von_string); StrArrayWrite( handleStringArr_Zusatzinfo, i, zusatzinfo_ausgabe); aktpos = pos; } // Text Zusatzinfo nicht gefunden bzw. nicht mehr gefunden, letzten Kommentar ausgeben else { midstr(zusatzinfo_ausgabe, zusatzinfo_inbetriebnahme, aktpos , length_of_string); StrArrayWrite( handleStringArr_Zusatzinfo, i+1, zusatzinfo_ausgabe); ende_von_string = length_of_string; } } // 10 sec Anzeige auf dem Schirm callstatemachine ( WARNUNG_FEHLER_DARSTELLUNG ); // StringArray wird geloescht StrArrayDestroy ( handleStringArr_Zusatzinfo ); } // nur in diesen beiden Faellen soll eine Anzeige auf dem // Bildschirm erfolgen. // // vorhandene Warnungen werden angezeigt ( z.B. Luft im VA System ) // es sind KEINE Zusatzinfos vorhanden d.h. 'zustand = 128' else if ( warn_code_hex != 0 && zustand == 128 ) { // bool Varible out , int Variable out // erzeugen erfolgreich , HANDLE auf Array StrArrayCreate( b_handleStringArr_Zusatzinfo, handleStringArr_Zusatzinfo ); // Speicherplatz erfolgreich reserviert ? if ( b_handleStringArr_Zusatzinfo == FALSE ) exit(); if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_FEHLER_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_FEHLER_TEXT"; } INPAapiResultText( fehler_inbetriebnahme, result_var , 1, ""); fehlertext_1 = fehler_inbetriebnahme; if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_WARNUNG_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_WARNUNG_TEXT"; } INPAapiResultText( warnung_inbetriebnahme, result_var, 1, "" ); fehlertext_2 = warnung_inbetriebnahme; // Ausgabe keine Zusatzinfo vorhanden StrArrayWrite( handleStringArr_Zusatzinfo, 1, "keine Zusatzinfo bei Inbetriebnahme"); // 10 sec Anzeige auf dem Schirm callstatemachine ( WARNUNG_FEHLER_DARSTELLUNG ); // StringArray wird geloescht StrArrayDestroy ( handleStringArr_Zusatzinfo ); } // vorhandene Warnungen werden angezeigt ( z.B. Luft im VA System ) // es werden die vorhandenen Zusatzinfos angezeigt; d.h. 'zustand > 128' else if ( warn_code_hex != 0 && zustand > 128 ) { if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_FEHLER_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_FEHLER_TEXT"; } INPAapiResultText( fehler_inbetriebnahme, result_var , 1, ""); fehlertext_1 = fehler_inbetriebnahme; if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_WARNUNG_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_WARNUNG_TEXT"; } INPAapiResultText( warnung_inbetriebnahme, result_var, 1, "" ); fehlertext_2 = warnung_inbetriebnahme; if (sgbd == "ARS_E65") { result_var = "ANZ_ZUSATZINFOS"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_ANZ_ZUSATZINFOS"; } /* Zusatzinfoauswertung fuer Bildschirmdarstellung */ INPAapiResultInt( anzahl_zusatzinfo, result_var, 1 ); zusatzinfotext = ""; // bool Varible out , int Variable out // erzeugen erfolgreich , HANDLE auf Array StrArrayCreate( b_handleStringArr_Zusatzinfo, handleStringArr_Zusatzinfo ); // Speicherplatz erfolgreich reserviert ? if ( b_handleStringArr_Zusatzinfo == FALSE ) exit(); // Zusatzinformation als string abholen INPAapiResultText( zusatzinfo_inbetriebnahme, "STAT_INBETRIEBNAHME_ZUSATZINFO_TEXT" , 1, "" ); // Länge des Zusatztextes strlen(length_of_string, zusatzinfo_inbetriebnahme); // Lesen der ersten Zusatzinfo instr(pos, ab, zusatzinfo_inbetriebnahme, "Zusatzinfo:"); aktpos = pos; ab = pos + 1; // Lesen weiterer Zusatzinfos while (ende_von_string < length_of_string) { instr(pos, ab, zusatzinfo_inbetriebnahme, "Zusatzinfo:"); // Text Zusatzinfo gefunden und zeilenweise ausgeben if ( pos != -1) { ab = pos + 1; ende_von_string = pos-2; midstr(zusatzinfo_ausgabe, zusatzinfo_inbetriebnahme, aktpos, ende_von_string); StrArrayWrite( handleStringArr_Zusatzinfo, i, zusatzinfo_ausgabe); aktpos = pos; } // Text Zusatzinfo nicht gefunden bzw. nicht mehr gefunden, letzten Kommentar ausgeben else { midstr(zusatzinfo_ausgabe, zusatzinfo_inbetriebnahme, aktpos , length_of_string); StrArrayWrite( handleStringArr_Zusatzinfo, i+1, zusatzinfo_ausgabe); ende_von_string = length_of_string; } } // 10 sec Anzeige auf dem Schirm callstatemachine ( WARNUNG_FEHLER_DARSTELLUNG ); // StringArray wird geloescht StrArrayDestroy ( handleStringArr_Zusatzinfo ); } // fuer DEBUG Zwecke //infobox("Inb Kurzmeldung","Inbetriebnahme TRUE"); inbetriebnahme = TRUE; message_box_close(); delay(1500); returnstatemachine(); } // fehlerhafte Inbetriebnahme else { // fuer DEBUG Zwecke //infobox("Inb Kurzmeldung","Inbetriebnahme FALSE"); inbetriebnahme = FALSE; if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_FEHLER_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_FEHLER_TEXT"; } INPAapiResultText( fehler_inbetriebnahme, result_var , 1, ""); //infobox ( "Inbetriebnahmefehler", fehler_inbetriebnahme ); fehlertext_1 = fehler_inbetriebnahme; if (sgbd == "ARS_E65") { result_var = "INBETRIEBNAHME_WARNUNG_TEXT"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_INBETRIEBNAHME_WARNUNG_TEXT"; } INPAapiResultText( warnung_inbetriebnahme, result_var, 1, "" ); // infobox ( "Inbetriebnahmewarnung", warnung_inbetriebnahme ); fehlertext_2 = warnung_inbetriebnahme; // ab VS2 Software --> FSV Stand 6.5.0 // zusaetzliche Ausgabe fuer Fehlerspeicher // 'INBETRIEBNAHME_FEHLER_ERWEITERT_TEXT' if ( zustand > 1 ) { if (sgbd == "ARS_E65") { result_var = "ANZ_ZUSATZINFOS"; } else if ((sgbd == "ARS_60") || ( sgbd == "ARS_70" )) { result_var = "STAT_ANZ_ZUSATZINFOS"; } INPAapiResultInt( anzahl_zusatzinfo, result_var, 1 ); zusatzinfotext = ""; // bool Varible out , int Variable out // erzeugen erfolgreich , HANDLE auf Array StrArrayCreate( b_handleStringArr_Zusatzinfo, handleStringArr_Zusatzinfo ); // Speicherplatz erfolgreich reserviert ? if ( b_handleStringArr_Zusatzinfo == FALSE ) exit(); // Zusatzinformation als string abholen INPAapiResultText( zusatzinfo_inbetriebnahme, "STAT_INBETRIEBNAHME_ZUSATZINFO_TEXT" , 1, "" ); // Länge des Zusatztextes strlen(length_of_string, zusatzinfo_inbetriebnahme); // Lesen der ersten Zusatzinfo instr(pos, ab, zusatzinfo_inbetriebnahme, "Zusatzinfo:"); aktpos = pos; ab = pos + 1; // Lesen weiterer Zusatzinfos while (ende_von_string < length_of_string) { instr(pos, ab, zusatzinfo_inbetriebnahme, "Zusatzinfo:"); // Text Zusatzinfo gefunden und zeilenweise ausgeben if ( pos != -1) { ab = pos + 1; ende_von_string = pos-2; midstr(zusatzinfo_ausgabe, zusatzinfo_inbetriebnahme, aktpos, ende_von_string); StrArrayWrite( handleStringArr_Zusatzinfo, i, zusatzinfo_ausgabe); aktpos = pos; } // Text Zusatzinfo nicht gefunden bzw. nicht mehr gefunden, letzten Kommentar ausgeben else { midstr(zusatzinfo_ausgabe, zusatzinfo_inbetriebnahme, aktpos , length_of_string); StrArrayWrite( handleStringArr_Zusatzinfo, i+1, zusatzinfo_ausgabe); ende_von_string = length_of_string; } } //zusatzinfo_inbetriebnahme = ""; //zusatzinfo_inbetriebnahme = zusatzinfotext; //infobox ( "Zusatzinfo Inbetriebnahme", zusatzinfotext ); // 10 sec Anzeige auf dem Schirm callstatemachine ( WARNUNG_FEHLER_DARSTELLUNG ); // StringArray wird geloescht StrArrayDestroy ( handleStringArr_Zusatzinfo ); message_box_close(); returnstatemachine(); } } } } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// STATEMACHINE WARNUNG_FEHLER_DARSTELLUNG() { INIT { // setcolor( 1, 4 ); // rot mit schwarzer Schrift // action_box_open( fehler_inbetriebnahme, warnung_inbetriebnahme, "" ); action_box_meldung_inbetriebnahme ( fehler_inbetriebnahme, warnung_inbetriebnahme ); // 10 sec. Anzeige auf dem Schirm delay ( 10000 ); action_box_close(); returnstatemachine(); } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// STATEMACHINE AUSWERTUNG() // Schritt 13, Prüfablauf auswerten { INIT { if (( zuendung_ein_test == TRUE ) && ( status_motor_aus == TRUE ) && ( werte_va_schreiben == TRUE ) && ( werte_ha_schreiben == TRUE ) && ( werte_quer_schreiben == TRUE ) && ( werte_va_lernen == TRUE ) && ( werte_ha_lernen == TRUE ) && ( werte_quer_lernen == TRUE ) && ( sg_reset == TRUE ) && ( fehlerspeicher_loeschen == TRUE ) && ( status_leerlauf == TRUE ) && ( status_erhoehte_drehzahl == TRUE ) && ( start_inbetriebnahme_okay == TRUE ) && ( inbetriebnahme == TRUE )) { ARS_TEST_OK = TRUE; setcolor(1,10); // Bildschirm grün message_box_open("Ende Püfablauf","","Prüfung i.O."); delay(1500); returnstatemachine(); } else // *********** Pruefung nicht OKAY ************* { ARS_TEST_OK = FALSE; setcolor(1,4); // Bildschirm rot message_box_open("Ende Püfablauf","","Prüfung n.i.O."); delay(1500); returnstatemachine(); } } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// /// //////////////////////////////////////////////////////////////////////////////////////////////// /// // Zuendung an/aus STATEMACHINE STATUS_KL15() { bool kl_15_ein = FALSE; // Ausschaltzeit 30 sec. int zaehler = 30; string zaehler_txt = ""; INIT { // setcolor( 1, 8 ); // gelb mit schwarzer Schrift // action_box_open( "Bitte Zuendung einschalten" ,"" ,"" ); setstate( STATUS_KLEMME15_AUS ); } STATUS_KLEMME15_AUS { INPAapiJob( "UTILITY", "STATUS_ZUENDUNG", "", "" ); INPAapiResultDigital( kl_15_ein, "STAT_ZUENDUNG", 1 ); if ( kl_15_ein == TRUE ) { zuendung_ein_test = TRUE; digitalout(FALSE,7,62,"","i.O."); action_box_close(); //delay( 1500 ); returnstatemachine(); } else // ***** Zuendung ist faelschlicherweise aus *********** { setcolor( 1, 8 ); // gelb mit schwarzer Schrift action_box_open( "Bitte Zuendung einschalten" ,"" ,"" ); if ( zaehler > 0 ) // wenn Zuendung nach 30 sec. nicht ein ist, dann Ende { zaehler = zaehler - 1; delay(1000); setstate( STATUS_KLEMME15_AUS ); inttostring( zaehler, zaehler_txt ); ftextout( "verbleibende Einschaltzeit", 26, 40, 1, 1 ); meldung_4( zaehler_txt ); } else { zuendung_ein_test = FALSE; fehlertext_1 = "Zuendung ist aus"; delay( 2000 ); action_box_close(); returnstatemachine(); } } } } /// //////////////////////////////////////////////////////////////////////////////////////////////// /// // end of :#include "inb_70.src" // ***************************************************** // ******** Bildschirm-Manager-Funktionen************* // ***************************************************** ScriptInit() {} // **************************************************** // *** M e n ue a u f b a u *** // **************************************************** // ************************** // *** Statusmenue *** // ************************** // wird ueber F5 aktiviert 'Status lesen' MENU m_status() { INIT { setmenutitle("Status lesen"); } ITEM( 1 ,"SG Reset") { setscreen( s_sgreset, TRUE ); setmenu( m_sgreset ) ; } ITEM( 2 ,"erw. Ident") { toggle_1 = 1; setscreen( s_ars_ident, TRUE ); setmenu( m_ars_ident ); } ITEM( 3 ,"CAN Sig") { setscreen( s_can_signale_uebersicht, TRUE ); setmenu( m_can_signale ) ; } ITEM( 4 ,"Ventile") { setscreen( s_ventile_status, TRUE ); setmenu( m_ventile_status ) ; } ITEM( 5 ,"Sensorabgl.") { setscreen( s_sensorabgleich, TRUE ); setmenu( m_sensorabgleich_status ) ; } ITEM( 6 ,"Sensoren") { setscreen( s_stati_sensor, TRUE); setmenu( m_stati_sensor ) ; } ITEM( 7 ,"Versorgungen") { setscreen( s_versorgungen, TRUE); setmenu( m_stati_versorgungen ) ; } ITEM( 11 ,"AIF aktuell") { setscreen( s_aif_aktuell_lesen, TRUE ); setmenu( m_aif_aktuell_lesen ) ; } ITEM( 12 ,"AIF Tabelle") { setscreen( s_aif_tabelle_lesen, TRUE ); setmenu( m_aif_tabelle_lesen ) ; } ITEM( 13 ,"PAF DAF") { setscreen( s_paf_daf_indizes, TRUE ); setmenu( m_paf_daf_indizes ) ; } ITEM( 14 ,"Höhenst.abgl.") { setscreen( s_hoehenstandabgleich,TRUE); setmenu( m_hoehenstandabgleich_status ) ; } ITEM( 8 ,"Drucken") { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_main, TRUE ); setmenu( m_main ); } ITEM( 10, "Ende" ) { exit(); } } // ************************** // *** Steuernmenue *** // ************************** // wird ueber F6 aktiviert 'Ansteuern' MENU m_steuern() { INIT { setmenutitle("Steuern"); } ITEM( 1 ,"Inbetriebnahme") { // Implementierung des Screens und des Menues // siehe include File 'INB_ARS.SRC' setscreen( s_inbetriebnahme,TRUE); setmenu( m_inbetriebnahme ) ; } ITEM( 2 ,"Cockpit") { setscreen( s_cockpit, TRUE ); setmenu( m_cockpit ) ; } ITEM( 3 ,"Mehr Ventile") { sv_ein_aus = FALSE; rv_ein_aus = FALSE; ramp_mode_ein_aus = FALSE; strom_va_1 = 0; strom_ha_1 = 0; setscreen( s_mehr_ventile_steuern, TRUE ); setmenu( m_mehr_ventile_steuern ) ; } ITEM( 4 ,"Ventile bestr." ) { setscreen( s_ventile_steuern, TRUE ); setmenu( m_ventile_steuern ) ; } ITEM( 5 ,"Rampenlogik") { sv_ein_aus = FALSE; rv_ein_aus = FALSE; ramp_mode_ein_aus = FALSE; strom_va_1 = 0; strom_ha_1 = 0; setscreen( s_rampen_steuern, TRUE ); setmenu( m_rampen_steuern ) ; } ITEM( 6 ,"Sensorabgl.") { setscreen( s_sensorabgleich, TRUE ); setmenu( m_sensorabgleich_steuern ) ; } ITEM( 7 ,"Höhenst.abgl.") { setscreen( s_hoehenstandabgleich,TRUE); setmenu( m_hoehenstandabgleich_steuern ) ; } ITEM( 8 ,"Drucken") { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_main, TRUE ); setmenu( m_main ); } ITEM( 10, "Ende" ) { exit(); } } // ***************************************************** // ********************************* // *** ueber Menuepkt status F5 *** // ********************************* // ******************************* // *** Steuergeraete Reset *** // ******************************* // wird ueber F1 aktiviert MENU m_sgreset() { INIT { setmenutitle( "Steuergeraete Reset" ); } ITEM( 1, "SG reset") { sg_reset_einmal = TRUE; setscreen( s_sgreset, TRUE ); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ************************** // *** Identifikation *** // ************************** // wird ueber F2 aktiviert MENU m_ars_ident() { INIT { setmenutitle( "Identifikation Nacharbeitung" ); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** PT CAN Signale *** // ******************************* // wird ueber F3 aktiviert MENU m_can_signale() { INIT { setmenutitle( "PT CAN Signale" ); } ITEM( 1, "Allgemein" ) { allgemein = 1; geschw = 0; drehzahl = 0; beschl = 0; temperatur = 0; diverses = 0; hoehenstand = 0; setscreen( s_can_signale, TRUE ); } ITEM( 2, "Geschw." ) { allgemein = 0; geschw = 1; drehzahl = 0; beschl = 0; temperatur = 0; diverses = 0; hoehenstand = 0; setscreen( s_can_signale, TRUE ); } ITEM( 3, "Drehzahl" ) { allgemein = 0; geschw = 0; drehzahl = 1; beschl = 0; temperatur = 0; diverses = 0; hoehenstand = 0; setscreen( s_can_signale, TRUE ); } ITEM( 4, "Beschl." ) { allgemein = 0; geschw = 0; drehzahl = 0; beschl = 1; temperatur = 0; diverses = 0; hoehenstand = 0; setscreen( s_can_signale, TRUE ); } ITEM( 5, "Temp." ) { allgemein = 0; geschw = 0; drehzahl = 0; beschl = 0; temperatur = 1; diverses = 0; hoehenstand = 0; setscreen( s_can_signale, TRUE ); } ITEM( 6, "Diverses" ) { allgemein = 0; geschw = 0; drehzahl = 0; beschl = 0; temperatur = 0; diverses = 1; hoehenstand = 0; setscreen( s_can_signale, TRUE ); } ITEM( 7, "Höhenstände" ) { allgemein = 0; geschw = 0; drehzahl = 0; beschl = 0; temperatur = 0; diverses = 0; hoehenstand = 1; setscreen( s_can_signale, TRUE ); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** Ventilemenue status *** // ******************************* // wird ueber F4 aktiviert MENU m_ventile_status() { INIT { setmenutitle("Ventile"); } // Lesen ITEM( 1 ,"SV lesen") { setscreen( s_sv_ventil, TRUE); } ITEM( 2 ,"RV lesen") { setscreen( s_rv_ventil, TRUE); } ITEM( 3 ,"Prop VA lesen") { setscreen( s_va_ventil, TRUE); } ITEM( 4 ,"Prop HA lesen") { setscreen( s_ha_ventil, TRUE); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Sensorabgleichmenue 'STATUS' *** // ************************************ // wird ueber F5 aktiviert MENU m_sensorabgleich_status() { INIT { setmenutitle("Sensorabgleichwerte auslesen"); } // Lesen ITEM( 1 ,"Offsets lesen") { setscreen( s_sensorabgleich , TRUE); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Sensorabgleichmenue 'STATUS' *** // ************************************ // wird ueber Shift F4 aktiviert MENU m_hoehenstandabgleich_status() { INIT { setmenutitle("Höhenstandswerte auslesen"); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** Stati Sensoren *** // ******************************* // wird ueber F6 aktiviert MENU m_stati_sensor() { INIT { setmenutitle( "Sensoren Status" ); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** Versorgungen *** // ******************************* // wird ueber F7 aktiviert MENU m_stati_versorgungen() { INIT { setmenutitle( "Versorgungen" ); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** AIF UIF Aktuell lesen *** // ******************************* // wird ueber 'Shift F1' aktiviert MENU m_aif_aktuell_lesen() { INIT { setmenutitle( "Aktuelles AIF Info; ausgelesen ueber '1A 86'" ); } ITEM( 8, "Print" ) { printscreen(); } ITEM( 9, "zurueck" ) { userboxclose(0); viewclose(); userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** AIF UIF Detail lesen *** // ******************************* // wird ueber 'Shift F2' aktiviert MENU m_aif_tabelle_lesen() { INIT { setmenutitle( "AIF Tabelle der bereits bestehenden Eintraege" ); } ITEM( 1, "AIF 1" ) { aif_nr = 1; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 2, "AIF 2" ) { aif_nr = 2; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 3, "AIF 3" ) { aif_nr = 3; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 4, "AIF 4" ) { aif_nr = 4; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 5, "AIF 5" ) { aif_nr = 5; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 6, "AIF 6" ) { aif_nr = 6; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 7, "AIF 7" ) { aif_nr = 7; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 8, "AIF 8" ) { aif_nr = 8; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 9, "AIF 9" ) { aif_nr = 9; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 10, "AIF 10" ) { aif_nr = 10; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 11, "AIF 11" ) { aif_nr = 11; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 12, "AIF 12" ) { aif_nr = 12; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 13, "AIF 13" ) { aif_nr = 13; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 14, "AIF 14" ) { aif_nr = 14; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 15, "AIF 15" ) { aif_nr = 15; setscreen( s_aif_detail_lesen, TRUE ); setmenu( m_aif_detail_lesen ); } ITEM( 18, "Print" ) { printscreen(); } ITEM( 19, "zurueck" ) { userboxclose(0); viewclose(); userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 20, "Ende" ) { exit(); } } // ******************************* // *** AIF UIF Detail lesen *** // ******************************* MENU m_aif_detail_lesen() { INIT { if ( aif_nr != 0 ) setmenutitle( "Anwender Info Feld Detail lesen" ); else setmenutitle( "Aktuelles AIF Info" ); } ITEM( 8, "Print" ) { printscreen(); } ITEM( 9, "zurueck" ) { userboxclose(0); viewclose(); if ( aif_nr != 0 ) { // setscreen( s_aif_lesen, TRUE ); // setmenu( m_aif_lesen ); setscreen( s_aif_tabelle_lesen, TRUE ); setmenu( m_aif_tabelle_lesen ); } else { setscreen( s_status, TRUE ); setmenu( m_status ); } } ITEM( 10, "Ende" ) { exit(); } } // ******************************************** // *** PAF DAF Indizes darstellen (lesen) *** // ******************************************** // wird ueber 'Shift F3' aktiviert MENU m_paf_daf_indizes() { INIT { setmenutitle( "PAF und DAF Filenamen" ); } ITEM( 8, "Print" ) { printscreen(); } ITEM( 9, "zurueck" ) { userboxclose(0); viewclose(); setscreen( s_status, TRUE ); setmenu( m_status ); } ITEM( 10, "Ende" ) { exit(); } } // ************************** // *** Cockpit Meldungen *** // ************************** // wird ueber F2 aktiviert MENU m_cockpit() { INIT { setmenutitle( "Cockpit Meldungen" ); } ITEM( 1, "Ueb. ein" ) { toggle_1 = 1; setscreen( s_cockpit_anzeige, TRUE ); setmenu( m_cockpit ); } ITEM( 2, "Regel. ein" ) { toggle_2 = 2; setscreen( s_cockpit_anzeige, TRUE ); setmenu( m_cockpit ); } ITEM( 3, "Fail Safe" ) { toggle_3 = 3; setscreen( s_cockpit_anzeige, TRUE ); setmenu( m_cockpit ); } ITEM( 4, "Oelverlust" ) { toggle_4 = 4; setscreen( s_cockpit_anzeige, TRUE ); setmenu( m_cockpit ); } ITEM( 5, "FS temp" ) { toggle_5 = 5; setscreen( s_cockpit_anzeige, TRUE ); setmenu( m_cockpit ); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** Ventilemenue steuern *** // *** Mehrfachbestromung *** // ******************************* // wird ueber F3 aktiviert MENU m_mehr_ventile_steuern() { INIT { setmenutitle( "Simultanbestromung von SV,RV,PropVA,PropHA"); } // Sicherheitsventil ITEM( 1, "SV EIN" ) { sv_ein_aus = TRUE; setscreen( s_mehr_ventile_steuern, TRUE ); } ITEM( 2, "SV AUS" ) { sv_ein_aus = FALSE; setscreen( s_mehr_ventile_steuern, TRUE ); } // Richtungsventil ITEM( 3, "RV EIN" ) { rv_ein_aus = TRUE; setscreen( s_mehr_ventile_steuern, TRUE ); } ITEM( 4, "RV AUS" ) { rv_ein_aus = FALSE; setscreen( s_mehr_ventile_steuern, TRUE ); } // Propventil Voderachse (VA) bestromen // Eingabe von Stromwert erforderlich ITEM( 5, "PropVA EIN" ) { // fuer einmaligen Aufruf der SGBD strom_va_1 = 1; PropVA_ein_aus = TRUE; setscreen( s_mehr_ventile_steuern, TRUE ); } ITEM( 6, "PropVA AUS" ) { // fuer einmaligen Aufruf der SGBD strom_va_1 = 0; PropVA_ein_aus = FALSE; setscreen( s_mehr_ventile_steuern, TRUE ); } // Propventil Voderachse (HA) // Eingabe von Stromwert erforderlich ITEM( 7, "PropHA EIN" ) { strom_ha_1 = 1; PropHA_ein_aus = TRUE; setscreen( s_mehr_ventile_steuern, TRUE ); } ITEM( 8, "PropHA AUS" ) { strom_ha_1 = 0; PropHA_ein_aus = FALSE; setscreen( s_mehr_ventile_steuern, TRUE ); } // Shift F8 ITEM( 18, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { sv_ein_aus = FALSE; rv_ein_aus = FALSE; ramp_mode_ein_aus = FALSE; PropVA_ein_aus = FALSE; PropHA_ein_aus = FALSE; strom_va_1 = 0; strom_ha_1 = 0; userboxclose(0); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** Ventilemenue steuern *** // *** Rampenlogik *** // ******************************* // wird ueber F3 aktiviert MENU m_rampen_steuern() { int int_eingabe_tmp; int int_eingabe_tmp2; INIT { setmenutitle( "Rampenlogik fuer Ventilansteuerung"); } // Sicherheitsventil ITEM( 1, "SV EIN" ) { sv_ein_aus = TRUE; setscreen( s_rampen_steuern, TRUE ); } ITEM( 2, "SV AUS" ) { sv_ein_aus = FALSE; setscreen( s_rampen_steuern, TRUE ); } // Richtungsventil ITEM( 3, "RV EIN" ) { rv_ein_aus = TRUE; setscreen( s_rampen_steuern, TRUE ); } ITEM( 4, "RV AUS" ) { rv_ein_aus = FALSE; setscreen( s_rampen_steuern, TRUE ); } // Propventil Voderachse (VA) bestromen // Eingabe von Rampenrichtung erforderlich ITEM( 5, "PropVA EIN" ) { // fuer einmaligen Aufruf der SGBD PropVA_ein_aus = TRUE; int_eingabe_tmp = va_ramp_art; inputint( int_eingabe_tmp, "Proportionalventil VA", "Rampenrichtung (0 = Halt, 1 = Auf, 2 = Ab)", 0, 2 ); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { va_ramp_art = int_eingabe_tmp; } // Dialog schliessen userboxclose( 0 ); viewclose(); if(0 == va_ramp_zeit) { inputint( int_eingabe_tmp, "Proportionalventil VA", "Zeit ist Null, Neueingabe in 0.01 s", 0, 6000 ); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { va_ramp_zeit = int_eingabe_tmp; } userboxclose( 0 ); viewclose(); } setscreen( s_rampen_steuern, TRUE ); } ITEM( 6, "PropVA AUS" ) { // fuer einmaligen Aufruf der SGBD PropVA_ein_aus = FALSE; va_ramp_art = 0; setscreen( s_rampen_steuern, TRUE ); } // Propventil Voderachse (HA) // Eingabe von Stromwert erforderlich ITEM( 7, "PropHA EIN" ) { PropHA_ein_aus = TRUE; int_eingabe_tmp = ha_ramp_art; inputint( int_eingabe_tmp, "Proportionalventil HA", "Rampenrichtung (0 = Halt, 1 = Auf, 2 = Ab)", 0, 2 ); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { ha_ramp_art = int_eingabe_tmp; } // Dialog schliessen userboxclose( 0 ); viewclose(); if(0 == ha_ramp_zeit) { inputint( int_eingabe_tmp, "Proportionalventil HA", "Zeit ist Null, Neueingabe in 0.01 s", 0, 6000 ); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { ha_ramp_zeit = int_eingabe_tmp; } userboxclose( 0 ); viewclose(); } setscreen( s_rampen_steuern, TRUE ); } ITEM( 8, "PropHA AUS" ) { PropHA_ein_aus = FALSE; ha_ramp_art = 0; setscreen( s_rampen_steuern, TRUE ); } ITEM( 11, "Rampe EIN" ) { ramp_mode_ein_aus = TRUE; setscreen( s_rampen_steuern, TRUE ); } ITEM( 12, "Rampe AUS" ) { ramp_mode_ein_aus = FALSE; setscreen( s_rampen_steuern, TRUE ); } ITEM( 13, "Vorgabe Strom" ) { int_eingabe_tmp = va_ramp_wert; int_eingabe_tmp2 = ha_ramp_wert; if ((TRUE == ramp_mode_ein_aus)&&(0 != rampenvorgabe)) { // Vorgabenwechsen --> Warnung mit ausgeben! input2int( int_eingabe_tmp, int_eingabe_tmp2, "Rampenvorgabe Strom", "Steuerstrom in mA, Rampe wird automatisch deaktiviert!", "Proportionalventil VA", "Proportionalventil HA", 0, 3000, 0, 3000); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { // Eingabe wurde mit OK abgeschlossen, Eingabe uebernehmen rampenvorgabe = 0; warnung_erfolgt = FALSE; ramp_mode_ein_aus = FALSE; va_ramp_wert = int_eingabe_tmp; ha_ramp_wert = int_eingabe_tmp2; } } else { rampenvorgabe = 0; input2int( int_eingabe_tmp, int_eingabe_tmp2, "Rampenvorgabe Strom", "Steuerstrom in mA", "Proportionalventil VA", "Proportionalventil HA", 0, 3000, 0, 3000); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { // Eingabe wurde mit OK abgeschlossen, Eingabe uebernehmen va_ramp_wert = int_eingabe_tmp; ha_ramp_wert = int_eingabe_tmp2; warnung_erfolgt = FALSE; } } // Dialog schliessen userboxclose( 0 ); viewclose(); setscreen( s_rampen_steuern, TRUE ); } ITEM( 14, "Vorgabe Druck" ) { int_eingabe_tmp = va_ramp_wert; int_eingabe_tmp2 = ha_ramp_wert; if ((TRUE == ramp_mode_ein_aus)&&(1 != rampenvorgabe)) { // Vorgabenwechsen --> Warnung mit ausgeben! input2int( int_eingabe_tmp, int_eingabe_tmp2, "Rampenvorgabe Druck", "Steuerdruck in 0.1 bar, Rampe wird automatisch deaktiviert!", "Proportionalventil VA", "Proportionalventil HA", 0, 2500, 0, 2500); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { // Eingabe wurde mit OK abgeschlossen, Eingabe uebernehmen rampenvorgabe = 1; ramp_mode_ein_aus = FALSE; warnung_erfolgt = FALSE; va_ramp_wert = int_eingabe_tmp; ha_ramp_wert = int_eingabe_tmp2; } } else { rampenvorgabe = 1; input2int( int_eingabe_tmp, int_eingabe_tmp2, "Rampenvorgabe Druck", "Steuerdruck in 0.1 bar", "Proportionalventil VA", "Proportionalventil HA", 0, 2500, 0, 2500); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { // Eingabe wurde mit OK abgeschlossen, Eingabe uebernehmen va_ramp_wert = int_eingabe_tmp; ha_ramp_wert = int_eingabe_tmp2; warnung_erfolgt = FALSE; } } // Dialog schliessen userboxclose( 0 ); viewclose(); setscreen( s_rampen_steuern, TRUE ); } ITEM( 15, "Vorgabe TV" ) { int_eingabe_tmp = va_ramp_wert; int_eingabe_tmp2 = ha_ramp_wert; if ((TRUE == ramp_mode_ein_aus)&&(2 != rampenvorgabe)) { // Vorgabenwechsen --> Warnung mit ausgeben! input2int( int_eingabe_tmp, int_eingabe_tmp2, "Rampenvorgabe Tastverhältnis", "Tastverhältnis in 0.1 %, Rampe wird automatisch deaktiviert!", "Proportionalventil VA", "Proportionalventil HA", 0, 1000, 0, 1000); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { // Eingabe wurde mit OK abgeschlossen, Eingabe uebernehmen rampenvorgabe = 2; ramp_mode_ein_aus = FALSE; warnung_erfolgt = FALSE; va_ramp_wert = int_eingabe_tmp; ha_ramp_wert = int_eingabe_tmp2; } } else { rampenvorgabe = 2; input2int( int_eingabe_tmp, int_eingabe_tmp2, "Rampenvorgabe Tastverhältnis", "Tastverhältnis in 0.1 %", "Proportionalventil VA", "Proportionalventil HA", 0, 1000, 0, 1000); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { // Eingabe wurde mit OK abgeschlossen, Eingabe uebernehmen va_ramp_wert = int_eingabe_tmp; ha_ramp_wert = int_eingabe_tmp2; warnung_erfolgt = FALSE; } } // Dialog schliessen userboxclose( 0 ); viewclose(); setscreen( s_rampen_steuern, TRUE ); } ITEM( 16, "Rampenzeit" ) { int_eingabe_tmp = va_ramp_zeit; int_eingabe_tmp2 = ha_ramp_zeit; input2int( int_eingabe_tmp, int_eingabe_tmp2, "Vorgabe Rampenzeit", "Rampenzeit in 0.01 s", "Proportionalventil VA", "Proportionalventil HA", 0, 6000, 0, 6000); getinputstate( input_state_VA ); if ( input_state_VA == 0 ) { // Eingabe uebernehmen va_ramp_zeit = int_eingabe_tmp; ha_ramp_zeit = int_eingabe_tmp2; } // Dialog schliessen userboxclose( 0 ); viewclose(); setscreen( s_rampen_steuern, TRUE ); } // Shift F8 ITEM( 18, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { sv_ein_aus = FALSE; rv_ein_aus = FALSE; ramp_mode_ein_aus = FALSE; PropVA_ein_aus = FALSE; PropHA_ein_aus = FALSE; strom_va_1 = 0; strom_ha_1 = 0; userboxclose(0); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); } ITEM( 10, "Ende" ) { exit(); } } // ******************************* // *** Ventilemenue steuern *** // *** Einzelbestromung *** // ******************************* // wird ueber F4 aktiviert MENU m_ventile_steuern() { INIT { setmenutitle("Ventile konstant und dauerhaft bestromen"); } // Ventile ansteuern, bestromen ITEM( 4 ,"SV bestrom") { strom_sv_ventil = 0; setscreen( s_sv_schreiben, TRUE); setmenu( m_sv_ventil_schreiben ); } ITEM( 5 ,"RV bestrom") { strom_rv_ventil = 0; setscreen( s_rv_schreiben, TRUE); setmenu( m_rv_ventil_schreiben ); } ITEM( 6 ,"PropVA bestrom") { strom_va_ventil = 0; setscreen( s_va_schreiben, TRUE); setmenu( m_va_ventil_schreiben ); } ITEM( 7 ,"PropHA bestrom") { strom_ha_ventil = 0; setscreen( s_ha_schreiben, TRUE); setmenu( m_ha_ventil_schreiben ); } ITEM( 1, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Sicherheitsventil schreiben *** // ************************************ MENU m_sv_ventil_schreiben() { INIT { setmenutitle( "Sicherheitsventil bestromen" ); } // ITEM( 1 ,"Strom mF") { strom_sv_1 = 1; setscreen( s_sv1_ventil_schreiben, TRUE); } ITEM( 2 ,"Strom oF") { strom_sv_2 = 1; setscreen( s_sv2_ventil_schreiben, TRUE); } ITEM( 3 ,"Hochlauf") { strom_sv_3 = 1; setscreen( s_sv3_ventil_schreiben, TRUE); } ITEM( 4 ,"PushHold") { // Sicherheitsventil wird nur einmal aufgerufen // wird nach nochmaligem Druecken erneut ausgefuehrt // nach 2 sec. wird die Bestromung eingestellt strom_sv_4 = 1; setscreen( s_sv4_ventil_schreiben, TRUE); } ITEM( 5 ,"Dauer PH") { // Sicherheitsventil wird immer wieder zyklisch aufgerufen setscreen( s_sv_ventil_pushhold_dauer_schreiben, TRUE); setmenu( m_sv_ventil_pushhold_dauer_schreiben ); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_ventile_steuern, TRUE ); setmenu( m_ventile_steuern ); strom_sv_1 = 0; strom_sv_2 = 0; strom_sv_3 = 0; strom_sv_4 = 0; } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Sicherheitsventil schreiben *** // ************************************ MENU m_sv_ventil_pushhold_dauer_schreiben() { INIT { setmenutitle( "Sicherheitsventil wird dauerbestromt" ); } ITEM( 1, "EIN" ) { sv_ein_aus = TRUE; setscreen( s_sv_ventil_pushhold_dauer_schreiben, TRUE ); } ITEM( 2, "AUS" ) { sv_ein_aus = FALSE; setscreen( s_sv_ventil_pushhold_dauer_schreiben, TRUE ); } ITEM( 8, "Print" ) { printscreen(); } ITEM( 9, "zurueck" ) { userboxclose(0); viewclose(); setscreen( s_sv_schreiben, TRUE ); setmenu( m_sv_ventil_schreiben ); } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Richtungsventil schreiben *** // ************************************ MENU m_rv_ventil_schreiben() { INIT { setmenutitle( "Richtungsventil bestromen" ); } // ITEM( 1 ,"Strom mF") { strom_rv_1 = 1; setscreen( s_rv1_ventil_schreiben, TRUE); } ITEM( 2 ,"Strom oF") { strom_rv_2 = 1; setscreen( s_rv2_ventil_schreiben, TRUE); } ITEM( 3 ,"Hochlauf") { strom_rv_3 = 1; setscreen( s_rv3_ventil_schreiben, TRUE); } ITEM( 4 ,"PushHold") { strom_rv_4 = 1; setscreen( s_rv4_ventil_schreiben, TRUE); } ITEM( 5 ,"Dauer PH") { // Sicherheitsventil wird immer wieder zyklisch aufgerufen setscreen( s_rv_ventil_pushhold_dauer_schreiben, TRUE); setmenu( m_rv_ventil_pushhold_dauer_schreiben ); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_ventile_steuern, TRUE ); setmenu( m_ventile_steuern ); strom_rv_1 = 0; strom_rv_2 = 0; strom_rv_3 = 0; strom_rv_4 = 0; } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Sicherheitsventil schreiben *** // ************************************ MENU m_rv_ventil_pushhold_dauer_schreiben() { INIT { setmenutitle( "Richtungsventil wird dauerbestromt" ); } ITEM( 1, "EIN" ) { rv_ein_aus = TRUE; setscreen( s_rv_ventil_pushhold_dauer_schreiben, TRUE ); } ITEM( 2, "AUS" ) { rv_ein_aus = FALSE; setscreen( s_rv_ventil_pushhold_dauer_schreiben, TRUE ); } ITEM( 8, "Print" ) { printscreen(); } ITEM( 9, "zurueck" ) { userboxclose(0); viewclose(); setscreen( s_rv_schreiben, TRUE ); setmenu( m_rv_ventil_schreiben ); } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Propventil VA schreiben *** // ************************************ MENU m_va_ventil_schreiben() { INIT { setmenutitle( "Proportionalventil VA bestromen" ); } // ITEM( 1 ,"Strom mF") { strom_va_1 = 1; setscreen( s_va1_ventil_schreiben, TRUE); } ITEM( 2 ,"Strom oF") { strom_va_2 = 1; setscreen( s_va2_ventil_schreiben, TRUE); } ITEM( 3 ,"Hochlauf") { strom_va_3 = 1; setscreen( s_va3_ventil_schreiben, TRUE); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_ventile_steuern, TRUE ); setmenu( m_ventile_steuern ); strom_va_1 = 0; strom_va_2 = 0; strom_va_3 = 0; } ITEM( 10, "Ende" ) { exit(); } } // ************************************ // *** Propventil HA schreiben *** // ************************************ MENU m_ha_ventil_schreiben() { INIT { setmenutitle( "Proportionalventil HA bestromen" ); } // ITEM( 1 ,"Strom mF") { strom_ha_1 = 1; setscreen( s_ha1_ventil_schreiben, TRUE); } ITEM( 2 ,"Strom oF") { strom_ha_2 = 1; setscreen( s_ha2_ventil_schreiben, TRUE); } ITEM( 3 ,"Hochlauf") { strom_ha_3 = 1; setscreen( s_ha3_ventil_schreiben, TRUE); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_ventile_steuern, TRUE ); setmenu( m_ventile_steuern ); strom_ha_1 = 0; strom_ha_2 = 0; strom_ha_3 = 0; } ITEM( 10, "Ende" ) { exit(); } } // ************************************* // *** Sensorabgleichmenue 'STEUERN' *** // ************************************* // wird ueber F6 aktiviert MENU m_sensorabgleich_steuern() { INIT { setmenutitle("Sensorabgleichwerte festlegen"); } // Lesen ITEM( 1 ,"Offsets lesen") { setscreen( s_sensorabgleich , TRUE); } // Lernen mit Grenzwertueberwachung ITEM( 3 ,"Null mG") { toggle_1 = 0; toggle_2 = 0; toggle_3 = 0; setscreen( s_nullpkt_lernen , TRUE); setmenu( m_nullpkt_lernen ); } ITEM( 11 ,"Para HA") { para_lernen_4 = 1; setscreen( s_sensorabgleich , TRUE); } ITEM( 12 ,"Para VA") { para_lernen_5 = 1; setscreen( s_sensorabgleich , TRUE); } ITEM( 13 ,"Para AQuer") { para_lernen_6 = 1; setscreen( s_sensorabgleich , TRUE); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9, "Zurueck" ) { userboxclose(0); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); para_lernen_4 = 0; para_lernen_5 = 0; para_lernen_6 = 0; } ITEM( 10, "Ende" ) { exit(); } } // ***************************************** // *** Höhenstandabgleichmenue 'STEUERN' *** // ***************************************** // wird ueber F7 aktiviert MENU m_hoehenstandabgleich_steuern() { INIT { setmenutitle("Höhenstandslernwerte Abgleichen"); } ITEM( 1 ,"Abgl vorne li") { hs_abgleichen_1 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 2 ,"Abgl vorne re") { hs_abgleichen_2 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 3 ,"Abgl hinten li") { hs_abgleichen_3 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 4 ,"Abgl hinten re") { hs_abgleichen_4 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 11 ,"Para vorne li") { hs_abgleichen_5 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 12 ,"Para vorne re") { hs_abgleichen_6 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 13 ,"Para hinten li") { hs_abgleichen_7 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 14 ,"Para hinten re") { hs_abgleichen_8 = 1; setscreen( s_hoehenstandabgleich , TRUE); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9 ,"Zurueck") { userboxclose(0); viewclose(); setscreen( s_steuern ,TRUE); setmenu( m_steuern ); hs_abgleichen_1 = 0; hs_abgleichen_2 = 0; hs_abgleichen_3 = 0; hs_abgleichen_4 = 0; hs_abgleichen_5 = 0; hs_abgleichen_6 = 0; hs_abgleichen_7 = 0; hs_abgleichen_8 = 0; } } // **************************************** // *** Nullpunkte der Sensoren lernen *** // *** mit Grenzwertueberwachung *** // **************************************** MENU m_nullpkt_lernen() { INIT { setmenutitle("Nullpunkte der Drucksensoren lernen"); } ITEM( 1 ,"VA lernen") { toggle_1 = 1; setscreen( s_nullpkt_lernen , TRUE); } // Lernen ITEM( 2 ,"HA lernen") { toggle_2 = 1; setscreen( s_nullpkt_lernen , TRUE); } // Lernen ITEM( 3 ,"Quer lernen") { toggle_3 = 1; setscreen( s_nullpkt_lernen , TRUE); } ITEM( 8, "Drucken" ) { printscreen(); } ITEM( 9 ,"Zurueck") { userboxclose(0); viewclose(); setscreen( s_sensorabgleich ,TRUE); setmenu( m_sensorabgleich_steuern ); toggle_1 = 0; toggle_2 = 0; toggle_3 = 0; } ITEM( 10 ,"Ende") { exit(); } } // ***************************************************** // ***************************************************** // **************************************************** // *** S c r e e n a u f b a u *** // **************************************************** // ************************** // *** Statusscreen *** // ************************** // wird ueber F5 aktiviert 'STATUS' SCREEN s_status() { // Initialisierung string text_var = ""; int status_ars; real stat_alive; ftextout("Status lesen", 1, 0, 1, 0 ); ftextout("",2,0,0,0); // zeigt Alive Zaehler an INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); ftextout( "SG Status", 3, 50, 0, 0 ); ftextout( ":", 3, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 3, 60, 0, 0 ); INPAapiJob( sgbd, "IDENT", "", "" ); INPAapiCheckJobStatus( "OKAY" ); LINE("","") { ftextout( "BMW Teilenummer", 1, 0, 0, 0 ); ftextout( ":", 1, 19, 0, 0 ); INPAapiResultText( text_var, "ID_BMW_NR", 1, "" ); ftextout( text_var, 1, 20, 0, 1 ); ftextout( "Herstelldatum", 1, 43, 0, 0 ); ftextout( ":", 1, 53, 0, 0 ); ftextout( "Tag / Monat / Jahr", 1, 68, 0, 0 ); // ftextout( "/", 1, 55, 0, 1 ); INPAapiResultText( text_var, "ID_DATUM_TAG", 1, "" ); ftextout( text_var, 1, 55, 0, 1 ); INPAapiResultText(text_var,"ID_DATUM_MONAT",1,""); ftextout(text_var, 1, 58, 0, 1 ); INPAapiResultText( text_var, "ID_DATUM_JAHR", 1, "" ); ftextout( text_var, 1, 61, 0, 1 ); // linke Seite des Bildschirms ftextout( "< F1 > SG Reset" , 3, 5, 0, 1 ); ftextout( "< F2 > erweiterte Identifikation" , 5, 5, 0, 1 ); ftextout( "< F3 > CAN Signale" , 7, 5, 0, 1 ); ftextout( "< F4 > Ventile" , 9, 5, 0, 1 ); ftextout( "< F5 > Sensorabgleichwerte ( lesen )" , 11, 5 ,0 ,1 ); // ftextout( "< F6 > Sensoren" , 13, 5, 0, 1 ); ftextout( "< F7 > Versorgungen" , 15, 5, 0, 1 ); // ftextout( "< F8 > Bildschirmdruck" , 19, 5, 0, 1 ); ftextout( "< F9 > Zurueck" , 21, 5, 0, 1 ); ftextout( "< F10 > Ende" , 23, 5, 0, 1 ); // // // rechte Seite des Bildschirms ftextout( " + < F1 > AIF aktuell (1A 86)" , 3, 45, 0, 1 ); ftextout( " + < F2 > AIF Tabelle" , 5, 45, 0, 1 ); ftextout( " + < F3 > PAF DAF" , 7, 45, 0, 1 ); INPAapiCheckJobStatus( "OKAY" ); } } // ************************** // *** Steuernscreen *** // ************************** // wurde ueber F6 aktiviert 'Ansteuern' SCREEN s_steuern() { // ftextout("ARS Inbetriebnahme und Pruefung", 2,5,2,5); // Initialisierung string text_var = ""; int status_ars; real stat_alive; ftextout("Ansteuern",1,0,1,0); ftextout("",2,0,0,0); // zeigt Alive Zaehler an INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); ftextout( "SG Status", 3, 50, 0, 0 ); ftextout( ":", 3, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 3, 60, 0, 0 ); INPAapiJob( sgbd, "IDENT", "", "" ); INPAapiCheckJobStatus( "OKAY" ); LINE("","") { ftextout( "BMW Teilenummer", 1, 0, 0, 0 ); ftextout( ":", 1, 19, 0, 0 ); INPAapiResultText( text_var, "ID_BMW_NR", 1, "" ); ftextout( text_var, 1, 20, 0, 1 ); ftextout( "Herstelldatum:", 1, 43, 0, 0 ); ftextout( "Tag / Monat / Jahr", 1, 68, 0, 0 ); // ftextout( "/", 1, 55, 0, 1 ); INPAapiResultText( text_var, "ID_DATUM_TAG", 1, "" ); ftextout( text_var, 1, 55, 0, 1 ); INPAapiResultText(text_var,"ID_DATUM_MONAT",1,""); ftextout(text_var, 1, 58, 0, 1 ); INPAapiResultText( text_var, "ID_DATUM_JAHR", 1, "" ); ftextout( text_var, 1, 61, 0, 1 ); ftextout( "< F1 > Inbetriebnahmeablauf" , 3, 5, 0, 1 ); ftextout( "< F2 > Cockpit Meldungen" , 5, 5, 0, 1 ); ftextout( "< F3 > Ventile Mehrfachbestromung" , 7, 5, 0, 1 ); ftextout( "< F4 > Ventile Einzelbestromung" , 9, 5, 0, 1 ); ftextout( "< F5 > Rampenlogik fuer Ventilansteuerung" , 11, 5 ,0 ,1 ); ftextout( "< F6 > Sensorabgleichwerte ( lernen )" , 13, 5 ,0 ,1 ); ftextout( "< F7 > Höhenstandabgleichwerte ( lernen )" , 15, 5, 0, 1 ); // ftextout( "< F8 > Bildschirmdruck" , 19, 5, 0, 1 ); ftextout( "< F9 > Zurueck" , 21, 5, 0, 1 ); ftextout( "< F10 > Ende" , 23, 5, 0, 1 ); INPAapiCheckJobStatus( "OKAY" ); } } // ***************************** // *** Statusscreen Anzeigen *** // ***************************** // ****************************** // *** Steuergeraete Reset *** // ****************************** // wird ueber F1 aktiviert 'SG reset' SCREEN s_sgreset() { int status_ars; real stat_alive; string text_var = ""; ftextout( "Steuergeraete Reset durchfuehren", 1, 0, 1, 0 ); ftextout( "", 2, 0, 0 ,0 ); // zeigt Alive Zaehler an INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); ftextout( "SG Status", 3, 50, 0, 0 ); ftextout( ":", 3, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 3, 60, 0, 0 ); LINE( "","" ) { if ( sg_reset_einmal == TRUE ) { sg_reset_einmal = FALSE; INPAapiJob( sgbd, "STEUERGERAETE_RESET", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Reset war erfolgreich", 1, 0, 1, 1 ); ftextout( "", 3, 0, 0 ,0 ); delay(2000); } } } // ************************** // *** Identscreen *** // ************************** // wird ueber F2 aktiviert 'erw. Ident' SCREEN s_ars_ident() { string text_1A87 = ""; string text_1A91 = ""; string text_zus = ""; ftextout( "erweiterte Identifikations Informationen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); LINE( "","" ) { // Linke Seite auf dem Bildschirm ////////////////////////////////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "IDENT_HWNR_PHYS_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "physikalische Hardwarenummer (1A 87)", 0, 0, 0, 0 ); ftextout( ":", 0, 29, 0, 0 ); INPAapiResultText( text_1A87, "HWNR_PHYS", 1, "" ); ftextout( text_1A87, 0, 31, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Herstelldatum INPAapiJob( sgbd, "IDENT", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG-Herstelldatum (1A 9D)", 2, 0, 0, 0 ); ftextout( ":", 2, 29, 0, 0 ); INPAapiResultText( text_var, "ID_DATUM_TAG", 1, "" ); ftextout( text_var, 2, 31, 0, 0 ); ftextout( ".", 2, 33, 0, 0 ); INPAapiResultText( text_var, "ID_DATUM_MONAT", 1, "" ); ftextout( text_var, 2, 35, 0, 0 ); ftextout( ".", 2, 37, 0, 0 ); INPAapiResultText( text_var, "ID_DATUM_JAHR", 1, "" ); ftextout( text_var, 2, 39, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Hardware Referenz auslesen INPAapiJob( sgbd, "HARDWARE_REFERENZ_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "gelesene HW Ref.(22 2502)", 4, 0, 0, 0 ); ftextout( ":", 4, 29, 0, 0 ); INPAapiResultText( text_var, "HARDWARE_REFERENZ", 1, "" ); ftextout( text_var, 4, 31, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Varaintenindex, BMW Teilenummer; Hardware* Nummer INPAapiJob( sgbd, "IDENT", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Varianten-Index (1A 97)", 6, 0, 0, 0 ); ftextout( ":", 6, 29, 0, 0 ); INPAapiResultText( text_var, "ID_VAR_INDEX", 1, "" ); ftextout( text_var, 6, 31, 0, 0 ); ftextout( "BMW Teilenummer = HW*Nr (1A 91)", 8, 0, 0, 0 ); ftextout( ":", 8, 29, 0, 0 ); INPAapiResultText( text_1A91, "ID_BMW_NR", 1, "" ); ftextout( text_1A91, 8, 31, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Programm Refz. auslesen INPAapiJob( sgbd, "PROGRAMM_REFERENZ_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "gelesene Prg. Ref.(22 2503)", 10, 0, 0, 0 ); ftextout( ":", 10, 29, 0, 0 ); INPAapiResultText( text_var, "PROGRAMM_REFERENZ", 1, "" ); ftextout( text_var, 10, 31, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Versionsnummers MCV, OSV, FSV, RES INPAapiJob( sgbd, "IDENT", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "MCV (1A 9F)", 12, 0, 0, 0 ); ftextout( ":", 12, 29, 0, 0 ); INPAapiResultText( text_var, "ID_SW_NR_MCV", 1, "" ); ftextout( text_var, 12, 31, 0, 0 ); ftextout( "Nachrichtenkatalog", 12, 36, 0, 0 ); ftextout( "FSV (1A 9F)", 14, 0, 0, 0 ); ftextout( ":", 14, 29, 0, 0 ); INPAapiResultText( text_var, "ID_SW_NR_FSV", 1, "" ); ftextout( text_var, 14, 31, 0, 0 ); ftextout( "Funktionssoftware", 14, 36, 0, 0 ); ftextout( "OSV (1A 9F)", 16, 0, 0, 0 ); ftextout( ":", 16, 29, 0, 0 ); INPAapiResultText( text_var, "ID_SW_NR_OSV", 1, "" ); ftextout( text_var, 16, 31, 0, 0 ); ftextout( "Betriebssystem", 16, 36, 0, 0 ); ftextout( "RES (1A 9F)", 18, 0, 0, 0 ); ftextout( ":", 18, 29, 0, 0 ); INPAapiResultText( text_var, "ID_SW_NR_RES", 1, "" ); ftextout( text_var, 18, 31, 0, 0 ); ftextout( "SoftwareNummer", 18, 36, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Zusbaunummer INPAapiJob( sgbd, "AIF_LESEN", "0", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "ZusBauNummer (23 xx xx xx 07 40)", 20, 0, 0, 0 ); ftextout( ":", 20, 29, 0, 0 ); ftextout( "Teilergebnis des AnwenderInfoFeldes", 21, 0, 0, 0 ); INPAapiResultText( text_zus, "AIF_ZB_NR", 1, "" ); ftextout( text_zus, 20, 31, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Daten Referenz auslesen INPAapiJob( sgbd, "DATEN_REFERENZ_LESEN", "", "" ); INPAapiCheckJobStatus( "ERROR_NO_DREF" ); ftextout( "gelesene Daten Ref.(22 2504)", 23, 0, 0, 0 ); ftextout( ":", 23, 29, 0, 0 ); //INPAapiResultText( text_var, "DATEN_REFERENZ", 1, "" ); ftextout( "ERROR_NO_DREF", 23, 31, 0, 0 ); // Rechte Seite auf dem Bildschirm // // ////////////////////////////////////////////////////////////////////////////////////////////////////// // letztes Progrmmierdatum INPAapiJob( sgbd, "IDENT_PD_LESEN", "", "" ); // TT.MM.JJJJ ftextout( "letztes Prog.datum (1A 99)", 0, 53, 0, 0 ); ftextout( ":", 0, 73, 0, 0 ); INPAapiResultText( text_var, "ID_DATUM", 1, "" ); ftextout( text_var, 0, 75, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Tag an dem mit Cabi und CBD Codierdatensatz progra. wurde INPAapiJob( sgbd, "DATENSATZ_COD_DATUM", "", "" ); // TT.MM.JJ ftextout( "CBD Codierdatum vom", 2, 53, 0, 0 ); ftextout( ":", 2, 73, 0, 0 ); INPAapiResultText( text_var, "COD_DATUM_TAG", 1, "" ); ftextout( text_var, 2, 75, 0, 0 ); ftextout( ".", 2, 77, 0, 0 ); INPAapiResultText( text_var, "COD_DATUM_MONAT", 1, "" ); ftextout( text_var, 2, 78, 0, 0 ); ftextout( ".", 2, 80, 0, 0 ); INPAapiResultText( text_var, "COD_DATUM_JAHR", 1, "" ); ftextout( text_var, 2, 81, 0, 0 ); // Datensatzdatum // TT.MM.JJJJ ftextout( "Codierdatensatz vom", 4, 53, 0, 0 ); ftextout( ":", 4, 73, 0, 0 ); INPAapiResultText( text_var, "DATENSATZ_DATUM_TAG", 1, "" ); ftextout( text_var, 4, 75, 0, 0 ); ftextout( ".", 4, 77, 0, 0 ); INPAapiResultText( text_var, "DATENSATZ_DATUM_MONAT", 1, "" ); ftextout( text_var, 4, 78, 0, 0 ); ftextout( ".", 4, 80, 0, 0 ); INPAapiResultText( text_var, "DATENSATZ_DATUM_JAHR", 1, "" ); ftextout( text_var, 4, 81, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // SGBD Version INPAapiJob( sgbd, "INFO", "", "" ); ftextout( "SGBD-Version", 6, 53, 0, 0 ); ftextout( ":", 6, 73, 0, 0 ); ftextout( sgbd_revision, 6, 75, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Lieferantenindex, Codierindex, Diagnoseindex INPAapiJob( sgbd, "IDENT", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Lieferant", 8, 53, 0, 0 ); ftextout( ":", 8, 73, 0, 0 ); INPAapiResultText( text_var, "ID_LIEF_TEXT", 1, "" ); ftextout( text_var, 8, 75, 0, 0 ); ftextout( "Lieferantennummer (1A 9E)", 10, 53, 0, 0 ); ftextout( ":", 10, 73, 0, 0 ); INPAapiResultText( text_var, "ID_LIEF_NR", 1, "" ); ftextout( text_var, 10, 75, 0, 0 ); ftextout( "Codier-Index (1A 9B)", 12, 53, 0, 0 ); ftextout( ":", 12, 73, 0, 0 ); INPAapiResultText( text_var, "ID_COD_INDEX", 1, "" ); ftextout( text_var, 12, 75, 0, 0 ); ftextout( "Diagnose-Index (1A 9C)", 14, 53, 0, 0 ); ftextout( ":", 14, 73, 0, 0 ); INPAapiResultText( text_var, "ID_DIAG_INDEX", 1, "" ); ftextout( text_var, 14, 75, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Aenderungsindex auslesen INPAapiJob( sgbd, "C_AEI_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Aenderungsindex (22 3FFF)", 16, 53, 0, 0 ); ftextout( ":", 16, 73, 0, 0 ); INPAapiResultText( text_var, "COD_AE_INDEX", 1, "" ); ftextout( text_var, 16, 75, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Fahrgestellnummer lesen INPAapiJob( sgbd, "C_FG_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Fahrgestellnr. (7 stellig)", 18, 53, 0, 0 ); ftextout( ":", 18, 73, 0, 0 ); INPAapiResultText( text_var, "FG_NR", 1, "" ); ftextout( text_var, 18, 75, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Seriennummernummer lesen INPAapiJob( sgbd, "SERIENNUMMER_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Seriennr. (1A 89) (9 stellig)", 20, 53, 0, 0 ); ftextout( ":", 20, 73, 0, 0 ); INPAapiResultText( text_var, "SERIENNUMMER", 1, "" ); ftextout( text_var, 20, 75, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Hardwaremusternummer auslesen INPAapiJob( sgbd, "IDENT_VMECUHVN_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "HardwareNr.(1A 9A)", 23, 53, 0, 0 ); ftextout( ":", 23, 73, 0, 0 ); INPAapiResultText( text_var, "ID_HW_NR", 1, "" ); ftextout( text_var, 23, 75, 0, 0 ); ////////////////////////////////////////////////////////////////////////////////////////////////////// // Nummerngleichheit pruefen /* if ( ( text_1A87 != text_1A91 || text_1A87 != text_zus || text_1A91 != text_zus ) && toggle_1 == 1 ) { infobox( "Einnummernstrategie", "Nummern sind NICHT identisch; 1A87 <--> 1A91 <--> ZusBau" ); // mehrmaligen Aufruf verhindern toggle_1 = 0; }*/ } } // ********************************* // *** PT CAN Signale Uebersicht *** // ********************************* // wird ueber F3 aktiviert SCREEN s_can_signale_uebersicht() { int status_ars; real stat_alive; real zahl_var; string text_var = ""; ftextout( "PT CAN Signale", 1, 0, 1, 0 ); ftextout( "", 2, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); INPAapiResultText( text_var, "STAT_ALIVE_ZAEHLER_TEXT", 1, "" ); ftextout( text_var, 3, 50, 0, 0 ); ftextout( "SG Status", 5, 50, 0, 0 ); ftextout( ":", 5, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 5, 60, 0, 0 ); LINE( "","" ) { ftextout( "< F1 Allgemein>" ,1, 5, 0, 0 ); ftextout( "Zuendung, Anlasser, EDCK, ABS, DSC" ,1, 25, 0, 0 ); ftextout( "< F2 Geschwindigkeit>" ,3, 5, 0, 0 ); ftextout( "Fahrzeuggeschw., Radgeschw. VL, VR, HL, HR" ,3, 25, 0, 0 ); ftextout( "< F3 Drehzahl>" ,5, 5, 0, 0 ); ftextout( "Motordrehzahl, Fehler Motordrehzahl" ,5, 25, 0, 0 ); ftextout( "< F4 Beschleunigung>" ,7, 5, 0, 0 ); ftextout( "DSC Querbeschl., DSC Winkelbeschl." ,7, 25, 0, 0 ); ftextout( "< F5 Temperatur>" ,9, 5, 0, 0 ); ftextout( "Außen-,Motor-, Innentemperatur" ,9, 25, 0, 0 ); ftextout( "< F6 Diverses>" ,11, 5, 0, 0 ); ftextout( "Kilometerstand, Lenkradwinkel, Rotorposition, Codierung" ,11, 25, 0, 0 ); ftextout( "< F7 Höhenstände>" ,13, 5, 0, 0 ); ftextout( "Höhenstände" ,13, 25, 0, 0 ); } } // ************************** // *** PT CAN Signale *** // ************************** // wird ueber F3 aktiviert SCREEN s_can_signale() { int offset_vl = 0; int offset_vr = 0; int offset_hl = 0; int offset_hr = 0; int steigung_vl = 0; int steigung_vr = 0; int steigung_hl = 0; int steigung_hr = 0; int nullpunkt_vl = 0; int nullpunkt_vr = 0; int nullpunkt_hl = 0; int nullpunkt_hr = 0; int abw_vl = 0; int abw_vr = 0; int abw_hl = 0; int abw_hr = 0; real tmpr = 0; real tmpr_steig = 0; real tmpr_null = 0; string tmps = ""; string tmpn = ""; string offset_einh = "no response"; string offset_einh2 = "Einheitenfehler"; string steigung_einh = "no response"; string nullpunkt_einh = "no response"; string chk_jobstatus=""; string err_jobstatus = "none"; int status_ars; real stat_alive; real zahl_var; string text_var = ""; ftextout( "PT CAN Signale", 1, 0, 1, 0 ); ftextout( "", 2, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); INPAapiResultText( text_var, "STAT_ALIVE_ZAEHLER_TEXT", 1, "" ); ftextout( text_var, 3, 50, 0, 0 ); ftextout( "SG Status", 5, 50, 0, 0 ); ftextout( ":", 5, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 5, 60, 0, 0 ); LINE( "","" ) { if ( allgemein == 1 ) { INPAapiJob( sgbd, "STATUS_CAN_SIGNALE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Wert Zuendung", 1, 1, 0, 0 ); ftextout( ":", 1, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_KL15_NR_WERT", 1, "" ); ftextout( text_var, 1, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_KL15_TEXT", 1, "" ); ftextout( text_var, 1, 35, 0, 0 ); ftextout( "CAN Wert Anlasser", 2, 1, 0, 0 ); ftextout( ":", 2, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_KL50_NR_WERT", 1, "" ); ftextout( text_var, 2, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_KL50_TEXT", 1, "" ); ftextout( text_var, 2, 35, 0, 0 ); ftextout( "CAN Wert Status DSC", 3, 1, 0, 0 ); ftextout( ":", 3, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_DSC_WERT", 1, "" ); ftextout( text_var, 3, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_DSC_EINH", 1, "" ); ftextout( text_var, 3, 35, 0, 0 ); /* CAN Fehler Darstellung */ /* ftextout( "CAN Fehler Status Quitt Mot. ARS", 10, 1, 0, 0 ); ftextout( ":", 10, 30, 0, 0 ); INPAapiResultText( text_var, "FEHLER_QUITT_MOTOR_ARS_WERT", 1, "" ); ftextout( text_var, 10, 32, 0, 0 ); INPAapiResultText( text_var, "FEHLER_QUITT_MOTOR_ARS_TEXT", 1, "" ); ftextout( text_var, 10, 42, 0, 0 );*/ ftextout( "CAN Fehler Klemme 15 (Zuendung)", 11, 1, 0, 0 ); ftextout( ":", 11, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_KL15_WERT", 1, "" ); ftextout( text_var, 11, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_KL15_TEXT", 1, "" ); ftextout( text_var, 11, 42, 0, 0 ); ftextout( "CAN Fehler Klemme 50 (Anlasser)", 12, 1, 0, 0 ); ftextout( ":", 12, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_KL50_WERT", 1, "" ); ftextout( text_var, 12, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_KL50_TEXT", 1, "" ); ftextout( text_var, 12, 42, 0, 0 ); ftextout( "CAN Fehler Status DSC", 13, 1, 0, 0 ); ftextout( ":", 13, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_DSC_WERT", 1, "" ); ftextout( text_var, 13, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_DSC_TEXT", 1, "" ); ftextout( text_var, 13, 42, 0, 0 ); } if ( geschw == 1 ) { INPAapiJob( sgbd, "STATUS_CAN_GESCHWINDIGKEIT_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Wert Fahrzeuggeschwindigkeit", 1, 1, 0, 0 ); ftextout( ":", 1, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_GESCHWINDIGKEIT_FZG_WERT", 1, "" ); // stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "3.1" , text_var ); ftextout( text_var, 1, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_GESCHWINDIGKEIT_FZG_EINH", 1, "" ); ftextout( text_var, 1, 50, 0, 0 ); /* CAN Fehler Darstellung */ ftextout( "CAN Fehler Geschw. Fzg.", 10, 1, 0, 0 ); ftextout( ":", 10, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_GESCHWINDIGKEIT_FZG_WERT", 1, "" ); ftextout( text_var, 10, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_GESCHWINDIGKEIT_FZG_TEXT", 1, "" ); ftextout( text_var, 10, 42, 0, 0 ); } if ( drehzahl == 1 ) { INPAapiJob( sgbd, "STATUS_CAN_DREHZAHL_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Wert Motordrehzahl", 1, 1, 0, 0 ); ftextout( ":", 1, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_DREHZAHL_MOTOR_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "4.1" , text_var ); ftextout( text_var, 1, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_DREHZAHL_MOTOR_EINH", 1, "" ); ftextout( text_var, 1, 50, 0, 0 ); ftextout( "CAN Wert Fehler Motordrehzahl", 2, 1, 0, 0 ); ftextout( ":", 2, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_DREHZAHL_MOTOR_FEHLER_WERT", 1, "" ); ftextout( text_var, 2, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_DREHZAHL_MOTOR_FEHLER_EINH", 1, "" ); ftextout( text_var, 2, 50, 0, 0 ); /* CAN Fehler Darstellung */ ftextout( "CAN Fehler Drehzahl Motor", 10, 1, 0, 0 ); ftextout( ":", 10, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_DREHZAHL_MOTOR_WERT", 1, "" ); ftextout( text_var, 10, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_DREHZAHL_MOTOR_TEXT", 1, "" ); ftextout( text_var, 10, 42, 0, 0 ); ftextout( "CAN Fehler Drehzahl Motor Fehler", 11, 1, 0, 0 ); ftextout( ":", 11, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_DREHZAHL_MOTOR_FEHLER_WERT", 1, "" ); ftextout( text_var, 11, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_DREHZAHL_MOTOR_FEHLER_TEXT", 1, "" ); ftextout( text_var, 11, 42, 0, 0 ); } if ( beschl == 1 ) { INPAapiJob( sgbd, "STATUS_CAN_BESCHLEUNIGUNG_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Wert DSC Querbeschl.", 1, 1, 0, 0 ); ftextout( ":", 1, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_DSC_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "1.3" , text_var ); ftextout( text_var, 1, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_DSC_EINH", 1, "" ); ftextout( text_var, 1, 50, 0, 0 ); ftextout( "CAN Wert DSC Winkelbeschl.", 2, 1, 0, 0 ); ftextout( ":", 2, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_WINKELGESCHW_DSC_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "3.3" , text_var ); ftextout( text_var, 2, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_WINKELGESCHW_DSC_EINH", 1, "" ); ftextout( text_var, 2, 50, 0, 0 ); /* CAN Fehler Darstellung */ ftextout( "CAN Fehler Beschl.FZG Quer DSC", 10, 1, 0, 0 ); ftextout( ":", 10, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_QUERBESCHL_DSC_WERT", 1, "" ); ftextout( text_var, 10, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_QUERBESCHL_DSC_TEXT", 1, "" ); ftextout( text_var, 10, 42, 0, 0 ); ftextout( "CAN Fehler Winkelgeschw. Gier DSC", 11, 1, 0, 0 ); ftextout( ":", 11, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_WINKELGESCHW_DSC_WERT", 1, "" ); ftextout( text_var, 11, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_WINKELGESCHW_DSC_TEXT", 1, "" ); ftextout( text_var, 11, 42, 0, 0 ); INPAapiJob( sgbd, "STATUS_ROSE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Fehler STATUS ROSE ARS", 12, 1, 0, 0 ); ftextout( ":", 12, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_QUERBESCHL_ROSE_WERT", 1, "" ); ftextout( text_var, 12, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_QUERBESCHL_ROSE_TEXT", 1, "" ); ftextout( text_var, 12, 42, 0, 0 ); ftextout( "CAN Wert ROSE Querbeschl.", 3, 1, 0, 0 ); ftextout( ":", 3, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_ROSE_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "1.3" , text_var ); ftextout( text_var, 3, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_ROSE_EINH", 1, "" ); ftextout( text_var, 3, 50, 0, 0 ); } if ( temperatur == 1 ) { INPAapiJob( sgbd, "STATUS_CAN_TEMP_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Wert Aussentemperatur", 1, 1, 0, 0 ); ftextout( ":", 1, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_AUSSENTEMPERATUR_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 2 Nachkommastellen realtostring ( zahl_var, "2.2" , text_var ); ftextout( text_var, 1, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_AUSSENTEMPERATUR_EINH", 1, "" ); ftextout( text_var, 1, 50, 0, 0 ); ftextout( "CAN Wert Motortemperatur", 2, 1, 0, 0 ); ftextout( ":", 2, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_MOTORTEMPERATUR_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 2 Nachkommastellen realtostring ( zahl_var, "2.2" , text_var ); ftextout( text_var, 2, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_MOTORTEMPERATUR_EINH", 1, "" ); ftextout( text_var, 2, 50, 0, 0 ); /* CAN Fehler Darstellung */ ftextout( "CAN Fehler Aussentemperatur", 10, 1, 0, 0 ); ftextout( ":", 10, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_AUSSENTEMPERATUR_WERT", 1, "" ); ftextout( text_var, 10, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_AUSSENTEMPERATUR_TEXT", 1, "" ); ftextout( text_var, 10, 42, 0, 0 ); ftextout( "CAN Fehler Motortemperatur", 11, 1, 0, 0 ); ftextout( ":", 11, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_MOTORTEMPERATUR_WERT", 1, "" ); ftextout( text_var, 11, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_MOTORTEMPERATUR_TEXT", 1, "" ); ftextout( text_var, 11, 42, 0, 0 ); /* zusätzlich Steuergeräte Innentemperatur */ INPAapiJob( sgbd, "STATUS_SG_TEMP", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Steuergerät Innentemperatur", 4, 1, 0, 0 ); ftextout( ":", 4, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_SG_TEMP_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 2 Nachkommastellen realtostring ( zahl_var, "2.2" , text_var ); ftextout( text_var, 4, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_SG_TEMP_EINH", 1, "" ); ftextout( text_var, 4, 50, 0, 0 ); } if ( diverses == 1 ) { INPAapiJob( sgbd, "STATUS_CAN_DIVERSES_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Wert Kilometerstand", 1, 1, 0, 0 ); ftextout( ":", 1, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_KILOMETERSTAND_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "6.1" , text_var ); ftextout( text_var, 1, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_KILOMETERSTAND_EINH", 1, "" ); ftextout( text_var, 1, 42, 0, 0 ); ftextout( "CAN Wert Lenkradwinkel", 2, 1, 0, 0 ); ftextout( ":", 2, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_LENKRADWINKEL_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "3.1" , text_var ); ftextout( text_var, 2, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_LENKRADWINKEL_EINH", 1, "" ); ftextout( text_var, 2, 42, 0, 0 ); ftextout( "CAN Wert Fehler Lenkradwinkel", 3, 1, 0, 0 ); ftextout( ":", 3, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_LENKRADWINKEL_FEHLER_NR", 1, "" ); ftextout( text_var, 3, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_LENKRADWINKEL_FEHLER_TEXT", 1, "" ); clearrect(9,40,1,40); ftextout( text_var, 3, 42, 0, 0 ); /* CAN Fehler Darstellung */ ftextout( "CAN Fehler Kilometerstand", 10, 1, 0, 0 ); ftextout( ":", 10, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_KILOMETERSTAND_WERT", 1, "" ); ftextout( text_var, 10, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_KILOMETERSTAND_TEXT", 1, "" ); ftextout( text_var, 10, 42, 0, 0 ); ftextout( "CAN Fehler Lenkradwinkel", 11, 1, 0, 0 ); ftextout( ":", 11, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_LENKRADWINKEL_WERT", 1, "" ); ftextout( text_var, 11, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_LENKRADWINKEL_TEXT", 1, "" ); ftextout( text_var, 11, 42, 0, 0 ); ftextout( "CAN Fehler Lenkradwinkel Fehler", 12, 1, 0, 0 ); ftextout( ":", 12, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_LENKRADWINKEL_FEHLER_WERT", 1, "" ); ftextout( text_var, 12, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_LENKRADWINKEL_FEHLER_TEXT", 1, "" ); ftextout( text_var, 12, 42, 0, 0 ); /*zusätzlich Rotor Position */ INPAapiJob( sgbd, "STATUS_CAN_ROTOR_POSITION", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "CAN Wert Rotorposition", 4, 1, 0, 0 ); ftextout( ":", 4, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_ROTOR_POSITION_ACTUAL_VALUE_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 4 Vorkommastellen, 1 Nachkommastellen realtostring ( zahl_var, "6.1" , text_var ); ftextout( text_var, 4, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_ROTOR_POSITION_ACTUAL_VALUE_EINH", 1, "" ); ftextout( text_var, 4, 42, 0, 0 ); ftextout( "CAN Wert Status Rotorposition", 5, 1, 0, 0 ); ftextout( ":", 5, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_ROTOR_POSITION_STAT_AFS_WERT", 1, "" ); ftextout( text_var, 5, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_ROTOR_POSITION_STAT_AFS_TEXT", 1, "" ); clearrect(11,40,1,40); ftextout( text_var, 5, 42, 0, 0 ); ftextout( "CAN Wert Codierstring 2", 6, 1, 0, 0 ); ftextout( ":", 6, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_CODSTR2_WERT", 1, "" ); ftextout( text_var, 6, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_CODSTR2_TEXT", 1, "" ); ftextout( text_var, 6, 42, 0, 0 ); ftextout( "CAN Fehler Rotorposition", 13, 1, 0, 0 ); ftextout( ":", 13, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_ROTOR_POSITION_ACTUAL_VALUE_WERT", 1, "" ); ftextout( text_var, 13, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_ROTOR_POSITION_ACTUAL_VALUE_TEXT", 1, "" ); ftextout( text_var, 13, 42, 0, 0 ); ftextout( "CAN Fehler Status Rotorposition", 14, 1, 0, 0 ); ftextout( ":", 14, 30, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_ROTOR_POSITION_STAT_WERT", 1, "" ); ftextout( text_var, 14, 32, 0, 0 ); INPAapiResultText( text_var, "STAT_FEHLER_ROTOR_POSITION_STAT_TEXT", 1, "" ); ftextout( text_var, 14, 42, 0, 0 ); } if ( hoehenstand == 1 ) { INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "1", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_vl, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_vl, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); INPAapiResultText( steigung_einh, "STAT_SENSOR_STEIGUNG_HGLV_EINH", 1, "" ); INPAapiResultText( nullpunkt_einh, "STAT_SENSOR_NULLPKT_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "2", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_vr, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_vr, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); } else { err_jobstatus = chk_jobstatus; } INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "3", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_hl, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_hl, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); } else { err_jobstatus = chk_jobstatus; } INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "4", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_hr, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_hr, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); } INPAapiJob( sgbd, "STATUS_OFFSET_WERTE_HGLV", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( offset_vl, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_FLH_WERT", 1 ); INPAapiResultInt( offset_vr, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_FRH_WERT", 1 ); INPAapiResultInt( offset_hl, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_RLH_WERT", 1 ); INPAapiResultInt( offset_hr, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_RRH_WERT", 1 ); INPAapiResultText( offset_einh, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } // Ausgabe der Sensorwerte ftextout( "Sensornullpunkt Höhenstand VR", 6, 1, 0, 0 ); ftextout( ":", 6, 22, 0, 0 ); inttoreal(nullpunkt_vr, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 6, 24, 0, 0 ); ftextout( nullpunkt_einh, 6, 30, 0, 0 ); ftextout( "Sensorsteigung Höhenstand VR", 7, 1, 0, 0 ); ftextout( ":", 7, 22, 0, 0 ); inttoreal(steigung_vr, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 7, 24, 0, 0 ); ftextout( steigung_einh, 7, 30, 0, 0 ); ftextout( "Sensornullpunkt Höhenstand VL", 3, 1, 0, 0 ); ftextout( ":", 3, 22, 0, 0 ); inttoreal(nullpunkt_vl, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 3, 24, 0, 0 ); ftextout( nullpunkt_einh, 3, 30, 0, 0 ); ftextout( "Sensorsteigung Höhenstand VL", 4, 1, 0, 0 ); ftextout( ":", 4, 22, 0, 0 ); inttoreal(steigung_vl, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 4, 24, 0, 0 ); ftextout( steigung_einh, 4, 30, 0, 0 ); ftextout( "Sensornullpunkt Höhenstand HR", 12, 1, 0, 0 ); ftextout( ":", 12, 22, 0, 0 ); inttoreal(nullpunkt_hr, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 12, 24, 0, 0 ); ftextout( nullpunkt_einh, 12, 30, 0, 0 ); ftextout( "Sensorsteigung Höhenstand HR", 13, 1, 0, 0 ); ftextout( ":", 13, 22, 0, 0 ); inttoreal(steigung_hr, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 13, 24, 0, 0 ); ftextout( steigung_einh, 13, 30, 0, 0 ); ftextout( "Sensornullpunkt Höhenstand HL", 9, 1, 0, 0 ); ftextout( ":", 9, 22, 0, 0 ); inttoreal(nullpunkt_hl, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 9, 24, 0, 0 ); ftextout( nullpunkt_einh, 9, 30, 0, 0 ); ftextout( "Sensorsteigung Höhenstand HL", 10, 1, 0, 0 ); ftextout( ":", 10, 22, 0, 0 ); inttoreal(steigung_hl, tmpr); realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 10, 24, 0, 0 ); ftextout( steigung_einh, 10, 30, 0, 0 ); // Ausgabe Offsetwerte ftextout( "Offset VL", 3, 55, 0, 0 ); ftextout( ":", 3, 62, 0, 0 ); inttoreal(offset_vl, tmpr); inttoreal(steigung_vl, tmpr_steig); inttoreal(nullpunkt_vl, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 3, 64, 0, 0 ); ftextout( "Offset VR",6, 55, 0, 0 ); ftextout( ":", 6, 62, 0, 0 ); inttoreal(offset_vr, tmpr); inttoreal(steigung_vr, tmpr_steig); inttoreal(nullpunkt_vr, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 6, 64, 0, 0 ); ftextout( "Offset HL", 9, 55, 0, 0 ); ftextout( ":", 9, 62, 0, 0 ); inttoreal(offset_hl, tmpr); inttoreal(steigung_hl, tmpr_steig); inttoreal(nullpunkt_hl, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 9, 64, 0, 0 ); ftextout( "Offset HR", 12, 55, 0, 0 ); ftextout( ":", 12, 62, 0, 0 ); inttoreal(offset_hr, tmpr); inttoreal(steigung_hr, tmpr_steig); inttoreal(nullpunkt_hr, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 12, 64, 0, 0 ); } } } // ****************************** // *** Ventile Status *** // ****************************** SCREEN s_ventile_status() { int status_ars; real stat_alive; real zahl_var; string text_var = ""; ftextout( "Ventile", 1, 0, 1, 0 ); ftextout( "", 2, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); INPAapiResultText( text_var, "STAT_ALIVE_ZAEHLER_TEXT", 1, "" ); ftextout( text_var, 3, 50, 0, 0 ); ftextout( "SG Status", 5, 50, 0, 0 ); ftextout( ":", 5, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 5, 60, 0, 0 ); LINE( "","" ) { ftextout( "< F1 > Sicherheitsventil lesen" ,3, 5, 0, 1 ); ftextout( "< F2 > Richtungsventil lesen" ,5, 5, 0, 1 ); ftextout( "< F3 > Proportionalventil VA lesen" ,7, 5, 0, 1 ); ftextout( "< F4 > Proportionalventil HA lesen" ,9, 5, 0, 1 ); } } // ****************************** // *** SV Ventil *** // ****************************** SCREEN s_sv_ventil() { real strom_sv_ventil; real stat_querbesch; real stat_pwm_ventil; string text_var = ""; ftextout( "Sicherheitsventil", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // 'Fehlerzustaende' des Sicherheitsventils INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 40, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ftextout( "Soll Strom Sicherheitsventil", 10, 5, 0, 0 ); ftextout( ":", 10, 27, 0, 0 ); //Soll Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_SOLLSTROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 10, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_SOLLSTROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 10, 65, 0, 0 ); ftextout( "Status PWM Sicherheitsventil", 13, 5, 0, 0 ); ftextout( ":", 13, 27, 0, 0 ); //Soll Stromwert auslesen INPAapiResultAnalog( stat_pwm_ventil, "STAT_PWM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_pwm_ventil, 13, 30, 0, 100, 0, 100, "3.1" ); // Einheit [%] INPAapiResultText( text_var, "STAT_PWM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 13, 65, 0, 0 ); //************************************************************ // physikalischer Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Querbeschleunigung ftextout( "Querbeschleunigung (physik.)", 17, 5, 0, 0 ); ftextout( ":", 17, 27, 0, 0 ); // Querbeschleunigung auslesen INPAapiResultAnalog( stat_querbesch, "STAT_QUERBESCHL_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_querbesch, 17, 30, -20, 20, -20, 20, "5.3" ); // Einheit [g] / [m/s2] INPAapiResultText( text_var, "STAT_QUERBESCHL_SW_EINH", 1, "" ); ftextout( text_var, 17, 65, 0, 0 ); /* //************************************************************ // Rohwert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Querbeschleunigung ftextout( "Querbeschleunigung (Roh)", 20, 5, 0, 0 ); ftextout( ":", 20, 27, 0, 0 ); // Querbeschleunigung auslesen INPAapiResultText( text_var, "STAT_QUERBESCHLSEN_WERT", 1, "" ); ftextout( text_var, 20, 30, 0, 0 ); // Einheit [10bit] Rohwert INPAapiResultText( text_var, "STAT_QUERBESCHLSEN_TEXT", 1, "" ); ftextout( text_var, 20, 40, 0, 0 ); */ } } // ****************************** // *** RV Ventil *** // ****************************** SCREEN s_rv_ventil() { real strom_rv_ventil; real stat_pwm_ventil; real stat_querbesch; real stat_schaltstellung_RV; string text_var = ""; ftextout( "Richtungsventile", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { //************************************************************ INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 40, 0, 0 ); ftextout( "Steuerstrom Richtungsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ftextout( "Soll Strom Richtungsventil", 10, 5, 0, 0 ); ftextout( ":", 10, 27, 0, 0 ); //Soll Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_SOLLSTROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 10, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_SOLLSTROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 10, 65, 0, 0 ); ftextout( "Status PWM Richtungsventil", 13, 5, 0, 0 ); ftextout( ":", 13, 27, 0, 0 ); //Soll Stromwert auslesen INPAapiResultAnalog( stat_pwm_ventil, "STAT_PWM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_pwm_ventil, 13, 30, 0, 100, 0, 100, "3.1" ); // Einheit [%] INPAapiResultText( text_var, "STAT_PWM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 13, 65, 0, 0 ); //************************************************************ INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Querbeschleunigung ftextout( "Querbeschleunigung (physik.)", 17, 5, 0, 0 ); ftextout( ":", 17, 27, 0, 0 ); // Querbeschleunigung auslesen INPAapiResultAnalog( stat_querbesch, "STAT_QUERBESCHL_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_querbesch, 17, 30, -20, 20, -20, 20, "5.3" ); // Einheit [g] / [m/s2] INPAapiResultText( text_var, "STAT_QUERBESCHL_SW_EINH", 1, "" ); ftextout( text_var, 17, 65, 0, 0 ); //************************************************************ // Schaltstellung RV [ -1, 0, 1 ] ftextout( "Schaltstellung RV", 21, 5, 0, 0 ); ftextout( ":", 21, 27, 0, 0 ); // Schaltstellung RV auslesen INPAapiResultAnalog( stat_schaltstellung_RV, "STAT_POSITION_SW_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_schaltstellung_RV, 21, 30, -1, 1, -1, 1, "7.5" ); analogout( stat_schaltstellung_RV, 21, 30, -1.5, 1.5, -1, 1, "1" ); // Einheit [Zustand] INPAapiResultText( text_var, "STAT_POSITION_SW_EINH", 1, "" ); ftextout( text_var, 21, 65, 0, 0 ); } } // ****************************** // *** VA Ventil *** // ****************************** SCREEN s_va_ventil() { real stat_istdruck_ventil; real stat_pwm_ventil; real strom_va_ventil; real stat_querbesch; string text_var = ""; ftextout( "Proportionalventil VA", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Propventil VA", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_VA_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_VA_TEXT", 1, "" ); ftextout( text_var, 5, 40, 0, 0 ); ftextout( "Steuerstrom Propventil VA", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_va_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_VA_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ftextout( "Soll Strom Propventil VA", 10, 5, 0, 0 ); ftextout( ":", 10, 27, 0, 0 ); //Soll Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_SOLLSTROM_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_va_ventil, 10, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_SOLLSTROM_VA_EINH", 1, "" ); ftextout( text_var, 10, 65, 0, 0 ); ftextout( "PWM Propventil VA", 13, 5, 0, 0 ); ftextout( ":", 13, 27, 0, 0 ); // INPAapiResultAnalog( stat_pwm_ventil, "STAT_PWM_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_pwm_ventil, 13, 30, 0, 100, 0, 100, "3.1" ); // Einheit [%] INPAapiResultText( text_var, "STAT_PWM_VA_EINH", 1, "" ); ftextout( text_var, 13, 65, 0, 0 ); //************************************************************ INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck VA ftextout( "Ist Druck VA", 16, 5, 0, 0 ); ftextout( ":", 16, 27, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_VA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 16, 30, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_DRUCK_VA_SW_EINH", 1, "" ); ftextout( text_var, 16, 65, 0, 0 ); // Querbeschleunigung ftextout( "Querbeschleunigung (physik.)", 23, 5, 0, 0 ); ftextout( ":", 23, 27, 0, 0 ); // Querbeschleunigung auslesen INPAapiResultAnalog( stat_querbesch, "STAT_QUERBESCHL_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_querbesch, 23, 30, -20, 20, -20, 20, "5.3" ); // Einheit [g] / [m/s2] INPAapiResultText( text_var, "STAT_QUERBESCHL_SW_EINH", 1, "" ); ftextout( text_var, 23, 65, 0, 0 ); } } // ****************************** // *** HA Ventil *** // ****************************** SCREEN s_ha_ventil() { real stat_istdruck_ventil; real stat_pwm_ventil; real strom_ha_ventil; real stat_querbesch; string text_var = ""; ftextout( "Proportionalventil HA", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Propventil HA", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_HA_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_HA_TEXT", 1, "" ); ftextout( text_var, 5, 40, 0, 0 ); ftextout( "Steuerstrom Propventil HA", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_ha_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_HA_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ftextout( "Soll Strom Propventil VA", 10, 5, 0, 0 ); ftextout( ":", 10, 27, 0, 0 ); //Soll Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_SOLLSTROM_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_ha_ventil, 10, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_SOLLSTROM_HA_EINH", 1, "" ); ftextout( text_var, 10, 65, 0, 0 ); ftextout( "PWM Propventil HA", 13, 5, 0, 0 ); ftextout( ":", 13, 27, 0, 0 ); // INPAapiResultAnalog( stat_pwm_ventil, "STAT_PWM_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_pwm_ventil, 13, 30, 0, 100, 0, 100, "3.1" ); // Einheit [%] INPAapiResultText( text_var, "STAT_PWM_HA_EINH", 1, "" ); ftextout( text_var, 13, 65, 0, 0 ); //************************************************************ INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck HA ftextout( "Ist Druck HA", 16, 5, 0, 0 ); ftextout( ":", 16, 27, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_HA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 16, 30, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_DRUCK_HA_SW_EINH", 1, "" ); ftextout( text_var, 16, 65, 0, 0 ); // Querbeschleunigung ftextout( "Querbeschleunigung (physik.)", 23, 5, 0, 0 ); ftextout( ":", 23, 27, 0, 0 ); // Querbeschleunigung auslesen INPAapiResultAnalog( stat_querbesch, "STAT_QUERBESCHL_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_querbesch, 23, 30, -20, 20, -20, 20, "5.3" ); // Einheit [g] / [m/s2] INPAapiResultText( text_var, "STAT_QUERBESCHL_SW_EINH", 1, "" ); ftextout( text_var, 23, 65, 0, 0 ); } } // ****************************** // *** Ventilabgleich *** // ****************************** SCREEN s_sensorabgleich() { real stat_offsetdruck_ventil; real stat_offsetquerbesch; real stat_dynoffsetquerbesch; real stat_sensorpara; real tmpr = 0; int stat_steigung; string text_var = ""; int sensor_nullpunkt = 0; int sensor_steigung = 0; int input_state_key_1 = 0; string err_jobstatus = ""; string chk_jobstatus = ""; string sensor_nullpunkt_einh = ""; string sensor_steigung_einh = ""; string tmpn = ""; string tmps = ""; ftextout( "Sensorabgleich", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { // gelernter Offset Wert lesen fuer Nullpunkt Druck VA INPAapiJob( sgbd, "STATUS_OFFSET_WERTE_VA", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Druck VA ftextout( "Arbeitsnullpunkt fuer Druck VA", 1, 1, 0, 0 ); ftextout( ":", 1, 35, 0, 0 ); // INPAapiResultAnalog( stat_offsetdruck_ventil, "STAT_NULLPUNKT_OFFSET_DRUCK_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_offsetdruck_ventil, 1, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_NULLPUNKT_OFFSET_DRUCK_VA_EINH", 1, "" ); ftextout( text_var, 1, 75, 0, 0 ); // gelernter Offset Wert lesen fuer Nullpunkt Druck HA INPAapiJob( sgbd, "STATUS_OFFSET_WERTE_HA", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Druck HA ftextout( "Arbeitsnullpunkt fuer Druck HA", 3, 1, 0, 0 ); ftextout( ":", 3, 35, 0, 0 ); // INPAapiResultAnalog( stat_offsetdruck_ventil, "STAT_NULLPUNKT_OFFSET_DRUCK_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_offsetdruck_ventil, 3, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_NULLPUNKT_OFFSET_DRUCK_HA_EINH", 1, "" ); ftextout( text_var, 3, 75, 0, 0 ); // gelernter Offset Wert lesen fuer Querbeschleunigung INPAapiJob( sgbd, "STATUS_OFFSET_QUERBESCH", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Querbeschleunigung ftextout( "Arbeitsnullpunkt fuer Querbeschleunigung", 5, 1, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); // Querbeschleunigung ftextout( "Dynamischer Nullpunkt für Querbeschleunigung",7, 1, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); // INPAapiResultAnalog( stat_offsetquerbesch, "STAT_NULLPUNKT_OFFSET_QUERBESCH_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_offsetquerbesch, 5, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [mV] INPAapiResultText( text_var, "STAT_NULLPUNKT_OFFSET_QUERBESCH_EINH", 1, "" ); ftextout( text_var, 5, 75, 0, 0 ); INPAapiResultAnalog( stat_dynoffsetquerbesch, "STAT_DYN_OFFSET_QUERBESCH_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_dynoffsetquerbesch, 7, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [mV] INPAapiResultText( text_var, "STAT_DYN_OFFSET_QUERBESCH_EINH", 1, "" ); ftextout( text_var, 7, 75, 0, 0 ); // Sensorparameter Druck VA lesen INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_VA", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // ftextout( "Sensornullpunkt Druck VA", 10, 1, 0, 0 ); ftextout( ":", 10, 35, 0, 0 ); // INPAapiResultAnalog( stat_sensorpara, "STAT_SENSOR_NULLPKT_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_sensorpara, 10, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [mV] INPAapiResultText( text_var, "STAT_SENSOR_NULLPKT_VA_EINH", 1, "" ); ftextout( text_var, 10, 75, 0, 0 ); ftextout( "Sensorsteigung Druck VA", 12, 1, 0, 0 ); ftextout( ":", 12, 35, 0, 0 ); // INPAapiResultInt( stat_steigung, "STAT_SENSOR_STEIGUNG_VA_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_sensorpara, 12, 37, 0, 32000, 0, 32000, "5.1" ); inttoreal(stat_steigung, tmpr); // tmpr= tmpr/1000; realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 12, 37, 0, 0 ); // Einheit [mueVolt/bar] INPAapiResultText( text_var, "STAT_SENSOR_STEIGUNG_VA_EINH", 1, "" ); ftextout( text_var, 12, 42, 0, 0 ); // Sensorparameter Druck HA lesen INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HA", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // ftextout( "Sensornullpunkt Druck HA", 16, 1, 0, 0 ); ftextout( ":", 16, 35, 0, 0 ); // INPAapiResultAnalog( stat_sensorpara, "STAT_SENSOR_NULLPKT_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_sensorpara, 16, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [mV] INPAapiResultText( text_var, "STAT_SENSOR_NULLPKT_HA_EINH", 1, "" ); ftextout( text_var, 16, 75, 0, 0 ); ftextout( "Sensorsteigung Druck HA", 18, 1, 0, 0 ); ftextout( ":", 18, 35, 0, 0 ); // INPAapiResultInt( stat_steigung, "STAT_SENSOR_STEIGUNG_HA_WERT", 1 ); // Zl, Sp, min max Format // analogout( stat_sensorpara, 18, 37, 0, 32000, 0, 32000, "5.1" ); inttoreal(stat_steigung, tmpr); // tmpr= tmpr/1000; realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 18, 37, 0, 0 ); // Einheit [mueVolt/bar] INPAapiResultText( text_var, "STAT_SENSOR_STEIGUNG_HA_EINH", 1, "" ); ftextout( text_var, 18, 42, 0, 0 ); // gelernter Offset Wert lesen fuer Querbeschleunigung INPAapiJob( sgbd, "STATUS_NEUE_WERTE_QUERBESCH", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // ftextout( "Sensornullpkt Querbesch", 22, 1, 0, 0 ); ftextout( ":", 22, 35, 0, 0 ); // INPAapiResultAnalog( stat_sensorpara, "STAT_SENSOR_NULLPKT_AQUER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_sensorpara, 22, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [mV] INPAapiResultText( text_var, "STAT_SENSOR_NULLPKT_AQUER_EINH", 1, "" ); ftextout( text_var, 22, 75, 0, 0 ); ftextout( "Sensorsteigung Querbesch", 24, 1, 0, 0 ); ftextout( ":", 24, 35, 0, 0 ); // INPAapiResultInt( stat_steigung, "STAT_SENSOR_STEIGUNG_AQUER_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_sensorpara, 24, 37, 0, 32000, 0, 32000, "5.1" ); inttoreal(stat_steigung, tmpr); // tmpr= tmpr/1000; realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 24, 37, 0, 0 ); // Einheit [mVolt/g] INPAapiResultText( text_var, "STAT_SENSOR_STEIGUNG_AQUER_EINH", 1, "" ); ftextout( text_var, 24, 42, 0, 0 ); if ( para_lernen_4 == 1 ) { para_lernen_4 = 0; INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_VA", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( sensor_nullpunkt, "STAT_SENSOR_NULLPKT_VA_WERT", 1 ); INPAapiResultText( sensor_nullpunkt_einh, "STAT_SENSOR_NULLPKT_VA_EINH", 1, "" ); INPAapiResultInt( sensor_steigung, "STAT_SENSOR_STEIGUNG_VA_WERT", 1 ); INPAapiResultText( sensor_steigung_einh, "STAT_SENSOR_STEIGUNG_VA_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } input2int( sensor_nullpunkt, sensor_steigung, "VA Sensorabgleich", "Parameter schreiben:", "Sensornullpunkt:", "Sensorsteigung:", 0, 1500 , 0, 25000); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(sensor_nullpunkt, tmpn); inttostring(sensor_steigung, tmps); INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_VA", tmpn+";"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Werte ausserhalb zulässigen Bereichs", "" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if ( para_lernen_5 == 1 ) { para_lernen_5 = 0; INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HA", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( sensor_nullpunkt, "STAT_SENSOR_NULLPKT_HA_WERT", 1 ); INPAapiResultText( sensor_nullpunkt_einh, "STAT_SENSOR_NULLPKT_HA_EINH", 1, "" ); INPAapiResultInt( sensor_steigung, "STAT_SENSOR_STEIGUNG_HA_WERT", 1 ); INPAapiResultText( sensor_steigung_einh, "STAT_SENSOR_STEIGUNG_HA_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } input2int( sensor_nullpunkt, sensor_steigung, "HA Sensorabgleich", "Parameter schreiben:", "Sensornullpunkt:", "Sensorsteigung:", 0, 1500 , 0, 25000); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(sensor_nullpunkt, tmpn); inttostring(sensor_steigung, tmps); INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_HA", tmpn+";"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Werte ausserhalb zulässigen Bereichs", "" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if ( para_lernen_6 == 1 ) { para_lernen_6 = 0; INPAapiJob( sgbd, "STATUS_NEUE_WERTE_QUERBESCH", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( sensor_nullpunkt, "STAT_SENSOR_NULLPKT_AQUER_WERT", 1 ); INPAapiResultText( sensor_nullpunkt_einh, "STAT_SENSOR_NULLPKT_AQUER_EINH", 1, "" ); INPAapiResultInt( sensor_steigung, "STAT_SENSOR_STEIGUNG_AQUER_WERT", 1 ); INPAapiResultText( sensor_steigung_einh, "STAT_SENSOR_STEIGUNG_AQUER_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } input2int( sensor_nullpunkt, sensor_steigung, "AQuer Sensorabgleich", "Parameter schreiben:", "Sensornullpunkt:", "Sensorsteigung:", 0, 4000 , 0, 5000); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(sensor_nullpunkt, tmpn); inttostring(sensor_steigung, tmps); INPAapiJob( sgbd, "START_LERNEN_NEUE_WERTE_QUERBESCH", tmpn+";"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Werte ausserhalb zulässigen Bereichs", "" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } } } // ****************************** // *** Höhenstandabgleich *** // ****************************** SCREEN s_hoehenstandabgleich() { int offset_vl = 0; int offset_vr = 0; int offset_hl = 0; int offset_hr = 0; int steigung_vl = 0; int steigung_vr = 0; int steigung_hl = 0; int steigung_hr = 0; int nullpunkt_vl = 0; int nullpunkt_vr = 0; int nullpunkt_hl = 0; int nullpunkt_hr = 0; int abw_vl = 0; int abw_vr = 0; int abw_hl = 0; int abw_hr = 0; real tmpr = 0; real tmpr_steig = 0; real tmpr_null = 0; string tmps = ""; string tmpn = ""; string offset_einh = "no response"; string offset_einh2 = "Einheitenfehler"; string steigung_einh = "no response"; string nullpunkt_einh = "no response"; string text_var= ""; string chk_jobstatus=""; string err_jobstatus = "none"; int input_state_key_1 = 0; int input_state_key_2 = 0; int input_state_key_3 = 0; int input_state_key_4 = 0; ftextout("Höhenstandabgleichwerte",1,0,1,0); ftextout("",3,0,0,0); LINE("","") { ftextout("aktuelle Abgleichwerte",1,0,0,1); // aktuelle Werte lesen INPAapiJob( sgbd, "STATUS_OFFSET_WERTE_HGLV", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( offset_vl, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_FLH_WERT", 1 ); INPAapiResultInt( offset_vr, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_FRH_WERT", 1 ); INPAapiResultInt( offset_hl, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_RLH_WERT", 1 ); INPAapiResultInt( offset_hr, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_RRH_WERT", 1 ); INPAapiResultText( offset_einh, "STAT_NULLPUNKT_OFFSET_DRUCK_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "1", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_vl, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_vl, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); INPAapiResultText( steigung_einh, "STAT_SENSOR_STEIGUNG_HGLV_EINH", 1, "" ); INPAapiResultText( nullpunkt_einh, "STAT_SENSOR_NULLPKT_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "2", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_vr, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_vr, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); } else { err_jobstatus = chk_jobstatus; } INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "3", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_hl, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_hl, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); } else { err_jobstatus = chk_jobstatus; } INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "4", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_hr, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_hr, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); } // Aktuelle Werte darstellen // Parameter ftextout( "Wert Sensornullpunkt VL", 3, 1, 0, 0 ); ftextout( "Offset: ", 2, 55, 0, 0 ); ftextout( "Differenz zw. Sensornullpunkt", 2, 60, 0, 0 ); ftextout( "und gelernter Nulllage", 3, 60, 0, 0 ); ftextout( ":", 3, 17, 0, 0 ); inttoreal(nullpunkt_vl, tmpr); analogout( tmpr, 3, 18, 0, 5000, 0, 5000, "" ); ftextout( nullpunkt_einh, 3, 49, 0, 0 ); ftextout( "Steigung VL", 5, 1, 0, 0 ); ftextout( ":", 5, 17, 0, 0 ); inttoreal(steigung_vl, tmpr); // analogout( tmpr, 5, 27, -32767, 32767, -32767, 32767, "" ); // tmpr= tmpr/1000; realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 5, 18, 0, 0 ); ftextout( steigung_einh, 5, 23, 0, 0 ); ftextout( "Wert Sensornullpunkt VR", 8, 1, 0, 0 ); ftextout( ":", 8, 17, 0, 0 ); inttoreal(nullpunkt_vr, tmpr); analogout( tmpr, 8, 18, 0, 5000, 0, 5000, "" ); ftextout( nullpunkt_einh, 8, 49, 0, 0 ); ftextout( "Steigung VR", 10, 1, 0, 0 ); ftextout( ":", 10, 17, 0, 0 ); inttoreal(steigung_vr, tmpr); // analogout( tmpr, 10, 27, -32767, 32767, -32767, 32767, "" ); // tmpr= tmpr/1000; realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 10, 18, 0, 0 ); ftextout( steigung_einh, 10, 23, 0, 0 ); ftextout( "Wert Sensornullpunkt HL", 13, 1, 0, 0 ); ftextout( ":", 13, 17, 0, 0 ); inttoreal(nullpunkt_hl, tmpr); analogout( tmpr, 13, 18, 0, 5000, 0, 5000, "" ); ftextout( nullpunkt_einh, 13, 49, 0, 0 ); ftextout( "Steigung HL", 15, 1, 0, 0 ); ftextout( ":", 15, 17, 0, 0 ); inttoreal(steigung_hl, tmpr); // analogout( tmpr, 15, 27, -32767, 32767, -32767, 32767, "" ); // tmpr= tmpr/1000; realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 15, 18, 0, 0 ); ftextout( steigung_einh, 15, 23, 0, 0 ); ftextout( "Wert Sensornullpunkt HR", 18, 1, 0, 0 ); ftextout( ":", 18, 17, 0, 0 ); inttoreal(nullpunkt_hr, tmpr); analogout( tmpr, 18, 18, 0, 5000, 0, 5000, "" ); ftextout( nullpunkt_einh, 18, 49, 0, 0 ); ftextout( "Steigung HR", 20, 1, 0, 0 ); ftextout( ":", 20, 17, 0, 0 ); inttoreal(steigung_hr, tmpr); // analogout( tmpr, 20, 27, -32767, 32767, -32767, 32767, "" ); // tmpr= tmpr/1000; realtostring( tmpr, "5.0",text_var ); ftextout( text_var, 20, 18, 0, 0 ); ftextout( steigung_einh, 20, 23, 0, 0 ); // Offsetwerte ftextout( "Offset VL", 5, 55, 0, 0 ); ftextout( ":", 5, 62, 0, 0 ); inttoreal(offset_vl, tmpr); inttoreal(steigung_vl, tmpr_steig); inttoreal(nullpunkt_vl, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 5, 64, 0, 0 ); ftextout( "Offset VR",10, 55, 0, 0 ); ftextout( ":", 10, 62, 0, 0 ); inttoreal(offset_vr, tmpr); inttoreal(steigung_vr, tmpr_steig); inttoreal(nullpunkt_vr, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 10, 64, 0, 0 ); ftextout( "Offset HL", 15, 55, 0, 0 ); ftextout( ":", 15, 62, 0, 0 ); inttoreal(offset_hl, tmpr); inttoreal(steigung_hl, tmpr_steig); inttoreal(nullpunkt_hl, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 15, 64, 0, 0 ); ftextout( "Offset HR", 20, 55, 0, 0 ); ftextout( ":", 20, 62, 0, 0 ); inttoreal(offset_hr, tmpr); inttoreal(steigung_hr, tmpr_steig); inttoreal(nullpunkt_hr, tmpr_null); offset_einh2 = offset_einh; if ((steigung_einh == "mV/m") && (offset_einh == "mV")) { // umskalieren von mV auf mm tmpr = (tmpr - tmpr_null)/ tmpr_steig * 1000; offset_einh2 = "mm"; } realtostring (tmpr, "4.2", tmps); ftextout( tmps+" "+offset_einh2, 20, 64, 0, 0 ); if(err_jobstatus != "none") { ftextout( "Diagnosefehler", 8, 70, 0, 0); ftextout( err_jobstatus, 10, 70, 0, 0); ftextout( "Codierung prüfen!", 12, 70, 0, 0 ); } } LINE ( "","" ) { if(hs_abgleichen_1 == 1) { hs_abgleichen_1 = 0; inputint( abw_vl, "Höhenstandabgleich", "aktuelle Abweichung von Nulllage (Ausgefedert positiv) vorne links:", -200, 200 ); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(abw_vl, tmps); INPAapiJob( sgbd, "START_OFFSET_WERTE_HGLV", "1;"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "Nulllagenabweichung zu groß! Spannung bei Nulllage außerhalb des Sensorbereichs" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if(hs_abgleichen_2 == 1) { hs_abgleichen_2 = 0; inputint( abw_vr, "Höhenstandabgleich", "aktuelle Abweichung von Nulllage (Ausgefedert positiv) vorne rechts:", -200, 200 ); getinputstate( input_state_key_2 ); if ( input_state_key_2 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_2 == 0 ) { inttostring(abw_vr, tmps); INPAapiJob( sgbd, "START_OFFSET_WERTE_HGLV", "2;"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ){} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "Nulllagenabweichung zu groß! Spannung bei Nulllage außerhalb des Sensorbereichs" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if(hs_abgleichen_3 == 1) { hs_abgleichen_3 = 0; inputint( abw_hl, "Höhenstandabgleich", "aktuelle Abweichung von Nulllage (Ausgefedert positiv) hinten links:", -200, 200 ); getinputstate( input_state_key_3 ); if ( input_state_key_3 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_3 == 0 ) { inttostring(abw_hl, tmps); INPAapiJob( sgbd, "START_OFFSET_WERTE_HGLV", "3;"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "Nulllagenabweichung zu groß! Spannung bei Nulllage außerhalb des Sensorbereichs" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if(hs_abgleichen_4 == 1) { hs_abgleichen_4 = 0; inputint( abw_hr, "Höhenstandabgleich", "aktuelle Abweichung von Nulllage (Ausgefedert positiv) hinten rechts:", -200, 200 ); getinputstate( input_state_key_4 ); if ( input_state_key_4 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_4 == 0 ) { inttostring(abw_hr, tmps); INPAapiJob( sgbd, "START_OFFSET_WERTE_HGLV", "4;"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "Nulllagenabweichung zu groß! Spannung bei Nulllage außerhalb des Sensorbereichs" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if(hs_abgleichen_5 == 1) { hs_abgleichen_5 = 0; INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "1", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_vl, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_vl, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); INPAapiResultText( steigung_einh, "STAT_SENSOR_STEIGUNG_HGLV_EINH", 1, "" ); INPAapiResultText( nullpunkt_einh, "STAT_SENSOR_NULLPKT_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } input2int( nullpunkt_vl, steigung_vl, "Höhenstandabgleich", "vorne links:", "Sensornullpunkt:", "Sensorsteigung:", 0, 5000 , -30000, 30000); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(nullpunkt_vl, tmpn); inttostring(steigung_vl, tmps); INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_HGLV", "1;"+tmpn+";"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if(hs_abgleichen_6 == 1) { hs_abgleichen_6 = 0; INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "2", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_vr, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_vr, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); INPAapiResultText( steigung_einh, "STAT_SENSOR_STEIGUNG_HGLV_EINH", 1, "" ); INPAapiResultText( nullpunkt_einh, "STAT_SENSOR_NULLPKT_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } input2int( nullpunkt_vr, steigung_vr, "Höhenstandabgleich", "vorne rechts:", "Sensornullpunkt:", "Sensorsteigung:", 0, 5000 , -30000, 30000); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(nullpunkt_vr, tmpn); inttostring(steigung_vr, tmps); INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_HGLV", "2;"+tmpn+";"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if(hs_abgleichen_7 == 1) { hs_abgleichen_7 = 0; INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "3", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_hl, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_hl, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); INPAapiResultText( steigung_einh, "STAT_SENSOR_STEIGUNG_HGLV_EINH", 1, "" ); INPAapiResultText( nullpunkt_einh, "STAT_SENSOR_NULLPKT_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } input2int( nullpunkt_hl, steigung_hl, "Höhenstandabgleich", "hinten links:", "Sensornullpunkt:", "Sensorsteigung:", 0, 5000 , -30000, 30000); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(nullpunkt_hl, tmpn); inttostring(steigung_hl, tmps); INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_HGLV", "3;"+tmpn+";"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } if(hs_abgleichen_8 == 1) { hs_abgleichen_8 = 0; INPAapiJob( sgbd, "STATUS_NEUE_SENSOR_WERTE_HGLV", "4", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); if(chk_jobstatus == "OKAY") { INPAapiResultInt( steigung_vl, "STAT_SENSOR_STEIGUNG_HGLV_WERT", 1 ); INPAapiResultInt( nullpunkt_vl, "STAT_SENSOR_NULLPKT_HGLV_WERT", 1 ); INPAapiResultText( steigung_einh, "STAT_SENSOR_STEIGUNG_HGLV_EINH", 1, "" ); INPAapiResultText( nullpunkt_einh, "STAT_SENSOR_NULLPKT_HGLV_EINH", 1, "" ); } else { err_jobstatus = chk_jobstatus; } input2int( nullpunkt_hr, steigung_hr, "Höhenstandabgleich", "hinten rechts:", "Sensornullpunkt:", "Sensorsteigung:", 0, 5000 , -30000, 30000); getinputstate( input_state_key_1 ); if ( input_state_key_1 == 1 ) { // Eingabe 1 wurde mit Abbruch abgeschlossen userboxclose( 0 ); viewclose(); } // nur bei OK ausfuehren if ( input_state_key_1 == 0 ) { inttostring(nullpunkt_hr, tmpn); inttostring(steigung_hr, tmps); INPAapiJob( sgbd, "START_LERNEN_NEUE_SENSOR_WERTE_HGLV", "4;"+tmpn+";"+tmps, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) {} else if( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Wert ausserhalb zulässigen Bereichs", "" ); else { infobox ( "Fehler", "Fehlertyp: "+chk_jobstatus ); userboxclose( 0 ); viewclose(); } } } } } // *************************** // *** Stati Sensoren ARS *** // *************************** // wird ueber F6 aktiviert 'Sensoren' SCREEN s_stati_sensor() { int status_ars; real stat_alive; string text_var = ""; real zahl_var; // 5 Volt / 10bit --> 5 Volt /1024 real EinBitVoltWert = 0.0048828125; real SensorWert_VA_roh; real SensorWert_VA; real SensorWert_HA_roh; real SensorWert_HA; real SensorWert_RV_roh; real SensorWert_RV; real SensorWert_QU_roh; real SensorWert_QU; ftextout( "Status Sensoren", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); // zeigt Alive Zaehler an INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); ftextout( "SG Status", 3, 50, 0, 0 ); ftextout( ":", 3, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 3, 60, 0, 0 ); LINE( "","" ) { INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Drucksensor VA", 1, 1, 0, 0 ); ftextout( ":", 1, 35, 0, 0 ); // Ausgabe des Telegrammwertes INPAapiResultText( text_var, "STAT_DRUCK_VA_WERT", 1, "" ); ftextout( text_var, 1, 37, 0, 0 ); // Fehlertext fuer den Sensor INPAapiResultText( text_var, "STAT_DRUCK_VA_TEXT", 1, "" ); ftextout( text_var, 1, 45, 0, 0 ); ftextout( "Status Drucksensor HA", 3, 1, 0, 0 ); ftextout( ":", 3, 35, 0, 0 ); // Ausgabe des Telegrammwertes INPAapiResultText( text_var, "STAT_DRUCK_HA_WERT", 1, "" ); ftextout( text_var, 3, 37, 0, 0 ); // Fehlertext fuer den Sensor INPAapiResultText( text_var, "STAT_DRUCK_HA_TEXT", 1, "" ); ftextout( text_var, 3, 45, 0, 0 ); ftextout( "Status Schaltstellungssensor", 5, 1, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); // Ausgabe des Telegrammwertes INPAapiResultText( text_var, "STAT_POSITION_WERT", 1, "" ); ftextout( text_var, 5, 37, 0, 0 ); // Fehlertext fuer den Sensor INPAapiResultText( text_var, "STAT_POSITION_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Status Querbeschleunigungssensor", 7, 1, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHLSEN_WERT", 1, "" ); ftextout( text_var, 7, 37, 0, 0 ); // Fehlertext fuer den Sensor INPAapiResultText( text_var, "STAT_QUERBESCHLSEN_TEXT", 1, "" ); ftextout( text_var, 7, 45, 0, 0 ); //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // Ausgabe des Telegrammwertes // Druck VA ftextout( "Druck VA (Spg. Roh)", 9, 1, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_VA_SW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "3.3" , text_var ); ftextout( text_var, 9, 37, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_VA_SW_EINH", 1, "" ); ftextout( text_var, 9, 45, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_VA_HW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 9, 65, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_VA_HW_EINH", 1, "" ); ftextout( text_var, 9, 71, 0, 0 ); //////////////////////////////////////////////////////////////////////////////// // Druck HA ftextout( "Druck HA (Spg. Roh)", 11, 1, 0, 0 ); ftextout( ":", 11, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_HA_SW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "3.3" , text_var ); ftextout( text_var, 11, 37, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_HA_SW_EINH", 1, "" ); ftextout( text_var, 11, 45, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_HA_HW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 11, 65, 0, 0 ); INPAapiResultText( text_var, "STAT_DRUCK_HA_HW_EINH", 1, "" ); ftextout( text_var, 11, 71, 0, 0 ); //////////////////////////////////////////////////////////////////////////////// // Schaltstellung RV ftextout( "Schaltstellung RV (Spg. Roh)", 13, 1, 0, 0 ); ftextout( ":", 13, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_POSITION_SW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "1.0" , text_var ); ftextout( text_var, 13, 37, 0, 0 ); INPAapiResultText( text_var, "STAT_POSITION_SW_EINH", 1, "" ); ftextout( text_var, 13, 45, 0, 0 ); INPAapiResultText( text_var, "STAT_POSITION_HW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 13, 65, 0, 0 ); INPAapiResultText( text_var, "STAT_POSITION_HW_EINH", 1, "" ); ftextout( text_var, 13, 71, 0, 0 ); //////////////////////////////////////////////////////////////////////////////// // Querbeschleunigung ftextout( "Querbeschleunigung (Spg. Roh)", 15, 1, 0, 0 ); ftextout( ":", 15, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_SW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 15, 37, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_SW_EINH", 1, "" ); ftextout( text_var, 15, 45, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_HW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 15, 65, 0, 0 ); INPAapiResultText( text_var, "STAT_QUERBESCHL_HW_EINH", 1, "" ); ftextout( text_var, 15, 71, 0, 0 ); //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // Oelstand ftextout( "Oelstand (Spg. Roh)", 17, 1, 0, 0 ); ftextout( ":", 17, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_OELSTAND_SW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "1.0" , text_var ); ftextout( text_var, 17, 37, 0, 0 ); INPAapiResultText( text_var, "STAT_OELSTAND_SW_EINH", 1, "" ); ftextout( text_var, 17, 45, 0, 0 ); INPAapiResultText( text_var, "STAT_OELSTAND_HW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 17, 65, 0, 0 ); INPAapiResultText( text_var, "STAT_OELSTAND_HW_EINH", 1, "" ); ftextout( text_var, 17, 71, 0, 0 ); // Weckleitung ftextout( "Weckleitung", 19, 1, 0, 0 ); ftextout( ":", 19, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_WECKLEITUNG_HW_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); realtostring ( zahl_var, "1.0" , text_var ); ftextout( text_var, 19, 37, 0, 0 ); // Pegel INPAapiResultText( text_var, "STAT_WECKLEITUNG_HW_EINH", 1, "" ); ftextout( text_var, 19, 45, 0, 0 ); } } // **************************** // *** Stati Versorgungen *** // **************************** // wird ueber F7 aktiviert 'Versorgungen' SCREEN s_versorgungen() { int status_ars; real stat_alive; real zahl_var; string text_var = ""; ftextout( "Versorgungen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); // zeigt Alive Zaehler an INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); ftextout( "SG Status", 3, 50, 0, 0 ); ftextout( ":", 3, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 3, 60, 0, 0 ); LINE( "","" ) { INPAapiJob( sgbd, "STATUS_VERSORGUNGEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Versorgung Klemme 30 (Batterie)", 1, 1, 0, 0 ); ftextout( ":", 1, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_KLEMME30_WERT", 1, "" ); // stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 3 Nachkommastellen realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 1, 37, 0, 0 ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_KLEMME30_EINH", 1, "" ); ftextout( text_var, 1, 50, 0, 0 ); ftextout( "Versorgung Schaltstellungssensor", 3, 1, 0, 0 ); ftextout( ":", 3, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VERSORGUNG_SCHALTSEN_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 3 Nachkommastellen realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 3, 37, 0, 0 ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_VERSORGUNG_SCHALTSEN_EINH", 1, "" ); ftextout( text_var, 3, 50, 0, 0 ); ftextout( "Versorgung Drucksensor VA", 5, 1, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VERSORGUNG_VA_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 3 Nachkommastellen realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 5, 37, 0, 0 ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_VERSORGUNG_VA_EINH", 1, "" ); ftextout( text_var, 5, 50, 0, 0 ); ftextout( "Versorgung Drucksensor HA", 7, 1, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VERSORGUNG_HA_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 3 Nachkommastellen realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 7, 37, 0, 0 ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_VERSORGUNG_HA_EINH", 1, "" ); ftextout( text_var, 7, 50, 0, 0 ); ftextout( "Versorgung Querbeschleunigungssensor", 9, 1, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VERSORGUNG_QUERBESCHL_WERT", 1, "" ); stringtoreal( text_var, zahl_var ); // 2 Vorkommastellen, 3 Nachkommastellen realtostring ( zahl_var, "2.3" , text_var ); ftextout( text_var, 9, 37, 0, 0 ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_VERSORGUNG_QUERBESCHL_EINH", 1, "" ); ftextout( text_var, 9, 50, 0, 0 ); } } // ***************************** // *** Steuerscreen Anzeigen *** // ***************************** // ******************************** // *** Cockpit Auswahl Screen *** // ******************************** // wird ueber F2 aktiviert 'Cockpit' SCREEN s_cockpit() { string text_var = ""; int status_ars; real stat_alive; ftextout("Cockpit Meldungen absetzen",1,0,1,0); ftextout("",2,0,0,0); // zeigt Alive Zaehler an INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); ftextout( "SG Status", 3, 50, 0, 0 ); ftextout( ":", 3, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 3, 60, 0, 0 ); LINE("","") { ftextout( "< F1 > Ueberwachung eingeschraenkt" ,3, 5, 0, 1 ); ftextout( "< F2 > eingeschraenkter Regelkomfort" ,5, 5, 0, 1 ); ftextout( "< F3 > Fail Safe" ,7, 5, 0, 1 ); ftextout( "< F4 > Oelverlust" ,9, 5, 0, 1 ); ftextout( "< F5 > Fail Safe temporaer" ,11, 5, 0, 1 ); } } // ********************************* // *** Cockpit Meldungsanzeige *** // ********************************* SCREEN s_cockpit_anzeige() { string chk_jobstatus = ""; // Ueberwachung eingeschraenkt if ( toggle_1 == 1 ) { INPAapiJob( sgbd, "FS_SPERREN", "JA","" ); INPAapiCheckJobStatus( "OKAY" ); INPAapiJob( sgbd, "STEUERN_ARS_CHECKCONTROL", "1", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { INPAapiResultText( text_var, "CHECK_CONTROL_MELDUNG_TEXT", 1, "" ); // ( Text in der Menueleiste, auszugebender Text ) infobox ( text_var, "Meldung wurde erfolgreich ans Cockpit gesendet" ); } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); else infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); INPAapiJob( sgbd, "FS_SPERREN", "NEIN","" ); INPAapiCheckJobStatus( "OKAY" ); toggle_1 = 0; } // eingeschraaenkter Regelkomfort if ( toggle_2 == 2 ) { INPAapiJob( sgbd, "FS_SPERREN", "JA","" ); INPAapiCheckJobStatus( "OKAY" ); INPAapiJob( sgbd, "STEUERN_ARS_CHECKCONTROL", "2", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { INPAapiResultText( text_var, "CHECK_CONTROL_MELDUNG_TEXT", 1, "" ); // ( Text in der Menueleiste, auszugebender Text ) infobox ( text_var, "Meldung wurde erfolgreich ans Cockpit gesendet" ); } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); else infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); INPAapiJob( sgbd, "FS_SPERREN", "NEIN","" ); INPAapiCheckJobStatus( "OKAY" ); toggle_2 = 0; } // Fail Safe if ( toggle_3 == 3 ) { INPAapiJob( sgbd, "FS_SPERREN", "JA","" ); INPAapiCheckJobStatus( "OKAY" ); INPAapiJob( sgbd, "STEUERN_ARS_CHECKCONTROL", "3", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { INPAapiResultText( text_var, "CHECK_CONTROL_MELDUNG_TEXT", 1, "" ); // ( Text in der Menueleiste, auszugebender Text ) infobox ( text_var, "Meldung wurde erfolgreich ans Cockpit gesendet" ); } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); else infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); INPAapiJob( sgbd, "FS_SPERREN", "NEIN","" ); INPAapiCheckJobStatus( "OKAY" ); toggle_3 = 0; } // Oelverlust if ( toggle_4 == 4 ) { INPAapiJob( sgbd, "FS_SPERREN", "JA","" ); INPAapiCheckJobStatus( "OKAY" ); INPAapiJob( sgbd, "STEUERN_ARS_CHECKCONTROL", "4", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { INPAapiResultText( text_var, "CHECK_CONTROL_MELDUNG_TEXT", 1, "" ); // ( Text in der Menueleiste, auszugebender Text ) infobox ( text_var, "Meldung wurde erfolgreich ans Cockpit gesendet" ); } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); else infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); INPAapiJob( sgbd, "FS_SPERREN", "NEIN","" ); INPAapiCheckJobStatus( "OKAY" ); toggle_4 = 0; } // Fail Safe temporaer if ( toggle_5 == 5 ) { INPAapiJob( sgbd, "FS_SPERREN", "JA","" ); INPAapiCheckJobStatus( "OKAY" ); INPAapiJob( sgbd, "STEUERN_ARS_CHECKCONTROL", "5", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { INPAapiResultText( text_var, "CHECK_CONTROL_MELDUNG_TEXT", 1, "" ); // ( Text in der Menueleiste, auszugebender Text ) infobox ( text_var, "Meldung wurde erfolgreich ans Cockpit gesendet" ); } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); else infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); INPAapiJob( sgbd, "FS_SPERREN", "NEIN","" ); INPAapiCheckJobStatus( "OKAY" ); toggle_5 = 0; } setscreen( s_cockpit, TRUE ); } // ****************************** // *** Ventile Steuern *** // *** Mehrfachbestromung *** // ****************************** // wird ueber F3 aktiviert 'Ansteuern' SCREEN s_mehr_ventile_steuern() { int status_ars; bool warnung_va_erfolgt = FALSE; bool warnung_ha_erfolgt = FALSE; real stat_alive; real zahl_var; real stat_istdruck_va; real stat_istdruck_ha; real mgl_restdruck; real mgl_reststrom; real eingabe_tmp; //string strom_var = ""; string text_var = ""; string chk_jobstatus = ""; ftextout( "Simultanbestromung der Ventile SV, RV, PropVA, PropHA", 1, 0, 1, 0 ); ftextout( "", 2, 0, 1, 0 ); //////////////////////////////////////////////////////////////////////////////////////////////////// // Sicherheitsventil und Richtungsventil //////////////////////////////////////////////////////////////////////////////////////////////////// LINE( "","" ) { //////////////////////////////////////////////////////////////////////////////////////////////////// // Sicherheitsventil ftextout( "Sicherheitsventil wird dauerbestromt", 1, 0, 0, 0 ); digitalout( sv_ein_aus, 1, 30, "Ein", "Aus" ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 3, 0, 0, 0 ); ftextout( ":", 3, 22, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 3, 23, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 3, 30, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil", 5, 0, 0, 0 ); ftextout( ":", 5, 22, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 6, 0, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 6, 35, 0, 0 ); // Sicherheitsventil // Taste 'EIN' wurde gedrueckt if ( sv_ein_aus == TRUE ) { ftextout( "Nach Taste AUS wird der Strom noch 2 sec. gehalten", 9, 1, 0, 0 ); // Push Hold Ansteuerung INPAapiJob( sgbd, "STEUERN_SV_PUSHHOLD", "", "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { sv_ein_aus = TRUE; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt (SV)", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL" ); userboxclose( 0 ); viewclose(); // setscreen( s_sv_schreiben, TRUE ); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); sv_ein_aus = FALSE; } else { infobox ( "Randbedingungen wurden verletzt (SV) --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); // setscreen( s_sv_schreiben, TRUE ); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); sv_ein_aus = FALSE; } } //////////////////////////////////////////////////////////////////////////////////////////////////// // Richtungsventil ftextout( "Richtungsventil wird dauerbestromt", 1, 45, 0, 0 ); //ftextout( "", 3, 0, 0, 0 ); digitalout( rv_ein_aus, 1, 75, "Ein", "Aus" ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil", 3, 45, 0, 0 ); ftextout( ":", 3, 67, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 3, 68, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 3, 75, 0, 0 ); ftextout( "Steuerstrom Richtungsventil", 5, 45, 0, 0 ); ftextout( ":", 5, 67, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 6, 45, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 6, 80, 0, 0 ); if ( rv_ein_aus == TRUE ) { ftextout( "Nach Taste AUS wird der Strom noch 2 sec. gehalten", 9, 45, 0, 0 ); // Push Hold Ansteuerung INPAapiJob( sgbd, "STEUERN_RV_PUSHHOLD", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { rv_ein_aus = TRUE; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt (RV)", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL" ); userboxclose( 0 ); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); rv_ein_aus = FALSE; } else { infobox ( "Randbedingungen wurden verletzt (RV) --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); rv_ein_aus = FALSE; } } } //ende Line Sicherheitsventil und Richtungsventil LINE( "","" ) { ftextout( "", 0, 0, 1, 0 ); } //////////////////////////////////////////////////////////////////////////////////////////////////// // Propventil VA mit Fehlerpruefung UND // Propventil HA mit Fehlerpruefung LINE( "","" ) { // vorab alle notwendigen Grenzen berechnen: // // Roter Bereich VA abhaengig vom Istdruck HA /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); INPAapiResultAnalog( stat_istdruck_ha, "STAT_DRUCK_HA_SW_WERT", 1 ); INPAapiResultAnalog( stat_istdruck_va, "STAT_DRUCK_VA_SW_WERT", 1 ); /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); mgl_restdruck = 180; mgl_reststrom = 0.453 + (0.0069375 * (180 - stat_istdruck_ha)); //////////////////////////////////////////////////////////////////////////////////////////////////// // Propventil VA mit Fehlerpruefung ftextout( "Proportionalventil VA wird dauerbestromt", 1, 0, 0, 0 ); digitalout( PropVA_ein_aus, 1, 30, "Ein", "Aus" ); ftextout( "Status Propventil VA", 3, 0, 0, 0 ); ftextout( ":", 3, 22, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_VA_WERT", 1, "" ); ftextout( text_var, 3, 23, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_VA_TEXT", 1, "" ); ftextout( text_var, 3, 30, 0, 0 ); ftextout( "Steuerstrom Propventil VA", 5, 0, 0, 0 ); ftextout( ":", 5, 22, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); // Zl, Sp, min max Format // Beschriftungen loeschen, neu ausgeben clearrect (20,0,2,30); analogout( strom_va_ventil, 6, 0, 0, 3, 0, mgl_reststrom, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_VA_EINH", 1, "" ); ftextout( text_var, 6, 35, 0, 0 ); /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck VA ftextout( "Ist Druck VA", 9, 0, 0, 0 ); ftextout( ":", 9, 22, 0, 0 ); // Zl, Sp, min max Format analogout( stat_istdruck_va, 10, 0, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_DRUCK_VA_SW_EINH", 1, "" ); ftextout( text_var, 10, 35, 0, 0 ); /////////////////////////////////////////////////////////////////////////// // Taste 'EIN' wurde gedrueckt if ( PropVA_ein_aus == TRUE ) { ftextout( "Nach Taste AUS wird der Strom noch 2 sec. gehalten", 14, 0, 0, 0 ); if ( strom_va_1 == 1 ) { //strom_var = ""; strom_var_va = ""; // zweimaliger Aufruf wird verhindert, Eingabe darf nur einmal aufgerufen werden strom_va_1 = 0; inputint( strom_va_mA, "Proportionalventil VA", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state_VA ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state_VA == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state_VA == 0 ) { // Variablenumwandlung int --> string //inttostring( strom_va_mA, strom_var ); inttostring( strom_va_mA, strom_var_va ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state_VA == 0 ) { ftextout( "Proportionalventil VA bestromen MIT Fehlerpruefung", 13, 1, 0, 0 ); // Ventil faellt nach 2 sec wieder auf '0' Ampere zurueck // Dauerbestromung sicherstellen bei Taste 'EIN' // Strom Ausgabe mit Fehlerpruefung //INPAapiJob( sgbd, "STEUERN_PVVA_PWM_MIT_FP", strom_var, "" ); INPAapiJob( sgbd, "STEUERN_PVVA_PWM_MIT_FP", strom_var_va, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_va_1 = 0; PropVA_ein_aus = TRUE; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt (PropVA)", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); PropVA_ein_aus = FALSE; } else { infobox ( "Randbedingungen wurden verletzt (PropVA) --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); PropVA_ein_aus = FALSE; } } strom_va_1 = 0; if (( sv_ein_aus == TRUE ) && ( PropVA_ein_aus == TRUE ) && ( PropHA_ein_aus == TRUE )) { stringtoreal( strom_var_va , eingabe_tmp ); if(eingabe_tmp > (mgl_reststrom*1000)) { if(warnung_va_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil VA: Vorsicht!", "Vorgeschriebene Grenzwerte ueberschritten, "+CRLF+ "Schaedigung des Fahrwerks moeglich"); warnung_va_erfolgt = TRUE; } } else { warnung_va_erfolgt = FALSE; } } } //////////////////////////////////////////////////////////////////////////////////////////////////// // konstante Werte fuer Hinterachsgrenzen mgl_restdruck = 180 - (stat_istdruck_va - stat_istdruck_ha); mgl_reststrom = 0.453 + (0.0069375 * mgl_restdruck ); //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// // Propventil HA mit Fehlerpruefung ftextout( "Proportionalventil HA wird dauerbestromt", 1, 45, 0, 0 ); digitalout( PropHA_ein_aus, 1, 75, "Ein", "Aus" ); /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Propventil HA", 3, 45, 0, 0 ); ftextout( ":", 3, 67, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_HA_WERT", 1, "" ); ftextout( text_var, 3, 68, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_HA_TEXT", 1, "" ); ftextout( text_var, 3, 75, 0, 0 ); ftextout( "Steuerstrom Propventil HA", 5, 45, 0, 0 ); ftextout( ":", 5, 67, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); // Zl, Sp, min max Format // Beschriftungen loeschen, neu ausgeben clearrect (20,45,2,30); analogout( strom_ha_ventil, 6, 45, 0, 3, 0, mgl_reststrom, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_HA_EINH", 1, "" ); ftextout( text_var, 6, 80, 0, 0 ); /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck HA ftextout( "Ist Druck HA", 9, 45, 0, 0 ); ftextout( ":", 9, 67, 0, 0 ); // Zl, Sp, min max Format // Beschriftungen loeschen, neu ausgeben clearrect (25,45,2,30); analogout( stat_istdruck_ha, 10, 45, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_DRUCK_HA_SW_EINH", 1, "" ); ftextout( text_var, 10, 80, 0, 0 ); /////////////////////////////////////////////////////////////////////////// if ( PropHA_ein_aus == TRUE ) { ftextout( "Nach Taste AUS wird der Strom noch 2 sec. gehalten", 14, 45, 0, 0 ); if ( strom_ha_1 == 1 ) { strom_var_ha = ""; strom_ha_1 = 0; inputint( strom_ha_mA, "Proportionalventil HA", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state_HA ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state_HA == 0 ) { // Variablenumwandlung int --> string //inttostring( strom_ha_mA, strom_var ); inttostring( strom_ha_mA, strom_var_ha ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state_HA == 0 ) { ftextout( "Proportionalventil HA bestromen MIT Fehlerpruefung", 13, 45, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung //INPAapiJob( sgbd, "STEUERN_PVHA_PWM_MIT_FP", strom_var, "" ); INPAapiJob( sgbd, "STEUERN_PVHA_PWM_MIT_FP", strom_var_ha, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_ha_1 = 0; PropHA_ein_aus = TRUE; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt (PropHA)", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); PropHA_ein_aus = FALSE; } else { infobox ( "Randbedingungen wurden verletzt (PropHA) --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_steuern, TRUE ); setmenu( m_steuern ); PropHA_ein_aus = FALSE; } } strom_ha_1 = 0; if (( sv_ein_aus == TRUE ) && ( PropVA_ein_aus == TRUE ) && ( PropHA_ein_aus == TRUE )) { stringtoreal( strom_var_ha , eingabe_tmp ); if(eingabe_tmp > (mgl_reststrom*1000)) { if(warnung_ha_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil HA: Vorsicht!", "Vorgeschriebene Grenzwerte ueberschritten, "+CRLF+ "Schaedigung des Fahrwerks moeglich"); warnung_ha_erfolgt = TRUE; } } else { warnung_ha_erfolgt = FALSE; } } } //////////////////////////////////////////////////////////////////////////////////////////////////// } // Ende 'Line' PropVA und PropHA } // ****************************** // *** Ventile Steuern *** // *** Rampenlogik *** // ****************************** // wird ueber F5 aktiviert 'Ansteuern' SCREEN s_rampen_steuern() { int status_ars; real stat_alive; real zahl_var; real stat_istdruck_va; real stat_istdruck_ha; real mgl_restdruck; real mgl_reststrom; real eingabe_tmp; real r_min = 0; real r_max = 0; int int_eingabe_tmp; string text_var = ""; string text_var2 = ""; string chk_jobstatus = ""; string job_parameter = ""; string text_tmp = ""; string text_va_druck_einh = ""; string text_ha_druck_einh = ""; ftextout( "Rampenlogik fuer Ventilansteuerung", 1, 0, 1, 0 ); ftextout( "", 2, 0, 1, 0 ); //////////////////////////////////////////////////////////////////////////////////////////////////// // Sicherheitsventil und Richtungsventil //////////////////////////////////////////////////////////////////////////////////////////////////// LINE( "","" ) { //////////////////////////////////////////////////////////////////////////////////////////////////// // Sicherheitsventil ftextout( "Sicherheitsventil bei Rampe", 1, 0, 0, 0 ); digitalout( sv_ein_aus, 1, 30, "Ein", "Aus" ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 3, 0, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 3, 23, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 3, 30, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil:", 5, 0, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 6, 0, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 6, 35, 0, 0 ); //////////////////////////////////////////////////////////////////////////////////////////////////// // Richtungsventil ftextout( "Richtungsventil bei Rampe", 1, 45, 0, 0 ); //ftextout( "", 3, 0, 0, 0 ); digitalout( rv_ein_aus, 1, 75, "Ein", "Aus" ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil:", 3, 45, 0, 0 ); ftextout( ":", 3, 67, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 3, 68, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 3, 75, 0, 0 ); ftextout( "Steuerstrom Richtungsventil:", 5, 45, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 6, 45, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 6, 80, 0, 0 ); } //ende Line Sicherheitsventil und Richtungsventil LINE( "","" ) { ftextout( "", 0, 0, 1, 0 ); } //////////////////////////////////////////////////////////////////////////////////////////////////// // Propventil VA UND // Propventil HA LINE( "","" ) { // vorab alle notwendigen Grenzen berechnen: // // Roter Bereich VA abhaengig vom Istdruck HA /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); INPAapiResultAnalog( stat_istdruck_ha, "STAT_DRUCK_HA_SW_WERT", 1 ); INPAapiResultAnalog( stat_istdruck_va, "STAT_DRUCK_VA_SW_WERT", 1 ); INPAapiResultText( text_va_druck_einh, "STAT_DRUCK_VA_SW_EINH", 1, "" ); INPAapiResultText( text_ha_druck_einh, "STAT_DRUCK_HA_SW_EINH", 1, "" ); /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); mgl_restdruck = 180; mgl_reststrom = 0.453 + (0.0069375 * (180 - stat_istdruck_ha)); //////////////////////////////////////////////////////////////////////////////////////////////////// // Propventil VA ftextout( "Proportionalventil VA bei Rampe", 1, 0, 0, 0 ); digitalout( PropVA_ein_aus, 1, 30, "Ein", "Aus" ); ftextout( "Status Propventil VA:", 3, 0, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_VA_WERT", 1, "" ); ftextout( text_var, 3, 23, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_VA_TEXT", 1, "" ); ftextout( text_var, 3, 30, 0, 0 ); ftextout("Rampenzeit:", 4, 0,0,0); inttoreal(va_ramp_zeit, eingabe_tmp); eingabe_tmp= eingabe_tmp/100; realtostring( eingabe_tmp, "3.2",text_var ); strcat(text_var2, text_var, " s"); ftextout( text_var2, 4, 23,0,0); if(0 == va_ramp_art) { ftextout( "Stop ", 4, 30,0,0); } else if(1 == va_ramp_art) { ftextout("Aufwaerts ", 4, 30,0,0); } else if(2 == va_ramp_art) { ftextout("Abwaerts ", 4, 30,0,0); } else { ftextout("Ungueltig ", 4, 30,0,0); } if(0 == rampenvorgabe) { // Vorgabe ueber Strom ftextout( "Rampenobergrenze (Strom):", 5, 0, 0, 0); inttoreal(va_ramp_wert, eingabe_tmp); eingabe_tmp= eingabe_tmp/1000; realtostring( eingabe_tmp, "3.3",text_var ); ftextout( text_var, 5, 23,0,0); ftextout( "Ampere", 5,30,0,0); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (20,0,2,30); // Zl, Sp, min max Format analogout( strom_va_ventil, 6, 0, 0, 3, 0, mgl_reststrom, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_VA_EINH", 1, "" ); ftextout( text_var, 6, 35, 0, 0 ); // Ist Druck VA ftextout( "Ist Druck VA:", 8, 0, 0, 0 ); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (23,0,2,30); // Zl, Sp, min max Format analogout( stat_istdruck_va, 9, 0, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] ftextout( text_va_druck_einh, 9, 35, 0, 0 ); } else if(1 == rampenvorgabe) { // Vorgabe ueber Druck ftextout( "Rampenobergrenze (Druck):", 5, 0, 0, 0); inttoreal(va_ramp_wert, eingabe_tmp); eingabe_tmp= eingabe_tmp/10; realtostring( eingabe_tmp, "3.1",text_var ); ftextout( text_var, 5, 23,0,0); ftextout( "[bar]", 5,30,0,0); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (20,0,2,30); // Zl, Sp, min max Format analogout( stat_istdruck_va, 6, 0, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] ftextout( text_va_druck_einh, 6, 35, 0, 0 ); } else if(2 == rampenvorgabe) { // Vorgabe ueber TV ftextout( "Rampenobergrenze (Tastverhaeltnis):", 5, 0, 0, 0); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (20,0,2,30); inttoreal(va_ramp_wert, eingabe_tmp); eingabe_tmp = eingabe_tmp/10; analogout( eingabe_tmp, 6, 0, 0, 100, 0, 100, "3.3" ); // Einheit [%] ftextout( "[%]", 6, 35, 0, 0 ); } if(0 != rampenvorgabe) { // fuer Druck und TV: INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); ftextout( "Steuerstrom Propventil VA:", 8, 0, 0, 0); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (23,0,2,30); // Zl, Sp, min max Format analogout( strom_va_ventil, 9, 0, 0, 3, 0, mgl_reststrom, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_VA_EINH", 1, "" ); ftextout( text_var,9, 35, 0, 0 ); } if(2 == rampenvorgabe) { // nur bei TV: // Ist Druck VA ftextout( "Ist Druck VA:", 11, 0, 0, 0 ); // Zl, Sp, min max Format // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (26,0,2,30); analogout( stat_istdruck_va, 12, 0, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] ftextout( text_va_druck_einh, 12, 35, 0, 0 ); } /////////////////////////////////////////////////////////////////////////// // Taste 'EIN' wurde gedrueckt if ( PropVA_ein_aus == TRUE ) { if (TRUE == ramp_mode_ein_aus) { inttoreal(va_ramp_wert, eingabe_tmp); if((0 == rampenvorgabe) && (eingabe_tmp > (mgl_reststrom*1000))) { if(warnung_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil VA: Vorsicht!", "Vorgeschriebene Grenzwerte ueberschritten, "+CRLF+ "Schaedigung des Fahrwerks moeglich"); warnung_erfolgt = TRUE; } } else if((1 == rampenvorgabe) && (eingabe_tmp > (mgl_restdruck*10))) { if(warnung_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil VA: Vorsicht!", "Vorgeschriebene Grenzwerte ueberschritten, "+CRLF+ "Schaedigung des Fahrwerks moeglich"); warnung_erfolgt = TRUE; } } else if(2 == rampenvorgabe) { if(warnung_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil VA: Vorsicht!", "Keine Ueberpruefung der Grenzwerte bei Vorgabe TV"); warnung_erfolgt = TRUE; } } } } //////////////////////////////////////////////////////////////////////////////////////////////////// // konstante Werte fuer Hinterachsgrenzen mgl_restdruck = 180 - (stat_istdruck_va - stat_istdruck_ha); mgl_reststrom = 0.453 + (0.0069375 * mgl_restdruck ); //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// // Propventil HA mit Fehlerpruefung ftextout( "Proportionalventil HA bei Rampe", 1, 45, 0, 0 ); digitalout( PropHA_ein_aus, 1, 75, "Ein", "Aus" ); /////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Propventil HA:", 3, 45, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_HA_WERT", 1, "" ); ftextout( text_var, 3, 68, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_HA_TEXT", 1, "" ); ftextout( text_var, 3, 75, 0, 0 ); ftextout("Rampenzeit", 4, 45,0,0); inttoreal(ha_ramp_zeit, eingabe_tmp); eingabe_tmp= eingabe_tmp/100; realtostring( eingabe_tmp, "3.2",text_var ); strcat(text_var2, text_var, " s"); ftextout( text_var2, 4, 68,0,0); if(0 == ha_ramp_art) { ftextout( "Stop ", 4, 75,0,0); } else if(1 == ha_ramp_art) { ftextout("Aufwaerts ", 4, 75,0,0); } else if(2 == ha_ramp_art) { ftextout("Abwaerts ", 4, 75,0,0); } else { ftextout("Ungueltig ", 4, 75,0,0); } ftextout( "Rampenwert Propventil HA:", 5, 45, 0, 0); if(0 == rampenvorgabe) { // Vorgabe ueber Strom ftextout( "Rampenobergrenze (Strom):", 5, 45, 0, 0); inttoreal(ha_ramp_wert, eingabe_tmp); eingabe_tmp= eingabe_tmp/1000; realtostring( eingabe_tmp, "3.3",text_var ); ftextout( text_var, 5, 68,0,0); ftextout( "Ampere", 5,75,0,0); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (20,45,2,30); // Zl, Sp, min max Format analogout( strom_ha_ventil, 6, 45, 0, 3, 0, mgl_reststrom, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_HA_EINH", 1, "" ); ftextout( text_var, 6, 80, 0, 0 ); // Ist Druck VA ftextout( "Ist Druck HA:", 8, 45, 0, 0 ); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (23,45,2,30); // Zl, Sp, min max Format analogout( stat_istdruck_ha, 9, 45, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] ftextout( text_ha_druck_einh, 9, 80, 0, 0 ); } else if(1 == rampenvorgabe) { // Vorgabe ueber Druck ftextout( "Rampenobergrenze (Druck):", 5, 45, 0, 0); inttoreal(ha_ramp_wert, eingabe_tmp); eingabe_tmp= eingabe_tmp/10; realtostring( eingabe_tmp, "3.1",text_var ); ftextout( text_var, 5, 68,0,0); ftextout( "[bar]", 5,75,0,0); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (20,45,2,30); // Zl, Sp, min max Format analogout( stat_istdruck_ha, 6, 45, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] ftextout( text_ha_druck_einh, 6, 80, 0, 0 ); } else if(2 == rampenvorgabe) { // Vorgabe ueber TV ftextout( "Rampenobergrenze (Tastverhaeltnis):", 5, 75, 0, 0); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (20,45,2,30); inttoreal(ha_ramp_wert, eingabe_tmp); eingabe_tmp = eingabe_tmp/10; analogout( eingabe_tmp, 6, 45, 0, 100, 0, 100, "3.3" ); // Einheit [%] ftextout( "[%]", 6, 80, 0, 0 ); } if(0 != rampenvorgabe) { // fuer Druck und TV: INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); ftextout( "Steuerstrom Propventil HA:", 8, 45, 0, 0); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (23,45,2,30); // Zl, Sp, min max Format analogout( strom_ha_ventil, 9, 45, 0, 3, 0, mgl_reststrom, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_HA_EINH", 1, "" ); ftextout( text_var,9, 80, 0, 0 ); } if(2 == rampenvorgabe) { // nur bei TV: // Ist Druck HA ftextout( "Ist Druck HA:", 11, 45, 0, 0 ); // Zl, Sp, min max Format // Loeschen der Einheitentexte um 'verschmieren' zu verhindern clearrect (26,45,2,30); analogout( stat_istdruck_ha, 12, 45, -2, 250, -2, mgl_restdruck, "3.3" ); // Einheit [bar] ftextout( text_ha_druck_einh, 12, 80, 0, 0 ); } /////////////////////////////////////////////////////////////////////////// // Sicherheitsventil oder Richtungsventil if ( (sv_ein_aus == TRUE) || (rv_ein_aus == TRUE) ||(PropVA_ein_aus == TRUE) || (PropHA_ein_aus == TRUE)) { if( FALSE == ramp_mode_ein_aus ) { ftextout( "Rampe aktivieren durch + ", 14, 25, 0, 0 ); // Ansteuerung durch Rampenlogik Job spaeter } else { ftextout( "Rampenansteuerung aktiv!", 14, 30, 0, 0 ); } } // Taste 'EIN' wurde gedrueckt if ( PropHA_ein_aus == TRUE ) { if (TRUE == ramp_mode_ein_aus) { inttoreal(ha_ramp_wert, eingabe_tmp); if((0 == rampenvorgabe) && (eingabe_tmp > (mgl_reststrom*1000))) { if(warnung_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil HA: Vorsicht!", "Vorgeschriebene Grenzwerte ueberschritten, "+CRLF+ "Schaedigung des Fahrwerks moeglich"); warnung_erfolgt = TRUE; } } else if((1 == rampenvorgabe) && (eingabe_tmp > (mgl_restdruck*10))) { if(warnung_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil HA: Vorsicht!", "Vorgeschriebene Grenzwerte ueberschritten, "+CRLF+ "Schaedigung des Fahrwerks moeglich"); warnung_erfolgt = TRUE; } } else if(2 == rampenvorgabe) { if(warnung_erfolgt == FALSE) { // falls noch nicht erfolgt, dann warnung ausgeben messagebox("Proportionalventil HA: Vorsicht!", "Keine Ueberpruefung der Grenzwerte bei Vorgabe TV"); warnung_erfolgt = TRUE; } } } } // ftextout( "Nach Taste AUS wird der Strom noch 2 sec. gehalten", 14, 45, 0, 0 ); // Eigentlichen Diagnoseaufruf starten if(TRUE == ramp_mode_ein_aus) { // Parameter1: Diag Ramp Ctrl Status int_eingabe_tmp = 0; if(0==ha_ramp_art) { int_eingabe_tmp = int_eingabe_tmp + 1; } // HA Halt if(1==ha_ramp_art) { int_eingabe_tmp = int_eingabe_tmp + 4; } // HA Auf if(2==ha_ramp_art) { int_eingabe_tmp = int_eingabe_tmp + 2; } // HA Ab if(0==va_ramp_art) { int_eingabe_tmp = int_eingabe_tmp + 8; } // VA Halt if(1==va_ramp_art) { int_eingabe_tmp = int_eingabe_tmp + 32; } // VA Auf if(2==va_ramp_art) { int_eingabe_tmp = int_eingabe_tmp + 16; } // VA Ab if(4==ha_ramp_art) { int_eingabe_tmp = int_eingabe_tmp + 64; } // HA zusammen mit VA inttostring(int_eingabe_tmp, text_tmp); strcat(job_parameter, text_tmp, ";"); // Parameter2,3: Diag Ramp Time VA, HA inttostring(va_ramp_zeit, text_tmp); strcat(job_parameter, job_parameter, text_tmp); strcat(job_parameter, job_parameter, ";"); inttostring(ha_ramp_zeit, text_tmp); strcat(job_parameter, job_parameter, text_tmp); strcat(job_parameter, job_parameter, ";"); // Parameter4,5: Diag Ramp Time VA, HA inttostring(va_ramp_wert, text_tmp); strcat(job_parameter, job_parameter, text_tmp); strcat(job_parameter, job_parameter, ";"); inttostring(ha_ramp_wert, text_tmp); strcat(job_parameter, job_parameter, text_tmp); strcat(job_parameter, job_parameter, ";"); // Parameter6: Diag Ramp RV FS Status int_eingabe_tmp = 0; if(TRUE == sv_ein_aus) { int_eingabe_tmp = int_eingabe_tmp + 4; } // HA Halt if(TRUE == rv_ein_aus) { int_eingabe_tmp = int_eingabe_tmp + 16; } // HA Halt inttostring(int_eingabe_tmp, text_tmp); strcat(job_parameter, job_parameter, text_tmp); INPAapiJob( sgbd, "STEUERN_RAMPE_PARAMETER", job_parameter, "OKAY" ); // Momentan kein Errorhandling // Parameter: Status Wort int_eingabe_tmp = 8; // Rampenmode aktiv if(0==rampenvorgabe) { int_eingabe_tmp = int_eingabe_tmp + 32; } // Strom if(1==rampenvorgabe) { int_eingabe_tmp = int_eingabe_tmp + 16; } // Druck if(2==rampenvorgabe) { int_eingabe_tmp = int_eingabe_tmp + 64; } // TV inttostring(int_eingabe_tmp, job_parameter); INPAapiJob( sgbd, "STEUERN_RAMPE_DIAGSTAT_SETZEN", job_parameter, "OKAY" ); } } //////////////////////////////////////////////////////////////////////////////////////////////////// // Ende 'Line' Rampenlogik } // ****************************** // *** Ventile Steuern *** // ****************************** // wird ueber F4 aktiviert 'Steuern' SCREEN s_ventile_steuern() { int status_ars; real stat_alive; real zahl_var; string text_var = ""; ftextout( "Ventile", 1, 0, 1, 0 ); ftextout( "", 2, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_CAN_ALIVE_ARS", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "SG AliveZaehler", 3, 2, 0, 0 ); ftextout( ":", 3, 15 , 0, 0 ); INPAapiResultAnalog( stat_alive, "STAT_ALIVE_ZAEHLER_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_alive, 3, 17, 0, 15, 0, 15, "2" ); INPAapiResultText( text_var, "STAT_ALIVE_ZAEHLER_TEXT", 1, "" ); ftextout( text_var, 3, 50, 0, 0 ); ftextout( "SG Status", 5, 50, 0, 0 ); ftextout( ":", 5, 58 , 0, 0 ); INPAapiResultInt( status_ars , "STAT_ARS_WERT", 1 ); INPAapiResultText( text_var, "STAT_ARS_TEXT", 1, "" ); ftextout( text_var, 5, 60, 0, 0 ); LINE( "","" ) { ftextout( "< F4 > Sicherheitsventil bestromen" ,12, 5, 0, 1 ); ftextout( "< F5 > Richtungsventil bestromen" ,14, 5, 0, 1 ); ftextout( "< F6 > Proportionalventil VA bestromen" ,16, 5, 0, 1 ); ftextout( "< F7 > Proportionalventil HA bestromen" ,18, 5, 0, 1 ); } } // ************************************* // *** Basisscreen zur Bestromung *** // *** des Sicherheitsventils *** // ************************************* SCREEN s_sv_schreiben() { ftextout( "Sicherheitsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { ftextout( "< F1 > Sicherheitsventil bestromen MIT Fehlerpruefung(2 sec.)" ,3, 5, 0, 1 ); ftextout( "< F2 > Sicherheitsventil bestromen OHNE Fehlerpruefung(2 sec.)" ,5, 5, 0, 1 ); ftextout( "< F3 > Sicherheitsventil Hochlauf" ,7, 5, 0, 1 ); ftextout( "< F4 > Sicherheitsventil Pushhold" ,9, 5, 0, 1 ); ftextout( "< F5 > Dauerbestromung Sicherheitsventil Pushhold" ,15, 5, 0, 1 ); } } // ************************************* // *** Basisscreen zur Bestromung *** // *** des Richtungsventils *** // ************************************* SCREEN s_rv_schreiben() { ftextout( "Richtungsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { ftextout( "< F1 > Richtungsventil bestromen MIT Fehlerpruefung(2 sec.)" ,3, 5, 0, 1 ); ftextout( "< F2 > Richtungsventil bestromen OHNE Fehlerpruefung(2 sec.)" ,5, 5, 0, 1 ); ftextout( "< F3 > Richtungsventil Hochlauf" ,7, 5, 0, 1 ); ftextout( "< F4 > Richtungsventil Pushhold" ,9, 5, 0, 1 ); ftextout( "< F5 > Dauerbestromung Richtungsventil Pushhold" ,15, 5, 0, 1 ); } } // ************************************* // *** Basisscreen zur Bestromung *** // *** des Propventils VA *** // ************************************* SCREEN s_va_schreiben() { ftextout( "Proportionalventil VA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { ftextout( "< F1 > Proportionalventil VA bestromen MIT Fehlerpruefung(2 sec.)" ,3, 5, 0, 1 ); ftextout( "< F2 > Proportionalventil VA OHNE Fehlerpruefung(2 sec.)" ,5, 5, 0, 1 ); ftextout( "< F3 > Proportionalventil HA Hochlauf" ,7, 5, 0, 1 ); } } // ************************************* // *** Basisscreen zur Bestromung *** // *** des Propventils VA *** // ************************************* SCREEN s_ha_schreiben() { ftextout( "Proportionalventil HA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0 ,0 ); LINE( "","" ) { ftextout( "< F1 > Proportionalventil HA bestromen MIT Fehlerpruefung(2 sec.)" ,3, 5, 0, 1 ); ftextout( "< F2 > Proportionalventil HA OHNE Fehlerpruefung(2 sec.)" ,5, 5, 0, 1 ); ftextout( "< F3 > Proportionalventil HA Hochlauf" ,7, 5, 0, 1 ); } } // ****************************************** // *** Sicherheitsventile beschreiben *** // *** mit Fehlerpruefung *** // ****************************************** SCREEN s_sv1_ventil_schreiben() { string strom_var = ""; string text_var = ""; string chk_jobstatus = ""; ftextout( "Sicherheitsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); LINE( "","" ) { if ( strom_sv_1 == 1 ) { strom_var = ""; strom_sv_1 = 0; inputint( strom_sv_mA, "Sicherheitsventil", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_sv_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Sicherheitsventil bestromen MIT Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung INPAapiJob( sgbd, "STEUERN_SV_PWM_MIT_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_sv_1 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } } strom_sv_1 = 0; } } // ****************************************** // *** Sicherheitsventile beschreiben *** // *** ohne Fehlerpruefung *** // ****************************************** SCREEN s_sv2_ventil_schreiben() { string strom_var = ""; string text_var = ""; string chk_jobstatus = ""; ftextout( "Sicherheitsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); LINE( "","" ) { if ( strom_sv_2 == 1 ) { strom_var = ""; strom_sv_2 = 0; inputint( strom_sv_mA, "Sicherheitsventil", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_sv_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Sicherheitsventil bestromen OHNE Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe ohne Fehlerpruefung INPAapiJob( sgbd, "STEUERN_SV_PWM_OHNE_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_sv_2 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } } strom_sv_2 = 0; } } // ****************************************** // *** Sicherheitsventile beschreiben *** // *** Hochlaufpruefung *** // ****************************************** SCREEN s_sv3_ventil_schreiben() { string text_var = ""; string chk_jobstatus = ""; ftextout( "Sicherheitsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); LINE( "","" ) { if ( strom_sv_3 == 1 ) { ftextout( "Sicherheitsventil Hochlaufpruefung", 1, 1, 0, 0 ); // Hochlaufpruefung Pruefimpuls INPAapiJob( sgbd, "STEUERN_SV_HOCHLAUFPRUEFUNG", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_sv_3 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } } ftextout( "Sicherheitsventil Hochlaufpruefung", 1, 1, 0, 0 ); } } // ****************************************** // *** Sicherheitsventile beschreiben *** // *** Push Hold Ansteuerung *** // ****************************************** SCREEN s_sv4_ventil_schreiben() { string text_var = ""; string chk_jobstatus = ""; ftextout( "Sicherheitsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); LINE( "","" ) { if ( strom_sv_4 == 1 ) { ftextout( "Sicherheitsventil Push Hold Ansteuerung", 1, 1, 0, 0 ); // Push Hold Ansteuerung INPAapiJob( sgbd, "STEUERN_SV_PUSHHOLD", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_sv_4 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); } } ftextout( "Sicherheitsventil Push Hold Ansteuerung", 1, 1, 0, 0 ); } } // ****************************************** // *** Sicherheitsventile beschreiben *** // *** Push Hold Ansteuerung *** // *** Dauerbestromung *** // ****************************************** SCREEN s_sv_ventil_pushhold_dauer_schreiben() { string chk_jobstatus = ""; ftextout( "Sicherheitsventil wird dauerbestromt", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Sicherheitsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_SICHERHEITSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Sicherheitsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_sv_ventil, "STAT_STROM_SICHVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_sv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_SICHVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ftextout( "Daueransteuerung", 12, 1, 1, 0 ); digitalout( sv_ein_aus, 12, 30, "Ein", "Aus" ); LINE( "","" ) { if ( sv_ein_aus == TRUE ) { ftextout( "Nach Taste AUS wird der Strom noch 2 sec. gehalten", 1, 1, 0, 0 ); // Push Hold Ansteuerung INPAapiJob( sgbd, "STEUERN_SV_PUSHHOLD", "", "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { sv_ein_aus = TRUE; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL" ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); sv_ein_aus = FALSE; } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_sv_schreiben, TRUE ); sv_ein_aus = FALSE; } } } } // ****************************************** // *** Richtungsventil beschreiben *** // *** mit Fehlerpruefung *** // ****************************************** SCREEN s_rv1_ventil_schreiben() { string strom_var = ""; string text_var = ""; string chk_jobstatus = ""; real stat_schaltstellung_RV; real spg_rv_sensor; ftextout( "Richtungsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Richtungsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Schaltventilsensor ( RV ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Richtungsventil", 9, 5, 0, 0 ); ftextout( ":", 9, 27, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_rv_sensor, "STAT_POSITION_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_rv_sensor, 9, 30, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_POSITION_HW_EINH", 1, "" ); ftextout( text_var, 9, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Schaltstellung RV [ -1, 0, 1 ] ftextout( "Schaltstellung RV", 11, 5, 0, 0 ); ftextout( ":", 11, 27, 0, 0 ); // Schaltstellung RV auslesen INPAapiResultAnalog( stat_schaltstellung_RV, "STAT_POSITION_SW_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_schaltstellung_RV, 21, 30, -1, 1, -1, 1, "7.5" ); analogout( stat_schaltstellung_RV, 11, 30, -1.5, 1.5, -1, 1, "1" ); // Einheit [Zustand] INPAapiResultText( text_var, "STAT_POSITION_SW_EINH", 1, "" ); ftextout( text_var, 11, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_rv_1 == 1 ) { strom_var = ""; strom_rv_1 = 0; inputint( strom_rv_mA, "Richtungsventil", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_rv_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Richtungsventil bestromen MIT Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung INPAapiJob( sgbd, "STEUERN_RV_PWM_MIT_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_rv_1 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } } strom_rv_1 = 0; } } // ****************************************** // *** Richtungsventil beschreiben *** // *** mit Fehlerpruefung *** // ****************************************** SCREEN s_rv2_ventil_schreiben() { string strom_var = ""; string text_var = ""; string chk_jobstatus = ""; real spg_rv_sensor; real stat_schaltstellung_RV; ftextout( "Richtungsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Richtungsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Schaltventilsensor ( RV ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Richtungsventil", 9, 5, 0, 0 ); ftextout( ":", 9, 27, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_rv_sensor, "STAT_POSITION_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_rv_sensor, 9, 30, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_POSITION_HW_EINH", 1, "" ); ftextout( text_var, 9, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Schaltstellung RV [ -1, 0, 1 ] ftextout( "Schaltstellung RV", 11, 5, 0, 0 ); ftextout( ":", 11, 27, 0, 0 ); // Schaltstellung RV auslesen INPAapiResultAnalog( stat_schaltstellung_RV, "STAT_POSITION_SW_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_schaltstellung_RV, 21, 30, -1, 1, -1, 1, "7.5" ); analogout( stat_schaltstellung_RV, 11, 30, -1.5, 1.5, -1, 1, "1" ); // Einheit [Zustand] INPAapiResultText( text_var, "STAT_POSITION_SW_EINH", 1, "" ); ftextout( text_var, 11, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_rv_2 == 1 ) { strom_var = ""; strom_rv_2 = 0; inputint( strom_rv_mA, "Richtungsventil", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_rv_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Richtungsventil bestromen OHNE Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung INPAapiJob( sgbd, "STEUERN_RV_PWM_OHNE_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_rv_2 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } } strom_rv_2 = 0; } } // ****************************************** // *** Richtungsventil beschreiben *** // *** Hochlaufpruefung *** // ****************************************** SCREEN s_rv3_ventil_schreiben() { string text_var = ""; string chk_jobstatus = ""; real spg_rv_sensor; real stat_schaltstellung_RV; ftextout( "Richtungsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Richtungsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Schaltventilsensor ( RV ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Richtungsventil", 9, 5, 0, 0 ); ftextout( ":", 9, 27, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_rv_sensor, "STAT_POSITION_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_rv_sensor, 9, 30, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_POSITION_HW_EINH", 1, "" ); ftextout( text_var, 9, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Schaltstellung RV [ -1, 0, 1 ] ftextout( "Schaltstellung RV", 11, 5, 0, 0 ); ftextout( ":", 11, 27, 0, 0 ); // Schaltstellung RV auslesen INPAapiResultAnalog( stat_schaltstellung_RV, "STAT_POSITION_SW_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_schaltstellung_RV, 21, 30, -1, 1, -1, 1, "7.5" ); analogout( stat_schaltstellung_RV, 11, 30, -1.5, 1.5, -1, 1, "1" ); // Einheit [Zustand] INPAapiResultText( text_var, "STAT_POSITION_SW_EINH", 1, "" ); ftextout( text_var, 11, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_rv_3 == 1 ) { ftextout( "Richtungsventil Hochlaufpruefung", 1, 1, 0, 0 ); // Hochlaufpruefung Pruefimpuls INPAapiJob( sgbd, "STEUERN_RV_HOCHLAUFPRUEFUNG", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_rv_3 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } } ftextout( "Richtungsventil Hochlaufpruefung", 1, 1, 0, 0 ); } } // ****************************************** // *** Richtungsventil beschreiben *** // *** Push Hold Ansteuerung *** // ****************************************** SCREEN s_rv4_ventil_schreiben() { string text_var = ""; string chk_jobstatus = ""; real spg_rv_sensor; real stat_schaltstellung_RV; ftextout( "Richtungsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Richtungsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Schaltventilsensor ( RV ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Richtungsventil", 9, 5, 0, 0 ); ftextout( ":", 9, 27, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_rv_sensor, "STAT_POSITION_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_rv_sensor, 9, 30, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_POSITION_HW_EINH", 1, "" ); ftextout( text_var, 9, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Schaltstellung RV [ -1, 0, 1 ] ftextout( "Schaltstellung RV", 11, 5, 0, 0 ); ftextout( ":", 11, 27, 0, 0 ); // Schaltstellung RV auslesen INPAapiResultAnalog( stat_schaltstellung_RV, "STAT_POSITION_SW_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_schaltstellung_RV, 21, 30, -1, 1, -1, 1, "7.5" ); analogout( stat_schaltstellung_RV, 11, 30, -1.5, 1.5, -1, 1, "1" ); // Einheit [Zustand] INPAapiResultText( text_var, "STAT_POSITION_SW_EINH", 1, "" ); ftextout( text_var, 11, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_rv_4 == 1 ) { ftextout( "Richtungsventil Push Hold Ansteuerung", 1, 1, 0, 0 ); // Push Hold Ansteuerung INPAapiJob( sgbd, "STEUERN_RV_PUSHHOLD", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_rv_4 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); } } ftextout( "Richtungsventil Push Hold Ansteuerung", 1, 1, 0, 0 ); } } // ****************************************** // *** Richtungsventil beschreiben *** // *** Push Hold Ansteuerung *** // ****************************************** SCREEN s_rv_ventil_pushhold_dauer_schreiben() { string chk_jobstatus = ""; real spg_rv_sensor; real stat_schaltstellung_RV; ftextout( "Richtungsventil bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_SCHALTVENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Richtungsventil", 5, 5, 0, 0 ); ftextout( ":", 5, 27, 0, 0 ); INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_WERT", 1, "" ); ftextout( text_var, 5, 30, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_RICHTUNGSVENTIL_TEXT", 1, "" ); ftextout( text_var, 5, 45, 0, 0 ); ftextout( "Steuerstrom Richtungsventil", 7, 5, 0, 0 ); ftextout( ":", 7, 27, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_rv_ventil, "STAT_STROM_RICHTVENT_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_rv_ventil, 7, 30, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STROM_RICHTVENT_EINH", 1, "" ); ftextout( text_var, 7, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Schaltventilsensor ( RV ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Richtungsventil", 9, 5, 0, 0 ); ftextout( ":", 9, 27, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_rv_sensor, "STAT_POSITION_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_rv_sensor, 9, 30, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_POSITION_HW_EINH", 1, "" ); ftextout( text_var, 9, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Schaltstellung RV [ -1, 0, 1 ] ftextout( "Schaltstellung RV", 11, 5, 0, 0 ); ftextout( ":", 11, 27, 0, 0 ); // Schaltstellung RV auslesen INPAapiResultAnalog( stat_schaltstellung_RV, "STAT_POSITION_SW_WERT", 1 ); // Zl, Sp, min max Format //analogout( stat_schaltstellung_RV, 21, 30, -1, 1, -1, 1, "7.5" ); analogout( stat_schaltstellung_RV, 11, 30, -1.5, 1.5, -1, 1, "1" ); // Einheit [Zustand] INPAapiResultText( text_var, "STAT_POSITION_SW_EINH", 1, "" ); ftextout( text_var, 11, 65, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ftextout( "Daueransteuerung", 16, 1, 1, 0 ); digitalout( rv_ein_aus, 16, 30, "Ein", "Aus" ); LINE( "","" ) { if ( rv_ein_aus == TRUE ) { ftextout( "Nach Taste AUS wird der Strom noch 2 sec. gehalten", 1, 1, 0, 0 ); // Push Hold Ansteuerung INPAapiJob( sgbd, "STEUERN_RV_PUSHHOLD", "", "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { rv_ein_aus = TRUE; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL" ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); rv_ein_aus = FALSE; } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_rv_schreiben, TRUE ); rv_ein_aus = FALSE; } } } } // ****************************************** // *** Propventil VA beschreiben *** // *** mit Fehlerpruefung *** // ****************************************** SCREEN s_va1_ventil_schreiben() { string strom_var = ""; string text_var = ""; string text_var_einh = ""; string chk_jobstatus = ""; real spg_va_sensor; real stat_istdruck_ventil; ftextout( "Proportionalventil VA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Propventil VA", 5, 5, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_VA_WERT", 1, "" ); ftextout( text_var, 5, 37, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_VA_TEXT", 1, "" ); ftextout( text_var, 5, 50, 0, 0 ); ftextout( "Steuerstrom Proportionalventil VA", 7, 5, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_va_ventil, 7, 37, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_VA_EINH", 1, "" ); ftextout( text_var, 7, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Drucksensor ( VA ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Drucksensor VA", 9, 5, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_va_sensor, "STAT_DRUCK_VA_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_va_sensor, 9, 37, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_DRUCK_VA_HW_EINH", 1, "" ); ftextout( text_var, 9, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck VA ftextout( "Ist Druck VA", 11, 5, 0, 0 ); ftextout( ":", 11, 35, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_VA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 11, 37, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var_einh, "STAT_DRUCK_VA_SW_EINH", 1, "" ); ftextout( text_var_einh, 11, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_va_1 == 1 ) { strom_var = ""; strom_va_1 = 0; inputint( strom_va_mA, "Proportionalventil VA", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_va_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Proportionalventil VA bestromen MIT Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung INPAapiJob( sgbd, "STEUERN_PVVA_PWM_MIT_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_va_1 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_va_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_va_schreiben, TRUE ); } } strom_va_1 = 0; } } // ****************************************** // *** Propventil VA beschreiben *** // *** mit Fehlerpruefung *** // ****************************************** SCREEN s_va2_ventil_schreiben() { string strom_var = ""; string text_var = ""; string text_var_einh = ""; string chk_jobstatus = ""; real spg_va_sensor; real stat_istdruck_ventil; ftextout( "Proportionalventil VA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Proportionalventil VA", 5, 5, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_VA_WERT", 1, "" ); ftextout( text_var, 5, 37, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_VA_TEXT", 1, "" ); ftextout( text_var, 5, 50, 0, 0 ); ftextout( "Steuerstrom Proportionalventil VA", 7, 5, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_va_ventil, 7, 37, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_VA_EINH", 1, "" ); ftextout( text_var, 7, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Drucksensor ( VA ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Drucksensor VA", 9, 5, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_va_sensor, "STAT_DRUCK_VA_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_va_sensor, 9, 37, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_DRUCK_VA_HW_EINH", 1, "" ); ftextout( text_var, 9, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck VA ftextout( "Ist Druck VA", 11, 5, 0, 0 ); ftextout( ":", 11, 35, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_VA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 11, 37, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var_einh, "STAT_DRUCK_VA_SW_EINH", 1, "" ); ftextout( text_var_einh, 11, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_va_2 == 1 ) { strom_var = ""; strom_va_2 = 0; inputint( strom_va_mA, "Proportionalventil VA", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_va_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Proportionalventil VA bestromen OHNE Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung INPAapiJob( sgbd, "STEUERN_PVVA_PWM_OHNE_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_va_2 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_va_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_va_schreiben, TRUE ); } } strom_va_2 = 0; } } // ********************************************** // *** Proportionalventil VA beschreiben *** // *** Hochlaufpruefung *** // ********************************************** SCREEN s_va3_ventil_schreiben() { string text_var = ""; string text_var_einh = ""; string chk_jobstatus = ""; real spg_va_sensor; real stat_istdruck_ventil; ftextout( "Proportionalventil VA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Proportionalventil VA", 5, 5, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_VA_WERT", 1, "" ); ftextout( text_var, 5, 37, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_VA_TEXT", 1, "" ); ftextout( text_var, 5, 50, 0, 0 ); ftextout( "Steuerstrom Proportionalventil VA", 7, 5, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_va_ventil, "STAT_STEUERSTROM_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_va_ventil, 7, 37, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_VA_EINH", 1, "" ); ftextout( text_var, 7, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Drucksensor ( VA ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Drucksensor VA", 9, 5, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_va_sensor, "STAT_DRUCK_VA_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_va_sensor, 9, 37, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_DRUCK_VA_HW_EINH", 1, "" ); ftextout( text_var, 9, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck VA ftextout( "Ist Druck VA", 11, 5, 0, 0 ); ftextout( ":", 11, 35, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_VA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 11, 37, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var_einh, "STAT_DRUCK_VA_SW_EINH", 1, "" ); ftextout( text_var_einh, 11, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_va_3 == 1 ) { ftextout( "Proportionalventil VA Hochlaufpruefung", 1, 1, 0, 0 ); // Hochlaufpruefung Pruefimpuls INPAapiJob( sgbd, "STEUERN_PVVA_HOCHLAUFPRUEFUNG", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_va_3 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_va_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_va_schreiben, TRUE ); } } ftextout( "Proportionalventil VA Hochlaufpruefung", 1, 1, 0, 0 ); } } // ****************************************** // *** Propventil HA beschreiben *** // *** mit Fehlerpruefung *** // ****************************************** SCREEN s_ha1_ventil_schreiben() { string strom_var = ""; string text_var = ""; string text_var_einh = ""; string chk_jobstatus = ""; real spg_ha_sensor; real stat_istdruck_ventil; ftextout( "Proportionalventil HA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Propventil HA", 5, 5, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_HA_WERT", 1, "" ); ftextout( text_var, 5, 37, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_HA_TEXT", 1, "" ); ftextout( text_var, 5, 50, 0, 0 ); ftextout( "Steuerstrom Proportionalventil HA", 7, 5, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_ha_ventil, 7, 37, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_HA_EINH", 1, "" ); ftextout( text_var, 7, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Drucksensor ( HA ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Drucksensor HA", 9, 5, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_ha_sensor, "STAT_DRUCK_HA_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_ha_sensor, 9, 37, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_DRUCK_HA_HW_EINH", 1, "" ); ftextout( text_var, 9, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck HA ftextout( "Ist Druck HA", 11, 5, 0, 0 ); ftextout( ":", 11, 35, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_HA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 11, 37, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var_einh, "STAT_DRUCK_HA_SW_EINH", 1, "" ); ftextout( text_var_einh, 11, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_ha_1 == 1 ) { strom_var = ""; strom_ha_1 = 0; inputint( strom_ha_mA, "Proportionalventil HA", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_ha_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Proportionalventil HA bestromen MIT Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung INPAapiJob( sgbd, "STEUERN_PVHA_PWM_MIT_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_ha_1 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_ha_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_ha_schreiben, TRUE ); } } strom_ha_1 = 0; } } // ****************************************** // *** Propventil HA beschreiben *** // *** mit Fehlerpruefung *** // ****************************************** SCREEN s_ha2_ventil_schreiben() { string strom_var = ""; string text_var = ""; string text_var_einh = ""; string chk_jobstatus = ""; real spg_ha_sensor; real stat_istdruck_ventil; ftextout( "Proportionalventil HA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Proportionalventil HA", 5, 5, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_HA_WERT", 1, "" ); ftextout( text_var, 5, 37, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_HA_TEXT", 1, "" ); ftextout( text_var, 5, 50, 0, 0 ); ftextout( "Steuerstrom Proportionalventil HA", 7, 5, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_ha_ventil, 7, 37, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_HA_EINH", 1, "" ); ftextout( text_var, 7, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Drucksensor ( HA ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Drucksensor HA", 9, 5, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_ha_sensor, "STAT_DRUCK_HA_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_ha_sensor, 9, 37, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_DRUCK_HA_HW_EINH", 1, "" ); ftextout( text_var, 9, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck HA ftextout( "Ist Druck HA", 11, 5, 0, 0 ); ftextout( ":", 11, 35, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_HA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 11, 37, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var_einh, "STAT_DRUCK_HA_SW_EINH", 1, "" ); ftextout( text_var_einh, 11, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_ha_2 == 1 ) { strom_var = ""; strom_ha_2 = 0; inputint( strom_ha_mA, "Proportionalventil HA", "Steuerstrom in mA", 0, 3000 ); // getinputstate( input_state ); // Eingabe wurde mit Abbruch abgeschlossen if ( input_state == 1 ) { userboxclose( 0 ); viewclose(); } // Eingabe wurde mit OK abgeschlossen else if ( input_state == 0 ) { // Variablenumwandlung int --> string inttostring( strom_ha_mA, strom_var ); // Dialog schliessen userboxclose( 0 ); viewclose(); } } // nur bei OK ausfuehren if ( input_state == 0 ) { ftextout( "Proportionalventil HA bestromen OHNE Fehlerpruefung", 1, 1, 0, 0 ); // Strom Ausgabe mit Fehlerpruefung INPAapiJob( sgbd, "STEUERN_PVHA_PWM_OHNE_FP", strom_var, "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_ha_2 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_ha_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_ha_schreiben, TRUE ); } } strom_ha_2 = 0; } } // ********************************************** // *** Proportionalventil HA beschreiben *** // *** Hochlaufpruefung *** // ********************************************** SCREEN s_ha3_ventil_schreiben() { string strom_var = ""; string text_var = ""; string text_var_einh = ""; string chk_jobstatus = ""; real spg_ha_sensor; real stat_istdruck_ventil; ftextout( "Proportionalventil HA bestromen", 1, 0, 1, 0 ); ftextout( "", 3, 0, 0, 0 ); INPAapiJob( sgbd, "STATUS_PROPORTIONAL_VENTILE", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Status Proportionalventil HA", 5, 5, 0, 0 ); ftextout( ":", 5, 35, 0, 0 ); INPAapiResultText( text_var, "STAT_VENTIL_HA_WERT", 1, "" ); ftextout( text_var, 5, 37, 0, 0 ); // Einheit [Zustand (ein/aus)] INPAapiResultText( text_var, "STAT_VENTIL_HA_TEXT", 1, "" ); ftextout( text_var, 5, 50, 0, 0 ); ftextout( "Steuerstrom Proportionalventil HA", 7, 5, 0, 0 ); ftextout( ":", 7, 35, 0, 0 ); // Stromwert auslesen INPAapiResultAnalog( strom_ha_ventil, "STAT_STEUERSTROM_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( strom_ha_ventil, 7, 37, 0, 3, 0, 3, "5.3" ); // Einheit [Ampere] INPAapiResultText( text_var, "STAT_STEUERSTROM_HA_EINH", 1, "" ); ftextout( text_var, 7, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// // anzeigen der aktuell anliegenden Spannung am Drucksensor ( HA ) // umgerechneter 10 bit Wert INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Spannung am Drucksensor HA", 9, 5, 0, 0 ); ftextout( ":", 9, 35, 0, 0 ); // Spannung auslesen INPAapiResultAnalog( spg_ha_sensor, "STAT_DRUCK_HA_HW_WERT", 1 ); // Zl, Sp, min max Format analogout( spg_ha_sensor, 9, 37, 0, 6, 0, 6, "2.3" ); // Einheit [Volt] INPAapiResultText( text_var, "STAT_DRUCK_HA_HW_EINH", 1, "" ); ftextout( text_var, 9, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// INPAapiJob( sgbd, "STATUS_ARS_SENSOREN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Ist Druck HA ftextout( "Ist Druck HA", 11, 5, 0, 0 ); ftextout( ":", 11, 35, 0, 0 ); // INPAapiResultAnalog( stat_istdruck_ventil, "STAT_DRUCK_HA_SW_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_istdruck_ventil, 11, 37, -2, 250, -2, 250, "3.3" ); // Einheit [bar] INPAapiResultText( text_var_einh, "STAT_DRUCK_HA_SW_EINH", 1, "" ); ftextout( text_var_einh, 11, 70, 0, 0 ); ////////////////////////////////////////////////////////////////////////// LINE( "","" ) { if ( strom_ha_3 == 1 ) { ftextout( "Proportionalventil HA Hochlaufpruefung", 1, 1, 0, 0 ); // Hochlaufpruefung Pruefimpuls INPAapiJob( sgbd, "STEUERN_PVHA_HOCHLAUFPRUEFUNG", "", "" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { strom_ha_3 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_ha_schreiben, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_ha_schreiben, TRUE ); } } ftextout( "Proportionalventil HA Hochlaufpruefung", 1, 1, 0, 0 ); } } // *************************************** // *** Nullpunkte der Sensoren lernen *** // *** mit Grenzwertueberwachung *** // *** Anfangsbildschirm *** // *************************************** SCREEN s_nullpkt_mitGrenz_lernen() { ftextout( "MIT GRENZWERTUEBERWACHUNG" ,1, 1, 0, 1 ); ftextout( "< F1 > Arbeitsnullpunkt Drucksensor VA lernen" ,3, 5, 0, 1 ); ftextout( "< F2 > Arbeitsnullpunkt Drucksensor HA lernen" ,5, 5, 0, 1 ); ftextout( "< F3 > Arbeitsnullpunkt Querbeschleunigungssensor lernen" ,7, 5, 0, 1 ); } // *************************************** // *** Nullpunkte der Sensoren lernen *** // *** mit Grenzwertueberwachung *** // *************************************** SCREEN s_nullpkt_lernen() { real stat_offsetdruck_ventil; real stat_offsetquerbesch; string chk_jobstatus = ""; ftextout( "MIT GRENZWERTUEBERWACHUNG" ,1, 1, 0, 1 ); ftextout( "< F1 > Arbeitsnullpunkt Drucksensor VA lernen" ,3, 5, 0, 1 ); ftextout( "< F2 > Arbeitsnullpunkt Drucksensor HA lernen" ,5, 5, 0, 1 ); ftextout( "< F3 > Arbeitsnullpunkt Querbeschleunigungssensor lernen" ,7, 5, 0, 1 ); if ( toggle_1 == 1 ) { INPAapiJob( sgbd, "START_OFFSET_WERTE_VA", "", "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { // gelernter Offset Wert lesen fuer Nullpunkt Druck VA INPAapiJob( sgbd, "STATUS_OFFSET_WERTE_VA", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Druck VA ftextout( "Arbeitsnullpunkt fuer Druck VA", 10, 1, 0, 0 ); ftextout( ":", 10, 35, 0, 0 ); // INPAapiResultAnalog( stat_offsetdruck_ventil, "STAT_NULLPUNKT_OFFSET_DRUCK_VA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_offsetdruck_ventil, 10, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_NULLPUNKT_OFFSET_DRUCK_VA_EINH", 1, "" ); ftextout( text_var, 10, 75, 0, 0 ); toggle_1 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_nullpkt_mitGrenz_lernen, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_nullpkt_mitGrenz_lernen, TRUE ); } toggle_1 = 0; } if ( toggle_2 == 1 ) { INPAapiJob( sgbd, "START_OFFSET_WERTE_HA", "", "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { // gelernter Offset Wert lesen fuer Nullpunkt Druck HA INPAapiJob( sgbd, "STATUS_OFFSET_WERTE_HA", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Druck HA ftextout( "Arbeitsnullpunkt fuer Druck HA", 15, 1, 0, 0 ); ftextout( ":", 15, 35, 0, 0 ); // INPAapiResultAnalog( stat_offsetdruck_ventil, "STAT_NULLPUNKT_OFFSET_DRUCK_HA_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_offsetdruck_ventil, 15, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_NULLPUNKT_OFFSET_DRUCK_HA_EINH", 1, "" ); ftextout( text_var, 15, 75, 0, 0 ); toggle_2 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_nullpkt_mitGrenz_lernen, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_nullpkt_mitGrenz_lernen, TRUE ); } toggle_2 = 0; } if ( toggle_3 == 1 ) { INPAapiJob( sgbd, "START_OFFSET_QUERBESCH", "", "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); if ( chk_jobstatus == "OKAY" ) { // gelernter Offset Wert lesen fuer Querbeschleunigung INPAapiJob( sgbd, "STATUS_OFFSET_QUERBESCH", "", "" ); INPAapiCheckJobStatus( "OKAY" ); // Querbeschleunigung ftextout( "Arbeitsnullpunkt fuer Querbeschleunigung", 20, 1, 0, 0 ); ftextout( ":", 20, 35, 0, 0 ); // INPAapiResultAnalog( stat_offsetquerbesch, "STAT_NULLPUNKT_OFFSET_QUERBESCH_WERT", 1 ); // Zl, Sp, min max Format analogout( stat_offsetquerbesch, 20, 37, 0, 3000, 0, 3000, "5.1" ); // Einheit [bar] INPAapiResultText( text_var, "STAT_NULLPUNKT_OFFSET_QUERBESCH_EINH", 1, "" ); ftextout( text_var, 20, 75, 0, 0 ); toggle_3 = 0; } else if ( chk_jobstatus == "ERROR_ECU_CONDITIONS_NOT_CORRECT_OR_REQUEST_SEQUENCE_ERROR" ) { infobox ( "Randbedingungen wurden verletzt", "Fahrzeug muss stehen, ==> FZGgeschw. gleich NULL oder DSC inaktiv" ); userboxclose( 0 ); viewclose(); setscreen( s_nullpkt_mitGrenz_lernen, TRUE ); } else { infobox ( "Randbedingungen wurden verletzt --> unbekannter Fehlerfall", chk_jobstatus ); userboxclose( 0 ); viewclose(); setscreen( s_nullpkt_mitGrenz_lernen, TRUE ); } toggle_3 = 0; } } // *************************************************** // *** AIF UIF Felder Aktuell lesen ueber '1A 86' *** // *************************************************** // ueber Taste 'Shift F1' SCREEN s_aif_aktuell_lesen() { int offset; int temp; int aif_adresse; int spalte_beschreibung = 10; int spalte_speicherwerte = 55; int spalte_anzeigewerte = 40; int spalte_doppelpkt = 38; INPAapiJob( sgbd, "AIF_AKTUELL_LESEN", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Aktuelles AIF Info; ausgelesen ueber '1A 86'", 1, 0, 0, 1 ); ftextout( "Anzeigendarstellung", 3, spalte_doppelpkt, 0, 0 ); ftextout( "Telegrammdarstellung", 3, spalte_speicherwerte, 0, 0 ); // // // 2te Zeile 'Fahrgestellnummer'; 7 Byte ftextout( "VIN", 7, 0, 0, 0 ); ftextout( "Fahrgestellnummer", 7, spalte_beschreibung, 0, 0 ); ftextout( ":", 7, spalte_doppelpkt, 0, 0 ); INPAapiResultText( text_var, "AIF_FAHRGESTELL_NR", 1, "" ); ftextout( text_var, 7, spalte_anzeigewerte, 0, 0 ); // Speicherwerte / Telegrammdaten INPAapiResultText( text_var, "AIF_FAHRGESTELL_NR_HEX", 1, "" ); ftextout( text_var, 7, spalte_speicherwerte, 0, 0 ); // // // 3te Zeile 'Programmierdatum'; 4 Byte ftextout( "PD", 9, 0, 0, 0 ); ftextout( "Programmierdatum", 9, spalte_beschreibung, 0, 0 ); ftextout( ":", 9, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_PD_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_PROGRAMMIER_DATUM", 1, "" ); ftextout( text_var, 9, spalte_anzeigewerte, 0, 0 ); // Speicherwerte / Telegrammdaten INPAapiResultText( text_var, "AIF_PROGRAMMIER_DATUM_HEX", 1, "" ); ftextout( text_var, 9, spalte_speicherwerte, 0, 0 ); // // // 4te Zeile 'Zusammenbaunummer'; 6 Byte ftextout( "AN", 11, 0, 0, 0 ); ftextout( "Zusammenbaunummer", 11, spalte_beschreibung, 0, 0 ); ftextout( ":", 11, spalte_doppelpkt, 0, 0 ); //INPAapiJob( sgbd, "AIF_MPC555_AN_LESEN", aif_block_nr, "" ); //INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_ZUSAMMENBAU_NR", 1, "" ); ftextout( text_var, 11, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_ZUSAMMENBAU_NR_HEX", 1, "" ); ftextout( text_var, 11, spalte_speicherwerte, 0, 0 ); // // // 5te Zeile 'Codierdatensatznummer'; 6 Byte ftextout( "CDSN", 13, 0, 0, 0 ); ftextout( "Codierdatensatznummer", 13, spalte_beschreibung, 0, 0 ); ftextout( ":", 13, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_CDSN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_DATENSATZ_NR", 1, "" ); ftextout( text_var, 13, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_DATENSATZ_NR_HEX", 1, "" ); ftextout( text_var, 13, spalte_speicherwerte, 0, 0 ); // // // 6te Zeile 'Behoerdennummer'; 6 Byte ftextout( "EROTAN", 15, 0, 0, 0 ); ftextout( "Behoerdennummer/Abgasnummer", 15, spalte_beschreibung, 0, 0 ); ftextout( ":", 15, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_EROTAN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_BEHOERDEN_NR", 1, "" ); ftextout( text_var, 15, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_BEHOERDEN_NR_HEX", 1, "" ); ftextout( text_var, 15, spalte_speicherwerte, 0, 0 ); // // // 7te Zeile 'Haendlernummer'; 3 Byte ftextout( "RSCOTSN", 17, 0, 0, 0 ); ftextout( "Werkscode bzw HaendlerNr.", 17, spalte_beschreibung, 0, 0 ); ftextout( ":", 17, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_RSCOTSN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_HAENDLER_NR", 1, "" ); ftextout( text_var, 17, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_HAENDLER_NR_HEX", 1, "" ); ftextout( text_var, 17, spalte_speicherwerte, 0, 0 ); // // // 8te Zeile 'Testernummer'; 5 Byte ftextout( "RSCOTSN", 19, 0, 0, 0 ); ftextout( "Tester-SerienNr.", 19, spalte_beschreibung, 0, 0 ); ftextout( ":", 19, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_RSCOTSN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_TESTER_NR", 1, "" ); ftextout( text_var, 19, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_TESTER_NR_HEX", 1, "" ); ftextout( text_var, 19, spalte_speicherwerte, 0, 0 ); // // // 9te Zeile 'KM Stand' mit Faktor 600 multipli.; 1 Byte ftextout( "KM", 21, 0, 0, 0 ); ftextout( "km Stand bei Programmierung", 21, spalte_beschreibung, 0, 0 ); ftextout( ":", 21, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_KMPD_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_KM_STAND", 1, "" ); ftextout( text_var, 21, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_KM_STAND_HEX", 1, "" ); ftextout( text_var, 21, spalte_speicherwerte, 0, 0 ); // // // 10te Zeile 'Programmstand als Programmreferenz'; 12 Byte ftextout( "PRGREF", 23, 0, 0, 0 ); ftextout( "Programmstand als Programmreferenz", 23, spalte_beschreibung, 0, 0 ); ftextout( ":", 23, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_PRGREF_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_PROGRAMM_STAND", 1, "" ); ftextout( text_var, 23, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_PROGRAMM_STAND_HEX", 1, "" ); ftextout( text_var, 23, spalte_speicherwerte, 0, 0 ); // // // 11te Zeile 'Fahrgestellnummer lang'; 10 Byte // ftextout( "VINLONG", 25, 0, 0, 0 ); ftextout( "Fahrgestellnummer lang", 25, spalte_beschreibung, 0, 0 ); ftextout( ":", 25, spalte_doppelpkt, 0, 0 ); INPAapiResultText( text_var, "AIF_FG_NR_LANG", 1, "" ); ftextout( text_var, 25, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_FG_NR_LANG_HEX", 1, "" ); ftextout( text_var, 25, spalte_speicherwerte, 0, 0 ); // // // 12te Zeile 'Reserve'; 3 Byte ftextout( "Reserve", 27, 0, 0, 0 ); ftextout( "3 Byte Reserve bei Power PC", 27, spalte_beschreibung, 0, 0 ); ftextout( ":", 27, spalte_doppelpkt, 0, 0 ); INPAapiResultText( text_var, "AIF_RESERVE", 1, "" ); ftextout( text_var, 27, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_RESERVE_HEX", 1, "" ); ftextout( text_var, 27, spalte_speicherwerte, 0, 0 ); } // ********************************* // *** AIF UIF Felder lesen *** // ********************************* // ueber Taste 'Shift F2' SCREEN s_aif_tabelle_lesen() { int aifblocknr = 1; int offset; int belegteAIF = 0; int unbelegteAIF = 0; int ndAIF = 0; int belegt; string aif_block_nr = ""; string logische_adresse = ""; string physikalische_adresse = ""; // Spaltenheader // erste Spalte ftextout( "AIF Nr.", 1, 0, 0, 0 ); // // 2 Spalte ftextout( "freie AIF's", 1, 8, 0, 0 ); ftextout( "(0xFF)oder(0x00)", 2, 8, 0, 0 ); // // 3te Spalte ftextout( "kl. AIF", 1, 23, 0, 0 ); ftextout( "(18,0x12)", 2, 23, 0, 0 ); // // 4te Spalte ftextout( "gr. AIF", 1, 32, 0, 0 ); ftextout( "(51,0x33)", 2, 32, 0, 0 ); // // 5te Spalte ftextout( "gr. AIF PowPC", 1, 42, 0, 0 ); ftextout( "(64,0x40)", 2, 42, 0, 0 ); // // 6te Spalte ftextout( "undef. AIF", 1, 55, 0, 0 ); ftextout( "(??,0x??)", 2, 55, 0, 0 ); // // 7te Spalte 'Zusammenbaunummer' ftextout( "log. Adresse", 1, 65, 0, 0 ); // // 8te Spalte 'Codierdatensatznummer' ftextout( "phys. Adresse", 1, 75, 0, 0 ); ftextout( "----------------------------------------------------------------------------------------------------------------------------------------------------------", 3, 0, 0, 0 ); //while ( aifblocknr < 15 ) // Schleife fuer 16 AIF Felder while ( aifblocknr < 16 ) { inttostring( aifblocknr, aif_block_nr ); INPAapiJob( sgbd, "AIF_TABELLE_LESEN", aif_block_nr, "" ); INPAapiCheckJobStatus( "OKAY" ); // Zeichenkette Zeile Spalte ftextout( aif_block_nr, aifblocknr + 3, 1, 0, 0 ); // Telegrammwert in Hex --> 0x40; INPAapiResultText( text_var, "AIF_ANZ_DATEN_HEX", 1, "" ); // Dezimalwertdarstellung 0x40 hex --> 64 dez INPAapiResultInt( offset, "AIF_ANZ_DATEN", 1 ); INPAapiResultInt( belegt, "BELEGT", 1 ); if ( offset == 255 && belegt == 0 ) { // freie AIF's alle Bytes sind mit 0xFF belegt ftextout( text_var, aifblocknr + 3, 8, 0, 0 ); inttostring( offset, text_var ); ftextout( text_var, aifblocknr + 3, 15, 0, 0 ); unbelegteAIF = unbelegteAIF + 1; } else if ( offset == 18 ) { // kleines AIF nur 3 Felder belegt ( VIN, PD, AN ) ftextout( text_var, aifblocknr + 3, 23, 0, 0 ); inttostring( offset, text_var ); ftextout( text_var, aifblocknr + 3, 28, 0, 0 ); belegteAIF = belegteAIF + 1; } else if ( offset == 51 ) { // grosses AIF ftextout( text_var, aifblocknr + 3, 32, 0, 0 ); inttostring( offset, text_var ); ftextout( text_var, aifblocknr + 3, 37, 0, 0 ); belegteAIF = belegteAIF + 1; } else if ( offset == 64 ) { // grosses AIF Powewr PC belegte AIF's ftextout( text_var, aifblocknr + 3, 42, 0, 0 ); inttostring( offset, text_var ); ftextout( text_var, aifblocknr + 3, 47, 0, 0 ); belegteAIF = belegteAIF + 1; } else { // undefinierte AIF's ftextout( text_var, aifblocknr + 3, 55, 0, 0 ); inttostring( offset, text_var ); ftextout( text_var, aifblocknr + 3, 60, 0, 0 ); ndAIF = ndAIF + 1; } INPAapiResultText( logische_adresse, "LOGISCHE_ADRESSE", 1, "" ); ftextout( logische_adresse, aifblocknr + 3, 65, 0, 0 ); INPAapiResultText( physikalische_adresse, "PHYSIKALISCHE_ADRESSE", 1, "" ); ftextout( physikalische_adresse, aifblocknr + 3, 75, 0, 0 ); aifblocknr = aifblocknr + 1; } ftextout( "----------------------------------------------------------------------------------------------------------------------------------------------------------", aifblocknr + 4, 0, 0, 0 ); ftextout( "Summe", aifblocknr + 6 , 0, 0, 0 ); inttostring ( unbelegteAIF, text_var ); // Zeile Sp ftextout( text_var, aifblocknr + 6 , 8, 0, 0 ); // inttostring ( belegteAIF, text_var ); // Zeile Sp ftextout( text_var, aifblocknr + 6 , 42, 0, 0 ); // inttostring ( ndAIF, text_var ); // Zeile Sp ftextout( text_var, aifblocknr + 6 , 55, 0, 0 ); //ftextout( "Detail Info's zu jedem AIF Feld mit F1.... F4", 25 , 1, 1, 1 ); } // ************************************* // *** AIF UIF Felder Detail lesen *** // ************************************* SCREEN s_aif_detail_lesen() { int offset; int temp; int aif_adresse; int spalte_beschreibung = 10; int spalte_speicherwerte = 55; int spalte_anzeigewerte = 40; int spalte_doppelpkt = 38; string aif_block_nr = ""; inttostring( aif_nr, aif_block_nr ); // ftextout( "Anzeigendarstellung", 3, spalte_doppelpkt, 0, 0 ); ftextout( "Telegrammdarstellung", 3, spalte_speicherwerte, 0, 0 ); // // // // erste Zeile; 1 Byte ftextout( "Offset auf naechsten gueltigen Blockeintrag", 5, 0, 0, 0 ); ftextout( ":", 5, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_OFFSET_LESEN", aif_block_nr, "" ); INPAapiJob( sgbd, "AIF_TABELLE_LESEN", aif_block_nr, "" ); INPAapiCheckJobStatus( "OKAY" ); // letzter, damit aktuell gueltiger Datensatz if ( aif_nr == 0 ) { INPAapiResultInt( aif_adresse, "AIF_ADRESSE", 1 ); temp = ( aif_adresse / 64 ) + 1; inttostring( temp, aif_block_nr ); strcat( text_var, "aktueller AIF Block ", aif_block_nr ); } else strcat( text_var, "AIF Block ", aif_block_nr ); ftextout( text_var, 1, 1, 1, 1 ); // Dezimalwertdarstellung 0x40 hex --> 64 dez // Anzahl der DAten im AIF INPAapiResultInt( offset, "AIF_ANZ_DATEN", 1 ); inttostring( offset, text_var ); ftextout( text_var, 5, spalte_anzeigewerte, 0, 0 ); // Speicherwerte / Telegrammdaten INPAapiResultText( text_var, "AIF_ANZ_DATEN_HEX", 1, "" ); ftextout( text_var, 5, spalte_speicherwerte, 0, 0 ); // // // 2te Zeile 'Fahrgestellnummer'; 7 Byte ftextout( "VIN", 7, 0, 0, 0 ); ftextout( "Fahrgestellnummer", 7, spalte_beschreibung, 0, 0 ); ftextout( ":", 7, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_VIN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_FAHRGESTELL_NR", 1, "" ); ftextout( text_var, 7, spalte_anzeigewerte, 0, 0 ); // Speicherwerte / Telegrammdaten INPAapiResultText( text_var, "AIF_FAHRGESTELL_NR_HEX", 1, "" ); ftextout( text_var, 7, spalte_speicherwerte, 0, 0 ); // // // 3te Zeile 'Programmierdatum'; 4 Byte ftextout( "PD", 9, 0, 0, 0 ); ftextout( "Programmierdatum", 9, spalte_beschreibung, 0, 0 ); ftextout( ":", 9, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_PD_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_PROGRAMMIER_DATUM", 1, "" ); ftextout( text_var, 9, spalte_anzeigewerte, 0, 0 ); // Speicherwerte / Telegrammdaten INPAapiResultText( text_var, "AIF_PROGRAMMIER_DATUM_HEX", 1, "" ); ftextout( text_var, 9, spalte_speicherwerte, 0, 0 ); // // // 4te Zeile 'Zusammenbaunummer'; 6 Byte ftextout( "AN", 11, 0, 0, 0 ); ftextout( "Zusammenbaunummer", 11, spalte_beschreibung, 0, 0 ); ftextout( ":", 11, spalte_doppelpkt, 0, 0 ); //INPAapiJob( sgbd, "AIF_MPC555_AN_LESEN", aif_block_nr, "" ); //INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_ZUSAMMENBAU_NR", 1, "" ); ftextout( text_var, 11, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_ZUSAMMENBAU_NR_HEX", 1, "" ); ftextout( text_var, 11, spalte_speicherwerte, 0, 0 ); // // // 5te Zeile 'Codierdatensatznummer'; 6 Byte ftextout( "CDSN", 13, 0, 0, 0 ); ftextout( "Codierdatensatznummer", 13, spalte_beschreibung, 0, 0 ); ftextout( ":", 13, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_CDSN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_DATENSATZ_NR", 1, "" ); ftextout( text_var, 13, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_DATENSATZ_NR_HEX", 1, "" ); ftextout( text_var, 13, spalte_speicherwerte, 0, 0 ); // // // 6te Zeile 'Behoerdennummer'; 6 Byte ftextout( "EROTAN", 15, 0, 0, 0 ); ftextout( "Behoerdennummer/Abgasnummer", 15, spalte_beschreibung, 0, 0 ); ftextout( ":", 15, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_EROTAN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_BEHOERDEN_NR", 1, "" ); ftextout( text_var, 15, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_BEHOERDEN_NR_HEX", 1, "" ); ftextout( text_var, 15, spalte_speicherwerte, 0, 0 ); // // // 7te Zeile 'Haendlernummer'; 3 Byte ftextout( "RSCOTSN", 17, 0, 0, 0 ); ftextout( "Werkscode bzw HaendlerNr.", 17, spalte_beschreibung, 0, 0 ); ftextout( ":", 17, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_RSCOTSN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_HAENDLER_NR", 1, "" ); ftextout( text_var, 17, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_HAENDLER_NR_HEX", 1, "" ); ftextout( text_var, 17, spalte_speicherwerte, 0, 0 ); // // // 8te Zeile 'Testernummer'; 5 Byte ftextout( "RSCOTSN", 19, 0, 0, 0 ); ftextout( "Tester-SerienNr.", 19, spalte_beschreibung, 0, 0 ); ftextout( ":", 19, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_RSCOTSN_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_TESTER_NR", 1, "" ); ftextout( text_var, 19, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_TESTER_NR_HEX", 1, "" ); ftextout( text_var, 19, spalte_speicherwerte, 0, 0 ); // // // 9te Zeile 'KM Stand' mit Faktor 600 multipli.; 1 Byte ftextout( "KM", 21, 0, 0, 0 ); ftextout( "km Stand bei Programmierung", 21, spalte_beschreibung, 0, 0 ); ftextout( ":", 21, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_KMPD_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_KM_STAND", 1, "" ); ftextout( text_var, 21, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_KM_STAND_HEX", 1, "" ); ftextout( text_var, 21, spalte_speicherwerte, 0, 0 ); // // // 10te Zeile 'Programmstand als Programmreferenz'; 12 Byte ftextout( "PRGREF", 23, 0, 0, 0 ); ftextout( "Programmstand als Programmreferenz", 23, spalte_beschreibung, 0, 0 ); ftextout( ":", 23, spalte_doppelpkt, 0, 0 ); // INPAapiJob( sgbd, "AIF_MPC555_PRGREF_LESEN", aif_block_nr, "" ); // INPAapiCheckJobStatus( "OKAY" ); INPAapiResultText( text_var, "AIF_PROGRAMM_STAND", 1, "" ); ftextout( text_var, 23, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_PROGRAMM_STAND_HEX", 1, "" ); ftextout( text_var, 23, spalte_speicherwerte, 0, 0 ); // // // 11te Zeile 'Fahrgestellnummer lang'; 10 Byte // ftextout( "VINLONG", 25, 0, 0, 0 ); ftextout( "Fahrgestellnummer lang", 25, spalte_beschreibung, 0, 0 ); ftextout( ":", 25, spalte_doppelpkt, 0, 0 ); INPAapiResultText( text_var, "AIF_FG_NR_LANG", 1, "" ); ftextout( text_var, 25, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_FG_NR_LANG_HEX", 1, "" ); ftextout( text_var, 25, spalte_speicherwerte, 0, 0 ); // // // 12te Zeile 'Reserve'; 3 Byte ftextout( "Reserve", 27, 0, 0, 0 ); ftextout( "3 Byte Reserve bei Power PC", 27, spalte_beschreibung, 0, 0 ); ftextout( ":", 27, spalte_doppelpkt, 0, 0 ); INPAapiResultText( text_var, "AIF_RESERVE", 1, "" ); ftextout( text_var, 27, spalte_anzeigewerte, 0, 0 ); INPAapiResultText( text_var, "AIF_RESERVE_HEX", 1, "" ); ftextout( text_var, 27, spalte_speicherwerte, 0, 0 ); } // *************************************** // *** PAF DAF Indizes *** // *************************************** // ueber Taste 'Shift F3' SCREEN s_paf_daf_indizes() { string text_var_paf_ppp = ""; string text_var_paf_v = ""; string text_var_paf_bb = ""; string text_var_paf_x = ""; string text_var_paf_h = ""; string text_var_daf_d = ""; string text_var_daf_xxxx = ""; LINE( "","" ) { // Hardware Referenz auslesen INPAapiJob( sgbd, "HARDWARE_REFERENZ_LESEN_PAF_DAF", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Hardware Ref. (22 2502) ZZZ PPPx", 2, 1, 0, 0 ); ftextout( ":", 2, 40, 0, 0 ); INPAapiResultText( text_var, "HARDWARE_ZZZ", 1, "" ); ftextout( text_var, 2, 42, 0, 0 ); INPAapiResultText( text_var_paf_ppp, "HARDWARE_PPP", 1, "" ); ftextout( text_var_paf_ppp, 2, 46, 0, 0 ); INPAapiResultText( text_var, "HARDWARE_X", 1, "" ); ftextout( text_var, 2, 50, 0, 0 ); // Programm Refz. auslesen INPAapiJob( sgbd, "PROGRAMM_REFERENZ_LESEN_PAF_DAF", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Progamm Ref. (22 2503) ZZZ PPPx V BBxh", 4, 1, 0, 0 ); ftextout( ":", 4, 40, 0, 0 ); INPAapiResultText( text_var, "HARDWARE_REFERENZ", 1, "" ); ftextout( text_var, 4, 42, 0, 0 ); INPAapiResultText( text_var_paf_v, "PROGRAMM_V", 1, "" ); ftextout( text_var_paf_v, 4, 50, 0, 0 ); INPAapiResultText( text_var_paf_bb, "PROGRAMM_BB", 1, "" ); ftextout( text_var_paf_bb, 4, 52, 0, 0 ); INPAapiResultText( text_var_paf_x, "PROGRAMM_X", 1, "" ); ftextout( text_var_paf_x, 4, 56, 0, 0 ); INPAapiResultText( text_var_paf_h, "PROGRAMM_H", 1, "" ); ftextout( text_var_paf_h, 4, 58, 0, 0 ); // PAF File Namen darstellen /* ftextout( "PPP V BB x h", 11, 15, 0, 0 ); ftextout( "PAF Name: ", 12, 1, 0, 0 ); ftextout( text_var_paf_ppp, 12, 15, 0, 0 ); ftextout( text_var_paf_v, 12, 19, 0, 0 ); ftextout( text_var_paf_bb, 12, 21, 0, 0 ); ftextout( text_var_paf_x, 12, 24, 0, 0 ); ftextout( text_var_paf_h, 12, 26, 0, 0 ); */ ftextout( "PPP V BB x h", 13, 25, 1, 1 ); ftextout( "PAF Name: ", 15, 1, 1, 1 ); ftextout( text_var_paf_ppp, 15, 25, 1, 1 ); ftextout( text_var_paf_v, 15, 33, 1, 1 ); ftextout( text_var_paf_bb, 15, 37, 1, 1 ); ftextout( text_var_paf_x, 15, 43, 1, 1 ); ftextout( text_var_paf_h, 15, 46, 1, 1 ); // Daten Referenz auslesen INPAapiJob( sgbd, "DATEN_REFERENZ_LESEN_PAF_DAF", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Daten Ref. (22 2504) ZZZ PPPx V BBxh d xxxx", 8, 1, 0, 0 ); ftextout( ":", 8, 40, 0, 0 ); INPAapiResultText( text_var, "PROGRAMM_REFERENZ", 1, "" ); ftextout( text_var, 8, 42, 0, 0 ); // Hardware Referenz auslesen INPAapiJob( sgbd, "HARDWARE_REFERENZ_LESEN_PAF_DAF", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "PROGRAMMREFERENZ und DATENREFERENZ", 2, 1, 0, 1 ); ftextout( "Hardware Ref. (22 2502) ZZZ PPPx", 4, 1, 0, 0 ); ftextout( ":", 4, 40, 0, 0 ); INPAapiResultText( text_var, "HARDWARE_ZZZ", 1, "" ); ftextout( text_var, 4, 42, 0, 0 ); INPAapiResultText( text_var_paf_ppp, "HARDWARE_PPP", 1, "" ); ftextout( text_var_paf_ppp, 4, 46, 0, 0 ); INPAapiResultText( text_var, "HARDWARE_X", 1, "" ); ftextout( text_var, 4, 50, 0, 0 ); // Programm Refz. auslesen INPAapiJob( sgbd, "PROGRAMM_REFERENZ_LESEN_PAF_DAF", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Progamm Ref. (22 2503) ZZZ PPPx V BBxh", 6, 1, 0, 0 ); ftextout( ":", 6, 40, 0, 0 ); INPAapiResultText( text_var, "HARDWARE_REFERENZ", 1, "" ); ftextout( text_var, 6, 42, 0, 0 ); INPAapiResultText( text_var_paf_v, "PROGRAMM_V", 1, "" ); ftextout( text_var_paf_v, 6, 50, 0, 0 ); INPAapiResultText( text_var_paf_bb, "PROGRAMM_BB", 1, "" ); ftextout( text_var_paf_bb, 6, 52, 0, 0 ); INPAapiResultText( text_var_paf_x, "PROGRAMM_X", 1, "" ); ftextout( text_var_paf_x, 6, 56, 0, 0 ); INPAapiResultText( text_var_paf_h, "PROGRAMM_H", 1, "" ); ftextout( text_var_paf_h, 6, 58, 0, 0 ); // PAF File Namen darstellen ftextout( "PAF Name PPP V BB x h", 10, 1, 0, 0 ); ftextout( ":", 10, 20, 0, 0 ); ftextout( text_var_paf_ppp, 10, 22, 0, 0 ); ftextout( text_var_paf_v, 10, 26, 0, 0 ); ftextout( text_var_paf_bb, 10, 28, 0, 0 ); ftextout( text_var_paf_x, 10, 30, 0, 0 ); ftextout( text_var_paf_h, 10, 32, 0, 0 ); // Daten Referenz auslesen INPAapiJob( sgbd, "DATEN_REFERENZ_LESEN_PAF_DAF", "", "" ); INPAapiCheckJobStatus( "OKAY" ); ftextout( "Daten Ref. (22 2504) ZZZ PPPx V BBxh d xxxx", 8, 1, 0, 0 ); ftextout( ":", 8, 40, 0, 0 ); INPAapiResultText( text_var, "PROGRAMM_REFERENZ", 1, "" ); ftextout( text_var, 8, 42, 0, 0 ); INPAapiResultText( text_var_daf_d, "DATEN_D", 1, "" ); ftextout( text_var_daf_d, 8, 60, 0, 0 ); INPAapiResultText( text_var_daf_xxxx, "DATEN_XXXX", 1, "" ); ftextout( text_var_daf_xxxx, 8, 62, 0, 0 ); // DAF File Namen darstellen ftextout( "DAF Name V BB d xxxx", 12, 1, 0, 0 ); ftextout( ":", 12, 20, 0, 0 ); ftextout( text_var_paf_v, 12, 22, 0, 0 ); ftextout( text_var_paf_bb, 12, 24, 0, 0 ); ftextout( text_var_daf_d, 12, 26, 0, 0 ); ftextout( text_var_daf_xxxx, 12, 28, 0, 0 ); } } //// **************************************** //// *** Steuernscreen Höhenstandabgleich *** //// **************************************** //SCREEN s_steuern_abgleich_hs() //{ // int offset_vl; // int offset_vr; // int offset_hl; // int offset_hr; // real steigung_vl; // real steigung_vr; // real steigung_hl; // real steigung_hr; // real steigung_vl_phys; // real steigung_vr_phys; // real steigung_hl_phys; // real steigung_hr_phys; // int abw_vl; // int abw_vr; // int abw_hl; // int abw_hr; // string str_abw_vl; // string str_abw_vr; // string str_abw_hl; // string str_abw_hr; // string text_var= ""; // string chk_jobstatus=""; // // ftextout("Steuern Höhenstandabgleich",1,0,1,0); // ftextout("",3,0,0,0); // LINE("","") // { // ftextout("aktuelle Abgleichwerte",1,0,0,1); // // aktuelle Werte lesen // INPAapiJob( sgbd, "STATUS_OFFSET_WERTE_HGLV", "", "" ); // INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); // // // INPAapiJob( sgbd, "STATUS_ABGLEICH_HOEHENSTAND", "", "" ); // INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); // // if(chk_jobstatus == "OKAY") // { // // AD Wert Sensornullpunkt VL // ftextout( "AD-Wert Sensornullpunkt VL", 3, 1, 0, 0 ); // ftextout( ":", 3, 25, 0, 0 ); // // Wert // INPAapiResultAnalog( ad_null_vl, "STAT_AD_0_VL_WERT", 1 ); // // Zl, Sp, min max Format // analogout( ad_null_vl, 3, 27, 0, 1024, 0, 1024, "" ); // // Einheit [digits] // INPAapiResultText( text_var, "STAT_AD_0_VL_EINH", 1, "" ); // ftextout( text_var, 3, 60, 0, 0 ); // // // Steigung VL // ftextout( "Steigung VL", 5, 1, 0, 0 ); // ftextout( ":", 5, 25, 0, 0 ); // // Steigung // INPAapiResultAnalog( steigung_vl, "STAT_STEIGUNG_VL_WERT", 1 ); // // Zl, Sp, min max Format // //analogout( steigung_vl, 5, 27, -32767, 32767, -32767, 32767, "" ); // // Einheit [digits/m] // steigung_vl_phys = (steigung_vl * 5)/1023; // analogout( steigung_vl_phys, 5, 27, -200, 200, -200, 200, "3.2" ); // ftextout( "mV/mm", 5, 60, 0, 0 ); // realtostring(steigung_vl,"5.0",text_var); // ftextout( text_var, 5, 70, 0, 0 ); // INPAapiResultText( text_var, "STAT_STEIGUNG_VL_EINH", 1, "" ); // ftextout( text_var, 5, 75, 0, 0 ); // // // AD Wert Sensornullpunkt VR // ftextout( "AD-Wert Sensornullpunkt VR", 7, 1, 0, 0 ); // ftextout( ":", 7, 25, 0, 0 ); // // Wert // INPAapiResultAnalog( ad_null_vr, "STAT_AD_0_VR_WERT", 1 ); // // Zl, Sp, min max Format // analogout( ad_null_vr, 7, 27, 0, 1024, 0, 1024, "" ); // // Einheit [digits] // INPAapiResultText( text_var, "STAT_AD_0_VR_EINH", 1, "" ); // ftextout( text_var, 7, 60, 0, 0 ); // // // Steigung VR // ftextout( "Steigung VR", 9, 1, 0, 0 ); // ftextout( ":", 9, 25, 0, 0 ); // // Steigung // INPAapiResultAnalog( steigung_vr, "STAT_STEIGUNG_VR_WERT", 1 ); // // Zl, Sp, min max Format // //analogout( steigung_vr, 9, 27, -32767, 32767, -32767, 32767, "" ); // // Einheit [digits/m] // steigung_vr_phys = (steigung_vr * 5)/1023; // analogout( steigung_vr_phys, 9, 27, -200, 200, -200, 200, "3.2" ); // ftextout( "mV/mm", 9, 60, 0, 0 ); // realtostring(steigung_vr,"5.0",text_var); // ftextout( text_var, 9, 70, 0, 0 ); // INPAapiResultText( text_var, "STAT_STEIGUNG_VR_EINH", 1, "" ); // ftextout( text_var, 9, 75, 0, 0 ); // // // AD Wert Sensornullpunkt HL // ftextout( "AD-Wert Sensornullpunkt HL", 11, 1, 0, 0 ); // ftextout( ":", 11, 25, 0, 0 ); // // Wert // INPAapiResultAnalog( ad_null_hl, "STAT_AD_0_HL_WERT", 1 ); // // Zl, Sp, min max Format // analogout( ad_null_hl, 11, 27, 0, 1024, 0, 1024, "" ); // // Einheit [digits] // INPAapiResultText( text_var, "STAT_AD_0_HL_EINH", 1, "" ); // ftextout( text_var, 11, 60, 0, 0 ); // // // Steigung HL // ftextout( "Steigung HL", 13, 1, 0, 0 ); // ftextout( ":", 13, 25, 0, 0 ); // // Steigung // INPAapiResultAnalog( steigung_hl, "STAT_STEIGUNG_HL_WERT", 1 ); // // Zl, Sp, min max Format // //analogout( steigung_hl, 13, 27, -32767, 32767, -32767, 32767, "" ); // // Einheit [digits/m] // steigung_hl_phys = (steigung_hl * 5)/1023; // analogout( steigung_hl_phys, 13, 27, -200, 200, -200, 200, "3.2" ); // ftextout( "mV/mm", 13, 60, 0, 0 ); // realtostring(steigung_hl,"5.0",text_var); // ftextout( text_var, 13, 70, 0, 0 ); // INPAapiResultText( text_var, "STAT_STEIGUNG_HL_EINH", 1, "" ); // ftextout( text_var, 13, 75, 0, 0 ); // // // AD Wert Sensornullpunkt HR // ftextout( "AD-Wert Sensornullpunkt HR", 15, 1, 0, 0 ); // ftextout( ":", 15, 25, 0, 0 ); // // Wert // INPAapiResultAnalog( ad_null_hr, "STAT_AD_0_HR_WERT", 1 ); // // Zl, Sp, min max Format // analogout( ad_null_hr, 15, 27, 0, 1024, 0, 1024, "" ); // // Einheit [digits] // INPAapiResultText( text_var, "STAT_AD_0_HR_EINH", 1, "" ); // ftextout( text_var, 15, 60, 0, 0 ); // // // Steigung HR // ftextout( "Steigung HR", 17, 1, 0, 0 ); // ftextout( ":", 17, 25, 0, 0 ); // // Steigung // INPAapiResultAnalog( steigung_hr, "STAT_STEIGUNG_HR_WERT", 1 ); // // Zl, Sp, min max Format // //analogout( steigung_hr, 17, 27, -32767, 32767, -32767, 32767, "" ); // // Einheit [digits/m] // steigung_hr_phys = (steigung_hr * 5)/1023; // analogout( steigung_hr_phys, 17, 27, -200, 200, -200, 200, "3.2" ); // ftextout( "mV/mm", 17, 60, 0, 0 ); // realtostring(steigung_hr,"5.0",text_var); // ftextout( text_var, 17, 70, 0, 0 ); // INPAapiResultText( text_var, "STAT_STEIGUNG_HR_EINH", 1, "" ); // ftextout( text_var, 17, 75, 0, 0 ); // } // else if(chk_jobstatus == "ERROR: Steigung ist Null") // { // ftextout( chk_jobstatus, 2, 1, 2, 0 ); // ftextout( "Codierung prüfen", 5, 1, 2, 0 ); // } // // ftextout("aktuelle Fahrzeughöhe",20,0,0,1); // // aktuelle Werte lesen // INPAapiJob( sgbd, "STATUS_FAHRZEUGHOEHE", "", "" ); // INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, ""); // // if(chk_jobstatus == "OKAY") // { // // Wert Höhe VL // ftextout( "Höhenwert VL", 21, 1, 0, 0 ); // ftextout( ":", 21, 20, 0, 0 ); // // Wert // INPAapiResultText( text_var, "STAT_HOEHE_VL_WERT", 1, "" ); // clearrect(25,27,1,10); // ftextout( text_var, 21, 25, 0, 0 ); // // Einheit [mm] // INPAapiResultText( text_var, "STAT_HOEHE_VL_EINH", 1, "" ); // ftextout( text_var, 21, 30, 0, 0 ); // // // Wert Höhe VR // ftextout( "Höhenwert VR", 22, 1, 0, 0 ); // ftextout( ":", 22, 20, 0, 0 ); // // Wert // INPAapiResultText( text_var, "STAT_HOEHE_VR_WERT", 1, "" ); // clearrect(26,27,1,10); // ftextout( text_var, 22, 25, 0, 0 ); // // Einheit [mm] // INPAapiResultText( text_var, "STAT_HOEHE_VR_EINH", 1, "" ); // ftextout( text_var, 22, 30, 0, 0 ); // // // Wert Höhe HL // ftextout( "Höhenwert HL", 23, 1, 0, 0 ); // ftextout( ":", 23, 20, 0, 0 ); // // Wert // INPAapiResultText( text_var, "STAT_HOEHE_HL_WERT", 1, "" ); // clearrect(27,27,1,10); // ftextout( text_var, 23, 25, 0, 0 ); // // Einheit [mm] // INPAapiResultText( text_var, "STAT_HOEHE_HL_EINH", 1, "" ); // ftextout( text_var, 23, 30, 0, 0 ); // // // Wert Höhe HR // ftextout( "Höhenwert HR", 24, 1, 0, 0 ); // ftextout( ":", 24, 20, 0, 0 ); // // Wert // INPAapiResultText( text_var, "STAT_HOEHE_HR_WERT", 1, "" ); // clearrect(28,27,1,10); // ftextout( text_var, 24, 25, 0, 0 ); // // Einheit [mm] // INPAapiResultText( text_var, "STAT_HOEHE_HR_EINH", 1, "" ); // ftextout( text_var, 24, 30, 0, 0 ); // } // else if(chk_jobstatus == "ERROR: Steigung ist Null") // { // ftextout( chk_jobstatus, 2, 1, 0, 0 ); // ftextout( "Codierung prüfen", 5, 1, 2, 0 ); // } // } // // LINE( "","" ) // { // if(ABGLEICHEN == TRUE) // { // ABGLEICHEN = FALSE; // // input2int( abw_vl, abw_vr, "Höhenstandabgleich", "Abweichung Vorderachse:", "vorne links in mm:", "vorne rechts in mm:",-200, 200 , -200, 200); // getinputstate( input_state_key ); // // Eingabe wurde mit Abbruch abgeschlossen // if ( input_state_key == 1 ) // { // userboxclose( 0 ); // viewclose(); // } // // Eingabe wurde mit OK abgeschlossen // else if ( input_state_key == 0 ) // { // input2int( abw_hl, abw_hr, "Höhenstandabgleich", "Abweichung Hinterachse:", "hinten links in mm:", "hinten rechts in mm:",-200, 200 , -200, 200); // getinputstate( input_state_key_2 ); // // Eingabe 2 wurde mit Abbruch abgeschlossen // if ( input_state_key_2 == 1 ) // { // userboxclose( 0 ); // viewclose(); // } // // Eingabe 2 wurde mit OK abgeschlossen // else if ( input_state_key_2 == 0 ) // { // // Dialog schliessen // userboxclose( 0 ); // viewclose(); // } // // Dialog schliessen // userboxclose( 0 ); // viewclose(); // } // // // nur bei OK ausfuehren // if ( input_state_key == 0 // &&input_state_key_2 == 0) // { // inttostring(abw_vl, str_abw_vl); // inttostring(abw_vr, str_abw_vr); // inttostring(abw_hl, str_abw_hl); // inttostring(abw_hr, str_abw_hr); // INPAapiJob( sgbd, "STEUERN_ABGLEICH_HOEHENSTAND", str_abw_vl+";"+str_abw_vr+";"+str_abw_hl+";"+str_abw_hr, "" ); // // INPAapiResultText( chk_jobstatus, "JOB_STATUS", 1, "" ); // if ( chk_jobstatus == "OKAY" ) // { // infobox ( "Info", "Höhenstand abgeglichen"); // userboxclose( 0 ); // viewclose(); // } // else // { // infobox ( "Fehler", chk_jobstatus ); // userboxclose( 0 ); // viewclose(); // } // } // } // } // //} // -- EOF --