/// <summary>
/// Sends a message to slave. Does not wait for any data to be returned.
/// </summary>
/// <param name="messageFrame">Contains address and message to send.</param>
public void SendMessage(MessageFrame messageFrame)
{
ushort[] message = messageFrame.GetMessageFrameInShorts();
_master.WriteMultipleRegisters((byte)messageFrame.TargetSlaveAddress,
(ushort)HoldingRegisterStartAddress, message);
}
public static int WriteMultipleRegisters(ushort startAddress, ushort[] data)
{
try
{
master.WriteMultipleRegisters(slaveID, startAddress, data);
return(nOK);
}
catch (Exception ex)
{
_logger.Error("Error: " + ex.Message);
return(nFail);
}
}
public static void WriteAllowPump(Device device, bool value)
{
try {
if (tryWrite < 0)
{
tryWrite = 3;
return;
}
tryWrite--;
System.Threading.Thread.Sleep(250);
ushort[] holding_reg = master.ReadHoldingRegisters(device.ModbusID, 50, 1);
string bitMask = Convert.ToString(holding_reg[0], 2);
int countSym = bitMask.Length;
for (int i = 0; i < 8 - countSym; i++)
{
bitMask = "0" + bitMask;
}
char[] buf = bitMask.ToCharArray();
buf[4] = value ? '1' : '0';
string resultS = "";
for (int i = 0; i < 8; i++)
{
resultS += buf[i].ToString();
}
ushort[] result = new ushort[] { Convert.ToUInt16(resultS, 2) };
master.WriteMultipleRegisters(device.ModbusID, 50, result);
//master.WriteSingleCoil(device.ModbusID, 4, value);
} catch (Exception e) {
System.Threading.Thread.Sleep(250);
WriteAllowPump(device, value);
}
}
public int SetDataMultiple(out byte[] requestBytes, out byte[] responseBytes, ushort start, ushort[] ushortRegs, bool[] boolRegs, out string errCode)
{
errCode = "OK";
try
{
if (_config.SelectedMemType == Memtype.Coils)
{
_modbus.WriteMultipleCoils(_config.Slaves, start, boolRegs);
}
if (_config.SelectedMemType == Memtype.HoldingRegisters)
{
_modbus.WriteMultipleRegisters(_config.Slaves, start, ushortRegs);
}
return(0);
}
catch (SlaveException ex)
{
errCode = ex.Message;
return(1);
}
catch (Exception ex)
{
if (ex is InvalidOperationException)
{
throw;
}
errCode = ex.Message;
return(2);
}
finally
{
requestBytes = _modbus.Transport.RequestFrame;
responseBytes = _modbus.Transport.ResponseFrame;
}
}
private static void WriteRegister <TResult>(HoldRegister index, byte slaveId, ModbusSerialMaster master, decimal value) where TResult : struct
{
//Как хранится Int8??? в первом байте или во втором ushort?
//возможно надо будет Buffer.BlockCopy(s, 0, dest, 0, readsize * 2); и брать dest[1]
var address = index.RealAddress;
//int32 = 4
var size = index.DataType.GetDataTypeSize();
//кол-во ushort для записи
var readSize = (ushort)(size / 2);
if (size < 2)
{
readSize = 1;
}
var dest = new ushort[readSize];
var realValue = new[] { (TResult)Convert.ChangeType(index.Multiplier * value, typeof(TResult)) };
Buffer.BlockCopy(realValue, 0, dest, 0, size);
if (readSize == 1)
{
master.WriteSingleRegister(slaveId, address, dest[0]);
}
else
{
master.WriteMultipleRegisters(slaveId, address, dest);
}
}
/// <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]);
}
}
/// <summary>
/// 设定温度偏移
/// </summary>
/// <param name="Address">站号地址</param>
/// <param name="Channel">通道地址</param>
/// <param name="InL">标定下限，修正前</param>
/// <param name="OuL">标定下限，修正后</param>
/// <param name="InH">标定上限，修正前</param>
/// <param name="OuH">标定上限，修正后</param>
/// <returns>成功或失败</returns>
public static bool SetTempDeviation(byte Address, ushort Channel, float InL, float OuL, float InH, float OuH)
{
if (PMAMaster == null)
{
return(false);
}
byte SlaveAddress = Address;
ushort StartAddress = (ushort)(17465 + Channel * 512);
ushort[] Value = new ushort[4];
Value[0] = Auxiliary.ShortToUshort((short)(InL * 10f));
Value[1] = Auxiliary.ShortToUshort((short)(OuL * 10f));
Value[2] = Auxiliary.ShortToUshort((short)(InH * 10f));
Value[3] = Auxiliary.ShortToUshort((short)(OuH * 10f));
try
{
lock (LockValue)
{
PMAMaster.WriteMultipleRegisters(SlaveAddress, StartAddress, Value);
}
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Write a 32 bit value.
/// </summary>
public async void ReadWriteSerial32BitValue()
{
using (SerialDevice device = await SerialDevice.FromIdAsync("device_id"))
{
// configure serial port
device.BaudRate = 9600;
device.DataBits = 8;
device.Parity = SerialParity.Even;
device.StopBits = SerialStopBitCount.One;
var adapter = new SerialPortAdapter(device);
// create modbus master
ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(adapter);
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]);
}
}
private void buttonWriteReg_Click(object sender, EventArgs e)
{
ushort[] value = { 0 };
try
{
value[0] = ushort.Parse(textBox7.Text);
}
catch (Exception err)
{
MessageBox.Show(err.ToString());
}
modbusMasterRTU.WriteMultipleRegisters(1, 6, value);
}
private void ModbusSetK012()
{
if (serialPort.IsOpen == true)
{
ushort[] sendUShort = { };
ushort[] ushorts = BitConverterHelper.SingleToUShort(K0_XiShu.Value);
sendUShort = BitConverterHelper.UShortConnect(sendUShort, ushorts);
ushorts = BitConverterHelper.SingleToUShort(K1_XiShu.Value);
sendUShort = BitConverterHelper.UShortConnect(sendUShort, ushorts);
ushorts = BitConverterHelper.SingleToUShort(K2_XiShu.Value);
sendUShort = BitConverterHelper.UShortConnect(sendUShort, ushorts);
try
{
master?.WriteMultipleRegisters(SlaveAddress,
(ushort)(AddressConfig.K0 - 1), sendUShort);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
private void btn_Set_address_Click(object sender, EventArgs e)
{
slave_address = Convert.ToByte(txt_Set_address.Text);
lbl_address.Text = txt_Set_address.Text;
ushort[] set_address = new ushort[1];
set_address[0] = Convert.ToUInt16(txt_Set_address.Text);
try
{
master.WriteMultipleRegisters(0, 0, set_address);
}
catch (Exception err)
{
Console.WriteLine(err.ToString());
MessageBox.Show("The current address " + current_address.ToString() + " will be set to slave address " + slave_address.ToString());
}
}
public void WriteMultipleRegisters(byte slaveAddress, ushort startAddress, ushort[] data)
{
if (!serialPort.IsOpen)
{
Open();
}
try
{
master.WriteMultipleRegisters(slaveAddress, startAddress, data);
}
catch (Exception ex)
{
AddMessage("Catch exception in the function WriteMultipleRegisters(). " + ex.Message,
DebugLevel.ExceptionLevel);
Close();
}
}
private void BasicDryingSetButtonZone5_Click(object sender, EventArgs e)
{
try
{
if (serialPort1.IsOpen)
{
//Задавати Уставку
//---------------------------------------------------------------//
ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(serialPort1);
ushort Address = readAdressList[14];
ushort[] setData = SetParameter(BasicDryingSetTextZone5.Text);
master.WriteMultipleRegisters(slaveID, Address, setData);
//----------------------------------------------------------------------------------------------//
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Mesage", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void buttonWrite_Click(object sender, EventArgs e)
{
if (float.TryParse(textboxDensityCoe.Text, out var data) == true)
{
try
{
mMaster?.WriteMultipleRegisters(mSlaveAddress,
(ushort)(AddressConfig.DensityFactor - 1),
FloatToUshort(data));
}
catch
{
MessageBox.Show("仪表拒绝写入数据\r\n可能原因：数据不符合范围");
}
}
else
{
MessageBox.Show("输入的数据不符合规范!");
}
}
private void buttonSet1_Click(object sender, EventArgs e)
{
try
{
if (serialPort2.IsOpen)
{
//Задавати Уставку
//---------------------------------------------------------------//
ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(serialPort2);
ushort Address = 128;
ushort[] setData = SetParameter(textBoxSet1.Text);
master.WriteMultipleRegisters(16, Address, setData);
//----------------------------------------------------------------------------------------------//
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Mesage", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public string WriteUnitData(ModbusExchangeableUnit unit)
{
if (_modbusSerial == null)
{
return("Нет подключения");
}
try
{
foreach (ModbusDataBlock block in unit.GetWriteMap())
{
/*if (block.Size == 1)
* _modbusSerial.WriteSingleRegister(SlaveAddress, block.Offset,
* unit.GetPropertiesDataAsRegisters()[block.AbsoluteOffset]);
* else
* {
* List<ushort> registersToWrite = new List<ushort>();
* for (int j = block.AbsoluteOffset; j < block.AbsoluteOffset + block.Size; j++)
* registersToWrite.Add(unit.GetPropertiesDataAsRegisters()[j]);
*
* _modbusSerial.WriteMultipleRegisters(SlaveAddress, block.Offset, registersToWrite.ToArray());
* }*/
//петя попросил только 16-ю функцию
List <ushort> registersToWrite = new List <ushort>();
for (int j = block.AbsoluteOffset; j < block.AbsoluteOffset + block.Size; j++)
{
registersToWrite.Add(unit.GetPropertiesDataAsRegisters()[j]);
}
_modbusSerial.WriteMultipleRegisters(SlaveAddress, block.Offset, registersToWrite.ToArray());
}
}
catch (Exception exception)
{
return(exception.Message);
}
return("OK");
}
private bool transResultToServer(byte[] ascii)
{
try
{
Configure cfg = null;
string cfgfile = System.IO.Path.Combine(Application.StartupPath, "cfg.json");
if (File.Exists(cfgfile))
{
cfg = JsonConvert.DeserializeObject <Configure>(File.ReadAllText(cfgfile));
if (cfg != null)
{
if (cfg.OutoutMethod == "串口")
{
if (cfg.OutputSerialPortName.Length == 0)
{
return(true);
}
if (cfg.bGetDataOnload && inputCommPortSingleton.GetInstance().checkSerialPort(cfg.OutputSerialPortName))
{
using (SerialPort masterPort = new SerialPort(cfg.OutputSerialPortName))
{
// configure serial ports
masterPort.BaudRate = (int)GetNumber(cfg.OutputSerialPortBaud);
masterPort.DataBits = (int)GetNumber(cfg.OutputSerialPortDataBit);
if (cfg.OutputSerialPortParity == "None Parity")
{
masterPort.Parity = Parity.None;
}
else if (cfg.OutputSerialPortParity == "Odd Parity")
{
masterPort.Parity = Parity.Odd;
}
else
{
masterPort.Parity = Parity.Even;
}
if (cfg.OutputSerialPortStopBit == "1 Stop Bit")
{
masterPort.StopBits = StopBits.One;
}
else
{
masterPort.StopBits = StopBits.Two;
}
masterPort.ReadTimeout = 1000;
masterPort.WriteTimeout = 1000;
masterPort.Open();
// create modbus master
ModbusSerialMaster master = ModbusSerialMaster.CreateAscii(masterPort);
master.Transport.Retries = 5;
ushort startAddress = 0x08;
ushort[] data = new ushort[ascii.Length / sizeof(short)];
Buffer.BlockCopy(ascii, 0, data, 0, data.Length * sizeof(short));
master.WriteMultipleRegisters(1, startAddress, data);
// read five register values
//ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
}
}
}
else
{
using (TcpClient client = new TcpClient(cfg.ServerIp, (int)GetNumber(cfg.ServerPort)))
{
ModbusSerialMaster master = ModbusSerialMaster.CreateAscii(client);
master.Transport.Retries = 5;
ushort startAddress = 0x08;
ushort[] data = new ushort[ascii.Length / sizeof(short)];
Buffer.BlockCopy(ascii, 0, data, 0, data.Length * sizeof(short));
client.SendTimeout = 1000;
client.ReceiveTimeout = 1000;
master.WriteMultipleRegisters(1, startAddress, data);
}
}
}
}
}
catch (Exception ex)
{
LogClass.GetInstance().WriteExceptionLog(ex);
//MessageBox.Show(ex.ToString(), "Error - No Ports available", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(true);
}
/// <summary>
/// отправка инфоданных
/// </summary>
public void send_multi_message(MemoryStream stream)
{
ushort coilAddress = 10;
byte[] date = stream.ToArray();
int count = 50;
count = (date.Length / 2) + 1;
ushort[] date_modbus = new ushort[date.Length / 2 + 1];
int needtopacketsend;
//Кол-во переднных какналов за 1 запрос
int count_send_packet = 70;
ushort[] sentpacket = new ushort[count_send_packet];
write_console(date);
Console.WriteLine("");
//конвертирует в ushort
logger.Info("Преобразование в ushort:Начато");
Buffer.BlockCopy(date, 0, date_modbus, 0, date.Length);
logger.Info("Преобразование в ushort:закончено");
write_console(date_modbus);
byte[] date_unpack = new byte[date.Length];
/*
* Buffer.BlockCopy(date_modbus, 0, date_unpack, 0, date.Length);
* Console.WriteLine("");
* write_console(date_unpack);
* Console.WriteLine("");
*/
try
{
logger.Info("Запрос о получении статуса");
status_slave = SendRequestforStatusSlave();
logger.Info("Cтатус Slave " + status_slave);
//есть свободное время у slave для отправки
if (status_slave == SlaveState.have_free_time)
{
logger.Info("Статус свободен:");
//SendStatusforSlave(SlaveState.havetimetransfer);
//Отправка кол-во байт
Sendpaketwithcountbytes(date.Length);
logger.Info("Статус свободен:");
logger.Info("Отправляем метапкет с кол-вом данных байт" + date.Length);
logger.Info("Отправляем метапкет с кол - вом данных ushort" + date_modbus.Length);
//Console.WriteLine("Отправляем метапкет с кол-вом данных байт"+ date.Length);
//Console.WriteLine("Отправляем метапкет с кол-вом данных ushort" + date_modbus.Length);
if (date_modbus.Length > count_send_packet)
{
//Console.WriteLine("Объем данных больше чем в пакете");
logger.Info("Объем данных больше чем в пакете");
int countneedsend = (date_modbus.Length / count_send_packet) + 1;
int k = 0;
//Console.WriteLine("Будет отправлено " + countneedsend + " пакетов");
logger.Info("Будет отправлено " + countneedsend + " пакетов");
//кол-во отправок
for (int i = 0; i < countneedsend; i++)
{
int counter_reguest_status = 0;
//lonsole.WriteLine("Отправляем запрос о статусе");
logger.Info("Отправляем запрос о статусе");
status_slave = SendRequestforStatusSlave();
if (status_slave == SlaveState.havenot_time)
{
while (counter_reguest_status != 3)
{
//Console.WriteLine("Отправляем запрос о статусе, так как был занят на "+i+" попытке");
logger.Info("Отправляем запрос о статусе, так как был занят на " + i + " попытке");
Thread.Sleep(1000);
status_slave = SendRequestforStatusSlave();
if (status_slave == SlaveState.have_free_time || status_slave == SlaveState.havetimetransfer)
{
counter_reguest_status = 3;
}
else
{
counter_reguest_status++;
}
}
//если нет свободного статуса в течение 3 попыток идет прекращение передачи
if (status_slave == SlaveState.havenot_time)
{
//Console.WriteLine("Попытка передачи не удалось на "+i+"передаче");
logger.Warn("Отправляем запрос о статусе, так как был занят на " + i + " попытке");
}
}
if (status_slave == SlaveState.have_free_time || status_slave == SlaveState.havetimetransfer)
{
//окончание передачи
if (countneedsend - 1 == i)
{
//Console.WriteLine("Отправка " + i + " пакета");
logger.Trace("Отправка " + i + " пакета");
for (int j = i * count_send_packet; j < date_modbus.Length; j++)
{
sentpacket[k] = date_modbus[j];
k++;
}
//Console.WriteLine("Отправка данных");
logger.Trace("Отправка данных");
write_console(sentpacket);
k = 0;
//Console.WriteLine("Отправка данных");
logger.Trace("Отправка данных");
Console.WriteLine("Контрольная сумма");
//если slave свободен то отправляем
master.WriteMultipleRegisters(slaveID, coilAddress, sentpacket);
//Console.WriteLine("Отправлено");
logger.Trace("Отправлено");
Thread.Sleep(500);
//Контрольная сумма
crc16 = new Crc16();
byte[] controlsum16 = crc16.ComputeChecksumBytes(date);
for (int cr1 = 0; cr1 < controlsum16.Length; cr1++)
{
Console.WriteLine(controlsum16[cr1]);
}
//Отправка контрольной суммы
send_cr16_message(controlsum16);
Console.WriteLine("Cформирован");
}
else
{
//Console.WriteLine("Отправка " + i + " пакета");
logger.Trace("Отправка " + i + " пакета");
for (int j = i * count_send_packet; j < (i + 1) * count_send_packet; j++)
{
sentpacket[k] = date_modbus[j];
k++;
}
//Console.WriteLine("Отправка данных");
logger.Trace("Отправка данных");
write_console(sentpacket);
k = 0;
//Console.WriteLine("Отправка данных");
logger.Trace("Отправка данных");
//если slave свободен то отправляем
master.WriteMultipleRegisters(slaveID, coilAddress, sentpacket);
//Console.WriteLine("Отправлено");
logger.Trace("Отправлено");
Thread.Sleep(500);
}
//status_slave = SendRequestforStatusSlave();
}
else
{
//Console.WriteLine("Slave занят: Передача отменена");
logger.Trace("Slave занят: Передача отменена");
counter_reguest_status = 0;
}
}
//после завершение отправки отправить запрос на проверку
//SendStatusforSlave(SlaveState.have_free_time);
}
else //в случае если пакет меньше чем ограничения
{
logger.Trace("Передача меньше чем, пакет");
master.WriteMultipleRegisters(slaveID, coilAddress, date_modbus);
}
}
else //В случае если не получено данные
{
//Console.WriteLine("Пакет не может передаться, связи с тем, что Slave занят");
logger.Warn("Пакет не может передаться, связи с тем, что Slave занят");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
logger.Error(ex);
}
/* обратная передача
* Buffer.BlockCopy(date_modbus, 0, date_unpack, 0, date.Length);
* byte[] date_unpack = new byte[date.Length];
* Console.WriteLine("yes");
*/
}
