Remarks

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

Rotary encoders are similar in form factor to potentiometers, but instead of modifying a voltage output, they send a digital signal encoded using Gray Code when rotated that can be decoded to ascertain the direction of turn.

Rotary encoders have several advantages over potentiometers as input devices, namely:

  • They’re more power efficient; they only use power when actuated.
  • They’re not rotation-bound; they spin infinitely in either direction.
  • Many rotary encoders also have a built-in pushbutton.

Rotary encoders are used almost exclusively on things like volume knobs on stereos.

And because they’re not rotation bound, they are especially useful in the case in which a device might have multiple inputs to control the same parameter. For instance, a stereo’s volume might be controlled via a knob and a remote control. If a potentiometer were used for the volume knob, then the actual volume could get out of synch with the apparent value on the potentiometer when the volume was changed via the remote.

For this reason, rotary encoders are particularly useful in connected things, in which parameters might be controlled remotely.

Code Example

protected int value = 0;
protected RotaryEncoderWithButton rotaryEncoder;

public override Task Initialize()
{
    Resolver.Log.Info("Initializing Hardware...");

    // Note: on the rotary encoder in the hack kit, the pinout is as
    // follows:
    //
    // | Encoder Name | Driver Pin Name |
    // |--------------|-----------------|
    // | `SW`         | `buttonPin`     |
    // | `DT`         | `aPhasePin`     |
    // | `CLK`        | `bPhasePin`     |

    // initialize the encoder
    rotaryEncoder = new RotaryEncoderWithButton(Device.Pins.D07, Device.Pins.D08, Device.Pins.D06);

    //==== Classic Events
    rotaryEncoder.Rotated += RotaryEncoder_Rotated;

    rotaryEncoder.Clicked += (s, e) => Resolver.Log.Info("Button Clicked");
  
    rotaryEncoder.PressEnded += (s, e) => Resolver.Log.Info("Press ended");
       
    rotaryEncoder.PressStarted += (s, e) => Resolver.Log.Info("Press started");
     
    Resolver.Log.Info("Hardware initialization complete.");

    return Task.CompletedTask;
}

private void RotaryEncoder_Rotated(object sender, RotaryChangeResult e)
{
    switch (e.New) 
    {
        case RotationDirection.Clockwise:
            value++;
            Resolver.Log.Info($"/\\ Value = {value} CW");
            break;
        case RotationDirection.CounterClockwise:
            value--;
            Resolver.Log.Info($"\\/ Value = {value} CCW");
            break;
    }
}

Sample project(s) available on GitHub

###Two-bit Gray Code

This rotary encoder driver works with most rotary encoders which return a two-bit Gray Code which is the minimum number of bits necessary to describe direction. Most common rotary encoders use two-bit Gray Code, so this driver should work with most common rotary encoders.

The following example uses a rotary encoder to adjust the brightness of a PwmLed.

public class MeadowApp : App<F7Micro, MeadowApp>
{
    protected RotaryEncoder _rotary = null;
    protected PwmLed _led = null;
    // how much to change the brightness per rotation step. 
    // 0.05 = 20 clicks to 100%
    protected float _brightnessStepChange = 0.05F; 

    public MeadowApp()
    {
        // instantiate our peripherals
        _rotary = new RotaryEncoder(Device.Pins.D07, Device.Pins.D09);
        _rotary.Rotated += RotaryRotated;

        _led = new PwmLed(Device.Pins.D12, TypicalForwardVoltage.Red);
    }

    protected void RotaryRotated(object sender, RotaryTurnedEventArgs e)
    {
        // if clockwise, turn it up! clamp to 1, so we don't go over.
        if (e.Direction == RotationDirection.Clockwise)
        {
            if(_led.Brightness >= 1) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness + 
                    _brightnessStepChange).Clamp(0,1));
            }
        } 
        else // otherwise, turn it down. clamp to 0 so we don't go below. 
        { 
            if (_led.Brightness <= 0) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness - 
                    _brightnessStepChange).Clamp(0,1));
            }
        }
    }
}

Sample projects available on GitHub

Wiring Example

Note, depending on your encoder, it may have a common/ground (gnd) or (-) leg in addition to the positive (+) leg. If it does, make sure to wire it to ground.

