/// <summary>
/// Set state relay by index
/// </summary>
/// <param name="master">modbus transport</param>
/// <param name="index">aim index relay</param>
/// <param name="value">aim value relay</param>
public void SetRelayState(IModbusMaster master, int index, bool value)
{
var answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays);
Thread.Sleep(10);
var state = SetBitToUShortArray(answer, index, value);
master.WriteMultipleRegisters(_address, RegisterStartRelays, state);
//answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays);
//if (state != answer)
// throw new Exception(string.Format("Relay not setted(must by {0} but now {1})", state, answer));
}
public static void ReadRegisters(IModbusMaster master)
{
var result = master.ReadHoldingRegisters(1, 0, 5);
for (int i = 0; i < 5; i++)
{
if (result[i] != i + 1)
throw new Exception();
}
}
/// <summary>
/// Set state multiply relay by index
/// </summary>
/// <param name="master">modbus transport</param>
/// <param name="values">aim values relays</param>
public void SetRelayState(IModbusMaster master, IDictionary<int, bool> values)
{
var answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays);
var state = answer;
Thread.Sleep(10);
foreach (var value in values)
{
state = SetBitToUShortArray(answer, value.Key, value.Value);
}
master.WriteMultipleRegisters(_address, RegisterStartRelays, state);
_relays = state;
//Thread.Sleep(50);
//answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays);
//if (state != answer)
// throw new Exception(string.Format("Relay not setted(must by {0} but now {1})", state, answer));
}
/// <summary>
/// Возвращает состояние дискретного выхода
/// </summary>
/// <param name="registerAddress">Адрес дискретного выхода</param>
public bool ReadHoldingRegister(ushort registerAddress)
{
if (!_connectionEstablished)
{
throw new InvalidOperationException(_connectionErrorMessage);
}
try
{
_logger.Trace($"Controller: {_controllerId}|ReadHoldingRegister ({registerAddress})");
var value = _client.ReadHoldingRegisters(_slaveAddress, (ushort)(registerAddress), 1)[0] == 1;
_logger.Trace($"Controller: {_controllerId}|{registerAddress} == {value}");
return(value);
}
catch
{
_connectionEstablished = false;
throw;
}
}
/// <summary>
/// Read state all state relay
/// </summary>
/// <param name="master">Транспорт</param>
/// <returns>Список изменившихся входов</returns>
public void UpdateAllStateRelay(IModbusMaster master)
{
_relays = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays);
}
private bool ModbusUpdate()
{
try
{
lock (m_syncObject)
{
switch (state)
{
case State.Read:
try
{
rdBuf = m_mbMaster.ReadHoldingRegisters(slaveaddr, read_start_addr, read_regs_number);
state = State.New;
Array.Copy(rdBuf, date_ind, date_regs, 0, 3); //++
Array.Copy(rdBuf, id_ind, ID, 0, 6); //++
Array.Copy(rdBuf, src_ind, src_num_regs, 0, 2); //++
Array.Copy(rdBuf, md5_ind, md5_regs, 0, 8); //++
Read_reg = rdBuf[19]; //++
ver_reg = rdBuf[39]; //++
Status_lbl.Invoke((MethodInvoker) delegate
{
Status_lbl.Text = "Подключен";
});
mb_ok++;
is_connected = true;
if (mb_ok > mb_tresh)
{
mb_ok = 0;
error_cnt = 0;
}
}
catch (Exception ex)
{
string strcgc = ex.Message;
m_lastError = "Ошибка чтения";
error_cnt++;
Status_lbl.Invoke((MethodInvoker) delegate
{
Status_lbl.Text = m_lastError + " " + error_cnt.ToString();
});
if (error_cnt > mb_tresh)
{
is_connected = false;
}
state = State.New;
return(false);
}
break;
case State.Write:
try
{
state = State.Set;
}
catch (Exception ex)
{
return(false);
}
break;
case State.New:
break;
case State.Set:
state = State.Read;
break;
}
}
return(true);
}
catch (Exception ex)
{
m_lastError = ex.Message;
return(false);
}
}
public ushort Read_reg(byte addr, ushort reg_addr, ushort num, string str, bool need = true)
{
ushort one_reg = 0xFF;
ushort[] buf;
try
{
switch (str)
{
case "input":
buf = master.ReadInputRegisters(addr, reg_addr, num);
one_reg = buf[0];
if (need == true)
{
for (int i = 0; i < buf.Length; i++)
{
output += (addr).ToString("D3") + ":" + (reg_addr + i).ToString("D3") + " " + str + ": " + buf[i].ToString("D5") + "\n";
}
}
break;
case "holding":
buf = master.ReadHoldingRegisters(addr, reg_addr, num);
one_reg = buf[0];
if (need == true)
{
for (int i = 0; i < buf.Length; i++)
{
output += (addr).ToString("D3") + ":" + (reg_addr + i).ToString("D3") + " " + str + ": " + buf[i].ToString("D5") + "\n";
}
}
break;
default:
reg_addr = 31;
num = 1;
buf = master.ReadInputRegisters(addr, reg_addr, num);
one_reg = buf[0];
buf = master.ReadInputRegisters(addr, (ushort)(reg_addr + 1), (ushort)(one_reg * 8));
if (need == true)
{
for (int i = 0; i < buf.Length; i++)
{
if (i % 8 == 0)
{
output += "\n";
}
if (i % 8 < 4)
{
output += ((byte)buf[i]).ToString("X2") + ((byte)(buf[i] >> 8)).ToString("X2");
}
if (i % 8 == 4)
{
output += " " + ((double)buf[i] / 10).ToString("F1") + " ";
}
if (i % 8 > 4)
{
output += buf[i].ToString() + " ";
}
}
output += "\n";
}
break;
}
}
catch
{
output += (addr).ToString("D3") + " " + str + ":" + "Time out\n";
}
RaisePropertyChanged("Terminal");
return(one_reg);
}
private void Connect_check()
{
COM1.BaudRate = br_enum[Baudrate.SelectedIndex];
switch (Databits.SelectedIndex)
{
case 0: COM1.DataBits = 8; break;
case 1: COM1.DataBits = 9; break;
}
switch (Parity.SelectedIndex)
{
case 0: COM1.Parity = System.IO.Ports.Parity.None; break;
case 1: COM1.Parity = System.IO.Ports.Parity.Odd; break;
case 2: COM1.Parity = System.IO.Ports.Parity.Even; break;
default: COM1.Parity = System.IO.Ports.Parity.None; break;
}
switch (Stopbit.SelectedIndex)
{
case 0: COM1.StopBits = System.IO.Ports.StopBits.One; break;
case 1: COM1.StopBits = System.IO.Ports.StopBits.Two; break;
case 2: COM1.StopBits = System.IO.Ports.StopBits.OnePointFive; break;
default: COM1.StopBits = System.IO.Ports.StopBits.None; break;
}
status_line.Text = null;
checkBox1.CheckState = CheckState.Unchecked;
try
{
if (!COM1.IsOpen)
{
COM1.Open();
}
//Thread read =
//m_mbMaster = ModbusSerialMaster.CreateRtu(COM1);
//m_mbMaster.Transport.ReadTimeout = 1000;
//m_state = WorkState.Update;
ushort[] tBuf = m_mbMaster.ReadHoldingRegisters(0, 90, 10);
if ((tBuf[0] == 0x0102) && (tBuf[9] == 0x01))
{
status_line.Text = " Подключен ";
IsConnected = true;
checkBox1.CheckState = CheckState.Checked;
baudrate_label.BackColor = Color.Green;
baudrate_label.Text = "Set";
databits_label.BackColor = Color.Green;
databits_label.Text = "Set";
parity_label.BackColor = Color.Green;
parity_label.Text = "Set";
stopbit_label.BackColor = Color.Green;
stopbit_label.Text = "Set";
addr_label.BackColor = Color.Green;
addr_label.Text = "Set";
}
}
catch (Exception ex)
{
status_line.Text = " Ошибка подключения";
checkBox1.CheckState = CheckState.Unchecked;
MessageBox.Show(ex.Message, "Ошибка !!!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//if(!COM1.IsOpen)
//{
// COM1.Open();
// m_mbMaster = ModbusSerialMaster.CreateRtu(COM1);
//}
// rxBuf = m_mbMaster.ReadHoldingRegisters(0, 20, 1);
}
/// <summary>
/// Метод для считывния содержимого с регистров выхода (AO - на модуле, сигнал от модуля )
/// Read holding registers value
/// </summary>
/// <param name="slaveID">Address of device to read values from</param>
/// <param name="startAddress">Address to begin reading.</param>
/// <param name="numOfPoints">Number of holding registers to read</param>
/// <returns> ushort[] </returns>
public ushort[] ReadHoldingRegistr(byte slaveID, ushort startAddress, ushort numOfPoints) // функциональный код 03
{
return(NetworkIsOk ? master.ReadHoldingRegisters(slaveID, startAddress, numOfPoints) : null);
}
protected void ReadBuffer(ModbusBaseClientStation self, IModbusMaster master, ModbusBuffer buf)
{
try
{
ushort[] registers;
byte[] adr;
bool[] inputs;
if (buf.pauseCounter == 0)
{
ushort startAddress = buf.startAddress;
ushort numInputs = buf.numInputs;
switch (buf.ModbusDataType)
{
case ModbusDataTypeEx.InputRegister:
case ModbusDataTypeEx.HoldingRegister:
if (buf.ModbusDataType == ModbusDataTypeEx.InputRegister)
{
registers = master.ReadInputRegisters(buf.slaveId, startAddress, numInputs);
}
else
{
registers = master.ReadHoldingRegisters(buf.slaveId, startAddress, numInputs);
}
DateTime dt = DateTime.Now;
int iresult = 0;
uint uresult = 0;
double fresult = 0.0;
foreach (ModbusChannelImp ch in buf.channels)
{
switch (ch.DeviceDataType)
{
case ModbusDeviceDataType.Int:
adr = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]);
switch (ch.ConversionType)
{
case ModbusConversionType.SwapBytes:
byte tmp = adr[0]; adr[0] = adr[1]; adr[1] = tmp;
iresult = BitConverter.ToInt16(adr, 0);
break;
default:
iresult = BitConverter.ToInt16(adr, 0);
break;
}
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32)
{
ch.DoUpdate(iresult, dt, ChannelStatusFlags.Good);
}
else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double)
{
ch.DoUpdate((double)(ch.K * iresult + ch.D), dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
break;
case ModbusDeviceDataType.UInt:
adr = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]);
switch (ch.ConversionType)
{
case ModbusConversionType.SwapBytes:
byte tmp = adr[0]; adr[0] = adr[1]; adr[1] = tmp;
uresult = BitConverter.ToUInt16(adr, 0);
break;
default:
uresult = BitConverter.ToUInt16(adr, 0);
break;
}
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.UInt32)
{
ch.DoUpdate(uresult, dt, ChannelStatusFlags.Good);
}
else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double)
{
ch.DoUpdate((double)(ch.K * uresult + ch.D), dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
break;
case ModbusDeviceDataType.DInt:
byte[] adr0 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]);
byte[] adr1 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + 1]);
byte[] res = new byte[4];
res = self.SwapBytesIn(adr0, adr1, ch.ConversionType);
iresult = BitConverter.ToInt32(res, 0);
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32)
{
ch.DoUpdate(iresult, dt, ChannelStatusFlags.Good);
}
else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double)
{
ch.DoUpdate((double)(ch.K * iresult + ch.D), dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
break;
case ModbusDeviceDataType.DUInt:
adr0 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]);
adr1 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + 1]);
res = self.SwapBytesIn(adr0, adr1, ch.ConversionType);
uresult = BitConverter.ToUInt32(res, 0);
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.UInt32)
{
ch.DoUpdate(uresult, dt, ChannelStatusFlags.Good);
}
else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double)
{
ch.DoUpdate((double)(ch.K * uresult + ch.D), dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
break;
case ModbusDeviceDataType.Float:
adr0 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]);
adr1 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + 1]);
res = self.SwapBytesIn(adr0, adr1, ch.ConversionType);
fresult = BitConverter.ToSingle(res, 0);
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double)
{
ch.DoUpdate((double)(ch.K * fresult + ch.D), dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
break;
case ModbusDeviceDataType.Bool:
bool bit = (registers[ch.ModbusDataAddress - buf.startAddress] & (0x01 << ch.BitIndex)) > 0;
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Boolean)
{
ch.DoUpdate(bit, dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
break;
case ModbusDeviceDataType.String:
byte[] str = new byte[2 * ch.DeviceDataLen];
Decoder ascii = (new ASCIIEncoding()).GetDecoder();
int bytesUsed = 0;
int charsUsed = 0;
bool completed = false;
int j = 0;
// Conversion strategy: FIRST NONPRINTABLE CHARACTER (ORD < 32) BREAKS CONVERSION, string consists of printables converted before
for (int i = 0; i < ch.DeviceDataLen; i++)
{
byte[] word = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + i]);
if (ch.ConversionType == ModbusConversionType.SwapBytes)
{
if (word[1] < 32)
{
break; // nonprintable character
}
str[j++] = word[1];
if (word[0] < 32)
{
break; // nonprintable character
}
str[j++] = word[0];
}
else
{
if (word[0] < 32)
{
break; // nonprintable character
}
str[j++] = word[0];
if (word[1] < 32)
{
break; // nonprintable character
}
str[j++] = word[1];
//Array.Copy(BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + i]), 0, str, 2 * i, 2);
}
}
string sresult;
if (j > 0)
{
char[] chars = new char[j];
ascii.Convert(str, 0, j, chars, 0, j, true, out bytesUsed, out charsUsed, out completed);
sresult = new String(chars);
}
else
{
sresult = "";
}
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.String)
{
ch.DoUpdate(sresult, dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
break;
}
}
break;
case ModbusDataTypeEx.Coil:
case ModbusDataTypeEx.Input:
if (buf.ModbusDataType == ModbusDataTypeEx.Coil)
{
inputs = master.ReadCoils(buf.slaveId, startAddress, numInputs);
}
else
{
inputs = master.ReadInputs(buf.slaveId, startAddress, numInputs);
}
dt = DateTime.Now;
foreach (ModbusChannelImp ch in buf.channels)
{
if (ch.ModbusFs2InternalType == ModbusFs2InternalType.UInt32)
{
uint val = (uint)(inputs[ch.ModbusDataAddress - buf.startAddress] ? 1 : 0);
ch.DoUpdate(val, dt, ChannelStatusFlags.Good);
}
else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Boolean)
{
bool val = inputs[ch.ModbusDataAddress - buf.startAddress];
ch.DoUpdate(val, dt, ChannelStatusFlags.Good);
}
else
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert,
self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString()));
}
}
break;
} // Case
if (self.failures.ContainsKey(buf.slaveId))
{
// failure signal defined
self.failures[buf.slaveId].Value = false;
}
} // If
else
{
buf.pauseCounter--;
}
} // Try
catch (Modbus.SlaveException e)
{
buf.pauseCounter = self.FailedCount;
if (self.failures.ContainsKey(buf.slaveId))
{
// failure signal defined
self.failures[buf.slaveId].Value = true;
}
foreach (ModbusChannelImp ch in buf.channels)
{
ch.StatusFlags = ChannelStatusFlags.Bad;
}
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrReceive,
self.Name, buf.slaveId, buf.ModbusDataType.ToString(), buf.startAddress, buf.numInputs, e.Message));
}
}
catch (TimeoutException e)
{
buf.pauseCounter = self.FailedCount;
if (self.failures.ContainsKey(buf.slaveId))
{
// failure signal defined
self.failures[buf.slaveId].Value = true;
}
foreach (ModbusChannelImp ch in buf.channels)
{
ch.StatusFlags = ChannelStatusFlags.Bad;
}
if (self.LoggingLevel >= ModbusLog.logWarnings)
{
Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrReceive,
self.Name, buf.slaveId, buf.ModbusDataType.ToString(), buf.startAddress, buf.numInputs, e.Message));
}
}
}
public IEnumerable<KeyValuePair<Tag, object>> Update(IModbusMaster master)
{
Parse(storage, master.ReadHoldingRegisters(addr, 0, nregs));
return storage.ToList();
}
private void SendPackage(IModbusMaster modbus, Device dv, DataBlock db)
{
try
{
SendDone.WaitOne(-1);
switch (db.DataType)
{
case "Bit":
byte[] bitArys = null;
switch (db.TypeOfRead)
{
case "ReadCoilStatus":
bitArys = modbus.ReadCoilStatus((byte)dv.SlaveId, $"{db.StartAddress}",
db.Length);
break;
case "ReadInputStatus":
bitArys = modbus.ReadInputStatus((byte)dv.SlaveId, $"{db.StartAddress}",
db.Length);
break;
default:
break;
}
var BitRs = Bit.ToArray(bitArys);
if (bitArys.Length > db.Tags.Count)
{
return;
}
for (var j = 0; j < db.Tags.Count; j++)
{
db.Tags[j].Value = BitRs[j];
db.Tags[j].Checked = BitRs[j];
db.Tags[j].Enabled = BitRs[j];
db.Tags[j].Visible = BitRs[j];
db.Tags[j].ValueSelect1 = BitRs[j];
db.Tags[j].ValueSelect2 = BitRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
break;
case "Int":
var IntArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId,
$"{db.StartAddress}", db.Length);
var IntRs = Int.ToArray(IntArys);
if (IntRs.Length > db.Tags.Count)
{
return;
}
for (var j = 0; j < IntRs.Length; j++)
{
db.Tags[j].Value = IntRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
break;
case "DInt":
var DIntArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId,
$"{db.StartAddress}", db.Length);
var DIntRs = Int.ToArray(DIntArys);
if (DIntRs.Length > db.Tags.Count)
{
return;
}
for (var j = 0; j < DIntRs.Length; j++)
{
db.Tags[j].Value = DIntRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
break;
case "Word":
byte[] wdArys = null;
switch (db.TypeOfRead)
{
case "ReadHoldingRegisters":
wdArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length);
break;
case "ReadInputRegisters":
wdArys = modbus.ReadInputRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length);
break;
default:
break;
}
var wdRs = Word.ToArray(wdArys);
if (wdRs.Length > db.Tags.Count)
{
return;
}
for (var j = 0; j < wdRs.Length; j++)
{
db.Tags[j].Value = wdRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
break;
case "DWord":
var dwArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId,
$"{db.StartAddress}", db.Length);
var dwRs = DWord.ToArray(dwArys);
for (var j = 0; j < dwRs.Length; j++)
{
db.Tags[j].Value = dwRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
break;
case "Real":
var rl1Arys = modbus.ReadHoldingRegisters((byte)dv.SlaveId,
$"{db.StartAddress}", db.Length);
var rl1Rs = Real.ToArray(rl1Arys);
for (var j = 0; j < rl1Rs.Length; j++)
{
db.Tags[j].Value = rl1Rs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
break;
}
}
catch (Exception ex)
{
IsConnected = false;
EventscadaException?.Invoke(this.GetType().Name + " XModbus.SendPackage", ex.Message);
}
}
public void OnButtonMbusExecuteClicked(object sender, RoutedEventArgs e)
{
if (mbus_client.Connected)
{
ushort offset = ushort.Parse(boxRegOffset.Text);
ushort quantity = ushort.Parse(boxRegNumber.Text);
byte slave = 0x00;
ushort val = ushort.Parse(boxModbusWriteValue.Text);
switch (boxModbusOp.Text)
{
case "Чтение дискретных входов":
bool[] discrete_output;
try
{
discrete_output = mbus_master.ReadInputs(slave, offset, quantity);
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
discrete_output = new bool[0];
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
discrete_output = new bool[0];
}
foreach (bool b in discrete_output)
{
if (b)
{
Console.Write("1 ");
}
else
{
Console.Write("0 ");
}
}
Console.Write('\n');
break;
case "Чтение дискретных выходов":
bool[] coil_output;
try
{
coil_output = mbus_master.ReadCoils(slave, offset, quantity);
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
coil_output = new bool[0];
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
coil_output = new bool[0];
}
foreach (bool b in coil_output)
{
if (b)
{
Console.Write("1 ");
}
else
{
Console.Write("0 ");
}
}
Console.Write('\n');
break;
case "Чтение выходных регистров":
ushort[] holding_output;
try
{
holding_output = mbus_master.ReadHoldingRegisters(slave, offset, quantity);
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
holding_output = new ushort[0];
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
holding_output = new ushort[0];
}
foreach (int i in holding_output)
{
Console.Write(i.ToString() + " ");
}
Console.WriteLine("");
break;
case "Чтение входных регистров":
ushort[] inreg_output;
try
{
inreg_output = mbus_master.ReadInputRegisters(slave, offset, quantity);
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
inreg_output = new ushort[0];
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
inreg_output = new ushort[0];
}
foreach (int i in inreg_output)
{
Console.Write(i.ToString() + " ");
}
Console.WriteLine("");
break;
case "Запись в дискретный выход":
bool coil = val > 0 ? true : false;
try
{
mbus_master.WriteSingleCoil(slave, offset, coil);
Console.WriteLine("ЗАП OK");
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
}
break;
case "Запись в регистр":
try
{
mbus_master.WriteSingleRegister(slave, offset, val);
Console.WriteLine("ЗАП OK");
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
}
break;
case "Запись в несколько дискретных выходов":
bool[] coil_input = new bool[quantity];
for (int i = 0; i < quantity; i++)
{
coil_input[i] = val > 0 ? true : false;
}
try
{
mbus_master.WriteMultipleCoils(slave, offset, coil_input);
Console.WriteLine("ЗАП OK");
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
}
break;
case "Запись в несколько регистров":
ushort[] reg_out = new ushort[quantity];
for (int i = 0; i < quantity; i++)
{
reg_out[0] = val;
}
try
{
mbus_master.WriteMultipleRegisters(slave, offset, reg_out);
Console.WriteLine("ЗАП OK");
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
}
catch (InvalidModbusRequestException)
{
Console.WriteLine("Что-то пошло не так...");
}
break;
case "Чтение/Запись в несколько регистров":
ushort[] reg_write = new ushort[quantity];
ushort[] reg_read;
ushort offset_write = ushort.Parse(boxRegOffsetWr.Text);
for (int i = 0; i < quantity; i++)
{
reg_write[i] = val;
}
try
{
reg_read = mbus_master.ReadWriteMultipleRegisters(slave, offset, quantity, offset_write, reg_write);
Console.WriteLine("ЧТЕН OK");
foreach (int i in reg_read)
{
Console.Write(i + " ");
}
Console.WriteLine("\nЗАП OK");
}
catch (IOException)
{
Console.WriteLine("Ошибка соединения. Соединение сброшено");
mbus_client.Close();
}
catch (InvalidModbusRequestException ex)
{
Console.WriteLine("Что-то пошло не так...");
}
break;
}
}
}
private void ProcessDataUpdateTick(object info)
{
if ((_client != null) && _client.Connected)
{
ScaleStatus = "";
_processDataTimer.Change(Timeout.Infinite, Timeout.Infinite);
try
{
ushort[] _data = _master.ReadHoldingRegisters(MODBUS_SLAVE_ADDRESS, (CANOPEN_SLAVE_ADDRESS * 10), WTX_REGISTER_DATAWORD_COUNT);
if (_data.Length > 4)
{
if ((_data[3] & 0x0080) > 0)
{
Weight = "--------";
ScaleStatus = "OVFL";
}
else
{
Weight = UIntToWeight(_data[1] + (uint)(_data[2] << 16));
ScaleStatus = "";
}
FillingResult = UIntToWeight(_data[4] + (uint)(_data[5] << 16));
if ((_data[3] & 0x0001) > 0)
{
CoarseFlow = "COARSE";
}
else
{
CoarseFlow = "";
}
if ((_data[3] & 0x0002) > 0)
{
_fineFlow = "FINE";
}
else
{
_fineFlow = "";
}
if ((_data[3] & 0x0004) > 0)
{
ScaleStatus = "READY";
}
else
{
ScaleStatus = "";
}
if ((_data[3] & 0x0040) > 0)
{
ScaleStatus = "ALARM";
}
else
{
ScaleStatus = "";
}
}
else
{
Weight = "Communication error";
}
}
catch (Exception ex)
{
Weight = ex.Message;
}
finally
{
_processDataTimer.Change(200, 200);
}
}
}
private async void ExecuteFunction()
{
try
{
//每次操作是要开启串口 操作完成后需要关闭串口
//目的是为了slave更换连接是不报错
if (port.IsOpen == false)
{
port.Open();
}
//根据功能码写操作方法
if (functionCode != null)
{
switch (functionCode)
{
case "01 Read Coils": //读取单个线圈
SetReadParameters();
coilsBuffer = master.ReadCoils(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < coilsBuffer.Length; i++)
{
SetMsg(coilsBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "02 Read DisCrete Inputs": //读取输入线圈/离散量线圈
SetReadParameters();
coilsBuffer = master.ReadInputs(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < coilsBuffer.Length; i++)
{
SetMsg(coilsBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "03 Read Holding Registers": //读取保持寄存器
SetReadParameters();
registerBuffer = master.ReadHoldingRegisters(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < registerBuffer.Length; i++)
{
SetMsg(registerBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "04 Read Input Registers": //读取输入寄存器
SetReadParameters();
registerBuffer = master.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < registerBuffer.Length; i++)
{
SetMsg(registerBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "05 Write Single Coil": //写单个线圈
SetWriteParametes();
await master.WriteSingleCoilAsync(slaveAddress, startAddress, coilsBuffer[0]);
break;
case "06 Write Single Registers": //写单个输入线圈/离散量线圈
SetWriteParametes();
await master.WriteSingleRegisterAsync(slaveAddress, startAddress, registerBuffer[0]);
break;
case "0F Write Multiple Coils": //写一组线圈
SetWriteParametes();
await master.WriteMultipleCoilsAsync(slaveAddress, startAddress, coilsBuffer);
break;
case "10 Write Multiple Registers": //写一组保持寄存器
SetWriteParametes();
await master.WriteMultipleRegistersAsync(slaveAddress, startAddress, registerBuffer);
break;
default:
break;
}
}
else
{
MessageBox.Show("请选择功能码!");
}
//关闭串口
port.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void Scanner_Tick(object sender, EventArgs e)
{
try
{
/////////////////////////////////////////////////////////////////////////////
byte[] bytes = MMaster.ReadHoldingRegisters(1, 3829, 1); //خواندن خط کش
txtSpacingRead.Text = string.Empty; // clear text.
if (bytes != null)
{
short[] result = Int.ToArray(bytes); //3200
txtSpacingRead.Text = string.Format("{0}", result[1] * 0.02); // محاسبه عدد خط کش
SpacingValue = (int)(result[1] * 0.02);
// trackMM.Value = SpacingValue; }
////////////////////////////////////////////////////////////////////////
if (StartTest && SpacingValue > ((int)txtSpacing.Value) - 1) // توقف تست
{
MMaster.WriteSingleCoil(1, 2048, false); //
StartTest = false;
watch.Stop();
}
/////////////////////////////////////////////////////////////////////////
byte[] Loadcell = MMaster.ReadHoldingRegisters(2, 231, 4);// ترانسمیتر
for (int i = 0, j = 1; i < Loadcell.Length;)
{
byte TempA = Loadcell[j]; // B
Loadcell[j] = Loadcell[i]; // B <= A
Loadcell[i] = TempA; // A<= B
i += 2;
j += 2;
}
valueff1 = BitConverter.ToSingle(Loadcell, 0); //لودسل سمت جک
valueff2 = BitConverter.ToSingle(Loadcell, 4); // لودسل سمت فنر
int x1 = (int)valueff1;
int x2 = (int)valueff2; //
Eff = (valueff2 / valueff1) * 100;
txtForceSpring.Text = x2.ToString();
txtForceHand.Text = x1.ToString();
/////////////////////////////////////////////////////////////////////////
if (x2 > 1 && x1 > 1)
{
txtEffective.Text = (Eff + 5).ToString();
}
//if (x2 > (Convert.ToDouble(Properties.Settings.Default.SpringForce)))
//{
// MMaster.WriteSingleCoil(1, 2048, false);// توقف تست
// watch.Stop();
//}
if (true)
{
txtTime.Text = watch.Elapsed.ToString();
}
if (x2 < 1)
{
MMaster.WriteSingleCoil(1, 2049, false);// توقف در نقطه صفر
}
}
}
catch
{
MessageBox.Show("Errorr Reaaaad");
}
}
/// <summary>
/// Get state relay by index
/// </summary>
/// <param name="master">modbus transport</param>
/// <param name="index">aim index</param>
/// <returns>state relay</returns>
public bool GetRelayState(IModbusMaster master, int index)
{
var answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays);
return GetBitFromUShortArray(answer, index);
}
private ushort[] ReadHoldingRegisters(ushort startAddress, ushort pointCount)
{
return(m_modbusConnection.ReadHoldingRegisters(m_unitID, startAddress, pointCount));
}
public ushort[] ReadPoints(ushort startAddress, ushort numberOfPoints)
{
return(_master.ReadHoldingRegisters(_unitId, startAddress, numberOfPoints));
}
/// <summary>
/// Проверка наличия измененеий в состоянии входов
/// </summary>
/// <param name="master">Транспорт</param>
/// <returns>Список изменившихся входов</returns>
public IEnumerable<int> UpdateAllInputState(IModbusMaster master)
{
var res = new List<int>();
var answer = master.ReadHoldingRegisters(_address, RegisterStartInputs, CountRegistersInputs);
if (_lastState == null)
{
_lastState = answer;
for (int i = 0; i < (_lastState.Length * 16); i++)
res.Add(i);
}
else
{
for(int i = 0; i< answer.Length; i++)
{
if(answer[i]==_lastState[i])
continue;
for(int bit = 0; bit<16; bit++)
if (GetBitFromUShortArray(_lastState, (i * 16 + bit)) != GetBitFromUShortArray(answer, (i * 16 + bit)))
res.Add(i * 16 + bit);
}
_lastState = answer;
}
_lastStateTimestamp = DateTime.Now;
return res;
}
bool ModbusUpdate()
{
try
{
lock (m_syncObject)
{
//for (int i = 0; i < 1281; i += 125)
//{
///*rdBuf*/ = m_mbMaster.ReadHoldingRegisters(m_slaveAddr, m_startAddr, m_count);
//for (int j = 0; j < 126; j++)
//{
// if (i + j < 1281)
// {
// //MyClass.rxData[i + j] = rdBuf[j];
// }
//}
int count = RegistersCountMax;
ushort addr = m_startAddr;
int rdLen;
int index = 0;
if (rdBuf == null)
{
rdBuf = new ushort[RegistersCountMax];
}
while (count > 0)
{
rdLen = count;
if (rdLen > IOCountMax)
{
rdLen = IOCountMax;
}
ushort[] tBuf = m_mbMaster.ReadHoldingRegisters(m_slaveAddr, (ushort)index, (ushort)rdLen);
// ushort[] tBuf = m_mbMaster.ReadHoldingRegisters(1, 1, 5);
Array.Copy(tBuf, 0, rdBuf, index, rdLen);
index += rdLen;
addr += (ushort)rdLen;
count -= rdLen;
// ushort[] buf = ValueUtil.StructToBuff<ushort, RegistersData.MbRegisters>(USM_Reg);
//GetVals(tBuf);
}
USM_Reg = ValueUtil.BufToStruct <common.devices.USM.MbUsmRegisters, ushort>(rdBuf);
//}
//rdBuf[280] = 1;
}
return(true);
}
catch (Exception ex)
{
m_lastError = ex.Message;
return(false);
}
}
//////////////////////////////////////////////////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
private void ModbusScan_Tick(object sender, EventArgs e)
{
watch.Start();
mmstart = true;
if (c == Course)
{
ModbusScan.Stop();
if (TestStep == 1)
{
PublicVar.TestEnd1 = true;
db.Database.ExecuteSqlCommandAsync("UPDATE CTest.dbo.ProgramMain SET Counter1 =" + c + " ,TestEnd1 = 1 WHERE id =" + PublicVar.ProgramID);
Stop();
MessageBox.Show("The test was completed with course" + PublicVar.Course1 + "and tensile strength of" + PublicVar.Force1 + "kg", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
else if (TestStep == 2)
{
db.Database.ExecuteSqlCommand("UPDATE CTest.dbo.ProgramMain SET Counter2 =" + c + ",TestEnd2 = 1 WHERE id =" + PublicVar.ProgramID);
db.Database.ExecuteSqlCommand("UPDATE CTest.dbo.ProgramMain SET TestEnd1 = 0 WHERE id =" + PublicVar.ProgramID);
Stop();
MessageBox.Show("The test was completed with course" + PublicVar.Course2 + "and tensile strength of" + PublicVar.Force2 + "kg", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
PublicVar.TestEnd2 = true;
MessageBox.Show("The settings for the second test step apply to change the spring", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
else if (TestStep == 3)
{
db.Database.ExecuteSqlCommand("UPDATE CTest.dbo.ProgramMain SET Counter1 =" + c + ",TestEnd1 = 1 WHERE id =" + PublicVar.ProgramID);
Stop();
MessageBox.Show("The test was completed with course" + PublicVar.Course2 + "and tensile strength of" + PublicVar.Force2 + "kg", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
}
try
{
byte[] bytes = MMaster.ReadHoldingRegisters(2, 231, 4);
for (int i = 0, j = 1; i < bytes.Length;)
{
byte TempA = bytes[j]; // B
bytes[j] = bytes[i]; // B <= A
bytes[i] = TempA; // A<= B
i += 2;
j += 2;
}
float valueff2 = BitConverter.ToSingle(bytes, 4); // لودسل سمت فنر
int x2 = (int)valueff2; //
txtLoadcell1.Text = string.Format("{0}, ", valueff2);
if (Enumerable.Range(105, 105).Contains(x2))// && x2 > Convert.ToInt32(PublicVar.Force2) + 10)
{
watch.Stop();
txtTime.Text = watch.Elapsed.ToString();
watch.Reset();
c++;
PrcLoadCell(valueff2);
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error ModBusScan", MessageBoxButtons.OK, MessageBoxIcon.Error);
ModbusScan.Stop();
}
}
/// <summary>
/// Perform read registers command
/// </summary>
/// <param name="master"></param>
/// <returns></returns>
internal static double CalculateAverage(IModbusMaster master)
{
ushort startAddress = 5;
ushort numRegisters = 5;
// JIT compile the IL
master.ReadHoldingRegisters(SlaveAddress, startAddress, numRegisters);
Stopwatch stopwatch = new Stopwatch();
long sum = 0;
double numberOfReads = 50;
for (int i = 0; i < numberOfReads; i++)
{
stopwatch.Reset();
stopwatch.Start();
master.ReadHoldingRegisters(SlaveAddress, startAddress, numRegisters);
stopwatch.Stop();
log.DebugFormat("CalculateAverage read {0}", i + 1);
checked
{
sum += stopwatch.ElapsedMilliseconds;
}
}
return sum / numberOfReads;
}
private async void ExecuteFunction()
{
try
{
//重新实例化是为了 modbus slave更换连接时不报错
master = modbusFactory.CreateMaster(new TcpClient("127.0.0.1", 502));
if (functionCode != null)
{
switch (functionCode)
{
case "01 Read Coils": //读取单个线圈
SetReadParameters();
coilsBuffer = master.ReadCoils(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < coilsBuffer.Length; i++)
{
SetMsg(coilsBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "02 Read DisCrete Inputs": //读取输入线圈/离散量线圈
SetReadParameters();
coilsBuffer = master.ReadInputs(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < coilsBuffer.Length; i++)
{
SetMsg(coilsBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "03 Read Holding Registers": //读取保持寄存器
SetReadParameters();
registerBuffer = master.ReadHoldingRegisters(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < registerBuffer.Length; i++)
{
SetMsg(registerBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "04 Read Input Registers": //读取输入寄存器
SetReadParameters();
registerBuffer = master.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints);
for (int i = 0; i < registerBuffer.Length; i++)
{
SetMsg(registerBuffer[i] + " ");
}
SetMsg("\r\n");
break;
case "05 Write Single Coil": //写单个线圈
SetWriteParametes();
await master.WriteSingleCoilAsync(slaveAddress, startAddress, coilsBuffer[0]);
break;
case "06 Write Single Registers": //写单个输入线圈/离散量线圈
SetWriteParametes();
await master.WriteSingleRegisterAsync(slaveAddress, startAddress, registerBuffer[0]);
break;
case "0F Write Multiple Coils": //写一组线圈
SetWriteParametes();
await master.WriteMultipleCoilsAsync(slaveAddress, startAddress, coilsBuffer);
break;
case "10 Write Multiple Registers": //写一组保持寄存器
SetWriteParametes();
await master.WriteMultipleRegistersAsync(slaveAddress, startAddress, registerBuffer);
break;
default:
break;
}
}
else
{
MessageBox.Show("请选择功能码!");
}
master.Dispose();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
internal ushort[] ReadHoldingRegisters(ushort address, ushort num)
{
return(PLC.ReadHoldingRegisters(1, address, num));
}
public JObject ReadModbusToJson(int siteId, int DeviceIndex, GroupPoint slaves, out HashEntry[] hashEntries)
{
JObject datarow = new JObject();
List <HashEntry> entries = new List <HashEntry>();
hashEntries = entries.ToArray();
try
{
if (master == null)
{
return(datarow);
}
ushort startAddr = slaves.StartAddress;
ushort pointCnt = (ushort)slaves.AiMaps.Sum(x => x.DataType.Size);
ushort[] datas = null;
lock (lockerObj)
{
switch ((modbus_io)slaves.IoType)
{
case modbus_io.ANALOG_INPUT:
datas = master.ReadInputRegisters(_config.SlaveId, startAddr, pointCnt);
break;
case modbus_io.HOLDING_REGISTER:
datas = master.ReadHoldingRegisters(_config.SlaveId, startAddr, pointCnt);
break;
}
}
DateTime timeStamp = DateTime.Now;
datarow.Add("groupid", slaves.GroupId);
datarow.Add("groupname", slaves.GroupName);
datarow.Add("deviceId", _config.DeviceName);
datarow.Add("siteId", siteId);
string normalizedeviceid = slaves.GroupId == 1 ? "PCS" : "BMS";
datarow.Add("normalizedeviceid", normalizedeviceid + DeviceIndex.ToString());
entries.Add(new HashEntry("timestamp", timeStamp.ToString()));
datarow.Add("timestamp", DateTime.Now.ToString("yyyyMMddHHmmss"));
int bitIdx = 0;
foreach (AiMap register in slaves.AiMaps)
{
if (register.Disable == 1)
{
continue;
}
//Console.WriteLine("READ REGISTER: " + register.Name);
byte[] buffer = GetReadBytes(register.DataType, bitIdx, datas);
bitIdx += register.DataType.Size;
dynamic value = 0f;
switch ((modbus_type)register.DataType.TypeCode)
{
case modbus_type.DT_BOOLEAN:
value = BitConverter.ToBoolean(buffer);
break;
case modbus_type.DT_INT32:
value = BitConverter.ToInt32(buffer);
break;
case modbus_type.DT_INT16:
value = BitConverter.ToInt16(buffer);
break;
case modbus_type.DT_UINT32:
value = BitConverter.ToUInt32(buffer);
break;
case modbus_type.DT_UINT16:
value = BitConverter.ToUInt16(buffer);
break;
case modbus_type.DT_FLOAT:
value = BitConverter.ToSingle(buffer);
break;
}
value = register.ConvertValue(value);
entries.Add(new HashEntry(register.Name, value.ToString()));
datarow.Add(register.Name, value.ToString());
//registers.Add(register.ConvertRegister(Convert.ToSingle(value)));
}
hashEntries = entries.ToArray();
return(datarow);
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return(null);
}
}
protected override ushort[] ReadCore(IModbusMaster modbusMaster, byte slaveId, ushort startAddress, ushort numberOfPoints)
{
return(modbusMaster.ReadHoldingRegisters(slaveId, startAddress, numberOfPoints));
}
/// <summary>
/// Обновить состояние панели
/// </summary>
/// <param name="master">Транспорт</param>
/// <returns>Список изменившихся входов</returns>
public void UpdatePannelState(IModbusMaster master)
{
var res = new List<int>();
var answer = master.ReadHoldingRegisters(_address, RegisterStar, CountRegisters);
ParceFromUShortArray(answer);
_lastStateTimestamp = DateTime.Now;
}
private ushort[] ReadModbusRegisters()
{
AllData = _master.ReadHoldingRegisters(WTX_SLAVE_ADDRESS, WTX_REGISTER_START_ADDRESS, WTX_REGISTER_DATAWORD_COUNT);
CommunicationLog?.Invoke(this, new LogEventArgs("Read all: " + string.Join(",", AllData.Select(x => x.ToString("X")).ToArray())));
return(AllData);
}
void ModbusUpdate()
{
float gas_v;
float pump;
float steam_v;
float water_lvl;
float pressure;
ushort alrm;
bool torch;
while (client_connected == 2)
{
Thread.Sleep(500);
if (update_task_ctoken.IsCancellationRequested)
{
return;
}
gas_v = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 0, 2));
pump = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 2, 2));
steam_v = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 4, 2));
water_lvl = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 6, 2));
pressure = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 8, 2));
alrm = mbus_client.ReadHoldingRegisters(0x00, 10, 1)[0];
torch = mbus_client.ReadCoils(0x00, 5, 1)[0];
Dispatcher.Invoke(() =>
{
valve2_label.Content = String.Format("КЛ2: {0:F1}%", gas_v * 100);
pump_label.Content = String.Format("НАС: {0:F1}%", pump * 100);
valve1_label.Content = String.Format("КЛ1: {0:F1}%", steam_v * 100);
waterlvl_label.Content = String.Format("{0:F1}%", water_lvl * 100);
waterlvl_progressbar.Value = water_lvl;
pressure_label.Content = String.Format("{0:F1}%", pressure * 100);
pressure_progressbar.Value = pressure;
if (torch)
{
heater_status_ellipse.Fill = new SolidColorBrush(Colors.Green);
}
else
{
heater_status_ellipse.Fill = new SolidColorBrush(Colors.Red);
}
if (alrm == 1)
{
alarm_presshigh.IsEnabled = true;
}
else if (alrm == 2)
{
alarm_pressdang.IsEnabled = true;
}
else if (alrm == 3)
{
alarm_watrlow.IsEnabled = true;
}
else if (alrm == 4)
{
alarm_watrhigh.IsEnabled = true;
}
else if (alrm == 0)
{
alarm_pressdang.IsEnabled = false;
alarm_presshigh.IsEnabled = false;
alarm_watrhigh.IsEnabled = false;
alarm_watrlow.IsEnabled = false;
}
});
if (auto_mode)
{
}
}
}
