private Int16 GetTagCanonicalType(string itemName)
{
const int ItemCanonicalDataTypeProperty = 1;
TreeNode rootNode = uiGroupsTab_AllFoldersTreeView.SelectedNode;
while (rootNode.Parent != null)
{
rootNode = rootNode.Parent;
}
var opcServer = Settings.OpcServers.Where(os => rootNode.FullPath == os.ServerName).Single();
string urlstring = opcServer.URL;
Server server = new Server(new Factory(), new URL(urlstring));
server.Connect();
ItemIdentifier [] itemIdentifiers = new ItemIdentifier[] {new ItemIdentifier(itemName)};
PropertyID[] propertyIDs = new PropertyID[] { new PropertyID(ItemCanonicalDataTypeProperty) };
var result = server.GetProperties(itemIdentifiers, propertyIDs, true);
server.Disconnect();
var resultType = result[0][0].Value.GetType();
PropertyInfo nameProperty = resultType.GetProperty("Name");
string name = nameProperty.GetValue(result[0][0].Value, null) as string;
switch (name.ToLower())
{
case "string":
case "char":
return 0;
case "int16":
case "int32":
case "int64":
case "uint16":
case "uint32":
case "uint64":
return 1;
case "boolean":
return 2;
case "decimal":
case "double":
return 3;
case "datetime":
case "datetimeoffset":
return 4;
default:
return 0;
}
}
private void Operation_1_Button_Click(object sender, EventArgs e)
{
SelectedOperation = 1;
OperationWriteOPC();
OPCServer.Disconnect();
this.Owner.PassOperationValue(SelectedOperation);
User_Program__ControlLogix_System_.UserInterface.Enabled = true;
this.Close();
}
private void Run_Button_Click(object sender, EventArgs e)
{
HMI_PB_SCAN_HARDWARE_VALUE = 0;
SetHardware_OPC();
this.owner.PassValue(PartsNeeded_TextBox.Text);
this.owner.PassReferenceNumber(ReferenceNumber_TextBox.Text);
User_Program.UserProgram.Enabled = true;
OPCServer.Disconnect();
this.Dispose();
this.Close();
}
public void CheckTheConnectionStatus()
{
try
{
if (!_status)
{
if (_repConnectionWorker.IsBusy)
{
_repConnectionWorker.CancelAsync();
}
DisplayPanelServerError.Visible = true;
Trends.Visible = false;
DisplayPanel.Visible = Status;
if (_server.IsConnected)
{
_server.Disconnect();
}
if (!_repConnectionWorker.IsBusy)
{
_repConnectionWorker.RunWorkerAsync();
}
}
else if (_server.GetStatus().ServerState == serverState.running)
{
//Toolbar.Visible = false;
Trends.Visible = false;
DisplayPanel.Visible = Status;
OffConnectionDisplayPanelIndicator.Visible = false;
OnConnectionDisplayPanelIndicator.Visible = false;
DisplayPanelServerError.Visible = true;
DisplayPanelServerError.Text = string.Format(@"| Нет соединения с шахтой {0}");
DisplayPanelServerError.Font = new Font("Segoe UI Symbo", 12F, FontStyle.Regular);
DisplayPanel.ForeColor = Color.PaleVioletRed;
}
}
catch (Exception)
{
//Toolbar.Visible = false;
Trends.Visible = false;
DisplayPanel.Visible = Status;
DisplayPanelServerError.Visible = true;
OffConnectionDisplayPanelIndicator.Visible = true;
OnConnectionDisplayPanelIndicator.Visible = false;
DisplayPanelServerError.Text = @"| Ошибка соединения: Не удалось установить соединение с OPC-сервером";
DisplayPanel.ForeColor = Color.PaleVioletRed;
DisplayPanelServerError.Font = new Font("Segoe UI Symbo", 12F, FontStyle.Regular);
}
}
/// <summary>
/// Disconnect from server.
/// </summary>
/// <returns>Boolean flag.</returns>
public void Disconnect()
{
if (IsConnected)
{
_server.Disconnect();
}
}
/// <summary>
/// 断开OPC连接
/// </summary>
public void OPC_disconnect()
{
OpcGroupClasssubscription.DataChanged -= new Opc.Da.DataChangedEventHandler(this.OnDataChange); //取消回调事件
OpcGroupClasssubscription.RemoveItems(OpcGroupClasssubscription.Items); //移除组内item
//结束：释放各资源
OpcGroupClassm_server.CancelSubscription(OpcGroupClasssubscription); //m_server前文已说明，通知服务器要求删除组。
OpcGroupClasssubscription.Dispose(); //强制.NET资源回收站回收该subscription的所有资源。
OpcGroupClassm_server.Disconnect(); //断开服务器连接
//不相关的
}
/// <summary>
/// 断开与OPC服务连接，并释放资源
/// </summary>
public void Disconect()
{
itemIndexDic.Clear();
//移除组内item
subscription.RemoveItems(subscription.Items);
//通知服务器要求删除组。
m_server.CancelSubscription(subscription);
subscription.Dispose();
m_server.Disconnect();
}
/// <summary>
/// 断开OPC服务器连接
/// </summary>
private void DisConnect()
{
if (m_server != null)
{
m_subscription.RemoveItems(m_subscription.Items);
// 结束：释放各资源
m_server.CancelSubscription(m_subscription); // m_server前文已说明，通知服务器要求删除组。
m_subscription.Dispose(); // 强制.NET资源回收站回收该subscription的所有资源。
m_server.Disconnect(); // 断开服务器连接
}
}
/// <summary>
/// Отключение от сервера OPC.
/// </summary>
public void Disconnect()
{
try
{
serverHandle.Disconnect();
isConnected = false;
Console.WriteLine("Disconnect succeeded");
}
catch (Exception exception)
{
Console.WriteLine("Failed to disconnect - status {0}", exception);
}
}
public override void Dispose()
{
if (!ServiceManager.DesignMode)
{
//WriteXml();
if (_opcDaServer != null && _opcDaServer.IsConnected)
{
_opcDaServer.Disconnect();
_opcDaServer.Dispose();
}
}
}
private void Clear(System.Windows.Forms.TreeNode parent)
{
foreach (System.Windows.Forms.TreeNode parent2 in parent.Nodes)
{
this.Clear(parent2);
}
if (this.IsServerNode(parent))
{
Opc.Da.Server server = (Opc.Da.Server)parent.Tag;
if (server.IsConnected)
{
server.Disconnect();
}
}
}
private Connection CreateConnection(string serverUrl)
{
ServiceManager.LogMessage("Connecting to {0}...", serverUrl);
URL url = new URL(serverUrl);
Opc.Da.Server server = null;
try
{
server = new Opc.Da.Server(new OpcCom.Factory(), url);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
server.Connect();
Opc.Da.ServerStatus serverStatus = server.GetStatus();
if (serverStatus.ServerState != Opc.Da.serverState.running)
{
throw new Exception(String.Format("Bad server state ({0})", serverStatus.ServerState));
}
Connection connection = new Connection(serverUrl, server);
server = null;
stopwatch.Stop();
ServiceManager.LogMessage("Successful created new connection {0}: {1} ({2} ms)",
connection.GetUID(), serverUrl, stopwatch.ElapsedMilliseconds);
Counter counter = counters[serverUrl];
Interlocked.Increment(ref counter.numConnections);
return(connection);
}
catch (Exception ex)
{
stopwatch.Stop();
ServiceManager.LogMessage("Failed create new connection to {0}: {1} ({2} ms)",
serverUrl, ex.Message, stopwatch.ElapsedMilliseconds);
throw new FaultException(ex.Message, new FaultCode("E_FAIL"));
}
}
finally
{
if (server != null)
{
if (server.IsConnected)
{
server.Disconnect();
}
server.Dispose();
}
}
}
/// <summary>
/// Tries to disconnect to the server.
/// </summary>
private void DisConnect()
{
try
{
if (Server != null && Server.IsConnected)
{
Server.Disconnect();
}
}
catch (Exception ex)
{
_error.Append(ex.ToString());
if (ex.InnerException != null)
{
_error.Append(ex.InnerException.ToString());
}
}
}
/// <summary>
/// OPC断开连接
/// </summary>
public void mOpc_DisConn()
{
try
{
if (m_Server != null)
{
subscription.RemoveItems(subscription.Items);
//结束：释放各资源
m_Server.CancelSubscription(subscription); //m_server前文已说明，通知服务器要求删除组。
subscription.Dispose(); //强制.NET资源回收站回收该subscription的所有资源。
m_Server.Disconnect();
}
}
catch (Exception ex)
{
throw new Exception("OPC断开函数（mOpc_DisConn）异常：" + ex.ToString());
}
}
private void Disconnect(System.Windows.Forms.TreeNode node)
{
try
{
if (this.IsServerNode(node))
{
Opc.Da.Server server = (Opc.Da.Server)node.Tag;
if (server.IsConnected)
{
server.Disconnect();
}
node.Nodes.Clear();
}
}
catch (System.Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message);
}
}
public override bool Uninitialize()
{
if (Activated && server != null)
{
try
{
logger.Logged("Info", "Отключаемся от сервера #" + PollerId + "...", "", "");
Activated = false;
TagListBackup.Clear();
server.Disconnect();
server = null;
}
catch (Exception ex)
{
logger.Logged("Error", "Не удалось корректно отключиться от OPC DA сервера #" + PollerId + ": " + ex.Message, "", "");
}
}
return(true);
}
/// <summary>
/// 断开OPC服务器连接
/// </summary>
private void DisConnect()
{
if (m_server != null)
{
m_subscription.RemoveItems(m_subscription.Items);
// 结束：释放各资源
m_server.CancelSubscription(m_subscription); // m_server前文已说明，通知服务器要求删除组。
m_subscription.Dispose(); // 强制.NET资源回收站回收该subscription的所有资源。
m_server.Disconnect(); // 断开服务器连接
}
if (null != m_timer)
{
m_timer.Stop();
m_timer.Close();
m_timer.Dispose();
}
m_lstItemValueResult = null;
m_lstAckTelegram = null;
}
/// <summary>
/// 关闭连接
/// </summary>
private void disConnect()
{
try
{
if (!IsConnected)
{
if (!Equals(null, OnLogHappened))
{
OnLogHappened(this, new OpcLogEventArgs("Opc服务器已断开"));
}
}
if (!Equals(this.opcServer.Subscriptions, null) && this.opcServer.Subscriptions.Count > 0)
{
foreach (Opc.Da.Subscription thisSubscription in this.opcServer.Subscriptions)
{
thisSubscription.RemoveItems(thisSubscription.Items);
thisSubscription.DataChanged -= ThisSubscription_DataChanged;
this.opcServer.CancelSubscription(thisSubscription);
thisSubscription.Dispose();
}
this.opcServer.Subscriptions.Clear();
opcServer.Disconnect();
IsConnected = false;
}
if (!Equals(null, OnLogHappened))
{
OnLogHappened(this, new OpcLogEventArgs("断开Opc服务器成功"));
}
}
catch (Exception ex)
{
IsConnected = false;
if (!Equals(null, OnErrorHappened))
{
OnErrorHappened(this, new OpcErrorEventArgs(OpcResult.E_FAIL, "断开Opc服务器时出错，" + ex.Message, ex));
}
}
}
public void Work()
{
int i = 5;
if (i == 1)
{
url = new Opc.URL("opcda://192.168.0.4/OPC.PHDServerDA.1");
server = new Opc.Da.Server(fact, null);
server.Connect(url, new Opc.ConnectData(new System.Net.NetworkCredential()));
Opc.Da.Item[] itemCollection = new Opc.Da.Item[1];
itemCollection[0] = new Opc.Da.Item {
ItemName = "RTOS.TEST.PV", MaxAge = -1
};
Opc.Da.ItemValueResult[] result = server.Read(itemCollection);
Console.WriteLine(result[0].Value);
server.Disconnect();
}
else if (i == 2)
{
url = new Opc.URL("opcda://192.168.0.4/OPC.PHDServerDA.1");
server = new Opc.Da.Server(fact, null);
server.Connect(url, new Opc.ConnectData(new System.Net.NetworkCredential()));
groupState = new Opc.Da.SubscriptionState();
groupState.Name = "Group";
groupState.ServerHandle = null;
groupState.ClientHandle = Guid.NewGuid().ToString();
groupState.Active = true;
groupState.UpdateRate = 1000;
groupState.Deadband = 0;
groupState.Locale = null;
groupRead = (Opc.Da.Subscription)server.CreateSubscription(groupState);
string[] itemName = { "RTOS.TEST.PV", "RTOR.TI1237.DACA.PV" };
Opc.Da.Item[] items = new Opc.Da.Item[2];
for (int j = 0; j < items.Length; j++)
{
items[j] = new Opc.Da.Item();
items[j].ClientHandle = Guid.NewGuid().ToString();
items[j].ItemPath = null;
items[j].ItemName = itemName[j];
}
groupRead.AddItems(items);
//groupRead.DataChanged += new Opc.Da.DataChangedEventHandler(group_DataChanged);
Opc.Da.ItemValueResult[] results = groupRead.Read(groupRead.Items);
foreach (ItemValueResult result in results)
{
Console.WriteLine("{0},{1},{2},{3}", result.ItemName, result.Value, result.Quality, result.Timestamp);
}
//groupRead.DataChanged -= new Opc.Da.DataChangedEventHandler(group_DataChanged);
groupRead.RemoveItems(groupRead.Items);
server.CancelSubscription(groupRead);
groupRead.Dispose();
server.Disconnect();
}
else if (i == 3)
{
url = new Opc.URL("opcda://192.168.0.4/OPC.PHDServerDA.1");
server = new Opc.Da.Server(fact, null);
server.Connect(url, new Opc.ConnectData(new System.Net.NetworkCredential()));
groupState = new Opc.Da.SubscriptionState();
groupState.Name = "Group";
groupState.ServerHandle = null;
groupState.ClientHandle = Guid.NewGuid().ToString();
groupState.Active = true;
groupState.UpdateRate = 1000;
groupState.Deadband = 0;
groupState.Locale = null;
groupWrite = (Opc.Da.Subscription)server.CreateSubscription(groupState);
string[] itemName = { "RTOS.TEST.PV", "RTOS.TEST2.PV" };
Opc.Da.Item[] items = new Opc.Da.Item[2];
for (int j = 0; j < items.Length; j++)
{
items[j] = new Opc.Da.Item();
items[j].ClientHandle = Guid.NewGuid().ToString();
items[j].ItemPath = null;
items[j].ItemName = itemName[j];
}
groupWrite.AddItems(items);
//groupRead.DataChanged += new Opc.Da.DataChangedEventHandler(group_DataChanged);
Opc.Da.ItemValue[] writeValues = new Opc.Da.ItemValue[groupWrite.Items.Length];
for (int k = 0; k < groupWrite.Items.Length; k++)
{
writeValues[k] = new Opc.Da.ItemValue((ItemIdentifier)groupWrite.Items[k]);
}
writeValues[0].Value = 5;
writeValues[1].Value = 6;
groupWrite.Write(writeValues);
Console.WriteLine("Press any key to close...");
Console.ReadLine();
//groupRead.DataChanged -= new Opc.Da.DataChangedEventHandler(group_DataChanged);
groupWrite.RemoveItems(groupWrite.Items);
server.CancelSubscription(groupWrite);
groupWrite.Dispose();
server.Disconnect();
}
else if (i == 4)
{
url = new Opc.URL("opchda://192.168.0.4/OPC.PHDServerHDA.1");
serverHda = new Opc.Hda.Server(fact, null);
serverHda.Connect(url, new Opc.ConnectData(new System.Net.NetworkCredential()));
try
{
}
catch (Opc.ConnectFailedException opcConnEx)
{
Console.WriteLine(string.Format("Could not connect to server {0}", "OPC.PHDServerHDA.1"));
Console.WriteLine(opcConnEx.ToString());
}
Console.WriteLine("Are we connected? " + serverHda.IsConnected);
string[] itemName = { "RTOS.TEST.PV", "RTOS.TEST2.PV" };
Opc.Hda.Trend groupHda = new Trend(serverHda);
groupHda.Name = "HDA";
groupHda.AggregateID = AggregateID.NOAGGREGATE;
DateTime startTime = DateTime.Now.AddHours(-1);
DateTime endTime = DateTime.Now;
groupHda.StartTime = new Opc.Hda.Time(startTime);
groupHda.EndTime = new Opc.Hda.Time(endTime);
groupHda.MaxValues = 0;
groupHda.IncludeBounds = false;
serverHda.Trends.Add(groupHda);
Opc.Hda.Item[] items = new Opc.Hda.Item[2];
for (int m = 0; m < 2; m++)
{
items[m] = new Opc.Hda.Item();
items[m].ItemName = itemName[m];
items[m].ItemPath = null;
items[m].ClientHandle = Guid.NewGuid().ToString();
}
IdentifiedResult[] identifiedResult = serverHda.CreateItems(items);
if (identifiedResult != null)
{
foreach (IdentifiedResult item in identifiedResult)
{
if (item.ResultID.Succeeded())
{
groupHda.Items.Add(new Opc.Hda.Item(item));
}
}
}
Opc.Hda.ItemValueCollection[] results = groupHda.ReadRaw();
Opc.Hda.ItemValueCollection result1 = results[0];
foreach (Opc.Hda.ItemValue result in result1)
{
Console.WriteLine("{0},{1},{2}", result.Value, result.Quality, result.Timestamp);
}
serverHda.Disconnect();
}
else if (i == 5)
{
url = new Opc.URL("opchda://192.168.0.4/OPC.PHDServerHDA.1");
serverHda = new Opc.Hda.Server(fact, null);
serverHda.Connect(url, new Opc.ConnectData(new System.Net.NetworkCredential()));
try
{
}
catch (Opc.ConnectFailedException opcConnEx)
{
Console.WriteLine(string.Format("Could not connect to server {0}", "OPC.PHDServerHDA.1"));
Console.WriteLine(opcConnEx.ToString());
}
Console.WriteLine("Are we connected? " + serverHda.IsConnected);
string[] itemName = { "RTOR.TI1237.DACA.PV", "RTOS.TEST2.PV" };
Opc.Hda.Trend groupHda = new Trend(serverHda);
groupHda.Name = "HDA";
groupHda.AggregateID = AggregateID.AVERAGE;
DateTime startTime = DateTime.Now.AddHours(-1);
DateTime endTime = DateTime.Now;
//TimeSpan span = endTime.Subtract(startTime);
//int calcInterval = ((int)span.TotalSeconds);
//groupHda.ResampleInterval = (decimal)calcInterval;
//DateTime startTime = new DateTime(2020, 6, 12, 9, 0, 0, 0);
//DateTime endTime = new DateTime(2020, 6, 12, 10, 0, 0, 0);
int calcInterval = 300;
groupHda.ResampleInterval = (decimal)calcInterval;
groupHda.StartTime = new Opc.Hda.Time(startTime);
groupHda.EndTime = new Opc.Hda.Time(endTime);
groupHda.MaxValues = 0;
groupHda.IncludeBounds = false;
serverHda.Trends.Add(groupHda);
Opc.Hda.Item[] items = new Opc.Hda.Item[2];
for (int m = 0; m < 2; m++)
{
items[m] = new Opc.Hda.Item();
items[m].ItemName = itemName[m];
items[m].ItemPath = null;
items[m].ClientHandle = Guid.NewGuid().ToString();
}
IdentifiedResult[] identifiedResult = serverHda.CreateItems(items);
if (identifiedResult != null)
{
foreach (IdentifiedResult item in identifiedResult)
{
if (item.ResultID.Succeeded())
{
groupHda.Items.Add(new Opc.Hda.Item(item));
}
}
}
Opc.Hda.ItemValueCollection[] results = groupHda.ReadProcessed();
Opc.Hda.ItemValueCollection result1 = results[0];
foreach (Opc.Hda.ItemValue result in result1)
{
Console.WriteLine("{0},{1},{2}", result.Value, result.Quality, result.Timestamp);
}
serverHda.Disconnect();
}
}
/*********************************************************************************************************************
* TextBox Enter Region End
*********************************************************************************************************************/
#endregion
/*********************************************************************************************************************
*
* Events Region End
*
*********************************************************************************************************************/
#endregion
/*********************************************************************************************************************
*
* User Teach Sensor End
*
*********************************************************************************************************************/
private void User_Program_Teach_Senson_FormClosing(object sender, FormClosingEventArgs e)
{
OPCServer.Disconnect();
}
// OPC Server Disconnects When the Form is Closing
private void User_Program_Select_Operation_FormClosing(object sender, FormClosingEventArgs e)
{
OPCServer.Disconnect();
}
public string[] GetDataType(List <OPCChannelInfo> Subscribed)
{
string serverName = txtOPCServer.Text;
string hostName = txtOPCServerPath.Text;
_server = new Server(fact, null)
{
Url = new URL(hostName + "/" +
serverName)
};
_server.Connect();
SubscribedCollection = new List <string>();
for (int i = 0; i < Subscribed.Count; i++)
{
SubscribedCollection.Add(Subscribed[i].channel);
}
if (SubscriptionOPC == null)
{
SubscriptionState.Name = "SubscribedGroup";
SubscriptionOPC = (Subscription)_server.CreateSubscription(SubscriptionState);
}
SubscribedItems = new Item[SubscribedCollection.Count];
for (int i = 0; i < SubscribedCollection.Count; i++)
{
SubscribedItems[i] = new Item
{
ItemName = SubscribedCollection[i],
SamplingRate = 200,
Active = true,
ClientHandle = i
};
}
ItemResult = SubscriptionOPC.AddItems(SubscribedItems);
ItemValue[] values = _server.Read(SubscribedItems);
int ArraySize = values.Length;
if (values[0].Value is Array)
{
ArraySize = ((Array)values[0].Value).Length - 1;
}
string[] ReturnValues = new string[ArraySize];
for (int i = 0; i < values.Length; i++)
{
if (values[i].Value is string)
{
ReturnValues[i] = "String";
}
if (values[i].Value is bool)
{
ReturnValues[i] = "Bit";
}
else if (values[i].Value is byte)
{
ReturnValues[i] = "Byte";
}
else if (values[i].Value is float)
{
ReturnValues[i] = "Float";
}
else if (values[i].Value is char)
{
ReturnValues[i] = "char";
}
else if (values[i].Value is short)
{
ReturnValues[i] = "Short";
}
else if (values[i].Value is int)
{
ReturnValues[i] = "Int";
}
else if (values[i].Value is double)
{
ReturnValues[i] = "Double";
}
else if (values[i].Value is Array)
{
ReturnValues[i] = "Array";
}
else if (values[i].Value is uint)
{
ReturnValues[i] = "UInt";
}
else if (values[i].Value is ushort)
{
ReturnValues[i] = "UShort";
}
//else
//{
// ReturnValues[i] = "null";
//}
}
if (_server != null)
{
if (_server.IsConnected)
{
try
{
_server.Disconnect();
}
catch
{
}
}
_server.Dispose();
}
return(ReturnValues);
}
//private void AddNode(Server opcServer, TreeNode treeNode)
//{
// ItemIdentifier itemId;
// BrowsePosition position;
// BrowseFilters filters = new BrowseFilters() { BrowseFilter = browseFilter.branch };
// if (treeNode.FullPath == opcServer.Name)
// {
// itemId = null;
// }
// else
// {
// //int serverNameLength = opcServer.Name.Length;
// //string itemIdentifier = treeNode.FullPath.Substring(serverNameLength + 1);
// itemId = new ItemIdentifier(treeNode.Name);
// }
// BrowseElement[] elements = opcServer.Browse(itemId, filters, out position);
// if (elements == null)
// {
// return;
// }
// foreach (var element in elements)
// {
// treeNode.Nodes.Add(element.Name).Name = element.ItemName;
// }
// //foreach (TreeNode node in treeNode.Nodes)
// //{
// // AddNode(opcServer, node);
// //}
//}
private void UpdateFoldersTree()
{
uiGroupsTab_AllFoldersTreeView.Nodes.Clear();
List<OpcServer> opcServers;
if (uiGroupsTab_Groups.SelectedItem == null)
{
opcServers = Settings.OpcServers;
}
else
{
var selectedGroup = uiGroupsTab_Groups.SelectedItem as Group;
opcServers = new List<OpcServer>();
opcServers.Add(selectedGroup.OpcServer);
}
foreach (var opcServer in opcServers)
{
string urlstring = opcServer.URL;
Server server = new Server(new Factory(), new URL(urlstring));
if (opcServer.RootNode == null)
{
var newNode = uiGroupsTab_AllFoldersTreeView.Nodes.Add(server.Name);
server.Connect();
//AddNode(server, newNode);
UpdateFolderData(newNode);
server.Disconnect();
opcServer.RootNode = newNode;
}
else
{
uiGroupsTab_AllFoldersTreeView.Nodes.Add(opcServer.RootNode);
}
}
if (uiGroupsTab_AllFoldersTreeView.Nodes != null)
{
foreach (TreeNode node in uiGroupsTab_AllFoldersTreeView.Nodes)
{
node.Expand();
}
}
UpdateFolderData(uiGroupsTab_AllFoldersTreeView.SelectedNode);
}
private void UpdateFolderData(TreeNode node)
{
if (node == null)
{
uiFolderTagsBindingSource.DataSource = null;
return;
}
//Add items to folder, read from OPC Server if first time
var folderTags = node.Tag as List<BrowseElement>;
if (folderTags == null)
{
TreeNode rootNode = node;
while (rootNode.Parent != null)
{
rootNode = rootNode.Parent;
}
var opcServer = Settings.OpcServers.Where(os => rootNode.FullPath == os.ServerName).Single();
string urlstring = opcServer.URL;
Server server = new Server(new Factory(), new URL(urlstring));
server.Connect();
BrowsePosition position;
BrowseFilters filters = new BrowseFilters() { BrowseFilter = browseFilter.all };
ItemIdentifier itemId = null;
if (node.FullPath != server.Name)
{
itemId = new ItemIdentifier(node.Name);
}
BrowseElement[] elements = server.Browse(itemId, filters, out position);
server.Disconnect();
var items = elements.Where(e => e.IsItem);
if (items.Any())
{
folderTags = items.ToList();
}
else
{
folderTags = new List<BrowseElement>();
}
var folders = elements.Where(e => e.IsItem == false);
if(folders.Any())
{
foreach (var element in elements.Where(e => !e.IsItem))
{
node.Nodes.Add(element.Name).Name = element.ItemName;
}
}
node.Tag = folderTags;
}
//Exlude elements which already are in group
folderTags = folderTags.ToList();
var selectedGroup = uiGroupsTab_Groups.SelectedItem as Group;
if (selectedGroup != null)
{
if (selectedGroup.Properties != null)
{
foreach (var property in selectedGroup.Properties)
{
folderTags.RemoveAll(t => t.ItemName == property.TagName);
}
}
}
uiFolderTagsBindingSource.DataSource = folderTags;
//if (elements != null)
//{
// var itemsIDs = new List<ItemIdentifier>();
// foreach (var element in elements)
// {
// itemsIDs.Add(new ItemIdentifier(element.ItemName));
// }
// var prid = new List<PropertyID>();
// prid.Add(new PropertyID(1));
// prid.Add(new PropertyID(2));
// var tst = server.GetProperties(itemsIDs.ToArray(), prid.ToArray(), true);
//}
}
private void Cancel_Button_Click(object sender, EventArgs e)
{
OPCServer.Disconnect();
User_Program.UserProgram.Enabled = true;
this.Close();
}
public void Dispose()
{
_server.Disconnect();
}
private void Disconnect()
{
m_server.Disconnect();
}
