tbf/TBFTests/Rig/RegisterReaders/iPerlASICReader/communication/C4/diagnosticLed/DiagnosticLedParserTest.cs

using JetBrains.Annotations;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.diagnosticLed;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.diagnosticLed.parserer;


namespace TBFTests.Rig.RegisterReaders.iPerlASICReader.communication.C4.diagnosticLed
{
    [TestClass]
    [TestSubject(typeof(DiagnosticLedParser))]
    public class DiagnosticLedParserTest
    {
        private static string WithChecksum(string bodyWithoutChecksum)
        {
            byte sum = 0;
            foreach (char c in bodyWithoutChecksum)
                sum += (byte)c;

            return bodyWithoutChecksum + sum.ToString("X2") + "\r\n";
        }

        [TestMethod]
        public void Parse_DiagnosticLed_State1()
        {
            string body =
                "FFFF9C\t" +   // signed 24-bit ADC = -100
                "2020\t" +     // field strength
                "FFFA\t" +     // raw flow (-6)
                "0050FC\t" +   // raw volume
                "0054\t";      // capacitor mV

            string line = WithChecksum(body);

            var parser = new DiagnosticLedParser(DiagnosticLedState.State1);
            var data = (DiagnosticLedState1Data)parser.ParseLine(line);

            Assert.AreEqual(-100, data.Adc24);
            Assert.AreEqual((ushort)0x2020, data.FieldStrength);
            Assert.AreEqual((short)-6, data.RawFlow);
            Assert.AreEqual((uint)0x0050FC, data.RawVolume);
            Assert.AreEqual((ushort)0x0054, data.CapacitorMv);
        }

        
        [TestMethod]
        public void Parse_DiagnosticLed_State2()
        {
            string line =
                "00004F\t029A\t0000\tFFD3B1\t005C\t3B9AC9B1\t02\t01\t0D\r\n";

            var parser = new DiagnosticLedParser(DiagnosticLedState.State2);
            var data = (DiagnosticLedState2Data)parser.ParseLine(line);

            Assert.AreEqual(79, data.Adc24);
            Assert.AreEqual((ushort)666, data.FieldStrength);
            Assert.AreEqual((short)0, data.RawFlow);
            Assert.AreEqual(0xFFD3B1u, data.RawVolume);
            Assert.AreEqual((ushort)92, data.CapacitorMv);
            Assert.AreEqual(0x3B9AC9B1u, data.LcdVolume);
            Assert.AreEqual((byte)0x02, data.MeterState);
            Assert.IsTrue(data.IsLowFlowCutoff);
        }


        [TestMethod]
        public void Parse_DiagnosticLed_State3()
        {
            string body =
                "FFCC09\t2020\tFFFA\t0050FC\t0054\t0B01\t048000\tA7\t";

            string line = WithChecksum(body);

            var parser = new DiagnosticLedParser(DiagnosticLedState.State3);
            var data = (DiagnosticLedState3Data)parser.ParseLine(line);

            Assert.AreEqual(-13303, data.Adc24);
            Assert.AreEqual((ushort)0x2020, data.FieldStrength);
            Assert.AreEqual((short)-6, data.RawFlow);
            Assert.AreEqual((uint)0x0050FC, data.RawVolume);
            Assert.AreEqual((ushort)0x0054, data.CapacitorMv);
            Assert.AreEqual((ushort)0x0B01, data.FieldCalibration);
            Assert.AreEqual((uint)0x048000, data.AsicTimestamp);
            Assert.AreEqual((byte)0xA7, data.FieldDriveTimeUs);
        }

        
        [TestMethod]
        public void Parse_DiagnosticLed_State4()
        {
            string body =
                "000ABC\t2020\tFFFA\t0050FC\t0054\t0B01\t048000\tA7\t" +
                "00001234\t00F0\t00F1\t0100\t0200\t03\t";

            string line = WithChecksum(body);

            var parser = new DiagnosticLedParser(DiagnosticLedState.State4);
            var data = (DiagnosticLedState4Data)parser.ParseLine(line);

            Assert.AreEqual(2748, data.Adc24);
            Assert.AreEqual((ushort)0x2020, data.FieldStrength);
            Assert.AreEqual((short)-6, data.RawFlow);
            Assert.AreEqual((uint)0x0050FC, data.RawVolume);
            Assert.AreEqual((ushort)0x0054, data.CapacitorMv);

            Assert.AreEqual((ushort)0x0B01, data.FieldCalibration);
            Assert.AreEqual((uint)0x048000, data.AsicTimestamp);
            Assert.AreEqual((byte)0xA7, data.FieldDriveTimeUs);

            Assert.AreEqual(0x00001234, data.MeanFlowRate);
            Assert.AreEqual((ushort)0x00F0, data.Field1Measurement);
            Assert.AreEqual((ushort)0x00F1, data.Field2Measurement);
            Assert.AreEqual((ushort)0x0100, data.IntegratorCalibrationPositive);
            Assert.AreEqual((ushort)0x0200, data.IntegratorCalibrationNegative);
            Assert.AreEqual((byte)0x03, data.AsicState);
        }

