private void writeMultipleCoils_Click(object sender, EventArgs e)
{
//connect to modbus...
TcpClient tcpClient = ConnectTcpClient();
ModbusIpMaster master = ConnectModbusMaster(tcpClient);
master.Transport.ReadTimeout = Convert.ToInt16(textBox5.Text);
bool selectedState = Convert.ToBoolean(comboBox2.SelectedItem.ToString());
int startAddress = 512;
int o = startAddress;
ushort readAddress = (ushort)o;
ushort numberOfCoils = 16; // 2 x 8 outputs
bool[] boolArray = new bool[numberOfCoils];
for (int i = 0; i <= 15; i++)
{
boolArray[i] = selectedState;
}
try
{
master.WriteMultipleCoils(readAddress, boolArray);
}
catch (Exception ex)
{
MessageBox.Show("Exception: " + ex.ToString());
throw;
}
tcpClient.Close();
master.Dispose();
}
/// <summary>
/// Simple Modbus UDP master write coils example.
/// </summary>
public static void ModbusUdpMasterWriteCoils()
{
using (UdpClient client = new UdpClient())
{
IPEndPoint endPoint = new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), 502);
client.Connect(endPoint);
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
ushort startAddress = 1;
// write three coils
master.WriteMultipleCoils(startAddress, new bool[] { true, false, true });
}
}
public bool WriteCoils(int address, bool[] values)
{
if (this.CheckConnection())
{
try {
using TcpClient client = new TcpClient(this.IpAddress, this.Port);
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
if (this.SlaveAddress != 0)
{
master.WriteMultipleCoils(this.SlaveAddress, (ushort)address, values);
}
else
{
master.WriteMultipleCoils((ushort)address, values);
}
client.Close();
master.Dispose();
return(true);
} catch {
return(false);
}
}
return(false);
}
public static void Write_MultipleCoils(ushort write_start_addr, bool[] coils_value)
{
coils_value = _writemultiplecoils_Value;
write_start_addr = _writestartAddress;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteMultipleCoils(write_start_addr, coils_value);
Stop_MBClient();
Stop_MBServer();
}
public void WriteMultipleCoils(byte slaveAddress, ushort startAddress, ushort numberOfPoints, bool[] data)
{
if (!status)
{
Connect();
}
try
{
master.WriteMultipleCoils(slaveAddress, startAddress, data);
}
catch (Exception ex)
{
status = false;
AddMessage("Catch exception in the function WriteMultipleCoils(). " + ex.Message,
DebugLevel.ExceptionLevel);
}
}
private static void PutInMaintenceMode()
{
Console.Clear();
Console.WriteLine("Switching To Maintence Mode Please Wait....");
if (CheckConnection(IpAddress, 500))
{
ushort[] regData = { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 };
using (TcpClient client = new TcpClient(IpAddress, 502)) {
bool[] com = { true, false, false, false };
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
com[1] = true;
com[2] = false;
com[3] = false;
master.WriteMultipleCoils(39, com);
bool success = false;
while (true)
{
var check = master.ReadCoils(39, 1);
if (!check[0])
{
Console.WriteLine("Success, Waiting 5 sec then turning off Warning");
success = true;
break;
}
}
//if (success) {
// System.Threading.Thread.Sleep(5000);
// com[1] = false;
// com[2] = false;
// com[3] = false;
// master.WriteMultipleCoils(39, com);
//}
client.Close();
}
Console.WriteLine("Press any key to continue");
Console.ReadKey();
}
else
{
Console.WriteLine("Connection Failed");
}
}
public string WriteIoData(CT2.CIoNode node)
{
ushort len;
if (node.CheckIfExistDO())
{
len = (ushort)((node.m_DO_AddrEnd + 1 - node.m_DO_AddrStart) * 8);
if (len != node.m_DataDO.Count)
{
return("ERR_illegalDataLength_DO");
}
try
{
Thread.Sleep(5);
ushort addrStart = (ushort)(CT2.ECT2Coils.RegionDO + node.m_DO_AddrStart * 8);
master.WriteMultipleCoils(addrStart, node.m_DataDO.ToArray());
}
catch (Exception e)
{
return(e.Message);
}
}
if (node.CheckIfExistAO())
{
len = (ushort)((node.m_AO_AddrEnd + 1 - node.m_AO_AddrStart) / 2);
if (len != node.m_DataAO.Count)
{
return("ERR_illegalDataLength_DO");
}
try
{
Thread.Sleep(5);
ushort addrStart = (ushort)(CT2.ECT2HoldReg.RegionAO + (node.m_AO_AddrStart - 200) / 2);
master.WriteMultipleRegisters(addrStart, node.m_DataAO.ToArray());
}
catch (Exception e)
{
return(e.Message);
}
}
return("NO_ERR");
}
// 1. Run the Write - Part on a Threadpool Thread ...
private bool WriteCoil()
{
master.WriteMultipleCoils(offset, coil_output);
return(true);
}
void cleanQuery()
{
// вначале разбираем очередь на запись
writeComm wr;
// создание дубликата writeQuveryDuble и освобождение исходной коллеции
List <writeComm> writeQuveryDuble = new List <writeComm>();
lock (block)
{
for (int i = 0; i < writeQuvery.Count; i++)
{
writeQuveryDuble.Add(writeQuvery[i]);
}
writeQuvery.Clear();
} //lock
try
{
for (int i = 0; i < writeQuveryDuble.Count; i++)
{
wr = writeQuveryDuble[i];
if (wr.reg == 0)
{
if (wr.len == 1)
{
master.WriteSingleCoil(wr.address, (bool)wr.value);
}
else
{
bool[] b = (bool[])wr.value;
master.WriteMultipleCoils(wr.address, b);
}
}
if (wr.reg == 3)
{
if (wr.type == 2 || wr.type == 3) //2 байтный int
{
if (wr.len == 1)
{
master.WriteSingleRegister(wr.address, BitConverter.ToUInt16(BitConverter.GetBytes((int)wr.value), 0));
}
else
{
ushort[] b = (ushort[])wr.value;
master.WriteMultipleRegisters(wr.address, b);
}
}
if (wr.type >= 4 && wr.type <= 7) //4 байтный int
{
if (wr.len == 1)
{
ushort[] b = new ushort[2];
b[0] = BitConverter.ToUInt16(BitConverter.GetBytes((int)wr.value), 0);
b[1] = BitConverter.ToUInt16(BitConverter.GetBytes((int)wr.value), 2);
master.WriteMultipleRegisters(wr.address, b);
}
else
{
int[] b = (int[])wr.value;
for (ushort j = 0; j < wr.len; j++)
{
ushort[] bb = new ushort[2];
bb[0] = BitConverter.ToUInt16(BitConverter.GetBytes(b[j]), 0);
bb[1] = BitConverter.ToUInt16(BitConverter.GetBytes(b[j]), 2);
master.WriteMultipleRegisters((ushort)(wr.address + (j * 2)), bb);
}
}
}
if (wr.type >= 8 && wr.type <= 9) //4 байтный float
{
if (wr.len == 1)
{
byte[] b = BitConverter.GetBytes((float)wr.value);
ushort[] bb = new ushort[2];
bb[0] = BitConverter.ToUInt16(b, 0);
bb[1] = BitConverter.ToUInt16(b, 2);
master.WriteMultipleRegisters(wr.address, bb);
}
else
{
float[] bb = (float[])wr.value;
for (int j = 0; j < wr.len; j++)
{
byte[] b = BitConverter.GetBytes(bb[j]);
ushort[] bbb = new ushort[2];
bbb[0] = BitConverter.ToUInt16(b, 0);
bbb[1] = BitConverter.ToUInt16(b, 2);
master.WriteMultipleRegisters((ushort)(wr.address + (j * 2)), bbb);
}
}
} //if
} //if
} //for
}
catch (Exception err)
{
Util.errorTCP();
Util.errorMessage(err.Message, description);
device.status = err.HResult;
device.ready = false; //??????????????????????????????/
}
//writeQuvery.Clear();
}
