Custom Node Development

public override Task InitAsync()
{
    Output = Value;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    Output = Value;
    return Task.CompletedTask;
}

public override Task InitAsync()
{
    Value = 0;
    Error = false;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    if (Math.Abs(RawMax - RawMin) < 0.000001)
    {
        Error = true;
        return Task.CompletedTask;
    }
 
    Error = false;
    Value = Math.Round((RawValue - RawMin) * (EngMax - EngMin) / (RawMax - RawMin) + EngMin, 3);
    return Task.CompletedTask;
}

public override Task InitAsync()
{
    Allowed = false;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    Allowed = AutoMode && !EmergencyStop && PressureOk && !Fault;
    return Task.CompletedTask;
}

private bool _active;
 
public override Task InitAsync()
{
    _active = false;
    Alarm = false;
    RisingEdge = false;
    FallingEdge = false;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    var previous = _active;
 
    if (!_active && PV >= HighLimit)
    {
        _active = true;
    }
    else if (_active && PV <= HighLimit - Math.Abs(Hysteresis))
    {
        _active = false;
    }
 
    Alarm = _active;
    RisingEdge = !previous && _active;
    FallingEdge = previous && !_active;
    return Task.CompletedTask;
}

public override Task InitAsync()
{
    Output = 0;
    Source = "Auto";
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    Output = UseManual ? ManualValue : AutoValue;
    Source = UseManual ? "Manual" : "Auto";
    return Task.CompletedTask;
}

public override Task InitAsync()
{
    Message = string.Empty;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    var unit = string.IsNullOrWhiteSpace(Unit) ? string.Empty : $" {Unit}";
    Message = $"{DeviceName}.{VariableName} = {ValueText}{unit}";
    return Task.CompletedTask;
}

public override Task InitAsync()
{
    Value = 0;
    Success = false;
    ErrorMessage = string.Empty;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    if (double.TryParse(InputText, out var number))
    {
        Value = number;
        Success = true;
        ErrorMessage = string.Empty;
    }
    else
    {
        Success = false;
        ErrorMessage = $"Cannot convert to number: {InputText}";
    }
 
    return Task.CompletedTask;
}

private bool _lastIncrement;
private int _count;
 
public override Task InitAsync()
{
    _lastIncrement = false;
    _count = 0;
    Count = 0;
    Overflow = false;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    if (Reset)
    {
        _count = 0;
    }
    else if (Increment && !_lastIncrement)
    {
        _count++;
    }
 
    _lastIncrement = Increment;
    Overflow = MaxValue > 0 && _count >= MaxValue;
    Count = Overflow && MaxValue > 0 ? MaxValue : _count;
    return Task.CompletedTask;
}

private bool _previous;
 
public override Task InitAsync()
{
    _previous = Input;
    Rising = false;
    Falling = false;
    Changed = false;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    Rising = Input && !_previous;
    Falling = !Input && _previous;
    Changed = Input != _previous;
    _previous = Input;
    return Task.CompletedTask;
}

private readonly Queue<double> _samples = new();
 
public override Task InitAsync()
{
    _samples.Clear();
    Average = 0;
    SampleCount = 0;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    var size = Math.Max(1, WindowSize);
    _samples.Enqueue(Input);
 
    while (_samples.Count > size)
    {
        _samples.Dequeue();
    }
 
    SampleCount = _samples.Count;
    Average = Math.Round(_samples.Average(), 3);
    return Task.CompletedTask;
}

private double _lastValue;
private DateTime _lastTime;
 
public override Task InitAsync()
{
    _lastValue = Input;
    _lastTime = DateTime.UtcNow;
    Changed = false;
    Delta = 0;
    RatePerSecond = 0;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    var now = DateTime.UtcNow;
    var seconds = Math.Max(0.001, (now - _lastTime).TotalSeconds);
    var delta = Input - _lastValue;
 
    Delta = Math.Round(delta, 3);
    RatePerSecond = Math.Round(delta / seconds, 3);
    Changed = Math.Abs(delta) >= Math.Abs(Threshold);
 
    _lastValue = Input;
    _lastTime = now;
    return Task.CompletedTask;
}