The a-phase pin may be labeled (A), (CLK) or other. If the Rotated event is indicating the wrong direction, simply switch the a-phase and b-phase pins.

<img src="../../API_Assets/Meadow.Foundation.Sensors.Rotary.RotaryEncoder/RotaryEncoder_Fritzing.svg"

Characteristic Locus
Inheritance object > RotaryEncoder > RotaryEncoderWithButton
Implements IRotaryEncoder
Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString()
Namespace Meadow.Foundation.Sensors.Rotary
Assembly Meadow.Foundation.dll

Syntax

public class RotaryEncoder : IRotaryEncoder

Constructors

RotaryEncoder(IDigitalInterruptPort, IDigitalInterruptPort)

Instantiate a new RotaryEncoder on the specified ports

Declaration
public RotaryEncoder(IDigitalInterruptPort aPhasePort, IDigitalInterruptPort bPhasePort)

Parameters

Type Name Description
IDigitalInterruptPort aPhasePort
IDigitalInterruptPort bPhasePort

Remarks

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

Rotary encoders are similar in form factor to potentiometers, but instead of modifying a voltage output, they send a digital signal encoded using Gray Code when rotated that can be decoded to ascertain the direction of turn.

Rotary encoders have several advantages over potentiometers as input devices, namely:

  • They’re more power efficient; they only use power when actuated.
  • They’re not rotation-bound; they spin infinitely in either direction.
  • Many rotary encoders also have a built-in pushbutton.

Rotary encoders are used almost exclusively on things like volume knobs on stereos.

And because they’re not rotation bound, they are especially useful in the case in which a device might have multiple inputs to control the same parameter. For instance, a stereo’s volume might be controlled via a knob and a remote control. If a potentiometer were used for the volume knob, then the actual volume could get out of synch with the apparent value on the potentiometer when the volume was changed via the remote.

For this reason, rotary encoders are particularly useful in connected things, in which parameters might be controlled remotely.

Code Example

protected int value = 0;
protected RotaryEncoderWithButton rotaryEncoder;

public override Task Initialize()
{
    Resolver.Log.Info("Initializing Hardware...");

    // Note: on the rotary encoder in the hack kit, the pinout is as
    // follows:
    //
    // | Encoder Name | Driver Pin Name |
    // |--------------|-----------------|
    // | `SW`         | `buttonPin`     |
    // | `DT`         | `aPhasePin`     |
    // | `CLK`        | `bPhasePin`     |

    // initialize the encoder
    rotaryEncoder = new RotaryEncoderWithButton(Device.Pins.D07, Device.Pins.D08, Device.Pins.D06);

    //==== Classic Events
    rotaryEncoder.Rotated += RotaryEncoder_Rotated;

    rotaryEncoder.Clicked += (s, e) => Resolver.Log.Info("Button Clicked");
  
    rotaryEncoder.PressEnded += (s, e) => Resolver.Log.Info("Press ended");
       
    rotaryEncoder.PressStarted += (s, e) => Resolver.Log.Info("Press started");
     
    Resolver.Log.Info("Hardware initialization complete.");

    return Task.CompletedTask;
}

private void RotaryEncoder_Rotated(object sender, RotaryChangeResult e)
{
    switch (e.New) 
    {
        case RotationDirection.Clockwise:
            value++;
            Resolver.Log.Info($"/\\ Value = {value} CW");
            break;
        case RotationDirection.CounterClockwise:
            value--;
            Resolver.Log.Info($"\\/ Value = {value} CCW");
            break;
    }
}

Sample project(s) available on GitHub

###Two-bit Gray Code

This rotary encoder driver works with most rotary encoders which return a two-bit Gray Code which is the minimum number of bits necessary to describe direction. Most common rotary encoders use two-bit Gray Code, so this driver should work with most common rotary encoders.

The following example uses a rotary encoder to adjust the brightness of a PwmLed.

public class MeadowApp : App<F7Micro, MeadowApp>
{
    protected RotaryEncoder _rotary = null;
    protected PwmLed _led = null;
    // how much to change the brightness per rotation step. 
    // 0.05 = 20 clicks to 100%
    protected float _brightnessStepChange = 0.05F; 

