Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Characteristic Locus
Inheritance object > RgbPwmLed
Implements IRgbPwmLed
Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString()
Namespace Meadow.Foundation.Leds
Assembly Meadow.Foundation.dll

Syntax

public class RgbPwmLed : IRgbPwmLed

Constructors

RgbPwmLed(IPin, IPin, IPin, CommonType)

Create instance of RgbPwmLed

Declaration
public RgbPwmLed(IPin redPwmPin, IPin greenPwmPin, IPin bluePwmPin, CommonType commonType = CommonType.CommonCathode)

Parameters

Type Name Description
IPin redPwmPin

The PWM pin for the red LED

IPin greenPwmPin

The PWM pin for the green LED

IPin bluePwmPin

The PWM pin for the blue LED

CommonType commonType

Common anode or common cathode

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

RgbPwmLed(IPin, IPin, IPin, Voltage, Voltage, Voltage, CommonType)

Create instance of RgbPwmLed

Declaration
public RgbPwmLed(IPin redPwmPin, IPin greenPwmPin, IPin bluePwmPin, Voltage redLedForwardVoltage, Voltage greenLedForwardVoltage, Voltage blueLedForwardVoltage, CommonType commonType = CommonType.CommonCathode)

Parameters

Type Name Description
IPin redPwmPin

The PWM pin for the red LED

IPin greenPwmPin

The PWM pin for the green LED

IPin bluePwmPin

The PWM pin for the blue LED

Voltage redLedForwardVoltage

The forward voltage for the red LED

Voltage greenLedForwardVoltage

The forward voltage for the green LED

Voltage blueLedForwardVoltage

The forward voltage for the blue LED

CommonType commonType

Common anode or common cathode

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

RgbPwmLed(IPwmPort, IPwmPort, IPwmPort, CommonType)

Create instance of RgbPwmLed

Declaration
public RgbPwmLed(IPwmPort redPwmPort, IPwmPort greenPwmPort, IPwmPort bluePwmPort, CommonType commonType = CommonType.CommonCathode)

Parameters

Type Name Description
IPwmPort redPwmPort

The PWM port for the red LED

IPwmPort greenPwmPort

The PWM port for the green LED

IPwmPort bluePwmPort

The PWM port for the blue LED

CommonType commonType

Common anode or common cathode

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

RgbPwmLed(IPwmPort, IPwmPort, IPwmPort, Voltage, Voltage, Voltage, CommonType)

Create instance of RgbPwmLed

Declaration
public RgbPwmLed(IPwmPort redPwmPort, IPwmPort greenPwmPort, IPwmPort bluePwmPort, Voltage redLedForwardVoltage, Voltage greenLedForwardVoltage, Voltage blueLedForwardVoltage, CommonType commonType = CommonType.CommonCathode)

Parameters

Type Name Description
IPwmPort redPwmPort

The PWM port for the red LED

IPwmPort greenPwmPort

The PWM port for the green LED

IPwmPort bluePwmPort

The PWM port for the blue LED

Voltage redLedForwardVoltage

The forward voltage for the red LED

Voltage greenLedForwardVoltage

The forward voltage for the green LED

Voltage blueLedForwardVoltage

The forward voltage for the blue LED

CommonType commonType

Common anode or common cathode

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Properties

BlueForwardVoltage

The blue LED forward voltage

Declaration
public Voltage BlueForwardVoltage { get; protected set; }

Property Value

Type Description
Voltage

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

BluePwm

The blue LED port

Declaration
protected IPwmPort BluePwm { get; set; }

Property Value

Type Description
IPwmPort

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Brightness

The brightness value assigned to the LED

Declaration
public float Brightness { get; protected set; }

Property Value

Type Description
float

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Color

The current LED color

Declaration
public Color Color { get; protected set; }

Property Value

Type Description
Color

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Common

The common type (common anode or common cathode)

Declaration
public CommonType Common { get; protected set; }

Property Value

