internal static ReadHoldingInputRegistersResponse ReadRegisters(ReadHoldingInputRegistersRequest request, ModbusDataCollection<ushort> dataSource)
        {
            RegisterCollection data = DataStore.ReadData<RegisterCollection, ushort>(dataSource, request.StartAddress, request.NumberOfPoints);
            ReadHoldingInputRegistersResponse response = new ReadHoldingInputRegistersResponse(request.FunctionCode, request.SlaveAddress, data);

            return response;
        }
        internal static ReadCoilsInputsResponse ReadDiscretes(ReadCoilsInputsRequest request, ModbusDataCollection<bool> dataSource)
        {
            DiscreteCollection data = DataStore.ReadData<DiscreteCollection, bool>(dataSource, request.StartAddress, request.NumberOfPoints);
            ReadCoilsInputsResponse response = new ReadCoilsInputsResponse(request.FunctionCode, request.SlaveAddress, data.ByteCount, data);

            return response;
        }
 public void WriteDataSingle()
 {
     ModbusDataCollection<bool> destination = new ModbusDataCollection<bool>(true, true);
     DiscreteCollection newValues = new DiscreteCollection(false);
     DataStore.WriteData(new DataStore(), newValues, destination, 0, new object());
     Assert.Equal(false, destination[1]);
 }
示例#4
0
		public void WriteDataMultiple()
		{
			ModbusDataCollection<bool> destination = new ModbusDataCollection<bool>(false, false, false, false, false, false, true);
			DiscreteCollection newValues = new DiscreteCollection(true, true, true, true);
			DataStore.WriteData(new DataStore(), newValues, destination, 0, new object());
			Assert.AreEqual(new bool[] { false, true, true, true, true, false, false, true }, destination.ToArray());
		}
        internal static WriteMultipleCoilsResponse WriteMultipleCoils(WriteMultipleCoilsRequest request, ModbusDataCollection<bool> dataSource)
        {
            DataStore.WriteData(request.Data, dataSource, request.StartAddress);
            WriteMultipleCoilsResponse response = new WriteMultipleCoilsResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);

            return response;
        }
 public void ReadData()
 {
     ModbusDataCollection<ushort> slaveCol = new ModbusDataCollection<ushort>(0, 1, 2, 3, 4, 5, 6);
     RegisterCollection result = DataStore.ReadData<RegisterCollection, ushort>(new DataStore(), slaveCol, 1, 3,
         new object());
     Assert.Equal(new ushort[] {1, 2, 3}, result.ToArray());
 }
示例#7
0
        internal static WriteSingleCoilRequestResponse WriteSingleCoil(WriteSingleCoilRequestResponse request,
            DataStore dataStore, ModbusDataCollection<bool> dataSource)
        {
            DataStore.WriteData(dataStore, new DiscreteCollection(request.Data[0] == Modbus.CoilOn), dataSource,
                request.StartAddress, dataStore.SyncRoot);

            return request;
        }
示例#8
0
        internal static WriteMultipleCoilsResponse WriteMultipleCoils(WriteMultipleCoilsRequest request,
            DataStore dataStore, ModbusDataCollection<bool> dataSource)
        {
            DataStore.WriteData(dataStore, request.Data.Take(request.NumberOfPoints), dataSource, request.StartAddress,
                dataStore.SyncRoot);
            var response = new WriteMultipleCoilsResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);

            return response;
        }
 public void SetZeroElementUsingItem()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, false);
     Assert.Throws<ArgumentOutOfRangeException>(() => col[0] = true);
 }
 public void RemoveAtZeroElement()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, false);
     col.RemoveAt(0);
 }
 public void InsertZeroElement()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, false);
     col.Insert(0, true);
 }
 public void Empty()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>();
     Assert.AreEqual(1, col.Count);
 }
 public void AddDefaultUshort()
 {
     ModbusDataCollection<ushort> col = new ModbusDataCollection<ushort>(1, 1);
     Assert.AreEqual(3, col.Count);
     Assert.AreEqual(new ushort[] {0, 1, 1}, col.ToArray());
 }
 public void WriteDataTooLarge()
 {
     ModbusDataCollection<bool> slaveCol = new ModbusDataCollection<bool>(true);
     DiscreteCollection newValues = new DiscreteCollection(false, false);
     Assert.Throws<InvalidModbusRequestException>(() => DataStore.WriteData(new DataStore(), newValues, slaveCol, 1, new object()));
 }
示例#15
0
        internal static WriteSingleRegisterRequestResponse WriteSingleRegister(WriteSingleRegisterRequestResponse request, DataStore dataStore, ModbusDataCollection <ushort> dataSource)
        {
            DataStore.WriteData(dataStore, request.Data, dataSource, request.StartAddress, dataStore.SyncRoot);

            return(request);
        }
