//********************************************************************** //* ProgrammierAblaufBeschreibungsDatei PABD //* für Flash-Prozess mit //* Muster SteuerGeräteBeschreibungsDatei SGBD //* ********************************************************************* //* History: //* 16.02.2001 rd V1.00 Freigabe der Muster PABD //* 03.04.2001 rd V1.01 TesterPresent, DNMT, ENMT Handling erweitert //* V1.01 TesterPresentHandlingSwitch neu dazu //* V1.01 Bei Wiederaufsetzen TransferExit mit Datenanzahl=0 //* 21.05.2001 rd V1.02 WiederaufsetzenSwitch neu dazu //* 11.07.2001 rd V2.00 Benötigt mindestens WinKfp Version 2.0 //* V2.00 Neue Programmierstati in FlashStatusLesen //* V2.00 Funktion SetEcuAdr neu dazu //* V2.00 Überarbeitung AIF lesen //* V2.00 Überarbeitung Datenreferenz lesen //* V2.00 Loeschzeit jetzt Wordparameter //* 03.12.2001 rj V2.10 Erweiterung um neue Prozessortypen //* Neuer Name von 00flash auf 01flash //* 18.03.2002 rj V2.11 Setzen der globalen Variable SIMULATION: //* ALt: SIMULATION = TRUE //* Neu: SIMULATION = FALSE //* 15.05.2002 Mw V3.00 Auswerten der 17-stelligen Fahrgestellnummer bei AIF_LESEN //* V3.00 Aufruf von SG_PHYS_HWNR_LESEN für die Anzeige der physik. Hardwarenummer //* V3.00 Aufruf von SG_INNENTEMP_LESEN für die Anzeige der SG-Innentemperatur //* V3.00 Erweiterung der Adressraums auf 4 Adressbytes //* 13.06.2002 Pf V3.01 Fehlerbehebung FLASH_BLOCK_LAENGE_GESAMT => Unsigned Int //* V3.01 Fehlerbehebung FLASH_SCHREIBEN_ANZAHL => Unsigned Int //* 08.08.2002 Pf V4.00 # Deaktivierung/Aktivierung des FZGBusses während der Flashprogrammierung //* # Polling Verfahren während des RESETs am Ende der Flashprogrammierung Prozess //* Funktion : "STEUERGERAETE_RESET //* # Prozessor Typ : entweder "Standard" oder "HC12D128"" //* # Wiederaufsetzen in der "Programmieren" Funktion //* Wenn 1 Fehler auftritt, flashen 2 Datenblöcke zurück //* 27.08.2002 Pf V4.01 # Boot Sektor Update : BSUTime in der PAF File gelesen. Wenn nicht vorhanden, //* ist die Null Werte gültig //* 12.11.2002 Pf V4.02 # AuffuellenSwitch: Auffuellung von Datenbloecke bis zu Maximal Block Laenge (MXBL) //* Betroffen ist die Funktion CDHGetApiJobByteData() //* 27.11.2002 Pf V4.03 # Daten Laenge Buffer beim "Flash_Loeschen" automatsich auffuellen //* //* 27.11.2002 Pf V4.04 # ENMT nach dem RESET am Ende der Programmierung nach dem Polling Verfahren geschoben //* 28.11.2002 Pf V4.05 # Polling Verfahren am Ende der Programmierung (nach dem RESET Aufruf) geloescht //* # Maximal Anzahl von Wiederaufsetzen ist parametrierbar //* 29.11.2002 Pf V4.06 # ENMT und DNMT wie in der 03Flash.ips implementiert //* # TesterPresentHandling DNMTTimerZeit = 10000 msec //* # 2 Wiederaufsetzen Verfahren sind // implementiert: //* WiederaufsetzenSwitch: nur den letzen Telegramm wird gesendet //* => NICHT MIT NEUEN Standard Core zu verwenden //* WiederaufsetzenSwitchBlock: die 2 letzten fehlerfreien Datenbloecken //* werden wiederholt //* 05.12.2002 Pf V4.07 # "SgInnenTemperaturLesen" und "SgPhysHwNrLesen" Parameter werden in dem anzupassenden //* Teil verschoben (vor "Ab hier darf....!!!") //* 19.02.2003 Pf V4.08 # Neue Implementierung der "TesterPresentHandling" Funktion //* # Auffuellung: Berücksichtigung der Länge des Puffers "Buffer": von BufferSize nach MaxData //* # Funktion TesterPresentHandling: - Nachdem die Busse geweckt wurden, warten 2000 mSek. //* damit diese auch wach sind //* - Neue Werte für TesterPresentTimerZeit = 8000 //* 21.02.2003 Pf V5.00 # Optimierung des Wiederaufsetzen- Verfahrens. Ab dieser Version wird nur ein Backup- Puffer //* kopiert und seine Reihenfolge wird mit einem boolean Flag (BufferErst_X) markiert. //* //* 06.06.2003 Pf V5.01 # DebugSwitch an FALSE gesetzt. Es werden keine Debuginformationen in error.log geschrieben //* //* 04.07.2003 KuS V5.02 # WiederaufsetzenSwitch, WiederaufsetzenBlockSwitch - Switches in den Änderbaren //* # Bereich verschoben und nach Default-Vorgabe auf FALSE gesetzt. //* //********************************************************************** // Version, Verantwortung, Steuergerätedaten string ModulName = "05FLASH"; string Revision = "5.02"; string Author = "BMW EE-11 Jusko,BMW TI-430 Drexel, ESG GmbH Forissier, Softing AEC Marziw, ESG GmbH Kurzeder"; string Comment = "Serienstand"; string SGFamilie = "RCAS2"; int SG_MAXANZAHL_AIF = 0x02; // Anzahl der Anwender-Infofelder // 0x00 Nicht zulässig // sonst Anzahl der AIF // default = 0x02 int SG_GROESSE_AIF = 0x12; // Grösse des Anwender-Infofeldes // 0x12 18 dez kleines AIF // 0x33 51 dez grosses AIF // 0x40 64 dez grosses AIF ( gilt nur für Power-Pc ) // sonst Nicht zulässig // default = 0x12 int SG_ENDEKENNUNG_AIF = 0x01; // Offset für letztes Anwender-Infofeld // 0xFE Letztes AIF nicht überschreibbar // 0x01 Letztes AIF ist überschreibbar // sonst Nicht zulässig // default = 0x01 string SG_AUTHENTISIERUNG = "Asymetrisch"; // Authentisierungsart // "Simple" // "Symetrisch" // "Asymetrisch" // "Keine" // default = "Asymetrisch" bool ProgrammUndDaten = FALSE; // TRUE wenn Programm und Daten // FALSE wenn nur Programm // default = FALSE string ProzessorTyp = "Standard"; // mögliche Werte // "Standard" // "HC12D128" Auswirkung : RequestDownload bei 0x004000, 0x008000, 0x00C000 // default = "Standard" bool AuffuellenSwitch = FALSE; // TRUE Datenblock zum Flashen wird bis zur MXBL aufgefuellt // FALSE Auffuellung Verfahren wird ausgeschaltet // default = FALSE bool SgInnenTemperaturLesen = FALSE; // TRUE Das Steuergerät unterstützt die Ausgabe der Innentemperatur // FALSE Das Steuergerät unterstützt n i c h t die Ausgabe der Innentemperatur // default = FALSE bool SgPhysHwNrLesen = FALSE; // TRUE Das Steuergerät unterstützt die Ausgabe der physikalischen Hardwarenummer // FALSE Das Steuergerät unterstützt n i c h t die Ausgabe der physikalischen Hardwarenummer // default = FALSE bool WiederaufsetzenSwitch=FALSE; // Alte Verfahren, wo nur den letzten Telegramm wiederholt wird. // TRUE Es wird im Kommunikationsfehlerfall bei Transfer Data wiederaufgesetzt // FALSE Es wird im Kommunikationsfehlerfall bei Transfer Data nicht wiederaufgesetzt // default = FALSE bool WiederaufsetzenBlockSwitch=FALSE; // Neue Verfahren, wo die beiden letzten fehlerfreien Datenbloecke wiederholt werden. // TRUE Es wird im Kommunikationsfehlerfall bei Transfer Data wiederaufgesetzt // FALSE Es wird im Kommunikationsfehlerfall bei Transfer Data nicht wiederaufgesetzt // default = FALSE //********************************************************************** //* * //* A b h i e r d a r f n i c h t s * //* * //* g e ä n d e r t w e r d e n ! ! ! * //* * //********************************************************************** int WartenNachECUProgrammMode=0; // Wartezeit nach Umschalten in den Programmiermodus in Sekunden // 0 Es wird die Resetzeit des SG abgewartet mindestens 500 ms // sonst Es wird die Zeit in Sekunden gewartet. // default = 0 bool TesterPresentHandlingSwitch=TRUE; // TRUE Es wird DNMT, TesterPresent, ENMT gesendet // FALSE Es wird kein DNMT, TesterPresent, ENMT gesendet // default = TRUE bool DebugSwitch = FALSE; // TRUE Es werden Debuginformationen in error.log geschrieben // FALSE Es werden keine Debuginformationen in error.log geschrieben // default = FALSE //********************************************************************** //* * //* Anfang des Codes * //* * //********************************************************************** #include "cabi.h" //********************************************************************** //* G l o b a l e V a r i a b l e n * //********************************************************************** bool FreibrennBlockSchreiben = FALSE; bool TesterPresentHandlingFlag = FALSE; bool SIMULATION = FALSE; int DEBUG_LEVEL= 0; //********************************************************************** //* F e h l e r n u m m e r n * //********************************************************************** int COAPI_ECU_PROG_STATUS_ERROR = 2080; // Programmierstatus fehlerhaft int COAPI_ECU_AUTHENTICATION_ERROR = 2081; // Authentisierung fehlerhaft int COAPI_ECU_FLASH_ERASE_ERROR = 2082; // Flash löschen fehlerhaft int COAPI_ECU_FLASH_REQUEST_DOWNLOAD_ERROR = 2083; // Flash Download vorbereiten fehlerhaft int COAPI_ECU_FLASH_DOWNLOAD_ERROR = 2084; // Flash Download fehlerhaft int COAPI_ECU_FLASH_TRANSFER_EXIT_ERROR = 2085; // Flash Download abschliessen fehlerhaft int COAPI_ECU_SIGNATUR_ERROR = 2086; // Signaturpruefung fehlerhaft int COAPI_ECU_READ_AIF = 2087; // AIF lesen fehlerhaft int COAPI_ECU_WRITE_AIF = 2088; // AIF schreiben fehlerhaft int COAPI_ECU_PROGRAMMING_MODE_ERROR = 2089; // Programmiermode umschalten fehlerhaft int COAPI_ECU_AUTHENTICATION_FORMAT_ERROR = 2090; // Authentisierung Formatfehler int COAPI_ECU_DATA_REFERENZ_ERROR = 2091; // Datenreferenz fehlerhaft int COAPI_PROCESSOR_TYPE_ERROR = 2099; // Prozessortyp fehlerhaft int COAPI_DEBUG_INFO = 9000; // Debuginformation in error.log //********************************************************************** //* F u n k t i o n e n * //********************************************************************** //********************************************************************** //* //* Name : OutputDebugString //* //* Funktion : Debugausgabe in Datei error.log //* //* Parameter : LineNr - ZeilenNr im PABD-File //* Level - Debugtiefe //* Info - Auszugebender Text //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** OutputDebugString(in: int LineNr, in: int Level, in: string Info) { string temp; if (DebugSwitch == TRUE) { if ((Level == DEBUG_LEVEL) || (Level == 0) || (DEBUG_LEVEL == 0)) { temp=Info; CDHSetError (COAPI_DEBUG_INFO + Level, "Debuginfo", temp, LineNr, ""); } } } //********************************************************************** //* //* Name : OutputDebugInt //* //* Funktion : Debugausgabe in Datei error.log //* //* Parameter : LineNr - ZeilenNr im PABD-File //* Level - Debugtiefe //* Info - Auszugebender Text //* Wert - Auszugebende Zahl //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** OutputDebugInt(in: int LineNr, in: int Level, in: string Info, in: int Wert) { string temp; if (DebugSwitch == TRUE) { inttostring(Wert,temp); temp=Info+": "+temp; OutputDebugString(LineNr, Level, temp); } } //********************************************************************** //* //* Name : OutputDebugBool //* //* Funktion : Debugausgabe in Datei error.log //* //* Parameter : LineNr - ZeilenNr im PABD-File //* Level - Debugtiefe //* Info - Auszugebender Text //* Wert - Auszugebender Bool-Wert //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** OutputDebugBool(in: int LineNr, in: int Level, in: string Info, in: bool Wert) { string temp; if (DebugSwitch == TRUE) { if (Wert == TRUE) temp=Info+": TRUE"; else temp=Info+": FALSE"; OutputDebugString(LineNr, Level, temp); } } //********************************************************************** //* //* Name : hexstring //* //* Funktion : Erzeugt einen 2-stelligen Hexstring //* //* Parameter : IntWert - Zahl //* //* Rueckgabe : StrWert - 2-stelliger Hexstring //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** hexstring(in: int IntWert, inout: string StrWert) { int Low, High; StrWert="??"; Low = IntWert / 16; Low = Low * 16; Low = IntWert - Low; High = IntWert / 256; High = High * 256; High = IntWert - High; High = High / 16; if (Low == 0) StrWert = "0"; else if (Low == 1) StrWert = "1"; else if (Low == 2) StrWert = "2"; else if (Low == 3) StrWert = "3"; else if (Low == 4) StrWert = "4"; else if (Low == 5) StrWert = "5"; else if (Low == 6) StrWert = "6"; else if (Low == 7) StrWert = "7"; else if (Low == 8) StrWert = "8"; else if (Low == 9) StrWert = "9"; else if (Low == 10) StrWert = "A"; else if (Low == 11) StrWert = "B"; else if (Low == 12) StrWert = "C"; else if (Low == 13) StrWert = "D"; else if (Low == 14) StrWert = "E"; else if (Low == 15) StrWert = "F"; if (High == 0) StrWert = "0" + StrWert; else if (High == 1) StrWert = "1" + StrWert; else if (High == 2) StrWert = "2" + StrWert; else if (High == 3) StrWert = "3" + StrWert; else if (High == 4) StrWert = "4" + StrWert; else if (High == 5) StrWert = "5" + StrWert; else if (High == 6) StrWert = "6" + StrWert; else if (High == 7) StrWert = "7" + StrWert; else if (High == 8) StrWert = "8" + StrWert; else if (High == 9) StrWert = "9" + StrWert; else if (High == 10) StrWert = "A" + StrWert; else if (High == 11) StrWert = "B" + StrWert; else if (High == 12) StrWert = "C" + StrWert; else if (High == 13) StrWert = "D" + StrWert; else if (High == 14) StrWert = "E" + StrWert; else if (High == 15) StrWert = "F" + StrWert; } //********************************************************************** //* //* Name : TestCDHFehler //* //* Funktion : Ueberpruefen, ob ein CDH-Fehler aufgetreten ist //* und wenn ja: Setzen der ReturnWerte und Ausstieg //* //* Parameter : FStatus - Returnwert dieser Funktion //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** TestCDHFehler( in: int FStatus ) { if ( FStatus != 0 ) { CDHSetReturnVal (FStatus); exit (); } } //********************************************************************** //* //* Name : SetCDHFehler //* //* Funktion : Setzen der ReturnWerte //* //* Parameter : CStatus - FehlerNr //* ProcName - Name der aufrufenden PABD-Funktion //* LineNr - ZeilenNr im PABD-File //* Info - SgbdName + EDIABAS-Job //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** SetCDHFehler( in: int CStatus, in: string ProcName, in: int LineNr, in: string Info ) { CDHSetError (CStatus, ModulName, ProcName, LineNr, Info); CDHSetReturnVal (CStatus); exit(); } //********************************************************************** //* //* Name : TestApiFehler //* //* Funktion : Ueberpruefen, ob bei ApiJob ein Fehler aufgetreten ist //* und wenn ja: Setzen der ReturnWerte und Ausstieg //* //* Parameter : CStatus - FehlerNr bei Fehler //* ProcName - Name der aufrufenden PABD-Funktion //* LineNr - ZeilenNr im PABD-File //* Info - SgbdName + EDIABAS-Job //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** TestApiFehler( in: int CStatus, in: string ProcName, in: int LineNr, in: string Info ) { string ApiStatusText; CDHapiResultText (ApiStatusText, "JOB_STATUS", 1, ""); if (ApiStatusText != "OKAY") { CDHSetError (CStatus, ModulName, ProcName, LineNr, Info+": "+ApiStatusText); CDHSetReturnVal (CStatus); exit(); } } //********************************************************************** //* //* Name : TestApiFehlerNoExit //* //* Funktion : Ueberpruefen, ob bei ApiJob ein Fehler aufgetreten ist //* und wenn ja: Setzen der ReturnWerte, aber kein Ausstieg //* auch nicht bei Kommunikationsfehler //* //* Parameter : CStatus - FehlerNr bei Fehler //* ProcName - Name der aufrufenden PABD-Funktion //* LineNr - ZeilenNr im PABD-File //* Info - SgbdName + EDIABAS-Job //* //* Rueckgabe : RetVal : kein Fehler 0, sonst CStatus //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 25.01.2001 rd V0.05 CDHapiResultText ersetzt durch apiResultText //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** TestApiFehlerNoExit( in: int CStatus, in: string ProcName, in: int LineNr, in: string Info, out: int RetVal) { bool rc; string ApiStatusText; string ErrorText; RetVal = 0; apiResultText (rc, ApiStatusText, "JOB_STATUS", 1, ""); if (rc==TRUE) { if (ApiStatusText != "OKAY") { CDHSetError (CStatus, ModulName, ProcName, LineNr, Info+": "+ApiStatusText); CDHSetReturnVal (CStatus); RetVal = CStatus; } } else { apiErrorText(ErrorText); CDHSetError (CStatus, ModulName, ProcName, LineNr, Info+": "+ErrorText); CDHSetReturnVal (CStatus); RetVal = CStatus; } } //********************************************************************** //* //* Name : TesterPresentHandling //* //* Funktion : Fahrzeugbus einschlafen lassen, //* Tester Present senden, //* Fahrzeugbus wieder wecken. //* //* Parameter : ProcName - Name der aufrufenden PABD-Funktion //* SgbdName - SGBD //* Ein - DNMT setzen bzw. loeschen //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 29.01.2001 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //* 30.03.2001 rd V1.01 TesterPresentHandlingSwitch neu dazu //* 19.02.2003 sj V4.08 - TesterPresentTimerZeit = 8000 //* - "settimer" wird vor dem "NORMALER_DATENVERKEHR" Job Aufruf //* aufgerufen und nicht mehr nachher //********************************************************************** TesterPresentHandling(in: string ProcName, in: string SgbdName, in:bool Ein) { int DNMTTimerNr = 1; int DNMTTimerZeit= 10000; // Zeit in ms int TesterPresentTimerNr = 2; int TesterPresentTimerZeit= 8000; // Zeit in ms bool DNMTTimerAbgelaufen; bool TesterPresentTimerAbgelaufen; int Status; if (TesterPresentHandlingSwitch == TRUE) { if (Ein==TRUE) { TesterPresentHandlingFlag=TRUE; // Aktiviert testtimer(DNMTTimerNr, DNMTTimerAbgelaufen); if (DNMTTimerAbgelaufen==TRUE) { //********************************************************************** // Fahrzeugbusse einschlafen lassen // Timer aufziehen //********************************************************************** OutputDebugString( 534, 64, "--> Disable Normal Message Transmission"); CDHapiJob (SgbdName, "NORMALER_DATENVERKEHR", "NEIN;NEIN;JA", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 536, SgbdName + ", NORMALER_DATENVERKEHR (NEIN;NEIN;JA)"); // JS settimer(DNMTTimerNr, DNMTTimerZeit); settimer(TesterPresentTimerNr, TesterPresentTimerZeit); CDHapiJob (SgbdName, "NORMALER_DATENVERKEHR", "JA;NEIN;NEIN", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 542, SgbdName + ", NORMALER_DATENVERKEHR (JA;NEIN;NEIN)"); // settimer(DNMTTimerNr, DNMTTimerZeit); // settimer(TesterPresentTimerNr, TesterPresentTimerZeit); } else { testtimer(TesterPresentTimerNr, TesterPresentTimerAbgelaufen); if (TesterPresentTimerAbgelaufen==TRUE) { //********************************************************************** // TesterPresent // Timer aufziehen //********************************************************************** OutputDebugString( 555, 64, "--> Tester Present"); // JS settimer(DNMTTimerNr, DNMTTimerZeit); settimer(TesterPresentTimerNr, TesterPresentTimerZeit); CDHapiJob (SgbdName, "DIAGNOSE_AUFRECHT", "NEIN;JA", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 561, SgbdName + ", DIAGNOSE_AUFRECHT (NEIN;JA)"); // settimer(DNMTTimerNr, DNMTTimerZeit); // settimer(TesterPresentTimerNr, TesterPresentTimerZeit); } } } else { //********************************************************************** // Fahrzeugbusse wieder wecken // Timer loeschen //********************************************************************** TesterPresentHandlingFlag=FALSE; // Deaktiviert OutputDebugString( 574, 64, "--> Enable Normal Message Transmission"); CDHapiJob (SgbdName, "NORMALER_DATENVERKEHR", "JA;NEIN;JA", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 577, SgbdName + ", NORMALER_DATENVERKEHR (JA;NEIN;JA)"); settimer(DNMTTimerNr, 0); settimer(TesterPresentTimerNr, 0); CDHDelay(2000); // JS Nachdem die Busse geweckt wurden warten damit diese auch wach sind } } } //********************************************************************** //* //* Name : Jobs //* //* Funktion : Ausgabe der unterstuetzten Jobs //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** Jobs() { string ProcName = "Jobs"; int Status; OutputDebugString( 604, 2, ProcName); CDHSetCabdPar ("JOB[1]" , "JOB_ERMITTELN" , Status); CDHSetCabdPar ("JOB[2]" , "INFO" , Status); CDHSetCabdPar ("JOB[3]" , "SG_IDENT_LESEN" , Status); CDHSetCabdPar ("JOB[4]" , "SG_AIF_LESEN" , Status); CDHSetCabdPar ("JOB[5]" , "SG_AIF_SCHREIBEN", Status); CDHSetCabdPar ("JOB[6]" , "SG_STATUS_LESEN" , Status); CDHSetCabdPar ("JOB[7]" , "SG_PROGRAMMIEREN", Status); CDHSetCabdPar ("JOB[8]" , "FEHLER_LOESCHEN" , Status); CDHSetCabdPar ("JOB[9]" , "DATEN_REFERENZ" , Status); CDHSetCabdPar ("JOB[10]" , "HW_REFERENZ" , Status); CDHSetCabdPar ("JOB[11]" , "ZIF" , Status); CDHSetCabdPar ("JOB[12]" , "ZIF_BACKUP" , Status); CDHSetCabdPar ("JOB[13]" , "U_PROG_LESEN" , Status); CDHSetCabdPar ("JOB[14]" , "GET_DIAG_PROT" , Status); CDHSetCabdPar ("JOB[15]" , "SET_DIAG_PROT" , Status); CDHSetCabdPar ("JOB[16]" , "SET_ECU_ADDRESS" , Status); CDHSetCabdPar ("JOB[17]" , "SG_INNENTEMP_LESEN" , Status); CDHSetCabdPar ("JOB[18]" , "SG_PHYS_HWNR_LESEN" , Status); CDHSetCabdPar ("JOB_ANZAHL", "18" , Status); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : UProgLesen //* //* Funktion : Dummy Job Programmierspannung auslesen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** UProgLesen() { string ProcName = "UProgLesen"; int Status; OutputDebugString( 648, 2, ProcName); CDHSetCabdPar ("U_PROG", "0.0V", Status); TestCDHFehler (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : GetDiagProt //* //* Funktion : Diagnoseprotokolle des SG lesen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** GetDiagProt() { string ProcName = "GetDiagProt"; int Status; string SgbdName; string StringResult; int ProtAnzahl; int i; string ResultName; OutputDebugString( 679, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "DIAGNOSEPROTOKOLL_LESEN", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 685, SgbdName + ", DIAGNOSEPROTOKOLL_LESEN"); CDHapiResultInt (ProtAnzahl , "DIAG_PROT_ANZAHL", 1); CDHSetCabdWordPar("DIAG_PROT_ANZAHL", ProtAnzahl , Status); OutputDebugInt ( 689, 3, "ProtAnzahl ", ProtAnzahl); i=0; while(i < ProtAnzahl ) { i = i + 1; inttostring(i,ResultName); ResultName="DIAG_PROT_NR" + ResultName; CDHapiResultText (StringResult, ResultName , 1, ""); CDHSetCabdPar (ResultName , StringResult, Status); OutputDebugString( 700, 3, ResultName+" : "+StringResult); } CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : SetDiagProt //* //* Funktion : Diagnoseprotokoll setzen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** SetDiagProt() { string ProcName = "SetDiagProt"; int Status; string SgbdName; string DiagProt; OutputDebugString( 729, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHGetCabdPar ("DIAG_PROT", DiagProt, Status); TestCDHFehler (Status); CDHapiJob(SgbdName, "DIAGNOSEPROTOKOLL_SETZEN", DiagProt, ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 738, SgbdName + ", DIAGNOSEPROTOKOLL_SETZEN (" + DiagProt + ")"); OutputDebugString( 739, 3, "DiagProt : "+DiagProt); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : SetEcuAdr //* //* Funktion : Diagnoseadresse setzen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 03.07.2001 rd V2.00 Ersterstellung //********************************************************************** SetEcuAdr() { string ProcName = "SetEcuAdr"; int Status; string SgbdName; string EcuAdr; string StringArgument; string Temp; OutputDebugString( 768, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHGetCabdPar ("ECU_ADDRESS", EcuAdr, Status); TestCDHFehler (Status); OutputDebugString( 775, 3, "EcuAdr : 0x"+EcuAdr); StringArgument="0x"+EcuAdr; inttostring(SG_MAXANZAHL_AIF, Temp); StringArgument= StringArgument + ";" + Temp; inttostring(SG_GROESSE_AIF, Temp); StringArgument= StringArgument + ";" + Temp; inttostring(SG_ENDEKENNUNG_AIF, Temp); StringArgument= StringArgument + ";" + Temp; StringArgument= StringArgument + ";" + SG_AUTHENTISIERUNG; CDHapiJob(SgbdName, "FLASH_PARAMETER_SETZEN", StringArgument, ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 787, SgbdName + ", FLASH_PARAMETER_SETZEN (" + StringArgument + ")"); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : VersionInfo //* //* Funktion : Ausgabe der PABD-VersionInfo //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** VersionInfo() { string ProcName = "VersionInfo"; int Status; OutputDebugString( 812, 2, ProcName); CDHSetCabdPar ("REVISION", Revision, Status); CDHSetCabdPar ("AUTHOR" , Author , Status); CDHSetCabdPar ("COMMENT" , Comment , Status); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : Ident //* //* Funktion : ID-Daten des SG lesen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** Ident() { string ProcName = "Ident"; int Status; string SgbdName; string StringResult; int IntResult; OutputDebugString( 843, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "IDENT", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 849, SgbdName + ", IDENT"); CDHapiResultText (StringResult , "ID_BMW_NR" , 1, ""); CDHSetCabdPar ("ID_BMW_NR" , StringResult , Status); CDHapiResultText (StringResult , "ID_HW_NR" , 1, ""); CDHSetCabdPar ("ID_HW_NR" , StringResult , Status); CDHapiResultText (StringResult , "ID_DIAG_INDEX" , 1, ""); CDHSetCabdPar ("ID_DIAG_INDEX" , StringResult , Status); CDHapiResultText (StringResult , "ID_COD_INDEX" , 1, ""); CDHSetCabdPar ("ID_COD_INDEX" , StringResult , Status); CDHapiResultText (StringResult , "ID_VAR_INDEX" , 1, ""); CDHSetCabdPar ("ID_VAR_INDEX" , StringResult , Status); CDHapiResultText (StringResult , "ID_DATUM" , 1, ""); CDHSetCabdPar ("ID_DATUM" , StringResult , Status); CDHapiResultText (StringResult , "ID_LIEF_NR" , 1, ""); CDHSetCabdPar ("ID_LIEF_NR" , StringResult , Status); CDHapiResultText (StringResult , "ID_LIEF_TEXT" , 1, ""); CDHSetCabdPar ("ID_LIEF_TEXT" , StringResult , Status); CDHapiResultText (StringResult , "ID_SW_NR_MCV" , 1, ""); CDHSetCabdPar ("ID_SW_NR_MCV" , StringResult , Status); CDHapiResultText (StringResult , "ID_SW_NR_FSV" , 1, ""); CDHSetCabdPar ("ID_SW_NR_FSV" , StringResult , Status); CDHapiResultText (StringResult , "ID_SW_NR_OSV" , 1, ""); CDHSetCabdPar ("ID_SW_NR_OSV" , StringResult , Status); CDHapiResultText (StringResult , "ID_SW_NR_RES" , 1, ""); CDHSetCabdPar ("ID_SW_NR_RES" , StringResult , Status); CDHapiResultInt (IntResult , "ID_DATUM_TAG" , 1); CDHSetCabdWordPar("ID_DATUM_TAG" , IntResult , Status); CDHapiResultInt (IntResult , "ID_DATUM_MONAT", 1); CDHSetCabdWordPar("ID_DATUM_MONAT", IntResult , Status); CDHapiResultInt (IntResult , "ID_DATUM_JAHR" , 1); CDHSetCabdWordPar("ID_DATUM_JAHR" , IntResult , Status); CDHSetCabdPar ("ID_PROD_NR" , "000000000" , Status); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : FehlerLoeschen //* //* Funktion : Fehlerspeicher loeschen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** FehlerLoeschen() { string ProcName = "FehlerLoeschen"; int Status; string SgbdName; string StringResult; int IntResult; OutputDebugString( 925, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "FS_LOESCHEN", "", ""); TestApiFehler (COAPI_ECU_DELETE_DTC_ERROR, ProcName, 931, SgbdName + ", FS_LOESCHEN"); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : AifLesen //* //* Funktion : erste freie AIF-Adresse und Anzahl freie AIF-Eintraege //* des SGs sowie alle Daten des aktuellen Aifs //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //* 03.07.2001 rd V2.00 Überarbeitung für Letztes AIF ist überschreibbar //********************************************************************** AifLesen() { string ProcName = "AifLesen"; int Status; string SgbdName; string AifNr; string StringResult; int IntResult; int AifAnzFrei; OutputDebugString( 964, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHGetCabdPar ("AIF_NUMMER", AifNr, Status); TestCDHFehler (Status); CDHapiJob(SgbdName, "AIF_LESEN", AifNr, ""); TestApiFehler (COAPI_ECU_READ_AIF, ProcName, 973, SgbdName + ", AIF_LESEN"); CDHapiResultInt (IntResult , "AIF_GROESSE" , 1); CDHSetCabdWordPar("AIF_GROESSE" , IntResult , Status); CDHapiResultInt (IntResult , "AIF_ADRESSE_LOW" , 1); CDHSetCabdWordPar("AIF_ADRESSE_LOW" , IntResult , Status); CDHapiResultInt (IntResult , "AIF_ADRESSE_HIGH", 1); CDHSetCabdWordPar("AIF_ADRESSE_HIGH", IntResult , Status); CDHapiResultInt (AifAnzFrei , "AIF_ANZ_FREI" , 1); // Letztes AIF ist überschreibbar if (SG_ENDEKENNUNG_AIF == 0x01 && AifAnzFrei == 1 && AifNr != "0") { inttostring(SG_MAXANZAHL_AIF, StringResult); if (StringResult == AifNr) AifAnzFrei=0; } CDHSetCabdWordPar("AIF_ANZ_FREI" , AifAnzFrei , Status); CDHapiResultText (StringResult , "AIF_FG_NR_LANG" , 1, ""); CDHSetCabdPar ("AIF_FG_NR" , StringResult , Status); CDHapiResultText (StringResult , "AIF_DATUM" , 1, ""); CDHSetCabdPar ("AIF_DATUM" , StringResult , Status); CDHapiResultText (StringResult , "AIF_SW_NR" , 1, ""); CDHSetCabdPar ("AIF_SW_NR" , StringResult , Status); CDHapiResultText (StringResult , "AIF_BEHOERDEN_NR", 1, ""); CDHSetCabdPar ("AIF_BEHOERDEN_NR", StringResult , Status); CDHapiResultText (StringResult , "AIF_ZB_NR" , 1, ""); CDHSetCabdPar ("AIF_ZB_NR" , StringResult , Status); CDHapiResultText (StringResult , "AIF_SERIEN_NR" , 1, ""); CDHSetCabdPar ("AIF_SERIEN_NR" , StringResult , Status); CDHapiResultText (StringResult , "AIF_HAENDLER_NR" , 1, ""); CDHSetCabdPar ("AIF_HAENDLER_NR" , StringResult , Status); CDHapiResultText (StringResult , "AIF_KM" , 1, ""); CDHSetCabdPar ("AIF_KM" , StringResult , Status); CDHapiResultText (StringResult , "AIF_PROG_NR" , 1, ""); CDHSetCabdPar ("AIF_PROG_NR" , StringResult , Status); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : HwReferenzLesen //* //* Funktion : HW-Referenz lesen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** HwReferenzLesen() { string ProcName = "HwReferenzLesen"; int Status; string SgbdName; string StringResult; int IntResult; OutputDebugString( 1047, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "HARDWARE_REFERENZ_LESEN", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1053, SgbdName + ", HARDWARE_REFERENZ_LESEN"); CDHapiResultInt (IntResult , "HW_REF_STATUS" , 1); CDHSetCabdWordPar("HW_REF_STATUS" , IntResult , Status); CDHapiResultText (StringResult , "HW_REF_SG_KENNUNG", 1, ""); CDHSetCabdPar ("HW_REF_SG_KENNUNG", StringResult , Status); CDHapiResultText (StringResult , "HW_REF_PROJEKT" , 1, ""); CDHSetCabdPar ("HW_REF_PROJEKT" , StringResult , Status); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : DatenReferenzLesen //* //* Funktion : Daten-Referenz lesen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //* 03.07.2001 rd V2.00 Überarbeitung ERROR_NO_DREF //********************************************************************** DatenReferenzLesen() { string ProcName = "DatenReferenzLesen"; int Status; string SgbdName; string StringResult; int IntResult; bool rc; OutputDebugString( 1093, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "DATEN_REFERENZ_LESEN", "", ""); apiResultText (rc, StringResult, "JOB_STATUS", 1, ""); if (rc==TRUE) { if (StringResult == "OKAY") { CDHapiResultInt (IntResult , "DATEN_REF_STATUS" , 1); CDHSetCabdWordPar("DATEN_REF_STATUS" , IntResult , Status); CDHapiResultText (StringResult , "DATEN_REF_SG_KENNUNG" , 1, ""); CDHSetCabdPar ("DATEN_REF_SG_KENNUNG" , StringResult , Status); CDHapiResultText (StringResult , "DATEN_REF_PROJEKT" , 1, ""); CDHSetCabdPar ("DATEN_REF_PROJEKT" , StringResult , Status); CDHapiResultText (StringResult , "DATEN_REF_PROGRAMM_STAND", 1, ""); CDHSetCabdPar ("DATEN_REF_PROGRAMM_STAND", StringResult , Status); CDHapiResultText (StringResult , "DATEN_REF_DATENSATZ" , 1, ""); CDHSetCabdPar ("DATEN_REF_DATENSATZ" , StringResult , Status); } else { if (StringResult == "ERROR_NO_DREF") { CDHSetCabdWordPar("DATEN_REF_STATUS" , 0 , Status); CDHSetCabdPar ("DATEN_REF_SG_KENNUNG" , "-" , Status); CDHSetCabdPar ("DATEN_REF_PROJEKT" , "-" , Status); CDHSetCabdPar ("DATEN_REF_PROGRAMM_STAND", "-" , Status); CDHSetCabdPar ("DATEN_REF_DATENSATZ" , "-" , Status); } else TestApiFehler (COAPI_ECU_DATA_REFERENZ_ERROR, ProcName, 1130, SgbdName + ", DATEN_REFERENZ_LESEN"); } } else TestApiFehler (COAPI_ECU_DATA_REFERENZ_ERROR, ProcName, 1134, SgbdName + ", DATEN_REFERENZ_LESEN"); CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : ZifLesen //* //* Funktion : ZIF lesen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** ZifLesen() { string ProcName = "ZifLesen"; int Status; string SgbdName; string StringResult; int IntResult; OutputDebugString( 1163, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "ZIF_LESEN", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1169, SgbdName + ", ZIF_LESEN"); CDHapiResultInt (IntResult , "ZIF_STATUS" , 1); CDHSetCabdWordPar("ZIF_STATUS" , IntResult , Status); CDHapiResultText (StringResult , "ZIF_SG_KENNUNG" , 1, ""); CDHSetCabdPar ("ZIF_SG_KENNUNG" , StringResult , Status); CDHapiResultText (StringResult , "ZIF_PROJEKT" , 1, ""); CDHSetCabdPar ("ZIF_PROJEKT" , StringResult , Status); CDHapiResultText (StringResult , "ZIF_PROGRAMM_STAND", 1, ""); CDHSetCabdPar ("ZIF_PROGRAMM_STAND", StringResult , Status); CDHapiResultText (StringResult , "ZIF_BMW_HW" , 1, ""); CDHSetCabdPar ("ZIF_BMW_HW" , StringResult , Status); CDHSetCabdPar ("ZIF_BMW_PST" , "" , Status); // ??? CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : ZifBackupLesen //* //* Funktion : ZIF-Backup lesen //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** ZifBackupLesen() { string ProcName = "ZifBackupLesen"; int Status; string SgbdName; string StringResult; int IntResult; OutputDebugString( 1215, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "ZIF_BACKUP_LESEN", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1221, SgbdName + ", ZIF_BACKUP_LESEN"); CDHapiResultInt (IntResult , "ZIF_BACKUP_STATUS" , 1); CDHSetCabdWordPar("ZIF_BACKUP_STATUS" , IntResult , Status); CDHapiResultText (StringResult , "ZIF_BACKUP_SG_KENNUNG" , 1, ""); CDHSetCabdPar ("ZIF_BACKUP_SG_KENNUNG" , StringResult , Status); CDHapiResultText (StringResult , "ZIF_BACKUP_PROJEKT" , 1, ""); CDHSetCabdPar ("ZIF_BACKUP_PROJEKT" , StringResult , Status); CDHapiResultText (StringResult , "ZIF_BACKUP_PROGRAMM_STAND", 1, ""); CDHSetCabdPar ("ZIF_BACKUP_PROGRAMM_STAND", StringResult , Status); CDHapiResultText (StringResult , "ZIF_BACKUP_BMW_HW" , 1, ""); CDHSetCabdPar ("ZIF_BACKUP_BMW_HW" , StringResult , Status); CDHSetCabdPar ("ZIF_BACKUP_BMW_PST" , "" , Status); // ??? CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : AifSchreiben //* //* Funktion : Dummy Job Aif schreiben //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** AifSchreiben() { string ProcName = "AifSchreiben"; int Status=0; OutputDebugString( 1264, 2, ProcName); OutputDebugString( 1265,16, "Dummy Job Aif schreiben"); CDHTestError (Status); CDHSetReturnVal (Status); } //************************************************************* //* //* Name : Innentemp //* //* Funktion : Innentemperatur des SG auslesen //* //* Parameter : - //* //* Rueckgabe : - //* //************************************************************* //* History : //* 16.07.2001 SK V1.00 Freigabe //* 16.05.2002 Softing Mw Ausgabe ist konfigurierbar //************************************************************* Innentemp() { string ProcName = "Innentemp"; string SgbdName; string Innentemperatur; string Innentemp_einh; string JobStatus; int Status; if (SgInnenTemperaturLesen == TRUE) { OutputDebugString( 1297, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "INNENTEMP_LESEN", "", ""); //Innentemperatur aus SG lesen TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1303, SgbdName + ", INNENTEMP_LESEN"); CDHapiResultText (Innentemperatur , "SG_INNENTEMP" , 1, ""); CDHSetCabdPar ("SG_INNENTEMP" , Innentemperatur , Status); CDHapiResultText (Innentemp_einh , "SG_INNENTEMP_EINH" , 1, ""); CDHSetCabdPar ("SG_INNENTEMP_EINH", Innentemp_einh , Status); CDHTestError (Status); CDHSetReturnVal (Status); } else { Status = COAPI_CABD_PAR_ERROR; TestCDHFehler (Status); } } //************************************************************* //* //* Name : PhysHwNrLesen //* //* Funktion : Physikalische Hardwarenummer des SG auslesen //* //* Parameter : - //* //* Rueckgabe : - //* //************************************************************* //* History : //* 26.11.2001 Softing Mw Mustererstellung //* 17.05.2002 Softing Mw Ausgabe ist konfigurierbar //************************************************************* PhysHwNrLesen() { string ProcName = "PhysHwNrLesen"; string SgbdName; string PhysHwNummer; string JobStatus; int Status; if (SgPhysHwNrLesen == TRUE) { OutputDebugString( 1348, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHapiJob(SgbdName, "PHYSIKALISCHE_HW_NR_LESEN", "", ""); //Physikalische Hardwarenummer aus SG lesen TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1354, SgbdName + ", PHYSIKALISCHE_HW_NR_LESEN"); CDHapiResultText (PhysHwNummer, "PHYSIKALISCHE_HW_NR", 1, ""); CDHSetCabdPar ("PHYSIKALISCHE_HW_NR", PhysHwNummer, Status); CDHTestError (Status); CDHSetReturnVal (Status); } else { Status = COAPI_CABD_PAR_ERROR; TestCDHFehler (Status); } } //********************************************************************** //* //* Name : Programmieren //* //* Funktion : Programmieren des SG //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** Programmieren() { string ProcName = "Programmieren"; int Status; string SgbdName; int Index; int IntWert; string StrWert; string Text; int Buffer; int StartAdrBuffer; int BlockLengthBuffer; int RequestDownloadBuffer; int MaxData; int BufferSize; int NrOfData; int ZwischenBuffer; int ZwischenBufferSize; int ZwischenBufferNrOfData; int BlockCounter; bool BlockSchreibenFlag; bool FreibrennBlockFlag; int AdrSprungFlag; int AnzahlIst; int AnzahlSoll; int AktuellAdrLow, AktuellAdrMidLow, AktuellAdrMidHigh, AktuellAdrHigh; int StartAdrLow, StartAdrMidLow, StartAdrMidHigh, StartAdrHigh; int NextAdrLow, NextAdrMidLow, NextAdrMidHigh, NextAdrHigh; int DataLengthLow, DataLengthMidLow, DataLengthMidHigh, DataLengthHigh; int DataBlockLengthLow, DataBlockLengthMidLow, DataBlockLengthMidHigh, DataBlockLengthHigh; int NextDataBlockLengthLow, NextDataBlockLengthMidLow, NextDataBlockLengthMidHigh, NextDataBlockLengthHigh; int EndDataBlockLengthLow, EndDataBlockLengthMidLow, EndDataBlockLengthMidHigh, EndDataBlockLengthHigh; int AktuellDataBlockLengthLow, AktuellDataBlockLengthMidLow, AktuellDataBlockLengthMidHigh, AktuellDataBlockLengthHigh; int LoeschZeit; string SignaturTestZeit; int ResetZeit; int AuthentisierungZeit; int SgStatus; string SgSerienNr; string UserIdSGBD; string UserId; string AuthentisierungLevel = "3"; int AuthentisierungZufallsZahl; string AuthentisierungArt; int AuthentisierungSchluessel; int AuthentisierungSchluesselLaenge; int AuthentisierungBuffer; string SGFamilieTestschluessel; int PROG_WITH_AIF; int AifGroesse; string AifDaten; int AifDatenLen; string StringArgument; int TransitionTime; // Polling Verfahren string ApiStatusText; int BSUTime; // Boot Sektor Update int Byte; // TEST fuer Affuellung int position; int MaxDataLowByte; int MaxDataHighByte; ////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Wiederaufsetzen bool SgmtWechsel; // WAS Optimierung int Buffer_A, Buffer_B; int BufferSize_A, BufferSize_B; bool BufferErst_A, BufferErst_B; // wenn boolean Variable = TRUE => der Buffer_X ist gleich nach dem Buffer von GetApiJobData() int BufferStartAdrLow_A, BufferStartAdrMidLow_A, BufferStartAdrMidHigh_A, BufferStartAdrHigh_A; int BufferStartAdrLow_B, BufferStartAdrMidLow_B, BufferStartAdrMidHigh_B, BufferStartAdrHigh_B; int BufferDataBlockLenLow_A, BufferDataBlockLenMidLow_A, BufferDataBlockLenMidHigh_A, BufferDataBlockLenHigh_A; int BufferDataBlockLenLow_B, BufferDataBlockLenMidLow_B, BufferDataBlockLenMidHigh_B, BufferDataBlockLenHigh_B; int value, ShiftCounterStart, WiederaufstznCounter; int MaximalAnzahlWiederaufsetzen = 3; // Wiederaufsetzen ////////////////////////////////////////////////////////////////////////////////////////////////////////////// OutputDebugString( 1482, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); if (SIMULATION == TRUE) OutputDebugString( 1488, 8, "S I M U L A T I O N ist aktiv !!!!"); OutputDebugString( 1489, 8, "PABD-Modulname : " + ModulName); OutputDebugString( 1490, 8, "PABD-Revision : " + Revision); OutputDebugString( 1491, 8, "PABD-Author : " + Author); OutputDebugString( 1492, 8, "PABD-Comment : " + Comment); OutputDebugString( 1493, 8, "PABD-SGFamilie : " + SGFamilie); OutputDebugInt ( 1494, 8, "PABD-SG_MAXANZAHL_AIF " , SG_MAXANZAHL_AIF); OutputDebugInt ( 1495, 8, "PABD-SG_GROESSE_AIF " , SG_GROESSE_AIF); OutputDebugInt ( 1496, 8, "PABD-SG_ENDEKENNUNG_AIF " , SG_ENDEKENNUNG_AIF); OutputDebugString( 1497, 8, "PABD-SG_AUTHENTISIERUNG : " + SG_AUTHENTISIERUNG); OutputDebugBool ( 1498, 8, "PABD-ProgrammUndDaten " , ProgrammUndDaten); OutputDebugString( 1499, 8, "PABD-ProzessorTyp : " + ProzessorTyp); OutputDebugInt ( 1500, 8, "PABD-WartenNachECUProgrammMode " , WartenNachECUProgrammMode); OutputDebugBool ( 1501, 8, "PABD-WiederaufsetzenSwitch " , WiederaufsetzenSwitch); OutputDebugBool ( 1502, 8, "PABD-WiederaufsetzenBlockSwitch " , WiederaufsetzenBlockSwitch); OutputDebugBool ( 1503, 8, "PABD-AuffuellenSwitch " , AuffuellenSwitch); OutputDebugBool ( 1504, 8, "PABD-TesterPresentHandlingSwitch" , TesterPresentHandlingSwitch); // Erzeugen der dynamischen Puffer CDHBinBufCreate(StartAdrBuffer,Status); // Erzeugen des StartAdressDaten-Buffers TestCDHFehler (Status); CDHBinBufCreate(BlockLengthBuffer,Status); // Erzeugen des LaengenDaten-Buffers TestCDHFehler (Status); CDHBinBufCreate(Buffer,Status); // Erzeugen des Flashdaten-Buffers TestCDHFehler (Status); CDHBinBufCreate(ZwischenBuffer,Status); // Erzeugen des Flashdaten-ZwischenBuffers TestCDHFehler (Status); //********************************************************************** // Versionsnummern auslesen //********************************************************************** OutputDebugString( 1519, 8, "Sgbd-Name : " + SgbdName); CDHapiJob (SgbdName, "INFO", "", ""); CDHapiResultText (StrWert , "ORIGIN", 1, ""); OutputDebugString( 1522, 8, "SGBD-Origin : " + StrWert); CDHapiResultText (StrWert , "REVISION", 1, ""); OutputDebugString( 1524, 8, "SGBD-Revision : " + StrWert); CDHapiResultText (StrWert , "PACKAGE", 1, ""); OutputDebugString( 1526, 8, "SGBD-Package : " + StrWert); //********************************************************************** // Flash Zeiten aus SG auslesen //********************************************************************** CDHapiJob (SgbdName, "FLASH_ZEITEN_LESEN", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1532, SgbdName + ", FLASH_ZEITEN_LESEN"); CDHapiResultInt (LoeschZeit , "FLASH_LOESCHZEIT" , 1); CDHapiResultText (SignaturTestZeit , "FLASH_SIGNATURTESTZEIT", 1, ""); CDHapiResultInt (ResetZeit , "FLASH_RESETZEIT" , 1); CDHapiResultInt (AuthentisierungZeit, "FLASH_AUTHENTISIERZEIT", 1); OutputDebugInt ( 1539, 8, "LoeschZeit ", LoeschZeit); OutputDebugString( 1540, 8, "SignaturTestZeit : " + SignaturTestZeit); OutputDebugInt ( 1541, 8, "ResetZeit ", ResetZeit); OutputDebugInt ( 1542, 8, "AuthentisierungZeit", AuthentisierungZeit); //********************************************************************** // Programmierstatus abfragen //********************************************************************** CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS"); TestApiFehlerNoExit (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 1548, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN", Status); if( Status == 0 ) { CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1); OutputDebugInt( 1552, 8, "ProgrammierStatus ",SgStatus); if ((SgStatus >= 0x10) && (SgStatus <= 0x7F)) { Status = COAPI_ECU_PROG_STATUS_ERROR; } if (SgStatus >= 0x80) SgStatus = 0x01; // Für Zulieferer reserviert - Interpretation wie 0x01 if ((SgStatus != 0x01) && (SgStatus != 0x00) && (SgStatus != 0x0F)) { //********************************************************************** // STEUERGERAET ist im Boot-Modus // Reset der Statemachine //********************************************************************** OutputDebugString( 1564, 8, "Reset"); CDHapiJob (SgbdName, "STEUERGERAETE_RESET", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1566, SgbdName + ", STEUERGERAETE_RESET"); if (ResetZeit > 0) CDHDelay(ResetZeit*1000+500); else CDHDelay(500); } } if ( Status != 0 ) { SetCDHFehler (Status, ProcName, 1575, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN"); } //********************************************************************** // Blocklänge lesen //********************************************************************** CDHapiJob(SgbdName, "FLASH_BLOCKLAENGE_LESEN", "", "FLASH_BLOCKLAENGE_GESAMT"); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1582, SgbdName + ", FLASH_BLOCKLAENGE_LESEN"); CDHapiResultInt (MaxData, "FLASH_BLOCKLAENGE_GESAMT", 1 ); Text = ""; // Initialisierung if (MaxData < 0) MaxData = MaxData + 65536; // MaxData > 0x8000 if (MaxData > 255) // MaxData > 0x00FF { Text = "Error_Maximal_Plausibler_Wert_MaxData"; OutputDebugString( 1590, 8, "Error_Maximal_Plausibler_Wert_MaxData"); // MaxData stellt keinen plausiblen Wert dar } MaxData=MaxData-1; OutputDebugInt( 1596, 8, "MaxData ",MaxData); //********************************************************************** // Laenge & Anfangsadressen der Datenbloecke ohne Adressenluecken ermitteln // Start //********************************************************************** // ersten Datenblock holen CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status); if( NrOfData == 0 ) { Status = COAPI_READ_INPUT_FILE_ERROR; } BlockCounter = 0; BlockSchreibenFlag = TRUE; DataBlockLengthLow = 0; DataBlockLengthMidLow = 0; DataBlockLengthMidHigh = 0; DataBlockLengthHigh = 0; DataLengthLow = 0; DataLengthMidLow = 0; DataLengthMidHigh = 0; DataLengthHigh = 0; while (NrOfData > 0) { // Startadresse bestimmen CDHBinBufReadByte(Buffer,AktuellAdrLow ,17,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrMidLow ,18,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrMidHigh,19,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrHigh ,20,Status); TestCDHFehler (Status); StartAdrLow = AktuellAdrLow; StartAdrMidLow = AktuellAdrMidLow; StartAdrMidHigh = AktuellAdrMidHigh; StartAdrHigh = AktuellAdrHigh; NextAdrLow = AktuellAdrLow ; // fuer Erkennung auf Datenblockende NextAdrMidLow = AktuellAdrMidLow ; NextAdrMidHigh = AktuellAdrMidHigh ; NextAdrHigh = AktuellAdrHigh ; // Laenge des Datenblocks feststellen AdrSprungFlag = 0; FreibrennBlockFlag = FALSE; while (AdrSprungFlag != 1) { // Naechste Adresse Berechnen NextAdrLow = NextAdrLow + NrOfData; if (NextAdrLow > 0xFF) { NextAdrMidLow = NextAdrMidLow + 1; // Uebertrag nach MidLow NextAdrLow = NextAdrLow - 0x100; } if (NextAdrMidLow > 0xFF) { NextAdrMidHigh = NextAdrMidHigh + 1; // Uebertrag nach MidHigh NextAdrMidLow = NextAdrMidLow - 0x100; } if (NextAdrMidHigh > 0xFF) { NextAdrHigh = NextAdrHigh + 1; // Uebertrag nach High NextAdrMidHigh = NextAdrMidHigh - 0x100; } // Laenge des Datenblocks DataBlockLengthLow = DataBlockLengthLow + NrOfData; if (DataBlockLengthLow > 0xFF) { DataBlockLengthMidLow = DataBlockLengthMidLow + 1; // Uebertrag nach MidLow DataBlockLengthLow = DataBlockLengthLow - 0x100; } if (DataBlockLengthMidLow > 0xFF) { DataBlockLengthMidHigh = DataBlockLengthMidHigh + 1; // Uebertrag nach MidHigh DataBlockLengthMidLow = DataBlockLengthMidLow - 0x100; } if (DataBlockLengthMidHigh> 0xFF) { DataBlockLengthHigh = DataBlockLengthHigh + 1; // Uebertrag nach High DataBlockLengthMidHigh = DataBlockLengthMidHigh - 0x100; } // Naechsten Datenblock lesen CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status); // Daten holen TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrLow ,17,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrMidLow ,18,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrMidHigh,19,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrHigh ,20,Status); TestCDHFehler (Status); // Ueberpruefung auf Adressluecke if( (NextAdrLow == AktuellAdrLow) && // keine Luecke (NextAdrMidLow == AktuellAdrMidLow) && // keine Luecke (NextAdrMidHigh == AktuellAdrMidHigh) && // keine Luecke (NextAdrHigh == AktuellAdrHigh)) // keine Luecke { AdrSprungFlag=0; // keine Luecke // Sonderbehandlung Segmentwechsel if (ProzessorTyp == "HC12D128") { if ( (NextAdrLow == 0x00) && ((NextAdrMidLow == 0x40) || (NextAdrMidLow == 0x80) || (NextAdrMidLow == 0xC0)) && (NextAdrMidHigh == 0x00) && (NextAdrHigh == 0x00) ) { hexstring(NextAdrMidLow,StrWert); OutputDebugString( 1722, 8, "Segmentwechsel bei 00:"+StrWert+":00"); AdrSprungFlag=1; // Segmentwechsel } } } else { if( (StartAdrLow == AktuellAdrLow) && // Freibrennblock (StartAdrMidLow == AktuellAdrMidLow) && // fuer Flash (StartAdrMidHigh == AktuellAdrMidHigh) && // (Lauter 0xFF) (StartAdrHigh == AktuellAdrHigh)) { AdrSprungFlag = 1; // Freibrennblock erkannt FreibrennBlockFlag = TRUE; if (FreibrennBlockSchreiben == TRUE) { BlockSchreibenFlag = TRUE; OutputDebugInt( 1739, 8, "FreibrennBlockSchreibenFlag ( gesetzt ) in Block",BlockCounter); } else { BlockSchreibenFlag = FALSE; OutputDebugInt( 1744, 8, "FreibrennBlockSchreibenFlag ( ignoriert ) in Block",BlockCounter); } } else { AdrSprungFlag = 1; // echte Adressluecke } } if (NrOfData==0) { AdrSprungFlag=1; // Datenende } } // end of while (AdrSprungFlag != 1) // Startadressen im Buffer merken CDHBinBufWriteByte(StartAdrBuffer,StartAdrLow , (4*BlockCounter) ,Status); TestCDHFehler (Status); CDHBinBufWriteByte(StartAdrBuffer,StartAdrMidLow , (4*BlockCounter)+1,Status); TestCDHFehler (Status); CDHBinBufWriteByte(StartAdrBuffer,StartAdrMidHigh , (4*BlockCounter)+2,Status); TestCDHFehler (Status); CDHBinBufWriteByte(StartAdrBuffer,StartAdrHigh , (4*BlockCounter)+3,Status); TestCDHFehler (Status); // Datenlaenge im Buffer merken CDHBinBufWriteByte(BlockLengthBuffer,DataBlockLengthLow , (4*BlockCounter) ,Status); TestCDHFehler (Status); CDHBinBufWriteByte(BlockLengthBuffer,DataBlockLengthMidLow , (4*BlockCounter)+1,Status); TestCDHFehler (Status); CDHBinBufWriteByte(BlockLengthBuffer,DataBlockLengthMidHigh , (4*BlockCounter)+2,Status); TestCDHFehler (Status); CDHBinBufWriteByte(BlockLengthBuffer,DataBlockLengthHigh , (4*BlockCounter)+3,Status); TestCDHFehler (Status); if (FreibrennBlockFlag == FALSE) { // Gesamtlänge errechnen DataLengthLow = DataLengthLow + DataBlockLengthLow; if (DataLengthLow > 0xFF) { DataLengthMidLow = DataLengthMidLow + 1; // Uebertrag nach MidLow DataLengthLow = DataLengthLow - 0x100; } if (DataLengthMidLow > 0xFF) { DataLengthMidHigh = DataLengthMidHigh + 1; // Uebertrag nach MidHigh DataLengthMidLow = DataLengthMidLow - 0x100; } if (DataLengthMidHigh > 0xFF) { DataLengthHigh = DataLengthHigh + 1; // Uebertrag nach High DataLengthMidHigh = DataLengthMidHigh - 0x100; } DataLengthMidLow = DataLengthMidLow + DataBlockLengthMidLow; if (DataLengthMidLow > 0xFF) { DataLengthMidHigh = DataLengthMidHigh + 1; // Uebertrag nach MidHigh DataLengthMidLow = DataLengthMidLow - 0x100; } if (DataLengthMidHigh > 0xFF) { DataLengthHigh = DataLengthHigh + 1; // Uebertrag nach High DataLengthMidHigh = DataLengthMidHigh - 0x100; } DataLengthMidHigh = DataLengthMidHigh + DataBlockLengthMidHigh; if (DataLengthMidHigh > 0xFF) { DataLengthHigh = DataLengthHigh + 1; // Uebertrag nach High DataLengthMidHigh = DataLengthMidHigh - 0x100; } DataLengthHigh = DataLengthHigh + DataBlockLengthHigh; } DataBlockLengthLow = 0; DataBlockLengthMidLow = 0; DataBlockLengthMidHigh = 0; DataBlockLengthHigh = 0; BlockCounter = BlockCounter + 1; } // end of while (NrOfData > 0) OutputDebugBool( 1829, 8, "BlockSchreibenFlag ",BlockSchreibenFlag); OutputDebugInt ( 1830, 8, "BlockCounter ",BlockCounter); Index = 0; while (Index < BlockCounter) { inttostring(Index,StrWert); Text="Block("+StrWert+") Adr = "; CDHBinBufReadByte(StartAdrBuffer,IntWert , (4*Index)+3,Status); hexstring(IntWert,StrWert); Text=Text+StrWert+":"; CDHBinBufReadByte(StartAdrBuffer,IntWert , (4*Index)+2,Status); hexstring(IntWert,StrWert); Text=Text+StrWert+":"; CDHBinBufReadByte(StartAdrBuffer,IntWert , (4*Index)+1,Status); hexstring(IntWert,StrWert); Text=Text+StrWert+":"; CDHBinBufReadByte(StartAdrBuffer,IntWert , (4*Index) ,Status); hexstring(IntWert,StrWert); Text=Text+StrWert+" Anz = "; CDHBinBufReadByte(BlockLengthBuffer,IntWert , (4*Index)+3,Status); hexstring(IntWert,StrWert); Text=Text+StrWert+":"; CDHBinBufReadByte(BlockLengthBuffer,IntWert , (4*Index)+2,Status); hexstring(IntWert,StrWert); Text=Text+StrWert+":"; CDHBinBufReadByte(BlockLengthBuffer,IntWert , (4*Index)+1,Status); hexstring(IntWert,StrWert); Text=Text+StrWert+":"; CDHBinBufReadByte(BlockLengthBuffer,IntWert , (4*Index) ,Status); hexstring(IntWert,StrWert); Text=Text+StrWert; OutputDebugString ( 1868, 8, Text); Index = Index + 1; } Text="Gesamtanzahl = "; hexstring(DataLengthHigh ,StrWert); Text=Text+StrWert+":"; hexstring(DataLengthMidHigh ,StrWert); Text=Text+StrWert+":"; hexstring(DataLengthMidLow ,StrWert); Text=Text+StrWert+":"; hexstring(DataLengthLow ,StrWert); Text=Text+StrWert; OutputDebugString ( 1880, 8, Text); TestCDHFehler (Status); //********************************************************************** // Ende // Laenge & Anfangsadressen der Datenbloecke ohne Adressenluecken ermitteln //********************************************************************** //********************************************************************** // StartDiagonsticSession wird vor der Authentisierung durchgefuehrt. // Bei positive Response muss sie nicht mehr durchgefuehrt werden, // bei negative Response wird die Authentisierung aufgerufen // mit nachfolgendem StartDiagonsticSession //********************************************************************** CDHapiJob (SgbdName, "DIAGNOSE_MODE", "ECUPM", ""); TestApiFehlerNoExit (COAPI_ECU_PROGRAMMING_MODE_ERROR, ProcName, 1895, SgbdName + ", DIAGNOSE_MODE (ECUPM)", Status); //********************************************************************** // Status von StartDiagonsticSession auswerten //********************************************************************** if (Status == 0) { if (WartenNachECUProgrammMode > 0) { CDHDelay(WartenNachECUProgrammMode*1000+500); } else { if (ResetZeit > 0) CDHDelay(ResetZeit*1000+500); else CDHDelay(500); } } else { //********************************************************************** // Authentisierung // Start //********************************************************************** CDHapiJob(SgbdName, "SERIENNUMMER_LESEN", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1920, SgbdName + ", SERIENNUMMER_LESEN"); CDHapiResultText (SgSerienNr, "SERIENNUMMER", 1, ""); // nur die Zeichen 5-8 + terminierungs-Null benutzen midstr(SgSerienNr,SgSerienNr,5,5); OutputDebugString( 1924, 8, "SgSerienNr : "+SgSerienNr); // Zufallszahlen holen CDHAuthGetRandom(UserId,UserIdSGBD); OutputDebugString( 1928, 8, "UserId : "+UserId); OutputDebugString( 1929, 8, "UserIdSGBD : "+UserIdSGBD); CDHapiJob(SgbdName, "AUTHENTISIERUNG_ZUFALLSZAHL_LESEN", AuthentisierungLevel+";"+UserIdSGBD, ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 1932, SgbdName + ", AUTHENTISIERUNG_ZUFALLSZAHL_LESEN (3;"+UserIdSGBD+")"); // Erzeugen Buffer fuer Authentisierungs Zufallszahl CDHBinBufCreate(AuthentisierungZufallsZahl,Status); TestCDHFehler (Status); CDHapiResultBinary (AuthentisierungZufallsZahl, "ZUFALLSZAHL", 1, Status); TestCDHFehler (Status); CDHapiResultText (AuthentisierungArt, "AUTHENTISIERUNG", 1,""); OutputDebugString( 1942, 8, "AuthentisierungArt : "+AuthentisierungArt); OutputDebugString( 1943, 8, "SGFamilie : "+SGFamilie); // Erzeugen Buffer fuer Authentisierungs Schlüssel CDHBinBufCreate(AuthentisierungSchluessel,Status); TestCDHFehler (Status); CDHCallAuthenticate(SGFamilie, UserId, SgSerienNr, AuthentisierungArt, AuthentisierungZufallsZahl, AuthentisierungLevel, AuthentisierungSchluessel, AuthentisierungSchluesselLaenge, Status); if (Status != 0) TestCDHFehler (COAPI_ECU_AUTHENTICATION_FORMAT_ERROR); OutputDebugInt ( 1959, 8, "SchluesselLaenge ",AuthentisierungSchluesselLaenge); // Erzeugen Buffer fuer Authentisierungs Buffer CDHBinBufCreate(AuthentisierungBuffer,Status); TestCDHFehler (Status); CDHBinBufWriteByte(AuthentisierungBuffer, 1, 0, Status); CDHBinBufWriteByte(AuthentisierungBuffer, AuthentisierungZeit, 4, Status); CDHBinBufWriteByte(AuthentisierungBuffer, AuthentisierungSchluesselLaenge, 13, Status); CDHBinBufWriteByte(AuthentisierungBuffer, 0, 14, Status); // AuthentisierungSchluessel nach AuthentisierungBuffer kopieren Index = 0; while (Index < AuthentisierungSchluesselLaenge) { CDHBinBufReadByte(AuthentisierungSchluessel, IntWert, Index, Status); CDHBinBufWriteByte(AuthentisierungBuffer, IntWert, Index+21, Status); TestCDHFehler (Status); Index = Index + 1; } CDHBinBufWriteByte(AuthentisierungBuffer, 3, 21+AuthentisierungSchluesselLaenge, Status); // ETX setzen (03h) TestCDHFehler (Status); OutputDebugInt ( 1982, 8, "AuthentisierungZeit",AuthentisierungZeit); CDHapiJobData (SgbdName, "AUTHENTISIERUNG_START", AuthentisierungBuffer, 21+AuthentisierungSchluesselLaenge, ""); TestApiFehlerNoExit (COAPI_ECU_AUTHENTICATION_ERROR, ProcName, 1984, SgbdName + ", AUTHENTISIERUNG_START ( SG-Schluessel ...)", Status); if (Status != 0) { //********************************************************************** // Authentisierung fehlerhaft // Versuch mit Testschlüssel //********************************************************************** //********************************************************************** // STEUERGERAETE_RESET //********************************************************************** OutputDebugString( 1996, 8, "Reset"); CDHapiJob (SgbdName, "STEUERGERAETE_RESET", "", ""); TestApiFehlerNoExit (COAPI_ECU_TIMEOUT, ProcName, 1998, SgbdName + ", STEUERGERAETE_RESET", Status); if (Status == 0) { if (ResetZeit > 0) CDHDelay(ResetZeit*1000+500); else CDHDelay(500); } // Zufallszahlen holen CDHAuthGetRandom(UserId,UserIdSGBD); OutputDebugString( 2009, 8, "UserId : "+UserId); OutputDebugString( 2010, 8, "UserIdSGBD : "+UserIdSGBD); CDHapiJob(SgbdName, "AUTHENTISIERUNG_ZUFALLSZAHL_LESEN", AuthentisierungLevel+";"+UserIdSGBD, ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 2013, SgbdName + ", AUTHENTISIERUNG_ZUFALLSZAHL_LESEN (3;"+UserIdSGBD+")"); // Löschen Buffer fuer Authentisierungs Zufallszahl CDHBinBufDelete(AuthentisierungZufallsZahl,Status); // Erzeugen Buffer fuer Authentisierungs Zufallszahl CDHBinBufCreate(AuthentisierungZufallsZahl,Status); TestCDHFehler (Status); CDHapiResultBinary (AuthentisierungZufallsZahl, "ZUFALLSZAHL", 1, Status); TestCDHFehler (Status); CDHapiResultText (AuthentisierungArt, "AUTHENTISIERUNG", 1,""); OutputDebugString( 2025, 8, "AuthentisierungArt : "+AuthentisierungArt); SGFamilieTestschluessel="??"; if (AuthentisierungArt=="Asymetrisch" ) SGFamilieTestschluessel="T_SMA"; if (AuthentisierungArt=="Symetrisch" ) SGFamilieTestschluessel="T_SMB"; if (AuthentisierungArt=="Simple" ) SGFamilieTestschluessel="T_SMC"; OutputDebugString( 2031, 8, "SGFamilieTestschl. : "+SGFamilieTestschluessel); // Löschen Buffer fuer Authentisierungs Schlüssel CDHBinBufDelete(AuthentisierungSchluessel,Status); // Erzeugen Buffer fuer Authentisierungs Schlüssel CDHBinBufCreate(AuthentisierungSchluessel,Status); TestCDHFehler (Status); CDHCallAuthenticate(SGFamilieTestschluessel, UserId, SgSerienNr, AuthentisierungArt, AuthentisierungZufallsZahl, AuthentisierungLevel, AuthentisierungSchluessel, AuthentisierungSchluesselLaenge, Status); if (Status != 0) TestCDHFehler (COAPI_ECU_AUTHENTICATION_FORMAT_ERROR); OutputDebugInt ( 2049, 8, "SchluesselLaenge ",AuthentisierungSchluesselLaenge); // Löschen Buffer fuer Authentisierungs Buffer CDHBinBufDelete(AuthentisierungBuffer,Status); // Erzeugen Buffer fuer Authentisierungs Buffer CDHBinBufCreate(AuthentisierungBuffer,Status); TestCDHFehler (Status); CDHBinBufWriteByte(AuthentisierungBuffer, 1, 0, Status); CDHBinBufWriteByte(AuthentisierungBuffer, AuthentisierungZeit, 4, Status); CDHBinBufWriteByte(AuthentisierungBuffer, AuthentisierungSchluesselLaenge, 13, Status); CDHBinBufWriteByte(AuthentisierungBuffer, 0, 14, Status); // AuthentisierungSchluessel nach AuthentisierungBuffer kopieren Index = 0; while (Index < AuthentisierungSchluesselLaenge) { CDHBinBufReadByte(AuthentisierungSchluessel, IntWert, Index, Status); CDHBinBufWriteByte(AuthentisierungBuffer, IntWert, Index+21, Status); TestCDHFehler (Status); Index = Index + 1; } CDHBinBufWriteByte(AuthentisierungBuffer, 3, 21+AuthentisierungSchluesselLaenge, Status); // ETX setzen (03h) TestCDHFehler (Status); OutputDebugInt ( 2074, 8, "AuthentisierungZeit",AuthentisierungZeit); CDHapiJobData (SgbdName, "AUTHENTISIERUNG_START", AuthentisierungBuffer, 21+AuthentisierungSchluesselLaenge, ""); TestApiFehler (COAPI_ECU_AUTHENTICATION_ERROR, ProcName, 2076, SgbdName + ", AUTHENTISIERUNG_START ( Test-Schluessel ... )"); //********************************************************************** // Ende // Versuch mit Testschlüssel //********************************************************************** } // Löschen Buffer fuer Authentisierungs Buffer CDHBinBufDelete(AuthentisierungBuffer,Status); // Löschen Buffer fuer Authentisierungs Zufallszahl CDHBinBufDelete(AuthentisierungZufallsZahl,Status); // Löschen Buffer fuer Authentisierungs Schlüssel CDHBinBufDelete(AuthentisierungSchluessel,Status); //********************************************************************** // Ende // Authentisierung //********************************************************************** CDHapiJob (SgbdName, "DIAGNOSE_MODE", "ECUPM", ""); TestApiFehler (COAPI_ECU_PROGRAMMING_MODE_ERROR, ProcName, 2098, SgbdName + ", DIAGNOSE_MODE (ECUPM)"); if (WartenNachECUProgrammMode > 0) { CDHDelay(WartenNachECUProgrammMode*1000+500); } else { if (ResetZeit > 0) CDHDelay(ResetZeit*1000+500); else CDHDelay(500); } } //********************************************************************** // // Ruecksetzen des "File-Pointer" bei den Daten //********************************************************************** CDHResetApiJobData(); // ersten Datenblock holen CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status); TestCDHFehler (Status); //PF OutputDebugInt( 2120, 9, "BufferSize bei ersten Datenblock holen ", BufferSize); //********************************************************************************** //Auffuellen mit 0xFF bis MaxData (Laenge) //********************************************************************************** if (AuffuellenSwitch == TRUE) { if (NrOfData < MaxData) { Byte = 0xFF; OutputDebugInt( 2129, 8, "BufferSize first Datablock ",BufferSize); position = BufferSize - 1; // Um das alte letzte Byte zu überschreiben: ETX=0x03h OutputDebugInt( 2131, 8, "Position first Datablock ",position); while (position <= MaxData + 21 - 1) // 20 von Info Bytes(Adresse,...) { // Letzte Byte ist fuer ETX = 03h CDHBinBufWriteByte(Buffer, Byte, position, Status); position = position + 1; BufferSize = BufferSize + 1; } CDHBinBufWriteByte(Buffer, 0x03, position, Status); //Letzte Byte ist immer ETX = 03h BufferSize = BufferSize + 1; if (MaxData > 0xFF) { MaxDataHighByte = (MaxData / 256); MaxDataLowByte = (MaxData - (MaxDataHighByte * 256)); } else { MaxDataHighByte = 0x00; MaxDataLowByte = MaxData; } CDHBinBufWriteByte(Buffer, MaxDataLowByte, 13, Status); // Anzahl Bytedaten LowByte CDHBinBufWriteByte(Buffer, MaxDataHighByte, 14, Status); // Anzahl Bytedaten HighByte CDHBinBufWriteByte(Buffer, MaxDataLowByte, 15, Status); // Anzahl Wortdaten LowByte CDHBinBufWriteByte(Buffer, MaxDataHighByte, 16, Status); // Anzahl Wortdaten HighByte } // End_Of_if (NrOfData) } //********************************************************************************** //Ende von auffuellen mit 0xFF bis MaxData (Laenge) //********************************************************************************** //********************************************************************** // Flash loeschen //********************************************************************** if ( LoeschZeit < 256 ) { CDHBinBufWriteByte(Buffer, LoeschZeit, 4, Status); CDHBinBufWriteWord(Buffer, 0 , 5, Status); } else { CDHBinBufWriteByte(Buffer, 0 , 4, Status); CDHBinBufWriteWord(Buffer, LoeschZeit, 5, Status); } CDHBinBufWriteByte(Buffer, DataLengthLow ,13, Status); // Low CDHBinBufWriteByte(Buffer, DataLengthMidLow ,14, Status); // MidLow CDHBinBufWriteByte(Buffer, DataLengthMidHigh ,15, Status); // MidHigh CDHBinBufWriteByte(Buffer, DataLengthHigh ,16, Status); // High TestCDHFehler (Status); if( Status == 0 ) { OutputDebugInt ( 2187, 8, "LoeschZeit ",LoeschZeit); CDHapiJobData (SgbdName, "FLASH_LOESCHEN", Buffer, BufferSize, ""); TestApiFehlerNoExit (COAPI_ECU_FLASH_ERASE_ERROR, ProcName, 2190, SgbdName + ", FLASH_LOESCHEN (...)", Status); if( Status == 0 ) { CDHapiResultInt (SgStatus, "FLASH_LOESCHEN_STATUS", 1); OutputDebugInt( 2194, 8, "LoeschStatus ",SgStatus); if (SgStatus != 0x01) { Status = COAPI_ECU_FLASH_ERASE_ERROR; } } if ( Status != 0 ) { SetCDHFehler (Status, ProcName, 2202, SgbdName + ", FLASH_LOESCHEN (...)"); } } if ( Status != 0 ) { TestCDHFehler (Status); } //********************************************************************** // Datenbloecke schreiben // Start //********************************************************************** OutputDebugBool( 2214, 8, "BlockSchreibenFlag ",BlockSchreibenFlag); // Erzeugen des RequestDownload-Buffers CDHBinBufCreate(RequestDownloadBuffer,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer, 0x01, 0, Status); // Datentyp Daten setzen CDHBinBufWriteByte(RequestDownloadBuffer, 0x03, 21, Status); // ETX setzen TestCDHFehler (Status); //********************************************************************** // Fahrzeugbusse einschlafen lassen // Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); BlockCounter = 0; WiederaufstznCounter = 0; // Wiederaufsetzen PF CDHBinBufCreate(Buffer_A, Status); TestCDHFehler (Status); CDHBinBufCreate(Buffer_B, Status); TestCDHFehler (Status); // -- // / \ // || // // Buffer ::::: BufferSize // //-------------- AktuellAdr // // Buffer_A (bzw. Buffer_B) ::::: BufferSize_A (bzw. BufferSize_B) // //-------------- BufferStartAdr_A (bzw. B) // // Buffer_B (bzw. Buffer_A) ::::: BufferSize_B (bzw. BufferSize_A) // //-------------- BufferStartAdr_B (bzw. A) while (NrOfData > 0) { SgmtWechsel = TRUE; ShiftCounterStart = 0; BufferSize_A = BufferSize; BufferErst_A = TRUE; BufferErst_B = FALSE; // Startadresse des Datenblocks aus Buffer holen CDHBinBufReadByte(StartAdrBuffer,StartAdrLow , (4*BlockCounter) , Status); TestCDHFehler (Status); CDHBinBufReadByte(StartAdrBuffer,StartAdrMidLow , (4*BlockCounter)+1, Status); TestCDHFehler (Status); CDHBinBufReadByte(StartAdrBuffer,StartAdrMidHigh , (4*BlockCounter)+2, Status); TestCDHFehler (Status); CDHBinBufReadByte(StartAdrBuffer,StartAdrHigh , (4*BlockCounter)+3, Status); TestCDHFehler (Status); // Startadresse fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrLow ,17,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrMidLow ,18,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrMidHigh ,19,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrHigh ,20,Status); TestCDHFehler (Status); // Laenge des Datenblocks aus Buffer holen CDHBinBufReadByte(BlockLengthBuffer,DataBlockLengthLow , (4*BlockCounter) ,Status); TestCDHFehler (Status); CDHBinBufReadByte(BlockLengthBuffer,DataBlockLengthMidLow , (4*BlockCounter)+1,Status); TestCDHFehler (Status); CDHBinBufReadByte(BlockLengthBuffer,DataBlockLengthMidHigh , (4*BlockCounter)+2,Status); TestCDHFehler (Status); CDHBinBufReadByte(BlockLengthBuffer,DataBlockLengthHigh , (4*BlockCounter)+3,Status); TestCDHFehler (Status); // Laenge des Datenblocks fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthLow ,13,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthMidLow ,14,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthMidHigh ,15,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthHigh ,16,Status); TestCDHFehler (Status); // Aktuelle Adresse und Laenge merken fuer wiederaufsetzen AktuellAdrLow = StartAdrLow; AktuellAdrMidLow = StartAdrMidLow; AktuellAdrMidHigh = StartAdrMidHigh; AktuellAdrHigh = StartAdrHigh; AktuellDataBlockLengthLow = DataBlockLengthLow; AktuellDataBlockLengthMidLow = DataBlockLengthMidLow; AktuellDataBlockLengthMidHigh = DataBlockLengthMidHigh; AktuellDataBlockLengthHigh = DataBlockLengthHigh; // Wiederaufsetzen : Speichern den Buffer, der geschrieben sein wird // Ersten DatenBlock des Segments Index = 0; while (Index < BufferSize) { CDHBinBufReadByte(Buffer, value, Index, Status); CDHBinBufWriteByte(Buffer_A, value, Index, Status); Index = Index + 1; } BufferSize_A = BufferSize; BufferErst_A = TRUE; BufferStartAdrLow_A = StartAdrLow; BufferStartAdrMidLow_A = StartAdrMidLow; BufferStartAdrMidHigh_A = StartAdrMidHigh; BufferStartAdrHigh_A = StartAdrHigh; BufferDataBlockLenLow_A = DataBlockLengthLow; BufferDataBlockLenMidLow_A = DataBlockLengthMidLow; BufferDataBlockLenMidHigh_A = DataBlockLengthMidHigh; BufferDataBlockLenHigh_A = DataBlockLengthHigh; if ( BlockSchreibenFlag == TRUE ) { //********************************************************************** // Flash Adresse schreiben //********************************************************************** AnzahlSoll = 0; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN_ADRESSE", RequestDownloadBuffer, 21, ""); TestApiFehlerNoExit (COAPI_ECU_FLASH_REQUEST_DOWNLOAD_ERROR, ProcName, 2343, SgbdName + ", FLASH_SCHREIBEN_ADRESSE (...)", Status); if ( Status != 0 ) { SetCDHFehler (Status, ProcName, 2346, SgbdName + ", FLASH_SCHREIBEN_ADRESSE (...)"); } //********************************************************************** // TesterPresent // Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); } //********************************************************************** // TransferData //********************************************************************** //********************************************************************** // Flash Block schreiben //********************************************************************** EndDataBlockLengthLow = 0; // fuer Erkennung auf Datenblockende EndDataBlockLengthMidLow = 0; EndDataBlockLengthMidHigh = 0; EndDataBlockLengthHigh = 0; AdrSprungFlag = 0; while (AdrSprungFlag != 1) // Datenblock schreiben bis zum Naechsten Block { TesterPresentHandling(ProcName, SgbdName, TRUE); if ( BlockSchreibenFlag == TRUE ) { AnzahlSoll = AnzahlSoll + 1; //OutputDebugInt( 2375, 9, "AnzahlSoll ", AnzahlSoll); CDHapiJobData (SgbdName, "FLASH_SCHREIBEN", Buffer, BufferSize, ""); TestApiFehlerNoExit (COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 2378, SgbdName + ", FLASH_SCHREIBEN (...)", Status); if (Status != 0) { if (WiederaufsetzenBlockSwitch == TRUE ) { //********************************************************************** // Flash Block schreiben wiederaufsetzen Datenbloecke (2 zurück) // Start //********************************************************************** WiederaufstznCounter = WiederaufstznCounter + 1; OutputDebugInt( 2388, 8, "WAS - WiederaufstznCounter", WiederaufstznCounter); if (WiederaufstznCounter > MaximalAnzahlWiederaufsetzen) { OutputDebugString( 2392, 8, "WAS - Maximal Anzahl von Wiederaufsetzen erreicht"); exit(); } OutputDebugString( 2396, 8, "WAS - Wiederaufsetzen nach Kommunikationsfehler"); CDHDelay(1000); TesterPresentHandling(ProcName, SgbdName, TRUE); AnzahlSoll = 0; //********************************************************************** // Flash Schreiben abschliessen (wiederaufsetzen) //********************************************************************** // Startadresse fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrLow ,17,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrMidLow ,18,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrMidHigh ,19,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,StartAdrHigh ,20,Status); TestCDHFehler (Status); // Laenge des Datenblocks fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthLow ,13,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthMidLow ,14,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthMidHigh ,15,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,DataBlockLengthHigh ,16,Status); TestCDHFehler (Status); TesterPresentHandling(ProcName, SgbdName, TRUE); CDHapiJobData (SgbdName, "FLASH_SCHREIBEN_ENDE", RequestDownloadBuffer, 21, ""); TestApiFehler(COAPI_ECU_FLASH_TRANSFER_EXIT_ERROR, ProcName, 2431, SgbdName + ", WAS - FLASH_SCHREIBEN_ENDE Datenbloecke(...)"); //********************************************************************** // TesterPresent // Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); //********************************************************************** // Flash Adresse schreiben (wiederaufsetzen) //********************************************************************** if (BufferErst_A == FALSE) { // Reihenfolge : Buffer -> Buffer_A -> Buffer_B // Aktuelle Adresse fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrLow_A ,17,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrMidLow_A ,18,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrMidHigh_A ,19,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrHigh_A ,20,Status); TestCDHFehler (Status); // Aktuelle Laenge des Datenblocks fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenLow_A ,13,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenMidLow_A ,14,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenMidHigh_A,15,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenHigh_A ,16,Status); TestCDHFehler (Status); Text="Wiederaufsetzen an Adresse = "; hexstring(BufferStartAdrHigh_A, StrWert); Text=Text+StrWert+":"; hexstring(BufferStartAdrMidHigh_A,StrWert); Text=Text+StrWert+":"; hexstring(BufferStartAdrMidLow_A, StrWert); Text=Text+StrWert+":"; hexstring(BufferStartAdrLow_A, StrWert); Text=Text+StrWert+" Anzahl = "; hexstring(BufferDataBlockLenHigh_A, StrWert); Text=Text+StrWert+":"; hexstring(BufferDataBlockLenMidHigh_A,StrWert); Text=Text+StrWert+":"; hexstring(BufferDataBlockLenMidLow_A, StrWert); Text=Text+StrWert+":"; hexstring(BufferDataBlockLenLow_A, StrWert); Text=Text+StrWert; OutputDebugString( 2483, 8, Text); } else { CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrLow_B ,17,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrMidLow_B ,18,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrMidHigh_B ,19,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferStartAdrHigh_B ,20,Status); TestCDHFehler (Status); // Aktuelle Laenge des Datenblocks fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenLow_B ,13,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenMidLow_B ,14,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenMidHigh_B ,15,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,BufferDataBlockLenHigh_B ,16,Status); TestCDHFehler (Status); Text="Wiederaufsetzen an Adresse = "; hexstring(BufferStartAdrHigh_B, StrWert); Text=Text+StrWert+":"; hexstring(BufferStartAdrMidHigh_B,StrWert); Text=Text+StrWert+":"; hexstring(BufferStartAdrMidLow_B, StrWert); Text=Text+StrWert+":"; hexstring(BufferStartAdrLow_B, StrWert); Text=Text+StrWert+" Anzahl = "; hexstring(BufferDataBlockLenHigh_B, StrWert); Text=Text+StrWert+":"; hexstring(BufferDataBlockLenMidHigh_B,StrWert); Text=Text+StrWert+":"; hexstring(BufferDataBlockLenMidLow_B, StrWert); Text=Text+StrWert+":"; hexstring(BufferDataBlockLenLow_B, StrWert); Text=Text+StrWert; OutputDebugString( 2524, 8, Text); } TesterPresentHandling(ProcName, SgbdName, TRUE); CDHapiJobData (SgbdName, "FLASH_SCHREIBEN_ADRESSE", RequestDownloadBuffer, 21, ""); TestApiFehlerNoExit (COAPI_ECU_FLASH_REQUEST_DOWNLOAD_ERROR, ProcName, 2530, SgbdName + ", FLASH_SCHREIBEN_ADRESSE (...)", Status); if ( Status != 0 ) { SetCDHFehler (Status, ProcName, 2533, SgbdName + ", FLASH_SCHREIBEN_ADRESSE (...)"); } //********************************************************************** // TesterPresent // Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); //********************************************************************** // Flash Block schreiben ( wiederaufgesetzt ) //********************************************************************** if (BufferErst_A == FALSE) // Reihenfolge: Buffer -> Buffer_B (TRUE) -> Buffer_A (FALSE) { OutputDebugInt( 2546, 8, "WAS - Buffer_A beim FLASH_SCHREIBEN", BufferSize_A); AnzahlSoll = AnzahlSoll + 1; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN", Buffer_A, BufferSize_A, ""); TestApiFehler (COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 2549, SgbdName + ", FLASH_SCHREIBEN_WAS_BUFFER_A"); } else { OutputDebugInt( 2553, 8, "WAS - Buffer_B beim FLASH_SCHREIBEN", BufferSize_B); AnzahlSoll = AnzahlSoll + 1; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN", Buffer_B, BufferSize_B, ""); TestApiFehler (COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 2556, SgbdName + ", FLASH_SCHREIBEN_WAS_BUFFER_B"); } //********************************************************************** // TesterPresent // Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); if (SgmtWechsel == FALSE) { if (ShiftCounterStart >= 2) { if (BufferErst_A == TRUE) // Reihenfolge: Buffer -> Buffer_A (TRUE) -> Buffer_B (FALSE) { OutputDebugInt( 2570, 8, "WAS - Buffer_A beim FLASH_SCHREIBEN - ShiftCounterStart >= 2", BufferSize_A); AnzahlSoll = AnzahlSoll + 1; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN", Buffer_A, BufferSize_A, ""); TestApiFehler (COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 2573, SgbdName + ", FLASH_SCHREIBEN_WAS_BUFFER_A"); } else { OutputDebugInt( 2577, 8, "WAS - Buffer_B beim FLASH_SCHREIBEN - ShiftCounterStart >= 2", BufferSize_B); AnzahlSoll = AnzahlSoll + 1; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN", Buffer_B, BufferSize_B, ""); TestApiFehler (COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 2580, SgbdName + ", FLASH_SCHREIBEN_WAS_BUFFER_B"); } } OutputDebugInt( 2584, 8, "WAS - Buffer beim FLASH_SCHREIBEN - BufferSize", BufferSize); AnzahlSoll = AnzahlSoll + 1; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN", Buffer, BufferSize, ""); TestApiFehler (COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 2587, SgbdName + ", FLASH_SCHREIBEN (...)"); } } // End of WiederaufsetzenBlockSwitch == TRUE TesterPresentHandling(ProcName, SgbdName, TRUE); //**************************************************************************** // Ende Wiederaufsetzen, wo 2 fehlerfrei Datenbloecke zurueckgeflasht werden // ************************************************************************** // Anfang Wiederaufsetzen, wo nur der letzte Telegramm gesendet wird //**************************************************************************** if ((WiederaufsetzenSwitch == TRUE) && (WiederaufsetzenBlockSwitch == FALSE)) { //********************************************************************** // WAS - Letzte Telegramm wiederaufsetzen - Start //********************************************************************** OutputDebugString( 2604, 8, "Wiederaufsetzen nach Kommunikationsfehler - WAS LETZTE TELEGRAMM"); //********************************************************************** // Flash Schreiben abschliessen (wiederaufsetzen) //********************************************************************** // Aktuelle Laenge des Datenblocks auf 0 setzen CDHBinBufWriteByte(RequestDownloadBuffer, 0, 13,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer, 0, 14,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer, 0, 15,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer, 0, 16,Status); TestCDHFehler (Status); CDHapiJobData (SgbdName, "FLASH_SCHREIBEN_ENDE", RequestDownloadBuffer, 21, ""); TestApiFehler (COAPI_ECU_FLASH_TRANSFER_EXIT_ERROR, ProcName, 2619, SgbdName + ", FLASH_SCHREIBEN_ENDE (...) - WAS"); //********************************************************************** // TesterPresent - Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); //********************************************************************** // Flash Adresse schreiben (wiederaufsetzen) //********************************************************************** // Aktuelle Adresse fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,AktuellAdrLow , 17,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,AktuellAdrMidLow , 18,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,AktuellAdrMidHigh, 19,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,AktuellAdrHigh , 20,Status); TestCDHFehler (Status); // Aktuelle Laenge des Datenblocks fuer Telegramm setzen CDHBinBufWriteByte(RequestDownloadBuffer,AktuellDataBlockLengthLow ,13,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,AktuellDataBlockLengthMidLow ,14,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,AktuellDataBlockLengthMidHigh,15,Status); TestCDHFehler (Status); CDHBinBufWriteByte(RequestDownloadBuffer,AktuellDataBlockLengthHigh ,16,Status); TestCDHFehler (Status); Text="Wiederaufsetzen an Adresse = "; hexstring(AktuellAdrHigh,StrWert); Text=Text+StrWert+":"; hexstring(AktuellAdrMidHigh,StrWert); Text=Text+StrWert+":"; hexstring(AktuellAdrMidLow,StrWert); Text=Text+StrWert+":"; hexstring(AktuellAdrLow,StrWert); Text=Text+StrWert+" Anzahl = "; hexstring(AktuellDataBlockLengthHigh,StrWert); Text=Text+StrWert+":"; hexstring(AktuellDataBlockLengthMidHigh,StrWert); Text=Text+StrWert+":"; hexstring(AktuellDataBlockLengthMidLow,StrWert); Text=Text+StrWert+":"; hexstring(AktuellDataBlockLengthLow,StrWert); Text=Text+StrWert; OutputDebugString( 2665, 8, Text); // JS TesterPresentHandling(ProcName, SgbdName, TRUE); AnzahlSoll = 0; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN_ADRESSE", RequestDownloadBuffer, 21, ""); TestApiFehlerNoExit (COAPI_ECU_FLASH_REQUEST_DOWNLOAD_ERROR, ProcName, 2672, SgbdName + ", FLASH_SCHREIBEN_ADRESSE (...)", Status); if ( Status != 0 ) { SetCDHFehler (Status, ProcName, 2675, SgbdName + ", FLASH_SCHREIBEN_ADRESSE (...)"); } //********************************************************************** // TesterPresent - Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); //********************************************************************** // Flash Block schreiben ( wiederaufgesetzt ) //********************************************************************** AnzahlSoll = AnzahlSoll + 1; CDHapiJobData (SgbdName, "FLASH_SCHREIBEN", Buffer, BufferSize, ""); TestApiFehlerNoExit (COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 2687, SgbdName + ", FLASH_SCHREIBEN (...)", Status); //********************************************************************** // TesterPresent - Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); //********************************************************************** // WAS - Letzte Telegramm wiederaufsetzen - Ende //********************************************************************** } // End of if ((WiederaufsetzenSwitch == TRUE) && (WiederaufsetzenBlockSwitch == FALSE)) //********************************************************************** // WIEDERAUFSETZEN - ENDE //********************************************************************** } //End of if (Status != 0) => ab jetzt "Normal" flashen if( Status == 0 ) { CDHapiResultInt (SgStatus, "FLASH_SCHREIBEN_STATUS", 1); if (SgStatus != 0x01) { OutputDebugInt( 2707, 8, "SchreibStatus ",SgStatus); Status = COAPI_ECU_FLASH_DOWNLOAD_ERROR; } CDHapiResultInt (AnzahlIst, "FLASH_SCHREIBEN_ANZAHL", 1); OutputDebugString( 2712, 9, "if (AnzahlIst < 0)"); if (AnzahlIst < 0) { //AnzahlIst = AnzahlIst + 65536; AnzahlIst = AnzahlIst + 65535; } if (SIMULATION == TRUE) { AnzahlIst = AnzahlSoll; } if (AnzahlIst != AnzahlSoll) { OutputDebugInt( 2726, 9, "AnzahlIst ",AnzahlIst); OutputDebugInt( 2727, 9, "AnzahlSoll ",AnzahlSoll); Status = COAPI_ECU_FLASH_DOWNLOAD_ERROR; } } else { SetCDHFehler (Status, ProcName, 2733, SgbdName + ", FLASH_SCHREIBEN (...)"); } //********************************************************************** // TesterPresent - Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); } // Sobald man mindestens 1 Datenblock geschrieben hat, ist man nicht am Anfang des Datenblocks SgmtWechsel = FALSE; // ShiftCounterStart : In der Wiederaufsetzung benutzt : Anfang eines Segments ShiftCounterStart = ShiftCounterStart + 1; // Wiederaufsetzen : "Shift" Verfahren if ((ShiftCounterStart == 1) && (WiederaufsetzenBlockSwitch == TRUE)) // 1 Datenblock ist geschrieben { OutputDebugString( 2750, 8, "if ((ShiftCounterStart == 1) && (WiederaufsetzenBlockSwitch == TRUE))"); if (BufferErst_A == TRUE) { //Reihenfolge: Buffer -> Buffer_A Index = 0; while (Index < BufferSize) { CDHBinBufReadByte(Buffer, value, Index, Status); CDHBinBufWriteByte(Buffer_A, value, Index, Status); TesterPresentHandling(ProcName, SgbdName, TRUE); Index = Index + 1; } BufferSize_A = BufferSize; BufferErst_A = TRUE; //OutputDebugInt( 2766, 8, "BufferSize_A am ENDE von if ((ShiftCounterStart = 1) & (WAS = TRUE) ", BufferSize_A); } else { //Reihenfolge: Buffer -> Buffer_B Index = 0; while (Index < BufferSize) { CDHBinBufReadByte(Buffer, value, Index, Status); CDHBinBufWriteByte(Buffer_B, value, Index, Status); TesterPresentHandling(ProcName, SgbdName, TRUE); Index = Index + 1; } BufferSize_B = BufferSize; BufferErst_B =TRUE; //OutputDebugInt( 2782, 8, "BufferSize_B am ENDE von if ((ShiftCounterStart = 1) & (WAS = TRUE) ", BufferSize_B); } //********************************************************************** // Fahrzeugbusse einschlafen lassen // Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); } // End of "if ((ShiftCounterStart == 1) && (WiederaufsetzenBlockSwitch == TRUE))" if ((ShiftCounterStart == 2) && (WiederaufsetzenBlockSwitch == TRUE)) // 2 Datenbloecke sind geschrieben { OutputDebugString( 2793, 8, "if ((ShiftCounterStart == 2) && (WiederaufsetzenBlockSwitch == TRUE))"); if (BufferErst_A == TRUE) { //Reihenfolge: Buffer -> Buffer_A Index = 0; while (Index < BufferSize) { CDHBinBufReadByte(Buffer, value, Index, Status); CDHBinBufWriteByte(Buffer_B, value, Index, Status); TesterPresentHandling(ProcName, SgbdName, TRUE); Index = Index + 1; } //Reihenfolge: Buffer -> Buffer_B -> Buffer_A BufferSize_B = BufferSize; BufferErst_B = TRUE; BufferErst_A = FALSE; OutputDebugInt( 2811, 8, "BufferSize_B am ENDE von if ((ShiftCounterStart = 2) & (WAS = TRUE) ", BufferSize_B); TesterPresentHandling(ProcName, SgbdName, TRUE); BufferStartAdrLow_B = AktuellAdrLow; BufferStartAdrMidLow_B = AktuellAdrMidLow; BufferStartAdrMidHigh_B = AktuellAdrMidHigh; BufferStartAdrHigh_B = AktuellAdrHigh; BufferDataBlockLenLow_B = AktuellDataBlockLengthLow; BufferDataBlockLenMidLow_B = AktuellDataBlockLengthMidLow; BufferDataBlockLenMidHigh_B = AktuellDataBlockLengthMidHigh; BufferDataBlockLenHigh_B = AktuellDataBlockLengthHigh; } else { //Reihenfolge: Buffer -> Buffer_B Index = 0; while (Index < BufferSize) { CDHBinBufReadByte(Buffer, value, Index, Status); CDHBinBufWriteByte(Buffer_A, value, Index, Status); TesterPresentHandling(ProcName, SgbdName, TRUE); Index = Index + 1; } //Reihenfolge: Buffer -> Buffer_A -> Buffer_B BufferSize_A = BufferSize; BufferErst_A = TRUE; BufferErst_B = FALSE; OutputDebugInt( 2841, 8, "BufferSize_A am ENDE von if ((ShiftCounterStart = 2) & (WAS = TRUE) ", BufferSize_A); TesterPresentHandling(ProcName, SgbdName, TRUE); BufferStartAdrLow_A = AktuellAdrLow; BufferStartAdrMidLow_A = AktuellAdrMidLow; BufferStartAdrMidHigh_A = AktuellAdrMidHigh; BufferStartAdrHigh_A = AktuellAdrHigh; BufferDataBlockLenLow_A = AktuellDataBlockLengthLow; BufferDataBlockLenMidLow_A = AktuellDataBlockLengthMidLow; BufferDataBlockLenMidHigh_A = AktuellDataBlockLengthMidHigh; BufferDataBlockLenHigh_A = AktuellDataBlockLengthHigh; } } // End of "if ((ShiftCounterStart == 2) && (WiederaufsetzenBlockSwitch == TRUE))" TesterPresentHandling(ProcName, SgbdName, TRUE); if ((ShiftCounterStart > 2) && (WiederaufsetzenBlockSwitch == TRUE)) // mehr als 2 Datenbloecke sind geschrieben { //OutputDebugString( 2861, 8, "if ((ShiftCounterStart > 2) && (WiederaufsetzenBlockSwitch == TRUE))"); if (BufferErst_A == TRUE) { //Reihenfolge: Buffer -> Buffer_A Index = 0; while (Index < BufferSize) { CDHBinBufReadByte(Buffer, value, Index, Status); CDHBinBufWriteByte(Buffer_B, value, Index, Status); TesterPresentHandling(ProcName, SgbdName, TRUE); Index = Index + 1; } //Reihenfolge: Buffer -> Buffer_B -> Buffer_A BufferSize_B = BufferSize; BufferErst_B = TRUE; BufferErst_A = FALSE; //OutputDebugInt( 2879, 8, "BufferSize_B am ENDE von if ((ShiftCounterStart > 2) & (WASBlockSwitch = TRUE)", BufferSize_B); TesterPresentHandling(ProcName, SgbdName, TRUE); BufferStartAdrLow_B = AktuellAdrLow; BufferStartAdrMidLow_B = AktuellAdrMidLow; BufferStartAdrMidHigh_B = AktuellAdrMidHigh; BufferStartAdrHigh_B = AktuellAdrHigh; BufferDataBlockLenLow_B = AktuellDataBlockLengthLow; BufferDataBlockLenMidLow_B = AktuellDataBlockLengthMidLow; BufferDataBlockLenMidHigh_B = AktuellDataBlockLengthMidHigh; BufferDataBlockLenHigh_B = AktuellDataBlockLengthHigh; } else { //Reihenfolge: Buffer -> Buffer_B Index = 0; while (Index < BufferSize) { CDHBinBufReadByte(Buffer, value, Index, Status); CDHBinBufWriteByte(Buffer_A, value, Index, Status); TesterPresentHandling(ProcName, SgbdName, TRUE); Index = Index + 1; } //Reihenfolge: Buffer -> Buffer_A -> Buffer_B BufferSize_A = BufferSize; BufferErst_A = TRUE; BufferErst_B = FALSE; //OutputDebugInt( 2909, 8, "BufferSize_A am ENDE von if ((ShiftCounterStart > 2) & (WASBlockSwitch = TRUE)", BufferSize_A); TesterPresentHandling(ProcName, SgbdName, TRUE); BufferStartAdrLow_A = AktuellAdrLow; BufferStartAdrMidLow_A = AktuellAdrMidLow; BufferStartAdrMidHigh_A = AktuellAdrMidHigh; BufferStartAdrHigh_A = AktuellAdrHigh; BufferDataBlockLenLow_A = AktuellDataBlockLengthLow; BufferDataBlockLenMidLow_A = AktuellDataBlockLengthMidLow; BufferDataBlockLenMidHigh_A = AktuellDataBlockLengthMidHigh; BufferDataBlockLenHigh_A = AktuellDataBlockLengthHigh; } } // End of if ((ShiftCounterStart > 2) & (WASBlockSwitch = TRUE)) TesterPresentHandling(ProcName, SgbdName, TRUE); // Aktuelle Laenge merken fuer wiederaufsetzen AktuellDataBlockLengthLow = AktuellDataBlockLengthLow - NrOfData; // Uebertrag auf MidLow if (AktuellDataBlockLengthLow < 0) { AktuellDataBlockLengthLow = AktuellDataBlockLengthLow + 0x100; AktuellDataBlockLengthMidLow = AktuellDataBlockLengthMidLow - 1; } // Uebertrag auf MidHigh if (AktuellDataBlockLengthMidLow < 0) { AktuellDataBlockLengthMidLow = AktuellDataBlockLengthMidLow + 0x100; AktuellDataBlockLengthMidHigh = AktuellDataBlockLengthMidHigh - 1; } // Uebertrag auf High if (AktuellDataBlockLengthMidHigh < 0) { AktuellDataBlockLengthMidHigh = AktuellDataBlockLengthMidHigh + 0x100; AktuellDataBlockLengthHigh = AktuellDataBlockLengthHigh - 1; } EndDataBlockLengthLow = EndDataBlockLengthLow + NrOfData; TesterPresentHandling(ProcName, SgbdName, TRUE); // Uebertrag auf MidLow if (EndDataBlockLengthLow > 0xFF) { EndDataBlockLengthLow = EndDataBlockLengthLow - 0x100; EndDataBlockLengthMidLow = EndDataBlockLengthMidLow + 1; } // Uebertrag auf MidHigh if (EndDataBlockLengthMidLow > 0xFF) { EndDataBlockLengthMidLow = EndDataBlockLengthMidLow - 0x100; EndDataBlockLengthMidHigh = EndDataBlockLengthMidHigh + 1; } // Uebertrag auf High if (EndDataBlockLengthMidHigh > 0xFF) { EndDataBlockLengthMidHigh = EndDataBlockLengthMidHigh - 0x100; EndDataBlockLengthHigh = EndDataBlockLengthHigh + 1; } // Ueberpruefung auf Blockende if ( (DataBlockLengthLow == EndDataBlockLengthLow ) && (DataBlockLengthMidLow == EndDataBlockLengthMidLow ) && (DataBlockLengthMidHigh == EndDataBlockLengthMidHigh ) && (DataBlockLengthHigh == EndDataBlockLengthHigh) ) { AdrSprungFlag = 1; // AdressSprung erkannt - Naechster Block von Daten OutputDebugString( 2981, 8, "AdrSprungFlag = 1 & WAS = TRUE"); } TesterPresentHandling(ProcName, SgbdName, TRUE); // Naechsten Datenblock lesen - Daten holen CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status); //********************************************************************************** //Auffuellen mit 0xFF bis MaxData (Laenge) //********************************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); if (AuffuellenSwitch == TRUE) { if ((NrOfData < MaxData) && (AdrSprungFlag == 0)) //if (NrOfData < MaxData) { Byte = 0xFF; OutputDebugInt( 3001, 8, "Auffuellen - BufferSize ", BufferSize); position = BufferSize - 1; // Um das alte letzte Byte zu überschreiben: ETX OutputDebugInt( 3004, 8, "Auffuellen - Position ", position); while (position <= MaxData + 21 - 1) // 20 von Info Bytes(Adresse,...) { // Letzte Byte ist fuer ETX = 03h CDHBinBufWriteByte(Buffer, Byte, position, Status); position = position + 1; BufferSize = BufferSize + 1; } CDHBinBufWriteByte(Buffer, 0x03, position, Status); //Letzte Byte ist immer ETX = 03h BufferSize = BufferSize + 1; OutputDebugInt( 3013, 8, "Auffuellen - BufferSize nach Auffuellen ",BufferSize); if (MaxData > 0xFF) { MaxDataHighByte = (MaxData / 256); MaxDataLowByte = (MaxData - (MaxDataHighByte * 256)); } else { MaxDataHighByte = 0x00; MaxDataLowByte = MaxData; } CDHBinBufWriteByte(Buffer, MaxDataLowByte, 13, Status); // Anzahl Bytedaten LowByte CDHBinBufWriteByte(Buffer, MaxDataHighByte, 14, Status); // Anzahl Bytedaten HighByte CDHBinBufWriteByte(Buffer, MaxDataLowByte, 15, Status); // Anzahl Wortdaten LowByte CDHBinBufWriteByte(Buffer, MaxDataHighByte, 16, Status); // Anzahl Wortdaten HighByte } // End_Of_if (NrOfData) } //********************************************************************************** //Ende von auffuellen mit 0xFF bis MaxData (Laenge) //********************************************************************************** // Aktuelle Adresse merken fuer wiederaufsetzen CDHBinBufReadByte(Buffer,AktuellAdrLow ,17,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrMidLow ,18,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrMidHigh,19,Status); TestCDHFehler (Status); CDHBinBufReadByte(Buffer,AktuellAdrHigh ,20,Status); TestCDHFehler (Status); TesterPresentHandling(ProcName, SgbdName, TRUE); //********************************************************************** // Überprüfung ob Segmentwechsel ohne Adress-Sprung //********************************************************************** if ((NrOfData != MaxData) && (NrOfData != 0) && (AdrSprungFlag == 0)) { OutputDebugString( 3055, 8, "Segmentwechsel ohne Adress-Sprung"); NextDataBlockLengthLow = EndDataBlockLengthLow + NrOfData; NextDataBlockLengthMidLow = EndDataBlockLengthMidLow; NextDataBlockLengthMidHigh = EndDataBlockLengthMidHigh; NextDataBlockLengthHigh = EndDataBlockLengthHigh; // Uebertrag auf MidLow if (NextDataBlockLengthLow > 0xFF) { NextDataBlockLengthLow = NextDataBlockLengthLow - 0x100; NextDataBlockLengthMidLow = NextDataBlockLengthMidLow + 1; } // Uebertrag auf MidHigh if (NextDataBlockLengthMidLow > 0xFF) { NextDataBlockLengthMidLow = NextDataBlockLengthMidLow - 0x100; NextDataBlockLengthMidHigh = NextDataBlockLengthMidHigh + 1; } // Uebertrag auf High if (NextDataBlockLengthMidHigh> 0xFF) { NextDataBlockLengthMidHigh = NextDataBlockLengthMidHigh - 0x100; NextDataBlockLengthHigh = NextDataBlockLengthHigh + 1; } // Ueberpruefung auf Blockende if ( (DataBlockLengthLow != NextDataBlockLengthLow ) || (DataBlockLengthMidLow != NextDataBlockLengthMidLow ) || (DataBlockLengthMidHigh != NextDataBlockLengthMidHigh ) || (DataBlockLengthHigh != NextDataBlockLengthHigh ) ) { //********************************************************************** // Segmentwechsel ohne Adress-Sprung gefunden //********************************************************************** // Adresse ermitteln NextAdrLow = StartAdrLow + NextDataBlockLengthLow; NextAdrMidLow = StartAdrMidLow; NextAdrMidHigh = StartAdrMidHigh; NextAdrHigh = StartAdrHigh; if (NextAdrLow > 0xFF) { NextAdrMidLow = NextAdrMidLow + 1; // Uebertrag nach MidLow NextAdrLow = NextAdrLow - 0x100; } if (NextAdrMidLow > 0xFF) { NextAdrMidHigh = NextAdrMidHigh + 1;// Uebertrag nach MidHigh NextAdrMidLow = NextAdrMidLow - 0x100; } if (NextAdrMidHigh > 0xFF) { NextAdrHigh = NextAdrHigh + 1; // Uebertrag nach High NextAdrMidHigh = NextAdrMidHigh - 0x100; } NextAdrMidLow = NextAdrMidLow + NextDataBlockLengthMidLow; if (NextAdrMidLow > 0xFF) { NextAdrMidHigh = NextAdrMidHigh + 1;// Uebertrag nach MidHigh NextAdrMidLow = NextAdrMidLow - 0x100; } if (NextAdrMidHigh > 0xFF) { NextAdrHigh = NextAdrHigh + 1; // Uebertrag nach High NextAdrMidHigh = NextAdrMidHigh - 0x100; } NextAdrMidHigh = NextAdrMidHigh + NextDataBlockLengthMidHigh; if (NextAdrMidHigh > 0xFF) { NextAdrHigh = NextAdrHigh + 1; // Uebertrag nach High NextAdrMidHigh = NextAdrMidHigh - 0x100; } NextAdrHigh = NextAdrHigh + NextDataBlockLengthHigh; Text="Segmentwechsel ohne Adress-Sprung = "; hexstring(NextAdrHigh ,StrWert); Text=Text+StrWert+":"; hexstring(NextAdrMidHigh,StrWert); Text=Text+StrWert+":"; hexstring(NextAdrMidLow ,StrWert); Text=Text+StrWert+":"; hexstring(NextAdrLow ,StrWert); Text=Text+StrWert; OutputDebugString ( 3145, 8, Text); TesterPresentHandling(ProcName, SgbdName, TRUE); CDHGetApiJobByteData (MaxData - NrOfData, ZwischenBuffer, ZwischenBufferSize, ZwischenBufferNrOfData, Status); TestCDHFehler (Status); TesterPresentHandling(ProcName, SgbdName, TRUE); // Daten umkopieren OutputDebugInt( 3155, 8, "ZwischenBufferNrOfData ", ZwischenBufferNrOfData); Index = 0; while (Index < ZwischenBufferNrOfData) { CDHBinBufReadByte(ZwischenBuffer, IntWert, Index + 21, Status); CDHBinBufWriteByte(Buffer, IntWert, Index + NrOfData + 21, Status); TestCDHFehler (Status); Index = Index + 1; } CDHBinBufWriteByte(Buffer, NrOfData + ZwischenBufferNrOfData, 13, Status); // Länge setzen CDHBinBufWriteByte(Buffer, 3, NrOfData + ZwischenBufferNrOfData + 21, Status); // ETX setzen (03h) NrOfData = NrOfData + ZwischenBufferNrOfData; TestCDHFehler (Status); TesterPresentHandling(ProcName, SgbdName, TRUE); } } //OutputDebugString( 3174, 9, " End of while (AdrSprungFlag != 1)"); } // End of while (AdrSprungFlag != 1) //********************************************************************** // Flash Schreiben abschliessen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); if ( BlockSchreibenFlag == TRUE ) { OutputDebugString( 3185, 8, "FLASH_SCHREIBEN_ENDE nach if ( BlockSchreibenFlag == TRUE )"); CDHapiJobData (SgbdName, "FLASH_SCHREIBEN_ENDE", RequestDownloadBuffer, 21, ""); TestApiFehler (COAPI_ECU_FLASH_TRANSFER_EXIT_ERROR, ProcName, 3187, SgbdName + ", FLASH_SCHREIBEN_ENDE (...)"); } //********************************************************************** // TesterPresent - Timer aufziehen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, TRUE); BlockSchreibenFlag = TRUE; // Naechster Block ist gueltig BlockCounter = BlockCounter + 1; // Naechster Datenblock OutputDebugInt( 3197, 8, "BlockCounter - End of while (NrOfData > 0) ", BlockCounter); } // End of while (NrOfData > 0) //********************************************************************** // Ende - Datenbloecke schreiben //********************************************************************** if ( Status != 0 ) { TestCDHFehler (Status); } //********************************************************************** // Fahrzeugbusse wieder wecken // Timer loeschen //********************************************************************** TesterPresentHandling(ProcName, SgbdName, FALSE); //********************************************************************** // Programmierstatus abfragen fuer Signaturpruefung //********************************************************************** CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS"); TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3220, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN"); CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1); OutputDebugInt( 3222, 8, "ProgrammierStatus ",SgStatus); // Programmierstatus auswerten //********************************************************************** // Signaturpruefung //********************************************************************** OutputDebugString( 3228, 8, "SignaturTestZeit : "+SignaturTestZeit); if (SgStatus == 0x06) // Signaturpruefung DAF nicht durchgefuehrt { CDHapiJob (SgbdName, "FLASH_SIGNATUR_PRUEFEN", "Daten;"+SignaturTestZeit, ""); TestApiFehler (COAPI_ECU_SIGNATUR_ERROR, ProcName, 3232, SgbdName + ", FLASH_SIGNATUR_PRUEFEN (Daten;"+SignaturTestZeit+")"); } else { if ((SgStatus == 0x05) || // Signaturpruefung PAF nicht durchgefuehrt ((SgStatus == 0x0C) && (ProgrammUndDaten == FALSE))) { CDHapiJob (SgbdName, "FLASH_SIGNATUR_PRUEFEN", "Programm;"+SignaturTestZeit, ""); TestApiFehler (COAPI_ECU_SIGNATUR_ERROR, ProcName, 3240, SgbdName + ", FLASH_SIGNATUR_PRUEFEN (Programm;"+SignaturTestZeit+")"); } else { if (SIMULATION == TRUE) { OutputDebugString( 3246, 8, "FLASH_PROGRAMMIER_STATUS_LESEN, Programmierstatus nicht plausibel (ignoriert im Simulationsmode)"); } else { Status = COAPI_ECU_PROG_STATUS_ERROR; SetCDHFehler (Status, ProcName, 3251, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN, Programmierstatus nicht plausibel"); } } } //********************************************************************** // Programmierstatus abfragen //********************************************************************** CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS"); TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3260, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN"); CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1); OutputDebugInt( 3262, 8, "ProgrammierStatus ",SgStatus); // Programmierstatus auswerten if ((SgStatus == 0x01) || // Normalbetrieb ((SgStatus == 0x0C) && (ProgrammUndDaten == FALSE))) { CDHGetCabdWordPar ("PROG_WITH_AIF" , PROG_WITH_AIF, Status); TestCDHFehler (Status); OutputDebugInt( 3270, 8, "PROG_WITH_AIF ",PROG_WITH_AIF); if ( PROG_WITH_AIF == 1 ) { //********************************************************************** // AIF schreiben //********************************************************************** CDHGetCabdPar ("AIF_FG_NR" , AifDaten, Status); TestCDHFehler (Status); StringArgument= AifDaten; CDHGetCabdPar ("AIF_DATUM" , AifDaten, Status); TestCDHFehler (Status); StringArgument= StringArgument + ";" + AifDaten; CDHGetCabdPar ("AIF_ZB_NR" , AifDaten, Status); TestCDHFehler (Status); StringArgument= StringArgument + ";" + AifDaten; CDHGetCabdWordPar ("AIF_GROESSE" , AifGroesse, Status); TestCDHFehler (Status); OutputDebugInt( 3289, 8, "AifGroesse ",AifGroesse); //********************************************************************** // Daten für grosses AIF // 0x12 18 dez kleines AIF // 0x33 51 dez grosses AIF // 0x40 64 dez grosses AIF ( gilt nur fuer Power-Pc ) // sonst Nicht zulaessig //********************************************************************** if ((AifGroesse == 0x40) || (AifGroesse == 0x33)) { CDHGetCabdPar ("AIF_SW_NR" , AifDaten, Status); TestCDHFehler (Status); StringArgument= StringArgument + ";" + AifDaten; CDHGetCabdPar ("AIF_BEHOERDEN_NR", AifDaten, Status); TestCDHFehler (Status); StringArgument= StringArgument + ";" + AifDaten; CDHGetCabdPar ("AIF_HAENDLER_NR" , AifDaten, Status); TestCDHFehler (Status); // 6 Byte BCD AifDaten = "000000" + AifDaten; strlen(AifDatenLen,AifDaten); midstr(AifDaten,AifDaten,AifDatenLen-6,6); StringArgument= StringArgument + ";" + AifDaten; CDHGetCabdPar ("AIF_SERIEN_NR" , AifDaten, Status); TestCDHFehler (Status); // 5 Byte ASCII AifDaten = " " + AifDaten; strlen(AifDatenLen,AifDaten); midstr(AifDaten,AifDaten,AifDatenLen-5,5); StringArgument= StringArgument + ";" + AifDaten; CDHGetCabdPar ("AIF_KM" , AifDaten, Status); TestCDHFehler (Status); StringArgument= StringArgument + ";" + AifDaten; CDHGetCabdPar ("AIF_PROG_NR" , AifDaten, Status); TestCDHFehler (Status); // 12 Byte ASCII AifDaten = " " + AifDaten; strlen(AifDatenLen,AifDaten); midstr(AifDaten,AifDaten,AifDatenLen-12,12); StringArgument= StringArgument + ";" + AifDaten; } OutputDebugString( 3331, 8, "Aif Argument : "+StringArgument); CDHapiJob (SgbdName, "AIF_SCHREIBEN", StringArgument, ""); TestApiFehler (COAPI_ECU_WRITE_AIF, ProcName, 3333, SgbdName + ", AIF_SCHREIBEN ("+StringArgument+")"); } //********************************************************************** // DIAGNOSE_ENDE //********************************************************************** CDHapiJob (SgbdName, "DIAGNOSE_ENDE", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 3340, SgbdName + ", DIAGNOSE_ENDE"); //********************************************************************** // STEUERGERAETE_RESET //********************************************************************** // Boot Sektor Update CDHGetCabdWordPar ("BSUTIME", BSUTime, Status); OutputDebugInt( 3347, 8, "BSUTime ", BSUTime); ResetZeit = ResetZeit + BSUTime; OutputDebugInt( 3350, 8, "ResetZeit ",ResetZeit); CDHapiJob (SgbdName, "STEUERGERAETE_RESET", "", ""); TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 3352, SgbdName + ", STEUERGERAETE_RESET"); if (ResetZeit > 0) CDHDelay(ResetZeit*1000+500); else CDHDelay(500); //********************************************************************** // Programmierstatus abfragen //********************************************************************** CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS"); TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3362, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN"); CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1); OutputDebugInt( 3364, 8, "ProgrammierStatus ",SgStatus); // Programmierstatus auswerten if (SgStatus != 1) { Status = COAPI_ECU_PROG_STATUS_ERROR; SetCDHFehler (Status, ProcName, 3370, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN"); } } CDHTestError (Status); CDHSetReturnVal (0); } //********************************************************************** //* //* Name : FlashStatusLesen //* //* Funktion : Status des SG und Festlegung der Programmierung: //* Programm-, Datenprogrammierung, Reihenfolge //* //* Parameter : HWNR_IS_NEW ( != 0 bedeutet neue HwNr -> Programmprog.) //* (soll nur Status gelesen werden auf 0 setzen) //* //* Rueckgabe : PRG_TYP (1 Daten, 2 Programm, 3 Programm + Daten), //* PRG_ORDER (1 Daten zuerst, 2 Programm zuerst) //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //* 03.07.2001 rd V2.00 Neue Programmierstati //********************************************************************** FlashStatusLesen() { string ProcName = "FlashStatusLesen"; int Status; string SgbdName; string StringResult; int IntResult; int SgStatus; int IsNewHwNr; int ProgTyp = 0; int ProgOrder = 0; OutputDebugString( 3410, 2, ProcName); CDHapiInit(); // CDH-Initialisierung CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); CDHGetCabdWordPar ("HWNR_IS_NEW", IsNewHwNr, Status); TestCDHFehler (Status); OutputDebugInt( 3417, 32, "IsNewHwNr ",IsNewHwNr); //********************************************************************** // Programmierstatus abfragen //********************************************************************** CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS"); TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3423, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN"); CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1); OutputDebugInt( 3425, 32, "ProgrammierStatus ",SgStatus); if (SgStatus >= 0x80) SgStatus = 0x01; // Für Zulieferer reserviert - Interpretation wie 0x01 CDHSetCabdWordPar ("SG_STATUS", SgStatus, Status); CDHTestError (Status); //********************************************************************** // Festlegung Programm-, Datenprogrammierung, Reihenfolge //********************************************************************** if ( ProgrammUndDaten == TRUE ) { if( SgStatus == 0x05 || // Signaturpruefung PAF nicht durchgefuehrt SgStatus == 0x07 || // Programmprogrammiersitzung aktiv SgStatus == 0x0A || // Programmreferenzeintrag fehlerhaft SgStatus == 0x0B || // Referenzierungsfehler Hardware -> Programm SgStatus == 0x0C ) // Programm nicht vollstaendig { ProgTyp = 3; // Programm + Daten ProgOrder = 2; // Programm zuerst } if( SgStatus == 0x00 || // Anlieferzustand SgStatus == 0x06 || // Signaturpruefung DAF nicht durchgefuehrt SgStatus == 0x08 || // Datenprogrammiersitzung aktiv SgStatus == 0x0D || // Datenreferenzeintrag fehlerhaft SgStatus == 0x0F ) // Daten nicht vollstaendig { if( IsNewHwNr != 0 ) { ProgTyp = 3; // Programm + Daten ProgOrder = 1; // Daten zuerst } else { ProgTyp = 1; // nur Daten ProgOrder = 1; // Daten zuerst } } if( SgStatus == 0x01 || // Normalbetrieb SgStatus == 0x0E ) // Referenzierungsfehler Programm -> Daten { if( IsNewHwNr != 0 ) { ProgTyp = 3; // Programm + Daten ProgOrder = 2; // Programm zuerst } else { ProgTyp = 1; // nur Daten ProgOrder = 1; // Daten zuerst } } } else { ProgTyp = 2; // nur Programm ProgOrder = 2; // Programm zuerst } CDHSetCabdWordPar ("PROG_TYP", ProgTyp, Status); TestCDHFehler (Status); OutputDebugInt( 3488, 32, "ProgTyp ",ProgTyp); CDHSetCabdWordPar ("PROG_ORDER", ProgOrder, Status); TestCDHFehler (Status); OutputDebugInt( 3492, 32, "ProgOrder ",ProgOrder); if (ProgTyp == 0 || ProgOrder == 0) { Status = COAPI_ECU_PROG_STATUS_ERROR; SetCDHFehler (Status, ProcName, 3497, "PROG_TYP, PROG_ORDER ungültig"); } CDHTestError (Status); CDHSetReturnVal (Status); } //********************************************************************** //* //* Name : cabimain //* //* Funktion : Hauptfunktion des Scripts //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //* 03.12.2001 rj V2.10 Erweiterung um neue Prozessortypen //* 08.08.2002 pf V3.00 Nur 2 Moeglichkeiten als ProzessorTyp //********************************************************************** cabimain() { string ProcName = "cabimain"; string JobName; int Status = 0; // Test ob Prozessortyp erlaubt if ( ProzessorTyp != "Standard" && ProzessorTyp != "HC12D128") { Status = COAPI_PROCESSOR_TYPE_ERROR; SetCDHFehler (Status, ProcName, 3531, "ProzessorTyp = " + ProzessorTyp); } OutputDebugString( 3534, 1, ProcName); CDHGetCabdPar ("JOBNAME", JobName, Status); TestCDHFehler (Status); if ( JobName == "JOB_ERMITTELN" ) Jobs(); else if ( JobName == "INFO" ) VersionInfo(); else if ( JobName == "SG_IDENT_LESEN" ) Ident(); else if ( JobName == "SG_AIF_LESEN" ) AifLesen(); else if ( JobName == "SG_AIF_SCHREIBEN" ) AifSchreiben(); else if ( JobName == "SG_STATUS_LESEN" ) FlashStatusLesen(); else if ( JobName == "SG_PROGRAMMIEREN" ) Programmieren(); else if ( JobName == "FEHLER_LOESCHEN" ) FehlerLoeschen(); else if ( JobName == "DATEN_REFERENZ" ) DatenReferenzLesen(); else if ( JobName == "HW_REFERENZ" ) HwReferenzLesen(); else if ( JobName == "ZIF" ) ZifLesen(); else if ( JobName == "ZIF_BACKUP" ) ZifBackupLesen(); else if ( JobName == "U_PROG_LESEN" ) UProgLesen(); else if ( JobName == "GET_DIAG_PROT" ) GetDiagProt(); else if ( JobName == "SET_DIAG_PROT" ) SetDiagProt(); else if ( JobName == "SET_ECU_ADDRESS" ) SetEcuAdr(); else if ( JobName == "SG_INNENTEMP_LESEN" ) Innentemp(); else if ( JobName == "SG_PHYS_HWNR_LESEN" ) PhysHwNrLesen(); else { Status = COAPI_CABD_PAR_ERROR; SetCDHFehler (Status, ProcName, 3559, "JobName = " + JobName); } CDHSetReturnVal (Status); exit(); } //********************************************************************** //* //* Name : cabiexit //* //* Funktion : Exit-Funktion des Scripts //* //* Parameter : - //* //* Rueckgabe : - //* //********************************************************************** //* History : //* 19.10.2000 rd V0.01 Ersterstellung //* 16.02.2001 rd V1.00 Freigabe //********************************************************************** cabiexit() { string ProcName = "cabiexit"; string SgbdName; int Status = 0; int i = 0; OutputDebugString( 3587, 1, ProcName); if (TesterPresentHandlingFlag==TRUE) { //********************************************************************** // Fahrzeugbusse wieder wecken // Timer loeschen // Tritt nur bei abgebrochener Programmierung auf //********************************************************************** CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET TestCDHFehler (Status); TesterPresentHandling(ProcName, SgbdName, FALSE); } // Löschen der dynamischen Buffer i=0; while(Status == 0) { CDHBinBufDelete(i,Status); i = i + 1; } CDHapiEnd(); } // -- EOF --