byte-sized-encoder-decoder.h

Go to the documentation of this file.

#ifndef BYTE_SIZED_ENCODER_DECODER_H
#define BYTE_SIZED_ENCODER_DECODER_H
#include <Arduino.h>
#include <Wire.h>
class ByteSizedEncoderDecoder {
protected:
    uint8_t address;
    int16_t encoderCount[8];
    int16_t encoderOverflows[8];
    int16_t lastEncoderCount[8];
    int16_t lastVelocityEncoderCount[8];
    TwoWire* wire;
    uint8_t whichEncodersMask;
    unsigned long lastReadMicros[8];
    int16_t encoderVelocity[8];
    int16_t encoderSlowestInterval[8];
    int16_t encoderEnoughCounts[8];
    boolean isVelNewVal[8];
    inline void write(uint8_t data)
    {
        wire->beginTransmission(address);
        wire->write(data);
        wire->endTransmission();
    }
 
public:
    ByteSizedEncoderDecoder(TwoWire* _wire, uint8_t _address = 14, int16_t _encoderSlowestInterval = 0, int16_t _encoderEnoughCounts = 0)
    {
        wire = _wire;
        address = _address;
        whichEncodersMask = 255;
 
        // memset encoderCount[] all 0
        memset(encoderCount, 0, 8 * sizeof(int16_t));
        memset(encoderOverflows, 0, 8 * sizeof(int16_t));
        memset(lastEncoderCount, 0, 8 * sizeof(int16_t));
        memset(lastVelocityEncoderCount, 0, 8 * sizeof(int16_t));
        memset(lastReadMicros, 0, 8 * sizeof(unsigned long));
        memset(encoderVelocity, 0, 8 * sizeof(int16_t));
        memset(encoderSlowestInterval, _encoderSlowestInterval, 8 * sizeof(int16_t));
        memset(encoderEnoughCounts, _encoderEnoughCounts, 8 * sizeof(int16_t));
        memset(isVelNewVal, 0, 8 * sizeof(boolean));
    }
    void setEncoderSlowestInterval(uint8_t n, int16_t interval)
    {
        if (n > 8) {
            return;
        }
        if (n == 0) {
            for (byte i = 0; i < 8; i++) {
                encoderSlowestInterval[i] = interval;
            }
            return;
        }
        encoderSlowestInterval[n - 1] = interval;
    }
    void setEncoderEnoughCounts(uint8_t n, int16_t counts)
    {
        if (n > 8) {
            return;
        }
        if (n == 0) {
            for (byte i = 0; i < 8; i++) {
                encoderEnoughCounts[i] = counts;
            }
            return;
        }
        encoderEnoughCounts[n - 1] = counts;
    }
 
    boolean isVelNew(uint8_t n)
    {
        if (n > 8 || n < 1) {
            return false;
        }
        boolean temp = isVelNewVal[n - 1];
        isVelNewVal[n - 1] = false;
        return temp;
    }
 
    void begin(boolean resetEncoders = true)
    {
        setWhichEncoders(255);
        if (resetEncoders) {
            resetEncoderPositions();
        }
    }
    void run()
    {
        wire->beginTransmission(address);
        wire->write(whichEncodersMask);
        wire->endTransmission(true);
        delayMicroseconds(50); // time for the board to prepare to respond
        for (byte i = 0; i < 8; i++) {
            if (bitRead(whichEncodersMask, 7 - i) == 0) {
                continue;
            }
            int high = -1;
            int low = -1;
            wire->requestFrom(address, (uint8_t)1);
            if (wire->available())
                high = wire->read();
            wire->requestFrom(address, (uint8_t)1);
            if (wire->available())
                low = wire->read();
            if (high == -1 || low == -1) {
                // we didn't get data
            } else {
                lastEncoderCount[i] = encoderCount[i];
                encoderCount[i] = (((uint16_t)high) << 8 | ((uint16_t)low));
                if (abs(encoderCount[i] - lastEncoderCount[i]) > (1 << 15)) {
                    encoderOverflows[i] += (encoderCount[i] > lastEncoderCount[i]) ? -1 : 1;
                }
                // calculate velocity
                unsigned long mic = micros();
                int32_t hundredMicrosSinceLastRead = (mic - lastReadMicros[i]) / 100; // using a time interval of 100 microseconds (won't overflow int32)
                if (hundredMicrosSinceLastRead > (int32_t)(encoderSlowestInterval[i] * 10) || abs(encoderCount[i] - lastVelocityEncoderCount[i]) > encoderEnoughCounts[i]) {
                    lastReadMicros[i] = mic;
                    encoderVelocity[i] = (int32_t)10000 * (encoderCount[i] - lastVelocityEncoderCount[i]) / hundredMicrosSinceLastRead;
                    lastVelocityEncoderCount[i] = encoderCount[i];
                    isVelNewVal[i] = true;
                }
            }
        }
    }
    int32_t getEncoderPosition(uint8_t n, boolean read = false)
    {
        if (read) {
            run();
        }
        if (n > 8 || n < 1) {
            return 0;
        }
        return (int32_t)encoderCount[n - 1] + (int32_t)encoderOverflows[n - 1] * 65536;
    }
    int16_t getEncoderPositionWithoutOverflows(uint8_t n, boolean read = false)
    {
        if (read) {
            run();
        }
        if (n > 8 || n < 1) {
            return 0;
        }
        return encoderCount[n - 1];
    }
    int16_t getEncoderVelocity(uint8_t n, boolean read = false)
    {
        if (read) {
            run();
        }
        if (n > 8 || n < 1) {
            return 0;
        }
        return encoderVelocity[n - 1];
    }
    void resetEncoderPositions(boolean resetVariables = true)
    {
        write(0);
        if (resetVariables) {
            for (byte i = 0; i < 8; i++) {
                encoderCount[i] = 0;
                encoderOverflows[i] = 0;
                lastEncoderCount[i] = 0;
                encoderVelocity[i] = 0;
            }
        }
    }
    void setWhichEncoders(uint8_t mask)
    {
        if (mask != 0) {
            whichEncodersMask = mask;
            write(mask);
        }
    }
    boolean isEncoderActive(uint8_t n)
    {
        if (n > 8 || n < 1) {
            return false;
        }
        return bitRead(whichEncodersMask, 7 - (n - 1));
    }
};
#endif // BYTE_SIZED_ENCODER_DECODER_H