public void ReConnect()
{
m_mutex.WaitOne();
try
{
Disconnect();
m_port = new SerialPort(m_settings.COM)
{
BaudRate = m_settings.Baudrate,
DataBits = 7,
Parity = Parity.None,
StopBits = StopBits.Two,
ReadTimeout = 300,
WriteTimeout = 300
};
m_port.Open();
m_master = ModbusSerialMaster.CreateAscii(m_port);
}
catch
{
};
m_mutex.ReleaseMutex();
}
public ushort ModbusSerialRtuMasterReadRegisters(ushort startAddress = 1, ushort numRegisters = 5, byte slaveId = 1)
{
using (SerialPort port = new SerialPort(PrimarySerialPortName))
{
// configure serial port
port.BaudRate = _baudRate;
port.DataBits = _dataBits;
port.Parity = _parity;
port.StopBits = _stopBits;
port.Open();
var t = port.ReadTimeout;
var factory = new ModbusFactory();
IModbusSerialMaster master = factory.CreateRtuMaster(port);
master.Transport.ReadTimeout = 1000;
byte _slaveId = slaveId;
ushort _startAddress = startAddress;//1;
ushort _numRegisters = numRegisters;
// read five registers
ushort[] registers = master.ReadHoldingRegisters(_slaveId, _startAddress, _numRegisters);
var currentThread = Thread.CurrentThread.ManagedThreadId;
port.Close();
return(registers[0]);
}
// output:
// Register 1=0
// Register 2=0
// Register 3=0
// Register 4=0
// Register 5=0
}
public async Task <bool> TryOpenConnectionAsync(bool isThrowingException, IComPortConfiguration comPortConfiguration)
{
//if ((_openedPort != null) && (_openedPort == PortName)) return true;
try
{
IModbusSerialMaster modbusSerialMaster = null;
await Task.Run((() =>
{
IStreamResource streamResource = _connectionManager.GetSerialPortAdapter(PortName, comPortConfiguration);
modbusSerialMaster = ModbusSerialMaster.CreateRtu(streamResource);
}));
if (modbusSerialMaster != null)
{
_currentModbusMaster?.Dispose();
_currentModbusMaster = modbusSerialMaster;
}
else
{
throw new Exception();
}
_slaveId = SlaveId;
// QueryQueue.Initialize(_currentModbusSerialMaster,deviceLogger,(() => LastQueryStatusChangedAction?.Invoke()));
_openedPort = PortName;
}
catch (Exception e)
{
if (isThrowingException)
{
throw e;
}
return(false);
}
return(true);
}
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>
/// 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 async Task <Result> TryOpenConnectionAsync(IDeviceLogger deviceLogger)
{
try
{
IStreamResource streamResource;
IModbusSerialMaster modbusSerialMaster = null;
await Task.Run(() =>
{
streamResource = _connectionManager.GetSerialPortAdapter(PortName);
modbusSerialMaster = ModbusSerialMaster.CreateRtu(streamResource);
});
if (modbusSerialMaster != null)
{
_currentModbusMaster?.Dispose();
_currentModbusMaster = modbusSerialMaster;
}
else
{
throw new Exception();
}
_slaveId = SlaveId;
_deviceLogger = deviceLogger;
_isConnectionLost = false;
_lastQuerySucceed = true;
}
catch (Exception e)
{
return(Result.Create(e));
}
return(Result.Create(true));
}
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();
}
}
}
void p()
{
using (SerialPort port = new SerialPort("COM1"))
{
port.BaudRate = 19200;
port.DataBits = 8;
port.Parity = Parity.Odd;
port.StopBits = StopBits.One;
port.ReadTimeout = 1000;
port.WriteTimeout = 1000;
port.Open();
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
byte slaveId = 1;
ushort startAddress = 0x180;
ushort[] res = master.ReadHoldingRegisters(slaveId, startAddress, 1);
for (int i = 0; i < res.Length; i++)
{
Console.Write(res[i].ToString() + " ");
if ((i + 1) % 4 == 0)
{
Console.WriteLine();
}
Console.ReadKey();
}
}
}
/// <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);
}
}
public void setValue <T>(IModbusConfig config, T value)
{
lock (locker)
{
var toWrite = (ushort)Convert.ChangeType(value, typeof(ushort));
SerialPort port = new SerialPort(config.portName, config.baudRate);
if (port.IsOpen)
{
port.Close();
}
lock (_locker)
{
port.Open();
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
master.Transport.ReadTimeout = 1000;
master.Transport.WriteTimeout = 1000;
//Запись
master.WriteMultipleRegisters(config.device_address, config.register_write_address, new ushort[] { toWrite });
port.Close();
Thread.Sleep(100);
}
}
}
private void WriteRegisters(string portName)
{
try
{
using (var port = GetSerialPort(portName))
{
var factory = new ModbusFactory();
IModbusSerialMaster master = factory.CreateRtuMaster(port);
master.WriteMultipleRegisters(_slaveID, 0, new ushort[]
{
(ushort)'M',
(ushort)'M',
(ushort)'r',
(ushort)DateTime.Now.Year,
(ushort)DateTime.Now.Month,
(ushort)DateTime.Now.Day,
(ushort)DateTime.Now.Hour,
(ushort)DateTime.Now.Minute,
(ushort)DateTime.Now.Second,
(ushort)CPU,
(ushort)GPU
});
}
}
catch { }
}
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);
}
}
public IModbusSerialMaster CreateModBusRtuConnection(SerialPort serialPort)
{
IModbusSerialMaster master = null;
if (!serialPort.IsOpen)
{
try
{
serialPort.Open();
}
catch (Exception e)
{
throw e;
}
}
try
{
master = ModbusSerialMaster.CreateRtu(serialPort);
///同时也可以配置master的一些参数
master.Transport.ReadTimeout = 100; //读取数据超时100ms
master.Transport.WriteTimeout = 100; //写入数据超时100ms
master.Transport.Retries = 3; //重试次数
master.Transport.WaitToRetryMilliseconds = 10; //重试间隔
}
catch (Exception e)
{
throw e;
}
return(master);
}
/// <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);
}
}
}
/// <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);
}
}
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);
}
}
/// <summary>
/// Write a 32 bit value.
/// </summary>
public static void ReadWrite32BitValue()
{
using (SerialPort port = new SerialPort(PrimarySerialPortName))
{
// configure serial port
port.BaudRate = 9600;
port.DataBits = 8;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
port.Open();
var factory = new ModbusFactory();
IModbusRtuTransport transport = factory.CreateRtuTransport(port);
IModbusSerialMaster master = factory.CreateMaster(transport);
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]);
}
}
/// <summary>
/// Simple Modbus serial ASCII master read holding registers example.
/// </summary>
public static ushort [] ModbusSerialRtuMasterReadRegisters(string COM)
{
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);
byte slaveId = 1;
ushort startAddress = 0;
ushort numRegisters = 8;
master.Transport.ReadTimeout = 550;
ushort[] registers = master.ReadInputRegisters(slaveId, startAddress, numRegisters);
return(registers);
}
}
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);
}
}
public void CreateAscii_SerialPortFactoryMethod()
{
IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(new SerialPort());
Assert.AreEqual(Modbus.DefaultTimeout, master.Transport.StreamResource.ReadTimeout);
Assert.AreEqual(Modbus.DefaultTimeout, master.Transport.StreamResource.ReadTimeout);
}
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 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(PrimarySerialPortName))
{
// configure serial port
port.BaudRate = 9600;
port.DataBits = 8;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
port.Open();
var factory = new ModbusFactory();
IModbusSerialMaster master = factory.CreateAsciiMaster(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 {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);
}
}
private static double SingleMeasure(IModbusSerialMaster master, byte IDAddress)
{
master.WriteMultipleRegisters(IDAddress, (ushort)32, new ushort[] { 100 });
bool measuring = true;
while (measuring)
{
ushort[] stateRead = new ushort[1];
stateRead = master.ReadHoldingRegisters(IDAddress, (ushort)32, 1);
short stateConnect = BitConverter.ToInt16(new byte[] {
BitConverter.GetBytes(stateRead[0])[0],
BitConverter.GetBytes(stateRead[0])[1]
},
0);
if (stateConnect <= 0)
{
break;
}
System.Threading.Thread.Sleep(1000);
}
ushort[] result = new ushort[3];
result = master.ReadHoldingRegisters(IDAddress, (ushort)58, 6);
float responseDuration = BitConverter.ToSingle(new byte[] {
BitConverter.GetBytes(result[2])[0],
BitConverter.GetBytes(result[2])[1],
BitConverter.GetBytes(result[2 + 1])[0],
BitConverter.GetBytes(result[2 + 1])[1]
},
0);
return(responseDuration * 301.0 / 2.0);
}
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 void NModbusUsbRtuMaster_ReadTimeout()
{
using (FtdUsbPort port = ModbusMasterFixture.CreateAndOpenUsbPort(ModbusMasterFixture.DefaultMasterUsbPortId))
{
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
master.ReadCoils(100, 1, 1);
}
}
public void NModbusAsciiMaster_ReadTimeout()
{
using (SerialPort port = ModbusMasterFixture.CreateAndOpenSerialPort(ModbusMasterFixture.DefaultMasterSerialPortName))
{
IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(port);
master.ReadCoils(100, 1, 1);
}
}
protected override void serialThread()
{
BPPacketModbus pckt;
Byte[] txBuf= new Byte[0];
if (cDataReceivedDelegate == null)
throw new Exception("ReceiveDelegate not set!");
log.Debug("Creating modbus protocol.");
master = ModbusSerialMaster.CreateRtu(sp);
log.Debug("Starting infinite receiving loop");
while (true)
{
// Do we need to shutdown the thread?
if ((shutdownThread == true) &&
(packets.Count == 0))
{
log.Debug("Communication thread shutdown");
try
{
sp.Close();
}
catch (Exception e)
{
log.Error("Problem closing serial port", e);
}
return;
}
if (packets.Count != 0)
{
log.Debug("New packet on queue to send");
lock (packets)
{
pckt = (BPPacketModbus)packets.Dequeue();
if(pckt.Data.Length>0)
txBuf = cHeaderSerializer.SerializeData(new object[] { pckt.Data });
}
try
{
if (pckt.Data.Length > 0)
{
log.Debug("Writing packet to modbus");
master.WriteMultipleRegisters((byte)100,
(ushort)GenAddress((Byte)pckt.LinkId,
(Byte)pckt.BPProtocolHeader.cOperationId),
CreateRegisters(txBuf));
}
else
{
log.Debug("Reading packet from modbus");
master.ReadInputRegisters((byte)100,
(ushort)GenAddress((Byte)pckt.LinkId,
(Byte)pckt.BPProtocolHeader.cOperationId),
(ushort)pckt.ExpectedLength);
}
}
catch (TimeoutException e)
{
log.Error("Timeout while writing packet to serial bus", e);
}
catch (Exception e)
{
log.Error("Problem writing packet to serial bus, closing serial port and communication thread", e);
sp.Close();
return;
}
log.Debug("Resetting state variables");
txBuf = new Byte[0];
}
// We don't want to hog up whole CPU
Thread.Sleep(100);
}
}
public DataReader(SerialPort port)
{
master = ModbusSerialMaster.CreateRtu(port);
master.Transport.ReadTimeout = 250;
}
