public void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (byte)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += (byte)(c << 0);
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (byte)(c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength = (byte)(c << 0);
if (msgDecodedPayloadLength == 0)
{
rcvState = StateReception.CheckSum;
}
else if (msgDecodedPayloadLength >= 1024)
{
rcvState = StateReception.Waiting;
}
else
{
rcvState = StateReception.Payload;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
msgDecodedPayloadIndex = 0;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex] = c;
msgDecodedPayloadIndex++;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
if (calculatedChecksum == c)
{
textBoxReception.Text = textBoxReception.Text + "Success, on a un message valide" + "\n";
}
else
{
textBoxReception.Text = textBoxReception.Text + "Sorry ! Try again !" + "\n";
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (int)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += (int)(c << 0);
rcvState = StateReception.PayLoadLengthMSB;
break;
case StateReception.PayLoadLengthMSB:
msgDecodedPayloadLength = (int)(c << 8);
rcvState = StateReception.PayLoadLengthLSB;
break;
case StateReception.PayLoadLengthLSB:
msgDecodedPayloadLength += (int)(c << 0);
if (msgDecodedPayloadLength == 0)
{
rcvState = StateReception.Checksum;
}
else if (msgDecodedPayloadLength > 512)
{
rcvState = StateReception.Waiting;
}
else
{
rcvState = StateReception.Payload;
msgDecodedPayloadIndex = 0;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex++] = c;
if (msgDecodedPayloadIndex == msgDecodedPayloadLength)
{
rcvState = StateReception.Checksum;
}
break;
case StateReception.Checksum:
byte receivedChecksum = c;
byte calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
if (calculatedChecksum == receivedChecksum)
{
iscorrectChecksum = true;
ProcessDecodedMessage(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
}
else
{
iscorrectChecksum = false;
}
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
Console.Write("0x" + c.ToString("X2") + " ");
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (UInt16)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (UInt16)(c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c;
if (msgDecodedPayloadLength == 0)
{
rcvState = StateReception.CheckSum;
}
else if (msgDecodedPayloadLength < 1024)
{
msgDecodedPayload = new byte[msgDecodedPayloadLength];
msgDecodedPayloadIndex = 0;
rcvState = StateReception.Payload;
}
else
{
rcvState = StateReception.Waiting;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex++] = c;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
msgDecodedChecksum = c;
msgCalculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
//Console.WriteLine("CHECKSUM : " + msgCalculatedChecksum.ToString("X2"));
if (msgDecodedChecksum == msgCalculatedChecksum)
{
robot.messageQueue.Enqueue(new Message(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload));
isChecksumOk = 1;
MessageProcessor(msgDecodedFunction, msgDecodedPayload, 24); //msgDecodedPayloadLength
}
else
{
//Console.WriteLine("Wrong Message Checksum");
isChecksumOk = 0;
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (UInt16)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (UInt16)(c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c;
if (msgDecodedPayloadLength == 0)
{
rcvState = StateReception.CheckSum;
}
else if (msgDecodedPayloadLength < 1024)
{
rcvState = StateReception.Payload;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
msgDecodedPayloadIndex = 0;
}
else
{
rcvState = StateReception.Waiting;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex++] = c;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum = CalculateChecksum((ushort)msgDecodedFunction, (ushort)msgDecodedPayloadLength, msgDecodedPayload);
byte receivedChecksum = c;
if (calculatedChecksum == receivedChecksum)
{
// Success , on a un message valide
robot.MessageQueue.Enqueue(new Message(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload));
}
else
{
Console.WriteLine("Erreur de décodage de message");
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
msgDecodedFunction = 0;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = c << 8;
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c << 0;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = c << 8;
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c << 0;
if (msgDecodedPayloadLength == 0)
{
rcvState = StateReception.Waiting;
}
else
{
rcvState = StateReception.Payload;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
msgDecodedPayloadIndex = 0;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex++] = c;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
byte receivedChecksum = c;
if (calculatedChecksum == receivedChecksum)
{
//textBoxReception.Text += "Message valide" + "\n";
Dispatcher.Invoke(delegate { ProcessDecodedMessage(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload); });
}
else
{
Dispatcher.Invoke(delegate { textBoxReception.Text += "Message invalide \n"; });
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
rcvBefore = rcvState;
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
// Message begin
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (ushort)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += (ushort)(c << 0);
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (ushort)(c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += (ushort)(c << 0);
if (msgDecodedPayloadLength > 0)
{
msgDecodedPayload = new byte[msgDecodedPayloadLength];
rcvState = StateReception.Payload;
}
else
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex] = c;
msgDecodedPayloadIndex++;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum, receivedChecksum = c;
calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
if (calculatedChecksum == receivedChecksum)
{
// Success, on a un message
Console.WriteLine("Message is Correct");
msgIsWrong = false;
}
else
{
Console.WriteLine("Message has an error");
msgIsWrong = true;
}
rcvState = StateReception.Waiting;
msgDecodedFunction = 0;
msgDecodedPayloadLength = 0;
msgDecodedPayloadIndex = 0;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
msgDecodedFunction = 0;
msgDecodedPayloadIndex = 0;
msgDecodedPayloadLength = 0;
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (byte)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += (byte)(c << 0);
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (byte)(c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += (byte)(c << 0);
if (msgDecodedPayloadLength != 0)
{
msgDecodedPayload = new byte[msgDecodedPayloadLength];
msgDecodedPayloadIndex = 0;
rcvState = StateReception.Payload;
}
else
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex] = c;
msgDecodedPayloadIndex++;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum, receivedChecksum;
receivedChecksum = c;
calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
if (calculatedChecksum == receivedChecksum)
{
CheckBoxMessage.IsChecked = true; //Success, on a un message valide
CheckBoxMessage.Background = Brushes.Green;
CheckBoxMessage.Foreground = Brushes.Green;
CheckBoxMessage.Content = " Message Correct";
ProcessDecodedMessage(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
}
else
{
CheckBoxMessage.IsChecked = false;
CheckBoxMessage.Background = Brushes.Red;
CheckBoxMessage.Foreground = Brushes.Red;
CheckBoxMessage.Content = " /!\\ Message Corrompu";
TextBoxReception.Text += "\n\r/!\\ Attention, message corrompu. fonctions: " + "0x" + msgDecodedFunction.ToString("X4");
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
public void DecodeMessage(byte b)
{
switch (rcvState)
{
case StateReception.Waiting:
if (b == ConstsProtocol.START_OF_FRAME)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (ushort)(b << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += (ushort)(b << 0);
if (IsFunctionExist(msgDecodedFunction))
{
rcvState = StateReception.PayloadLengthMSB;
}
else
{
OnUnknowFunction(msgDecodedFunction);
}
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLenght = (ushort)(b << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLenght += (ushort)(b << 0);
if (!IsPayloadExist(msgDecodedPayloadLenght))
{
OnNoPayload();
}
if (!IsLessThanMaximalLenghtSize(msgDecodedFunction))
{
OnOverLengthSize();
}
if (!IsPayloadLengthCorrect(msgDecodedFunction, msgDecodedPayloadLenght))
{
OnWrongPayloadLenght();
}
else
{
rcvState = StateReception.Payload;
msg_decoded_payload_index = 0;
msgDecodedPayload = new byte[msgDecodedPayloadLenght];
}
break;
case StateReception.Payload:
msgDecodedPayload[msg_decoded_payload_index++] = b;
if (msg_decoded_payload_index == msgDecodedPayloadLenght)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte receivedChecksum = b;
if (receivedChecksum == CalculateChecksum(msgDecodedFunction,
msgDecodedPayloadLenght, msgDecodedPayload))
{
OnMessageDecoded(msgDecodedFunction, msgDecodedPayloadLenght, msgDecodedPayload);
}
else
{
OnMessageDecodedError(msgDecodedFunction, msgDecodedPayloadLenght, msgDecodedPayload);
}
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
msgDecodedPayloadLength = 0;
msgDecodedFunction = 0;
msgDecodedPayloadIndex = 0;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c;
if (msgDecodedPayloadLength > 1500)
{
rcvState = StateReception.Waiting;
}
rcvState = StateReception.Payload;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex] = c;
msgDecodedPayloadIndex++;
if (msgDecodedPayloadIndex == msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
receivedChecksum = c;
calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
if (calculatedChecksum == receivedChecksum)
{
// TextBoxReception.Text += "youpi\n";
ProcessDecodedMessage(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
}
else
{
TextBoxReception.Text += "snif\n";
nb_snif++;
TextTest.Text = nb_snif.ToString();
TextBoxReception.Text += msgDecodedFunction.ToString() + " " + msgDecodedPayloadLength.ToString() + " " + msgDecodedPayload + "\n";
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void decodeMsg(byte c)
{
switch (rcv_state)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcv_state = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msg_decoded_func += c;
msg_decoded_func <<= 8;
rcv_state = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msg_decoded_func += c;
rcv_state = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msg_decoded_payload_length += c;
msg_decoded_payload_length <<= 8;
rcv_state = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msg_decoded_payload_length += c;
msg_decoded_payload = new byte[msg_decoded_payload_length];
if (msg_decoded_payload_length == 0)
{
rcv_state = StateReception.CheckSum;
}
else
{
rcv_state = StateReception.Payload;
}
break;
case StateReception.Payload:
msg_decoded_payload[msg_decoded_payload_index++] = c;
if (msg_decoded_payload_index == msg_decoded_payload_length)
{
rcv_state = StateReception.CheckSum;
}
break;
case StateReception.CheckSum: // Contrôle d'erreur à rajouter
if (calcChecksum(msg_decoded_func, msg_decoded_payload_length, msg_decoded_payload) == c)
{
processDecodedMessage(msg_decoded_func, msg_decoded_payload_length, msg_decoded_payload);
}
msg_decoded_func = 0;
msg_decoded_payload_length = 0;
msg_decoded_payload = new byte[0];
msg_decoded_payload_index = 0;
rcv_state = StateReception.Waiting;
break;
default:
rcv_state = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = c << 8;
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c << 0;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = c << 8;
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c << 0;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
msgDecodedPayloadIndex = 0;
rcvState = StateReception.Payload;
break;
case StateReception.Payload:
if (msgDecodedPayloadIndex < msgDecodedPayloadLength)
{
msgDecodedPayload[msgDecodedPayloadIndex] = c;
msgDecodedPayloadIndex++;
}
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte receivedChecksum = c;
byte calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
if (calculatedChecksum == receivedChecksum)
{
ProcessDecodedMessage(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
}
else
{
robot.flagChecksum = true;
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (Int16)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += (Int16)(c << 0);
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (Int16)(c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += (Int16)(c << 0);
if (msgDecodedPayloadLength > 0)
{
if (msgDecodedPayloadLength < 1024)
{
msgDecodedPayloadIndex = 0;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
rcvState = StateReception.Payload;
}
else
{
rcvState = StateReception.Waiting;
}
}
else
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex++] = c;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
byte receivedChecksum = c;
if (calculatedChecksum == receivedChecksum)
{
//Lance l'event de fin de decodage
OnMessageDecoded(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
}
else
{
OnMessageDecodedError(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
//DecodeMessage input event
public void DecodeMessage(object sender, DataReceivedArgs e)
{
foreach (byte c in e.Data)
{
if (rcvState == StateReception.Waiting)
{
messageAvailable = false;
}
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = (ushort)(c << 8);
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += (ushort)(c << 0);
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = (ushort)(c << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += (ushort)(c << 0);
if (msgDecodedPayloadLength > 0)
{
msgDecodedPayloadIndex = 0;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
rcvState = StateReception.Payload;
}
else
{
rcvState = StateReception.CheckSum; //if no payload, skip to CheckSum state
}
break;
case StateReception.Payload:
if (msgDecodedPayloadIndex < msgDecodedPayloadLength)
{
msgDecodedPayload[msgDecodedPayloadIndex] = c;
msgDecodedPayloadIndex++;
if (msgDecodedPayloadIndex == msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
}
break;
case StateReception.CheckSum:
receivedCheckSum = c;
calculatedCheckSum = mesEncoder.CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
messageAvailable = true;
if (calculatedCheckSum == receivedCheckSum)
{
//Console.WriteLine("checksum ok received: " + receivedCheckSum.ToString("X2") +
// " calculated: " + calculatedCheckSum.ToString("X2"));
CheckSumErrorOccured = false;
}
else
{
// Console.WriteLine("checksum error received: " + receivedCheckSum.ToString("X2") +
// " calculated: " + calculatedCheckSum.ToString("X2"));
CheckSumErrorOccured = true;
}
OnDataDecoded(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload, receivedCheckSum, CheckSumErrorOccured);
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
msgDecodedFunction = 0;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = c << 8;
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c << 0;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = c << 8;
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c << 0;
if (msgDecodedPayloadLength == 0)
{
rcvState = StateReception.CheckSum;
}
else if (msgDecodedPayloadLength >= 1024)
{
rcvState = StateReception.Waiting;
}
else
{
rcvState = StateReception.Payload;
msgDecodedPayload = new byte[msgDecodedPayloadLength];
msgDecodedPayloadIndex = 0;
}
break;
case StateReception.Payload:
msgDecodedPayload[msgDecodedPayloadIndex++] = c;
if (msgDecodedPayloadIndex >= msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
byte receivedChecksum = c;
if (calculatedChecksum == receivedChecksum)
{
//Success, on a un message valide
textBoxRéception.Text += "Pas d'erreur";
}
else
{
textBoxRéception.Text += "Erreur les amis :')" + "\n";
}
rcvState = StateReception.Waiting;
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
Message DecMsg;
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
isValidSOF = true;
}
else
{
isValidSOF = false;
lastInvalidChar = c;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = c * 0x100;
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = c * 0x100;
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c;
rcvState = StateReception.Payload;
break;
case StateReception.Payload:
if (msgDecodedPayloadIndex < msgDecodedPayloadLength - 1 && msgDecodedPayloadLength < 256)
{
msgDecodedPayload[msgDecodedPayloadIndex++] = c;
}
else
{
msgDecodedPayload[msgDecodedPayloadIndex] = c; //caca
rcvState = StateReception.CheckSum;
msgDecodedPayloadIndex = 0;
}
break;
case StateReception.CheckSum:
receivedChecksum = c;
if (msgDecodedPayloadLength < 256)
{
calculatedChecksum = CalculateCheckSum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
}
if (calculatedChecksum == receivedChecksum)
{
isValidChecksum = true; // Success , on a un message valide
}
else
{
isValidChecksum = false;
}
decodeFinishedFlag = true;
rcvState = StateReception.Waiting;
DecMsg.msgDecodedFunction = msgDecodedFunction;
DecMsg.msgDecodedPayloadLength = msgDecodedPayloadLength;
DecMsg.msgDecodedPayload = msgDecodedPayload;
DecMsg.isValidChecksum = isValidChecksum;
Messages.Enqueue(DecMsg);
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
private void DecodeMessage(byte c)
{
switch (rcvState)
{
case StateReception.Waiting:
if (c == 0xFE)
{
rcvState = StateReception.FunctionMSB;
msgDecodedFunction = 0;
msgDecodedPayloadLength = 0;
//msgDecodedPayload;
msgDecodedPayloadIndex = 0;
}
break;
case StateReception.FunctionMSB:
msgDecodedFunction = c;
msgDecodedFunction = msgDecodedFunction << 8;
rcvState = StateReception.FunctionLSB;
break;
case StateReception.FunctionLSB:
msgDecodedFunction += c;
rcvState = StateReception.PayloadLengthMSB;
break;
case StateReception.PayloadLengthMSB:
msgDecodedPayloadLength = c;
msgDecodedPayloadLength = (msgDecodedPayloadLength << 8);
rcvState = StateReception.PayloadLengthLSB;
break;
case StateReception.PayloadLengthLSB:
msgDecodedPayloadLength += c;
if (msgDecodedPayloadLength == 0)
{
rcvState = StateReception.Waiting;
}
else
{
rcvState = StateReception.Payload;
}
msgDecodedPayload = new byte[msgDecodedPayloadLength];
break;
case StateReception.Payload:
msgDecodedPayload [msgDecodedPayloadIndex] = (byte)c;
msgDecodedPayloadIndex++;
if (msgDecodedPayloadIndex == msgDecodedPayloadLength)
{
rcvState = StateReception.CheckSum;
}
break;
case StateReception.CheckSum:
byte calculatedChecksum = CalculateChecksum(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
byte receivedChecksum = c;
if (calculatedChecksum == receivedChecksum)
{
//textBoxReception.Text += "ouiiii!!!" + "\n";
ProcessDecodeMessage(msgDecodedFunction, msgDecodedPayloadLength, msgDecodedPayload);
rcvState = StateReception.Waiting;
}
else
{
textBoxReception.Text += "nooooon!!!!" + "\n";
}
break;
default:
rcvState = StateReception.Waiting;
break;
}
}
