// Loop function
public void Loop()
{
// Create command FloatAddition, which will wait for a return command FloatAdditionResult
var command = new SendCommand((int)Command.FloatAddition, (int)Command.FloatAdditionResult, 1000);
// Add 2 float command arguments
var a = 3.14F;
var b = 2.71F;
command.AddArgument(a);
command.AddArgument(b);
// Send command
var floatAdditionResultCommand = _cmdMessenger.SendCommand(command);
// Check if received a (valid) response
if (floatAdditionResultCommand.Ok)
{
// Read returned argument
var sum = floatAdditionResultCommand.ReadFloatArg();
var diff = floatAdditionResultCommand.ReadFloatArg();
// Compare with sum of sent values
var errorSum = sum - (a + b);
var errorDiff = diff - (a - b);
Console.WriteLine("Received sum {0}, difference of {1}", sum, diff);
Console.WriteLine("with errors {0} and {1}, respectively", errorSum, errorDiff);
}
else
Console.WriteLine("No response!");
// Stop running loop
RunLoop = false;
}
// Setup function
public void Setup()
{
_transport = new SerialTransport {CurrentSerialSettings = {DtrEnable = false}};
// some boards (e.g. Sparkfun Pro Micro) DtrEnable may need to be true.
// We do not need to set serial port and baud rate: it will be found by the connection manager
// Initialize the command messenger with the Serial Port transport layer
// Set if it is communicating with a 16- or 32-bit Arduino board
_cmdMessenger = new CmdMessenger(_transport, BoardType.Bit16)
{
PrintLfCr = false // Do not print newLine at end of command, to reduce data being sent
};
// The Connection manager is capable or storing connection settings, in order to reconnect more quickly
// the next time the application is run. You can determine yourself where and how to store the settings
// by supplying a class, that implements ISerialConnectionStorer. For convenience, CmdMessenger provides
// simple binary file storage functionality
var serialConnectionStorer = new SerialConnectionStorer("SerialConnectionManagerSettings.cfg");
// We don't need to provide a handler for the Identify command - this is a job for Connection Manager.
_connectionManager = new SerialConnectionManager(
_transport as SerialTransport,
_cmdMessenger,
(int) Command.Identify,
CommunicationIdentifier,
serialConnectionStorer)
{
// Enable watchdog functionality.
WatchdogEnabled = true,
// Instead of scanning for the connected port, you can disable scanning and only try the port set in CurrentSerialSettings
//DeviceScanEnabled = false
};
// Show all connection progress on command line
_connectionManager.Progress += (sender, eventArgs) =>
{
// If you want to reduce verbosity, you can only show events of level <=2 or ==1
if (eventArgs.Level <= 3) Console.WriteLine(eventArgs.Description);
};
// If connection found, tell the arduino to turn the (internal) led on
_connectionManager.ConnectionFound += (sender, eventArgs) =>
{
// Create command
var command = new SendCommand((int)Command.TurnLedOn);
// Send command
_cmdMessenger.SendCommand(command);
};
//You can also do something when the connection is lost
_connectionManager.ConnectionTimeout += (sender, eventArgs) =>
{
//Do something
};
// Finally - activate connection manager
_connectionManager.StartConnectionManager();
}
public void SetLedFrequency(double ledFrequency)
{
// Send command to start sending data
var command = new SendCommand((int)Command.SetLedFrequency,ledFrequency);
// Send command
_cmdMessenger.SendCommand(command);
}
// Sent command to change led on/of state
public void SetLedState(bool ledState)
{
// Create command to start sending data
var command = new SendCommand((int)Command.SetLed, ledState);
// Send command
_cmdMessenger.SendCommand(new SendCommand((int)Command.SetLed, ledState));
}
// Loop function
public void Loop()
{
// Create command
var command = new SendCommand((int)Command.SetLed,_ledState);
// Send command
_cmdMessenger.SendCommand(command);
// Wait for 1 second and repeat
Thread.Sleep(1000);
_ledState = !_ledState; // Toggle led state
}
public override void Send(string message)
{
try
{
var cmd = new SendCommand((int)SerialCommand.SetLed, message);
var recieve = cmdMessenger.SendCommand(cmd);
OnSendSuccess(new MessageEventArgs(string.Format("Message Send Success: Id={0}, Message={1}", recieve.RawString, message)));
}
catch (Exception e)
{
OnSendFailure(new MessageEventArgs("Message Send Failure: " + e.ToString()));
}
}
// Sent command to change led blinking frequency
public void SetLedFrequency(double ledFrequency)
{
// Create command to start sending data
var command = new SendCommand((int)Command.SetLedFrequency,ledFrequency);
// Put the command on the queue and wrap it in a collapse command strategy
// This strategy will avoid duplicates of this certain command on the queue: if a SetLedFrequency command is
// already on the queue when a new one is added, it will be replaced at its current queue-position.
// Otherwise the command will be added to the back of the queue.
//
// This will make sure that when the slider raises a lot of events that each send a new blink frequency, the
// embedded controller will not start lagging.
_cmdMessenger.QueueCommand(new CollapseCommandStrategy(command));
}
// Loop function
public void Loop()
{
// Create command
var command = new SendCommand((int)Command.SetLed,_ledState);
// Send command
_cmdMessenger.SendCommand(command);
Console.Write("Turning led ");
Console.WriteLine(_ledState?"on":"off");
// Wait for 1 second and repeat
Thread.Sleep(1000);
_ledState = !_ledState; // Toggle led state
}
/// <summary> Directly executes the send command operation. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear the send and receive queues. </param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand ExecuteSendCommand(SendCommand sendCommand, SendQueue sendQueueState)
{
// Disable listening, all callbacks are disabled until after command was sent
ReceivedCommand ackCommand;
lock (_sendCommandDataLock)
{
if (PrintLfCr)
_communicationManager.WriteLine(sendCommand.CommandString());
else
_communicationManager.Write(sendCommand.CommandString());
ackCommand = sendCommand.ReqAc ? BlockedTillReply(sendCommand.AckCmdId, sendCommand.Timeout, sendQueueState) : new ReceivedCommand();
}
return ackCommand;
}
// Loop function
public void Loop()
{
_count++;
// Create command
var command = new SendCommand((int)Command.SetLed,_ledState);
// Send command
_cmdMessenger.SendCommand(command);
// Wait for 1 second and repeat
Thread.Sleep(1000);
_ledState = !_ledState; // Toggle led state
if (_count > 100) RunLoop = false; // Stop loop after 100 rounds
}
// ------------------ MAIN ----------------------
// Setup function
public void Setup(ChartForm chartForm)
{
// getting the chart control on top of the chart form.
_chartForm = chartForm;
// Set up chart
_chartForm.SetupChart();
// Create Serial Port object
// Note that for some boards (e.g. Sparkfun Pro Micro) DtrEnable may need to be true.
_serialTransport = new SerialTransport
{
CurrentSerialSettings = { PortName = "COM6", BaudRate = 115200, DtrEnable = false } // object initializer
};
// Initialize the command messenger with the Serial Port transport layer
// Set if it is communicating with a 16- or 32-bit Arduino board
_cmdMessenger = new CmdMessenger(_serialTransport, BoardType.Bit16);
// Tell CmdMessenger to "Invoke" commands on the thread running the WinForms UI
_cmdMessenger.ControlToInvokeOn = chartForm;
// Set Received command strategy that removes commands that are older than 1 sec
_cmdMessenger.AddReceiveCommandStrategy(new StaleGeneralStrategy(1000));
// Attach the callbacks to the Command Messenger
AttachCommandCallBacks();
// Attach to NewLinesReceived for logging purposes
_cmdMessenger.NewLineReceived += NewLineReceived;
// Attach to NewLineSent for logging purposes
_cmdMessenger.NewLineSent += NewLineSent;
// Start listening
_cmdMessenger.Connect();
// Send command to start sending data
var command = new SendCommand((int)Command.StartLogging);
// Send command
_cmdMessenger.SendCommand(command);
}
/// <summary> Directly executes the send command operation. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear the send and receive queues. </param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand ExecuteSendCommand(SendCommand sendCommand, SendQueue sendQueueState)
{
// Disable listening, all callbacks are disabled until after command was sent
ReceivedCommand ackCommand;
lock (_sendCommandDataLock)
{
sendCommand.CommunicationManager = this;
sendCommand.InitArguments();
if (sendCommand.ReqAc)
{
// Stop processing receive queue before sending. Wait until receive queue is actualy done
_receiveCommandQueue.Suspend();
}
if (sendCommand.ReqAc)
{
_receiveCommandQueue.PrepareForCmd(sendCommand.AckCmdId, sendQueueState);
WriteCommand(sendCommand);
var rc = BlockedTillReply(sendCommand.Timeout);
ackCommand = rc ?? new ReceivedCommand();
}
else
{
WriteCommand(sendCommand);
ackCommand = new ReceivedCommand();
}
ackCommand.CommunicationManager = this;
}
if (sendCommand.ReqAc)
{
// Stop processing receive queue before sending
_receiveCommandQueue.Resume();
}
return(ackCommand);
}
// ------------------ MAIN ----------------------
// Setup function
public void Setup(ChartForm chartForm)
{
// getting the chart control on top of the chart form.
_chartForm = chartForm;
// Set up chart
_chartForm.SetupChart();
// Create Serial Port object
_serialTransport = new SerialTransport
{
CurrentSerialSettings = { PortName = "COM6", BaudRate = 115200 } // object initializer
};
// Initialize the command messenger with the Serial Port transport layer
_cmdMessenger = new CmdMessenger(_serialTransport);
// Tell CmdMessenger to "Invoke" commands on the thread running the WinForms UI
_cmdMessenger.SetControlToInvokeOn(chartForm);
// Set Received command strategy that removes commands that are older than 1 sec
_cmdMessenger.AddReceiveCommandStrategy(new StaleGeneralStrategy(1000));
// Attach the callbacks to the Command Messenger
AttachCommandCallBacks();
// Attach to NewLinesReceived for logging purposes
_cmdMessenger.NewLineReceived += NewLineReceived;
// Attach to NewLineSent for logging purposes
_cmdMessenger.NewLineSent += NewLineSent;
// Start listening
_cmdMessenger.StartListening();
// Send command to start sending data
var command = new SendCommand((int)Command.StartLogging);
// Send command
_cmdMessenger.SendCommand(command);
}
/// <summary> Directly executes the send command operation. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear the send and receive queues. </param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand ExecuteSendCommand(SendCommand sendCommand, SendQueue sendQueueState)
{
// Disable listening, all callbacks are disabled until after command was sent
ReceivedCommand ackCommand;
lock (_sendCommandDataLock)
{
if (PrintLfCr)
{
_communicationManager.WriteLine(sendCommand.CommandString());
}
else
{
_communicationManager.Write(sendCommand.CommandString());
}
ackCommand = sendCommand.ReqAc ? BlockedTillReply(sendCommand.AckCmdId, sendCommand.Timeout, sendQueueState) : new ReceivedCommand();
}
return(ackCommand);
}
private const float SeriesBase = 1111111.111111F; // Base of values to return: SeriesBase * (0..SeriesLength-1)
// ------------------ M A I N ----------------------
// Setup function
public void Setup()
{
// Create Serial Port object
_serialTransport = new SerialTransport
{
CurrentSerialSettings = { PortName = "COM6", BaudRate = 115200 } // object initializer
};
// Initialize the command messenger with the Serial Port transport layer
_cmdMessenger = new CmdMessenger(_serialTransport);
// Attach the callbacks to the Command Messenger
AttachCommandCallBacks();
// Start listening
_cmdMessenger.StartListening();
_receivedPlainTextCount = 0;
// Send command requesting a series of 100 float values send in plain text
var commandPlainText = new SendCommand((int)Command.RequestPlainTextFloatSeries);
commandPlainText.AddArgument(SeriesLength);
commandPlainText.AddArgument(SeriesBase);
// Send command
_cmdMessenger.SendCommand(commandPlainText);
// Now wait until all values have arrived
while (!_receivePlainTextFloatSeriesFinished) {}
// Send command requesting a series of 100 float values send in plain text
var commandBinary = new SendCommand((int)Command.RequestBinaryFloatSeries);
commandBinary.AddBinArgument((UInt16)SeriesLength);
commandBinary.AddBinArgument((Single)SeriesBase);
// Send command
_cmdMessenger.SendCommand(commandBinary);
// Now wait until all values have arrived
while (!_receiveBinaryFloatSeriesFinished) { }
}
/// <summary> Directly executes the send command operation. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="clearQueueState"> Property to optionally clear the send and receive queues. </param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand ExecuteSendCommand(SendCommand sendCommand, ClearQueue clearQueueState)
{
// Disable listening, all callbacks are disabled until after command was sent
lock (_sendCommandDataLock)
{
CurrentSentLine = CommandToString(sendCommand);
if (PrintLfCr)
{
_communicationManager.WriteLine(CurrentSentLine + _commandSeparator);
}
else
{
_communicationManager.Write(CurrentSentLine + _commandSeparator);
}
InvokeEvent(NewLineSent);
var ackCommand = sendCommand.ReqAc ? BlockedTillReply(sendCommand.AckCmdId, sendCommand.Timeout, clearQueueState) : new ReceivedCommand();
return(ackCommand);
}
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired.
/// Based on ClearQueueState, the send- and receive-queues are left intact or are cleared</summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear/wait the send queue</param>
/// <param name="receiveQueueState"> Property to optionally clear/wait the send queue</param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand SendCommand(SendCommand sendCommand, SendQueue sendQueueState = SendQueue.InFrontQueue, ReceiveQueue receiveQueueState = ReceiveQueue.Default)
{
return SendCommand(sendCommand, sendQueueState, receiveQueueState, UseQueue.UseQueue);
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired. </summary>
/// <param name="sendCommand"> The command to sent. </param>
public ReceivedCommand SendCommand(SendCommand sendCommand)
{
return SendCommand(sendCommand, ClearQueue.KeepQueue);
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired. </summary>
/// <param name="sendCommand"> The command to sent. </param>
public ReceivedCommand SendCommand(SendCommand sendCommand)
{
return(SendCommand(sendCommand, ClearQueue.KeepQueue));
}
// *** Benchmark 1 ***
private void SetupReceiveSeries()
{
Common.StartTest("Calculating speed in receiving series of float data");
WaitAndClear();
_receiveSeriesFinished = false;
_receivedItemsCount = 0;
_receivedBytesCount = 0;
_minimalBps = _systemSettings.MinReceiveSpeed;
// Send command requesting a series of 100 float values send in plain text form
var commandPlainText = new SendCommand(_command["RequestSeries"]);
commandPlainText.AddArgument(SeriesLength);
commandPlainText.AddArgument(SeriesBase);
// Send command
_cmdMessenger.SendCommand(commandPlainText);
// Now wait until all values have arrived
while (!_receiveSeriesFinished)
{
Thread.Sleep(10);
}
}
// *** Benchmark 3 ***
private void DirectSendSeries()
{
Common.StartTest("Calculating speed in individually sending a series of float data");
WaitAndClear();
_minimalBps = _systemSettings.MinDirectSendSpeed;
_sendSeriesFinished = false;
var prepareSendSeries = new SendCommand(_command["PrepareSendSeries"]);
prepareSendSeries.AddArgument(SeriesLength);
// We need to to send the prepareSendSeries by bypassing the queue or it might be sent after the directly send commands later on
_cmdMessenger.SendCommand(prepareSendSeries, SendQueue.WaitForEmptyQueue, ReceiveQueue.WaitForEmptyQueue,UseQueue.BypassQueue);
// Prepare
_receivedBytesCount = 0;
_cmdMessenger.PrintLfCr = true;
_beginTime = Millis;
// Now send all commands individually and bypass the queue
for (var sendItemsCount = 0; sendItemsCount < SeriesLength; sendItemsCount++)
{
var sendSeries = new SendCommand(_command["SendSeries"]);
sendSeries.AddArgument(sendItemsCount * SeriesBase);
_receivedBytesCount += CountBytesInCommand(sendSeries, _cmdMessenger.PrintLfCr);
_cmdMessenger.SendCommand(sendSeries, SendQueue.Default, ReceiveQueue.Default, UseQueue.BypassQueue);
if (sendItemsCount%(SeriesLength/10) == 0)
{
Common.WriteLine("Send value: " + sendItemsCount*SeriesBase);
}
}
_endTime = Millis;
// Now wait until receiving party acknowledges that values have arrived
while (!_sendSeriesFinished)
{
Thread.Sleep(10);
}
}
/// <summary> Queue the send command. </summary>
/// <param name="sendCommand"> The command to sent. </param>
public void QueueCommand(SendCommand sendCommand)
{
QueueCommand(new CommandStrategy(sendCommand));
}
/// <summary> Put the command at the back of the sent queue.</summary>
/// <param name="sendCommand"> The command to sent. </param>
public void QueueCommand(SendCommand sendCommand)
{
_sendCommandQueue.QueueCommand(sendCommand);
}
private void ValuePingPongBool(bool value)
{
var pingCommand = new SendCommand(_command["ValuePing"], _command["ValuePong"], 1000);
pingCommand.AddArgument((Int16)DataType.Bool);
pingCommand.AddArgument(value);
var pongCommand = _cmdMessenger.SendCommand(pingCommand);
if (!pongCommand.Ok)
{
Common.TestNotOk("No response on ValuePing command");
return;
}
var result = pongCommand.ReadBoolArg();
if (result == value)
Common.TestOk("Value as expected");
else
Common.TestNotOk("unexpected value received: " + result + " instead of " + value);
}
/// <summary> Sends a command. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <returns> . </returns>
public ReceivedCommand SendCommand(SendCommand sendCommand)
{
return(SendCommand(sendCommand.CmdId, sendCommand.Arguments, sendCommand.ReqAc, sendCommand.AckCmdId,
sendCommand.Timeout));
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired.
/// Based on ClearQueueState, the send- and receive-queues are left intact or are cleared</summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear/wait the send queue</param>
/// <param name="receiveQueueState"> Property to optionally clear/wait the send queue</param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand SendCommand(SendCommand sendCommand, SendQueue sendQueueState = SendQueue.InFrontQueue, ReceiveQueue receiveQueueState = ReceiveQueue.Default)
{
return(SendCommand(sendCommand, sendQueueState, receiveQueueState, UseQueue.UseQueue));
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired.
/// Based on ClearQueueState, the send- and receive-queues are left intact or are cleared</summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear/wait the send queue</param>
/// <param name="receiveQueueState"> Property to optionally clear/wait the send queue</param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand SendCommand(SendCommand sendCommand, SendQueue sendQueueState, ReceiveQueue receiveQueueState)
{
return(SendCommand(sendCommand, sendQueueState, receiveQueueState, UseQueue.UseQueue));
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired. </summary>
/// <param name="sendCommand"> The command to sent. </param>
public ReceivedCommand SendCommand(SendCommand sendCommand)
{
return(SendCommand(sendCommand, SendQueue.InFrontQueue, ReceiveQueue.Default));
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired.
/// Based on ClearQueueState, the send- and receive-queues are left intact or are cleared</summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear/wait the send queue</param>
/// <param name="receiveQueueState"> Property to optionally clear/wait the send queue</param>
/// <param name="useQueue"> Property to optionally bypass the queue</param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand SendCommand(SendCommand sendCommand, SendQueue sendQueueState, ReceiveQueue receiveQueueState, UseQueue useQueue)
{
var synchronizedSend = (sendCommand.ReqAc || useQueue == UseQueue.BypassQueue);
// When waiting for an acknowledge, it is typically best to wait for the ReceiveQueue to be empty
// This is thus the default state
if (sendCommand.ReqAc && receiveQueueState == ReceiveQueue.Default)
{
receiveQueueState = ReceiveQueue.WaitForEmptyQueue;
}
if (sendQueueState == SendQueue.ClearQueue )
{
// Clear receive queue
_receiveCommandQueue.Clear();
}
if (receiveQueueState == ReceiveQueue.ClearQueue )
{
// Clear send queue
_sendCommandQueue.Clear();
}
// If synchronized sending, the only way to get command at end of queue is by waiting
if (sendQueueState == SendQueue.WaitForEmptyQueue ||
(synchronizedSend && sendQueueState == SendQueue.AtEndQueue)
)
{
SpinWait.SpinUntil(() => _sendCommandQueue.IsEmpty);
}
if (receiveQueueState == ReceiveQueue.WaitForEmptyQueue)
{
SpinWait.SpinUntil(() => _receiveCommandQueue.IsEmpty);
}
if (synchronizedSend)
{
return SendCommandSync(sendCommand, sendQueueState);
}
if (sendQueueState != SendQueue.AtEndQueue)
{
// Put command at top of command queue
_sendCommandQueue.SendCommand(sendCommand);
}
else
{
// Put command at bottom of command queue
_sendCommandQueue.QueueCommand(sendCommand);
}
return new ReceivedCommand { CommunicationManager = _communicationManager };
}
/// <summary> Synchronized send a command. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="sendQueueState"> Property to optionally clear/wait the send queue. </param>
/// <returns> . </returns>
public ReceivedCommand SendCommandSync(SendCommand sendCommand, SendQueue sendQueueState)
{
// Directly call execute command
var resultSendCommand = _communicationManager.ExecuteSendCommand(sendCommand, sendQueueState);
InvokeNewLineEvent(NewLineSent, new CommandEventArgs(sendCommand));
return resultSendCommand;
}
private void ValuePingPongFloat(float value)
{
var pingCommand = new SendCommand(_command["ValuePing"], _command["ValuePong"], 1000);
pingCommand.AddArgument((Int16)DataType.Float);
pingCommand.AddArgument(value);
var pongCommand = _cmdMessenger.SendCommand(pingCommand);
if (!pongCommand.Ok)
{
Common.TestNotOk("No response on ValuePing command");
return;
}
var result = pongCommand.ReadFloatArg();
var difference = Math.Abs(result - value);
var accuracy = Math.Abs(value * 2e-7);
if (difference <= accuracy)
Common.TestOk("Value as expected");
else
Common.TestNotOk("unexpected value received: " + result + " instead of " + value);
}
/// <summary> Sends a command. Note that the command is put at the front of the queue </summary>
/// <param name="sendCommand"> The command to sent. </param>
public void SendCommand(SendCommand sendCommand)
{
// Add command to front of queue
QueueCommand(new TopCommandStrategy(sendCommand));
}
private void ValuePingPongDoubleSci(double value, double accuracy)
{
var pingCommand = new SendCommand(_command["ValuePing"], _command["ValuePong"], 1000);
pingCommand.AddArgument((Int16)DataType.DoubleSci);
pingCommand.AddArgument(value);
var pongCommand = _cmdMessenger.SendCommand(pingCommand);
if (!pongCommand.Ok)
{
Common.TestNotOk("No response on ValuePing command");
return;
}
var result = pongCommand.ReadDoubleArg();
var difference = RelativeError(value, result);
if (difference <= accuracy)
Common.TestOk("Value as expected");
else
Common.TestNotOk("unexpected value received: " + result + " instead of " + value);
}
/// <summary> Sends a command. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <returns> . </returns>
public ReceivedCommand SendCommand(SendCommand sendCommand)
{
return SendCommand(sendCommand.CmdId, sendCommand.Arguments, sendCommand.ReqAc, sendCommand.AckCmdId,
sendCommand.Timeout);
}
public bool MoveMotor(short Channel, short Speed)
{
if (!Initialized)
throw new Exception("Not yet initialized");
var command = new SendCommand((int)Command.MotorCommand, (int)Command.Acknowledge, 1000);
command.AddArgument(Channel);
command.AddArgument(Speed);
var response = _cmdMessenger.SendCommand(command);
if (response.Ok)
{
var cn = response.ReadInt16Arg();
var cs = response.ReadInt16Arg();
Debug.WriteLine(String.Format("Command response - channel={0}; speed={1}", cn, cs));
if (Channel == cn && Speed == cs)
{
Debug.WriteLine("Alles gut");
//OnChannelStateConfirmation(new ChannelStatus(cn, cs));
return true;
}
}
return false;
}
// *** Benchmark 2 ***
// Setup queued send series
private void SetupQueuedSendSeries()
{
Common.StartTest("Calculating speed in sending queued series of float data");
WaitAndClear();
_minimalBps = _systemSettings.MinSendSpeed;
_sendSeriesFinished = false;
var prepareSendSeries = new SendCommand(_command["PrepareSendSeries"]);
prepareSendSeries.AddArgument(SeriesLength);
_cmdMessenger.SendCommand(prepareSendSeries, SendQueue.WaitForEmptyQueue, ReceiveQueue.WaitForEmptyQueue);
// Prepare
_receivedBytesCount = 0;
_cmdMessenger.PrintLfCr = true;
_beginTime = Millis;
// Now queue all commands
for (var sendItemsCount = 0; sendItemsCount < SeriesLength; sendItemsCount++)
{
var sendSeries = new SendCommand(_command["SendSeries"]);
sendSeries.AddArgument(sendItemsCount * SeriesBase);
_receivedBytesCount += CountBytesInCommand(sendSeries, _cmdMessenger.PrintLfCr);
_cmdMessenger.QueueCommand(sendSeries);
if (sendItemsCount % (SeriesLength / 10) == 0)
Common.WriteLine("Send value: " + sendItemsCount * SeriesBase);
}
// Now wait until receiving party acknowledges that values have arrived
while (!_sendSeriesFinished)
{
Thread.Sleep(10);
}
}
/// <summary> Directly executes the send command operation. </summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="clearQueueState"> Property to optionally clear the send and receive queues. </param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand ExecuteSendCommand(SendCommand sendCommand, ClearQueue clearQueueState)
{
// Disable listening, all callbacks are disabled until after command was sent
lock (_sendCommandDataLock)
{
CurrentSentLine = CommandToString(sendCommand);
if (PrintLfCr)
_communicationManager.WriteLine(CurrentSentLine + _commandSeparator);
else
{
_communicationManager.Write(CurrentSentLine + _commandSeparator);
}
InvokeEvent(NewLineSent);
var ackCommand = sendCommand.ReqAc ? BlockedTillReply(sendCommand.AckCmdId, sendCommand.Timeout, clearQueueState) : new ReceivedCommand();
return ackCommand;
}
}
private void WaitAndClear()
{
var requestResetCommand = new SendCommand(_command["RequestReset"], _command["RequestResetAcknowledge"], 1000);
var requestResetAcknowledge = _cmdMessenger.SendCommand(requestResetCommand, SendQueue.ClearQueue,ReceiveQueue.ClearQueue);
Common.WriteLine(!requestResetAcknowledge.Ok ? "No Wait OK received" : "Wait received");
// Wait another second to see if
Thread.Sleep(1000);
// Clear queues again to be very sure
_cmdMessenger.ClearReceiveQueue();
_cmdMessenger.ClearSendQueue();
}
/// <summary> Sends a command.
/// If no command acknowledge is requested, the command will be send asynchronously: it will be put on the top of the send queue
/// If a command acknowledge is requested, the command will be send synchronously: the program will block until the acknowledge command
/// has been received or the timeout has expired.
/// Based on ClearQueueState, the send- and receive-queues are left intact or are cleared</summary>
/// <param name="sendCommand"> The command to sent. </param>
/// <param name="clearQueueState"> Property to optionally clear the send and receive queues</param>
/// <returns> A received command. The received command will only be valid if the ReqAc of the command is true. </returns>
public ReceivedCommand SendCommand(SendCommand sendCommand, ClearQueue clearQueueState)
{
//_sendCommandLogger.LogLine(CommandToString(sendCommand) + _commandSeparator);
if (clearQueueState == ClearQueue.ClearReceivedQueue ||
clearQueueState == ClearQueue.ClearSendAndReceivedQueue)
{
// Clear receive queue
_receiveCommandQueue.Clear();
}
if (clearQueueState == ClearQueue.ClearSendQueue ||
clearQueueState == ClearQueue.ClearSendAndReceivedQueue)
{
// Clear send queue
_sendCommandQueue.Clear();
}
if (sendCommand.ReqAc)
{
// Directly call execute command
return ExecuteSendCommand(sendCommand, clearQueueState);
}
// Put command at top of command queue
_sendCommandQueue.SendCommand(sendCommand);
return new ReceivedCommand();
}
/// <summary> Put the command at the back of the sent queue.</summary>
/// <param name="sendCommand"> The command to sent. </param>
public void QueueCommand(SendCommand sendCommand)
{
_sendCommandQueue.QueueCommand(sendCommand);
}
public bool Switch(short ChannelName, bool state)
{
if (!Initialized)
throw new Exception("Not yet initialized");
OnChannelStateRequest(new ChannelStatus(ChannelName, state));
var command = new SendCommand((int)Command.SwitchChannel,(int)Command.Acknowledge,1000);
command.AddArgument(ChannelName);
command.AddArgument(state);
var response = _cmdMessenger.SendCommand(command);
if (response.Ok)
{
var cn = response.ReadInt16Arg();
var cs = response.ReadBoolArg();
Debug.WriteLine(String.Format("Command response - channelNumber={0}; channelState={1}", cn,cs));
if (ChannelName == cn && state == cs)
{
OnChannelStateConfirmation(new ChannelStatus(cn, cs));
return true;
}
}
return false;
}
