Pathfindr
init
Dependencies: aconno_I2C Lis2dh12 WatchdogTimer
Revision 7:e9a19750700d, committed 2018-12-11
- Comitter:
- pathfindr
- Date:
- Tue Dec 11 22:18:24 2018 +0000
- Parent:
- 6:388d3c7efdd9
- Child:
- 8:7351f8c4cd60
- Commit message:
- init
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LIS3DH.h Tue Dec 11 22:18:24 2018 +0000
@@ -0,0 +1,524 @@
+#ifndef LIS3DH_H
+#define LIS3DH_H
+
+#include "mbed.h"
+
+namespace mbed {
+
+#ifndef __ARCHDEP__TYPES
+#define __ARCHDEP__TYPES
+
+typedef unsigned char u8_t;
+typedef unsigned short int u16_t;
+typedef short int i16_t;
+typedef signed char i8_t;
+
+#endif /*__ARCHDEP__TYPES*/
+
+typedef u8_t LIS3DH_IntPinConf_t;
+typedef u8_t LIS3DH_Axis_t;
+typedef u8_t LIS3DH_Int1Conf_t;
+
+
+//define structure
+#ifndef __SHARED__TYPES
+#define __SHARED__TYPES
+
+typedef enum {
+ MEMS_SUCCESS = 0x01,
+ MEMS_ERROR = 0x00
+} status_t;
+
+typedef enum {
+ MEMS_ENABLE = 0x01,
+ MEMS_DISABLE = 0x00
+} State_t;
+
+typedef __packed struct {
+ i16_t AXIS_X;
+ i16_t AXIS_Y;
+ i16_t AXIS_Z;
+} AxesRaw_t;
+
+#endif /*__SHARED__TYPES*/
+
+typedef enum {
+ LIS3DH_ODR_1Hz = 0x01,
+ LIS3DH_ODR_10Hz = 0x02,
+ LIS3DH_ODR_25Hz = 0x03,
+ LIS3DH_ODR_50Hz = 0x04,
+ LIS3DH_ODR_100Hz = 0x05,
+ LIS3DH_ODR_200Hz = 0x06,
+ LIS3DH_ODR_400Hz = 0x07,
+ LIS3DH_ODR_1620Hz_LP = 0x08,
+ LIS3DH_ODR_1344Hz_NP_5367HZ_LP = 0x09
+} LIS3DH_ODR_t;
+
+typedef enum {
+ LIS3DH_POWER_DOWN = 0x00,
+ LIS3DH_LOW_POWER = 0x01,
+ LIS3DH_NORMAL = 0x02
+} LIS3DH_Mode_t;
+
+typedef enum {
+ LIS3DH_HPM_NORMAL_MODE_RES = 0x00,
+ LIS3DH_HPM_REF_SIGNAL = 0x01,
+ LIS3DH_HPM_NORMAL_MODE = 0x02,
+ LIS3DH_HPM_AUTORESET_INT = 0x03
+} LIS3DH_HPFMode_t;
+
+typedef enum {
+ LIS3DH_HPFCF_0 = 0x00,
+ LIS3DH_HPFCF_1 = 0x01,
+ LIS3DH_HPFCF_2 = 0x02,
+ LIS3DH_HPFCF_3 = 0x03
+} LIS3DH_HPFCutOffFreq_t;
+
+typedef struct {
+ u16_t AUX_1;
+ u16_t AUX_2;
+ u16_t AUX_3;
+} LIS3DH_Aux123Raw_t;
+
+typedef enum {
+ LIS3DH_FULLSCALE_2 = 0x00,
+ LIS3DH_FULLSCALE_4 = 0x01,
+ LIS3DH_FULLSCALE_8 = 0x02,
+ LIS3DH_FULLSCALE_16 = 0x03
+} LIS3DH_Fullscale_t;
+
+typedef enum {
+ LIS3DH_BLE_LSB = 0x00,
+ LIS3DH_BLE_MSB = 0x01
+} LIS3DH_Endianess_t;
+
+typedef enum {
+ LIS3DH_SELF_TEST_DISABLE = 0x00,
+ LIS3DH_SELF_TEST_0 = 0x01,
+ LIS3DH_SELF_TEST_1 = 0x02
+} LIS3DH_SelfTest_t;
+
+typedef enum {
+ LIS3DH_FIFO_BYPASS_MODE = 0x00,
+ LIS3DH_FIFO_MODE = 0x01,
+ LIS3DH_FIFO_STREAM_MODE = 0x02,
+ LIS3DH_FIFO_TRIGGER_MODE = 0x03,
+ LIS3DH_FIFO_DISABLE = 0x04
+} LIS3DH_FifoMode_t;
+
+typedef enum {
+ LIS3DH_TRIG_INT1 = 0x00,
+ LIS3DH_TRIG_INT2 = 0x01
+} LIS3DH_TrigInt_t;
+
+typedef enum {
+ LIS3DH_SPI_4_WIRE = 0x00,
+ LIS3DH_SPI_3_WIRE = 0x01
+} LIS3DH_SPIMode_t;
+
+typedef enum {
+ LIS3DH_X_ENABLE = 0x01,
+ LIS3DH_X_DISABLE = 0x00,
+ LIS3DH_Y_ENABLE = 0x02,
+ LIS3DH_Y_DISABLE = 0x00,
+ LIS3DH_Z_ENABLE = 0x04,
+ LIS3DH_Z_DISABLE = 0x00
+} LIS3DH_AXISenable_t;
+
+typedef enum {
+ LIS3DH_INT1_6D_4D_DISABLE = 0x00,
+ LIS3DH_INT1_6D_ENABLE = 0x01,
+ LIS3DH_INT1_4D_ENABLE = 0x02
+} LIS3DH_INT_6D_4D_t;
+
+typedef enum {
+ LIS3DH_UP_SX = 0x44,
+ LIS3DH_UP_DX = 0x42,
+ LIS3DH_DW_SX = 0x41,
+ LIS3DH_DW_DX = 0x48,
+ LIS3DH_TOP = 0x60,
+ LIS3DH_BOTTOM = 0x50
+} LIS3DH_POSITION_6D_t;
+
+typedef enum {
+ LIS3DH_INT_MODE_OR = 0x00,
+ LIS3DH_INT_MODE_6D_MOVEMENT = 0x01,
+ LIS3DH_INT_MODE_AND = 0x02,
+ LIS3DH_INT_MODE_6D_POSITION = 0x03
+} LIS3DH_Int1Mode_t;
+
+
+//interrupt click response
+// b7 = don't care b6 = IA b5 = DClick b4 = Sclick b3 = Sign
+// b2 = z b1 = y b0 = x
+typedef enum {
+LIS3DH_DCLICK_Z_P = 0x24,
+LIS3DH_DCLICK_Z_N = 0x2C,
+LIS3DH_SCLICK_Z_P = 0x14,
+LIS3DH_SCLICK_Z_N = 0x1C,
+LIS3DH_DCLICK_Y_P = 0x22,
+LIS3DH_DCLICK_Y_N = 0x2A,
+LIS3DH_SCLICK_Y_P = 0x12,
+LIS3DH_SCLICK_Y_N = 0x1A,
+LIS3DH_DCLICK_X_P = 0x21,
+LIS3DH_DCLICK_X_N = 0x29,
+LIS3DH_SCLICK_X_P = 0x11,
+LIS3DH_SCLICK_X_N = 0x19,
+LIS3DH_NO_CLICK = 0x00
+} LIS3DH_Click_Response;
+
+//TODO: start from here and manage the shared macros etc before this
+
+/* Exported constants --------------------------------------------------------*/
+
+#ifndef __SHARED__CONSTANTS
+#define __SHARED__CONSTANTS
+
+#define MEMS_SET 0x01
+#define MEMS_RESET 0x00
+
+#endif /*__SHARED__CONSTANTS*/
+
+
+//Register Definition
+#define LIS3DH_WHO_AM_I 0x0F // device identification register (00110011 default value=0x33)
+
+// CONTROL REGISTER 1
+#define LIS3DH_CTRL_REG1 0x20
+#define LIS3DH_ODR_BIT BIT(4)
+#define LIS3DH_LPEN BIT(3)
+#define LIS3DH_ZEN BIT(2)
+#define LIS3DH_YEN BIT(1)
+#define LIS3DH_XEN BIT(0)
+
+//CONTROL REGISTER 2
+#define LIS3DH_CTRL_REG2 0x21
+#define LIS3DH_HPM BIT(6)
+#define LIS3DH_HPCF BIT(4)
+#define LIS3DH_FDS BIT(3)
+#define LIS3DH_HPCLICK BIT(2)
+#define LIS3DH_HPIS2 BIT(1)
+#define LIS3DH_HPIS1 BIT(0)
+
+//CONTROL REGISTER 3
+#define LIS3DH_CTRL_REG3 0x22
+#define LIS3DH_I1_CLICK BIT(7)
+#define LIS3DH_I1_AOI1 BIT(6)
+#define LIS3DH_I1_AOI2 BIT(5)
+#define LIS3DH_I1_DRDY1 BIT(4)
+#define LIS3DH_I1_DRDY2 BIT(3)
+#define LIS3DH_I1_WTM BIT(2)
+#define LIS3DH_I1_ORUN BIT(1)
+
+//CONTROL REGISTER 6
+#define LIS3DH_CTRL_REG6 0x25
+#define LIS3DH_I2_CLICK BIT(7)
+#define LIS3DH_I2_INT1 BIT(6)
+#define LIS3DH_I2_BOOT BIT(4)
+#define LIS3DH_H_LACTIVE BIT(1)
+
+//TEMPERATURE CONFIG REGISTER
+#define LIS3DH_TEMP_CFG_REG 0x1F
+#define LIS3DH_ADC_PD BIT(7)
+#define LIS3DH_TEMP_EN BIT(6)
+
+//CONTROL REGISTER 4
+#define LIS3DH_CTRL_REG4 0x23
+#define LIS3DH_BDU BIT(7)
+#define LIS3DH_BLE BIT(6)
+#define LIS3DH_FS BIT(4)
+#define LIS3DH_HR BIT(3)
+#define LIS3DH_ST BIT(1)
+#define LIS3DH_SIM BIT(0)
+
+//CONTROL REGISTER 5
+#define LIS3DH_CTRL_REG5 0x24
+#define LIS3DH_BOOT BIT(7)
+#define LIS3DH_FIFO_EN BIT(6)
+#define LIS3DH_LIR_INT1 BIT(3)
+#define LIS3DH_D4D_INT1 BIT(2)
+
+//REFERENCE/DATA_CAPTURE
+#define LIS3DH_REFERENCE_REG 0x26
+#define LIS3DH_REF BIT(0)
+
+//STATUS_REG_AXIES
+#define LIS3DH_STATUS_REG 0x27
+#define LIS3DH_ZYXOR BIT(7)
+#define LIS3DH_ZOR BIT(6)
+#define LIS3DH_YOR BIT(5)
+#define LIS3DH_XOR BIT(4)
+#define LIS3DH_ZYXDA BIT(3)
+#define LIS3DH_ZDA BIT(2)
+#define LIS3DH_YDA BIT(1)
+#define LIS3DH_XDA BIT(0)
+
+//STATUS_REG_AUX
+#define LIS3DH_STATUS_AUX 0x07
+
+//INTERRUPT 1 CONFIGURATION
+#define LIS3DH_INT1_CFG 0x30
+#define LIS3DH_ANDOR BIT(7)
+#define LIS3DH_INT_6D BIT(6)
+#define LIS3DH_ZHIE BIT(5)
+#define LIS3DH_ZLIE BIT(4)
+#define LIS3DH_YHIE BIT(3)
+#define LIS3DH_YLIE BIT(2)
+#define LIS3DH_XHIE BIT(1)
+#define LIS3DH_XLIE BIT(0)
+
+//FIFO CONTROL REGISTER
+#define LIS3DH_FIFO_CTRL_REG 0x2E
+#define LIS3DH_FM BIT(6)
+#define LIS3DH_TR BIT(5)
+#define LIS3DH_FTH BIT(0)
+
+//CONTROL REG3 bit mask
+#define LIS3DH_CLICK_ON_PIN_INT1_ENABLE 0x80
+#define LIS3DH_CLICK_ON_PIN_INT1_DISABLE 0x00
+#define LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE 0x40
+#define LIS3DH_I1_INT1_ON_PIN_INT1_DISABLE 0x00
+#define LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE 0x20
+#define LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE 0x00
+#define LIS3DH_I1_DRDY1_ON_INT1_ENABLE 0x10
+#define LIS3DH_I1_DRDY1_ON_INT1_DISABLE 0x00
+#define LIS3DH_I1_DRDY2_ON_INT1_ENABLE 0x08
+#define LIS3DH_I1_DRDY2_ON_INT1_DISABLE 0x00
+#define LIS3DH_WTM_ON_INT1_ENABLE 0x04
+#define LIS3DH_WTM_ON_INT1_DISABLE 0x00
+#define LIS3DH_INT1_OVERRUN_ENABLE 0x02
+#define LIS3DH_INT1_OVERRUN_DISABLE 0x00
+
+//CONTROL REG6 bit mask
+#define LIS3DH_CLICK_ON_PIN_INT2_ENABLE 0x80
+#define LIS3DH_CLICK_ON_PIN_INT2_DISABLE 0x00
+#define LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE 0x40
+#define LIS3DH_I2_INT1_ON_PIN_INT2_DISABLE 0x00
+#define LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE 0x20
+#define LIS3DH_I2_INT2_ON_PIN_INT2_DISABLE 0x00
+#define LIS3DH_I2_BOOT_ON_INT2_ENABLE 0x10
+#define LIS3DH_I2_BOOT_ON_INT2_DISABLE 0x00
+#define LIS3DH_INT_ACTIVE_HIGH 0x00
+#define LIS3DH_INT_ACTIVE_LOW 0x02
+
+//INT1_CFG bit mask
+#define LIS3DH_INT1_AND 0x80
+#define LIS3DH_INT1_OR 0x00
+#define LIS3DH_INT1_ZHIE_ENABLE 0x20
+#define LIS3DH_INT1_ZHIE_DISABLE 0x00
+#define LIS3DH_INT1_ZLIE_ENABLE 0x10
+#define LIS3DH_INT1_ZLIE_DISABLE 0x00
+#define LIS3DH_INT1_YHIE_ENABLE 0x08
+#define LIS3DH_INT1_YHIE_DISABLE 0x00
+#define LIS3DH_INT1_YLIE_ENABLE 0x04
+#define LIS3DH_INT1_YLIE_DISABLE 0x00
+#define LIS3DH_INT1_XHIE_ENABLE 0x02
+#define LIS3DH_INT1_XHIE_DISABLE 0x00
+#define LIS3DH_INT1_XLIE_ENABLE 0x01
+#define LIS3DH_INT1_XLIE_DISABLE 0x00
+
+//INT1_SRC bit mask
+#define LIS3DH_INT1_SRC_IA 0x40
+#define LIS3DH_INT1_SRC_ZH 0x20
+#define LIS3DH_INT1_SRC_ZL 0x10
+#define LIS3DH_INT1_SRC_YH 0x08
+#define LIS3DH_INT1_SRC_YL 0x04
+#define LIS3DH_INT1_SRC_XH 0x02
+#define LIS3DH_INT1_SRC_XL 0x01
+
+//INT1 REGISTERS
+#define LIS3DH_INT1_THS 0x32
+#define LIS3DH_INT1_DURATION 0x33
+
+//INT2 REGISTERS
+#define LIS3DH_INT2_THS 0x36
+#define LIS3DH_INT2_DURATION 0x37
+
+//INTERRUPT 1 SOURCE REGISTER
+#define LIS3DH_INT1_SRC 0x31
+#define LIS3DH_INT2_SRC 0x35
+
+//FIFO Source Register bit Mask
+#define LIS3DH_FIFO_SRC_WTM 0x80
+#define LIS3DH_FIFO_SRC_OVRUN 0x40
+#define LIS3DH_FIFO_SRC_EMPTY 0x20
+
+//INTERRUPT CLICK REGISTER
+#define LIS3DH_CLICK_CFG 0x38
+//INTERRUPT CLICK CONFIGURATION bit mask
+#define LIS3DH_ZD_ENABLE 0x20
+#define LIS3DH_ZD_DISABLE 0x00
+#define LIS3DH_ZS_ENABLE 0x10
+#define LIS3DH_ZS_DISABLE 0x00
+#define LIS3DH_YD_ENABLE 0x08
+#define LIS3DH_YD_DISABLE 0x00
+#define LIS3DH_YS_ENABLE 0x04
+#define LIS3DH_YS_DISABLE 0x00
+#define LIS3DH_XD_ENABLE 0x02
+#define LIS3DH_XD_DISABLE 0x00
+#define LIS3DH_XS_ENABLE 0x01
+#define LIS3DH_XS_DISABLE 0x00
+
+//INTERRUPT CLICK SOURCE REGISTER
+#define LIS3DH_CLICK_SRC 0x39
+//INTERRUPT CLICK SOURCE REGISTER bit mask
+#define LIS3DH_IA 0x40
+#define LIS3DH_DCLICK 0x20
+#define LIS3DH_SCLICK 0x10
+#define LIS3DH_CLICK_SIGN 0x08
+#define LIS3DH_CLICK_Z 0x04
+#define LIS3DH_CLICK_Y 0x02
+#define LIS3DH_CLICK_X 0x01
+
+//Click-click Register
+#define LIS3DH_CLICK_THS 0x3A
+#define LIS3DH_TIME_LIMIT 0x3B
+#define LIS3DH_TIME_LATENCY 0x3C
+#define LIS3DH_TIME_WINDOW 0x3D
+
+//OUTPUT REGISTER
+#define LIS3DH_OUT_X_L 0x28
+#define LIS3DH_OUT_X_H 0x29
+#define LIS3DH_OUT_Y_L 0x2A
+#define LIS3DH_OUT_Y_H 0x2B
+#define LIS3DH_OUT_Z_L 0x2C
+#define LIS3DH_OUT_Z_H 0x2D
+
+//AUX REGISTER
+#define LIS3DH_OUT_1_L 0x08
+#define LIS3DH_OUT_1_H 0x09
+#define LIS3DH_OUT_2_L 0x0A
+#define LIS3DH_OUT_2_H 0x0B
+#define LIS3DH_OUT_3_L 0x0C
+#define LIS3DH_OUT_3_H 0x0D
+
+//STATUS REGISTER bit mask
+#define LIS3DH_STATUS_REG_ZYXOR 0x80 // 1 : new data set has over written the previous one
+ // 0 : no overrun has occurred (default)
+#define LIS3DH_STATUS_REG_ZOR 0x40 // 0 : no overrun has occurred (default)
+ // 1 : new Z-axis data has over written the previous one
+#define LIS3DH_STATUS_REG_YOR 0x20 // 0 : no overrun has occurred (default)
+ // 1 : new Y-axis data has over written the previous one
+#define LIS3DH_STATUS_REG_XOR 0x10 // 0 : no overrun has occurred (default)
+ // 1 : new X-axis data has over written the previous one
+#define LIS3DH_STATUS_REG_ZYXDA 0x08 // 0 : a new set of data is not yet avvious one
+ // 1 : a new set of data is available
+#define LIS3DH_STATUS_REG_ZDA 0x04 // 0 : a new data for the Z-Axis is not availvious one
+ // 1 : a new data for the Z-Axis is available
+#define LIS3DH_STATUS_REG_YDA 0x02 // 0 : a new data for the Y-Axis is not available
+ // 1 : a new data for the Y-Axis is available
+#define LIS3DH_STATUS_REG_XDA 0x01 // 0 : a new data for the X-Axis is not available
+
+#define LIS3DH_DATAREADY_BIT LIS3DH_STATUS_REG_ZYXDA
+
+
+//STATUS AUX REGISTER bit mask
+#define LIS3DH_STATUS_AUX_321OR 0x80
+#define LIS3DH_STATUS_AUX_3OR 0x40
+#define LIS3DH_STATUS_AUX_2OR 0x20
+#define LIS3DH_STATUS_AUX_1OR 0x10
+#define LIS3DH_STATUS_AUX_321DA 0x08
+#define LIS3DH_STATUS_AUX_3DA 0x04
+#define LIS3DH_STATUS_AUX_2DA 0x02
+#define LIS3DH_STATUS_AUX_1DA 0x01
+
+#define LIS3DH_MEMS_I2C_ADDRESS 0x33
+
+//FIFO REGISTERS
+#define LIS3DH_FIFO_CTRL_REG 0x2E
+#define LIS3DH_FIFO_SRC_REG 0x2F
+
+
+/* Exported macro ------------------------------------------------------------*/
+
+#ifndef __SHARED__MACROS
+
+#define __SHARED__MACROS
+#define ValBit(VAR,Place) (VAR & (1<<Place))
+#define BIT(x) ( (x) )
+
+#endif /*__SHARED__MACROS*/
+
+class LIS3DH
+{
+public:
+ LIS3DH(PinName mosi, PinName miso, PinName ss, PinName sck);
+ ~LIS3DH();
+
+ //own functions
+ u8_t InitLIS3DH(LIS3DH_Mode_t Mode, LIS3DH_ODR_t Odr, LIS3DH_Fullscale_t Grange);
+ u8_t SetLIS3DHActivityDetection(uint8_t Th, LIS3DH_Int1Mode_t Mode, uint8_t OnOff);
+
+ //Sensor Configuration Functions
+ status_t LIS3DH_SetODR(LIS3DH_ODR_t ov);
+ status_t LIS3DH_SetMode(LIS3DH_Mode_t md);
+ status_t LIS3DH_SetAxis(LIS3DH_Axis_t axis);
+ status_t LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs);
+ status_t LIS3DH_SetBDU(State_t bdu);
+ status_t LIS3DH_SetBLE(LIS3DH_Endianess_t ble);
+ status_t LIS3DH_SetSelfTest(LIS3DH_SelfTest_t st);
+ status_t LIS3DH_SetTemperature(State_t state);
+ status_t LIS3DH_SetADCAux(State_t state);
+
+ //Filtering Functions
+ status_t LIS3DH_HPFClickEnable(State_t hpfe);
+ status_t LIS3DH_HPFAOI1Enable(State_t hpfe);
+ status_t LIS3DH_HPFAOI2Enable(State_t hpfe);
+ status_t LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpf);
+ status_t LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf);
+ status_t LIS3DH_SetFilterDataSel(State_t state);
+
+ //Interrupt Functions
+ status_t LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf);
+ status_t LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf);
+ status_t LIS3DH_IntLatchEnable(State_t latch);
+ status_t LIS3DH_ResetInt1Latch(void);
+ status_t LIS3DH_ResetInt2Latch(void);
+ status_t LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic);
+ status_t LIS3DH_SetInt1Threshold(u8_t ths);
+ status_t LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id);
+ status_t LIS3DH_SetIntMode(LIS3DH_Int1Mode_t ic);
+ status_t LIS3DH_SetClickCFG(u8_t status);
+ status_t LIS3DH_SetClickTHS(u8_t ths);
+ status_t LIS3DH_SetClickLIMIT(u8_t t_limit);
+ status_t LIS3DH_SetClickLATENCY(u8_t t_latency);
+ status_t LIS3DH_SetClickWINDOW(u8_t t_window);
+ status_t LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic);
+ status_t LIS3DH_GetInt1Src(u8_t* val);
+ status_t LIS3DH_GetInt1SrcBit(u8_t statusBIT, u8_t* val);
+
+ //FIFO Functions
+ status_t LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm);
+ status_t LIS3DH_SetWaterMark(u8_t wtm);
+ status_t LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr);
+ status_t LIS3DH_GetFifoSourceReg(u8_t* val);
+ status_t LIS3DH_GetFifoSourceBit(u8_t statusBIT, u8_t* val);
+ status_t LIS3DH_GetFifoSourceFSS(u8_t* val);
+
+ //Other Reading Functions
+ status_t LIS3DH_GetStatusReg(u8_t* val);
+ status_t LIS3DH_GetStatusBit(u8_t statusBIT, u8_t* val);
+ status_t LIS3DH_GetStatusAUXBit(u8_t statusBIT, u8_t* val);
+ status_t LIS3DH_GetStatusAUX(u8_t* val);
+
+ status_t LIS3DH_GetAccAxesRaw(AxesRaw_t* buff);
+ status_t LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff);
+ status_t LIS3DH_GetClickResponse(u8_t* val);
+ status_t LIS3DH_GetTempRaw(i8_t* val);
+ status_t LIS3DH_GetWHO_AM_I(u8_t* val);
+ status_t LIS3DH_Get6DPosition(u8_t* val);
+
+ u8_t LIS3DH_ReadReg(u8_t Reg, u8_t* Data);
+ u8_t LIS3DH_WriteReg(u8_t WriteAddr, u8_t Data);
+
+private:
+
+
+
+protected:
+ SPI _spi;
+ DigitalOut _ss;
+
+};
+} //Namespace
+#endif
--- a/LIS3DH_SPI.lib Wed Nov 14 16:08:28 2018 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1 +0,0 @@ -https://os.mbed.com/teams/Pathfindr/code/LIS3DH_SPI/#1b06721b55b9
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LISD3H.cpp Tue Dec 11 22:18:24 2018 +0000
@@ -0,0 +1,1621 @@
+#include "LIS3DH.h"
+
+LIS3DH::LIS3DH(PinName mosi, PinName miso, PinName ss, PinName sck): _spi(mosi,miso,sck), _ss(ss){
+ // Make sure CS is high
+ _ss = 1;
+ // Setup the spi for 8 bit data, high steady state clock,
+ // second edge capture, with a 1MHz clock rate
+ _spi.format(8,3);
+ _spi.frequency(4000000);
+}
+
+u8_t LIS3DH::InitLIS3DH(LIS3DH_Mode_t Mode, LIS3DH_ODR_t Odr, LIS3DH_Fullscale_t Grange)
+{
+ uint8_t response;
+ uint8_t Tmp;
+
+ LIS3DH_GetWHO_AM_I(&Tmp);
+
+ response = LIS3DH_SetODR(Odr);
+
+ //set PowerMode
+ response = LIS3DH_SetMode(Mode);
+
+ //set Fullscale
+ response = LIS3DH_SetFullScale(Grange);
+
+ //set axis Enable
+ response = LIS3DH_SetAxis(LIS3DH_X_ENABLE | LIS3DH_Y_ENABLE | LIS3DH_Z_ENABLE);
+
+ return response;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetStatusAUX
+* Description : Read the AUX status register
+* Input : Char to empty by status register buffer
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetStatusAUX(u8_t* val) {
+
+ if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetStatusAUXBIT
+* Description : Read the AUX status register BIT
+* Input : LIS3DH_STATUS_AUX_321OR, LIS3DH_STATUS_AUX_3OR, LIS3DH_STATUS_AUX_2OR, LIS3DH_STATUS_AUX_1OR,
+ LIS3DH_STATUS_AUX_321DA, LIS3DH_STATUS_AUX_3DA, LIS3DH_STATUS_AUX_2DA, LIS3DH_STATUS_AUX_1DA
+* Output : None
+* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetStatusAUXBit(u8_t statusBIT, u8_t* val) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, &value) )
+ return MEMS_ERROR;
+
+ if(statusBIT == LIS3DH_STATUS_AUX_321OR){
+ if(value &= LIS3DH_STATUS_AUX_321OR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_STATUS_AUX_3OR){
+ if(value &= LIS3DH_STATUS_AUX_3OR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_STATUS_AUX_2OR){
+ if(value &= LIS3DH_STATUS_AUX_2OR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_STATUS_AUX_1OR){
+ if(value &= LIS3DH_STATUS_AUX_1OR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_STATUS_AUX_321DA){
+ if(value &= LIS3DH_STATUS_AUX_321DA) {
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_STATUS_AUX_3DA){
+ if(value &= LIS3DH_STATUS_AUX_3DA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_STATUS_AUX_2DA){
+ if(value &= LIS3DH_STATUS_AUX_2DA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_STATUS_AUX_1DA){
+ if(value &= LIS3DH_STATUS_AUX_1DA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+ return MEMS_ERROR;
+}
+
+u8_t LIS3DH::SetLIS3DHActivityDetection(uint8_t Th, LIS3DH_Int1Mode_t Mode, uint8_t OnOff)
+{
+ uint8_t response;
+
+ response = LIS3DH_SetInt1Pin(LIS3DH_CLICK_ON_PIN_INT1_DISABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE |
+ LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE | LIS3DH_I1_DRDY1_ON_INT1_DISABLE | LIS3DH_I1_DRDY2_ON_INT1_DISABLE |
+ LIS3DH_WTM_ON_INT1_DISABLE | LIS3DH_INT1_OVERRUN_DISABLE );
+
+ //set Interrupt Threshold
+ response = LIS3DH_SetInt1Threshold(Th);
+
+ //set Interrupt configuration (all enabled)
+ if(OnOff)
+ {
+ response = LIS3DH_SetIntConfiguration(LIS3DH_INT1_ZHIE_ENABLE | LIS3DH_INT1_ZLIE_ENABLE |
+ LIS3DH_INT1_YHIE_ENABLE | LIS3DH_INT1_YLIE_ENABLE |
+ LIS3DH_INT1_XHIE_ENABLE | LIS3DH_INT1_XLIE_ENABLE );
+ }
+ else
+ {
+ response = LIS3DH_SetIntConfiguration(LIS3DH_INT1_ZHIE_DISABLE | LIS3DH_INT1_ZLIE_DISABLE |
+ LIS3DH_INT1_YHIE_DISABLE | LIS3DH_INT1_YLIE_DISABLE |
+ LIS3DH_INT1_XHIE_DISABLE | LIS3DH_INT1_XLIE_DISABLE );
+ }
+
+ //set Interrupt Mode
+ response = LIS3DH_SetIntMode(Mode);
+
+ return response;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetODR
+* Description : Sets LIS3DH Output Data Rate
+* Input : Output Data Rate
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetODR(LIS3DH_ODR_t ov){
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x0f;
+ value |= ov<<LIS3DH_ODR_BIT;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetMode
+* Description : Sets LIS3DH Operating Mode
+* Input : Modality (LIS3DH_NORMAL, LIS3DH_LOW_POWER, LIS3DH_POWER_DOWN)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetMode(LIS3DH_Mode_t md) {
+ u8_t value;
+ u8_t value2;
+ static u8_t ODR_old_value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value2) )
+ return MEMS_ERROR;
+
+ if((value & 0xF0)==0)
+ value = value | (ODR_old_value & 0xF0); //if it comes from POWERDOWN
+
+ switch(md) {
+
+ case LIS3DH_POWER_DOWN:
+ ODR_old_value = value;
+ value &= 0x0F;
+ break;
+
+ case LIS3DH_NORMAL:
+ value &= 0xF7;
+ value |= (MEMS_RESET<<LIS3DH_LPEN);
+ value2 &= 0xF7;
+ value2 |= (MEMS_SET<<LIS3DH_HR); //set HighResolution_BIT
+ break;
+
+ case LIS3DH_LOW_POWER:
+ value &= 0xF7;
+ value |= (MEMS_SET<<LIS3DH_LPEN);
+ value2 &= 0xF7;
+ value2 |= (MEMS_RESET<<LIS3DH_HR); //reset HighResolution_BIT
+ break;
+
+ default:
+ return MEMS_ERROR;
+ }
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value2) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetAxis
+* Description : Enable/Disable LIS3DH Axis
+* Input : LIS3DH_X_ENABLE/DISABLE | LIS3DH_Y_ENABLE/DISABLE | LIS3DH_Z_ENABLE/DISABLE
+* Output : None
+* Note : You MUST use all input variable in the argument, as example
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetAxis(LIS3DH_Axis_t axis) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
+ return MEMS_ERROR;
+ value &= 0xF8;
+ value |= (0x07 & axis);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetFullScale
+* Description : Sets the LIS3DH FullScale
+* Input : LIS3DH_FULLSCALE_2/LIS3DH_FULLSCALE_4/LIS3DH_FULLSCALE_8/LIS3DH_FULLSCALE_16
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xCF;
+ value |= (fs<<LIS3DH_FS);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetBDU
+* Description : Enable/Disable Block Data Update Functionality
+* Input : ENABLE/DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetBDU(State_t bdu) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+ value |= (bdu<<LIS3DH_BDU);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetBLE
+* Description : Set Endianess (MSB/LSB)
+* Input : BLE_LSB / BLE_MSB
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetBLE(LIS3DH_Endianess_t ble) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= (ble<<LIS3DH_BLE);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetSelfTest
+* Description : Set Self Test Modality
+* Input : LIS3DH_SELF_TEST_DISABLE/ST_0/ST_1
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetSelfTest(LIS3DH_SelfTest_t st) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xF9;
+ value |= (st<<LIS3DH_ST);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_HPFClick
+* Description : Enable/Disable High Pass Filter for click
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_HPFClickEnable(State_t hpfe) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFB;
+ value |= (hpfe<<LIS3DH_HPCLICK);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_HPFAOI1
+* Description : Enable/Disable High Pass Filter for AOI on INT_1
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_HPFAOI1Enable(State_t hpfe) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFE;
+ value |= (hpfe<<LIS3DH_HPIS1);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_HPFAOI2
+* Description : Enable/Disable High Pass Filter for AOI on INT_2
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_HPFAOI2Enable(State_t hpfe) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFD;
+ value |= (hpfe<<LIS3DH_HPIS2);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetHPFMode
+* Description : Set High Pass Filter Modality
+* Input : LIS3DH_HPM_NORMAL_MODE_RES/LIS3DH_HPM_REF_SIGNAL/
+ LIS3DH_HPM_NORMAL_MODE/LIS3DH_HPM_AUTORESET_INT
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpm) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x3F;
+ value |= (hpm<<LIS3DH_HPM);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetHPFCutOFF
+* Description : Set High Pass CUT OFF Freq
+* Input : HPFCF [0,3]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf) {
+ u8_t value;
+
+ if (hpf > 3)
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xCF;
+ value |= (hpf<<LIS3DH_HPCF);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetFilterDataSel
+* Description : Set Filter Data Selection bypassed or sent to FIFO OUT register
+* Input : MEMS_SET, MEMS_RESET
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetFilterDataSel(State_t state) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xF7;
+ value |= (state<<LIS3DH_FDS);
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetTemperature
+* Description : Sets LIS3DH Output Temperature
+* Input : MEMS_ENABLE, MEMS_DISABLE
+* Output : None
+* Note : For Read Temperature by LIS3DH_OUT_AUX_3, LIS3DH_SetADCAux and LIS3DH_SetBDU
+ functions must be ENABLE
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetTemperature(State_t state){
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= state<<LIS3DH_TEMP_EN;
+
+ if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetADCAux
+* Description : Sets LIS3DH Output ADC
+* Input : MEMS_ENABLE, MEMS_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetADCAux(State_t state){
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+ value |= state<<LIS3DH_ADC_PD;
+
+ if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetAuxRaw
+* Description : Read the Aux Values Output Registers
+* Input : Buffer to empty
+* Output : Aux Values Registers buffer
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff) {
+ u8_t valueL;
+ u8_t valueH;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_1_L, &valueL) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_1_H, &valueH) )
+ return MEMS_ERROR;
+
+ buff->AUX_1 = (u16_t)( (valueH << 8) | valueL )/16;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_2_L, &valueL) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_2_H, &valueH) )
+ return MEMS_ERROR;
+
+ buff->AUX_2 = (u16_t)( (valueH << 8) | valueL )/16;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
+ return MEMS_ERROR;
+
+ buff->AUX_3 = (u16_t)( (valueH << 8) | valueL )/16;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetInt1Pin
+* Description : Set Interrupt1 pin Function
+* Input : LIS3DH_CLICK_ON_PIN_INT1_ENABLE/DISABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE/DISABLE |
+ LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE/DISABLE | LIS3DH_I1_DRDY1_ON_INT1_ENABLE/DISABLE |
+ LIS3DH_I1_DRDY2_ON_INT1_ENABLE/DISABLE | LIS3DH_WTM_ON_INT1_ENABLE/DISABLE |
+ LIS3DH_INT1_OVERRUN_ENABLE/DISABLE
+* example : SetInt1Pin(LIS3DH_CLICK_ON_PIN_INT1_ENABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE |
+ LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE | LIS3DH_I1_DRDY1_ON_INT1_ENABLE | LIS3DH_I1_DRDY2_ON_INT1_ENABLE |
+ LIS3DH_WTM_ON_INT1_DISABLE | LIS3DH_INT1_OVERRUN_DISABLE )
+* Note : To enable Interrupt signals on INT1 Pad (You MUST use all input variable in the argument, as example)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG3, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x00;
+ value |= pinConf;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG3, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetInt2Pin
+* Description : Set Interrupt2 pin Function
+* Input : LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |
+ LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |
+ LIS3DH_INT_ACTIVE_HIGH/LOW
+* example : LIS3DH_SetInt2Pin(LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |
+ LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |
+ LIS3DH_INT_ACTIVE_HIGH/LOW)
+* Note : To enable Interrupt signals on INT2 Pad (You MUST use all input variable in the argument, as example)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG6, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x00;
+ value |= pinConf;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG6, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetClickCFG
+* Description : Set Click Interrupt config Function
+* Input : LIS3DH_ZD_ENABLE/DISABLE | LIS3DH_ZS_ENABLE/DISABLE | LIS3DH_YD_ENABLE/DISABLE |
+ LIS3DH_YS_ENABLE/DISABLE | LIS3DH_XD_ENABLE/DISABLE | LIS3DH_XS_ENABLE/DISABLE
+* example : LIS3DH_SetClickCFG( LIS3DH_ZD_ENABLE | LIS3DH_ZS_DISABLE | LIS3DH_YD_ENABLE |
+ LIS3DH_YS_DISABLE | LIS3DH_XD_ENABLE | LIS3DH_XS_ENABLE)
+* Note : You MUST use all input variable in the argument, as example
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetClickCFG(u8_t status) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CLICK_CFG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xC0;
+ value |= status;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CLICK_CFG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetClickTHS
+* Description : Set Click Interrupt threshold
+* Input : Click-click Threshold value [0-127]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetClickTHS(u8_t ths) {
+
+ if(ths>127)
+ return MEMS_ERROR;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CLICK_THS, ths) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetClickLIMIT
+* Description : Set Click Interrupt Time Limit
+* Input : Click-click Time Limit value [0-127]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetClickLIMIT(u8_t t_limit) {
+
+ if(t_limit>127)
+ return MEMS_ERROR;
+
+ if( !LIS3DH_WriteReg(LIS3DH_TIME_LIMIT, t_limit) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetClickLATENCY
+* Description : Set Click Interrupt Time Latency
+* Input : Click-click Time Latency value [0-255]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetClickLATENCY(u8_t t_latency) {
+
+ if( !LIS3DH_WriteReg(LIS3DH_TIME_LATENCY, t_latency) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetClickWINDOW
+* Description : Set Click Interrupt Time Window
+* Input : Click-click Time Window value [0-255]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetClickWINDOW(u8_t t_window) {
+
+ if( !LIS3DH_WriteReg(LIS3DH_TIME_WINDOW, t_window) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetClickResponse
+* Description : Get Click Interrupt Response by CLICK_SRC REGISTER
+* Input : char to empty by Click Response Typedef
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetClickResponse(u8_t* res) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CLICK_SRC, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+
+ if((value & LIS3DH_IA)==0) {
+ *res = LIS3DH_NO_CLICK;
+ return MEMS_SUCCESS;
+ }
+ else {
+ if (value & LIS3DH_DCLICK){
+ if (value & LIS3DH_CLICK_SIGN){
+ if (value & LIS3DH_CLICK_Z) {
+ *res = LIS3DH_DCLICK_Z_N;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_Y) {
+ *res = LIS3DH_DCLICK_Y_N;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_X) {
+ *res = LIS3DH_DCLICK_X_N;
+ return MEMS_SUCCESS;
+ }
+ }
+ else{
+ if (value & LIS3DH_CLICK_Z) {
+ *res = LIS3DH_DCLICK_Z_P;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_Y) {
+ *res = LIS3DH_DCLICK_Y_P;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_X) {
+ *res = LIS3DH_DCLICK_X_P;
+ return MEMS_SUCCESS;
+ }
+ }
+ }
+ else{
+ if (value & LIS3DH_CLICK_SIGN){
+ if (value & LIS3DH_CLICK_Z) {
+ *res = LIS3DH_SCLICK_Z_N;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_Y) {
+ *res = LIS3DH_SCLICK_Y_N;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_X) {
+ *res = LIS3DH_SCLICK_X_N;
+ return MEMS_SUCCESS;
+ }
+ }
+ else{
+ if (value & LIS3DH_CLICK_Z) {
+ *res = LIS3DH_SCLICK_Z_P;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_Y) {
+ *res = LIS3DH_SCLICK_Y_P;
+ return MEMS_SUCCESS;
+ }
+ if (value & LIS3DH_CLICK_X) {
+ *res = LIS3DH_SCLICK_X_P;
+ return MEMS_SUCCESS;
+ }
+ }
+ }
+ }
+ return MEMS_ERROR;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_Int1LatchEnable
+* Description : Enable Interrupt 1 Latching function
+* Input : ENABLE/DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_IntLatchEnable(State_t latch) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
+ return MEMS_ERROR;
+
+ value &= 0b00001010; //Latch 1 and 2
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+status_t LIS3DH::LIS3DH_ResetInt1Latch(void) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+status_t LIS3DH::LIS3DH_ResetInt2Latch(void) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT2_SRC, &value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetIntConfiguration
+* Description : Interrupt 1 Configuration (without LIS3DH_6D_INT)
+* Input : LIS3DH_INT1_AND/OR | LIS3DH_INT1_ZHIE_ENABLE/DISABLE | LIS3DH_INT1_ZLIE_ENABLE/DISABLE...
+* Output : None
+* Note : You MUST use all input variable in the argument, as example
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x40;
+ value |= ic;
+
+ if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetIntMode
+* Description : Interrupt 1 Configuration mode (OR, 6D Movement, AND, 6D Position)
+* Input : LIS3DH_INT_MODE_OR, LIS3DH_INT_MODE_6D_MOVEMENT, LIS3DH_INT_MODE_AND,
+ LIS3DH_INT_MODE_6D_POSITION
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetIntMode(LIS3DH_Int1Mode_t int_mode) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x3F;
+ value |= (int_mode<<LIS3DH_INT_6D);
+
+ if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetInt6D4DConfiguration
+* Description : 6D, 4D Interrupt Configuration
+* Input : LIS3DH_INT1_6D_ENABLE, LIS3DH_INT1_4D_ENABLE, LIS3DH_INT1_6D_4D_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic) {
+ u8_t value;
+ u8_t value2;
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
+ return MEMS_ERROR;
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value2) )
+ return MEMS_ERROR;
+
+ if(ic == LIS3DH_INT1_6D_ENABLE){
+ value &= 0xBF;
+ value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
+ value2 &= 0xFB;
+ value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
+ }
+
+ if(ic == LIS3DH_INT1_4D_ENABLE){
+ value &= 0xBF;
+ value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
+ value2 &= 0xFB;
+ value2 |= (MEMS_ENABLE<<LIS3DH_D4D_INT1);
+ }
+
+ if(ic == LIS3DH_INT1_6D_4D_DISABLE){
+ value &= 0xBF;
+ value |= (MEMS_DISABLE<<LIS3DH_INT_6D);
+ value2 &= 0xFB;
+ value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
+ }
+
+ if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
+ return MEMS_ERROR;
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value2) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_Get6DPosition
+* Description : 6D, 4D Interrupt Position Detect
+* Input : Byte to empty by POSITION_6D_t Typedef
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_Get6DPosition(u8_t* val){
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+
+ switch (value){
+ case LIS3DH_UP_SX:
+ *val = LIS3DH_UP_SX;
+ break;
+ case LIS3DH_UP_DX:
+ *val = LIS3DH_UP_DX;
+ break;
+ case LIS3DH_DW_SX:
+ *val = LIS3DH_DW_SX;
+ break;
+ case LIS3DH_DW_DX:
+ *val = LIS3DH_DW_DX;
+ break;
+ case LIS3DH_TOP:
+ *val = LIS3DH_TOP;
+ break;
+ case LIS3DH_BOTTOM:
+ *val = LIS3DH_BOTTOM;
+ break;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetInt1Threshold
+* Description : Sets Interrupt 1 Threshold
+* Input : Threshold = [0,31]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetInt1Threshold(u8_t ths) {
+ if (ths > 127)
+ return MEMS_ERROR;
+
+ if( !LIS3DH_WriteReg(LIS3DH_INT1_THS, ths) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetInt1Duration
+* Description : Sets Interrupt 1 Duration
+* Input : Duration value
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id) {
+
+ if (id > 127)
+ return MEMS_ERROR;
+
+ if( !LIS3DH_WriteReg(LIS3DH_INT1_DURATION, id) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_FIFOModeEnable
+* Description : Sets Fifo Modality
+* Input : LIS3DH_FIFO_DISABLE, LIS3DH_FIFO_BYPASS_MODE, LIS3DH_FIFO_MODE,
+ LIS3DH_FIFO_STREAM_MODE, LIS3DH_FIFO_TRIGGER_MODE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm) {
+ u8_t value;
+
+ if(fm == LIS3DH_FIFO_DISABLE) {
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x1F;
+ value |= (LIS3DH_FIFO_BYPASS_MODE<<LIS3DH_FM);
+
+ if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) ) //fifo mode bypass
+ return MEMS_ERROR;
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo disable
+ return MEMS_ERROR;
+ }
+
+ if(fm == LIS3DH_FIFO_BYPASS_MODE) {
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= MEMS_SET<<LIS3DH_FIFO_EN;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
+ return MEMS_ERROR;
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x1f;
+ value |= (fm<<LIS3DH_FM); //fifo mode configuration
+
+ if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
+ return MEMS_ERROR;
+ }
+
+ if(fm == LIS3DH_FIFO_MODE) {
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= MEMS_SET<<LIS3DH_FIFO_EN;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
+ return MEMS_ERROR;
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x1f;
+ value |= (fm<<LIS3DH_FM); //fifo mode configuration
+
+ if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
+ return MEMS_ERROR;
+ }
+
+ if(fm == LIS3DH_FIFO_STREAM_MODE) {
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= MEMS_SET<<LIS3DH_FIFO_EN;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
+ return MEMS_ERROR;
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x1f;
+ value |= (fm<<LIS3DH_FM); //fifo mode configuration
+
+ if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
+ return MEMS_ERROR;
+ }
+
+ if(fm == LIS3DH_FIFO_TRIGGER_MODE) {
+ if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= MEMS_SET<<LIS3DH_FIFO_EN;
+
+ if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
+ return MEMS_ERROR;
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x1f;
+ value |= (fm<<LIS3DH_FM); //fifo mode configuration
+
+ if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
+ return MEMS_ERROR;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetTriggerInt
+* Description : Trigger event liked to trigger signal INT1/INT2
+* Input : LIS3DH_TRIG_INT1/LIS3DH_TRIG_INT2
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xDF;
+ value |= (tr<<LIS3DH_TR);
+
+ if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_SetWaterMark
+* Description : Sets Watermark Value
+* Input : Watermark = [0,31]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_SetWaterMark(u8_t wtm) {
+ u8_t value;
+
+ if(wtm > 31)
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xE0;
+ value |= wtm;
+
+ if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetStatusReg
+* Description : Read the status register
+* Input : char to empty by Status Reg Value
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetStatusReg(u8_t* val) {
+ if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetStatusBIT
+* Description : Read the status register BIT
+* Input : LIS3DH_STATUS_REG_ZYXOR, LIS3DH_STATUS_REG_ZOR, LIS3DH_STATUS_REG_YOR, LIS3DH_STATUS_REG_XOR,
+ LIS3DH_STATUS_REG_ZYXDA, LIS3DH_STATUS_REG_ZDA, LIS3DH_STATUS_REG_YDA, LIS3DH_STATUS_REG_XDA,
+ LIS3DH_DATAREADY_BIT
+ val: Byte to be filled with the status bit
+* Output : status register BIT
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetStatusBit(u8_t statusBIT, u8_t* val) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, &value) )
+ return MEMS_ERROR;
+
+ switch (statusBIT){
+ case LIS3DH_STATUS_REG_ZYXOR:
+ if(value &= LIS3DH_STATUS_REG_ZYXOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case LIS3DH_STATUS_REG_ZOR:
+ if(value &= LIS3DH_STATUS_REG_ZOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case LIS3DH_STATUS_REG_YOR:
+ if(value &= LIS3DH_STATUS_REG_YOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case LIS3DH_STATUS_REG_XOR:
+ if(value &= LIS3DH_STATUS_REG_XOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case LIS3DH_STATUS_REG_ZYXDA:
+ if(value &= LIS3DH_STATUS_REG_ZYXDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case LIS3DH_STATUS_REG_ZDA:
+ if(value &= LIS3DH_STATUS_REG_ZDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case LIS3DH_STATUS_REG_YDA:
+ if(value &= LIS3DH_STATUS_REG_YDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case LIS3DH_STATUS_REG_XDA:
+ if(value &= LIS3DH_STATUS_REG_XDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+
+ }
+ return MEMS_ERROR;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetAccAxesRaw
+* Description : Read the Acceleration Values Output Registers
+* Input : buffer to empity by AxesRaw_t Typedef
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetAccAxesRaw(AxesRaw_t* buff) {
+ i16_t value;
+ u8_t *valueL = (u8_t *)(&value);
+ u8_t *valueH = ((u8_t *)(&value)+1);
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_X_L, valueL) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_X_H, valueH) )
+ return MEMS_ERROR;
+
+ buff->AXIS_X = value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_L, valueL) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_H, valueH) )
+ return MEMS_ERROR;
+
+ buff->AXIS_Y = value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_L, valueL) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_H, valueH) )
+ return MEMS_ERROR;
+
+ buff->AXIS_Z = value;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetInt1Src
+* Description : Reset Interrupt 1 Latching function
+* Input : Char to empty by Int1 source value
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetInt1Src(u8_t* val) {
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetInt1SrcBit
+* Description : Reset Interrupt 1 Latching function
+* Input : statusBIT: LIS3DH_INT_SRC_IA, LIS3DH_INT_SRC_ZH, LIS3DH_INT_SRC_ZL.....
+* val: Byte to be filled with the status bit
+* Output : None
+* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetInt1SrcBit(u8_t statusBIT, u8_t* val) {
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
+ return MEMS_ERROR;
+
+ if(statusBIT == LIS3DH_INT1_SRC_IA){
+ if(value &= LIS3DH_INT1_SRC_IA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_INT1_SRC_ZH){
+ if(value &= LIS3DH_INT1_SRC_ZH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_INT1_SRC_ZL){
+ if(value &= LIS3DH_INT1_SRC_ZL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_INT1_SRC_YH){
+ if(value &= LIS3DH_INT1_SRC_YH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_INT1_SRC_YL){
+ if(value &= LIS3DH_INT1_SRC_YL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+ if(statusBIT == LIS3DH_INT1_SRC_XH){
+ if(value &= LIS3DH_INT1_SRC_XH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_INT1_SRC_XL){
+ if(value &= LIS3DH_INT1_SRC_XL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+ return MEMS_ERROR;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetFifoSourceReg
+* Description : Read Fifo source Register
+* Input : Byte to empty by FIFO source register value
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetFifoSourceReg(u8_t* val) {
+
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetFifoSourceBit
+* Description : Read Fifo WaterMark source bit
+* Input : statusBIT: LIS3DH_FIFO_SRC_WTM, LIS3DH_FIFO_SRC_OVRUN, LIS3DH_FIFO_SRC_EMPTY
+* val: Byte to fill with the bit value
+* Output : None
+* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetFifoSourceBit(u8_t statusBIT, u8_t* val){
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
+ return MEMS_ERROR;
+
+
+ if(statusBIT == LIS3DH_FIFO_SRC_WTM){
+ if(value &= LIS3DH_FIFO_SRC_WTM){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == LIS3DH_FIFO_SRC_OVRUN){
+ if(value &= LIS3DH_FIFO_SRC_OVRUN){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+ if(statusBIT == LIS3DH_FIFO_SRC_EMPTY){
+ if(value &= statusBIT == LIS3DH_FIFO_SRC_EMPTY){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+ return MEMS_ERROR;
+}
+
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetFifoSourceFSS
+* Description : Read current number of unread samples stored in FIFO
+* Input : Byte to empty by FIFO unread sample value
+* Output : None
+* Return : Status [value of FSS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetFifoSourceFSS(u8_t* val){
+ u8_t value;
+
+ if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x1F;
+
+ *val = value;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetTempRaw
+* Description : Read the Temperature Values by AUX Output Registers OUT_3_H
+* Input : Buffer to empty
+* Output : Temperature Values Registers buffer
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetTempRaw(i8_t* buff) {
+ u8_t valueL;
+ u8_t valueH;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
+ return MEMS_ERROR;
+
+ if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
+ return MEMS_ERROR;
+
+ *buff = (i8_t)( valueH );
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_GetWHO_AM_I
+* Description : Read identification code by WHO_AM_I register
+* Input : Char to empty by Device identification Value
+* Output : None
+* Return : Status [value of FSS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetWHO_AM_I(u8_t* val){
+
+ if( !LIS3DH_ReadReg(LIS3DH_WHO_AM_I, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_ReadReg
+* Description : Generic Reading function. It must be fullfilled with either
+* : I2C or SPI reading functions
+* Input : Register Address
+* Output : Data REad
+* Return : None
+*******************************************************************************/
+u8_t LIS3DH::LIS3DH_ReadReg(u8_t Reg, u8_t* Data) {
+
+ //To be completed with either I2c or SPI reading function
+ //i.e. *Data = SPI_Mems_Read_Reg( Reg );
+
+ _ss = 0;
+ _spi.write(0x80 | Reg);
+ signed char raw = _spi.write(0x00);
+ _ss = 1;
+
+ *Data=raw;
+
+ return 1;
+}
+
+/*******************************************************************************
+* Function Name : LIS3DH_WriteReg
+* Description : Generic Writing function. It must be fullfilled with either
+* : I2C or SPI writing function
+* Input : Register Address, Data to be written
+* Output : None
+* Return : None
+*******************************************************************************/
+u8_t LIS3DH::LIS3DH_WriteReg(u8_t WriteAddr, u8_t Data) {
+
+ //To be completed with either I2c or SPI writing function
+ //i.e. SPI_Mems_Write_Reg(WriteAddr, Data);
+
+ _ss = 0;
+ _spi.write(0x00 | WriteAddr);
+ _spi.write (Data);
+ _ss = 1;
+
+ return 1;
+}
+
+LIS3DH::~LIS3DH(){};
+
\ No newline at end of file
--- a/README.md Wed Nov 14 16:08:28 2018 +0000 +++ b/README.md Tue Dec 11 22:18:24 2018 +0000 @@ -0,0 +1,6 @@ +Temperature logging + +Location logging + +Activity logging +
--- a/board.h Wed Nov 14 16:08:28 2018 +0000 +++ b/board.h Tue Dec 11 22:18:24 2018 +0000 @@ -32,16 +32,4 @@ #define PN_I2C_SCL P0_27 //NVSTORAGE KEYS -#define NV_IDENTIFIER 1 - - - -//LEDS -extern DigitalOut led1; - -//PERIPHERAL PINS -extern DigitalOut vreg_en; -extern DigitalOut gsm_pwkey; - -//extern DigitalIn lis3dh_int1; -//extern DigitalIn lis3dh_int2; \ No newline at end of file +#define NV_IDENTIFIER 1 \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/common.cpp Tue Dec 11 22:18:24 2018 +0000
@@ -0,0 +1,28 @@
+#include "common.h"
+
+//------------------------------------------------------------------------------
+// LED
+//------------------------------------------------------------------------------
+DigitalOut led1(PN_LED);
+
+void LED1on(long milliseconds = 0) {
+ led1 = 0;
+ if (milliseconds > 0) {
+ ThisThread::sleep_for(milliseconds);
+ led1 = 1;
+ }
+}
+void LED1blink(int count = 2, long milliseconds = 100) {
+ for (int i = 0; i < (count*2); i++) {
+ led1 = !led1;
+ if (milliseconds > 0) {
+ ThisThread::sleep_for(milliseconds);
+ } else {
+ ThisThread::sleep_for(100); //default if 0 provided
+ }
+ }
+ led1 = 1;
+}
+void LED1off() {
+ led1 = 1;
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common.h Tue Dec 11 22:18:24 2018 +0000 @@ -0,0 +1,11 @@ +#ifndef COMMON_H_ +#define COMMON_H_ + +#include "main.h" + +extern DigitalOut led1; +extern void LED1on(long milliseconds); +extern void LED1blink(int count, long milliseconds); +extern void LED1off(void); + +#endif \ No newline at end of file
--- a/main.cpp Wed Nov 14 16:08:28 2018 +0000
+++ b/main.cpp Tue Dec 11 22:18:24 2018 +0000
@@ -1,205 +1,207 @@
#include "main.h"
-#include "board.h"
-#include "modes.h"
-
//include "nrf_soc.h"
-//#include "ATCommand.h"
-
-//LowPowerTicker ticker; //no impact on power consumption
-
//------------------------------------------------------------------------------
-//Function declarations- Local
+//FUNCTION PROTOTYPES
//------------------------------------------------------------------------------
static void mainStateEngine(void);
-static void mode_mtu(void);
static void selftest(void);
-static void LEDon(void);
-static void LEDoff(void);
+static void buttonPress(void);
+static void buttonRelease(void);
//------------------------------------------------------------------------------
-//Var declarations- Local
+//GLOBAL VARS
//------------------------------------------------------------------------------
bool accel_healthy = false;
bool firstBoot = false;
bool requireSoftReset = false;
+bool motionFlagTriggered = false;
//------------------------------------------------------------------------------
-//Var declarations- RETAINED NOINIT RAM
+//RETAINED NOINIT RAM VARS
//------------------------------------------------------------------------------
-#if defined ( __CC_ARM )
-/** THIS IS THE MBED ONLINE COMPILER TOOLCHAIN*/
-static uint8_t RET_mode __attribute__((section("noinit"),zero_init));
-static uint32_t RET_unixtime_backup __attribute__((section("noinit"),zero_init));
-static char RET_buffer[64] __attribute__((section("noinit"),zero_init));
+#if defined ( __CC_ARM ) /** THIS IS THE MBED ONLINE COMPILER TOOLCHAIN*/
+static uint8_t RET_mode __attribute__((section("noinit"),zero_init));
+
+static uint8_t RET_buttonReleaseCount __attribute__((section("noinit"),zero_init));
+static uint32_t RET_buttonPressTime __attribute__((section("noinit"),zero_init));
+static uint32_t RET_buttonReleaseTime __attribute__((section("noinit"),zero_init));
+static uint32_t RET_unixtime_backup __attribute__((section("noinit"),zero_init));
+static bool RET_requireImpactFlag __attribute__((section("noinit"),zero_init));
+static char RET_buffer[64] __attribute__((section("noinit"),zero_init));
+
+//MOTION SETTINGS
+static bool RET_motionTriggered __attribute__((section("noinit"),zero_init));
+static time_t RET_motionStartTime __attribute__((section("noinit"),zero_init));
+static time_t RET_motionStopTime __attribute__((section("noinit"),zero_init));
+static uint32_t RET_motionStartThreshold_seconds __attribute__((section("noinit"),zero_init));
+static uint32_t RET_motionStopThreshold_seconds __attribute__((section("noinit"),zero_init));
+static bool RET_motionPendingOnState __attribute__((section("noinit"),zero_init));
+static bool RET_motionPendingOffState __attribute__((section("noinit"),zero_init));
+static bool RET_motionState __attribute__((section("noinit"),zero_init));
+
+//EVENT HANDLING
+static uint32_t RET_eventTime_location __attribute__((section("noinit"),zero_init));
+static uint32_t RET_eventTime_environmental __attribute__((section("noinit"),zero_init));
+static uint32_t RET_eventTime_activity __attribute__((section("noinit"),zero_init));
#elif defined ( __GNUC__ )
#elif defined ( __ICCARM__ )
#endif
-char RET_pf_identifier[9]; //includes null byte at end
-int RET_interval_setting = 720;
-int RET_interval_hours_failsafe = 24;
-int RET_motioncheck_interval_seconds = 60;
-int RET_gps_timeout = 180;
-int RET_gsm_timeout = 120;
-bool RET_gsmtimedout = false;
-int RET_beacon_scan = 0;
-int RET_accel_awake_thr = 11;
-int RET_accel_awake_triggercount = 0;
-int RET_accel_alarm_thr = 127;
-unsigned long RET_unixtime_configrun = 0;
-unsigned long RET_unixtime_lastpost = 0;
-unsigned long RET_unixtime_nextpost = 0;
-unsigned long RET_unixtime_nextpost_failsafe = 0;
-unsigned long RET_unixtime_framestart = 0;
-unsigned long RET_motionstarttime = 0;
-unsigned long RET_motionstoptime = 0;
-int RET_gsm_failcount = 0;
-int RET_serverresponse_failcount = 0;
-int RET_motionconsecutive = 0;
-int RET_no_motionconsecutive = 0;
-bool RET_wethinkinmotion = false;
-bool RET_wethinkhasmoved = false;
-bool RET_haveservertime = false;
-float RET_operationTimeHours = 0;
-float RET_operationFrameTimeHours = 0;
-int RET_operationCount = 0;
-char RET_operationTimeString[100];
-
-
//------------------------------------------------------------------------------
-//Pin states
-//------------------------------------------------------------------------------
-DigitalOut led1(PN_LED);
-DigitalOut vreg_en(PN_VREG_EN);
-DigitalOut gsm_pwkey(PN_GSM_PWR_KEY);
-DigitalOut lis3dh_cs(PN_SPI_CS0);
-DigitalOut flash_cs(PN_SPI_CS1);
-DigitalIn lis3dh_int1(PN_ACC_INT1); //IMPACT
-DigitalIn lis3dh_int2(PN_ACC_INT2); //DISTURBED
-
-//------------------------------------------------------------------------------
-//Peripherals
+//PERIPHERALS
//------------------------------------------------------------------------------
//BLE myble;
+WatchdogTimer watchdog(65.0); //Do not set to less than 4500ms or can cause issues with softdevice
+InterruptIn button(PN_IN_BUTTON); //This causes wake from sleep
#if NEED_CONSOLE_OUTPUT
Serial uart(PN_UART_TX, PN_UART_RX, 115200);
#endif
-//ATSerial atserial(PN_UART_TX, PN_UART_RX, 115200);
-WatchdogTimer watchdog(65.0); //Do not set to less than 4500ms or can cause issues with softdevice
//------------------------------------------------------------------------------
-//Singletons
+//SINGLETONS
//------------------------------------------------------------------------------
-NVStore &nvstore = NVStore::get_instance();
+//NVStore &nvstore = NVStore::get_instance();
-
+//------------------------------------------------------------------------------
+// LOW LEVEL CRITICAL FUNCS
+//------------------------------------------------------------------------------
void gotoSleep(long sleep_milliseconds) {
- //accelerometer.configureForSleep();
if (requireSoftReset) { //dont need to clear this var as reset changes it back to false
RET_unixtime_backup = time(NULL); //save unixtime for reset
- //NVIC_SystemReset();
system_reset();
}
- ThisThread::sleep_for(sleep_milliseconds);
-}
-
-void LED1on(long flash_milliseconds = 0) {
- led1 = 0;
- if (flash_milliseconds > 0) {
- ThisThread::sleep_for(flash_milliseconds);
- led1 = 1;
- }
-}
-void LED1off() {
- led1 = 1;
-}
-
-bool GSMon() {
- //power on GSM
- vreg_en = 1;
- ThisThread::sleep_for(500);
- gsm_pwkey = 0;
- ThisThread::sleep_for(1500);
- gsm_pwkey = 1;
- LED1on(1000);
+
+ //button.fall(&buttonPress);
+ //button.rise(&buttonRelease);
+
+ ThisThread::sleep_for(sleep_milliseconds);
}
-void setup_CS_LIS3DH()
-{
- //Without this setup CS lines of AT45 & LIS3DH are in conflict, causing huge current consumption
- lis3dh_cs = 1; //not selected
- flash_cs = 1; //not selected
- //AT_RS = 0; //asserted == reset state
- //wait_ms(100);
- //AT_RS = 1;
-}
-
-void lis3dh_configureForSleep() {
- //init
- LIS3DH lis3dh(PN_SPI_MOSI, PN_SPI_MISO, PN_SPI_CS0, PN_SPI_CLK);
- requireSoftReset = true; //WE HAVE STARTED SPI SO NEED THIS
- //Mode
- lis3dh.InitLIS3DH(LIS3DH_NORMAL, LIS3DH_ODR_25Hz, LIS3DH_FULLSCALE_8);
- lis3dh.LIS3DH_SetIntMode(LIS3DH_INT_MODE_6D_MOVEMENT);
- //Int1
- lis3dh.LIS3DH_SetInt1Pin(LIS3DH_CLICK_ON_PIN_INT1_DISABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE |
- LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE | LIS3DH_I1_DRDY1_ON_INT1_DISABLE | LIS3DH_I1_DRDY2_ON_INT1_DISABLE |
- LIS3DH_WTM_ON_INT1_DISABLE | LIS3DH_INT1_OVERRUN_DISABLE );
- lis3dh.LIS3DH_SetInt1Threshold(10);
- lis3dh.LIS3DH_SetIntConfiguration(LIS3DH_INT1_ZHIE_ENABLE | LIS3DH_INT1_ZLIE_ENABLE |
- LIS3DH_INT1_YHIE_ENABLE | LIS3DH_INT1_YLIE_ENABLE |
- LIS3DH_INT1_XHIE_ENABLE | LIS3DH_INT1_XLIE_ENABLE );
- lis3dh.LIS3DH_SetInt1Duration(0);
- lis3dh.LIS3DH_Int1LatchEnable(MEMS_ENABLE);
- //HP filter
- lis3dh.LIS3DH_SetHPFMode(LIS3DH_HPM_AUTORESET_INT);
- lis3dh.LIS3DH_SetFilterDataSel(MEMS_ENABLE);
- lis3dh.LIS3DH_HPFAOI1Enable(MEMS_ENABLE);
- lis3dh.LIS3DH_HPFAOI2Enable(MEMS_ENABLE);
-}
-
-void resetState() {
+void factoryReset() {
firstBoot = true;
//RESET VARS
RET_mode = 0;
RET_unixtime_backup = 0;
+ RET_buttonReleaseCount = 0;
+ RET_eventTime_location = 0;
+ RET_eventTime_environmental = 0;
+ RET_eventTime_activity = 0;
+ RET_motionPendingOffState = 0;
+ RET_motionPendingOnState = 0;
+ RET_motionState = 0;
+ RET_motionStartTime = 0;
+ RET_motionStopTime = 0;
+ RET_motionStartThreshold_seconds = 60;
+ RET_motionStopThreshold_seconds = 60;
set_time(RET_unixtime_backup);
//SET IDENTIFIER
- uint32_t nv_value = 12345678;
- int rc = nvstore.set(NV_IDENTIFIER, sizeof(nv_value), &nv_value);
+ //uint32_t nv_value = 12345678;
+ //int rc = nvstore.set(NV_IDENTIFIER, sizeof(nv_value), &nv_value);
+}
+
+void turnOffEverything() {
+ //vreg_en = 0;
+ led1 = 1;
}
+//------------------------------------------------------------------------------
+// USER BUTTON
+//------------------------------------------------------------------------------
+void buttonPress() {
+ led1 = 0;
+
+ //while(RET_buttonReleaseCount < 1){
+ //wait
+ //}
+
+ //led1 = 1;
+ /*
+ //RET_buttonPressTime = time(NULL);
+ RET_buttonReleaseCount ++;
+ led1 = 0;
+ for (int i = 0; i < RET_buttonReleaseCount; i++) {
+ led1 = 0;
+ wait_ms(100);
+ led1 = 1;
+ wait_ms(100);
+ */
+}
+void buttonRelease() {
+ led1 = 1;
+ //RET_buttonReleaseCount ++;
+ /*RET_buttonReleaseCount ++;
+ led1 = 0;
+ for (int i = 0; i < RET_buttonReleaseCount; i++) {
+ led1 = 0;
+ wait_ms(100);
+ led1 = 1;
+ wait_ms(100);
+ }*/
+}
+
+//------------------------------------------------------------------------------
+// STATE ENGINE
+//------------------------------------------------------------------------------
+
void mainStateEngine() {
RET_mode = MODE_NORMAL;
-
switch(RET_mode) {
case MODE_SETUP :
- resetState();
+ factoryReset();
//selftest();
break;
case MODE_NORMAL :
-
- if (RET_requireMotionFlag) {
- bool MotionFlagTriggered = false;
-
- //check interrupt
- if (lis3dh_int2) {
- MotionFlagTriggered = true;
- }
+ //check and log motion
+ if (lis3dh_int1) {
+ LED1blink(2,100);
+ RET_motionTriggered = true;
+ if (!RET_motionPendingOnState) {
+ RET_motionPendingOnState = true;
+ RET_motionPendingOffState = false;
+ // Log start motion time
+ RET_motionStartTime = time(NULL);
+ RET_motionStopTime = 0;
+ }
+ } else {
+ LED1blink(2,500);
+ RET_motionTriggered = false;
+ RET_motionPendingOnState = false;
+ if (!RET_motionPendingOffState) {
+ RET_motionPendingOffState = true;
+ //log stop motion time
+ RET_motionStopTime = time(NULL);
+ RET_motionStartTime = 0;
+ }
+ }
+ //calculate motion state
+ if (RET_motionPendingOnState) {
+ //check if above threshold
+ time_t inMotionForSeconds = (time(NULL) - RET_motionStartTime);
+ if (inMotionForSeconds >= RET_motionStartThreshold_seconds) {
+ RET_motionState = true;
+ LED1blink(10,100);
+ }
+ }
+ if (RET_motionPendingOffState) {
+ time_t noMotionForSeconds = (time(NULL) - RET_motionStopTime);
+ if (noMotionForSeconds >= RET_motionStartThreshold_seconds) {
+ RET_motionState = false;
+ LED1blink(5,500);
+ }
}
break;
case MODE_DORMANT :
-
+ //LIS3DH lis3dh(PN_SPI_MOSI, PN_SPI_MISO, PN_SPI_CS0, PN_SPI_CLK);
break;
case MODE_OFF_48HRS :
@@ -212,8 +214,11 @@
}
+//------------------------------------------------------------------------------
+// MAIN
+//------------------------------------------------------------------------------
+
int main() {
- led1 = 1;
//CHECK IF THIS IS RESET
//0x00000004 == soft reset //0x00000002 == watchdog //0x00000001 == button/hardreset
@@ -221,7 +226,7 @@
switch(NRF_POWER->RESETREAS) {
case 0x00000001 :
DEBUG("reset_reason: 0x%08x. - Hard Reset\n",NRF_POWER->RESETREAS);
- resetState();
+ factoryReset();
break;
case 0x00000002 :
DEBUG("reset_reason: 0x%08x. - Watchdog\n",NRF_POWER->RESETREAS);
@@ -234,238 +239,21 @@
}
NRF_POWER->RESETREAS = 0xffffffff;
}
-
+
while(true) {
- //GOTO TO SLEEP
- if (!firstBoot) gotoSleep(60000);
- LED1on(20);
+ turnOffEverything();
watchdog.kick();
+ firstBoot = false; //temp
+ if (!firstBoot) gotoSleep(10000);
+
+ //INIT
+ Modem modem(PN_UART_TX, PN_UART_RX, PN_UART_CTS, PN_UART_RTS, PN_GSM_PWR_KEY, PN_VREG_EN);
//MAIN STATE ENGINE
+ //LED1blink(1,100);
mainStateEngine();
- }
-}
-
-
-
-/*
-void initMotion() {
- //CHECK FOR ANY MOTION
- if (!accelerometer.selfTest()) {
- if (exceptions.find("A.") < 0) {
- exceptions += "A.";
- }
- DEBUG("Couldnt start accelerometer");
- } else {
- accel_healthy = true;
+
+ //Configure for sleep
+ lis3dh_configureForSleep(10);
}
-}
-*/
-
-/*
-void mode_mtu() {
- bool accel_awake = accelerometer.getINT2();
-
- //CHECK FOR MOTION
- if (accel_awake == true) {
- LED1on(50);
- RET_motionconsecutive ++;
- RET_no_motionconsecutive = 0;
-
- //this is needed to ensure accel_awake_triggercount is 1 or higher for mode 2
- if (RET_accel_awake_triggercount == 0) {
- RET_accel_awake_triggercount = 1;
- }
-
- if (RET_motionconsecutive == RET_accel_awake_triggercount && RET_wethinkinmotion == false) {
- RET_wethinkinmotion = true;
- RET_motionstarttime = (time(NULL) - ((RET_accel_awake_triggercount+1) * RET_motioncheck_interval_seconds));
- long eventEpoch = RET_motionstarttime;
- long epochoffsetminutes = ((eventEpoch - RET_unixtime_framestart) / 60);
-
- char buf[20];
- sprintf(buf,"1.%i!", epochoffsetminutes);
- strcat(RET_operationTimeString, buf);
- RET_operationCount ++;
-
- DEBUG("%s", RET_operationTimeString);
-
- LEDon(100);
- LEDon(100);
- LEDon(100);
- LEDon(100);
- }
- } else if (accel_awake == false) {
- RET_no_motionconsecutive ++;
- RET_motionconsecutive = 0;
- if (RET_no_motionconsecutive == RET_accel_awake_triggercount && RET_wethinkinmotion == true) {
- RET_wethinkinmotion = false;
- // log engine stop
- RET_motionstoptime = (time(NULL) - ((RET_accel_awake_triggercount+1) * RET_motioncheck_interval_seconds));
- long eventEpoch = RET_motionstoptime;
- long epochoffsetminutes = ((eventEpoch - RET_unixtime_framestart) / 60);
-
- char buf[20];
- sprintf(buf,"0.%i!", epochoffsetminutes);
- strcat(RET_operationTimeString, buf);
-
- RET_operationFrameTimeHours = (float(RET_motionstoptime - RET_motionstarttime) / 3600.0);
- RET_operationTimeHours += RET_operationFrameTimeHours;
-
- //test by posting on every stop event
- //doOperationTimePost = true;
-
- DEBUG("%i", RET_operationTimeHours);
- LEDon(500);
- }
- }
-
-
- // Check time interval for location run
- if (time(NULL) > RET_unixtime_nextpost_failsafe) {
- //setfailsafetime(); //these must be before gpsPost, incase gpsPost fails, then stuck in broadcast loop
- //gpsPost();
- }
-
- //Check for operatingTime post time or if data buffer is full for force post
- if (RET_operationFrameTimeHours > 0.0) {
- if (time(NULL) > RET_unixtime_nextpost || strlen(RET_operationTimeString) > 60) {
- //only bother if we actual have data to post
- //setwaketime(); //these must be before gpsPost, incase gpsPost fails, then stuck in broadcast loop
- //uploadOperationTimeData();
- }
- }
-
-}
-*/
-
-
-
-
-
-/*
-
-int selftest() {
- int result = 0;
- int tests = 0;
- int testscore = 0;
- led1 = 0;
- string failures;
-
- //Accelerometer
- tests ++;
- if (accelerometer.read_id() == 51){
- testscore ++;
- } else {
- //Accelerometer Fail
- failures += 'Ac,';
- };
-
- return result;
-}
-*/
-
-
-/*
-void readRegs(uint8_t addr, uint8_t * data, int len) {
- lis3dh_cs = 0;
- for (int i = 0 ; i < len ; i++ ) {
- spi.write((addr+i)|0x80) ; // specify address to read
- data[i] = spi.write((addr+i)|0x80) ;
- }
- spi.write(0x00) ; // to terminate read mode
- lis3dh_cs = 1;
-}
-
-uint8_t read_reg(uint8_t addr)
-{
- uint8_t data[1] ;
- readRegs(addr, data, 1) ;
- return( data[0] ) ;
-}
-*/
-
-
-
-
-
-
-
-
-
-
-
-
-/*
-//OPTION 1
- // Switch on both RAM banks when in System OFF mode.
- NRF_POWER->RAMON |= (POWER_RAMON_OFFRAM0_RAM0On << POWER_RAMON_OFFRAM0_Pos) |
- (POWER_RAMON_OFFRAM1_RAM1On << POWER_RAMON_OFFRAM1_Pos);
-
- // Enter System OFF and wait for wake up from GPIO detect signal.
- NRF_POWER->SYSTEMOFF = 0x1;
-
-
- //spi.close();
-
- //delete spi;
- //spi_disable();
-
- //spi_free(spi);
-
- //nrf_drv_spi_uninit(spi);
- //nordic_nrf5_spi_initialized[instance] = false;
- //HFCLKSTOP = 0x1;
-
- NRF_SPI0->ENABLE = 0;
- NRF_SPI1->ENABLE = 0;
- NRF_SPI2->ENABLE = 0;
- NRF_TWI0->ENABLE = 0;
- NRF_TWI1->ENABLE = 0;
-
- sd_clock_hfclk_release();
- NRF_POWER->SYSTEMOFF=1;
- //NRF_SPI0->POWER = 0;
-
- //OPTION 3
-
- *(volatile uint32_t *)0x40003FFC = 0;
- *(volatile uint32_t *)0x40003FFC;
- *(volatile uint32_t *)0x40003FFC = 1;
-
- NRF_SPI0->ENABLE = (SPI_ENABLE_ENABLE_Disabled << SPI_ENABLE_ENABLE_Pos);
- NRF_SPI1->ENABLE = (SPI_ENABLE_ENABLE_Disabled << SPI_ENABLE_ENABLE_Pos);
-
-
- if (sleep_manager_can_deep_sleep()) {
- ThisThread::sleep_for(10000);
- } else {
- led1 = 0;
- wait(50.0);
- }
-
- //system_reset();
-*/
-
-
- //time_t unixtime = time(NULL);
- //DEBUG("got: %i, %d, %d \n", RET_mode, RET_unixtime, unixtime);
-
-/*
-uint8_t acc_id;
- lis3dh.LIS3DH_GetWHO_AM_I(&acc_id);
- uart.printf("%i \n\r", acc_id);
- */
-
-/*
- AxesRaw_t accel_raw;
- lis3dh.LIS3DH_GetAccAxesRaw(&accel_raw);
-
- uart.printf("x=");
- uart.printf("%i", accel_raw.AXIS_X);
- uart.printf(" y=");
- uart.printf("%i", accel_raw.AXIS_Y);
- uart.printf(" z=");
- uart.printf("%i", accel_raw.AXIS_Z);
- uart.printf("\n\r");
-*/
\ No newline at end of file
+}
\ No newline at end of file
--- a/main.h Wed Nov 14 16:08:28 2018 +0000
+++ b/main.h Tue Dec 11 22:18:24 2018 +0000
@@ -19,15 +19,10 @@
//mbed Libraries
//------------------------------------------------------------------------------
#include "mbed.h"
+#include "board.h"
#include "WatchdogTimer.h"
#include "ble/BLE.h"
-#include "nvstore.h"
-//#include "ATCmdParser.h"
-//#include "UARTSerial.h"
-
-
-// Block devices
-//#include "SPIFBlockDevice.h"
+//#include "nvstore.h"
//------------------------------------------------------------------------------
@@ -55,16 +50,13 @@
//include <string> // dont use - causes 2ma sleep
//using std::string;
-
-//------------------------------------------------------------------------------
-//SEGGER Debugger Libraries
-//------------------------------------------------------------------------------
-//#include "SEGGER_RTT/SEGGER_RTT.h"
-
//------------------------------------------------------------------------------
//Application headers
//------------------------------------------------------------------------------
#include "modes.h"
+#include "common.h"
+#include "sensors.h"
+#include "modem.h"
//------------------------------------------------------------------------------
//Global macros
@@ -72,7 +64,7 @@
#define lowByte(w) ((uint8_t) ((w) & 0xff))
#define highByte(w) ((uint8_t) ((w) >> 8))
-#define NEED_CONSOLE_OUTPUT 1 /* Set this if you need debug messages on the console; * it will have an impact on code-size and power consumption. */
+#define NEED_CONSOLE_OUTPUT 0 /* Set this if you need debug messages on the console; * it will have an impact on code-size and power consumption. */
#if NEED_CONSOLE_OUTPUT
#define DEBUG(...) { uart.printf(__VA_ARGS__); }
#else
@@ -82,8 +74,8 @@
//------------------------------------------------------------------------------
//Global data structures
//------------------------------------------------------------------------------
-//NONE
-
+//VARS
+extern bool requireSoftReset;
#endif
--- a/mbed-os.lib Wed Nov 14 16:08:28 2018 +0000 +++ b/mbed-os.lib Tue Dec 11 22:18:24 2018 +0000 @@ -1,1 +1,1 @@ -https://github.com/ARMmbed/mbed-os/#bf6f2c3c6434a6de9eb9511feffa5948b3d1f20f +https://github.com/ARMmbed/mbed-os/#2fd0c5cfbd83fce62da6308f9d64c0ab64e1f0d6
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/modem.cpp Tue Dec 11 22:18:24 2018 +0000
@@ -0,0 +1,81 @@
+#include "modem.h"
+
+Modem::Modem(PinName tx, PinName rx, PinName cts, PinName rts, PinName pwrkey, PinName vreg_en): _uart(tx,rx,115200), _pwrkey(pwrkey), _vreg_en(vreg_en)
+{
+ requireSoftReset = true; //TODO: this can be removed when uart sleep issue resolved
+}
+
+void Modem::on(void)
+{
+ //power on Modem
+ _vreg_en = 1;
+ ThisThread::sleep_for(500);
+ _pwrkey = 0;
+ ThisThread::sleep_for(1500);
+ _pwrkey = 1;
+ LED1on(1000);
+}
+
+void Modem::off(bool soft)
+{
+ if (soft) {
+ ATsendCMD("AT+QPOWD=0");
+ ATwaitForWord("OK\r",5000);
+ }
+ _vreg_en = 0;
+}
+
+void Modem::flushSerial(void)
+{
+ char char1 = 0;
+ while (_uart.readable()) {
+ char1 = _uart.getc();
+ }
+ return;
+}
+
+void Modem::ATsendCMD(char* cmd)
+{
+ flushSerial();
+ _uart.puts(cmd);
+ _uart.puts("\r");
+}
+
+bool Modem::ATwaitForWord(char* word, long timeout)
+{
+ int targetIndex = 0;
+ bool havefullmatch = false;
+ char captured[32];
+ memset (captured,0,sizeof(captured));
+ Timer t;
+ t.start();
+ long startmillis = t.read_ms();
+ long runtime = 0;
+ while(!havefullmatch && runtime < timeout) {
+ runtime = (t.read_ms() - startmillis);
+ if(_uart.readable()) {
+ char c = _uart.getc();
+ if (c != word[targetIndex]) { //no match, reset
+ targetIndex = 0;
+ }
+ if (c == word[targetIndex]) { //we have a match
+ captured[targetIndex] = c;
+ targetIndex ++;
+ //check for full match
+ if ( strcmp(word, captured) == 0 ) {
+ havefullmatch = true;
+ }
+ }
+ }
+ }
+ t.stop();
+ t.reset();
+ ThisThread::sleep_for(500);
+ if (havefullmatch) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+Modem::~Modem(){};
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/modem.h Tue Dec 11 22:18:24 2018 +0000
@@ -0,0 +1,36 @@
+#ifndef MODEM_H
+#define MODEM_H
+
+#include "main.h"
+
+namespace mbed {
+
+ #define UC20_BAUDRATE 115200
+ #define SIM7600_BAUDRATE 115200
+
+ class Modem
+ {
+ public:
+ Modem(PinName tx, PinName rx, PinName cts, PinName rts, PinName pwrkey, PinName vreg_en);
+ ~Modem();
+
+ //control
+ void on(void);
+ void off(bool soft);
+
+ //commands
+ void flushSerial(void);
+ void ATsendCMD(char* cmd);
+ bool ATwaitForWord(char* word, long timeout);
+ private:
+
+
+
+ protected:
+ Serial _uart;
+ DigitalOut _pwrkey;
+ DigitalOut _vreg_en;
+ };
+
+} //Namespace
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sensors.cpp Tue Dec 11 22:18:24 2018 +0000
@@ -0,0 +1,36 @@
+#include "sensors.h"
+
+//------------------------------------------------------------------------------
+// ACCELEROMETER
+//------------------------------------------------------------------------------
+
+DigitalIn lis3dh_int1(PN_ACC_INT1, PullNone); //DISTUBANCE
+DigitalIn lis3dh_int2(PN_ACC_INT2, PullNone); //IMPACT
+
+void lis3dh_configureForSleep(uint8_t threshold) {
+ //init
+ LIS3DH lis3dh(PN_SPI_MOSI, PN_SPI_MISO, PN_SPI_CS0, PN_SPI_CLK);
+ requireSoftReset = true; //WE HAVE STARTED SPI SO NEED THIS
+ //Mode
+ lis3dh.InitLIS3DH(LIS3DH_NORMAL, LIS3DH_ODR_25Hz, LIS3DH_FULLSCALE_8);
+ //Int settings
+ lis3dh.LIS3DH_SetIntMode(LIS3DH_INT_MODE_6D_MOVEMENT);
+ lis3dh.LIS3DH_IntLatchEnable(MEMS_ENABLE);
+ //Int1
+ lis3dh.LIS3DH_SetInt1Pin(LIS3DH_CLICK_ON_PIN_INT1_DISABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE |
+ LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE | LIS3DH_I1_DRDY1_ON_INT1_DISABLE | LIS3DH_I1_DRDY2_ON_INT1_DISABLE |
+ LIS3DH_WTM_ON_INT1_DISABLE | LIS3DH_INT1_OVERRUN_DISABLE );
+ lis3dh.LIS3DH_SetInt1Threshold(threshold);
+ lis3dh.LIS3DH_SetInt1Duration(0);
+ lis3dh.LIS3DH_SetIntConfiguration(LIS3DH_INT1_ZHIE_ENABLE | LIS3DH_INT1_ZLIE_ENABLE |
+ LIS3DH_INT1_YHIE_ENABLE | LIS3DH_INT1_YLIE_ENABLE |
+ LIS3DH_INT1_XHIE_ENABLE | LIS3DH_INT1_XLIE_ENABLE );
+ //Clear interrupt
+ lis3dh.LIS3DH_ResetInt1Latch();
+
+ //HP filter
+ //lis3dh.LIS3DH_SetHPFMode(LIS3DH_HPM_AUTORESET_INT);
+ //lis3dh.LIS3DH_SetFilterDataSel(MEMS_ENABLE);
+ //lis3dh.LIS3DH_HPFAOI1Enable(MEMS_ENABLE);
+ //lis3dh.LIS3DH_HPFAOI2Enable(MEMS_ENABLE);
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sensors.h Tue Dec 11 22:18:24 2018 +0000 @@ -0,0 +1,20 @@ +#ifndef SENSORS_H_ +#define SENSORS_H_ + +#include "main.h" + +//------------------------------------------------------------------------------ +// ACCELEROMETER +//------------------------------------------------------------------------------ +//PINS +extern DigitalIn lis3dh_int1; +extern DigitalIn lis3dh_int2; + +//FUNCS +extern void lis3dh_configureForSleep(uint8_t threshold); + +//------------------------------------------------------------------------------ +// TEMPERATURE +//------------------------------------------------------------------------------ + +#endif \ No newline at end of file