adxl345.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/serial/spi/spi.h>
 
namespace PropWare {
 
class ADXL345 {
    public:
        enum class Register {
                    DEVICE_ID,
                    TAP_THRESHOLD = 0x1D,
                    X_AXIS_OFFSET,
                    Y_AXIS_OFFSET,
                    Z_AXIS_OFFSET,
                    TAP_DURATION,
                    TAP_LATENCY,
                    TAP_WINDOW,
                    ACTIVITY_THRESHOLD,
                    INACTIVITY_THRESHOLD,
                    INACTIVITY_TIME,
                    ACT_INACT_CTL,
                    FREE_FALL_THRESHOLD,
                    FREE_FALL_TIME,
                    TAP_AXES,
                    TAP_SOURCE,
                    RATE_AND_POWER_MODE,
                    POWER_CONTROL,
                    INTERRUPT_ENABLE,
                    INTERRUPT_MAPPING,
                    INTERRUPT_SOURCES,
                    DATA_FORMAT,
                    X_AXIS_0,
                    X_AXIS_1,
                    Y_AXIS_0,
                    Y_AXIS_1,
                    Z_AXIS_0,
                    Z_AXIS_1,
                    FIFO_CONTROL,
                    FIFO_STATUS
        };
 
        typedef enum {
            X,
            Y,
            Z,
            AXES
        } Axis;
 
        typedef enum { _6_25_HZ = 6,  _12_5_HZ,    _25_HZ,      _50_HZ,     _100_HZ,    _200_HZ,    _400_HZ,     _800_HZ,    _1600_HZ,   _3200_HZ
        } DataRate;
 
        typedef enum { HZ_8, HZ_4, HZ_2, HZ_1
        } WakeupFrequency;
 
        typedef enum {  _2G,  _4G,  _8G, _16G
        } Range;
 
        typedef enum {
                BYPASS,
                FIFO,
                STREAM,
                TRIGGER
        } FIFOMode;
 
        union ActivityDetection {
            struct {
                unsigned int inactiveZEnable: 1;
                unsigned int inactiveYEnable: 1;
                unsigned int inactiveXEnable: 1;
                unsigned int inactiveAcDc: 1;
                unsigned int activeZEnable: 1;
                unsigned int activeYEnable: 1;
                unsigned int activeXEnable: 1;
                unsigned int activeAcDc: 1;
            }       fields;
            uint8_t raw;
        };
 
        union TapAxes {
            struct {
                unsigned int tapZEnable: 1;
                unsigned int tapYEnable: 1;
                unsigned int tapXEnable: 1;
                unsigned int suppress: 1;
            }       fields;
            uint8_t raw;
        };
 
        union TapSource {
            struct {
                unsigned int zTapped: 1;
                unsigned int yTapped: 1;
                unsigned int xTapped: 1;
                unsigned int asleep: 1;
                unsigned int zActivity: 1;
                unsigned int yActivity: 1;
                unsigned int xActivity: 1;
            }       fields;
            uint8_t raw;
        };
 
        union RateAndPowerMode {
            struct {
                DataRate     dataRate: 3;
                unsigned int lowPowerMode: 1;
            }       fields;
            uint8_t raw;
        };
 
        union PowerControl {
            struct {
                WakeupFrequency wakeup: 2;
                unsigned int    sleep: 1;
                unsigned int    measure: 1;
                unsigned int    autoSleep: 1;
                unsigned int    link: 1;
            }       fields;
            uint8_t raw;
        };
 
        union InterruptEnable {
            struct { unsigned int    overrun: 1; unsigned int  watermark: 1; unsigned int  freeFall: 1; unsigned int inactivity: 1; unsigned int   activity: 1; unsigned int doubleTap: 1; unsigned int singleTap: 1; unsigned int dataReady: 1;
            }       fields;
            uint8_t raw;
        };
 
        union InterruptMapping {
            struct { unsigned int
                    overrun: 1; unsigned int
                    watermark: 1; unsigned int
                    freeFall: 1; unsigned int
                    inactivity: 1; unsigned int
                    activity: 1; unsigned int
                    doubleTap: 1; unsigned int
                    singleTap: 1; unsigned int
                    dataReady: 1;
            }       fields;
            uint8_t raw;
        };
 
        union InterruptSources {
            struct { unsigned int    overrun: 1; unsigned int   watermark: 1; unsigned int   freeFall: 1; unsigned int inactivity: 1; unsigned int   activity: 1; unsigned int  doubleTap: 1; unsigned int  singleTap: 1; unsigned int  dataReady: 1;
            }       fields;
            uint8_t raw;
        };
 
        union DataFormat {
            struct {
                Range        range: 2;
                unsigned int justify: 1;
                unsigned int fullResolution: 1;
                unsigned int invertedInterrupts: 1;
                unsigned int spiMode;
                unsigned int selfTest;
            }       fields;
            uint8_t raw;
        };
 
