ADXL362.c File Reference

All code for the ADXL362 accelerometer. More...

#include <stdint.h>
#include <stdbool.h>
#include "em_cmu.h"
#include "em_gpio.h"
#include "em_usart.h"
#include "ADXL362.h"
#include "pin_mapping.h"
#include "debug_dbprint.h"
#include "delay.h"
#include "util.h"

Go to the source code of this file.

Macros
#define	ADXL_REG_DEVID_AD   0x00 /* Reset: 0xAD */
#define	ADXL_REG_DEVID_MST   0x01 /* Reset: 0x1D */
#define	ADXL_REG_PARTID   0x02 /* Reset: 0xF2 */
#define	ADXL_REG_REVID   0x03 /* Reset: 0x01 (can be incremented) */
#define	ADXL_REG_XDATA   0x08
#define	ADXL_REG_YDATA   0x09
#define	ADXL_REG_ZDATA   0x0A
#define	ADXL_REG_STATUS   0x0B
#define	ADXL_REG_TEMP_L   0x14
#define	ADXL_REG_TEMP_H   0x15
#define	ADXL_REG_SOFT_RESET   0x1F /* Needs to be 0x52 ("R") written to for a soft reset */
#define	ADXL_REG_THRESH_ACT_L   0x20 /* 7:0 bits used */
#define	ADXL_REG_THRESH_ACT_H   0x21 /* 2:0 bits used */
#define	ADXL_REG_ACT_INACT_CTL   0x27 /* Activity/Inactivity control register: XX - XX - LINKLOOP - LINKLOOP - INACT_REF - INACT_EN - ACT_REF - ACT_EN */
#define	ADXL_REG_INTMAP1   0x2A /* INT_LOW -- AWAKE -- INACT -- ACT -- FIFO_OVERRUN -- FIFO_WATERMARK -- FIFO_READY -- DATA_READY */
#define	ADXL_REG_INTMAP2   0x2B /* INT_LOW -- AWAKE -- INACT -- ACT -- FIFO_OVERRUN -- FIFO_WATERMARK -- FIFO_READY -- DATA_READY */
#define	ADXL_REG_FILTER_CTL   0x2C /* Write FFxx xxxx (FF = 00 for +-2g, 01 for =-4g, 1x for +- 8g) for measurement range selection */
#define	ADXL_REG_POWER_CTL   0x2D /* Write xxxx xxMM (MM = 10) to: measurement mode */

Functions
static void	powerADXL (bool enabled)
	Enable or disable the power to the accelerometer. More...
static void	initADXL_SPI (void)
	Initialize USARTx in SPI mode according to the settings required by the accelerometer. More...
static void	softResetADXL (void)
	Soft reset accelerometer. More...
static void	resetHandlerADXL (void)
	Soft reset accelerometer handler. More...
static uint8_t	readADXL (uint8_t address)
	Read an SPI byte from the accelerometer (8 bits) using a given address. More...
static void	writeADXL (uint8_t address, uint8_t data)
	Write an SPI byte to the accelerometer (8 bits) using a given address and specified data. More...
static void	readADXL_XYZDATA (void)
	Read the X-Y-Z data registers in the XYZDATA[] field using burst reads. More...
static bool	checkID_ADXL (void)
	Check if the ID is correct. More...
static int32_t	convertGRangeToGValue (int8_t sensorValue)
	Convert sensor value in +-g range to mg value. More...
void	initADXL (void)
	Initialize the accelerometer. More...
uint16_t	ADXL_getCounter (void)
	Getter for the ADXL_triggercounter variable. More...
void	ADXL_clearCounter (void)
	Method to set the ADXL_triggercounter variable back to zero. More...
void	ADXL_setTriggered (bool triggered)
	Setter for the ADXL_triggered variable. More...
bool	ADXL_getTriggered (void)
	Getter for the ADXL_triggered variable. More...
void	ADXL_ackInterrupt (void)
	Acknowledge the interrupt from the accelerometer. More...
void	ADXL_enableSPI (bool enabled)
	Enable or disable the SPI pins and USART0/1 clock and peripheral to the accelerometer. More...
void	ADXL_enableMeasure (bool enabled)
	Enable or disable measurement mode. More...
void	ADXL_configRange (ADXL_Range_t givenRange)
	Configure the measurement range and store the selected one in a global variable for later (internal) use. More...
void	ADXL_configODR (ADXL_ODR_t givenODR)
	Configure the Output Data Rate (ODR). More...
void	ADXL_configActivity (uint8_t gThreshold)
	Configure the accelerometer to work in (referenced) activity threshold mode. More...
void	ADXL_readValues (void)
	Read and display "g" values forever with a 100ms interval. More...
