private void btnReadHoldingRegisters_Click(object sender, EventArgs e)
{
try
{
if (!modbusClient.Connected)
{
modbusClient.IPAddress = txtIpAddressInput.Text;
modbusClient.Port = int.Parse(txtPortInput.Text);
modbusClient.Connect();
}
int[] serverResponse = modbusClient.ReadHoldingRegisters(int.Parse(txtStartingAddressInput.Text) - 1, int.Parse(txtNumberOfValuesInput.Text));
lsbAnswerFromServer.Items.Clear();
for (int i = 0; i < serverResponse.Length; i++)
{
lsbAnswerFromServer.Items.Add(serverResponse[i]);
}
}
catch (Exception exc)
{
MessageBox.Show(exc.Message, "Exception Reading values from Server", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
modbusClient.Disconnect();
}
}
private void TMR_Read_Tick(object sender, EventArgs e)
{
int[] tmp;
if (modbusClient.Connected)
{
try
{
tmp = modbusClient.ReadHoldingRegisters(iCurrentAddress, 1);
LB_Data.Items.Add(iCurrentAddress + " => " + tmp[0]);
HoldingRegisters[iCurrentAddress] = tmp[0];
}
catch (Exception ex)
{
}
iCurrentAddress++;
if (iCurrentAddress > NUD_MaxAddr.Value)
{
iCurrentAddress = (int)NUD_MaxAddr.Value;
TMR_Read.Enabled = false;
}
}
else
{
TMR_Read.Enabled = false;
}
RefreshGUI();
}
static void Main(string[] args)
{
// int[] registers = EasyModbus.ModbusClient.ConvertStringToRegisters("hello");
// SerialPort serialport = new SerialPort("COM3");
/* serialport.PortName = "COM3";
* serialport.BaudRate = 9600;
* serialport.Parity = Parity.None;
* serialport.StopBits = StopBits.One;
* byte[] buffer = new byte[50];
* serialport.Open();
* byte[] bufferout = new byte[50];
* int numberOfBytesRead = 0;
* do
* {
* int quantity = serialport.Read(buffer, 0, 15);
* Buffer.BlockCopy(buffer, 0, bufferout, numberOfBytesRead, quantity);
* numberOfBytesRead = numberOfBytesRead + quantity;
* }
* while (numberOfBytesRead < 5);
* for (int i = 0; i < 15; i++)
* Console.WriteLine(bufferout[i].ToString());
* serialport.Write("ddddddddd");*/
EasyModbus.ModbusClient modbusClient = new EasyModbus.ModbusClient("COM3");
modbusClient.SerialPort = "COM3";
//EasyModbus.ModbusClient modbusClient = new EasyModbus.ModbusClient("127.0.0.1", 502);
modbusClient.ConnectionTimeout = 5000;
modbusClient.LogFileFilename = "test.txt";
modbusClient.UnitIdentifier = 0xF7;
modbusClient.Connect();
while (true)
{
// Console.WriteLine("Execute FC5");
// modbusClient.WriteSingleCoil(0, true);
// Console.WriteLine("Execute FC6");
// modbusClient.WriteSingleRegister(0, 1234);
// Console.WriteLine("Execute FC15");
// modbusClient.WriteMultipleCoils(0, new bool[] { true, false, true, false, true, false, true });
//Console.WriteLine("Execute FC16");
//modbusClient.WriteMultipleRegisters(0, EasyModbus.ModbusClient.ConvertStringToRegisters("hallo2"));
//modbusClient.Disconnect();
//System.Threading.Thread.Sleep(100);
//modbusClient.Connect();
//Console.WriteLine("Execute FC3");
//Console.WriteLine("Value of Holding Register 1000: " + modbusClient.ReadHoldingRegisters(1000, 1)[0]);
Console.WriteLine("Read and Publish Input Registers");
modbusClient.WriteSingleRegister(60, 1234);
int[] holdingRegister = modbusClient.ReadHoldingRegisters(60, 2);
//Console.WriteLine(holdingRegister[0]);
// System.Threading.Thread.Sleep(1000);
}
modbusClient.Disconnect();
Console.ReadKey();
}
public void TestEasyModbus()
{
EasyModbus.ModbusClient mc = new EasyModbus.ModbusClient()
{
IPAddress = "127.0.0.1",
Port = 502,
ConnectionTimeout = 5 * 1000,
};
mc.Connect();
if (mc.Connected)
{
var data = mc.ReadHoldingRegisters(0, 10);
Console.WriteLine(string.Join(" ", data));
}
}
public void ThenTheResultShouldBeInt()
{
try
{
int[] serverResponse = mdbus.ReadHoldingRegisters(2279, 3);
for (int i = 0; i < serverResponse.Length; i++)
{
IoC.Logger.Log($"{2279 + i} value {serverResponse[i]}", LogLevel.Informative);
}
WhenIPressDisconnect();
}
catch (Exception)
{
throw;
}
}
public static void ReadRegisters(int start, int length)
{
if (PLC.Connected)
{
int[] data = new int[length];
GVL.readexc = false;
try
{
data = PLC.ReadHoldingRegisters(start, length);
for (int i = 0; i < length; i++)
{
GVL.registers[i + start] = data[i];
}
}
catch (EasyModbus.Exceptions.ModbusException e)
{
GVL.readexc = true;
for (int i = 0; i < length; i++)
{
GVL.registers[i + start] = -200;
}
MessageBox.Show("Error Read Registers : " + e.Message, "Info", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (System.Net.Sockets.SocketException e)
{
GVL.readexc = true;
for (int i = 0; i < length; i++)
{
GVL.registers[i + start] = -500;
}
MessageBox.Show("Error Socket Registers : " + e.Message, "Info", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (System.IO.IOException e)
{
GVL.readexc = true;
for (int i = 0; i < length; i++)
{
GVL.registers[i + start] = -501;
}
//MessageBox.Show("Error PLC connection : " + e.Message, "Info", MessageBoxButtons.OK, MessageBoxIcon.Error);
MessageBox.Show("Error PLC connection.", "Connection", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <summary>
/// Read Holding Registers from Master device (Function code 3)
/// </summary>
/// <param name="startingAddress">the first holding register address to be read</param>
/// <param name="quantity">number of holding registers to be read</param>
public int[] ReadHoldingRegisters(int startingAddress, int quantity)
{
try
{
if (!modbusClient.Connected)
{
return(null);
}
else
{
return(modbusClient.ReadHoldingRegisters(startingAddress - 1, quantity));
}
}
catch (Exception ex)
{
// log this error in to log file.
IoC.Logger.Log($"{ex.Message}");
// inform the user about this error
IoC.Communication.Log += $"{DateTime.Now.ToLocalTime():MM/dd/yy HH:mm:ss.fff}: Exception occurred. {ex.Message}.\n";
return(null);
}
}
public void GetValues(ConnectionProperties connectionProperties)
{
modbusClient = connectionProperties.modbusClient;
if (!modbusClient.Connected)
{
modbusClient.IPAddress = connectionProperties.ModbusTCPAddress;
modbusClient.Port = connectionProperties.Port;
modbusClient.Connect();
}
foreach (FunctionProperties functionProperty in connectionProperties.FunctionPropertiesList)
{
switch (functionProperty.FunctionCode)
{
case FunctionCode.ReadCoils:
functionProperty.values = modbusClient.ReadCoils(functionProperty.StartingAdress, functionProperty.Quantity);
break;
case FunctionCode.ReadDiscreteInputs:
functionProperty.values = modbusClient.ReadDiscreteInputs(functionProperty.StartingAdress, functionProperty.Quantity);
break;
case FunctionCode.ReadHoldingRegisters:
functionProperty.values = modbusClient.ReadHoldingRegisters(functionProperty.StartingAdress, functionProperty.Quantity);
break;
case FunctionCode.ReadInputRegisters:
functionProperty.values = modbusClient.ReadInputRegisters(functionProperty.StartingAdress, functionProperty.Quantity);
break;
default: break;
}
}
if (valuesChanged != null)
{
valuesChanged(this);
}
}
private void ConnectPLC(object item)
{
try
{
List <string[]> informations = excelInfors.FindAll(x => x[1] != "" && x[2] != "" && x[3] != "");
float Temperature = 0;
float Humidity = 0;
foreach (string[] infor in informations)
{
float value = 0;
var tagName = infor[0];
var ip = (string)infor[1];
var port = Int32.Parse(infor[2]);
EasyModbus.ModbusClient modbusClient = new EasyModbus.ModbusClient(ip, port);
try
{
////Increase the Connection Timeout to 5 seconds
modbusClient.ConnectionTimeout = 5000;
modbusClient.Connect();
var address = Int32.Parse(infor[3]);
var length = Int32.Parse(infor[4]);
int[] holdingRegister = modbusClient.ReadHoldingRegisters(address - 1, length);
var rawValue = holdingRegister[0];
value = Convert.ToSingle(Decimal.Divide(rawValue, 10));
}
catch (Exception ex)
{
}
try
{
using (SqlConnection connection = new SqlConnection(conString))
using (SqlCommand command = new SqlCommand("Insert into [ADVANTECH WISE-4220] (Time, TagName, Value, MachineIRAI, SensorIRAI) values(@date,@tagName,@value,@irai,@sensorIrai)", connection))
{
command.Parameters.AddWithValue("date", System.DateTime.Now);
command.Parameters.AddWithValue("tagName", tagName);
command.Parameters.AddWithValue("value", value);
command.Parameters.AddWithValue("irai", infor[5]);
command.Parameters.AddWithValue("sensorIrai", infor[6]);
connection.Open();
command.ExecuteNonQuery();
connection.Close();
}
}
catch (Exception ex)
{
}
if (tagName == "Temperature")
{
Temperature = value;
}
if (tagName == "Humidity")
{
Humidity = value;
}
PropertyState matrix = (PropertyState)FindPredefinedNode(new NodeId(infor[0], NamespaceIndex), typeof(PropertyState));
matrix.Value = value;
matrix.ClearChangeMasks(SystemContext, true);
modbusClient.Disconnect();
}
var data = new Record();
data.Temperature = Temperature;
data.Humidity = Humidity;
MongoHelper.Asset.UpdatePrimaryValue("0990-MY.0027101.0000000001-#TS-00058200.0000000005.0002", data);
}
catch (Exception e)
{
Utils.Trace(e, "Unexpected error during simulation.");
}
}
private void UpdateTimer_Elapsed(object sender, ElapsedEventArgs e)
{
lock (locker)
{
if (modbusClient != null)
{
updateTimer.Stop();
DateTime updateStart = DateTime.Now;
bool updateSucces = false;
int[] inverterResponse = null;
int[] meterResponse = null;;
TimeSpan inverterReadDuration = TimeSpan.MinValue;
TimeSpan meterReadDuration = TimeSpan.MinValue;
string ExceptionText = "";
try
{
if (!ConnectionEstablished)
{
try
{
ConnectToModBus();
log.Debug($"Modbus connection established for {IPAdress}:{ModBusPort}");
}
catch (Exception E)
{
log.Debug($"A exeception occured while establishing Modbos connection to {IPAdress}:{ModBusPort}. {E.Message}", E);
throw new Exception($"A exeception occured while establishing Modbos connection to {IPAdress}:{ModBusPort} {E.Message}", E);
}
}
if (ReadInverterData)
{
try
{
DateTime StartTime = DateTime.Now;
inverterResponse = modbusClient.ReadHoldingRegisters(inverterStartPos, inverterNumberOfRegisters);
inverterReadDuration = DateTime.Now - StartTime;
log.Debug($"Inverter data read: {inverterReadDuration.TotalMilliseconds}ms");
}
catch (Exception E)
{
log.Debug($"Reading inverter data failed. {E.Message}", E);
throw new Exception($"Reading inverter data failed. {E.Message}", E);
}
if (inverterResponse == null || inverterResponse.All(v => v == 0))
{
log.Debug("No valid data received from inverter.");
throw new Exception("No valid data received from inverter.");
}
}
if (ReadMeterData)
{
try
{
DateTime StartTime = DateTime.Now;
meterResponse = modbusClient.ReadHoldingRegisters(meterStartPos, meterNumberOfRegisters);
meterReadDuration = DateTime.Now - StartTime;
log.Debug($"Meter data read: {meterReadDuration.TotalMilliseconds}ms");
}
catch (Exception E)
{
log.Debug($"Reading meter data failed. {E.Message}", E);
throw new Exception($"Reading meter data failed. {E.Message}", E);
}
if (meterResponse == null || meterResponse.All(v => v == 0))
{
log.Debug("No valid data received from inverter.");
throw new Exception("No valid data received from inverter.");
}
}
}
catch (Exception E)
{
ExceptionText = E.Message;
}
if (!ExceptionText.IsNullOrWhiteSpace())
{
log.Debug($"Exception occured while establishing the connection or while reading data.\n{ExceptionText}");
DisconnectFromModbus();
}
else
{
ModbusDataUpdater U = new ModbusDataUpdater();
try
{
switch (DataUpdateMode)
{
case DataUpdateModeEnum.UpdateExistingObjects:
lock (DataLocker)
{
if (SolarEdgeFullData == null)
{
SolarEdgeFullData = new SolarEdgeFullData();
}
if (ReadInverterData)
{
U.UpdateData(inverterResponse, inverterStartPos, SolarEdgeFullData);
}
if (ReadMeterData)
{
U.UpdateData(meterResponse, meterStartPos, SolarEdgeFullData);
}
if (_SolarEdgeBaseData == null)
{
SolarEdgeBaseData = new SolarEdgeBaseData();
}
if (ReadInverterData)
{
U.UpdateData(inverterResponse, inverterStartPos, SolarEdgeBaseData);
}
if (ReadMeterData)
{
U.UpdateData(meterResponse, meterStartPos, SolarEdgeBaseData);
}
};
break;
case DataUpdateModeEnum.CreateNewObjects:
SolarEdgeFullData FD = new SolarEdgeFullData();
if (ReadInverterData)
{
U.UpdateData(inverterResponse, inverterStartPos, FD);
}
if (ReadMeterData)
{
U.UpdateData(meterResponse, meterStartPos, FD);
}
SolarEdgeBaseData BD = new SolarEdgeBaseData();
if (ReadInverterData)
{
U.UpdateData(inverterResponse, inverterStartPos, BD);
}
if (ReadMeterData)
{
U.UpdateData(meterResponse, meterStartPos, BD);
}
lock (DataLocker)
{
SolarEdgeFullData = FD;
SolarEdgeBaseData = BD;
};
break;
default:
log.Error($"Unknown {nameof(DataUpdateMode)} {DataUpdateMode}");
throw new Exception($"Unknown {nameof(DataUpdateMode)} {DataUpdateMode}");
}
successiveFailCount = 0;
updateSucces = true;
log.Debug("Data successfully updated");
}
catch (Exception E)
{
successiveFailCount++;
log.Warn($"Updating data failed. {E.Message}", E);
if (successiveFailCount > maxSuccessiveFails)
{
DisconnectFromModbus();
log.Debug($"Disconnected from Modbus on {IPAdress}:{ModBusPort}\n{ExceptionText}. Data update failed more than {maxSuccessiveFails} times.");
successiveFailCount = 0;
}
}
}
if (updateSucces)
{
LastDataUpdate = DateTime.Now;
SolarEdgeDataIsValid = true;
StartDataValidTimeoutTimer();
OnSolarEdgeDataUpdated();
}
else
{
OnSolarEdgeDataUpdateFailed();
}
int totalUpdateDurationMs = (int)(DateTime.Now - updateStart).TotalMilliseconds;
int sleepDurationMs = (RefreshIntervalMs - totalUpdateDurationMs).Limit(MinIntervalBetweenUpdatesMs.Limit(10, int.MaxValue), int.MaxValue);
log.Debug($"Update duration {totalUpdateDurationMs}ms. Will wait for {sleepDurationMs}ms before next update.");
updateTimer.Interval = sleepDurationMs;
updateTimer.Start();
}
else
{
log.Warn($"{nameof(modbusClient)} is null. Most likely Stop has been called.");
}
}
}
