Rotary.hh

Go to the documentation of this file.

#ifndef COSA_ROTARY_HH
#define COSA_ROTARY_HH

#include "Cosa/Types.h"
#include "Cosa/PinChangeInterrupt.hh"
#include "Cosa/RTT.hh"

class Rotary {
public:
  class Encoder : public Event::Handler {
  public:
    enum Direction {
      NONE = 0x00,              
      CW = 0x10,                
      CCW = 0x20                
    } __attribute__((packed));

    enum Mode {
      HALF_CYCLE,
      FULL_CYCLE
    }  __attribute__((packed));

    Encoder(Board::InterruptPin clk, Board::InterruptPin dt,
            Mode mode = FULL_CYCLE) :
      m_clk(clk, this),
      m_dt(dt, this),
      m_state(0),
      m_mode(mode)
    {
      enable();
    }

    Mode mode() const
    {
      return (m_mode);
    }

    void mode(Mode mode)
    {
      m_mode = mode;
    }

    void enable()
      __attribute__((always_inline))
    {
      m_clk.enable();
      m_dt.enable();
    }

    void disable()
      __attribute__((always_inline))
    {
      m_clk.disable();
      m_dt.disable();
    }

  protected:
    class SignalPin : public PinChangeInterrupt {
    public:
      SignalPin(Board::InterruptPin pin, Encoder* encoder) :
        PinChangeInterrupt(pin),
        m_encoder(encoder)
      {}

    private:
      Encoder* m_encoder;

      virtual void on_interrupt(uint16_t arg);
    };

    static const uint8_t half_cycle_table[6][4] PROGMEM;

    static const uint8_t full_cycle_table[7][4] PROGMEM;

    SignalPin m_clk;
    SignalPin m_dt;
    uint8_t m_state;
    Mode m_mode;

    Direction detect();
  };

  template<typename T>
  class Dial : public Encoder {
  public:
    Dial(Board::InterruptPin clk, Board::InterruptPin dt, Mode mode,
         T initial, T min, T max, T step) :
      Encoder(clk, dt, mode),
      m_value(initial),
      m_min(min),
      m_max(max),
      m_step(step)
    {}

    T value() const
    {
      return (m_value);
    }

    T step() const
    {
      return (m_step);
    }

    void step(T step)
    {
      m_step = step;
    }

    virtual void on_change(T value)
    {
      UNUSED(value);
    }

  protected:
    T m_value;
    T m_min;
    T m_max;
    T m_step;

    virtual void on_event(uint8_t type, uint16_t value)
    {
      UNUSED(type);
      if (value == CW) {
        if (m_value == m_max) return;
        m_value += m_step;
      }
      else {
        if (m_value == m_min) return;
        m_value -= m_step;
      }
      on_change(m_value);
    }
  };

  template<typename T, uint32_t THRESHOLD>
  class AcceleratedDial : public Encoder {
  public:
    AcceleratedDial(Board::InterruptPin clk, Board::InterruptPin dt, Mode mode,
                    T initial, T min, T max, T step, T steps) :
      Encoder(clk, dt, mode),
      m_latest(0L),
      m_value(initial),
      m_min(min),
      m_max(max),
      m_step(step),
      m_steps(steps)
    {}

    T value() const
    {
      return (m_value);
    }

    T step() const
    {
      return (m_step);
    }

    void step(T step)
    {
      m_step = step;
    }

    T steps() const
    {
      return (m_steps);
    }

    void steps(T steps)
    {
      m_steps = steps;
    }

    virtual void on_change(T value)
    {
      UNUSED(value);
    }

  private:
    uint32_t m_latest;
    T m_value;
    T m_min;
    T m_max;
    T m_step;
    T m_steps;

    virtual void on_event(uint8_t type, uint16_t direction)
    {
      uint32_t now = RTT::micros();
      int32_t diff = now - m_latest;
      m_latest = now;
      if (direction == CW) {
        if (m_value == m_max) return;
        if (diff > THRESHOLD)
          m_value += m_step;
        else
          m_value += m_steps;
        if (m_value > m_max) m_value = m_max;
      }
      else {
        if (m_value == m_min) return;
        if (diff > THRESHOLD)
          m_value -= m_step;
        else
          m_value -= m_steps;
        if (m_value < m_min) m_value = m_min;
      }
      on_change(m_value);
    }
  };
};
#endif