        [TestMethod]
        public void Parse_DiagnosticLed_State5()
        {
            string body =
                "FFCC09\t2020\tFFFA\t0050FC\t0054\t0B01\t048000\tA7\t" +
                "00001234\t00F0\t00F1\t0100\t0200\t03\tFFEC\t";

            string line = WithChecksum(body);

            var parser = new DiagnosticLedParser(DiagnosticLedState.State5);
            var data = (DiagnosticLedState5Data)parser.ParseLine(line);

            Assert.AreEqual((short)-20, data.WaterImpedance);
            Assert.AreEqual((byte)0x03, data.AsicState);
        }

        [TestMethod]
        public void Parse_DiagnosticLed_State6()
        {
            string body =
                "FFCC09\t2020\tFFFA\t0050FC\t0054\t0B01\t048000\tA7\t" +
                "00001234\t00F0\t00F1\t0100\t0200\t03\tFFEC\t0010\t" +
                "02\t" +          // pp spike detection
                "02\t" +          // ll pipe status
                "00000099\t" +    // LCD volume
                "01\t";           // ASIC state1


            string line = WithChecksum(body);

            var parser = new DiagnosticLedParser(DiagnosticLedState.State6);
            var data = (DiagnosticLedState6Data)parser.ParseLine(line);

            Assert.AreEqual((short)-20, data.WaterImpedance);
            Assert.AreEqual((short)0x0010, data.ElectrodeDeltaMv);
            Assert.AreEqual((byte)0x02, data.SpikeDetection);
            Assert.AreEqual((byte)0x02, data.PipeStatus);
            Assert.AreEqual((uint)0x99, data.LcdVolume);
            Assert.AreEqual((byte)0x01, data.AsicState1);
        }

        [TestMethod]
        public void Parse_DiagnosticLed_State7()
        {
            string body =
                "FFCC09\t2020\tFFFA\t0050FC\t0054\t0B01\t048000\tA7\t" +
                "00001234\t00F0\t00F1\t0100\t0200\t03\tFFEC\t0010\t" +
                "02\t" +          // pp spike detection
                "02\t" +          // ll pipe status
                "00000099\t" +    // LCD volume
                "01\t" +          // ASIC state1
                "FFAA10\t" +      // raw ADC before offset
                "000123\t" +      // detrended ADC
                "FFEE\t" +        // imaginary water impedance
                "0011\t" +        // electrode voltage noise
                "03\t";           // ADC offset learning status

            string line = WithChecksum(body);

            var parser = new DiagnosticLedParser(DiagnosticLedState.State7);
            var data = (DiagnosticLedState7Data)parser.ParseLine(line);

            Assert.AreEqual(-22000, data.RawAdcBeforeOffset);
            Assert.AreEqual(0x000123, data.DetrendedAdc);
            Assert.AreEqual((short)-18, data.ImaginaryWaterImpedance);
            Assert.AreEqual((ushort)0x0011, data.ElectrodeVoltageNoise);
            Assert.AreEqual((byte)0x03, data.AdcOffsetLearningStatus);
        }

        
        
        
    }
}