private double _held;
 
public override Task InitAsync()
{
    _held = Input;
    Output = Input;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    if (Sample)
    {
        _held = Input;
    }
 
    Output = Hold ? _held : Input;
    return Task.CompletedTask;
}

public override Task InitAsync()
{
    SinValue = 0;
    CosValue = 1;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    var radians = UseDegrees ? Angle * Math.PI / 180.0 : Angle;
    SinValue = Math.Round(Math.Sin(radians), 6);
    CosValue = Math.Round(Math.Cos(radians), 6);
    return Task.CompletedTask;
}

public override Task InitAsync()
{
    Json = string.Empty;
    HasData = false;
    return Task.CompletedTask;
}
 
public override Task ChangedAsync()
{
    HasData = InputData != null;
    Json = InputData == null ? string.Empty : InputData.ToSystemTextJsonString();
    return Task.CompletedTask;
}

using System;
using System.ComponentModel;
using System.Text.Json;
using System.Threading.Tasks;
using TGateway.Application;
 
/// <summary>将匹配变量的冻结快照交给规则调度器消费。</summary>
[Category("触发器")]
[RuleNode("manual.variable-notification")]
public sealed class SimpleVariableNotifyNode : CustomExpressionBase, IDisposable
{
    /// <summary>用于节点库显示，不参与类型身份匹配。</summary>
    public override string Name => "变量变化触发";
 
    /// <summary>限定通知设备，空字符串表示不限制。</summary>
    [ExpressionInput]
    public string DeviceName { get; set; } = string.Empty;
 
    /// <summary>限定变量名称，空字符串表示不限制。</summary>
    [ExpressionInput]
    public string VariableName { get; set; } = string.Empty;
 
    /// <summary>保存与运行时对象解耦的值快照。</summary>
    private JsonElement _value;
 
    /// <summary>发布当前值状态，相同已提交值不重复传播。</summary>
    [ExpressionOutput]
    public JsonElement Value
    {
        get => _value;
        private set => SetOutput(ref _value, value);
    }
 
    /// <summary>保存本次完整变量快照。</summary>
    private JsonElement _data;
 
    /// <summary>每次匹配通知都发布一次完整快照事件。</summary>
    [ExpressionOutput(IsEvent = true)]
    public JsonElement Data
    {
        get => _data;
        private set => SetOutput(ref _data, value);
    }
 
    /// <summary>流程初始化时订阅，初始化阶段不生成虚假通知。</summary>
    public override Task InitAsync()
    {
        GlobalData.VariableValueChangeEvent += OnVariableChanged;
        return Task.CompletedTask;
    }
 
    /// <summary>在广播入口固定本次数据，不在广播线程传播规则输出。</summary>
    private void OnVariableChanged(VariableRuntime runtime, VariableUpdateSource source)
    {
        if (!runtime.IsOnline ||
            (!string.IsNullOrWhiteSpace(DeviceName) && runtime.DeviceName != DeviceName) ||
            (!string.IsNullOrWhiteSpace(VariableName) && runtime.Name != VariableName))
            return;
        var data = runtime.AdaptVariableBasicData();
        data.UpdateSource = source;
        var snapshot = JsonSerializer.SerializeToElement(data);
        var value = JsonSerializer.SerializeToElement(data.Value);
        EnqueueNotification(() =>
        {
            Data = snapshot;
            Value = value;
        }, nameof(Data));
    }
 
    /// <summary>通知源没有需要在输入变化时重复执行的业务。</summary>
    public override Task ChangedAsync() => Task.CompletedTask;
 
    /// <summary>流程停止后解除全局订阅，防止保留旧实例。</summary>
    public void Dispose()
    {
        GlobalData.VariableValueChangeEvent -= OnVariableChanged;
    }
}

using System;
using System.ComponentModel;
using System.Text.Json;
using System.Threading.Tasks;
using TGateway.Application;
 
