/// <summary> /// Changes the requested data type for one or more items in a group. /// </summary> /// <param name="items">The group items.</param> /// <param name="requestedTypes">Array of new Requested Datatypes to be stored.</param> /// <returns> /// Array of HRESULTs. Indicates which items were successfully affected. /// </returns> /// <exception cref="System.ArgumentException">Wrong size of requested types array.;requestedTypes</exception> public HRESULT[] SetDataTypes(IList <OpcDaItem> items, IList <Type> requestedTypes) { CheckItems(items); if (items.Count != requestedTypes.Count) { throw new ArgumentException("Wrong size of requested types array.", "requestedTypes"); } int[] serverHandles = ArrayHelpers.GetServerHandles(items); IList <VarEnum> requestedDatatypes = requestedTypes.Select(TypeConverter.ToVarEnum).ToArray(); HRESULT[] ppErrors = As <OpcItemMgt>().SetDatatypes(serverHandles, requestedDatatypes); var changedItems = new List <OpcDaItem>(items.Count); for (int index = 0; index < items.Count; index++) { if (ppErrors[index].Succeeded) { OpcDaItem item = items[index]; item.RequestedDataType = requestedTypes[index]; changedItems.Add(item); } } OnItemsChanged(new OpcDaItemsChangedEventArgs(null, null, changedItems.ToArray())); return(ppErrors); }
public Task <HRESULT[]> Start(IList <OpcDaItem> items, ICollection <object> values, CancellationToken token) { try { var serverHandles = ArrayHelpers.GetServerHandles(items); HRESULT[] ppErrors; int cancelId = _asyncIO2.Write(serverHandles, values.ToArray(), TransactionId, out ppErrors); if (ppErrors.All(e => e.Failed)) // if all errors no callback will take place { _requestManager.CompleteRequest(TransactionId); _tcs.SetResult(ppErrors); } else { CancellationId = cancelId; RequestHelpers.SetCancellationHandler(token, Cancel); } return(Task); } catch (Exception ex) { _requestManager.CompleteRequest(TransactionId); _tcs.SetException(ex); return(Task); } }
/// <summary> /// Writes values to one or more items in a group. /// </summary> /// <param name="items">The group items.</param> /// <param name="values">The list of values to be written to the items.</param> /// <returns> /// Array of HRESULTs indicating the success of the individual item Writes. /// </returns> public HRESULT[] Write(IList <OpcDaItem> items, object[] values) { CheckItems(items); CheckSupported(OpcDaGroupFeatures.Write); int[] serverHandles = ArrayHelpers.GetServerHandles(items); return(As <OpcSyncIO>().Write(serverHandles, values)); }
public Task <OpcDaItemValue[]> Start(IList <OpcDaItem> items, IList <TimeSpan> maxAge, CancellationToken token) { try { var serverHandles = ArrayHelpers.GetServerHandles(items); HRESULT[] ppErrors; int cancelId = _asyncIO3.ReadMaxAge(serverHandles, maxAge, TransactionId, out ppErrors); if (ppErrors.All(e => e.Failed)) // if all errors no callback will take place { _requestManager.CompleteRequest(TransactionId); var result = new OpcDaItemValue[ppErrors.Length]; for (var i = 0; i < result.Length; i++) { result[i] = new OpcDaItemValue { Error = ppErrors[i], Item = items[i] }; } _tcs.SetResult(result); } else { CancellationId = cancelId; RequestHelpers.SetCancellationHandler(token, Cancel); } return(Task); } catch (Exception ex) { _requestManager.CompleteRequest(TransactionId); _tcs.SetException(ex); return(Task); } }
/// <summary> /// Reads the specified group items. /// </summary> /// <param name="items">The group items.</param> /// <param name="dataSource">The data source.</param> /// <returns> /// The values of the group items. /// </returns> public OpcDaItemValue[] Read(IList <OpcDaItem> items, OpcDaDataSource dataSource = OpcDaDataSource.Cache) { CheckItems(items); CheckSupported(OpcDaGroupFeatures.Read); int[] serverHandles = ArrayHelpers.GetServerHandles(items); HRESULT[] ppErrors; OPCITEMSTATE[] ppItemValues = As <OpcSyncIO>().Read((OPCDATASOURCE)dataSource, serverHandles, out ppErrors); OpcDaItemValue[] result = OpcDaItemValue.Create(this, ppItemValues, ppErrors); OnValuesChanged(new OpcDaItemValuesChangedEventArgs(result)); return(result); }
/// <summary> /// Removes (deletes) items from the group. /// </summary> /// <param name="items">The group items.</param> /// <returns> /// Array of HRESULTs. Indicates which items were successfully removed. /// </returns> public HRESULT[] RemoveItems(IList <OpcDaItem> items) { CheckItems(items); int[] serverHandles = ArrayHelpers.GetServerHandles(items); HRESULT[] ppErrors = As <OpcItemMgt>().RemoveItems(serverHandles); foreach (int serverHandle in serverHandles) { _items.RemoveAll(i => i.ServerHandle == serverHandle); } // Set client handles to index of items UpdateClientHandles(); OnItemsChanged(new OpcDaItemsChangedEventArgs(null, items.ToArray(), null)); return(ppErrors); }
/// <summary> /// Writes one or more values, qualities and timestamps for the items specified. If a client attempts to write VQ, VT, /// or VQT it should expect that the server will write them all or none at all. /// </summary> /// <param name="items">The group items.</param> /// <param name="values">The list of values, qualities and timestamps.</param> /// <returns> /// Array of HRESULTs indicating the success of the individual item Writes. /// </returns> /// <exception cref="System.ArgumentException">Invalid size of values;values</exception> public HRESULT[] WriteVQT(IList <OpcDaItem> items, IList <OpcDaVQT> values) { CheckSupported(OpcDaGroupFeatures.WriteVQT); CheckItems(items); int[] serverHandles = ArrayHelpers.GetServerHandles(items); if (serverHandles.Length != values.Count) { throw new ArgumentException("Invalid size of values", "values"); } OPCITEMVQT[] vqts = ArrayHelpers.CreateOpcItemVQT(values); return(As <OpcSyncIO2>().WriteVQT(serverHandles, vqts)); }
/// <summary> /// Sets one or more items in a group to active or inactive. This controls whether or not valid data can be obtained /// from Read CACHE for those items and whether or not they are included in the OnDataChange subscription to the group. /// </summary> /// <param name="items">The group items.</param> /// <param name="isActive">If set to <c>true</c> items are to be activated, otherwise items are to be deactivated.</param> /// <returns> /// Array of HRESULTs. Indicates which items were successfully affected. /// </returns> public HRESULT[] SetActiveItems(IList <OpcDaItem> items, bool isActive = true) { CheckItems(items); int[] serverHandles = ArrayHelpers.GetServerHandles(items); HRESULT[] ppErrors = As <OpcItemMgt>().SetActiveState(serverHandles, isActive); var changedItems = new List <OpcDaItem>(items.Count); for (int index = 0; index < items.Count; index++) { if (ppErrors[index].Succeeded) { OpcDaItem item = items[index]; item.IsActive = isActive; changedItems.Add(item); } } OnItemsChanged(new OpcDaItemsChangedEventArgs(null, null, changedItems.ToArray())); return(ppErrors); }
/// <summary> /// Reads the specified group items using MaxAge. If the information in the cache is within the MaxAge, then the data /// will be obtained from the cache, otherwise the server must access the device for the requested information. /// </summary> /// <param name="items">The group items.</param> /// <param name="maxAge">The list of MaxAges for the group items.</param> /// <returns> /// The values of the group items. /// </returns> /// <exception cref="System.ArgumentException">Invalid size of maxAge;maxAge</exception> public OpcDaItemValue[] ReadMaxAge(IList <OpcDaItem> items, IList <TimeSpan> maxAge) { CheckSupported(OpcDaGroupFeatures.ReadMaxAge); CheckItems(items); int[] serverHandles = ArrayHelpers.GetServerHandles(items); if (serverHandles.Length != maxAge.Count) { throw new ArgumentException("Invalid size of maxAge", "maxAge"); } // int[] intMaxAge = ArrayHelpers.CreateMaxAgeArray(maxAge, items.Count); DateTimeOffset[] timestamps; HRESULT[] errors; OpcDaQuality[] qualities; object[] ppvValues = As <OpcSyncIO2>() .ReadMaxAge(serverHandles, maxAge, out qualities, out timestamps, out errors); OpcDaItemValue[] result = OpcDaItemValue.Create(items, ppvValues, qualities, timestamps, errors); OnValuesChanged(new OpcDaItemValuesChangedEventArgs(result)); return(result); }