    public MeadowApp()
    {
        // instantiate our peripherals
        _rotary = new RotaryEncoder(Device.Pins.D07, Device.Pins.D09);
        _rotary.Rotated += RotaryRotated;

        _led = new PwmLed(Device.Pins.D12, TypicalForwardVoltage.Red);
    }

    protected void RotaryRotated(object sender, RotaryTurnedEventArgs e)
    {
        // if clockwise, turn it up! clamp to 1, so we don't go over.
        if (e.Direction == RotationDirection.Clockwise)
        {
            if(_led.Brightness >= 1) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness + 
                    _brightnessStepChange).Clamp(0,1));
            }
        } 
        else // otherwise, turn it down. clamp to 0 so we don't go below. 
        { 
            if (_led.Brightness <= 0) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness - 
                    _brightnessStepChange).Clamp(0,1));
            }
        }
    }
}

Sample projects available on GitHub

Wiring Example

Note, depending on your encoder, it may have a common/ground (gnd) or (-) leg in addition to the positive (+) leg. If it does, make sure to wire it to ground.

The a-phase pin may be labeled (A), (CLK) or other. If the Rotated event is indicating the wrong direction, simply switch the a-phase and b-phase pins.

<img src="../../API_Assets/Meadow.Foundation.Sensors.Rotary.RotaryEncoder/RotaryEncoder_Fritzing.svg"

RotaryEncoder(IPin, IPin, bool)

Instantiate a new RotaryEncoder on the specified pins

Declaration
public RotaryEncoder(IPin aPhasePin, IPin bPhasePin, bool isCommonGround = false)

Parameters

Type Name Description
IPin aPhasePin

Pin A

IPin bPhasePin

Pin B

bool isCommonGround

Do the encode pins use a common ground (true) or common positive (false)

Remarks

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

Rotary encoders are similar in form factor to potentiometers, but instead of modifying a voltage output, they send a digital signal encoded using Gray Code when rotated that can be decoded to ascertain the direction of turn.

Rotary encoders have several advantages over potentiometers as input devices, namely:

  • They’re more power efficient; they only use power when actuated.
  • They’re not rotation-bound; they spin infinitely in either direction.
  • Many rotary encoders also have a built-in pushbutton.

Rotary encoders are used almost exclusively on things like volume knobs on stereos.

And because they’re not rotation bound, they are especially useful in the case in which a device might have multiple inputs to control the same parameter. For instance, a stereo’s volume might be controlled via a knob and a remote control. If a potentiometer were used for the volume knob, then the actual volume could get out of synch with the apparent value on the potentiometer when the volume was changed via the remote.

For this reason, rotary encoders are particularly useful in connected things, in which parameters might be controlled remotely.

Code Example

protected int value = 0;
protected RotaryEncoderWithButton rotaryEncoder;

public override Task Initialize()
{
    Resolver.Log.Info("Initializing Hardware...");

    // Note: on the rotary encoder in the hack kit, the pinout is as
    // follows:
    //
    // | Encoder Name | Driver Pin Name |
    // |--------------|-----------------|
    // | `SW`         | `buttonPin`     |
    // | `DT`         | `aPhasePin`     |
    // | `CLK`        | `bPhasePin`     |

    // initialize the encoder
    rotaryEncoder = new RotaryEncoderWithButton(Device.Pins.D07, Device.Pins.D08, Device.Pins.D06);

    //==== Classic Events
    rotaryEncoder.Rotated += RotaryEncoder_Rotated;

    rotaryEncoder.Clicked += (s, e) => Resolver.Log.Info("Button Clicked");
  
    rotaryEncoder.PressEnded += (s, e) => Resolver.Log.Info("Press ended");
       
    rotaryEncoder.PressStarted += (s, e) => Resolver.Log.Info("Press started");
     
    Resolver.Log.Info("Hardware initialization complete.");

    return Task.CompletedTask;
}

private void RotaryEncoder_Rotated(object sender, RotaryChangeResult e)
{
    switch (e.New) 
    {
        case RotationDirection.Clockwise:
            value++;
            Resolver.Log.Info($"/\\ Value = {value} CW");
            break;
        case RotationDirection.CounterClockwise:
            value--;
            Resolver.Log.Info($"\\/ Value = {value} CCW");
            break;
    }
}

