JEncoderSingle.h

Go to the documentation of this file.

#ifndef J_ENCODER_ATTACH_INTERRUPT_SINGLE_H
#define J_ENCODER_ATTACH_INTERRUPT_SINGLE_H
#include "JEncoder.h"
#include <Arduino.h>
 
class JEncoderSingle : public JEncoder {
 
protected:
    unsigned char encoderPin;
    byte interruptType;
 
private:
    bool rev;
    signed char reverse;
    float distPerCountFactor;
 
    volatile bool velNew;
    volatile long tickCounter;
    volatile unsigned long lastEncoderTickMicros;
    volatile unsigned long encoderIntervalMicros;
    bool newSpeed;
    unsigned long slowestIntervalMicros;
    bool wasTimedOut;
    unsigned long switchBounceIntervalMicros;
 
protected:
    JEncoderSingle(byte _encoderPin, float _distPerCountFactor, bool _reverse, unsigned long _slowestIntervalMicros, unsigned long _switchBounceIntervalMicros, byte _interruptType)
    {
        rev = false;
        encoderPin = _encoderPin;
        distPerCountFactor = _distPerCountFactor;
        slowestIntervalMicros = _slowestIntervalMicros;
        switchBounceIntervalMicros = _switchBounceIntervalMicros;
        if (_reverse) {
            reverse = -1;
        } else {
            reverse = 1;
        }
        interruptType = _interruptType;
 
        velNew = false;
        tickCounter = 0;
        encoderIntervalMicros = 0;
        lastEncoderTickMicros = 0;
        newSpeed = false;
        wasTimedOut = false;
    }
    virtual void setUpInterrupts(void (*_isrPointer)(void));
    virtual void turnOffInterrupts();
 
public:
    bool getRev()
    {
        return rev;
    }
    void setRev(bool _rev)
    {
        rev = _rev;
    }
 
    long zeroCounter()
    {
        long tempCounter = tickCounter * reverse;
        tickCounter = 0;
        return tempCounter;
    }
    float getVel()
    {
        // store temporary copies of variables set by ISR since they may be changed at any time
        unsigned long tempEncoderTickMicros = lastEncoderTickMicros;
        unsigned long tempInterval = encoderIntervalMicros;
 
        // occasionally micros seems to be smaller than tempEncoderTickMicros and there's an overflow
        //   adding tempInterval fixes the problem (looking back one more tick)
        if ((micros() - tempEncoderTickMicros + tempInterval) > slowestIntervalMicros) {
            return 0.0; // set to zero if it's been a while since a tick
        }
        if (tempInterval == 0) { // avoid divide by zero
            return 0.0;
        }
        return (rev ? -1 : 1) * reverse * 1000000.0 / tempInterval * distPerCountFactor;
    }
    long getCounter()
    {
        return tickCounter * reverse;
    }
    float getPos()
    {
        return tickCounter * distPerCountFactor * reverse;
    }
    float getDistPerCountFactor()
    {
        return distPerCountFactor;
    }
    void setDistPerCountFactor(float _factor)
    {
        distPerCountFactor = _factor;
    }
    void setReverse(bool _reverse)
    {
        if (_reverse) {
            reverse = -1;
        } else {
            reverse = 1;
        }
    }
    bool hasDirection()
    {
        return false;
    }
    bool isVelNew()
    {
        // occasionally micros seems to be smaller than tempEncoderTickMicros and there's an overflow
        //   adding tempInterval fixes the problem (looking back one more tick)
 
        unsigned long tempEncoderTickMicros = lastEncoderTickMicros;
        unsigned long tempInterval = encoderIntervalMicros;
        if ((micros() - tempEncoderTickMicros + tempInterval) > slowestIntervalMicros) {
            if (!wasTimedOut) {
                wasTimedOut = true;
                return true;
            }
        } else {
            wasTimedOut = false;
        }
 
        if (newSpeed) {
            newSpeed = false;
            return true;
        }
        return false;
    }
    void run() { }
 
    void encoderISR(void)
    {
        if (micros() - lastEncoderTickMicros >= switchBounceIntervalMicros) {
            unsigned long tempMicros = micros();
            encoderIntervalMicros = tempMicros - lastEncoderTickMicros;
            lastEncoderTickMicros = tempMicros;
            newSpeed = true;
            tickCounter += (rev ? -1 : 1);
        }
    }
};
#endif