/// <summary>
/// 写入一个保持寄存器
/// </summary>
/// <param name="registerAddress"></param>
/// <param name="value"></param>
public void WriteSingleRegister(ushort registerAddress, short value)
{
Thread.Sleep(Delay_ms);
try
{
CheckInitPort();
master.WriteSingleRegister(slaveID, registerAddress, value);
}
catch (Exception e)
{
throw;
}
}
public void WriteSingleRegister(ushort registerAddress, short value)
{
Thread.Sleep(delayms);
try
{
CheckInitPort();
//Global.MBMutex.WaitOne();
master.WriteSingleRegister(slaveID, registerAddress, value);
//Global.MBMutex.ReleaseMutex();
}
catch (Exception e)
{
//Global.MBMutex.ReleaseMutex();
}
}
/// <summary>
/// Simple Modbus serial RTU master write holding registers example.
/// </summary>
public static void ModbusSerialRtuMasterWriteRegisters(string com, int taxaTrans, int bits, int bitParada,
string pariedade, byte slaveId, ushort startAddress, ushort numRegisters, ushort valor)
{
using (SerialPort port = new SerialPort(com))
{
// configure serial port
port.BaudRate = taxaTrans;
port.DataBits = bits;
if (pariedade == "Sem")
{
port.Parity = Parity.None;
}
if (bitParada == 1)
{
port.StopBits = StopBits.One;
}
if (bitParada == 2)
{
port.StopBits = StopBits.Two;
}
port.Open();
// create modbus master
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
// write three registers
master.WriteSingleRegister(slaveId, startAddress, valor);
}
}
void writeToDevice(int slaveadr)
{
ushort val;
ushort uAdr = 120;
bool err = false;
if (!serialPort.IsOpen)
{
MessageBox.Show("Port isn`t open", "Error");
return;
}
progressBar1.Minimum = 0;
progressBar1.Maximum = 120;
for (int i = 0; i < 120; i++)
{
progressBar1.Value = i;
val = Convert.ToUInt16(dgvModbusAdr[1, i].Value);
try {
uAdr = (ushort)(120 + i);
master.WriteSingleRegister((byte)slaveadr, uAdr, val);
} catch {
err = true;
}
if (err)
{
MessageBox.Show("Ошибка записи в устройство № " + slaveadr.ToString() + ". Адрес регистра " + uAdr.ToString() + ". Запись прервана!", "Ошибка!", MessageBoxButtons.OK, MessageBoxIcon.Error);
progressBar1.Value = 0;
return;
}
}
progressBar1.Value = 0;
}
private void senddata_Click(object sender, RoutedEventArgs e)
{
byte slaveID = 1;
ushort registerAddress = 0;
ushort value = 100; //你要写的值
imodbusserialmaster.WriteSingleRegister(slaveID, registerAddress, value); // 写单个寄存器
//imodbusserialmaster.WriteMultipleRegisters(); // 写多个寄存器
addmsg($">> 发送数据！");
}
public void writeSingleRegister(ModbusRegisters regs, ushort value)
{
if (master == null)
{
return;
}
lock (locker)
{
master.WriteSingleRegister(regs.slaveid, regs.startAddress, value);
}
}
private void button1_Click(object sender, EventArgs e)
{
IModbusSerialMaster master5 = ModbusSerialMaster.CreateRtu(ports);
try
{
if (start == 1)
{
timer1.Enabled = false;
//timer2.Enabled = false;
button1.Text = "Desconnected";
button1.BackColor = Color.Red;
btn_for.Enabled = true;
btn_sol.Enabled = true;
master5.WriteSingleRegister(1, 47, 0);
master5.WriteSingleRegister(1, 61, 0);
master5.WriteSingleRegister(1, 59, 0);
time_h = 0;
time_s = 0;
time_m = 0;
txt_time.Text = Convert.ToString(time_h) + "0:0" + Convert.ToString(time_m) + ":0" + Convert.ToString(time_s);
//fun1 = 0;
//contador = 0;
start = 0;
}
else
{
//Ativa o RUN e set para saida i/o 5 seja saída (5)
master5.WriteSingleRegister(1, 47, 1);
// master5.WriteSingleRegister(1, 73, Convert.ToUInt16(box1));
timer1.Enabled = true;
//timer2.Enabled = true;
btn_for.Enabled = false;
btn_sol.Enabled = false;
button1.Text = "Connected";
button1.BackColor = Color.Green;
//fun1 = 1;
master5.WriteSingleRegister(1, 61, 5);
master5.WriteSingleRegister(1, 59, 6);
start = 1;
}
}
catch (Exception err)
{
MessageBox.Show("Erro de Porta!");
}
}
public int writeSingleRegister(ModbusRegisters regs, ushort value)
{
try
{
if (master == null)
{
commsts = COMMSTS_UNKONOWN;
return(RET_INITFAILURE);
}
if (port.IsOpen == false)
{
commsts = COMMSTS_PORTNOTOPEN;
return(RET_INITFAILURE);
}
lock (locker)
{
master.WriteSingleRegister(regs.slaveid, regs.startAddress, value);
}
}
catch (TimeoutException ex)
{
LogClass.GetInstance().WriteLogFile("writeSingleRegister Timeout:" + port.WriteTimeout.ToString());
//MessageBox.Show("Serial Port Write Timeout:" + port.WriteTimeout.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
if (rtycnt++ < MAX_RETYR_COUNT)
{
return(RET_TIMEOUT);
}
else
{
commsts = COMMSTS_FAILURE;
return(RET_COMMERROR);
}
}
catch (Exception ex)
{
LogClass.GetInstance().WriteExceptionLog(ex);
//MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
commsts = COMMSTS_FAILURE;
return(RET_FAILURE);
}
rtycnt = 0;
commsts = COMMSTS_NORMAL;
return(RET_OK);
}
private static int CurrentStateCheck(IModbusSerialMaster master, byte IDAddress)
{
ushort[] result = new ushort[1];
result = master.ReadHoldingRegisters(IDAddress, (ushort)32, 1);
short stateConnect = BitConverter.ToInt16(new byte[] {
BitConverter.GetBytes(result[0])[0],
BitConverter.GetBytes(result[0])[1]
},
0);
if (stateConnect > 0)
{
master.WriteSingleRegister(IDAddress, (ushort)32, 0);
}
System.Threading.Thread.Sleep(250);
return(0);
}
private void WriteRegisters(ushort startAddress, ushort registerValue)
{
CheckPort();
try
{
if (!port.IsOpen)
{
port.Open();
}
IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(port);
master.Transport.WriteTimeout = timeout;
master.WriteSingleRegister(slaveId, startAddress, registerValue);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public static void ModbusSerialRtuMasterWriteRegisters(string baudBaud)
{
//MessageBox.Show(baudBaud);
using (SerialPort port = new SerialPort(baudBaud))
{
// configure serial port
port.BaudRate = 9600;
port.DataBits = 8;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
port.Open();
// create modbus master
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
//ushort[] ReadHoldingRegisters(
byte slaveId = 1;
ushort startAddress = 300;
ushort value = 680;
master.WriteSingleRegister(slaveId, startAddress, value);
}
}
private void send()
{
try
{
int.Parse(sendData.Text);
}
catch
{
myMessageQueue.Enqueue(rm.GetString("onlyInteger", cultureInfo), rm.GetString("ok", cultureInfo), () => HandleOKMethod());
return;
}
try
{
master.WriteSingleRegister(slave, address, ushort.Parse(sendData.Text));
MessageBox.Show(rm.GetString("writingSuccessful", cultureInfo), rm.GetString("system", cultureInfo),
MessageBoxButton.OK, MessageBoxImage.Information);
this.Close();
}
catch (IOException) {
}
}
public void Connect()
{
try
{
port = new SerialPort("COM1");
port.BaudRate = 115200;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
port.WriteTimeout = 500;
port.ReadTimeout = 500;
port.Handshake = Handshake.None;
port.Open();
ushort INIT_OUTPUT = 65535;
modbus_master = ModbusSerialMaster.CreateRtu(port);
modbus_master.WriteSingleRegister(SHJ_digital_slaveID, SHJ_digital_outputReg, INIT_OUTPUT); //== all outputs are set LOW MAX = 65535
timer1.Start();
}
catch
{
MessageBoxResult result =
System.Windows.MessageBox.Show("Eroare de conexiune. Redeschidem aplicatia?", "Confirmare restart",
MessageBoxButton.YesNo,
MessageBoxImage.Question);
if (result == MessageBoxResult.Yes)
{
System.Windows.Forms.Application.Restart();
Close();
}
if (result == MessageBoxResult.No)
{
}
}
}
private void autoManual_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
master.WriteSingleRegister(slave, 31, 1);
}
public string parameterSeting(byte addr, UInt16 reg_addr, byte reg_lenth, String value, string type, SerialPort port)
{
string result = "Success";
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
master.Transport.ReadTimeout = 1000;
master.Transport.WriteTimeout = 1000;
if (!port.IsOpen)
{
try
{
port.Open();
}
catch (InvalidOperationException)
{
result = "Port was open";
}
catch (UnauthorizedAccessException)
{
result = "Port was open";
}
catch (IOException)
{
result = "Port was not found";
}
}
if (result == "Success")
{
if ((type == "uint16") && (reg_lenth == 1))
{
try
{
master.WriteSingleRegister(addr, reg_addr, Convert.ToUInt16(value));
}
catch (System.Exception ex)
{
result = ex.Message;
}
//catch (InvalidOperationException)
//{
// result = "Port not Found";
//}
//catch (TimeoutException)
//{
// result = "Time out";
//}
//catch (Modbus.SlaveException ex)
//{
// result = "unknown exception :" + ex.SlaveExceptionCode.ToString();
//}
}
if ((type == "uint32") && (reg_lenth == 2))
{
try
{
UInt32 Value = Convert.ToUInt32(value);
ushort[] data = { (ushort)Value, (ushort)(Value >> 16) };
master.WriteMultipleRegisters(addr, reg_addr, data);
}
catch (InvalidOperationException)
{
result = "Port not Found";
}
catch (TimeoutException)
{
result = "Time out";
}
catch (Modbus.SlaveException ex)
{
result = "unknown exception :" + ex.SlaveExceptionCode.ToString();
}
}
if ((type == "float") && (reg_lenth == 2))
{
try
{
float Value = float.Parse(value);
byte[] temp_bytes = BitConverter.GetBytes(Value);
UInt32 temp_int = 0;
temp_int += (uint)temp_bytes[3] << 3 * 8;
temp_int += (uint)temp_bytes[2] << 2 * 8;
temp_int += (uint)temp_bytes[1] << 1 * 8;
temp_int += (uint)temp_bytes[0] << 0 * 8;
ushort[] data = { (ushort)temp_int, (ushort)(temp_int >> 16) };
master.WriteMultipleRegisters(addr, reg_addr, data);
}
catch (InvalidOperationException)
{
result = "Port not Found";
}
catch (TimeoutException)
{
result = "Time out";
}
catch (Modbus.SlaveException ex)
{
result = "unknown exception :" + ex.SlaveExceptionCode.ToString();
}
}
if ((type == "char") && ((reg_lenth == 8 || (reg_lenth == 16)))) //通常为设置序列号
{
try
{
ushort[] data = new ushort[value.Length / 2 + 1];
int rest = value.Length % 2;
for (int i = 0, j = 0; i < value.Length / 2; i++)
{
data[i] = (ushort)(value[j + 1] << 8 | value[j]);
j += 2;
}
if (rest == 0)
{
data[value.Length / 2] = 0;
}
else
{
data[value.Length / 2] = value[value.Length - 1];
}
master.WriteMultipleRegisters(addr, reg_addr, data);
}
catch (InvalidOperationException)
{
result = "Port not Found";
}
catch (TimeoutException)
{
result = "Time out";
}
catch (Modbus.SlaveException ex)
{
result = "unknown exception :" + ex.SlaveExceptionCode.ToString();
}
}
}
port.Close();
master.Dispose();
return(result);
}
public string parameterSeting(byte addr, UInt16 reg_addr, byte reg_lenth, UInt32 value, string type, SerialPort port)
{
string result = "Success";
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
master.Transport.ReadTimeout = 1000;
master.Transport.WriteTimeout = 1000;
if (!port.IsOpen)
{
try
{
port.Open();
}
catch (InvalidOperationException)
{
result = "Port was open";
}
catch (UnauthorizedAccessException)
{
result = "Port was open";
}
catch (IOException)
{
result = "Port was not found";
}
}
if (result == "Success")
{
if (type == "uint16")
{
try
{
master.WriteSingleRegister(addr, reg_addr, (UInt16)value);
}
catch (InvalidOperationException)
{
result = "Port not Found";
}
catch (TimeoutException)
{
result = "Time out";
}
catch (Modbus.SlaveException ex)
{
result = "unknown exception :" + ex.SlaveExceptionCode.ToString();
}
}
else if (type == "uint32")
{
try
{
ushort[] data = { (ushort)value, (ushort)(value >> 16) };
master.WriteMultipleRegisters(addr, reg_addr, data);
}
catch (InvalidOperationException)
{
result = "Port not Found";
}
catch (TimeoutException)
{
result = "Time out";
}
catch (Modbus.SlaveException ex)
{
result = "unknown exception :" + ex.SlaveExceptionCode.ToString();
}
}
}
port.Close();
master.Dispose();
//stopwatch.Start();
//stopwatch.Stop();
//System.Diagnostics.Debug.WriteLine("modbuswriteTime:" + stopwatch.ElapsedMilliseconds.ToString());
//stopwatch.Reset();
return(result);
}
private void timer1_Tick(object sender, EventArgs e)
{
IModbusSerialMaster master6 = ModbusSerialMaster.CreateRtu(ports);
// Crônometro--------------------------------------------------------------------------------------------------
if (time_s <= 59)
{
if (time_s < 10)
{
txt_time.Text = Convert.ToString(time_h) + "0:0" + Convert.ToString(time_m) + ":0" + Convert.ToString(time_s);
}
else
{
txt_time.Text = Convert.ToString(time_h) + "0:0" + Convert.ToString(time_m) + ":" + Convert.ToString(time_s);
}
}
else if (time_m <= 59)
{
time_m++;
time_s = 0;
if (time_m < 10)
{
txt_time.Text = Convert.ToString(time_h) + "0:0" + Convert.ToString(time_m) + ":0" + Convert.ToString(time_s);
}
else
{
txt_time.Text = Convert.ToString(time_h) + "0:" + Convert.ToString(time_m) + ":" + Convert.ToString(time_s);
}
}
else if (time_h < 999)
{
time_h++;
time_s = 0;
time_m = 0;
if (time_h < 10)
{
txt_time.Text = "0" + Convert.ToString(time_h) + ":0" + Convert.ToString(time_m) + ":0" + Convert.ToString(time_s);
}
else
{
txt_time.Text = Convert.ToString(time_h) + ":" + Convert.ToString(time_m) + ":" + Convert.ToString(time_s);
}
}
time_s++;
try
{
ushort[] holding_register = master6.ReadHoldingRegisters(1, 0, 2); // Cria a Variável e recebe o 2 registradores
float valor = Convert.ToSingle(holding_register[0]); // Transforma em um float para ser manipulado
float valor1 = Convert.ToSingle(holding_register[1]);
leitura.Text = Convert.ToString(valor1 / 10) + " °C"; // escreve o valor no 'box'
leitura2.Text = Convert.ToString(valor / 10) + " °C";
//Escrita dos Registradores de Configuração
master6.WriteSingleRegister(1, 72, Convert.ToUInt16(box1));
master6.WriteSingleRegister(1, 73, Convert.ToUInt16(box1));
//master6.WriteSingleRegister(1, 13, Convert.ToUInt16(box2));
master6.WriteSingleRegister(1, 94, Convert.ToUInt16(box3));
master6.WriteSingleRegister(1, 96, Convert.ToUInt16(tempo1v));
master6.WriteSingleRegister(1, 97, Convert.ToUInt16(tempo2v));
master6.WriteSingleRegister(1, 98, Convert.ToUInt16(tempo3v));
master6.WriteSingleRegister(1, 99, Convert.ToUInt16(tempo4v));
master6.WriteSingleRegister(1, 100, Convert.ToUInt16(tempo5v));
master6.WriteSingleRegister(1, 101, Convert.ToUInt16(set1v * 10));
master6.WriteSingleRegister(1, 102, Convert.ToUInt16(set2v * 10));
master6.WriteSingleRegister(1, 103, Convert.ToUInt16(set3v * 10));
master6.WriteSingleRegister(1, 104, Convert.ToUInt16(set4v * 10));
master6.WriteSingleRegister(1, 105, Convert.ToUInt16(set5v * 10));
}
catch (Exception err)
{
MessageBox.Show("Problema de comunicação");
}
//-------------------------------------------------------------------------------------------------------------
}
/// <summary>
/// 写入操作,针对的数据类型只有 字符串量 计算值 关系数据库值
/// </summary>
/// <param name="server"></param>
/// <param name="comm"></param>
/// <param name="device"></param>
/// <param name="para">要写入参数</param>
/// <param name="value">要写入的值</param>
/// <returns></returns>
public Task <bool> ResponseData(string SlaveId, string Address, ModbusFragment para, string value)
{
var task = Task.Run <bool>(() => {
if (para == null)
{
return(false);
}
//设备地址不能为空
if (Address == "")
{
return(false);
}
try
{
//获取参数中的
if (serialPort != null && serialPort.IsOpen && master != null)
{
ushort offset = para.StartRegister;
switch (para.Code)
{
case "01":
{
///写入单个线圈
if (ushort.Parse(value) > 0)
{
master.WriteSingleCoil(byte.Parse(Address), offset, true);
}
else
{
master.WriteSingleCoil(byte.Parse(Address), offset, false);
}
}
break;
case "02": //此类型只能查询，不能写入
{
}
break;
case "03":
{
switch (para.DataType)
{
case "float": //单精度浮点型
{
ushort[] buff = new ushort[2];
float WriteValue = float.Parse(value);
ModbusConvert.SetReal(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
}
break;
case "double": //双精度浮点数64位
{
ushort[] buff = new ushort[4];
double WriteValue = double.Parse(value);
ModbusConvert.SetDouble(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
}
break;
case "string": //字符型
{
ushort[] buff = new ushort[para.charsize];
string WriteValue = value;
if (value.Length > para.charsize)
{
WriteValue = value.Substring(0, para.charsize);
}
if (value.Length < para.charsize)
{
WriteValue = value.PadRight(para.charsize, ' ');
}
ModbusConvert.SetString(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
}
break;
case "byte": //无符号整数8位:
{
ushort[] buff = new ushort[1];
byte WriteValue = byte.Parse(value);
ModbusConvert.SetByte(buff, 0, WriteValue, true);
master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
}
break;
case "sbyte": //有符号整数8位:
{
ushort[] buff = new ushort[1];
sbyte WriteValue = sbyte.Parse(value);
ModbusConvert.SetSByte(buff, 0, WriteValue, true);
master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
}
break;
case "uint16": //无符号整数16位:
{
ushort WriteValue = ushort.Parse(value);
ushort[] buff = new ushort[1];
ModbusConvert.SetUShort(buff, 0, WriteValue);
master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
}
break;
case "int16": //有符号整数16位:
{
Int16 WriteValue = Int16.Parse(value);
ushort[] buff = new ushort[1];
ModbusConvert.SetShort(buff, 0, WriteValue);
master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
}
break;
case "uint32": //无符号整数32位:
{
uint WriteValue = uint.Parse(value);
ushort[] buff = new ushort[2];
ModbusConvert.SetUInt(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
}
break;
case "int32": //有符号整数32位:
{
int WriteValue = int.Parse(value);
ushort[] buff = new ushort[2];
ModbusConvert.SetInt(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
}
break;
}
}
break;
}
}
}
catch
{
return(false);
}
return(true);
});
return(task);
}
private void button1_Click(object sender, EventArgs e)
{
master.WriteSingleRegister(slaveAddress, Convert.ToUInt16(numAddress.Value.ToString()), Convert.ToUInt16(numValue.Value.ToString()));
}
