/// <summary>
/// 控制手爪
/// </summary>
/// <param name="positionReq"></param>位置
/// <param name="speedReq"></param>速度
/// <param name="forceReq"></param>力
public static void ModbusSerialRtuMasterWriteRegisters(int positionReq, int speedReq, int forceReq)
{
if (positionReq > 100 || positionReq < 0 || speedReq > 100 || speedReq < 0 || forceReq > 100 || forceReq < 0)
{
MessageBox.Show("输入参数有误，请重新输入！");
}
else
{
using (SerialPort port = new SerialPort("COM3"))
{
// configure serial port
port.BaudRate = 115200;
port.DataBits = 8;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
port.Open();
// create modbus master
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
byte slaveId = 9;
ushort startAddress = 1000;
int realSpeedReq = Convert.ToUInt16(speedReq * 255 / 100);
int realForceReq = Convert.ToUInt16(forceReq * 255 / 100);
ushort realSpeedForceReq = Convert.ToUInt16(realSpeedReq * 256 + realForceReq);
ushort realPositionReq = Convert.ToUInt16(positionReq * 255 / 100);
ushort[] registers = new ushort[] { 2304, realPositionReq, realSpeedForceReq };
// write three registers
master.WriteMultipleRegisters(slaveId, startAddress, registers);
}
}
}
public void NModbusSerialRtuSlave_BonusCharacter_VerifyTimeout()
{
SerialPort masterPort = ModbusMasterFixture.CreateAndOpenSerialPort(ModbusMasterFixture.DefaultMasterSerialPortName);
SerialPort slavePort = ModbusMasterFixture.CreateAndOpenSerialPort(ModbusMasterFixture.DefaultSlaveSerialPortName);
using (var master = ModbusSerialMaster.CreateRtu(masterPort))
using (var slave = ModbusSerialSlave.CreateRtu(1, slavePort))
{
master.Transport.ReadTimeout = master.Transport.WriteTimeout = 1000;
slave.DataStore = DataStoreFactory.CreateTestDataStore();
Thread slaveThread = new Thread(slave.Listen);
slaveThread.IsBackground = true;
slaveThread.Start();
// assert successful communication
Assert.AreEqual(new bool[] { false, true }, master.ReadCoils(1, 1, 2));
// write "bonus" character
masterPort.Write("*");
// assert successful communication
Assert.AreEqual(new bool[] { false, true }, master.ReadCoils(1, 1, 2));
}
}
public Form1()
{
InitializeComponent();
Fill_Com_Ports();
Baudrate.SelectedIndex = 17;
Databits.SelectedIndex = 0;
Parity.SelectedIndex = 0;
Stopbit.SelectedIndex = 0;
module_addr1.Text = "1";
m_mbMaster = ModbusSerialMaster.CreateRtu(COM1);
m_mbMaster.Transport.ReadTimeout = 100;
m_mbMaster.Transport.Retries = 5;
baudrate_label.BackColor = Color.White;
baudrate_label.Text = "Set";
databits_label.BackColor = Color.White;
databits_label.Text = "Set";
parity_label.BackColor = Color.White;
parity_label.Text = "Set";
stopbit_label.BackColor = Color.White;
stopbit_label.Text = "Set";
addr_label.BackColor = Color.White;
addr_label.Text = "Set";
}
public void Handler(TcpClient client)
{
try
{
Connection = ModbusSerialMaster.CreateRtu(client);
//mConnection.Transport.Retries = 3;
Connection.Transport.ReadTimeout = 3000;
var inputs = Connection.ReadInputRegisters(0, 0, 4);
var id = new byte[8];
for (var i = 0; i < 4; i++)
{
id[i] = (byte)(inputs[i] & 0xFF);
id[i + 1] = (byte)((inputs[i] >> 8) & 0xFF);
}
Id = Encoding.ASCII.GetString(id);
}
catch (Exception ex)
{
// Connection exception
// No response from server
// The server maybe close the connection or response timeout
if (ex.Source.Equals("System"))
{
IsActive = false;
}
// The server return error code. You can get the function code and exception code.
//if(ex.Source.Equals("nModbusPC")) { }
}
IsActive = true;
}
/// <summary>
/// Write a 32 bit value.
/// </summary>
public static void ReadWrite32BitValue()
{
using (SerialPort port = new SerialPort("COM1"))
{
// configure serial port
port.BaudRate = 9600;
port.DataBits = 8;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
port.Open();
// create modbus master
ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
byte slaveId = 1;
ushort startAddress = 1008;
uint largeValue = UInt16.MaxValue + 5;
ushort lowOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 0);
ushort highOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 2);
// write large value in two 16 bit chunks
master.WriteMultipleRegisters(slaveId, startAddress, new ushort[] { lowOrderValue, highOrderValue });
// read large value in two 16 bit chunks and perform conversion
ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2);
uint value = ModbusUtility.GetUInt32(registers[1], registers[0]);
}
}
public static ModbusMaster CreateSerialMaster(SerialPort port, SerialModBusMode type)
{
ModbusMaster master = null;
if (port != null)
{
if (!port.IsOpen)
{
port.Open();
}
switch (type)
{
case SerialModBusMode.Rtu:
master = ModbusSerialMaster.CreateRtu(port);
break;
case SerialModBusMode.Ascii:
master = ModbusSerialMaster.CreateRtu(port);
break;
default:
break;
}
}
return(master);
}
public ModbusASCII(string portName, int baudRate, string parity, int dataBit, string stBit)
{
Parity masterParity = Parity.None;
if (parity == "Odd")
{
masterParity = Parity.Odd;
}
if (parity == "Even")
{
masterParity = Parity.Even;
}
StopBits stopBit = StopBits.None;
if (stBit == "One")
{
stopBit = StopBits.One;
}
if (stBit == "Two")
{
stopBit = StopBits.Two;
}
serialPort = new SerialPort(portName, baudRate, masterParity, dataBit, stopBit);
master = ModbusSerialMaster.CreateAscii(serialPort);
master.Transport.ReadTimeout = 500;
}
private ushort ModbusReadValue(string com, ushort startAddress)
{
try
{
ushort readValue = 0;
using (SerialPort port = new SerialPort(com))
{
// 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);
master.Transport.ReadTimeout = 2000;
byte slaveId = 1;
ushort numOfPoints = 1;
ushort[] values = master.ReadHoldingRegisters(slaveId, startAddress, numOfPoints);
readValue = values[0];
Console.WriteLine("{0}, 当前读取到数值：{1};", DateTime.Now.ToString(), readValue);
}
return(readValue);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
System.IO.File.AppendAllText("log.txt", "\r\n Read TimeOut Exception:" + ex.Message.ToString());
return(0);
}
}
protected override void OnStart(string[] args)
{
LoadSettings();
WriteLog(GetVersion());
sp.PortName = o.SerialPortName;
sp.BaudRate = o.SerialPortBaudRate;
sp.DataBits = o.SerialPortDataBits;
sp.Parity = o.SerialPortParity;
sp.StopBits = o.SerialPortStopBits;
try
{
sp.Open();
}
catch
{
WriteLog("Unable to open serial port " + sp.PortName);
WriteLog("Service not started.");
WriteLog("Exitting...");
return;
}
Values = new SValue[o.Registers.Length];
for (int i = 0; i < Values.Length; ++i)
{
Values[i].Ready = false;
Values[i].Value = 0;
}
MBRtu = ModbusSerialMaster.CreateRtu(sp);
workerThread.Start();
WriteLog("Service started.");
}
private float ReadFloatRegister(ushort startAddress)
{
CheckPort();
try
{
if (!port.IsOpen)
{
port.Open();
}
IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(port);
//master.Transport.ReadTimeout = timeout;
ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2);
return
(ModbusUtility.GetSingle(registers[1], registers[0]));
}
catch (TimeoutException)
{
timerGraphUpdate.Stop();
MessageBox.Show("Порт не отвечает");
return(0);
}
catch (Exception ex)
{
timerGraphUpdate.Stop();
MessageBox.Show(ex.Message);
return(0);
}
}
private static void SerialPortTest()
{
var slaveId = byte.Parse(ConfigurationManager.AppSettings["SM4"]);
var serialPort = ConfigurationManager.AppSettings["serialPort"];
var baudRate = int.Parse(ConfigurationManager.AppSettings["baudRate"]);
var dataBits = int.Parse(ConfigurationManager.AppSettings["dataBits"]);
var parity = (Parity)Enum.Parse(typeof(Parity), ConfigurationManager.AppSettings["parity"]);
var stopBits = (StopBits)Enum.Parse(typeof(StopBits), ConfigurationManager.AppSettings["stopBits"]);
ushort startAddress = 2200;
using (var port = new SerialPort(serialPort, baudRate, parity, dataBits, stopBits))
using (var master = ModbusSerialMaster.CreateRtu(port))
{
port.Open();
Console.WriteLine("Connected.");
// Przykładowe wartości
bool[] outputs = { true, false, false, true };
// Zapis wielu rejestrów
master.WriteMultipleCoils(slaveId, startAddress, outputs);
// Odczyt wielu rejestrów
bool[] inputs = master.ReadCoils(slaveId, startAddress, 4);
// Wyświetlenie
Console.WriteLine(String.Join(", ", inputs));
}
}
private ushort ReadIntRegister(ushort startAddress)
{
CheckPort();
try
{
if (!port.IsOpen)
{
port.Open();
}
IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(port);
ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 1);
return(registers[0]);
}
catch (TimeoutException)
{
timerGraphUpdate.Stop();
MessageBox.Show("Порт не отвечает");
return(0);
}
catch (Exception ex)
{
timerGraphUpdate.Stop();
MessageBox.Show(ex.Message);
return(0);
}
}
/// <summary>
/// 窗口服务构造函数
/// </summary>
/// <param name="modbus">modbus设置</param>[]
/// <param name="slaveConfig">从机信息</param>
/// <param name="warningCabinetId">警示灯从机id（1-4）</param>
///
private SerialPortService(Modbussetting modbus, List <SlaveConfig> slaveConfig, ushort warningCabinetId)
{
try
{
_ModbusSetting = modbus;
_SlaveConfig = slaveConfig;
_WarningCabinetId = warningCabinetId;
//if (_serialPort != null)
// _serialPort.Dispose();
if (_serialPort == null || !_serialPort.IsOpen)
{
_serialPort = new SerialPort(_ModbusSetting.PortName, _ModbusSetting.BaudRate, (Parity)_ModbusSetting.Parity, _ModbusSetting.DataBits, (StopBits)_ModbusSetting.StopBits);
_modbusSerialMaster = ModbusSerialMaster.CreateRtu(new SerialPortAdapter(_serialPort));
}
//设置Modbus通讯的超时时间
_modbusSerialMaster.Transport.ReadTimeout = TimeoutMilliseconds;
_modbusSerialMaster.Transport.WriteTimeout = TimeoutMilliseconds;
if (!_serialPort.IsOpen)
{
_serialPort.Open();
}
}
catch (Exception ex)
{
SaveErrLogHelper.SaveErrorLog(string.Empty, ex.ToString());
}
}
private void TestCom()
{
using (SerialPort port = new SerialPort(comPort))
{
// configure serial port配置串口
port.BaudRate = int.Parse(baudRate);
port.DataBits = int.Parse(dataBits);
port.Parity = (Parity)Enum.Parse(typeof(Parity), parity);
port.StopBits = (StopBits)Enum.Parse(typeof(StopBits), stopBits);
//port.Parity = Parity.None;
//port.StopBits = StopBits.One;
port.Open();
//创建Modbus主站
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
byte slaveid = byte.Parse(slaveId); //从站ID
ushort startAddress = ushort.Parse(registerAdd1); //地址16
//写
//master.WriteSingleCoil(slaveId,startAddress,false);
WriteValue(master, slaveid, startAddress, true);
Console.WriteLine("写入成功。");
//读
//var a = master.ReadCoils(slaveId, startAddress, 1);
var a = ReadValue(master, slaveid, startAddress);
Console.WriteLine(a);
Console.ReadKey();
}
}
/// <summary>
/// 按位输出信号
/// </summary>
/// <param name="nIndex"></param>
/// <param name="bBit"></param>
/// <returns></returns>
public override bool WriteIoBit(int nIndex, bool bBit)
{
if (!m_bOpen)
{
return(false);
}
int nAxisNo = (nIndex & 0xff00) >> 8;
int nIoIndex = nIndex & 0xff;
byte byteWrite = bBit ? (byte)1 : (byte)0;
// Motion.mAcm_AxDoSetBit(m_Axishand[nAxisNo], (ushort)nIoIndex, byteWrite);
byte slaveAddress = (byte)m_nCardNo;
ushort coilAddress = (ushort)(nIoIndex + 80);
try
{
lock (_syncRoot)
_master.WriteSingleCoil(slaveAddress, coilAddress, bBit);
return(true);
}
catch (Exception ex)
{
if (_serialPort.IsOpen)
{
_serialPort.Close();
}
if (!_serialPort.IsOpen)
{
_serialPort.Open();
}
_master.Dispose();
_master = ModbusSerialMaster.CreateRtu(_serialPort);
_logger.Warn(ex.Message);
return(false);
}
}
public Device()
{
stateRegs = new WorkState();
stateRegs = WorkState.Idle;
//Regs_Update = new BackgroundWorker();
//Regs_Update.WorkerSupportsCancellation = true;
//Regs_Update.WorkerReportsProgress = true;
//Regs_Update.DoWork += Regs_Update_DoWork;
//Regs_Update.ProgressChanged += Regs_Update_ProgressChanged;
m_mbMaster = ModbusSerialMaster.CreateRtu(COM);
m_mbMaster.Transport.ReadTimeout = 100;
m_mbMaster.Transport.Retries = 3;
m_mbMaster.Transport.SlaveBusyUsesRetryCount = true;
m_mbMaster.Transport.WaitToRetryMilliseconds = 100;
m_bgwModbusUpdater = new BackgroundWorker();
m_bgwModbusUpdater.WorkerSupportsCancellation = true;
m_bgwModbusUpdater.WorkerReportsProgress = true;
m_bgwModbusUpdater.DoWork += M_bgwModbusUpdater_DoWork;;
m_bgwModbusUpdater.ProgressChanged += M_bgwModbusUpdater_ProgressChanged;;
m_bgwModbusUpdater.RunWorkerAsync();
Regs = new common.devices.ACID_Stend.Registers();
}
private void ShowSerialConfigForm()
{
if (serialPortConfig.PortIsOpen == false)
{
var form = new Form_SerialConfig(serialPortConfig);
var result = form.ShowDialog();
if (result == DialogResult.OK)
{
baudComboBox.SelectedIndex = serialPortConfig.BaudRateIndex;
stopBitsComboBox.SelectedIndex = serialPortConfig.StopBitsIndex;
dataBitsComboBox.SelectedIndex = serialPortConfig.DataBitsIndex;
parityComboBox.SelectedIndex = serialPortConfig.ParityIndex;
protocolComboBox.SelectedIndex = serialPortConfig.ProtocolIndex;
comName = form.ComText;
btnConnect_Click(null, null);
}
}
else
{
master = null;
serialPort?.Close();
serialPort?.Dispose();
timerDraw.Enabled = false;
timerSave.Enabled = false;
labelConnect.Text = "未连接";
pictureBoxConnect.BackColor = Color.Red;
serialPortConfig.PortIsOpen = false;
labelStatus.Text = "端口关闭";
MessageBox.Show("断开连接!");
}
}
public void connect_modbus()
{
serialPort.PortName = post_buf; // СОМ порт для каждого канала
serialPort.BaudRate = Convert.ToInt32(speed_net_buf); // скорость передачи по выбранному каналу модбас
serialPort.DataBits = Convert.ToInt32(quantity_bit_buf); // кол-во бит в посылке
switch (parity_net_buf) // проверка на чётность
{
case "Even": serialPort.Parity = Parity.Even; break;
case "Mark": serialPort.Parity = Parity.Mark; break;
case "None": serialPort.Parity = Parity.None; break;
case "Odd": serialPort.Parity = Parity.Odd; break;
case "Space": serialPort.Parity = Parity.Space; break;
}
switch (stop_bit_net_buf) // кол-во стоп бит
{
case "None": serialPort.StopBits = StopBits.None; break;
case "One": serialPort.StopBits = StopBits.One; break;
case "OnePointFive": serialPort.StopBits = StopBits.OnePointFive; break;
case "Two": serialPort.StopBits = StopBits.Two; break;
}
try
{
serialPort.Open();
master = ModbusSerialMaster.CreateRtu(serialPort);
master.Transport.Retries = 0; // don't have to do retries
master.Transport.ReadTimeout = 50; // milliseconds
toolStripStatusLabel2.Text = DateTime.Now.ToString() + " " + serialPort.PortName + " Открыт "; // выводим сообщение в строку состояния
}
catch (Exception)
{
//Console.WriteLine("Error: " + ex.Message);
toolStripStatusLabel2.Text = DateTime.Now.ToString() + " " + serialPort.PortName + " Не удалось открыть "; // выводим сообщение в строку состояния
}
try
{
Thread_Modbus.Start(modBus_var); // запуск процесса обработки ком порта
toolStripStatusLabel4.Text = " Поток запущен "; // выводим сообщение в строку состояния
}
catch (Exception)
{
toolStripStatusLabel4.Text = " Поток не запущен "; // выводим сообщение в строку состояния
}
}
private void 连接ToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
SelfCheckFlag = false; //复位自检标志
DeviceOnlineCount = 0;
if (SerialPorts[0].IsOpen == true)
{
return;
}
//SerialPortInit();
for (int i = 0; i < 2; ++i)
{
SerialPorts[i].Open();
ModbusMasters[i] = ModbusSerialMaster.CreateRtu(SerialPorts[i]);
ModbusMasters[i].Transport.Retries = 0;
ModbusMasters[i].Transport.ReadTimeout = 300;
}
timerGetData.Enabled = true;
MessageBox.Show("连接成功");
labelStatus.Text = "连接成功";
}
catch (System.Exception ex)
{
MessageBox.Show("串口打开失败!\r\n可能原因：" + ex.Message);
}
}
public ModbusCommunication(String portName)
{
// Creae an instance of a serial port
SerialPort serialPort = new SerialPort()
{
// Settings for the serial port
PortName = portName,
BaudRate = 57600,
DataBits = 8,
Parity = Parity.Even,
StopBits = StopBits.One,
Handshake = Handshake.None,
ReadTimeout = 20,
WriteTimeout = 20
};
// Open up a serial port
serialPort.Open();
var adapter = new SerialPortAdapter(serialPort);
// Create modbus master
Master = ModbusSerialMaster.CreateRtu(adapter);
}
public override void Init()
{
base.Init();
MasterSerialPort = CreateAndOpenSerialPort("COM4");
Master = ModbusSerialMaster.CreateRtu(MasterSerialPort);
}
public bool CreateSocket()
{
try
{
//socket
Socket socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint point = new IPEndPoint(IPAddress.Parse(slaveConfig.TCPHost), Convert.ToInt32(slaveConfig.TCPPort));
socketSend.Connect(point);
masterSocket = ModbusSerialMaster.CreateRtu(socketSend);
masterSocket.Transport.WriteTimeout = writeTimeout;
masterSocket.Transport.ReadTimeout = readTimeout;
//tcp
//TcpClient client = new TcpClient(slaveConfig.TCPHost, slaveConfig.TCPPort);
//masterSocket = ModbusSerialMaster.CreateRtu(client);
//masterSocket.Transport.WriteTimeout = writeTimeout;
//masterSocket.Transport.ReadTimeout = readTimeout;
return(true);
}
catch
{
return(false);
}
}
public void DisconnectFromDevice()
{
_modbusSerial?.Dispose();
_modbusSerial = null;
Port.Close();
IsConnected = false;
}
public bool openComm()
{
LogClass.GetInstance().WriteLogFile("OpenComm Called " + port.PortName);
lock (locker)
{
if (port != null && !port.IsOpen)
{
try
{
port.Open();
LogClass.GetInstance().WriteLogFile("port opened");
// create modbus master
if (InputModbusType == "RTU")
{
master = ModbusSerialMaster.CreateRtu(port);
}
else
{
master = ModbusSerialMaster.CreateAscii(port);
}
return(true);
}
catch (Exception ex)
{
LogClass.GetInstance().WriteExceptionLog(ex);
//MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
}
}
return(true);
}
/// <summary>
/// Simple Modbus serial ASCII master read holding registers example.
/// </summary>
public static void ModbusSerialAsciiMasterReadRegisters()
{
using (SerialPort port = new SerialPort("COM1"))
{
// 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.CreateAscii(port);
byte slaveId = 1;
ushort startAddress = 1;
ushort numRegisters = 5;
// read five registers
ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
for (int i = 0; i < numRegisters; i++)
{
Console.WriteLine("Register {0}={1}", startAddress + i, registers[i]);
}
}
// output:
// Register 1=0
// Register 2=0
// Register 3=0
// Register 4=0
// Register 5=0
}
public static void ModbusSerialRtuMasterReadRegisters(string 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);
byte slaveId = 1;
ushort startAddress = 300;
ushort numRegisters = 1;
ushort[] registers; //= new ushort[numRegisters];
string result;
// read registers
registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
result = Convert.ToString(registers[0]);
MessageBox.Show(result);
}
}
public Form1()
{
InitializeComponent();
is_connected = false;
stateForm = WorkState.Idle;
Form_Update = new BackgroundWorker();
Form_Update.WorkerSupportsCancellation = true;
Form_Update.WorkerReportsProgress = true;
Form_Update.DoWork += Form_Update_DoWork;
Form_Update.ProgressChanged += Form_Update_ProgressChanged;
Form_Update.RunWorkerAsync();
m_mbMaster = ModbusSerialMaster.CreateRtu(COM);
m_mbMaster.Transport.ReadTimeout = 100;
m_mbMaster.Transport.Retries = 3;
m_mbMaster.Transport.SlaveBusyUsesRetryCount = true;
m_mbMaster.Transport.WaitToRetryMilliseconds = 100;
m_bgwModbusUpdater = new BackgroundWorker();
m_bgwModbusUpdater.WorkerSupportsCancellation = true;
m_bgwModbusUpdater.WorkerReportsProgress = true;
m_bgwModbusUpdater.DoWork += M_bgwModbusUpdater_DoWork;
m_bgwModbusUpdater.ProgressChanged += M_bgwModbusUpdater_ProgressChanged;
m_bgwModbusUpdater.RunWorkerAsync();
}
/// <summary>
///按位获取输出信号
/// </summary>
/// <param name="nIndex"></param>
/// <returns></returns>
public override bool ReadIoOutBit(int nIndex)
{
if (!m_bOpen)
{
return(false);
}
int nAxisIndex = (nIndex & 0xff00) >> 8;
int nBitIndex = nIndex & 0x00ff;
byte bitData = 0;
byte slaveAddress = (byte)m_nCardNo;
ushort coilAddress = (ushort)nBitIndex;
try
{
lock (_syncRoot)
return(_master.ReadCoils(slaveAddress, (ushort)(coilAddress + 80), 1)[0]);
}
catch (Exception ex)
{
if (_serialPort.IsOpen)
{
_serialPort.Close();
}
if (!_serialPort.IsOpen)
{
_serialPort.Open();
}
_master.Dispose();
_master = ModbusSerialMaster.CreateRtu(_serialPort);
_logger.Warn(ex.Message);
return(false);
}
}
private void button1_Click(object sender, EventArgs e)
{
try {
if (!COM1.IsOpen)
{
COM1.Close();
COM1.PortName = "COM3";
COM1.BaudRate = 115200;
COM1.DataBits = 8;
COM1.Parity = System.IO.Ports.Parity.None;
COM1.StopBits = System.IO.Ports.StopBits.One;
COM1.Open();
}
m_mbMaster = ModbusSerialMaster.CreateRtu(COM1);
ushort[] rBuf = { 200 };
m_mbMaster.WriteMultipleRegisters(m_slaveAddr, 1, rBuf);
System.Threading.Thread.Sleep(200);
ushort[] tBuf = m_mbMaster.ReadHoldingRegisters(m_slaveAddr, 0x00, 104);
int t = 5;
t++;
}
catch (Exception ex)
{
this.Text = (string.IsNullOrEmpty(ex.Message)) ? "Form1" : ("Form1... Error: " + ex.Message);
}
}
public void ChangeHeaterState(bool shouldBeStarted)
{
SerialPort port = new SerialPort("COM2");
port.BaudRate = 9600;
port.DataBits = 8;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
try
{
port.Open();
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
byte slaveId = 1;
ushort startAddress = 100;
ushort[] registers = new ushort[] { ((shouldBeStarted)? ushort.Parse("1"): ushort.Parse("0")), 21 };
master.WriteMultipleRegisters(slaveId, startAddress, registers);
}
finally
{
if (port != null)
{
if (port.IsOpen)
{
port.Close();
}
port.Dispose();
}
}
}