Type Description
CommonType

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

GreenForwardVoltage

The green LED forward voltage

Declaration
public Voltage GreenForwardVoltage { get; protected set; }

Property Value

Type Description
Voltage

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

GreenPwm

The green LED port

Declaration
protected IPwmPort GreenPwm { get; set; }

Property Value

Type Description
IPwmPort

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

IsOn

Turns on LED with current color or turns it off

Declaration
public bool IsOn { get; set; }

Property Value

Type Description
bool

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

MAX_FORWARD_VOLTAGE

Maximum forward voltage (3.3 Volts)

Declaration
public Voltage MAX_FORWARD_VOLTAGE { get; }

Property Value

Type Description
Voltage

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

MIN_FORWARD_VOLTAGE

Minimum forward voltage (0 Volts)

Declaration
public Voltage MIN_FORWARD_VOLTAGE { get; }

Property Value

Type Description
Voltage

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

RedForwardVoltage

The red LED forward voltage

Declaration
public Voltage RedForwardVoltage { get; protected set; }

Property Value

Type Description
Voltage

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

RedPwm

The red LED port

Declaration
protected IPwmPort RedPwm { get; set; }

Property Value

Type Description
IPwmPort

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Methods

ResetPwmPorts()

Resets all PWM ports

Declaration
protected void ResetPwmPorts()

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

SetBrightness(float)

Set the led brightness

Declaration
public void SetBrightness(float brightness)

Parameters

Type Name Description
float brightness

Valid values are from 0 to 1, inclusive

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

SetColor(Color, float)

Sets the current color of the LED

Declaration
public void SetColor(Color color, float brightness = 1)

Parameters

Type Name Description
Color color

The LED color

float brightness

Valid values are from 0 to 1, inclusive

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Start the Blink animation which sets the brightness of the LED alternating between a low and high brightness On an interval of 1 second (500ms on, 500ms off)

Declaration
public Task StartBlink(Color color, float highBrightness = 1, float lowBrightness = 0)

Parameters

Type Name Description
Color color

The LED color

float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task
RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Start the Blink animation which sets the brightness of the LED alternating between a low and high brightness setting, using the durations provided.

Declaration
public Task StartBlink(Color color, TimeSpan onDuration, TimeSpan offDuration, float highBrightness = 1, float lowBrightness = 0)

Parameters

Type Name Description
Color color

The LED color

TimeSpan onDuration

The duration the LED stays on

TimeSpan offDuration

The duration the LED stays off

float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task
RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Start the Blink animation which sets the brightness of the LED alternating between a low and high brightness On an interval of 1 second (500ms on, 500ms off)

Declaration
public Task StartBlink(float highBrightness = 1, float lowBrightness = 0)

Parameters

Type Name Description
float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task
RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

Start the Blink animation which sets the brightness of the LED alternating between a low and high brightness setting, using the durations provided.

Declaration
public Task StartBlink(TimeSpan onDuration, TimeSpan offDuration, float highBrightness = 1, float lowBrightness = 0)

Parameters

Type Name Description
TimeSpan onDuration

The duration the LED stays on

TimeSpan offDuration

The duration the LED stays off

float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task
RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

StartPulse(Color, float, float)

Start the Pulse animation which gradually alternates the brightness of the LED between a low and high brightness setting with a cycle time of 600ms

Declaration
public Task StartPulse(Color color, float highBrightness = 1, float lowBrightness = 0.15)

Parameters

Type Name Description
Color color

The LED color

float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

StartPulse(Color, TimeSpan, float, float)

Start the Pulse animation which gradually alternates the brightness of the LED between a low and high brightness setting, using the durations provided.

Declaration
public Task StartPulse(Color color, TimeSpan pulseDuration, float highBrightness = 1, float lowBrightness = 0.15)

Parameters

Type Name Description
Color color

The LED color

TimeSpan pulseDuration

The pulse animation duration

float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

StartPulse(float, float)

