public void GenerateNotificationMessage_SetNotification()
{
// Arrange
mockLogsRepository = new Mock <IRepository <Log> >();
mockModbusTCPService = new Mock <IModbusTCPService>();
var pLCDatas = new List <PLCDataDomain>()
{
new PLCDataDomain
{
Address = 1,
Data = "true",
TypePLC = PLCDataType.Coils,
DataEpressionRule = "x => bool.Parse(x.Data) == true",
NotificationMessage = string.Empty
}
};
var modbusService = new ModbusService(mockModbusTCPService.Object, mockLogsRepository.Object);
// Act
var data = modbusService.GenerateNotificationMessage(pLCDatas);
// Assert
Assert.AreEqual("Error, be careful", data[0].NotificationMessage);
mockLogsRepository.Verify(x => x.Create(It.IsAny <Log>()), Times.Once);
}
public void GetData_GetDataFromModbusService()
{
// Arrange
mockLogsRepository = new Mock <IRepository <Log> >();
mockModbusTCPService = new Mock <IModbusTCPService>();
var pLCDatas = new List <PLCDataDomain>()
{
new PLCDataDomain
{
Address = 1,
Data = "true",
TypePLC = PLCDataType.Coils,
DataEpressionRule = string.Empty,
NotificationMessage = string.Empty
}
};
mockModbusTCPService.Setup(m => m.GetData(pLCDatas)).Returns(pLCDatas);
var modbusService = new ModbusService(mockModbusTCPService.Object, mockLogsRepository.Object);
// Act
var data = modbusService.GetData(pLCDatas);
// Assert
mockModbusTCPService.Verify(s => s.GetData(It.IsAny <List <PLCDataDomain> >()), Times.Once);
mockLogsRepository.Verify(x => x.Create(It.IsAny <Log>()), Times.Never);
}
public ModbusHMIWindowViewModel()
{
_modbusService = new ModbusService();
_modbusService.Device2ValuesRefreshed += _modbusService_Device2ValuesRefreshed;
_modbusService.ValuesRefreshed += _modbusService_ValuesRefreshed;
_dbContext = new HmiDBContext();
_modbusSlaveDevice1 = new ModbusSlaveDeviceService();
}
internal string GetFirstAndEightRegisters(Sensor sensor, ModbusService modbusService)
{
var registers = modbusService.GetAllRegisterForSelectedDevice(new Slave
{
DeviceNumber = (ushort)sensor.Id,
SlaveId = (byte)sensor.GatewayId
});
return(string.Format("Rejestr 1 - {0}, rejestr 8 - {1}", registers[0], registers[7]));
}
internal bool CheckIfSensorIsActive(Sensor sensor, ModbusService modbusService)
{
var activeMode = GetActiveMode();
return(modbusService.CheckActivityStatusOfDevice(new Slave
{
DeviceNumber = (ushort)sensor.Id,
SlaveId = (byte)sensor.GatewayId
}, activeMode));
}
internal Sensor GetSensorStatus(Sensor sensor, ModbusService modbusService)
{
var status = modbusService.GetSensorStatus(new Slave
{
DeviceNumber = (ushort)sensor.Id,
SlaveId = (byte)sensor.GatewayId,
});
sensor.Status = status ? 1 : 0;
return(sensor);
}
public MainForm()
{
InitializeComponent();
_modbusService = new ModbusService();
_serialPortService = new SerialPortService();
Configuration.Instance.LoadConfiguration("configuration.xml");
_enableNodes = GetEnableNodes();
var frequencySensorsReading = GetFrequencySensorReading();
uxCheckStatusTimer.Interval = Convert.ToInt32(frequencySensorsReading);
}
public SerialPortConfigerViewModel()
{
this.modbusService = (ModbusService)IocContainerFactory.GetUnityContainer().Resolve <IModbusService>();
this.OpenOrCloseSerialPortCommand = new DelegateCommand(new Action(this.OpenOrCloseSerialPortCommandExecute));
SerialPort serialPort = this.modbusService.GetCurrentSerialPort();
this.PortName = serialPort.PortName;
this.BaudRate = serialPort.BaudRate;
this.Parity = serialPort.Parity;
this.DataBits = serialPort.DataBits;
this.StopBits = serialPort.StopBits;
this.SerialPortConnecting = serialPort.IsOpen;
}
internal SynchroniseService()
{
_modbusService = new ModbusService();
}
public OperationResult TestProject(int projectId, int cyclesCount, string userId)
{
var project = this.Get(projectId, userId);
var modbusService = new ModbusService(new ModbusSlavesRepository(), false);
var slaveSettings = new List <ModbusApp.Core.Models.GroupSettings>();
foreach (var action in project.Actions)
{
slaveSettings.Add(new ModbusApp.Core.Models.GroupSettings()
{
Id = action.Id,
DeviceId = (byte)action.SlaveAddress,
StartAddress = (ushort)action.StartAddress,
NumberOfRegisters = (ushort)action.NumberOfRegisters,
Types = action.Types.Select(type =>
{
switch (type)
{
case ModbusDataType.Hex:
return(Tuple.Create(2, ModbusApp.Core.Misc.Enums.ModbusDataType.Hex));
case ModbusDataType.SInt16:
return(Tuple.Create(2, ModbusApp.Core.Misc.Enums.ModbusDataType.SInt16));
case ModbusDataType.SInt32:
return(Tuple.Create(4, ModbusApp.Core.Misc.Enums.ModbusDataType.SInt32));
case ModbusDataType.UInt16:
return(Tuple.Create(2, ModbusApp.Core.Misc.Enums.ModbusDataType.UInt16));
case ModbusDataType.UInt32:
return(Tuple.Create(4, ModbusApp.Core.Misc.Enums.ModbusDataType.UInt32));
case ModbusDataType.UtcTimestamp:
return(Tuple.Create(4, ModbusApp.Core.Misc.Enums.ModbusDataType.UtcTimestamp));
case ModbusDataType.String:
return(null);
}
return(null);
}).ToList()
});
}
var operationResult = new OperationResult();
var timerLock = new object();
int cyclesPassedCount = 0;
var timer = new System.Timers.Timer(project.Period * 1000);
if (project.Period > 0)
{
timer.Elapsed += (sender, e) =>
{
cyclesPassedCount += 1;
if (cyclesPassedCount >= cyclesCount)
{
timer.Stop();
}
Monitor.Enter(timerLock);
if (project.ConnectionSettings is IpConnectionSettings)
{
var connectionSettings = project.ConnectionSettings as IpConnectionSettings;
try
{
operationResult.Logs.Add($"Attempting to get data from {connectionSettings.Host}:{connectionSettings.Port}");
var results = modbusService.GetDataFromSlaves(new ModbusApp.Core.Models.MasterSettingsIp()
{
Host = connectionSettings.Host,
IsLoggerEnabled = false,
Period = project.Period,
Port = connectionSettings.Port,
SlaveSettings = slaveSettings,
StatFlushPeriod = project.StatFlushPeriod,
Timeout = project.Timeout
});
operationResult.Logs.Add($"Successfully got data from {connectionSettings.Host}:{connectionSettings.Port}");
operationResult.Results.Add(results.ToDictionary(x => x.Key.ToString(), x => x.Value));
}
catch (Exception ex)
{
operationResult.Logs.Add(ex.Message);
}
}
Monitor.Exit(timerLock);
};
timer.Start();
}
while (timer.Enabled)
{
Thread.Sleep(project.Period * 1000);
}
return(operationResult);
}
internal SensorBgWService()
{
_sensorService = new SensorService();
_sensorRepository = new SensorRepository();
_modbusService = new ModbusService();
}
internal GatewayService()
{
_gatewayRepository = new GatewayRepository();
_sensorRepository = new SensorRepository();
_modbusService = new ModbusService();
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="logger"></param>
/// <param name="tcpHelper"></param>
public HeatSystemController(ILogger <HeatSystemController> logger, ModbusService tcpHelper)
{
_logger = logger;
_modbus = tcpHelper;
}
