tbf/TBFTests/Rig/RegisterReaders/iPerlASICReader/communication/C4/IperlHatProtocol/IperlHatIntegrationTests.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Ports;
using System.Text;
using log4net;
using log4net.Appender;
using log4net.Layout;
using log4net.Repository.Hierarchy;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.diagnosticLed;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.diagnosticLed.parserer;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.hexLogger;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.IperlHatProtocol;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.protocolCommons;


namespace TBFTests.Rig.RegisterReaders.iPerlASICReader.communication.C4.IperlHatProtocol
{
    [TestClass]
    public class IperlHatIntegrationTests
    {
        
        public static class LogConfig
        {
            public static void Configure()
            {
                var hierarchy = (Hierarchy)LogManager.GetRepository();
                hierarchy.Root.RemoveAllAppenders();

                var patternLayout = new PatternLayout
                {
                    ConversionPattern = "%date{yyyy-MM-dd HH:mm:ss.fff} [%thread] %-5level %logger - %message%newline"
                };
                patternLayout.ActivateOptions();

                var consoleAppender = new ConsoleAppender
                {
                    Layout = patternLayout
                };
                consoleAppender.ActivateOptions();

                hierarchy.Root.AddAppender(consoleAppender);
                hierarchy.Root.Level = log4net.Core.Level.Debug;
                hierarchy.Configured = true;
            }
        }
        ILog log = LogManager.GetLogger(typeof(IperlHatIntegrationTests)); 
        
        private const string ComPort = "COM3";   // CHANGE THIS
        private const int BaudRate = 2400;
        private const int BaudRateOpto = 38400;
        private const int ReadTimeoutMs = 2000;

        [TestMethod]
        [TestCategory("Hardware")]
        [TestCategory("Serial")]
        public void Serial_ViewFactoryId_ReadSerialNumber()
        {
            // -------- Arrange --------
            byte[] request = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.ViewFactoryId)
                .BuildBytes();

            var parser = new IperlHatFrameParser();

            using (var port = new SerialPort(ComPort, BaudRate, Parity.None, 8, StopBits.One))
            {
                port.Handshake = Handshake.None;
                port.ReadTimeout = 5000;
                port.Open();

                DateTime end = DateTime.Now.AddSeconds(10);
                
                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(request));
                port.Write(request, 0, request.Length);

                Console.WriteLine("Listening for 10 seconds...");
                byte[] response = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                IperlHatResponse iperlHatResponse = parser.Parse(response);
                
                Assert.IsTrue(iperlHatResponse.IsOk);
                Assert.IsFalse(iperlHatResponse.Payload.Length < 8);
                