void	testADXL (void)
	This method goes through all of the ODR settings to see the influence they have on power usage. The measurement range is the default one (+-2g). More...

Variables
volatile bool	ADXL_triggered = false
volatile uint16_t	ADXL_triggercounter = 0
int8_t	XYZDATA [3] = { 0x00, 0x00, 0x00 }
ADXL_Range_t	range
bool	ADXL_VDD_initialized = false

Detailed Description

All code for the ADXL362 accelerometer.

Version

3.1

Author

Brecht Van Eeckhoudt

---

Versions

• v1.0: Started with the code from https://github.com/Fescron/Project-LabEmbeddedDesign1/tree/master/code/SLSTK3400A_ADXL362 Changed file name from accel.c to ADXL362.c.
• v1.1: Changed PinModeSet out value to 0 in initADXL_VCC.
• v1.2: Changed last argument in GPIO_PinModeSet in method initADXL_VCC to change the pin mode and enable the pin in one statement.
• v1.3: Changed some methods and global variables to be static (~hidden).
• v1.4: Changed delay method and cleaned up includes.
• v1.5: Added get/set method for the static variable ADXL_triggered.
• v1.6: Changed a lot of things...
• v1.7: Updated documentation and chanced USART0 to ADXL_SPI.
• v1.8: Updated code with new DEFINE checks.
• v1.9: Started using custom enum for range & ODR configuration methods.
• v2.0: Added testing method to go through all the settings, moved the register definitions.
• v2.1: Disabled SPI pins on hard reset, cleaned up some code.
• v2.2: Added functionality to check the number of interrupts.
• v2.3: Updated documentation.
• v2.4: Changed error numbering.
• v2.5: Updated ODR enum and changed masking logic for register settings.
• v3.0: Added functionality to exit methods after error call and updated version number.
• v3.1: Removed static before the local variables (not necessary).

---

Todo:

Future improvements:

