kx122.hpp

Go to the documentation of this file.

/*
* The MIT License (MIT)
*
* Author: Samuli Rissanen <samuli.rissanen@hotmail.com>
* Copyright (c) 2018 Rohm Semiconductor.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#pragma once

#include <vector>
#include <mraa/gpio.hpp>

#include "kx122.h"

namespace upm{

  class KX122{
    public:

      KX122(int bus, int addr, int chip_select, int spi_bus_frequency = DEFAULT_SPI_FREQUENCY);

      ~KX122();

      void deviceInit(KX122_ODR_T odr, KX122_RES_T res, KX122_RANGE_T grange);

      float getSamplePeriod();

      uint8_t getWhoAmI();

      void getRawAccelerationData(float *x, float *y, float *z);

      void getAccelerationData(float *x, float *y, float *z);

      std::vector<float> getAccelerationDataVector();

      void softwareReset();

      void enableIIR();

      void disableIIR();

      void selfTest();

      void setSensorStandby();

      void setSensorActive();

      void setODR(KX122_ODR_T odr);

      void setGrange(KX122_RANGE_T grange);

      void setResolution(KX122_RES_T res);

      void setBW(LPRO_STATE_T lpro);

      void setAverage(KX122_AVG_T avg);

      void installISR(mraa::Edge edge, KX122_INTERRUPT_PIN_T intp, int pin, void (*isr)(void*), void *arg);

      void uninstallISR(KX122_INTERRUPT_PIN_T intp);

      void enableInterrupt1(KX122_INTERRUPT_POLARITY_T polarity);

      void enableInterrupt2(KX122_INTERRUPT_POLARITY_T polarity);

      void disableInterrupt1();

      void disableInterrupt2();

      void routeInterrupt1(uint8_t bits);

      void routeInterrupt2(uint8_t bits);

      bool getInterruptStatus();

      uint8_t getInterruptSource();

      void clearInterrupt();

      void enableDataReadyInterrupt();

      void disableDataReadyInterrupt();

      void enableBufferFullInterrupt();

      void disableBufferFullInterrupt();

      void enableBuffer();

      void disableBuffer();

      void bufferInit(uint samples, KX122_RES_T res, KX122_BUFFER_MODE_T mode);

      void setBufferResolution(KX122_RES_T res);

      void setBufferThreshold(uint samples);

      void setBufferMode(KX122_BUFFER_MODE_T mode);

      uint getBufferStatus();

      std::vector<float> getRawBufferSamples(uint len);

      std::vector<float> getBufferSamples(uint len);

      void clearBuffer();
    private:
      //Device context
      kx122_context m_kx122;

      /* Disable implicit copy and assignment operators */
      KX122(const KX122&) = delete;
      KX122 &operator=(const KX122&) = delete;
  };
}