Comments by Member 11961673 (Top 21 by date)

private bool ReadAckMsg()
{

bool DataRead = false;

////Initializes a new instance CommTimer class
CommTimer objCommTimer = new CommTimer();

////start the timmer for 1 sec
objCommTimer.Start(Properties.Settings.Default.timeOutInterval);

//// wait until any message is recieved and timeout status is false
while ((this._AckNackRspQueue.Count <= 0) && (objCommTimer.Timedoutstatus == false))
{

}
objCommTimer.Dispose();

if (this._AckNackRspQueue.Count == 1)
{
// Read the acknowledgement form the AckNackRspQueue
AckNackRsp = this._AckNackRspQueue.Dequeue();
DataRead = true;

}

return DataRead;

}

private bool SendCommand(string strCANCommand, CanMessage SuccessCANMessage)
{

// this._recievedMsg = string.Empty;
bool status = false;
AckNackRsp = '\0';
int ackItr = 0;
bool statusAckNackRsp = false;
bool statusAsyncMsgRxvd = false;
int MsgRxvdItr = 0;

//// call the WriteData Method again for maximum 3 times if statusAckNackRsp is true and statusAsyncMsgRxvd is true
do
{
// this._recievedMsg = string.Empty;
this._AckNackRspQueue.Clear();
this._AsyncMsgRxvdQueue.Clear();

// Clear the CANUSB converter buffer before sending the CAN Command
status = ClearUSBCANBuffer();

//if CAN Buffer is Cleared Successfully
if (status)
{
//function call to send CAN Command to the serial port
this.WriteData(strCANCommand);

// function call to check the response of the Command returns true is correct acknowledgement is recieved
statusAckNackRsp = CheckAckNackRsp();

// if correct acknowledgement is recieved
if (statusAckNackRsp == true)
{
//Function Call to read and Check the Response from the target device returns true if response CAN Message is same as Success CAN Message
statusAsyncMsgRxvd = CheckAsyncMsgRxvd(SuccessCANMessage);

// if response CAN Message is not same as Success CAN Message increment the CAN Message recieved iterator
if (statusAsyncMsgRxvd == false)
{
MsgRxvdItr++;
}
}
// if wrong acknowledgement is recieved increment the acknowledgement iterator
else
{
ackItr++;
}
}

} while ((!statusAckNackRsp || !statusAsyncMsgRxvd) && (ackItr < 3) && (MsgRxvdItr < 3) && (_CancelStatus == false));


if ((statusAckNackRsp && statusAsyncMsgRxvd))
{
status = true;
}
else
{
status = false;
}


return status;
}

if (_Lineaddress > _CurrentMemoryAddress)
{
UInt32 addressdifference = _Lineaddress - _CurrentMemoryAddress;

for (uint i = 0; i < addressdifference; i++)
{
string str = "FF";
_List.Add(str);
_CurrentMemoryAddress++;
}
status = true;
}
if (_Lineaddress == _CurrentMemoryAddress)
{
for (int i = 0; i < Convert.ToInt16(a[0]); i++)
{

int x = (Convert.ToInt16(a[4 + i]));

string str = string.Empty;
if ((x <= 15) && (x >= 0))
{
str = "0" + x.ToString("X");
}
else
{
str = x.ToString("X");
}
_List.Add(str);
_CurrentMemoryAddress++;
}
status = true;
}
else if (_Lineaddress < _CurrentMemoryAddress)
{



for (int i = 0; i < Convert.ToInt16(a[0]); i++)
{

int Position = 0;

Position = (int)(_Lineaddress - Convert.ToUInt32(_Startingaddress, 16));

if (Position > 0 && Position < _List.Count)
{

int x = (Convert.ToInt16(a[4 + i]));

string str = string.Empty;
if ((x <= 15) && (x >= 0))
{
str = "0" + x.ToString("X");
}
else
{
str = x.ToString("X");
}

_List[Position] = (str);

_Lineaddress++;
}
}
status = true;
}

return status;
}

