Adding alarm messages 1000, 1001

src/MIDTesters.Core/Alarm/TestMid1000.cs

@@ -0,0 +1,39 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OpenProtocolInterpreter.Alarm;
+
+namespace MIDTesters.Alarm
+{
+    [TestClass]
+    [TestCategory("Alarm")]
+    public class TestMid1000 : DefaultMidTests<Mid1000>
+    {
+        [TestMethod]
+        [TestCategory("Revision 1"), TestCategory("ASCII")]
+        public void Mid1000Revision1()
+        {
+            string pack = "00911000001         ABCDE2017-12-01:20:12:4500201700009040000000ALARMTEXT017010010100000001";
+            var mid = _midInterpreter.Parse<Mid1000>(pack);
+
+            Assert.IsNotNull(mid.AlarmCode);
+            Assert.IsNotNull(mid.Time);
+            Assert.IsNotNull(mid.AlarmDataFields);
+            Assert.AreEqual(2, mid.NumberOfDataFields);
+            AssertEqualPackages(pack, mid);
+        }
+
+        [TestMethod]
+        [TestCategory("Revision 1"), TestCategory("ByteArray")]
+        public void Mid1000ByteRevision1()
+        {
+            string pack = "00911000001         ABCDE2017-12-01:20:12:4500201700009040000000ALARMTEXT017010010100000001";
+            byte[] bytes = GetAsciiBytes(pack);
+            var mid = _midInterpreter.Parse<Mid1000>(bytes);
+
+            Assert.IsNotNull(mid.AlarmCode);
+            Assert.IsNotNull(mid.Time);
+            Assert.IsNotNull(mid.AlarmDataFields);
+            Assert.AreEqual(2, mid.NumberOfDataFields);
+            AssertEqualPackages(bytes, mid);
+        }
+    }
+}

src/MIDTesters.Core/Alarm/TestMid1001.cs

@@ -0,0 +1,33 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OpenProtocolInterpreter.Alarm;
+
+namespace MIDTesters.Alarm
+{
+    [TestClass]
+    [TestCategory("Alarm")]
+    public class TestMid1001 : DefaultMidTests<Mid1001>
+    {
+        [TestMethod]
+        [TestCategory("ASCII")]
+        public void Mid1001AllRevisions()
+        {
+            string pack = @"00201001            ";
+            var mid = _midInterpreter.Parse(pack);
+
+            Assert.AreEqual(typeof(Mid1001), mid.GetType());
+            AssertEqualPackages(pack, mid, true);
+        }
+
+        [TestMethod]
+        [TestCategory("ByteArray")]
+        public void Mid1001ByteAllRevisions()
+        {
+            string pack = @"00201001            ";
+            byte[] bytes = GetAsciiBytes(pack);
+            var mid = _midInterpreter.Parse(bytes);
+
+            Assert.AreEqual(typeof(Mid1001), mid.GetType());
+            AssertEqualPackages(bytes, mid, true);
+        }
+    }
+}

src/OpenProtocolInterpreter/Alarm/AlarmMessages.cs

@@ -22,6 +22,8 @@ public AlarmMessages() : base()
                { Mid0076.MID,  new MidCompiledInstance(typeof(Mid0076)) },
                { Mid0077.MID,  new MidCompiledInstance(typeof(Mid0077)) },
                { Mid0078.MID,  new MidCompiledInstance(typeof(Mid0078)) },
+               { Mid1000.MID,  new MidCompiledInstance(typeof(Mid1000)) },
+               { Mid1001.MID,  new MidCompiledInstance(typeof(Mid1001)) },
             };
         }
 
@@ -35,6 +37,6 @@ public AlarmMessages(InterpreterMode mode) : this()
             FilterSelectedMids(mode);
         }
 
-        public override bool IsAssignableTo(int mid) => mid > 69 && mid < 79;
+        public override bool IsAssignableTo(int mid) => mid > 69 && mid < 79 || mid > 999 && mid < 1002;
     }
 }