• Check configurations by reading the registers again and return true/false when the registers have/don't have the correct values.
• Enable wake-up mode (writeADXL(ADXL_REG_POWER_CTL, 0b00001000); // 5th bit)
• Enable loop mode (with act/inact time registers?) so interrupts don't need to be acknowledged by host (writeADXL(ADXL_REG_ACT_INACT_CTL, 0b00110000);)

---

License

Copyright (C) 2019 - Brecht Van Eeckhoudt

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the LICENSE file along with this source code.

Some methods use code obtained from examples from Silicon Labs' GitHub. These sections are licensed under the Silabs License Agreement. See the file "Silabs_License_Agreement.txt" for details. Before using this software for any purpose, you must agree to the terms of that agreement.

Definition in file ADXL362.c.

Macro Definition Documentation

ADXL_REG_ACT_INACT_CTL

#define ADXL_REG_ACT_INACT_CTL   0x27 /* Activity/Inactivity control register: XX - XX - LINKLOOP - LINKLOOP - INACT_REF - INACT_EN - ACT_REF - ACT_EN */

Definition at line 96 of file ADXL362.c.

ADXL_REG_DEVID_AD

#define ADXL_REG_DEVID_AD   0x00 /* Reset: 0xAD */

Definition at line 83 of file ADXL362.c.

ADXL_REG_DEVID_MST

#define ADXL_REG_DEVID_MST   0x01 /* Reset: 0x1D */

Definition at line 84 of file ADXL362.c.

ADXL_REG_FILTER_CTL

#define ADXL_REG_FILTER_CTL   0x2C /* Write FFxx xxxx (FF = 00 for +-2g, 01 for =-4g, 1x for +- 8g) for measurement range selection */

Definition at line 99 of file ADXL362.c.

ADXL_REG_INTMAP1

#define ADXL_REG_INTMAP1   0x2A /* INT_LOW -- AWAKE -- INACT -- ACT -- FIFO_OVERRUN -- FIFO_WATERMARK -- FIFO_READY -- DATA_READY */

Definition at line 97 of file ADXL362.c.

ADXL_REG_INTMAP2

#define ADXL_REG_INTMAP2   0x2B /* INT_LOW -- AWAKE -- INACT -- ACT -- FIFO_OVERRUN -- FIFO_WATERMARK -- FIFO_READY -- DATA_READY */

Definition at line 98 of file ADXL362.c.

ADXL_REG_PARTID

#define ADXL_REG_PARTID   0x02 /* Reset: 0xF2 */

Definition at line 85 of file ADXL362.c.

ADXL_REG_POWER_CTL

#define ADXL_REG_POWER_CTL   0x2D /* Write xxxx xxMM (MM = 10) to: measurement mode */

Definition at line 100 of file ADXL362.c.

ADXL_REG_REVID

#define ADXL_REG_REVID   0x03 /* Reset: 0x01 (can be incremented) */

Definition at line 86 of file ADXL362.c.

ADXL_REG_SOFT_RESET

#define ADXL_REG_SOFT_RESET   0x1F /* Needs to be 0x52 ("R") written to for a soft reset */

Definition at line 93 of file ADXL362.c.

ADXL_REG_STATUS

#define ADXL_REG_STATUS   0x0B

Definition at line 90 of file ADXL362.c.

ADXL_REG_TEMP_H

#define ADXL_REG_TEMP_H   0x15

Definition at line 92 of file ADXL362.c.

ADXL_REG_TEMP_L

#define ADXL_REG_TEMP_L   0x14

Definition at line 91 of file ADXL362.c.

ADXL_REG_THRESH_ACT_H

#define ADXL_REG_THRESH_ACT_H   0x21 /* 2:0 bits used */

Definition at line 95 of file ADXL362.c.

ADXL_REG_THRESH_ACT_L

#define ADXL_REG_THRESH_ACT_L   0x20 /* 7:0 bits used */

Definition at line 94 of file ADXL362.c.

ADXL_REG_XDATA

#define ADXL_REG_XDATA   0x08

Definition at line 87 of file ADXL362.c.

ADXL_REG_YDATA

#define ADXL_REG_YDATA   0x09

Definition at line 88 of file ADXL362.c.

ADXL_REG_ZDATA

#define ADXL_REG_ZDATA   0x0A

Definition at line 89 of file ADXL362.c.

Function Documentation

ADXL_ackInterrupt()

void ADXL_ackInterrupt

(

void

)

Acknowledge the interrupt from the accelerometer.

Read a certain register (necessary if the accelerometer is not in linked-loop mode) and clear the variable.

Definition at line 230 of file ADXL362.c.

{
    readADXL(ADXL_REG_STATUS);
    ADXL_triggered = false;
}

ADXL_clearCounter()

void ADXL_clearCounter

(

void

)

Method to set the ADXL_triggercounter variable back to zero.

Definition at line 188 of file ADXL362.c.

{
    ADXL_triggercounter = 0;
}

ADXL_configActivity()

void ADXL_configActivity

(

uint8_t

gThreshold

)

Configure the accelerometer to work in (referenced) activity threshold mode.

Route activity detector to INT1 pin using INTMAP1, isolate bits and write settings to both threshold registers.

Referenced means that during the initialization a reference acceleration gets measured (like for example 1 g on a certain axis) and stored internally. This value always gets internally subtracted from a measured acceleration value to calculate the final value and check if it exceeds the set threshold:

• ABS(acceleration - reference) > threshold

Parameters

[in]

gThreshold

Threshold [g].

Definition at line 468 of file ADXL362.c.

{
    /* Map activity detector to INT1 pin  */
    writeADXL(ADXL_REG_INTMAP1, 0b00010000); /* Bit 4 selects activity detector */

    /* Enable referenced activity threshold mode (last two bits) */
    writeADXL(ADXL_REG_ACT_INACT_CTL, 0b00000011);

    /* Convert g value to "codes"
     *   THRESH_ACT [codes] = Threshold Value [g] × Scale Factor [LSB per g] */
    uint8_t threshold;

    if (range == ADXL_RANGE_2G) threshold = gThreshold * 1000;
    else if (range == ADXL_RANGE_4G) threshold = gThreshold * 500;
    else if (range == ADXL_RANGE_8G) threshold = gThreshold * 250;
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Range wrong, can't set gThreshold!");
#endif /* DEBUG_DBPRINT */

        error(26);

        /* Exit function */
        return;
    }

    /* Isolate bits using masks and shifting */
    uint8_t low  = (threshold & 0b0011111111);
    uint8_t high = (threshold & 0b1100000000) >> 8;

    /* Set threshold register values (total: 11bit unsigned) */
    writeADXL(ADXL_REG_THRESH_ACT_L, low);  /* 7:0 bits used */
    writeADXL(ADXL_REG_THRESH_ACT_H, high); /* 2:0 bits used */

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    dbinfoInt("ADXL362: Activity configured: ", gThreshold, "g");
#endif /* DEBUG_DBPRINT */

}

ADXL_configODR()

void ADXL_configODR

(

ADXL_ODR_t

givenODR

)

Configure the Output Data Rate (ODR).

Parameters

[in]

givenODR

The selected ODR.

Definition at line 411 of file ADXL362.c.