////End of file record
default:
case (char)1:
////End of the hex file
stat_unAddressToWrite = 0;
parsedHexData = string.Empty;
break;

////Extended segment address
case (char)2:
////Address considered as the offset with the normal address
stat_unAddressToWrite = 0;
parsedHexData = string.Empty;
break;

////Start segment address
case (char)3:
parsedHexData = string.Empty;
break;

////Extended linear address
case (char)4:
// parsedHexData = string.Empty;
// stat_unAddressToWrite = 0;

//uint x = Convert.ToUInt16(stat_pucTempBuff[4]);
//uint y = Convert.ToUInt16(stat_pucTempBuff[5]);
_Jumptoaddress = Convert.ToUInt16(stat_pucTempBuff[4]).ToString("X") + Convert.ToUInt16(stat_pucTempBuff[5]).ToString("X") + "0000";
// string m = jumptoaddress + multiplicationfactor;

// uint p = Convert.ToUInt16(m);
uint p = Convert.ToUInt32(_Jumptoaddress, 16);

// z = Convert.ToUInt16(x * y);

// Lineaddress = p * multiplicationfactor;
//AddDefaultValueatMissingAddress(p);

//////////if (((x + y) > 506) && ((x + y) < 511))
//////////{
////////// jumpaddress = (65535 * (x + y - 507));
//////////}
parsedHexData = string.Empty;
break;

////Start linear address
case (char)5:
////This has the physical address of the controller from where the code execution has to start
parsedHexData = string.Empty;
stat_unAddressToWrite = 0;
break;
}

return parsedHexData;
}