示例#16
0
        internal static WriteMultipleCoilsResponse WriteMultipleCoils(WriteMultipleCoilsRequest request, DataStore dataStore, ModbusDataCollection <bool> dataSource)
        {
            DataStore.WriteData(dataStore, request.Data.Take(request.NumberOfPoints), dataSource, request.StartAddress, dataStore.SyncRoot);
            WriteMultipleCoilsResponse response = new WriteMultipleCoilsResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);

            return(response);
        }
示例#17
0
        internal static WriteSingleCoilRequestResponse WriteSingleCoil(WriteSingleCoilRequestResponse request, DataStore dataStore, ModbusDataCollection <bool> dataSource)
        {
            DataStore.WriteData(dataStore, new DiscreteCollection(request.Data[0] == Modbus.CoilOn), dataSource, request.StartAddress, dataStore.SyncRoot);

            return(request);
        }
示例#18
0
        internal static ReadHoldingInputRegistersResponse ReadRegisters(ReadHoldingInputRegistersRequest request, DataStore dataStore, ModbusDataCollection <ushort> dataSource)
        {
            RegisterCollection data = DataStore.ReadData <RegisterCollection, ushort>(dataStore, dataSource, request.StartAddress, request.NumberOfPoints, dataStore.SyncRoot);
            ReadHoldingInputRegistersResponse response = new ReadHoldingInputRegistersResponse(request.FunctionCode, request.SlaveAddress, data);

            return(response);
        }
 public void RemoveZeroElement()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>();
     Assert.Throws<ArgumentOutOfRangeException>(() => col.Remove(default(bool)));
 }
 public void RemoveAtZeroElement()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, false);
     Assert.Throws<ArgumentOutOfRangeException>(() => col.RemoveAt(0));
 }
 public void AddDefaultBool()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, true);
     Assert.AreEqual(3, col.Count);
     Assert.AreEqual(new bool[] {false, true, true}, col.ToArray());
 }
        internal static WriteMultipleRegistersResponse WriteMultipleRegisters(WriteMultipleRegistersRequest request, DataStore dataStore, ModbusDataCollection<ushort> dataSource)
        {
            DataStore.WriteData(dataStore, request.Data, dataSource, request.StartAddress, dataStore.SyncRoot);
            WriteMultipleRegistersResponse response = new WriteMultipleRegistersResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);

            return response;
        }
 public void Clear()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, false);
     col.Clear();
     Assert.AreEqual(1, col.Count);
 }
        internal static WriteSingleRegisterRequestResponse WriteSingleRegister(WriteSingleRegisterRequestResponse request, ModbusDataCollection<ushort> dataSource)
        {
            DataStore.WriteData(request.Data, dataSource, request.StartAddress);

            return request;
        }
 public void FromReadOnlyList()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(new bool[] {true, false});
     Assert.AreEqual(3, col.Count);
 }
 public void SetZeroElementUsingItem()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, false);
     col[0] = true;
 }
 public void ModbusDataCollection_FromParams()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>(true, false);
     Assert.AreEqual(3, col.Count);
 }
示例#28
0
        internal static WriteMultipleRegistersResponse WriteMultipleRegisters(WriteMultipleRegistersRequest request, ModbusDataCollection <ushort> dataSource)
        {
            DataStore.WriteData(request.Data, dataSource, request.StartAddress);
            WriteMultipleRegistersResponse response = new WriteMultipleRegistersResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);

            return(response);
        }
 public void RemoveZeroElement()
 {
     ModbusDataCollection<bool> col = new ModbusDataCollection<bool>();
     col.Remove(default(bool));
 }
示例#30
0
        internal static ReadCoilsInputsResponse ReadDiscretes(ReadCoilsInputsRequest request, DataStore dataStore, ModbusDataCollection <bool> dataSource)
        {
            DiscreteCollection      data     = DataStore.ReadData <DiscreteCollection, bool>(dataStore, dataSource, request.StartAddress, request.NumberOfPoints, dataStore.SyncRoot);
            ReadCoilsInputsResponse response = new ReadCoilsInputsResponse(request.FunctionCode, request.SlaveAddress, data.ByteCount, data);

            return(response);
        }
示例#31
0
 public void WriteDataTooLarge()
 {
     ModbusDataCollection<bool> slaveCol = new ModbusDataCollection<bool>(true);
     DiscreteCollection newValues = new DiscreteCollection(false, false);
     DataStore.WriteData(new DataStore(), newValues, slaveCol, 1, new object());
 }
示例#32
0
        public void setValue16(int groupindex, int offset, ushort value)
        {
            ModbusDataCollection <ushort> data = getRegisterGroup(groupindex);

            data[offset] = value;
        }