public VariableRef GetStateVarRef(string stateID)
{
string calcID = this.CalcConfig.ID;
string fullStateID = calcID + Config.State.ID_Separator + stateID;
return(VariableRef.Make(moduleID, fullStateID, "Value"));
}
private static async Task OnReceivedVarWriteRequest(MqttVarReceive mqtt, Connection clientFAST, MqttApplicationMessageReceivedEventArgs arg)
{
await arg.AcknowledgeAsync(CancellationToken.None);
var msg = arg.ApplicationMessage;
string objID = GetObjIdFromTopicName(msg.Topic);
Console.WriteLine($"On got write req for {objID}");
byte[] payloadBytes = msg.Payload;
if (payloadBytes != null && payloadBytes.Length > 0)
{
string payload = Encoding.UTF8.GetString(payloadBytes);
DataValue value = DataValue.FromJSON(payload);
var variable = VariableRef.Make(mqtt.ModuleID, objID, "Value");
VTQ vtq = VTQ.Make(value, Timestamp.Now, Quality.Good);
try {
await clientFAST.WriteVariable(variable, vtq);
}
catch (Exception exp) {
Exception e = exp.GetBaseException() ?? exp;
Console.Error.WriteLine($"Failed to write variable {variable}: {e.Message}");
}
}
}
public void CompileVariableRef(VariableRef variableRef)
{
XmlElement tmpElement = document.CreateElement("VariableRef");
tmpElement.SetAttribute("Name", variableRef.Name);
currentElement.AppendChild(tmpElement);
}
public VariableRef GetOutputVarRef(string outputID)
{
string calcID = this.CalcConfig.ID;
string fullOutputID = calcID + Config.Output.ID_Separator + outputID;
return(VariableRef.Make(moduleID, fullOutputID, "Value"));
}
public void MergeDefaults(string defaultJson, IDictionary <string, NestedScope> existing)
{
var data = JsonConvert.DeserializeObject <NestedData>(defaultJson);
var variables = LoadData(data, Constants.PackageManagerIdentity).ToList();
// Complete the hierarchy and then merge the variables into the hierarchy
var scopes = NestedScope.BuildHeirarchy(variables.Select(v => v.PackageId), ErrorCache, existing);
foreach (var variable in variables)
{
var varRef = new VariableRef {
PackageId = variable.PackageId, VariableName = variable.Name
};
if (scopes[variable.PackageId].TryFindVariable(varRef, out var existingVariable))
{
existingVariable.Default = variable.Default;
if (existingVariable.Type != variable.Type)
{
existingVariable.Type = variable.Type;
existingVariable.Value = null;
}
}
else
{
scopes[variable.PackageId].Store(variable);
}
}
}
private async Task LoadData()
{
var result = new List <AggregatedEvent>();
VariableRef varRef = GetVar();
Timestamp t = Timestamp.Max;
while (true)
{
VTTQ[] data = await connection.HistorianReadRaw(varRef, Timestamp.Empty, t, 1000, BoundingMethod.TakeLastN);
var events = data.Select(VTTQ2AggregatedEvent)
.Where(ev => ev.IsWarningOrAlarm() && ev.State != EventState.Reset)
.ToList();
if (events.Count == 0)
{
break;
}
events.AddRange(result);
result = events;
t = data[0].T.AddMillis(-1);
}
aggregatedWarningsAndAlarms = result;
if (aggregatedWarningsAndAlarms.Count > 0)
{
latestUsedTimestamp = aggregatedWarningsAndAlarms.Last().TimeFirst;
}
}
public VariableInfo LoadConstantSetting(Constant constant, string settingName)
{
// Lookup a previously stored version of this variable
var variableRef = new VariableRef
{
PackageId = PackageId,
VariableName = $"constant.{settingName}"
};
if (!Scope.TryFindVariable(variableRef, out var variable))
{
// This is the first time a constant has been used here
// so create a new variable for it
variable = new Variable {
Name = variableRef.VariableName
};
}
variable.Value = variable.Default = constant.Value.ToString();
variable.Units = constant.Units.GetStringValue();
variable.Type = constant.SupportedType.GetStringValue();
variable.IsGenerated = true;
return(VariableInfo.Extract(variable, PackageId, ErrorCache));
}
public VariableRefRef GetVariableRefRef(string name, bool recursively, bool throwException)
{
VariableRef varRef = null;
Overlay overlay;
BasicBlock block;
if (recursively)
{
var overlayBlock = this.LocateVariableBlock(name, throwException);
if (overlayBlock == null)
{
Debug.Assert(!throwException);
return(null);
}
overlay = overlayBlock.Overlay;
block = overlayBlock.Block;
varRef = block.GetVariableDict(overlay)[name];
}
else
{
block = this.Block;
for (overlay = this.Overlay; overlay != null; overlay = overlay.ParentOverlay)
{
if (block.GetVariableDict(overlay).ContainsKey(name))
{
varRef = block.GetVariableDict(overlay)[name];
break;
}
}
if (varRef == null)
{
if (throwException)
{
throw new Exception($"Unexpected variable \"{name}\".");
}
else
{
return(null);
}
}
}
// important: copy the variableRef to this overlay
if (overlay != this.Overlay)
{
Debug.Assert(!(block.GetVariableDict(this.Overlay).ContainsKey(name)));
// make a shallow copy of this variableRef
var newRef = varRef.Clone() as VariableRef;
block.GetVariableDict(this.Overlay).Add(name, newRef);
overlay = this.Overlay;
//block = block;
varRef = newRef;
}
return(new VariableRefRef(varRef));
}
public VariableInfo LookupReferencedVariable(VariableRef variableRef)
{
if (!Scope.TryFindVariable(variableRef, out var variable))
{
ErrorCache.AddError($"Could not find variable: '{variableRef.ToFullName()}'");
return(null);
}
return(VariableInfo.Extract(variable, variableRef.PackageId, ErrorCache));
}
public virtual void Store(Variable variable)
{
var varRef = new VariableRef {
PackageId = variable.PackageId, VariableName = variable.Name
};
byFullName[varRef.ToFullName()] = variable;
byLocalName[variable.Name] = variable;
}
/// <summary>
/// Generates a delegate that wraps a scripted function and that could be invoked from the user code.
/// </summary>
/// <param name="function">The name of the function to be wrapped</param>
/// <param name="delegateType">The type of delegate to return</param>
/// <returns>A <see cref="Delegate"/> of the <paramref name="delegateType"/> type</returns>
/// <remarks>For the returned delegate to run properly, the ScriptEngine from which it has been created must be kept alive</remarks>
public Delegate GetDelegate(string function, Type delegateType)
{
var varRef = new VariableRef(function);
RuntimeServices.Interpreter = interpreter;
varRef.AcceptCompiler(interpreter);
return(interpreter.ReturnedValue.AsFunction.ToDelegate(delegateType));
}
private VariableInfo(Variable variable, VariableRef varRef)
{
if (variable.Name != varRef.VariableName)
{
throw new ArgumentException("Name of variable and reference don't match.");
}
Variable = variable;
Ref = varRef;
}
private async Task ExpectCount(VariableRef v, long c)
{
if (con == null)
{
throw new Exception("con == null");
}
long count = await con.HistorianCount(v, Timestamp.Empty, Timestamp.Max);
assert(count == c, $"count == {c}");
}
public void LookupReferencedAgeSettingUnsuccessfully()
{
var varRef = new VariableRef {
PackageId = TestPackageId, VariableName = "var.name"
};
var variableInfo = loader.LookupReferencedVariable(varRef);
variableInfo.Should().BeNull();
errorCache.ShouldContain($"Could not find variable: '{varRef.ToFullName()}'");
}
private TreeNode MapObjectInfo2TreeNode(ObjectInfo obj, List <ObjectInfo> siblings, Dictionary <ObjectRef, List <ObjectInfo> > map)
{
List <TreeNode> children = null;
if (map.ContainsKey(obj.ID))
{
var ch = map[obj.ID];
children = ch.Select(n => MapObjectInfo2TreeNode(n, ch, map)).ToList();
}
else
{
children = new List <TreeNode>();
}
var listVariables = new List <VariableVal>();
foreach (Variable v in obj.Variables)
{
var key = VariableRef.Make(obj.ID, v.Name);
VTQ vtq;
if (mapVariables.TryGetValue(key, out vtq))
{
listVariables.Add(new VariableVal()
{
Name = v.Name,
V = vtq.V,
T = vtq.T,
Q = vtq.Q
});
}
}
int count = 1;
int idx = 0;
if (obj.Parent.HasValue)
{
var p = obj.Parent.Value;
idx = p.Index;
string mem = p.Name;
count = siblings.Count(sib => sib.Parent.Value.Name == mem);
}
return(new TreeNode()
{
ID = obj.ID.ToString(),
ParentID = obj.Parent.HasValue ? obj.Parent.Value.Object.ToString() : "",
First = idx == 0,
Last = idx + 1 == count,
Name = obj.Name,
Type = obj.ClassName,
Children = children,
Variables = listVariables
});
}
public override async Task<ReqResult> OnUiRequestAsync(string command, DataValue parameters) {
switch (command) {
case "Read":
Console.Out.WriteLine("Parameters: " + parameters.ToString());
VTQ vtq = await Connection.ReadVariable(VariableRef.Make("IO", "A", "Value"));
return ReqResult.OK(vtq);
default:
return ReqResult.Bad("Unknown command: " + command);
}
}
private static VariableRef MakeVarRefFromAddress(string address, string moduleID)
{
try {
string[]? arr = StdJson.ObjectFromString <string[]>(address);
if (arr != null && arr.Length == 2 && arr[0].Length > 0 && arr[1].Length > 0)
{
return(VariableRef.Make(moduleID, arr[0], arr[1]));
}
}
catch (Exception) {}
return(VariableRef.Make(moduleID, address, "Value"));
}
public override async Task <VTQ[]> ReadDataItems(string group, IList <ReadRequest> items, Duration?timeout)
{
if (!await TryConnect() || connection == null)
{
return(GetBadVTQs(items));
}
var readHelper = new ReadManager <VariableRef, VariableValue>(items, readRequest => mapId2Info[readRequest.ID].VarRef);
List <VariableRef> dataItemsToRead = readHelper.GetRefsList();
try {
List <VariableValue> readResponse = await connection.ReadVariablesSyncIgnoreMissing(dataItemsToRead);
if (readResponse.Count == dataItemsToRead.Count)
{
readHelper.SetAllResults(readResponse, (vv, request) => vv.Value);
return(readHelper.values);
}
else
{
var badDataItems = new List <DataItem>();
for (int i = 0; i < dataItemsToRead.Count; ++i)
{
VariableRef v = dataItemsToRead[i];
try {
VariableValue value = readResponse.First(rr => rr.Variable == v);
readHelper.SetSingleResult(i, value.Value);
}
catch (Exception) { // not found
ReadRequest req = readHelper.GetReadRequest(i);
readHelper.SetSingleResult(i, VTQ.Make(req.LastValue.V, Timestamp.Now, Quality.Bad));
DataItem dataItem = mapId2Info[req.ID].Item;
badDataItems.Add(dataItem);
}
}
string[] dataItemNamesWithAddresss = badDataItems.Select(di => di.Name + ": " + di.Address).ToArray();
string details = string.Join("; ", dataItemNamesWithAddresss);
string msg = badDataItems.Count == 1 ? $"Invalid address for data item '{badDataItems[0].Name}': {badDataItems[0].Address}" : $"Invalid address for {badDataItems.Count} data items";
LogError("Invalid_Addr", msg, badDataItems.Select(di => di.ID).ToArray(), details);
return(readHelper.values);
}
}
catch (Exception exp) {
Exception e = exp.GetBaseException() ?? exp;
LogWarn("ReadExcept", $"Read exception: {e.Message}", details: e.ToString());
Task ignored = CloseConnection();
return(GetBadVTQs(items));
}
}
public static List <VariableRef> MakeTestData(int n)
{
List <VariableRef> res = new List <VariableRef>(n);
List <VariableRef> varRefs = MakeVarRefs();
for (int i = 0; i < n; ++i)
{
VariableRef varRef = varRefs[i % varRefs.Count];
res.Add(varRef);
}
return(res);
}
private async Task TestHistoryRaw(VariableRef v, Timestamp tStart, Timestamp tEnd, int maxValues, params VTQ[] expectedData)
{
Action <VTTQ[]> test = (vttqs) => {
assert(vttqs.Length == expectedData.Length, $"vttqs.Length == {expectedData.Length}");
for (int i = 0; i < vttqs.Length; ++i)
{
assert(vttqs[i].T == expectedData[i].T, $"vttqs[{i}].T == {expectedData[i].T}");
assert(vttqs[i].Q == expectedData[i].Q, $"vttqs[{i}].Q == {expectedData[i].Q}");
assert(vttqs[i].V == expectedData[i].V, $"vttqs[{i}].V == {expectedData[i].V}");
}
};
test(await con.HistorianReadRaw(v, tStart, tEnd, maxValues, BoundingMethod.TakeFirstN));
test(await con.HistorianReadRaw(v, tStart, tEnd, maxValues, BoundingMethod.TakeLastN));
}
public void LookupReferencedAgeSettingSuccessfully()
{
var varRef = new VariableRef {
PackageId = TestPackageId, VariableName = "var.name"
};
var existing = MakeSampleVariable(TestPackageId, varRef.VariableName);
loader.Scope.Store(existing);
var variableInfo = loader.LookupReferencedVariable(varRef);
variableInfo.Variable.Should().BeSameAs(existing);
variableInfo.Ref.PackageId.Should().Be(TestPackageId);
errorCache.ShouldHaveNoErrors();
}
public VariableInfo LookupGlobalDefaultSetting(string settingName)
{
var globalRef = new VariableRef
{
PackageId = Constants.PackageManagerIdentity,
VariableName = settingName
};
if (!Scope.TryFindVariable(globalRef, out var variable))
{
ErrorCache.AddError($"Could not find global default variable: '{globalRef.ToFullName()}'");
return(null);
}
return(VariableInfo.Extract(variable, globalRef.PackageId, ErrorCache));
}
//public void UpdateInputValues(VariableValue[] variables) {
// foreach (Config.Input input in Config.Inputs) {
// if (input.Variable.HasValue) {
// VariableRef va = input.Variable.Value;
// int idx = variables.FindIndex(v => v.Variable == va);
// if (idx > -1) {
// mapInputValues[input.ID] = variables[idx];
// }
// }
// }
//}
public void UpdateInputValues(List <VariableRef> variables, VTQs values)
{
foreach (Config.Input input in CalcConfig.Inputs)
{
if (input.Variable.HasValue)
{
VariableRef va = input.Variable.Value;
int idx = variables.FindIndex(v => v == va);
if (idx > -1)
{
mapInputValues[input.ID] = VariableValue.Make(va, values[idx]);
}
}
}
}
private static List <VariableRef> MakeVarRefs()
{
return(new List <VariableRef>()
{
VariableRef.Make("IO", "ObjectName1", "Value"),
VariableRef.Make("IO", "ObjectName2", "Value"),
VariableRef.Make("IO", "ObjectName3", "Value"),
//VariableRef.Make("IO", "INCTRL_WSBDN_FP_BB1_DENI_NOXC_FallbackSP", "Value"),
VariableRef.Make("CALC", "Signal_Object_Name1", "Value"),
VariableRef.Make("CALC", "Signal_Object_Name2", "Value"),
VariableRef.Make("CALC", "Signal_Object_Name3", "Value"),
//VariableRef.Make("CALC", "Signal_INCTRL_WSBDN_FP_BB1_DENI_NOXC_ymin_Min_PumpCapacity", "Value"),
VariableRef.Make("IO2", "ObjectName1", "Value1"),
VariableRef.Make("IO3", "ObjectName1", "Value2"),
//VariableRef.Make("IO4", "ObjectName1", "Value3"),
//VariableRef.Make("IO5", "ObjectName1", "Value4"),
//VariableRef.Make("IO6", "ObjectName1", "Value5"),
//VariableRef.Make("IO7", "ObjectName1", "Value6"),
//VariableRef.Make("IO8", "ObjectName1", "Value7"),
//VariableRef.Make("IO9", "ObjectName1", "Value8"),
// VariableRef.Make("IO2", "ObjectName1","Value9"),
//VariableRef.Make("IO3", "ObjectName1", "Value10"),
//VariableRef.Make("IO4", "ObjectName1", "Value11"),
//VariableRef.Make("IO5", "ObjectName1", "Value12"),
//VariableRef.Make("IO6", "ObjectName1", "Value13"),
//VariableRef.Make("IO7", "ObjectName1", "Value14"),
//VariableRef.Make("IO8", "ObjectName1", "Value15"),
//VariableRef.Make("IO9", "ObjectName1", "Value16"),
//VariableRef.Make("IO9", "ObjectName1", "Value17"),
//VariableRef.Make("IO9", "ObjectName1", "Value18"),
//VariableRef.Make("IO9", "ObjectName1", "Value19"),
//VariableRef.Make("IO9", "ObjectName1", "Value20"),
//VariableRef.Make("IO9", "ObjectName1", "Value21"),
//VariableRef.Make("IO9", "ObjectName1", "Value22"),
//VariableRef.Make("IO9", "ObjectName1", "Value23"),
//VariableRef.Make("IO9", "ObjectName1", "Value24"),
//VariableRef.Make("IO9", "ObjectName1", "Value25"),
//VariableRef.Make("IO9", "ObjectName1", "Value26"),
//VariableRef.Make("IO9", "ObjectName1", "Value27"),
//VariableRef.Make("IO9", "ObjectName1", "Value28"),
//VariableRef.Make("IO9", "ObjectName1", "Value29"),
//VariableRef.Make("IO9", "ObjectName1", "Value30"),
//VariableRef.Make("IO9", "ObjectName1", "Value31"),
//VariableRef.Make("IO9", "ObjectName1", "Value32"),
//VariableRef.Make("IO9", "ObjectName1", "Value33"),
});
}
public static List <VariableValue> MakeTestData(int n)
{
List <VTQ> vtqs = Test_VTQ.MakeTestData(n);
List <VariableValue> res = new List <VariableValue>(vtqs.Count);
List <VariableRef> varRefs = MakeVarRefs();
for (int i = 0; i < vtqs.Count; ++i)
{
VTQ vtq = vtqs[i];
VariableRef varRef = varRefs[i % varRefs.Count];
res.Add(VariableValue.Make(varRef, vtq));
}
return(res);
}
public void SetInitialOutputValues(Dictionary <VariableRef, VTQ> mapVarValues)
{
lastOutputValues.Clear();
foreach (Config.Output output in CalcConfig.Outputs)
{
VariableRef v = GetOutputVarRef(output.ID);
if (mapVarValues.ContainsKey(v))
{
VTQ value = mapVarValues[v];
lastOutputValues.Add(new OutputValue()
{
OutputID = output.ID,
Value = value
});
}
}
}
public void SetInitialStateValues(Dictionary <VariableRef, VTQ> mapVarValues)
{
lastStateValues.Clear();
foreach (Config.State state in CalcConfig.States)
{
VariableRef v = GetStateVarRef(state.ID);
if (mapVarValues.ContainsKey(v))
{
VTQ value = mapVarValues[v];
lastStateValues.Add(new StateValue()
{
StateID = state.ID,
Value = value.V
});
}
}
}
public override async Task <VTQ[]> ReadVariables(Origin origin, VariableRef[] variables, Duration?timeout)
{
VTQ[] result = new VTQ[variables.Length];
var adapter2Items = new Dictionary <AdapterState, List <ReadRequest> >();
for (int i = 0; i < variables.Length; ++i)
{
VariableRef vr = variables[i];
string id = vr.Object.LocalObjectID;
if (dataItemsState.ContainsKey(id) && vr.Name == VariableName)
{
ItemState itemState = dataItemsState[id];
AdapterState adapter = itemState.Adapter;
if (!adapter2Items.ContainsKey(adapter))
{
adapter2Items[adapter] = new List <ReadRequest>();
}
VTQ value = itemState.LastReadValue;
adapter2Items[adapter].Add(new ReadRequest(id, value));
}
else
{
result[i] = new VTQ(Timestamp.Empty, Quality.Bad, DataValue.Empty);
}
}
var allReadTasks = new List <Task <VTQ[]> >(adapter2Items.Count);
foreach (var adapterItems in adapter2Items)
{
AdapterState adapter = adapterItems.Key;
List <ReadRequest> requests = adapterItems.Value;
Task <VTQ[]> task = AdapterReadTask(adapter, requests, timeout);
allReadTasks.Add(task);
}
VTQ[][] resArr = await Task.WhenAll(allReadTasks);
VTQ[] res = resArr.SelectMany(x => x).ToArray();
return(res);
}
public override async Task <WriteDataItemsResult> WriteDataItems(string group, IList <DataItemValue> values, Duration?timeout)
{
if (!await TryConnect() || connection == null)
{
var failed = values.Select(div => new FailedDataItemWrite(div.ID, "No connection to server")).ToArray();
return(WriteDataItemsResult.Failure(failed));
}
var writeMan = new WriteManager <VariableValue, VariableError>(values, request => {
if (mapId2Info.ContainsKey(request.ID))
{
ItemInfo info = mapId2Info[request.ID];
return(VariableValue.Make(info.VarRef, request.Value));
}
else
{
throw new Exception("No Address defined");
}
});
try {
var dataItemsToWrite = writeMan.GetRefsList();
WriteResult res = await connection.WriteVariablesSyncIgnoreMissing(dataItemsToWrite, timeout);
if (!res.IsOK())
{
writeMan.AddWriteErrors(res.FailedVariables, failedVar => {
VariableRef v = failedVar.Variable;
int idx = dataItemsToWrite.FindIndexOrThrow(vv => vv.Variable == v);
string id = writeMan.GetWriteRequest(idx).ID;
return(new FailedDataItemWrite(id, failedVar.Error));
});
}
}
catch (Exception exp) {
Task ignored = CloseConnection();
Exception e = exp.GetBaseException() ?? exp;
string msg = $"Write exception: {e.Message}";
LogWarn("WriteExcept", msg, details: e.ToString());
var failed = values.Select(div => new FailedDataItemWrite(div.ID, msg)).ToArray();
return(WriteDataItemsResult.Failure(failed));
}
return(writeMan.GetWriteResult());
}
/// <summary>
/// Generates a method to make it easier to trigger this event.
/// </summary>
/// <returns>A <see cref="ClassMethod"/></returns>
/// <remarks>The so generated method is always private</remarks>
public ClassMethod CreateTriggerEventMethod()
{
var arguments = new Expression[Parameters.Length];
for (int i = 0; i < arguments.Length; ++i)
{
arguments[i] = new VariableRef(Parameters[i].Name);
}
var triggerEventFunc = new Function(Parameters,
new Block(new ForEachLoop(ForEachLoop.DEFAULT_KEY_NAME,
"handler",
PropertyRef.This(HandlerSetName),
new FunctionCall("handler", arguments)),
new Return()));
return(new ClassMethod(TriggerEventName, Scope.Private, Modifier, triggerEventFunc));
}
