ResistiveTouchScreen.h

Go to the documentation of this file.

 
#ifndef IOA_RESISTIVETOUCHSCREEN_H
#define IOA_RESISTIVETOUCHSCREEN_H
 
#include "PlatformDetermination.h"
#include "AnalogDeviceAbstraction.h"
#include <TaskManagerIO.h>
 
#ifndef TOUCH_THRESHOLD
#define TOUCH_THRESHOLD 0.05F
#endif
 
#define TOUCH_ORIENTATION_BIT_SWAP  0
#define TOUCH_ORIENTATION_BIT_INV_X 1
#define TOUCH_ORIENTATION_BIT_INV_Y 2
 
namespace iotouch {
    class TouchOrientationSettings {
    private:
        uint16_t flags;
    public:
        TouchOrientationSettings(bool swapAxisXY, bool xIsInverted, bool yIsInverted) {
            flags = 0;
            bitWrite(flags, TOUCH_ORIENTATION_BIT_SWAP, swapAxisXY);
            bitWrite(flags, TOUCH_ORIENTATION_BIT_INV_X, xIsInverted);
            bitWrite(flags, TOUCH_ORIENTATION_BIT_INV_Y, yIsInverted);
        }
        TouchOrientationSettings(const TouchOrientationSettings& other) = default;
        TouchOrientationSettings& operator= (const TouchOrientationSettings& other) = default;
 
        bool isOrientationSwapped() const { return bitRead(flags, TOUCH_ORIENTATION_BIT_SWAP);}
        bool isXInverted() const { return bitRead(flags, TOUCH_ORIENTATION_BIT_INV_X);}
        bool isYInverted() const { return bitRead(flags, TOUCH_ORIENTATION_BIT_INV_Y);}
    };
 
    enum AccelerationMode: uint8_t {
        WAITING,
        ACCELERATING,
        NEVER_ACCELERATES
    };
 
    class AccelerationHandler {
    private:
        uint8_t minTicks;
        uint8_t ticks;
        uint8_t accel;
        AccelerationMode mode;
    public:
        AccelerationHandler(uint8_t minTicks, bool accelerate) : minTicks(minTicks) {
            mode = accelerate ? WAITING : NEVER_ACCELERATES;
        }
 
        void reset() {
            if(mode == ACCELERATING) mode = WAITING;
        }
 
        bool tick();
    };
 
    class CalibrationHandler {
    private:
        float minX, maxX;
        float minY, maxY;
        bool calibrationOn;
 
    public:
        CalibrationHandler() = default;
        CalibrationHandler(const CalibrationHandler& other) = default;
        CalibrationHandler& operator=(const CalibrationHandler& other) = default;
 
        void setCalibrationValues(float mnX, float mxX, float mnY, float mxY);
 
        void enableCalibration(bool state) {
            calibrationOn = state;
        }
 
        float calibrateX(float rawValue, bool isInverted) const;
 
        float calibrateY(float rawValue, bool isInverted) const;
 
        float getMinX() const { return minX;}
        float getMinY() const { return minY;}
        float getMaxX() const { return maxX;}
        float getMaxY() const { return maxY;}
        void setXPosition(float x, bool isMax);
        void setYPosition(float y, bool isMax);
    };
 
    enum TouchState : uint8_t {
        NOT_TOUCHED,
        TOUCHED,
        HELD,
        TOUCH_DEBOUNCE
    };
 
#define portableFloatAbs(x) ((x)<0.0F?-(x):(x))
 
    class TouchInterrogator {
    public:
        virtual TouchState internalProcessTouch(float* ptrX, float* ptrY, const TouchOrientationSettings& settings, const CalibrationHandler& calib)=0;
    };
 
    class TouchInterrogator;
 
    class TouchScreenManager : public Executable {
    public:
    private:
        AccelerationHandler accelerationHandler;
        CalibrationHandler calibrator;
        TouchInterrogator* touchInterrogator;
        TouchState touchMode;
        TouchOrientationSettings orientation;
        bool usedForScrolling = false;
    public:
        explicit TouchScreenManager(TouchInterrogator* interrogator, const TouchOrientationSettings& orientationSettings) :
                accelerationHandler(10, true), calibrator(),
                touchInterrogator(interrogator), touchMode(NOT_TOUCHED), orientation(orientationSettings) {}
 
        void start() {
            touchMode = NOT_TOUCHED;
            taskManager.execute(this);
        }
 
        void setUsedForScrolling(bool scrolling) {
            usedForScrolling = scrolling;
        }
 
        void calibrateMinMaxValues(float xmin, float xmax, float ymin, float ymax) {
            calibrator.setCalibrationValues(xmin, xmax, ymin, ymax);
        }
 
        void setCalibration(const CalibrationHandler& other) { calibrator = other; }
 
        void enableCalibration(bool ena) {
            calibrator.enableCalibration(ena);
        }
 
        TouchOrientationSettings changeOrientation(const TouchOrientationSettings& newOrientation);
 
        TouchOrientationSettings getOrientation() { return orientation; }
 
        void exec() override;
 
        virtual void sendEvent(float locationX, float locationY, float touchPressure, TouchState touched) = 0;
    };
 
    class ResistiveTouchInterrogator : public TouchInterrogator {
    private:
        pinid_t xpPin, xnPinAdc, ypPinAdc, ynPin;
    public:
 
        ResistiveTouchInterrogator(pinid_t xpPin, pinid_t xnPin, pinid_t ypPin, pinid_t ynPin)
                : xpPin(xpPin), xnPinAdc(xnPin), ypPinAdc(ypPin), ynPin(ynPin) {}
 
        TouchState internalProcessTouch(float* ptrX, float* ptrY, const TouchOrientationSettings& rotation, const CalibrationHandler& calibrator) override;
 
    };
 
    class ValueStoringResistiveTouchScreen : public TouchScreenManager {
    private:
        float lastX, lastY, touchPressure;
        TouchState touchState;
    public:
        ValueStoringResistiveTouchScreen(TouchInterrogator& interrogator, const TouchOrientationSettings& rotation)
            : TouchScreenManager(&interrogator, rotation), lastX(0.0F), lastY(0.0F), touchState(NOT_TOUCHED) {
        }
 
        void sendEvent(float locationX, float locationY, float pressure, TouchState touched) override;
 
        float getTouchPressure() const { return touchPressure; }
        float getLastX() const { return lastX; }
        float getLastY() const { return lastY; }
        bool isPressed() const { return touchState == TOUCHED; }
        TouchState getTouchState() const { return touchState; }
    };
}
 
#endif //IOA_RESISTIVETOUCHSCREEN_H