/// <summary>将指定级别与设备的报警快照发布为事件。</summary>
[Category("触发器")]
[RuleNode("manual.alarm-notification")]
public sealed class SimpleAlarmNotifyNode : CustomExpressionBase, IDisposable
{
    /// <summary>节点库显示名称。</summary>
    public override string Name => "报警变化触发";
 
    /// <summary>最低允许报警级别。</summary>
    [ExpressionInput]
    public int MinLevel { get; set; } = 0;
 
    /// <summary>限定设备名称，空字符串表示不限制。</summary>
    [ExpressionInput]
    public string DeviceName { get; set; } = string.Empty;
 
    /// <summary>保存与广播对象解耦的报警快照。</summary>
    private JsonElement _alarm;
 
    /// <summary>每次匹配报警发布一个 JSON 事件。</summary>
    [ExpressionOutput(IsEvent = true)]
    public JsonElement Alarm
    {
        get => _alarm;
        private set => SetOutput(ref _alarm, value);
    }
 
    /// <summary>保存报警摘要。</summary>
    private string _text = string.Empty;
 
    /// <summary>发布最近报警的可读摘要状态。</summary>
    [ExpressionOutput]
    public string Text
    {
        get => _text;
        private set => SetOutput(ref _text, value);
    }
 
    /// <summary>在流程初始化时建立报警订阅。</summary>
    public override Task InitAsync()
    {
        GlobalData.AlarmChangedEvent += OnAlarmChanged;
        return Task.CompletedTask;
    }
 
    /// <summary>冻结载荷后入队，避免广播对象后续修改影响当前事件。</summary>
    private void OnAlarmChanged(AlarmVariable alarm)
    {
        if (alarm.AlarmLevel < MinLevel)
        {
            return;
        }
 
        if (!string.IsNullOrWhiteSpace(DeviceName) && alarm.DeviceName != DeviceName)
        {
            return;
        }
 
        var snapshot = JsonSerializer.SerializeToElement(alarm);
        var text = $"{alarm.DeviceName}.{alarm.Name} {alarm.EventType} {alarm.AlarmText}";
        EnqueueNotification(() =>
        {
            Alarm = snapshot;
            Text = text;
        }, nameof(Alarm));
    }
 
    /// <summary>只由报警订阅发布业务输出。</summary>
    public override Task ChangedAsync() => Task.CompletedTask;
 
    /// <summary>释放流程实例持有的全局事件订阅。</summary>
    public void Dispose()
    {
        GlobalData.AlarmChangedEvent -= OnAlarmChanged;
    }
}

using System;
using System.ComponentModel;
using System.Text.Json;
using System.Threading.Tasks;
using TGateway.Application;
 
/// <summary>将设备状态快照交给规则的事件接收端。</summary>
[Category("触发器")]
[RuleNode("manual.device-notification")]
public sealed class SimpleDeviceStatusNode : CustomExpressionBase, IDisposable
{
    /// <summary>节点库显示名称。</summary>
    public override string Name => "设备状态触发";
 
    /// <summary>限定设备名称，空字符串表示不限制。</summary>
    [ExpressionInput]
    public string DeviceName { get; set; } = string.Empty;
 
    /// <summary>保存本次设备快照。</summary>
    private JsonElement _device;
 
    /// <summary>每次匹配状态变化发布一次 JSON 事件。</summary>
    [ExpressionOutput(IsEvent = true)]
    public JsonElement Device
    {
        get => _device;
        private set => SetOutput(ref _device, value);
    }
 
    /// <summary>保存最近状态的文字表示。</summary>
    private string _status = string.Empty;
 
    /// <summary>发布最近设备状态。</summary>
    [ExpressionOutput]
    public string Status
    {
        get => _status;
        private set => SetOutput(ref _status, value);
    }
 
    /// <summary>在当前流程实例中订阅设备变化。</summary>
    public override Task InitAsync()
    {
        GlobalData.DeviceStatusChangeEvent += OnDeviceChanged;
        return Task.CompletedTask;
    }
 
