@aryacode/dsh-engineering 0.4.22 → 0.6.0

package/vendor/optix/netlogic/pages/engineering-units.md

@@ -0,0 +1,298 @@
+# Engineering Units
+
+Engineering units are exposed through the `EngineeringUnits` property (`EUInformation`) on analog variables (or any variable where this property was added).
+
+When working with Engineering Units in FactoryTalk Optix, you can define custom units in an `EngineeringUnitDictionary` variable and reference them from the `EUInformation` of your variables. Alternatively, you can directly assign standard OPC UA engineering units by setting the appropriate `UnitId`.
+
+AnalogVariables are not required to have engineering units, but when they do, it allows clients to understand the physical meaning of the variable's value and display it accordingly.
+
+## EngineeringUnitDictionary
+
+### Create an EngineeringUnitDictionary
+
+The following example shows how to create (or overwrite) an `EngineeringUnitDictionary` variable in `Model` and add custom engineering units (including a `Percent` unit with `UnitId = 0`)
+
+```csharp
+using FTOptix.Core;
+using FTOptix.NetLogic;
+using UAManagedCore;
+
+public class DesignTimeNetLogic1 : BaseNetLogic
+{
+    [ExportMethod]
+    public void CreateCustomEngineeringUnitDictionary()
+    {
+        var model = Project.Current.Get("Model");
+        if (model == null)
+        {
+            Log.Warning("DesignTimeNetLogic1", "Model folder not found");
+            return;
+        }
+
+        const string dictionaryName = "EngineeringUnitDictionary1";
+
+        // Recreate the dictionary to keep this example deterministic.
+        var existingDictionary = model.GetVariable(dictionaryName);
+        existingDictionary?.Delete();
+
+        var dictionary = InformationModel.MakeVariable(
+            dictionaryName,
+            FTOptix.Core.DataTypes.EngineeringUnitDictionaryItem,
+            FTOptix.Core.VariableTypes.EngineeringUnitDictionary,
+            new uint[] { 0 });
+
+        // UnitId values are project-defined for custom units.
+        // Percent example: UnitId = 0.
+        // Use LocalizedText(text, localeId) to populate Text/LocaleId.
+        // LocalizedText("...") alone sets TextId, not Text.
+        var units = new EngineeringUnitDictionaryItem[]
+        {
+            new EngineeringUnitDictionaryItem
+            {
+                UnitId = 0,
+                DisplayName = new LocalizedText("%", "en-US"),
+                Description = new LocalizedText("Percentage", "en-US"),
+                PhysicalDimension = PhysicalDimension.None,
+                Slope = 0.0,
+                Intercept = 0.0
+            },
+            new EngineeringUnitDictionaryItem
+            {
+                UnitId = 10,
+                DisplayName = new LocalizedText("bpm", "en-US"),
+                Description = new LocalizedText("Beats per minute", "en-US"),
+                PhysicalDimension = PhysicalDimension.Frequency,
+                Slope = 60.0,
+                Intercept = 0.0
+            }
+        };
+
+        dictionary.Value = units;
+        model.Add(dictionary);
+
+        Log.Info("DesignTimeNetLogic1", $"Created {dictionaryName} with {units.Length} custom units");
+    }
+```
+
+### Read an EngineeringUnitDictionary
+
+```csharp
+using FTOptix.Core;
+using FTOptix.NetLogic;
+using UAManagedCore;
+
+public class DesignTimeNetLogic1 : BaseNetLogic
+{
+    [ExportMethod]
+    public void PrintCustomEngineeringUnitDictionary()
+    {
+        var dictionary = Project.Current.GetVariable("Model/EngineeringUnitDictionary1");
+        if (dictionary == null)
+        {
+            Log.Warning("DesignTimeNetLogic1", "EngineeringUnitDictionary1 not found");
+            return;
+        }
+
+        if (dictionary.Value.Value is EngineeringUnitDictionaryItem[] typedUnits)
+        {
+            foreach (var unit in typedUnits)
+            {
+                Log.Info(
+                    "DesignTimeNetLogic1",
+                    $"UnitId={unit.UnitId}, DisplayName={unit.DisplayName}, Description={unit.Description}, " +
+                    $"PhysicalDimension={unit.PhysicalDimension}, Slope={unit.Slope}, Intercept={unit.Intercept}");
+            }
+
+            return;
+        }
+
+        // Fallback in case runtime returns a raw Struct array.
+        if (dictionary.Value.Value is Struct[] rawUnits)
+        {
+            foreach (var rawUnit in rawUnits)
+            {
+                var values = rawUnit.Values;
+                if (values == null || values.Count < 6)
+                    continue;
+
+                Log.Info(
+                    "DesignTimeNetLogic1",
+                    $"UnitId={values[0]}, DisplayName={values[1]}, Description={values[2]}, " +
+                    $"PhysicalDimension={values[3]}, Slope={values[4]}, Intercept={values[5]}");
+            }
+
+            return;
+        }
+
+        Log.Warning("DesignTimeNetLogic1", "Engineering unit dictionary has an unexpected value format");
+    }
+}
+```
+
+## EngineeringUnit
+
+### Read engineering units of a variable
+
+The `EngineeringUnits` node can be retrieved from an `AnalogItem` (or from a variable that contains this property) and inspected through `EUInformation` fields such as `UnitId`, `NamespaceIndex`, `DisplayName`, and `Description`.
+
+```csharp
+using FTOptix.Core;
+using FTOptix.NetLogic;
+using UAManagedCore;
+
+public class RuntimeNetLogic1 : BaseNetLogic
+{
+    [ExportMethod]
+    public void GetEUInfoDisplayName()
+    {
+        var analogVariable = Project.Current.GetVariable("Model/Object1/AnalogVariable1");
+        if (analogVariable == null)
+        {
+            Log.Warning("RuntimeNetLogic1", "Variable not found");
+            return;
+        }
+
+        var euInfo = analogVariable.Get<EUInformation>("EngineeringUnits");
+        if (euInfo == null)
+        {
+            Log.Warning("RuntimeNetLogic1", "EngineeringUnits property not found");
+            return;
+        }
+
+        var translation = InformationModel.LookupTranslation(euInfo.DisplayName);
+        Log.Info("RuntimeNetLogic1", $"EU DisplayName: {translation.Text}");
+    }
+}
+```
+
+### Assign engineering units to a variable
+
+The engineering unit follows the OPC UA model and is identified by a `UnitId`.
+
+#### Standard engineering units
+
+Reference: [OPC UA Engineering Units specification](https://reference.opcfoundation.org/Core/Part8/v104/docs/5.6.3)
+
+> [!WARNING]
+> - It is mandatory to set `UnitId` when generating or updating `EUInformation`.
+> - Not all `UnitId` from the OPC UA specification are mapped into FactoryTalk Optix
+
+For standard OPC UA units, set `UnitId` only.
+
+Example below assigns **degree Celsius** (`UnitId = 4408652` from OPC UA Part 8):
+
+```csharp
+using FTOptix.Core;
+using FTOptix.NetLogic;
+using UAManagedCore;
+using OpcUa = UAManagedCore.OpcUa;
+
+public class DesignTimeNetLogic1 : BaseNetLogic
+{
+    [ExportMethod]
+    public void AssignCelsiusUnit()
+    {
+        var targetVariable = Project.Current.GetVariable("Model/AnalogVariable1");
+        if (targetVariable == null)
+        {
+            Log.Info("DesignTimeNetLogic1", "Target variable not found");
+            return;
+        }
+
+        const int celsiusUnitId = 4408652;
+        SetStandardEngineeringUnitById(targetVariable, celsiusUnitId);
+        Log.Info("DesignTimeNetLogic1", $"Assigned Celsius (UnitId={celsiusUnitId}) to {targetVariable.BrowseName}");
+    }
+
+    private void SetStandardEngineeringUnitById(IUAVariable targetVariable, int euId)
+    {
+        var euInfo = targetVariable.GetVariable("EngineeringUnits");
+        if (euInfo == null)
+        {
+            euInfo = InformationModel.MakeVariable<EUInformation>("EngineeringUnits", OpcUa.DataTypes.EUInformation);
+            euInfo.QualifiedBrowseName = new QualifiedName(0, "EngineeringUnits");
+            euInfo.ModellingRule = NamingRuleType.Mandatory;
+            euInfo.SetModellingRuleRecursive();
+            targetVariable.Refs.AddReference(OpcUa.ReferenceTypes.HasProperty, euInfo);
+        }
+
+        euInfo.GetVariable("UnitId").Value = euId;
+
+        // NamespaceIndex is not required for standard OPC UA units.
+        var namespaceIndexVariable = euInfo.GetVariable("NamespaceIndex");
+        namespaceIndexVariable?.Delete();
+
+        if (euInfo.ModellingRule != NamingRuleType.Mandatory)
+        {
+            euInfo.ModellingRule = NamingRuleType.Mandatory;
+            euInfo.SetModellingRuleRecursive();
+        }
+    }
+}
+```
+
+#### Custom engineering units from an EngineeringUnitDictionary
+
+For custom units defined in an `EngineeringUnitDictionary`, set:
+
+1. `UnitId` (the custom ID in your dictionary item)
+2. `NamespaceIndex` (the namespace index of the dictionary variable)
+
+If `NamespaceIndex` is missing, custom units may not resolve correctly.
+
+Example below assigns a custom unit called **Percent** (`UnitId = 0`) from `EngineeringUnitDictionary1`:
+
+```csharp
+using FTOptix.Core;
+using FTOptix.NetLogic;
+using UAManagedCore;
+using OpcUa = UAManagedCore.OpcUa;
+
+public class DesignTimeNetLogic1 : BaseNetLogic
+{
+    [ExportMethod]
+    public void AssignPercentUnit()
+    {
+        // This method assumes a custom unit, called "Percent" with UnitId=0 is defined in the EngineeringUnitDictionary. The dictionary should have the same NamespaceIndex of the project
+
+        var targetVariable = Project.Current.GetVariable("Model/AnalogVariable1");
+        if (targetVariable == null)
+        {
+            Log.Info("DesignTimeNetLogic1", "Target variable not found");
+            return;
+        }
+
+        var euDictionary = Project.Current.GetVariable("Model/EngineeringUnitDictionary1");
+        var customNamespaceIndex = euDictionary?.NodeId.NamespaceIndex ?? targetVariable.NodeId.NamespaceIndex;
+
+        // Here is where the UnitId should be passed as an argument,
+        // UnitId is displayed in the IDE after opening the custom EngineeringUnitDictionary
+        SetEngineeringUnitById(targetVariable, 0u, true, customNamespaceIndex);
+        Log.Info("DesignTimeNetLogic1", $"Assigned UnitId=0 to {targetVariable.BrowseName} (NamespaceIndex={customNamespaceIndex})");
+    }
+
+    private void SetEngineeringUnitById(IUAVariable targetVariable, uint euId, bool isCustomEngineeringUnit, int customNamespaceIndex)
+    {
+        var euInfo = targetVariable.GetVariable("EngineeringUnits");
+        if (euInfo == null)
+        {
+            euInfo = InformationModel.MakeVariable<EUInformation>("EngineeringUnits", OpcUa.DataTypes.EUInformation);
+            euInfo.QualifiedBrowseName = new QualifiedName(0, "EngineeringUnits");
+            euInfo.ModellingRule = NamingRuleType.Mandatory;
+            euInfo.SetModellingRuleRecursive();
+            targetVariable.Refs.AddReference(OpcUa.ReferenceTypes.HasProperty, euInfo);
+        }
+
+        euInfo.GetVariable("UnitId").Value = (int)euId;
+
+        if (isCustomEngineeringUnit)
+            euInfo.GetOrCreateVariable("NamespaceIndex").Value = customNamespaceIndex;
+
+        if (euInfo.ModellingRule != NamingRuleType.Mandatory)
+        {
+            euInfo.ModellingRule = NamingRuleType.Mandatory;
+            euInfo.SetModellingRuleRecursive();
+        }
+    }
+}
+```

package/vendor/optix/netlogic/pages/events.md

@@ -0,0 +1,340 @@
+# Events handling
+
+> [!WARNING]
+> This section is a work in progress and uses some low-level APIs.
+> The documentation will be completed as soon as possible.
+
+> [!NOTE]
+> It is recommended to add events to the InformationModel at design time, and then trigger them at runtime, instead of creating and dispatching events fully at runtime.
+
+## Add MouseClick event to a Button
+
+This code adds a GeneratePDF method to a button, and a SetVariableValue to a different button
+
+```csharp
+#region Using directives
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UAManagedCore;
+using OpcUa = UAManagedCore.OpcUa;
+using FTOptix.HMIProject;
+using FTOptix.UI;
+using FTOptix.Core;
+using FTOptix.CoreBase;
+using FTOptix.NetLogic;
+#endregion
+
+public class DesignTimeNetLogic1 : BaseNetLogic
+{
+    [ExportMethod]
+    public void CreateEventHandlers()
+    {
+        var mainWindow = Project.Current.Get<WindowType>("UI/MainWindow");
+        var generateReportButton = mainWindow.Get<Button>("GenerateReportButton");
+        var changeColorButton = mainWindow.Get<Button>("ChangeColorButton");
+        var button1 = mainWindow.Get<Button>("Button1");
+        var button1BackgroundColor = button1.BackgroundColorVariable;
+
+        // Make sure to remove old handlers (if any)
+        var oldEventHandlers = generateReportButton.Children.OfType<FTOptix.CoreBase.EventHandler>().ToList();
+        oldEventHandlers.AddRange(changeColorButton.Children.OfType<FTOptix.CoreBase.EventHandler>());
+        foreach (var oldEventHandler in oldEventHandlers)
+            oldEventHandler.Delete();
+
+        // Report object that we want to create with a button
+        var report1 = Project.Current.GetObject("Reports/Report1");
+
+        MakeEventHandler( // Add the GeneratePdf method to the button
+            generateReportButton, // Object where to create the method
+            FTOptix.UI.ObjectTypes.MouseClickEvent, // Method to be created
+            report1, // Object pointer where to call the method
+            "GeneratePdf", // Method name
+            new List<Tuple<string, NodeId, object>> // Method arguments
+            {
+                // Each row is a tuple, each tuple contains a string (name of the argument), a NodeId (DataType) and an Object (value)
+                new("OutputPath", FTOptix.Core.DataTypes.ResourceUri, (string)ResourceUri.FromApplicationRelativePath("MyReport.pdf")),
+                new("LocaleId", OpcUa.DataTypes.String, "en-US")
+            }
+        );
+        
+        MakeEventHandler( // Add the SetVariableValue method to the button
+            changeColorButton, // Object where to create the method
+            FTOptix.UI.ObjectTypes.MouseClickEvent, // Event to be added
+            InformationModel.GetObject(FTOptix.CoreBase.Objects.VariableCommands), // Object that exposes the method
+            "Set", // Name of the method
+            new List<Tuple<string, NodeId, object>> // Method arguments
+            {
+                // Each row is a tuple, each tuple contains a string (name of the argument), a NodeId (DataType) and an Object (value)
+                new("VariableToModify", FTOptix.Core.DataTypes.VariablePointer, NodeId.Empty),
+                new("Value", FTOptix.Core.DataTypes.Color, new Color(0xff3480ebu).ARGB),
+                new("ArrayIndex", OpcUa.DataTypes.UInt32, 0u)
+            }
+        );
+
+        // Set which variable to be modified by the Set method
+        var changeColorButtonEventHandler = changeColorButton.Get("EventHandler");
+        // This path can be different depending on the MethodContainer name assigned by the MakeEventHandler method
+        var variableToModifyArgumentVariable = changeColorButtonEventHandler.GetVariable("MethodsToCall/MethodContainer1/InputArguments/VariableToModify");
+        // Assign a DynamicLink to the VariableToModify
+        variableToModifyArgumentVariable.SetDynamicLink(button1BackgroundColor);
+        // Change the DynamicLink to make sure the NodeId attribute is used (IDE has a fallback to the @Value otherwise)
+        var dynamicLink = variableToModifyArgumentVariable.Children.OfType<DynamicLink>().First();
+        dynamicLink.Value = dynamicLink.Value + "@NodeId";
+    }
+
+    private FTOptix.CoreBase.EventHandler MakeEventHandler(
+        IUANode parentNode, // The parent node to which the event handler is to be added
+        NodeId listenEventTypeId, // The NodeID of the event to be listened
+        IUAObject callingObject, // The object on which the method is to be called
+        string methodName, // The name of the method to be called
+        List<Tuple<string, NodeId, object>> arguments = null // List of input arguments (name, data type NodeID, value)
+    )
+    {
+        // Create event handler object
+        var eventHandler = InformationModel.MakeObject<FTOptix.CoreBase.EventHandler>("EventHandler");
+        parentNode.Add(eventHandler);
+
+        // Set the ListenEventType variable value to the Node ID of the event to be listened
+        eventHandler.ListenEventType = listenEventTypeId;
+
+        // Create method container
+        // This must be an unique name if the multiple methods are added to the same button. A random name can also be used
+        var methodIndex = eventHandler.MethodsToCall.Any() ? eventHandler.MethodsToCall.Count + 1 : 1;
+        var methodContainer = InformationModel.MakeObject($"MethodContainer{methodIndex}");
+        eventHandler.MethodsToCall.Add(methodContainer);
+
+        // Create the ObjectPointer variable and set its value to the object on which the method is to be called
+        var objectPointerVariable = InformationModel.MakeVariable<NodePointer>("ObjectPointer", OpcUa.DataTypes.NodeId);
+        objectPointerVariable.Value = callingObject.NodeId;
+        methodContainer.Add(objectPointerVariable);
+
+        // Create the Method variable and set its value to the name of the method to be called
+        var methodNameVariable = InformationModel.MakeVariable("Method", OpcUa.DataTypes.String);
+        methodNameVariable.Value = methodName;
+        methodContainer.Add(methodNameVariable);
+
+        if (arguments != null)
+            CreateInputArguments(methodContainer, arguments);
+
+        return eventHandler;
+    }
+
+    private void CreateInputArguments(
+        IUANode methodContainer,
+        List<Tuple<string, NodeId, object>> arguments)
+    {
+        IUAObject inputArguments = InformationModel.MakeObject("InputArguments");
+        methodContainer.Add(inputArguments);
+
+        foreach (var arg in arguments)
+        {
+            var argumentVariable = inputArguments.Context.NodeFactory.MakeVariable(
+                NodeId.Random(inputArguments.NodeId.NamespaceIndex),
+                arg.Item1,
+                arg.Item2,
+                OpcUa.VariableTypes.BaseDataVariableType,
+                false,
+                arg.Item3);
+
+            inputArguments.Add(argumentVariable);
+        }
+    }
+}
+
+```
+
+## Add a method handler to an object
+
+```csharp
+#region Using directives
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FTOptix.Core;
+using FTOptix.CoreBase;
+using FTOptix.HMIProject;
+using FTOptix.NetLogic;
+using UAManagedCore;
+using OpcUa = UAManagedCore.OpcUa;
+
+#endregion
+
+public class CreateEventHandler : BaseNetLogic
+{
+    private FTOptix.CoreBase.EventHandler MakeEventHandler(
+       IUANode parentNode, // The parent node to which the event handler is to be added
+       NodeId listenEventTypeId, // The NodeID of the event to be listened
+       IUAObject callingObject, // The object on which the method is to be called
+       string methodName, // The name of the method to be called
+       List<Tuple<string, NodeId, object>> arguments = null // List of input arguments (name, data type NodeID, value)
+    )
+
+    {
+        // Create event handler object
+        var eventHandler = InformationModel.MakeObject<FTOptix.CoreBase.EventHandler>("EventHandler");
+        parentNode.Add(eventHandler);
+
+        // Set the ListenEventType variable value to the Node ID of the event to be listened
+        eventHandler.ListenEventType = listenEventTypeId;
+
+        // Create method container
+        var methodContainer = InformationModel.MakeObject("MethodContainer1");
+        eventHandler.MethodsToCall.Add(methodContainer);
+
+        // Create the ObjectPointer variable and set its value to the object on which the method is to be called
+        var objectPointerVariable = InformationModel.MakeVariable<NodePointer>("ObjectPointer", OpcUa.DataTypes.NodeId);
+        objectPointerVariable.Value = callingObject.NodeId;
+        string resultPath = CreateRelativePath(parentNode, callingObject);
+        var isCore = resultPath.Contains("Root");
+        if (!isCore)
+        {
+            IUAVariable temp = null;
+            objectPointerVariable.SetDynamicLink(temp, DynamicLinkMode.ReadWrite);
+            var dynamicLinkVar = objectPointerVariable.Refs.GetVariable(FTOptix.CoreBase.ReferenceTypes.HasDynamicLink) as IUAVariable;
+            if (dynamicLinkVar != null)
+            {
+                dynamicLinkVar.Value = "../../../../" + resultPath;
+            }
+        }
+
+        methodContainer.Add(objectPointerVariable);
+
+        // Create the Method variable and set its value to the name of the method to be called
+        var methodNameVariable = InformationModel.MakeVariable("Method", OpcUa.DataTypes.String);
+        methodNameVariable.Value = methodName;
+        methodContainer.Add(methodNameVariable);
+
+        if (arguments != null)
+            CreateInputArguments(methodContainer, arguments);
+
+        return eventHandler;
+    }
+
+    private void CreateInputArguments(
+        IUANode methodContainer,
+        List<Tuple<string, NodeId, object>> arguments)
+    {
+        IUAObject inputArguments = InformationModel.MakeObject("InputArguments");
+        methodContainer.Add(inputArguments);
+
+        foreach (var arg in arguments)
+        {
+            var argumentVariable = inputArguments.Context.NodeFactory.MakeVariable(
+                NodeId.Random(inputArguments.NodeId.NamespaceIndex),
+                arg.Item1,
+                arg.Item2,
+                OpcUa.VariableTypes.BaseDataVariableType,
+                false,
+                arg.Item3);
+
+            inputArguments.Add(argumentVariable);
+        }
+    }
+
+    private static string CreateRelativePath(IUANode source, IUANode target)
+    {
+        string result = "";
+        var srcPath = GetCurrentProjectBrowsePath(source);
+        var tarPath = GetCurrentProjectBrowsePath(target);
+        var srcArr = srcPath.Split("/");
+        var tarArr = tarPath.Split("/");
+        var max = Math.Max(srcPath.Count(), tarPath.Count());
+        int i = 0;
+        for (; i < max; i++)
+        {
+            result = "..";
+            if (srcArr[i] != tarArr[i])
+            {
+                break;
+            }
+        }
+        for (int j = srcArr.Count() - 1; j > i; j--)
+        {
+            result = result + "/..";
+        }
+        for (int k = i; k < tarArr.Count(); k++)
+        {
+            result = result + "/" + tarArr[k];
+        }
+        return result;
+    }
+
+    private static string GetCurrentProjectBrowsePath(IUANode node)
+    {
+        if (node.Owner == Project.Current || node.BrowseName == "Root")
+            return node.BrowseName;
+        return GetCurrentProjectBrowsePath(node.Owner) + "/" + node.BrowseName;
+    }
+}
+```
+
+## Subscribe to OPCUA methods
+
+This script can be put anywhere on the project and will listen to every OPCUA method being called (script or UI)
+
+> [!NOTE]
+> In FactoryTalk Optix, any method is mapped to an OPCUA method, so even when calling a NetLogic method, or a core command, this script will intercept the call.
+
+```csharp
+public class OpcMethodsAuditLogic : BaseNetLogic, IUAEventObserver
+{
+    public override void Start()
+    {
+        var serverObject = LogicObject.Context.GetObject(OpcUa.Objects.Server);
+        //eventRegistration = serverObject.RegisterUAEventObserver(this, UAManagedCore.OpcUa.ObjectTypes.AuditUpdateMethodEventType);
+    }
+
+    public override void Stop()
+    {
+        // Insert code to be run when the user-defined logic is stopped
+    }
+
+    public void OnEvent(IUAObject eventNotifier, IUAObjectType eventType, IReadOnlyList<object> eventData, ulong senderId)
+    {
+        StringBuilder builder = new StringBuilder();
+        builder.Append($"Event of type {eventType.BrowseName} triggered");
+
+        var eventArguments = eventType.EventArguments;
+        foreach (var eventField in eventArguments.GetFields())
+        {
+            var fieldValue = eventArguments.GetFieldValue(eventData, eventField);
+            builder.Append($"\t{eventField} = {fieldValue?.ToString() ?? "null"}");
+        }
+
+        builder.Append("\n");
+        Log.Info(builder.ToString());
+    }
+
+  //  private IEventRegistration eventRegistration;
+}
+```
+
+## Add a VariableChanged event to a variable
+
+> [!WARNING]
+> This method can only work at DesignTime
+
+```csharp
+[ExportMethod]
+public void AddVariableChangeEvent()
+{
+    IUAVariable targetVariable = null;
+    try
+    {
+        targetVariable = InformationModel.GetVariable(LogicObject.GetVariable("VariableToAddChangeMethod").Value);
+    }
+    catch
+    {
+        Log.Error("Variable not found");
+        return;
+    }
+
+    var variableOwner = targetVariable.Owner;
+    var variableChangedEventDispatcher = InformationModel.Make<VariableChangedEventDispatcher>($"{targetVariable.BrowseName}Changed");
+    variableChangedEventDispatcher.GetVariable("VariableNodePath").Value = $"../{targetVariable.BrowseName}";
+
+    variableOwner.Add(variableChangedEventDispatcher);
+}
+```