public void RegisterCollectionEmpty()
{
RegisterCollection col = new RegisterCollection();
Assert.IsNotNull(col);
Assert.AreEqual(0, col.NetworkBytes.Length);
}
public void AddRegister()
{
RegisterCollection col = new RegisterCollection();
Assert.AreEqual(0, col.Count);
col.Add(45);
Assert.AreEqual(1, col.Count);
}
public void NewRegisterCollection()
{
var col = new RegisterCollection(5, 3, 4, 6);
Assert.NotNull(col);
Assert.Equal(4, col.Count);
Assert.Equal(5, col[0]);
}
private void AddRegister(ParserParagraph aPara, ParserField aField, ParserFieldName aFieldName, uint aValue)
{
RegisterCollection.TType type = (RegisterCollection.TType)aPara.Tag;
string regName = aFieldName.Name;
// USR registers are a bit tricky since they are largely shared. Only R13 and R14 are
// really USR specific.
if (type == RegisterCollection.TType.ETypeUser)
{
ArmRegister reg = new ArmRegister(regName, aValue);
//
switch (reg.RegType)
{
default:
type = RegisterCollection.TType.ETypeCommonBank;
break;
case TArmRegisterType.EArmReg_SP:
case TArmRegisterType.EArmReg_LR:
break;
}
}
RegisterCollection regCollection = iInfo[type];
regCollection.Add(regName, aValue);
}
public void ToString_WriteMultipleRegistersRequest()
{
RegisterCollection col = new RegisterCollection(10, 20, 30, 40, 50);
WriteMultipleRegistersRequest request = new WriteMultipleRegistersRequest(11, 34, col);
Assert.AreEqual("Write 5 holding registers starting at address 34.", request.ToString());
}
public void ProtocolDataUnit()
{
RegisterCollection data = new RegisterCollection(1, 2, 3, 4);
DiagnosticsRequestResponse request = new DiagnosticsRequestResponse(Modbus.DiagnosticsReturnQueryData, 5,
data);
Assert.Equal(new byte[] {8, 0, 0, 0, 1, 0, 2, 0, 3, 0, 4}, request.ProtocolDataUnit);
}
public void NewRegisterCollection()
{
RegisterCollection col = new RegisterCollection(5, 3, 4, 6);
Assert.IsNotNull(col);
Assert.AreEqual(4, col.Count);
Assert.AreEqual(5, col[0]);
}
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.AreEqual(new ushort[] { 1, 2, 3 }, result.ToArray());
}
public void ProtocolDataUnit()
{
RegisterCollection data = new RegisterCollection(1, 2, 3, 4);
DiagnosticsRequestResponse request = new DiagnosticsRequestResponse(Modbus.DiagnosticsReturnQueryData, 5, data);
Assert.AreEqual(new byte[] { 8, 0, 0, 0, 1, 0, 2, 0, 3, 0, 4 }, request.ProtocolDataUnit);
}
public void RemoveRegister()
{
var col = new RegisterCollection(3, 4, 5);
Assert.Equal(3, col.Count);
col.RemoveAt(2);
Assert.Equal(2, col.Count);
}
public void ToString_WriteMultipleRegistersRequest()
{
RegisterCollection col = new RegisterCollection(10, 20, 30, 40, 50);
WriteMultipleRegistersRequest request = new WriteMultipleRegistersRequest(11, 34, col);
Assert.Equal("Write 5 holding registers starting at address 34.", request.ToString());
}
public void ToString_ReadWriteMultipleRegistersRequest()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
Assert.AreEqual("Write 3 holding registers starting at address 14, and read 6 registers starting at address 3.", request.ToString());
}
public void ToString_ReadWriteMultipleRegistersRequest()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
Assert.AreEqual("Write 3 holding registers starting at address 14, and read 6 registers starting at address 3.", request.ToString());
}
public void ProtocolDataUnit()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
byte[] pdu = { 0x17, 0x00, 0x03, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x03, 0x06, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff };
Assert.AreEqual(pdu, request.ProtocolDataUnit);
}
public void CreateDefaultCollection()
{
RegisterCollection col = MessageUtility.CreateDefaultCollection <RegisterCollection, ushort>(3, 5);
Assert.Equal(5, col.Count);
Assert.Equal(new ushort[] { 3, 3, 3, 3, 3 }, col.ToArray());
}
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 AddRegister()
{
var col = new RegisterCollection();
Assert.Equal(0, col.Count);
col.Add(45);
Assert.Equal(1, col.Count);
}
public void RemoveRegister()
{
RegisterCollection col = new RegisterCollection(3, 4, 5);
Assert.AreEqual(3, col.Count);
col.RemoveAt(2);
Assert.AreEqual(2, col.Count);
}
public void ProtocolDataUnit()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
byte[] pdu = { 0x17, 0x00, 0x03, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x03, 0x06, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff };
Assert.AreEqual(pdu, request.ProtocolDataUnit);
}
/// <summary>
///
/// </summary>
/// <param name="slaveAddress"></param>
/// <param name="startReadAddress"></param>
/// <param name="numberOfPointsToRead"></param>
/// <param name="startWriteAddress"></param>
/// <param name="writeData"></param>
public ReadWriteMultipleRegistersRequest(byte slaveAddress, ushort startReadAddress, ushort numberOfPointsToRead,
ushort startWriteAddress, RegisterCollection writeData)
: base(slaveAddress, Modbus.ReadWriteMultipleRegisters)
{
_readRequest = new ReadHoldingInputRegistersRequest(Modbus.ReadHoldingRegisters, slaveAddress,
startReadAddress, numberOfPointsToRead);
_writeRequest = new WriteMultipleRegistersRequest(slaveAddress, startWriteAddress, writeData);
}
public void CreateModbusMessageReadWriteMultipleRegistersRequest()
{
ReadWriteMultipleRegistersRequest request = ModbusMessageFactory.CreateModbusMessage <ReadWriteMultipleRegistersRequest>(new byte[] { 0x05, 0x17, 0x00, 0x03, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x03, 0x06, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff });
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest expectedRequest = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
}
/// <summary>
///
/// </summary>
/// <param name="slaveAddress"></param>
/// <param name="startReadAddress"></param>
/// <param name="numberOfPointsToRead"></param>
/// <param name="startWriteAddress"></param>
/// <param name="writeData"></param>
public ReadWriteMultipleRegistersRequest(byte slaveAddress, ushort startReadAddress, ushort numberOfPointsToRead,
ushort startWriteAddress, RegisterCollection writeData)
: base(slaveAddress, Modbus.ReportSlaveId)
{
_readRequest = new ReadHoldingInputRegistersRequest(Modbus.ReadHoldingRegisters, slaveAddress,
startReadAddress, numberOfPointsToRead);
_writeRequest = new WriteMultipleRegistersRequest(slaveAddress, startWriteAddress, writeData);
}
public CustomWriteMultipleRegistersRequest(byte slaveAddress, ushort startAddress, RegisterCollection data)
{
SlaveAddress = slaveAddress;
StartAddress = startAddress;
NumberOfPoints = (ushort)data.Count;
ByteCount = data.ByteCount;
Data = data;
}
public void RegisterCollectionNetworkBytes()
{
var col = new RegisterCollection(5, 3, 4, 6);
byte[] bytes = col.NetworkBytes;
Assert.NotNull(bytes);
Assert.Equal(8, bytes.Length);
Assert.Equal(new byte[] { 0, 5, 0, 3, 0, 4, 0, 6 }, bytes);
}
protected override IModbusMessage Handle(ReadHoldingInputRegistersRequest request, ISlaveDataStore dataStore)
{
ushort[] registers = dataStore.InputRegisters.ReadPoints(request.StartAddress, request.NumberOfPoints);
RegisterCollection regsiterCollection = new RegisterCollection(registers);
return(new ReadHoldingInputRegistersResponse(request.FunctionCode, request.SlaveAddress, regsiterCollection));
}
public CustomWriteMultipleRegistersRequest(byte slaveAddress, ushort startAddress, RegisterCollection data)
{
SlaveAddress = slaveAddress;
StartAddress = startAddress;
NumberOfPoints = (ushort) data.Count;
ByteCount = data.ByteCount;
Data = data;
}
public void NewRegisterCollection()
{
RegisterCollection col = new RegisterCollection(5, 3, 4, 6);
Assert.IsNotNull(col);
Assert.AreEqual(4, col.Count);
Assert.AreEqual(5, col[0]);
}
public void RegisterCollectionNetworkBytes()
{
RegisterCollection col = new RegisterCollection(5, 3, 4, 6);
byte[] bytes = col.NetworkBytes;
Assert.IsNotNull(bytes);
Assert.AreEqual(8, bytes.Length);
Assert.AreEqual(new byte[] { 0, 5, 0, 3, 0, 4, 0, 6 }, bytes);
}
public void NewRegisterCollectionFromBytes()
{
var col = new RegisterCollection(new byte[] { 0, 1, 0, 2, 0, 3 });
Assert.NotNull(col);
Assert.Equal(3, col.Count);
Assert.Equal(1, col[0]);
Assert.Equal(2, col[1]);
Assert.Equal(3, col[2]);
}
public static void PushRegisters(this Stack s, RegisterCollection r)
{
for (int i = 0; i < r.Register.Length; i++)
{
Register register = r.Register[i];
s.Push(register.value);
}
}
public void ReadInputRegistersResponse()
{
ReadHoldingInputRegistersResponse response = new ReadHoldingInputRegistersResponse(Modbus.ReadInputRegisters, 5, new RegisterCollection(1, 2));
Assert.AreEqual(Modbus.ReadInputRegisters, response.FunctionCode);
Assert.AreEqual(5, response.SlaveAddress);
Assert.AreEqual(4, response.ByteCount);
RegisterCollection col = new RegisterCollection(1, 2);
Assert.AreEqual(col.NetworkBytes, response.Data.NetworkBytes);
}
public CustomWriteMultipleRegistersRequest(byte functionCode, byte slaveAddress, ushort startAddress, RegisterCollection data)
{
_functionCode = functionCode;
_slaveAddress = slaveAddress;
_startAddress = startAddress;
_numberOfPoints = (ushort)data.Count;
_byteCount = data.ByteCount;
_data = data;
}
private void TryToUpdateRegister(ArmRegister aObjectToUpdate, RegisterCollection aSource)
{
RegisterEntry entry = aSource[aObjectToUpdate.RegType];
if (entry != null)
{
aObjectToUpdate.Value = entry.Value;
}
}
public void NewRegisterCollectionFromBytes()
{
RegisterCollection col = new RegisterCollection(new byte[] { 0, 1, 0, 2, 0, 3 });
Assert.IsNotNull(col);
Assert.AreEqual(3, col.Count);
Assert.AreEqual(1, col[0]);
Assert.AreEqual(2, col[1]);
Assert.AreEqual(3, col[2]);
}
public CustomWriteMultipleRegistersRequest(byte functionCode, byte slaveAddress, ushort startAddress, RegisterCollection data)
{
_functionCode = functionCode;
_slaveAddress = slaveAddress;
_startAddress = startAddress;
_numberOfPoints = (ushort) data.Count;
_byteCount = data.ByteCount;
_data = data;
}
public void ReturnQueryDataRequestResponse()
{
RegisterCollection data = new RegisterCollection(1, 2, 3, 4);
DiagnosticsRequestResponse request = new DiagnosticsRequestResponse(Modbus.DiagnosticsReturnQueryData, 5, data);
Assert.AreEqual(Modbus.Diagnostics, request.FunctionCode);
Assert.AreEqual(Modbus.DiagnosticsReturnQueryData, request.SubFunctionCode);
Assert.AreEqual(5, request.SlaveAddress);
Assert.AreEqual(data.NetworkBytes, request.Data.NetworkBytes);
}
public void CreateWriteMultipleRegistersRequestFixture()
{
RegisterCollection col = new RegisterCollection(10, 20, 30, 40, 50);
WriteMultipleRegistersRequest request = new WriteMultipleRegistersRequest(11, 34, col);
Assert.Equal(Modbus.WriteMultipleRegisters, request.FunctionCode);
Assert.Equal(11, request.SlaveAddress);
Assert.Equal(34, request.StartAddress);
Assert.Equal(10, request.ByteCount);
Assert.Equal(col.NetworkBytes, request.Data.NetworkBytes);
}
public void ReturnQueryDataRequestResponse()
{
RegisterCollection data = new RegisterCollection(1, 2, 3, 4);
DiagnosticsRequestResponse request = new DiagnosticsRequestResponse(Modbus.DiagnosticsReturnQueryData, 5, data);
Assert.AreEqual(Modbus.Diagnostics, request.FunctionCode);
Assert.AreEqual(Modbus.DiagnosticsReturnQueryData, request.SubFunctionCode);
Assert.AreEqual(5, request.SlaveAddress);
Assert.AreEqual(data.NetworkBytes, request.Data.NetworkBytes);
}
public Response6(byte[] frame) : base(frame)
{
if (frame.Length < MinimumFrameSize)
{
string msg = $"Message frame must contain at least {MinimumFrameSize} bytes of data.";
throw new FormatException(msg);
}
StartAddress = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(frame, 2));
Data = new RegisterCollection(frame.Skip(MinimumFrameSize).Take(2).ToArray());
}
public void CreateWriteMultipleRegistersRequestFixture()
{
RegisterCollection col = new RegisterCollection(10, 20, 30, 40, 50);
WriteMultipleRegistersRequest request = new WriteMultipleRegistersRequest(11, 34, col);
Assert.AreEqual(Modbus.WriteMultipleRegisters, request.FunctionCode);
Assert.AreEqual(11, request.SlaveAddress);
Assert.AreEqual(34, request.StartAddress);
Assert.AreEqual(10, request.ByteCount);
Assert.AreEqual(col.NetworkBytes, request.Data.NetworkBytes);
}
public void ReadInputRegistersResponse()
{
ReadHoldingInputRegistersResponse response = new ReadHoldingInputRegistersResponse(Modbus.ReadInputRegisters, 5, new RegisterCollection(1, 2));
Assert.AreEqual(Modbus.ReadInputRegisters, response.FunctionCode);
Assert.AreEqual(5, response.SlaveAddress);
Assert.AreEqual(4, response.ByteCount);
RegisterCollection col = new RegisterCollection(1, 2);
Assert.AreEqual(col.NetworkBytes, response.Data.NetworkBytes);
}
public void Initialize(byte[] frame)
{
if (frame == null)
throw new ArgumentNullException("frame");
if (frame.Length < 3 || frame.Length < 3 + frame[2])
throw new ArgumentException("Message frame does not contain enough bytes.", "frame");
SlaveAddress = frame[0];
FunctionCode = frame[1];
ByteCount = frame[2];
_data = new RegisterCollection(frame.Slice(3, ByteCount).ToArray());
}
public void CreateModbusMessageReturnQueryDataRequestResponse()
{
byte slaveAddress = 5;
RegisterCollection data = new RegisterCollection(50);
byte[] frame = SequenceUtility.ToSequence <byte>(slaveAddress, 8, 0, 0).Concat(data.NetworkBytes).ToArray();
DiagnosticsRequestResponse message = ModbusMessageFactory.CreateModbusMessage <DiagnosticsRequestResponse>(frame);
DiagnosticsRequestResponse expectedMessage = new DiagnosticsRequestResponse(Modbus.DiagnosticsReturnQueryData, slaveAddress, data);
Assert.AreEqual(expectedMessage.SubFunctionCode, message.SubFunctionCode);
AssertModbusMessagePropertiesAreEqual(expectedMessage, message);
}
private RegisterCollection GetUserContextRegisters()
{
bool isCurrent = IsCurrent;
RegisterCollection ret = new RegisterCollection(Registers, RegisterCollection.TType.ETypeUser, iParentThread.OwningProcess);
// User-land CPSR is stored in SPSR_SVC
RegisterEntry spsr = Registers[TArmRegisterType.EArmReg_SPSR];
ret[TArmRegisterType.EArmReg_CPSR].Value = spsr.Value;
// Get the context table that we'll need to work out the reg positions
UserContextTable.UserContextTable table = CrashDebugger.UserContextTableManager[UserContextType];
// Get SP and stack data for supervisor thread
uint sp = SavedSP;
ThreadStackData spData = iParentThread.StackInfoSupervisor.Data;
if (spData.Info.Data.Size > 0)
{
// This is the user side address that will be branched back to once we exit SVC mode...
uint retAddr = UserReturnAddress;
ret[TArmRegisterType.EArmReg_PC].Value = retAddr;
// Now try to get the register values off of the supervisor stack
DataBuffer superStackData = spData.Data;
foreach (ArmRegister reg in ret)
{
if (UserContextTable.UserContextTable.IsSupported(reg.RegType))
{
UserContextTableEntry uctEntry = table[reg.RegType];
if (uctEntry.IsAvailable(isCurrent))
{
ArmRegister savedSp = new ArmRegister(TArmRegisterType.EArmReg_SP, sp);
uint newValue = uctEntry.Process(savedSp, superStackData);
reg.Value = newValue;
}
}
}
}
// Getting context of current thread? Some values can be fetched directly
// from the registers if they are not available from the stack.
if (isCurrent && table[TArmRegisterType.EArmReg_SP].Type == UserContextTableEntry.TType.EOffsetFromSp)
{
RegisterCollection userRegs = CrashDebugger.InfoCpu[RegisterCollection.TType.ETypeUser];
//
ret[TArmRegisterType.EArmReg_SP].Value = userRegs[TArmRegisterType.EArmReg_SP];
ret[TArmRegisterType.EArmReg_LR].Value = userRegs[TArmRegisterType.EArmReg_LR];
}
return(ret);
}
public RegisterCollection GetRegisters()
{
RegisterCollection.TType bankType = CPSRBankType;
RegisterCollection bank = this[bankType];
//
RegisterCollection ret = new RegisterCollection(CrashDebugger, bankType);
foreach (RegisterEntry entry in bank)
{
ret.Add(entry.OriginalName, entry.Value);
}
return(ret);
}
public Response14(byte[] frame) : base(frame)
{
int ByteCount = (new byte[2] {
frame[2], frame[3]
}).ToInt();
int framesize = MinimumFrameSize + ByteCount + 2;
if (frame.Length < framesize)
{
throw new FormatException(String.Format(Res.Message.ArraySize, framesize));
}
Data = new RegisterCollection(frame.Skip(MinimumFrameSize).Take(ByteCount).ToArray());// beside fisrt 3 bytes and two crc bytes
}
public void ReadWriteMultipleRegistersRequest()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
Assert.AreEqual(Modbus.ReadWriteMultipleRegisters, request.FunctionCode);
Assert.AreEqual(5, request.SlaveAddress);
// test read
Assert.IsNotNull(request.ReadRequest);
Assert.AreEqual(request.SlaveAddress, request.ReadRequest.SlaveAddress);
Assert.AreEqual(3, request.ReadRequest.StartAddress);
Assert.AreEqual(6, request.ReadRequest.NumberOfPoints);
// test write
Assert.IsNotNull(request.WriteRequest);
Assert.AreEqual(request.SlaveAddress, request.WriteRequest.SlaveAddress);
Assert.AreEqual(14, request.WriteRequest.StartAddress);
Assert.AreEqual(writeCollection.NetworkBytes, request.WriteRequest.Data.NetworkBytes);
}
public void CreateModbusMessageReturnQueryDataRequestResponse()
{
const byte slaveAddress = 5;
RegisterCollection data = new RegisterCollection(50);
byte[] frame = new byte[] { slaveAddress, 8, 0, 0 }.Concat(data.NetworkBytes).ToArray();
DiagnosticsRequestResponse message =
ModbusMessageFactory.CreateModbusMessage<DiagnosticsRequestResponse>(frame);
DiagnosticsRequestResponse expectedMessage =
new DiagnosticsRequestResponse(Modbus.DiagnosticsReturnQueryData, slaveAddress, data);
Assert.AreEqual(expectedMessage.SubFunctionCode, message.SubFunctionCode);
AssertModbusMessagePropertiesAreEqual(expectedMessage, message);
}
public void CreateModbusMessageReadWriteMultipleRegistersRequest()
{
ReadWriteMultipleRegistersRequest request =
ModbusMessageFactory.CreateModbusMessage<ReadWriteMultipleRegistersRequest>(new byte[]
{0x05, 0x17, 0x00, 0x03, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x03, 0x06, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff});
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest expectedRequest = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14,
writeCollection);
AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
}
public RegisterManager(Radio radio)
{
ConfigurationRegister = new ConfigurationRegister(radio);
EnableAutoAcknowledgementRegister = new EnableAutoAcknowledgementRegister(radio);
EnableReceiveAddressRegister = new EnableReceiveAddressRegister(radio);
AddressWidthRegister = new SetupAddressWidthRegister(radio);
SetupRetransmissionRegister = new SetupRetransmissionRegister(radio);
RfChannelRegister = new RfChannelRegister(radio);
RfSetupRegister = new RfSetupRegister(radio);
StatusRegister = new StatusRegister(radio);
ObserveTransmitRegister = new ObserveTransmitRegister(radio);
ReceivedPowerDetectorRegister = new ReceivedPowerDetectorRegister(radio);
TransmitAddressRegister = new AddressPipeRegister(radio, Addresses.TX_ADDR, 0);
FifoStatusRegister = new FifoStatusRegister(radio);
DynamicPayloadLengthRegister = new DynamicPayloadLengthRegister(radio);
FeatureRegister = new FeatureRegister(radio);
ReceiveAddressPipeRegisters = new RegisterCollection<AddressPipeRegister>
{
{0, new AddressPipeRegister(radio, Addresses.RX_ADDR_P0, 0)},
{1, new AddressPipeRegister(radio, Addresses.RX_ADDR_P1, 1)},
{2, new AddressPipeRegister(radio, Addresses.RX_ADDR_P1, 2)},
{3, new AddressPipeRegister(radio, Addresses.RX_ADDR_P1, 3)},
{4, new AddressPipeRegister(radio, Addresses.RX_ADDR_P1, 4)},
{5, new AddressPipeRegister(radio, Addresses.RX_ADDR_P1, 5)},
};
ReceivePayloadWidthPipeRegisters = new RegisterCollection<ReceivePayloadWidthPipeRegister>
{
{0, new ReceivePayloadWidthPipeRegister(radio, Addresses.RX_PW_P0, 0)},
{1, new ReceivePayloadWidthPipeRegister(radio, Addresses.RX_PW_P1, 1)},
{2, new ReceivePayloadWidthPipeRegister(radio, Addresses.RX_PW_P2, 2)},
{3, new ReceivePayloadWidthPipeRegister(radio, Addresses.RX_PW_P3, 3)},
{4, new ReceivePayloadWidthPipeRegister(radio, Addresses.RX_PW_P4, 4)},
{5, new ReceivePayloadWidthPipeRegister(radio, Addresses.RX_PW_P5, 5)}
};
AllRegisters = new RegisterCollection<RegisterBase>
{
{Addresses.CONFIG, ConfigurationRegister},
{Addresses.EN_AA, EnableAutoAcknowledgementRegister},
{Addresses.EN_RXADDR, EnableReceiveAddressRegister},
{Addresses.SETUP_AW, AddressWidthRegister},
{Addresses.SETUP_RETR, SetupRetransmissionRegister},
{Addresses.RF_CH, RfChannelRegister},
{Addresses.RF_SETUP, RfSetupRegister},
{Addresses.STATUS, StatusRegister},
{Addresses.OBSERVE_TX, ObserveTransmitRegister},
{Addresses.RPD, ReceivedPowerDetectorRegister},
{Addresses.RX_ADDR_P0, ReceiveAddressPipeRegisters[0]},
{Addresses.RX_ADDR_P1, ReceiveAddressPipeRegisters[1]},
{Addresses.RX_ADDR_P2, ReceiveAddressPipeRegisters[2]},
{Addresses.RX_ADDR_P3, ReceiveAddressPipeRegisters[3]},
{Addresses.RX_ADDR_P4, ReceiveAddressPipeRegisters[4]},
{Addresses.RX_ADDR_P5, ReceiveAddressPipeRegisters[5]},
{Addresses.TX_ADDR, TransmitAddressRegister},
{Addresses.RX_PW_P0, ReceivePayloadWidthPipeRegisters[0]},
{Addresses.RX_PW_P1, ReceivePayloadWidthPipeRegisters[1]},
{Addresses.RX_PW_P2, ReceivePayloadWidthPipeRegisters[2]},
{Addresses.RX_PW_P3, ReceivePayloadWidthPipeRegisters[3]},
{Addresses.RX_PW_P4, ReceivePayloadWidthPipeRegisters[4]},
{Addresses.RX_PW_P5, ReceivePayloadWidthPipeRegisters[5]},
{Addresses.FIFO_STATUS, FifoStatusRegister},
{Addresses.DYNPD, DynamicPayloadLengthRegister},
{Addresses.FEATURE, FeatureRegister}
};
}
public RegisterContainer(ILoggerFactoryAdapter loggerFactoryAdapter, ICommandProcessor commandProcessor)
{
ConfigurationRegister = new ConfigurationRegister(loggerFactoryAdapter, commandProcessor);
EnableAutoAcknowledgementRegister = new EnableAutoAcknowledgementRegister(loggerFactoryAdapter, commandProcessor);
EnableReceiveAddressRegister = new EnableReceiveAddressRegister(loggerFactoryAdapter, commandProcessor);
AddressWidthRegister = new SetupAddressWidthRegister(loggerFactoryAdapter, commandProcessor);
SetupRetransmissionRegister = new SetupRetransmissionRegister(loggerFactoryAdapter, commandProcessor);
RfChannelRegister = new RfChannelRegister(loggerFactoryAdapter, commandProcessor);
RfSetupRegister = new RfSetupRegister(loggerFactoryAdapter, commandProcessor);
StatusRegister = new StatusRegister(loggerFactoryAdapter, commandProcessor);
ObserveTransmitRegister = new ObserveTransmitRegister(loggerFactoryAdapter, commandProcessor);
ReceivedPowerDetectorRegister = new ReceivedPowerDetectorRegister(loggerFactoryAdapter, commandProcessor);
TransmitAddressRegister = new AddressPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.TX_ADDR, RegisterDefaults.TX_ADDR, 0, "TX_ADDR");
FifoStatusRegister = new FifoStatusRegister(loggerFactoryAdapter, commandProcessor);
DynamicPayloadLengthRegister = new DynamicPayloadLengthRegister(loggerFactoryAdapter, commandProcessor);
FeatureRegister = new FeatureRegister(loggerFactoryAdapter, commandProcessor);
ReceiveAddressPipeRegisters = new RegisterCollection<AddressPipeRegister>
{
{0, new AddressPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_ADDR_P0, RegisterDefaults.RX_ADDR_P0, 0, "RX_ADDR_P0")},
{1, new AddressPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_ADDR_P1, RegisterDefaults.RX_ADDR_P1, 1, "RX_ADDR_P1")},
{2, new AddressPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_ADDR_P2, RegisterDefaults.RX_ADDR_P2, 2, "RX_ADDR_P2")},
{3, new AddressPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_ADDR_P3, RegisterDefaults.RX_ADDR_P3, 3, "RX_ADDR_P3")},
{4, new AddressPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_ADDR_P4, RegisterDefaults.RX_ADDR_P4, 4, "RX_ADDR_P4")},
{5, new AddressPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_ADDR_P5, RegisterDefaults.RX_ADDR_P5, 5, "RX_ADDR_P5")},
};
ReceivePayloadWidthPipeRegisters = new RegisterCollection<ReceivePayloadWidthPipeRegister>
{
{0, new ReceivePayloadWidthPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_PW_P0, RegisterDefaults.RX_PW_P0, 0, "RX_PW_P0")},
{1, new ReceivePayloadWidthPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_PW_P1, RegisterDefaults.RX_PW_P1, 1, "RX_PW_P1")},
{2, new ReceivePayloadWidthPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_PW_P2, RegisterDefaults.RX_PW_P2, 2, "RX_PW_P2")},
{3, new ReceivePayloadWidthPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_PW_P3, RegisterDefaults.RX_PW_P3, 3, "RX_PW_P3")},
{4, new ReceivePayloadWidthPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_PW_P4, RegisterDefaults.RX_PW_P4, 4, "RX_PW_P4")},
{5, new ReceivePayloadWidthPipeRegister(loggerFactoryAdapter, commandProcessor, RegisterAddresses.RX_PW_P5, RegisterDefaults.RX_PW_P5, 5, "RX_PW_P5")}
};
AllRegisters = new RegisterCollection<IRegister>
{
{RegisterAddresses.CONFIG, ConfigurationRegister},
{RegisterAddresses.EN_AA, EnableAutoAcknowledgementRegister},
{RegisterAddresses.EN_RXADDR, EnableReceiveAddressRegister},
{RegisterAddresses.SETUP_AW, AddressWidthRegister},
{RegisterAddresses.SETUP_RETR, SetupRetransmissionRegister},
{RegisterAddresses.RF_CH, RfChannelRegister},
{RegisterAddresses.RF_SETUP, RfSetupRegister},
{RegisterAddresses.STATUS, StatusRegister},
{RegisterAddresses.OBSERVE_TX, ObserveTransmitRegister},
{RegisterAddresses.RPD, ReceivedPowerDetectorRegister},
{RegisterAddresses.RX_ADDR_P0, ReceiveAddressPipeRegisters[0]},
{RegisterAddresses.RX_ADDR_P1, ReceiveAddressPipeRegisters[1]},
{RegisterAddresses.RX_ADDR_P2, ReceiveAddressPipeRegisters[2]},
{RegisterAddresses.RX_ADDR_P3, ReceiveAddressPipeRegisters[3]},
{RegisterAddresses.RX_ADDR_P4, ReceiveAddressPipeRegisters[4]},
{RegisterAddresses.RX_ADDR_P5, ReceiveAddressPipeRegisters[5]},
{RegisterAddresses.TX_ADDR, TransmitAddressRegister},
{RegisterAddresses.RX_PW_P0, ReceivePayloadWidthPipeRegisters[0]},
{RegisterAddresses.RX_PW_P1, ReceivePayloadWidthPipeRegisters[1]},
{RegisterAddresses.RX_PW_P2, ReceivePayloadWidthPipeRegisters[2]},
{RegisterAddresses.RX_PW_P3, ReceivePayloadWidthPipeRegisters[3]},
{RegisterAddresses.RX_PW_P4, ReceivePayloadWidthPipeRegisters[4]},
{RegisterAddresses.RX_PW_P5, ReceivePayloadWidthPipeRegisters[5]},
{RegisterAddresses.FIFO_STATUS, FifoStatusRegister},
{RegisterAddresses.DYNPD, DynamicPayloadLengthRegister},
{RegisterAddresses.FEATURE, FeatureRegister}
};
// Set the LoadStatusRegister Action of the ICommandProcessor to call
// StatusRegister.Load. This will ensure that the Status register is
// automatically updated after call ICommandProcessor.ExecuteCommand()
commandProcessor.LoadStatusRegister = StatusRegister.Load;
}
public void Initialize(byte[] frame)
{
if (frame == null)
throw new ArgumentNullException("frame");
if (frame.Length < 7 || frame.Length < 7 + frame[6])
throw new FormatException("Message frame does not contain enough bytes.");
SlaveAddress = frame[0];
FunctionCode = frame[1];
StartAddress = (ushort) IPAddress.NetworkToHostOrder(BitConverter.ToInt16(frame, 2));
NumberOfPoints = (ushort) IPAddress.NetworkToHostOrder(BitConverter.ToInt16(frame, 4));
ByteCount = frame[6];
Data = new RegisterCollection(frame.Slice(7, ByteCount).ToArray());
}
public void RegisterCollectionEmpty()
{
RegisterCollection col = new RegisterCollection();
Assert.IsNotNull(col);
Assert.AreEqual(0, col.NetworkBytes.Length);
}
public void ModifyRegister()
{
RegisterCollection col = new RegisterCollection(1, 2, 3, 4);
col[0] = 5;
}
public void ByteCount()
{
RegisterCollection col = new RegisterCollection(1, 2, 3);
Assert.AreEqual(6, col.ByteCount);
}
