tbf/TBF/Rig/TestMethods/iPerlCommunication/communication/RadioService.cs

using log4net;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.diagnosticLed;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.IperlHatProtocol;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.protocolCommons;
using TBF.Rig.TestMethods.iPerlCommunication.communication.Utils;
using TBF.Rig.TestMethods.iPerlCommunication.iPerlHead;

namespace TBF.Rig.TestMethods.iPerlCommunication.communication
{
    public class RadioService
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(RadioService));
        
        static string okResponse = "Command complete, no errors";
        static string errorResponse = "Unable to execute";
        
        private ISerialDriver serialDriver;
        public RadioService(SerialDriver serialDriver)
        {
            this.serialDriver = serialDriver;
            log.Debug("RadioService created with serialDriver= " + serialDriver + "");
        }
        
        public RadioService(ISerialDriver serialDriver)
        {
            this.serialDriver = serialDriver;
            log.Debug("RadioService created with serialDriver= " + serialDriver + "");
        }

        public string ReadRequest_PCB(ref IperlHead iHead)
        {
            if (!serialDriver.IsOpen())
            {
                serialDriver.Open();
            }

            var request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.ViewFactoryId)
                .BuildBytes();
            
            
            byte[] rawData = serialDriver.SendAndWait(request, 10000);
            if (rawData == null)
                return null;
            
            // parse rawData
            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);
            if (decoded.IsOk)
            {
                string asciiPayload = decoded.GetAsciiPayload();
                iHead.SerialNr = asciiPayload;
                if (iHead.ConfigStruct != null) // store mechanism
                {
                    iHead.ConfigStruct.PCBNumberString = asciiPayload;
                }
                return asciiPayload;
            }
            
            return null;
        }
        
        public ProtocolStatuses GetActivityStatusMode(IperlHead iHead)
        {
            if (!serialDriver.IsOpen())
                serialDriver.Open();

            var request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.ViewState)
                .BuildBytes();

            byte[] rawData = serialDriver.SendAndWait(request, 10000);
            if (rawData == null)
                return ProtocolStatuses.Unknown;

            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);

            if (!decoded.IsOk)
                return ProtocolStatuses.Unknown;
            
            ProtocolStatuses statusMode = decoded.GetResponse<ProtocolStatuses>(out bool isOK);

            if (!isOK)
                return ProtocolStatuses.Unknown; // wrong payload

            return statusMode;
        }
        
        public DiagnosticLedState SetOptoStatusMode(IperlHead iHead, DiagnosticLedState opthoStatusMode)
        {
            if (!serialDriver.IsOpen())
                serialDriver.Open();

            var request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddDeviceCommand(ProtocolDeviceSubCommand.SetDiagnosticLEDState)
                .AddPayload(opthoStatusMode)
                .BuildBytes();

            byte[] rawData = serialDriver.SendAndWait(request, 10000);
            if (rawData == null)
                return DiagnosticLedState.StatusUnknown;

            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);

            log.Debug("SetOptoStatusMode isOK: " + decoded.IsOk);
            // if is response ok - it set it correctly
            if (!decoded.IsOk) 
                return DiagnosticLedState.StatusUnknown;

            return opthoStatusMode;
        }

        
        private static ushort SafeIntToUShort(int value)
        {
            if (value < ushort.MinValue || value > ushort.MaxValue)
                return 0xFD; // your error code

            return (ushort)value;
        }

        
        public string GetVersion(IperlHead iHead)
        {
            if (!serialDriver.IsOpen())
            {
                serialDriver.Open();
            }

            byte[] request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.Question)
                .AddPayload(IperlHatProtocolConstants.Version)
                .BuildBytes();
            
            
            byte[] rawData = serialDriver.SendAndWait(request, 10000);
            if (rawData == null)
                return "";
            
            // parse rawData
            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);
            log.Debug("GetVersion isOK: " + decoded.IsOk);
            if (decoded.IsOk)
            {
                return decoded.GetAsciiPayload();
            }
            
            return "";
        }

        
        public bool SetActivityMode_Active(IperlHead iHead)
        {
            if (!serialDriver.IsOpen())
            {
                serialDriver.Open();
            }
            
            //Set LED to state 4
            byte[] request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.SetState)
                .AddSubCommand(ProtocolStatuses.Active) // Active
                .BuildBytes();

            byte[] rawData = serialDriver.SendAndWait(request, 5000);
            if (rawData == null)
                return false;
            
            
            // parse rawData
            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);
            log.Debug("SetActivityMode_Active isOK: " + decoded.IsOk);
            if (decoded.IsOk && iHead.ConfigStruct != null)
            {
                iHead.ConfigStruct.StatusMode = ProtocolStatuses.Active;
            }
            return decoded.IsOk;
        }
        
        public bool SetActivityMode_Idle(IperlHead iHead)
        {
            if (!serialDriver.IsOpen())
            {
                serialDriver.Open();
            }
            
            //Set Activity State Idle
            byte[] request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.SetState)
                .AddSubCommand(ProtocolStatuses.Idle)
                .BuildBytes();

            byte[] rawData = serialDriver.SendAndWait(request, 5000);
            if (rawData == null)
                return false;
            
            
            // parse rawData
            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);
            log.Debug("SetActivityMode_Idle isOK: " + decoded.IsOk);
            if (decoded.IsOk && iHead.ConfigStruct != null)
            {
                iHead.ConfigStruct.StatusMode = ProtocolStatuses.Idle;
            }
            return decoded.IsOk;
        }
        
        public bool SetOptTestMode(IperlHead iHead)
        {
            if (!serialDriver.IsOpen())
            {
                serialDriver.Open();
            }
            
            //Set LED to state 4
            var request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddDeviceCommand(ProtocolDeviceSubCommand.SetDiagnosticLEDState)
                .AddPayload(DiagnosticLedState.State4)
                .BuildBytes();

            byte[] rawData = serialDriver.SendAndWait(request, 5000);
            if (rawData == null)
                return false;
            
            
            // parse rawData
            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);
            bool isOk = decoded.IsOk;
            log.Debug("SetOptTestMode isOK: " + isOk);
            if (decoded.IsOk && iHead.ConfigStruct != null)
            {
                iHead.ConfigStruct.OpthoStatusMode = DiagnosticLedState.State4;
            }
            return isOk;
            
        }

        /// <summary>
        /// stop data streaming by LED
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        public bool SetOptActiveMode(IperlHead iHead)
        {
            if (!serialDriver.IsOpen())
            {
                serialDriver.Open();
            }

            //Set LED to state 1
            var request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddDeviceCommand(ProtocolDeviceSubCommand.SetDiagnosticLEDState)
                .AddPayload(DiagnosticLedState.StateOFF)
                .BuildBytes();

            byte[] rawData = serialDriver.SendAndWait(request, 5000);
            if (rawData == null)
                return false;
            
            
            // parse rawData
            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);
            log.Debug("SetOptActiveMode isOK: " + decoded.IsOk);
            if (decoded.IsOk && iHead.ConfigStruct != null)
            {
                iHead.ConfigStruct.OpthoStatusMode = DiagnosticLedState.StateOFF;
            }
            return decoded.IsOk;
        }

        public string GetUnit(IperlHead iperlHead)
        {
            if (!serialDriver.IsOpen())
            {
                serialDriver.Open();
            }

            var request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.ViewFactoryId)
                .BuildBytes();
            
            
            byte[] rawData = serialDriver.SendAndWait(request, 10000);
            if (rawData == null)
                return null;
            
            // parse rawData
            var parser = new IperlHatFrameParser();
            IperlHatResponse decoded = parser.Parse(rawData);
            if (decoded.IsOk)
            {
                string asciiPayload = decoded.GetAsciiPayload();
                if (iperlHead.ConfigStruct != null) // store mechanism
                {
                    iperlHead.ConfigStruct.Unit = asciiPayload;
                }
                return asciiPayload;
            }
            
            return null;
        }
    }
}