{
    /* Get value in register */
    uint8_t reg = readADXL(ADXL_REG_FILTER_CTL);

    /* AND with mask to keep the bits we don't want to change */
    reg &= 0b11111000;

    /* Set ODR (OR with new setting bits, last three bits) */
    if (givenODR == ADXL_ODR_12_5_HZ) writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b00000000));
    else if (givenODR == ADXL_ODR_25_HZ) writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b00000001));
    else if (givenODR == ADXL_ODR_50_HZ) writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b00000010));
    else if (givenODR == ADXL_ODR_100_HZ) writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b00000011));
    else if (givenODR == ADXL_ODR_200_HZ) writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b00000100));
    else if (givenODR == ADXL_ODR_400_HZ) writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b00000101));
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Non-existing ODR selected!");
#endif /* DEBUG_DBPRINT */

        error(25);

        /* Exit function */
        return;
    }

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    if (givenODR == ADXL_ODR_12_5_HZ) dbinfo("ADXL362: ODR set at 12.5 Hz");
    else if (givenODR == ADXL_ODR_25_HZ) dbinfo("ADXL362: ODR set at 25 Hz");
    else if (givenODR == ADXL_ODR_50_HZ) dbinfo("ADXL362: ODR set at 50 Hz");
    else if (givenODR == ADXL_ODR_100_HZ) dbinfo("ADXL362: ODR set at 100 Hz");
    else if (givenODR == ADXL_ODR_200_HZ) dbinfo("ADXL362: ODR set at 200 Hz");
    else if (givenODR == ADXL_ODR_400_HZ) dbinfo("ADXL362: ODR set at 400 Hz");
#endif /* DEBUG_DBPRINT */

}

ADXL_configRange()

void ADXL_configRange

(

ADXL_Range_t

givenRange

)

Configure the measurement range and store the selected one in a global variable for later (internal) use.

When a range of, for example "2g" is selected, the real range is "+-2g".

Parameters

[in]

givenRange

The selected range.

Definition at line 358 of file ADXL362.c.

{
    /* Get value in register */
    uint8_t reg = readADXL(ADXL_REG_FILTER_CTL);

    /* AND with mask to keep the bits we don't want to change */
    reg &= 0b00111111;

    /* Set measurement range (OR with new setting bits, first two bits) */
    if (givenRange == ADXL_RANGE_2G)
    {
        writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b00000000));
        range = ADXL_RANGE_2G;
    }
    else if (givenRange == ADXL_RANGE_4G)
    {
        writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b01000000));
        range = ADXL_RANGE_4G;
    }
    else if (givenRange == ADXL_RANGE_8G)
    {
        writeADXL(ADXL_REG_FILTER_CTL, (reg | 0b10000000));
        range = ADXL_RANGE_8G;
    }
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Non-existing range selected!");
#endif /* DEBUG_DBPRINT */

        error(24);

        /* Exit function */
        return;
    }

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    if (range == ADXL_RANGE_2G) dbinfo("ADXL362: Measurement mode +- 2g selected");
    else if (range == ADXL_RANGE_4G) dbinfo("ADXL362: Measurement mode +- 4g selected");
    else if (range == ADXL_RANGE_8G) dbinfo("ADXL362: Measurement mode +- 8g selected");
#endif /* DEBUG_DBPRINT */

}

ADXL_enableMeasure()

void ADXL_enableMeasure

(

bool

enabled

)

Enable or disable measurement mode.

Parameters

[in]

enabled

true - Enable measurement mode. false - Disable measurement mode (standby).

Definition at line 310 of file ADXL362.c.

{
    if (enabled)
    {
        /* Get value in register */
        uint8_t reg = readADXL(ADXL_REG_POWER_CTL);

        /* AND with mask to keep the bits we don't want to change */
        reg &= 0b11111100;

        /* Enable measurements (OR with new setting bits) */
        writeADXL(ADXL_REG_POWER_CTL, reg | 0b00000010); /* Last 2 bits are measurement mode */

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbinfo("ADXL362: Measurement enabled");
#endif /* DEBUG_DBPRINT */

    }
    else
    {
        /* Get value in register */
        uint8_t reg = readADXL(ADXL_REG_POWER_CTL);

        /* AND with mask to keep the bits we don't want to change */
        reg &= 0b11111100;

        /* Disable measurements (OR with new setting bits) */
        writeADXL(ADXL_REG_POWER_CTL, reg | 0b00000000); /* Last 2 bits are measurement mode */

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbinfo("ADXL362: Measurement disabled (standby)");
#endif /* DEBUG_DBPRINT */

    }
}

ADXL_enableSPI()

void ADXL_enableSPI

(

bool

enabled

)

Enable or disable the SPI pins and USART0/1 clock and peripheral to the accelerometer.

Parameters

[in]

enabled

true - Enable the SPI pins and USART0/1 clock and peripheral to the accelerometer. false - Disable the SPI pins and USART0/1 clock and peripheral to the accelerometer.

Definition at line 245 of file ADXL362.c.