Sample project(s) available on GitHub

###Two-bit Gray Code

This rotary encoder driver works with most rotary encoders which return a two-bit Gray Code which is the minimum number of bits necessary to describe direction. Most common rotary encoders use two-bit Gray Code, so this driver should work with most common rotary encoders.

The following example uses a rotary encoder to adjust the brightness of a PwmLed.

public class MeadowApp : App<F7Micro, MeadowApp>
{
    protected RotaryEncoder _rotary = null;
    protected PwmLed _led = null;
    // how much to change the brightness per rotation step. 
    // 0.05 = 20 clicks to 100%
    protected float _brightnessStepChange = 0.05F; 

    public MeadowApp()
    {
        // instantiate our peripherals
        _rotary = new RotaryEncoder(Device.Pins.D07, Device.Pins.D09);
        _rotary.Rotated += RotaryRotated;

        _led = new PwmLed(Device.Pins.D12, TypicalForwardVoltage.Red);
    }

    protected void RotaryRotated(object sender, RotaryTurnedEventArgs e)
    {
        // if clockwise, turn it up! clamp to 1, so we don't go over.
        if (e.Direction == RotationDirection.Clockwise)
        {
            if(_led.Brightness >= 1) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness + 
                    _brightnessStepChange).Clamp(0,1));
            }
        } 
        else // otherwise, turn it down. clamp to 0 so we don't go below. 
        { 
            if (_led.Brightness <= 0) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness - 
                    _brightnessStepChange).Clamp(0,1));
            }
        }
    }
}

Sample projects available on GitHub

Wiring Example

Note, depending on your encoder, it may have a common/ground (gnd) or (-) leg in addition to the positive (+) leg. If it does, make sure to wire it to ground.

The a-phase pin may be labeled (A), (CLK) or other. If the Rotated event is indicating the wrong direction, simply switch the a-phase and b-phase pins.

<img src="../../API_Assets/Meadow.Foundation.Sensors.Rotary.RotaryEncoder/RotaryEncoder_Fritzing.svg"

Properties

APhasePort

Returns the pin connected to the A-phase output on the rotary encoder.

Declaration
protected IDigitalInterruptPort APhasePort { get; }

Property Value

Type Description
IDigitalInterruptPort

Remarks

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

Rotary encoders are similar in form factor to potentiometers, but instead of modifying a voltage output, they send a digital signal encoded using Gray Code when rotated that can be decoded to ascertain the direction of turn.

Rotary encoders have several advantages over potentiometers as input devices, namely:

  • They’re more power efficient; they only use power when actuated.
  • They’re not rotation-bound; they spin infinitely in either direction.
  • Many rotary encoders also have a built-in pushbutton.

Rotary encoders are used almost exclusively on things like volume knobs on stereos.

And because they’re not rotation bound, they are especially useful in the case in which a device might have multiple inputs to control the same parameter. For instance, a stereo’s volume might be controlled via a knob and a remote control. If a potentiometer were used for the volume knob, then the actual volume could get out of synch with the apparent value on the potentiometer when the volume was changed via the remote.

For this reason, rotary encoders are particularly useful in connected things, in which parameters might be controlled remotely.

Code Example

protected int value = 0;
protected RotaryEncoderWithButton rotaryEncoder;

public override Task Initialize()
{
    Resolver.Log.Info("Initializing Hardware...");

    // Note: on the rotary encoder in the hack kit, the pinout is as
    // follows:
    //
    // | Encoder Name | Driver Pin Name |
    // |--------------|-----------------|
    // | `SW`         | `buttonPin`     |
    // | `DT`         | `aPhasePin`     |
    // | `CLK`        | `bPhasePin`     |

    // initialize the encoder
    rotaryEncoder = new RotaryEncoderWithButton(Device.Pins.D07, Device.Pins.D08, Device.Pins.D06);

    //==== Classic Events
    rotaryEncoder.Rotated += RotaryEncoder_Rotated;

    rotaryEncoder.Clicked += (s, e) => Resolver.Log.Info("Button Clicked");
  
    rotaryEncoder.PressEnded += (s, e) => Resolver.Log.Info("Press ended");
       
    rotaryEncoder.PressStarted += (s, e) => Resolver.Log.Info("Press started");
     
    Resolver.Log.Info("Hardware initialization complete.");

    return Task.CompletedTask;
}

