l3g.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/PropWare.h>
#include <PropWare/serial/spi/spi.h>
 
namespace PropWare {
 
class L3G {
    public:
        typedef enum {         X,         Y,         Z, AXES
        } Axis;
 
        typedef enum { DPS_250  = 0x00, DPS_500  = 0x10,DPS_2000 = 0x20
        } DPSMode;
 
    public:
        static const SPI::Mode    SPI_MODE    = SPI::Mode::MODE_3;
        static const SPI::BitMode SPI_BITMODE = SPI::BitMode::MSB_FIRST;
 
        enum class Register {
                WHO_AM_I      = 0x0F,
                CTRL_REG1     = 0x20,
                CTRL_REG2     = 0x21,
                CTRL_REG3     = 0x22,
                CTRL_REG4     = 0x23,
                CTRL_REG5     = 0x24,
                REFERENCE     = 0x25,
                OUT_TEMP      = 0x26,
                STATUS_REG    = 0x27,
                OUT_X_L       = 0x28,
                OUT_X_H       = 0x29,
                OUT_Y_L       = 0x2A,
                OUT_Y_H       = 0x2B,
                OUT_Z_L       = 0x2C,
                OUT_Z_H       = 0x2D,
                FIFO_CTRL_REG = 0x2E,
                FIFO_SRC_REG  = 0x2F,
                INT1_CFG      = 0x30,
                INT1_SRC      = 0x31,
                INT1_THS_XH   = 0x32,
                INT1_THS_XL   = 0x33,
                INT1_THS_YH   = 0x34,
                INT1_THS_YL   = 0x35,
                INT1_THS_ZH   = 0x36,
                INT1_THS_ZL   = 0x37,
                INT1_DURATION = 0x38
        };
 
    public:
        static double to_dps (const int rawValue, const DPSMode dpsMode) {
            switch (dpsMode) {
                case DPSMode::DPS_250:
                    return rawValue * 0.00875;
                case DPSMode::DPS_500:
                    return rawValue * 0.01750;
                case DPSMode::DPS_2000:
                    return rawValue * 0.07000;
            }
            return 0;
        }
 
    public:
        L3G (SPI &spi, const Port::Mask cs, const bool alwaysSetMode = false)
            : m_spi(&spi),
              m_cs(cs, Pin::Dir::OUT),
              m_alwaysSetMode(alwaysSetMode) {
            this->m_cs.set();
        }
 
        void always_set_spi_mode (const bool alwaysSetMode) {
            this->m_alwaysSetMode = alwaysSetMode;
        }
 
        void read (int16_t *values) const {
            const auto addr = static_cast<uint8_t>(Register::OUT_X_L) | BIT_7 | BIT_6;
 
            this->maybe_set_spi_mode();
 
            this->m_cs.clear();
            this->m_spi->shift_out(8, addr);
            values[Axis::X]        = static_cast<int16_t>(this->m_spi->shift_in(16));
            values[Axis::Y]        = static_cast<int16_t>(this->m_spi->shift_in(16));
            values[Axis::Z]        = static_cast<int16_t>(this->m_spi->shift_in(16));
            this->m_cs.set();
 
            // err is useless at this point and will be used as a temporary
            // 8-bit variable
            uint32_t          temp;
            for (unsigned int axis = 0; axis < AXES; ++axis) {
                temp = (uint32_t) (values[axis] >> 8);
                values[axis] <<= 8;
                values[axis] |= temp;
            }
        }
 
        int16_t read (const Axis axis) const {
            return this->read16(static_cast<Register>(static_cast<unsigned int>(Register::OUT_X_L) + 2 * axis));
        }
 
        int16_t read_x () const {
            return this->read16(Register::OUT_X_L);
        }
 
        int16_t read_y () const {
            return this->read16(Register::OUT_Y_L);
        }
 
        int16_t read_z () const {
            return this->read16(Register::OUT_Z_L);
        }
 
        void set_dps (const DPSMode dpsMode) const {
            this->maybe_set_spi_mode();
 
            uint8_t registerValue = this->read(Register::CTRL_REG4);
            registerValue &= ~(BIT_5 | BIT_4);
            registerValue |= dpsMode;
            this->write(Register::CTRL_REG4, registerValue);
        }
 
        void write (const Register address, const uint8_t registerValue) const {
            const uint8_t  commandByte  = static_cast<uint8_t>(address) & ~BIT_7;  // Clear the RW bit (write mode)
            const uint16_t combinedWord = commandByte << 8 | registerValue;
 
            this->maybe_set_spi_mode();
 
            this->m_cs.clear();
            this->m_spi->shift_out(16, combinedWord);
            this->m_cs.set();
        }
 
        uint8_t read (const Register address) const {
            // Set RW bit and enable auto-increment
            const uint8_t commandByte = static_cast<uint8_t>(address) | BIT_7 | BIT_6;
 
            this->maybe_set_spi_mode();
 
            this->m_cs.clear();
            this->m_spi->shift_out(8, commandByte);
            const auto registerValue = static_cast<uint8_t>(this->m_spi->shift_in(8));
            this->m_cs.set();
 
            return registerValue;
        }
 
        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);
        }
 
    protected:
        int16_t read16 (Register address) const {
            // Set RW bit and enable auto-increment
            const uint8_t commandByte = static_cast<uint8_t>(address) | BIT_7 | BIT_6;
 
            this->maybe_set_spi_mode();
 
            this->m_cs.clear();
            this->m_spi->shift_out(8, commandByte);
            uint16_t registerValue = static_cast<uint16_t>(this->m_spi->shift_in(16));
            this->m_cs.set();
 
            uint_fast8_t temp = registerValue >> 8;
            registerValue <<= 8;
            return static_cast<int16_t>(registerValue | temp);
        }
 
        void maybe_set_spi_mode () const {
            if (this->m_alwaysSetMode) {
                this->m_spi->set_mode(SPI_MODE);
                this->m_spi->set_bit_mode(SPI_BITMODE);
            }
        }
 
    private:
        SPI       *m_spi;
        const Pin m_cs;
        bool      m_alwaysSetMode;
};
 
}