{
    if (enabled)
    {
        /* Enable USART clock and peripheral */
        if (ADXL_SPI == USART0) CMU_ClockEnable(cmuClock_USART0, true);
        else if (ADXL_SPI == USART1) CMU_ClockEnable(cmuClock_USART1, true);
        else
        {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
            dbcrit("Wrong peripheral selected!");
#endif /* DEBUG_DBPRINT */

            error(22);

            /* Exit function */
            return;
        }

        USART_Enable(ADXL_SPI, usartEnable);

        /* In the case of gpioModePushPull", the last argument directly sets the pin state */
        GPIO_PinModeSet(ADXL_CLK_PORT, ADXL_CLK_PIN, gpioModePushPull, 0);   /* US0_CLK is push pull */
        GPIO_PinModeSet(ADXL_NCS_PORT, ADXL_NCS_PIN, gpioModePushPull, 1);   /* US0_CS is push pull */
        GPIO_PinModeSet(ADXL_MOSI_PORT, ADXL_MOSI_PIN, gpioModePushPull, 1); /* US0_TX (MOSI) is push pull */
        GPIO_PinModeSet(ADXL_MISO_PORT, ADXL_MISO_PIN, gpioModeInput, 1);    /* US0_RX (MISO) is input */
    }
    else
    {
        /* Disable USART clock and peripheral */
        if (ADXL_SPI == USART0) CMU_ClockEnable(cmuClock_USART0, false);
        else if (ADXL_SPI == USART1) CMU_ClockEnable(cmuClock_USART1, false);
        else
        {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
            dbcrit("Wrong peripheral selected!");
#endif /* DEBUG_DBPRINT */

            error(23);

            /* Exit function */
            return;
        }

        USART_Enable(ADXL_SPI, usartDisable);

        /* gpioModeDisabled: Pull-up if DOUT is set. */
        GPIO_PinModeSet(ADXL_CLK_PORT, ADXL_CLK_PIN, gpioModeDisabled, 0);
        GPIO_PinModeSet(ADXL_NCS_PORT, ADXL_NCS_PIN, gpioModeDisabled, 1);
        GPIO_PinModeSet(ADXL_MOSI_PORT, ADXL_MOSI_PIN, gpioModeDisabled, 1);
        GPIO_PinModeSet(ADXL_MISO_PORT, ADXL_MISO_PIN, gpioModeDisabled, 1);
    }
}

ADXL_getCounter()

uint16_t ADXL_getCounter

(

void

)

Getter for the ADXL_triggercounter variable.

Returns

The value of ADXL_triggercounter.

Definition at line 178 of file ADXL362.c.

{
    return (ADXL_triggercounter);
}

ADXL_getTriggered()

bool ADXL_getTriggered

(

void

)

Getter for the ADXL_triggered variable.

Returns

The value of ADXL_triggered.

Definition at line 216 of file ADXL362.c.

{
    return (ADXL_triggered);
}

ADXL_readValues()

void ADXL_readValues

(

void

)

Read and display "g" values forever with a 100ms interval.

Definition at line 515 of file ADXL362.c.

{
    uint32_t counter = 0;

    /* Enable measurement mode */
    ADXL_enableMeasure(true);

    /* Infinite loop */
    while (1)
    {
        led(true); /* Enable LED */

        readADXL_XYZDATA(); /* Read XYZ sensor data */

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        /* Print XYZ sensor data */
        dbprint("\r[");
        dbprintInt(counter);
        dbprint("] X: ");
        dbprintInt(convertGRangeToGValue(XYZDATA[0]));
        dbprint(" mg | Y: ");
        dbprintInt(convertGRangeToGValue(XYZDATA[1]));
        dbprint(" mg | Z: ");
        dbprintInt(convertGRangeToGValue(XYZDATA[2]));
        dbprint(" mg       "); /* Extra spacing is to overwrite other data if it's remaining (see \r) */
#endif /* DEBUG_DBPRINT */

        led(false); /* Disable LED */

        counter++;

        delay(100);
    }
}

ADXL_setTriggered()

void ADXL_setTriggered

(

bool

triggered

)

Setter for the ADXL_triggered variable.

Parameters

[in]

triggered

true - Set ADXL_triggered to true. false - Set ADXL_triggered to false.

Definition at line 202 of file ADXL362.c.

{
    ADXL_triggered = triggered;
    ADXL_triggercounter++;
}

checkID_ADXL()

static bool checkID_ADXL ( void  )

static

Check if the ID is correct.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Returns

• true - Correct ID returned.
• false - Incorrect ID returned.

Definition at line 918 of file ADXL362.c.

{
    return (readADXL(ADXL_REG_DEVID_AD) == 0xAD);
}

convertGRangeToGValue()

static int32_t convertGRangeToGValue ( int8_t  sensorValue )

static

Convert sensor value in +-g range to mg value.

Note

