internal static bool[] ExtractValues(ReadHoldingCoilsRequest request, RTUResponse response)
        {
            if (response.Data.Length < 1)
            {
                throw new RTUException("The Response Data Length was too short to extract the Byte Count");
            }

            int expectedByteCount = request.Length > 0 ? request.Length / 8 : 0;

            if (request.Length % 8 != 0)
            {
                expectedByteCount += 1;
            }

            if (response.Data[0] != expectedByteCount)
            {
                throw new RTUException("The Response Byte Count '" + response.Data[0].ToString() + "' did not match the Expected Byte Count '" + expectedByteCount.ToString() + "'");
            }

            if (response.Data.Length < expectedByteCount + 1)
            {
                throw new RTUException("The Response Data Length of '" + response.Data.Length.ToString() + "' was too short - Expecting a Length of '" + (expectedByteCount + 1).ToString() + "'");
            }

            if (request.Length == 0)
            {
                return(new bool[0]);
            }

            BitArray bitArray = new BitArray(response.Data.Skip(1).ToArray());

            bool[] values = new bool[request.Length];

            for (int i = 0; i < values.Length; i++)
            {
                values[i] = bitArray.Get(i);
            }

            return(values);
        }
Ejemplo n.º 2
0
        public async Task <ReadCoilsResult> ReadHoldingCoilsAsync(ushort startAddress, ushort length, CancellationToken cancellationToken)
        {
            lock (_isInitializedLock)
            {
                if (_isInitialized == false)
                {
                    throw new ModbusException("This Modbus RTU Device must be Initialized first before any Requests can be Processed");
                }
            }

            if (startAddress > MaximumAddress)
            {
                throw new ArgumentOutOfRangeException(nameof(startAddress), "The Start Address is greater than the Maximum Allowed Value of '" + MaximumAddress + "'");
            }

            if (length == 0)
            {
                throw new ArgumentOutOfRangeException(nameof(length), "The Length cannot be Zero");
            }

            if (length > MaximumCoilsReadLength)
            {
                throw new ArgumentOutOfRangeException(nameof(length), "The Length is greater than the Maximum Allowed Value of '" + MaximumCoilsReadLength + "'");
            }

            ReadHoldingCoilsRequest request = ReadHoldingCoilsRequest.CreateNew(this, startAddress, length);

            ProcessRequestResult requestResult = await _channel.ProcessRequestAsync(request, _timeout, _retries, _delayBetweenMessages, cancellationToken);

            return(new ReadCoilsResult
            {
                BytesSent = requestResult.BytesSent,
                PacketsSent = requestResult.PacketsSent,
                BytesReceived = requestResult.BytesReceived,
                PacketsReceived = requestResult.PacketsReceived,
                Duration = requestResult.Duration,
                Values = ReadHoldingCoilsResponse.ExtractValues(request, requestResult.Response),
            });
        }