/// <summary>
/// Get block identifier of matching language identifier
/// </summary>
/// <param name="lId">Language identifier</param>
/// <returns>Blockidentifier matching to language identifier</returns>
public static Block.BlockId GetLanguageBlockId(LanguageId lId)
{
Block.BlockId ret = Block.BlockId.IdLngEN;
switch (lId)
{
case LanguageId.German:
ret = Block.BlockId.IdLngDE;
break;
case LanguageId.English:
ret = Block.BlockId.IdLngEN;
break;
case LanguageId.French:
ret = Block.BlockId.IdLngFR;
break;
case LanguageId.Italian:
ret = Block.BlockId.IdLngIT;
break;
case LanguageId.Spanish:
ret = Block.BlockId.IdLngES;
break;
case LanguageId.Polish:
ret = Block.BlockId.IdLngPO;
break;
case LanguageId.Dutch:
ret = Block.BlockId.IdLngNL;
break;
}
return(ret);
}
/// <summary>Read parameter block from ecu</summary>
/// <param name="Identifier">Block identifier</param>
/// <param name="ParameterBlock">Referece of block to read to</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue ReadParamBlock(Block.BlockId Identifier, ref Block ParameterBlock)
{
ReturnValue ret = ReturnValue.NoError;
byte[] Buffer;
switch (Identifier)
{
case Block.BlockId.IdKonfig:
case Block.BlockId.IdKennfld:
ret = mEcu.Read(Comm.OrderByte.ReadBlock, (UInt16)Identifier, out Buffer);
if (ret == ReturnValue.NoError)
{
ParameterBlock = new Block();
ParameterBlock.Type = Identifier;
ret = ParameterBlock.ReadRaw(ref Buffer, false);
}
break;
case Block.BlockId.IdLngDE:
case Block.BlockId.IdLngEN:
case Block.BlockId.IdLngFR:
case Block.BlockId.IdLngIT:
case Block.BlockId.IdLngES:
case Block.BlockId.IdLngNL:
case Block.BlockId.IdLngPL:
case Block.BlockId.IdLngTK:
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)Identifier, out Buffer);
if (ret == ReturnValue.NoError)
{
ParameterBlock = new Block();
ParameterBlock.Type = Identifier;
ret = ParameterBlock.ReadRaw(ref Buffer, false);
}
break;
default:
ret = ReturnValue.BlockNotFound;
break;
}
return(ret);
}
/// <summary>
/// Read language and check checksum
/// </summary>
/// <param name="Language">Language identifier</param>
/// <param name="Checksum">Reference checksum</param>
/// <returns>True is language is loaded and checksums matching</returns>
public override bool CheckLanguageChecksum(Block.BlockId Language, UInt16 Checksum)
{
ReturnValue ret = ReturnValue.NoError;
byte[] ReadBuffer = new byte[4096];
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)Language, out ReadBuffer);
if (ret == ReturnValue.Retry)
{
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)Language, out ReadBuffer);
}
if (ret == ReturnValue.NoError)
{
return(Checksum != ((ReadBuffer[5] * 256) + ReadBuffer[4]) ? false : true);
}
else
{
// auslesefehler
return(false);
}
}
/// <summary>
/// Check checksum of language
/// </summary>
/// <param name="Language">Language identifier</param>
/// <param name="Checksum">Checksum</param>
/// <returns>True if checksum matches</returns>
public override bool CheckLanguageChecksum(Block.BlockId Language, UInt16 Checksum)
{
ReturnValue ret = ReturnValue.NoError;
byte[] ReadBuffer = new byte[4096];
UInt16 l = 1;
switch (Language)
{
case Block.BlockId.IdLngDE:
l = 0; break;
case Block.BlockId.IdLngEN:
l = 1; break;
case Block.BlockId.IdLngFR:
l = 2; break;
case Block.BlockId.IdLngIT:
l = 3; break;
}
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, l, out ReadBuffer);
//ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)Language, out ReadBuffer);
if (ret == ReturnValue.Retry)
{
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, l, out ReadBuffer);
}
if (ret == ReturnValue.NoError)
{
UInt16 c = Block.GenerateCRC16(ReadBuffer, 4096, 0);
return(Checksum != c ? false : true);
}
else
{
// auslesefehler
return(false);
}
}
/// <summary>Get certain block from file</summary>
/// <param name="pBlock">Reference to target block</param>
/// <param name="BlockType">Type of block</param>
/// <param name="KeepVersion">Flag if current version of target
/// block is not allowed to be changed</param>
/// <returns>0 on success, else see ReturnValue</returns>
public ReturnValue GetBlock(out Block pBlock,
Block.BlockId BlockType, bool KeepVersion)
{
byte[] BlockHeaderByteArray = new byte[Block.BLOCK_HEADER_SIZE];
int lOff = FILE_HEADER_SIZE;
ReturnValue RetVal = ReturnValue.NoError;
pBlock = new Block();
pBlock.Type = BlockType;
if (mNumberOfBlocks > 0)
{
for (byte i = 1; i <= mNumberOfBlocks; i++)
{
try
{
hFile.Position = lOff;
hFile.Read(BlockHeaderByteArray, 0, Block.BLOCK_HEADER_SIZE);
lOff += Block.BLOCK_HEADER_SIZE;
if (BlockHeaderByteArray[(int)Block.HeaderPosition.Type] == (byte)BlockType)
{
break;
}
lOff += BlockHeaderByteArray[(int)Block.HeaderPosition.SizeHighByte] * 256;
lOff += BlockHeaderByteArray[(int)Block.HeaderPosition.SizeLowByte];
}
catch
{
RetVal = ReturnValue.FileReadError;
break;
}
}
if (RetVal == ReturnValue.NoError)
{
if (BlockHeaderByteArray[(int)Block.HeaderPosition.Type] != (byte)BlockType)
{
RetVal = ReturnValue.BlockNotFound;
}
else
{
// read block header
if (pBlock.UpdateHeader(ref BlockHeaderByteArray, KeepVersion) == false)
{
RetVal = ReturnValue.VersionMismatch;
}
// adjust file pointer for reading block header again!
//hFile.Position = lOff;
hFile.Position = hFile.Position - Block.BLOCK_HEADER_SIZE;
byte[] BlockByteArray = new byte[pBlock.DataSize + Block.BLOCK_HEADER_SIZE];
try
{
hFile.Read(BlockByteArray, 0, (pBlock.DataSize + Block.BLOCK_HEADER_SIZE));
}
catch
{
RetVal = ReturnValue.FileReadError;
}
if (RetVal == ReturnValue.NoError)
{
RetVal = pBlock.ReadRaw(ref BlockByteArray, KeepVersion);
}
}
}
else
{
RetVal = ReturnValue.FileEmpty;
}
}
else
{
pBlock = null;
}
return(RetVal);
}
/// <summary>Read parameter block from ecu</summary>
/// <param name="Identifier">Block identifier</param>
/// <param name="ParameterBlock">Referece of block to read to</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue ReadParamBlock(Block.BlockId Identifier, ref Block ParameterBlock)
{
return(ReturnValue.VersionMismatch);
}
/// <summary>Check checksum of language block</summary> /// <param name="Language">Language identifier</param> /// <param name="Checksum">Checksum</param> /// <returns>True if checksum matches</returns> public abstract bool CheckLanguageChecksum(Block.BlockId Language, UInt16 Checksum);
/// <summary>Read parameter block from ecu</summary> /// <param name="Identifier">Block identifier</param> /// <param name="ParameterBlock">Referece of block to read to</param> /// <returns>0 on success, else see ReturnValue</returns> public abstract ReturnValue ReadParamBlock(Block.BlockId Identifier, ref Block ParameterBlock);
/// <summary>
/// Connect to ECU
/// </summary>
/// <param name="language">Language: 0=german, 1=english, 2=french, 3=italian</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Connect(LanguageId language)
{
mEcu.pVersion = ProtocolVersion;
ReturnValue ret = mEcu.Connect();
if (ret == ReturnValue.NoError)
{
// Read digital info block
mInfo = new DigitalInfoBlock();
byte[] ReadBuffer = new byte[MAX_READ_BUFFER_SIZE];
ret = mEcu.Read(Comm.OrderByte.ReadInfoBlock, out ReadBuffer);
if (ret == ReturnValue.Retry)
{
ret = mEcu.Read(Comm.OrderByte.ReadInfoBlock, out ReadBuffer);
}
if (ret == ReturnValue.NoError)
{
ReturnValue RetB;
RetB = mInfo.Parse(ref ReadBuffer);
mFirmware.SoftwareRevision = mInfo.SoftwareVersion.Revision;
mRtcData.SoftwareRevision = mInfo.SoftwareVersion.Revision;
mEmpData.Version = mInfo.EmpiricalVersion;
// Read Language data
Block.BlockId LanguageBlockId = GetLanguageBlockId(language);
ReadBuffer = new byte[4096];
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)LanguageBlockId, out ReadBuffer);
if (ret == ReturnValue.Retry)
{
// One retry
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)LanguageBlockId, out ReadBuffer);
}
if (ret == ReturnValue.NoError)
{
mLanguage = new LanguageBlock(LanguageBlockId);
ReturnValue BlockRet = ReturnValue.NoError;
BlockRet = mLanguage.ReadRaw(ref ReadBuffer, false);
if (BlockRet == ReturnValue.NoError)
{
BlockRet = mLanguage.Parse();
}
if (BlockRet != ReturnValue.NoError)
{
ret = ReturnValue.LanguageNotValid;
}
}
else
{
// Language not available, so load english
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)Block.BlockId.IdLngEN, out ReadBuffer);
if (ret == ReturnValue.Retry)
{
// One retry
ret = mEcu.Read(Comm.OrderByte.ReadLanguage, (UInt16)Block.BlockId.IdLngEN, out ReadBuffer);
}
if (ret == ReturnValue.NoError)
{
mLanguage = new LanguageBlock(Block.BlockId.IdLngEN);
ReturnValue BlockRet = ReturnValue.NoError;
BlockRet = mLanguage.ReadRaw(ref ReadBuffer, false);
if (BlockRet == ReturnValue.NoError)
{
BlockRet = mLanguage.Parse();
}
if (BlockRet != ReturnValue.NoError)
{
ret = ReturnValue.LanguageNotValid;
}
}
else
{
if (mInfo.ConfigurationVersion.Hauptversion == 0)
{
// Emergency configuration: language not available
mLanguage = new LanguageBlock(Block.BlockId.IdLngEN);
ret = ReturnValue.NoError;
}
}
}
}
}
else
{
mEcu.Disconnect();
}
return(ret);
}
