ArduinoCommands.cs

Go to the documentation of this file.

using System;
using System.IO.Ports;
using System.Threading;
using System.Threading.Tasks;
using Logging;
using SharedObjects;

namespace ArduinoConnection
{
    public class ArduinoCommands
    {

        private readonly int baudRate;
        private SerialPort currentPort;

        public bool PortFound { get; private set; }

        public string PortString { get; private set; }

        [Log]
        [LogException]
        public ArduinoCommands(int baudRate, string portString = "")
        {
            Singleton<Logger>.Instance.LogInfo($"Starting arduino connection with baudrate:{baudRate}");

            this.baudRate = baudRate;
            if (String.IsNullOrEmpty(portString))
                this.FindComPort();
            else
            {
                this.PortString = portString;
                this.currentPort = new SerialPort(this.PortString, baudRate) {ReadTimeout = 2000};
            }

            if (null != this.currentPort)
                this.currentPort.ErrorReceived += this.CurrentPortOnErrorReceived;
            
        }

        [Log]
        [LogException]
        private void CurrentPortOnErrorReceived(object sender, SerialErrorReceivedEventArgs serialErrorReceivedEventArgs)
        {
            if (null != this.currentPort)
            {
                this.currentPort.ErrorReceived -= this.CurrentPortOnErrorReceived;
                this.currentPort.Dispose();
                this.currentPort = null;
            }

            this.currentPort = new SerialPort(this.PortString, this.baudRate) { ReadTimeout = 2000 };

            if (null != this.currentPort)
                this.currentPort.ErrorReceived += this.CurrentPortOnErrorReceived;
        }

        [Log]
        public string FindComPort()
        {
            try
            {
                string[] ports = SerialPort.GetPortNames();
                foreach (string port in ports)
                {
                    string testPort = port;
                    Task<string> detectPort = Task<string>.Factory.StartNew(() =>
                    {
                        Singleton<Logger>.Instance.LogInfo($"Testing COM port:{testPort}");
                        SerialPort serialPort = new SerialPort(testPort, this.baudRate) {ReadTimeout = 2000};
                        return this.DetectArduino(serialPort) ? testPort : String.Empty;
                    });

                    if (detectPort.Wait(5000))
                    {

                        string detectedPort = detectPort.Result;

                        if (String.IsNullOrEmpty(detectedPort))
                            this.PortFound = false;
                        else
                        {
                            Singleton<Logger>.Instance.LogInfo($"Using Arduino on COM port:{detectedPort}");
                            this.PortString = detectedPort;
                            this.PortFound = true;
                            this.currentPort = new SerialPort(testPort, this.baudRate) {ReadTimeout = 2000};
                            return this.PortString;
                        }
                    }
                    else
                    {
                        this.PortFound = false;
                    }
                }
            }
            catch (Exception ex)
            {
                Singleton<Logger>.Instance.LogException(ex);
            }
            return string.Empty;
        }

        [Log]
        public void ActivateLaser(bool on = true)
        {
            this.SendCommand(@on
                ? CommandRepresentations.EnableLaserCommand
                : CommandRepresentations.DisableLaserCommand);
        }

        [Log]
        public void ActivateLight(bool on, int hue)
        {
            if (on)
                this.SendCommand(CommandRepresentations.EnableLightCommand, hue);
            else
                this.SendCommand(CommandRepresentations.DisableLightCommand);
        }

        [Log]
        public void RotateTurnTableCw(int steps)
        {
            this.SendCommand(CommandRepresentations.RotateTurnTableCwCommand, steps);
        }

        [Log]
        public void RotateTurnTableCcw(int steps)
        {
            this.SendCommand(CommandRepresentations.RotateTurnTableCcwCommand, steps);
        }

        [Log]
        public void RotateLaserCw(int steps)
        {
            this.SendCommand(CommandRepresentations.RotateLaserCwCommand, steps);
        }

        [Log]
        public void RotateLaserCcw(int steps)
        {
            this.SendCommand(CommandRepresentations.RotateLaserCcwCommand, steps);
        }

        [Log]
        public void EnableMicroStepping()
        {
            this.SendCommand(CommandRepresentations.EnableMicroSteppingCommand);
        }

        [Log]
        public void DisableMicroStepping()
        {
            this.SendCommand(CommandRepresentations.DisableMicroSteppingCommand);
        }

        [Log]
        [LogException]
        private bool DetectArduino(SerialPort serialPort)
        {
            try
            {
                //The below setting are for the Hello handshake
                byte[] buffer = new byte[1];
                buffer[0] = Convert.ToByte(CommandRepresentations.Ping);

                Singleton<Logger>.Instance.LogInfo($"Try open port {serialPort}");
                serialPort.Open();

                Singleton<Logger>.Instance.LogInfo($"Ask for reply on port {serialPort}");
                serialPort.Write(buffer, 0, 1);
                try
                {
                    Singleton<Logger>.Instance.LogInfo($"Wait for result on port {serialPort}");
                    int intReturnAscii = serialPort.ReadByte();
                    Singleton<Logger>.Instance.LogInfo($"Detected on port {serialPort}");
                    return intReturnAscii == CommandRepresentations.ACK;
                }
                catch (TimeoutException) 
                {
                    Singleton<Logger>.Instance.LogInfo($"Not detected on port {serialPort}");
                    return false;
                }
            }
            catch (Exception ex)
            {
                Singleton<Logger>.Instance.LogInfo($"Not detected on port {serialPort}");
                Singleton<Logger>.Instance.LogException(ex);
            }
            finally
            {
                Singleton<Logger>.Instance.LogInfo($"Close port {serialPort}");
                if(serialPort.IsOpen)
                    serialPort.Close();
            }

            return false;
        }

        [LogException]
        private bool SendCommand(int command, int parameter = -1, int retry = 5)
        {
            try
            {
                byte[] buffer = parameter == -1 ? new byte[1] : new byte[2];

                buffer[0] = Convert.ToByte(command);
                if (parameter != -1)
                    buffer[1] = Convert.ToByte(parameter);
                this.currentPort.Open();
                this.currentPort.Write(buffer, 0, parameter == -1 ? 1 : 2);

                return this.currentPort.ReadByte() == CommandRepresentations.ACK;
            }
            catch (TimeoutException)
            {
                Singleton<Logger>.Instance.LogWarning($"Command took longer then expected: {command}");
                return false;
            }
            catch (UnauthorizedAccessException uax)
            {
                // happens if port is not ready.
                if (retry <= 0)
                {
                    Singleton<Logger>.Instance.LogException(uax);
                    return false;
                }
                
                Thread.Sleep(20);
                return this.SendCommand(command, parameter, retry - 1);
               
            }
            catch (Exception ex)
            {
                Singleton<Logger>.Instance.LogException(ex);
                return false;
            }
            finally
            {
                if (this.currentPort.IsOpen)
                    this.currentPort.Close();
            }
        }
    }
}