Info found at http://ozzmaker.com/accelerometer-to-g/
This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

sensorValue

Value in g-range returned by sensor.

Returns

The calculated mg value.

Definition at line 939 of file ADXL362.c.

{
    /* Explanation of the used numbers:
     *   - 255 = (-) 128 + 127
     *   - 2 = "+" & "-"
     *   - 1000 = "m"g */

    if (range == ADXL_RANGE_2G) return ((2*2*1000 / 255) * sensorValue);
    else if (range == ADXL_RANGE_4G) return ((2*4*1000 / 255) * sensorValue);
    else if (range == ADXL_RANGE_8G) return ((2*8*1000 / 255) * sensorValue);
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Range wrong, can't calculate mg value!");
#endif /* DEBUG_DBPRINT */

        error(27);

        /* Exit function */
        return (0);
    }
}

initADXL()

void initADXL

(

void

)

Initialize the accelerometer.

This method calls all the other internal necessary functions. Clock enable functionality is gathered here instead of in lower (static) functions.

Definition at line 132 of file ADXL362.c.

{
    /* Enable necessary clocks (just in case) */
    CMU_ClockEnable(cmuClock_HFPER, true); /* GPIO and USART0/1 are High Frequency Peripherals */
    CMU_ClockEnable(cmuClock_GPIO, true);

    /* Initialize and power VDD pin */
    powerADXL(true);

    /* Power-up delay of 40 ms */
    delay(40);

    /* Enable necessary clock (just in case) */
    if (ADXL_SPI == USART0) CMU_ClockEnable(cmuClock_USART0, true);
    else if (ADXL_SPI == USART1) CMU_ClockEnable(cmuClock_USART1, true);
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Wrong peripheral selected!");
#endif /* DEBUG_DBPRINT */

        /* Disable power to the VDD pin */
        powerADXL(false);

        error(21);

        /* Exit function */
        return;
    }

    /* Initialize USART0/1 as SPI slave (also initialize CS pin) */
    initADXL_SPI();

    /* Soft reset ADXL handler */
    resetHandlerADXL();
}

initADXL_SPI()

static void initADXL_SPI ( void  )

static

Initialize USARTx in SPI mode according to the settings required by the accelerometer.

Configure pins, configure USARTx in SPI mode, route the pins, enable USARTx and set CS high. Necessary clocks are enabled in a previous method.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Definition at line 647 of file ADXL362.c.

{
    /* Configure GPIO */
    /* In the case of gpioModePushPull", the last argument directly sets the pin state */
    GPIO_PinModeSet(ADXL_CLK_PORT, ADXL_CLK_PIN, gpioModePushPull, 0);   /* US0_CLK is push pull */
    GPIO_PinModeSet(ADXL_NCS_PORT, ADXL_NCS_PIN, gpioModePushPull, 1);   /* US0_CS is push pull */
    GPIO_PinModeSet(ADXL_MOSI_PORT, ADXL_MOSI_PIN, gpioModePushPull, 1); /* US0_TX (MOSI) is push pull */
    GPIO_PinModeSet(ADXL_MISO_PORT, ADXL_MISO_PIN, gpioModeInput, 1);    /* US0_RX (MISO) is input */

    /* Start with default config */
    USART_InitSync_TypeDef config = USART_INITSYNC_DEFAULT;

    /* Modify some settings */
    config.enable       = false;            /* making sure to keep USART disabled until we've set everything up */
    config.refFreq      = 0;                /* USART/UART reference clock assumed when configuring baud rate setup. Set to 0 to use the currently configured reference clock. */
    config.baudrate     = 4000000;          /* CLK freq is 1 MHz (1000000) */
    config.databits     = usartDatabits8;   /* master mode */
    config.master       = true;             /* master mode */
    config.msbf         = true;             /* send MSB first */
    config.clockMode    = usartClockMode0;  /* clock idle low, sample on rising/first edge (Clock polarity/phase mode = CPOL/CPHA) */
    config.prsRxEnable = false;             /* If enabled: Enable USART Rx via PRS. */
    config.autoTx = false;                  /* If enabled: Enable AUTOTX mode. Transmits as long as RX is not full. Generates underflows if TX is empty. */
    config.autoCsEnable = false;            /* CS pin controlled by hardware, not firmware */

    /* Initialize USART0/1 with the configured parameters */
    USART_InitSync(ADXL_SPI, &config);

    /* Set the pin location for USART0/1 (before: USART_ROUTE_LOCATION_LOC0) */
    ADXL_SPI->ROUTE = USART_ROUTE_CLKPEN | USART_ROUTE_CSPEN | USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | ADXL_SPI_LOC;

    /* Enable USART0/1 */
    USART_Enable(ADXL_SPI, usartEnable);

    /* Set CS high (active low!) */
    GPIO_PinOutSet(gpioPortE, 13);
}

