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 OpcSim(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name)
{
Context = context;
Simulator.Instance().Register(this);
//LoadChildren(simChildren, Context);
//RegisterChildren();
}
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));
}
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 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;
}
protected override void ImplementNode(IOpcNode node)
{
if (node is OpcObjectNode objectNode && node.Name.Value == "Alerts")
{
this.alertsNode = objectNode;
}
base.ImplementNode(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override IOpcNodeHistoryProvider RetrieveNodeHistoryProvider(IOpcNode node)
{
if (this.positionHistorian.Node == node)
{
return(this.positionHistorian);
}
return(base.RetrieveNodeHistoryProvider(node));
}
public Silo(IOpcNode parent, OpcName name, OpcContext context, double capacity) : base(parent, name, context)
{
Level = new LevelSensor(this, "LevelSensor", Context, capacity);
Motor = new Motor(this, "Fördermotor", Context);
Outlet = new Valve(this, "Ausgangsventil", Context);
RegisterComponent(Motor);
RegisterComponent(Level);
RegisterComponent(Outlet);
}
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;
}
public MotorDelayLane(IOpcNode parent, OpcName name, OpcContext context, int numerOfMotors) : base(parent, name, context)
{
for (int i = 0; i < numerOfMotors; i++)
{
motors.Add(new Motor(this, "Motor" + i, Context));
}
motors.ForEach(m => RegisterComponent(m));
}
public MyComplexVariableNode(
IOpcNode parent,
OpcName name,
string mandatoryValue,
int optionalValue = -1)
: base(parent, name)
{
this.InitializeChildren(mandatoryValue, optionalValue);
}
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);
}
}
protected override IOpcNodeHistoryProvider RetrieveNodeHistoryProvider(IOpcNode node)
{
// Determine existing historian of the node the history provider is requested for.
if (this.historians.TryGetValue(node, out var historian))
{
return(historian);
}
return(base.RetrieveNodeHistoryProvider(node));
}
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);
}
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 Kuehler(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
Ventilators.Add(new Motor(this, "Ventilator1", Context));
Ventilators.Add(new Motor(this, "Ventilator2", Context));
Ventilators.Add(new Motor(this, "Ventilator3", Context));
Ventilators.ForEach(v => RegisterComponent(v));
tempSensor = new TemperaturSensor(this, "Temperatur", context);
tempSensor.UpperLimit = 120.0;
RegisterComponent(tempSensor);
}
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);
}
protected override void AddNode(
OpcContext context,
IOpcNode node,
IEnumerable <IOpcNodeReferenceAware> references)
{
base.AddNode(context, node, references);
// "Catch" nodes added by the client and "schedule" job nodes.
if (node.Parent == this.jobsNode)
{
if (node is OpcDataVariableNode jobNode)
{
this.jobs.Enqueue(jobNode);
}
}
}
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);
}
protected override void AddNode(
OpcContext context,
IOpcNode node,
IEnumerable <IOpcNodeReferenceAware> references)
{
base.AddNode(context, node, references);
// "Catch" nodes added by the client and "attach" the on-demand timestamp determination
// (see HandleWriteVariableValue) and a simple in-memory historian which shall
// automatically fill its historical values whenever a node value is written.
if (node is OpcVariableNode variableNode && variableNode.AccessLevel.HasFlag(OpcAccessLevel.HistoryRead))
{
variableNode.WriteVariableValueCallback = this.HandleWriteVariableValue;
variableNode.IsHistorizing = true;
var historian = new OpcNodeHistorian(this, variableNode);
historian.AutoUpdateHistory = true;
this.historians.Add(node, historian);
}
}
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 MySimpleVariableNode(IOpcNode parent, OpcName name, int value)
: base(parent, name, value)
{
}
public Brenner(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
_fuelMissing = new OpcDataVariableNode <bool>(this, "AlarmBrennstoffFehlt");
}
public Brecher(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
motors.ForEach(m => RegisterComponent(m));
}
public OpcSimComponentControl(IOpcNode parent, OpcName name, OpcContext context) : base(parent, name, context)
{
}
public MySimpleObjectNode(IOpcNode parent, OpcName name)
: base(parent, name)
{
}
public MyComplexObjectNode(IOpcNode parent, OpcName name)
: base(parent, name)
{
this.InitializeChildren();
}
protected static void AddConfig(IOpcNode node)
{
_timeLapse = new OpcDataVariableNode <TimeMultiplier>(node, "Zeitraffer");
_clock = new OpcDataVariableNode <int>(node, "Clock", 100);
_clock.Description = "Clock in Millisekunden";
}
