/// <summary>
/// 设置DataPiont的值
/// </summary>
/// <param name="setDpDto"></param>
public void AddDataPointToSetValue(SetDataPointValue setDpDto)
{
var toFindModbusUnit = FindModbusUnit(this.ModbusUnits, setDpDto.DataPointNumber);
if (toFindModbusUnit != null)
{
List <DataPoint> toWriteDataPoints = new List <DataPoint>();
var toWriteDataPoint = toFindModbusUnit.AllDataPoints.FirstOrDefault(p => p.Number == setDpDto.DataPointNumber);
if (toWriteDataPoint != null)
{
var copyDp = toWriteDataPoint.CopyNew();
copyDp.ValueToSet = setDpDto.ValueToSet;
toWriteDataPoints.Add(copyDp);
}
List <List <byte> > requestBytes = ModbusTCP.CreateWriteRegisterCommands(toFindModbusUnit.DataAnalyzeMode, toWriteDataPoints);
foreach (var requestByte in requestBytes)
{
lock (writeMobusThreadLoker)
{
WriteRegisterCommand writeRegisterCommand = new WriteRegisterCommand();
writeRegisterCommand.WriteCommand = requestByte;
toFindModbusUnit.ToWriteRegisterCommands.Enqueue(writeRegisterCommand);
}
}
}
}
private void StopDrivers()
{
if (modbusTCP != null)
{
foreach (ModbusTCPClient client in modbusTCP)
{
client.Dismiss();
}
if (dbhelper != null)
{
modbusTCP.SetAllDevicesDisconnected();
while (dbhelper.HasAnyValuAtBuffers())
{
}
}
modbusTCP = null;
}
if (mailClient != null)
{
mailClient = null;
}
if (archivist != null)
{
archivist = null;
}
IsDriverStarted = false;
Log.Instance.Info("EnMon Sürücü Yöneticisi durduruldu.");
}
public void Init()
{
// Disable SO_REUSEPORT to prevent https://github.com/grpc/grpc/issues/10755
server = new Server(new[] { new ChannelOption(ChannelOptions.SoReuseport, 0) })
{
Services = { ModbusTCP.BindService(new ModbusImpl()) },
Ports = { { Hostname, Port, ServerCredentials.Insecure } }
};
server.Start();
channel = new Channel(Hostname, Port, ChannelCredentials.Insecure);
client = new ModbusTCP.ModbusTCPClient(channel);
}
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
IModbus objModbus = new ModbusTCP(txtCurrentIp.Text);
objModbus.Start();
ShowMsg(MessageBoxIcon.Information, "Connection Success!");
}
catch (Exception ex)
{
ShowMsg(MessageBoxIcon.Error, "Connection Fail!");
}
}
private void WriteModbus()
{
try
{
foreach (var modbusUint in this.ModbusUnits)
{
if (!modbusUint.Connector.IsConnect())
{
modbusUint.Connector.Connect();
}
}
while (CanWirteModbus())
{
foreach (var modbusUint in this.ModbusUnits)
{
if (modbusUint.ToWriteRegisterCommands != null && modbusUint.ToWriteRegisterCommands.Count > 0)
{
WriteRegisterCommand currentWriteRegisterCommand = null;
List <byte> recvBytes = null;
lock (writeMobusThreadLoker)
{
currentWriteRegisterCommand = modbusUint.ToWriteRegisterCommands.Dequeue();
}
if (currentWriteRegisterCommand != null)
{
recvBytes = modbusUint.Connector.Send(currentWriteRegisterCommand.WriteCommand);
if (recvBytes != null)
{
AnalyzeRecivedDataReponse reponse = ModbusTCP.AnalyzeRecivedDataStatic(modbusUint.DataAnalyzeMode, currentWriteRegisterCommand.WriteCommand, recvBytes);
if (reponse.ModbusReponseSuccess && reponse.AnalyzeRecivedDataSuccess)
{
var dataPointsWhoseRealTimeDataChanged = ModbusTCP.SetDataPointValueFromRegisterValue(reponse.Registers, modbusUint.AllDataPoints);
List <DataPointRealValue> dataPointRealValues = DataObjectMapper.ConvertToListFrom(dataPointsWhoseRealTimeDataChanged);
RaiseCurrentReceiveDataChangedEvent(dataPointRealValues);
}
}
}
}
}
}
}
catch (Exception ex)
{
WriteModbus();
}
}
private List <ReadRegisterCommand> GetReadRegisterCommands(List <DataPoint> dataPoints)
{
List <ReadRegisterCommand> readRegisterCommands = new List <ReadRegisterCommand>();
List <List <byte> > requestBytes = ModbusTCP.CreateReadRegisterCommands(dataPoints);
foreach (var requestByte in requestBytes)
{
var readRegisterCommand = new ReadRegisterCommand();
readRegisterCommand.ReadCommand = requestByte;
readRegisterCommands.Add(readRegisterCommand);
}
return(readRegisterCommands);
}
public Item(int ItemID,ModbusTCP.IRTU rtu,string ItemType,tblItemConfig ItemConfig)
{
this.rtu = rtu;
this.ItemConfig = ItemConfig;
this.ItemType = ItemType;
this.ItemID = ItemID;
this._Value = ItemConfig.Value??0;
this._Degree = ItemConfig.Degree;
new System.Threading.Thread(ReadindAction).Start();
// Task task = Task.Run(new Action(ReadindAction));
}
static void Main(string[] args)
{
/*Application.Init();
*
* var app = new Application("org.gtksharp.gtksharp", GLib.ApplicationFlags.None);
* app.Register(GLib.Cancellable.Current);
*
* var win = new MainWindow();
* app.AddWindow(win);
*
* win.Show();
* Application.Run();*/
var modbusTcp = new ModbusTCP();
modbusTcp.Start();
}
private async void StartModbusDriver()
{
// ModbusTCP Config dosyası mevcutsa
if (File.Exists(Constants.ModbusTCPDriverConfigFileLocation))
{
// Ayrı bir thread içerisinde ModbusTCP driver'ı çalıştırılıyor.
Task t1 = Task.Factory.StartNew(() =>
{
modbusTCP = new ModbusTCP(Constants.ModbusTCPDriverConfigFileLocation);
modbusTCP.SetAllDevicesDisconnected();
modbusTCP.StartCommunication();
});
await t1;
}
else
{
Log.Instance.Error("{0}: Modbus Driver Config dosyası bulunamadığı için ModbusDriver başlatılamadı.", this.GetType().Name);
}
}
public void GetDataPointRealValueTest()
{
ModbusTCPServer modbusTCPServer = new ModbusTCPServer();
modbusTCPServer.InitializeFromConfigFile(modbusConfigFile);
List <DataPoint> allDataPointsWhoseRealTimeDataChanged = new List <DataPoint>();
foreach (var modbusUint in modbusTCPServer.ModbusUnits)
{
if (modbusUint.Connector.Connect())
{
int i = 0;
foreach (var readRegisterCommand in modbusUint.AllReadRegisterCommands)
{
++i;
var recvBytes = modbusUint.Connector.Send(readRegisterCommand.ReadCommand);
var sendMsg = string.Format("{0}SendBytes:{1} ", i, readRegisterCommand.ReadCommand.ToString());
Debug.WriteLine(sendMsg);
if (recvBytes != null)
{
var recvMsg = string.Format("{0}RecvBytes:{1} ", i, recvBytes.ToString());
Debug.WriteLine(recvMsg);
AnalyzeRecivedDataReponse reponse = ModbusTCP.AnalyzeRecivedDataStatic(modbusUint.DataAnalyzeMode, readRegisterCommand.ReadCommand, recvBytes);
if (reponse.ModbusReponseSuccess && reponse.AnalyzeRecivedDataSuccess)
{
List <DataPoint> dataPointsWhoseRealTimeDataChanged = ModbusTCP.SetDataPointValueFromRegisterValue(reponse.Registers, modbusUint.AllDataPoints);
allDataPointsWhoseRealTimeDataChanged.AddRange(dataPointsWhoseRealTimeDataChanged);
}
}
else
{
Debug.WriteLine(i + ".RecvBytes: null");
}
}
}
}
}
public void SetDataPointRealValueByFunNun16Test()
{
ModbusTCPServer modbusTCPServer = new ModbusTCPServer();
modbusTCPServer.InitializeFromConfigFile(modbusConfigFile);
foreach (var modbusUint in modbusTCPServer.ModbusUnits)
{
List <DataPoint> dataPointsWhoseRealTimeDataChanged = new List <DataPoint>();
List <DataPoint> dataPoints = new List <DataPoint>();
dataPoints.Add(new DataPoint()
{
DeviceAddress = 1,
StartRegisterAddress = 83,
DataPointType = DataPointType.WriteAndReadByFunNum03,
DataPointDataType = DataPointDataType.F32,
RealTimeValue = -1,
ValueToSet = 101.7
});
List <List <byte> > writeRegisterCommandBytes = ModbusTCP.CreateWriteRegisterCommands(DataAnalyzeMode.DataHighToLow, dataPoints);
if (modbusUint.Connector.Connect())
{
foreach (var writeBytes in writeRegisterCommandBytes)
{
var recvBytes = modbusUint.Connector.Send(writeBytes);
if (recvBytes != null)
{
AnalyzeRecivedDataReponse reponse = ModbusTCP.AnalyzeRecivedDataStatic(modbusUint.DataAnalyzeMode, writeBytes, recvBytes);
if (reponse.ModbusReponseSuccess && reponse.AnalyzeRecivedDataSuccess)
{
dataPointsWhoseRealTimeDataChanged = ModbusTCP.SetDataPointValueFromRegisterValue(reponse.Registers, dataPoints);
}
}
}
}
}
}
public Program()
{
modbusTCP = new ModbusTCP(ipAddress, port);
modbusTCP.Connect();
//int[] response = modbusTCP.ReadInputRegisters(startAddress, qty);
bool[] response = modbusTCP.ReadDiscreteInputs(40001, qty);
modbusTCP.Disconnect();
System.Console.WriteLine("Reg 1: " + response[0].ToString());
System.Console.WriteLine("Reg 2: " + response[1].ToString());
System.Console.WriteLine("Reg 1: " + response[2].ToString());
System.Console.WriteLine("Reg 1: " + response[3].ToString());
System.Console.WriteLine("Reg 1: " + response[4].ToString());
System.Console.WriteLine("Reg 1: " + response[5].ToString());
System.Console.WriteLine("Reg 1: " + response[6].ToString());
System.Console.WriteLine("Reg 1: " + response[7].ToString());
System.Console.WriteLine("Reg 1: " + response[8].ToString());
System.Console.WriteLine("Reg 1: " + response[9].ToString());
}
private void ReadModbus()
{
try
{
foreach (var modbusUint in this.ModbusUnits)
{
if (!modbusUint.Connector.IsConnect())
{
modbusUint.Connector.Connect();
}
}
while (CanReadModbus())
{
foreach (var modbusUint in this.ModbusUnits)
{
foreach (var readRegisterCommand in modbusUint.AllReadRegisterCommands)
{
var recvBytes = modbusUint.Connector.Send(readRegisterCommand.ReadCommand);
if (recvBytes != null)
{
AnalyzeRecivedDataReponse reponse = ModbusTCP.AnalyzeRecivedDataStatic(modbusUint.DataAnalyzeMode, readRegisterCommand.ReadCommand, recvBytes);
if (reponse.ModbusReponseSuccess && reponse.AnalyzeRecivedDataSuccess)
{
List <DataPoint> dataPointsWhoseRealTimeDataChanged = ModbusTCP.SetDataPointValueFromRegisterValue(reponse.Registers, modbusUint.AllDataPoints);
List <DataPointRealValue> dataPointRealValues = DataObjectMapper.ConvertToListFrom(dataPointsWhoseRealTimeDataChanged);
RaiseCurrentReceiveDataChangedEvent(dataPointRealValues);
}
}
}
}
}
}
catch (Exception ex)
{
ReadModbus();
}
}
public static void Main(string[] args)
{
var server = new Server
{
Services = { ModbusTCP.BindService(new ModbusImpl()) },
Ports = { new ServerPort(Hostname, Port, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("Modbus gRPC server listening on port " + Port);
// Console.WriteLine("Press any key to stop the server...");
// Console.ReadKey();
// TODO: Fix this mock later
while (true)
{
Thread.Sleep(1000);
}
server.ShutdownAsync().Wait();
}
static void Main(string[] args)
{
ModbusTCP modbus = new ModbusTCP("192.168.0.115", 502);
modbus.OnException += Modbus_OnException;
modbus.OnResponseData += Modbus_OnResponseData;
modbus.ReadCoilsAsync(1, 1, 0, 2);
var conn = modbus.Connected;
ushort start = 16;
ushort lenght = 2;
// calculate the number of bytes data needs
int numBytes = (lenght / 8 + (lenght % 8 > 0 ? 1 : 0));
byte[] data = new byte[numBytes];
byte[] multipleCoils = new byte[lenght];
multipleCoils[0] = 255;
multipleCoils[1] = 255;
// write data to device
byte[] result = new byte[numBytes];
modbus.WriteMultipleCoils(1, 1, start, lenght, multipleCoils, ref result);
//modbus.WriteSingleCoil(1, 1, start, false, ref result);
//read data from device
modbus.ReadHoldingRegisters(1, 1, start, lenght, ref data);
// convert data into int value
int length2 = data.Length / 2 + Convert.ToInt16(data.Length % 2 > 0);
var word = new int[length2];
for (int x = 0; x < length2; x++)
{
word[x] = data[x * 2] * 256 + data[x * 2 + 1];
Console.WriteLine(word[x]);
}
//convert data into bit value
BitArray bitArray = new BitArray(data);
int[] numbers = new int[bitArray.Count];
for (int i = 0; i < bitArray.Length; i++)
{
numbers[i] = bitArray[i] ? 1 : 0;
Console.WriteLine($"Coil {i} : {numbers[i]}");
}
//var data1 = Convert.ToBoolean(Convert.ToByte("3"));
//var coils = Convert.ToString(data[0],2);
//var reversed = coils.ToArray();
//Array.Reverse(reversed);
//foreach (var item in reversed)
//{
// Console.WriteLine(item);
//}
modbus.OnException -= Modbus_OnException;
modbus.OnResponseData -= Modbus_OnResponseData;
modbus.Disconnect();
Console.ReadLine();
}
public void SetDataPointRealValueByTest()
{
ModbusTCPServer modbusTCPServer = new ModbusTCPServer();
modbusTCPServer.InitializeFromConfigFile(modbusConfigFile);
foreach (var modbusUint in modbusTCPServer.ModbusUnits)
{
List <DataPoint> allDataPointsWhoseRealTimeDataChangeds = new List <DataPoint>();
List <WriteRegisterCommand> allWriterRegisterCommands = new List <WriteRegisterCommand>();
List <DataPoint> canWriteDataPoints =
modbusUint.AllDataPoints.FindAll(p => p.DataPointType == DataPointType.WriteAndReadByFunNum01 ||
p.DataPointType == DataPointType.WriteAndReadByFunNum03);
#region 模拟数据
foreach (var writeDataPoint in canWriteDataPoints)
{
if (writeDataPoint.DataPointType == DataPointType.WriteAndReadByFunNum01)
{
var dataPointNo = Convert.ToInt32(writeDataPoint.Number);
if (dataPointNo % 2 == 0)
{
writeDataPoint.ValueToSet = 1;
}
else
{
writeDataPoint.ValueToSet = 0;
}
}
else if (writeDataPoint.DataPointType == DataPointType.WriteAndReadByFunNum03)
{
writeDataPoint.ValueToSet = Convert.ToDouble(writeDataPoint.Number);
}
}
#endregion
List <List <byte> > requestBytes = ModbusTCP.CreateWriteRegisterCommands(modbusUint.DataAnalyzeMode, canWriteDataPoints);
foreach (var requestByte in requestBytes)
{
WriteRegisterCommand writeRegisterCommand = new WriteRegisterCommand();
writeRegisterCommand.WriteCommand = requestByte;
allWriterRegisterCommands.Add(writeRegisterCommand);
}
if (modbusUint.Connector.Connect())
{
int i = 0;
foreach (var writeRegisterCommand in allWriterRegisterCommands)
{
++i;
var recvBytes = modbusUint.Connector.Send(writeRegisterCommand.WriteCommand);
if (recvBytes != null)
{
AnalyzeRecivedDataReponse reponse = ModbusTCP.AnalyzeRecivedDataStatic(modbusUint.DataAnalyzeMode, writeRegisterCommand.WriteCommand, recvBytes);
if (reponse.ModbusReponseSuccess && reponse.AnalyzeRecivedDataSuccess)
{
var dataPointsWhoseRealTimeDataChanged = ModbusTCP.SetDataPointValueFromRegisterValue(reponse.Registers, modbusUint.AllDataPoints);
allDataPointsWhoseRealTimeDataChangeds.AddRange(dataPointsWhoseRealTimeDataChanged);
}
}
}
}
}
}
void rtu_OnCommStateChanged(ModbusTCP.IRTU sender, int comm_state)
{
SecureDBEntities1 db = new SecureDBEntities1();
tblControllerConfig ctl= db.tblControllerConfig.Where(n => n.ControlID == sender.ControlID).FirstOrDefault();
if (ctl != null)
{
ctl.Comm_state = comm_state;
db.tblDeviceStateLog.Add(
new tblDeviceStateLog()
{
TypeID=10, TypeCode=(short)comm_state, TimeStamp=DateTime.Now, ControlID=sender.ControlID
}
);
db.SaveChanges();
}
db.Dispose();
//throw new NotImplementedException();
}
