public void WriteExample( )
{
#region WriteExample1
SiemensS7Net siemens = new SiemensS7Net(SiemensPLCS.S1200, " 192.168.1.110");
// 此处以M100寄存器作为示例
siemens.Write("M100", (short)1234); // 写入M100 short值 ,W3C0,R3C0 效果是一样的
siemens.Write("M100", (ushort)45678); // 写入M100 ushort值
siemens.Write("M100", 1234566); // 写入M100 int值
siemens.Write("M100", (uint)1234566); // 写入M100 uint值
siemens.Write("M100", 123.456f); // 写入M100 float值
siemens.Write("M100", 123.456d); // 写入M100 double值
siemens.Write("M100", 123456661235123534L); // 写入M100 long值
siemens.Write("M100", 523456661235123534UL); // 写入M100 ulong值
siemens.Write("M100", "K123456789"); // 写入M100 string值
// 读取数组
siemens.Write("M100", new short[] { 123, 3566, -123 }); // 写入M100 short值 ,W3C0,R3C0 效果是一样的
siemens.Write("M100", new ushort[] { 12242, 42321, 12323 }); // 写入M100 ushort值
siemens.Write("M100", new int[] { 1234312312, 12312312, -1237213 }); // 写入M100 int值
siemens.Write("M100", new uint[] { 523123212, 213, 13123 }); // 写入M100 uint值
siemens.Write("M100", new float[] { 123.456f, 35.3f, -675.2f }); // 写入M100 float值
siemens.Write("M100", new double[] { 12343.542312d, 213123.123d, -231232.53432d }); // 写入M100 double值
siemens.Write("M100", new long[] { 1231231242312, 34312312323214, -1283862312631823 }); // 写入M100 long值
siemens.Write("M100", new ulong[] { 1231231242312, 34312312323214, 9731283862312631823 }); // 写入M100 ulong值
#endregion
}
private void button1_Click(object sender, EventArgs e)
{
try
{
siemens = new SiemensS7Net(SiemensPLCS.S1200, "127.0.0.1");
siemens.SetPersistentConnection( );
mqttServer = new MqttServer( );
mqttServer.OnClientApplicationMessageReceive += MqttServer_OnClientApplicationMessageReceive;
mqttServer.OnClientConnected += MqttServer_OnClientConnected;
if (checkBox1.Checked)
{
mqttServer.ClientVerification += MqttServer_ClientVerification;
}
mqttServer.RegisterMqttRpcApi("Account", this);
mqttServer.RegisterMqttRpcApi("Siemens", siemens); // 注册一个西门子PLC的服务接口的示例
mqttServer.RegisterMqttRpcApi("TimeOut", typeof(HslTimeOut)); // 注册的类的静态方法和静态属性
mqttServer.RegisterMqttRpcApi("Fanuc", new HslCommunication.CNC.Fanuc.FanucSeries0i("127.0.0.1"));
mqttServer.ServerStart(int.Parse(textBox2.Text));
mqttServer.LogNet = new HslCommunication.LogNet.LogNetSingle("");
mqttServer.LogNet.BeforeSaveToFile += LogNet_BeforeSaveToFile;
mqttServer.RegisterMqttRpcApi("Log", mqttServer.LogNet);
button1.Enabled = false;
button2.Enabled = true;
panel2.Enabled = true;
MessageBox.Show("Start Success");
}
catch (Exception ex)
{
MessageBox.Show("Start Failed : " + ex.Message);
}
}
public SiemensPLC()
{
InitializeComponent();
//实例化一个西门子对象
m_siemensTcpNet = new SiemensS7Net(SiemensPLCS.S1500);
}
//连接PLC SiemensPLCS.S1200
public void SiemensS7NetConnect(SiemensPLCS siemens, out string strMsg)
{
strMsg = "";
siemensTcpNet = new SiemensS7Net(siemens); // 实例化西门子的对象
siemensTcpNet.IpAddress = ConfigurationManager.AppSettings["S7IpAdress"].ToString(); // 设置IP地址
siemensTcpNet.ConnectTimeOut = 1000; // 超时时间为1秒
try
{
OperateResult connect = siemensTcpNet.ConnectServer(); //切换为长连接
if (connect.IsSuccess)
{
//成功添加处理，日志？
Log.loginfo.Info("PLC连接成功！");
strMsg = "PLC连接成功";
}
else
{
strMsg = HslCommunication.StringResources.Language.ConnectedFailed + connect.Message;
Log.logerror.Error("PLC连接失败！", new Exception("失败"));
}
}
catch (Exception ex)
{
strMsg = ex.Message;
}
}
private PLCService()
{
string str = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
string type = IniService.Instance.ReadIniData("PLC", "Type", "S1200", str + "Config.ini");
SiemensPLCS siemensPLCS = 0;
switch (type)
{
case "S1200":
siemensPLCS = SiemensPLCS.S1200;
break;
case "S300":
siemensPLCS = SiemensPLCS.S300;
break;
case "S1500":
siemensPLCS = SiemensPLCS.S1500;
break;
case "S200Smart":
siemensPLCS = SiemensPLCS.S200Smart;
break;
case "S200":
siemensPLCS = SiemensPLCS.S200;
break;
default:
break;
}
siemensTcpNet = new SiemensS7Net(siemensPLCS);
}
private void button12_Click(object sender, EventArgs e)
{
pipeSocket?.Socket?.Close( );
pipeSocket = new PipeSocket("127.0.0.1", 102);
siemensS[0] = new SiemensS7Net(SiemensPLCS.S1200);
siemensS[1] = new SiemensS7Net(SiemensPLCS.S1200);
siemensS[2] = new SiemensS7Net(SiemensPLCS.S1200);
siemensS[0].SetPipeSocket(pipeSocket);
siemensS[1].SetPipeSocket(pipeSocket);
siemensS[2].SetPipeSocket(pipeSocket);
thread_status = 3;
failed = 0;
thread_time_start = DateTime.Now;
new Thread(new ParameterizedThreadStart(thread_test2))
{
IsBackground = true,
}.Start("M100");
new Thread(new ParameterizedThreadStart(thread_test2))
{
IsBackground = true,
}.Start("M200");
new Thread(new ParameterizedThreadStart(thread_test2))
{
IsBackground = true,
}.Start("M300");
button12.Enabled = false;
timer = new System.Windows.Forms.Timer( );
timer.Interval = 1000;
timer.Tick += Timer_Tick;
timer.Start( );
}
/// <summary>
/// S7协议连接PLC
/// </summary>
/// <param name="IPAdrr">PLC地址</param>
/// <returns></returns>
public bool Connect(string IPAdrr)
{
bool result = false;
if (!System.Net.IPAddress.TryParse(IPAdrr, out System.Net.IPAddress address))
{
MessageBox.Show("IP地址错误！");
}
else
{
siemensS7Net = new SiemensS7Net(SiemensPLCS.S200Smart, IPAdrr)
{
ConnectTimeOut = 1000
};
OperateResult connect = siemensS7Net.ConnectServer();
if (connect.IsSuccess)
{
result = true;
}
else
{
result = false;
}
}
return(result);
}
private void button1_Click(object sender, EventArgs e)
{
// 连接
if (!int.TryParse(textBox2.Text, out int port))
{
MessageBox.Show("端口输入不正确！");
return;
}
siemensTcpNet = new SiemensS7Net(siemensPLCSelected, "127.0.0.1");
if (siemensPLCSelected != SiemensPLCS.S200Smart)
{
siemensTcpNet.Rack = byte.Parse(textBox15.Text);
siemensTcpNet.Slot = byte.Parse(textBox16.Text);
}
try
{
siemensTcpNet.ConnectionId = textBox1.Text; // 设置唯一的ID
NetworkAlienStart(port);
siemensTcpNet.ConnectServer(null); // 切换为异形客户端，并等待服务器的连接。
userControlReadWriteOp1.SetReadWriteNet(siemensTcpNet, "M100", true);
MessageBox.Show("等待服务器的连接！");
button1.Enabled = false;
button2.Enabled = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public HsControlServer(string plcip)
{
sPLC = new SiemensS7Net(SiemensPLCS.S1500, plcip)
{
ConnectTimeOut = 5000
};
}
public void ReadExample( )
{
#region ReadExample1
SiemensS7Net siemensTcpNet = new SiemensS7Net(SiemensPLCS.S1200, " 192.168.1.110");
// 此处以M100寄存器作为示例
byte byte_M100 = siemensTcpNet.ReadByte("M100").Content; // 读取M100的值
short short_M100 = siemensTcpNet.ReadInt16("M100").Content; // 读取M100-M101组成的字
ushort ushort_M100 = siemensTcpNet.ReadUInt16("M100").Content; // 读取M100-M101组成的无符号的值
int int_M100 = siemensTcpNet.ReadInt32("M100").Content; // 读取M100-M103组成的有符号的数据
uint uint_M100 = siemensTcpNet.ReadUInt32("M100").Content; // 读取M100-M103组成的无符号的值
float float_M100 = siemensTcpNet.ReadFloat("M100").Content; // 读取M100-M103组成的单精度值
long long_M100 = siemensTcpNet.ReadInt64("M100").Content; // 读取M100-M107组成的大数据值
ulong ulong_M100 = siemensTcpNet.ReadUInt64("M100").Content; // 读取M100-M107组成的无符号大数据
double double_M100 = siemensTcpNet.ReadDouble("M100").Content; // 读取M100-M107组成的双精度值
string str_M100 = siemensTcpNet.ReadString("M100", 10).Content; // 读取M100-M109组成的ASCII字符串数据
// 读取数组
short[] short_M100_array = siemensTcpNet.ReadInt16("M100", 10).Content; // 读取M100-M101组成的字
ushort[] ushort_M100_array = siemensTcpNet.ReadUInt16("M100", 10).Content; // 读取M100-M101组成的无符号的值
int[] int_M100_array = siemensTcpNet.ReadInt32("M100", 10).Content; // 读取M100-M103组成的有符号的数据
uint[] uint_M100_array = siemensTcpNet.ReadUInt32("M100", 10).Content; // 读取M100-M103组成的无符号的值
float[] float_M100_array = siemensTcpNet.ReadFloat("M100", 10).Content; // 读取M100-M103组成的单精度值
long[] long_M100_array = siemensTcpNet.ReadInt64("M100", 10).Content; // 读取M100-M107组成的大数据值
ulong[] ulong_M100_array = siemensTcpNet.ReadUInt64("M100", 10).Content; // 读取M100-M107组成的无符号大数据
double[] double_M100_array = siemensTcpNet.ReadDouble("M100", 10).Content; // 读取M100-M107组成的双精度值
#endregion
}
private async void thread_test2(object add)
{
string address = (string)add;
SiemensS7Net plc = address == "M100" ? siemensS[0] : address == "M200" ? siemensS[1] : siemensS[2];
int count = 10000;
while (count > 0)
{
if (!(await plc.WriteAsync(address, (short)count)).IsSuccess)
{
failed++;
}
OperateResult <short> read = await plc.ReadInt16Async(address);
if (!read.IsSuccess)
{
failed++;
}
else
{
if (read.Content != count)
{
failed++;
}
}
count--;
successCount++;
}
thread_end2( );
}
/// <summary>
/// 初始化连接client，传递PLC构建类型list
/// </summary>
/// <param name="siemensPLCS"></param>
/// <exception cref="ArgumentNullException">未传递参数</exception>
/// <exception cref="Exception">其他可能异常</exception>
public HslSiemensImplement(List <SiemensPLCBuildModel> siemensPLCBuildModels)
{
if (siemensPLCBuildModels == null || siemensPLCBuildModels.Count == 0)
{
throw new ArgumentNullException("请传递参数");
}
try
{
foreach (var item in siemensPLCBuildModels)
{
var siemensTcpNet = new SiemensS7Net(item.SiemensPLCS);
siemensTcpNet.IpAddress = item.IP;
siemensTcpNet.Port = item.Port;
siemensTcpNet.Rack = byte.Parse(item.Rack.ToString());
siemensTcpNet.Slot = byte.Parse(item.Slot.ToString());
//长链接模式；后面的每次请求都共享一个通道
siemensTcpNet.ConnectServer();
siemensTcpNets.Add(siemensTcpNet);
}
}
catch (Exception ex)
{
throw ex;
}
}
public void WriteExample2( )
{
#region WriteExample2
SiemensS7Net siemens = new SiemensS7Net(SiemensPLCS.S1200, " 192.168.1.110");
// 拼凑数据，这样的话，一次通讯就完成数据的全部写入
byte[] buffer = new byte[8];
siemens.ByteTransform.TransByte((short)1234).CopyTo(buffer, 0);
siemens.ByteTransform.TransByte((short)2100).CopyTo(buffer, 2);
siemens.ByteTransform.TransByte(12353423).CopyTo(buffer, 4);
OperateResult write = siemens.Write("M100", buffer);
if (write.IsSuccess)
{
// success
}
else
{
// failed
}
// 上面的功能等同于三个数据分别写入，下面的性能更差点，因为进行了三次通讯，而且每次还要判断是否写入成功
//siemens.Write( "M100", (short)1234 );
//siemens.Write( "M100", (short)2100 );
//siemens.Write( "M100", 12353423 );
#endregion
}
static void Main(string[] args)
{
IReadWriteNet siemens = new SiemensS7Net(SiemensPLCS.S1500, "192.168.0.1");
siemens.Write("M8000", (ushort)99);
var result = siemens.ReadUInt16("M8000");
}
private void button1_Click(object sender, EventArgs e)
{
// 启动服务
try
{
siemens = new SiemensS7Net(SiemensPLCS.S1200, "127.0.0.1");
siemens.SetPersistentConnection( );
pcccNet = new AllenBradleyPcccNet("127.0.0.1");
pcccNet.SetPersistentConnection( );
httpServer = new HttpServer( );
httpServer.Start(int.Parse(textBox2.Text));
httpServer.HandleRequestFunc = HandleRequest;
httpServer.IsCrossDomain = checkBox1.Checked; // 是否跨域的设置
httpServer.RegisterHttpRpcApi("", this);
httpServer.RegisterHttpRpcApi("Siemens", siemens); // 注册一个西门子PLC的服务接口的示例
httpServer.RegisterHttpRpcApi("TimeOut", typeof(HslTimeOut)); // 注册的类的静态方法和静态属性
httpServer.RegisterHttpRpcApi("PCCC", pcccNet);
if (checkBox2.Checked)
{
httpServer.SetLoginAccessControl(new HslCommunication.MQTT.MqttCredential[] {
new HslCommunication.MQTT.MqttCredential("admin", "123456")
});
}
panel2.Enabled = true;
button1.Enabled = false;
}
catch (Exception ex)
{
MessageBox.Show("Started Failed:" + ex.Message);
}
}
static void Main(string[] args)
{
SiemensS7Net plc = new SiemensS7Net(SiemensPLCS.S1200, "127.0.0.1"); // 此处拿了本地虚拟的PLC测试
plc.SetPersistentConnection( ); // 设置了长连接
MqttServer mqttServer = new MqttServer( );
mqttServer.RegisterMqttRpcApi("MainPLC", plc);
mqttServer.ServerStart(1883);
while (true)
{
Thread.Sleep(1000); // 每秒读取一次
OperateResult <short> read = plc.ReadInt16("M100");
if (read.IsSuccess)
{
// 读取成功后，进行业务处理，存入数据库，或是其他的分析
Console.WriteLine("读取成功，M100：" + read.Content);
}
else
{
// 读取失败之后，显示下状态
Console.WriteLine("读取PLC失败，原因：" + read.Message);
}
}
}
public static void Start(bool bIsRunning)
{
PLCHelper.bIsRunning = bIsRunning;
siemensTcpNet = new SiemensS7Net(SiemensPLCS.S1200, "127.0.0.1")
{
ConnectTimeOut = 5000
};
}
private void btnConnect_Click(object sender, EventArgs e)
{
plc = new SiemensS7Net(plcType);
try
{
plc.IpAddress = edtIPAddress.Text;
if (int.TryParse(edtPort.Text, out int port))
{
plc.Port = port;
}
else
{
plc.Port = 102;
edtPort.Text = "102";
}
if (byte.TryParse(edtSlot.Text, out byte slot))
{
plc.Slot = slot;
}
else
{
plc.Slot = 0;
edtSlot.Text = "0";
}
if (byte.TryParse(edtRack.Text, out byte rack))
{
plc.Rack = rack;
}
else
{
plc.Rack = 0;
edtRack.Text = "0";
}
OperateResult connect = plc.ConnectServer();
if (connect.IsSuccess)
{
isConnected = true;
btnConnect.Enabled = false;
btnDisconnect.Enabled = true;
edtIPAddress.Enabled = false;
edtPort.Enabled = false;
edtRack.Enabled = false;
edtSlot.Enabled = false;
}
else
{
MessageBox.Show($"({connect.ErrorCode}){connect.Message}");
isConnected = false;
}
}
catch (Exception error)
{
MessageBox.Show(error.Message);
isConnected = false;
}
}
private void TheadConnection()
{
SiemensS7Net siemensS7 = new SiemensS7Net(SiemensPLCS.S1200);
siemensS7.ConnectTimeOut = 10000;
siemensS7.ConnectServer( );
siemensS7.ConnectClose( );
}
private void button7_Click(object sender, EventArgs e)
{
SiemensS7Net server = new SiemensS7Net(SiemensPLCS.S1200);
server.IpAddress = "192.168.5.1";
sim = new SiemensPLCSolution(server, Functions.Model.ItemCollection.newFuc());
sim1 = new SiemensPLCSolution(server, Functions.Model.ItemCollection.newFuc2());
}
public void ClosePLC()
{
if (_SiementsTcpNet != null)
{
_SiementsTcpNet.ConnectClose();
_SiementsTcpNet = null;
PLCIsopen = false;
}
}
public void ClassTest( )
{
#region Usage
// 实例化对象，指定PLC的ip地址
SiemensS7Net siemens = new SiemensS7Net(SiemensPLCS.S1200, " 192.168.1.110");
// 举例读取M100的值
short M100 = siemens.ReadInt16("M100").Content;
#endregion
}
/// <summary>
/// 停止
/// </summary>
public override void DoStop()
{
try
{
this.isClose = true;
foreach (LD.Config.PlcTypeItem item in this.config.PlcTypeItems)
{
if (!item.IsActive || !item.IsConnected)
{
continue;
}
switch (item.DevType)
{
case Common.DeviceType.S1200:
case Common.DeviceType.S1500:
case Common.DeviceType.S200:
case Common.DeviceType.S200Smart:
case Common.DeviceType.S300:
case Common.DeviceType.S400:
SiemensS7Net plc = (SiemensS7Net)item.Tag;
plc.ConnectClose();
break;
case Common.DeviceType.ModbusTcp:
ModbusTcpNet mdTcp = (ModbusTcpNet)item.Tag;
mdTcp.ConnectClose();
break;
case Common.DeviceType.ModbusRtu:
ModbusRtu mdRtu = (ModbusRtu)item.Tag;
mdRtu.Close();
break;
default:
break;
}
item.IsConnected = false;
}
foreach (LD.Config.PlcDataItem plc in this.config.PlcDataItems)
{
plc.PropertyChanged -= new PropertyChangedEventHandler(plc_PropertyChanged);
plc.PropertyChanged -= new PropertyChangedEventHandler(Ui.frmSiemens.Instance.plc_PropertyChanged);
}
this.PlcValueChanged -= new LD.Config.PlcValueChangeEventHandler(PlcClient_PlcValueChanged);
}
catch (Exception ex)
{
throw new StopException(this.ToString(), ex.ToString());
}
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="ipAddress">PLC的IP地址</param>
/// <param name="rack">PLC的机架号</param>
/// <param name="slot">PLC的插槽号</param>
public SiemensPLCConnection(string ipAddress, int rack, int slot)
{
_log = Logger.Get <SiemensPLCConnection>();
siemensTcpNet = new SiemensS7Net(siemensPLCS);
IPAddress = ipAddress;
Rack = rack;
Slot = slot;
isConnected = Connect();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Console.WriteLine(System.Globalization.CultureInfo.CurrentCulture.ToString());
SiemensS7Net siemens = new SiemensS7Net(SiemensPLCS.S1200, "192.168.8.12");
Console.ReadLine( );
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="siemensServer">传入西门子服务器</param>
/// <param name="vs">地址</param>
public SiemensPLCSolution(SiemensS7Net siemensServer, List <string> vs)
{
Vs = vs;
SiemensTcpNet = siemensServer;
OperateResult connect = SiemensTcpNet.ConnectServer();
if (!connect.IsSuccess)
{
throw new Exception("初始化失败！" + connect.Message);
}
}
private Thread threadReadPlc = null; // 后台读取PLC的线程
private void SiemensTcpNetInitialization( )
{
siemensTcpNet = new SiemensS7Net(SiemensPLCS.S1200); // 实例化西门子的对象
siemensTcpNet.IpAddress = "192.168.8.12"; // 设置IP地址
siemensTcpNet.LogNet = LogNet; // 设置统一的日志记录器
siemensTcpNet.ConnectTimeOut = 1000; // 超时时间为1秒
// 启动后台读取的线程
threadReadPlc = new Thread(new System.Threading.ThreadStart(ThreadBackgroundReadPlc));
threadReadPlc.IsBackground = true;
threadReadPlc.Priority = ThreadPriority.AboveNormal;
threadReadPlc.Start( );
}
// 写设备的值
public bool WriteValue(Common.PlcDevice plcDevice, object value)
{
bool IsOk = false;
try
{
Config.PlcDataItem devData = this.GetPlcDataItem(plcDevice);
Config.PlcTypeItem devType = this.GetPlcTypeItem(devData.DeviceName);
switch (devType.DevType)
{
//Keyence
case Common.DeviceType.Keyence:
KeyenceMcNet kPlcClient = (KeyenceMcNet)devType.Tag;
IsOk = this.WriteSieTcpValue(devType, devData, kPlcClient, value);
break;
//Melsec
case Common.DeviceType.Qseries:
MelsecMcNet mPlcClient = (MelsecMcNet)devType.Tag;
IsOk = this.WriteSieTcpValue(devType, devData, mPlcClient, value);
break;
case Common.DeviceType.S1200:
case Common.DeviceType.S300:
case Common.DeviceType.S400:
case Common.DeviceType.S1500:
case Common.DeviceType.S200Smart:
case Common.DeviceType.S200:
SiemensS7Net sPlcClient = (SiemensS7Net)devType.Tag;
IsOk = this.WriteSieTcpValue(devType, devData, sPlcClient, value);
break;
case Common.DeviceType.ModbusTcp:
ModbusTcpNet mTcpClient = (ModbusTcpNet)devType.Tag;
IsOk = this.WriteModTcpValue(devType, devData, mTcpClient, value);
break;
case Common.DeviceType.ModbusRtu:
ModbusRtu mRtuClinet = (ModbusRtu)devType.Tag;
IsOk = this.WriteModRtuValue(devType, devData, mRtuClinet, value);
break;
default:
break;
}
}
catch { }
return(IsOk);
}
/// <summary>
/// 实例化一个西门子的设备对象，从配置信息创建
/// </summary>
/// <param name="element">配置信息</param>
public DeviceSiemens(XElement element)
{
NodeSiemens nodeSiemens = new NodeSiemens( );
nodeSiemens.LoadByXmlElement(element);
LoadRequest(element);
if (nodeSiemens.PlcType == NodeSiemens.PLCFW)
{
isS7Net = false;
siemensFetchWrite = new SiemensFetchWriteNet(nodeSiemens.IpAddress, nodeSiemens.Port);
siemensFetchWrite.ConnectTimeOut = nodeSiemens.ConnectTimeOut;
ReadWriteDevice = siemensFetchWrite;
ByteTransform = siemensFetchWrite.ByteTransform;
UniqueId = siemensFetchWrite.ConnectionId;
}
else
{
isS7Net = true;
if (nodeSiemens.PlcType == NodeSiemens.PLC300)
{
siemensS7Net = new SiemensS7Net(SiemensPLCS.S300);
}
else if (nodeSiemens.PlcType == NodeSiemens.PLC1200)
{
siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200);
}
else if (nodeSiemens.PlcType == NodeSiemens.PLC1500)
{
siemensS7Net = new SiemensS7Net(SiemensPLCS.S1500);
}
else if (nodeSiemens.PlcType == NodeSiemens.PLC200Smart)
{
siemensS7Net = new SiemensS7Net(SiemensPLCS.S200Smart);
}
else
{
siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200);
}
siemensS7Net.IpAddress = nodeSiemens.IpAddress;
siemensS7Net.ConnectTimeOut = nodeSiemens.ConnectTimeOut;
ByteTransform = siemensS7Net.ByteTransform;
ReadWriteDevice = siemensS7Net;
UniqueId = siemensS7Net.ConnectionId;
}
TypeName = "西门子设备";
}
public void PLCInit()
{
LogNet = new LogNetDateTime(Application.StartupPath + "\\Logs\\通讯异常", GenerateMode.ByEveryDay); // 创建日志器，按每天存储不同的文件
LogNet.BeforeSaveToFile += LogNet_BeforeSaveToFile; // 设置存储日志前的一些额外操作
//天车A的PLC（本车PLC）
//siemensTcpNet1 =new SiemensS7Net(SiemensPLCS.S1200, "192.168.0.4") { ConnectTimeOut = 1000 }
siemensTcpNet1 = new SiemensS7Net(SiemensPLCS.S1500, "192.168.0.4")
{
ConnectTimeOut = 1000
};
//天车B的PLC（邻车PLC）
siemensTcpNet2_Read = new SiemensS7Net(SiemensPLCS.S1500, "192.168.0.1")
{
ConnectTimeOut = 1000
};
siemensTcpNet2_Write = new SiemensS7Net(SiemensPLCS.S1500, "192.168.0.1")
{
ConnectTimeOut = 1000
};
siemensTcpNet1.LogNet = LogNet; // 设置统一的日志记录器
siemensTcpNet2_Read.LogNet = LogNet;
siemensTcpNet2_Read.LogNet = LogNet;
// 启动后台读取的线程
threadReadPlc1 = new Thread(new System.Threading.ThreadStart(ThreadBackgroundReadPlc1));
threadReadPlc1.IsBackground = true;
threadReadPlc1.Priority = ThreadPriority.AboveNormal;
siemensTcpNet2_Read.LogNet = LogNet; // 设置统一的日志记录器
siemensTcpNet2_Read.ConnectTimeOut = 1000;
// 启动后台读取的线程
threadReadPlc2 = new Thread(new System.Threading.ThreadStart(ThreadBackgroundReadPlc2));
threadReadPlc2.IsBackground = true;
threadReadPlc2.Priority = ThreadPriority.AboveNormal;
//建立PLC1读取长连接
PlcisSuccess1 = ConnectPLC1();
//建立PLC2读取长连接
PlcisSuccess2_Read = ConnectPLC2();
//建立PLC2写长连接
PlcisSuccess2_Write = ConnectPLC2_Write();
//开启线程
threadstart_plc1 = StartPLC1Read();
//开启线程
threadstart_plc2 = StartPLC2Read();
//PLC连接成功后先给夹具一个张开状态
}
