private void DataStoreReadFrom(object sender, DataStoreEventArgs e)
{
switch (e.ModbusDataType)
{
case ModbusDataType.Coil:
// Read CoilDiscretes values
// add code here
break;
case ModbusDataType.Input:
// Read InputDiscretes values
// add code here
break;
case ModbusDataType.InputRegister:
// Read InputRegisters values
// add code here
break;
case ModbusDataType.HoldingRegister:
// Read HoldingRegisters values
// add code here
break;
}
if (lblMessage.Text != "Comms Okay")
{
lblMessage.Invoke((MethodInvoker) delegate { lblMessage.Text = "Comms Okay"; });
}
}
internal static DataStoreEventArgs CreateDataStoreEventArgs <T>(ushort startAddress, ModbusDataType modbusDataType, IEnumerable <T> data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
DataStoreEventArgs eventArgs;
if (typeof(T) == typeof(bool))
{
ReadOnlyCollection <bool>?a = new(data.Cast <bool>().ToArray());
eventArgs = new DataStoreEventArgs(startAddress, modbusDataType)
{
Data = DiscriminatedUnion <ReadOnlyCollection <bool>, ReadOnlyCollection <ushort> > .CreateA(a)
};
}
else if (typeof(T) == typeof(ushort))
{
ReadOnlyCollection <ushort>?b = new(data.Cast <ushort>().ToArray());
eventArgs = new DataStoreEventArgs(startAddress, modbusDataType)
{
Data = DiscriminatedUnion <ReadOnlyCollection <bool>, ReadOnlyCollection <ushort> > .CreateB(b)
};
}
else
{
throw new ArgumentException("Generic type T should be of type bool or ushort");
}
return(eventArgs);
}
public void CreateDataStoreEventArgs()
{
var eventArgs = DataStoreEventArgs.CreateDataStoreEventArgs(5, ModbusDataType.HoldingRegister, new ushort[] { 1, 2, 3 });
Assert.AreEqual(ModbusDataType.HoldingRegister, eventArgs.ModbusDataType);
Assert.AreEqual(5, eventArgs.StartAddress);
Assert.AreEqual(new ushort[] { 1, 2, 3 }, eventArgs.Data.B.ToArray());
}
private void Server_Written_to_handler(object sender, DataStoreEventArgs e)
{
MCU_Modbusserver.DataStore.HoldingRegisters[1] = (ushort)(MCU_Modbusserver.DataStore.HoldingRegisters[1] & 0xff7f);
//Console.WriteLine("plcdriver data writen 1 reg "+ e.Data.B[0]+" start adr "+ e.StartAddress);
ushort[] data = new ushort[e.Data.B.Count];
for (int i = 0; i < e.Data.B.Count; i++)
{
data[i] = e.Data.B[i];
}
handleCMD(data);
}
private void Server_Written_to_handler(object sender, DataStoreEventArgs e)
{
MCU_Modbusserver.DataStore.HoldingRegisters[1] = (ushort)(MCU_Modbusserver.DataStore.HoldingRegisters[1] & 0xff7f);
MCU_Modbusserver.DataStore.HoldingRegisters[11] = (ushort)(MCU_Modbusserver.DataStore.HoldingRegisters[11] & 0xff7f);
ushort[] data = new ushort[20];//e.Data.B.Count
if (e.StartAddress >= 1023)
{
data = Copy_modbus_registers(1025, 20);
handleTestCMD(data);
}
}
/// <summary>
/// fires whenever the data on the modbus server changes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Server_Written_to_handler(object sender, DataStoreEventArgs e)
{
//e.Data.B //array representing data
switch (e.StartAddress) //
{
case (ushort)PLC_modbus_server_register_mapping.CMD_ACK: {
// Console.WriteLine(" data {0} written to 22",PLC_Modbusserver.DataStore.HoldingRegisters[e.StartAddress]);
try {
//comand_acknoledged.Release();
} catch (Exception err) {
Console.WriteLine(err);
}
break;
}
case (ushort)PLC_modbus_server_register_mapping.AZ_LEFT_LIMIT: {
break;
}
case (ushort)PLC_modbus_server_register_mapping.AZ_LEFT_WARNING: {
break;
}
case (ushort)PLC_modbus_server_register_mapping.AZ_RIGHT_WARNING: {
break;
}
case (ushort)PLC_modbus_server_register_mapping.AZ_RIGHT_LIMIT: {
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_BOTTOM_LIMIT: {
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_BOTTOM_WARNING: {
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_TOP_WARNING: {
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_TOP_LIMIT: {
break;
}
}
}
private static void DataStore_DataStoreReadFrom(object sender, DataStoreEventArgs e)
{
{
if (e.ModbusDataType == ModbusDataType.HoldingRegister)
{
Console.WriteLine($"\nClient reads {e.ModbusDataType} address {e.StartAddress + 40001} - read {e.Data.B[0]}");
Console.Write("> ");
}
else
{
Console.WriteLine($"\nClient reads {e.ModbusDataType} address {e.StartAddress + 1} - read {e.Data.A[0]}");
Console.Write("> ");
}
}
}
private void DataStore_DataStoreWrittenTo(object sender, DataStoreEventArgs e)
{
if (e.ModbusDataType != ModbusDataType.HoldingRegister) return;
var data = (DataStore)sender;
var newValue = data.HoldingRegisters[e.StartAddress + 1];
modifiedRegister = new Register()
{
Address = e.StartAddress,
Value = newValue
};
Debugger.Log(1, "Debug", modifiedRegister.Value + " | " + newValue);
context.Post((a) => ValueWasWritten?.Invoke(null, modifiedRegister), null);
}
private void DataStore_DataStoreWrittenTo(object sender, DataStoreEventArgs e)
{
if (e != null && e.Data != null)
{
try
{
if (e.Data.Option == Modbus.Utility.DiscriminatedUnionOption.B)
{
LogText($"Written to addr {e.StartAddress} : {e.Data.B[0]}");
}
else
{
LogText($"Written to addr {e.StartAddress} : {e.Data.A[0]}");
}
}
catch (Exception ex)
{
LogText($"Excpetion {ex.Message}");
}
}
}
private void DataStoreWriteTo(object sender, DataStoreEventArgs e)
{
int address = e.StartAddress;
switch (e.ModbusDataType)
{
case ModbusDataType.Coil:
// Write CoilDiscretes values
for (int i = 0; i <= e.Data.A.Count - 1; i++)
{
if (e.Data.A[i])
{
UpdateCD(1, address, "1");
}
else
{
UpdateCD(1, address, "0");
}
address += 1;
}
break;
case ModbusDataType.HoldingRegister:
// Write HoldingRegisters values
for (int i = 0; i <= e.Data.B.Count - 1; i++)
{
UpdateHR(1, address, e.Data.B[i].ToString());
address += 1;
}
break;
}
if (lblMessage.Text != "Comms Okay")
{
lblMessage.Invoke((MethodInvoker) delegate { lblMessage.Text = "Comms Okay"; });
}
}
private static void Modbus_DataStoreWriteTo(object sender, DataStoreEventArgs e)
{
int number = 0;
int Address = e.StartAddress;//e.StartAddress;
switch (e.ModbusDataType)
{
case ModbusDataType.HoldingRegister:
SetInputStatus(68, false);
Console.WriteLine("Holding Register");
Console.WriteLine("address: " + Address.ToString());
Console.WriteLine("length frame: " + e.Data.B.Count.ToString());
Console.Write("data: ");
for (int i = 1; i <= e.Data.B.Count; i++)
{
Console.Write(ModbusProtocol.GetDataHoldingRegister(Address + i) + ",");
}
Console.WriteLine();
ViewModel.VisualizationViewModel.HideMessage();
if (Address == 0)
{
if (GetDataCoils(15) == true)
{
ViewModel.VisualizationViewModel.TurnpikePutDown(SetSpeedTurnpike());
}
else if (GetDataCoils(15) == false)
{
ViewModel.VisualizationViewModel.TurnpikePutUp(SetSpeedTurnpike());
}
}
break;
case ModbusDataType.Coil:
Console.WriteLine("Coil");
Console.WriteLine("address: " + Address.ToString());
Console.WriteLine("length frame: " + e.Data.A.Count.ToString());
Console.Write("data: ");
for (int i = 0; i < e.Data.A.Count; i++)
{
Console.Write(ModbusProtocol.GetDataCoils(Address + i + 1) + ",");
number++;
}
ViewModel.VisualizationViewModel.HideMessage();
SetInputStatus(68, false);
Answers(Address);
CheckAvaliableDeparture();
SetAvaliableTrack1();
SetAvaliableTrack2();
Console.WriteLine("avaliable track: {0}", availableTrack);
Console.WriteLine("avaliable track2: {0}", availableTrack2);
Console.WriteLine("avaliable departure track: {0}", avaliableDeparture);
Console.WriteLine();
break;
}
}
public void CreateDataStoreEventArgs_DataNull()
{
var eventArgs = DataStoreEventArgs.CreateDataStoreEventArgs(5, ModbusDataType.HoldingRegister, default(ushort[]));
}
public void CreateDataStoreEventArgs_InvalidType()
{
var eventArgs = DataStoreEventArgs.CreateDataStoreEventArgs(5, ModbusDataType.HoldingRegister, new int[] { 1, 2, 3 });
}
/// <summary>
/// fires whenever the data on the modbus server changes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Server_Written_to_handler(object sender, DataStoreEventArgs e)
{
//e.Data.B //array representing data
if (is_test)
{
logger.Info(Utilities.GetTimeStamp() + ": recived message from PLC");
}
PLC_last_contact = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
switch (e.StartAddress)
{
case (ushort)PLC_modbus_server_register_mapping.AZ_0_LIMIT: {
bool previous = limitSwitchData.Azimuth_CCW_Limit;
limitSwitchData.Azimuth_CCW_Limit = !Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.AZ_0_LIMIT]);
if (previous != limitSwitchData.Azimuth_CCW_Limit)
{
pLCEvents.PLCLimitChanged(limitSwitchData, PLC_modbus_server_register_mapping.AZ_0_LIMIT, limitSwitchData.Azimuth_CCW_Limit);
}
break;
}
case (ushort)PLC_modbus_server_register_mapping.AZ_0_HOME: {
bool previous = homeSensorData.Azimuth_Home_One;
homeSensorData.Azimuth_Home_One = Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.AZ_0_HOME]);
break;
}
case (ushort)PLC_modbus_server_register_mapping.AZ_0_SECONDARY: {
bool previous = homeSensorData.Azimuth_Home_Two;
homeSensorData.Azimuth_Home_Two = Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.AZ_0_SECONDARY]);
break;
}
case (ushort)PLC_modbus_server_register_mapping.AZ_375_LIMIT: {
bool previous = limitSwitchData.Azimuth_CW_Limit;
limitSwitchData.Azimuth_CW_Limit = !Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.AZ_375_LIMIT]);
if (previous != limitSwitchData.Azimuth_CW_Limit)
{
pLCEvents.PLCLimitChanged(limitSwitchData, PLC_modbus_server_register_mapping.AZ_375_LIMIT, limitSwitchData.Azimuth_CW_Limit);
}
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_10_LIMIT: {
bool previous = limitSwitchData.Elevation_Lower_Limit;
limitSwitchData.Elevation_Lower_Limit = !Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.EL_10_LIMIT]);
if (previous != limitSwitchData.Elevation_Lower_Limit)
{
pLCEvents.PLCLimitChanged(limitSwitchData, PLC_modbus_server_register_mapping.EL_10_LIMIT, limitSwitchData.Elevation_Lower_Limit);
if (limitSwitchData.Elevation_Lower_Limit)
{
logger.Info(Utilities.GetTimeStamp() + ": Elevation Lower Limit Switch Hit");
pushNotification.sendToAllAdmins("LIMIT SWITCH", "Elevation lower limit switch hit");
EmailNotifications.sendToAllAdmins("LIMIT SWITCH", "Elevation lower limit switch hit");
}
}
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_0_HOME: {
bool previous = homeSensorData.Elevation_Home;
homeSensorData.Elevation_Home = Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.EL_0_HOME]);
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_90_LIMIT: {
bool previous = limitSwitchData.Elevation_Upper_Limit;
limitSwitchData.Elevation_Upper_Limit = !Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.EL_90_LIMIT]);
if (previous != limitSwitchData.Elevation_Upper_Limit)
{
pLCEvents.PLCLimitChanged(limitSwitchData, PLC_modbus_server_register_mapping.EL_90_LIMIT, limitSwitchData.Elevation_Upper_Limit);
if (limitSwitchData.Elevation_Upper_Limit)
{
logger.Info(Utilities.GetTimeStamp() + ": Elevation Upper Limit Switch Hit");
pushNotification.sendToAllAdmins("LIMIT SWITCH", "Elevation upper limit switch hit");
EmailNotifications.sendToAllAdmins("LIMIT SWITCH", "Elevation upper limit switch hit");
}
}
break;
}
case (ushort)PLC_modbus_server_register_mapping.Gate_Safety_INTERLOCK: {
bool previous = plcInput.Gate_Sensor;
plcInput.Gate_Sensor = !Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.Gate_Safety_INTERLOCK]);
if (previous != plcInput.Gate_Sensor)
{
if (plcInput.Gate_Sensor)
{
logger.Info(Utilities.GetTimeStamp() + ": gate opened");
pushNotification.sendToAllAdmins("GATE ACTIVITY", "Gate has been opened.");
EmailNotifications.sendToAllAdmins("GATE ACTIVITY", "Gate has been opened.");
}
else
{
logger.Info(Utilities.GetTimeStamp() + ": gate closed");
pushNotification.sendToAllAdmins("GATE ACTIVITY", "Gate has been closed.");
EmailNotifications.sendToAllAdmins("GATE ACTIVITY", "Gate has been closed.");
}
}
break;
}
case (ushort)PLC_modbus_server_register_mapping.E_STOP: {
bool previous = plcInput.Estop;
plcInput.Estop = !Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.E_STOP]);
if (previous != plcInput.Estop)
{
if (plcInput.Estop)
{
logger.Info(Utilities.GetTimeStamp() + ": Estop Hit");
pushNotification.sendToAllAdmins("E-STOP ACTIVITY", "E-stop has been hit.");
EmailNotifications.sendToAllAdmins("E-STOP ACTIVITY", "E-stop has been hit.");
}
else
{
logger.Info(Utilities.GetTimeStamp() + ": Estop released");
pushNotification.sendToAllAdmins("E-STOP ACTIVITY", "E-stop has been released.");
EmailNotifications.sendToAllAdmins("E-STOP ACTIVITY", "E-stop has been released.");
}
}
break;
}
case (ushort)PLC_modbus_server_register_mapping.EL_SLIP_CAPTURE: {
bool previous = plcInput.EL_Slip_CAPTURE;
plcInput.EL_Slip_CAPTURE = Int_to_bool(PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.EL_SLIP_CAPTURE]);
break;
}
}
}
void DataStore_DataStoreWrittenTo(object sender, DataStoreEventArgs e)
{
switch (e.ModbusDataType)
{
case ModbusDataType.HoldingRegister:
for (int i = 0; i < e.Data.B.Count; i++)
{
//Set AO
//e.Data.B[i] already write to
var tmp = regValues.Where(x => x.Register == e.StartAddress + i + 1);
tmp.ElementAt(0).Value = slave.DataStore.HoldingRegisters[e.StartAddress + i + 1];
//e.StartAddress starts from 0
//You can set AO value to hardware here
}
break;
case ModbusDataType.Coil:
break;
}
}
public void CreateDataStoreEventArgs_InvalidType() =>
Assert.Throws <ArgumentException>(() => DataStoreEventArgs.CreateDataStoreEventArgs(5, ModbusDataType.HoldingRegister,
new int[] { 1, 2, 3 }));
public void CreateDataStoreEventArgs_DataNull() =>
Assert.Throws <ArgumentNullException>(() =>
DataStoreEventArgs.CreateDataStoreEventArgs(5, ModbusDataType.HoldingRegister, default(ushort[])));
private static void DataStore_DataStoreWrittenTo(object sender, DataStoreEventArgs e)
{
Console.WriteLine($"\nClient writes {e.ModbusDataType} address {e.StartAddress + 1} - write {e.Data.A[0]}");
Console.Write("> ");
}
