internal DigitalInput(int numberOfInputOnGroup, NeuronGroup neuronGroup, ushort registerNumber, ushort bitInRegister)
{
_registerNumber = registerNumber;
_bitInRegister = bitInRegister;
UniqueIdentifyer = new UniqueIdentifier(neuronGroup, NeuronResource.DigitalInput, numberOfInputOnGroup);
_currentValue = OnOffValue.Unknown;
}
internal AnalogOutput(NeuronGroup neuronGroup, int number, ushort registerNumber, NeuronSpiConnector spiConnector, DriverLogger logger)
{
_registerNumber = registerNumber;
_logger = logger;
_logger.LogInstantiating(this);
_neuronGroup = neuronGroup;
_spiConnector = spiConnector;
UniqueIdentifyer = new UniqueIdentifier(neuronGroup, NeuronResource.AnalogOutput, number);
var vOffset = _spiConnector.GetSingleRegisterValue(neuronGroup, 1021);
var vDef = _spiConnector.GetSingleRegisterValue(neuronGroup, 1020);
var vRef = _spiConnector.GetSingleRegisterValue(neuronGroup, 1009);
var vRefInt = _spiConnector.GetSingleRegisterValue(neuronGroup, 5);
if (vRefInt == null || vRef == null || vOffset == null || vDef == null)
{
throw new Exception("failure while getting the calibration Values from the Registers!");
}
_vOffset = BitConverter.ToInt16(BitConverter.GetBytes(vOffset.Value), 0);
_vDev = BitConverter.ToInt16(BitConverter.GetBytes(vDef.Value), 0);
_vRealInt = 3.3 * ((double)vRef / (double)vRefInt);
}
internal NeuronGroupBoardBase(NeuronGroup neuronGroup, IBoardInformation boardSystemInformation, NeuronSpiConnector spiConnector, I2CConnector i2CConnector, DriverLogger logger)
{
NeuronGroup = neuronGroup;
SpiConnector = spiConnector;
I2CConnector = i2CConnector;
Logger = logger;
_observeLocker = new object();
_registersToObserve = new Dictionary <ushort, List <IObservedRegisterObject> >();
BoardSystemInformation = boardSystemInformation;
DigitalInputDictionary = new Dictionary <IUniqueIdentifier, IDigitalInput>();
DigitalOutputsDictionary = new Dictionary <IUniqueIdentifier, IDigitalOutput>();
RelayOutputsDictionary = new Dictionary <IUniqueIdentifier, IDigitalOutput>();
UserLedsDictionary = new Dictionary <IUniqueIdentifier, IUserLed>();
AnalogInputsDictionary = new Dictionary <IUniqueIdentifier, IAnalogInput>();
AnalogOutputsDictionary = new Dictionary <IUniqueIdentifier, IAnalogOutput>();
OneWireConnectorsDictionary = new Dictionary <IUniqueIdentifier, IOneWireConnector>();
ModbusConnectorsDictionary = new Dictionary <IUniqueIdentifier, IModbusConnector>();
_pollInProgess = false;
_pollingTimer = new Timer(PollInformation, new object(), 50, 50);
}
internal AnalogInput(NeuronGroup neuronGroup, int number, ushort registerNumber, NeuronSpiConnector spiConnector)
{
_registerNumber = registerNumber;
UniqueIdentifyer = new UniqueIdentifier(neuronGroup, NeuronResource.AnalogInput, number);
var value = spiConnector.GetSingleRegisterValue(neuronGroup, 1021);
if (value == null)
{
throw new Exception("failure while getting Voffset from registers");
}
var vRef = spiConnector.GetSingleRegisterValue(neuronGroup, 1009);
var vRefInt = spiConnector.GetSingleRegisterValue(neuronGroup, 5);
var aI1Vdev = spiConnector.GetSingleRegisterValue(neuronGroup, 1025);
var ai1Offset = spiConnector.GetSingleRegisterValue(neuronGroup, 1026);
if (vRefInt == null || vRef == null || aI1Vdev == null || ai1Offset == null)
{
throw new Exception("failure while getting the calibration values from the Registers!");
}
_aI1Vdev = BitConverter.ToInt16(BitConverter.GetBytes(aI1Vdev.Value), 0);
_ai1Offset = BitConverter.ToInt16(BitConverter.GetBytes(ai1Offset.Value), 0);
_vRealInt = 3.3 * ((double)vRef / (double)vRefInt);
}
private void OnePhaseCommunication(NeuronGroup neuronGroup, byte[] message)
{
var returnMessage = new byte[message.Length];
message.CopyTo(returnMessage, 0);
SpiDevice device;
if (!_devices.TryGetValue(neuronGroup, out device) || device == null)
{
_driverLogger.LogError(this, "Device not found!");
return;
}
var crcCheck = false;
var tryCounter = 10;
while (!crcCheck)
{
try
{
if (tryCounter-- < 0)
{
throw new Exception("the spi communication failed!");
}
lock (_spiDeviceLocker)
{
PrepareSpiCommunication(device);
device.TransferFullDuplex(message, returnMessage);
}
var crc = CreateCrc(returnMessage, returnMessage.Length - 2);
if (crc != null && crc[0] == returnMessage[returnMessage.Length - 2] && crc[1] == returnMessage[returnMessage.Length - 1])
{
crcCheck = true;
}
else
{
throw new Exception("CRC Check failed for answer " + string.Join("-", returnMessage));
}
}
catch (Exception e)
{
_driverLogger.LogException(this, e);
if (tryCounter < 0)
{
throw;
}
Task.Delay(100)?.Wait();
}
}
}
//public bool GetCoilsValue(NeuronGroup neuronGroup, ushort coil)
//{
// var messagePhase1 = ByteArrayForGetCoilsMessagePhase1(NeuronSpiCommand.ReadBit, coil, 1);
// var messagePhase2 = ByteArrayForGetCoilsMessagePhase2(NeuronSpiCommand.ReadBit, coil, 1);
// var value = TwoPhaseCommunication(neuronGroup, messagePhase1, messagePhase2);
// Debug.WriteLine(String.Join("-", value));
// if (value[4] == 0) return false;
// return true;
//}
internal void SetRegisterValue(NeuronGroup neuronGroup, ushort register, ushort value)
{
var messagePhaseOne = ByteArrayForReadRegisterMessagePhase1(NeuronSpiCommand.WriteRegister, register, 1);
var crc = BitConverter.ToUInt16(messagePhaseOne, messagePhaseOne.Length - 2);
var messagePhaseTwo = ByteArrayForSetRegisterMessagePhase2(NeuronSpiCommand.WriteRegister, register, value, crc);
TwoPhaseCommunication(neuronGroup, messagePhaseOne, messagePhaseTwo);
}
internal UserLed(int ledNumber, NeuronGroup neuronGroup, ushort coilNumber, NeuronSpiConnector neuronSpiConnector, ushort registerNumber, ushort bitNumber)
{
UniqueIdentifyer = new UniqueIdentifier(neuronGroup, NeuronResource.UserLed, ledNumber);
_coilNumber = coilNumber;
_neuronSpiConnector = neuronSpiConnector;
_registerNumber = registerNumber;
_bitNumber = bitNumber;
_currentValue = OnOffValue.Unknown;
}
public B10001GroupBoard(NeuronGroup neuronGroup, IBoardInformation boardSystemInformation, NeuronSpiConnector spiConnector, I2CConnector i2CConnector, DriverLogger logger) : base(neuronGroup, boardSystemInformation, spiConnector, i2CConnector, logger)
{
#region Digital Inputs
for (ushort i = 0; i < AnzahlDigitalInputs; i++)
{
var input = new DigitalInput(i + 1, neuronGroup, 0, i);
SetObservation(0, input);
DigitalInputDictionary.Add(input.UniqueIdentifyer, input);
}
#endregion Digital Inputs
#region Digital Outputs
for (ushort i = 0; i < AnzahlDigitalOutputs; i++)
{
var digitalOutput = new DigitalOutput(1 + i, neuronGroup, i, spiConnector, logger, DigitalRelayOutputType.DigitalOutput, 1, i);
DigitalOutputsDictionary.Add(digitalOutput.UniqueIdentifyer, digitalOutput);
}
#endregion Digital Outputs
#region One Wire
var oneWireConnector = new OneWireConnector(neuronGroup, 1, Logger, I2CConnector);
OneWireConnectorsDictionary.Add(oneWireConnector.UniqueIdentifyer, oneWireConnector);
#endregion One Wire
#region User LED's
for (ushort i = 0; i < UserLedsCount; i++)
{
var userLed = new UserLed(i + 1, neuronGroup, (ushort)(8 + i), spiConnector, 20, i);
UserLedsDictionary.Add(userLed.UniqueIdentifyer, userLed);
}
#endregion User LED's
#region Analog Output
var analogOutput = new AnalogOutput(neuronGroup, 1, 2, spiConnector, logger);
AnalogOutputsDictionary.Add(analogOutput.UniqueIdentifyer, analogOutput);
#endregion Analog Output
#region Analog Input
var analogInput = new AnalogInput(neuronGroup, 1, 3, spiConnector);
SetObservation(3, analogInput);
AnalogInputsDictionary.Add(analogInput.UniqueIdentifyer, analogInput);
#endregion Analog Input
}
internal BoardInformation(Version firmwareVersion, Version hardwareVersion, int digitalInputCount, int digitalOutputCount, int analogInputCount, int analogOutputCount, int userLedCount, int hwVersion, NeuronGroup neuronGroup)
{
NeuronGroup = neuronGroup;
FirmwareVersion = firmwareVersion;
HardwareVersion = hardwareVersion;
DigitalInputCount = digitalInputCount;
DigitalOutputCount = digitalOutputCount;
AnalogInputCount = analogInputCount;
AnalogOutputCount = analogOutputCount;
UserLedCount = userLedCount;
BoardType = GetBoardType(hwVersion);
}
internal void SetCoilsValue(NeuronGroup neuronGroup, ushort coil, bool value)
{
byte intValue = 0;
if (value)
{
intValue = 1;
}
var message = ByteArrayForSetCoilsMessage(NeuronSpiCommand.WriteBit, coil, intValue);
OnePhaseCommunication(neuronGroup, message);
}
internal DigitalOutput(int numberOfOutputOnGroup, NeuronGroup neuronGroup, ushort coilNumber, NeuronSpiConnector neuronSpiConnector, DriverLogger logger, DigitalRelayOutputType digitalRelayOutputType, ushort registerNumber, ushort bitNumber)
{
_neuronGroup = neuronGroup;
_coilNumber = coilNumber;
_neuronSpiConnector = neuronSpiConnector;
_registerNumber = registerNumber;
_bitNumber = bitNumber;
logger.LogInstantiating(this);
UniqueIdentifyer = digitalRelayOutputType == DigitalRelayOutputType.DigitalOutput ?
new UniqueIdentifier(_neuronGroup, NeuronResource.DigitalOutput, numberOfOutputOnGroup) :
new UniqueIdentifier(_neuronGroup, NeuronResource.RelayOutput, numberOfOutputOnGroup);
UpdateLocalValue();
}
internal OneWireConnector(NeuronGroup neuronGroup, int number, DriverLogger logger, I2CConnector i2CGateway)
{
_logger = logger;
_logger.LogInformation(this, "create Instance...");
UniqueIdentifyer = new UniqueIdentifier(neuronGroup, NeuronResource.OneWireConnector, number);
OneWirePeriodicBusScan = true;
_timerState = new object();
_controllerLock = new object();
Devices = new List <IOneWireDevice>();
_neuronConnectedOneWireDevice = new NeuronConnectedOneWireDevice(i2CGateway);
_logger.LogInformation(this, "scanning bus on startup");
ScanForNewOrDeadDevices();
PeriodicBusScanIntervalSeconds = 60;
}
public UniversalNeuronGroupDiRoBoard(int digitalInCount, int relayOutCount, NeuronGroup neuronGroup, IBoardInformation boardSystemInformation, NeuronSpiConnector spiConnector, I2CConnector i2CConnector, DriverLogger logger) : base(neuronGroup, boardSystemInformation, spiConnector, i2CConnector, logger)
{
#region Digital Inputs
for (ushort i = 0; i < digitalInCount; i++)
{
var input = new DigitalInput(i + 1, neuronGroup, 0, i);
SetObservation(0, input);
DigitalInputDictionary.Add(input.UniqueIdentifyer, input);
}
#endregion Digital Inputs
#region Relay Outputs
for (ushort i = 0; i < relayOutCount; i++)
{
var digitalOutput = new DigitalOutput(1 + i, neuronGroup, i, spiConnector, logger, DigitalRelayOutputType.RelayOutput, 1, i);
DigitalOutputsDictionary.Add(digitalOutput.UniqueIdentifyer, digitalOutput);
}
#endregion Relay Outputs
}
internal SpiRegisterSet GetRegisterValues(NeuronGroup neuronGroup, ushort register, byte numberOfRegisters)
{
var result = new SpiRegisterSet();
var returnMessage = new byte[0];
try
{
var bytesToSendPhaseOne = ByteArrayForReadRegisterMessagePhase1(NeuronSpiCommand.ReadRegister, register, numberOfRegisters);
var bytesToSendPhaseTwo = ByteArrayForReadRegisterMessagePhase2(NeuronSpiCommand.ReadRegister, register, numberOfRegisters);
returnMessage = TwoPhaseCommunication(neuronGroup, bytesToSendPhaseOne, bytesToSendPhaseTwo);
if (returnMessage == null)
{
return(result);
}
var firstRegister = 4;
for (ushort i = 0; i < numberOfRegisters; i++)
{
var completeRegister = new[] { returnMessage[firstRegister++], returnMessage[firstRegister++] };
var registerValue = BitConverter.ToUInt16(completeRegister, 0);
var registerNumber = Convert.ToUInt16(i + register);
result.SetRegisterWithValue(registerNumber, registerValue);
}
return(result);
}
catch (Exception e)
{
_driverLogger.LogException(this, e);
_driverLogger.LogDebug(this, "SPI Return Value:" + string.Join("-", returnMessage));
return(new SpiRegisterSet());
}
}
internal static BoardInformation GetBoardInfoFromRegisters(SpiRegisterSet registerSet, DriverLogger logger, NeuronGroup neuronGroup)
{
try
{
if (registerSet == null || registerSet.Count != 5)
{
return(null);
}
if (!registerSet.ContainsRegister(1000) ||
!registerSet.ContainsRegister(1001) ||
!registerSet.ContainsRegister(1002) ||
!registerSet.ContainsRegister(1003) ||
!registerSet.ContainsRegister(1004))
{
logger.LogError(null, "i got the wrong registerSet to create the system information!");
return(null);
}
var configRegisters = registerSet.ToRegisterValueArray();
int swSubver;
int hwVersion;
int hwSubver;
var swVersion = configRegisters[0] >> 8;
var diCount = configRegisters[1] >> 8;
var doCount = configRegisters[1] & 0xff;
var aiCount = configRegisters[2] >> 8;
var aoCount = (configRegisters[2] & 0xff) >> 4;
var uledCount = 0;
if (swVersion < 4)
{
swSubver = 0;
hwVersion = (configRegisters[0] & 0xff) >> 4;
hwSubver = configRegisters[0] & 0xf;
}
else
{
swSubver = configRegisters[0] & 0xff;
hwVersion = configRegisters[3] >> 8;
hwSubver = configRegisters[3] & 0xff;
if (hwSubver < 3)
{
}
if (hwVersion == 0)
{
if (configRegisters[0] != 0x0400)
{
uledCount = 4;
}
}
}
var firmwareVersion = new Version(swVersion, swSubver);
var digitalInputCount = diCount;
var digitalOutputCount = doCount;
var analogInputCount = aiCount;
var analogOutputCount = aoCount;
var userLedCount = uledCount;
var hardwareVersion = new Version(hwVersion, hwSubver);
return(new BoardInformation(firmwareVersion, hardwareVersion, digitalInputCount, digitalOutputCount, analogInputCount, analogOutputCount, userLedCount, hwVersion, neuronGroup));
}
catch (Exception e)
{
logger.LogException(null, e);
return(null);
}
}
internal INeuronGroupBoard CreateNeuronBoard(NeuronGroup neuronGroup)
{
try
{
var boardInformationRegisterSet = _spiConnector.GetRegisterValues(neuronGroup, 1000, 5);
var boardInformation = GetBoardInfoFromRegisters(boardInformationRegisterSet, _logger, neuronGroup);
if (boardInformation != null)
{
switch (boardInformation.BoardType)
{
case BoardType.UnknownBoard:
_logger.LogInformation(this, "Board " + boardInformation.BoardType + " not supported!");
break;
case BoardType.B10001:
return(new B10001GroupBoard(neuronGroup, boardInformation, _spiConnector, _i2CConnector, _logger));
case BoardType.E8Di8Ro1:
return(new UniversalNeuronGroupDiRoBoard(8, 8, neuronGroup, boardInformation, _spiConnector, _i2CConnector, _logger));
case BoardType.E14Ro1:
return(new UniversalNeuronGroupDiRoBoard(0, 16, neuronGroup, boardInformation, _spiConnector, _i2CConnector, _logger));
case BoardType.E16Di1:
return(new UniversalNeuronGroupDiRoBoard(16, 0, neuronGroup, boardInformation, _spiConnector, _i2CConnector, _logger));
case BoardType.E8Di8Ro1P11DiMb485:
_logger.LogInformation(this, "Board " + boardInformation.BoardType + " not supported!");
break;
case BoardType.E14Ro1P11DiR4851:
_logger.LogInformation(this, "Board " + boardInformation.BoardType + " not supported!");
break;
case BoardType.E16Di1P11DiR4851:
_logger.LogInformation(this, "Board " + boardInformation.BoardType + " not supported!");
break;
case BoardType.E14Ro1U14Ro1:
_logger.LogInformation(this, "Board " + boardInformation.BoardType + " not supported!");
break;
case BoardType.E16Di1U14Ro1:
return(new UniversalNeuronGroupDiRoBoard(16, 14, neuronGroup, boardInformation, _spiConnector, _i2CConnector, _logger));
case BoardType.E14Ro1U14Di1:
return(new UniversalNeuronGroupDiRoBoard(14, 14, neuronGroup, boardInformation, _spiConnector, _i2CConnector, _logger));
case BoardType.E16Di1U14Di1:
_logger.LogInformation(this, "Board " + boardInformation.BoardType + " not supported!");
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
catch (Exception e)
{
_logger.LogException(this, e);
return(null);
}
return(null);
}
private byte[] TwoPhaseCommunication(NeuronGroup neuronGroup, byte[] messagePhaseOne, byte[] messagePhaseTwo)
{
var returnMessagePhaseOne = new byte[messagePhaseOne.Length];
messagePhaseOne.CopyTo(returnMessagePhaseOne, 0);
var returnMessagePhaseTwo = new byte[messagePhaseTwo.Length];
messagePhaseTwo.CopyTo(returnMessagePhaseTwo, 0);
byte[] correctByte = null;
SpiDevice device;
if (!_devices.TryGetValue(neuronGroup, out device) || device == null)
{
_driverLogger.LogError(this, "Device not found!");
return(null);
}
var crcCheck = false;
var tryCounter = 10;
while (!crcCheck)
{
try
{
if (tryCounter-- < 0)
{
throw new Exception("the spi communication failed!");
}
lock (_spiDeviceLocker)
{
PrepareSpiCommunication(device);
device.TransferFullDuplex(messagePhaseOne, returnMessagePhaseOne);
if (returnMessagePhaseOne[0] == 0)
{
correctByte = new byte[1];
device.Read(correctByte);
}
device.TransferFullDuplex(messagePhaseTwo, returnMessagePhaseTwo);
}
if (correctByte != null)
{
for (var i = 1; i < returnMessagePhaseOne.Length; i++)
{
returnMessagePhaseOne[i - 1] = returnMessagePhaseOne[i];
}
returnMessagePhaseOne[returnMessagePhaseOne.Length - 1] = correctByte[0];
}
var firstCrc = CreateCrc(returnMessagePhaseOne, returnMessagePhaseOne.Length - 2);
var crc = CreateCrc(returnMessagePhaseTwo, returnMessagePhaseTwo.Length - 2, BitConverter.ToUInt16(firstCrc, 0));
if (crc != null &&
crc[0] == returnMessagePhaseTwo[returnMessagePhaseTwo.Length - 2] &&
crc[1] == returnMessagePhaseTwo[returnMessagePhaseTwo.Length - 1])
{
crcCheck = true;
}
else
{
_driverLogger.LogError(this, "CRC Check failed for answer " + string.Join("-", returnMessagePhaseTwo));
Task.Delay(100)?.Wait();
}
}
catch (Exception e)
{
_driverLogger.LogException(this, e);
_driverLogger.LogError(this, "#1 PI->Board " + string.Join("-", messagePhaseOne));
_driverLogger.LogError(this, "#1 PI<-Board " + string.Join("-", returnMessagePhaseOne));
_driverLogger.LogError(this, "#2 PI->Board " + string.Join("-", messagePhaseTwo));
_driverLogger.LogError(this, "#2 PI<-Board " + string.Join("-", returnMessagePhaseTwo));
if (tryCounter < 0)
{
throw;
}
Task.Delay(10)?.Wait();
}
}
return(returnMessagePhaseTwo);
}
internal ushort?GetSingleRegisterValue(NeuronGroup neuronGroup, ushort registerNumber)
{
var result = GetRegisterValues(neuronGroup, registerNumber, 1);
return(result.GetSpiRegisterValue(registerNumber));
}
internal UniqueIdentifier(NeuronGroup group, NeuronResource resource, int number)
{
Resource = resource;
Group = group;
Number = number;
}
