internal static OpcDaItemValue[] Create(OpcDaGroup opcDaGroup, OPCITEMSTATE[] ppItemValues, HRESULT[] ppErrors) { try { var result = new OpcDaItemValue[ppItemValues.Length]; for (var i = 0; i < result.Length; i++) { result[i] = new OpcDaItemValue { Timestamp = FileTimeConverter.FromFileTime(ppItemValues[i].ftTimeStamp), Value = ppItemValues[i].vDataValue, Quality = ppItemValues[i].wQuality, Error = ppErrors[i], Item = opcDaGroup.GetItem(ppItemValues[i].hClient) }; } return result; } catch (Exception ex) { Log.Error("Cannot create OpcDaItemValue object.", ex); return new OpcDaItemValue[0]; } }
public async Task ReadValiesAsynchronously() { Uri url = UrlBuilder.Build("Matrikon.OPC.Simulation.1"); using (var server = new OpcDaServer(url)) { // Connect to the server first. server.Connect(); // Create a group with items. OpcDaGroup group = CreateGroupWithItems(server); // Read values of items from device asynchronously. OpcDaItemValue[] values = await group.ReadAsync(group.Items); // Output values foreach (OpcDaItemValue value in values) { Console.WriteLine("ItemId: {0}; Value: {1}; Quality: {2}; Timestamp: {3}", value.Item.ItemId, value.Value, value.Quality, value.Timestamp); } // The output should be like the following: // ItemId: Bucket Brigade.Int4; Value: 0; Quality: Good+Good+NotLimited; Timestamp: 04/18/2016 13:40:57 +03:00 // ItemId: Random.Int2; Value: 26500; Quality: Good+Good+NotLimited; Timestamp: 04/18/2016 13:40:57 +03:00 values.Should().OnlyContain(v => v.Error.Succeeded); values.Should().OnlyContain(v => v.Quality.Master == OpcDaQualityMaster.Good); } }
//Создание групп для чтения данных из OPC-сервера protected void InitDataGroup(string[] itemDescription, string groupName, out OpcDaGroup dataGroup) { dataGroup = opcReader._opcServer.AddGroup(groupName); //Группа переменных для чтения (записи) из OPC-сервера dataGroup.IsActive = true; List <OpcDaItemDefinition> itemDefinitions = new List <OpcDaItemDefinition>(); //Definitions для добавления в группу чтения в OPC-сервер foreach (var item in opcTagNamesCollection) { for (int i = 0; i < itemDescription.Length; i++) { itemDefinitions.Add(new OpcDaItemDefinition { ItemId = item + "." + itemDescription[i], IsActive = true }); } } OpcDaItemResult[] results = dataGroup.AddItems(itemDefinitions); //Добавление переменных в группу foreach (OpcDaItemResult result in results) { if (result.Error.Failed) { Console.WriteLine("Error adding items: {0}", result.Error); } } }
public void WriteValues(string host, string serviceProgId, string groupKey, Dictionary <string, object> itemValuePairs) { OpcDaService server = GetOpcDaService(host, serviceProgId); if (server == null) { return; } if (server.OpcDaGroupS.ContainsKey(groupKey) == true) { OpcDaGroup group = server.OpcDaGroupS[groupKey]; var keyList = itemValuePairs.Keys.ToList(); List <OpcDaItem> itemList = new List <OpcDaItem>(); keyList.ForEach(ids => { var daItem = group.Items .Where(a => a.ItemId == ids) .FirstOrDefault(); itemList.Add(daItem); }); object[] dd = itemValuePairs.Values.ToArray(); HRESULT[] res = group.Write(itemList, dd); LogHelper.Log("Write HRESULT " + res.ToString()); } }
private static OpcDaGroup CreateGroupWithItems(OpcDaServer server) { // Create a group with items. OpcDaGroup group = server.AddGroup("MyGroup"); group.IsActive = true; var definition1 = new OpcDaItemDefinition { ItemId = "Bucket Brigade.Int4", IsActive = true }; var definition2 = new OpcDaItemDefinition { ItemId = "Random.Int2", IsActive = true }; OpcDaItemDefinition[] definitions = { definition1, definition2 }; OpcDaItemResult[] results = group.AddItems(definitions); // Handle adding results. foreach (OpcDaItemResult result in results) { if (result.Error.Failed) { Console.WriteLine("Error adding items: {0}", result.Error); } } return(group); }
public async Task GetAValueOfAnItemBySubscription() { Uri url = UrlBuilder.Build("Matrikon.OPC.Simulation.1"); using (var server = new OpcDaServer(url)) { // Connect to the server first. server.Connect(); // Create a group with items. OpcDaGroup group = CreateGroupWithItems(server); // Configure subscription. group.ValuesChanged += OnGroupValuesChanged; group.UpdateRate = TimeSpan.FromMilliseconds(100); // ValuesChanged won't be triggered if zero // Wait some time. await Task.Delay(1000); // The output should be like the following: // ItemId: Bucket Brigade.Int4; Value: 0; Quality: Good+Good+NotLimited; Timestamp: 04/19/2016 12:41:11 +03:00 // ItemId: Random.Int2; Value: 0; Quality: Bad+BadOutOfService+NotLimited; Timestamp: 04/19/2016 12:41:11 +03:00 // ItemId: Random.Int2; Value: 41; Quality: Good+Good+NotLimited; Timestamp: 04/19/2016 12:41:13 +03:00 // ItemId: Random.Int2; Value: 18467; Quality: Good+Good+NotLimited; Timestamp: 04/19/2016 12:41:13 +03:00 // ... } }
public void setItemsCount(string groupKey, OpcDaGroup group) { try { OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device); if (values.Length == group.Items.Count) { for (int i = 0; i < values.Length; ++i) { if (values[i].Value != null) { if (itemscountCollection.ContainsKey(groupKey) == false) { itemscountCollection.Add(groupKey, 1); itemstotalCollection.Add(groupKey, 1); } else { itemscountCollection[groupKey] = itemscountCollection[groupKey] + 1; itemstotalCollection[groupKey] = itemstotalCollection[groupKey] + 1; } } } } } catch (Exception e) { LogHelper.Log("Exception: " + e.ToString()); } }
internal static OpcDaItemValue[] Create(OpcDaGroup opcDaGroup, int dwCount, int[] phClientItems, object[] pvValues, short[] pwQualities, FILETIME[] pftTimeStamps, HRESULT[] pErrors) { try { var values = new OpcDaItemValue[dwCount]; for (var i = 0; i < values.Length; i++) { values[i] = new OpcDaItemValue { Value = pvValues[i], Item = opcDaGroup.GetItem(phClientItems[i]), Quality = pwQualities[i], Timestamp = FileTimeConverter.FromFileTime(pftTimeStamps[i]), Error = pErrors[i] }; } return values; } catch (Exception ex) { Log.Error("Cannot create OpcDaItemValue object.", ex); return new OpcDaItemValue[0]; } }
public static void SetTagValues(string opcServerUrl, BaseTagValueWrapper valuesWrapper) { lock (GetLockObject(opcServerUrl)) { OpcDaServer server = GetOrCreateServer(opcServerUrl); OpcDaGroup group = server.Groups.FirstOrDefault(x => x.Name == "DecisionsWriteGroup"); if (group == null) { group = server.AddGroup("DecisionsWriteGroup"); } BaseTagValue[] values = valuesWrapper.Values; if (values == null || values.Length == 0) { return; } List <OpcDaItemDefinition> missing = new List <OpcDaItemDefinition>(); foreach (BaseTagValue value in values) { OpcDaItem item = group.Items.FirstOrDefault(x => x.ItemId == value.Path); if (item == null) { missing.Add(new OpcDaItemDefinition { ItemId = value.Path }); } } // ensure that tags are in group if (missing.Count > 0) { OpcDaItemResult[] addResults = group.AddItems(missing); foreach (OpcDaItemResult result in addResults) { if (result.Error.Failed) { throw new Exception($"Set tag value failed: could not add tag to group"); } } } List <OpcDaItem> items = new List <OpcDaItem>(); List <object> itemValues = new List <object>(); foreach (BaseTagValue value in values) { OpcDaItem item = group.Items.First(x => x.ItemId == value.Path); //throw if missing items.Add(item); itemValues.Add(OPCAgentUtils.GetObjectValueFromTag(value)); } HRESULT[] writeResults = group.Write(items, itemValues.ToArray()); foreach (HRESULT writeResult in writeResults) { if (writeResult.Failed) { throw new Exception($"Set tag value failed: Error while writing values: {writeResult.ToString()}"); } } } }
static void Main() { Bootstrap.Initialize(); Uri url = UrlBuilder.Build("Matrikon.OPC.Simulation.1"); using (var server = new OpcDaServer(url)) { // Connect to the server first. server.Connect(); // Create a group with items. OpcDaGroup group = server.AddGroup("MyGroup"); group.IsActive = true; var definition1 = new OpcDaItemDefinition { ItemId = "Random.Boolean", IsActive = true }; var definition2 = new OpcDaItemDefinition { ItemId = "Random.Int1", IsActive = true }; var definition3 = new OpcDaItemDefinition { ItemId = "Random.Int2", IsActive = true }; OpcDaItemDefinition[] definitions = { definition1, definition2, definition3 }; OpcDaItemResult[] results = group.AddItems(definitions); // Handle adding results. foreach (OpcDaItemResult result in results) { if (result.Error.Failed) { Console.WriteLine("Error adding items: {0}", result.Error); } } while (true) { OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device); Console.WriteLine("Random.Boolean: {0} \n Random.Int1: {1} \n Random.Int2: {2}", values[0].Value, values[1].Value, values[2].Value); Thread.Sleep(1000); Console.Clear(); } /*int count = server.Groups.Count; * Console.WriteLine(count);*/ } }
public static void AddOrUpdateEventGroup(string opcServerUrl, OpcEventGroup eventGroup) { lock (GetLockObject(opcServerUrl)) { OpcDaServer server = GetServer(opcServerUrl); if (server == null) { return; } if (eventGroup?.Paths == null || eventGroup.Paths.Length == 0) { RemoveEventGroup(opcServerUrl, eventGroup.EventId); return; } // If server isn't connected or there is no ping thread running, then we aren't listening, and can't do anything here: PingThread pingThread; if (!ServerIsConnected(opcServerUrl) || !pingThreads.TryGetValue(opcServerUrl, out pingThread) || !pingThread.IsRunning) { return; } string groupName = "DecisionsGroup_" + eventGroup.EventId; OpcDaGroup group = server.Groups.FirstOrDefault(x => x.Name == groupName); if (group == null) { group = server.AddGroup(groupName); group.IsActive = true; AddItemIdsToGroup(group, eventGroup.Paths); OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device); Callback(opcServerUrl, eventGroup.EventId, ConvertToBaseTagValues(values)); // Send all current values in this group before subscribing to further changes group.ValuesChanged += (object sender, OpcDaItemValuesChangedEventArgs e) => { Callback(opcServerUrl, eventGroup.EventId, ConvertToBaseTagValues(e.Values)); }; } else { string[] addedPaths = eventGroup.Paths.Except(group.Items.Select(x => x.ItemId)).ToArray(); OpcDaItem[] removedItems = group.Items.Where(x => !eventGroup.Paths.Contains(x.ItemId)).ToArray(); AddItemIdsToGroup(group, addedPaths); if (removedItems.Length > 0) { group.RemoveItems(removedItems); // could check return value for errors here } } group.PercentDeadband = eventGroup.Deadband; group.UpdateRate = TimeSpan.FromMilliseconds(eventGroup.UpdateRate > 0 ? eventGroup.UpdateRate : 100); // ValuesChanged won't be triggered if zero } }
//Method writes data to "VAL_CALC" field of Capacity (Density) object and than - to OPC server internal void WriteMultiplyItems(OpcDaGroup dataGroup, object[] values) { OpcDaItem[] items = dataGroup.Items.ToArray(); try { HRESULT[] resultsWrite = dataGroup.Write(items, values); } catch (Exception) { } }
public static List <OpcDaGroup> BuildSubcribtion(OpcDaServer server, OPCAgentConfig cfg) { List <OpcDaGroup> groups = new List <OpcDaGroup>(); try { string objectFilePath = cfg.AssetFolder + "\\objects.txt"; string tagFilePath = cfg.AssetFolder + "\\tags.txt"; string objLine, tagLine; List <String> objs = new List <string>(); System.IO.StreamReader fileObj = new System.IO.StreamReader(objectFilePath); while ((objLine = fileObj.ReadLine()) != null) { objLine = objLine.Trim(); if (!objLine.StartsWith("//")) { objs.Add(objLine); } } fileObj.Close(); List <String> tags = new List <string>(); System.IO.StreamReader fileTag = new System.IO.StreamReader(tagFilePath); while ((tagLine = fileTag.ReadLine()) != null) { tagLine = tagLine.Trim(); if (!tagLine.StartsWith("//")) { tags.Add(tagLine); } } fileTag.Close(); foreach (String obj in objs) { List <string> objtags = new List <string>(); foreach (string tag in tags) { String objTag = String.Concat(obj, ".", tag); objtags.Add(objTag); } OpcDaGroup g = Subscribe(obj, server, objtags.ToArray()); Console.WriteLine("Subscribe for " + obj); } }catch (Exception exc) { Console.WriteLine("Error: " + exc.Message); } return(groups); }
public void AddGroup(OpcDaService server, string groupKey, TreeNode groupNode, int interval, int count) { if (server.Service == null) { return; } foreach (TreeNode tmpNode in groupNode.Nodes) { if (tmpNode.Checked) { string md5Str = groupKey + tmpNode.Text; OpcDaGroup group = null; if (server.OpcDaGroupS.ContainsKey(md5Str) == false) { group = server.Service.AddGroup(md5Str); // maybe cost lot of time server.OpcDaGroupS.Add(md5Str, group); group.IsActive = true; group.UserData = groupNode; List <OpcDaItemDefinition> itemDefList = new List <OpcDaItemDefinition>(); var def = new OpcDaItemDefinition { ItemId = tmpNode.Text, UserData = groupKey, IsActive = true }; itemDefList.Add(def); group.AddItems(itemDefList); GroupEntity groupEntity = new GroupEntity() { Host = server.Host, ProgId = server.ServiceId }; groupCollection.Add(md5Str, groupEntity); group.UpdateRate = TimeSpan.FromMilliseconds(interval); // 1000毫秒触发一次 } else { group = server.OpcDaGroupS[md5Str]; } groupKeys.Add(md5Str); group.ValuesChanged += MonitorValuesChanged; SetGroupFlag(groupKey, count); // LogHelper.Log("GroupFlag " + GetGroupFlag(groupKey).ToString(), (int)LogHelper.Level.INFO); } // GetUnits(group); // LogHelper.Log("aaa: " + GetUnits(group), (int)LogHelper.Level.INFO); } }
public void startReadingGroup(string[] _tagName) { Console.WriteLine("Adicionando {0} itens ao grupo de leitura", _tagName.Length); //remove grupo para uma nova leitura if (readingGroup != null) { try{ this.server.RemoveGroup(readingGroup); } catch (Exception e) { Console.WriteLine(e); } } readingGroup = this.server.AddGroup("readingGroup"); readingGroup.IsActive = true; List <OpcDaItemDefinition> def = new List <OpcDaItemDefinition>(); foreach (string t in _tagName) { Console.WriteLine("Tag ItemID"); Console.WriteLine(t); def.Add(new OpcDaItemDefinition { ItemId = t, IsActive = true }); } //cria array com as definicoes OpcDaItemDefinition[] definitions = def.ToArray(); //readingGroup.Items.RemoveAll(); //readingGroup.RemoveItems(definitions.GetValue()); //remove itens para adicionar eles OpcDaItemResult[] results = readingGroup.AddItems(definitions); // Handle adding results. foreach (OpcDaItemResult result in results) { if (result.Item != null) { Console.WriteLine("Status of item: {0}", result.Item.ItemId); } if (result.Error.Failed) { Console.WriteLine("Error adding items: {0}", result.Error); } else { Console.WriteLine("Success adding items: "); } } }
internal OpcDaItem(OpcDaItemDefinition itemDefinition, OPCITEMRESULT itemResult, OpcDaGroup @group) { Group = @group; ClientHandle = 0; ServerHandle = itemResult.hServer; ItemId = itemDefinition.ItemId; RequestedDataType = itemDefinition.RequestedDataType; CanonicalDataType = TypeConverter.FromVarEnum((VarEnum) itemResult.vtCanonicalDataType); Blob = itemResult.pBlob; AccessPath = itemDefinition.AccessPath; IsActive = itemDefinition.IsActive; AccessRights = (OpcDaAccessRights) itemResult.dwAccessRights; }
public void StartMonitor(string groupKey, List <string> items, string serverID, string host = "127.0.0.1") { JsonArray properties = new JsonArray(); OpcDaService server = GetOpcDaService(host, serverID); if (server == null) { return; } foreach (string item in items) { string md5Str = groupKey + item; if (server.OpcDaGroupS.ContainsKey(md5Str) == false) { OpcDaGroup group = server.Service.AddGroup(md5Str); // maybe cost lot of time group.IsActive = true; server.OpcDaGroupS.Add(md5Str, group); List <OpcDaItemDefinition> itemDefList = new List <OpcDaItemDefinition>(); var def = new OpcDaItemDefinition { ItemId = item, UserData = groupKey, IsActive = true }; itemDefList.Add(def); group.AddItems(itemDefList); groupKeys.Add(md5Str); SetGroupFlag(groupKey, 0); LogHelper.Log("StartMonitoring is groupId " + md5Str + " interval " + "1000 ms", (int)LogHelper.Level.INFO); setItemsCount(groupKey, group); group.UpdateRate = TimeSpan.FromMilliseconds(1000); // 1000毫秒触发一次 group.ValuesChanged += MonitorValuesChanged; if (!groupCollection.ContainsKey(md5Str)) { GroupEntity groupEntity = new GroupEntity() { Host = server.Host, ProgId = server.ServiceId }; groupCollection.Add(md5Str, groupEntity); } LogHelper.Log("groupKeygroupKeygroupKey: " + groupKey); // LogHelper.Log("aaaa: " + GetUnits(group), (int)LogHelper.Level.INFO); } } }
public static OpcInitialData GetInitialData(string opcServerUrl, bool valuesOnly) { lock (GetLockObject(opcServerUrl)) { OpcDaServer server = GetOrCreateServer(opcServerUrl); var browser = new OpcDaBrowserAuto(server); OpcDaGroup group = server.AddGroup("DecisionsDataTypeGroup"); OpcNode[] nodes = GetNodesRecursive(browser, group, null); //now that group has all tags, read all initial values at once: OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device); server.RemoveGroup(group); return(new OpcInitialData { Nodes = valuesOnly ? null : nodes, Values = ConvertToBaseTagValues(values) }); } }
public AsyncRequestManager(OpcDaGroup opcDaGroup) { var opcDataCallback = new OpcDataCallback { CancelComplete = OnCancelComplete, DataChange = OnDataChange, ReadComplete = OnReadComplete, WriteComplete = OnWriteComplete }; _connectionPoint = new ConnectionPoint<IOPCDataCallback>(opcDataCallback); _slots = new Slots<IAsyncRequest>(OpcConfiguration.MaxSimultaneousRequests); _opcDaGroup = opcDaGroup; TryConnect(opcDaGroup.ComObject); }
internal OpcDaItem(OPCITEMATTRIBUTES opcItemDefinition, OpcDaGroup @group) { Group = @group; ClientHandle = opcItemDefinition.hClient; ServerHandle = opcItemDefinition.hServer; ItemId = opcItemDefinition.szItemID; RequestedDataType = TypeConverter.FromVarEnum((VarEnum) opcItemDefinition.vtRequestedDataType); CanonicalDataType = TypeConverter.FromVarEnum((VarEnum) opcItemDefinition.vtCanonicalDataType); AccessPath = opcItemDefinition.szAccessPath; IsActive = opcItemDefinition.bActive; AccessRights = (OpcDaAccessRights) opcItemDefinition.dwAccessRights; if (opcItemDefinition.pBlob != IntPtr.Zero) { Blob = new byte[opcItemDefinition.dwBlobSize]; Marshal.Copy(opcItemDefinition.pBlob, Blob, 0, Blob.Length); } }
public AsyncRequestManager(OpcDaGroup opcDaGroup) { var opcDataCallback = new OpcDataCallback { CancelComplete = OnCancelComplete, DataChange = OnDataChange, ReadComplete = OnReadComplete, WriteComplete = OnWriteComplete }; _connectionPoint = new ConnectionPoint <IOPCDataCallback>(opcDataCallback); _slots = new Slots <IAsyncRequest>(OpcConfiguration.MaxSimultaneousRequests); _opcDaGroup = opcDaGroup; TryConnect(opcDaGroup.ComObject); }
public static void RemoveEventGroup(string opcServerUrl, string eventId) { lock (GetLockObject(opcServerUrl)) { OpcDaServer server = GetServer(opcServerUrl); if (server == null) { return; } string groupName = "DecisionsGroup_" + eventId; OpcDaGroup group = server.Groups.FirstOrDefault(x => x.Name == groupName); if (group != null) { server.RemoveGroup(group); } } }
private static OpcNode[] GetNodesRecursive(OpcDaBrowserAuto browser, OpcDaGroup group, OpcNode parentNode) { OpcDaBrowseElement[] elements = browser.GetElements(parentNode?.FullPath); // fetches from root if null OpcNode[] results = elements.Select(x => new OpcNode { Name = x.Name, FullPath = x.ItemId, ItemId = x.IsItem ? x.ItemId : null }).ToArray(); foreach (OpcNode node in results) { GetNodesRecursive(browser, group, node); } if (parentNode != null) { parentNode.Children = results; if (!string.IsNullOrEmpty(parentNode.ItemId)) // fetch data types for tags { var def = new OpcDaItemDefinition { ItemId = parentNode.ItemId }; OpcDaItemResult[] groupAddResults = group.AddItems(new OpcDaItemDefinition[] { def }); foreach (OpcDaItemResult addResult in groupAddResults) { if (addResult.Error.Failed) { throw new Exception($"Could not fetch type data for {parentNode.ItemId}"); } } OpcDaItem item = group.Items.FirstOrDefault(x => x.ItemId == parentNode.ItemId); if (item != null) { parentNode.TypeName = item.CanonicalDataType.FullName; } } } return(results); }
private static void AddItemIdsToGroup(OpcDaGroup group, string[] paths) { if (paths.Length == 0) { return; } OpcDaItemDefinition[] definitions = paths.Select(x => new OpcDaItemDefinition { ItemId = x, IsActive = true }).ToArray(); OpcDaItemResult[] results = group.AddItems(definitions); foreach (OpcDaItemResult result in results) { if (result.Error.Failed) { ; //todo, error handling? } } }
public void ValueChangedCallBack(OpcDaGroup group, OpcDaItemValue[] values) { JsonObject result = new JsonObject(); result.Add("timestamp", DgiotHelper.Now()); string groupKey = ""; JsonObject properties = new JsonObject(); List <Item> collection = new List <Item>(); values.ToList().ForEach(v => { if (v.Item != null && v.Value != null) { properties.Add(v.Item.ItemId, v.Value); groupKey = v.Item.UserData as string; OpcDa.setItems(groupKey, v.Item.ItemId, properties); } }); int i = OpcDa.getItemsCount(groupKey); if (i <= 0) { properties = OpcDa.getItems(group, groupKey); string topic = "$dg/thing/" + productId + "/" + devAddr + "/properties/report"; int flag1 = OpcDa.GetGroupFlag(groupKey); if (flag1 > 0) { properties.Add("dgiotcollectflag", 0); LogHelper.Log(" topic: " + topic + " payload: " + properties); } else { properties.Add("dgiotcollectflag", 1); } result.Add("properties", properties); MqttClientHelper.Publish(topic, Encoding.UTF8.GetBytes(properties.ToString())); // LogHelper.Log("properties: " + properties.ToString()); } }
public List <Item> ReadItemsValues(string host, string serverID, string groupKey) { OpcDaService server = GetOpcDaService(host, serverID); if (server == null) { return(null); } if (server.OpcDaGroupS.ContainsKey(groupKey) == true) { OpcDaGroup group = server.OpcDaGroupS[groupKey]; OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device); if (values.Length != group.Items.Count) { LogHelper.Log($"values.Length(${values.Length}) != group.Items.Count(${group.Items.Count}) "); return(null); } List <Item> itemValues = new List <Item>(); for (int i = 0; i < values.Length; ++i) { Item it = new Item(); it.ItemId = group.Items[i].ItemId; it.Data = values[i].Value; if (values[i].Value != null) { it.Data = values[i].Value; it.Type = values[i].Value.GetType().ToString(); itemValues.Add(it); } } return(itemValues); } return(null); }
public void writeTag(string _tagName, string _tagValue, bool _sync = false) { // Create a group with items. if (writingGroup == null) { writingGroup = this.server.AddGroup("writingGroup"); } writingGroup.IsActive = true; OpcDaItemDefinition def = new OpcDaItemDefinition { ItemId = _tagName, IsActive = true }; OpcDaItemDefinition[] definitions = { def }; OpcDaItemResult[] results = writingGroup.AddItems(definitions); // Handle adding results. foreach (OpcDaItemResult result in results) { } OpcDaItem[] items = { writingGroup.Items[0] }; object[] values = { _tagValue }; if (_sync) { // Write values to the items synchronously. HRESULT[] hresults = writingGroup.Write(items, values); }/* * else * { * // Write values to the items asynchronously. * HRESULT[] results = await group.WriteAsync(items, values); * }*/ }
public async Task WriteValiesToAnItemOfAnOpcServerAsynchronously() { Uri url = UrlBuilder.Build("Matrikon.OPC.Simulation.1"); using (var server = new OpcDaServer(url)) { // Connect to the server first. server.Connect(); // Create a group with items. OpcDaGroup group = CreateGroupWithItems(server); // Write value to the item. OpcDaItem item = group.Items.FirstOrDefault(i => i.ItemId == "Bucket Brigade.Int4"); OpcDaItem[] items = { item }; object[] values = { 123 }; HRESULT[] results = await group.WriteAsync(items, values); // Handle write result. if (results[0].Failed) { Console.WriteLine("Error writing value"); } // Read and output value. OpcDaItemValue value = group.Read(items, OpcDaDataSource.Device)[0]; Console.WriteLine("ItemId: {0}; Value: {1}; Quality: {2}; Timestamp: {3}", value.Item.ItemId, value.Value, value.Quality, value.Timestamp); // The output should be like the following: // ItemId: Bucket Brigade.Int4; Value: 123; Quality: Good+Good+NotLimited; Timestamp: 04/18/2016 14:04:11 +03:00 value.Value.Should().Be(123); value.Quality.Master.Should().Be(OpcDaQualityMaster.Good); } }
public void read_group(string opcserver, string group_name, List <string> items) { Uri url = UrlBuilder.Build(opcserver); using (var server = new OpcDaServer(url)) { // Connect to the server first. server.Connect(); // Create a group with items. OpcDaGroup group = server.AddGroup(group_name); IList <OpcDaItemDefinition> definitions = new List <OpcDaItemDefinition>(); int i = 0; foreach (string id in items) { LogHelper.Log("id: " + id); var definition = new OpcDaItemDefinition { ItemId = id, IsActive = true }; definitions.Insert(i++, definition); } group.IsActive = true; OpcDaItemResult[] results = group.AddItems(definitions); OpcDaItemValue[] itemValues = group.Read(group.Items, OpcDaDataSource.Device); // Handle adding results. JsonObject data = new JsonObject(); foreach (OpcDaItemValue item in itemValues) { if (item.Item != null && item.Value != null) { data.Add(item.Item.ItemId, item.Value); } } server.Disconnect(); } }
public JsonObject getItems(OpcDaGroup group, string groupKey) { if (itemstotalCollection.ContainsKey(groupKey) == true) { if (itemscountCollection.ContainsKey(groupKey) == true) { itemscountCollection[groupKey] = itemstotalCollection[groupKey]; } else { itemscountCollection.Add(groupKey, itemstotalCollection[groupKey]); } } if (itemsCollection.ContainsKey(groupKey) == false) { return(new JsonObject()); } else { JsonObject json = itemsCollection[groupKey]; itemsCollection[groupKey] = new JsonObject(); return(json); } }
public void StopMonitoringItems(string md5Str) { if (groupCollection.ContainsKey(md5Str)) { LogHelper.Log("StopMonitoringItems: " + md5Str); Thread.Sleep(100); string host = groupCollection[md5Str].Host; string serviceProgId = groupCollection[md5Str].ProgId; OpcDaService server = GetOpcDaService(host, serviceProgId); if (server == null) { LogHelper.Log("StopMonitoringItems is null"); return; } // OpcDaGroup group = server.OpcDaGroupS[groupKey]; OpcDaGroup group = server.OpcDaGroupS[md5Str]; group.ValuesChanged -= MonitorValuesChanged; // server.OpcDaGroupS.Remove(groupKey); // server.Service.RemoveGroup(group); // groupCollection.Remove(groupKey); // groupFlagCollection.Remove(groupKey); } }
public JsonObject GetUnits(OpcDaGroup group) { JsonObject units = new JsonObject(); try { OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device); if (values.Length == group.Items.Count) { for (int i = 0; i < values.Length; ++i) { if (values[i].Value != null) { units.Add(values[i].Item.ItemId, values[i].Value.GetType().ToString()); } } } } catch (Exception) { } return(units); }
//Создание группы для OPC -для одного тега. Нахера??? :) protected virtual void InitSingleItemDataGroup(string groupName, string valueName, out OpcDaGroup dataGroup) { var definition = new OpcDaItemDefinition { ItemId = opcClient.ParentNodeDescriptor + valueName, IsActive = true }; dataGroup = opcClient.OpcServer.AddGroup(groupName); //Группа переменных для чтения (записи) из OPC-сервера dataGroup.IsActive = true; OpcDaItemResult[] results = dataGroup.AddItems(new OpcDaItemDefinition[] { definition }); //Добавление переменных в группу }
//Создание группы для OPC - с формированием списка пеерменных Characteristic (с фильтрацией на неправильные теги. Передается список opBrowseElements) protected virtual void InitDataGroup(string[] itemDescription, string groupName, IEnumerable <OpcDaBrowseElement> opBrowseElements, out OpcDaGroup dataGroup, out OpcDaItemResult[] results, out List <string> listOfValidItems) { List <OpcDaItemDefinition> itemDefinitions = new List <OpcDaItemDefinition>(); if (opBrowseElements != null) { foreach (var item in opBrowseElements) { for (int i = 0; i < itemDescription.Length; i++) { itemDefinitions.Add(new OpcDaItemDefinition { ItemId = opcClient.ParentNodeDescriptor + item.Name + "." + itemDescription[i], IsActive = true }); } } } dataGroup = opcClient.OpcServer.AddGroup(groupName); dataGroup.IsActive = true; results = dataGroup.AddItems(itemDefinitions); opcClient.OpcGroupsCount++; //Создаем список переменных, на основании добавленных в OPC тегов string itemyName; listOfValidItems = new List <string>(); //Формируем список пустых объектов Density foreach (var result in results) { if (result.Error.Succeeded) { itemyName = result.Item.ItemId.Substring(result.Item.ItemId.LastIndexOf('!') + 1); itemyName = itemyName.Substring(0, itemyName.LastIndexOf('.')); if (!listOfValidItems.Any(s => s == itemyName)) { listOfValidItems.Add(itemyName); } } } }
//Создание группы для OPC - без формирования списка пеерменных Characteristic (без фильтрации на несуществующие теги. Передается список Characteristic) protected virtual void InitDataGroup(string[] itemDescription, string groupName, IEnumerable <Characteristic> characteristicList, out OpcDaGroup dataGroup) { List <OpcDaItemDefinition> itemDefinitions = new List <OpcDaItemDefinition>(); foreach (var item in characteristicList) { for (int i = 0; i < itemDescription.Length; i++) { itemDefinitions.Add(new OpcDaItemDefinition { ItemId = opcClient.ParentNodeDescriptor + item.TagName + "." + itemDescription[i], IsActive = true }); } } dataGroup = opcClient.OpcServer.AddGroup(groupName); dataGroup.IsActive = true; OpcDaItemResult[] results = dataGroup.AddItems(itemDefinitions); opcClient.OpcGroupsCount++; }
/// <summary> /// Initializes a new instance of the <see cref="OpcDaServerGroupsChangedEventArgs"/> class. /// </summary> /// <param name="added">The added groups.</param> /// <param name="removed">The removed groups.</param> public OpcDaServerGroupsChangedEventArgs(OpcDaGroup added, OpcDaGroup removed) { Added = added; Removed = removed; }