powerADXL()

static void powerADXL ( bool  enabled )

static

Enable or disable the power to the accelerometer.

This method also initializes the pin-mode if necessary. Necessary clocks are enabled in a previous method.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

enabled

true - Enable the GPIO pin connected to the VDD pin of the accelerometer. false - Disable the GPIO pin connected to the VDD pin of the accelerometer.

Definition at line 875 of file ADXL362.c.

{
    /* Initialize VDD pin if not already the case */
    if (!ADXL_VDD_initialized)
    {
        /* In the case of gpioModePushPull", the last argument directly sets the pin state */
        GPIO_PinModeSet(ADXL_VDD_PORT, ADXL_VDD_PIN, gpioModePushPull, enabled);

        ADXL_VDD_initialized = true;
    }
    else
    {
        if (enabled) GPIO_PinOutSet(ADXL_VDD_PORT, ADXL_VDD_PIN); /* Enable VDD pin */
        else GPIO_PinOutClear(ADXL_VDD_PORT, ADXL_VDD_PIN); /* Disable VDD pin */
    }
}

readADXL()

static uint8_t readADXL ( uint8_t  address )

static

Read an SPI byte from the accelerometer (8 bits) using a given address.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

address

The register address to read from.

Returns

The response (one byte, uint8_t).

Definition at line 782 of file ADXL362.c.

{
    uint8_t response;

    /* Set CS low (active low!) */
    GPIO_PinOutClear(ADXL_NCS_PORT, ADXL_NCS_PIN);

    /* 3-byte operation according to datasheet */
    USART_SpiTransfer(ADXL_SPI, 0x0B);            /* "read" instruction */
    USART_SpiTransfer(ADXL_SPI, address);         /* Address */
    response = USART_SpiTransfer(ADXL_SPI, 0x00); /* Read response */

    /* Set CS high */
    GPIO_PinOutSet(ADXL_NCS_PORT, ADXL_NCS_PIN);

    return (response);
}

readADXL_XYZDATA()

static void readADXL_XYZDATA ( void  )

static

Read the X-Y-Z data registers in the XYZDATA[] field using burst reads.

Response data gets put in XYZDATA array (global volatile variable).

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Definition at line 842 of file ADXL362.c.

{
    /* CS low (active low!) */
    GPIO_PinOutClear(ADXL_NCS_PORT, ADXL_NCS_PIN);

    /* Burst read (address auto-increments) */
    USART_SpiTransfer(ADXL_SPI, 0x0B);              /* "read" instruction */
    USART_SpiTransfer(ADXL_SPI, ADXL_REG_XDATA);    /* Address */
    XYZDATA[0] = USART_SpiTransfer(ADXL_SPI, 0x00); /* Read response */
    XYZDATA[1] = USART_SpiTransfer(ADXL_SPI, 0x00); /* Read response */
    XYZDATA[2] = USART_SpiTransfer(ADXL_SPI, 0x00); /* Read response */

    /* CS high */
    GPIO_PinOutSet(ADXL_NCS_PORT, ADXL_NCS_PIN);
}

resetHandlerADXL()

static void resetHandlerADXL ( void  )

static

Soft reset accelerometer handler.

If the first ID check fails, the MCU is put on hold for one second and the ID gets checked again.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Definition at line 697 of file ADXL362.c.

{
    uint8_t retries = 0;

    /* Soft reset ADXL */
    softResetADXL();

    /* First try to get the correct ID failed */
    if (!checkID_ADXL())
    {
        retries++;

        delay(1000);

        /* Soft reset */
        softResetADXL();

        /* Second try to get the correct ID failed */
        if (!checkID_ADXL())
        {
            retries++;

            delay(1000);

            /* Soft reset */
            softResetADXL();

            /* Third try to get the correct ID failed
             * resorting to "hard" reset! */
            if (!checkID_ADXL())
            {
                retries++;

                powerADXL(false);
                ADXL_enableSPI(false); /* Make sure the accelerometer doesn't get power through the SPI pins */

                delay(1000);

                powerADXL(true);
                ADXL_enableSPI(true);

                delay(1000);

                /* Soft reset */
                softResetADXL();

                /* Last try to get the correct ID failed */
                if (!checkID_ADXL())
                {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
                    dbcrit("ADXL362 initialization failed");
#endif /* DEBUG_DBPRINT */

                    error(20);

                    /* Exit function */
                    return;
                }
            }
        }
    }

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    if (retries < 2) dbinfoInt("ADXL362 initialized (", retries, " soft reset retries)");
    else dbwarnInt("ADXL362 initialized (had to \"hard reset\", ", retries, " soft reset retries)");
#endif /* DEBUG_DBPRINT */

}