Start the Pulse animation which gradually alternates the brightness of the LED between a low and high brightness setting with a cycle time of 600ms

Declaration
public Task StartPulse(float highBrightness = 1, float lowBrightness = 0.15)

Parameters

Type Name Description
float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

StartPulse(TimeSpan, float, float)

Start the Pulse animation which gradually alternates the brightness of the LED between a low and high brightness setting, using the durations provided.

Declaration
public Task StartPulse(TimeSpan pulseDuration, float highBrightness = 1, float lowBrightness = 0.15)

Parameters

Type Name Description
TimeSpan pulseDuration

The pulse animation duration

float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Returns

Type Description
Task

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

StopAnimation()

Stops the current LED animation

Declaration
public Task StopAnimation()

Returns

Type Description
Task

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

ValidateBrightness(float, float)

Validates LED brightness to ensure they're within the range 0 (off) - 1 (full brightness)

Declaration
protected void ValidateBrightness(float highBrightness, float lowBrightness)

Parameters

Type Name Description
float highBrightness

The maximum brightness of the animation

float lowBrightness

The minimum brightness of the animation

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example

ValidateForwardVoltages(Voltage, Voltage, Voltage)

Validates forward voltages to ensure they're within the range MIN_FORWARD_VOLTAGE to MAX_FORWARD_VOLTAGE

Declaration
protected void ValidateForwardVoltages(Voltage redLedForwardVoltage, Voltage greenLedForwardVoltage, Voltage blueLedForwardVoltage)

Parameters

Type Name Description
Voltage redLedForwardVoltage

The forward voltage for the red LED

Voltage greenLedForwardVoltage

The forward voltage for the green LED

Voltage blueLedForwardVoltage

The forward voltage for the blue LED

Remarks

RgbPwmLed
Status Status badge: working
Source code GitHub
NuGet package NuGet Gallery for Meadow.Foundation

RgbPwmLed represents an RGB LED whose color is controlled by the duty-cycle of three PWM signals. Can be used both with LEDs that have been current limited with in-series resistors, or LEDs without resistors.

Controlling an RGB LED via a PWM signal is more power efficient than using a current-limiting resistor, and it provides more control; allowing thousands of different colors, as opposed to the 8 colors of non-PWM powered RGB LED.

To use without resistors, pass in the forward voltages (voltage drop) of each of the LED components to the redLedForwardVoltage, greenLedForwardVoltage, and blueLedForwardVoltage, constructor parameters, and the class will limit its output to the maximum forward voltage rating for those LEDs.

To use with an LED that has a resistor in series, pass 0.0 or TypicalForwardVoltage.ResistorLimited for the forwardVoltage parameter.

Code Example

RgbPwmLed onboardLed;

public override Task Initialize()
{
    Resolver.Log.Info("Creating peripherals...");

    onboardLed = new RgbPwmLed(
        Device.Pins.OnboardLedRed,
        Device.Pins.OnboardLedGreen,
        Device.Pins.OnboardLedBlue);

    return Task.CompletedTask;
}

public override Task Run()
{
    return TestColors();
}

public async Task TestColors()
{
    while (true)
    {
        Resolver.Log.Info("SetColor(RgbLedColors.Red);");
        onboardLed.SetColor(Color.Red);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse();");
        await onboardLed.StartPulse();
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Green);");
        await onboardLed.StartPulse(Color.Green);
        await Task.Delay(3000);

        Resolver.Log.Info("SetColor(RgbLedColors.Yellow);");
        onboardLed.SetColor(Color.Yellow);
        await Task.Delay(3000);

        Resolver.Log.Info("StartPulse(RgbLedColors.Cyan, 200, 200);");
        await onboardLed.StartPulse(Color.Cyan, TimeSpan.FromMilliseconds(400));
        await Task.Delay(3000);

        await onboardLed.StopAnimation();
    }
}

Sample project(s) available on GitHub

Wiring Example