ModBusDevice.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using TAG.Simulator.ModBus.Registers;
using TAG.Simulator.ObjectModel.Actors;
using Waher.Content.Xml;
 
namespace TAG.Simulator.ModBus.Actors
{
    public class ModBusDevice : ModBusActor
    {
        private readonly Dictionary<ushort, ModBusDevice> devicesPerAddress = new Dictionary<ushort, ModBusDevice>();
        private readonly Dictionary<ushort, ModBusRegister> registersByNr = new Dictionary<ushort, ModBusRegister>();
        private readonly object synchObj = new object();
        private byte startAddress;
        private byte instanceAddress;
 
        public ModBusDevice(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public ModBusDevice(ISimulationNode Parent, Model Model, int InstanceIndex, string InstanceId)
            : base(Parent, Model, InstanceIndex, InstanceId)
        {
        }
 
        public override string LocalName => nameof(ModBusDevice);
 
        public byte InstanceAddress => this.instanceAddress;
 
        public override ISimulationNode Create(ISimulationNode Parent, Model Model)
        {
            return new ModBusDevice(Parent, Model);
        }
 
        public override Task FromXml(XmlElement Definition)
        {
            this.startAddress = (byte)XML.Attribute(Definition, "startAddress", 0);
 
            return base.FromXml(Definition);
        }
 
        public override Task<Actor> CreateInstanceAsync(int InstanceIndex, string InstanceId)
        {
            return Task.FromResult<Actor>(new ModBusDevice(this, this.Model, InstanceIndex, InstanceId)
            {
                startAddress = this.startAddress,
                instanceAddress = (byte)(this.startAddress + InstanceIndex - 1)
            });
        }
 
        public override Task Start()
        {
            lock (this.synchObj)
            {
                this.devicesPerAddress.Clear();
                this.registersByNr.Clear();
 
                if (!(this.Instances is null))
                {
                    foreach (IActor Actor in this.Instances)
                    {
                        if (Actor is ModBusDevice Device)
                        {
                            if (this.devicesPerAddress.ContainsKey(Device.instanceAddress))
                                throw new Exception("Multiple devices with the same address: " + Device.instanceAddress.ToString());
 
                            this.devicesPerAddress[Device.instanceAddress] = Device;
                        }
                    }
                }
 
                if (!(this.Children is null))
                {
                    foreach (ISimulationNode Node in this.Children)
                    {
                        if (Node is ModBusRegister Register)
                        {
                            if (this.registersByNr.ContainsKey(Register.RegisterNr))
                                throw new Exception("Multiple registers with the same number: " + Register.RegisterNr.ToString());
 
                            this.registersByNr[Register.RegisterNr] = Register;
                        }
                    }
                }
            }
 
            return base.Start();
        }
 
        public override Task Finalize()
        {
            lock (this.synchObj)
            {
                this.devicesPerAddress.Clear();
                this.registersByNr.Clear();
            }
 
            return base.Finalize();
        }
 
        public override Task InitializeInstance()
        {
            return Task.CompletedTask;
        }
 
        public override Task StartInstance()
        {
            return Task.CompletedTask;
        }
 
        public override Task FinalizeInstance()
        {
            return Task.CompletedTask;
        }
 
        public ModBusDevice FindInstance(ushort Address)
        {
            lock (this.synchObj)
            {
                if (this.devicesPerAddress.TryGetValue(Address, out ModBusDevice Instance))
                    return Instance;
            }
 
            return null;
        }
 
        public ModBusRegister FindRegister(ushort RegisterNr)
        {
            lock (this.synchObj)
            {
                if (this.registersByNr.TryGetValue(RegisterNr, out ModBusRegister Register))
                    return Register;
            }
 
            return null;
        }
    }
}