        union FIFOControl {
            struct {
                unsigned int samples: 5;
                unsigned int trigger: 1;
                FIFOMode     fifoMode: 2;
            }       fields;
            uint8_t raw;
        };
 
        union FIFOStatus {
            struct { unsigned int         entries: 6; unsigned int                                                         unused: 1; unsigned int fifoTrigger: 1;
            }       fields;
            uint8_t raw;
        };
 
    public:
        static const SPI::Mode SPI_MODE = SPI::Mode::MODE_3;
 
        static const uint8_t DEVICE_ID = 0xE5;
 
        static constexpr double FULL_RESOLUTION_SCALE = 0.004;
 
        static double scale (const int value, const Range range) {
            return value * (1 << range) * FULL_RESOLUTION_SCALE;
        }
 
    public:
        ADXL345 (SPI &bus, const Pin::Mask csMask, const bool alwaysSetSPIMode = false)
            : m_bus(&bus),
              m_cs(csMask, Pin::Dir::OUT),
              m_alwaysSetMode(alwaysSetSPIMode) {
            if (!alwaysSetSPIMode)
                this->m_bus->set_mode(SPI_MODE);
            this->m_cs.set();
        }
 
        ADXL345 (const Pin::Mask csMask, const bool alwaysSetSPIMode = true)
            : m_bus(&SPI::get_instance()),
              m_cs(csMask, Pin::Dir::OUT),
              m_alwaysSetMode(alwaysSetSPIMode) {
            if (!alwaysSetSPIMode)
                this->m_bus->set_mode(SPI::Mode::MODE_1);
            this->m_cs.set();
        }
 
        void always_set_spi_mode (const bool alwaysSetMode) {
            this->m_alwaysSetMode = alwaysSetMode;
        }
 
        void start (const bool autoSleep = false, const bool link = false, const bool sleep = false,
                    const bool measure = true, const WakeupFrequency wakeupFrequency = WakeupFrequency::HZ_8) const {
            this->write(Register::POWER_CONTROL, PowerControl{fields: {
                wakeup: wakeupFrequency,
                sleep: static_cast<unsigned int>(sleep),
                measure: static_cast<unsigned int>(measure),
                autoSleep: static_cast<unsigned int>(autoSleep),
                link: static_cast<unsigned int>(link)
            }}.raw);
        }
 
        void read (int16_t *values) const {
            this->read(Register::X_AXIS_0, AXES, values);
        }
 
        int16_t read_axis (const Axis axis) const {
            int16_t temp[3];
            this->read(temp);
            return temp[static_cast<size_t>(axis)];
        }
 
        int16_t read_x () const {
            return this->read_axis(Axis::X);
        }
 
        int16_t read_y () const {
            return this->read_axis(Axis::Y);
        }
 
        int16_t read_z () const {
            return this->read_axis(Axis::Z);
        }
 
        void write (const Register address, const uint8_t value) const {
            if (this->m_alwaysSetMode)
                this->m_bus->set_mode(SPI_MODE);
 
            this->m_cs.clear();
            this->m_bus->shift_out(8, static_cast<uint32_t>(address));
            this->m_bus->shift_out(8, value);
            this->m_cs.set();
        }
 
        uint8_t read (const Register address) const {
            if (this->m_alwaysSetMode)
                this->m_bus->set_mode(SPI_MODE);
 
            this->m_cs.clear();
            this->m_bus->shift_out(8, BIT_7 | static_cast<uint32_t>(address));
            const uint8_t result = static_cast<const uint8_t>(this->m_bus->shift_in(8));
            this->m_cs.set();
            return result;
        }
 
        void read (const Register startingAddress, const size_t words, int16_t *result) const {
            if (this->m_alwaysSetMode)
                this->m_bus->set_mode(SPI_MODE);
 
            this->m_cs.clear();
            this->m_bus->shift_out(8, BIT_7 | BIT_6 | static_cast<uint32_t>(startingAddress));
            for (size_t i = 0; i < words; ++i) {
                const uint8_t lowByte  = static_cast<const uint8_t>(this->m_bus->shift_in(8));
                const uint8_t highByte = static_cast<const uint8_t>(this->m_bus->shift_in(8));
                result[i] = highByte << 8 | lowByte;
            }
            this->m_cs.set();
        }
 
        void set_bit (const Register address, const Bit bit) const {
            const auto startingValue = this->read(address);
            this->write(address, bit | startingValue);
        }
 
        void clear_bit (const Register address, const Bit bit) const {
            const auto startingValue = this->read(address);
            this->write(address, ~bit & startingValue);
        }
 
    private:
        SPI       *m_bus;
        const Pin m_cs;
        bool      m_alwaysSetMode;
};
 
}