////Record type
switch (stat_pucTempBuff[3])
{
//// Data record
case (char)0:
////Record type is normal
//stat_unAddressToWrite = unAddressInHexFile;
//parsedHexData = strDataRecord.Substring(9, length * 2);
int a = (Convert.ToInt16(stat_pucTempBuff[1])) * 256;
int b = Convert.ToInt16(stat_pucTempBuff[2]);
int address = (a + b);

if (_List.Count == 0)
{
_Startingaddress = (Convert.ToUInt32(_Jumptoaddress, 16) + address).ToString("X");

_CurrentMemoryAddress = Convert.ToUInt32(_Startingaddress, 16);
}

bool status = ExtractandStroreDataBytes(Convert.ToUInt32(address), stat_pucTempBuff);
if (status)
{
parsedHexData = string.Empty;
}
else
{
return null;
}

break;

//// Address error...
if (stat_unAddressToWrite > unAddressInHexFile)
{
if (stat_pucTempBuff[3] == 0)
{
//// ...return the frame error
return null;
}
}

//Check for the starting of the application code, remove the duplicated data from 0x0000 to 0x0030
// This is the starting address of the application of the Siderail motor control controller
//if(currentMemoryAddress


//if ((unAddressInHexFile < 0x100) && (stat_pucTempBuff[3] == 0))
//{
// return string.Empty;
//}

//// If the record type if invalid
if ((stat_pucTempBuff[3] < 0) || (stat_pucTempBuff[3] > 5))
{
//// ...If record type is invalid, return error
return null;
}

//// Get the Checksum value
char checksum =
(char)Convert.ToInt16(Convert.ToInt16(strDataRecord.Substring(9 + stat_pucTempBuff[0] * 2, 2), 16));
//// Compare that with the calculated checksum value...
if (this.CalculateCheckSum((char[])stat_pucTempBuff, stat_pucTempBuff[0] + 4) != checksum)
{
//// ...If they are not same, return error
return null;
}

Get the Data bytes present in the data record of Intel Hex file
///
/// <param name="strDataRecord">Single Data record of Intel Hex file</param>
/// <returns>Data bytes if present
public string ParseHex(string strDataRecord)
{
try
{
uint stat_unAddressToWrite = 0;
string parsedHexData = null;
int dlc = 0;
int parameterSize = strDataRecord.Length;
char[] pucData = strDataRecord.ToCharArray();
//Length of the character array is calculated
char[] stat_pucTempBuff = new char[(parameterSize - 1) / 2];
int unIndex = 2;
uint unIndexTemp = 1;

////Data format for intel hex
if (pucData[0] != ':')
{
return null;
}

////calculate number of data bytes present
dlc = Convert.ToInt16(Convert.ToInt32(strDataRecord.Substring(1, 2), 16));

////Confirmance of the length
if (parameterSize != (dlc * 2 + 11))
{
return null;
}

unIndex = 2;
unIndexTemp = 1;
stat_pucTempBuff[0] = (char)dlc;

//// Decode the string value into meaningful hex values
//// Example 0x2F will be received from host as '2' 'F'
//// So we will need to convert '2' 'F' to 0x2F
while (unIndex < (stat_pucTempBuff[0] * 2 + 8))
{
stat_pucTempBuff[unIndexTemp++] = (char)Convert.ToInt16(Convert.ToInt16(strDataRecord.Substring(1 + unIndex, 2), 16));
unIndex += 2;
}

//// Validation of the address
uint unAddressInHexFile = stat_pucTempBuff[1];
unAddressInHexFile <<= 8;
unAddressInHexFile |= stat_pucTempBuff[2];

public bool VerifyHexfile(string strFiletoSend)
{
try
{
string line;
_List.Clear();
_Jumptoaddress = "0000";
_CurrentMemoryAddress = 0;
////Initialize the new Stream Reader object to read the file content
StreamReader fileStream = new StreamReader(strFiletoSend);

// AssignStartingAddress();

string payload = null;

////read the content of file line by line
while ((line = fileStream.ReadLine()) != null)
{
////function call to get the data bytes in the line
payload = this.ParseHex(line);

//// if Correpted Hex file payload is null so return false otherwise return true
if (null == payload)
{
////dispose the steram reader object
fileStream.Dispose();
//// return false as selected Hex file is Corrupted
return false;
}
}

////dispose the stream reader object
fileStream.Dispose();
////return true as selected Hex file is OK
return true;
}
catch (Exception ex)
{
throw ex;
}
}

case STATE.RESPONSE:
// Append the received char
if ((Char.IsLetterOrDigit(ch)) || (ch == '*'))
{
// The message body
rawmsg.Append(ch);
}
else
{
state = STATE.FIRST;
// Not a hex value
if (ch == '\r')
{
// We have reached the end of the message
isCanMessage = STATE.RESPONSE;
retval = rawmsg.ToString();
}
else if (ch == '\a')
{
throw new Exception("Unexpected NACK Rxved during reception of Response" + ch.ToString());
}
else
{
// We have received an invalid char Exit
throw new Exception("Invalid char Rxved during reception of Response" + ch.ToString());
}
}
break;
}
return (retval);
}
catch (Exception exception)
{
throw exception;
}
}

case STATE.CANMSG:
// Append the received char
if (((ch >= '0') && (ch <= '9')) || ((ch >= 'A') && (ch <= 'F')))
{
// The message body
rawmsg.Append(ch);
}
else
{
state = STATE.FIRST;
// Not a hex value
if (ch == '\r')
{
// We have reached the end of the message
isCanMessage = STATE.CANMSG;
retval = rawmsg.ToString();
}
else if (ch == '\a')
{
throw new Exception("Unexpected NACK Rxved during reception of CAN Message" + ch.ToString());
}
else
{
// We have received an invalid char Exit
throw new Exception("Invalid char Rxved during reception of CAN Message" + ch.ToString());
}
}
break;

