private void SendNextMessage(NandakaDevice device)
{
MasterSession session = _deviceSessions[device.Address];
ISpecificMessage specificMessage = default;
try
{
if (device.TryGetSpecific(out specificMessage))
{
session.ProcessSpecificMessage(specificMessage);
}
else
{
session.ProcessNextMessage();
}
_dispatcher.OnMessageReceived(device);
}
catch (DeviceNotRespondException deviceNotRespondException)
{
_log.AppendMessage(LogMessageType.Warning, deviceNotRespondException.Message);
_dispatcher.OnErrorOccured(device, DeviceError.NotResponding);
}
catch (InvalidAddressException invalidAddressException)
{
_log.AppendMessage(LogMessageType.Error, invalidAddressException.Message);
_dispatcher.OnUnexpectedDeviceResponse(device, invalidAddressException.ReceivedAddress);
}
catch (InvalidMessageException invalidMessageException)
{
_log.AppendMessage(LogMessageType.Error, invalidMessageException.ToString());
_dispatcher.OnErrorOccured(device, DeviceError.WrongPacketData);
}
}
private void Routine()
{
try
{
while (true)
{
if (_isStopped)
{
break;
}
NandakaDevice device = _dispatcher.GetNextDevice();
_log.AppendMessage(LogMessageType.Info, $"Set current device: {device}");
SendNextMessage(device);
}
}
catch (Exception exception)
{
_log.AppendMessage(LogMessageType.Error, "Unexpected error occured");
_log.AppendMessage(LogMessageType.Error, exception.ToString());
Dispose();
}
_log.AppendMessage(LogMessageType.Warning, "Master thread has been stopped");
}
private SlaveSession(NandakaDevice device, IProtocol protocol, ILog log)
{
_device = device;
_protocol = protocol;
_log = log;
_listener = new MessageListener(protocol);
}
public static SlaveThread Create(NandakaDevice device, IProtocol protocol, ILog log)
{
var threadLog = new PrefixLog(log, $"[{device.Name} Slave]");
var session = SlaveSession.Create(device, protocol, threadLog);
return(new SlaveThread(session, threadLog));
}
public IRegisterMessage GetNextMessage(NandakaDevice device)
{
IRegisterGroup[] writeOnlyGroupsToUpdate = device.RegisterGroups
.Where(group => group.RegisterType == RegisterType.ReadWrite)
.Where(group => !group.IsUpdated)
.OrderBy(group => group.Address)
.ToArray();
if (!writeOnlyGroupsToUpdate.IsEmpty())
{
return(new CommonMessage(device.Address, MessageType.Request, OperationType.Write, writeOnlyGroupsToUpdate));
}
IRegisterGroup[] readOnlyGroupsToUpdate = device.RegisterGroups
.Where(group => group.RegisterType == RegisterType.Read)
.OrderBy(group => group.LastUpdateTime)
.ThenBy(group => group.Address)
.ToArray();
if (!readOnlyGroupsToUpdate.IsEmpty())
{
return(new CommonMessage(device.Address, MessageType.Request, OperationType.Read, readOnlyGroupsToUpdate));
}
return(new EmptyMessage());
}
public MasterSession(IProtocol protocol, NandakaDevice slaveDevice, MasterDeviceDispatcher dispatcher, ILog log)
{
_log = new PrefixLog(log, $"[{slaveDevice.Name} Session]");
_protocol = protocol;
_slaveDevice = slaveDevice;
_registersUpdatePolicy = slaveDevice.UpdatePolicy;
_dispatcher = dispatcher;
}
public IRegisterMessage GetNextMessage(NandakaDevice device)
{
IRegisterGroup[] orderedByVersionGroups = device.RegisterGroups
.OrderBy(group => group.LastUpdateTime)
.ToArray();
RegisterType firstGroupType = orderedByVersionGroups.First().RegisterType;
IRegisterGroup[] groupsToUpdate = orderedByVersionGroups
.Where(group => group.RegisterType == firstGroupType)
.ToArray();
OperationType operationType = firstGroupType == RegisterType.ReadWrite
? OperationType.Write
: OperationType.Read;
return(new CommonMessage(device.Address, MessageType.Request, operationType, groupsToUpdate));
}
public static SlaveSession Create(NandakaDevice device, IProtocol protocol, ILog log)
{
var sessionLog = new PrefixLog(log, "[Session]");
return(new SlaveSession(device, protocol, sessionLog));
}
