// Callback function that plots a data point for the current temperature, the goal temperature,
        // the heater steer value and the Pulse Width Modulated (PWM) value.
        private void OnPlotDataPoint(ReceivedCommand arguments)
        {
            var time = arguments.ReadBinFloatArg();
            var currTemp = arguments.ReadBinFloatArg();
            var goalTemp = arguments.ReadBinFloatArg();
            var heaterValue = arguments.ReadBinFloatArg();
            var heaterPwm = arguments.ReadBinBoolArg();

            _chartForm.UpdateGraph(time, currTemp, goalTemp, heaterValue, heaterPwm);
        }

 /// <summary> Helper function to Invoke or directly call callback function. </summary>
 /// <param name="messengerCallbackFunction"> The messenger callback function. </param>
 /// <param name="command">                   The command. </param>
 private void InvokeCallBack(MessengerCallbackFunction messengerCallbackFunction, ReceivedCommand command)
 {
     if (messengerCallbackFunction != null)
     {
         if (_controlToInvokeOn != null && _controlToInvokeOn.InvokeRequired)
         {
             //Asynchronously call on UI thread
             _controlToInvokeOn.Invoke(new MessengerCallbackFunction(messengerCallbackFunction), (object) command);
         }
         else
         {
             //Directly call
             messengerCallbackFunction(command);
         }
     }
 }

        // Callback function To receive the plain text float series from the Arduino
        void OnReceiveSeries(ReceivedCommand arguments)
        {
            if (_receivedItemsCount % (SeriesLength / 10) == 0)
                Common.WriteLine(_receivedItemsCount+ " Received value: " + arguments.ReadFloatArg());
            if (_receivedItemsCount == 0)
            {
                // Received first value, start stopwatch
                _beginTime = Millis;
            }

            _receivedItemsCount++;
            _receivedBytesCount += CountBytesInCommand(arguments, false);
        }

 // ------------------  C A L L B A C K S ---------------------
 // Called when a received command has no attached function.
 void OnUnknownCommand(ReceivedCommand arguments)
 {
     Console.WriteLine("Command without attached callback received");
 }

 /// <summary> Handle message. </summary>
 /// <param name="receivedCommand"> The received command. </param>
 public void HandleMessage(ReceivedCommand receivedCommand)
 {
     MessengerCallbackFunction callback = null;
     //var commandId = -1;
     //ReceivedCommand receivedCommand;
     if (receivedCommand.Ok)
     {
         //receivedCommand = new ReceivedCommand(commandString);
         if (_callbackList.ContainsKey(receivedCommand.CommandId))
         {
             callback = _callbackList[receivedCommand.CommandId];
         }
         else
         {
             if (_defaultCallback != null) callback = _defaultCallback;
         }
     }
     else
     {
         // Empty command
         receivedCommand = new ReceivedCommand();
     }
     InvokeCallBack(callback, receivedCommand);
 }

 private void UnknownCommand(ReceivedCommand args)
 {
     throw new NotSupportedException(Properties.Resources.UnknownCommand);
 }

        /// <summary> Helper function to Invoke or directly call callback function. </summary>
        /// <param name="messengerCallbackFunction"> The messenger callback function. </param>
        /// <param name="command">                   The command. </param>
        private void InvokeCallBack(MessengerCallbackFunction messengerCallbackFunction, ReceivedCommand command)
        {
            if (messengerCallbackFunction == null || (ControlToInvokeOn != null && ControlToInvokeOn.IsDisposed)) return;

            if (ControlToInvokeOn != null)
            {
                //Asynchronously call on UI thread
                ControlToInvokeOn.BeginInvoke(new MessengerCallbackFunction(messengerCallbackFunction), (object)command);
            }
            else
            {
                //Directly call
                messengerCallbackFunction(command);
            }
        }

 private void OnUnknownCommand(ReceivedCommand receivedCommand)
 {
     Debug.WriteLine("Unknown command");
     OnErrorEvent("Error > Unknown command");
 }

 private void OnWatchdog(ReceivedCommand receivedCommand)
 {
     Debug.WriteLine(String.Format("Watchdog > {0}", receivedCommand.CommandString()));
 }

 private void OnAcknowledge(ReceivedCommand receivedCommand)
 {
     Debug.WriteLine(receivedCommand.CommandString());
     //var a = receivedCommand.ReadInt16Arg();
     //var b = receivedCommand.ReadBoolArg();
     //Debug.WriteLine(String.Format("channel number: {0}, status {1}", a,b));
 }

 private void OnError(ReceivedCommand receivedCommand)
 {
     Debug.WriteLine(String.Format("Error > {0}", receivedCommand.CommandString()));
     OnErrorEvent(String.Format("Error > {0}", receivedCommand.CommandString()));
 }

        void OnButton1(ReceivedCommand arguments)
        {
            //Thread.Sleep(1000);
            Debug.Log("Arduino Button1: ");
              //  test = arguments.ReadInt32Arg();
               // Debug.Log(test);

               // var cmd_return = new SendCommand((int)Command.SetLed);

               // _cmdMessenger.SendCommand(cmd_return);
        }

 void OnUnknownCommand(ReceivedCommand arguments)
 {
     Debug.Log("Command without attached callback received");
 }

        /// <summary> Helper function to Invoke or directly call callback function. </summary>
        /// <param name="messengerCallbackFunction"> The messenger callback function. </param>
        /// <param name="command">                   The command. </param>
        private void InvokeCallBack(MessengerCallbackFunction messengerCallbackFunction, ReceivedCommand command)
        {
            if (messengerCallbackFunction == null) return;

            //Directly call
            messengerCallbackFunction(command);
        }

 // Callback function that prints that the Arduino has acknowledged
 void OnAcknowledge(ReceivedCommand arguments)
 {
     Console.WriteLine(@" Arduino is ready");
 }

        /// <summary> Handle message. </summary>
        /// <param name="receivedCommand"> The received command. </param>
        public void HandleMessage(ReceivedCommand receivedCommand)
        {
            CurrentReceivedLine = receivedCommand.rawString;
            // Send message that a new line has been received and is due to be processed
            InvokeEvent(NewLineReceived);

            MessengerCallbackFunction callback = null;
            if (receivedCommand.Ok)
            {
                //receivedCommand = new ReceivedCommand(commandString);
                if (_callbackList.ContainsKey(receivedCommand.CmdId))
                {
                    callback = _callbackList[receivedCommand.CmdId];
                }
                else
                {
                    if (_defaultCallback != null) callback = _defaultCallback;
                }
            }
            else
            {
                // Empty command
                receivedCommand = new ReceivedCommand();
            }
            InvokeCallBack(callback, receivedCommand);
        }

 // Callback function that prints that the Arduino has experienced an error
 void OnError(ReceivedCommand arguments)
 {
     Console.WriteLine(@"Arduino has experienced an error");
 }

        /// <summary> Blocks until acknowlegdement reply has been received. </summary>
        /// <param name="ackCmdId"> acknowledgement command ID </param>
        /// <param name="timeout">  Timeout on acknowlegde command. </param>
        /// <param name="clearQueueState"></param>
        /// <returns> . </returns>
        private ReceivedCommand BlockedTillReply(int ackCmdId, int timeout, ClearQueue clearQueueState)
        {
            // Disable invoking command callbacks
            _receiveCommandQueue.ThreadRunState = CommandQueue.ThreadRunStates.Stop;

            var start = TimeUtils.Millis;
            var time = start;
            var acknowledgeCommand = new ReceivedCommand();
            while ((time - start < timeout) && !acknowledgeCommand.Ok)
            {
                time = TimeUtils.Millis;
                acknowledgeCommand = CheckForAcknowledge(ackCmdId, clearQueueState);
            }

            // Re-enable invoking command callbacks
            _receiveCommandQueue.ThreadRunState = CommandQueue.ThreadRunStates.Start;
            return acknowledgeCommand;
        }

        /// <summary> Handle message. </summary>
        /// <param name="receivedCommand"> The received command. </param>
        private void HandleMessage(ReceivedCommand receivedCommand)
        {
            MessengerCallbackFunction callback = null;

            if (receivedCommand.Ok)
            {
                if (_callbackList.ContainsKey(receivedCommand.CmdId))
                {
                    callback = _callbackList[receivedCommand.CmdId];
                }
                else
                {
                    if (_defaultCallback != null) callback = _defaultCallback;
                }
            }
            else
            {
                // Empty command
                receivedCommand = new ReceivedCommand { CommunicationManager = _communicationManager };
            }

            InvokeCallBack(callback, receivedCommand);
        }

 public void TestSendCommandWithAcknowledgementByArduinoFinished(ReceivedCommand command)
 {
     var result = command.ReadBoolArg();
     if (!result)
     {
         Common.TestNotOk("Incorrect response");
     }
     _acknowledgementByEmbeddedFinished = true;
 }