InMemoryPlcMemory.cs

이 파일의 문서화 페이지로 가기

using Dreamine.PLC.Abstractions.Devices;
using Dreamine.PLC.Abstractions.Results;
 
namespace Dreamine.PLC.Core.Memory;

public sealed class InMemoryPlcMemory
{
    private readonly object _syncRoot = new();
    private readonly Dictionary<PlcDeviceType, Dictionary<int, short>> _words = new();
    private readonly Dictionary<PlcDeviceType, Dictionary<int, bool>> _bits = new();

    public PlcResult<bool[]> ReadBits(PlcAddress address, int count)
    {
        if (count <= 0)
        {
            return PlcResult<bool[]>.Failure("The read count must be greater than zero.");
        }
 
        lock (_syncRoot)
        {
            var values = new bool[count];
            var area = GetOrCreateBitArea(address.DeviceType);
 
            for (var i = 0; i < count; i++)
            {
                var offset = address.Offset + i;
                values[i] = area.TryGetValue(offset, out var value) && value;
            }
 
            return PlcResult<bool[]>.Success(values);
        }
    }

    public PlcResult<short[]> ReadWords(PlcAddress address, int count)
    {
        if (count <= 0)
        {
            return PlcResult<short[]>.Failure("The read count must be greater than zero.");
        }
 
        lock (_syncRoot)
        {
            var values = new short[count];
            var area = GetOrCreateWordArea(address.DeviceType);
 
            for (var i = 0; i < count; i++)
            {
                var offset = address.Offset + i;
                values[i] = area.TryGetValue(offset, out var value) ? value : default;
            }
 
            return PlcResult<short[]>.Success(values);
        }
    }

    public PlcResult WriteBits(PlcAddress address, IReadOnlyList<bool> values)
    {
        if (values.Count == 0)
        {
            return PlcResult.Failure("The bit value collection must not be empty.");
        }
 
        lock (_syncRoot)
        {
            var area = GetOrCreateBitArea(address.DeviceType);
 
            for (var i = 0; i < values.Count; i++)
            {
                var offset = address.Offset + i;
                area[offset] = values[i];
            }
 
            return PlcResult.Success();
        }
    }

    public PlcResult WriteWords(PlcAddress address, IReadOnlyList<short> values)
    {
        if (values.Count == 0)
        {
            return PlcResult.Failure("The word value collection must not be empty.");
        }
 
        lock (_syncRoot)
        {
            var area = GetOrCreateWordArea(address.DeviceType);
 
            for (var i = 0; i < values.Count; i++)
            {
                var offset = address.Offset + i;
                area[offset] = values[i];
            }
 
            return PlcResult.Success();
        }
    }

    public void Clear()
    {
        lock (_syncRoot)
        {
            _bits.Clear();
            _words.Clear();
        }
    }

    private Dictionary<int, short> GetOrCreateWordArea(PlcDeviceType deviceType)
    {
        if (!_words.TryGetValue(deviceType, out var area))
        {
            area = new Dictionary<int, short>();
            _words[deviceType] = area;
        }
 
        return area;
    }

    private Dictionary<int, bool> GetOrCreateBitArea(PlcDeviceType deviceType)
    {
        if (!_bits.TryGetValue(deviceType, out var area))
        {
            area = new Dictionary<int, bool>();
            _bits[deviceType] = area;
        }
 
        return area;
    }
}