ErriezRotaryFullStep.cpp

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2018-2020 Erriez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#if (defined(__AVR__) || defined(ARDUINO_ARCH_SAM))
#include <avr/pgmspace.h>
#else
#include <pgmspace.h>
#endif

#include "ErriezRotaryFullStep.h"

#define DIR_NONE  0x00      
#define DIR_CW    0x10      
#define DIR_CCW   0x20      

// Use the full-step state table, clockwise and counter clockwise
// Emits a code at '00' only
#define RFS_START          0x00     
#define RFS_CW_FINAL       0x01     
#define RFS_CW_BEGIN       0x02     
#define RFS_CW_NEXT        0x03     
#define RFS_CCW_BEGIN      0x04     
#define RFS_CCW_FINAL      0x05     
#define RFS_CCW_NEXT       0x06     

static const PROGMEM uint8_t fullStepTable[7][4] = {
    // RFS_START
    {RFS_START,      RFS_CW_BEGIN,  RFS_CCW_BEGIN, RFS_START},
    // RFS_CW_FINAL
    {RFS_CW_NEXT,    RFS_START,     RFS_CW_FINAL,  RFS_START | DIR_CW},
    // RFS_CW_BEGIN
    {RFS_CW_NEXT,    RFS_CW_BEGIN,  RFS_START,     RFS_START},
    // RFS_CW_NEXT
    {RFS_CW_NEXT,    RFS_CW_BEGIN,  RFS_CW_FINAL,  RFS_START},
    // RFS_CCW_BEGIN
    {RFS_CCW_NEXT,   RFS_START,     RFS_CCW_BEGIN, RFS_START},
    // RFS_CCW_FINAL
    {RFS_CCW_NEXT,   RFS_CCW_FINAL, RFS_START,     RFS_START | DIR_CCW},
    // RFS_CCW_NEXT
    {RFS_CCW_NEXT,   RFS_CCW_FINAL, RFS_CCW_BEGIN, RFS_START},
};

RotaryFullStep::RotaryFullStep(uint8_t pin1, uint8_t pin2, bool pullUp, uint8_t sensitivity) :
    _pin1(pin1), _pin2(pin2), _state(0), _sensitivity(sensitivity)
{
    if (pullUp) {
        // Enable internal pull-up
        pinMode(_pin1, INPUT_PULLUP);
        pinMode(_pin2, INPUT_PULLUP);
    }
}

int RotaryFullStep::read()
{
    int pinState;
    int rotaryState;
    unsigned long timeStamp;
    unsigned long changeTime;

    // Sample rotary digital pins
    pinState = (digitalRead(_pin1) << 1) | digitalRead(_pin2);

    // Determine new state from the pins and state table.
    _state = pgm_read_byte(&fullStepTable[_state & 0x0f][pinState]);

    // Check rotary state
    switch (_state & 0x30) {
        case DIR_CW:
            rotaryState = 1;
            break;
        case DIR_CCW:
            rotaryState = -1;
            break;
        case DIR_NONE:
        default:
            rotaryState = 0;
    }

    // Check if rotary changed
    if (rotaryState != 0) {
        timeStamp = millis();
        changeTime = timeStamp - _lastChange;
        _lastChange = timeStamp;

        // Check speed change
        if (changeTime < (_sensitivity / 2)) {
            rotaryState *= 3;
        } else if (changeTime < _sensitivity) {
            rotaryState *= 2;
        }
    }

    return rotaryState;
}

void RotaryFullStep::setSensitivity(uint8_t sensitivity)
{
    _sensitivity = sensitivity;
}

uint8_t RotaryFullStep::getSensitivity()
{
    return _sensitivity;
}