    /// <summary>广播入口只固定快照并提交通知。</summary>
    private void OnDeviceChanged(DeviceRuntime runtime, DeviceBasicData data)
    {
        if (!string.IsNullOrWhiteSpace(DeviceName) && data.Name != DeviceName)
        {
            return;
        }
 
        var snapshot = JsonSerializer.SerializeToElement(data);
        var status = data.DeviceStatus.ToString();
        EnqueueNotification(() =>
        {
            Device = snapshot;
            Status = status;
        }, nameof(Device));
    }
 
    /// <summary>设备变化由订阅通知处理。</summary>
    public override Task ChangedAsync() => Task.CompletedTask;
 
    /// <summary>解除设备事件订阅，允许旧流程实例释放。</summary>
    public void Dispose()
    {
        GlobalData.DeviceStatusChangeEvent -= OnDeviceChanged;
    }
}

#nullable enable
using System;
using System.ComponentModel;
using System.Threading.Tasks;
using TGateway.Application;
using TUtility;
 
/// <summary>以固定周期产生事件，由宿主串行发布输出。</summary>
[Category("定时器")]
[RuleNode("manual.periodic-pulse")]
public sealed class PeriodicPulseNode : CustomExpressionBase, IDisposable
{
    /// <summary>节点库显示名称。</summary>
    public override string Name => "周期脉冲";
 
    /// <summary>保存时固定的周期毫秒数，重新装载后生效。</summary>
    [ExpressionParameter]
    public int IntervalMs { get; set; } = 1000;
 
    /// <summary>允许当前周期发布事件。</summary>
    [ExpressionInput]
    public bool Enabled { get; set; } = true;
 
    /// <summary>保存最近一次周期事件载荷。</summary>
    private bool _tick;
 
    /// <summary>每次周期发布真事件，不需要先写假复位。</summary>
    [ExpressionOutput(IsEvent = true)]
    public bool Tick
    {
        get => _tick;
        private set => SetOutput(ref _tick, value);
    }
 
    /// <summary>保存当前实例的周期次数。</summary>
    private int _count;
 
    /// <summary>发布当前实例已经完成的周期计数。</summary>
    [ExpressionOutput]
    public int Count
    {
        get => _count;
        private set => SetOutput(ref _count, value);
    }
 
    /// <summary>由当前节点持有并释放的非重入定时任务。</summary>
    private TimerX? _timer;
 
    /// <summary>校验周期并建立当前流程实例的定时任务。</summary>
    public override Task InitAsync()
    {
        if (IntervalMs < 1)
            throw new RuleBusinessRejectedException("InvalidInterval", "IntervalMs must be positive.");
        Count = 0;
        ReportWaiting();
        _timer = new TimerX(OnTimer, null, IntervalMs, IntervalMs);
        return Task.CompletedTask;
    }
 
    /// <summary>启用输入变化时更新空闲等待说明。</summary>
    public override Task ChangedAsync()
    {
        ReportWaiting();
        return Task.CompletedTask;
    }
 
    /// <summary>定时线程不执行节点业务，只向流程队列提交固定通知。</summary>
    private void OnTimer(object? state)
    {
        if (!LifetimeCancellationToken.IsCancellationRequested)
            EnqueueNotification(PublishTick, nameof(Tick));
    }
 
    /// <summary>在受管串行执行内更新计数并发布本次周期事件。</summary>
    private void PublishTick()
    {
        if (!Enabled) return;
        Count++;
        Tick = true;
    }
 
    /// <summary>空闲周期等待与执行结果分别报告。</summary>
    private void ReportWaiting()
    {
        SetWaitingReason(Enabled ? "WaitingForInterval" : "WaitingForEnabled",
            Enabled ? $"等待下次周期：{IntervalMs} ms" : "等待启用");
    }
 
    /// <summary>停止时移除定时任务，流程令牌同时阻止后续通知进入。</summary>
    public void Dispose()
    {
        _timer?.Dispose();
        _timer = null;
    }
}