private void RotaryEncoder_Rotated(object sender, RotaryChangeResult e)
{
    switch (e.New) 
    {
        case RotationDirection.Clockwise:
            value++;
            Resolver.Log.Info($"/\\ Value = {value} CW");
            break;
        case RotationDirection.CounterClockwise:
            value--;
            Resolver.Log.Info($"\\/ Value = {value} CCW");
            break;
    }
}

Sample project(s) available on GitHub

###Two-bit Gray Code

This rotary encoder driver works with most rotary encoders which return a two-bit Gray Code which is the minimum number of bits necessary to describe direction. Most common rotary encoders use two-bit Gray Code, so this driver should work with most common rotary encoders.

The following example uses a rotary encoder to adjust the brightness of a PwmLed.

public class MeadowApp : App<F7Micro, MeadowApp>
{
    protected RotaryEncoder _rotary = null;
    protected PwmLed _led = null;
    // how much to change the brightness per rotation step. 
    // 0.05 = 20 clicks to 100%
    protected float _brightnessStepChange = 0.05F; 

    public MeadowApp()
    {
        // instantiate our peripherals
        _rotary = new RotaryEncoder(Device.Pins.D07, Device.Pins.D09);
        _rotary.Rotated += RotaryRotated;

        _led = new PwmLed(Device.Pins.D12, TypicalForwardVoltage.Red);
    }

    protected void RotaryRotated(object sender, RotaryTurnedEventArgs e)
    {
        // if clockwise, turn it up! clamp to 1, so we don't go over.
        if (e.Direction == RotationDirection.Clockwise)
        {
            if(_led.Brightness >= 1) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness + 
                    _brightnessStepChange).Clamp(0,1));
            }
        } 
        else // otherwise, turn it down. clamp to 0 so we don't go below. 
        { 
            if (_led.Brightness <= 0) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness - 
                    _brightnessStepChange).Clamp(0,1));
            }
        }
    }
}

Sample projects available on GitHub

Wiring Example

Note, depending on your encoder, it may have a common/ground (gnd) or (-) leg in addition to the positive (+) leg. If it does, make sure to wire it to ground.

The a-phase pin may be labeled (A), (CLK) or other. If the Rotated event is indicating the wrong direction, simply switch the a-phase and b-phase pins.

<img src="../../API_Assets/Meadow.Foundation.Sensors.Rotary.RotaryEncoder/RotaryEncoder_Fritzing.svg"

BPhasePort

Returns the pin connected to the B-phase output on the rotary encoder.

Declaration
protected IDigitalInterruptPort BPhasePort { get; }

Property Value

Type Description
IDigitalInterruptPort

Remarks

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

Rotary encoders are similar in form factor to potentiometers, but instead of modifying a voltage output, they send a digital signal encoded using Gray Code when rotated that can be decoded to ascertain the direction of turn.

Rotary encoders have several advantages over potentiometers as input devices, namely:

  • They’re more power efficient; they only use power when actuated.
  • They’re not rotation-bound; they spin infinitely in either direction.
  • Many rotary encoders also have a built-in pushbutton.

Rotary encoders are used almost exclusively on things like volume knobs on stereos.

And because they’re not rotation bound, they are especially useful in the case in which a device might have multiple inputs to control the same parameter. For instance, a stereo’s volume might be controlled via a knob and a remote control. If a potentiometer were used for the volume knob, then the actual volume could get out of synch with the apparent value on the potentiometer when the volume was changed via the remote.

For this reason, rotary encoders are particularly useful in connected things, in which parameters might be controlled remotely.

Code Example

protected int value = 0;
protected RotaryEncoderWithButton rotaryEncoder;