                Console.WriteLine("\nDone.");
            }
        }
        
        
        
        [TestMethod]
        [TestCategory("Hardware")]
        [TestCategory("Serial")]
        public void Serial_SetStatus_Idle_Active()
        {
            
            byte[] requestStatus = new IperlHatFrameBuilder()
                .RequestResponse(true)
                .AddCommand(ProtocolCommand.ViewState)
                .BuildBytes();
            
            

            var parser = new IperlHatFrameParser();

            using (var port = new SerialPort(ComPort, BaudRate, Parity.None, 8, StopBits.One))
            {
                port.Handshake = Handshake.None;
                port.ReadTimeout = 5000;
                port.Open();

                
                DateTime end = DateTime.Now.AddSeconds(10);
                
                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(requestStatus));
                port.Write(requestStatus, 0, requestStatus.Length);

                Console.WriteLine("Listening for 10 seconds...");
                byte[] resStart = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        resStart = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(resStart));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                IperlHatResponse iperlHatResponseOld = parser.Parse(resStart);
                Assert.IsTrue(iperlHatResponseOld.IsOk, "Idle No set!");
                Console.WriteLine("We start with status: " + HexFormatter.ToHex(iperlHatResponseOld.Payload[0]));
                //----------------------------------------------------------------
                
                // -------- Arrange --------
                byte[] request = new IperlHatFrameBuilder()
                    .RequestResponse(true)
                    .AddCommand(ProtocolCommand.SetState)
                    .AddSubCommand(ProtocolStatuses.Idle)
                    .BuildBytes();
                
                // -- set idle
                end = DateTime.Now.AddSeconds(10);
                
                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(request));
                port.Write(request, 0, request.Length);

                Console.WriteLine("Listening for 10 seconds...");
                byte[] response = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                IperlHatResponse iperlHatResponse = parser.Parse(response);
                Assert.IsTrue(iperlHatResponse.IsOk, "Idle No set!");
                //----------------------------------------------------------------
                
                request = new IperlHatFrameBuilder()
                    .RequestResponse(true)
                    .AddCommand(ProtocolCommand.SetState)
                    .AddSubCommand(ProtocolStatuses.Active)
                    .BuildBytes();
                
                end = DateTime.Now.AddSeconds(10);
                
                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(request));
                port.Write(request, 0, request.Length);

                Console.WriteLine("Listening for 10 seconds...");
                response = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                iperlHatResponse = parser.Parse(response);
                Assert.IsTrue(iperlHatResponse.IsOk, "Idle No set!");
                //--------------------------------------------------------------------
                
                
                
                
                Console.WriteLine("\nDone.");
            }
        }
        
        
        [TestMethod]
        [TestCategory("Hardware")]
        public void Serial_RawSniff()
        {
            using (var port = new SerialPort(ComPort, BaudRate, Parity.None, 8, StopBits.One))
            {
                port.Handshake = Handshake.None;
                port.ReadTimeout = 5000;
                port.Open();
                
                DateTime end = DateTime.Now.AddSeconds(10);
                //welcome message
                byte[] frame = HexFormatter.HexStringToByteArray("53 57 3F 76 65 72 73 0D");
                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(frame));
                port.Write(frame, 0, frame.Length);
                
                Console.WriteLine("Listening for 10 seconds...");
                while (DateTime.Now < end)
                {
                    try
                    {
                        byte[] response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ",e);
                    }
                }


                end = DateTime.Now.AddSeconds(10);
                byte[] frameID = HexFormatter.HexStringToByteArray("53 57 05 01 0D");
                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(frameID));
                port.Write(frameID, 0, frameID.Length);
                
                Console.WriteLine("Listening for 10 seconds...");
                while (DateTime.Now < end)
                {
                    try
                    {
                        byte[] response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ",e);
                    }
                }

                Console.WriteLine("\nDone.");
            }
        }

        public static byte[] ReadResponse(SerialPort port)
        {
            var result = new List<byte>();

            try
            {
                while (true)
                {
                    int value = port.ReadByte();   // blocks until byte or timeout

                    if (value < 0)
                        throw new IOException("Serial port returned end of stream.");

                    byte b = HexFormatter.ToHexByte(value);
                    result.Add(b);

                    // stop when CR received
                    if (b == 0x0D)
                        break;
                }

                return result.ToArray();
            }
            catch (TimeoutException ex)
            {
                if (result.Count > 0)
                    return result.ToArray();
                
                throw new TimeoutException("Timeout reading response from serial port.", ex);
            }
        }


        [TestMethod]
        [TestCategory("Hardware")]
        public void OptoCommunicationON_ReadOpto_CommunicatonOFF()
        {
            //OPEN COMMUNICATION to Iperl Hat
            
            var parser = new IperlHatFrameParser();

            using (var port = new SerialPort(ComPort, BaudRate, Parity.None, 8, StopBits.One))
            {
                port.Handshake = Handshake.None;
                port.ReadTimeout = 5000;
                port.Open();
                
                //----------------------------------------------------------------
                //  ------ Set active mode ------
                //----------------------------------------------------------------
            
                byte[] requestStatus = new IperlHatFrameBuilder()
                    .RequestResponse(true)
                    .AddCommand(ProtocolCommand.SetState)
                    .AddSubCommand(ProtocolStatuses.Active)
                    .BuildBytes();
                
                DateTime end = DateTime.Now.AddSeconds(10);

                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(requestStatus));
                port.Write(requestStatus, 0, requestStatus.Length);

                Console.WriteLine("Set active mode - Listening for 10 seconds...");
                byte[] resStart = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        resStart = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(resStart));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                IperlHatResponse iperlHatResponseOld = parser.Parse(resStart);
                Assert.IsTrue(iperlHatResponseOld.IsOk, "Active No set!");
                //----------------------------------------------------------------
                //  ------ Enable Opto data ------
                //----------------------------------------------------------------

                // ----------- Arrange -----------
                byte[] request = new IperlHatFrameBuilder()
                    .RequestResponse(true)
                    .AddDeviceCommand(ProtocolDeviceSubCommand.SetDiagnosticLEDState)
                    .AddPayload(DiagnosticLedState.State4)
                    .BuildBytes();
                
                end = DateTime.Now.AddSeconds(10);
                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(request));
                port.Write(request, 0, request.Length);

                Console.WriteLine("Enable Opto data - Listening for 10 seconds...");
                byte[] response = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                IperlHatResponse iperlHatResponse = parser.Parse(response);
                Assert.IsTrue(iperlHatResponse.IsOk, "Opto data not set!");

                //----------------------------------------------------------------
                //  ------ Test Opto data ------
                //----------------------------------------------------------------
                //Now try test opto data
                Serial_OptoRawSniff();

                //----------------------------------------------------------------
                //  ------ Disable Opto data ------
                //----------------------------------------------------------------

                // ----------- Arrange -----------
                request = new IperlHatFrameBuilder()
                    .RequestResponse(true)
                    .AddDeviceCommand(ProtocolDeviceSubCommand.SetDiagnosticLEDState)
                    .AddPayload(DiagnosticLedState.StateOFF)
                    .BuildBytes();

                end = DateTime.Now.AddSeconds(10);

                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(request));
                port.Write(request, 0, request.Length);

                Console.WriteLine("Disable Opto data - Listening for 10 seconds...");
                response = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                iperlHatResponse = parser.Parse(response);
                Assert.IsTrue(iperlHatResponse.IsOk, "Disabled opto LED not set!");
                
                //----------------------------------------------------------------
                //  ------ Set Idle mode ------
                //----------------------------------------------------------------

                // ----------- Arrange -----------
                request = new IperlHatFrameBuilder()
                    .RequestResponse(true)
                    .AddCommand(ProtocolCommand.SetState)
                    .AddSubCommand(ProtocolStatuses.Idle)
                    .BuildBytes();

                end = DateTime.Now.AddSeconds(10);

                Console.WriteLine("TX → " + HexFormatter.ToSerialHexWithAscii(request));
                port.Write(request, 0, request.Length);

                Console.WriteLine("Set Idle mode - Listening for 10 seconds...");
                response = null;
                while (DateTime.Now < end)
                {
                    try
                    {
                        response = ReadResponse(port);
                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHexWithAscii(response));
                        break;
                    }
                    catch (TimeoutException e)
                    {
                        Assert.Fail("Timeout: ", e);
                    }
                }

                iperlHatResponse = parser.Parse(response);
                Assert.IsTrue(iperlHatResponse.IsOk, "Idle status not set!");
                
                //----------------------------------------------------------------
                //  ------ Test finished ------
                //----------------------------------------------------------------
                Console.WriteLine("\nDone.");

            }
            
        }

        /// <summary>
        /// This test work only if Opto data are active
        /// Use OptoCommunicationON_ReadOpto_CommunicatonOFF() test method
        /// </summary>
        [TestMethod]
        [TestCategory("Hardware")]
        public void Serial_OptoRawSniff_Standalone()
        {
            Serial_OptoRawSniff();
        }
        
        //method test connection to optho head
        private void Serial_OptoRawSniff()
        {
            using (var port = new SerialPort("COM15", BaudRateOpto, Parity.None, 8, StopBits.One))
            {
                port.Handshake = Handshake.None;
                port.ReadTimeout = 10000;

                // 🔑 CRLF handling
                port.NewLine = "\r\n";
                port.Encoding = Encoding.ASCII; // or UTF8 if needed

                port.Open();

                Console.WriteLine("Listening for 10 seconds...");
                DateTime end = DateTime.Now.AddSeconds(10);

                var parser = new DiagnosticLedParser(DiagnosticLedState.State4);
                
                while (DateTime.Now < end)
                {
                    try
                    {
                        string line = port.ReadLine(); // string
                        byte[] bytes = port.Encoding.GetBytes(line);

                        Console.WriteLine("RX ← " + HexFormatter.ToSerialHex(bytes));

                        try
                        {
                            var data = (DiagnosticLedState4Data)parser.ParseLine(line,false);
                            Console.WriteLine($"[{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}] Time: Parsed: {data}");
                            log.Info("Parsed: " + data);
                        }catch(Exception e)
                        {
                            Console.WriteLine("Failed to parse: " + e.Message);
                        }

                    }
                    catch (TimeoutException)
                    {
                        Assert.Fail("Serial read timeout");
                    }
                }

                Console.WriteLine("\nDone.");
            }
        }
        
    }
}