em/bmw-advanced-tools
1
0
Fork 0
Code Issues Pull Requests Releases Activity
67cb1ebca2
bmw-advanced-tools/app/EC-APPS/INPA/SGDAT/46CCA060.ips
gushmazuko 22b1b674ba First commit
2021-09-18 17:45:57 +02:00

4461 lines
193 KiB
Plaintext
Executable File
Raw Blame History

//**********************************************************************
//* ProgrammierAblaufBeschreibungsDatei PABD
//* für Flash-Prozess mit
//* Muster SteuerGeräteBeschreibungsDatei SGBD
//**********************************************************************
//* History:
//*
//* 18.06.2003 KuS V1.00 # Übernahme von 5.00 PABD
//*
//* 18.06.2003 KuS V1.01 # Fehler behoben
//*
//* 23.06.2003 KuS V1.02 # Reihenfolge von FlashLöschen und TesterPresent vertauscht
//*
//* 24.06.2003 KuS V1.03 # ENMT für zu programmierendes SG nach STEUER_DLE_TP eingefügt
//*
//* 25.06.2003 KuS V1.04 # "MaxData erhalten" Abfrage vor Buffer in DLEBuffer kopieren eingefügt
//*
//* 25.06.2003 KuS V1.05 # ENMT für alle SGs nach Beenden des Downloads eingefügt
//*
//* 26.06.2003 KuS V1.06 # Daten schreiben komplett neu imlementiert
//*
//* 30.06.2003 KuS V1.07 # Buffer auffüllen hinzugefügt und Restdatenschreiben an das Blockende verschoben
//*
//* 22.07.2003 KuS V1.08 # Änderungen für XXL Telegramme
//*
//* 23.07.2003 KuS V1.09 # Angleich an 06Flash
//*
//* 23.07.2003 KuS V1.10 # DLEBuffer laden geändert
//*
//* 23.07.2003 KuS v1.11 # XXL Blocklänge lesen, WinKFP 100% Korrektur
//*
//* 25.07.2003 KuS v1.12 # Standard Flashablauf ohne DLE hinzugefügt
//*
//* 28.07.2003 KuS v1.13 # cabiexit verändert.
//* # Korrektur Freibrennblock überspringen.
//*
//* 29.07.2003 KuS v1.14 # CDHGetCbdbPar für Aktivierung und Deaktivierung der DLE hinzugefügt
//*
//* 19.08.2003 KuS v1.15 # Verwendung von CDHBinBufAppend. Korrektur Freibrennblock überspringen.
//* # Normaler Download mit CDHBinBufCopy
//*
//* 22.01.2004 KuS v1.15.1 # SGBD Job Aufruf STEUERN_INTERNAL_RESET hinzugefügt
//*
//* 29.01.2004 DTZ/SV v1.16 # Umstellung auf scharfe Schlüssel
//* # Ausmaskierung PS für NOFIB-Prozeß
//* # kürzere Wartezeit nach positiver Signaturprüfung
//* 03.02.2004 JM v1.16.1 # NoExit und Status zu Job STEUERN_INTERNAL_RESET hinzugefügt
//*
//* 14.06.2004 KuS v1.17 # Automatische Auswahl des Nicht-DLE Ablauf wenn keine DLE vorhanden.
//* # Ablauf DLE und Std in getrennte Funktionen ausgelagert
//*
//* 18.08.2004 KuS v1.18 # TesterPresentHandling nur im Std Ablauf
//*
//* 25.10.2004 JM/MK v1.18b # Signaturtestzeit auf 6000 erhöht
//*
//* 27.10.2004 MK v1.18c # FIB-Generierung explizit nochmal anstoßen, wenn keine Antwort nach der Signaturprüfungszeit kommt
//* # Signaturtestzeit auf 3600 sec (1 Stunde) reduziert
//* # vor FIB-Generierung einen Gateway-Reset schicken und 30 sec warten
//*
//* 28.10.2004 MK v1.18d # wenn MOST-Flash, dann nach Gateway-Reset ein Gateway-Disable schicken und 3 sec warten
//*
//* 02.11.2004 MK v1.18e # 1. Auth.-Art 'SG_AUTHENTISIERUNG' fest für 'CDHCallAuthenticate' eingesetzt, da bei Daten-
//* # programmierung die Auth.-Art auf 'keine' gesetzt wird, wenn Job aus 'CCCA60'-SGBD aufgerufen wurde
//* # 2. 'CCCA60' nicht mehr als string-Variable sondern fest eincodiert
//*
//* 02.11.2004 MK v1.18f # statt Gateway-Reset jetzt doch lieber 'STEUERN_INTERNAL_RESET', dafür ist jetzt kein GW-Disable notwendig
//*
//* 03.11.2004 MK v1.18g # 1. Signaturtestzeit auf 4500 sec (75 min) erhöht (-> 2. Cold-Boot möglich)
//* # 2. wenn nach SigTimeout kein ProgStatus verfügbar (keine Antwort oder Busy-RepeatRequest),
//* # dann 'STEUERN_INTERNAL_RESET', 5 min warten, FIB generieren, 1 min warten und weiter
//*
//* 04.11.2004 MK v1.18h # 1. Korrektur der Ergebnisauswertung der Signaturprüfung
//* # 2. 'STEUERN_INTERNAL_RESET'-Anfrage max. 10-mal in 10 sec Abständen versuchen
//* # 3. FIB generieren nicht mehr explizit anstoßen, läuft nach Reset automatisch ab
//* # 4. bei einem Flashabbruch sicherheitshalber die DLE resetieren
//*
//* 19.11.2004 DTZ v1.19 # Durchlauf vorzeitig beenden, wenn PS von CCC_HOST ungleich 0x01; damit wird Update von CCC_APPS verhindert, wenn Host durch einen Flash-Fehlversuch noch den alten SW-Stand beinhaltet
//*
//* 23.11.2004 MK v1.20 # alle SGBD-Job-Aufrufe beziehen sich jetzt immer auf die Flash-SGBD
//* # d.h. alle Sonderjobs wurden in die Flash-SGBD integriert
//*
//* 25.11.2004 DTZ v1.21 # Bugfix in AddWordToDWord bei der Berechnung der Überträge
//*
//* 25.11.2004 DTZ v1.21b # Bugfix in SubWordFromDWord bei der Berechnung der Überträge
//* # Bugfix in FlashStd bei der Berechnung der Überträge
//*
//* 15.12.2004 DTZ v1.21c # zusätzlicher Abort im Rahmen der Signaturprüfung via TestApiFehler
//*
//* 07.01.2005 DTZ v1.21d # im Falle "HIP nicht per Diagnosekommando status_hip_hw_version erreichbar" HIP-FW-Upgrade explizit
//* # über start_hip_sw_loading anstoßen
//*
//* 10.01.2005 DTZ v1.21e # Verfeinerung von v1.21d
//*
//* 12.01.2005 MK v1.21f # falls bei Programmierbeginn auf ProgStatus mit Busy-RepeatRequest geantwortet wird,
//* # HOST-Internen Reset und FIB-Generierung anstoßen
//*
//* 03.03.2005 MK v1.22 # Spezial-PABD (v6.10) mit erweiterter Fehlercodegenerierung integriert
//*
//* 03.06.2005 DTZ v1.23 # cabiexit: im Fehlerfall den SH4 immer im Bootmode SWL_DEMAND hinterlassen
//*
//* 09.06.2005 DTZ v1.24 # Cleanup Infolog: Eintrag mit IlId 0x64 loeschen
//*
//* 09.06.2005 MK v1.24BMW # einmalige Ermittlung des Programmierzuganges (OPPS-MOST) für MXBL-Einstellung und Fehlergenerierug
//* # Korrektur Busruhe: Timer initialisieren jetzt vor DNMT
//* # bei Abbruch vor Flashstate 2 (Programmierung) 1 Min warten
//* # erweiterte Fehlercodes auch bei FlashLöschen
//* # neu: Fehlercodes 70x4/70x5, wenn nicht OPPS-MOST-Zugang benutzt wird
//* # neu: Fehlercode COAPI_ADDRESS_CALC_ERROR bei Adressberechnungsfehler statt COAPI_DEBUG_INFO
//* # DLE: verfeinerte Fehlercodes statt Sammelfehler COAPI_OPPS_DLE_STATUS_ERROR (7405)
//*
//* 16.06.2005 DTZ v1.25 # PSGBD_STEUERN_RESET_SH4_VIA_GW anstelle PSGBD_STEUERN_RESET_CCC
//* # Modifikation "SH4 immer im Bootmode SWL_DEMAND hinterlassen"
//*
//* 07.07.2005 DTZ v1.26 # Aenderungen im Rahmen V1.24 und V1.25 entfernen wegen Problemen
//* # im Parallel-Flash-Betrieb
//*
//* 19.07.2005 DTZ v1.27 # Aenderungen im Rahmen V1.24 und V1.25 wieder aktivieren, da GW-Problem im Rahmen
//* # Parallel-Flash-Betrieb geloest
//*
//* 05.08.2005 DTZ v1.28 # Wartezeit nach DNMT wegen GW-Antwort auf DNMT mit anschließender Kollision im Tester
//*
//* 26.09.2005 MK v1.29 # neu: Funktion, die EDIABAS-Jobs bei Kommunikationsfehlern automatisch wiederholt
//* # automatische Wiederholung bei FLASH_PROGRAMMIER_STATUS_LESEN und HOST_STEUERN_INTERNAL_RESET am Ende der Programmierung
//*
//* 15.11.2005 DTZ v1.30 # Unterstützung von Programmierstatus=0x02 bei Abbrüchen "Nicht-Diagnosefähigkeit nach
//* # Umschalten in den Programmiermode"
//*
//* 22.02.2006 DTZ v1.31 # Unterstützung des NoFIB-Prozesses innerhalb dieser PABD
//*
//**********************************************************************
// Version, Verantwortung, Steuergerätedaten
string ModulName = "131DLEXXL";
string Revision = "1.31";
string Author = "QE Michael Knöbl, BMW Stefan Jurchen";
string Comment = "Serienstand";
string SGFamilie = "CCA060";
int SG_MAXANZAHL_AIF = 14;
// Anzahl der im SG gespeicherten Anwender-Info-Felder
// Werte kleiner 2 nicht zulässig
int SG_GROESSE_AIF = 0x12;
// Größe eines Anwender-Info-Feldes
// 0x12 18dez - kleines AIF
// 0x33 51dez - großes AIF
// 0x40 64dez - großes AIF (Power PC)
int SG_ENDEKENNUNG_AIF = 0x01;
// Kennzeichnung des letzten Anwender-Info-Feldes
// 0xFE letztes AIF nicht überschreibbar
// 0x01 letztes AIF ist überschreibbar
string SG_AUTHENTISIERUNG = "Asymetrisch";
// Authentisierungsart des Steuergeräts
// "Simple"
// "Symetrisch"
// "Asymetrisch"
// "Keine"
bool ProgrammUndDaten = TRUE;
// Programmierung von Programm und/oder Daten
// TRUE Programm und Daten
// FALSE nur Programm
string ProzessorTyp = "Standard";
// Definiert den im Steuergerät verwendeten Prozessortyp
// "Standard"
// "HC12DG128" Auswirkung: RequestDownload bei 0x004000, 0x008000, 0x00C000
bool AuffuellenSwitch = FALSE;
// Aktiviert/Deaktiviert das Auffüllen der Telegramme bis zur MXBL vor der Übertragung
// TRUE aktiviert
// FALSE deaktiviert
bool WiederaufsetzenBlockSwitch = FALSE;
// Neues Wiederaufsetzen Verfahren, wo die beiden letzten fehlerfreien Telegramme wiederholt werden
// TRUE aktiviert
// FALSE deaktiviert
//**********************************************************************
//* E r w e i t e r t e E i n s t e l l u n g e n *
//**********************************************************************
int WartenNachECUProgrammMode = 0;
// Wartezeit nach Umschalten in den Programmiermodus in Sekunden
// 0 es wird die Resetzeit des SG abgewartet
// sonst es wird die Zeit in Sekunden gewartet
// default = 0
bool TestSchluesselAuthentisierung = TRUE;
// Aktiviert/Deaktiviert die automatische Testschlüsselauthentisierung
// TRUE aktiviert
// FALSE deaktiviert
// default = FALSE
bool WiederaufsetzenSwitch = FALSE;
// Altes Wiederaufsetzen Verfahren, wo nur das letzte Telegramm wiederholt wird
// TRUE aktiviert
// FALSE deaktiviert
// default = FALSE
bool SgInnenTemperaturLesen = FALSE;
// Definiert, ob das Steuergerät ein Auslesen der Innentemperatur unterstützt oder nicht
// TRUE unterstützt
// FALSE nicht unterstützt
// default = FALSE
bool SgPhysHwNrLesen = FALSE;
// Definiert, ob das Steuergerät ein Auslesen der physikalischen Hardwarenummer unterstützt oder nicht
// TRUE unterstützt
// FALSE nicht unterstützt
// default = FALSE
bool TesterPresentHandlingSwitch = TRUE;
// Aktiviert/Deaktiviert das Senden von DNMT - TesterPresent - ENMT
// TRUE aktiviert
// FALSE deaktiviert
// default = TRUE
bool DebugSwitch = FALSE;
// Aktiviert/Deaktiviert das Schreiben von Debug-Informationen in die error.log Datei
// TRUE aktiviert
// FALSE deaktiviert
// default = FALSE
bool DownloadEngineSwitch = TRUE;
// Aktiviert/Deaktiviert die DownloadEngine (Telegramme => Ringpuffer)
// TRUE aktiviert
// FALSE deaktiviert
// 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 ! ! ! *
//* *
//**********************************************************************
//**********************************************************************
//* *
//* Anfang des Codes *
//* *
//**********************************************************************
#include "cabi.h"
//**********************************************************************
//* G l o b a l e V a r i a b l e n *
//**********************************************************************
bool TesterPresentHandlingFlag = FALSE;
bool ProgSuccess = TRUE;
bool OppsMostAccess = FALSE;
int FlashState = 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_ADDRESS_CALC_ERROR = 2098; // Fehler bei Adressberechnung
int COAPI_PROCESSOR_TYPE_ERROR = 2099; // Prozessortyp fehlerhaft
int COAPI_EDIABAS_ERROR_MATRIX = 7000; // bis 7099 belegt
int COAPI_ECU_IDENT_ERROR = 7210; // SG: Ident lesen
int COAPI_ECU_HWREF_ERROR = 7211; // SG: HW-Referenz lesen
int COAPI_ECU_ZIF_ERROR = 7212; // SG: ZIF lesen
int COAPI_ECU_ZIFBACKUP_ERROR = 7213; // SG: ZIF-Backup lesen
int COAPI_ECU_RESET_ERROR = 7214; // SG: Reset ausführen
int COAPI_ECU_TIMES_ERROR = 7215; // SG: Zeiten lesen
int COAPI_ECU_MXBL_ERROR = 7216; // SG: MaxBlocklänge
int COAPI_ECU_SERIAL_ERROR = 7217; // SG: Seriennummer lesen
int COAPI_ECU_RANDOM_ERROR = 7218; // SG: Zufallszahl lesen
int COAPI_ECU_STOPDIAG_ERROR = 7219; // SG: Stop Diagnose
int COAPI_ECU_PHYHWNR_ERROR = 7220; // SG: Physikalische HW-Nummer lesen
int COAPI_ECU_INNENTEMP_ERROR = 7221; // SG: Innentemperatur lesen
int COAPI_SGBD_FLASHPARAM_ERROR = 7228; // P-SGBD: Flashparameter setzen
int COAPI_SGBD_DIAGPROT_ERROR = 7229; // P-SGBD: Diagnoseprotokoll setzen
int COAPI_OPPS_STATUS_ERROR = 7400; // OPPS: OPPS Version bzw. Zugang ermitteln
int COAPI_OPPS_SET_TP_ERROR = 7401; // OPPS: Busruhe setzen, ein- und ausschalten
int COAPI_OPPS_DLE_VERSION_ERROR = 7402; // OPPS: DLE-Version und -Verfügbarkeit ermitteln
int COAPI_OPPS_DLE_RESET_ERROR = 7403; // OPPS: DLE-Reset
int COAPI_OPPS_DLE_INIT_ERROR = 7404; // OPPS: DLE-Initialisierung
// COAPI_OPPS_DLE_STATUS_ERROR = 7405; // OPPS: DLE STATUS Fehler
int COAPI_OPPS_DLE_OVERFLOW_ERROR = 7406; // OPPS: DLE FIFO Overflow
int COAPI_OPPS_DLE_FINISH_ERROR = 7407; // OPPS: DLE wird nicht fertig
int COAPI_OPPS_DLE_IFH_STATUS_ERROR = 7408; // OPPS-DLE: DLE_STATUS IFH-Fehler
int COAPI_OPPS_DLE_NET_STATUS_ERROR = 7409; // OPPS-DLE: DLE_STATUS NET-Fehler
int COAPI_OPPS_DLE_API_STATUS_ERROR = 7410; // OPPS-DLE: DLE_STATUS API-Fehler
int COAPI_OPPS_DLE_OTHER_STATUS_ERROR = 7411; // OPPS-DLE: andere DLE_STATUS Fehler
int COAPI_DLE_TIMEOUT_ERROR = 7412; // - 7419; OPPS-DLE: DLE_STATUS TIMEOUT
int COAPI_DLE_IFERR_ERROR = 7422; // - 7429; OPPS-DLE: DLE_STATUS IFERR
int COAPI_DLE_COMERR_ERROR = 7432; // - 7439; OPPS-DLE: DLE_STATUS COMERR
int COAPI_DLE_BLOCK_NIO_ERROR = 7440; // OPPS-DLE: SG Blockprogrammierung n.i.O.
int COAPI_DLE_BLOCK_NR_ERROR = 7441; // OPPS-DLE: SG Blockprogrammierung Negative Response
int COAPI_DLE_BLOCK_SID_ERROR = 7442; // OPPS-DLE: SG Blockprogrammierung SID falsch
int COAPI_DLE_SHORT_RESPONSE_ERROR = 7443; // OPPS-DLE: SG Blockprogrammierung Tlg zu kurz
int COAPI_DLE_NO_RESPONSE_ERROR = 7444; // OPPS-DLE: SG Blockprogrammierung kein Tlg
int COAPI_CCC_SET_END_SWL_ERROR = 7800; // CCC: SET_END_SWL
int COAPI_CCC_INTRESET_ERROR = 7900; // CCC: HOST-internen Reset
int COAPI_CCC_FIBGEN_ERROR = 7901; // CCC: FIB generieren anstoßen
int COAPI_CCC_FIBCREATE_ERROR = 7902; // CCC: FIB generieren nicht erfolgreich
int COAPI_CCC_HOST_STATUS_ERROR = 7903; // CCC: HOST-Programmierstatus nicht i.O. für APPL-Programmierung
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
//* Info - Auszugebender Text
//*
//* Rueckgabe : -
//*
//**********************************************************************
//* History :
//* 19.10.2000 rd V0.01 Ersterstellung
//* 16.02.2001 rd V1.00 Freigabe
//**********************************************************************
OutputDebugString(in: int LineNr, in: string Info)
{
string temp;
if (DebugSwitch == TRUE)
{
temp=Info;
CDHSetError (COAPI_DEBUG_INFO, "Debug-Info", temp, LineNr, "");
}
}
//**********************************************************************
//*
//* Name : OutputDebugInt
//*
//* Funktion : Debugausgabe in Datei error.log
//*
//* Parameter : LineNr - ZeilenNr im PABD-File
//* 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: string Info, in: int Wert)
{
string temp;
if (DebugSwitch == TRUE)
{
inttostring(Wert,temp);
temp=Info+temp;
OutputDebugString(LineNr, temp);
}
}
//**********************************************************************
//*
//* Name : OutputDebugBool
//*
//* Funktion : Debugausgabe in Datei error.log
//*
//* Parameter : LineNr - ZeilenNr im PABD-File
//* 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: string Info, in: bool Wert)
{
string temp;
if (DebugSwitch == TRUE)
{
if (Wert == TRUE)
temp=Info+"TRUE";
else
temp=Info+"FALSE";
OutputDebugString(LineNr, 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 : SetFlashState
//*
//* Funktion : Setzen des Flash-Zustandes
//*
//* Parameter : State - Zustand
//*
//* Rueckgabe : -
//*
//**********************************************************************
SetFlashState( in: int State)
{
int Status;
CDHSetCabdWordPar("FLASH_STATE" , State, Status);
FlashState = State;
}
//**********************************************************************
//*
//* Name : GetFlashState
//*
//* Funktion : Wiederherstellen des Flash-Zustandes
//*
//* Parameter : -
//*
//* Rueckgabe : -
//*
//**********************************************************************
GetFlashState()
{
int Status;
CDHGetCabdWordPar("FLASH_STATE" , FlashState, Status);
}
//**********************************************************************
//*
//* Name : RepeatedApiJobOnError
//*
//* Funktion : Wiederholt automatisch EDIABAS-Jobs bei Kommunikationsfehlern
//*
//* Parameter : SgbdName - SGBD Name
//* JobName - Job Name
//* JobArguments - Job Argumente
//* JobResults - Job Ergebnisse
//* RepeatCount - Anzahl der Wiederholungen
//* RepeatDelay - Pause in Sekunden zwischen den Wiederholungen
//*
//* Rueckgabe : -
//*
//**********************************************************************
RepeatedApiJobOnError(in: string SgbdName, in: string JobName, in: string JobArguments, in: string JobResults)
{
int RepeatCount = 10;
int RepeatDelay = 5;
//RepeatedApiJobOnError(in: string SgbdName, in: string JobName, in: string JobArguments, in: string JobResults, in: int RepeatCount, in: int RepeatDelay)
//{
int EndLoop, Counter, ErrorCode;
bool rc;
string tmp;
EndLoop = 0;
Counter = 0;
while((EndLoop == 0) && (Counter <= RepeatCount))
{
// Job ausführen
CDHapiJob(SgbdName, JobName, JobArguments, JobResults);
// Ergebnis prüfen (sonst ist Fehlercode immer 0 !!!)
apiResultText(rc, tmp, "JOB_STATUS", 1, "");
// Fehlercode holen (0 -> kein Fehler)
apiErrorCode(ErrorCode);
// 134: API-0014: RESULT NOT FOUND
// 159: NET-0009: TIMEOUT
// -> EDIABAS\Doku\Error.pdf
// API-0014 ?
if(ErrorCode == 134)
CDHDelay(RepeatDelay * 1000);
// i.O. oder anderer Fehler !
else
EndLoop = 1;
// Durchläufe zählen
Counter = Counter + 1;
}
}
//**********************************************************************
//*
//* 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)
{
bool rc;
string ApiStatusText;
string SgbdName;
int ErrCode, iTmp;
string strTmp, strTmp2;
// existiert JOB_STATUS bzw. hat SG geantwortet ?
apiResultText(rc, ApiStatusText, "JOB_STATUS", 1, "");
if(rc == TRUE)
{
// JA: Ergebnis nicht OKAY ?
if(ApiStatusText != "OKAY")
{
// Fehlertext und -code nach Vorgabe setzten
CDHSetError(CStatus, ModulName, ProcName, LineNr, Info + ": " + ApiStatusText);
CDHSetReturnVal(CStatus);
exit();
}
}
else
{
// NEIN: JOB_STATUS gibt's nicht !
// -> neue Fehlercodes generieren (Kommunikationsfehler)
// EDIABAS-Fehler auslesen
apiErrorText(ApiStatusText);
apiErrorCode(ErrCode);
// IFH-0009: keine Antwort vom SG ?
if(ErrCode == 19) {
// Name der Flash-SGBD besorgen, damit Jobs daraus verwendet werden können
CDHGetSgbdName(SgbdName, iTmp);
// SG-Adresse zwischenspeichern
CDHapiJob(SgbdName, "FLASH_PARAMETER_LESEN", "", "");
CDHapiResultInt(iTmp, "SG_ADRESSE", 1);
// Kommunikation mit MOST-CAN-Gateway prüfen
CDHapiJob(SgbdName, "FLASH_PARAMETER_SETZEN", "0x62;2;18;1;simple", "");
CDHapiJob(SgbdName, "IDENT", "", "");
apiResultText(rc, strTmp, "JOB_STATUS", 1, "");
if(rc == TRUE)
ErrCode = 2; // 2: OPPS-MOST-Zugang; keine Antwort vom SG, GW i.O.
else
ErrCode = 3; // 3: OPPS-MOST-Zugang; keine Antwort vom SG und GW
// OPPS-MOST-Zugang prüfen
if(OppsMostAccess == FALSE)
ErrCode = ErrCode + 2; // 4 bzw. 5: kein OPPS-MOST-Zugang
// ursprüngliche Parameter wieder einstellen
inttostring(iTmp, strTmp);
inttostring(SG_MAXANZAHL_AIF, strTmp2);
strTmp = strTmp + ";" + strTmp2;
inttostring(SG_GROESSE_AIF, strTmp2);
strTmp = strTmp + ";" + strTmp2;
inttostring(SG_ENDEKENNUNG_AIF, strTmp2);
strTmp = strTmp + ";" + strTmp2;
strTmp = strTmp + ";" + SG_AUTHENTISIERUNG;
CDHapiJob(SgbdName, "FLASH_PARAMETER_SETZEN", strTmp, "");
}
// anderer IFH-Fehler ?
else if((ErrCode >= 10) && (ErrCode <= 59))
ErrCode = 6;
// NET-Fehler ?
else if((ErrCode >= 150) && (ErrCode <= 199))
ErrCode = 7;
// API-Fehler ?
else if((ErrCode >= 120) && (ErrCode <= 149))
ErrCode = 8;
// anderer EDIABAS-Fehler
else
ErrCode = 9;
// Fehlercode gemäß FlashState generieren und ausgeben
GetFlashState();
ErrCode = COAPI_EDIABAS_ERROR_MATRIX + (FlashState * 10) + ErrCode;
CDHSetError(ErrCode, ModulName, ProcName, LineNr, Info + ": " + ApiStatusText);
CDHSetReturnVal(ErrCode);
// Programmierung noch nicht mal begonnen ?
if(FlashState < 2)
CDHDelay(60*1000); // dann 1 Min warten
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;
// Rückgabewert vorbelegen: JOB war i.O.
RetVal = 0;
// existiert JOB_STATUS bzw. hat SG geantwortet ?
apiResultText(rc, ApiStatusText, "JOB_STATUS", 1, "");
if(rc == TRUE)
{
// JA: Ergebnis nicht OKAY ?
if(ApiStatusText != "OKAY")
{
// Fehlertext und -code nach Vorgabe setzten
CDHSetError(CStatus, ModulName, ProcName, LineNr, Info + ": " + ApiStatusText);
CDHSetReturnVal(CStatus);
RetVal = CStatus;
}
}
else
{
// NEIN: JOB_STATUS gibt's nicht !
// EDIABAS-Fehler auslesen
apiErrorText(ApiStatusText);
// EDIABAS-Fehlertext und Fehlercode setzten
CDHSetError(CStatus, ModulName, ProcName, LineNr, Info + ": " + ApiStatusText);
CDHSetReturnVal(CStatus);
RetVal = CStatus;
}
}
CheckForOppsMostAccess(in: string ProcName, in: string SgbdName)
{
string Stat_Typ;
string Stat_Interface;
int Stat_Version;
// Initialisierung: Programmierung nicht über OPPS-MOST-Zugang
OppsMostAccess = FALSE;
// Interfacetyp und Interfaceversion ermitteln
CDHapiJob("OPPS", "STATUS_TYP_VER", "", "");
TestApiFehler(COAPI_OPPS_STATUS_ERROR, ProcName, 687, SgbdName + ", STATUS_TYP_VER");
CDHapiResultText(Stat_Typ, "STAT_TYP", 1, "");
OutputDebugString(689, "Interface-Typ : " + Stat_Typ);
CDHapiResultInt(Stat_Version, "STAT_VERSION", 1);
OutputDebugInt(691, "Interface-Version : ", Stat_Version);
// OPPS ab Version 4.12 verfügbar ?
if((Stat_Typ == "OPPS") && (Stat_Version >= 412))
{
// OPPS-Zugang ermitteln
CDHapiJob("OPPS", "STATUS_ROUTER", "", "");
TestApiFehler(COAPI_OPPS_STATUS_ERROR, ProcName, 698, SgbdName + ", STATUS_ROUTER");
CDHapiResultText(Stat_Interface, "STAT_INTERFACE", 1, "");
OutputDebugString(700, "Interface-Zugang : " + Stat_Interface);
if(Stat_Interface == "MOST")
{
// Programmierung über OPPS-MOST-Zugang
OppsMostAccess = TRUE;
}
}
}
//**********************************************************************
//*
//* 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 und Timer aufziehen
// OutputDebugString(550, "--> Disable Normal Message Transmission");
settimer(DNMTTimerNr, DNMTTimerZeit);
settimer(TesterPresentTimerNr, TesterPresentTimerZeit);
CDHapiJob(SgbdName, "NORMALER_DATENVERKEHR", "NEIN;NEIN;JA", "");
// TestApiFehler(COAPI_ECU_TIMEOUT, ProcName, 552, SgbdName + ", NORMALER_DATENVERKEHR (NEIN;NEIN;JA)");
CDHapiJob(SgbdName, "NORMALER_DATENVERKEHR", "JA;NEIN;NEIN", "");
// TestApiFehler(COAPI_ECU_TIMEOUT, ProcName, 556, SgbdName + ", NORMALER_DATENVERKEHR (JA;NEIN;NEIN)");
// DTZ, 05.08.05: Wartezeit nach DNMT wegen GW-Antwort auf DNMT mit anschließender Kollision im Tester
CDHDelay(1000);
}
else
{
testtimer(TesterPresentTimerNr, TesterPresentTimerAbgelaufen);
if (TesterPresentTimerAbgelaufen == TRUE)
{
// TesterPresent absetzen und Timer wieder aufziehen
// OutputDebugString(571, "--> Tester Present");
settimer(DNMTTimerNr, DNMTTimerZeit);
settimer(TesterPresentTimerNr, TesterPresentTimerZeit);
CDHapiJob(SgbdName, "DIAGNOSE_AUFRECHT", "NEIN;JA", "");
// TestApiFehler(COAPI_ECU_TIMEOUT, ProcName, 575, SgbdName + ", DIAGNOSE_AUFRECHT (NEIN;JA)");
}
}
}
else
{
// Fahrzeugbusse wieder wecken und Timer loeschen
TesterPresentHandlingFlag = FALSE; // Deaktiviert
// OutputDebugString(590, "--> Enable Normal Message Transmission");
CDHapiJob(SgbdName, "NORMALER_DATENVERKEHR", "JA;NEIN;JA", "");
// TestApiFehler(COAPI_ECU_TIMEOUT, ProcName, 592, SgbdName + ", NORMALER_DATENVERKEHR (JA;NEIN;JA)");
settimer(DNMTTimerNr, 0);
settimer(TesterPresentTimerNr, 0);
// warten, bis alle Steuergeräte wieder hochgefahren und diagnosefähig sind
// lt. LH muß dies nach spätestens 5 sec geschehen sein
// -> 6 sec mit Reserve
CDHDelay(6000);
}
}
}
//**********************************************************************
//*
//* 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(619, 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(663, 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(694, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHapiJob(SgbdName, "DIAGNOSEPROTOKOLL_LESEN", "", "");
TestApiFehler (COAPI_SGBD_DIAGPROT_ERROR, ProcName, 700, SgbdName + ", DIAGNOSEPROTOKOLL_LESEN");
CDHapiResultInt(ProtAnzahl , "DIAG_PROT_ANZAHL", 1);
CDHSetCabdWordPar("DIAG_PROT_ANZAHL", ProtAnzahl , Status);
OutputDebugInt(704, "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(715, 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(744, 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_SGBD_DIAGPROT_ERROR, ProcName, 753, SgbdName + ", DIAGNOSEPROTOKOLL_SETZEN (" + DiagProt + ")");
OutputDebugString(754, "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;
SetFlashState(0);
OutputDebugString(783, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHGetCabdPar ("ECU_ADDRESS", EcuAdr, Status);
TestCDHFehler (Status);
OutputDebugString(790, "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_SGBD_FLASHPARAM_ERROR, ProcName, 802, SgbdName + ", FLASH_PARAMETER_SETZEN (" + StringArgument + ")");
CDHTestError (Status);
CDHSetReturnVal (Status);
SetFlashState(1);
CheckForOppsMostAccess(ProcName, SgbdName); // Programmierzugang ermitteln (für erweiterte Fehlercodes)
}
//**********************************************************************
//*
//* 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(827, 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(858, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
RepeatedApiJobOnError(SgbdName, "IDENT", "", "");
TestApiFehler (COAPI_ECU_IDENT_ERROR, ProcName, 864, 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);
SetFlashState(2);
}
//**********************************************************************
//*
//* 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(940, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHapiJob(SgbdName, "FS_LOESCHEN", "", "");
TestApiFehler (COAPI_ECU_DELETE_DTC_ERROR, ProcName, 946, 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(979, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHGetCabdPar ("AIF_NUMMER", AifNr, Status);
TestCDHFehler (Status);
RepeatedApiJobOnError(SgbdName, "AIF_LESEN", AifNr, "");
TestApiFehler (COAPI_ECU_READ_AIF, ProcName, 988, 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(1062, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHapiJob(SgbdName, "HARDWARE_REFERENZ_LESEN", "", "");
TestApiFehler (COAPI_ECU_HWREF_ERROR, ProcName, 1068, 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(1108, 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, 1145, SgbdName + ", DATEN_REFERENZ_LESEN");
}
}
else
TestApiFehler (COAPI_ECU_DATA_REFERENZ_ERROR, ProcName, 1149, 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(1178, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHapiJob(SgbdName, "ZIF_LESEN", "", "");
TestApiFehler (COAPI_ECU_ZIF_ERROR, ProcName, 1184, 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(1230, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHapiJob(SgbdName, "ZIF_BACKUP_LESEN", "", "");
TestApiFehler (COAPI_ECU_ZIFBACKUP_ERROR, ProcName, 1236, 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(1279, ProcName);
OutputDebugString(1280, "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;
int Status;
if (SgInnenTemperaturLesen == TRUE)
{
OutputDebugString(1312, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHapiJob(SgbdName, "INNENTEMP_LESEN", "", ""); //Innentemperatur aus SG lesen
TestApiFehler (COAPI_ECU_INNENTEMP_ERROR, ProcName, 1318, 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;
int Status;
if (SgPhysHwNrLesen == TRUE)
{
OutputDebugString(1363, 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_PHYHWNR_ERROR, ProcName, 1369, 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 : TestDleFehler
//*
//* Funktion : Ueberpruefen, ob ein Fehler bei STEUERN_DLE_LADEN aufgetreten ist
//*
//* Parameter : DleStatus - DLE-S
//* 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
//**********************************************************************
TestDleFehler(in: string ProcName, in: int LineNr)
{
int ErrCode, iTmp1, iTmp2;
bool rc;
string DleStatus;
string SgbdName;
string strTmp1, strTmp2;
// Initialisierung: kein Fehler
ErrCode = 0;
// DLE-Status holen
apiResultText(rc, DleStatus, "DLE_STATUS", 1, "");
if(rc == FALSE)
{
// DLE_STATUS gibt's nicht !
// -> Kommunikationsfehler analysieren
// EDIABAS-Fehler auslesen
apiErrorText(DleStatus);
apiErrorCode(iTmp2);
// IFH-Fehler ?
if((iTmp2 >= 10) && (iTmp2 <= 59))
ErrCode = COAPI_OPPS_DLE_IFH_STATUS_ERROR;
// NET-Fehler ?
else if((iTmp2 >= 150) && (iTmp2 <= 199))
ErrCode = COAPI_OPPS_DLE_NET_STATUS_ERROR;
// API-Fehler ?
else if((iTmp2 >= 120) && (iTmp2 <= 149))
ErrCode = COAPI_OPPS_DLE_API_STATUS_ERROR;
// andere EDIABAS-Fehler
else
ErrCode = COAPI_OPPS_DLE_OTHER_STATUS_ERROR;
}
// DLE-Status auswerten
else
{
// DLE-Status: TIMEOUT oder IFERR oder COMERR ?
if(DleStatus == "TIMEOUT") ErrCode = COAPI_DLE_TIMEOUT_ERROR; // 8 Codes
else if(DleStatus == "IFERR") ErrCode = COAPI_DLE_IFERR_ERROR; // 8 Codes
else if(DleStatus == "COMERR") ErrCode = COAPI_DLE_COMERR_ERROR; // 8 Codes
if(ErrCode != 0)
{
// Name der Flash-SGBD besorgen, damit Jobs daraus verwendet werden können
CDHGetSgbdName(SgbdName, iTmp1);
// antwortet SG auf ProgStatus_lesen ?
CDHapiJob(SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "");
apiResultText(rc, strTmp1, "JOB_STATUS", 1, "");
if(rc == FALSE)
{
// NEIN: JOB_STATUS gibt's nicht !
// -> Kommunikationsfehler analysieren
// EDIABAS-Fehler auslesen
apiErrorCode(iTmp2);
// IFH-0009: keine Antwort vom SG ?
if(iTmp2 == 19) {
// SG-Adresse zwischenspeichern
CDHapiJob(SgbdName, "FLASH_PARAMETER_LESEN", "", "");
CDHapiResultInt(iTmp1, "SG_ADRESSE", 1);
// Kommunikation mit MOST-CAN-Gateway prüfen
CDHapiJob(SgbdName, "FLASH_PARAMETER_SETZEN", "0x62;2;18;1;simple", "");
CDHapiJob(SgbdName, "IDENT", "", "");
apiResultText(rc, strTmp1, "JOB_STATUS", 1, "");
if(rc == TRUE)
iTmp2 = 0; // 2: OPPS-MOST-Zugang; keine Antwort vom SG, GW i.O.
else
iTmp2 = 1; // 3: OPPS-MOST-Zugang; keine Antwort vom SG und GW
// OPPS-MOST-Zugang prüfen
if(OppsMostAccess == FALSE)
iTmp2 = iTmp2 + 2; // 4 bzw. 5: kein OPPS-MOST-Zugang
// ursprüngliche Parameter wieder einstellen
inttostring(iTmp1, strTmp1);
inttostring(SG_MAXANZAHL_AIF, strTmp2);
strTmp1 = strTmp1 + ";" + strTmp2;
inttostring(SG_GROESSE_AIF, strTmp2);
strTmp1 = strTmp1 + ";" + strTmp2;
inttostring(SG_ENDEKENNUNG_AIF, strTmp2);
strTmp1 = strTmp1 + ";" + strTmp2;
strTmp1 = strTmp1 + ";" + SG_AUTHENTISIERUNG;
CDHapiJob(SgbdName, "FLASH_PARAMETER_SETZEN", strTmp1, "");
}
// anderer IFH-Fehler ?
else if((iTmp2 >= 10) && (iTmp2 <= 59))
iTmp2 = 4;
// NET-Fehler ?
else if((iTmp2 >= 150) && (iTmp2 <= 199))
iTmp2 = 5;
// API-Fehler ?
else if((iTmp2 >= 120) && (iTmp2 <= 149))
iTmp2 = 6;
// anderer EDIABAS-Fehler
else
iTmp2 = 7;
// Fehlercode generieren
ErrCode = ErrCode + iTmp2;
}
}
// DLE-Status: MISMATCH ?
if(DleStatus == "MISMATCH")
{
// Buffer für SG-Antwort generieren
CDHBinBufCreate(iTmp2,ErrCode);
TestCDHFehler(ErrCode);
// OPPS-Antwort holen
CDHapiResultBinary(iTmp2, "_TEL_ANTWORT", 1, ErrCode);
TestCDHFehler(ErrCode);
// Antwortlänge prüfen
CDHBinBufReadByte(iTmp2, iTmp1, 14, ErrCode);
if(iTmp1 < 4) ErrCode = COAPI_DLE_NO_RESPONSE_ERROR; // nur max. 3 unbekannte Bytes
else if(iTmp1 < 7) ErrCode = COAPI_DLE_SHORT_RESPONSE_ERROR; // 4 - max. 6 Bytes (FMT, TGT und SRC)
else
{
// SID auswerten
CDHBinBufReadByte(iTmp2, iTmp1, 22, ErrCode);
if(iTmp1 == 0x76) ErrCode = COAPI_DLE_BLOCK_NIO_ERROR; // Positive Response -> Byte 3 =! 1 -> n.i.O.
else if(iTmp1 == 0x7F) ErrCode = COAPI_DLE_BLOCK_NR_ERROR; // Negative Response
else ErrCode = COAPI_DLE_BLOCK_SID_ERROR; // SID falsch
}
}
}
// DLE-Fehler aufgetreten ?
if(ErrCode != 0)
{
// Fehlercode ausgeben und Flashen abbrechen
CDHSetError(ErrCode, ModulName, ProcName, LineNr, "STEUERN_DLE_LADEN (DLE_STATUS): " + DleStatus);
CDHSetReturnVal(ErrCode);
exit();
}
}
//**********************************************************************
//*
//* Name : WaitDLEFinished
//*
//* Funktion : Warten bis die DLE mit Flashen fertig ist
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//*
//* Rueckgabe : -
//*
//**********************************************************************
//* History :
//* 27.06.2003 KuS V1.00 Ersterstellung
//**********************************************************************
WaitDLEFinished(in: string SgbdName)
{
string ProcName = "WaitDLEFinished";
string DLE_Status = "";
CDHapiJob(SgbdName, "WAIT_FOR_DLE", "", "");
TestApiFehler (COAPI_OPPS_DLE_FINISH_ERROR, ProcName, 0, SgbdName + ", STATUS_DLE");
CDHapiResultText(DLE_Status, "DLE_STATUS", 1, "");
OutputDebugString(0, "DLE_Status (WaitDLEFinished()) : " + DLE_Status);
if ("STOP" != DLE_Status)
{
SetCDHFehler(COAPI_OPPS_DLE_FINISH_ERROR, ProcName, 0, SgbdName + ", EXIT: ERROR: DLE_Status (WaitDLEFinished()) : " + DLE_Status);
}
}
//**********************************************************************
//*
//* Name : WaitDLEOverflow
//*
//* Funktion : Warten bis die DLE wieder Daten entgegen nimmt
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//* DLE_Buffer - Buffer den Daten die in die DLE geladen werden sollen
//* DLE_Buffer_Size - Groesse des DLE_Buffer
//*
//* Rueckgabe : -
//*
//**********************************************************************
//* History :
//* 27.06.2003 KuS V1.00 Ersterstellung
//**********************************************************************
WaitDLEOverflow(in: string SgbdName, in: int DLE_Buffer, in: int DLE_Buffer_Size)
{
string ProcName = "WaitDLEOverflow";
string FIFO_Status = "OVERFLOW"; // ist am eintritt der funktion immer OVERFLOW
int Counter = 1;
while ("OVERFLOW" == FIFO_Status)
{
CDHDelay(100); // warten 100 ms
CDHapiJobData(SgbdName, "STEUERN_DLE_LADEN", DLE_Buffer, DLE_Buffer_Size, "");
TestDleFehler(ProcName, 1855);
CDHapiResultText(FIFO_Status, "FIFO_STATUS", 1, "");
//OutputDebugString(0, "FIFO_Status (Warten OVERFLOW) : " + FIFO_Status);
if (Counter > 100)
{ // Abbruch, wenn nach 10s kein Platz im FIFO
OutputDebugString(0, "EXIT: Warten OVERFLOW" + FIFO_Status);
SetCDHFehler (COAPI_OPPS_DLE_OVERFLOW_ERROR, ProcName, 2678, SgbdName + ", DLE Kommt nicht zu STOP");
}
Counter = Counter + 1;
}
}
//*************************************************************
//*
//* Name : FlashSchreiben
//*
//* Funktion : Daten in Buffer an SG senden
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//* Buffer - Binaerpuffer mit Daten
//* BufferSize - Groesse des Binaerpuffers Buffer
//* RequestDownloadBuffer - Binaerpuffer mit Startadresse und Laenge des aktuellen Datenblocks
//* NoExit - TRUE wenn kein Abbruch im Fehlerfall von FLASH_SCHREIBEN erfolgen soll, FALSE andererseits
//*
//* Rueckgabe : RetVal - Status von FLASH_SCHREIBEN
//*
//*************************************************************
//* History :
//* 24.06.2003 V1.00 KuS Ersterstellung
//*************************************************************
FlashSchreiben(in: string SgbdName, in: int Buffer, in: int BufferSize, in: int RequestDownloadBuffer, in: bool NoExit, out: int RetVal)
{
string ProcName = "FlashSchreiben";
int Status = 0;
int SgStatus = 1; // Block i.O.
RetVal = 0;
CDHapiJobData(SgbdName, "FLASH_SCHREIBEN_XXL", Buffer, BufferSize, "");
// MK: wenn bei der Übertragung ohne Wiederaufsetzen ein Fehler passiert,
// dann sofort mit den neuen Fehlercodes abbrechen.
// Deshalb: "TestApiFehlerNoExit" nur, wenn Wiederaufsetzen in PABD eingeschalten ist
if ((NoExit == TRUE) && ((WiederaufsetzenBlockSwitch == TRUE) || (WiederaufsetzenSwitch == TRUE)))
// Übertragung mit Wiederaufsetzen
TestApiFehlerNoExit(COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 1448, SgbdName + ", FLASH_SCHREIBEN (...)", Status);
else
// Übertragung ohne Wiederaufsetzen oder beim Wiederaufsetzen (1 bis 3 Blöcke)
TestApiFehler(COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 1450, SgbdName + ", FLASH_SCHREIBEN (...)");
if (Status == 0) // Kann nur abgefragt werden wenn Status gleich Null ist.
CDHapiResultInt (SgStatus, "FLASH_SCHREIBEN_STATUS", 1);
if (SgStatus != 1)
{
// SG meldet Programmierung NOK --> Programmierung mit TransferExit abschliesen und beenden.
CDHapiJobData (SgbdName, "FLASH_SCHREIBEN_ENDE", RequestDownloadBuffer, 21, "");
// MK: ursprünglichen Fehler nicht verschleiern
// TestApiFehler(COAPI_ECU_FLASH_TRANSFER_EXIT_ERROR, ProcName, 1459, SgbdName + ", WAS - FLASH_SCHREIBEN_ENDE Datenbloecke(...)");
// Fehler eintragen und dann abbrechen
SetCDHFehler(COAPI_ECU_FLASH_DOWNLOAD_ERROR, ProcName, 1461, "SG meldet Programmierung NOK. Abbruch!!");
}
RetVal = Status;
}
//*************************************************************
//*
//* Name : AddWordToDWord
//*
//* Funktion : Word zu Double Word addieren
//*
//* Parameter : LowByte - Low-Byte Teil des DWord
//* MidLowByte - MidLow-Byte Teil des DWord
//* MidHighByte - MidHigh-Byte Teil des DWord
//* HighByte - High-Byte Teil des DWord
//* AddWord - Word das addiert werden soll
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 03.07.2003 V1.00 KuS Ersterstellung
//* 25.11.2004 V1.01 DTZ Bugfix Berechnung der Übertrags
//*************************************************************
AddWordToDWord(inout: int LowByte, inout: int MidLowByte, inout: int MidHighByte, inout: int HighByte, in: int AddWord)
{
int NextByte = 0;
LowByte = LowByte + AddWord;
// Uebertrag auf MidLow
if (LowByte > 0xFF)
{
NextByte = LowByte / 256;
MidLowByte = MidLowByte + NextByte;
LowByte = LowByte - (NextByte * 256);
}
// Uebertrag auf MidHigh
if (MidLowByte > 0xFF)
{
NextByte = MidLowByte / 256;
MidHighByte = MidHighByte + NextByte;
MidLowByte = MidLowByte - (NextByte * 256);
}
// Uebertrag auf High
if (MidHighByte > 0xFF)
{
NextByte = MidHighByte / 256;
HighByte = HighByte + NextByte;
MidHighByte = MidHighByte - (NextByte * 256);
}
}
//*************************************************************
//*
//* Name : AddDWordToDWord
//*
//* Funktion : Double Word zu Double Word addieren
//*
//* Parameter : LowByte - Low-Byte Teil des DWord
//* MidLowByte - MidLow-Byte Teil des DWord
//* MidHighByte - MidHigh-Byte Teil des DWord
//* HighByte - High-Byte Teil des DWord
//* AddLowByte - Low-Byte Teil des DWord
//* AddMidLowByte - MidLow-Byte Teil des DWord
//* AddMidHighByte - MidHigh-Byte Teil des DWord
//* AddHighByte - High-Byte Teil des DWord
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 16.07.2003 V1.00 KuS Ersterstellung
//*************************************************************
AddDWordToDWord(inout: int LowByte, inout: int MidLowByte, inout: int MidHighByte, inout: int HighByte, in: int AddLowByte, in: int AddMidLowByte, in: int AddMidHighByte, in: int AddHighByte)
{
LowByte = LowByte + AddLowByte;
if (LowByte > 0xFF)
{
MidLowByte = MidLowByte + 1; // Uebertrag nach MidLow
LowByte = LowByte - 0x100;
}
if (MidLowByte > 0xFF)
{
MidHighByte = MidHighByte + 1;// Uebertrag nach MidHigh
MidLowByte = MidLowByte - 0x100;
}
if (MidHighByte > 0xFF)
{
HighByte = HighByte + 1; // Uebertrag nach High
MidHighByte = MidHighByte - 0x100;
}
MidLowByte = MidLowByte + AddMidLowByte;
if (MidLowByte > 0xFF)
{
MidHighByte = MidHighByte + 1;// Uebertrag nach MidHigh
MidLowByte = MidLowByte - 0x100;
}
if (MidHighByte > 0xFF)
{
HighByte = HighByte + 1; // Uebertrag nach High
MidHighByte = MidHighByte - 0x100;
}
MidHighByte = MidHighByte + AddMidHighByte;
if (MidHighByte > 0xFF)
{
HighByte = HighByte + 1; // Uebertrag nach High
MidHighByte = MidHighByte - 0x100;
}
HighByte = HighByte + AddHighByte;
}
//*************************************************************
//*
//* Name : SubDWordFromDWord
//*
//* Funktion : Double Word von Double Word subtrahieren
//*
//* Parameter : LowByte - Low-Byte Teil des DWord
//* MidLowByte - MidLow-Byte Teil des DWord
//* MidHighByte - MidHigh-Byte Teil des DWord
//* HighByte - High-Byte Teil des DWord
//* AddLowByte - Low-Byte Teil des DWord
//* AddMidLowByte - MidLow-Byte Teil des DWord
//* AddMidHighByte - MidHigh-Byte Teil des DWord
//* AddHighByte - High-Byte Teil des DWord
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 16.07.2003 V1.00 KuS Ersterstellung
//*************************************************************
SubDWordFromDWord(inout: int LowByte, inout: int MidLowByte, inout: int MidHighByte, inout: int HighByte, in: int SubLowByte, in: int SubMidLowByte, in: int SubMidHighByte, in: int SubHighByte)
{
LowByte = LowByte - SubLowByte;
if (LowByte < 0)
{
LowByte = LowByte + 0x100;
MidLowByte = MidLowByte - 1;
}
if (MidLowByte < 0)
{
MidLowByte = MidLowByte + 0x100;
MidHighByte = MidHighByte - 1;
}
if (MidHighByte < 0)
{
MidHighByte = MidHighByte + 0x100;
HighByte = HighByte - 1;
}
MidLowByte = MidLowByte - SubMidLowByte;
if (MidLowByte < 0)
{
MidLowByte = MidLowByte + 0x100;
MidHighByte = MidHighByte - 1;
}
if (MidHighByte < 0)
{
MidHighByte = MidHighByte + 0x100;
HighByte = HighByte - 1;
}
MidHighByte = MidHighByte - SubMidHighByte;
if (MidHighByte < 0)
{
MidHighByte = MidHighByte + 0x100;
HighByte = HighByte - 1;
}
HighByte = HighByte - SubHighByte;
}
//*************************************************************
//*
//* Name : BufferAuffuellen
//*
//* Funktion : Buffer mit 0xFF bis MXBL auffuellen
//*
//* Parameter : Buffer - Binaerpuffer mit Daten
//* BufferSize - Groesse des Binaerpuffers Buffer
//* MaxData - MXBL des SG
//*
//* Rueckgabe :
//*
//*************************************************************
//* History :
//* 07.07.2003 V1.00 KuS Ersterstellung
//*************************************************************
BufferAuffuellen(in: int Buffer, in: int BufferSize, in: int MaxData)
{
string ProcName = "BufferAuffuellen";
int Status = 0;
int Byte = 0xFF;
int Position = 0;
int MaxDataHighByte = 0;
int MaxDataLowByte = 0;
// OutputDebugInt(1676, "Auffuellen des Buffer mit BufferSize = ",BufferSize);
Position = BufferSize - 1; // Um das alte letzte Byte zu überschreiben: ETX=0x03h
while (Position <= MaxData + 21 - 1) // 20 von Info Bytes(Adresse,...)
{ // Letztes 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
}
//*************************************************************
//*
//* Name : SubWordFromDWord
//*
//* Funktion : Word von Double Word subtrahieren
//*
//* Parameter : LowByte - Low-Byte Teil des DWord
//* MidLowByte - MidLow-Byte Teil des DWord
//* MidHighByte - MidHigh-Byte Teil des DWord
//* HighByte - High-Byte Teil des DWord
//* SubWord - Word das subtrahiert werden soll
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 03.07.2003 V1.00 KuS Ersterstellung
//* 25.11.2004 V1.01 DTZ Bugfix Berechnung der Übertrags
//*************************************************************
SubWordFromDWord(inout: int LowByte, inout: int MidLowByte, inout: int MidHighByte, inout: int HighByte, in: int SubWord)
{
int SubWordHigh;
int SubWordMidHigh;
int SubWordMidLow;
int SubWordLow;
SubWordHigh = 0;
SubWordMidHigh = 0;
SubWordMidLow = SubWord / 256;
SubWordLow = SubWord - (SubWordMidLow * 0x100);
if (LowByte < SubWordLow)
{
LowByte = (LowByte - SubWordLow) + 0x100;
SubWordMidLow = SubWordMidLow + 1;
}
else
{
LowByte = LowByte - SubWordLow;
}
if (MidLowByte < SubWordMidLow)
{
MidLowByte = (MidLowByte - SubWordMidLow) + 0x100;
SubWordMidHigh = SubWordMidHigh + 1;
}
else
{
MidLowByte = MidLowByte - SubWordMidLow;
}
if (MidHighByte < SubWordMidHigh)
{
MidHighByte = (MidHighByte - SubWordMidHigh) + 0x100;
SubWordHigh = SubWordHigh + 1;
}
else
{
MidHighByte = MidHighByte - SubWordMidHigh;
}
if (HighByte < SubWordHigh)
{
SetCDHFehler(COAPI_ADDRESS_CALC_ERROR, "SubWordFromDWord", 0, "Fehler bei Adressberechnung");
}
else
{
HighByte = HighByte - SubWordHigh;
}
}
//*************************************************************
//*
//* Name : WASBufferKopieren
//*
//* Funktion : Buffer in einen der WASBackup Buffer kopieren
//*
//* Parameter : Buffer - Binaerpuffer mit Daten
//* BufferSize - Groesse des Binaerpuffers Buffer
//* WASBuffer - WAS Puffer zum Speichern der Daten
//* WASBufferSize - Groesse des Binaerpuffers WASBuffer
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 14.07.2003 V1.00 KuS Ersterstellung
//*************************************************************
WASBufferKopieren(in: int Buffer, in: int BufferSize, inout: int WASBuffer, inout: int WASBufferSize)
{
int Status = 0;
int Position = 0;
int Byte = 0;
if (WASBufferSize != BufferSize) // Neu Erzeugen des Puffers. Sonst Fehler beim WAS eines kleineren Blocks als MXBL
{
CDHBinBufDelete(WASBuffer,Status);
TestCDHFehler (Status);
CDHBinBufCreate(WASBuffer,Status);
TestCDHFehler (Status);
}
Position = 0;
while (Position < BufferSize)
{
CDHBinBufReadByte(Buffer, Byte, Position, Status);
CDHBinBufWriteByte(WASBuffer, Byte, Position, Status);
Position = Position + 1;
}
WASBufferSize = Position;
}
//*************************************************************
//*
//* Name : FlashSchreibenEnde
//*
//* Funktion : SGBG Job FLASH_SCHREIBEN_ENDE ausführen
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//* RequestDownloadBuffer - Binaerpuffer mit Startadresse und Länge
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 16.07.2003 V1.00 KuS Ersterstellung
//*************************************************************
FlashSchreibenEnde(in: string SgbdName, in: int RequestDownloadBuffer)
{
string ProcName = "FlashSchreibenEnde";
CDHapiJobData(SgbdName, "FLASH_SCHREIBEN_ENDE", RequestDownloadBuffer, 21, "");
TestApiFehler(COAPI_ECU_FLASH_TRANSFER_EXIT_ERROR, ProcName, 1847, SgbdName + ", FLASH_SCHREIBEN_ENDE (...)");
}
//*************************************************************
//*
//* Name : FlashSchreibenAdresse
//*
//* Funktion : SGBG Job FLASH_SCHREIBEN_ENDE ausführen
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//* RequestDownloadBuffer - Binaerpuffer mit Startadresse und Länge
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 16.07.2003 V1.00 KuS Ersterstellung
//*************************************************************
FlashSchreibenAdresse(in: string SgbdName, in: int RequestDownloadBuffer)
{
string ProcName = "FlashSchreibenAdresse";
CDHapiJobData(SgbdName, "FLASH_SCHREIBEN_ADRESSE", RequestDownloadBuffer, 21, "");
TestApiFehler(COAPI_ECU_FLASH_REQUEST_DOWNLOAD_ERROR, ProcName, 1873, SgbdName + ", FLASH_SCHREIBEN_ADRESSE (...)");
}
//*************************************************************
//*
//* Name : VorbereitenRDBuffer
//*
//* Funktion : Setzen der Werte im RequestDownloadBuffer
//*
//* Parameter : StartAdrLow - Low Byte der Startadresse
//* StartAdrMidLow - MidLow Byte der Startadresse
//* StartAdrMidHigh - MidHigh Byte der Startadresse
//* StartAdrHigh - High Byte der Startadresse
//* DataBlockLengthLow - Low Byte der Datenblocklaenge
//* DataBlockLengthMidLow - MidLow Byte der Datenblocklaenge
//* DataBlockLengthMidHigh - MidHigh Byte der Datenblocklaenge
//* DataBlockLengthHigh - High Byte der Datenblocklaenge
//* RequestDownloadBuffer - Binaerpuffer mit Startadresse und Länge
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 16.07.2003 V1.00 KuS Ersterstellung
//*************************************************************
VorbereitenRDBuffer(in: int StartAdrLow, in: int StartAdrMidLow, in: int StartAdrMidHigh, in: int StartAdrHigh, in: int DataBlockLengthLow, in: int DataBlockLengthMidLow, in: int DataBlockLengthMidHigh, in: int DataBlockLengthHigh, inout: int RequestDownloadBuffer)
{
int Status = 0;
// 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);
}
//*************************************************************
//*
//* Name : SGReset
//*
//* Funktion : SGBG Job STEUERGERAETE_RESET ausführen
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//* ResetZeit - ResetZeit des SG
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 12.08.2003 V1.00 KuS Ersterstellung
//*************************************************************
SGReset(in: string SgbdName, in: int ResetZeit)
{
string ProcName = "SGReset";
OutputDebugString(2160, "Reset");
CDHapiJob(SgbdName, "STEUERGERAETE_RESET", "", "");
TestApiFehler(COAPI_ECU_RESET_ERROR, ProcName, 2162, SgbdName + ", STEUERGERAETE_RESET");
if (ResetZeit > 0)
CDHDelay(ResetZeit*1000+500);
else
CDHDelay(500);
}
//*************************************************************
//*
//* Name : FlashDLE
//*
//* Funktion : Programmieren mit DLE
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//* MaxData - MXBL
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 14.06.2004 V1.00 KuS Ersterstellung
//*************************************************************
FlashDLE(in: string SgbdName, in: int MaxData, in: int NrOfData, in: int Buffer, in: int BlockCounter, in: int StartAdrBuffer, in: int BlockLengthBuffer, in: bool BlockSchreibenFlag)
{
string ProcName = "FlashDLE";
int Status;
int RequestDownloadBuffer;
int DataBlockLoopCounter;
int StartAdrLow, StartAdrMidLow, StartAdrMidHigh, StartAdrHigh;
int DataBlockLengthLow, DataBlockLengthMidLow, DataBlockLengthMidHigh, DataBlockLengthHigh;
int EndDataBlockLengthLow, EndDataBlockLengthMidLow, EndDataBlockLengthMidHigh, EndDataBlockLengthHigh;
bool BlockEnd;
int BufferSize;
int Byte;
int ZwischenBufferNrOfData;
string DLE_TP_INTERVAL = "8000"; // Zeitabstand zw. 2 Tester Present Aufruf (in msek)=> 8000: Default Wert
string DLE_SOURCE = "0xF1";
int DLE_LENGTH_int;
string DLE_LENGTH = "192"; // Programmierblock länge MIT ServiceID, OHNE Pruefsumme
int DLE_SIZE_RINGBUFFER = 1014; // Maximal Groesse des Ringpuffers
string DLE_RESPONSE = "76000001"; // Antworttelegramm mit Header, ohne Pruefsumme
string DLE_MASK = "FF0000FF"; // Vergleichsmaske
string FIFO_Status;
int DLE_Buffer; // Datenbuffer zum Schreiben im Ringpuffer: DLE_Buffer = [SID | Data]
int DLE_Buffer_Size;
int DLE_Buffer_Position;
bool DLE_Buffer_Full;
int BINBUF_DATA_START_INDEX = 21;
// Flashen mit DLE
OutputDebugString(0, "DLE: Verwendet");
// DLE ruecksetzen
CDHapiJob(SgbdName, "STEUERN_DLE_RESET", "", "");
TestApiFehler(COAPI_OPPS_DLE_RESET_ERROR, ProcName, 0, SgbdName + ", STEUERN_DLE_RESET");
// DLE parametrieren
CDHapiJob(SgbdName, "STEUERN_TP_INTERVALL", DLE_TP_INTERVAL, "");
TestApiFehler(COAPI_OPPS_SET_TP_ERROR, ProcName, 0, SgbdName + ", STEUERN_TP_INTERVALL");
DLE_LENGTH_int = MaxData + 1;
inttostring(DLE_LENGTH_int, DLE_LENGTH);
CDHapiJob(SgbdName, "STEUERN_DLE_HEADER", DLE_SOURCE + ";" + DLE_LENGTH, "");
TestApiFehler(COAPI_OPPS_DLE_INIT_ERROR, ProcName, 0, SgbdName + ", STEUERN_DLE_HEADER");
CDHapiJob (SgbdName, "STEUERN_DLE_IOANTWORT", DLE_RESPONSE + ";" + DLE_MASK, "");
TestApiFehler(COAPI_OPPS_DLE_INIT_ERROR, ProcName, 0, SgbdName + ", STEUERN_DLE_IOANTWORT");
// 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);
// Erzeugen des Datenpuffers für die DLE
CDHBinBufCreate(DLE_Buffer,Status);
TestCDHFehler (Status);
// DLE DNMT / TP starten
CDHapiJob(SgbdName, "STEUERN_DLE_TP", "1", "");
TestApiFehler(COAPI_OPPS_SET_TP_ERROR, ProcName, 0, SgbdName + ", STEUERN_DLE_IOANTWORT");
// ENMT für zu programmierendes SG einschalten
CDHapiJob(SgbdName, "NORMALER_DATENVERKEHR", "JA;NEIN;NEIN", "");
// MK: nix auswerten, denn es soll ja gar nicht antworten
// TestApiFehler(COAPI_ECU_TIMEOUT, ProcName, 0, SgbdName + ", NORMALER_DATENVERKEHR (JA;NEIN;NEIN)");
DataBlockLoopCounter = 0;
while (DataBlockLoopCounter < BlockCounter) // solange nicht alle datenbloecke geschrieben sind
{
OutputDebugInt(0, "Datenblock schreiben ", DataBlockLoopCounter);
// Startadresse des Datenblocks aus Buffer holen
CDHBinBufReadByte(StartAdrBuffer, StartAdrLow, (4 * DataBlockLoopCounter), Status);
TestCDHFehler(Status);
CDHBinBufReadByte(StartAdrBuffer, StartAdrMidLow, (4 * DataBlockLoopCounter) + 1, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(StartAdrBuffer, StartAdrMidHigh, (4 * DataBlockLoopCounter) + 2, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(StartAdrBuffer, StartAdrHigh, (4 * DataBlockLoopCounter) + 3, Status);
TestCDHFehler(Status);
// Laenge des Datenblocks aus Buffer holen
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthLow, (4 * DataBlockLoopCounter), Status);
TestCDHFehler(Status);
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthMidLow, (4 * DataBlockLoopCounter) + 1, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthMidHigh, (4 * DataBlockLoopCounter) + 2, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthHigh, (4 * DataBlockLoopCounter) + 3, Status);
TestCDHFehler(Status);
// Den RequestDowmloadBuffer mit gelesenen Werten vorbereiten
VorbereitenRDBuffer(StartAdrLow, StartAdrMidLow, StartAdrMidHigh, StartAdrHigh,
DataBlockLengthLow, DataBlockLengthMidLow, DataBlockLengthMidHigh, DataBlockLengthHigh,
RequestDownloadBuffer);
// Flash Adresse schreiben
if (FALSE != BlockSchreibenFlag)
FlashSchreibenAdresse(SgbdName, RequestDownloadBuffer);
// Variablen rücksetzen
EndDataBlockLengthLow = 0; // fuer Erkennung auf Datenblockende
EndDataBlockLengthMidLow = 0;
EndDataBlockLengthMidHigh = 0;
EndDataBlockLengthHigh = 0;
BlockEnd = FALSE;
// wenn der erste block nicht geschrieben wird, aber größer als MaxData ist.
// muss CDHGetApiJobBateData mehrmal aufgerufen werden und die bereits in buffer vorliegenden daten müssen fuer
// die erkenung des blockendes beruecksichtigt werden.
if (FALSE == BlockSchreibenFlag)
{
AddWordToDWord(EndDataBlockLengthLow, EndDataBlockLengthMidLow, EndDataBlockLengthMidHigh, EndDataBlockLengthHigh, NrOfData);
if ((DataBlockLengthLow == EndDataBlockLengthLow ) &&
(DataBlockLengthMidLow == EndDataBlockLengthMidLow ) &&
(DataBlockLengthMidHigh == EndDataBlockLengthMidHigh ) &&
(DataBlockLengthHigh == EndDataBlockLengthHigh))
{
BlockEnd = TRUE;
}
}
while (FALSE == BlockEnd)
{
// solange kein datenblockende erreicht ist
DLE_Buffer_Full = FALSE;
DLE_Buffer_Size = 0;
// DLE Puffer löschen und neu erzeugen
CDHBinBufDelete(DLE_Buffer, Status);
CDHBinBufCreate(DLE_Buffer, Status);
while (FALSE == DLE_Buffer_Full && FALSE == BlockEnd)
{
// solange DLE puffer nicht voll oder datenblockende erreicht
CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status); // Daten aus PAF Datei holen
// prüfen auf datenblockende
AddWordToDWord(EndDataBlockLengthLow,
EndDataBlockLengthMidLow,
EndDataBlockLengthMidHigh,
EndDataBlockLengthHigh,
NrOfData);
if ((DataBlockLengthLow == EndDataBlockLengthLow ) &&
(DataBlockLengthMidLow == EndDataBlockLengthMidLow ) &&
(DataBlockLengthMidHigh == EndDataBlockLengthMidHigh ) &&
(DataBlockLengthHigh == EndDataBlockLengthHigh))
{
BlockEnd = TRUE;
}
//ServiceID (TransferData) liegt an der ersten Stelle im DLE_Buffer
Byte = 0x36;
CDHBinBufWriteByte(DLE_Buffer, Byte, DLE_Buffer_Size, Status);
DLE_Buffer_Size = DLE_Buffer_Size + 1;
// Kopieren der Nutzdaten aus dem normalen Puffer (Buffer) in den DLE Puffer (DLE_Buffer)
CDHBinBufAppend(Buffer, DLE_Buffer, BINBUF_DATA_START_INDEX, NrOfData, Status);
TestCDHFehler(Status);
DLE_Buffer_Size = DLE_Buffer_Size + NrOfData;
// nicht maxdata erhalten und es gibt noch weitere daten --> buffer auffüllen
while ( (NrOfData < MaxData) && (FALSE == BlockEnd) )
{
CDHGetApiJobByteData(MaxData - NrOfData, Buffer, BufferSize, ZwischenBufferNrOfData, Status);
TestCDHFehler(Status);
// Kopieren der Nutzdaten aus dem normalen Puffer (Buffer) in den DLE Puffer (DLE_Buffer)
CDHBinBufAppend(Buffer, DLE_Buffer, BINBUF_DATA_START_INDEX, ZwischenBufferNrOfData, Status);
TestCDHFehler(Status);
DLE_Buffer_Size = DLE_Buffer_Size + ZwischenBufferNrOfData;
NrOfData = NrOfData + ZwischenBufferNrOfData;
// erneutes prüfen auf datenblockende
AddWordToDWord(EndDataBlockLengthLow,
EndDataBlockLengthMidLow,
EndDataBlockLengthMidHigh,
EndDataBlockLengthHigh,
ZwischenBufferNrOfData);
if ((DataBlockLengthLow == EndDataBlockLengthLow ) &&
(DataBlockLengthMidLow == EndDataBlockLengthMidLow ) &&
(DataBlockLengthMidHigh == EndDataBlockLengthMidHigh ) &&
(DataBlockLengthHigh == EndDataBlockLengthHigh))
{
BlockEnd = TRUE;
}
}
// pruefen ob noch platz im dle buffer ist
if (DLE_Buffer_Size + 1 + NrOfData > DLE_SIZE_RINGBUFFER)
{
DLE_Buffer_Full = TRUE;
}
}
// DLE Laden
FIFO_Status = "";
if (FALSE != BlockSchreibenFlag)
{
CDHapiJobData(SgbdName, "STEUERN_DLE_LADEN", DLE_Buffer, DLE_Buffer_Size, "");
TestDleFehler(ProcName, 2595);
CDHapiResultText(FIFO_Status, "FIFO_STATUS", 1, "");
}
// die DLE kann nicht den ganzen Puffer empfangen und gibt OVERFLOW zurueck => 100 ms werden abgewartet
if ("OVERFLOW" == FIFO_Status)
{
WaitDLEOverflow(SgbdName, DLE_Buffer, DLE_Buffer_Size);
}
} // Ende von: while (FALSE == BlockEnd)
// Warten bis die DLE fertig ist
WaitDLEFinished(SgbdName);
// Flash Schreiben abschliessen
if (FALSE != BlockSchreibenFlag)
FlashSchreibenEnde(SgbdName, RequestDownloadBuffer);
DataBlockLoopCounter = DataBlockLoopCounter + 1;
BlockSchreibenFlag = TRUE;
} // Ende von: while (DataBlockLoopCounter < BlockCounter)
// Schönheitskorrektur, KEINE FUNKTION, setzt WinKfp Fortschrittsbalken auf 100% vor
CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status);
// DLE ENMT / TP stoppen
CDHapiJob (SgbdName, "STEUERN_DLE_TP", "0", "");
TestApiFehler (COAPI_OPPS_SET_TP_ERROR, ProcName, 0, SgbdName + ", STEUERN_DLE_TP");
OutputDebugString(0, "DNMT/TP stoppen ");
}
//*************************************************************
//*
//* Name : FlashStd
//*
//* Funktion : Programmieren ohne DLE mit Standard Ablauf
//*
//* Parameter : SgbdName - Name der verwendeten SGBD
//* MaxData - MXBL
//*
//* Rueckgabe : -
//*
//*************************************************************
//* History :
//* 14.06.2004 V1.00 KuS Ersterstellung
//*************************************************************
FlashStd(in: string SgbdName, in: int MaxData, in: int NrOfData, in: int Buffer, in: int BlockCounter, in: int StartAdrBuffer, in: int BlockLengthBuffer, in: bool BlockSchreibenFlag)
{
string ProcName = "FlashStd";
int Status;
int RequestDownloadBuffer;
int DataBlockLoopCounter;
int StartAdrLow, StartAdrMidLow, StartAdrMidHigh, StartAdrHigh;
int DataBlockLengthLow, DataBlockLengthMidLow, DataBlockLengthMidHigh, DataBlockLengthHigh;
int EndDataBlockLengthLow, EndDataBlockLengthMidLow, EndDataBlockLengthMidHigh, EndDataBlockLengthHigh;
bool BlockEnd;
int BufferSize;
int Byte;
int ZwischenBufferSize;
int ZwischenBufferNrOfData;
int ZwischenBuffer;
int NextByte; // Für Implementierung MaxData > 255
int WASBuffer_A_Handle, WASBuffer_B_Handle; // Handle der Buffer fuer WAS
int WASBuffer_1_Size, WASBuffer_2_Size; // Groeße der WAS Buffer
int WASBuffer_1_Pointer, WASBuffer_2_Pointer; // Zeiger auf die WAS Buffer
int WASBuffer_1_Size_Pointer, WASBuffer_2_Size_Pointer; // Groeße der WAS Buffer die durch Zeiger bestimmt sind
bool WASSwitch; // Flag zur Auswahl des richtigen WAS Buffer
int DEFAULT_BUFFER_SIZE = 22; // Anzahl der in den Binärpuffern zusätzlich enthaltenen Daten
int WASOffset; // Anzahl an Bytes die bei einem WAS zurückgegangen wird.
// Anzahl der Daten die bei einem WAS von der WAS Startadresse im Datenblock verbleiben
int RemainingDataBlockLengthLow, RemainingDataBlockLengthMidLow, RemainingDataBlockLengthMidHigh, RemainingDataBlockLengthHigh;
// Anzahl der Daten die im Datenblock erfolgreich übertragen wurden und bei einem WAS nicht wiederholt werden
int WrittenDataBlockLengthLow, WrittenDataBlockLengthMidLow, WrittenDataBlockLengthMidHigh, WrittenDataBlockLengthHigh;
// Startadresse fuer ein WAS
int WASStartAdrLow, WASStartAdrMidLow, WASStartAdrMidHigh, WASStartAdrHigh;
// Normaler Flashablauf
OutputDebugString(0, "DLE: Nicht verwendet");
// DNMT aktivieren, ENMT fuer zu programmierendes SG
TesterPresentHandling(ProcName, SgbdName, TRUE);
CDHBinBufCreate(ZwischenBuffer, Status); // Erzeugen des Flashdaten-ZwischenBuffers
TestCDHFehler(Status);
OutputDebugBool(2964, "### Ersten Datenblock schreiben ",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);
DataBlockLoopCounter = 0;
CDHBinBufCreate(WASBuffer_A_Handle, Status);
TestCDHFehler (Status);
CDHBinBufCreate(WASBuffer_B_Handle, Status);
TestCDHFehler (Status);
while (DataBlockLoopCounter < BlockCounter) // solange nicht alle datenbloecke geschrieben sind
{
OutputDebugInt(3002, "### Datenblock schreiben ", DataBlockLoopCounter);
WASSwitch = FALSE;
WASBuffer_1_Size = DEFAULT_BUFFER_SIZE;
WASBuffer_2_Size = DEFAULT_BUFFER_SIZE;
WASBuffer_1_Size_Pointer = DEFAULT_BUFFER_SIZE;
WASBuffer_2_Size_Pointer = DEFAULT_BUFFER_SIZE;
// Startadresse des Datenblocks aus StartAdrBuffer holen
CDHBinBufReadByte(StartAdrBuffer, StartAdrLow, (4 * DataBlockLoopCounter), Status);
TestCDHFehler(Status);
CDHBinBufReadByte(StartAdrBuffer, StartAdrMidLow, (4 * DataBlockLoopCounter) + 1, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(StartAdrBuffer, StartAdrMidHigh, (4 * DataBlockLoopCounter) + 2, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(StartAdrBuffer, StartAdrHigh, (4 * DataBlockLoopCounter) + 3, Status);
TestCDHFehler(Status);
// Laenge des Datenblocks aus BlockLengthBuffer holen
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthLow, (4 * DataBlockLoopCounter), Status);
TestCDHFehler(Status);
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthMidLow, (4 * DataBlockLoopCounter) + 1, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthMidHigh, (4 * DataBlockLoopCounter) + 2, Status);
TestCDHFehler(Status);
CDHBinBufReadByte(BlockLengthBuffer, DataBlockLengthHigh, (4 * DataBlockLoopCounter) + 3, Status);
TestCDHFehler(Status);
// Den RequestDownloadBuffer mit gelesenen Werten vorbereiten
VorbereitenRDBuffer(StartAdrLow, StartAdrMidLow, StartAdrMidHigh, StartAdrHigh,
DataBlockLengthLow, DataBlockLengthMidLow, DataBlockLengthMidHigh, DataBlockLengthHigh,
RequestDownloadBuffer);
// Download anfordern
if (FALSE != BlockSchreibenFlag)
FlashSchreibenAdresse(SgbdName, RequestDownloadBuffer);
// Variablen rücksetzen
EndDataBlockLengthLow = 0; // fuer Erkennung auf Datenblockende
EndDataBlockLengthMidLow = 0;
EndDataBlockLengthMidHigh = 0;
EndDataBlockLengthHigh = 0;
BlockEnd = FALSE;
// wenn der erste block nicht geschrieben wird, aber größer als MaxData ist.
// muss CDHGetApiJobBateData mehrmal aufgerufen werden und die bereits in buffer vorliegenden daten müssen fuer
// die erkenung des blockendes beruecksichtigt werden.
if (FALSE == BlockSchreibenFlag)
{
AddWordToDWord(EndDataBlockLengthLow, EndDataBlockLengthMidLow, EndDataBlockLengthMidHigh, EndDataBlockLengthHigh, NrOfData);
if ((DataBlockLengthLow == EndDataBlockLengthLow ) &&
(DataBlockLengthMidLow == EndDataBlockLengthMidLow ) &&
(DataBlockLengthMidHigh == EndDataBlockLengthMidHigh ) &&
(DataBlockLengthHigh == EndDataBlockLengthHigh))
{
BlockEnd = TRUE;
}
}
//**********************************************************************
// Flash Block schreiben
//**********************************************************************
while (FALSE == BlockEnd)
{ // solange kein datenblockende erreicht ist
TesterPresentHandling(ProcName, SgbdName, TRUE);
CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status); // Daten aus PAF Datei holen
// prüfen auf datenblockende
AddWordToDWord(EndDataBlockLengthLow, EndDataBlockLengthMidLow, EndDataBlockLengthMidHigh, EndDataBlockLengthHigh, NrOfData);
if ((DataBlockLengthLow == EndDataBlockLengthLow ) &&
(DataBlockLengthMidLow == EndDataBlockLengthMidLow ) &&
(DataBlockLengthMidHigh == EndDataBlockLengthMidHigh ) &&
(DataBlockLengthHigh == EndDataBlockLengthHigh))
{
OutputDebugString(3107, "### BlockEnd = TRUE");
BlockEnd = TRUE;
}
// nicht maxdata erhalten und es gibt noch weitere daten --> buffer auffüllen
while ( (NrOfData < MaxData) && (FALSE == BlockEnd) && (TRUE == BlockSchreibenFlag))
{
CDHGetApiJobByteData (MaxData - NrOfData, ZwischenBuffer, ZwischenBufferSize, ZwischenBufferNrOfData, Status);
TestCDHFehler (Status);
CDHBinBufCopy(ZwischenBuffer, Buffer, 21, NrOfData + 21, ZwischenBufferNrOfData, Status);
TestCDHFehler(Status);
NextByte = (NrOfData + ZwischenBufferNrOfData) / 256;
CDHBinBufWriteByte(Buffer, NextByte, 14, Status); // Länge setzen
CDHBinBufWriteByte(Buffer, (NrOfData + ZwischenBufferNrOfData) - (NextByte * 256), 13, Status); // Länge setzen
CDHBinBufWriteByte(Buffer, 3, NrOfData + ZwischenBufferNrOfData + 21, Status); // ETX setzen (03h)
NrOfData = NrOfData + ZwischenBufferNrOfData;
BufferSize = BufferSize + ZwischenBufferNrOfData;
// erneutes prüfen auf datenblockende
AddWordToDWord(EndDataBlockLengthLow, EndDataBlockLengthMidLow, EndDataBlockLengthMidHigh, EndDataBlockLengthHigh, ZwischenBufferNrOfData);
if ((DataBlockLengthLow == EndDataBlockLengthLow ) &&
(DataBlockLengthMidLow == EndDataBlockLengthMidLow ) &&
(DataBlockLengthMidHigh == EndDataBlockLengthMidHigh ) &&
(DataBlockLengthHigh == EndDataBlockLengthHigh))
{
OutputDebugString(3142, "### BlockEnd = TRUE");
BlockEnd = TRUE;
}
} // Ende von: if ( (NrOfData < MaxData) && (FALSE == BlockEnd) )
TesterPresentHandling(ProcName, SgbdName, TRUE);
// Auffuellen wenn der Buffer nicht MXBL hat.
if (AuffuellenSwitch == TRUE)
{
if (NrOfData < MaxData)
{
BufferAuffuellen(Buffer, BufferSize, MaxData);
}
}
Status = 0;
// Daten an das SG senden
if (FALSE != BlockSchreibenFlag)
FlashSchreiben(SgbdName, Buffer, BufferSize, RequestDownloadBuffer, TRUE, Status);
if (Status != 0 && (TRUE == WiederaufsetzenBlockSwitch || TRUE == WiederaufsetzenSwitch))
{
// WAS
// Fehler aufgetreten, WAS initiieren
TesterPresentHandling(ProcName, SgbdName, TRUE);
CDHDelay(7*1000); // 7 Sekunden warten
TesterPresentHandling(ProcName, SgbdName, TRUE);
OutputDebugString(3168, "*** WAS WAS WAS WAS WAS ***");
// Flash schreiben abschliessen
FlashSchreibenEnde(SgbdName, RequestDownloadBuffer);
// WAS Adresse berechnen
// Anzahl der bereits geschriebenen Daten neu berechnen (2 Bloecke zurueck bereits miteingerechnet)
WrittenDataBlockLengthLow = EndDataBlockLengthLow;
WrittenDataBlockLengthMidLow = EndDataBlockLengthMidLow;
WrittenDataBlockLengthMidHigh = EndDataBlockLengthMidHigh;
WrittenDataBlockLengthHigh = EndDataBlockLengthHigh;
if (TRUE == WiederaufsetzenBlockSwitch)
WASOffset = NrOfData + (WASBuffer_1_Size - DEFAULT_BUFFER_SIZE) + (WASBuffer_2_Size - DEFAULT_BUFFER_SIZE);
else
WASOffset = NrOfData;
SubWordFromDWord(WrittenDataBlockLengthLow,
WrittenDataBlockLengthMidLow,
WrittenDataBlockLengthMidHigh,
WrittenDataBlockLengthHigh,
WASOffset);
// Startadresse fuer WAS berechnen
WASStartAdrLow = StartAdrLow;
WASStartAdrMidLow = StartAdrMidLow;
WASStartAdrMidHigh = StartAdrMidHigh;
WASStartAdrHigh = StartAdrHigh;
AddDWordToDWord(WASStartAdrLow,
WASStartAdrMidLow,
WASStartAdrMidHigh,
WASStartAdrHigh,
WrittenDataBlockLengthLow,
WrittenDataBlockLengthMidLow,
WrittenDataBlockLengthMidHigh,
WrittenDataBlockLengthHigh);
// Verbleibende Blocklaenge berechnen
RemainingDataBlockLengthLow = DataBlockLengthLow;
RemainingDataBlockLengthMidLow = DataBlockLengthMidLow;
RemainingDataBlockLengthMidHigh = DataBlockLengthMidHigh;
RemainingDataBlockLengthHigh = DataBlockLengthHigh;
SubDWordFromDWord(RemainingDataBlockLengthLow,
RemainingDataBlockLengthMidLow,
RemainingDataBlockLengthMidHigh,
RemainingDataBlockLengthHigh,
WrittenDataBlockLengthLow,
WrittenDataBlockLengthMidLow,
WrittenDataBlockLengthMidHigh,
WrittenDataBlockLengthHigh);
//RequestDownloadBuffer mit berechneten Adressen vorbereiten
VorbereitenRDBuffer(WASStartAdrLow, WASStartAdrMidLow, WASStartAdrMidHigh, WASStartAdrHigh,
RemainingDataBlockLengthLow, RemainingDataBlockLengthMidLow,
RemainingDataBlockLengthMidHigh, RemainingDataBlockLengthHigh,
RequestDownloadBuffer);
// Flash schreiben Adressse
FlashSchreibenAdresse(SgbdName, RequestDownloadBuffer);
// Buffer_1 schreiben
if ((WASBuffer_1_Size_Pointer - DEFAULT_BUFFER_SIZE) > 0 && TRUE == WiederaufsetzenBlockSwitch)
{
OutputDebugString(3229, "*** WAS: WASBuffer_1 schreiben ***");
FlashSchreiben(SgbdName, WASBuffer_1_Pointer, WASBuffer_1_Size_Pointer, RequestDownloadBuffer, FALSE, Status);
}
// Buffer_2 schreiben
if ((WASBuffer_2_Size_Pointer - DEFAULT_BUFFER_SIZE) > 0 && TRUE == WiederaufsetzenBlockSwitch)
{
OutputDebugString(3236, "*** WAS: WASBuffer_2 schreiben ***");
FlashSchreiben(SgbdName, WASBuffer_2_Pointer, WASBuffer_2_Size_Pointer, RequestDownloadBuffer, FALSE, Status);
}
// Buffer schreiben
OutputDebugString(3241, "*** WAS: Buffer schreiben ***");
FlashSchreiben(SgbdName, Buffer, BufferSize, RequestDownloadBuffer, FALSE, Status);
} // Ende von: if (Status != 0)
else if (Status != 0)
{
// Fehler bei der Übertragung und kein WAS aktiviert --> Abbruch!
SetCDHFehler(Status, ProcName, 3247, SgbdName + ", FLASH_SCHREIBEN (...)");
}
if ((TRUE == WiederaufsetzenBlockSwitch) && (TRUE == BlockSchreibenFlag))
{
// Buffer fuer WAS speichern
if (FALSE == WASSwitch)
{
WASBufferKopieren(Buffer, BufferSize, WASBuffer_A_Handle, WASBuffer_1_Size);
WASSwitch = TRUE;
WASBuffer_1_Pointer = WASBuffer_B_Handle;
WASBuffer_2_Pointer = WASBuffer_A_Handle;
WASBuffer_1_Size_Pointer = WASBuffer_2_Size;
WASBuffer_2_Size_Pointer = WASBuffer_1_Size;
}
else
{
WASBufferKopieren(Buffer, BufferSize, WASBuffer_B_Handle, WASBuffer_2_Size);
WASSwitch = FALSE;
WASBuffer_1_Pointer = WASBuffer_A_Handle;
WASBuffer_2_Pointer = WASBuffer_B_Handle;
WASBuffer_1_Size_Pointer = WASBuffer_1_Size;
WASBuffer_2_Size_Pointer = WASBuffer_2_Size;
}
}
} // Ende von: while (FALSE == BlockEnd)
//**********************************************************************
// Flash Schreiben abschliessen
//**********************************************************************
if (FALSE != BlockSchreibenFlag)
FlashSchreibenEnde(SgbdName, RequestDownloadBuffer);
DataBlockLoopCounter = DataBlockLoopCounter + 1;
BlockSchreibenFlag = TRUE;
} // Ende von: while (DataBlockLoopCounter < BlockCounter)
// Schönheitskorrektur, KEINE FUNKTION
CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status);
// Fahrzeugbusse wieder wecken
TesterPresentHandling(ProcName, SgbdName, FALSE);
}
//**********************************************************************
//*
//* Name : Programmieren
//*
//* Funktion : Programmieren des SG
//*
//* Parameter : -
//*
//* Rueckgabe : -
//*
//**********************************************************************
//* History :
//* 25.07.2003 KuS V1.15 DLE, XXL, Standard Flashen
//**********************************************************************
Programmieren()
{
string ProcName = "Programmieren";
int Status;
string SgbdName;
int Index;
int IntWert;
string StrWert;
string Text;
int Buffer;
int StartAdrBuffer;
int BlockLengthBuffer;
int MaxData;
int BufferSize;
int NrOfData;
int BlockCounter;
bool BlockSchreibenFlag;
bool FreibrennBlockFlag;
int AdrSprungFlag;
bool FreibrennBlockSchreiben = FALSE;
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 LoeschZeit;
string SignaturTestZeit;
int ResetZeit;
int AuthentisierungZeit;
int SgStatus;
string SgSerienNr;
int HipStatus;
string UserIdSGBD;
string UserId;
string AUTHENTISIERUNGS_LEVEL = "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 BSUTime; // Boot Sektor Update
// OPPS XXL
int MXBL_STANDARD = 254;
int MXBL_MOST_XXL = 1002;
// OPPS Download Engine
string DLE_Present; // "TRUE" oder "FALSE"
string DLE_Version;
// string DLEUseKey = "DLEVerwenden";
// string DLEUseKeyValue = "TRUE";
// Workaround für CCC-Cold-Boot hängenbleiber
string MyResultString;
bool MyResultBool;
int MyCntr;
int MyStatus;
SetFlashState(2);
//############################################################################################################
// (1) Initialisierung
//############################################################################################################
ProgSuccess = FALSE;
OutputDebugString(2061, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler(Status);
// 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);
// Programmierzugang ermitteln
CheckForOppsMostAccess(ProcName, SgbdName);
//############################################################################################################
// (2) Ausgeben von PADB und SGBD Informationen
//############################################################################################################
// SGBD Informationen ausgeben
OutputDebugString(2084, "SGBD-Name : " + SgbdName);
CDHapiJob(SgbdName, "INFO", "", "");
CDHapiResultText(StrWert , "ORIGIN", 1, "");
OutputDebugString(2087, "SGBD-Origin : " + StrWert);
CDHapiResultText(StrWert , "REVISION", 1, "");
OutputDebugString(2089, "SGBD-Revision : " + StrWert);
CDHapiResultText(StrWert , "PACKAGE", 1, "");
OutputDebugString(2091, "SGBD-Package : " + StrWert);
// PABD Informationen ausgeben
OutputDebugString(2099, "PABD-Modulname : " + ModulName);
OutputDebugString(2100, "PABD-Revision : " + Revision);
OutputDebugString(2101, "PABD-Author : " + Author);
OutputDebugString(2102, "PABD-Comment : " + Comment);
// PABD Einstellungen ausgeben
OutputDebugString(2103, "PABD-SGFamilie : " + SGFamilie);
OutputDebugInt (2104, "PABD-SG_MAXANZAHL_AIF : " , SG_MAXANZAHL_AIF);
OutputDebugInt (2105, "PABD-SG_GROESSE_AIF : " , SG_GROESSE_AIF);
OutputDebugInt (2106, "PABD-SG_ENDEKENNUNG_AIF : " , SG_ENDEKENNUNG_AIF);
OutputDebugString(2107, "PABD-SG_AUTHENTISIERUNG : " + SG_AUTHENTISIERUNG);
OutputDebugBool (2108, "PABD-ProgrammUndDaten : " , ProgrammUndDaten);
OutputDebugString(2109, "PABD-ProzessorTyp : " + ProzessorTyp);
OutputDebugBool (2110, "PABD-AuffuellenSwitch : " , AuffuellenSwitch);
OutputDebugBool (2112, "PABD-WiederaufsetzenBlockSwitch : " , WiederaufsetzenBlockSwitch);
OutputDebugInt (2113, "PABD-WartenNachECUProgrammMode : " , WartenNachECUProgrammMode);
OutputDebugBool (2114, "PABD-TestSchluesselAuthentisierung: " , TestSchluesselAuthentisierung);
OutputDebugBool (2115, "PABD-WiederaufsetzenSwitch : " , WiederaufsetzenSwitch);
OutputDebugBool (2116, "PABD-SgInnenTemperaturLesen : " , SgInnenTemperaturLesen);
OutputDebugBool (2117, "PABD-SgPhysHwNrLesen : " , SgPhysHwNrLesen);
OutputDebugBool (2118, "PABD-TesterPresentHandlingSwitch : " , TesterPresentHandlingSwitch);
OutputDebugBool (2119, "PABD-DebugSwitch : " , DebugSwitch);
OutputDebugBool (2122, "OPPS: MOST-Zugang benutzt : " , OppsMostAccess);
//############################################################################################################
// (3) Flash Zeiten aus SG auslesen
//############################################################################################################
CDHapiJob(SgbdName, "FLASH_ZEITEN_LESEN", "", "");
TestApiFehler(COAPI_ECU_TIMES_ERROR, ProcName, 2125, SgbdName + ", FLASH_ZEITEN_LESEN");
CDHapiResultInt (LoeschZeit , "FLASH_LOESCHZEIT" , 1);
CDHapiResultText (SignaturTestZeit , "FLASH_SIGNATURTESTZEIT", 1, "");
SignaturTestZeit = "4500";
CDHapiResultInt (ResetZeit , "FLASH_RESETZEIT" , 1);
CDHapiResultInt (AuthentisierungZeit, "FLASH_AUTHENTISIERZEIT", 1);
OutputDebugInt (2132, "LoeschZeit : ", LoeschZeit);
OutputDebugString(2133, "SignaturTestZeit : " + SignaturTestZeit);
OutputDebugInt (2134, "ResetZeit : ", ResetZeit);
OutputDebugInt (2135, "AuthentisierungZeit: ", AuthentisierungZeit);
//############################################################################################################
// (4a) Programmierstatus CCC_HOST abfragen; wenn ungleich 0x01, Abbruch der Programmierung CCC_APPS
//############################################################################################################
CDHapiJob(SgbdName, "HOST_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
// 12.01.2005 MK v1.21f
// MK: Sonderablauf, um zu prüfen, ob CCC flashbereit ist
// wenn CCC mit Busy-RepeatRequest antwortet,
// dann FIB-Generierung anstoßen und warten
apiResultText(MyResultBool, MyResultString, "JOB_STATUS", 1, "");
if((MyResultBool == TRUE) && (MyResultString == "ERROR_ECU_BUSY_REPEAT_REQUEST"))
{
// internen Reset durchführen (Anfrage max. 10-mal in 10 sec Abständen senden)
MyCntr = 0;
MyStatus = 0;
while((MyCntr < 10) && (MyStatus == 0))
{
CDHapiJob(SgbdName, "HOST_STEUERN_INTERNAL_RESET", "", "");
apiResultText(MyResultBool, MyResultString, "JOB_STATUS", 1, "");
if((MyResultBool == TRUE) // Antwort vom SG verfügbar
&& (MyResultString == "OKAY")) // Antwort ist 'OKAY'
MyStatus = 1; // fertig
else
CDHDelay(10*1000); // 10 sec Wartezeit
MyCntr = MyCntr + 1; // Anfragen zählen
}
// falls nicht OKAY, dann Fehler ermitteln und raus
TestApiFehler(COAPI_CCC_INTRESET_ERROR, ProcName, 0, SgbdName + ", HOST_STEUERN_INTERNAL_RESET");
// Reset wird durchgeführt -> 5 min warten
CDHDelay(300*1000);
// FIB generieren immer anstoßen, auch wenn FIB aktuell ist
CDHapiJob(SgbdName, "HOST_GENERATE_FIB", "", "");
TestApiFehler(COAPI_CCC_FIBGEN_ERROR, ProcName, 0, SgbdName + ", HOST_GENERATE_FIB");
// max. 40 min auf die erfolgreiche Erstellung des FIB warten
MyCntr = 0;
MyStatus = 0;
while((MyStatus != 0x1F) && (MyCntr < 480)) // 40 min -> 2400 sec -> 480 * 5 sec
{
CDHapiJob(SgbdName, "HOST_STATUS_FIB_CREATE", "", "");
apiResultInt(MyResultBool, MyStatus, "STAT_FIB_CREATE", 1);
if(MyResultBool != TRUE) // keine Antwort vom SG verfügbar
MyStatus = 0; // Status ungültig
CDHDelay(5*1000); // 5 sec Wartezeit
MyCntr = MyCntr + 1; // 5 sec Incremente zählen
}
if(MyStatus != 0x1F) { // FIB nicht aktuell ?
// Abbruch: SG hat nicht geantwortet oder NegResponse
TestApiFehler(COAPI_CCC_FIBCREATE_ERROR, ProcName, 0, SgbdName + ", HOST_STATUS_FIB_CREATE");
// Abbruch: FIB ist nicht aktuell
SetCDHFehler (COAPI_CCC_FIBCREATE_ERROR, ProcName, 0, SgbdName + ", HOST_STATUS_FIB_CREATE");
}
// FIB i.O., dann nochmal 1 min warten
CDHDelay(60*1000);
// Programmierstatus nochmal lesen, damit weiterer Ablauf normal funktioniert
CDHapiJob(SgbdName, "HOST_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
}
// MK: Ende Sonderablauf
TestApiFehler(COAPI_CCC_HOST_STATUS_ERROR, ProcName, 2143, SgbdName + ", HOST_PROGRAMMIER_STATUS_LESEN");
// HOST-ProgStatus auswerten
CDHapiResultInt(SgStatus, "FLASH_PROGRAMMIER_STATUS", 1);
OutputDebugInt(2147, "ProgrammierStatus CCC_HOST ",SgStatus);
if (SgStatus >= 0x80)
SgStatus = 0x01; // Für Zulieferer reserviert - Interpretation wie 0x01
if (SgStatus != 0x01)
// HOST-ProgStatus nicht ok
SetCDHFehler(COAPI_CCC_HOST_STATUS_ERROR, ProcName, 1570, SgbdName + ", HOST_PROGRAMMIER_STATUS_LESEN: ERGEBNIS UNGLEICH 1");
//############################################################################################################
// (4) Programmierstatus abfragen
//############################################################################################################
CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 2143, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN");
CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1);
OutputDebugInt(2147, "ProgrammierStatus vor der Programmierung ", SgStatus);
// ProgStatus auswerten
if ((SgStatus >= 0x10) && (SgStatus <= 0x7F))
{
SetCDHFehler(COAPI_ECU_PROG_STATUS_ERROR, ProcName, 2171, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN");
}
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
SGReset(SgbdName, ResetZeit);
}
//############################################################################################################
// (5) Blocklänge lesen
//############################################################################################################
CDHapiJob(SgbdName, "FLASH_BLOCKLAENGE_LESEN", "", "FLASH_BLOCKLAENGE_GESAMT");
TestApiFehler(COAPI_ECU_MXBL_ERROR, ProcName, 2179, SgbdName + ", FLASH_BLOCKLAENGE_LESEN");
CDHapiResultInt(MaxData, "FLASH_BLOCKLAENGE_GESAMT", 1 );
if(MaxData < 0)
MaxData = MaxData + 65536; // MaxData > 0x8000
MaxData = MaxData - 1; // Service ID wird nicht gezaehlt
if(MaxData > MXBL_STANDARD) // MXBL > 0x00FF
{
if(OppsMostAccess == TRUE)
{
if(MaxData > MXBL_MOST_XXL)
{
MaxData = MXBL_MOST_XXL;
}
}
else
{
MaxData = MXBL_STANDARD; // Programmierung nicht über OPPS-MOST-Zugang
}
}
OutputDebugInt(2222, "MXBL : ",MaxData);
SetFlashState(3);
//############################################################################################################
// (6) Block-Informationen berechnen
//############################################################################################################
//**********************************************************************
// 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
AddWordToDWord(NextAdrLow, NextAdrMidLow, NextAdrMidHigh, NextAdrHigh, NrOfData);
// Laenge des Datenblocks
AddWordToDWord(DataBlockLengthLow, DataBlockLengthMidLow, DataBlockLengthMidHigh, DataBlockLengthHigh, NrOfData);
// 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 == "HC12DG128")
{
if ((NextAdrLow == 0x00) &&
((NextAdrMidLow == 0x40) || (NextAdrMidLow == 0x80) || (NextAdrMidLow == 0xC0)) &&
(NextAdrMidHigh == 0x00) &&
(NextAdrHigh == 0x00))
{
hexstring(NextAdrMidLow,StrWert);
OutputDebugString(2317, "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;
}
else
{
BlockSchreibenFlag = FALSE;
}
}
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)
OutputDebugInt(2427, "Anzahl Datenbloecke: ",BlockCounter);
Index = 0;
while (Index < BlockCounter)
{
inttostring(Index,StrWert);
Text="Block("+StrWert+") Startadressse = ";
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+" Anzahl Bytes = ";
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(2465, Text);
Index = Index + 1;
}
Text="Gesamtanzahl Bytes= ";
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(2477, Text);
TestCDHFehler(Status);
//**********************************************************************
// Ende
// Laenge & Anfangsadressen der Datenbloecke ohne Adressenluecken ermitteln
//**********************************************************************
//############################################################################################################
// (7) StartDiagonsticSession und Authentisierung
//############################################################################################################
//**********************************************************************
// 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, 2544, 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_SERIAL_ERROR, ProcName, 2595, SgbdName + ", SERIENNUMMER_LESEN");
CDHapiResultText (SgSerienNr, "SERIENNUMMER", 1, "");
// nur die Zeichen 5-8 + terminierungs-Null benutzen
midstr(SgSerienNr,SgSerienNr,5,5);
OutputDebugString(2599, "SgSerienNr : "+SgSerienNr);
// Zufallszahlen holen
CDHAuthGetRandom(UserId,UserIdSGBD);
CDHapiJob(SgbdName, "AUTHENTISIERUNG_ZUFALLSZAHL_LESEN", AUTHENTISIERUNGS_LEVEL+";"+UserIdSGBD, "");
TestApiFehler(COAPI_ECU_RANDOM_ERROR, ProcName, 2607, 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(2617, "Authentisierungsart: "+AuthentisierungArt);
// Erzeugen Buffer fuer Authentisierungs Schlüssel
CDHBinBufCreate(AuthentisierungSchluessel,Status);
TestCDHFehler(Status);
CDHCallAuthenticate(SGFamilie, UserId, SgSerienNr,
SG_AUTHENTISIERUNG, // MK: 'AuthentisierungArt' ist nach Stand-auf-Stand flashen beim DAF ungültig !!!
AuthentisierungZufallsZahl,
AUTHENTISIERUNGS_LEVEL,
AuthentisierungSchluessel,
AuthentisierungSchluesselLaenge,
Status);
if (Status != 0)
TestCDHFehler(COAPI_ECU_AUTHENTICATION_FORMAT_ERROR);
OutputDebugInt(2635, "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);
CDHapiJobData(SgbdName, "AUTHENTISIERUNG_START", AuthentisierungBuffer, 21+AuthentisierungSchluesselLaenge, "");
TestApiFehlerNoExit(COAPI_ECU_AUTHENTICATION_ERROR, ProcName, 2660, SgbdName + ", AUTHENTISIERUNG_START ( SG-Schluessel ...)", Status);
if ((Status != 0) && (TestSchluesselAuthentisierung == TRUE))
{
//**********************************************************************
// Authentisierung fehlerhaft
// Versuch mit Testschlüssel
//**********************************************************************
// Steuergerät Reset durchführen
SGReset(SgbdName, ResetZeit);
// Zufallszahlen holen
CDHAuthGetRandom(UserId,UserIdSGBD);
CDHapiJob(SgbdName, "AUTHENTISIERUNG_ZUFALLSZAHL_LESEN", AUTHENTISIERUNGS_LEVEL+";"+UserIdSGBD, "");
TestApiFehler(COAPI_ECU_RANDOM_ERROR, ProcName, 2689, 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(2701, "Authentisierungsart : "+AuthentisierungArt);
SGFamilieTestschluessel="??";
if (AuthentisierungArt=="Asymetrisch")
SGFamilieTestschluessel="T_SMA";
if (AuthentisierungArt=="Symetrisch")
SGFamilieTestschluessel="T_SMB";
if (AuthentisierungArt=="Simple")
SGFamilieTestschluessel="T_SMC";
OutputDebugString(2710, "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,
AUTHENTISIERUNGS_LEVEL,
AuthentisierungSchluessel,
AuthentisierungSchluesselLaenge,
Status);
if (Status != 0)
TestCDHFehler (COAPI_ECU_AUTHENTICATION_FORMAT_ERROR);
OutputDebugInt(2729, "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);
CDHapiJobData(SgbdName, "AUTHENTISIERUNG_START", AuthentisierungBuffer, 21+AuthentisierungSchluesselLaenge, "");
TestApiFehler(COAPI_ECU_AUTHENTICATION_ERROR, ProcName, 2756, SgbdName + ", AUTHENTISIERUNG_START ( Test-Schluessel ... )");
OutputDebugString(2779, "!!! Authentisierung mit Testschluessel !!!");
//**********************************************************************
// 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, 2812, SgbdName + ", DIAGNOSE_MODE (ECUPM)");
if (WartenNachECUProgrammMode > 0)
{
CDHDelay(WartenNachECUProgrammMode*1000+500);
}
else
{
if (ResetZeit > 0)
CDHDelay(ResetZeit*1000+500);
else
CDHDelay(500);
}
}
// ersten Datenblock holen
CDHGetApiJobByteData (MaxData, Buffer, BufferSize, NrOfData, Status);
TestCDHFehler(Status);
SetFlashState(4);
//############################################################################################################
// (8) Daten schreiben vorbereiten und Flash löschen
//############################################################################################################
//Auffuellen mit 0xFF bis MaxData (Laenge)
if (AuffuellenSwitch == TRUE)
{
if (NrOfData < MaxData)
{
BufferAuffuellen(Buffer, BufferSize, MaxData);
}
}
//Ende von auffuellen mit 0xFF bis MaxData (Laenge)
// Flash-Speicher im SG 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);
// Flash löschen
CDHapiJobData (SgbdName, "FLASH_LOESCHEN", Buffer, BufferSize, "");
TestApiFehler (COAPI_ECU_FLASH_ERASE_ERROR, ProcName, 2935, SgbdName + ", FLASH_LOESCHEN (...)");
CDHapiResultInt (SgStatus, "FLASH_LOESCHEN_STATUS", 1);
OutputDebugInt(2939, "### Status Flash-Loeschen : ",SgStatus);
if (SgStatus != 0x01)
{
SetCDHFehler (COAPI_ECU_FLASH_ERASE_ERROR, ProcName, 2947, SgbdName + ", FLASH_LOESCHEN (...)");
}
SetFlashState(5);
//############################################################################################################
// (9) Daten schreiben
//############################################################################################################
// // Prüfen auf globalen Parameter zur DLE Verwendung
// // wenn er nicht existiert, wird ein Fehler 1000 eingetragen, aber nicht abgebrochen
// CDHGetCabdPar(DLEUseKey, DLEUseKeyValue, Status);
// if (Status != 0)
// {
// // wenn der globale Parameter nicht existiert, dann DLE verwenden
// DLEUseKeyValue = "TRUE";
// }
CDHapiJob (SgbdName, "STATUS_DLE_VERSION", "", "");
TestApiFehler (COAPI_OPPS_DLE_VERSION_ERROR, ProcName, 2163, SgbdName + ", STATUS_DLE_VERSION");
CDHapiResultText(DLE_Present , "PRESENT", 1, "");
OutputDebugString(0, "DLE_Present : " + DLE_Present);
CDHapiResultText(DLE_Version , "VERSION", 1, "");
OutputDebugString(0, "DLE_Version : " + DLE_Version);
// DownloadEngine nutzen, wenn konfiguriert und vorhanden
// if ((DownloadEngineSwitch == TRUE) && (DLEUseKeyValue == "TRUE") && (DLE_Present == "TRUE"))
if ((DownloadEngineSwitch == TRUE) && (DLE_Present == "TRUE"))
{
FlashDLE(SgbdName, MaxData, NrOfData, Buffer, BlockCounter, StartAdrBuffer, BlockLengthBuffer, BlockSchreibenFlag);
}
else
{
FlashStd(SgbdName, MaxData, NrOfData, Buffer, BlockCounter, StartAdrBuffer, BlockLengthBuffer, BlockSchreibenFlag);
}
SetFlashState(6);
//############################################################################################################
// (10a) InfoLog-Eintrag mit der ID 0x64 loeschen
// DTZ, 09.06.2005
//############################################################################################################
CDHapiJob (SgbdName, "PSGBD_CLEANUP_INFOLOG_64", "", "");
//############################################################################################################
// (10) Signaturprüfung
//############################################################################################################
//**********************************************************************
// Programmierstatus abfragen fuer Signaturpruefung
//**********************************************************************
CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3332, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN");
CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1);
OutputDebugInt(3334, "ProgrammierStatus nach der Programmierung : ", SgStatus);
// Programmierstatus auswerten
//**********************************************************************
// Signaturpruefung
//**********************************************************************
if (SgStatus == 0x06) // Signaturpruefung DAF nicht durchgefuehrt
{
CDHapiJob (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, "");
}
else
{
// Programmierstatus nach Download nicht plausibel
SetCDHFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3363, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN, Programmierstatus nicht plausibel");
}
}
// Ergebnis der Signaturprüfung auswerten
apiResultText(MyResultBool, MyResultString, "JOB_STATUS", 1, "");
if((MyResultBool != TRUE)
|| ((MyResultString != "OKAY") && (MyResultString != "ERROR_FLASH_SIGNATURE_CHECK")))
{
// Sonderbehandlung, wenn keine Antwort vom SG verfügbar (nach Timeout)
// bzw. Antwort nicht 'Signatur i.O.' und nicht 'Signatur n.i.O.' (ggf. auch nach Timeout)
CDHDelay(20*1000); // kurze Pause einlegen (20 sec)
// Programmierstatus abfragen
CDHapiJob(SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "");
apiResultInt(MyResultBool, MyStatus, "FLASH_PROGRAMMIER_STATUS", 1);
if(MyResultBool == TRUE)
{
// "FLASH_PROGRAMMIER_STATUS" verfügbar, dann lieber noch ein bischen warten
// damit alles weitere sicher hochläuft (5 min)
CDHDelay(300*1000);
}
else
{
// "FLASH_PROGRAMMIER_STATUS" nicht verfügbar, dann
// internen Reset durchführen (Anfrage max. 10-mal in 10 sec Abständen senden)
MyCntr = 0;
MyStatus = 0;
while((MyCntr < 10) && (MyStatus == 0))
{
CDHapiJob(SgbdName, "HOST_STEUERN_INTERNAL_RESET", "", "");
apiResultText(MyResultBool, MyResultString, "JOB_STATUS", 1, "");
if((MyResultBool == TRUE) // Antwort vom SG verfügbar
&& (MyResultString == "OKAY")) // Antwort ist 'OKAY'
MyStatus = 1; // fertig
else
CDHDelay(10*1000); // 10 sec Wartezeit
MyCntr = MyCntr + 1; // Anfragen zählen
}
// falls nicht OKAY, dann Fehler ermitteln und raus
TestApiFehler(COAPI_CCC_INTRESET_ERROR, ProcName, 0, SgbdName + ", HOST_STEUERN_INTERNAL_RESET");
// Reset wird durchgeführt -> 5 min warten
CDHDelay(300*1000);
// durch den Reset wird beim Coldboot das FIB-generieren automatisch angestoßen
// max. 40 min auf die erfolgreiche Erstellung des FIB warten
MyCntr = 0;
MyStatus = 0;
while((MyStatus != 0x1F) && (MyCntr < 480)) // 40 min -> 2400 sec -> 480 * 5 sec
{
CDHapiJob(SgbdName, "HOST_STATUS_FIB_CREATE", "", "");
apiResultInt(MyResultBool, MyStatus, "STAT_FIB_CREATE", 1);
if(MyResultBool != TRUE) // keine Antwort vom SG verfügbar
MyStatus = 0; // Status ungültig
CDHDelay(5*1000); // 5 sec Wartezeit
MyCntr = MyCntr + 1; // 5 sec Incremente zählen
}
if(MyStatus != 0x1F) { // FIB nicht aktuell ?
// Abbruch: SG hat nicht geantwortet oder NegResponse
TestApiFehler(COAPI_CCC_FIBCREATE_ERROR, ProcName, 0, SgbdName + ", HOST_STATUS_FIB_CREATE");
// Abbruch: FIB ist nicht aktuell
SetCDHFehler(COAPI_CCC_FIBCREATE_ERROR, ProcName, 0, SgbdName + ", HOST_STATUS_FIB_CREATE");
}
// FIB i.O., dann nochmal 1 min warten
CDHDelay(60*1000);
}
}
// 15.12.2004 DTZ v1.21c
else
{
if (SgStatus == 0x06) // Signaturpruefung DAF nicht durchgefuehrt
{
TestApiFehler (COAPI_ECU_SIGNATUR_ERROR, ProcName, 3344, SgbdName + ", FLASH_SIGNATUR_PRUEFEN (Daten;" + SignaturTestZeit + ")");
}
else
{
TestApiFehler (COAPI_ECU_SIGNATUR_ERROR, ProcName, 3352, SgbdName + ", FLASH_SIGNATUR_PRUEFEN (Programm;" + SignaturTestZeit + ")");
}
}
// Auf CCC warten bis Applikationen vollständig gestartet sind
CDHDelay(30*1000+500);
SetFlashState(7);
//############################################################################################################
// 07.01.2005 DTZ v1.21d
// (11a) im Falle "HIP nicht per Diagnosekommando status_hip_hw_version erreichbar" HIP-FW-Upgrade explizit anstoßen
//############################################################################################################
CDHapiJob(SgbdName, "PSGBD_STATUS_HIP_HW_VERSION", "", "STAT_HIP_DRIVER");
// 10.01.2005 DTZ v1.21e
apiResultInt(MyResultBool, HipStatus, "STAT_HIP_DRIVER", 1);
if (MyResultBool == TRUE)
{
if (HipStatus == 1) // HIP_HW_VERSION nicht lesbar => ein Fall fürs HIP-FW-Update
{
CDHapiJob(SgbdName, "PSGBD_START_HIP_SW_LOADING", "/tffs0/flash/hip/hiprom.jar", "");
CDHDelay(120*1000);
}
}
//############################################################################################################
// (11) AIF schreiben
//############################################################################################################
//**********************************************************************
// Programmierstatus abfragen
//**********************************************************************
CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3377, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN");
CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1);
OutputDebugInt(3379, "ProgrammierStatus nach der Signaturpruefung : ",SgStatus);
// Programmierstatus auswerten
SetFlashState(8);
if (((SgStatus-(SgStatus/0x10)*0x10) == 0x01) || // Normalbetrieb, auch PS=0x81 für NoFIB-Prozeß wird erfaßt
((SgStatus == 0x0C) && (ProgrammUndDaten == FALSE)))
{
CDHGetCabdWordPar ("PROG_WITH_AIF" , PROG_WITH_AIF, Status);
TestCDHFehler (Status);
OutputDebugInt(3387, "AIF schreiben aktiviert : ",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(3406, "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(3448, "Aif Argument : "+StringArgument);
CDHapiJob (SgbdName, "AIF_SCHREIBEN", StringArgument, "");
TestApiFehler (COAPI_ECU_WRITE_AIF, ProcName, 3450, SgbdName + ", AIF_SCHREIBEN ("+StringArgument+")");
}
//############################################################################################################
// (12) Programmierung beenden
//############################################################################################################
//**********************************************************************
// DIAGNOSE_ENDE
//**********************************************************************
CDHapiJob (SgbdName, "DIAGNOSE_ENDE", "", "");
TestApiFehler (COAPI_ECU_STOPDIAG_ERROR, ProcName, 3461, SgbdName + ", DIAGNOSE_ENDE");
SetFlashState(9);
//**********************************************************************
// STEUERGERAETE_RESET
//**********************************************************************
// Boot Sektor Update
CDHGetCabdWordPar ("BSUTIME", BSUTime, Status);
OutputDebugInt(3468, "BSUTime : ", BSUTime);
ResetZeit = ResetZeit + BSUTime;
OutputDebugInt(3471, "ResetZeit mit BSUTime : ",ResetZeit);
SGReset(SgbdName, ResetZeit);
//**********************************************************************
// ggf. FIB kreieren im Rahmen "NoFIB-Prozeß"
//**********************************************************************
RepeatedApiJobOnError (SgbdName, "HOST_SET_END_SWL", "", "");
TestApiFehler (COAPI_CCC_SET_END_SWL_ERROR, ProcName, 3365, SgbdName + ", HOST_SET_END_SWL");
//**********************************************************************
// Programmierstatus abfragen
//**********************************************************************
RepeatedApiJobOnError (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3483, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN");
CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1);
OutputDebugInt(3485, "ProgrammierStatus nach RESET : ",SgStatus);
// Programmierstatus auswerten
if ((SgStatus != 1) && ((SgStatus != 0x0C) || (BSUTime == 0)))
{
SetCDHFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3491, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN");
}
//**********************************************************************
// CCC Nachbehandlung
//**********************************************************************
// internen Reset ausführen
RepeatedApiJobOnError (SgbdName, "HOST_STEUERN_INTERNAL_RESET", "", "");
TestApiFehler (COAPI_CCC_INTRESET_ERROR, ProcName, 3370, SgbdName + ", HOST_STEUERN_INTERNAL_RESET");
// Resetzeit abwarten
CDHDelay(ResetZeit*1000+500);
}
CDHTestError (Status);
CDHSetReturnVal (0);
OutputDebugString(0, "Programmierung erfolgreich beendet");
ProgSuccess = TRUE;
}
//**********************************************************************
//*
//* 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(3533, ProcName);
CDHapiInit(); // CDH-Initialisierung
CDHGetSgbdName(SgbdName,Status); // SGBD-Name aus SGET
TestCDHFehler (Status);
CDHGetCabdWordPar ("HWNR_IS_NEW", IsNewHwNr, Status);
TestCDHFehler (Status);
OutputDebugInt(3540, "IsNewHwNr : ",IsNewHwNr);
//**********************************************************************
// Programmierstatus abfragen
//**********************************************************************
RepeatedApiJobOnError (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
TestApiFehler (COAPI_ECU_PROG_STATUS_ERROR, ProcName, 3546, SgbdName + ", FLASH_PROGRAMMIER_STATUS_LESEN");
CDHapiResultInt (SgStatus, "FLASH_PROGRAMMIER_STATUS", 1);
OutputDebugInt(3548, "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 == 0x02 || // SG steht in SWL_DEMAND und hat noch kein RequestClearMemory erlebt DTZ, 15.11.2005
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(3611, "ProgTyp : ",ProgTyp);
CDHSetCabdWordPar ("PROG_ORDER", ProgOrder, Status);
TestCDHFehler (Status);
OutputDebugInt(3615, "ProgOrder : ",ProgOrder);
if (ProgTyp == 0 || ProgOrder == 0)
{
Status = COAPI_ECU_PROG_STATUS_ERROR;
SetCDHFehler (Status, ProcName, 3620, "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 != "HC12DG128"))
{
Status = COAPI_PROCESSOR_TYPE_ERROR;
SetCDHFehler (Status, ProcName, 3654, "ProzessorTyp = " + ProzessorTyp);
}
OutputDebugString(3657, 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, 3682, "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(3714, ProcName);
if (ProgSuccess == FALSE)
{
//******************************************************************************
// hier keine Fehlerauswertung mehr, da Abbruchgrund sonst verschleiert wird !!!
//******************************************************************************
CDHGetSgbdName (SgbdName,Status); // SGBD-Name aus SGET
if (DownloadEngineSwitch == TRUE)
{
// DLE: TP stoppen und rücksetzen
CDHapiJob (SgbdName, "STEUERN_DLE_TP", "0", "");
CDHapiJob (SgbdName, "STEUERN_DLE_RESET", "", "");
OutputDebugString(0, "DLE: TP stoppen & reset");
}
else if (TesterPresentHandlingFlag == TRUE)
{
//**********************************************************************
// Fahrzeugbusse wieder wecken
// Timer loeschen
// Tritt nur bei abgebrochener Programmierung auf
//**********************************************************************
TesterPresentHandling(ProcName, SgbdName, FALSE);
}
// nach Abbruch nocheinmal Kommunikation zum SG prüfen
CDHapiJob (SgbdName, "FLASH_BLOCKLAENGE_LESEN", "", "FLASH_BLOCKLAENGE_GESAMT");
CDHapiJob (SgbdName, "FLASH_PROGRAMMIER_STATUS_LESEN", "", "FLASH_PROGRAMMIER_STATUS");
// SH4-Reset über CCC_GW, danach in SH4-Bootmode SWL_DEMAND schalten
CDHapiJob (SgbdName, "PSGBD_STEUERN_RESET_SH4_VIA_GW", "", "");
CDHDelay(10*1000);
CDHapiJob (SgbdName, "PSGBD_STEUERN_BOOTMODE_HOST", "SWL_DEMAND", "");
CDHDelay(10*1000);
CDHapiJob (SgbdName, "PSGBD_STEUERN_RESET_SH4_VIA_GW", "", "");
CDHDelay(120*1000);
}
// Löschen der dynamischen Buffer
i = 0;
while(Status == 0)
{
CDHBinBufDelete(i,Status);
i = i + 1;
}
CDHapiEnd();
}
// -- EOF --
Reference in New Issue View Git Blame Copy Permalink