/// <summary>
/// Sends a command, verifies the ack.
/// </summary>
/// <param name="cmd1"></param>
/// <param name="cmd2"></param>
public PowerLineModemMessage.MessageResponse SendCommand(PowerLineModemMessage message)
{
// Only one message sending at a time.
log.Debug("Start <<");
try
{
lock (this)
{
// Lock access around the port when sending/receiving.
lock (port)
{
// Clear input first.
port_DataReceived(this, null);
byte[] preamble = new byte[2];
preamble[0] = START_OF_MESSAGE;
preamble[1] = (byte)message.MessageType;
byte[] payload = message.PayloadByteArray();
sending = message;
port.Write(preamble, 0, preamble.Length);
port.Write(payload, 0, payload.Length);
log.DebugFormat(" Output [{0}-{1}]", BitConverter.ToString(preamble), BitConverter.ToString(payload));
}
return(WaitForResponse(message));
}
}
finally
{
log.Debug(">> End");
}
}
private PowerLineModemMessage.MessageResponse WaitForResponse(PowerLineModemMessage message)
{
// See if we have some data.
if (receivedAck.WaitOne(2000))
{
return(sendingResponse);
}
else
{
return(PowerLineModemMessage.MessageResponse.Unknown);
}
}
/// <summary>
/// Disposes the port.
/// </summary>
public void Dispose()
{
this.port.Dispose();
this.message = PowerLineModemMessage.Message.UserResetDetected;
this.port = null;
this.readData = 0;
this.receivedAck.Dispose();
this.receivedAck = null;
this.sending = null;
this.sendingResponse = PowerLineModemMessage.MessageResponse.Unknown;
this.state = ReadState.START;
this.data = null;
this.depth = 0;
}
private void ReadMessages(byte[] input, int size)
{
List <PowerLineModemMessage> receivedMessages = new List <PowerLineModemMessage>();
lock (port)
{
string strDebug = "Input: [";
// First we look for a 0x2, which they all start with.
for (int i = 0; i < size; i++)
{
int data = input[i];
strDebug += String.Format("{0:x2}-", data, readData, (this.data == null ? 0 :this.data.Length), state.ToString());
switch (state)
{
case ReadState.START:
if (data == START_OF_MESSAGE)
{
state = ReadState.MESSAGE_TYPE;
}
break;
case ReadState.MESSAGE_TYPE:
// This next one is the message type.
message = (PowerLineModemMessage.Message)data;
state = ReadState.MESSAGE_DATA;
this.data = new byte[MessageFactory.SizeOfMessage(message, sending)];
readData = 0;
break;
case ReadState.MESSAGE_DATA:
if (readData < this.data.Length)
{
this.data[readData++] = (byte)data;
}
if (readData >= this.data.Length)
{
// If this is a response, update the request with the response data.
if (sending != null && message == sending.MessageType)
{
sendingResponse = sending.VerifyResponse(this.data);
sending = null;
receivedAck.Set();
}
else
{
// Create the received message.
PowerLineModemMessage packet = MessageFactory.GetReceivedMessage(message, this.data);
if (packet != null)
{
receivedMessages.Add(packet);
}
}
state = ReadState.START;
}
break;
}
}
log.Debug(strDebug + "]");
}
if (ReceivedMessage != null)
{
// Switch context so we don't end up deadlocked.
ThreadPool.QueueUserWorkItem(delegate
{
foreach (PowerLineModemMessage mess in receivedMessages)
{
ReceivedMessage(this, new RecievedMessageEventArgs(mess));
}
});
}
}
public RecievedMessageEventArgs(PowerLineModemMessage message)
{
this.message = message;
}