private string ParseChar(char ch, out STATE isCanMessage)
{

try
{
string retval = "";
isCanMessage = STATE.EMPTY;
// Process char
switch (state)
{
case STATE.FIRST:
if (ch == '\r')
{
isCanMessage = STATE.RESPONSE;
retval = "\r";
}
// If there is an \a, this is taken to be a NACK
else if (ch == '\a')
{
isCanMessage = STATE.RESPONSE;
retval = "\a";
}
// Check for a CAN message received
else if ((ch == 't') || (ch == 'T') ||
(ch == 'r') || (ch == 'R'))
{
// Clear the string and add the byte..
rawmsg.Length = 0; // Clear string builder contents
rawmsg.Append(ch);
// Get the rest of the message
state = STATE.CANMSG;
}
// Check for a response to see if it a response to a messages that may have been sent
else if ((ch == 'F') || (ch == 'V') || (ch == 'N') ||
(ch == 'z') || (ch == 'Z'))
{
// Clear the string and add the byte..
rawmsg.Length = 0; // Clear string builder contents
rawmsg.Append(ch);
// Get the rest of the message
state = STATE.RESPONSE;
}
else
{
state = STATE.FIRST;
// Unrecognised char. Idle.
throw new Exception("ClassAckNackRspRxvdParser Error=" + ch.ToString());

}
break;
case STATE.CANMSG:
// Append the received char
if (((ch >= '0') && (ch <= '9')) || ((ch >= 'A') && (ch <= 'F')))
{
// The message body
rawmsg.Append(ch);
}
else
{
state = STATE.FIRST;
// Not a hex value
if (ch == '\r')
{
// We have reached the end of the message
isCanMessage = STATE.CANMSG;
retval = rawmsg.ToString();
}
else if (ch == '\a')
{
throw new Exception("Unexpected NACK Rxved during reception of CAN Message" + ch.ToString());
}
else
{
// We have received an invalid char Exit
throw new Exception("Invalid char Rxved during reception of CAN Message" + ch.ToString());
}
}
break;
case STATE.RESPONSE:
// Append the received char
if ((Char.IsLetterOrDigit(ch)) || (ch == '*'))
{
// The message body
rawmsg.Append(ch);
}
else
{
state = STATE.FIRST;

private string ParseChar(char ch, out STATE isCanMessage)
{

try
{
string retval = "";
isCanMessage = STATE.EMPTY;
// Process char
switch (state)
{
case STATE.FIRST:
if (ch == '\r')
{
isCanMessage = STATE.RESPONSE;
retval = "\r";
}
// If there is an \a, this is taken to be a NACK
else if (ch == '\a')
{
isCanMessage = STATE.RESPONSE;
retval = "\a";
}
// Check for a CAN message received
else if ((ch == 't') || (ch == 'T') ||
(ch == 'r') || (ch == 'R'))
{
// Clear the string and add the byte..
rawmsg.Length = 0; // Clear string builder contents
rawmsg.Append(ch);
// Get the rest of the message
state = STATE.CANMSG;
}
// Check for a response to see if it a response to a messages that may have been sent
else if ((ch == 'F') || (ch == 'V') || (ch == 'N') ||
(ch == 'z') || (ch == 'Z'))
{
// Clear the string and add the byte..
rawmsg.Length = 0; // Clear string builder contents
rawmsg.Append(ch);
// Get the rest of the message
state = STATE.RESPONSE;
}
else
{
state = STATE.FIRST;
// Unrecognised char. Idle.
throw new Exception("ClassAckNackRspRxvdParser Error=" + ch.ToString());

}
break;

This method will be called when there is data waiting in the buffer

void comPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{


try
{
///Read the data
StringBuilder builder = new StringBuilder();
while (this._comPort.BytesToRead > 0)
{
builder.Append(this._comPort.ReadExisting());
}
if (builder.Length > 0)
{
this._recievedMsg = builder.ToString();
}
ReadData(_recievedMsg);

}
catch (Exception exception)
{
throw exception;
}
}

this function writes data to the serial communication port,waits for response for max 1 Sec, stores the response in "_recievedMsg" member variable

private void WriteData(string strMsg)
{
try
{
////first make sure the port is open
////if its not open then open it
if (this._comPort.IsOpen == false)
{
this._comPort.Open();
}

// discard data present in input and output buffer of serial communication port
this._comPort.DiscardInBuffer();
this._comPort.DiscardOutBuffer();

this._comPort.WriteTimeout = 10000;

////send the message to the port
this._comPort.Write(strMsg);

}

catch (Exception exception)
{
throw exception;
}
}