public override Task Initialize()
{
    Resolver.Log.Info("Initializing Hardware...");

    // Note: on the rotary encoder in the hack kit, the pinout is as
    // follows:
    //
    // | Encoder Name | Driver Pin Name |
    // |--------------|-----------------|
    // | `SW`         | `buttonPin`     |
    // | `DT`         | `aPhasePin`     |
    // | `CLK`        | `bPhasePin`     |

    // initialize the encoder
    rotaryEncoder = new RotaryEncoderWithButton(Device.Pins.D07, Device.Pins.D08, Device.Pins.D06);

    //==== Classic Events
    rotaryEncoder.Rotated += RotaryEncoder_Rotated;

    rotaryEncoder.Clicked += (s, e) => Resolver.Log.Info("Button Clicked");
  
    rotaryEncoder.PressEnded += (s, e) => Resolver.Log.Info("Press ended");
       
    rotaryEncoder.PressStarted += (s, e) => Resolver.Log.Info("Press started");
     
    Resolver.Log.Info("Hardware initialization complete.");

    return Task.CompletedTask;
}

private void RotaryEncoder_Rotated(object sender, RotaryChangeResult e)
{
    switch (e.New) 
    {
        case RotationDirection.Clockwise:
            value++;
            Resolver.Log.Info($"/\\ Value = {value} CW");
            break;
        case RotationDirection.CounterClockwise:
            value--;
            Resolver.Log.Info($"\\/ Value = {value} CCW");
            break;
    }
}

Sample project(s) available on GitHub

###Two-bit Gray Code

This rotary encoder driver works with most rotary encoders which return a two-bit Gray Code which is the minimum number of bits necessary to describe direction. Most common rotary encoders use two-bit Gray Code, so this driver should work with most common rotary encoders.

The following example uses a rotary encoder to adjust the brightness of a PwmLed.

public class MeadowApp : App<F7Micro, MeadowApp>
{
    protected RotaryEncoder _rotary = null;
    protected PwmLed _led = null;
    // how much to change the brightness per rotation step. 
    // 0.05 = 20 clicks to 100%
    protected float _brightnessStepChange = 0.05F; 

    public MeadowApp()
    {
        // instantiate our peripherals
        _rotary = new RotaryEncoder(Device.Pins.D07, Device.Pins.D09);
        _rotary.Rotated += RotaryRotated;

        _led = new PwmLed(Device.Pins.D12, TypicalForwardVoltage.Red);
    }

    protected void RotaryRotated(object sender, RotaryTurnedEventArgs e)
    {
        // if clockwise, turn it up! clamp to 1, so we don't go over.
        if (e.Direction == RotationDirection.Clockwise)
        {
            if(_led.Brightness >= 1) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness + 
                    _brightnessStepChange).Clamp(0,1));
            }
        } 
        else // otherwise, turn it down. clamp to 0 so we don't go below. 
        { 
            if (_led.Brightness <= 0) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness - 
                    _brightnessStepChange).Clamp(0,1));
            }
        }
    }
}

Sample projects available on GitHub

Wiring Example

Note, depending on your encoder, it may have a common/ground (gnd) or (-) leg in addition to the positive (+) leg. If it does, make sure to wire it to ground.

The a-phase pin may be labeled (A), (CLK) or other. If the Rotated event is indicating the wrong direction, simply switch the a-phase and b-phase pins.

<img src="../../API_Assets/Meadow.Foundation.Sensors.Rotary.RotaryEncoder/RotaryEncoder_Fritzing.svg"

LastDirectionOfRotation

Gets the last direction of rotation

Declaration
public RotationDirection? LastDirectionOfRotation { get; protected set; }

Property Value

Type Description
RotationDirection?

Remarks

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

Rotary encoders are similar in form factor to potentiometers, but instead of modifying a voltage output, they send a digital signal encoded using Gray Code when rotated that can be decoded to ascertain the direction of turn.

Rotary encoders have several advantages over potentiometers as input devices, namely:

  • They’re more power efficient; they only use power when actuated.
  • They’re not rotation-bound; they spin infinitely in either direction.
  • Many rotary encoders also have a built-in pushbutton.

Rotary encoders are used almost exclusively on things like volume knobs on stereos.

And because they’re not rotation bound, they are especially useful in the case in which a device might have multiple inputs to control the same parameter. For instance, a stereo’s volume might be controlled via a knob and a remote control. If a potentiometer were used for the volume knob, then the actual volume could get out of synch with the apparent value on the potentiometer when the volume was changed via the remote.

For this reason, rotary encoders are particularly useful in connected things, in which parameters might be controlled remotely.

Code Example

