/// <summary> /// 创建父级目录(请确保对应的根目录已创建) /// </summary> /// <param name="nodes"></param> /// <param name="currentNode"></param> /// <returns></returns> public FolderState GetParentFolderState(IEnumerable <OpcuaNode> nodes, OpcuaNode currentNode) { FolderState folder = null; if (!_folderDic.TryGetValue(currentNode.ParentPath, out folder)) { var parent = nodes.Where(d => d.NodePath == currentNode.ParentPath).FirstOrDefault(); if (!string.IsNullOrEmpty(parent.ParentPath)) { var pFol = GetParentFolderState(nodes, parent); folder = CreateFolder(pFol, parent.NodePath, parent.NodeName); pFol.ClearChangeMasks(SystemContext, false); AddPredefinedNode(SystemContext, folder); _folderDic.Add(currentNode.ParentPath, folder); } } return(folder); }
public AlarmConditionTypeHolder( AlarmNodeManager alarmNodeManager, FolderState parent, SourceController trigger, string name, SupportedAlarmConditionType alarmConditionType, Type controllerType, int interval, bool optional = true, double maxShelveTime = AlarmDefines.NORMAL_MAX_TIME_SHELVED, bool create = true) : base(alarmNodeManager, parent, trigger, name, alarmConditionType, controllerType, interval, optional, false) { if (create) { Initialize(Opc.Ua.ObjectTypes.AlarmConditionType, name, maxShelveTime); } }
/// <summary> /// Creates OPC server child nodes. /// </summary> private void CreateChildNodes(FolderState rootFolder) { foreach (ILineContext lineContext in commContext.GetCommLines()) { List <DeviceLogic> devices = new List <DeviceLogic>(); devices.AddRange(deviceFilter == null ? lineContext.SelectDevices() : lineContext.SelectDevices(d => deviceFilter.Contains(d.DeviceNum))); if (devices.Count > 0) { FolderState lineFolder = CreateFolder(rootFolder, CommUtils.GetLineLogFileName(lineContext.CommLineNum, ""), lineContext.Title); foreach (DeviceLogic deviceLogic in devices) { FolderState deviceFolder = CreateFolder(lineFolder, CommUtils.GetDeviceLogFileName(deviceLogic.DeviceNum, ""), deviceLogic.Title); DeviceVars deviceVars = new DeviceVars(); varByDevice[deviceLogic.DeviceNum] = deviceVars; if (deviceLogic.DeviceTags.FlattenGroups) { foreach (TagGroup tagGroup in deviceLogic.DeviceTags.TagGroups) { CreateDeviceTagNodes(deviceFolder, deviceLogic, tagGroup, deviceVars); } } else { int groupNum = 1; foreach (TagGroup tagGroup in deviceLogic.DeviceTags.TagGroups) { FolderState groupFolder = CreateFolder(deviceFolder, "group" + groupNum.ToString("D3"), tagGroup.Name); CreateDeviceTagNodes(groupFolder, deviceLogic, tagGroup, deviceVars); groupNum++; } } } } } }
//// Folders // public FolderState CreateAddFolder(AasUaBaseEntity.CreateMode mode, NodeState parent, string browseDisplayName, NodeId extraParentNodeId = null, bool doNotAddToParent = false) { var x = new FolderState(parent); x.BrowseName = browseDisplayName; x.DisplayName = browseDisplayName; x.NodeId = nodeMgr.New(nodeMgr.SystemContext, mode, x); x.TypeDefinitionId = ObjectTypeIds.FolderType; nodeMgr.AddPredefinedNode(nodeMgr.SystemContext, x); if (parent != null && !doNotAddToParent) { parent.AddChild(x); } return(x); }
public DiscreteHolder( AlarmNodeManager alarmNodeManager, FolderState parent, SourceController trigger, string name, SupportedAlarmConditionType alarmConditionType, Type controllerType, int interval, bool optional = true, double maxShelveTime = AlarmDefines.NORMAL_MAX_TIME_SHELVED, bool create = true) : base(alarmNodeManager, parent, trigger, name, alarmConditionType, controllerType, interval, optional, maxShelveTime, false) { Utils.LogTrace("{0} Discrete Constructor Optional = {1}", name, optional); if (create) { Initialize(ObjectTypes.DiscreteAlarmType, name, maxShelveTime); } }
private IEnumerator MoveFolder(bool isUp) { if (!isUp) { transform.LeanMove(_basePosition, .2f); currentState = FolderState.MovingDown; yield return(new WaitForSeconds(.2f)); currentState = FolderState.Down; } else { transform.LeanMove(_basePosition + new Vector3(0, .04f, 0), .2f); currentState = FolderState.MovingUp; yield return(new WaitForSeconds(.2f)); currentState = FolderState.Up; } }
/// <summary> /// Creates a new folder. /// </summary> private FolderState CreateFolder(NodeState parent, string path, string name) { FolderState folder = new FolderState(parent) { SymbolicName = name, ReferenceTypeId = ReferenceTypes.Organizes, TypeDefinitionId = ObjectTypeIds.FolderType, NodeId = new NodeId(path, NamespaceIndex), BrowseName = new QualifiedName(path, NamespaceIndex), DisplayName = new LocalizedText("en", name), WriteMask = AttributeWriteMask.None, UserWriteMask = AttributeWriteMask.None, EventNotifier = EventNotifiers.None }; parent?.AddChild(folder); return(folder); }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out IList <IReference> references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } FolderState root = CreateFolder(null, ProgramName, ProgramName, NamespaceType.OpcPlcApplications); root.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, root.NodeId)); root.EventNotifier = EventNotifiers.SubscribeToEvents; AddRootNotifier(root); var variables = new List <BaseDataVariableState>(); try { FolderState dataFolder = CreateFolder(root, "Telemetry", "Telemetry", NamespaceType.OpcPlcApplications); AddChangingNodes(dataFolder); AddSlowAndFastNodes(dataFolder); FolderState methodsFolder = CreateFolder(root, "Methods", "Methods", NamespaceType.OpcPlcApplications); AddMethods(methodsFolder); AddUserConfigurableNodes(root); AddComplexTypeBoiler(methodsFolder, externalReferences); AddSpecialNodes(dataFolder); } catch (Exception e) { Logger.Error(e, "Error creating the address space."); } AddPredefinedNode(SystemContext, root); } }
public HuiBoRobot(NodeState parent, string name, ushort NamespaceIndex, ServerSystemContext systemContext) { SystemContext = systemContext; FolderState myFolder = CreateFolder(parent, name, NamespaceIndex); RobotMode = CreateVariable(myFolder, "RobotMode", DataTypeIds.Int32, ValueRanks.Scalar, 1, NamespaceIndex); RobotMode.Description = "机器人的数据模式,1:关节 2:基座标 3:工具坐标"; RobotLocation = CreateVariable(myFolder, "RobotLocation", DataTypeIds.Double, ValueRanks.OneDimension, new double[6], NamespaceIndex); RobotLocation.Description = "机器人的位置信息,该数据将根据模式不同而不一致"; UserArrayBool = CreateVariable(myFolder, "UserBool", DataTypeIds.Boolean, ValueRanks.OneDimension, new bool[16], NamespaceIndex); UserArrayBool.Description = "备用的bool数据"; UserArrayFloat = CreateVariable(myFolder, "UserFloat", DataTypeIds.Float, ValueRanks.OneDimension, new float[16], NamespaceIndex); UserArrayFloat.Description = "备用的float数据"; UserArrayInt = CreateVariable(myFolder, "UserInt", DataTypeIds.Int32, ValueRanks.OneDimension, new int[16], NamespaceIndex); UserArrayInt.Description = "备用的int数据"; }
/// <summary> /// Creates a new area. /// </summary> private BaseObjectState CreateArea(SystemContext context, BaseObjectState platforms, string areaName) { System.Diagnostics.Contracts.Contract.Assume(context != null); var area = new FolderState(null) { NodeId = new NodeId(areaName, NamespaceIndex), BrowseName = new QualifiedName(areaName, NamespaceIndex) }; area.DisplayName = area.BrowseName.Name; area.EventNotifier = EventNotifiers.SubscribeToEvents | EventNotifiers.HistoryRead | EventNotifiers.HistoryWrite; area.TypeDefinitionId = Opc.Ua.ObjectTypeIds.FolderType; platforms.AddNotifier(SystemContext, ReferenceTypeIds.HasNotifier, false, area); area.AddNotifier(SystemContext, ReferenceTypeIds.HasNotifier, true, platforms); AddPredefinedNode(SystemContext, area); return(area); }
private FolderState AddMethods(FolderState methodsFolder) { if (PlcSimulation.GeneratePosTrend || PlcSimulation.GenerateNegTrend) { MethodState resetTrendMethod = CreateMethod(methodsFolder, "ResetTrend", "ResetTrend", "Reset the trend values to their baseline value", NamespaceType.OpcPlcApplications); SetResetTrendMethodProperties(ref resetTrendMethod); } if (PlcSimulation.GenerateData) { MethodState resetStepUpMethod = CreateMethod(methodsFolder, "ResetStepUp", "ResetStepUp", "Resets the StepUp counter to 0", NamespaceType.OpcPlcApplications); SetResetStepUpMethodProperties(ref resetStepUpMethod); MethodState startStepUpMethod = CreateMethod(methodsFolder, "StartStepUp", "StartStepUp", "Starts the StepUp counter", NamespaceType.OpcPlcApplications); SetStartStepUpMethodProperties(ref startStepUpMethod); MethodState stopStepUpMethod = CreateMethod(methodsFolder, "StopStepUp", "StopStepUp", "Stops the StepUp counter", NamespaceType.OpcPlcApplications); SetStopStepUpMethodProperties(ref stopStepUpMethod); } return(methodsFolder); }
private BaseDataVariableState[] CreateBaseLoadNodes(FolderState dataFolder, string name, uint count, NodeType type) { var nodes = new BaseDataVariableState[count]; if (count > 0) { Logger.Information($"Creating {count} {name} nodes of type: {type}"); Logger.Information("Node values will change every " + (name.Contains("Fast") ? PlcSimulation.FastNodeRate : PlcSimulation.SlowNodeRate) + " s"); Logger.Information("Node values sampling rate is " + (name.Contains("Fast") ? PlcSimulation.FastNodeSamplingInterval : PlcSimulation.SlowNodeSamplingInterval) + " ms"); } for (int i = 0; i < count; i++) { var(dataType, valueRank, defaultValue) = GetNodeType(type); string id = (i + 1).ToString(); nodes[i] = CreateBaseVariable(dataFolder, $"{name}{type}{id}", $"{name}{type}{id}", dataType, valueRank, AccessLevels.CurrentReadOrWrite, "Constantly increasing value(s)", NamespaceType.OpcPlcApplications, defaultValue); } return(nodes); }
/// <summary> /// Create a mechanism to create a folder /// </summary> public static FolderState CreateFolder(NodeState parent, ushort nameSpaceIndex, string path, string name) { FolderState folder = new FolderState(parent); folder.SymbolicName = name; folder.ReferenceTypeId = ReferenceTypes.Organizes; folder.TypeDefinitionId = ObjectTypeIds.FolderType; folder.NodeId = new NodeId(path, nameSpaceIndex); folder.BrowseName = new QualifiedName(path, nameSpaceIndex); folder.DisplayName = new LocalizedText("en", name); folder.WriteMask = AttributeWriteMask.None; folder.UserWriteMask = AttributeWriteMask.None; folder.EventNotifier = EventNotifiers.None; if (parent != null) { parent.AddChild(folder); } return(folder); }
/// <summary> /// Creates node for Signal associated to Component in Visual Components. /// </summary> private BaseDataVariableState CreateVariableNode(FolderState parentFolder, string nodeName, NodeId nodeDataType) { string namespaceUri = Namespaces.vc2opcua; string nodeNameParent = String.Format("{0}-{1}", nodeName, parentFolder.Parent.DisplayName); BaseDataVariableState variableNode = new BaseDataVariableState(parentFolder); NodeId nodeId = NodeId.Create(nodeNameParent, namespaceUri, uaServer.NamespaceUris); variableNode.Create( nodeManager.context, nodeId, new QualifiedName(nodeNameParent, (ushort)uaServer.NamespaceUris.GetIndex(namespaceUri)), new LocalizedText(nodeName), true); variableNode.DataType = nodeDataType; parentFolder.AddReference(ReferenceTypeIds.Organizes, false, variableNode.NodeId); variableNode.AddReference(ReferenceTypeIds.Organizes, true, parentFolder.NodeId); return(variableNode); }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { try { Monitor.Enter(dataLock); // create the root folder if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out IList <IReference> references)) { references = new List <IReference>(); externalReferences[ObjectIds.ObjectsFolder] = references; } FolderState rootFolder = CreateFolder(null, RootFolderName, RootFolderName); rootFolder.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, rootFolder.NodeId)); rootFolder.EventNotifier = EventNotifiers.SubscribeToEvents; AddRootNotifier(rootFolder); // create child nodes varByDevice = new Dictionary <int, DeviceVars>(); varByPath = new Dictionary <string, VarItem>(); CreateChildNodes(rootFolder); // recursively index the node AddPredefinedNode(SystemContext, rootFolder); } catch (Exception ex) { log.WriteException(ex, Locale.IsRussian ? "Ошибка при создании адресного пространства" : "Error creating address space"); throw; } finally { Monitor.Exit(dataLock); } }
/// <summary> /// Gets the item configuration node. /// </summary> /// <param name="itemId">The item id.</param> /// <param name="namespaceIndex">Index of the namespace.</param> /// <returns></returns> public static BaseInstanceState GetItemConfigurationNode(string itemId, ushort namespaceIndex) { if (itemId == null) { return(null); } FolderState component = new FolderState(null); component.NodeId = HdaParsedNodeId.Construct(HdaModelUtils.HdaItemConfiguration, itemId, null, namespaceIndex); component.SymbolicName = Opc.Ua.BrowseNames.HAConfiguration; component.BrowseName = new QualifiedName(component.SymbolicName); component.DisplayName = component.BrowseName.Name; component.ReferenceTypeId = Opc.Ua.ReferenceTypeIds.HasComponent; component.TypeDefinitionId = Opc.Ua.ObjectTypeIds.HistoricalDataConfigurationType; component.EventNotifier = EventNotifiers.None; component.AddReference(ReferenceTypeIds.HasHistoricalConfiguration, true, HdaModelUtils.ConstructIdForHdaItem(itemId, namespaceIndex)); component.AddReference(ReferenceTypeIds.HasComponent, false, HdaModelUtils.ConstructIdForInternalNode(Opc.Ua.BrowseNames.AggregateConfiguration, namespaceIndex)); return(component); }
private void AddUserConfigurableNodes(FolderState root) { if (!string.IsNullOrEmpty(_nodeFileName)) { string json = File.ReadAllText(_nodeFileName); var cfgFolder = JsonConvert.DeserializeObject <ConfigFolder>(json, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.All }); Logger.Information($"Processing node information configured in {_nodeFileName}"); Logger.Debug($"Create folder {cfgFolder.Folder}"); FolderState userNodesFolder = CreateFolder(root, cfgFolder.Folder, cfgFolder.Folder, NamespaceType.OpcPlcApplications); foreach (var node in cfgFolder.NodeList) { if (node.NodeId.GetType() != Type.GetType("System.Int64") && node.NodeId.GetType() != Type.GetType("System.String")) { Logger.Error($"The type of the node configuration for node with name {node.Name} ({node.NodeId.GetType()}) is not supported. Only decimal and string are supported. Default to string."); node.NodeId = node.NodeId.ToString(); } string typedNodeId = $"{(node.NodeId.GetType() == Type.GetType("System.Int64") ? "i=" : "s=")}{node.NodeId.ToString()}"; if (string.IsNullOrEmpty(node.Name)) { node.Name = typedNodeId; } if (string.IsNullOrEmpty(node.Description)) { node.Description = node.Name; } Logger.Debug($"Create node with Id '{typedNodeId}' and BrowseName '{node.Name}' in namespace with index '{NamespaceIndexes[(int)NamespaceType.OpcPlcApplications]}'"); CreateBaseVariable(userNodesFolder, node); } Logger.Information("Processing node information completed."); } }
private void AddComplexTypeBoiler(FolderState methodsFolder, IDictionary <NodeId, IList <IReference> > externalReferences) { if (PlcSimulation.AddComplexTypeBoiler) { // Load complex types from binary uanodes file. base.LoadPredefinedNodes(SystemContext, externalReferences); // Find the Boiler1 node that was created when the model was loaded. var passiveNode = (BaseObjectState)FindPredefinedNode(new NodeId(BoilerModel.Objects.Boiler1, NamespaceIndexes[(int)NamespaceType.Boiler]), typeof(BaseObjectState)); // Convert to node that can be manipulated within the server. _boiler1 = new BoilerModel.BoilerState(null); _boiler1.Create(SystemContext, passiveNode); base.AddPredefinedNode(SystemContext, _boiler1); // Create heater on/off methods. MethodState heaterOnMethod = CreateMethod(methodsFolder, "HeaterOn", "HeaterOn", "Turn the heater on", NamespaceType.Boiler); SetHeaterOnMethodProperties(ref heaterOnMethod); MethodState heaterOffMethod = CreateMethod(methodsFolder, "HeaterOff", "HeaterOff", "Turn the heater off", NamespaceType.Boiler); SetHeaterOffMethodProperties(ref heaterOffMethod); } }
public BaseObjectState addChildRootNode(string name, BaseObjectState parentNode = null) { if (parentNode == null) { parentNode = machines; } /*BaseObjectState objRoot = new BaseObjectState(parentNode); * objRoot.DisplayName = name; * objRoot.BrowseName = new QualifiedName(name, 3); * //objRoot.NodeId = getFreeNodeId(3,2000,1000); * objRoot.NodeId = new NodeId(name, 3); * objRoot.SymbolicName = name; * objRoot.ReferenceTypeId = ReferenceTypes.Organizes; * objRoot.TypeDefinitionId = ObjectTypeIds.BaseObjectType; * objRoot.WriteMask = AttributeWriteMask.None; * objRoot.UserWriteMask = AttributeWriteMask.None; * objRoot.EventNotifier = EventNotifiers.None;*/ FolderState objfolder = new FolderState(parentNode); objfolder.SymbolicName = name; objfolder.ReferenceTypeId = ReferenceTypes.Organizes; objfolder.TypeDefinitionId = ObjectTypeIds.FolderType; objfolder.NodeId = new NodeId(2003, NamespaceIndex); objfolder.BrowseName = new QualifiedName(name, NamespaceIndex); objfolder.DisplayName = new LocalizedText(name); objfolder.WriteMask = AttributeWriteMask.None; objfolder.UserWriteMask = AttributeWriteMask.None; objfolder.EventNotifier = EventNotifiers.None; if (parentNode != null) { parentNode.AddChild(objfolder); } AddPredefinedNode(SystemContext, machines); return(objfolder); }
private void AddDeviceCore(NodeState parent, XElement device) { if (device.Name == "DeviceNode") { // 提取名称和描述信息 string name = device.Attribute("Name").Value; string description = device.Attribute("Description").Value; // 创建OPC节点 FolderState deviceFolder = CreateFolder(parent, device.Attribute("Name").Value, device.Attribute("Description").Value); // 添加Request foreach (var requestXml in device.Elements("DeviceRequest")) { DeviceRequest deviceRequest = new DeviceRequest( ); deviceRequest.LoadByXmlElement(requestXml); AddDeviceRequest(deviceFolder, deviceRequest); } IDeviceCore deviceReal = CreateNewByXml(device); if (deviceReal != null) { deviceReal.OpcUaNode = deviceFolder.NodeId.ToString( ); AddDeviceCore(deviceReal); deviceReal.WriteDeviceData = WriteDeviceData; deviceReal.Name = name; deviceReal.StartRead( ); // 显示系统所有的设备数量 Interlocked.Increment(ref deviceCount); this.logNet?.WriteInfo($"已发现 {deviceCount} 台设备,类型为{deviceReal.TypeName}"); } } }
/// <summary> /// Creates OPC server nodes that correspond to device tags. /// </summary> private void CreateDeviceTagNodes(FolderState folder, DeviceLogic deviceLogic, TagGroup tagGroup, DeviceVars deviceVars) { string pathPrefix = CommUtils.GetDeviceLogFileName(deviceLogic.DeviceNum, "."); foreach (DeviceTag deviceTag in tagGroup.DeviceTags) { if (!string.IsNullOrEmpty(deviceTag.Code)) { BaseDataVariableState variable = CreateVariable(folder, pathPrefix, deviceTag); variable.OnSimpleWriteValue = OnSimpleWriteValue; VarItem varItem = new VarItem { Variable = variable, DeviceTag = deviceTag, DeviceNum = deviceLogic.DeviceNum }; deviceVars[deviceTag.Code] = varItem; varByPath[variable.NodeId.ToString()] = varItem; } } }
// any initialization required before the address space can be used. public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out IList <IReference> references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } FolderState root = CreateFolder(null, "CTT", "Test2"); root.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, root.NodeId)); root.EventNotifier = EventNotifiers.SubscribeToEvents; List <BaseDataVariableState> variables = new List <BaseDataVariableState>(); try { #region Scalar FolderState scalarFolder = CreateFolder(root, "Scalar", "Scalar"); BaseDataVariableState scalarInstructions = CreateVariable(scalarFolder, "Scalar_Instructions", "Scalar_Instructions", DataTypeIds.String, ValueRanks.Scalar); scalarInstructions.Value = "A library of Read/Write Variables of all supported data-types."; variables.Add(scalarInstructions); #endregion #region Scalar_Static FolderState staticFolder = CreateFolder(root, "Scalar_Static", "Scalar_Static"); const string scalarStatic = "Scalar_Static_"; variables.Add(CreateVariable(staticFolder, scalarStatic + "Boolean", "Boolean", DataTypeIds.Boolean, ValueRanks.Scalar)); variables.Add(CreateVariable(staticFolder, scalarStatic + "Byte", "Byte", DataTypeIds.Byte, ValueRanks.Scalar)); variables.Add(CreateVariable(staticFolder, scalarStatic + "ByteString", "ByteString", DataTypeIds.ByteString, ValueRanks.Scalar)); variables.Add(CreateVariable(staticFolder, scalarStatic + "DateTime", "DateTime", DataTypeIds.DateTime, ValueRanks.Scalar)); variables.Add(CreateVariable(staticFolder, scalarStatic + "Double", "Double", DataTypeIds.Double, ValueRanks.Scalar)); BaseDataVariableState decimalVariable = CreateVariable(staticFolder, scalarStatic + "Decimal", "Decimal", DataTypeIds.DecimalDataType, ValueRanks.Scalar); // Set an arbitrary precision decimal value. BigInteger largeInteger = BigInteger.Parse("1234567890123546789012345678901234567890123456789012345"); DecimalDataType decimalValue = new DecimalDataType { Scale = 100, Value = largeInteger.ToByteArray() }; decimalVariable.Value = decimalValue; variables.Add(decimalVariable); #endregion #region Scalar_Simulation FolderState simulationFolder = CreateFolder(root, "Scalar_Smulation", "Simulation"); const string scalarSimulation = "Scalar_Simulation_"; CreateDynamicVariable(simulationFolder, scalarSimulation + "Boolean", "Boolean", DataTypeIds.Boolean, ValueRanks.Scalar); CreateDynamicVariable(simulationFolder, scalarSimulation + "Byte", "Byte", DataTypeIds.Byte, ValueRanks.Scalar); CreateDynamicVariable(simulationFolder, scalarSimulation + "ByteString", "ByteString", DataTypeIds.ByteString, ValueRanks.Scalar); CreateDynamicVariable(simulationFolder, scalarSimulation + "DateTime", "DateTime", DataTypeIds.DateTime, ValueRanks.Scalar); CreateDynamicVariable(simulationFolder, scalarSimulation + "Double", "Double", DataTypeIds.Double, ValueRanks.Scalar); CreateDynamicVariable(simulationFolder, scalarSimulation + "Duration", "Duration", DataTypeIds.Duration, ValueRanks.Scalar); BaseDataVariableState intervalVariable = CreateVariable(simulationFolder, scalarSimulation + "Interval", "Interval", DataTypeIds.UInt16, ValueRanks.Scalar); intervalVariable.Value = m_simulationInterval; intervalVariable.OnSimpleWriteValue = OnWriteInterval; BaseDataVariableState enabledVariable = CreateVariable(simulationFolder, scalarSimulation + "Enabled", "Enabled", DataTypeIds.Boolean, ValueRanks.Scalar); enabledVariable.Value = m_simulationEnabled; enabledVariable.OnSimpleWriteValue = OnWriteEnabled; #endregion } catch (Exception e) { Utils.Trace(e, "Error creating the address space."); } AddPredefinedNode(SystemContext, root); m_simulationTimer = new Timer(DoSimulation, null, 3000, 1000); } }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { //Load DI nodeset LoadPredefinedNodes(SystemContext, externalReferences); //Add my variables to Address Space, under the DeviceSet object ----------------------- //------------------------------------------------------------------------------------- //get the DeviceSet object of the Address Space NodeState DeviceSetobj = (NodeState)FindPredefinedNode( ExpandedNodeId.ToNodeId(ObjectIds.DeviceSet, Server.NamespaceUris), typeof(NodeState)); //------------------------------------------------------------------------------------- //create myDevice1 as a simple folder with a variable FolderState mydev1 = CreateFolder(DeviceSetobj, "myDevice1", "myDevice1"); //create myDevice1/myVar1 BaseDataVariableState myvar1 = CreateVariable(mydev1, "myVar1", "myVar1", Opc.Ua.DataTypeIds.Double, ValueRanks.Scalar); //create myDevice1/Actual_State BaseDataVariableState Actual_State = CreateVariable(mydev1, "Actual_State", "Actual_State", Opc.Ua.DataTypeIds.Double, ValueRanks.Scalar); //create myDevice1/Sensors_Data Sensors_Data = CreateVariable(mydev1, "Sensors_Data", "Sensors_Data", Opc.Ua.DataTypeIds.Double, ValueRanks.OneDimension); //create myDevice1/myVar2 myvar2 = CreateVariable(mydev1, "myVar2", "myVar2", Opc.Ua.DataTypeIds.Int16, ValueRanks.Scalar); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Poject //create myDevice1/Start_Piece Start_Piece = CreateVariable(mydev1, "Start_Piece", "Start_Piece", Opc.Ua.DataTypeIds.Boolean, ValueRanks.Scalar); // create myDevice1/Mould_1 Mould_1 = CreateVariable(mydev1, "Mould_1", "Mould_1", Opc.Ua.DataTypeIds.String, ValueRanks.Scalar); // create myDevice1/Mould_1_SN Mould_1_SN = CreateVariable(mydev1, "Mould_1_SN", "Mould_1_SN", Opc.Ua.DataTypeIds.String, ValueRanks.Scalar); // create myDevice1/Mould_2 Mould_2 = CreateVariable(mydev1, "Mould_2", "Mould_2", Opc.Ua.DataTypeIds.String, ValueRanks.Scalar); // create myDevice1/Mould_2_SN Mould_2_SN = CreateVariable(mydev1, "Mould_2_SN", "Mould_2_SN", Opc.Ua.DataTypeIds.String, ValueRanks.Scalar); // create myDevice1/Piece_SN Piece_SN = CreateVariable(mydev1, "Piece_SN", "Piece_SN", Opc.Ua.DataTypeIds.Int32, ValueRanks.Scalar); // create myDevice1/Piece_SN Machine_SN = CreateVariable(mydev1, "Machine_SN", "Machine_SN", Opc.Ua.DataTypeIds.String, ValueRanks.Scalar); //create myDevice1/Change_Mould Change_Mould = CreateVariable(mydev1, "Change_Mould", "Change_Mould", Opc.Ua.DataTypeIds.Boolean, ValueRanks.Scalar); //create myDevice1/Mould_Changed Mould_Changed = CreateVariable(mydev1, "Mould_Changed", "Mould_Changed", Opc.Ua.DataTypeIds.Boolean, ValueRanks.Scalar); // create myDevice1/Actual_Mould Actual_Mould = CreateVariable(mydev1, "Actual_Mould", "Actual_Mould", Opc.Ua.DataTypeIds.Int32, ValueRanks.Scalar); // create myDevice1/Mould_tobeused Mould_tobeused = CreateVariable(mydev1, "Mould_tobeused", "Mould_tobeused", Opc.Ua.DataTypeIds.String, ValueRanks.Scalar); // create myDevice1/Operator_ID Operator_ID = CreateVariable(mydev1, "Operator_ID", "Operator_ID", Opc.Ua.DataTypeIds.Int32, ValueRanks.Scalar); // create myDevice1/Robot_Finished Robot_Finished = CreateVariable(mydev1, "Robot_Finished", "Robot_Finished", Opc.Ua.DataTypeIds.Boolean, ValueRanks.Scalar); //initialize var myvar1.Value = (double)0.0; myvar2.Value = (short)0; Actual_State.Value = (double)0.0; Start_Piece.Value = (bool)false; Mould_1.Value = (string)"Mould 1"; Mould_2.Value = (string)"Mould 2"; Mould_1_SN.Value = (string)"1"; Mould_2_SN.Value = (string)"2"; Piece_SN.Value = (int)1; Machine_SN.Value = (string)"1"; Change_Mould.Value = (bool)false; Robot_Finished.Value = (bool)true; Actual_Mould.Value = (int)0; //Sensors_Data.Value = (int[])null; Mould_tobeused.Value = Mould_1_SN.Value; Mould_Changed.Value = (bool)false; //store variable in my variable list for latter access (not necessary if variable is declare as a field of the class) m_dynamicNodes.Add(myvar1); m_dynamicNodes.Add(Actual_State); //add to Address Space AddPredefinedNode(SystemContext, mydev1); //------------------------------------------------------------------------------------- //Create a new object using the type "Device" defined by the DI specification //The class DeviceState is defined in the code generated by ModelCompiler myTemperatureSensor = new DeviceState(null); myTemperatureSensor.Create(SystemContext, null, new QualifiedName("myTemperatureSensor", m_namespaceIndex), null, true); //Object is created under DeviceSet DeviceSetobj.AddChild(myTemperatureSensor); //create a variable to hold the value of the temperature, of the type AnalogItem, under myTemperatureSensor TemperatureValue = new AnalogItemState(null); TemperatureValue.Create(SystemContext, null, new QualifiedName("Temperature", m_namespaceIndex), null, true); //Object is created under myTemperatureSensor myTemperatureSensor.AddChild(TemperatureValue); //initialize var TemperatureValue.Value = (double)0.0; //the type "Device" has a set of predefined info variables myTemperatureSensor.SerialNumber.Value = "AABB112233"; myTemperatureSensor.Manufacturer.Value = "ACME"; myTemperatureSensor.Model.Value = new LocalizedText("PT", "MODEL 1.0"); //add to Address Space AddPredefinedNode(SystemContext, myTemperatureSensor); //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- //initialize Modbus client Modbus_client = new ModbusClient(Modbus_IP, Modbus_port); Modbus_client.ConnectionTimeout = 5000; // start periodic method to update my Address Space variables m_doprocessingTimer = new Timer(myDoProcessing, null, m_doprocessingInterval, m_doprocessingInterval); } }
private void CreateBaseVariable(FolderState root, ConfigNode node) { BuiltInType tp; if (Enum.TryParse <BuiltInType>(node.DataType, out tp) == false) { throw new ArgumentException($"Value {node.DataType} of node {node.NodeId} cannot be parsed."); } byte accessLevel = 0; // We have to hard code conversion here, because AccessLevel is defined as byte in OPCUA lib. switch (node.AccessLevel) { case "None": accessLevel = AccessLevels.None; break; case "CurrentRead": accessLevel = AccessLevels.CurrentRead; break; case "CurrentWrite": accessLevel = AccessLevels.CurrentWrite; break; case "CurrentReadOrWrite": accessLevel = AccessLevels.CurrentReadOrWrite; break; case "HistoryRead": accessLevel = AccessLevels.HistoryRead; break; case "HistoryWrite": accessLevel = AccessLevels.HistoryWrite; break; case "HistoryReadOrWrite": accessLevel = AccessLevels.HistoryReadOrWrite; break; case "SemanticChange": accessLevel = AccessLevels.SemanticChange; break; case "StatusWrite": accessLevel = AccessLevels.StatusWrite; break; case "TimestampWrite": accessLevel = AccessLevels.TimestampWrite; break; default: throw new ArgumentException($"Unsupported AccessLevel '{node.AccessLevel}'"); } ; CreateBaseVariable(root, node.NodeId, node.Name, tp, node.ValueRank, accessLevel, node.Description.ToString()); }
/// <summary> /// Finds the child with the specified browse name. /// </summary> protected override BaseInstanceState FindChild( ISystemContext context, QualifiedName browseName, bool createOrReplace, BaseInstanceState replacement) { if (QualifiedName.IsNull(browseName)) { return(null); } BaseInstanceState instance = null; switch (browseName.Name) { case vc2opcua.BrowseNames.Signals: { if (createOrReplace) { if (Signals == null) { if (replacement == null) { Signals = new FolderState(this); } else { Signals = (FolderState)replacement; } } } instance = Signals; break; } case vc2opcua.BrowseNames.Properties: { if (createOrReplace) { if (Properties == null) { if (replacement == null) { Properties = new FolderState(this); } else { Properties = (FolderState)replacement; } } } instance = Properties; break; } } if (instance != null) { return(instance); } return(base.FindChild(context, browseName, createOrReplace, replacement)); }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { base.CreateAddressSpace(externalReferences); #region Task #A1 - Create Root Folder // create the root folder. FolderState root = new FolderState(null); root.NodeId = GenerateNodeId(); root.BrowseName = new QualifiedName("Root", NamespaceIndex); root.DisplayName = root.BrowseName.Name; root.TypeDefinitionId = ObjectTypeIds.FolderType; // ensure root can be found via the server object. IList <IReference> references = null; if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } root.AddReference(ReferenceTypeIds.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypeIds.Organizes, false, root.NodeId)); // save the node for later lookup. AddPredefinedNode(SystemContext, root); #endregion #region Task #A2 - Create Object Instance with a Property // create the folder object. BaseObjectState instance = new BaseObjectState(null); instance.NodeId = GenerateNodeId(); instance.BrowseName = new QualifiedName("Object", NamespaceIndex); instance.DisplayName = instance.BrowseName.Name; instance.TypeDefinitionId = ObjectTypeIds.BaseObjectType; // create a losely coupled relationship with the root object. root.AddReference(ReferenceTypeIds.Organizes, false, instance.NodeId); instance.AddReference(ReferenceTypeIds.Organizes, true, root.NodeId); // create a property. PropertyState <int> property = new PropertyState <int>(instance); property.NodeId = GenerateNodeId(); property.BrowseName = new QualifiedName("Property", NamespaceIndex); property.DisplayName = property.BrowseName.Name; property.TypeDefinitionId = VariableTypeIds.PropertyType; property.DataType = DataTypeIds.Int32; property.ValueRank = ValueRanks.Scalar; property.MinimumSamplingInterval = MinimumSamplingIntervals.Continuous; property.AccessLevel = AccessLevels.CurrentReadOrWrite; property.UserAccessLevel = AccessLevels.CurrentReadOrWrite; property.Historizing = false; property.ReferenceTypeId = ReferenceTypeIds.HasProperty; // create a property that is tightly coupled. instance.AddChild(property); // save the node for later lookup (all tightly coupled children are added with this call). AddPredefinedNode(SystemContext, instance); #endregion #region Task #A3 - Create a Variable using the Built-in Type Model // create the variable. AnalogItemState <double> variable = new AnalogItemState <double>(instance); // add optional properties. variable.InstrumentRange = new PropertyState <Range>(variable); // instantiate based on the type model. assigns ids automatically using SystemContext.NodeIdFactory variable.Create( SystemContext, GenerateNodeId(), new QualifiedName("Variable", NamespaceIndex), null, true); // set default values. variable.EURange.Value = new Range(90, 10); variable.InstrumentRange.Value = new Range(100, 0); // tightly coupled. instance.AddChild(variable); // need to add it manually since its parent was already added. AddPredefinedNode(SystemContext, variable); #endregion #region Task #A4 - Add Dynamic Behavoir by Updating In-Memory Nodes m_property = property; m_simulationTimer = new Timer(DoSimulation, null, 1000, 1000); #endregion #region Task #A5 - Add Support for External Nodes // External nodes are nodes that reference an entity which stored elsewhere. // These nodes use no memory in the server unless they are accessed. // The NodeId is a string that is used to create the external node on demand. root.AddReference(ReferenceTypeIds.Organizes, false, CreateNodeId("Alpha")); root.AddReference(ReferenceTypeIds.Organizes, false, CreateNodeId("Omega")); #endregion #region Task #A7 - Add Support for Method MethodState method = new MethodState(instance); method.NodeId = GenerateNodeId(); method.BrowseName = new QualifiedName("Method", NamespaceIndex); method.DisplayName = method.BrowseName.Name; method.Executable = true; method.UserExecutable = true; method.ReferenceTypeId = ReferenceTypeIds.HasComponent; instance.AddChild(method); // create the input arguments. PropertyState <Argument[]> inputArguments = new PropertyState <Argument[]>(method); inputArguments.NodeId = GenerateNodeId(); inputArguments.BrowseName = new QualifiedName(BrowseNames.InputArguments); inputArguments.DisplayName = inputArguments.BrowseName.Name; inputArguments.TypeDefinitionId = VariableTypeIds.PropertyType; inputArguments.DataType = DataTypeIds.Argument; inputArguments.ValueRank = ValueRanks.OneDimension; inputArguments.MinimumSamplingInterval = MinimumSamplingIntervals.Continuous; inputArguments.AccessLevel = AccessLevels.CurrentRead; inputArguments.UserAccessLevel = AccessLevels.CurrentRead; inputArguments.Historizing = false; inputArguments.ReferenceTypeId = ReferenceTypeIds.HasProperty; inputArguments.Value = new Argument[] { new Argument() { Name = "CurrentCount", Description = "The current count.", DataType = DataTypeIds.Int32, ValueRank = ValueRanks.Scalar } }; method.InputArguments = inputArguments; // create the output arguments. PropertyState <Argument[]> outputArguments = new PropertyState <Argument[]>(method); outputArguments.NodeId = GenerateNodeId(); outputArguments.BrowseName = new QualifiedName(BrowseNames.OutputArguments); outputArguments.DisplayName = outputArguments.BrowseName.Name; outputArguments.TypeDefinitionId = VariableTypeIds.PropertyType; outputArguments.DataType = DataTypeIds.Argument; outputArguments.ValueRank = ValueRanks.OneDimension; outputArguments.MinimumSamplingInterval = MinimumSamplingIntervals.Continuous; outputArguments.AccessLevel = AccessLevels.CurrentRead; outputArguments.UserAccessLevel = AccessLevels.CurrentRead; outputArguments.Historizing = false; outputArguments.ReferenceTypeId = ReferenceTypeIds.HasProperty; outputArguments.Value = new Argument[] { new Argument() { Name = "NewCount", Description = "The new count.", DataType = DataTypeIds.Int32, ValueRank = ValueRanks.Scalar } }; method.OutputArguments = outputArguments; // save the node for later lookup (all tightly coupled children are added with this call). AddPredefinedNode(SystemContext, instance); // register handler. method.OnCallMethod = new GenericMethodCalledEventHandler(DoMethodCall); #endregion #region Task #D6 - Add Support for Notifiers // enable subscriptions. root.EventNotifier = EventNotifiers.SubscribeToEvents; // creating notifier ensures events propogate up the hierarchy when the are produced. AddRootNotifier(root); // add link to server object. if (!externalReferences.TryGetValue(ObjectIds.Server, out references)) { externalReferences[ObjectIds.Server] = references = new List <IReference>(); } references.Add(new NodeStateReference(ReferenceTypeIds.HasNotifier, false, root.NodeId)); // add sub-notifiers. instance.EventNotifier = EventNotifiers.SubscribeToEvents; instance.AddNotifier(SystemContext, ReferenceTypeIds.HasNotifier, true, root); root.AddNotifier(SystemContext, ReferenceTypeIds.HasNotifier, false, instance); #endregion } }
/// <summary> /// Adds an aggregate function to the server capabilities object. /// </summary> public void AddAggregateFunction(NodeId aggregateId, string aggregateName, bool isHistorical) { lock (Lock) { FolderState state = new FolderState(null); state.SymbolicName = aggregateName; state.ReferenceTypeId = ReferenceTypes.HasComponent; state.TypeDefinitionId = ObjectTypeIds.AggregateFunctionType; state.NodeId = aggregateId; state.BrowseName = new QualifiedName(aggregateName, aggregateId.NamespaceIndex); state.DisplayName = state.BrowseName.Name; state.WriteMask = AttributeWriteMask.None; state.UserWriteMask = AttributeWriteMask.None; state.EventNotifier = EventNotifiers.None; NodeState folder = FindPredefinedNode(ObjectIds.Server_ServerCapabilities_AggregateFunctions, typeof(BaseObjectState)); if (folder != null) { folder.AddReference(ReferenceTypes.Organizes, false, state.NodeId); state.AddReference(ReferenceTypes.Organizes, true, folder.NodeId); } if (isHistorical) { folder = FindPredefinedNode(ObjectIds.HistoryServerCapabilities_AggregateFunctions, typeof(BaseObjectState)); if (folder != null) { folder.AddReference(ReferenceTypes.Organizes, false, state.NodeId); state.AddReference(ReferenceTypes.Organizes, true, folder.NodeId); } } AddPredefinedNode(SystemContext, state); } }
private void ReadNative(Queue <FolderState> subdirs, CancellationToken token) { Win32FindData find = new Win32FindData(); FolderState folderState = subdirs.Dequeue(); ScanningState state = folderState.State; FolderNode parent = folderState.Folder; bool findResult; string parentPath = parent.Path; string searchPattern = PathUtils.CombineNoChecks(parentPath, "*"); if (!searchPattern.StartsWith(@"\\?\")) { searchPattern = @"\\?\" + searchPattern; } IntPtr hFind = FindFirstFileEx(searchPattern, FindExInfoLevels.Basic, out find, FindExSearchOps.NameMatch, IntPtr.Zero, FindExFlags.LargeFetch); if (hFind == InvalidHandle) { return; } FolderNode fileCollection = null; FileNodeBase singleFile = null; try { do { string filePath = PathUtils.CombineNoChecks(parentPath, find.cFileName); if (find.IsRelativeDirectory || SkipFile(state, find.cFileName, filePath)) { // Skip these types of entries findResult = FindNextFile(hFind, out find); continue; } FileNodeBase child; if (find.IsDirectory) { FolderNode folder = new FolderNode(find); child = folder; if (!find.IsSymbolicLink) { subdirs.Enqueue(new FolderState(folder, state)); } } else { FileNode file = new FileNode(find); child = file; if (!find.IsSymbolicLink) { state.ScannedSize += child.Size; totalScannedSize += child.Size; } file.extRecord = extensions.Include(GetExtension(file.Name), child.Size); } parent.AddChild(child, ref fileCollection, ref singleFile); SuspendCheck(); if (token.IsCancellationRequested) { return; } findResult = FindNextFile(hFind, out find); } while (findResult); //if (parent.IsWatched) // parent.RaiseChanged(FileNodeAction.ChildrenDone); } finally { FindClose(hFind); } }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { #region Setup IList <IReference> references = null; if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } #endregion try { #region Initialize string alarmsName = "Alarms"; string alarmsNodeName = alarmsName; Type alarmControllerType = Type.GetType("Alarms.AlarmController"); int interval = 1000; string intervalString = interval.ToString(); int conditionTypeIndex = 0; #endregion #region Create Alarm Folder FolderState alarmsFolder = CreateFolder(null, alarmsNodeName, alarmsName); alarmsFolder.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, alarmsFolder.NodeId)); alarmsFolder.EventNotifier = EventNotifiers.SubscribeToEvents; AddRootNotifier(alarmsFolder); #endregion #region Create Methods string startMethodName = "Start"; string startMethodNodeName = alarmsNodeName + "." + startMethodName; MethodState startMethod = AlarmHelpers.CreateMethod(alarmsFolder, NamespaceIndex, startMethodNodeName, startMethodName); AlarmHelpers.AddStartInputParameters(startMethod, NamespaceIndex); startMethod.OnCallMethod = new GenericMethodCalledEventHandler(OnStart); string startBranchMethodName = "StartBranch"; string startBranchMethodNodeName = alarmsNodeName + "." + startBranchMethodName; MethodState startBranchMethod = AlarmHelpers.CreateMethod(alarmsFolder, NamespaceIndex, startBranchMethodNodeName, startBranchMethodName); AlarmHelpers.AddStartInputParameters(startBranchMethod, NamespaceIndex); startBranchMethod.OnCallMethod = new GenericMethodCalledEventHandler(OnStartBranch); string endMethodName = "End"; string endMethodNodeName = alarmsNodeName + "." + endMethodName; MethodState endMethod = AlarmHelpers.CreateMethod(alarmsFolder, NamespaceIndex, endMethodNodeName, endMethodName); endMethod.OnCallMethod = new GenericMethodCalledEventHandler(OnEnd); #endregion #region Create Variables string analogTriggerName = "AnalogSource"; string analogTriggerNodeName = alarmsNodeName + "." + analogTriggerName; BaseDataVariableState analogTrigger = AlarmHelpers.CreateVariable(alarmsFolder, NamespaceIndex, analogTriggerNodeName, analogTriggerName); analogTrigger.OnWriteValue = OnWriteAlarmTrigger; AlarmController analogAlarmController = (AlarmController)Activator.CreateInstance(alarmControllerType, analogTrigger, interval, false); SourceController analogSourceController = new SourceController(analogTrigger, analogAlarmController); m_triggerMap.Add("Analog", analogSourceController); string booleanTriggerName = "BooleanSource"; string booleanTriggerNodeName = alarmsNodeName + "." + booleanTriggerName; BaseDataVariableState booleanTrigger = AlarmHelpers.CreateVariable(alarmsFolder, NamespaceIndex, booleanTriggerNodeName, booleanTriggerName, boolValue: true); booleanTrigger.OnWriteValue = OnWriteAlarmTrigger; AlarmController booleanAlarmController = (AlarmController)Activator.CreateInstance(alarmControllerType, booleanTrigger, interval, true); SourceController booleanSourceController = new SourceController(booleanTrigger, booleanAlarmController); m_triggerMap.Add("Boolean", booleanSourceController); #endregion #region Create Alarms AlarmHolder mandatoryExclusiveLevel = new ExclusiveLevelHolder( this, alarmsFolder, analogSourceController, intervalString, GetSupportedAlarmConditionType(ref conditionTypeIndex), alarmControllerType, interval, optional: false); m_alarms.Add(mandatoryExclusiveLevel.AlarmNodeName, mandatoryExclusiveLevel); AlarmHolder mandatoryNonExclusiveLevel = new NonExclusiveLevelHolder( this, alarmsFolder, analogSourceController, intervalString, GetSupportedAlarmConditionType(ref conditionTypeIndex), alarmControllerType, interval, optional: false); m_alarms.Add(mandatoryNonExclusiveLevel.AlarmNodeName, mandatoryNonExclusiveLevel); AlarmHolder offNormal = new OffNormalAlarmTypeHolder( this, alarmsFolder, booleanSourceController, intervalString, GetSupportedAlarmConditionType(ref conditionTypeIndex), alarmControllerType, interval, optional: false); m_alarms.Add(offNormal.AlarmNodeName, offNormal); #endregion AddPredefinedNode(SystemContext, alarmsFolder); StartTimer(); m_allowEntry = true; } catch (Exception e) { Utils.LogError(e, "Error creating the AlarmNodeManager address space."); } } }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { LoadPredefinedNodes(SystemContext, externalReferences); IList <IReference> references = null; if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } FolderState rootMy = CreateFolder(null, "Machines"); rootMy.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, rootMy.NodeId)); rootMy.EventNotifier = EventNotifiers.SubscribeToEvents; AddRootNotifier(rootMy); string[] machines = new string[] { "Machine A", "Machine B", "Machine C" }; list = new List <BaseDataVariableState <int> >(); for (int i = 0; i < machines.Length; i++) { FolderState myFolder = CreateFolder(rootMy, machines[i]); CreateVariable(myFolder, "Name", DataTypeIds.String, ValueRanks.Scalar, "测试数据").Description = "设备的名称"; CreateVariable(myFolder, "IsFault", DataTypeIds.Boolean, ValueRanks.Scalar, true).Description = "设备是否启动"; CreateVariable(myFolder, "TestValueFloat", DataTypeIds.Float, ValueRanks.Scalar, 100.5f); CreateVariable(myFolder, "AlarmTime", DataTypeIds.DateTime, ValueRanks.Scalar, DateTime.Now); list.Add(CreateVariable(myFolder, "TestValueInt", DataTypeIds.Int32, ValueRanks.Scalar, 47123)); #region Add Method MethodState addMethod = CreateMethod(myFolder, "Calculate"); // set input arguments addMethod.InputArguments = new PropertyState <Argument[]>(addMethod) { NodeId = new NodeId(addMethod.BrowseName.Name + "InArgs", NamespaceIndex), BrowseName = BrowseNames.InputArguments }; addMethod.InputArguments.DisplayName = addMethod.InputArguments.BrowseName.Name; addMethod.InputArguments.TypeDefinitionId = VariableTypeIds.PropertyType; addMethod.InputArguments.ReferenceTypeId = ReferenceTypeIds.HasProperty; addMethod.InputArguments.DataType = DataTypeIds.Argument; addMethod.InputArguments.ValueRank = ValueRanks.OneDimension; addMethod.InputArguments.Value = new Argument[] { new Argument() { Name = "Int32 value", Description = "Int32 value", DataType = DataTypeIds.Int32, ValueRank = ValueRanks.Scalar }, new Argument() { Name = "Int32 value", Description = "Int32 value", DataType = DataTypeIds.Int32, ValueRank = ValueRanks.Scalar } }; // set output arguments addMethod.OutputArguments = new PropertyState <Argument[]>(addMethod); addMethod.OutputArguments.NodeId = new NodeId(addMethod.BrowseName.Name + "OutArgs", NamespaceIndex); addMethod.OutputArguments.BrowseName = BrowseNames.OutputArguments; addMethod.OutputArguments.DisplayName = addMethod.OutputArguments.BrowseName.Name; addMethod.OutputArguments.TypeDefinitionId = VariableTypeIds.PropertyType; addMethod.OutputArguments.ReferenceTypeId = ReferenceTypeIds.HasProperty; addMethod.OutputArguments.DataType = DataTypeIds.Argument; addMethod.OutputArguments.ValueRank = ValueRanks.OneDimension; addMethod.OutputArguments.Value = new Argument[] { new Argument() { Name = "Operater Result", Description = "Operater Result", DataType = DataTypeIds.String, ValueRank = ValueRanks.Scalar } }; addMethod.OnCallMethod = new GenericMethodCalledEventHandler(OnAddCall); #endregion } SystemState = CreateVariable(rootMy, "Enable", DataTypeIds.Boolean, ValueRanks.Scalar, false); CreateVariable(rootMy, "Mat", DataTypeIds.Double, ValueRanks.TwoDimensions, new double[4, 4]); AddPredefinedNode(SystemContext, rootMy); FolderState robots = CreateFolder(null, "Robots"); robots.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, robots.NodeId)); robots.EventNotifier = EventNotifiers.SubscribeToEvents; AddRootNotifier(robots); RobotA = new HuiBoRobot(robots, "RobotA", NamespaceIndex, SystemContext); RobotB = new HuiBoRobot(robots, "RobotB", NamespaceIndex, SystemContext); RobotC = new HuiBoRobot(robots, "RobotC", NamespaceIndex, SystemContext); AddPredefinedNode(SystemContext, robots); } }
public override void CopyFolderProperties(FolderRecWrapper sourceFolderRecWrapper, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped) { Guid empty = Guid.Empty; bool isRoot = base.IsRoot; bool flag = false; wasPropertyCopyingSkipped = false; FolderMapping folderMapping = sourceFolderRecWrapper as FolderMapping; while (folderMapping.WKFType != WellKnownFolderType.Root) { if (folderMapping.IsLegacyPublicFolder) { return; } folderMapping = (folderMapping.Parent as FolderMapping); } if (destFolder == null) { if (!isRoot || ((FolderMapping)sourceFolderRecWrapper).IsSystemPublicFolder) { MrsTracer.Service.Debug("Skipping final property copying for \"{0}\" folder since it's contents don't reside in this mailbox", new object[] { sourceFolderRecWrapper.FullFolderName }); return; } throw new FolderCopyFailedPermanentException(sourceFolderRecWrapper.FullFolderName); } else { PropValueData[] props = destFolder.GetProps(new PropTag[] { PropTag.ReplicaList, PropTag.IpmWasteBasketEntryId }); IDataConverter <PropValue, PropValueData> dataConverter = new PropValueConverter(); PropValue nativeRepresentation = dataConverter.GetNativeRepresentation(props[0]); byte[] array = nativeRepresentation.Value as byte[]; if (!nativeRepresentation.IsNull() && !nativeRepresentation.IsError() && array != null) { StorePropertyDefinition replicaList = CoreFolderSchema.ReplicaList; string[] stringArrayFromBytes = ReplicaListProperty.GetStringArrayFromBytes(array); if (stringArrayFromBytes.Length > 0 && GuidHelper.TryParseGuid(stringArrayFromBytes[0], out empty)) { flag = (empty == base.TargetMailboxGuid); } } FolderStateSnapshot folderStateSnapshot = base.ICSSyncState[sourceFolderRecWrapper.EntryId]; FolderState state = folderStateSnapshot.State; if (sourceFolder.GetFolderRec(this.GetAdditionalFolderPtags(), GetFolderRecFlags.None).IsGhosted) { folderStateSnapshot.State |= FolderState.IsGhosted; } else { folderStateSnapshot.State &= ~FolderState.IsGhosted; } if (state != folderStateSnapshot.State) { base.SaveICSSyncState(false); } if (!isRoot && !flag) { return; } List <PropValueData> list = new List <PropValueData>(2); bool flag2 = false; if (flag) { PropValue nativeRepresentation2 = dataConverter.GetNativeRepresentation(sourceFolder.GetProps(new PropTag[] { PropTag.PfProxy })[0]); if (!nativeRepresentation2.IsNull() && !nativeRepresentation2.IsError()) { byte[] array2 = nativeRepresentation2.Value as byte[]; if (array2 != null && array2.Length == 16 && new Guid(array2) != Guid.Empty) { Guid a = Guid.Empty; bool flag3 = base.Flags.HasFlag(MailboxCopierFlags.CrossOrg); if (flag3) { a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.EntryId, sourceFolderRecWrapper.EntryId); } else { a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.ObjectGuid, array2); } if (a != Guid.Empty) { list.Add(new PropValueData(PropTag.PfProxy, a.ToByteArray())); list.Add(new PropValueData(PropTag.PfProxyRequired, true)); flag2 = true; } else { base.Report.Append(new ReportEntry(MrsStrings.ReportFailedToLinkADPublicFolder(sourceFolderRecWrapper.FullFolderName, BitConverter.ToString(array2), BitConverter.ToString(sourceFolderRecWrapper.EntryId)), ReportEntryType.Warning)); } } } } if (!flag2) { list.Add(new PropValueData(PropTag.PfProxy, Guid.Empty.ToByteArray())); list.Add(new PropValueData(PropTag.PfProxyRequired, false)); } List <PropValueData> list2 = new List <PropValueData>(9); if (isRoot) { if (!flag) { dataToCopy &= (FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation); } list2.AddRange(list); } else { byte[] sessionSpecificEntryId = this.hierarchyMailbox.GetSessionSpecificEntryId(sourceFolderRecWrapper.EntryId); using (IDestinationFolder folder = this.hierarchyMailbox.GetFolder(sessionSpecificEntryId)) { if (folder == null) { MrsTracer.Service.Error("Something deleted destination hierarchy folder from under us", new object[0]); throw new UnexpectedErrorPermanentException(-2147221238); } if (list.Count > 0) { folder.SetProps(list.ToArray()); } } } base.CopyFolderProperties(sourceFolderRecWrapper, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped); PropTag[] pta = new PropTag[] { PropTag.DisablePeruserRead, PropTag.OverallAgeLimit, PropTag.RetentionAgeLimit, PropTag.PfQuotaStyle, PropTag.PfOverHardQuotaLimit, PropTag.PfStorageQuota, PropTag.PfMsgSizeLimit }; foreach (PropValueData propValueData in sourceFolder.GetProps(pta)) { PropValue nativeRepresentation3 = dataConverter.GetNativeRepresentation(propValueData); if (!nativeRepresentation3.IsNull() && !nativeRepresentation3.IsError()) { if (propValueData.PropTag == 1721303043 && (int)propValueData.Value > 0) { propValueData.Value = (int)EnhancedTimeSpan.FromDays((double)((int)propValueData.Value)).TotalSeconds; } list2.Add(propValueData); } } if (list2.Count > 0) { destFolder.SetProps(list2.ToArray()); } return; } }