src/OpenProtocolInterpreter/Alarm/Mid1000.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenProtocolInterpreter.Alarm
+{
+    /// <summary>
+    /// Alarm
+    /// <para>An alarm has appeared in the controller. The current alarm is uploaded from the controller to the integrator.
+    /// This MID replace the old alarm MID 0071.</para>
+    /// <para>Message sent by: Controller</para>
+    /// <para>Answer: <see cref="Mid0071"/> Alarm status acknowledge</para>
+    /// </summary>
+    public class Mid1000 : Mid, IAlarm, IController, IAcknowledgeable<Mid1001>
+    {
+        public const int MID = 1000;
+
+        public string AlarmCode
+        {
+            get => GetField(1, DataFields.AlarmCode).Value;
+            set => GetField(1, DataFields.AlarmCode).SetValue(value);
+        }
+        public DateTime Time
+        {
+            get => GetField(1, DataFields.Time).GetValue(OpenProtocolConvert.ToDateTime);
+            set => GetField(1, DataFields.Time).SetValue(OpenProtocolConvert.ToString, value);
+        }
+        public int NumberOfDataFields => AlarmDataFields.Count;
+        public List<VariableDataField> AlarmDataFields { get; set; }
+
+        public Mid1000() : this(DEFAULT_REVISION)
+        {
+
+        }
+
+        public Mid1000(Header header) : base(header)
+        {
+            AlarmDataFields = [];
+        }
+
+        public Mid1000(int revision) : this(new Header()
+        {
+            Mid = MID,
+            Revision = revision
+        })
+        {
+
+        }
+
+        public override string Pack()
+        {
+            GetField(1, DataFields.NumberOfDataFields).SetValue(OpenProtocolConvert.ToString, AlarmDataFields.Count);
+            GetField(1, DataFields.EachAlarmDataField).Value = OpenProtocolConvert.ToString(AlarmDataFields);
+            return base.Pack();
+        }
+
+        public override Mid Parse(string package)
+        {
+            Header = ProcessHeader(package);
+            var dataFieldsField = GetField(1, DataFields.EachAlarmDataField);
+            dataFieldsField.Size = Header.Length - dataFieldsField.Index;
+            ProcessDataFields(package);
+            AlarmDataFields = VariableDataField.ParseAll(dataFieldsField.Value).ToList();
+            return this;
+        }
+
+        protected override Dictionary<int, List<DataField>> RegisterDatafields()
+        {
+            return new Dictionary<int, List<DataField>>()
+            {
+                {
+                    1, new List<DataField>()
+                            {
+                                DataField.String(DataFields.AlarmCode, 20, 5, PaddingOrientation.RightPadded, false),
+                                DataField.Timestamp(DataFields.Time, 25, false),
+                                DataField.Number(DataFields.NumberOfDataFields, 44, 3, false),
+                                DataField.Volatile(DataFields.EachAlarmDataField, 47, false)
+                            }
+                }
+            };
+        }
+
+        protected enum DataFields
+        {
+            AlarmCode,
+            Time,
+            NumberOfDataFields,
+            EachAlarmDataField
+        }
+    }
+}

src/OpenProtocolInterpreter/Alarm/Mid1001.cs

@@ -0,0 +1,23 @@
+namespace OpenProtocolInterpreter.Alarm
+{
+    /// <summary>
+    /// Alarm status acknowledge
+    /// <para>Acknowledge for  <see cref="Mid1000"/> Alarm</para>
+    /// <para>Message sent by: Integrator</para>
+    /// <para>Answer : None</para>
+    /// </summary>
+    public class Mid1001 : Mid, IAlarm, IIntegrator, IAcknowledge
+    {
+        public const int MID = 1001;
+
+        public Mid1001() : base(MID, DEFAULT_REVISION)
+        {
+
+        }
+
+        public Mid1001(Header header) : base(header)
+        {
+
+        }
+    }
+}