private void OnSerialCommunicationMessageReceived(SerialMessageEventArgs serialMessageEventArgs)
{
if (SerialCommunicationMessageReceived != null)
{
SerialCommunicationMessageReceived(this, serialMessageEventArgs);
}
}
private void OnSerialCommunicationMessageSent(SerialMessageEventArgs serialMessageEventArgs)
{
if (SerialCommunicationMessageSent != null)
{
SerialCommunicationMessageSent(this, serialMessageEventArgs);
}
}
private void HandleSerialDataReceived(object sender, SerialMessageEventArgs e)
{
// Log.Info("<color=grey><b>" + e.Message + "</b></color>");
if (!_isRadioOn)
{
return;
}
StopCoroutine("ActivityLight");
StartCoroutine(ActivityLight());
}
/// <summary>
/// Sends an outgoing message through the serial port.
/// Returns true if a message has been sent.
/// </summary>
/// <param name="outgoingMessage"></param>
private bool SendMessage(string outgoingMessage)
{
lock (_writeLock)
{
//Remove all comments (characters after the terminal character) from the outgoing message).
if (!String.IsNullOrWhiteSpace(outgoingMessage))
{
outgoingMessage = outgoingMessage.Trim();
//If message is not a comment...
if (!(outgoingMessage[0] == SerialMessageCharacters.SerialTerminalCharacter))
{
//Remove comments from the message.
int terminalIndex = outgoingMessage.IndexOf(SerialMessageCharacters.SerialTerminalCharacter);
if (terminalIndex > 0)
{
outgoingMessage = outgoingMessage.Substring(0, terminalIndex + 1);
}
//Wait until the microcontroller inteprets the sent message before sending a new message.
//Pause and resume messages do not need a reply.
if (!((outgoingMessage[0] == SerialMessageCharacters.SerialPauseHardwareCharacter) ||
(outgoingMessage[0] == SerialMessageCharacters.SerialResumeHardwareCharacter) ||
(outgoingMessage[0] == SerialMessageCharacters.SerialMovementBufferClearCharacter)))
{
_shouldSend = false;
}
else
{
_shouldSend = true;
}
//Sends a message through the serial ports.
_serialPort.WriteLine(outgoingMessage);
//Triggers the message sent event.
SerialMessageEventArgs serialMessageEventArgs = new SerialMessageEventArgs(outgoingMessage);
Application.Current.Dispatcher.Invoke(() =>
OnSerialCommunicationMessageSent(serialMessageEventArgs));
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
}
/// <summary>
/// Executes when a message has been received from serial communication.
/// </summary>
/// <param name="sender"></param>
/// <param name="serialMessageEventArgs"></param>
private void SerialCommunicationMessageReceived(object sender, SerialMessageEventArgs serialMessageEventArgs)
{
string incomingMessage = serialMessageEventArgs.Message;
//Filter message by type.
if (incomingMessage[0] == SerialMessageCharacters.SerialTaskQueuedCharacter) //Task queued.
{
InterpretTaskQueuedMessage(incomingMessage);
}
else if (incomingMessage[0] == SerialMessageCharacters.SerialTaskCompletedCharacter) //Task completed.
{
//Earliest queued tasks are completed first.
if (_realTimeStatusDataModel.IsTaskQueuedEmpty() == false)
{
InterpretTaskCompletedMessage(_realTimeStatusDataModel.RetrieveNextTaskQueuedMessage());
_realTimeStatusDataModel.RecordTaskCompleted();
}
else
{
_errorListViewModel.AddError("Serial communication out of sync: ", "Task completed return does not correspond to a task");
}
}
else if (incomingMessage[0] == SerialMessageCharacters.SerialStatusCharacter) //Status.
{
InterpretStatusMessage(incomingMessage);
_realTimeStatusDataModel.RecordStatusMessage(incomingMessage.Substring(1));
}
else if (incomingMessage[0] == SerialMessageCharacters.SerialErrorCharacter) //Error.
{
_realTimeStatusDataModel.RecordErrorMessage(incomingMessage.Substring(1));
}
else //Also an error.
{
_realTimeStatusDataModel.RecordErrorMessage("Microcontroller return message unrecognized: " + incomingMessage);
}
}
/// <summary>
/// Triggered when a serial message is received.
/// Designates the appropriate event handler for the type of serial message received.
/// </summary>
/// <returns></returns>
private void ReceiveMessage(object sender, SerialDataReceivedEventArgs e)
{
lock (_readLock)
{
try
{
while (_serialPort.BytesToRead != 0)
{
//Reads a message coming from the serial port.
string incomingMessage = _serialPort.ReadLine();
if (!String.IsNullOrWhiteSpace(incomingMessage))
{
//If the micrcontroller has interpreted the previous command, then go ahead and send it new commands.
if (incomingMessage[0] == SerialMessageCharacters.SerialTaskQueuedCharacter)
{
_shouldSend = true;
}
if (incomingMessage[0] == SerialMessageCharacters.SerialErrorCharacter)
{
_shouldSend = true;
Application.Current.Dispatcher.Invoke(() =>
OnSerialCommunicationPrintSequencePaused()); //Pause a print sequence if an error was read.
}
//Update the serial messages UI.
if (incomingMessage[0] != SerialMessageCharacters.SerialErrorCharacter)
{
//Triggers the appropriate message received event.
SerialMessageEventArgs serialMessageEventArgs = new SerialMessageEventArgs(incomingMessage);
Application.Current.Dispatcher.Invoke(() =>
OnSerialCommunicationMessageReceived(serialMessageEventArgs));
}
else if ((incomingMessage[0] == SerialMessageCharacters.SerialErrorCharacter) && (_shouldProcessNextError == true))
{
//Pause the print sequence because of unexpected error.
_serialCommunicationOutgoingMessagesModel.QueueNextProspectiveOutgoingMessage(SerialMessageCharacters.SerialPrintPauseCharacter.ToString());
//Triggers the appropriate message received event.
SerialMessageEventArgs serialMessageEventArgs = new SerialMessageEventArgs(incomingMessage);
Application.Current.Dispatcher.Invoke(() =>
OnSerialCommunicationMessageReceived(serialMessageEventArgs));
}
else if ((incomingMessage[0] == SerialMessageCharacters.SerialErrorCharacter) && (_shouldProcessNextError == false))
{
_shouldProcessNextError = true;
}
}
}
if (_shouldSend == true)
{
SendNextMessage();
}
//Notify subscribers if all messages were sent and executed by the microcontroller.
if ((_serialCommunicationOutgoingMessagesModel.ContainsMessages() == false) &&
(_realTimeStatusDataModel.TaskQueuedMessagesListContainsMessages() == false))
{
Application.Current.Dispatcher.Invoke(() =>
OnSerialCommunicationCompleted());
}
}
catch (Exception exception)
{
HandleSerialException(exception);
}
}
}
/// <summary>
/// Executes whenever a serial message is received.
/// Updates Serial Messages Display.
/// </summary>
private void SerialCommunicationMessageReceived(object sender, SerialMessageEventArgs e)
{
string incomingMessage = e.Message;
_serialMessageDisplayViewModel.AppendIncomingMessage(incomingMessage);
}
/// <summary>
/// Executes whenever a s erial message is sent.
/// Updates Serial Messages Display.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SerialCommunicationMessageSent(object sender, SerialMessageEventArgs e)
{
string outgoingMessage = e.Message;
_serialMessageDisplayViewModel.AppendOutgoingMessage(outgoingMessage);
}
