public void SetDacChannelDataValueA(ChannelAddress channelAddress, ushort value)
{
if (channelAddress < ChannelAddress.Dac0 || channelAddress > ChannelAddress.Dac39)
{
throw new ArgumentOutOfRangeException(nameof(channelAddress));
}
using (_lockFactory.GetLock(LockType.CommandLock))
{
var val = _evalBoard.DeviceState.Precision == DacPrecision.SixteenBit
? value
: (ushort)(value & (ushort)BasicMasks.HighFourteenBits);
if (_evalBoard.DeviceState.UseRegisterCache &&
val == _evalBoard.DeviceState.X1ARegisters[channelAddress.ToChannelNumber()])
{
return;
}
var controlRegisterBits = _readbackControlRegisterCommand.ReadbackControlRegister() &
ControlRegisterBits.WritableBits;
controlRegisterBits &=
~ControlRegisterBits
.InputRegisterSelect; //set control register bit F2 =0 to select register X1A for input
_writeControlRegisterCommand.WriteControlRegister(controlRegisterBits);
_sendSPICommand.SendSPI((uint)SerialInterfaceModeBits.WriteToDACInputDataRegisterX |
(uint)(((byte)channelAddress & (byte)BasicMasks.SixBits) << 16) |
val);
_evalBoard.DeviceState.X1ARegisters[channelAddress.ToChannelNumber()] = val;
}
}
public ushort ReadbackX1BRegister(ChannelAddress channelAddress)
{
using (_lockFactory.GetLock(LockType.CommandLock))
{
if (channelAddress < ChannelAddress.Dac0 || channelAddress > ChannelAddress.Dac39)
{
throw new ArgumentOutOfRangeException(nameof(channelAddress));
}
if (_evalBoard.DeviceState.UseRegisterCache &&
_evalBoard.DeviceState.X1BRegisters[channelAddress.ToChannelNumber()].HasValue)
{
var deviceStateX1BRegister = _evalBoard.DeviceState.X1BRegisters[channelAddress.ToChannelNumber()];
if (deviceStateX1BRegister != null)
{
return(deviceStateX1BRegister.Value);
}
}
_sendSpecialFunctionCommand.SendSpecialFunction(SpecialFunctionCode.SelectRegisterForReadback,
(ushort)((ushort)AddressCodesForDataReadback.X1BRegister |
(ushort)(((byte)channelAddress & (byte)BasicMasks.SixBits) << 7)));
var val = _readSPICommand.ReadSPI();
if (_evalBoard.DeviceState.Precision == DacPrecision.FourteenBit)
{
val &= (ushort)BasicMasks.HighFourteenBits;
}
_evalBoard.DeviceState.X1BRegisters[channelAddress.ToChannelNumber()] = val;
return(val);
}
}
public void SetDacChannelGain(ChannelAddress channelAddress, ushort value)
{
if (channelAddress < ChannelAddress.Dac0 || channelAddress > ChannelAddress.Dac39)
{
throw new ArgumentOutOfRangeException(nameof(channelAddress));
}
var val = _evalBoard.DeviceState.Precision == DacPrecision.SixteenBit
? value
: (ushort)(value & (ushort)BasicMasks.HighFourteenBits);
if (!_evalBoard.DeviceState.UseRegisterCache ||
val != _evalBoard.DeviceState.MRegisters[channelAddress.ToChannelNumber()])
{
using (_lockFactory.GetLock(LockType.CommandLock))
{
_setCLRPinLowCommand.SetCLRPinLow();
_sendSPICommand.SendSPI((uint)SerialInterfaceModeBits.WriteToDACGainRegisterM |
(uint)(((byte)channelAddress & (byte)BasicMasks.SixBits) << 16) |
val);
_evalBoard.DeviceState.MRegisters[channelAddress.ToChannelNumber()] = val;
_setCLRPinHighCommand.SetCLRPinHigh();
}
}
}
public void ShouldThrowExceptionIfArgumentsAreOutOfRange(
[Values((int)(ChannelAddress.Dac0 - 1), (int)(ChannelAddress.Dac39 + 1))] ChannelAddress channelAddress,
[Values((int)(DacChannelDataSource.DataValueA - 1), (int)(DacChannelDataSource.DataValueB + 1))]
DacChannelDataSource dacChannelDataSource)
{
Assert.Throws <ArgumentOutOfRangeException>(
() => WhenSetDacChannelDataSourceInternal(channelAddress, dacChannelDataSource));
}
private void GivenCRegisterBits(ChannelAddress channelAddress, ushort cRegisterValue)
{
Mock.Get(_fakeRb)
.Setup(x => x.ReadbackCRegister(channelAddress))
.Returns((ushort)(cRegisterValue & (_deviceState.Precision == DacPrecision.SixteenBit
? (ushort)BasicMasks.SixteenBits
: (ushort)BasicMasks.HighFourteenBits)));
}
public void ShouldSetDacChannelDataSource
(
[Range((int)ChannelAddress.Dac0, (int)ChannelAddress.Dac39)] ChannelAddress channelAddress,
[Values] DacChannelDataSource dacChannelDataSource
)
{
WhenSetDacChannelDataSource(channelAddress, dacChannelDataSource);
ThenCallShouldBeDelegatedToSetDacChannelDataSourceInternalCommand(channelAddress, dacChannelDataSource);
}
public void ShouldUpdateCorrectABSelectRegister(
ChannelAddress channelAddress,
DacChannelDataSource dacChannelDataSource,
int registerNum
)
{
WhenSetDacChannelDataSourceInternal(channelAddress, dacChannelDataSource);
ThenABSelectRegisterUpdatedShouldBe(registerNum);
}
public void ShouldReturnCorrectDacChannelDataSource(
int abSelectRegisterNumber,
uint?abSelectRegisterValue,
ChannelAddress dacChannelAddress,
DacChannelDataSource expectedDacChannelDataSource)
{
GivenABSelectRegisterValue(abSelectRegisterNumber, (ABSelectRegisterBits?)abSelectRegisterValue);
WhenGetDacChannelDataSource(dacChannelAddress);
ThenDacChannelDataSourceShouldBe(expectedDacChannelDataSource);
}
public void ShouldSetDacChannelDataSourceAllChannelsInSameGroup(
ChannelAddress channelAddress,
DacChannelDataSource dacChannelDataSource,
byte specialFunctionCode,
ushort data
)
{
WhenSetDacChannelDataSource(channelAddress, dacChannelDataSource);
ThenSendSpecialFunctionCommandShouldBeCalled((SpecialFunctionCode)specialFunctionCode, data);
}
private static uint DataForSPI(DacPrecision dacPrecision, ChannelAddress channelAddress, ushort dacChannelGain)
{
return
((uint)SerialInterfaceModeBits.WriteToDACGainRegisterM
| (uint)(((byte)channelAddress & (byte)BasicMasks.SixBits) << 16)
| (dacChannelGain &
(dacPrecision == DacPrecision.SixteenBit
? (uint)BasicMasks.SixteenBits
: (uint)BasicMasks.HighFourteenBits)));
}
public void ShouldThrowExceptionIfArgumentsAreOutOfRange(
[Values((int)(ChannelAddress.AllGroupsAllChannels - 1), (int)(ChannelAddress.Group1Through4Channel7 + 1))]
ChannelAddress channelAddress,
[Values((int)(ChannelAddress.AllGroupsAllChannels - 1), (int)(ChannelAddress.Group1Through4Channel7 + 1),
6, 7)] DacChannelDataSource dacChannelDataSource
)
{
Assert.Throws <ArgumentOutOfRangeException>(
() => WhenSetDacChannelDataSource(channelAddress, dacChannelDataSource));
}
public void ShouldSendSPI(
[Values(DacPrecision.SixteenBit, DacPrecision.FourteenBit)] DacPrecision dacPrecision,
[Range((int)ChannelAddress.Dac0, (int)ChannelAddress.Dac39)] ChannelAddress channelAddress,
[Values(ushort.MinValue, 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7, 1 << 8, 1 << 9, 1 << 10,
1 << 11, 1 << 12, 1 << 13, 1 << 14, 1 << 15, ushort.MaxValue)] int dacChannelDataValueA)
{
GivenDACPrecision(dacPrecision);
WhenSetDacChannelDataValueA(channelAddress, (ushort)dacChannelDataValueA);
ThenSPICommandIsSent(DataForSPI(dacPrecision, channelAddress, (ushort)dacChannelDataValueA));
}
public ushort GetDacChannelDataValueB(ChannelAddress channelAddress)
{
using (_lockFactory.GetLock(LockType.CommandLock))
{
if (channelAddress >= ChannelAddress.Dac0 && channelAddress <= ChannelAddress.Dac39)
{
return(_readbackX1BRegisterCommand.ReadbackX1BRegister(channelAddress));
}
throw new ArgumentOutOfRangeException(nameof(channelAddress));
}
}
public void ShouldClearInputRegisterSelectBit(
[Values((byte)ControlRegisterBits.InputRegisterSelect, (byte)ControlRegisterBits.WritableBits,
byte.MaxValue, byte.MinValue)] byte controlRegisterBits,
[Range((int)ChannelAddress.Dac0, (int)ChannelAddress.Dac39)] ChannelAddress channelAddress,
[Values(ushort.MinValue, 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7, 1 << 8, 1 << 9, 1 << 10,
1 << 11, 1 << 12, 1 << 13, 1 << 14, 1 << 15, ushort.MaxValue)] int dacChannelDataValueA)
{
GivenControlRegisterBits((ControlRegisterBits)controlRegisterBits);
WhenSetDacChannelDataValueA(channelAddress, (ushort)dacChannelDataValueA);
ThenInputRegisterSelectBitInControlRegisterBitsIsCleared();
}
public void ShouldApplyExistingABSelectRegisterValuesWhenComputingNewValuesForSingleChannel(
int registerNum,
byte existingABSelectRegisterBits,
ChannelAddress channelAddress,
DacChannelDataSource dacChannelDataSource,
byte newABSelectRegisterBits
)
{
GivenExistingABSelectRegisterValues(registerNum, (ABSelectRegisterBits)existingABSelectRegisterBits);
WhenSetDacChannelDataSourceInternal(channelAddress, dacChannelDataSource);
ThenNewABSelectRegisterBitsShouldBe((ABSelectRegisterBits)newABSelectRegisterBits);
}
public void ShouldUpdateABSelectRegisterCacheInDeviceState(
int registerNum,
byte existingABSelectRegisterBits,
ChannelAddress channelAddress,
DacChannelDataSource dacChannelDataSource,
byte newABSelectRegisterBits
)
{
GivenExistingABSelectRegisterValues(registerNum, (ABSelectRegisterBits)existingABSelectRegisterBits);
WhenSetDacChannelDataSourceInternal(channelAddress, dacChannelDataSource);
ThenABSelectRegisterCacheInDeviceStateShouldBe(registerNum, (ABSelectRegisterBits)newABSelectRegisterBits);
}
private void ThenTheValueShouldBeReadFromTheDevice(ChannelAddress channelAddress)
{
Mock.Get(_fakeSendSpecialFunctionCommand)
.Verify(x => x.SendSpecialFunction(
SpecialFunctionCode.SelectRegisterForReadback,
It.Is <ushort>(y => y == (ushort)((ushort)AddressCodesForDataReadback.MRegister
|
(ushort)(((byte)channelAddress &
(byte)BasicMasks.SixBits) << 7))))
, Times.Once);
Mock.Get(_fakeReadSPICommand)
.Verify(x => x.ReadSPI(), Times.Once);
}
public void ShouldCacheX1ARegisterValues(
[Values(DacPrecision.SixteenBit, DacPrecision.FourteenBit)] DacPrecision dacPrecision,
[Range((int)ChannelAddress.Dac0, (int)ChannelAddress.Dac39)] ChannelAddress channelAddress,
[Values(ushort.MinValue, 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7, 1 << 8, 1 << 9, 1 << 10,
1 << 11, 1 << 12, 1 << 13, 1 << 14, 1 << 15, ushort.MaxValue)] int dacChannelDataValueA)
{
GivenDACPrecision(dacPrecision);
WhenSetDacChannelDataValueA(channelAddress, (ushort)dacChannelDataValueA);
ThenX1ARegisterValueInDeviceStateCacheIsSetTo(
(int)channelAddress - 8,
(ushort)(dacChannelDataValueA &
(dacPrecision == DacPrecision.SixteenBit
? (ushort)BasicMasks.SixteenBits
: (ushort)BasicMasks.HighFourteenBits))
);
}
public DacChannelDataSource GetDacChannelDataSource(ChannelAddress channelAddress)
{
using (_lockFactory.GetLock(LockType.CommandLock))
{
if (channelAddress < ChannelAddress.Dac0 || channelAddress > ChannelAddress.Dac39)
{
throw new ArgumentOutOfRangeException(nameof(channelAddress));
}
var channelNum = (byte)((byte)channelAddress - 8);
var currentSourceSelections =
_readbackABSelectRegisterCommand.ReadbackABSelectRegister(channelNum / 8);
var channelOffset = (byte)(channelNum % 8);
var channelMask = (ABSelectRegisterBits)(1 << channelOffset);
var sourceIsDataValueB = (currentSourceSelections & channelMask) == channelMask;
return(sourceIsDataValueB ? DacChannelDataSource.DataValueB : DacChannelDataSource.DataValueA);
}
}
public void ShouldSetDacChannelDataSourceSameChannelInGroups1To4(
ChannelAddress groupChannelAddress,
DacChannelDataSource dacChannelDataSource,
ChannelAddress group1ChannelAddress,
ChannelAddress group2ChannelAddress,
ChannelAddress group3ChannelAddress,
ChannelAddress group4ChannelAddress
)
{
WhenSetDacChannelDataSource(groupChannelAddress, dacChannelDataSource);
ThenCallShouldBeDelegatedToSetDacChannelDataSourceInternalCommand(group1ChannelAddress,
dacChannelDataSource);
ThenCallShouldBeDelegatedToSetDacChannelDataSourceInternalCommand(group2ChannelAddress,
dacChannelDataSource);
ThenCallShouldBeDelegatedToSetDacChannelDataSourceInternalCommand(group3ChannelAddress,
dacChannelDataSource);
ThenCallShouldBeDelegatedToSetDacChannelDataSourceInternalCommand(group4ChannelAddress,
dacChannelDataSource);
}
private static DeviceConfig WithInitialDacChannelGain(ChannelAddress channelAddress, ushort?dacChannelGain)
{
var deviceConfig = new DeviceConfig {
DACChannelConfig = new DACChannelConfigurations()
};
var propertyInfo = deviceConfig.DACChannelConfig.GetType()
.GetProperty($"DAC{(int) channelAddress - 8}");
if (propertyInfo == null)
{
return(deviceConfig);
}
propertyInfo
.SetValue(deviceConfig.DACChannelConfig,
new DACChannelConfiguration
{
Calibration = new DACChannelCalibration {
Gain = dacChannelGain
}
}
);
return(deviceConfig);
}
private static DeviceConfig WithInitialDacChannelDataValueB(ChannelAddress channelAddress,
ushort?dacChannelDataValueB)
{
var deviceConfig = new DeviceConfig {
DACChannelConfig = new DACChannelConfigurations()
};
var propertyInfo = deviceConfig.DACChannelConfig.GetType()
.GetProperty($"DAC{(int) channelAddress - 8}");
if (propertyInfo == null)
{
return(deviceConfig);
}
propertyInfo
.SetValue(deviceConfig.DACChannelConfig,
new DACChannelConfiguration
{
InitialState = new InitialDACChannelState {
DataValueB = dacChannelDataValueB
}
}
);
return(deviceConfig);
}
internal static int ToChannelNumber(this ChannelAddress channelAddress)
{
return(((int)channelAddress) - 8);
}
private void WhenReadbackMRegister(ChannelAddress channelAddress)
{
_resultOfReadback = _readbackMRegisterCommand.ReadbackMRegister(channelAddress);
}
private void WhenGetDacChannelOffset(ChannelAddress channelAddress)
{
_dacChannelOffset = _getDacChannelOffsetCommand.GetDacChannelOffset(channelAddress);
}
public void ShouldThrowExceptionIfChannelNumberIsOutOfRange(
[Values((int)(ChannelAddress.Dac0 - 1), (int)(ChannelAddress.Dac39 + 1))] ChannelAddress channelAddress)
{
Assert.Throws <ArgumentOutOfRangeException>(() => WhenGetDacChannelOffset(channelAddress));
}
private void ThenTheValueReadShouldBeCached(ChannelAddress channelAddress)
{
_deviceState.MRegisters[channelAddress.ToChannelNumber()].Should().Be(_resultOfReadback);
}
public void ShouldThrowExceptionIfChannelAddressIsOutOfRange(
[Values(ChannelAddress.Dac0 - 1, ChannelAddress.Dac39 + 1)] ChannelAddress channelAddress)
{
Assert.Throws <ArgumentOutOfRangeException>(() => WhenReadbackMRegister(channelAddress));
}
private float Vout(ChannelAddress dacChannel)
{
var dacChannelDataSource = rdoDataValueA.Checked
? DacChannelDataSource.DataValueA
: DacChannelDataSource.DataValueB;
var parsed = ushort.TryParse(txtDataValueA.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture,
out ushort dataValueA);
if (!parsed)
{
return(0);
}
parsed = ushort.TryParse(txtDataValueB.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture,
out ushort dataValueB);
if (!parsed)
{
return(0);
}
var dacChannelDataValue = dacChannelDataSource == DacChannelDataSource.DataValueA
? dataValueA
: dataValueB;
parsed = ushort.TryParse(txtDACChannelOffset.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture,
out ushort dacChannelOffsetValue);
if (!parsed)
{
return(0);
}
parsed = ushort.TryParse(txtDACChannelGain.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture,
out ushort dacChannelGainValue);
if (!parsed)
{
return(0);
}
ushort offsetDACValue;
float vRef;
if (dacChannel >= ChannelAddress.Group0Channel0 && dacChannel <= ChannelAddress.Group0Channel7)
{
parsed = ushort.TryParse(txtOffsetDAC0.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture,
out offsetDACValue);
if (!parsed)
{
return(0);
}
parsed = float.TryParse(txtVREF0.Text, out vRef);
if (!parsed)
{
return(0);
}
}
else if (dacChannel >= ChannelAddress.Group1Channel0 && dacChannel <= ChannelAddress.Group4Channel7)
{
parsed = ushort.TryParse(txtOffsetDAC1.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture,
out offsetDACValue);
if (!parsed)
{
return(0);
}
parsed = float.TryParse(txtVREF1.Text, out vRef);
if (!parsed)
{
return(0);
}
}
else
{
parsed = ushort.TryParse(txtOffsetDAC0.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture,
out offsetDACValue);
if (!parsed)
{
return(0);
}
parsed = float.TryParse(txtVREF0.Text, out vRef);
if (!parsed)
{
return(0);
}
}
return(Vout(dacChannelDataValue, dacChannelOffsetValue, dacChannelGainValue, offsetDACValue, vRef));
}
private void GivenMRegisterValueExistsInDeviceStateRegisterCache(ChannelAddress channelAddress, ushort?value)
{
_deviceState.MRegisters[channelAddress.ToChannelNumber()] = value;
}
