diff --git a/Generators/Generators.csproj b/Generators/Generators.csproj index fb26a79..825bab3 100644 --- a/Generators/Generators.csproj +++ b/Generators/Generators.csproj @@ -15,7 +15,7 @@ ..\Firmware\Harp.LedArray - + diff --git a/Interface/Harp.LedArray/AsyncDevice.Generated.cs b/Interface/Harp.LedArray/AsyncDevice.Generated.cs index b6decff..4df5654 100644 --- a/Interface/Harp.LedArray/AsyncDevice.Generated.cs +++ b/Interface/Harp.LedArray/AsyncDevice.Generated.cs @@ -1,4 +1,5 @@ using Bonsai.Harp; +using System.Threading; using System.Threading.Tasks; namespace Harp.LedArray @@ -47,26 +48,32 @@ internal AsyncDevice(string portName) /// /// Asynchronously reads the contents of the EnablePower register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadEnablePowerAsync() + public async Task ReadEnablePowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnablePower.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnablePower.Address), cancellationToken); return EnablePower.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the EnablePower register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedEnablePowerAsync() + public async Task> ReadTimestampedEnablePowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnablePower.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnablePower.Address), cancellationToken); return EnablePower.GetTimestampedPayload(reply); } @@ -74,36 +81,45 @@ public async Task> ReadTimestampedEnablePowerAsync() /// Asynchronously writes a value to the EnablePower register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteEnablePowerAsync(LedState value) + public async Task WriteEnablePowerAsync(LedState value, CancellationToken cancellationToken = default) { var request = EnablePower.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the EnableLedMode register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadEnableLedModeAsync() + public async Task ReadEnableLedModeAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnableLedMode.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnableLedMode.Address), cancellationToken); return EnableLedMode.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the EnableLedMode register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedEnableLedModeAsync() + public async Task> ReadTimestampedEnableLedModeAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnableLedMode.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnableLedMode.Address), cancellationToken); return EnableLedMode.GetTimestampedPayload(reply); } @@ -111,36 +127,45 @@ public async Task> ReadTimestampedEnableLedModeAsync() /// Asynchronously writes a value to the EnableLedMode register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteEnableLedModeAsync(LedState value) + public async Task WriteEnableLedModeAsync(LedState value, CancellationToken cancellationToken = default) { var request = EnableLedMode.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the EnableLed register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadEnableLedAsync() + public async Task ReadEnableLedAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnableLed.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnableLed.Address), cancellationToken); return EnableLed.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the EnableLed register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedEnableLedAsync() + public async Task> ReadTimestampedEnableLedAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnableLed.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnableLed.Address), cancellationToken); return EnableLed.GetTimestampedPayload(reply); } @@ -148,62 +173,77 @@ public async Task> ReadTimestampedEnableLedAsync() /// Asynchronously writes a value to the EnableLed register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteEnableLedAsync(LedState value) + public async Task WriteEnableLedAsync(LedState value, CancellationToken cancellationToken = default) { var request = EnableLed.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the DigitalInputState register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadDigitalInputStateAsync() + public async Task ReadDigitalInputStateAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputState.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputState.Address), cancellationToken); return DigitalInputState.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the DigitalInputState register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedDigitalInputStateAsync() + public async Task> ReadTimestampedDigitalInputStateAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputState.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputState.Address), cancellationToken); return DigitalInputState.GetTimestampedPayload(reply); } /// /// Asynchronously reads the contents of the DigitalOutputSync register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadDigitalOutputSyncAsync() + public async Task ReadDigitalOutputSyncAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputSync.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputSync.Address), cancellationToken); return DigitalOutputSync.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the DigitalOutputSync register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedDigitalOutputSyncAsync() + public async Task> ReadTimestampedDigitalOutputSyncAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputSync.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputSync.Address), cancellationToken); return DigitalOutputSync.GetTimestampedPayload(reply); } @@ -211,36 +251,45 @@ public async Task> ReadTimestampedDigitalO /// Asynchronously writes a value to the DigitalOutputSync register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteDigitalOutputSyncAsync(DigitalOutputSyncPayload value) + public async Task WriteDigitalOutputSyncAsync(DigitalOutputSyncPayload value, CancellationToken cancellationToken = default) { var request = DigitalOutputSync.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the DigitalInputTrigger register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadDigitalInputTriggerAsync() + public async Task ReadDigitalInputTriggerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputTrigger.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputTrigger.Address), cancellationToken); return DigitalInputTrigger.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the DigitalInputTrigger register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedDigitalInputTriggerAsync() + public async Task> ReadTimestampedDigitalInputTriggerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputTrigger.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalInputTrigger.Address), cancellationToken); return DigitalInputTrigger.GetTimestampedPayload(reply); } @@ -248,36 +297,45 @@ public async Task> ReadTimestampedDigita /// Asynchronously writes a value to the DigitalInputTrigger register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteDigitalInputTriggerAsync(DigitalInputTriggerPayload value) + public async Task WriteDigitalInputTriggerAsync(DigitalInputTriggerPayload value, CancellationToken cancellationToken = default) { var request = DigitalInputTrigger.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the PulseMode register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadPulseModeAsync() + public async Task ReadPulseModeAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(PulseMode.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(PulseMode.Address), cancellationToken); return PulseMode.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the PulseMode register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedPulseModeAsync() + public async Task> ReadTimestampedPulseModeAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(PulseMode.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(PulseMode.Address), cancellationToken); return PulseMode.GetTimestampedPayload(reply); } @@ -285,36 +343,45 @@ public async Task> ReadTimestampedPulseModeAsync() /// Asynchronously writes a value to the PulseMode register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WritePulseModeAsync(PulseModePayload value) + public async Task WritePulseModeAsync(PulseModePayload value, CancellationToken cancellationToken = default) { var request = PulseMode.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0Power register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PowerAsync() + public async Task ReadLed0PowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(Led0Power.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(Led0Power.Address), cancellationToken); return Led0Power.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0Power register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PowerAsync() + public async Task> ReadTimestampedLed0PowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(Led0Power.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(Led0Power.Address), cancellationToken); return Led0Power.GetTimestampedPayload(reply); } @@ -322,36 +389,45 @@ public async Task> ReadTimestampedLed0PowerAsync() /// Asynchronously writes a value to the Led0Power register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PowerAsync(byte value) + public async Task WriteLed0PowerAsync(byte value, CancellationToken cancellationToken = default) { var request = Led0Power.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1Power register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PowerAsync() + public async Task ReadLed1PowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(Led1Power.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(Led1Power.Address), cancellationToken); return Led1Power.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1Power register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PowerAsync() + public async Task> ReadTimestampedLed1PowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(Led1Power.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(Led1Power.Address), cancellationToken); return Led1Power.GetTimestampedPayload(reply); } @@ -359,36 +435,45 @@ public async Task> ReadTimestampedLed1PowerAsync() /// Asynchronously writes a value to the Led1Power register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PowerAsync(byte value) + public async Task WriteLed1PowerAsync(byte value, CancellationToken cancellationToken = default) { var request = Led1Power.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PwmFrequency register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PwmFrequencyAsync() + public async Task ReadLed0PwmFrequencyAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmFrequency.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmFrequency.Address), cancellationToken); return Led0PwmFrequency.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PwmFrequency register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PwmFrequencyAsync() + public async Task> ReadTimestampedLed0PwmFrequencyAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmFrequency.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmFrequency.Address), cancellationToken); return Led0PwmFrequency.GetTimestampedPayload(reply); } @@ -396,36 +481,45 @@ public async Task> ReadTimestampedLed0PwmFrequencyAsync() /// Asynchronously writes a value to the Led0PwmFrequency register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PwmFrequencyAsync(float value) + public async Task WriteLed0PwmFrequencyAsync(float value, CancellationToken cancellationToken = default) { var request = Led0PwmFrequency.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PwmDutyCycle register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PwmDutyCycleAsync() + public async Task ReadLed0PwmDutyCycleAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycle.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycle.Address), cancellationToken); return Led0PwmDutyCycle.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PwmDutyCycle register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PwmDutyCycleAsync() + public async Task> ReadTimestampedLed0PwmDutyCycleAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycle.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycle.Address), cancellationToken); return Led0PwmDutyCycle.GetTimestampedPayload(reply); } @@ -433,36 +527,45 @@ public async Task> ReadTimestampedLed0PwmDutyCycleAsync() /// Asynchronously writes a value to the Led0PwmDutyCycle register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PwmDutyCycleAsync(float value) + public async Task WriteLed0PwmDutyCycleAsync(float value, CancellationToken cancellationToken = default) { var request = Led0PwmDutyCycle.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PwmPulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PwmPulseCounterAsync() + public async Task ReadLed0PwmPulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PwmPulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PwmPulseCounter.Address), cancellationToken); return Led0PwmPulseCounter.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PwmPulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PwmPulseCounterAsync() + public async Task> ReadTimestampedLed0PwmPulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PwmPulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PwmPulseCounter.Address), cancellationToken); return Led0PwmPulseCounter.GetTimestampedPayload(reply); } @@ -470,36 +573,45 @@ public async Task> ReadTimestampedLed0PwmPulseCounterAsync() /// Asynchronously writes a value to the Led0PwmPulseCounter register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PwmPulseCounterAsync(ushort value) + public async Task WriteLed0PwmPulseCounterAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led0PwmPulseCounter.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PulseTimeOn register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PulseTimeOnAsync() + public async Task ReadLed0PulseTimeOnAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOn.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOn.Address), cancellationToken); return Led0PulseTimeOn.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PulseTimeOn register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PulseTimeOnAsync() + public async Task> ReadTimestampedLed0PulseTimeOnAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOn.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOn.Address), cancellationToken); return Led0PulseTimeOn.GetTimestampedPayload(reply); } @@ -507,36 +619,45 @@ public async Task> ReadTimestampedLed0PulseTimeOnAsync() /// Asynchronously writes a value to the Led0PulseTimeOn register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PulseTimeOnAsync(ushort value) + public async Task WriteLed0PulseTimeOnAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led0PulseTimeOn.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PulseTimeOff register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PulseTimeOffAsync() + public async Task ReadLed0PulseTimeOffAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOff.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOff.Address), cancellationToken); return Led0PulseTimeOff.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PulseTimeOff register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PulseTimeOffAsync() + public async Task> ReadTimestampedLed0PulseTimeOffAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOff.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeOff.Address), cancellationToken); return Led0PulseTimeOff.GetTimestampedPayload(reply); } @@ -544,36 +665,45 @@ public async Task> ReadTimestampedLed0PulseTimeOffAsync() /// Asynchronously writes a value to the Led0PulseTimeOff register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PulseTimeOffAsync(ushort value) + public async Task WriteLed0PulseTimeOffAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led0PulseTimeOff.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PulseTimePulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PulseTimePulseCounterAsync() + public async Task ReadLed0PulseTimePulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimePulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimePulseCounter.Address), cancellationToken); return Led0PulseTimePulseCounter.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PulseTimePulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PulseTimePulseCounterAsync() + public async Task> ReadTimestampedLed0PulseTimePulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimePulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimePulseCounter.Address), cancellationToken); return Led0PulseTimePulseCounter.GetTimestampedPayload(reply); } @@ -581,36 +711,45 @@ public async Task> ReadTimestampedLed0PulseTimePulseCounterA /// Asynchronously writes a value to the Led0PulseTimePulseCounter register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PulseTimePulseCounterAsync(ushort value) + public async Task WriteLed0PulseTimePulseCounterAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led0PulseTimePulseCounter.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PulseTimeTail register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PulseTimeTailAsync() + public async Task ReadLed0PulseTimeTailAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeTail.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeTail.Address), cancellationToken); return Led0PulseTimeTail.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PulseTimeTail register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PulseTimeTailAsync() + public async Task> ReadTimestampedLed0PulseTimeTailAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeTail.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseTimeTail.Address), cancellationToken); return Led0PulseTimeTail.GetTimestampedPayload(reply); } @@ -618,36 +757,45 @@ public async Task> ReadTimestampedLed0PulseTimeTailAsync() /// Asynchronously writes a value to the Led0PulseTimeTail register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PulseTimeTailAsync(ushort value) + public async Task WriteLed0PulseTimeTailAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led0PulseTimeTail.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PulseRepeatCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PulseRepeatCounterAsync() + public async Task ReadLed0PulseRepeatCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseRepeatCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseRepeatCounter.Address), cancellationToken); return Led0PulseRepeatCounter.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PulseRepeatCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PulseRepeatCounterAsync() + public async Task> ReadTimestampedLed0PulseRepeatCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseRepeatCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led0PulseRepeatCounter.Address), cancellationToken); return Led0PulseRepeatCounter.GetTimestampedPayload(reply); } @@ -655,36 +803,45 @@ public async Task> ReadTimestampedLed0PulseRepeatCounterAsyn /// Asynchronously writes a value to the Led0PulseRepeatCounter register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed0PulseRepeatCounterAsync(ushort value) + public async Task WriteLed0PulseRepeatCounterAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led0PulseRepeatCounter.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PwmFrequency register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PwmFrequencyAsync() + public async Task ReadLed1PwmFrequencyAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmFrequency.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmFrequency.Address), cancellationToken); return Led1PwmFrequency.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PwmFrequency register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PwmFrequencyAsync() + public async Task> ReadTimestampedLed1PwmFrequencyAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmFrequency.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmFrequency.Address), cancellationToken); return Led1PwmFrequency.GetTimestampedPayload(reply); } @@ -692,36 +849,45 @@ public async Task> ReadTimestampedLed1PwmFrequencyAsync() /// Asynchronously writes a value to the Led1PwmFrequency register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PwmFrequencyAsync(float value) + public async Task WriteLed1PwmFrequencyAsync(float value, CancellationToken cancellationToken = default) { var request = Led1PwmFrequency.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PwmDutyCycle register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PwmDutyCycleAsync() + public async Task ReadLed1PwmDutyCycleAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmDutyCycle.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmDutyCycle.Address), cancellationToken); return Led1PwmDutyCycle.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PwmDutyCycle register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PwmDutyCycleAsync() + public async Task> ReadTimestampedLed1PwmDutyCycleAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmDutyCycle.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmDutyCycle.Address), cancellationToken); return Led1PwmDutyCycle.GetTimestampedPayload(reply); } @@ -729,36 +895,45 @@ public async Task> ReadTimestampedLed1PwmDutyCycleAsync() /// Asynchronously writes a value to the Led1PwmDutyCycle register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PwmDutyCycleAsync(float value) + public async Task WriteLed1PwmDutyCycleAsync(float value, CancellationToken cancellationToken = default) { var request = Led1PwmDutyCycle.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PwmPulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PwmPulseCounterAsync() + public async Task ReadLed1PwmPulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PwmPulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PwmPulseCounter.Address), cancellationToken); return Led1PwmPulseCounter.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PwmPulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PwmPulseCounterAsync() + public async Task> ReadTimestampedLed1PwmPulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PwmPulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PwmPulseCounter.Address), cancellationToken); return Led1PwmPulseCounter.GetTimestampedPayload(reply); } @@ -766,36 +941,45 @@ public async Task> ReadTimestampedLed1PwmPulseCounterAsync() /// Asynchronously writes a value to the Led1PwmPulseCounter register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PwmPulseCounterAsync(ushort value) + public async Task WriteLed1PwmPulseCounterAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led1PwmPulseCounter.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PulseTimeOn register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PulseTimeOnAsync() + public async Task ReadLed1PulseTimeOnAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOn.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOn.Address), cancellationToken); return Led1PulseTimeOn.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PulseTimeOn register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PulseTimeOnAsync() + public async Task> ReadTimestampedLed1PulseTimeOnAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOn.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOn.Address), cancellationToken); return Led1PulseTimeOn.GetTimestampedPayload(reply); } @@ -803,36 +987,45 @@ public async Task> ReadTimestampedLed1PulseTimeOnAsync() /// Asynchronously writes a value to the Led1PulseTimeOn register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PulseTimeOnAsync(ushort value) + public async Task WriteLed1PulseTimeOnAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led1PulseTimeOn.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PulseTimeOff register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PulseTimeOffAsync() + public async Task ReadLed1PulseTimeOffAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOff.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOff.Address), cancellationToken); return Led1PulseTimeOff.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PulseTimeOff register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PulseTimeOffAsync() + public async Task> ReadTimestampedLed1PulseTimeOffAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOff.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeOff.Address), cancellationToken); return Led1PulseTimeOff.GetTimestampedPayload(reply); } @@ -840,36 +1033,45 @@ public async Task> ReadTimestampedLed1PulseTimeOffAsync() /// Asynchronously writes a value to the Led1PulseTimeOff register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PulseTimeOffAsync(ushort value) + public async Task WriteLed1PulseTimeOffAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led1PulseTimeOff.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PulseTimePulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PulseTimePulseCounterAsync() + public async Task ReadLed1PulseTimePulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimePulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimePulseCounter.Address), cancellationToken); return Led1PulseTimePulseCounter.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PulseTimePulseCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PulseTimePulseCounterAsync() + public async Task> ReadTimestampedLed1PulseTimePulseCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimePulseCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimePulseCounter.Address), cancellationToken); return Led1PulseTimePulseCounter.GetTimestampedPayload(reply); } @@ -877,36 +1079,45 @@ public async Task> ReadTimestampedLed1PulseTimePulseCounterA /// Asynchronously writes a value to the Led1PulseTimePulseCounter register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PulseTimePulseCounterAsync(ushort value) + public async Task WriteLed1PulseTimePulseCounterAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led1PulseTimePulseCounter.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PulseTimeTail register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PulseTimeTailAsync() + public async Task ReadLed1PulseTimeTailAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeTail.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeTail.Address), cancellationToken); return Led1PulseTimeTail.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PulseTimeTail register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PulseTimeTailAsync() + public async Task> ReadTimestampedLed1PulseTimeTailAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeTail.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseTimeTail.Address), cancellationToken); return Led1PulseTimeTail.GetTimestampedPayload(reply); } @@ -914,36 +1125,45 @@ public async Task> ReadTimestampedLed1PulseTimeTailAsync() /// Asynchronously writes a value to the Led1PulseTimeTail register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PulseTimeTailAsync(ushort value) + public async Task WriteLed1PulseTimeTailAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led1PulseTimeTail.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led1PulseRepeatCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PulseRepeatCounterAsync() + public async Task ReadLed1PulseRepeatCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseRepeatCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseRepeatCounter.Address), cancellationToken); return Led1PulseRepeatCounter.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PulseRepeatCounter register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PulseRepeatCounterAsync() + public async Task> ReadTimestampedLed1PulseRepeatCounterAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseRepeatCounter.Address)); + var reply = await CommandAsync(HarpCommand.ReadUInt16(Led1PulseRepeatCounter.Address), cancellationToken); return Led1PulseRepeatCounter.GetTimestampedPayload(reply); } @@ -951,140 +1171,173 @@ public async Task> ReadTimestampedLed1PulseRepeatCounterAsyn /// Asynchronously writes a value to the Led1PulseRepeatCounter register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteLed1PulseRepeatCounterAsync(ushort value) + public async Task WriteLed1PulseRepeatCounterAsync(ushort value, CancellationToken cancellationToken = default) { var request = Led1PulseRepeatCounter.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the Led0PwmReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PwmRealAsync() + public async Task ReadLed0PwmRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmReal.Address), cancellationToken); return Led0PwmReal.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PwmReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PwmRealAsync() + public async Task> ReadTimestampedLed0PwmRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmReal.Address), cancellationToken); return Led0PwmReal.GetTimestampedPayload(reply); } /// /// Asynchronously reads the contents of the Led0PwmDutyCycleReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed0PwmDutyCycleRealAsync() + public async Task ReadLed0PwmDutyCycleRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycleReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycleReal.Address), cancellationToken); return Led0PwmDutyCycleReal.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led0PwmDutyCycleReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed0PwmDutyCycleRealAsync() + public async Task> ReadTimestampedLed0PwmDutyCycleRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycleReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led0PwmDutyCycleReal.Address), cancellationToken); return Led0PwmDutyCycleReal.GetTimestampedPayload(reply); } /// /// Asynchronously reads the contents of the Led1PwmReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLed1PwmRealAsync() + public async Task ReadLed1PwmRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmReal.Address), cancellationToken); return Led1PwmReal.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the Led1PwmReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLed1PwmRealAsync() + public async Task> ReadTimestampedLed1PwmRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(Led1PwmReal.Address), cancellationToken); return Led1PwmReal.GetTimestampedPayload(reply); } /// /// Asynchronously reads the contents of the LedD1PwmDutyCycleReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadLedD1PwmDutyCycleRealAsync() + public async Task ReadLedD1PwmDutyCycleRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(LedD1PwmDutyCycleReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(LedD1PwmDutyCycleReal.Address), cancellationToken); return LedD1PwmDutyCycleReal.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the LedD1PwmDutyCycleReal register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedLedD1PwmDutyCycleRealAsync() + public async Task> ReadTimestampedLedD1PwmDutyCycleRealAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadSingle(LedD1PwmDutyCycleReal.Address)); + var reply = await CommandAsync(HarpCommand.ReadSingle(LedD1PwmDutyCycleReal.Address), cancellationToken); return LedD1PwmDutyCycleReal.GetTimestampedPayload(reply); } /// /// Asynchronously reads the contents of the AuxDigitalOutputState register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadAuxDigitalOutputStateAsync() + public async Task ReadAuxDigitalOutputStateAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(AuxDigitalOutputState.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(AuxDigitalOutputState.Address), cancellationToken); return AuxDigitalOutputState.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the AuxDigitalOutputState register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedAuxDigitalOutputStateAsync() + public async Task> ReadTimestampedAuxDigitalOutputStateAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(AuxDigitalOutputState.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(AuxDigitalOutputState.Address), cancellationToken); return AuxDigitalOutputState.GetTimestampedPayload(reply); } @@ -1092,36 +1345,45 @@ public async Task> ReadTimestampedAuxDigitalOutpu /// Asynchronously writes a value to the AuxDigitalOutputState register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteAuxDigitalOutputStateAsync(AuxDigitalOutputs value) + public async Task WriteAuxDigitalOutputStateAsync(AuxDigitalOutputs value, CancellationToken cancellationToken = default) { var request = AuxDigitalOutputState.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the AuxLedPower register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadAuxLedPowerAsync() + public async Task ReadAuxLedPowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(AuxLedPower.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(AuxLedPower.Address), cancellationToken); return AuxLedPower.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the AuxLedPower register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedAuxLedPowerAsync() + public async Task> ReadTimestampedAuxLedPowerAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(AuxLedPower.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(AuxLedPower.Address), cancellationToken); return AuxLedPower.GetTimestampedPayload(reply); } @@ -1129,36 +1391,45 @@ public async Task> ReadTimestampedAuxLedPowerAsync() /// Asynchronously writes a value to the AuxLedPower register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteAuxLedPowerAsync(byte value) + public async Task WriteAuxLedPowerAsync(byte value, CancellationToken cancellationToken = default) { var request = AuxLedPower.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the DigitalOutputState register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadDigitalOutputStateAsync() + public async Task ReadDigitalOutputStateAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputState.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputState.Address), cancellationToken); return DigitalOutputState.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the DigitalOutputState register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedDigitalOutputStateAsync() + public async Task> ReadTimestampedDigitalOutputStateAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputState.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(DigitalOutputState.Address), cancellationToken); return DigitalOutputState.GetTimestampedPayload(reply); } @@ -1166,36 +1437,45 @@ public async Task> ReadTimestampedDigitalOutputState /// Asynchronously writes a value to the DigitalOutputState register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteDigitalOutputStateAsync(DigitalOutputs value) + public async Task WriteDigitalOutputStateAsync(DigitalOutputs value, CancellationToken cancellationToken = default) { var request = DigitalOutputState.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } /// /// Asynchronously reads the contents of the EnableEvents register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the register payload. /// - public async Task ReadEnableEventsAsync() + public async Task ReadEnableEventsAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnableEvents.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnableEvents.Address), cancellationToken); return EnableEvents.GetPayload(reply); } /// /// Asynchronously reads the timestamped contents of the EnableEvents register. /// + /// + /// A which can be used to cancel the operation. + /// /// /// A task that represents the asynchronous read operation. The /// property contains the timestamped register payload. /// - public async Task> ReadTimestampedEnableEventsAsync() + public async Task> ReadTimestampedEnableEventsAsync(CancellationToken cancellationToken = default) { - var reply = await CommandAsync(HarpCommand.ReadByte(EnableEvents.Address)); + var reply = await CommandAsync(HarpCommand.ReadByte(EnableEvents.Address), cancellationToken); return EnableEvents.GetTimestampedPayload(reply); } @@ -1203,11 +1483,14 @@ public async Task> ReadTimestampedEnableEventsAsync( /// Asynchronously writes a value to the EnableEvents register. /// /// The value to be stored in the register. + /// + /// A which can be used to cancel the operation. + /// /// The task object representing the asynchronous write operation. - public async Task WriteEnableEventsAsync(LedArrayEvents value) + public async Task WriteEnableEventsAsync(LedArrayEvents value, CancellationToken cancellationToken = default) { var request = EnableEvents.FromPayload(MessageType.Write, value); - await CommandAsync(request); + await CommandAsync(request, cancellationToken); } } } diff --git a/Interface/Harp.LedArray/Device.Generated.cs b/Interface/Harp.LedArray/Device.Generated.cs index aabc627..327179f 100644 --- a/Interface/Harp.LedArray/Device.Generated.cs +++ b/Interface/Harp.LedArray/Device.Generated.cs @@ -165,12 +165,12 @@ public override IObservable> Process(IObse [XmlInclude(typeof(DigitalOutputState))] [XmlInclude(typeof(EnableEvents))] [Description("Filters register-specific messages reported by the LedArray device.")] - public class FilterMessage : FilterMessageBuilder, INamedElement + public class FilterRegister : FilterRegisterBuilder, INamedElement { /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// - public FilterMessage() + public FilterRegister() { Register = new EnablePower(); } @@ -3678,6 +3678,39 @@ public static Timestamped GetPayload(HarpMessage message) [XmlInclude(typeof(CreateAuxLedPowerPayload))] [XmlInclude(typeof(CreateDigitalOutputStatePayload))] [XmlInclude(typeof(CreateEnableEventsPayload))] + [XmlInclude(typeof(CreateTimestampedEnablePowerPayload))] + [XmlInclude(typeof(CreateTimestampedEnableLedModePayload))] + [XmlInclude(typeof(CreateTimestampedEnableLedPayload))] + [XmlInclude(typeof(CreateTimestampedDigitalInputStatePayload))] + [XmlInclude(typeof(CreateTimestampedDigitalOutputSyncPayload))] + [XmlInclude(typeof(CreateTimestampedDigitalInputTriggerPayload))] + [XmlInclude(typeof(CreateTimestampedPulseModePayload))] + [XmlInclude(typeof(CreateTimestampedLed0PowerPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PowerPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PwmFrequencyPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PwmDutyCyclePayload))] + [XmlInclude(typeof(CreateTimestampedLed0PwmPulseCounterPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PulseTimeOnPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PulseTimeOffPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PulseTimePulseCounterPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PulseTimeTailPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PulseRepeatCounterPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PwmFrequencyPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PwmDutyCyclePayload))] + [XmlInclude(typeof(CreateTimestampedLed1PwmPulseCounterPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PulseTimeOnPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PulseTimeOffPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PulseTimePulseCounterPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PulseTimeTailPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PulseRepeatCounterPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PwmRealPayload))] + [XmlInclude(typeof(CreateTimestampedLed0PwmDutyCycleRealPayload))] + [XmlInclude(typeof(CreateTimestampedLed1PwmRealPayload))] + [XmlInclude(typeof(CreateTimestampedLedD1PwmDutyCycleRealPayload))] + [XmlInclude(typeof(CreateTimestampedAuxDigitalOutputStatePayload))] + [XmlInclude(typeof(CreateTimestampedAuxLedPowerPayload))] + [XmlInclude(typeof(CreateTimestampedDigitalOutputStatePayload))] + [XmlInclude(typeof(CreateTimestampedEnableEventsPayload))] [Description("Creates standard message payloads for the LedArray device.")] public partial class CreateMessage : CreateMessageBuilder, INamedElement { @@ -3693,205 +3726,228 @@ public CreateMessage() } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that control the enable of both LEDs' power supply. /// [DisplayName("EnablePowerPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that control the enable of both LEDs' power supply.")] - public partial class CreateEnablePowerPayload : HarpCombinator + [Description("Creates a message payload that control the enable of both LEDs' power supply.")] + public partial class CreateEnablePowerPayload { /// /// Gets or sets the value that control the enable of both LEDs' power supply. /// [Description("The value that control the enable of both LEDs' power supply.")] - public LedState Value { get; set; } + public LedState EnablePower { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that control the enable of both LEDs' power supply. + /// Creates a message payload for the EnablePower register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public LedState GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return EnablePower; } /// - /// Creates an observable sequence of message payloads - /// that control the enable of both LEDs' power supply. + /// Creates a message that control the enable of both LEDs' power supply. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the EnablePower register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.EnablePower.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that control the enable of both LEDs' power supply. + /// + [DisplayName("TimestampedEnablePowerPayload")] + [Description("Creates a timestamped message payload that control the enable of both LEDs' power supply.")] + public partial class CreateTimestampedEnablePowerPayload : CreateEnablePowerPayload + { + /// + /// Creates a timestamped message that control the enable of both LEDs' power supply. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the EnablePower register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => EnablePower.FromPayload(MessageType, Value)); + return Harp.LedArray.EnablePower.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that start/stop the LEDs according to the pulse configuration. /// [DisplayName("EnableLedModePayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that start/stop the LEDs according to the pulse configuration.")] - public partial class CreateEnableLedModePayload : HarpCombinator + [Description("Creates a message payload that start/stop the LEDs according to the pulse configuration.")] + public partial class CreateEnableLedModePayload { /// /// Gets or sets the value that start/stop the LEDs according to the pulse configuration. /// [Description("The value that start/stop the LEDs according to the pulse configuration.")] - public LedState Value { get; set; } + public LedState EnableLedMode { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that start/stop the LEDs according to the pulse configuration. + /// Creates a message payload for the EnableLedMode register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public LedState GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return EnableLedMode; } /// - /// Creates an observable sequence of message payloads - /// that start/stop the LEDs according to the pulse configuration. + /// Creates a message that start/stop the LEDs according to the pulse configuration. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the EnableLedMode register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => EnableLedMode.FromPayload(MessageType, Value)); + return Harp.LedArray.EnableLedMode.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that start/stop the LEDs according to the pulse configuration. + /// + [DisplayName("TimestampedEnableLedModePayload")] + [Description("Creates a timestamped message payload that start/stop the LEDs according to the pulse configuration.")] + public partial class CreateTimestampedEnableLedModePayload : CreateEnableLedModePayload + { + /// + /// Creates a timestamped message that start/stop the LEDs according to the pulse configuration. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the EnableLedMode register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.EnableLedMode.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that enables/disables the LEDs. /// [DisplayName("EnableLedPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that enables/disables the LEDs.")] - public partial class CreateEnableLedPayload : HarpCombinator + [Description("Creates a message payload that enables/disables the LEDs.")] + public partial class CreateEnableLedPayload { /// /// Gets or sets the value that enables/disables the LEDs. /// [Description("The value that enables/disables the LEDs.")] - public LedState Value { get; set; } + public LedState EnableLed { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that enables/disables the LEDs. + /// Creates a message payload for the EnableLed register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public LedState GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return EnableLed; } /// - /// Creates an observable sequence of message payloads - /// that enables/disables the LEDs. + /// Creates a message that enables/disables the LEDs. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the EnableLed register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.EnableLed.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that enables/disables the LEDs. + /// + [DisplayName("TimestampedEnableLedPayload")] + [Description("Creates a timestamped message payload that enables/disables the LEDs.")] + public partial class CreateTimestampedEnableLedPayload : CreateEnableLedPayload + { + /// + /// Creates a timestamped message that enables/disables the LEDs. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the EnableLed register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => EnableLed.FromPayload(MessageType, Value)); + return Harp.LedArray.EnableLed.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that state of the digital input pins. An event will be emitted when the value of any digital input pin changes. /// [DisplayName("DigitalInputStatePayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that state of the digital input pins. An event will be emitted when the value of any digital input pin changes.")] - public partial class CreateDigitalInputStatePayload : HarpCombinator + [Description("Creates a message payload that state of the digital input pins. An event will be emitted when the value of any digital input pin changes.")] + public partial class CreateDigitalInputStatePayload { /// /// Gets or sets the value that state of the digital input pins. An event will be emitted when the value of any digital input pin changes. /// [Description("The value that state of the digital input pins. An event will be emitted when the value of any digital input pin changes.")] - public DigitalInputs Value { get; set; } + public DigitalInputs DigitalInputState { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that state of the digital input pins. An event will be emitted when the value of any digital input pin changes. + /// Creates a message payload for the DigitalInputState register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public DigitalInputs GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return DigitalInputState; } /// - /// Creates an observable sequence of message payloads - /// that state of the digital input pins. An event will be emitted when the value of any digital input pin changes. + /// Creates a message that state of the digital input pins. An event will be emitted when the value of any digital input pin changes. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the DigitalInputState register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => DigitalInputState.FromPayload(MessageType, Value)); + return Harp.LedArray.DigitalInputState.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that state of the digital input pins. An event will be emitted when the value of any digital input pin changes. + /// + [DisplayName("TimestampedDigitalInputStatePayload")] + [Description("Creates a timestamped message payload that state of the digital input pins. An event will be emitted when the value of any digital input pin changes.")] + public partial class CreateTimestampedDigitalInputStatePayload : CreateDigitalInputStatePayload + { + /// + /// Creates a timestamped message that state of the digital input pins. An event will be emitted when the value of any digital input pin changes. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the DigitalInputState register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.DigitalInputState.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that configuration of the digital outputs behavior. /// [DisplayName("DigitalOutputSyncPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that configuration of the digital outputs behavior.")] - public partial class CreateDigitalOutputSyncPayload : HarpCombinator + [Description("Creates a message payload that configuration of the digital outputs behavior.")] + public partial class CreateDigitalOutputSyncPayload { /// /// Gets or sets a value that configuration of the DO0 functionality. @@ -3906,52 +3962,55 @@ public partial class CreateDigitalOutputSyncPayload : HarpCombinator public DO1SyncConfig DO1Sync { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that configuration of the digital outputs behavior. + /// Creates a message payload for the DigitalOutputSync register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public DigitalOutputSyncPayload GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + DigitalOutputSyncPayload value; + value.DO0Sync = DO0Sync; + value.DO1Sync = DO1Sync; + return value; } /// - /// Creates an observable sequence of message payloads - /// that configuration of the digital outputs behavior. + /// Creates a message that configuration of the digital outputs behavior. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the DigitalOutputSync register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.DigitalOutputSync.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that configuration of the digital outputs behavior. + /// + [DisplayName("TimestampedDigitalOutputSyncPayload")] + [Description("Creates a timestamped message payload that configuration of the digital outputs behavior.")] + public partial class CreateTimestampedDigitalOutputSyncPayload : CreateDigitalOutputSyncPayload + { + /// + /// Creates a timestamped message that configuration of the digital outputs behavior. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the DigitalOutputSync register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => - { - DigitalOutputSyncPayload value; - value.DO0Sync = DO0Sync; - value.DO1Sync = DO1Sync; - return DigitalOutputSync.FromPayload(MessageType, value); - }); + return Harp.LedArray.DigitalOutputSync.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that configuration of the digital inputs pins behavior. /// [DisplayName("DigitalInputTriggerPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that configuration of the digital inputs pins behavior.")] - public partial class CreateDigitalInputTriggerPayload : HarpCombinator + [Description("Creates a message payload that configuration of the digital inputs pins behavior.")] + public partial class CreateDigitalInputTriggerPayload { /// /// Gets or sets a value that configuration of the DIO input pin. @@ -3966,52 +4025,55 @@ public partial class CreateDigitalInputTriggerPayload : HarpCombinator public DigitalInputTriggerConfig DI1Trigger { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that configuration of the digital inputs pins behavior. + /// Creates a message payload for the DigitalInputTrigger register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public DigitalInputTriggerPayload GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + DigitalInputTriggerPayload value; + value.DI0Trigger = DI0Trigger; + value.DI1Trigger = DI1Trigger; + return value; } /// - /// Creates an observable sequence of message payloads - /// that configuration of the digital inputs pins behavior. + /// Creates a message that configuration of the digital inputs pins behavior. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the DigitalInputTrigger register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => - { - DigitalInputTriggerPayload value; - value.DI0Trigger = DI0Trigger; - value.DI1Trigger = DI1Trigger; - return DigitalInputTrigger.FromPayload(MessageType, value); - }); + return Harp.LedArray.DigitalInputTrigger.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that configuration of the digital inputs pins behavior. + /// + [DisplayName("TimestampedDigitalInputTriggerPayload")] + [Description("Creates a timestamped message payload that configuration of the digital inputs pins behavior.")] + public partial class CreateTimestampedDigitalInputTriggerPayload : CreateDigitalInputTriggerPayload + { + /// + /// Creates a timestamped message that configuration of the digital inputs pins behavior. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the DigitalInputTrigger register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.DigitalInputTrigger.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the pulse mode used by the LEDs. /// [DisplayName("PulseModePayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the pulse mode used by the LEDs.")] - public partial class CreatePulseModePayload : HarpCombinator + [Description("Creates a message payload that sets the pulse mode used by the LEDs.")] + public partial class CreatePulseModePayload { /// /// Gets or sets a value that sets the pulse mode used in LED0. @@ -4026,52 +4088,55 @@ public partial class CreatePulseModePayload : HarpCombinator public PulseModeConfig Led1Mode { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that sets the pulse mode used by the LEDs. + /// Creates a message payload for the PulseMode register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public PulseModePayload GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + PulseModePayload value; + value.Led0Mode = Led0Mode; + value.Led1Mode = Led1Mode; + return value; } /// - /// Creates an observable sequence of message payloads - /// that sets the pulse mode used by the LEDs. + /// Creates a message that sets the pulse mode used by the LEDs. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the PulseMode register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.PulseMode.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the pulse mode used by the LEDs. + /// + [DisplayName("TimestampedPulseModePayload")] + [Description("Creates a timestamped message payload that sets the pulse mode used by the LEDs.")] + public partial class CreateTimestampedPulseModePayload : CreatePulseModePayload + { + /// + /// Creates a timestamped message that sets the pulse mode used by the LEDs. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the PulseMode register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => - { - PulseModePayload value; - value.Led0Mode = Led0Mode; - value.Led1Mode = Led1Mode; - return PulseMode.FromPayload(MessageType, value); - }); + return Harp.LedArray.PulseMode.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the power to LED0, between 1 and 120 (arbitrary units). /// [DisplayName("Led0PowerPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the power to LED0, between 1 and 120 (arbitrary units).")] - public partial class CreateLed0PowerPayload : HarpCombinator + [Description("Creates a message payload that sets the power to LED0, between 1 and 120 (arbitrary units).")] + public partial class CreateLed0PowerPayload { /// /// Gets or sets the value that sets the power to LED0, between 1 and 120 (arbitrary units). @@ -4079,49 +4144,55 @@ public partial class CreateLed0PowerPayload : HarpCombinator [Range(min: 1, max: 120)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the power to LED0, between 1 and 120 (arbitrary units).")] - public byte Value { get; set; } = 1; + public byte Led0Power { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the power to LED0, between 1 and 120 (arbitrary units). + /// Creates a message payload for the Led0Power register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public byte GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0Power; } /// - /// Creates an observable sequence of message payloads - /// that sets the power to LED0, between 1 and 120 (arbitrary units). + /// Creates a message that sets the power to LED0, between 1 and 120 (arbitrary units). /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0Power register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led0Power.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0Power.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the power to LED0, between 1 and 120 (arbitrary units). + /// + [DisplayName("TimestampedLed0PowerPayload")] + [Description("Creates a timestamped message payload that sets the power to LED0, between 1 and 120 (arbitrary units).")] + public partial class CreateTimestampedLed0PowerPayload : CreateLed0PowerPayload + { + /// + /// Creates a timestamped message that sets the power to LED0, between 1 and 120 (arbitrary units). + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0Power register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led0Power.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the power to LED1, between 1 and 120 (arbitrary units). /// [DisplayName("Led1PowerPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the power to LED1, between 1 and 120 (arbitrary units).")] - public partial class CreateLed1PowerPayload : HarpCombinator + [Description("Creates a message payload that sets the power to LED1, between 1 and 120 (arbitrary units).")] + public partial class CreateLed1PowerPayload { /// /// Gets or sets the value that sets the power to LED1, between 1 and 120 (arbitrary units). @@ -4129,49 +4200,55 @@ public partial class CreateLed1PowerPayload : HarpCombinator [Range(min: 1, max: 120)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the power to LED1, between 1 and 120 (arbitrary units).")] - public byte Value { get; set; } = 1; + public byte Led1Power { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the power to LED1, between 1 and 120 (arbitrary units). + /// Creates a message payload for the Led1Power register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public byte GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1Power; } /// - /// Creates an observable sequence of message payloads - /// that sets the power to LED1, between 1 and 120 (arbitrary units). + /// Creates a message that sets the power to LED1, between 1 and 120 (arbitrary units). /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1Power register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led1Power.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1Power.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the power to LED1, between 1 and 120 (arbitrary units). + /// + [DisplayName("TimestampedLed1PowerPayload")] + [Description("Creates a timestamped message payload that sets the power to LED1, between 1 and 120 (arbitrary units).")] + public partial class CreateTimestampedLed1PowerPayload : CreateLed1PowerPayload + { + /// + /// Creates a timestamped message that sets the power to LED1, between 1 and 120 (arbitrary units). + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1Power register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led1Power.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000. /// [DisplayName("Led0PwmFrequencyPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000.")] - public partial class CreateLed0PwmFrequencyPayload : HarpCombinator + [Description("Creates a message payload that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000.")] + public partial class CreateLed0PwmFrequencyPayload { /// /// Gets or sets the value that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000. @@ -4179,49 +4256,55 @@ public partial class CreateLed0PwmFrequencyPayload : HarpCombinator [Range(min: 0.5, max: 2000)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000.")] - public float Value { get; set; } = 0.5; + public float Led0PwmFrequency { get; set; } = 0.5F; /// - /// Creates an observable sequence that contains a single message - /// that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000. + /// Creates a message payload for the Led0PwmFrequency register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PwmFrequency; } /// - /// Creates an observable sequence of message payloads - /// that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000. + /// Creates a message that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PwmFrequency register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led0PwmFrequency.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PwmFrequency.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000. + /// + [DisplayName("TimestampedLed0PwmFrequencyPayload")] + [Description("Creates a timestamped message payload that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000.")] + public partial class CreateTimestampedLed0PwmFrequencyPayload : CreateLed0PwmFrequencyPayload + { + /// + /// Creates a timestamped message that sets the frequency (Hz) of LED0 when in Pwm mode, between 0.5 and 2000. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PwmFrequency register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led0PwmFrequency.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9. /// [DisplayName("Led0PwmDutyCyclePayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9.")] - public partial class CreateLed0PwmDutyCyclePayload : HarpCombinator + [Description("Creates a message payload that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9.")] + public partial class CreateLed0PwmDutyCyclePayload { /// /// Gets or sets the value that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9. @@ -4229,49 +4312,55 @@ public partial class CreateLed0PwmDutyCyclePayload : HarpCombinator [Range(min: 0.1, max: 99.9)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9.")] - public float Value { get; set; } = 0.1; + public float Led0PwmDutyCycle { get; set; } = 0.1F; /// - /// Creates an observable sequence that contains a single message - /// that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9. + /// Creates a message payload for the Led0PwmDutyCycle register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PwmDutyCycle; } /// - /// Creates an observable sequence of message payloads - /// that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9. + /// Creates a message that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PwmDutyCycle register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.Led0PwmDutyCycle.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9. + /// + [DisplayName("TimestampedLed0PwmDutyCyclePayload")] + [Description("Creates a timestamped message payload that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9.")] + public partial class CreateTimestampedLed0PwmDutyCyclePayload : CreateLed0PwmDutyCyclePayload + { + /// + /// Creates a timestamped message that sets the duty cycle (%) of LED0 when in Pwm mode, between 0.1 and 99.9. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PwmDutyCycle register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => Led0PwmDutyCycle.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PwmDutyCycle.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535. /// [DisplayName("Led0PwmPulseCounterPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535.")] - public partial class CreateLed0PwmPulseCounterPayload : HarpCombinator + [Description("Creates a message payload that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535.")] + public partial class CreateLed0PwmPulseCounterPayload { /// /// Gets or sets the value that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535. @@ -4279,49 +4368,55 @@ public partial class CreateLed0PwmPulseCounterPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led0PwmPulseCounter { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535. + /// Creates a message payload for the Led0PwmPulseCounter register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PwmPulseCounter; } /// - /// Creates an observable sequence of message payloads - /// that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535. + /// Creates a message that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PwmPulseCounter register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led0PwmPulseCounter.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PwmPulseCounter.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed0PwmPulseCounterPayload")] + [Description("Creates a timestamped message payload that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535.")] + public partial class CreateTimestampedLed0PwmPulseCounterPayload : CreateLed0PwmPulseCounterPayload + { + /// + /// Creates a timestamped message that sets the number of pulses of LED0 when in Pwm mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PwmPulseCounter register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led0PwmPulseCounter.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led0PulseTimeOnPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed0PulseTimeOnPayload : HarpCombinator + [Description("Creates a message payload that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed0PulseTimeOnPayload { /// /// Gets or sets the value that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. @@ -4329,49 +4424,55 @@ public partial class CreateLed0PulseTimeOnPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led0PulseTimeOn { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led0PulseTimeOn register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PulseTimeOn; } /// - /// Creates an observable sequence of message payloads - /// that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PulseTimeOn register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.Led0PulseTimeOn.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed0PulseTimeOnPayload")] + [Description("Creates a timestamped message payload that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed0PulseTimeOnPayload : CreateLed0PulseTimeOnPayload + { + /// + /// Creates a timestamped message that sets the time on (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PulseTimeOn register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => Led0PulseTimeOn.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PulseTimeOn.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led0PulseTimeOffPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed0PulseTimeOffPayload : HarpCombinator + [Description("Creates a message payload that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed0PulseTimeOffPayload { /// /// Gets or sets the value that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. @@ -4379,49 +4480,55 @@ public partial class CreateLed0PulseTimeOffPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led0PulseTimeOff { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led0PulseTimeOff register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PulseTimeOff; } /// - /// Creates an observable sequence of message payloads - /// that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PulseTimeOff register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led0PulseTimeOff.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PulseTimeOff.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed0PulseTimeOffPayload")] + [Description("Creates a timestamped message payload that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed0PulseTimeOffPayload : CreateLed0PulseTimeOffPayload + { + /// + /// Creates a timestamped message that sets the time off (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PulseTimeOff register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led0PulseTimeOff.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led0PulseTimePulseCounterPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed0PulseTimePulseCounterPayload : HarpCombinator + [Description("Creates a message payload that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed0PulseTimePulseCounterPayload { /// /// Gets or sets the value that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535. @@ -4429,49 +4536,55 @@ public partial class CreateLed0PulseTimePulseCounterPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led0PulseTimePulseCounter { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led0PulseTimePulseCounter register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PulseTimePulseCounter; } /// - /// Creates an observable sequence of message payloads - /// that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PulseTimePulseCounter register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.Led0PulseTimePulseCounter.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed0PulseTimePulseCounterPayload")] + [Description("Creates a timestamped message payload that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed0PulseTimePulseCounterPayload : CreateLed0PulseTimePulseCounterPayload + { + /// + /// Creates a timestamped message that sets the number of pulses of LED0 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PulseTimePulseCounter register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => Led0PulseTimePulseCounter.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PulseTimePulseCounter.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led0PulseTimeTailPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed0PulseTimeTailPayload : HarpCombinator + [Description("Creates a message payload that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed0PulseTimeTailPayload { /// /// Gets or sets the value that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. @@ -4479,49 +4592,55 @@ public partial class CreateLed0PulseTimeTailPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led0PulseTimeTail { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led0PulseTimeTail register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PulseTimeTail; } /// - /// Creates an observable sequence of message payloads - /// that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PulseTimeTail register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led0PulseTimeTail.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PulseTimeTail.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed0PulseTimeTailPayload")] + [Description("Creates a timestamped message payload that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed0PulseTimeTailPayload : CreateLed0PulseTimeTailPayload + { + /// + /// Creates a timestamped message that sets the wait time between pulses (milliseconds) of LED0 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PulseTimeTail register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led0PulseTimeTail.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led0PulseRepeatCounterPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed0PulseRepeatCounterPayload : HarpCombinator + [Description("Creates a message payload that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed0PulseRepeatCounterPayload { /// /// Gets or sets the value that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535. @@ -4529,49 +4648,55 @@ public partial class CreateLed0PulseRepeatCounterPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led0PulseRepeatCounter { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led0PulseRepeatCounter register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PulseRepeatCounter; } /// - /// Creates an observable sequence of message payloads - /// that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PulseRepeatCounter register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led0PulseRepeatCounter.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PulseRepeatCounter.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed0PulseRepeatCounterPayload")] + [Description("Creates a timestamped message payload that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed0PulseRepeatCounterPayload : CreateLed0PulseRepeatCounterPayload + { + /// + /// Creates a timestamped message that sets the number of repetitions of LED0 pulse protocol when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PulseRepeatCounter register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led0PulseRepeatCounter.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000. /// [DisplayName("Led1PwmFrequencyPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000.")] - public partial class CreateLed1PwmFrequencyPayload : HarpCombinator + [Description("Creates a message payload that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000.")] + public partial class CreateLed1PwmFrequencyPayload { /// /// Gets or sets the value that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000. @@ -4579,49 +4704,55 @@ public partial class CreateLed1PwmFrequencyPayload : HarpCombinator [Range(min: 0.5, max: 2000)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000.")] - public float Value { get; set; } = 0.5; + public float Led1PwmFrequency { get; set; } = 0.5F; /// - /// Creates an observable sequence that contains a single message - /// that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000. + /// Creates a message payload for the Led1PwmFrequency register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PwmFrequency; } /// - /// Creates an observable sequence of message payloads - /// that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000. + /// Creates a message that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PwmFrequency register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led1PwmFrequency.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PwmFrequency.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000. + /// + [DisplayName("TimestampedLed1PwmFrequencyPayload")] + [Description("Creates a timestamped message payload that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000.")] + public partial class CreateTimestampedLed1PwmFrequencyPayload : CreateLed1PwmFrequencyPayload + { + /// + /// Creates a timestamped message that sets the frequency (Hz) of LED1 when in Pwm mode, between 0.5 and 2000. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PwmFrequency register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led1PwmFrequency.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9. /// [DisplayName("Led1PwmDutyCyclePayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9.")] - public partial class CreateLed1PwmDutyCyclePayload : HarpCombinator + [Description("Creates a message payload that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9.")] + public partial class CreateLed1PwmDutyCyclePayload { /// /// Gets or sets the value that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9. @@ -4629,49 +4760,55 @@ public partial class CreateLed1PwmDutyCyclePayload : HarpCombinator [Range(min: 0.1, max: 99.9)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9.")] - public float Value { get; set; } = 0.1; + public float Led1PwmDutyCycle { get; set; } = 0.1F; /// - /// Creates an observable sequence that contains a single message - /// that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9. + /// Creates a message payload for the Led1PwmDutyCycle register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PwmDutyCycle; } /// - /// Creates an observable sequence of message payloads - /// that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9. + /// Creates a message that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PwmDutyCycle register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.Led1PwmDutyCycle.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9. + /// + [DisplayName("TimestampedLed1PwmDutyCyclePayload")] + [Description("Creates a timestamped message payload that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9.")] + public partial class CreateTimestampedLed1PwmDutyCyclePayload : CreateLed1PwmDutyCyclePayload + { + /// + /// Creates a timestamped message that sets the duty cycle (%) of LED1 when in Pwm mode, between 0.1 and 99.9. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PwmDutyCycle register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => Led1PwmDutyCycle.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PwmDutyCycle.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535. /// [DisplayName("Led1PwmPulseCounterPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535.")] - public partial class CreateLed1PwmPulseCounterPayload : HarpCombinator + [Description("Creates a message payload that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535.")] + public partial class CreateLed1PwmPulseCounterPayload { /// /// Gets or sets the value that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535. @@ -4679,49 +4816,55 @@ public partial class CreateLed1PwmPulseCounterPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led1PwmPulseCounter { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535. + /// Creates a message payload for the Led1PwmPulseCounter register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PwmPulseCounter; } /// - /// Creates an observable sequence of message payloads - /// that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535. + /// Creates a message that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PwmPulseCounter register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led1PwmPulseCounter.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PwmPulseCounter.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed1PwmPulseCounterPayload")] + [Description("Creates a timestamped message payload that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535.")] + public partial class CreateTimestampedLed1PwmPulseCounterPayload : CreateLed1PwmPulseCounterPayload + { + /// + /// Creates a timestamped message that sets the number of pulses of LED1 when in Pwm mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PwmPulseCounter register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led1PwmPulseCounter.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led1PulseTimeOnPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed1PulseTimeOnPayload : HarpCombinator + [Description("Creates a message payload that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed1PulseTimeOnPayload { /// /// Gets or sets the value that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. @@ -4729,49 +4872,55 @@ public partial class CreateLed1PulseTimeOnPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led1PulseTimeOn { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led1PulseTimeOn register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PulseTimeOn; } /// - /// Creates an observable sequence of message payloads - /// that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PulseTimeOn register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.Led1PulseTimeOn.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed1PulseTimeOnPayload")] + [Description("Creates a timestamped message payload that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed1PulseTimeOnPayload : CreateLed1PulseTimeOnPayload + { + /// + /// Creates a timestamped message that sets the time on (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PulseTimeOn register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => Led1PulseTimeOn.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PulseTimeOn.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led1PulseTimeOffPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed1PulseTimeOffPayload : HarpCombinator + [Description("Creates a message payload that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed1PulseTimeOffPayload { /// /// Gets or sets the value that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. @@ -4779,49 +4928,55 @@ public partial class CreateLed1PulseTimeOffPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led1PulseTimeOff { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led1PulseTimeOff register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PulseTimeOff; } /// - /// Creates an observable sequence of message payloads - /// that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PulseTimeOff register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led1PulseTimeOff.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PulseTimeOff.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed1PulseTimeOffPayload")] + [Description("Creates a timestamped message payload that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed1PulseTimeOffPayload : CreateLed1PulseTimeOffPayload + { + /// + /// Creates a timestamped message that sets the time off (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PulseTimeOff register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led1PulseTimeOff.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led1PulseTimePulseCounterPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed1PulseTimePulseCounterPayload : HarpCombinator + [Description("Creates a message payload that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed1PulseTimePulseCounterPayload { /// /// Gets or sets the value that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535. @@ -4829,49 +4984,55 @@ public partial class CreateLed1PulseTimePulseCounterPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led1PulseTimePulseCounter { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led1PulseTimePulseCounter register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PulseTimePulseCounter; } /// - /// Creates an observable sequence of message payloads - /// that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PulseTimePulseCounter register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.Led1PulseTimePulseCounter.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed1PulseTimePulseCounterPayload")] + [Description("Creates a timestamped message payload that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed1PulseTimePulseCounterPayload : CreateLed1PulseTimePulseCounterPayload + { + /// + /// Creates a timestamped message that sets the number of pulses of LED1 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PulseTimePulseCounter register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => Led1PulseTimePulseCounter.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PulseTimePulseCounter.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led1PulseTimeTailPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed1PulseTimeTailPayload : HarpCombinator + [Description("Creates a message payload that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed1PulseTimeTailPayload { /// /// Gets or sets the value that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. @@ -4879,49 +5040,55 @@ public partial class CreateLed1PulseTimeTailPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led1PulseTimeTail { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led1PulseTimeTail register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PulseTimeTail; } /// - /// Creates an observable sequence of message payloads - /// that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PulseTimeTail register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led1PulseTimeTail.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PulseTimeTail.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed1PulseTimeTailPayload")] + [Description("Creates a timestamped message payload that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed1PulseTimeTailPayload : CreateLed1PulseTimeTailPayload + { + /// + /// Creates a timestamped message that sets the wait time between pulses (milliseconds) of LED1 when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PulseTimeTail register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led1PulseTimeTail.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535. /// [DisplayName("Led1PulseRepeatCounterPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535.")] - public partial class CreateLed1PulseRepeatCounterPayload : HarpCombinator + [Description("Creates a message payload that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535.")] + public partial class CreateLed1PulseRepeatCounterPayload { /// /// Gets or sets the value that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535. @@ -4929,289 +5096,325 @@ public partial class CreateLed1PulseRepeatCounterPayload : HarpCombinator [Range(min: 1, max: 65535)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535.")] - public ushort Value { get; set; } = 1; + public ushort Led1PulseRepeatCounter { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535. + /// Creates a message payload for the Led1PulseRepeatCounter register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public ushort GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PulseRepeatCounter; } /// - /// Creates an observable sequence of message payloads - /// that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535. + /// Creates a message that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PulseRepeatCounter register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led1PulseRepeatCounter.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PulseRepeatCounter.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535. + /// + [DisplayName("TimestampedLed1PulseRepeatCounterPayload")] + [Description("Creates a timestamped message payload that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535.")] + public partial class CreateTimestampedLed1PulseRepeatCounterPayload : CreateLed1PulseRepeatCounterPayload + { + /// + /// Creates a timestamped message that sets the number of repetitions of LED1 pulse protocol when in PulseTime mode, between 1 and 65535. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PulseRepeatCounter register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led1PulseRepeatCounter.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that get the real frequency (Hz) of LED0 when in Pwm mode. /// [DisplayName("Led0PwmRealPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that get the real frequency (Hz) of LED0 when in Pwm mode.")] - public partial class CreateLed0PwmRealPayload : HarpCombinator + [Description("Creates a message payload that get the real frequency (Hz) of LED0 when in Pwm mode.")] + public partial class CreateLed0PwmRealPayload { /// /// Gets or sets the value that get the real frequency (Hz) of LED0 when in Pwm mode. /// [Description("The value that get the real frequency (Hz) of LED0 when in Pwm mode.")] - public float Value { get; set; } + public float Led0PwmReal { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that get the real frequency (Hz) of LED0 when in Pwm mode. + /// Creates a message payload for the Led0PwmReal register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PwmReal; } /// - /// Creates an observable sequence of message payloads - /// that get the real frequency (Hz) of LED0 when in Pwm mode. + /// Creates a message that get the real frequency (Hz) of LED0 when in Pwm mode. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PwmReal register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led0PwmReal.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PwmReal.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that get the real frequency (Hz) of LED0 when in Pwm mode. + /// + [DisplayName("TimestampedLed0PwmRealPayload")] + [Description("Creates a timestamped message payload that get the real frequency (Hz) of LED0 when in Pwm mode.")] + public partial class CreateTimestampedLed0PwmRealPayload : CreateLed0PwmRealPayload + { + /// + /// Creates a timestamped message that get the real frequency (Hz) of LED0 when in Pwm mode. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PwmReal register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led0PwmReal.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that get the real duty cycle (%) of LED0 when in Pwm mode. /// [DisplayName("Led0PwmDutyCycleRealPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that get the real duty cycle (%) of LED0 when in Pwm mode.")] - public partial class CreateLed0PwmDutyCycleRealPayload : HarpCombinator + [Description("Creates a message payload that get the real duty cycle (%) of LED0 when in Pwm mode.")] + public partial class CreateLed0PwmDutyCycleRealPayload { /// /// Gets or sets the value that get the real duty cycle (%) of LED0 when in Pwm mode. /// [Description("The value that get the real duty cycle (%) of LED0 when in Pwm mode.")] - public float Value { get; set; } + public float Led0PwmDutyCycleReal { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that get the real duty cycle (%) of LED0 when in Pwm mode. + /// Creates a message payload for the Led0PwmDutyCycleReal register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led0PwmDutyCycleReal; } /// - /// Creates an observable sequence of message payloads - /// that get the real duty cycle (%) of LED0 when in Pwm mode. + /// Creates a message that get the real duty cycle (%) of LED0 when in Pwm mode. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led0PwmDutyCycleReal register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.Led0PwmDutyCycleReal.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that get the real duty cycle (%) of LED0 when in Pwm mode. + /// + [DisplayName("TimestampedLed0PwmDutyCycleRealPayload")] + [Description("Creates a timestamped message payload that get the real duty cycle (%) of LED0 when in Pwm mode.")] + public partial class CreateTimestampedLed0PwmDutyCycleRealPayload : CreateLed0PwmDutyCycleRealPayload + { + /// + /// Creates a timestamped message that get the real duty cycle (%) of LED0 when in Pwm mode. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led0PwmDutyCycleReal register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => Led0PwmDutyCycleReal.FromPayload(MessageType, Value)); + return Harp.LedArray.Led0PwmDutyCycleReal.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that get the real frequency (Hz) of LED1 when in Pwm mode. /// [DisplayName("Led1PwmRealPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that get the real frequency (Hz) of LED1 when in Pwm mode.")] - public partial class CreateLed1PwmRealPayload : HarpCombinator + [Description("Creates a message payload that get the real frequency (Hz) of LED1 when in Pwm mode.")] + public partial class CreateLed1PwmRealPayload { /// /// Gets or sets the value that get the real frequency (Hz) of LED1 when in Pwm mode. /// [Description("The value that get the real frequency (Hz) of LED1 when in Pwm mode.")] - public float Value { get; set; } + public float Led1PwmReal { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that get the real frequency (Hz) of LED1 when in Pwm mode. + /// Creates a message payload for the Led1PwmReal register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return Led1PwmReal; } /// - /// Creates an observable sequence of message payloads - /// that get the real frequency (Hz) of LED1 when in Pwm mode. + /// Creates a message that get the real frequency (Hz) of LED1 when in Pwm mode. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the Led1PwmReal register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => Led1PwmReal.FromPayload(MessageType, Value)); + return Harp.LedArray.Led1PwmReal.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that get the real frequency (Hz) of LED1 when in Pwm mode. + /// + [DisplayName("TimestampedLed1PwmRealPayload")] + [Description("Creates a timestamped message payload that get the real frequency (Hz) of LED1 when in Pwm mode.")] + public partial class CreateTimestampedLed1PwmRealPayload : CreateLed1PwmRealPayload + { + /// + /// Creates a timestamped message that get the real frequency (Hz) of LED1 when in Pwm mode. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the Led1PwmReal register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.Led1PwmReal.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that get the real duty cycle (%) of LED1 when in Pwm mode. /// [DisplayName("LedD1PwmDutyCycleRealPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that get the real duty cycle (%) of LED1 when in Pwm mode.")] - public partial class CreateLedD1PwmDutyCycleRealPayload : HarpCombinator + [Description("Creates a message payload that get the real duty cycle (%) of LED1 when in Pwm mode.")] + public partial class CreateLedD1PwmDutyCycleRealPayload { /// /// Gets or sets the value that get the real duty cycle (%) of LED1 when in Pwm mode. /// [Description("The value that get the real duty cycle (%) of LED1 when in Pwm mode.")] - public float Value { get; set; } + public float LedD1PwmDutyCycleReal { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that get the real duty cycle (%) of LED1 when in Pwm mode. + /// Creates a message payload for the LedD1PwmDutyCycleReal register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public float GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return LedD1PwmDutyCycleReal; } /// - /// Creates an observable sequence of message payloads - /// that get the real duty cycle (%) of LED1 when in Pwm mode. + /// Creates a message that get the real duty cycle (%) of LED1 when in Pwm mode. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the LedD1PwmDutyCycleReal register. + public HarpMessage GetMessage(MessageType messageType) { - return source.Select(_ => LedD1PwmDutyCycleReal.FromPayload(MessageType, Value)); + return Harp.LedArray.LedD1PwmDutyCycleReal.FromPayload(messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a timestamped message payload + /// that get the real duty cycle (%) of LED1 when in Pwm mode. + /// + [DisplayName("TimestampedLedD1PwmDutyCycleRealPayload")] + [Description("Creates a timestamped message payload that get the real duty cycle (%) of LED1 when in Pwm mode.")] + public partial class CreateTimestampedLedD1PwmDutyCycleRealPayload : CreateLedD1PwmDutyCycleRealPayload + { + /// + /// Creates a timestamped message that get the real duty cycle (%) of LED1 when in Pwm mode. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the LedD1PwmDutyCycleReal register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) + { + return Harp.LedArray.LedD1PwmDutyCycleReal.FromPayload(timestamp, messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a message payload /// that write the state of the auxiliary digital output bit. /// [DisplayName("AuxDigitalOutputStatePayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that write the state of the auxiliary digital output bit.")] - public partial class CreateAuxDigitalOutputStatePayload : HarpCombinator + [Description("Creates a message payload that write the state of the auxiliary digital output bit.")] + public partial class CreateAuxDigitalOutputStatePayload { /// /// Gets or sets the value that write the state of the auxiliary digital output bit. /// [Description("The value that write the state of the auxiliary digital output bit.")] - public AuxDigitalOutputs Value { get; set; } + public AuxDigitalOutputs AuxDigitalOutputState { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that write the state of the auxiliary digital output bit. + /// Creates a message payload for the AuxDigitalOutputState register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public AuxDigitalOutputs GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return AuxDigitalOutputState; } /// - /// Creates an observable sequence of message payloads - /// that write the state of the auxiliary digital output bit. + /// Creates a message that write the state of the auxiliary digital output bit. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the AuxDigitalOutputState register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.AuxDigitalOutputState.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that write the state of the auxiliary digital output bit. + /// + [DisplayName("TimestampedAuxDigitalOutputStatePayload")] + [Description("Creates a timestamped message payload that write the state of the auxiliary digital output bit.")] + public partial class CreateTimestampedAuxDigitalOutputStatePayload : CreateAuxDigitalOutputStatePayload + { + /// + /// Creates a timestamped message that write the state of the auxiliary digital output bit. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the AuxDigitalOutputState register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => AuxDigitalOutputState.FromPayload(MessageType, Value)); + return Harp.LedArray.AuxDigitalOutputState.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that sets the power to be applied to auxiliary LED, between 1 and 120. /// [DisplayName("AuxLedPowerPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that sets the power to be applied to auxiliary LED, between 1 and 120.")] - public partial class CreateAuxLedPowerPayload : HarpCombinator + [Description("Creates a message payload that sets the power to be applied to auxiliary LED, between 1 and 120.")] + public partial class CreateAuxLedPowerPayload { /// /// Gets or sets the value that sets the power to be applied to auxiliary LED, between 1 and 120. @@ -5219,134 +5422,153 @@ public partial class CreateAuxLedPowerPayload : HarpCombinator [Range(min: 1, max: 120)] [Editor(DesignTypes.NumericUpDownEditor, DesignTypes.UITypeEditor)] [Description("The value that sets the power to be applied to auxiliary LED, between 1 and 120.")] - public byte Value { get; set; } = 1; + public byte AuxLedPower { get; set; } = 1; /// - /// Creates an observable sequence that contains a single message - /// that sets the power to be applied to auxiliary LED, between 1 and 120. + /// Creates a message payload for the AuxLedPower register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public byte GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return AuxLedPower; } /// - /// Creates an observable sequence of message payloads - /// that sets the power to be applied to auxiliary LED, between 1 and 120. + /// Creates a message that sets the power to be applied to auxiliary LED, between 1 and 120. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the AuxLedPower register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.AuxLedPower.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that sets the power to be applied to auxiliary LED, between 1 and 120. + /// + [DisplayName("TimestampedAuxLedPowerPayload")] + [Description("Creates a timestamped message payload that sets the power to be applied to auxiliary LED, between 1 and 120.")] + public partial class CreateTimestampedAuxLedPowerPayload : CreateAuxLedPowerPayload + { + /// + /// Creates a timestamped message that sets the power to be applied to auxiliary LED, between 1 and 120. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the AuxLedPower register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => AuxLedPower.FromPayload(MessageType, Value)); + return Harp.LedArray.AuxLedPower.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that write the state of digital output lines. /// [DisplayName("DigitalOutputStatePayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that write the state of digital output lines.")] - public partial class CreateDigitalOutputStatePayload : HarpCombinator + [Description("Creates a message payload that write the state of digital output lines.")] + public partial class CreateDigitalOutputStatePayload { /// /// Gets or sets the value that write the state of digital output lines. /// [Description("The value that write the state of digital output lines.")] - public DigitalOutputs Value { get; set; } + public DigitalOutputs DigitalOutputState { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that write the state of digital output lines. + /// Creates a message payload for the DigitalOutputState register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public DigitalOutputs GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return DigitalOutputState; } /// - /// Creates an observable sequence of message payloads - /// that write the state of digital output lines. + /// Creates a message that write the state of digital output lines. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the DigitalOutputState register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.DigitalOutputState.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that write the state of digital output lines. + /// + [DisplayName("TimestampedDigitalOutputStatePayload")] + [Description("Creates a timestamped message payload that write the state of digital output lines.")] + public partial class CreateTimestampedDigitalOutputStatePayload : CreateDigitalOutputStatePayload + { + /// + /// Creates a timestamped message that write the state of digital output lines. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the DigitalOutputState register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => DigitalOutputState.FromPayload(MessageType, Value)); + return Harp.LedArray.DigitalOutputState.FromPayload(timestamp, messageType, GetPayload()); } } /// - /// Represents an operator that creates a sequence of message payloads + /// Represents an operator that creates a message payload /// that specifies all the active events in the device. /// [DisplayName("EnableEventsPayload")] - [WorkflowElementCategory(ElementCategory.Transform)] - [Description("Creates a sequence of message payloads that specifies all the active events in the device.")] - public partial class CreateEnableEventsPayload : HarpCombinator + [Description("Creates a message payload that specifies all the active events in the device.")] + public partial class CreateEnableEventsPayload { /// /// Gets or sets the value that specifies all the active events in the device. /// [Description("The value that specifies all the active events in the device.")] - public LedArrayEvents Value { get; set; } + public LedArrayEvents EnableEvents { get; set; } /// - /// Creates an observable sequence that contains a single message - /// that specifies all the active events in the device. + /// Creates a message payload for the EnableEvents register. /// - /// - /// A sequence containing a single object - /// representing the created message payload. - /// - public IObservable Process() + /// The created message payload value. + public LedArrayEvents GetPayload() { - return Process(Observable.Return(System.Reactive.Unit.Default)); + return EnableEvents; } /// - /// Creates an observable sequence of message payloads - /// that specifies all the active events in the device. + /// Creates a message that specifies all the active events in the device. /// - /// - /// The type of the elements in the sequence. - /// - /// - /// The sequence containing the notifications used for emitting message payloads. - /// - /// - /// A sequence of objects representing each - /// created message payload. - /// - public IObservable Process(IObservable source) + /// Specifies the type of the created message. + /// A new message for the EnableEvents register. + public HarpMessage GetMessage(MessageType messageType) + { + return Harp.LedArray.EnableEvents.FromPayload(messageType, GetPayload()); + } + } + + /// + /// Represents an operator that creates a timestamped message payload + /// that specifies all the active events in the device. + /// + [DisplayName("TimestampedEnableEventsPayload")] + [Description("Creates a timestamped message payload that specifies all the active events in the device.")] + public partial class CreateTimestampedEnableEventsPayload : CreateEnableEventsPayload + { + /// + /// Creates a timestamped message that specifies all the active events in the device. + /// + /// The timestamp of the message payload, in seconds. + /// Specifies the type of the created message. + /// A new timestamped message for the EnableEvents register. + public HarpMessage GetMessage(double timestamp, MessageType messageType) { - return source.Select(_ => EnableEvents.FromPayload(MessageType, Value)); + return Harp.LedArray.EnableEvents.FromPayload(timestamp, messageType, GetPayload()); } } @@ -5443,6 +5665,7 @@ public PulseModePayload( [Flags] public enum LedState : byte { + None = 0x0, Led0On = 0x1, Led1On = 0x2, Led0Off = 0x4, @@ -5455,6 +5678,7 @@ public enum LedState : byte [Flags] public enum DigitalInputs : byte { + None = 0x0, DI0 = 0x1, DI1 = 0x2 } @@ -5465,6 +5689,7 @@ public enum DigitalInputs : byte [Flags] public enum AuxDigitalOutputs : byte { + None = 0x0, Aux0Set = 0x1, Aux1Set = 0x2, Aux0Clear = 0x4, @@ -5477,6 +5702,7 @@ public enum AuxDigitalOutputs : byte [Flags] public enum DigitalOutputs : byte { + None = 0x0, DO0Set = 0x1, DO1Set = 0x2, DO0Clear = 0x4, @@ -5489,6 +5715,7 @@ public enum DigitalOutputs : byte [Flags] public enum LedArrayEvents : byte { + None = 0x0, EnableLed = 0x1, DigitalInputState = 0x2 } diff --git a/Interface/Harp.LedArray/Harp.LedArray.csproj b/Interface/Harp.LedArray/Harp.LedArray.csproj index 0ecee1b..c2de8d7 100644 --- a/Interface/Harp.LedArray/Harp.LedArray.csproj +++ b/Interface/Harp.LedArray/Harp.LedArray.csproj @@ -1,26 +1,34 @@ - Harp.LedArray - - Copyright © 2023 + Harp - LedArray + harp-tech + Copyright © harp-tech and Contributors 2023 true snupkg true - Bonsai Library containing interfaces for data acquisition and control of Harp.LedArray devices. + Bonsai Library containing interfaces for data acquisition and control of Harp LedArray devices. true Harp LedArray Bonsai Rx - - - - + https://harp-tech.org + https://github.com/harp-tech/device.ledarray.git + git + icon.png + LICENSE + ..\bin\$(Configuration) net462;netstandard2.0 - 0.1.0-preview2 + 0.1.0 + 9.0 - + + + + + + diff --git a/Interface/LICENSE b/Interface/LICENSE index 765b3ab..ed8ab13 100644 --- a/Interface/LICENSE +++ b/Interface/LICENSE @@ -1,4 +1,4 @@ -Copyright (C) 2023 harp-tech +Copyright (C) 2023 harp-tech and Contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in diff --git a/Interface/icon.png b/Interface/icon.png new file mode 100644 index 0000000..836a850 Binary files /dev/null and b/Interface/icon.png differ