1380 lines
46 KiB
Plaintext
Executable File
1380 lines
46 KiB
Plaintext
Executable File
/**************************************************************/
|
|
/* BMW AG Knorrstr. 147 80788 Muenchen */
|
|
/* Projekt : Neues Codiersystem */
|
|
/**************************************************************/
|
|
/* */
|
|
/* Filename : a_r56rw.ips */
|
|
/* */
|
|
/* Funktion : CABD fuer R56-SG ohne Checksummenberechnung */
|
|
/* mit 10 sec Wait nach Reset */
|
|
/* */
|
|
/* Autor : Bernhard Haller, EG-75 */
|
|
/**************************************************************/
|
|
|
|
//*************************************************************
|
|
//* History :
|
|
//* 22.06.06 HA V0.01 aus A_E65R V1.06 abgeleitet mit 10 Sekunden Wait
|
|
//* V0.01 nach dem Reset fuer die HO-Codierung
|
|
//* 22.06.06 HA V1.00 Werksfreigabe
|
|
//* 19.09.06 HA V1.01 Korrektur bei Ermittlung der Haendlernummer
|
|
//* V1.01 durch Abfrage der Werk-Nr aus der Oberflaeche
|
|
//*********************>-.-.-.-.-1-.-.-.-.-2-.-.-.-.-3-.-.-.-.-4-.-.-.-.-5<
|
|
|
|
// DOS-Editor
|
|
#pragma dosedit
|
|
|
|
|
|
/***********************************/
|
|
/* I N C L U D E S */
|
|
/***********************************/
|
|
|
|
#include "cabi.h"
|
|
|
|
|
|
/***********************************/
|
|
/* D A T A */
|
|
/***********************************/
|
|
|
|
string ModulName = "A_R56RW.IPS";
|
|
string version = "1.01";
|
|
string origin = "BMW AG, EG-75 Bernhard Haller";
|
|
string csgbd = "SG-spezifisch";
|
|
string kommentar = "CABD fuer SG E65 ohne Checksummenberechung und mit Reset";
|
|
string cabd = "A_R56RW";
|
|
|
|
int intWarten = 10000; //Standartewartezeit nach Reset
|
|
|
|
/***********************************/
|
|
/* F U N C T I O N S */
|
|
/***********************************/
|
|
|
|
debug( in: string Debug_Text ){
|
|
string strFile = "c:\ediabas\trace\test_.txt";
|
|
fileopen(strFile,"a");
|
|
filewrite( Debug_Text );
|
|
fileclose();
|
|
}
|
|
|
|
debug_int( in: int int_Value ){
|
|
string int_String;
|
|
string strFile = "c:\ediabas\trace\test_.txt";
|
|
inttostring( int_Value, int_String);
|
|
fileopen(strFile,"a");
|
|
filewrite( int_String );
|
|
fileclose();
|
|
}
|
|
|
|
Warten (in: int timer_wert){
|
|
int timer1 = 1;
|
|
bool expiredflag = FALSE;
|
|
|
|
settimer(timer1, timer_wert);
|
|
while (expiredflag == FALSE)
|
|
{
|
|
testtimer(timer1, expiredflag);
|
|
} //endwhile
|
|
}
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : TestCDHFehler
|
|
//*
|
|
//* Funktion : Ueberpruefen, ob ein Fehler aufgetreten ist
|
|
//* und wenn ja: Setzen der ReturnWerte und Ausstieg
|
|
//*
|
|
//* Parameter : Eingangsparameter:
|
|
//* FStatus - Returnwert der aufgerufenen Funktion
|
|
//*
|
|
//* Rueckgabe : -
|
|
//*
|
|
//* Datum : 23.04.96 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
TestCDHFehler( in: int FStatus )
|
|
|
|
{
|
|
if ( FStatus != 0 )
|
|
{
|
|
CDHSetReturnVal (FStatus);
|
|
exit ();
|
|
}
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : TestApiFehler
|
|
//*
|
|
//* Funktion : Ueberpruefen, ob bei ApiJob ein Fehler aufgetreten ist
|
|
//*
|
|
//* Parameter : Eingangsparameter:
|
|
//* CStatus - Returnwert der aufgerufenen Funktion
|
|
//* ProcName - Name der aufgerufenen Prozedur
|
|
//* LinieNr -
|
|
//* Zusatzinfo - Steuergeraetename und API-Auftrag
|
|
//*
|
|
//*
|
|
//* Rueckgabe : -
|
|
//*
|
|
//* Datum : 23.04.96 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
TestApiFehler( in: int CStatus, in: string ProcName,
|
|
in: int LineNr, in: string Info)
|
|
{
|
|
string ApiStatusText;
|
|
|
|
CDHapiResultText (ApiStatusText, "JOB_STATUS", 1, "");
|
|
if (ApiStatusText != "OKAY")
|
|
{
|
|
strcat (Info, Info, ": "); //Zusammensetzen der FehlerZusatzInfo
|
|
strcat (Info, Info, ApiStatusText);
|
|
CDHSetError (CStatus, ModulName, ProcName, LineNr, Info);
|
|
CDHSetReturnVal (CStatus);
|
|
exit ();
|
|
}
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : Jobs
|
|
//*
|
|
//* Funktion : Ausgabe der unterstuetzten Jobs
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 02.12.04 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
Jobs( )
|
|
{
|
|
string ProcName = "Jobs";
|
|
int Status;
|
|
|
|
CDHSetCabdPar ("JOB[1]", "JOB_ERMITTELN", Status);
|
|
CDHSetCabdPar ("JOB[2]", "INFO", Status);
|
|
CDHSetCabdPar ("JOB[3]", "CODIERINDEX_LESEN", Status);
|
|
CDHSetCabdPar ("JOB[4]", "ID_LESEN", Status);
|
|
CDHSetCabdPar ("JOB[5]", "SG_CODIEREN", Status);
|
|
CDHSetCabdPar ("JOB[6]", "CODIERDATEN_LESEN", Status);
|
|
CDHSetCabdPar ("JOB[7]", "FGNR_LESEN", Status);
|
|
CDHSetCabdPar ("JOB[8]", "AE_INDEX_LESEN", Status);
|
|
CDHSetCabdPar ("JOB[9]", "AIF_LESEN", Status);
|
|
CDHSetCabdPar ("JOB[10]", "SG_RESET", Status);
|
|
|
|
CDHSetCabdPar ("JOB[11]", "SG_CODIEREN_OHNE_FG_AEI", Status);
|
|
CDHSetCabdPar ("JOB[12]", "AE_INDEX_AUFTRAG", Status);
|
|
CDHSetCabdPar ("JOB[13]", "AE_INDEX_SCHREIBEN", Status);
|
|
CDHSetCabdPar ("JOB[14]", "FGNR_AUFTRAG", Status);
|
|
CDHSetCabdPar ("JOB[15]", "FGNR_SCHREIBEN", Status);
|
|
CDHSetCabdPar ("JOB[16]", "TEST_FG_NR", Status);
|
|
CDHSetCabdPar ("JOB[17]", "TEST_AE_INDEX", Status);
|
|
CDHSetCabdPar ("JOB[18]", "TEST_CODIERUNG", Status);
|
|
// CDHSetCabdPar ("JOB[19]", "CODIERDATEN_SCHREIBEN", Status);
|
|
// CDHSetCabdPar ("JOB[20]", "NETTODATEN_CODIEREN", Status);
|
|
// CDHSetCabdPar ("JOB[21]", "CD_LESEN_OHNE_CI", Status);
|
|
// CDHSetCabdPar ("JOB[22]", "CD_SCHREIBEN_OHNE_CI", Status);
|
|
// CDHSetCabdPar ("JOB[23]", "SG_CODIEREN_OHNE_CI", Status);
|
|
|
|
CDHSetCabdPar ("JOB_ANZAHL", "18", Status);
|
|
CDHTestError (Status); //Pruefen Fehler insgesamt
|
|
CDHSetReturnVal (Status);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : InfoJob
|
|
//*
|
|
//* Funktion : Ausgabe der CABD-Infos
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 12.07.99 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
InfoJob( )
|
|
{
|
|
string ProcName = "InfoJob";
|
|
int Status;
|
|
|
|
CDHSetCabdPar ("REVISION", version, Status);
|
|
CDHSetCabdPar ("AUTOR", origin, Status);
|
|
CDHSetCabdPar ("COMMENT", kommentar, Status);
|
|
CDHSetCabdPar ("CABD", cabd, Status);
|
|
CDHTestError (Status); //Pruefen Fehler insgesamt
|
|
CDHSetReturnVal (Status);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : SgReset
|
|
//*
|
|
//* Funktion : SG-Reset
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 26.01.01 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
SgReset( )
|
|
{
|
|
string SgbdName;
|
|
string Info;
|
|
string ProcName = "SgReset";
|
|
|
|
int Status;
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET
|
|
TestCDHFehler (Status);
|
|
|
|
CDHapiJob(SgbdName, "STEUERGERAETE_RESET", "", ""); // Reset nach fehlerfreier Codierung
|
|
strcat (Info, SgbdName, ", STEUERGERAETE_RESET");
|
|
TestApiFehler (COAPI_ECU_WRITE_DATA_ERROR, ProcName, 449, Info); //Fehler beiSteuergeraete Reset
|
|
|
|
CDHSetReturnVal(0); //fehlerfreies Programmende
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : Ident
|
|
//*
|
|
//* Funktion : ID-Daten des SG
|
|
//*
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 28.03.00 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
Ident(out: int CodierindexTransfer)
|
|
|
|
{
|
|
string ProcName = "Ident";
|
|
string SgbdName, strCodierindexSg;
|
|
string Info;
|
|
string Funktions_SW, Nachrichtenkatalog, Operating_System, SW_Nr_Reserve, Var_Index;
|
|
string Teilenr_BMW, Lieferant, Lieferant_Nr, Datum, DiagnoseindexSg, HW_Nummer;
|
|
|
|
int Status, n;
|
|
int CodierindexSg;
|
|
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET
|
|
TestCDHFehler (Status);
|
|
//ID aus SG lesen
|
|
CDHapiJob(SgbdName, "IDENT", "", "");
|
|
TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 543, Info); //"SG antwortet nicht"
|
|
|
|
CDHapiResultInt (CodierindexSg, "ID_COD_INDEX", 1); //Holen Codierindex als Integer
|
|
CodierindexTransfer = CodierindexSg;
|
|
inttostring (CodierindexSg, strCodierindexSg);
|
|
strlen(n, strCodierindexSg); //Codierindex auf 2 Stellen auffuellen
|
|
if (n == 0)
|
|
strcat(strCodierindexSg, "00", strCodierindexSg);
|
|
if (n == 1)
|
|
strcat(strCodierindexSg, "0", strCodierindexSg);
|
|
|
|
CDHapiResultText (DiagnoseindexSg, "ID_DIAG_INDEX", 1, "");
|
|
strlen(n, DiagnoseindexSg); //Diagnoseinndex auf 2 Stellen auffuellen
|
|
if (n == 0)
|
|
strcat(DiagnoseindexSg, "00", DiagnoseindexSg);
|
|
if (n == 1)
|
|
strcat(DiagnoseindexSg, "0", DiagnoseindexSg);
|
|
|
|
CDHapiResultText (Var_Index, "ID_VAR_INDEX", 1, "");
|
|
|
|
CDHapiResultText (Teilenr_BMW, "ID_BMW_NR", 1, "");
|
|
|
|
CDHapiResultText (Datum, "ID_DATUM", 1, "");
|
|
|
|
CDHapiResultText (Lieferant, "ID_LIEF_TEXT", 1, "");
|
|
|
|
CDHapiResultText (Lieferant_Nr, "ID_LIEF_NR", 1, "");
|
|
|
|
CDHapiResultText (Funktions_SW, "ID_SW_NR_FSV", 1, "");
|
|
|
|
CDHapiResultText (Nachrichtenkatalog, "ID_SW_NR_MCV", 1, "");
|
|
|
|
CDHapiResultText (Operating_System, "ID_SW_NR_OSV", 1, "");
|
|
|
|
CDHapiResultText (SW_Nr_Reserve, "ID_SW_NR_RES", 1, "");
|
|
|
|
CDHapiResultText (HW_Nummer, "ID_HW_NR", 1, "");
|
|
|
|
CDHSetCabdPar ("CODIERINDEX", strCodierindexSg, Status);
|
|
CDHSetCabdPar ("DIAGNOSEINDEX", DiagnoseindexSg, Status);
|
|
CDHSetCabdPar ("VARIANTENINDEX", Var_Index, Status);
|
|
CDHSetCabdPar ("BMW-TEILENUMMER", Teilenr_BMW, Status);
|
|
CDHSetCabdPar ("HERSTELLDATUM", Datum, Status);
|
|
CDHSetCabdPar ("LIEFERANTEN-NR", Lieferant_Nr, Status);
|
|
CDHSetCabdPar ("LIEFERANT", Lieferant, Status);
|
|
CDHSetCabdPar ("HARDWARE-NR", HW_Nummer, Status);
|
|
CDHSetCabdPar ("FUNKTIONS-SW", Funktions_SW, Status);
|
|
CDHSetCabdPar ("NACHRICHTENKATALOG", Nachrichtenkatalog, Status);
|
|
CDHSetCabdPar ("STANDARD-CORE", Operating_System, Status);
|
|
CDHSetCabdPar ("SW-RESERVE-NR", SW_Nr_Reserve, Status);
|
|
CDHTestError (Status); //Pruefen Fehler insgesamt
|
|
CDHSetReturnVal (Status);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : FgnrTest
|
|
//*
|
|
//* Funktion : FGSt.Nr. schreiben/lesen pruefen
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 28.01.050 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
FgnrTest( )
|
|
{
|
|
string SgbdName;
|
|
string FgstNr, FgstNrTest;
|
|
string Info, Info1;
|
|
string ProcName = "FgnrTest";
|
|
string strN,strName;
|
|
|
|
int Status;
|
|
int intN;
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET
|
|
TestCDHFehler (Status);
|
|
|
|
debug ("Test Fahrgestellnummer");
|
|
|
|
intN=1;
|
|
|
|
while (intN < 3)
|
|
{
|
|
inttostring (intN, strN);
|
|
|
|
if (intN == 1)
|
|
{
|
|
FgstNr = "ZZZZZ66666ZZ66666V"; //1. FG-Nr. setzen
|
|
}
|
|
else
|
|
{
|
|
FgstNr = "EEEEE99999EE99999S"; //2. FG-Nr. setzen
|
|
}
|
|
|
|
strcat (strName, "Fahrgestellnr. schreiben " , strN);
|
|
CDHSetCabdPar (strName, FgstNr, Status); //FG-Nr zur Anzeige setzen
|
|
TestCDHFehler (Status);
|
|
|
|
strcat (strName, strName, ": ");
|
|
strcat (strName, strName, FgstNr);
|
|
debug (strName);
|
|
|
|
midstr (FgstNrTest, FgstNr, 10, 7); //letzten 7 Stellen der Fg-Nummer holen
|
|
|
|
CDHapiJob(SgbdName, "C_FG_SCHREIBEN", FgstNr, "");
|
|
strcat (Info, SgbdName, ", C_FG_SCHREIBEN");
|
|
TestApiFehler (COAPI_ECU_CODING_ERROR, ProcName, 205, Info); //Fgnr schreiben fehlerhaft
|
|
|
|
SgReset; //Steuergeraete Reset
|
|
|
|
Warten (intWarten); //warten fuer Resetbehandlung
|
|
|
|
CDHapiJob(SgbdName, "C_FG_LESEN", "", "");
|
|
strcat (Info, SgbdName, ", C_FG_LESEN");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 223, Info); //Fgnr. lesen fehlerhaft
|
|
CDHapiResultText(FgstNr, "FG_NR", 1, ""); //FG-Nr. holen
|
|
|
|
|
|
strcat (strName, "Fahrgestellnr. gelesen " ,strN);
|
|
CDHSetCabdPar(strName, FgstNr, Status);
|
|
TestCDHFehler (Status);
|
|
|
|
strcat (strName, strName, ": ");
|
|
strcat (strName, strName, FgstNr);
|
|
debug (strName);
|
|
|
|
if (FgstNrTest != FgstNr) //Vergleichen der FG-Nummern und ggf. Fehlermeldung setzen
|
|
{
|
|
strcat (Info1, Info1, "Fehler bei Vergleich der Fgnr ");
|
|
strcat (Info1, Info1, strN);
|
|
strcat (Info1, Info1, " ");
|
|
}
|
|
|
|
intN = intN + 1;
|
|
} //end while
|
|
|
|
debug (" ");
|
|
debug ("Bei Fehler Datei API.TRC und IFH.TRC auswerten");
|
|
debug (" ");
|
|
|
|
if (Info1 != "")
|
|
{
|
|
CDHSetError (COAPI_ECU_COMPARE_DATA_ERROR, ModulName, ProcName, 000, Info1);
|
|
CDHSetReturnVal (COAPI_ECU_COMPARE_DATA_ERROR);
|
|
exit ();
|
|
}
|
|
|
|
exit ();
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : AeIndexTest
|
|
//*
|
|
//* Funktion : AE-Index schreiben / lesen pruefen
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 28.01.05 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
AeIndexTest( )
|
|
{
|
|
string SgbdName;
|
|
string AeIndex, AeIndTest;
|
|
string Info, Info1;
|
|
string ProcName = "AeIndexTest";
|
|
string strN,strName;
|
|
|
|
int Status;
|
|
int intN;
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET
|
|
TestCDHFehler (Status);
|
|
|
|
debug ("Test Aenderungsindex");
|
|
|
|
intN=1;
|
|
|
|
while (intN < 3)
|
|
{
|
|
inttostring (intN, strN);
|
|
|
|
if (intN == 1)
|
|
{
|
|
AeIndex = "zz"; //1. AeIndex setzen
|
|
}
|
|
else
|
|
{
|
|
AeIndex = "ee"; //2. AeIndex setzen
|
|
}
|
|
|
|
strcat (strName, "Aenderungsindex schreiben " , strN);
|
|
CDHSetCabdPar (strName, AeIndex, Status); //AE-Index zur Anzeige setzen
|
|
TestCDHFehler (Status);
|
|
|
|
strcat (strName, strName, ": ");
|
|
strcat (strName, strName, AeIndex);
|
|
debug (strName);
|
|
|
|
AeIndTest = AeIndex; //AeIndexTest fuer Vergleich setzen
|
|
|
|
CDHapiJob(SgbdName, "C_AEI_SCHREIBEN", AeIndex, "");
|
|
strcat (Info, SgbdName, ", C_AEI_SCHREIBEN");
|
|
TestApiFehler (COAPI_ECU_CODING_ERROR, ProcName, 205, Info); //AE-Index schreiben fehlerhaft
|
|
|
|
SgReset; //Steuergeraete Reset
|
|
|
|
Warten (intWarten); //warten fuer Resetbehandlung
|
|
|
|
CDHapiJob(SgbdName, "C_AEI_LESEN", "", "");
|
|
strcat (Info, SgbdName, ", C_AEI_LESEN");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 223, Info); //AE-Index lesen fehlerhaft
|
|
CDHapiResultText(AeIndex, "COD_AE_INDEX", 1, ""); //AE-Index holen
|
|
|
|
|
|
strcat (strName, "Aenderungsindex gelesen " ,strN);
|
|
CDHSetCabdPar(strName, AeIndex, Status);
|
|
TestCDHFehler (Status);
|
|
|
|
strcat (strName, strName, ": ");
|
|
strcat (strName, strName, AeIndex);
|
|
debug (strName);
|
|
|
|
if (AeIndTest != AeIndex) //Vergleichen der FG-Nummern und ggf. Fehlermeldung setzen
|
|
{
|
|
strcat (Info1, Info1, "Fehler bei Vergleich des AeIndex ");
|
|
strcat (Info1, Info1, strN);
|
|
strcat (Info1, Info1, " ");
|
|
}
|
|
|
|
intN = intN + 1;
|
|
} //end while
|
|
|
|
debug (" ");
|
|
debug ("Bei Fehler Datei API.TRC und IFH.TRC auswerten");
|
|
debug (" ");
|
|
|
|
if (Info1 != "")
|
|
{
|
|
CDHSetError (COAPI_ECU_COMPARE_DATA_ERROR, ModulName, ProcName, 000, Info1);
|
|
CDHSetReturnVal (COAPI_ECU_COMPARE_DATA_ERROR);
|
|
exit ();
|
|
}
|
|
|
|
exit ();
|
|
}
|
|
|
|
|
|
//******************************************************************************
|
|
//*
|
|
//* Name : BufferErzeugen
|
|
//*
|
|
//* Funktion : erstellt Testbuffer
|
|
//*
|
|
//* Parameter : Eingangsparameter: Datenbuffer, NrOfData, Fuellwert
|
|
//*
|
|
//* Rueckgabe : Testbuffer
|
|
//*
|
|
//* Datum : 01.03.05 Autor: Bernhard Haller
|
|
//******************************************************************************
|
|
|
|
BufferErzeugen (in: int Quellbuffer, in: int intAnzahlDaten, in: int intWert, out: int Zielbuffer)
|
|
{
|
|
|
|
string ProcName = "BufferErzeugen";
|
|
string strBuffer, strBuffer1, strBuffer2, strAnzeige, strWert;
|
|
|
|
int intBuffer, intbuffer1, intbuffer2, Status;
|
|
int intZaehler = 21;
|
|
|
|
bool EndFlag = FALSE;
|
|
|
|
|
|
intBuffer = Quellbuffer; //Buffer zur Bearbeitung fuellen
|
|
|
|
while (EndFlag == FALSE)
|
|
{
|
|
CDHBinBufWriteByte (intBuffer, intWert, intZaehler, Status); //neuen Wert nach Position intZaehler schreiben
|
|
intZaehler = intZaehler + 1; //intZaehler inkrementieren
|
|
if (intZaehler > (intAnzahlDaten + 20))
|
|
EndFlag = TRUE; //alle Daten geschrieben
|
|
}
|
|
|
|
// CDHBinBufToStr (intBuffer, strBuffer, Status);
|
|
// inttostring (intWert, strWert);
|
|
// strcat(strAnzeige, "Buffer1 :", strBuffer1);
|
|
// debug (strAnzeige);
|
|
// strcat(strAnzeige, "Buffer :", strBuffer);
|
|
// debug (strAnzeige);
|
|
|
|
Zielbuffer = intBuffer; //Ausgangsbuffer1 fuellen
|
|
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : TestCod
|
|
//*
|
|
//* Funktion : prueft Codierspeicher auf beliebige Ueberschreibbarkeit
|
|
//* und Timing bei Telegrammempfang und positive Response
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 05.04.01 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
TestCod ( )
|
|
|
|
{
|
|
string ProcName = "TestCod";
|
|
string Info;
|
|
string SgbdName;
|
|
string strBuffer1, strBuffer2, strBuffer3, strBuffer;
|
|
string strErgebnis, strAnzeige;
|
|
|
|
int Status, CodierindexSg;
|
|
int Buffer, Buffer1, Buffer2, Buffer3, BufferSize, NrOfData, DataTyp;
|
|
int MAXDATA = 252; //Telegrammlaenge
|
|
|
|
bool EndFlag=FALSE;
|
|
bool bolFehler = FALSE;
|
|
|
|
CDHBinBufCreate( Buffer, Status); //Erzeugen des Codierdaten-Buffers
|
|
TestCDHFehler (Status);
|
|
CDHBinBufCreate( Buffer1, Status); //Buffer mit Testdaten 0x00
|
|
TestCDHFehler (Status);
|
|
CDHBinBufCreate( Buffer2, Status); //Buffer mit Testdaten 0xFF und zum Zuruecklesen
|
|
TestCDHFehler (Status);
|
|
CDHBinBufCreate( Buffer3, Status); //Ergebnisbuffer zum Ruecklesen der Daten
|
|
TestCDHFehler (Status);
|
|
|
|
CDHGetSgbdName( SgbdName, Status); //SGBD-Name aus SGET
|
|
TestCDHFehler( Status);
|
|
|
|
debug ("Test der Codierung");
|
|
|
|
strcat(strAnzeige, "SGBD-Name: ", SgbdName);
|
|
debug (strAnzeige);
|
|
|
|
//
|
|
// !!Achtung!! Der Aufruf von CDHGetNettoMaskFromCbd muss bei Codierdaten
|
|
// lesen vor der Abfrage des Codierindex geschehen, so dass die CBD
|
|
// eingelesen wird!!
|
|
|
|
CDHActivateAllFsw(); //Aktivieren aller FSW
|
|
|
|
CDHGetNettoDataFromCbd (Status); //Erzeugen der Nettodaten bei Codieren mit FSW-PSW-Liste
|
|
|
|
TestCDHFehler (Status);
|
|
|
|
Ident (CodierindexSg); //Codierindex lesen ueber Ident
|
|
CDHCheckIdent2 ("CODIERINDEX", CodierindexSg, Status); //Codierindex pruefen, Integeroperation
|
|
TestCDHFehler (Status);
|
|
|
|
EndFlag = FALSE; //SG codieren
|
|
|
|
while (EndFlag == FALSE)
|
|
{
|
|
CDHGetApiJobData(MAXDATA, Buffer, BufferSize, NrOfData, DataTyp, Status);
|
|
TestCDHFehler (Status);
|
|
|
|
if ( NrOfData > 0)
|
|
{
|
|
|
|
debug (" ");
|
|
|
|
//****1. Pruefung mit 0xFF***************************************************************************************
|
|
|
|
BufferErzeugen (Buffer, NrOfData, 0xFF, Buffer1); //Buffer mit Pruefmuster erzeugen
|
|
|
|
CDHBinBufToStr (Buffer1, strBuffer, Status); //Buffer in Datei ausgeben
|
|
strcat(strAnzeige, "Buffer Write: ", strBuffer);
|
|
debug (strAnzeige);
|
|
|
|
CDHapiJobData(SgbdName, "C_C_SCHREIBEN", Buffer1, BufferSize, "");
|
|
strcat (Info, SgbdName, ", C_C_SCHREIBEN");
|
|
TestApiFehler( COAPI_ECU_CODING_ERROR, ProcName, 365, Info);
|
|
|
|
SgReset( ); //SG-Reset
|
|
|
|
Warten (intWarten); //Warten fuer Resetbehandlung
|
|
|
|
CDHapiJobData(SgbdName, "C_C_LESEN_CAS", Buffer1, BufferSize, ""); //Codierdaten lesen
|
|
strcat (Info, SgbdName, ", C_C_LESEN_CAS");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 379, Info);
|
|
|
|
CDHapiResultBinary(Buffer3, "CODIER_DATEN", 1, Status); //Ergebnis holen
|
|
TestCDHFehler (Status);
|
|
|
|
CDHBinBufToStr (Buffer3, strBuffer, Status); //Buffer in Datei ausgeben
|
|
strcat(strAnzeige, "Buffer Read: ", strBuffer);
|
|
debug (strAnzeige);
|
|
|
|
//****Pruefung mit 0x00******************************************************************************************
|
|
|
|
BufferErzeugen (Buffer, NrOfData, 0x00, Buffer1); //Buffer mit Pruefmuster erzeugen
|
|
|
|
CDHBinBufToStr (Buffer1, strBuffer, Status); //Buffer in Datei ausgeben
|
|
strcat(strAnzeige, "Buffer Write: ", strBuffer);
|
|
debug (strAnzeige);
|
|
|
|
CDHapiJobData(SgbdName, "C_C_SCHREIBEN", Buffer1, BufferSize, "");
|
|
strcat (Info, SgbdName, ", C_C_SCHREIBEN");
|
|
TestApiFehler( COAPI_ECU_CODING_ERROR, ProcName, 365, Info);
|
|
|
|
SgReset; //Steuergeraete Reset
|
|
|
|
Warten (intWarten); //Warten fuer Resetbehandlung
|
|
|
|
BufferErzeugen (Buffer, NrOfData, 0xFF, Buffer1); //Buffer mit Pruefmuster erzeugen
|
|
|
|
CDHapiJobData(SgbdName, "C_C_LESEN", Buffer1, BufferSize, ""); //Codierdaten lesen
|
|
strcat (Info, SgbdName, ", C_C_LESEN");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 379, Info);
|
|
|
|
CDHapiResultBinary(Buffer3, "CODIER_DATEN", 1, Status); //Ergebnis holen
|
|
TestCDHFehler (Status);
|
|
|
|
CDHBinBufToStr (Buffer3, strBuffer, Status); //Buffer in Datei ausgeben
|
|
strcat(strAnzeige, "Buffer Read: ", strBuffer);
|
|
debug (strAnzeige);
|
|
|
|
//****2. Pruefung mit 0xFF***************************************************************************************
|
|
|
|
CDHBinBufToStr (Buffer1, strBuffer, Status); //Buffer in Datei ausgeben
|
|
strcat(strAnzeige, "Buffer Write: ", strBuffer);
|
|
debug (strAnzeige);
|
|
|
|
CDHapiJobData(SgbdName, "C_C_SCHREIBEN", Buffer1, BufferSize, "");
|
|
strcat (Info, SgbdName, ", C_C_SCHREIBEN");
|
|
TestApiFehler( COAPI_ECU_CODING_ERROR, ProcName, 365, Info);
|
|
|
|
SgReset; //Steuergeraete Reset
|
|
|
|
Warten (intWarten); //Warten fuer Resetbehandlung
|
|
|
|
CDHapiJobData(SgbdName, "C_C_LESEN", Buffer1, BufferSize, ""); //Codierdaten lesen
|
|
strcat (Info, SgbdName, ", C_C_LESEN");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 379, Info);
|
|
|
|
CDHapiResultBinary(Buffer3, "CODIER_DATEN", 1, Status); //Ergebnis holen
|
|
TestCDHFehler (Status);
|
|
|
|
CDHBinBufToStr (Buffer3, strBuffer, Status); //Buffer in Datei ausgeben
|
|
strcat(strAnzeige, "Buffer Read: ", strBuffer);
|
|
debug (strAnzeige);
|
|
|
|
//****Ende Pruefung**********************************************************************************************
|
|
|
|
}
|
|
else
|
|
{
|
|
EndFlag = TRUE;
|
|
} //endif
|
|
} //endwhile
|
|
|
|
CDHCheckDataUsed (Status); //Alle Daten verarbeitet?
|
|
TestCDHFehler (Status);
|
|
CDHBinBufDelete(Buffer, Status); //Loeschen des Binaerbuffers
|
|
TestCDHFehler (Status);
|
|
CDHBinBufDelete(Buffer1, Status); //Loeschen des Binaerbuffers
|
|
TestCDHFehler (Status);
|
|
CDHBinBufDelete(Buffer2, Status); //Loeschen des Binaerbuffers
|
|
TestCDHFehler (Status);
|
|
CDHBinBufDelete(Buffer3, Status); //Loeschen des Binaerbuffers
|
|
|
|
if (bolFehler == TRUE)
|
|
{
|
|
debug ("Test der Codierung mit Fehler beendet");
|
|
}
|
|
else
|
|
{
|
|
debug ("Test der Codierung i.O.");
|
|
}
|
|
|
|
SgReset; //Steuergeraete Reset
|
|
|
|
CDHSetReturnVal(0); //fehlerfreies Programmende
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : GetHaendler
|
|
//*
|
|
//* Funktion : Pruefen ob Haendlercodierung
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe : bol_HO
|
|
//*
|
|
//* Datum : 21.09.06 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
GetHaendler (out: bool bol_HO)
|
|
{
|
|
|
|
string WerkNr;
|
|
int Status;
|
|
bool bolHand = FALSE;
|
|
|
|
CDHGetSystemData ("WERK_NR", WerkNr, Status); //Werk-Nr. von Oberflaeche holen
|
|
|
|
TestCDHFehler( Status);
|
|
|
|
if (WerkNr == "0000")
|
|
bolHand = TRUE;
|
|
|
|
bol_HO = bolHand;
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : Fgnr
|
|
//*
|
|
//* Funktion : FGSt.Nr. Auftrag, schreiben, lesen
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe : FAHRGESTELL_NR
|
|
//*
|
|
//* Datum : 28.03.00 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
Fgnr( in: string Job)
|
|
{
|
|
string SgbdName;
|
|
string FgstNr, FgstNrTest;
|
|
string Info;
|
|
string ProcName = "Fgnr";
|
|
|
|
int Status;
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET
|
|
TestCDHFehler (Status);
|
|
|
|
CDHGetSystemData("FAHRGESTELL_NR", FgstNr, Status); //FG-Nr von Oberflaeche holen
|
|
TestCDHFehler (Status);
|
|
|
|
midstr (FgstNrTest, FgstNr, 10, 7); //letzten 7 Stellen der Fg-Nummer holen
|
|
|
|
if (Job == "FGNR_SCHREIBEN") //Schreiben der Fahrgestellnummer
|
|
{
|
|
CDHapiJob(SgbdName, "C_FG_SCHREIBEN", FgstNr, "");
|
|
strcat (Info, SgbdName, ", C_FG_SCHREIBEN");
|
|
TestApiFehler (COAPI_ECU_CODING_ERROR, ProcName, 205, Info); //"Codierung fehlerhaft (allgemein)"
|
|
}
|
|
|
|
|
|
if (Job == "FGNR_AUFTRAG" && FgstNrTest != "ZZ00000") //Schreiben der Fahrgestellnummer
|
|
{
|
|
CDHapiJob(SgbdName, "C_FG_AUFTRAG", FgstNr, "");
|
|
strcat (Info, SgbdName, ", C_FG_AUFTRAG");
|
|
TestApiFehler (COAPI_ECU_CODING_ERROR, ProcName, 215, Info); //"Codierung fehlerhaft (allgemein)"
|
|
}
|
|
|
|
|
|
if (Job == "FGNR_LESEN") //Lesen der Fahrgestellnummer
|
|
{
|
|
CDHapiJob(SgbdName, "C_FG_LESEN", "", "");
|
|
strcat (Info, SgbdName, ", C_FG_LESEN");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 223, Info); //"Codierung fehlerhaft (allgemein)"
|
|
CDHapiResultText(FgstNr, "FG_NR", 1, "");
|
|
CDHSetCabdPar("FAHRGESTELL_NR", FgstNr, Status);
|
|
TestCDHFehler (Status);
|
|
}
|
|
|
|
CDHSetReturnVal (0); //fehlerfreies Programmende
|
|
}
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : AeIndex
|
|
//*
|
|
//* Funktion : Aenderungsindex der Codierdaten schreiben / lesen
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe : AEND_INDEX
|
|
//*
|
|
//* Datum : 28.03.00 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
AeIndex( in: string Job)
|
|
{
|
|
string SgbdName;
|
|
string AenderIndex;
|
|
string Info;
|
|
string ProcName = "AeIndex";
|
|
|
|
int Status;
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET
|
|
TestCDHFehler (Status);
|
|
|
|
CDHGetSystemData("AEND_INDEX", AenderIndex, Status); //Aenderungindex aus Oberflaeche holen
|
|
TestCDHFehler (Status);
|
|
|
|
if (Job == "AE_INDEX_SCHREIBEN") //Schreiben des Aenderungsindex der Codierdaten
|
|
{
|
|
CDHapiJob(SgbdName, "C_AEI_SCHREIBEN", AenderIndex, "");
|
|
strcat (Info, SgbdName, ", C_AEI_SCHREIBEN");
|
|
TestApiFehler (COAPI_ECU_CODING_ERROR, ProcName, 265, Info); //"Codierung fehlerhaft (allgemein)"
|
|
}
|
|
|
|
|
|
if (Job == "AE_INDEX_AUFTRAG")
|
|
{ //Schreiben des Aenderungsindex der Codierdaten
|
|
CDHapiJob(SgbdName, "C_AEI_AUFTRAG", AenderIndex, "");
|
|
strcat (Info, SgbdName, ", C_AEI_AUFTRAG");
|
|
TestApiFehler (COAPI_ECU_CODING_ERROR, ProcName, 275, Info); //"Codierung fehlerhaft (allgemein)"
|
|
}
|
|
|
|
|
|
if (Job == "AE_INDEX_LESEN")
|
|
{
|
|
CDHapiJob(SgbdName, "C_AEI_LESEN", "", ""); //Lesen des Aenderungsindex
|
|
strcat (Info, SgbdName, ", C_AEI_LESEN");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 283, Info); //"Codierung fehlerhaft (allgemein)"
|
|
CDHapiResultText(AenderIndex, "COD_AE_INDEX", 1, "");
|
|
CDHSetCabdPar("AENDERUNGS_INDEX", AenderIndex, Status);
|
|
TestCDHFehler (Status);
|
|
}
|
|
|
|
CDHSetReturnVal (0); //fehlerfreies Programmende
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : CodIndex2Lesen
|
|
//*
|
|
//* Funktion : Codierindex lesen als Integer
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 15.05.01 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
CodIndex2Lesen (out: int CodierindexTransfer)
|
|
{
|
|
string ProcName = "CodIndex2Lesen";
|
|
string Info;
|
|
string SgbdName,strCodierindexSg;
|
|
|
|
int Status;
|
|
int n;
|
|
int CodierindexSg;
|
|
|
|
CDHGetSgbdName( SgbdName, Status); //SGBD-Name aus SGET
|
|
TestCDHFehler( Status);
|
|
|
|
|
|
CDHapiJob(SgbdName, "C_CI_LESEN", "", "ID_COD_INDEX"); //ID aus SG lesen
|
|
strcat (Info, SgbdName, ", C_CI_LESEN");
|
|
TestApiFehler( COAPI_ECU_TIMEOUT, ProcName, 495, Info); //"SG antwortet nicht"
|
|
|
|
CDHapiResultInt (CodierindexSg, "ID_COD_INDEX", 1); //Holen Codierindex als Integer
|
|
|
|
CodierindexTransfer = CodierindexSg;
|
|
|
|
inttostring (CodierindexSg, strCodierindexSg);
|
|
|
|
strlen(n, strCodierindexSg); //Codierindex auf 2 Stellen auffuellen
|
|
if (n == 0)
|
|
strcat(strCodierindexSg, "00", strCodierindexSg);
|
|
if (n == 1)
|
|
strcat(strCodierindexSg, "0", strCodierindexSg);
|
|
|
|
CDHSetCabdPar ("CODIERINDEX", strCodierindexSg, Status); //Codierindex zur Anzeige in Oberflaeche setzen
|
|
|
|
CDHTestError (Status); //Pruefen Fehler insgesamt
|
|
CDHSetReturnVal (0);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : Cod
|
|
//*
|
|
//* Funktion : SG codieren und Codierdaten lesen
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 02.12.04 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
Cod( in: string Job)
|
|
{
|
|
string ProcName = "Cod";
|
|
string Info;
|
|
string SgbdName;
|
|
|
|
int MAXDATA = 252; //Telegrammlaenge
|
|
int Status;
|
|
int Buffer, BufferSize, NrOfData, DataTyp;
|
|
int CodierindexSg;
|
|
|
|
bool EndFlag = FALSE;
|
|
bool bolHaendler = FALSE;
|
|
|
|
GetHaendler(bolHaendler); //Pruefen ob Haendlercodierung
|
|
|
|
CDHBinBufCreate( Buffer, Status); //Erzeugen des Codierdaten-Buffers
|
|
TestCDHFehler( Status);
|
|
|
|
CDHGetSgbdName( SgbdName, Status); //SGBD-Name aus SGET
|
|
TestCDHFehler( Status);
|
|
|
|
// !!Achtung!! Der Aufruf von CDHGetNettoMaskFromCbd muss bei Codierdaten
|
|
// lesen vor der Abfrage des Codierindex geschehen, so dass die CBD
|
|
// eingelesen wird!!
|
|
|
|
CDHActivateAllFsw(); //Aktivieren aller FSW
|
|
|
|
if (Job == "SG_CODIEREN" || Job == "CODIERDATEN_SCHREIBEN" || Job == "CD_SCHREIBEN_OHNE_CI" ||
|
|
Job == "SG_CODIEREN_OHNE_CI" || Job == "SG_CODIEREN_OHNE_FG_AEI")
|
|
{
|
|
CDHGetNettoDataFromCbd (Status); //Erzeugen der Nettodaten
|
|
}
|
|
else if (Job == "CODIERDATEN_LESEN" || Job == "CD_LESEN_OHNE_CI")
|
|
{
|
|
CDHGetNettoMaskFromCbd (Status); //Erzeugen der Layoutdaten
|
|
}
|
|
|
|
TestCDHFehler (Status);
|
|
|
|
if (Job == "SG_CODIEREN" || Job == "CODIERDATEN_SCHREIBEN" || Job == "CODIERDATEN_LESEN" || Job == "SG_CODIEREN_OHNE_FG_AEI")
|
|
{
|
|
Ident (CodierindexSg); //Codierindex lesen ueber Ident
|
|
|
|
CDHCheckIdent2 ("CODIERINDEX", CodierindexSg, Status); //Codierindex pruefen, Integeroperation
|
|
|
|
TestCDHFehler (Status);
|
|
}
|
|
|
|
EndFlag = FALSE; //SG codieren
|
|
while (EndFlag == FALSE)
|
|
{
|
|
CDHGetApiJobData(MAXDATA, Buffer, BufferSize, NrOfData, DataTyp, Status);
|
|
TestCDHFehler (Status);
|
|
if ( NrOfData > 0)
|
|
{
|
|
if (Job == "SG_CODIEREN" || Job == "SG_CODIEREN_OHNE_CI" || Job == "SG_CODIEREN_OHNE_FG_AEI") //Codierdaten schreiben und verifizieren
|
|
{
|
|
CDHapiJobData(SgbdName, "C_C_AUFTRAG", Buffer, BufferSize, "");
|
|
strcat (Info, SgbdName, ", C_C_AUFTRAG");
|
|
TestApiFehler( COAPI_ECU_CODING_ERROR, ProcName, 365, Info);
|
|
}
|
|
|
|
if (Job == "CODIERDATEN_SCHREIBEN" || Job == "CD_SCHREIBEN_OHNE_CI") //Codierdaten schreiben
|
|
{
|
|
CDHapiJobData(SgbdName, "C_C_SCHREIBEN", Buffer, BufferSize, "");
|
|
strcat (Info, SgbdName, ", C_C_SCHREIBEN");
|
|
TestApiFehler( COAPI_ECU_CODING_ERROR, ProcName, 372, Info);
|
|
}
|
|
|
|
if (Job == "CODIERDATEN_LESEN" || Job == "CD_LESEN_OHNE_CI") //Codierdaten lesen
|
|
{
|
|
CDHapiJobData(SgbdName, "C_C_LESEN", Buffer, BufferSize, "");
|
|
strcat (Info, SgbdName, ", C_C_LESEN");
|
|
TestApiFehler (COAPI_ECU_READ_DATA_ERROR, ProcName, 379, Info);
|
|
CDHapiResultBinary(Buffer, "CODIER_DATEN", 1, Status); //Ergebnis holen
|
|
TestCDHFehler (Status);
|
|
CDHBinBufToNettoData (Buffer, Status); //Buffer in Nettodaten umwandeln
|
|
TestCDHFehler (Status);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EndFlag = TRUE;
|
|
} //endif
|
|
} //endwhile
|
|
|
|
CDHCheckDataUsed (Status); //Alle Daten verarbeitet?
|
|
TestCDHFehler (Status);
|
|
|
|
CDHBinBufDelete(Buffer, Status); //Loeschen des Binaerbuffers
|
|
TestCDHFehler (Status);
|
|
|
|
if (Job == "SG_CODIEREN")
|
|
{
|
|
AeIndex ("AE_INDEX_AUFTRAG"); //Aenderungsindex schreiben
|
|
|
|
Fgnr ("FGNR_AUFTRAG"); //FG-Nr. schreiben
|
|
}
|
|
|
|
if (Job == "SG_CODIEREN" || Job == "CODIERDATEN_SCHREIBEN" || Job == "CD_SCHREIBEN_OHNE_CI" ||
|
|
Job == "SG_CODIEREN_OHNE_CI" || Job == "SG_CODIEREN_OHNE_FG_AEI")
|
|
SgReset( );
|
|
|
|
if (bolHaendler == TRUE) //10.000msec Wartepause nach Reset bei HO-Codierung
|
|
{
|
|
CDHSetCabdPar ("Warten aufgerufen, Wartezeit ", "10.000 ms", Status);
|
|
Warten(10000);
|
|
}
|
|
|
|
CDHSetReturnVal(0); //fehlerfreies Programmende
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : NettoDat
|
|
//*
|
|
//* Funktion : Codierung mit Nettodaten
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 22.10.01 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
NettoDat( )
|
|
{
|
|
string SgbdName;
|
|
string Info;
|
|
string ProcName = "NettoDat";
|
|
|
|
int MAXDATA = 252; //max. Telegrammlaenge
|
|
int Status;
|
|
int Buffer, BufferSize, NrOfData, DataSize, DataTyp;
|
|
int CodierindexSg;
|
|
|
|
bool EndFlag = FALSE;
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//-----Einstellung der Organisationsparameter, Standardwerte--------------------------------------------*/
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------------------------
|
|
|
|
int WortBreite = 1; //1 - BYTE, 2 - WORD, 3 - DWORD
|
|
int ByteFolge = 0; //0 - LSB zuerst, 1 - MSB zuerst
|
|
int AdrMode = 1; //0 - frei Adressierung, 1 - Blockadressierung
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//-----Ende Einstellung der Organisationsparameter------------------------------------------------------*/
|
|
//--------------------------------------------------------------------------------------------------------
|
|
|
|
CDHBinBufCreate(Buffer,Status); //Erzeugen des Codierdaten-Buffers
|
|
TestCDHFehler (Status);
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET/SGFAM
|
|
TestCDHFehler (Status);
|
|
|
|
if(SgbdName == "CIM") //Aenderung der Organisationsparameter bei CIM-SG
|
|
{
|
|
WortBreite = 2; //1 - BYTE, 2 - WORD, 3 - DWORD
|
|
ByteFolge = 1; //0 - LSB zuerst, 1 - MSB zuerst
|
|
}
|
|
|
|
CDHSetDataOrg(WortBreite, ByteFolge, AdrMode, Status); //Setzen der Organisationsparameter
|
|
TestCDHFehler (Status);
|
|
|
|
EndFlag = FALSE;
|
|
while (EndFlag == FALSE)
|
|
{
|
|
CDHGetApiJobData(MAXDATA, Buffer, BufferSize, NrOfData, DataTyp, Status);
|
|
TestCDHFehler (Status);
|
|
if (NrOfData > 0)
|
|
{
|
|
CDHapiJobData(SgbdName, "C_C_AUFTRAG", Buffer, BufferSize, "");
|
|
strcat (Info, SgbdName, ", C_C_AUFTRAG");
|
|
TestApiFehler (COAPI_ECU_WRITE_DATA_ERROR, ProcName, 450, Info); //"Fehler beim Codierdaten schreiben"
|
|
}
|
|
else
|
|
{
|
|
EndFlag = TRUE;
|
|
} //endif
|
|
} //endwhile
|
|
|
|
CDHCheckDataUsed (Status); //Alle Daten verarbeitet?
|
|
TestCDHFehler (Status);
|
|
|
|
CDHBinBufDelete(Buffer, Status); //Loeschen des Binaerbuffers
|
|
TestCDHFehler (Status);
|
|
|
|
SgReset( );
|
|
|
|
CDHSetReturnVal(0); //fehlerfreies Programmende
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : aif
|
|
//*
|
|
//* Funktion : AIF lesen
|
|
//*
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 29.10.01 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
aif( )
|
|
|
|
{
|
|
string ProcName = "aif";
|
|
string SgbdName;
|
|
string Info;
|
|
string strAifFgNr,strAifFgNrLang,strAifDatum,strAifZbNr,strAifSwNr,strAifBehoerdenNr;
|
|
string strAifHaendlerNr,strAifSerienNr,strAifKm,strAifProgrammNr,strAifAnzahlFrei,strAifAnzahlProg;
|
|
|
|
int Status, n;
|
|
int intAifAnzahlFrei,intAifAnzahlProg;
|
|
|
|
|
|
CDHGetSgbdName(SgbdName,Status); //SGBD-Name aus SGET
|
|
TestCDHFehler (Status);
|
|
|
|
CDHapiJob(SgbdName, "AIF_LESEN", "0", ""); //AIF aus SG lesen
|
|
TestApiFehler (COAPI_ECU_TIMEOUT, ProcName, 543, Info); //"SG antwortet nicht"
|
|
|
|
CDHapiResultText (strAifFgNr, "AIF_FG_NR", 1, "");
|
|
|
|
CDHapiResultText (strAifFgNrLang, "AIF_FG_NR_LANG", 1, "");
|
|
|
|
CDHapiResultText (strAifDatum, "AIF_DATUM", 1, "");
|
|
|
|
CDHapiResultText (strAifZbNr, "AIF_ZB_NR", 1, "");
|
|
|
|
CDHapiResultText (strAifSwNr, "AIF_SW_NR", 1, "");
|
|
|
|
CDHapiResultText (strAifBehoerdenNr, "AIF_BEHOERDEN_NR", 1, "");
|
|
|
|
CDHapiResultText (strAifHaendlerNr, "AIF_HAENDLER_NR", 1, "");
|
|
|
|
CDHapiResultText (strAifSerienNr, "AIF_SERIEN_NR", 1, "");
|
|
|
|
CDHapiResultText (strAifKm, "AIF_KM", 1, "");
|
|
|
|
CDHapiResultText (strAifProgrammNr, "AIF_PROG_NR", 1, "");
|
|
|
|
CDHapiResultInt (intAifAnzahlFrei, "AIF_ANZ_FREI", 1);
|
|
inttostring (intAifAnzahlFrei, strAifAnzahlFrei);
|
|
|
|
CDHapiResultInt (intAifAnzahlProg, "AIF_ANZAHL_PROG", 1);
|
|
inttostring (intAifAnzahlProg, strAifAnzahlProg);
|
|
|
|
CDHSetCabdPar ("AIF Fg-Nr. kurz", strAifFgNr, Status);
|
|
CDHSetCabdPar ("AIF Fg-Nr. lang", strAifFgNrLang, Status);
|
|
CDHSetCabdPar ("AIF Programmierdatum", strAifDatum, Status);
|
|
CDHSetCabdPar ("Zusbau-Nummer", strAifZbNr, Status);
|
|
CDHSetCabdPar ("Datensatznummer", strAifSwNr, Status);
|
|
CDHSetCabdPar ("Behoerdennummer", strAifBehoerdenNr, Status);
|
|
CDHSetCabdPar ("Haendlernummer", strAifHaendlerNr, Status);
|
|
CDHSetCabdPar ("Tester Seriennummer", strAifSerienNr, Status);
|
|
CDHSetCabdPar ("KM-Stand bei Programmierung", strAifKm, Status);
|
|
CDHSetCabdPar ("Programmstandnummer", strAifProgrammNr, Status);
|
|
CDHSetCabdPar ("Anzahl noch vorhandener AIF-Eintraege", strAifAnzahlFrei, Status);
|
|
CDHSetCabdPar ("Anzahl Programmiervorgaenge", strAifAnzahlProg, Status);
|
|
CDHTestError (Status); //Pruefen Fehler insgesamt
|
|
|
|
CDHSetReturnVal (0);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : cabimain
|
|
//*
|
|
//* Funktion : Hauptfunktion des Scripts:
|
|
//*
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 02.12.04 Autor: Bernhard Haller
|
|
//*************************************************************
|
|
|
|
cabimain()
|
|
{
|
|
string JobName;
|
|
int Status = 0;
|
|
int intWert;
|
|
|
|
CDHGetCabdPar ("JOBNAME", JobName, Status);
|
|
TestCDHFehler (Status);
|
|
|
|
if (JobName == "JOB_ERMITTELN")
|
|
Jobs( );
|
|
|
|
else if (JobName == "INFO")
|
|
InfoJob( );
|
|
|
|
else if (JobName == "ID_LESEN")
|
|
{
|
|
CDHapiInit();
|
|
Ident(intWert);
|
|
}
|
|
|
|
else if ( JobName == "CODIERINDEX_LESEN")
|
|
{
|
|
CDHapiInit();
|
|
CodIndex2Lesen(intWert);
|
|
}
|
|
|
|
else if ( JobName == "SG_CODIEREN" || JobName == "CODIERDATEN_SCHREIBEN" || JobName == "CODIERDATEN_LESEN" ||
|
|
JobName == "CD_LESEN_OHNE_CI" || JobName == "CD_SCHREIBEN_OHNE_CI" || JobName == "SG_CODIEREN_OHNE_CI" ||
|
|
JobName == "SG_CODIEREN_OHNE_FG_AEI")
|
|
{
|
|
CDHapiInit();
|
|
Cod( JobName);
|
|
}
|
|
|
|
else if (JobName == "FGNR_AUFTRAG" || JobName == "FGNR_SCHREIBEN" || JobName == "FGNR_LESEN")
|
|
{
|
|
CDHapiInit();
|
|
Fgnr( JobName);
|
|
}
|
|
|
|
else if (JobName == "AE_INDEX_AUFTRAG" || JobName == "AE_INDEX_SCHREIBEN" || JobName == "AE_INDEX_LESEN")
|
|
{
|
|
CDHapiInit();
|
|
AeIndex( JobName);
|
|
}
|
|
|
|
else if (JobName == "NETTODATEN_CODIEREN")
|
|
{
|
|
CDHapiInit();
|
|
NettoDat ();
|
|
}
|
|
|
|
else if (JobName == "AIF_LESEN")
|
|
{
|
|
CDHapiInit();
|
|
aif ();
|
|
}
|
|
|
|
else if (JobName == "TEST_FG_NR")
|
|
{
|
|
CDHapiInit();
|
|
FgnrTest ();
|
|
}
|
|
|
|
else if (JobName == "TEST_AE_INDEX")
|
|
{
|
|
CDHapiInit();
|
|
AeIndexTest ();
|
|
}
|
|
|
|
else if (JobName == "TEST_CODIERUNG")
|
|
{
|
|
CDHapiInit();
|
|
TestCod ();
|
|
}
|
|
|
|
else if (JobName == "SG_RESET")
|
|
{
|
|
CDHapiInit();
|
|
SgReset ();
|
|
}
|
|
|
|
else
|
|
{
|
|
CDHSetError (COAPI_CABD_PAR_ERROR, ModulName, "cabimain", 39, JobName);
|
|
Status = COAPI_CABD_PAR_ERROR;
|
|
}
|
|
|
|
CDHSetReturnVal (Status);
|
|
exit();
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//*
|
|
//* Name : cabiexit
|
|
//*
|
|
//* Funktion : Exit-Funktion des Scripts
|
|
//*
|
|
//* Parameter :
|
|
//*
|
|
//* Rueckgabe :
|
|
//*
|
|
//* Datum : 12.03.96 Autor: Manfred Steiniger
|
|
//*************************************************************
|
|
|
|
cabiexit()
|
|
{
|
|
CDHapiEnd();
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Scriptende
|
|
////////////////////////////////////////////////////////
|
|
|