softResetADXL()

static void softResetADXL ( void  )

static

Soft reset accelerometer.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Definition at line 901 of file ADXL362.c.

{
    writeADXL(ADXL_REG_SOFT_RESET, 0x52); /* 0x52 = "R" */
}

testADXL()

void testADXL

(

void

)

This method goes through all of the ODR settings to see the influence they have on power usage. The measurement range is the default one (+-2g).

To get the "correct" currents the delay method puts the MCU to EM2/3 sleep and the SPI lines are disabled. The order of the test is:

• Wait 5 seconds
• Soft reset the accelerometer
• One second in "standby" mode
• Enable "measurement" mode
• One second in ODR 12.5 Hz
• One second in ODR 25 Hz
• One second in ODR 50 Hz
• One second in ODR 100 Hz
• One second in ODR 200 Hz
• One second in ODR 400 Hz
• Soft reset the accelerometer

Definition at line 571 of file ADXL362.c.

{
    delay(5000);

    /* Soft reset ADXL */
    softResetADXL();

    /* Standby */
    ADXL_enableSPI(false); /* Disable SPI functionality */
    delay(1000);
    ADXL_enableSPI(true);  /* Enable SPI functionality */

    /* ODR 12,5Hz */
    writeADXL(ADXL_REG_FILTER_CTL, 0b00010000); /* last 3 bits are ODR */

    /* Enable measurements */
    writeADXL(ADXL_REG_POWER_CTL, 0b00000010); /* last 2 bits are measurement mode */

    ADXL_enableSPI(false); /* Disable SPI functionality */
    delay(1000);
    ADXL_enableSPI(true);  /* Enable SPI functionality */

    /* ODR 25Hz */
    writeADXL(ADXL_REG_FILTER_CTL, 0b00010001); /* last 3 bits are ODR */

    ADXL_enableSPI(false); /* Disable SPI functionality */
    delay(1000);
    ADXL_enableSPI(true);  /* Enable SPI functionality */

    /* ODR 50Hz */
    writeADXL(ADXL_REG_FILTER_CTL, 0b00010010); /* last 3 bits are ODR */

    ADXL_enableSPI(false); /* Disable SPI functionality */
    delay(1000);
    ADXL_enableSPI(true);  /* Enable SPI functionality */

    /* ODR 100Hz (default) */
    writeADXL(ADXL_REG_FILTER_CTL, 0b00010011); /* last 3 bits are ODR */

    ADXL_enableSPI(false); /* Disable SPI functionality */
    delay(1000);
    ADXL_enableSPI(true);  /* Enable SPI functionality */

    /* ODR 200Hz */
    writeADXL(ADXL_REG_FILTER_CTL, 0b00010100); /* last 3 bits are ODR */

    ADXL_enableSPI(false); /* Disable SPI functionality */
    delay(1000);
    ADXL_enableSPI(true);  /* Enable SPI functionality */

    /* ODR 400Hz */
    writeADXL(ADXL_REG_FILTER_CTL, 0b00010101); /* last 3 bits are ODR */

    ADXL_enableSPI(false); /* Disable SPI functionality */
    delay(1000);
    ADXL_enableSPI(true);  /* Enable SPI functionality */

    /* Soft reset ADXL */
    softResetADXL();
}

writeADXL()

static void writeADXL ( uint8_t  address, uint8_t  data  )

static

Write an SPI byte to the accelerometer (8 bits) using a given address and specified data.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]	address	The register address to write the data to (one byte, uint8_t).
[in]	data	The data to write to the address (one byte, uint8_t).

Definition at line 816 of file ADXL362.c.

{
    /* Set CS low (active low!) */
    GPIO_PinOutClear(ADXL_NCS_PORT, ADXL_NCS_PIN);

    /* 3-byte operation according to datasheet */
    USART_SpiTransfer(ADXL_SPI, 0x0A);    /* "write" instruction */
    USART_SpiTransfer(ADXL_SPI, address); /* Address */
    USART_SpiTransfer(ADXL_SPI, data);    /* Data */

    /* Set CS high */
    GPIO_PinOutSet(ADXL_NCS_PORT, ADXL_NCS_PIN);
}

Variable Documentation

ADXL_triggercounter

volatile uint16_t ADXL_triggercounter = 0

Definition at line 105 of file ADXL362.c.

ADXL_triggered

volatile bool ADXL_triggered = false

Definition at line 104 of file ADXL362.c.

ADXL_VDD_initialized

bool ADXL_VDD_initialized = false

Definition at line 108 of file ADXL362.c.

range

ADXL_Range_t range

Definition at line 107 of file ADXL362.c.

XYZDATA

int8_t XYZDATA[3] = { 0x00, 0x00, 0x00 }

Definition at line 106 of file ADXL362.c.