QTRSensors.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <stdint.h>
 
enum class QTRReadMode : uint8_t
{
    Off,
 
    On,
 
    OnAndOff,
 
    OddEven,
 
    OddEvenAndOff,
 
    Manual
};
 
enum class QTRType : uint8_t
{
    Undefined,
    RC,
    Analog
};
 
enum class QTREmitters : uint8_t
{
    All,
    Odd,
    Even,
    None
};
 
const uint8_t QTRNoEmitterPin = 255;
 
const uint16_t QTRRCDefaultTimeout = 2500;
 
const uint8_t QTRMaxSensors = 31;
 
class QTRSensors
{
public:
    QTRSensors() = default;
 
    ~QTRSensors();
 
    void setTypeRC();
 
    void setTypeAnalog(uint16_t maxVal = 1023);
 
    QTRType getType() { return _type; }
 
    void setSensorPins(const uint8_t *pins, uint8_t sensorCount);
 
    void setTimeout(uint16_t timeout);
 
    uint16_t getTimeout() { return _timeout; }
 
    void setSamplesPerSensor(uint8_t samples);
 
    uint16_t getSamplesPerSensor() { return _samplesPerSensor; }
 
    void setEmitterPin(uint8_t emitterPin);
 
    void setEmitterPins(uint8_t oddEmitterPin, uint8_t evenEmitterPin);
 
    void releaseEmitterPins();
 
    uint8_t getEmitterPinCount() { return _emitterPinCount; }
 
    uint8_t getEmitterPin() { return _oddEmitterPin; }
 
    uint8_t getOddEmitterPin() { return _oddEmitterPin; }
 
    uint8_t getEvenEmitterPin() { return _evenEmitterPin; }
 
    void setDimmable() { _dimmable = true; }
 
    void setNonDimmable() { _dimmable = false; }
 
    bool getDimmable() { return _dimmable; }
 
    void setDimmingLevel(uint8_t dimmingLevel);
 
    uint8_t getDimmingLevel() { return _dimmingLevel; }
 
    void emittersOff(QTREmitters emitters = QTREmitters::All, bool wait = true);
 
    void emittersOn(QTREmitters emitters = QTREmitters::All, bool wait = true);
 
    void emittersSelect(QTREmitters emitters);
 
    void calibrate(QTRReadMode mode = QTRReadMode::On);
 
    void resetCalibration();
 
    void read(uint16_t *sensorValues, QTRReadMode mode = QTRReadMode::On);
 
    void readCalibrated(uint16_t *sensorValues, QTRReadMode mode = QTRReadMode::On);
 
    uint16_t readLineBlack(uint16_t *sensorValues, QTRReadMode mode = QTRReadMode::On)
    {
        return readLinePrivate(sensorValues, mode, false);
    }
 
    uint16_t readLineWhite(uint16_t *sensorValues, QTRReadMode mode = QTRReadMode::On)
    {
        return readLinePrivate(sensorValues, mode, true);
    }
 
    struct CalibrationData
    {
        bool initialized = false;
        uint16_t *minimum = nullptr;
        uint16_t *maximum = nullptr;
    };
 
 
    CalibrationData calibrationOn;
 
    CalibrationData calibrationOff;
 
 
private:
    uint16_t emittersOnWithPin(uint8_t pin);
 
    // Handles the actual calibration, including (re)allocating and
    // initializing the storage for the calibration values if necessary.
    void calibrateOnOrOff(CalibrationData &calibration, QTRReadMode mode);
 
    void readPrivate(uint16_t *sensorValues, uint8_t start = 0, uint8_t step = 1);
 
    uint16_t readLinePrivate(uint16_t *sensorValues, QTRReadMode mode, bool invertReadings);
 
    QTRType _type = QTRType::Undefined;
 
    uint8_t *_sensorPins = nullptr;
    uint8_t _sensorCount = 0;
 
    uint16_t _timeout = QTRRCDefaultTimeout;  // only used for RC sensors
    uint16_t _maxValue = QTRRCDefaultTimeout; // the maximum value returned by readPrivate()
    uint8_t _samplesPerSensor = 4;            // only used for analog sensors
 
    uint8_t _oddEmitterPin = QTRNoEmitterPin; // also used for single emitter pin
    uint8_t _evenEmitterPin = QTRNoEmitterPin;
    uint8_t _emitterPinCount = 0;
 
    bool _dimmable = true;
    uint8_t _dimmingLevel = 0;
 
    uint16_t _lastPosition = 0;
};