Trill.h

#pragma once
#include <I2c.h>
#include <stdint.h>
#include <string>
#include <vector>

 
class Trill : public I2c
{
        public:
                typedef enum {
                        AUTO = -1, 
                        CENTROID = 0, 
                        RAW = 1, 
                        BASELINE = 2, 
                        DIFF = 3, 
                } Mode;

                typedef enum {
                        NONE = -1, 
                        ANY = 0, 
                        BAR = 1, 
                        SQUARE = 2, 
                        CRAFT = 3, 
                        RING = 4, 
                        HEX = 5, 
                        FLEX = 6, 
                        UNKNOWN = ANY, 
                } Device;

                typedef enum {
                        kEventModeTouch = 0, 
                        kEventModeChange = 1, 
                        kEventModeAlways = 2, 
                } EventMode;

                typedef enum {
                        kScanTriggerDisabled = 0x0, 
                        kScanTriggerI2c = 0x1, 
                        kScanTriggerTimer = 0x2, 
                        kScanTriggerI2cOrTimer = 0x3, 
                } ScanTriggerMode;
        private:
                Mode mode_; // Which mode the device is in
                Device device_type_ = NONE; // Which type of device is connected (if any)
                uint32_t frameId;
                uint8_t statusByte;
                uint8_t address;
                uint8_t firmware_version_ = 0; // Firmware version running on the device
                uint8_t num_touches_; // Number of touches on last read
                bool dataBufferIncludesStatusByte = false;
                bool quiet = false;
                std::vector<uint8_t> dataBuffer;
                uint16_t commandSleepTime = 1000;
                size_t currentReadOffset = -1;
                bool shouldReadFrameId = false;
                unsigned int numBits;
                unsigned int transmissionWidth = 16;
                unsigned int transmissionRightShift = 0;
                uint32_t channelMask;
                uint8_t numChannels;
                float posRescale;
                float posHRescale;
                float sizeRescale;
                float rawRescale;
                ScanTriggerMode scanTriggerMode;
                int identify();
                void updateRescale();
                void parseNewData(bool includesStatusByte);
                void processStatusByte(uint8_t newStatusByte);
                int writeCommandAndHandle(const i2c_char_t* data, size_t size, const char* name);
                int writeCommandAndHandle(i2c_char_t command, const char* name);
                int readBytesFrom(uint8_t offset, i2c_char_t* data, size_t size, const char* name);
                int readBytesFrom(uint8_t offset, i2c_char_t& byte, const char* name);
                int waitForAck(uint8_t command, const char* name);
                void updateChannelMask(uint32_t mask);
                int verbose = 0;
                uint8_t cmdCounter = 0;
                bool readErrorOccurred;
                bool enableVersionCheck = true;
        public:
                std::vector<float> rawData;

                static constexpr uint8_t speedValues[4] = {0, 1, 2, 3};
                static constexpr uint8_t prescalerMax = 8;
                Trill();
                ~Trill();
                Trill(unsigned int i2c_bus, Device device, uint8_t i2c_address = 255);
                int setup(unsigned int i2c_bus, Device device = ANY, uint8_t i2c_address = 255);

                static Device probe(unsigned int i2c_bus, uint8_t i2c_address);

                static std::vector<std::pair<Device,uint8_t> > probeRange(unsigned int i2c_bus, size_t maxCount = 0);

                int updateBaseline();
                int reset();

                int readI2C(bool shouldReadStatusByte = false);

                void newData(const uint8_t* newData, size_t len, bool includesStatusByte = false);

                Device deviceType() { return device_type_; }
                static const std::string& getNameFromDevice(Device device);
                static Device getDeviceFromName(const std::string& name);
                static const std::string& getNameFromMode(Mode mode);
                static Mode getModeFromName(const std::string& name);
                int firmwareVersion() { return firmware_version_; }
                Mode getMode() { return mode_; }
                uint8_t getAddress() { return address; }
                void printDetails() ;
                void setVerbose(int verbose);
                unsigned int getNumChannels() const;
                unsigned int getDefaultNumChannels() const;

                int setMode(Mode mode);
                int setScanSettings(uint8_t speed, uint8_t num_bits = 12);
                int setPrescaler(uint8_t prescaler);
                int setNoiseThreshold(float threshold);
                int setIDACValue(uint8_t value);
                int setMinimumTouchSize(float minSize);
                int setScanTrigger(ScanTriggerMode scanTriggerMode);
                int setTimerPeriod(float ms);
                int setAutoScanInterval(uint16_t interval);
                int setEventMode(EventMode mode);
                int setChannelMask(uint32_t mask);
                int setTransmissionFormat(uint8_t width, uint8_t shift); // end of Scan Configuration Settings
                int readStatusByte();
                bool hasReset();
                bool hasActivity();
                uint8_t getFrameId();
                uint32_t getFrameIdUnwrapped();

                bool is1D();
                bool is2D();
                unsigned int getBytesToRead(bool includesStatusByte);
                unsigned int getNumButtons() { return 2 * (getMode() == CENTROID && RING == deviceType());};
                unsigned int getNumTouches();
                float touchLocation(uint8_t touch_num);
                float touchSize(uint8_t touch_num);
                unsigned int getNumHorizontalTouches();
                float touchHorizontalLocation(uint8_t touch_num);
                float touchHorizontalSize(uint8_t touch_num);
                float compoundTouchLocation();
                float compoundTouchHorizontalLocation();
                float compoundTouchSize();
                float getButtonValue(uint8_t button_num);
 // end of centroid mode
};