protected int value = 0;
protected RotaryEncoderWithButton rotaryEncoder;

public override Task Initialize()
{
    Resolver.Log.Info("Initializing Hardware...");

    // Note: on the rotary encoder in the hack kit, the pinout is as
    // follows:
    //
    // | Encoder Name | Driver Pin Name |
    // |--------------|-----------------|
    // | `SW`         | `buttonPin`     |
    // | `DT`         | `aPhasePin`     |
    // | `CLK`        | `bPhasePin`     |

    // initialize the encoder
    rotaryEncoder = new RotaryEncoderWithButton(Device.Pins.D07, Device.Pins.D08, Device.Pins.D06);

    //==== Classic Events
    rotaryEncoder.Rotated += RotaryEncoder_Rotated;

    rotaryEncoder.Clicked += (s, e) => Resolver.Log.Info("Button Clicked");
  
    rotaryEncoder.PressEnded += (s, e) => Resolver.Log.Info("Press ended");
       
    rotaryEncoder.PressStarted += (s, e) => Resolver.Log.Info("Press started");
     
    Resolver.Log.Info("Hardware initialization complete.");

    return Task.CompletedTask;
}

private void RotaryEncoder_Rotated(object sender, RotaryChangeResult e)
{
    switch (e.New) 
    {
        case RotationDirection.Clockwise:
            value++;
            Resolver.Log.Info($"/\\ Value = {value} CW");
            break;
        case RotationDirection.CounterClockwise:
            value--;
            Resolver.Log.Info($"\\/ Value = {value} CCW");
            break;
    }
}

Sample project(s) available on GitHub

###Two-bit Gray Code

This rotary encoder driver works with most rotary encoders which return a two-bit Gray Code which is the minimum number of bits necessary to describe direction. Most common rotary encoders use two-bit Gray Code, so this driver should work with most common rotary encoders.

The following example uses a rotary encoder to adjust the brightness of a PwmLed.

public class MeadowApp : App<F7Micro, MeadowApp>
{
    protected RotaryEncoder _rotary = null;
    protected PwmLed _led = null;
    // how much to change the brightness per rotation step. 
    // 0.05 = 20 clicks to 100%
    protected float _brightnessStepChange = 0.05F; 

    public MeadowApp()
    {
        // instantiate our peripherals
        _rotary = new RotaryEncoder(Device.Pins.D07, Device.Pins.D09);
        _rotary.Rotated += RotaryRotated;

        _led = new PwmLed(Device.Pins.D12, TypicalForwardVoltage.Red);
    }

    protected void RotaryRotated(object sender, RotaryTurnedEventArgs e)
    {
        // if clockwise, turn it up! clamp to 1, so we don't go over.
        if (e.Direction == RotationDirection.Clockwise)
        {
            if(_led.Brightness >= 1) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness + 
                    _brightnessStepChange).Clamp(0,1));
            }
        } 
        else // otherwise, turn it down. clamp to 0 so we don't go below. 
        { 
            if (_led.Brightness <= 0) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness - 
                    _brightnessStepChange).Clamp(0,1));
            }
        }
    }
}

Sample projects available on GitHub

Wiring Example

Note, depending on your encoder, it may have a common/ground (gnd) or (-) leg in addition to the positive (+) leg. If it does, make sure to wire it to ground.

The a-phase pin may be labeled (A), (CLK) or other. If the Rotated event is indicating the wrong direction, simply switch the a-phase and b-phase pins.

<img src="../../API_Assets/Meadow.Foundation.Sensors.Rotary.RotaryEncoder/RotaryEncoder_Fritzing.svg"

Events

Rotated

Raised when the rotary encoder is rotated and returns a RotaryTurnedEventArgs object which describes the direction of rotation.

Declaration
public event EventHandler<RotaryChangeResult> Rotated

Event Type

Type Description
EventHandler<RotaryChangeResult>

Remarks

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

Rotary encoders are similar in form factor to potentiometers, but instead of modifying a voltage output, they send a digital signal encoded using Gray Code when rotated that can be decoded to ascertain the direction of turn.

Rotary encoders have several advantages over potentiometers as input devices, namely:

  • They’re more power efficient; they only use power when actuated.
  • They’re not rotation-bound; they spin infinitely in either direction.
  • Many rotary encoders also have a built-in pushbutton.

