EventAnalog.h

/*
 *
 * GPLv2 Licence https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
 * 
 * Copyright (c) 2024 Philip Fletcher <philip.fletcher@stutchbury.com>
 * 
 */
 
 
#ifndef EVENT_ANALOG_H
#define EVENT_ANALOG_H
 
#include "Arduino.h"
#include "EventInputBase.h"
 
class EventAnalog : public EventInputBase {
 
protected:
 
    #if defined(FUNCTIONAL_SUPPORTED)
        typedef std::function<void(InputEventType et, EventAnalog &ie)> CallbackFunction;
    #else
        typedef void (*CallbackFunction)(InputEventType et, EventAnalog &);
    #endif
 
    CallbackFunction callbackFunction = nullptr;
 
    void invoke(InputEventType et) override;
 
public:
 
 
    EventAnalog(byte analogPin, uint8_t adcBits=10);
 
 
 
    void begin();
 
    void setCallback(CallbackFunction f) {
        callbackFunction = f;
        callbackIsSet = true;
    }
 
    #if defined(FUNCTIONAL_SUPPORTED)
    // Method to set callback with instance and class method
    template <typename T>
    void setCallback(T* instance, void (T::*method)(InputEventType, EventAnalog&)) {
        // Wrap the method call in a lambda
        callbackFunction = [instance, method](InputEventType et, EventAnalog &ie) {
            (instance->*method)(et, ie); // Call the member function on the instance
        };
        callbackIsSet = true;
    }
    #endif
 
    void unsetCallback() override;
 
    void update();
 
    int16_t position() { return _reversePosition ? currentPos*-1 : currentPos; }
 
    int16_t previousPosition() { return _reversePosition ? previousPos*-1 : previousPos; }
 
 
    bool hasChanged() { return _hasChanged; }
 
 
 
 
    void setNumIncrements(uint8_t numIncr=10);
 
    void setNumNegativeIncrements(uint8_t numIncr=10);
 
    void setNumPositiveIncrements(uint8_t numIncr=10);
 
 
 
    void setStartValue(uint16_t val);
    
    void setStartValue();
    
    void setMinValue(uint16_t val);
 
    void setMaxValue(uint16_t val);
 
 
    void setStartBoundary(uint16_t width=200);
    
    void setEndBoundary(uint16_t width=100);
    
 
    void setRateLimit(uint16_t ms) { rateLimit = ms; }
 
    void enableAutoCalibrate(bool enable=true) { autoCalibrate = enable; }
 
    void reversePosition(bool rev=true) { _reversePosition = rev; }
 
    bool isPositionReversed() { return _reversePosition; }
 
    protected:
 
    void setSliceNeg() { sliceNeg = max(((startVal-startBoundary-minVal-endBoundary)/negativeIncrements),1); }//Never allow 0
 
    void setSlicePos() { slicePos = max(((maxVal-endBoundary-startBoundary-startVal)/positiveIncrements),1);  }//Never allow 0
 
private:
    byte analogPin = 0;
    int16_t startVal = 0;
    int16_t readVal = startVal;
    int16_t currentVal = startVal;
    int16_t previousVal = currentVal;
    int16_t minVal = 100;
    int16_t maxVal = 980;
    int16_t startBoundary = 0;
    int16_t endBoundary = 0;
    int16_t adcMax = 1023;
 
 
    int16_t negativeIncrements = 25;
    int16_t positiveIncrements = 25;
    int16_t sliceNeg = 20;
    int16_t slicePos = 20;
 
    int16_t readPos = 0;
    int16_t currentPos = 0;
    int16_t previousPos = 0;
    bool _reversePosition = false;
 
    bool autoCalibrate = true;
    bool _hasChanged = false;
    bool _started = false;
 
    uint16_t rateLimit = 0;
    unsigned long rateLimitCounter = 0;   
 
    void setReadPos(int16_t offset);
    void setInitialReadPos();
 
 
 
 
};
 
#endif