public ModbusClientNode(INodeContext context) { context.ThrowIfNull("context"); ITypeService typeService = context.GetService <ITypeService>(); this.TimeSpan = typeService.CreateInt(PortTypes.Integer, "Abfrageinterval", 60); this.ModbusHost = typeService.CreateString(PortTypes.String, "Modbus TCP Host"); this.ModbusPort = typeService.CreateInt(PortTypes.Integer, "Port", 502); this.ModbusID = typeService.CreateInt(PortTypes.Integer, "Geräte ID", 1); this.ModbusID.MinValue = 1; this.ModbusID.MaxValue = 256; // --------------------------------------------------------------------------------------- // this.ModbusAddress1 = typeService.CreateInt(PortTypes.Integer, "Register Addresse", 1); this.ModbusAddress1.MinValue = 1; this.ModbusAddress1.MaxValue = 65535; this.FunctionCode = typeService.CreateEnum("ModbusFunction", "Funktion", FunctionCodeEnum.VALUES, FunctionCodeEnum.FC_03); this.DataType = typeService.CreateEnum("ModbusDataType", "Datentyp", DataTypeEnum.VALUES, DataTypeEnum.INT32); this.RegisterOrder = typeService.CreateEnum("ModbusRegisterOrder", "Register Reihenfolge", ByteOrderEnum.VALUES, ByteOrderEnum.LOW_HIGH); this.OutputValue1 = typeService.CreateDouble(PortTypes.Number, "Register Wert"); this.ErrorMessage = typeService.CreateString(PortTypes.String, "RAW / Error"); SchedulerService = context.GetService <ISchedulerService>(); }
/// <summary> /// Initializes a new instance of the <see cref="BasicNode"/> class. /// </summary> /// <param name="context">The node context.</param> public InputSelector(INodeContext context) : base(context, INPUT_PREFIX) { context.ThrowIfNull("context"); mTypeService = context.GetService <ITypeService>(); // Initialize the input count, allowing range 2..99. mInputCount = mTypeService.CreateInt(PortTypes.Integer, "InputCount", 2); mInputCount.MinValue = 2; mInputCount.MaxValue = 50; // Initialize inputs using a helper function that grows/shrinks the list of inputs // whenever the input count is changed mInputs = new List <AnyValueObject>(); ListHelpers.ConnectListToCounter(mInputs, mInputCount, mTypeService.GetValueObjectCreator(PortTypes.Any, INPUT_PREFIX), updateOutputValues); // Initialize the input for the index of the input to select. mSelectIndexInput = mTypeService.CreateInt(PortTypes.Integer, "InputSelectIndex"); mSelectIndexInput.MinValue = 0; mSelectIndexInput.MaxValue = mInputCount.MaxValue - 1; mSelectIndexInput.ValueSet += updateOutputValues; // Initialize the selector for "send-on-select". mSelectAction = mTypeService.CreateEnum("ESelectAction2", "SelectAction2", mSelectActionValues, "ResendCurrent"); // Initialize the output mOutput = mTypeService.CreateAny(PortTypes.Any, "Output"); }
/// <summary> /// Initializes a new instance of the <see cref="UnifiPresenceDetectionNode"/> class. /// </summary> /// <param name="context">The node context.</param> public UnifiPresenceDetectionNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); // Get the TypeService from the context this.TypeService = context.GetService <ITypeService>(); this.Trigger = this.TypeService.CreateBool(PortTypes.Bool, "Trigger", false); this.BaseUrl = this.TypeService.CreateString(PortTypes.String, "BaseURL", "https://127.0.0.1:8443"); this.SiteId = this.TypeService.CreateString(PortTypes.String, "UniFi Site", "default"); this.Username = this.TypeService.CreateString(PortTypes.String, "Username", ""); this.Password = this.TypeService.CreateString(PortTypes.String, "Password", ""); this.DeviceAmount = this.TypeService.CreateInt(PortTypes.Integer, "Anzahl Geräte", 1); this.DeviceAmount.MinValue = 1; this.DeviceAmount.MaxValue = 15; this.Devices = new List <IValueObject>(); this.DeviceAmount.ValueSet += this.GenerateDevicePorts; this.ConnectedAmount = this.TypeService.CreateInt(PortTypes.Integer, "Anzahl angemeldete Clients", 0); this.IsOneConnected = this.TypeService.CreateBool(PortTypes.Bool, "Mindestens ein Device angemeldet", false); this.IsAllConnected = this.TypeService.CreateBool(PortTypes.Bool, "Alle Devices angemeldet", false); this.ConnectedPersons = this.TypeService.CreateString(PortTypes.String, "Angemeldete Personen", ""); this.Error = this.TypeService.CreateString(PortTypes.String, "Fehlermeldung", ""); this.DeviceAmount.Value = 1; this.DefinedDevicesAndPersons = new Dictionary <string, string>(); }
/// <summary> /// Initializes a new instance of the <see cref="TimedStatistics"/> class. /// </summary> /// <param name="context">The node context.</param> public TimedStatistics(INodeContext context) : base(context) { context.ThrowIfNull("context"); mSchedulerService = context.GetService <ISchedulerService>(); var typeService = context.GetService <ITypeService>(); // Initialize inputs mReset = typeService.CreateBool(PortTypes.Binary, "Reset", false); mInput = typeService.CreateDouble(PortTypes.Number, "Input"); // Initialize Outputs mOutputAvg = typeService.CreateDouble(PortTypes.Number, "Avg"); mOutputMin = typeService.CreateDouble(PortTypes.Number, "Min"); mOutputMax = typeService.CreateDouble(PortTypes.Number, "Max"); mOutputChange = typeService.CreateDouble(PortTypes.Number, "Change"); mOutputTrend = typeService.CreateInt(PortTypes.Integer, "Trend"); mOutputSum = typeService.CreateDouble(PortTypes.Number, "Sum"); mOutputNumber = typeService.CreateInt(PortTypes.Integer, "Number"); // Default resolution of input values is 1.0 mInputResolution = typeService.CreateDouble(PortTypes.Number, "InputResolution", 1.0); // Default considered timespan is one minute mConsideredTime = typeService.CreateTimeSpan(PortTypes.TimeSpan, "ConsideredTime", new TimeSpan(0, 0, 1, 0)); // Considered timespan range is 0s (unlimited), or 5s .. 1 year mConsideredTime.MinValue = new TimeSpan(0 /* ticks */); mConsideredTime.MaxValue = new TimeSpan(366 /* days */, 0, 0, 0); mConsideredTime.ValueSet += updateFirstOutputAfterTimeRange; // Default timespan to send first values after is 0 (immediately) mFirstOutputAfterTime = typeService.CreateTimeSpan(PortTypes.TimeSpan, "FirstOutputAfterTime", new TimeSpan(0 /* ticks */)); // Range is 0 (immediately) to considered time mFirstOutputAfterTime.MinValue = new TimeSpan(0 /* ticks */); mFirstOutputAfterTime.MaxValue = mConsideredTime.Value; // Default update timespan is 0 (updates only upon receiving new values) mUpdateInterval = typeService.CreateTimeSpan(PortTypes.TimeSpan, "UpdateTime", new TimeSpan(0, 0, 0, 0)); // Update timespan range is 0s (never), or 0,5s .. 1 year mUpdateInterval.MinValue = new TimeSpan(0 /* ticks */); mUpdateInterval.MaxValue = new TimeSpan(366 /* days */, 0, 0, 0); // Default maximum number of stored entries is 50; range is 10 .. 2000 mMaxEntries = typeService.CreateInt(PortTypes.Integer, "MaxNumber", 50); mMaxEntries.MinValue = 10; mMaxEntries.MaxValue = 2000; mTimedValues = new LinkedList <TimedValue>(); }
public KHueNodeBinary(INodeContext context) : base(context) { context.ThrowIfNull("context"); _typeService = context.GetService <ITypeService>(); Input = _typeService.CreateBool(PortTypes.Binary, "Input"); LightId = _typeService.CreateInt(PortTypes.Integer, "Light ID"); Username = _typeService.CreateString(PortTypes.String, "Hue user name"); IpAddress = _typeService.CreateString(PortTypes.String, "Hue bridge IP address"); ErrorMessage = _typeService.CreateString(PortTypes.String, "Error message"); }
public WakeOnLanNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); // Get the TypeService from the context var typeService = context.GetService <ITypeService>(); // Initialize the ports Input and Output with a double value object and the translateable name "Input" / "Output". // The port type 'Number' accepts connections to any other number. this.Trigger = typeService.CreateBool(PortTypes.Binary, "Trigger"); this.MacAddress = typeService.CreateString(PortTypes.String, "MacAddress"); }
public KHueNodeRgb(INodeContext context) : base(context) { context.ThrowIfNull("context"); _typeService = context.GetService <ITypeService>(); Red = _typeService.CreateByte(PortTypes.Byte, "Red"); Green = _typeService.CreateByte(PortTypes.Byte, "Green"); Blue = _typeService.CreateByte(PortTypes.Byte, "Blue"); LightId = _typeService.CreateInt(PortTypes.Integer, "Light ID"); Username = _typeService.CreateString(PortTypes.String, "Hue user name"); IpAddress = _typeService.CreateString(PortTypes.String, "Hue bridge IP address"); ErrorMessage = _typeService.CreateString(PortTypes.String, "Error message"); }
public DimmerNode(INodeContext context, ISchedulerService schedulerService) : base(context) { context.ThrowIfNull("context"); schedulerService.ThrowIfNull("schedulerService"); this._typeService = context.GetService <ITypeService>(); this._schedulerService = schedulerService; this.StartDimDelay = this._typeService.CreateInt(PortTypes.Integer, "StartDimDelay", 400, "ms"); this.DimPercent = this._typeService.CreateInt(PortTypes.Integer, "DimPercent", 100, "%"); this.Mode = this._typeService.CreateEnum("BINARYDIMMODE", "Mode", Modes, MODE_SINGLE_BUTTON_SWITCHING); this.Mode.ValueSet += (sender, e) => { this.UpdateMode(); }; UpdateMode(); this.LightState = this._typeService.CreateBool(PortTypes.Bool, "LightState"); this.SwitchOnOff = this._typeService.CreateBool(PortTypes.Bool, "SwitchOnOff"); }
public SendMail(INodeContext context) : base(context) { context.ThrowIfNull("context"); ITypeService typeService = context.GetService <ITypeService>(); this.SendTrigger = typeService.CreateBool(PortTypes.Bool, "Trigger"); this.To = typeService.CreateString(PortTypes.String, "Empfängeradresse"); this.From = typeService.CreateString(PortTypes.String, "Senderadresse"); this.SmtpHost = typeService.CreateString(PortTypes.String, "SMTP Server"); this.SmtpPort = typeService.CreateInt(PortTypes.Integer, "SMTP Port"); this.ErrorMessage = typeService.CreateString(PortTypes.String, "Fehlertext"); this.Encryption = typeService.CreateEnum("SmtpEncryption", "Verschlüsselung", EncryptionTypes.VALUES); this.SmtpUser = typeService.CreateString(PortTypes.String, "SMTP Benutzer"); this.SmtpPassword = typeService.CreateString(PortTypes.String, "SMTP Kennwort"); }
/// <summary> /// Initializes a new instance of the <see cref="AirPressureConverterNode"/> class. /// </summary> /// <param name="context">The node context.</param> public AirPressureConverterNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); // Get the TypeService from the context var typeService = context.GetService <ITypeService>(); this.Temperature = typeService.CreateDouble(PortTypes.Temperature, "Temperatur (°C)"); this.Temperature.MinValue = -50; this.Temperature.MaxValue = 50; this.AbsoluteAirPressure = typeService.CreateDouble(PortTypes.Float, "Absoluter Luftdruck (hPA)"); this.MeasurementHeight = typeService.CreateInt(PortTypes.Integer, "Messhöhe über N.N."); this.RelativeAirPressure = typeService.CreateDouble(PortTypes.Float, "Relative Luftfeuchtigkeit (hPA)"); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="context">The node context.</param> public XmlJsonParser(INodeContext context) : base(context, OUTPUT_PREFIX) { context.ThrowIfNull("context"); mTypeService = context.GetService <ITypeService>(); // Initialize the input. mInput = mTypeService.CreateString(PortTypes.String, INPUT_NAME); // Initialize the selector for "XML" or "JSON". mSelectInput = mTypeService.CreateEnum("ESelectCode", "SelectCode", mSelectInputValues, "XML"); // Initialize the output etc. parameter count. mCount = mTypeService.CreateInt(PortTypes.Integer, "OutputCount", 1); mCount.MinValue = 1; mCount.MaxValue = 50; mCount.ValueSet += updateSelectOperationCount; // Initialize operation selector parameters mSelectOperation = new List <EnumValueObject>(); updateSelectOperationCount(); // Initialize operation parameters using a helper function that grows/shrinks // the list whenever the count is changed mSelectParam = new List <StringValueObject>(); ListHelpers.ConnectListToCounter(mSelectParam, mCount, mTypeService.GetValueObjectCreator(PortTypes.String, SEL_OP_PARAM_PREFIX), null, updateSelectParamDefault); updateSelectParamDefault(); // Initialize path parameters using a helper function that grows/shrinks the // list whenever the count is changed mPath = new List <StringValueObject>(); ListHelpers.ConnectListToCounter(mPath, mCount, mTypeService.GetValueObjectCreator(PortTypes.String, PATH_PREFIX), null); // Initialize outputs using a helper function that grows/shrinks the list of // outputs whenever the output count is changed mOutput = new List <AnyValueObject>(); ListHelpers.ConnectListToCounter(mOutput, mCount, mTypeService.GetValueObjectCreator(PortTypes.Any, OUTPUT_PREFIX), null); // Initialize error text output mError = mTypeService.CreateString(PortTypes.String, "RuntimeError"); mCommaCulture = new CultureInfo("de"); mPointCulture = new CultureInfo("en"); }
/// <summary> /// Initializes a new instance of the <see cref="SendByDifference"/> class. /// </summary> /// <param name="context">The node context.</param> public SendByDifference(INodeContext context) : base(context) { context.ThrowIfNull("context"); var typeService = context.GetService <ITypeService>(); // Initialize Input and Output with no defaults or restrictions mInput = typeService.CreateDouble(PortTypes.Number, "Input"); mOutput = typeService.CreateDouble(PortTypes.Number, "Output"); // Initialize MinimumDifference parameter with a default of 2.0, // and restrict to positive values mMinimumDifference = typeService.CreateDouble(PortTypes.Number, "MinimumDifference", 1.0); mMinimumDifference.MinValue = 0.0; }
public DewPointNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); this.typeService = context.GetService <ITypeService>(); this.Temperature = this.typeService.CreateDouble(PortTypes.Temperature, "Temperatur (°C)"); this.Temperature.MinValue = -248; this.Temperature.MaxValue = 2000; this.Humidity = this.typeService.CreateDouble(PortTypes.Float, "rel. Luftfeuchte (%)"); this.Humidity.MinValue = 0; this.Humidity.MaxValue = 100; this.DewPoint = this.typeService.CreateDouble(PortTypes.Float, "Taupunkt (°C)"); }
public WebRequestNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); this.TypeService = context.GetService <ITypeService>(); this.Trigger = this.TypeService.CreateBool(PortTypes.Binary, "Trigger"); this.URL = this.TypeService.CreateString(PortTypes.String, "URL"); this.URL.ValueSet += RefreshVariables; this.Method = this.TypeService.CreateEnum("HttpMethodType", "Method", new string[] { "GET", "POST", "HEAD", "PUT", "DELETE", "CONNECT", "OPTIONS", "PATCH" }, "GET"); this.AuthType = this.TypeService.CreateEnum( "HttpAuthType", "AuthType", new string[] { AuthCredentials.AuthType.NoAuth.ToString(), AuthCredentials.AuthType.BasicAuth.ToString(), AuthCredentials.AuthType.BearerToken.ToString() }, AuthCredentials.AuthType.NoAuth.ToString()); this.AuthType.ValueSet += AuthType_ValueSet; this.Method.ValueSet += UpdateBodyAndContentTypeInputVisibility; this.ContentType = null; this.Body = null; this.HeaderMode = this.TypeService.CreateEnum("HeaderModeType", "HeaderMode", new string[] { "HeaderMode.0", "HeaderMode.1", "HeaderMode.2", "HeaderMode.3", "HeaderMode.4", "HeaderMode.5", "HeaderMode.6", "HeaderMode.7", "HeaderMode.8", "HeaderMode.9", "HeaderMode.10" }, "HeaderMode.0"); this.HeaderMode.ValueSet += UpdateHeaders; this.Headers = new List <StringValueObject>(); this.Variables = new List <StringValueObject>(); this.Response = this.TypeService.CreateString(PortTypes.String, "Response"); this.ErrorCode = this.TypeService.CreateInt(PortTypes.Integer, "ErrorCode"); this.ErrorMessage = this.TypeService.CreateString(PortTypes.String, "ErrorMessage"); }
/// <summary> /// Initializes a new instance of the <see cref="PlaceholderNodeBase"/> class. /// </summary> /// <param name="context">The node context.</param> public PlaceholderNodeBase(INodeContext context) : base(context) { context.ThrowIfNull("context"); mTypeService = context.GetService <ITypeService>(); // Initialize one template parameter, but allow more of them mTemplateCount = mTypeService.CreateInt(PortTypes.Integer, TEMPLATE_PREFIX + "Count", 1); mTemplateCount.MinValue = 1; mTemplateCount.MaxValue = 10; mTemplates = new List <StringValueObject>(); ListHelpers.ConnectListToCounter(mTemplates, mTemplateCount, mTypeService.GetValueObjectCreator(PortTypes.String, TEMPLATE_PREFIX + " "), updateTemplate); // Initialize token object storage and output per template parameter mTokensPerTemplate = new List <List <TokenBase> >(); mOutputs = new List <IValueObject>(); updateTemplateCount(); mTemplateCount.ValueSet += updateTemplateCount; // Initialize the input counts mBinInputCount = mTypeService.CreateInt(PortTypes.Integer, INPUT_BIN_PREFIX + "Count", 0); mIntInputCount = mTypeService.CreateInt(PortTypes.Integer, INPUT_INT_PREFIX + "Count", 0); mNumInputCount = mTypeService.CreateInt(PortTypes.Integer, INPUT_NUM_PREFIX + "Count", 0); mStrInputCount = mTypeService.CreateInt(PortTypes.Integer, INPUT_STR_PREFIX + "Count", 0); // Initialize inputs using helper functions that grow/shrink the list of // inputs whenever the input count is changed mBinInputs = new List <BoolValueObject>(); ListHelpers.ConnectListToCounter(mBinInputs, mBinInputCount, mTypeService.GetValueObjectCreator(PortTypes.Bool, INPUT_BIN_PREFIX), updateOutputValues); mIntInputs = new List <IntValueObject>(); ListHelpers.ConnectListToCounter(mIntInputs, mIntInputCount, mTypeService.GetValueObjectCreator(PortTypes.Integer, INPUT_INT_PREFIX), updateOutputValues); mNumInputs = new List <DoubleValueObject>(); ListHelpers.ConnectListToCounter(mNumInputs, mNumInputCount, mTypeService.GetValueObjectCreator(PortTypes.Number, INPUT_NUM_PREFIX), updateOutputValues); mStrInputs = new List <StringValueObject>(); ListHelpers.ConnectListToCounter(mStrInputs, mStrInputCount, mTypeService.GetValueObjectCreator(PortTypes.String, INPUT_STR_PREFIX), updateOutputValues); }
public Write(INodeContext context) : base(context) { context.ThrowIfNull("context"); ITypeService typeService = context.GetService <ITypeService>(); this.InfluxDbHost = typeService.CreateString(PortTypes.String, "Influx DB host"); this.InfluxDbPort = typeService.CreateInt(PortTypes.Integer, "Influx DB Port", 8086); this.InfluxDbName = typeService.CreateString(PortTypes.String, "Influx DB name"); this.InfluxMeasureName = typeService.CreateString(PortTypes.String, "Measure name"); this.InfluxDbMeasureTags = typeService.CreateString(PortTypes.String, "Measure tags"); this.InfluxDbMeasureFieldName1 = typeService.CreateString(PortTypes.String, "Measure field name 1"); this.InfluxDbMeasureFieldValue1 = typeService.CreateDouble(PortTypes.Float, "Measure value 1"); this.InfluxDbMeasureFieldName2 = typeService.CreateString(PortTypes.String, "Measure field name 2"); this.InfluxDbMeasureFieldValue2 = typeService.CreateDouble(PortTypes.Float, "Measure value 2"); this.ErrorCode = typeService.CreateInt(PortTypes.Integer, "HTTP status-code"); this.ErrorMessage = typeService.CreateString(PortTypes.String, "SMTP Benutzer"); }
/// <summary> /// Initializes a new instance of the <see cref="HumidityConverterNode"/> class. /// </summary> /// <param name="context">The node context.</param> public HumidityConverterNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); // Get the TypeService from the context var typeService = context.GetService <ITypeService>(); this.Temperature = typeService.CreateDouble(PortTypes.Temperature, "Temperatur (°C)"); this.Temperature.MinValue = -50; this.Temperature.MaxValue = 50; this.RelativeHumidity = typeService.CreateDouble(PortTypes.Float, "Relative Luftfeuchtigkeit (%)"); this.RelativeHumidity.MinValue = 0; this.RelativeHumidity.MaxValue = 100; this.AbsoluteHumidity = typeService.CreateDouble(PortTypes.Float, "Absolute Luftfeuchtigkeit (g/m3)"); }
/// <summary> /// Initializes a new instance of the <see cref="BasicNode"/> class. /// </summary> /// <param name="context">The node context.</param> public OutputSelector(INodeContext context) : base(context, OUTPUT_PREFIX) { context.ThrowIfNull("context"); mTypeService = context.GetService <ITypeService>(); // Initialize the input. mInput = mTypeService.CreateAny(PortTypes.Any, "Input"); mInput.ValueSet += updateOutputValues; // Initialize the output count. mOutputCount = mTypeService.CreateInt(PortTypes.Integer, "OutputCount", 2); mOutputCount.MinValue = 1; // for use as Lock-out+ (Sperre+) mOutputCount.MaxValue = 50; // Initialize the input for the index of the output to select. mSelectIndexInput = mTypeService.CreateInt(PortTypes.Integer, "OutputSelectIndex"); mSelectIndexInput.MinValue = -1; // -1 selects no output mSelectIndexInput.MaxValue = mOutputCount.MaxValue; // max selects no output mSelectIndexInput.ValueSet += updateOutputValues; // Initialize the selector for "send-on-select". mSelectAction = mTypeService.CreateEnum("ESelectAction3", "SelectAction3", mSelectActionValues, "ResendCurrent"); // Initialize outputs using a helper function that grows/shrinks the list of outputs // whenever the output count is changed mOutputs = new List <AnyValueObject>(); ListHelpers.ConnectListToCounter(mOutputs, mOutputCount, mTypeService.GetValueObjectCreator(PortTypes.Any, OUTPUT_PREFIX), null); // Initialize outputs using a helper function that grows/shrinks the // list of outputs whenever the output count is changed mPrevOutputs = new List <AnyValueObject>(); ListHelpers.ConnectListToCounter(mPrevOutputs, mOutputCount, mTypeService.GetValueObjectCreator(PortTypes.Any, ""), null, null); // Initialize the value to send upon "de-select". mIdleValueType = mTypeService.CreateEnum("EValueType", "IdleValueType", mValueTypes, "none"); updateIdleValueType(); mIdleValueType.ValueSet += updateIdleValueType; }
public ModbusClientNode(INodeContext context) { context.ThrowIfNull("context"); ITypeService typeService = context.GetService <ITypeService>(); this.ModbusHost = typeService.CreateString(PortTypes.String, "Modbus TCP Server"); this.ModbusPort = typeService.CreateInt(PortTypes.Integer, "Port", 502); this.ModbusAddress = typeService.CreateInt(PortTypes.Integer, "Modbus Addresse"); this.ModbusAddress.MinValue = 0; this.ModbusAddress.MaxValue = 65535; this.ReadCount = typeService.CreateInt(PortTypes.Integer, "Anzahl bytes"); this.ReadCount.MinValue = 1; this.ReadCount.MaxValue = 2; this.OutputValue = typeService.CreateDouble(PortTypes.Float, "Wert"); this.ErrorMessage = typeService.CreateString(PortTypes.String, "Error"); SchedulerService = context.GetService <ISchedulerService>(); }
public NotificationNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); this.SetupIgnoreSSLTrust(); var typeService = context.GetService<ITypeService>(); this.Trigger = typeService.CreateBool(PortTypes.Binary, "Trigger"); this.Token = typeService.CreateString(PortTypes.String, "Token"); this.UserKey = typeService.CreateString(PortTypes.String, "UserKey"); this.Message = typeService.CreateString(PortTypes.String, "Message"); this.Variables = new List<StringValueObject>(); this.VariableCount = typeService.CreateInt(PortTypes.Integer, "VariableCount", 0); this.VariableCount.MinValue = 0; this.VariableCount.MaxValue = 99; ListHelpers.ConnectListToCounter(this.Variables, this.VariableCount, typeService.GetValueObjectCreator(PortTypes.String, "Variable"), null, null); }
/// <summary> /// Initializes a new instance of the <see cref="BasicNode"/> class. /// </summary> /// <param name="context">The node context.</param> public Statistics(INodeContext context) : base(context, INPUT_PREFIX) { context.ThrowIfNull("context"); mTypeService = context.GetService <ITypeService>(); // Initialize the input count. mInputCount = mTypeService.CreateInt(PortTypes.Integer, "InputCount", 2); mInputCount.MinValue = 2; mInputCount.MaxValue = 50; // Initialize inputs using a helper function that grows/shrinks the list of inputs // whenever the input count is changed mInputs = new List <DoubleValueObject>(); ListHelpers.ConnectListToCounter(mInputs, mInputCount, mTypeService.GetValueObjectCreator(PortTypes.Number, INPUT_PREFIX), updateOutputValues); // Initialize the selector for the aggregate function that shall be calculated. mSelectedFunction = mTypeService.CreateEnum("ESelectedFunction", "SelectedFunction", mPriAllowedValues, /* defaultValue = */ "Avg"); // Initialize the primary output mOutput1 = mTypeService.CreateDouble(PortTypes.Number, "Output1"); // Initialize the selector for the secondary function (none by default) that shall // be calculated. string[] secAllowedValues = mAddAllowedValues.Concat(mPriAllowedValues).ToArray(); mSecondaryFunction = mTypeService.CreateEnum("ESecondaryFunction", "SecondaryFunction", secAllowedValues, /* defaultValue = */ "none"); // Update output properties now, and whenever the function selections change updatePrimaryOutputProperties(); updateSecondaryOutputProperties(); mSelectedFunction.ValueSet += updatePrimaryOutputProperties; mSecondaryFunction.ValueSet += updateSecondaryOutputProperties; }
public ModbusClientNode(INodeContext context) { context.ThrowIfNull("context"); ITypeService typeService = context.GetService <ITypeService>(); this.TimeSpan = typeService.CreateInt(PortTypes.Integer, "Restart (Sek.)", 60); this.ModbusHost = typeService.CreateString(PortTypes.String, "Modbus TCP Server"); this.ModbusPort = typeService.CreateInt(PortTypes.Integer, "Port", 502); this.ModbusID = typeService.CreateInt(PortTypes.Integer, "Modbus ID", 3); // --------------------------------------------------------------------------------------- // this.ModbusAddress1 = typeService.CreateInt(PortTypes.Integer, "Modbus Addresse", 0); this.ModbusAddress1.MinValue = 0; this.ModbusAddress1.MaxValue = 65535; this.ReadCount1 = typeService.CreateInt(PortTypes.Integer, "Anzahl words", 2); this.ReadCount1.MinValue = 1; this.ReadCount1.MaxValue = 2; this.OutputValue1 = typeService.CreateDouble(PortTypes.Number, "Register Wert"); this.ErrorMessage = typeService.CreateString(PortTypes.String, "RAW / Error"); SchedulerService = context.GetService <ISchedulerService>(); }