Rotary encoders are used almost exclusively on things like volume knobs on stereos.

And because they’re not rotation bound, they are especially useful in the case in which a device might have multiple inputs to control the same parameter. For instance, a stereo’s volume might be controlled via a knob and a remote control. If a potentiometer were used for the volume knob, then the actual volume could get out of synch with the apparent value on the potentiometer when the volume was changed via the remote.

For this reason, rotary encoders are particularly useful in connected things, in which parameters might be controlled remotely.

Code Example

protected int value = 0;
protected RotaryEncoderWithButton rotaryEncoder;

public override Task Initialize()
{
    Resolver.Log.Info("Initializing Hardware...");

    // Note: on the rotary encoder in the hack kit, the pinout is as
    // follows:
    //
    // | Encoder Name | Driver Pin Name |
    // |--------------|-----------------|
    // | `SW`         | `buttonPin`     |
    // | `DT`         | `aPhasePin`     |
    // | `CLK`        | `bPhasePin`     |

    // initialize the encoder
    rotaryEncoder = new RotaryEncoderWithButton(Device.Pins.D07, Device.Pins.D08, Device.Pins.D06);

    //==== Classic Events
    rotaryEncoder.Rotated += RotaryEncoder_Rotated;

    rotaryEncoder.Clicked += (s, e) => Resolver.Log.Info("Button Clicked");
  
    rotaryEncoder.PressEnded += (s, e) => Resolver.Log.Info("Press ended");
       
    rotaryEncoder.PressStarted += (s, e) => Resolver.Log.Info("Press started");
     
    Resolver.Log.Info("Hardware initialization complete.");

    return Task.CompletedTask;
}

private void RotaryEncoder_Rotated(object sender, RotaryChangeResult e)
{
    switch (e.New) 
    {
        case RotationDirection.Clockwise:
            value++;
            Resolver.Log.Info($"/\\ Value = {value} CW");
            break;
        case RotationDirection.CounterClockwise:
            value--;
            Resolver.Log.Info($"\\/ Value = {value} CCW");
            break;
    }
}

Sample project(s) available on GitHub

###Two-bit Gray Code

This rotary encoder driver works with most rotary encoders which return a two-bit Gray Code which is the minimum number of bits necessary to describe direction. Most common rotary encoders use two-bit Gray Code, so this driver should work with most common rotary encoders.

The following example uses a rotary encoder to adjust the brightness of a PwmLed.

public class MeadowApp : App<F7Micro, MeadowApp>
{
    protected RotaryEncoder _rotary = null;
    protected PwmLed _led = null;
    // how much to change the brightness per rotation step. 
    // 0.05 = 20 clicks to 100%
    protected float _brightnessStepChange = 0.05F; 

    public MeadowApp()
    {
        // instantiate our peripherals
        _rotary = new RotaryEncoder(Device.Pins.D07, Device.Pins.D09);
        _rotary.Rotated += RotaryRotated;

        _led = new PwmLed(Device.Pins.D12, TypicalForwardVoltage.Red);
    }

    protected void RotaryRotated(object sender, RotaryTurnedEventArgs e)
    {
        // if clockwise, turn it up! clamp to 1, so we don't go over.
        if (e.Direction == RotationDirection.Clockwise)
        {
            if(_led.Brightness >= 1) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness + 
                    _brightnessStepChange).Clamp(0,1));
            }
        } 
        else // otherwise, turn it down. clamp to 0 so we don't go below. 
        { 
            if (_led.Brightness <= 0) 
            {
                return;
            } 
            else 
            {
                _led.SetBrightness((_led.Brightness - 
                    _brightnessStepChange).Clamp(0,1));
            }
        }
    }
}

Sample projects available on GitHub

Wiring Example

Note, depending on your encoder, it may have a common/ground (gnd) or (-) leg in addition to the positive (+) leg. If it does, make sure to wire it to ground.

The a-phase pin may be labeled (A), (CLK) or other. If the Rotated event is indicating the wrong direction, simply switch the a-phase and b-phase pins.

<img src="../../API_Assets/Meadow.Foundation.Sensors.Rotary.RotaryEncoder/RotaryEncoder_Fritzing.svg"