public LevelSensor(OpcSimModule parent, OpcName name, OpcContext context, double maxLevel) : base(parent, name, context)
{
_maxLevelKg = new OpcAnalogItemNode <double>(this, "MaxLevelKg", maxLevel);
_maxLevelKg.AccessLevel = OpcAccessLevel.CurrentRead;
_levelKg = new OpcAnalogItemNode <double>(this, "LevelKg");
_levelKg.InstrumentRange = new OpcValueRange(MaxLevelKg, 0);
_levelKg.EngineeringUnit = new OpcEngineeringUnitInfo(4933453, "Kg", "Kilogramm");
_levelKg.EngineeringUnitRange = new OpcValueRange(MaxLevelKg, 0);
_levelKg.Description = "Füllstand in Kilogramm";
_levelKg.BeforeApplyChanges += _levelKg_BeforeApplyChanges;
_levelPercent = new OpcDataVariableNode <double>(this, "LevelPercent");
_levelPercent.Description = "Füllstand in Prozent";
_levelPercent.AccessLevel = OpcAccessLevel.CurrentRead;
_alarmLevelHeigh = new OpcDataVariableNode <bool>(this, "AlarmFüllstandHoch");
_alarmLevelHeigh.Description = "Füllstand > 95%";
_warningLevelHeigh = new OpcDataVariableNode <bool>(this, "WarnungFüllstandHoch");
_warningLevelHeigh.Description = "Füllstand > 80%";
//Random r = new Random();
//LevelKg = r.NextDouble() * 5000.0;
}
private OpcDataVariableNode <T> CreateNode <T>(
OpcFolderNode nodes,
T defaultValue,
Func <T, int, T> randomizer = null)
{
var name = typeof(T).Name;
name = char.ToUpper(name[0]) + name.Substring(1);
if (typeof(T).IsArray)
{
name = typeof(T).GetElementType().Name + "Array";
}
var node = new OpcDataVariableNode <T>(nodes, name, defaultValue);
node.ReadVariableValueCallback = this.HandleReadVariableValue;
node.WriteVariableValueCallback = this.HandleWriteVariableValue;
if (randomizer != null)
{
this.tasks.Add(() => {
node.Value = randomizer(node.Value, this.valueRandom.Next(0, 183));
node.ApplyChanges(this.SystemContext);
});
}
return(node);
}
public ManualControl(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_start = new OpcDataVariableNode <bool>(this, "Ein");
_start.AccessLevel = OpcAccessLevel.CurrentRead;
_manualActive = new OpcDataVariableNode <bool>(this, "Erlaubt");
_manualActive.AccessLevel = OpcAccessLevel.CurrentRead;
}
public Zyklon(IOpcNode parent, OpcName name, OpcContext context, Drehrohrofen ofen) : base(parent, name, context)
{
Ofen = ofen;
tempSensors.Add(new TemperaturSensor(this, "Temperatur_1,", Context)
{
UpperLimit = Ofen.MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_2,", Context)
{
UpperLimit = Ofen.MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_3,", Context)
{
UpperLimit = Ofen.MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_4,", Context)
{
UpperLimit = Ofen.MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_5,", Context)
{
UpperLimit = Ofen.MaxTemp
});
tempSensors.ForEach(s => s.TempPt1.TimeConstant = 8000);
exhaustHeat = new OpcDataVariableNode <bool>(this, "AbwärmeOk", false);
exhaustHeat.AccessLevel = OpcAccessLevel.CurrentRead;
tempSensors.ForEach(s => RegisterComponent(s));
}
internal IOpcNode AddNode(IOpcNode parentNode, params string[] path)
{
var context = this.SystemContext;
foreach (var name in path)
{
var childNode = (OpcInstanceNode)parentNode.Child(context, name);
if (childNode == null)
{
if (name[0] == '.')
{
childNode = new OpcDataVariableNode <int>(parentNode, name, DateTime.Now.Millisecond);
}
else
{
childNode = new OpcFolderNode(parentNode, name);
}
this.AddNode(context, childNode);
if (childNode is OpcVariableNode)
{
return(childNode);
}
}
parentNode = childNode;
}
return(parentNode);
}
public MachineToolAlarmConditionNode()
: base("MachineToolAlarmCondition")
{
this.alarmIdentifierNode = new OpcDataVariableNode <string>(this, "2:AlarmIdentifier");
this.auxParametersNode = new OpcDataVariableNode <string>(this, "2:AuxParameters");
this.EventTypeId = "ns=2;i=1042";
}
public OpcSimOperation(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_operationState = new OpcDataVariableNode <OperationState>(this, "State");
_operationState.BeforeApplyChanges += _operationState_BeforeApplyChanges;
_operationState.AccessLevel = OpcAccessLevel.CurrentRead;
_operationMode = new OpcDataVariableNode <OperationMode>(this, "Mode");
_operationMode.BeforeApplyChanges += _operationMode_BeforeApplyChanges;
}
public static void Main()
{
connectedClients = 0;
List <OpcDataVariableNode> nodeList = new List <OpcDataVariableNode>();
var temperatureNode = new OpcDataVariableNode <double>("Temperature", 100.0);
var messageNode = new OpcDataVariableNode <string>("Message", string.Empty);
var levelDetectionNode = new OpcDataVariableNode <bool>("Level", false);
bool avslutt = false;
nodeList.Add(levelDetectionNode);
nodeList.Add(temperatureNode);
nodeList.Add(messageNode);
using (var server = new OpcServer("opc.tcp://localhost:4840/", nodeList))
{
server.Started += new EventHandler((sender, e) => ServerStarted(sender, e, nodeList, server));
// server.RequestProcessing += new OpcRequestProcessingEventHandler((a, b) => reqProcessing(a,b));
//server.RequestProcessed += new OpcRequestProcessedEventHandler((sender, e) => RequestProcessed(sender, e));
server.SessionActivated += new OpcSessionEventHandler((sender, e) => SessionMethod(sender, e));
server.SessionCreated += new OpcSessionEventHandler((serr, rerrr) => sessionCreatedMethod(serr, rerrr));
server.SessionClosing += new OpcSessionEventHandler((sender, e) => SessionClosingMethod(sender, e));
server.Start();
while (true)
{
if (temperatureNode.Value == 110)
{
temperatureNode.Value = 100;
}
else
{
temperatureNode.Value++;
}
if (messageNode.Value.Length > 5)
{
messageNode.Value = "e";
}
else
{
messageNode.Value += 'a';
}
if (levelDetectionNode.Value == true)
{
levelDetectionNode.Value = false;
}
else
{
levelDetectionNode.Value = true;
}
Thread.Sleep(1000);
}
}
}
public OpcSimComponent(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_warningActive = new OpcDataVariableNode <bool>(this, "WarnungAktiv");
_errorActive = new OpcDataVariableNode <bool>(this, "ErrorAktiv");
_simError = new OpcDataVariableNode <bool>(this, "SimStörung");
_simError.BeforeApplyChanges += _simError_BeforeApplyChanges;
_simWarning = new OpcDataVariableNode <bool>(this, "SimWarnung");
_simWarning.BeforeApplyChanges += _simWarning_BeforeApplyChanges;
}
private List <string> UpdateVariables()
{
try
{
HashSet <string> variableList = new HashSet <string>();
_matlabService.Matlab.Execute(string.Format("{0} = who", MatlabService.VariablesTag));
object vars;
_matlabService.Matlab.GetWorkspaceData(MatlabService.VariablesTag, MatlabService.BaseTag, out vars);
object[,] variables = vars as object[, ];
if (variables != null)
{
for (int i = 0; i < variables.GetLength(0); i++)
{
string variableName = variables[i, 0].ToString();
if (variableName != MatlabService.VariablesTag)
{
variableList.Add(variableName);
object variable = _matlabService.Matlab.GetVariable(variableName, MatlabService.BaseTag);
OpcDataVariableNode dataNode;
if (!_variableNodesIds.TryGetValue(variableName, out dataNode))
{
dataNode = new OpcDataVariableNode(_matlabFolder,
new OpcName(variableName), variable);
dataNode.WriteVariableValueCallback = WriteMatlabVariableValueCallback;
_variableNodesIds.Add(variableName, dataNode);
AddNode(dataNode);
Console.WriteLine("Added variable {0} : {1}", variableName, variable);
}
else if (!dataNode.Value.Equals(variable))
{
dataNode.Value = variable;
Console.WriteLine("Modified variable {0} : {1}", variableName, variable);
}
dataNode.DataType = OpcDataTypes.GetDataType(variable.GetType());
}
}
//Remove variables that no longer exists
List <string> keys = _variableNodesIds.Keys.ToList();
foreach (string key in keys)
{
if (!variableList.Contains(key))
{
IOpcNode removeNode = _variableNodesIds[key];
this.RemoveNode(removeNode);
_variableNodesIds.Remove(key);
Console.WriteLine("Removed variable: {0}", key);
}
}
}
return(variableList.ToList());
}
catch (Exception ex)
{
Console.WriteLine("Update variables error:{0}{1}{0}{2}", Environment.NewLine, ex.Message, ex.StackTrace);
return(null);
}
}
public UAServer(string host)
{
//_nodeManager = new NodeManager();
_temperatureNode = new OpcDataVariableNode <double>("Temperature", 100.0);
_server = new OpcServer(host, _temperatureNode);
_server.Start();
Task task = Task.Factory.StartNew(TemperatureMaker);
}
public TemperaturSensor(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_unit = new OpcDataVariableNode <string>(this, "Unit", "°C");
_range = new OpcDataVariableNode <string>(this, "Range", "0..0");
_maxValue = new OpcDataVariableNode <double>(this, "MaxValue");
_tempValue = new OpcDataVariableNode <double>(this, "Value");
_upperLimit = new OpcDataVariableNode <double>(this, "UpperLimit", 100.0);
_upperLimit.AccessLevel = OpcAccessLevel.CurrentRead;
_overtemp = new OpcDataVariableNode <bool>(this, "AlarmÜbertemperatur");
CreatePT1();
}
public Absackung(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
Abfüllung = new Motor(this, "Abfüllung", context);
_numberOfBags = new OpcDataVariableNode <int>(this, "AnzahlSäcke", 0);
_numberOfBags.AccessLevel = OpcAccessLevel.CurrentRead;
_resetBags = new OpcDataVariableNode <bool>(this, "ResetAnzahl");
_resetBags.BeforeApplyChanges += _resetBags_BeforeApplyChanges;
RegisterComponent(Abfüllung);
}
private static OpcFolderNode CreateDataNode()
{
var dataNode = new OpcFolderNode("Data");
for (int index = 0; index < NumberOfNodes; index++)
{
dataNodes.Add(new OpcDataVariableNode <int>(dataNode, $"Var{index:00000}", value: index));
}
timestampNode = new OpcDataVariableNode <DateTime>(dataNode, "Timestamp");
return(dataNode);
}
public Drehrohrofen(IOpcNode parent, OpcName name, OpcContext context, Brennstoffzufuhr bsz) : base(parent, name, context)
{
Brennstoffzufuhr = bsz;
_heatOk = new OpcDataVariableNode <bool>(this, "TemperaturOk");
_delayLengthMs = new OpcDataVariableNode <int>(this, "SimDelayLength", 10000);
_delayLengthMs.Description = "Simulierte Verzögerung von Einlauf zum Auslauf von Material";
Brenner = new Brenner(this, "Brenner", Context);
Motor = new Motor(this, "Hauptmotor", Context);
ValveWasteHeate = new Valve(this, "VentilAbwärme", Context);
tempSensors.Add(new TemperaturSensor(this, "Temperatur_1,", Context)
{
UpperLimit = MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_2,", Context)
{
UpperLimit = MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_3,", Context)
{
UpperLimit = MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_4,", Context)
{
UpperLimit = MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_5,", Context)
{
UpperLimit = MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_4,", Context)
{
UpperLimit = MaxTemp
});
tempSensors.Add(new TemperaturSensor(this, "Temperatur_5,", Context)
{
UpperLimit = MaxTemp
});
tempSensors.ForEach(s => s.TempPt1.TimeConstant = 14000);
RegisterComponent(Brenner);
RegisterComponent(Motor);
RegisterComponent(ValveWasteHeate);
tempSensors.ForEach(s => RegisterComponent(s));
}
public Valve(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_maxFlow = new OpcAnalogItemNode <double>(this, "MaxDurchfluss", 600.0);
_maxFlow.BeforeApplyChanges += _maxFlow_BeforeApplyChanges;
_flow = new OpcAnalogItemNode <double>(this, "Durchfluss");
_flow.InstrumentRange = new OpcValueRange(400.0, 0);
_flow.EngineeringUnit = new OpcEngineeringUnitInfo(4666675, "m3/min", "Kubikmeter pro Minute");
_flow.EngineeringUnitRange = new OpcValueRange(400.0, 0);
_flow.Description = "Kubikmeter pro Minute";
_open = new OpcDataVariableNode <bool>(this, "Offen");
_open.Description = "True = offen, False = zu";
_movementAlarm = new OpcDataVariableNode <bool>(this, "AlarmPosition");
ManualControl = new ManualControl(this, "Handbetrieb", Context);
}
private static OpcFolderNode CreateDataNode()
{
var dataNode = new OpcFolderNode("Data");
dataAvailableNode = new OpcDataVariableNode <bool>(dataNode, "DataAvailable");
dataProcessedNode = new OpcDataVariableNode <bool>(dataNode, "DataProcessed");
dataProcessedNode.WriteVariableValueCallback = WriteDataProcessed;
for (int index = 0; index < NumberOfNodes; index++)
{
dataNodes.Add(new OpcDataVariableNode <int>(dataNode, $"Var{index:00000}", value: index));
}
timestampNode = new OpcDataVariableNode <DateTime>(dataNode, "Timestamp");
return(dataNode);
}
protected override IEnumerable <IOpcNode> CreateNodes(OpcNodeReferenceCollection references)
{
_matlabFolder = new OpcFolderNode(
new OpcName(MatlabFolderName, this.DefaultNamespaceIndex));
references.Add(_matlabFolder, OpcObjectTypes.ObjectsFolder);
MyDeleagate del = UpdateVariables;
new OpcMethodNode(_matlabFolder, GetVariablesMethod, del);
var v = new OpcDataVariableNode <int>(_matlabFolder, new OpcName("GetVariablesVariable"), 0);//new OpcVariableNode(_matlabFolder,new OpcName("GetVariablesVariable"), 0);
v.WriteVariableValueCallback = WriteVariableValueCallback;
v.AccessLevel = OpcAccessLevel.CurrentReadOrWrite;
Console.WriteLine();
UpdateVariables();
return(new IOpcNode[] { _matlabFolder });
}
public Motor(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
tempSensor = new TemperaturSensor(this, "Temperatur", context);
tempSensor.AlarmEventChanged += TempSensor_AlarmEventChanged;
tempSensor.UpperLimit = 70.0;
_speed = new OpcDataVariableNode <double>(this, "Speed");
_current = new OpcDataVariableNode <double>(this, "Current");
_power = new OpcDataVariableNode <double>(this, "Power");
_running = new OpcDataVariableNode <bool>(this, "Running");
_overcurrent = new OpcDataVariableNode <bool>(this, "AlarmÜberlast");
ManualControl = new ManualControl(this, "Handbetrieb", Context);
CreateSpeedPt1();
PowerPt1 = new PT1_Floating(5000);
CurrentPt1 = new PT1_Floating(12.5);
CurrentPt1.TimeConstant = 200;
}
public RohMaterialGewinnung(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_truckReadyToUnload = new OpcDataVariableNode <bool>(this, "TruckBereitZumAbladen");
_truckReadyToUnload.Description = "Truck is ready to unload.";
_truckReadyToUnload.AccessLevel = OpcAccessLevel.CurrentRead;
_unloadingActive = new OpcDataVariableNode <bool>(this, "TruckAbladenAktiv");
_unloadingActive.Description = "Truck is ready to unload.";
_unloadingActive.AccessLevel = OpcAccessLevel.CurrentRead;
_timeUnloading = new OpcDataVariableNode <int>(this, "ZeitAbladen");
_timeUnloading.Description = "Zeit des Abladevorgangs";
_timeWaitTruck = new OpcDataVariableNode <int>(this, "ZeitWartenAufTruck");
_timeWaitTruck.Description = "Wartezeit nächster Truck";
_simTruckIntervalMs = new OpcDataVariableNode <int>(this, "Z_SimTruckIntervallMs", 10000);
_simTruckLoadCapacity = new OpcDataVariableNode <double>(this, "Z_SimTruckKapazität", 10000.0);
_simTruckUnloadTimeMs = new OpcDataVariableNode <int>(this, "Z_SimTruckAbladeZeitMs", 8000);
}
public static void Main(string[] args)
{
var someNode = new OpcDataVariableNode <string>("Hello", value: "Hello World!");
using (var server = new OpcServer("opc.tcp://localhost:4840/", someNode)) {
var users = server.Security.UserNameAcl;
// 1. Add the generic users to the UserName-ACL.
users.AddEntry(OpcWindowsIdentity.Generic);
users.AddEntry(OpcSubSystemIdentity.Generic);
// 2. Activate the UserName-ACL (this inline disables anonymous access).
users.IsEnabled = true;
server.Start();
Console.WriteLine("Server started - press any key to exit.");
Console.ReadKey(true);
}
}
public static void Main(string[] args)
{
temperatureNode = new OpcDataVariableNode <double>("Temperature");
speedNode = new OpcDataVariableNode <int>("Speed");
var machineNode = new OpcObjectNode(
"Machine",
temperatureNode,
speedNode,
new OpcActionMethodNode("StartMachine", StartMachine),
new OpcActionMethodNode("StopMachine", StopMachine));
using (var server = new OpcServer("opc.tcp://localhost:4840/", machineNode)) {
server.Start();
machineNode.AddNotifier(server.SystemContext, temperatureNode);
machineNode.AddNotifier(server.SystemContext, speedNode);
Console.WriteLine("Server started - press any key to exit.");
Console.ReadKey(true);
}
}
public OpcSimModule(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_start = new OpcDataVariableNode <bool>(this, "Start");
_start.Description = "Eine steigende Flanke startet die Anlage.";
_stop = new OpcDataVariableNode <bool>(this, "Stop");
_stop.Description = "Eine steigende Flanke stoppt die Anlage.";
_warningPending = new OpcDataVariableNode <bool>(this, "WarnungAktiv");
_warningPending.Description = "Zeigt eine anstehende Warnung.";
_warningPending.AccessLevel = OpcAccessLevel.CurrentRead;
_acknowledge = new OpcDataVariableNode <bool>(this, "Quittieren");
_acknowledge.Description = "Eine steigende Flanke quittiert die Anlage.";
_stop.BeforeApplyChanges += _stop_BeforeApplyChanges;
_start.BeforeApplyChanges += _start_BeforeApplyChanges;
_acknowledge.BeforeApplyChanges += _acknowledge_BeforeApplyChanges;
_receiverReady = new OpcDataVariableNode <bool>(this, "EmpfangenBereit");
_receiverReady.AccessLevel = OpcAccessLevel.CurrentRead;
}
public static void Main()
{
var temperatureNode = new OpcDataVariableNode <double>("Temperature", 100.0);
using (var server = new OpcServer("opc.tcp://localhost:4840/", temperatureNode)) {
server.Start();
while (true)
{
if (temperatureNode.Value == 110)
{
temperatureNode.Value = 100;
}
else
{
temperatureNode.Value++;
}
temperatureNode.ApplyChanges(server.SystemContext);
Thread.Sleep(1000);
}
}
}
public static void Main(string[] args)
{
if (args == null || args.Length == 0)
{
Console.WriteLine("Enter a valid ip address for the server (or localhost)");
return;
}
string serverIP = args[0];
#region 1st Way: Use the OpcServer class.
{
//// The OpcServer class interacts with one or more OPC UA clients using one of
//// the registered base addresses of the server. While this class provides the
//// different OPC UA services defined by OPC UA, it does not implement a main loop.
//string serverURL = "https://localhost:4840/SampleServer";
//string serverURL = "opc.tcp://localhost:4840/SampleServer";
string serverURL = $"opc.tcp://{serverIP}:4840/SampleServer";
var temperatureNode = new OpcDataVariableNode <double>("Temperature", 100.0);
//using var server = new OpcServer(serverURL, temperatureNode);
using var server = new OpcServer(serverURL, temperatureNode);
server.Start();
Console.WriteLine("Started the server at {0}", serverURL);
while (true)
{
if (temperatureNode.Value == 110)
{
temperatureNode.Value = 100;
}
else
{
temperatureNode.Value++;
}
temperatureNode.ApplyChanges(server.SystemContext);
Thread.Sleep(1000);
}
}
#endregion
#region 2nd Way: Use the OpcServerApplication class.
{
// The OpcServerApplication class uses a single OpcServer instance which is
// wrapped within a main loop.
//
// Remarks
// - The app instance does start a main loop when the server has been started.
// - Custom startup code have to be implemented within the event handler of the
// Started event of the app instance.
// new OpcServerApplication("opc.tcp://localhost:4840/SampleServer", new SampleNodeManager()).Run();
}
#endregion
#region 3rd Way: Use the OpcServerServiceApplication class.
{
//// The OpcServerServiceApplication class uses a single OpcServer instance which is
//// wrapped within a main loop when it is started with an interactive user or in
//// debug mode. Otherwise it will start the process as a windows service which
//// allows the application can be registered as a service process.
////
//// Remarks
//// - The app instance does start a main loop when the server has been started.
//// - Custom startup code have to be implemented within the event handler of the
//// Started event of the app instance.
//new OpcServerServiceApplication("opc.tcp://localhost:4840/SampleServer", new SampleNodeManager()).Run();
}
#endregion
}
protected static void AddConfig(IOpcNode node)
{
_timeLapse = new OpcDataVariableNode <TimeMultiplier>(node, "Zeitraffer");
_clock = new OpcDataVariableNode <int>(node, "Clock", 100);
_clock.Description = "Clock in Millisekunden";
}
/// <summary>
/// Creates the nodes provided and associated with the node manager.
/// </summary>
/// <param name="references">A dictionary used to determine the logical references between
/// existing nodes (e.g. OPC default nodes) and the nodes provided by the node
/// manager.</param>
/// <returns>An enumerable containing the root nodes of the node manager.</returns>
/// <remarks>This method will be only called once by the server on start up.</remarks>
protected override IEnumerable <IOpcNode> CreateNodes(OpcNodeReferenceCollection references)
{
// It is necessary to assign to all root nodes one of the namespaces used to
// identify one of the associated namespaces (see the ctor of the class). This
// namespace does identify the node as member of the namespace of the node
// manager. Optionally it is possible to assign namespace to the child nodes
// too. But by default their missing namespace will be auto-completed through the
// namespace of their parent node.
var machineOne = new OpcFolderNode(this.DefaultNamespace.GetName("Machine_1"));
// In case a client requests a condition referesh it queries the current event
// information which is gathered using the CreateEvent method from each active
// and retained alarm nodes.
machineOne.QueryEventsCallback = (context, events) => {
// Ensure that an re-entrance upon notifier cross-references will not add
// events to the collection which are already stored in.
if (events.Count != 0)
{
return;
}
if (this.statusChangeNode.IsRetained)
{
events.Add(this.statusChangeNode.CreateEvent(context));
}
if (this.positionLimitNode.IsRetained)
{
events.Add(this.positionLimitNode.CreateEvent(context));
}
if (this.temperatureCriticalNode.IsRetained)
{
events.Add(this.temperatureCriticalNode.CreateEvent(context));
}
};
// Add new reference to make the node visible beneath the ObjectsFolder
// (the top most root node within every OPC UA server).
references.Add(machineOne, OpcObjectTypes.ObjectsFolder);
new OpcDataVariableNode <string>(machineOne, "Name", "Machine 1");
this.isActiveNode = new OpcDataVariableNode <bool>(machineOne, "IsActive", true);
//// An alarm node have to be a notifier for another node or for the whole server.
//// Is a alarm a notifier of another node:
//// -> this node (the notified one) needs to be subscribed by the client to receive
//// the alarm data.
//// Is a alarm a notifier of the whole server:
//// -> the OpcObjectTypes.Server needs to be subscribed by the client to receive
//// the alarm data.
// Machine 1, Status nodes setup
{
this.statusNode = new OpcDataVariableNode <byte>(machineOne, "Status", 1);
// Define an alarm used to request a dialog which requires a dedicated response
// action by a client. This kind of node can be used for service / operator tasks.
this.statusChangeNode = new OpcDialogConditionNode(machineOne, "StatusChange");
this.statusChangeNode.AutoReportChanges = true;
this.statusChangeNode.Message = "Operator requested";
this.statusChangeNode.Prompt = "The job has been finished, continue with the next one?";
this.statusChangeNode.ResponseOptions = new OpcText[] { "Yes", "No" };
this.statusChangeNode.DefaultResponse = 0;
this.statusChangeNode.CancelResponse = 1;
this.statusChangeNode.OkResponse = 0;
// Handle any client response on an active dialog through applying the response
// using RespondDialog and configuring the dialog as inactive.
this.statusChangeNode.RespondCallback = (context, response) => {
this.isActiveNode.Value = (response == this.statusChangeNode.OkResponse);
this.isActiveNode.ApplyChanges(context);
this.statusChangeNode.RespondDialog(context, response);
this.statusChangeNode.Message = "No operator required";
this.statusChangeNode.IsRetained = false;
return(OpcStatusCode.Good);
};
// Define the alarm as the notifier of the machineOne node.
machineOne.AddNotifier(this.SystemContext, this.statusChangeNode);
}
// Machine 1, Position nodes setup
{
this.positionNode = new OpcAnalogItemNode <int>(machineOne, "Position", -1);
this.positionNode.InstrumentRange = new OpcValueRange(low: 120, high: 1);
this.positionNode.EngineeringUnit = new OpcEngineeringUnitInfo(4732211, "mm", "millimetre");
this.positionNode.EngineeringUnitRange = new OpcValueRange(byte.MaxValue);
// Define an alarm used to indicate the reaching of one or more limits during
// a progress. Such limits may be predefined or progress dependent.
this.positionLimitNode = new OpcExclusiveLimitAlarmNode(
machineOne, "PositionLimit", OpcLimitAlarmStates.All);
this.positionLimitNode.HighHighLimit = 120; // e.g. mm
this.positionLimitNode.HighLimit = 100; // e.g. mm
this.positionLimitNode.LowLimit = 5; // e.g. mm
this.positionLimitNode.LowLowLimit = 1; // e.g. mm
this.positionLimitNode.Message = "No range problems";
this.positionLimitNode.ReceiveTime = DateTime.UtcNow;
this.positionLimitNode.AcknowledgeCallback = (context, eventId, comment) => {
this.positionLimitNode.Message = "Acknowledged with " + comment;
return(OpcStatusCode.Good);
};
// Define the alarm as the notifier of the machineOne node.
machineOne.AddNotifier(this.SystemContext, this.positionLimitNode);
}
// Machine 1, Temperature nodes setup
{
this.temperatureNode = new OpcAnalogItemNode <double>(machineOne, "Temperature", 18.3);
this.temperatureNode.InstrumentRange = new OpcValueRange(80.0, -40.0);
this.temperatureNode.EngineeringUnit = new OpcEngineeringUnitInfo(4408652, "°C", "degree Celsius");
this.temperatureNode.EngineeringUnitRange = new OpcValueRange(70.8, 5.0);
// Define an alarm which just indicates the fulfillment of an alarm associated
// condition. Such simple alarms only notify about the fulfillment without to
// define additional prerequisites defined by the alarm itself. Much more
// specialized alarms are subclasses of this type of alarm node.
this.temperatureCriticalNode = new OpcAlarmConditionNode(machineOne, "TemperatureCritical");
// Define the alarm as the notifier of the machineOne node.
machineOne.AddNotifier(this.SystemContext, this.temperatureCriticalNode);
// Define the alarm as the notifier of the whole Server node.
this.AddNotifierNode(this.temperatureCriticalNode);
}
return(new IOpcNode[] { machineOne });
}
public Brenner(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_fuelMissing = new OpcDataVariableNode <bool>(this, "AlarmBrennstoffFehlt");
}
public Brennstoffzufuhr(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_gasLevel = new OpcDataVariableNode <int>(this, "GasVorrat", 35);
_coleLevel = new OpcDataVariableNode <int>(this, "KohleVorrat", 75);
}