rt-thread-official/bsp/efm32/dev_accel.c

/***************************************************************************//**
 * @file    dev_accel.c
 * @brief   Accelerometer driver of RT-Thread RTOS for EFM32
 *  COPYRIGHT (C) 2012, RT-Thread Development Team
 * @author  onelife
 * @version 1.0
 *******************************************************************************
 * @section License
 * The license and distribution terms for this file may be found in the file
 * LICENSE in this distribution or at http://www.rt-thread.org/license/LICENSE
 *******************************************************************************
 * @section Change Logs
 * Date         Author      Notes
 * 2011-07-13   onelife     Initial creation for using EFM32 ADC module to
 *  interface the Freescale MMA7361L
 * 2011-08-02   onelife     Add digital interface support of using EFM32 IIC
 *  module for the Freescale MMA7455L
 ******************************************************************************/

/***************************************************************************//**
 * @addtogroup efm32
 * @{
 ******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "board.h"

#if defined(EFM32_USING_ACCEL)
#if (EFM32_USING_ACCEL == EFM32_INTERFACE_ADC)
#include "drv_adc.h"
#elif (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
#include "drv_iic.h"
#include "hdl_interrupt.h"
#endif
#include "dev_accel.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
#ifdef EFM32_ACCEL_DEBUG
#define accel_debug(format,args...)         rt_kprintf(format, ##args)
#else
#define accel_debug(format,args...)
#endif

/* Private constants ---------------------------------------------------------*/
static rt_device_t                      accel;
#if (EFM32_USING_ACCEL == EFM32_INTERFACE_ADC)
static struct efm32_adc_control_t       control = \
    {ADC_MODE_SCAN, {3, ACCEL_USING_DMA}, {}};
static struct efm32_accel_result_t      accelOffset = {0};
#elif (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
static const struct efm32_iic_control_t control = \
    {IIC_STATE_MASTER, 0x0000};
#endif
static rt_bool_t                        accelInTime = true;
static rt_uint32_t                      accelConfig = 0;

/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/***************************************************************************//**
 * @brief
 *   Get accelerometer output
 *
 * @details
 *
 * @note
 *
 * @param[out] data
 *  Pointer to output buffer
 *
 * @param[in] lowResolution
 *  Resolution selection
 *
 * @return
 *   Error code
 ******************************************************************************/
rt_err_t efm_accel_get_data(struct efm32_accel_result_t *data,
    rt_bool_t lowResolution)
{
    RT_ASSERT(accel != RT_NULL);

    rt_err_t ret;

    if (data == RT_NULL)
    {
        return -RT_ERROR;
    }

    ret = RT_EOK;
    do
    {
        /* --------- ADC interface --------- */
#if (EFM32_USING_ACCEL == EFM32_INTERFACE_ADC)
        struct efm32_adc_result_t result;

        result.mode = control.mode;
        result.buffer = (void *)data;
        if ((ret = accel->control(accel, RT_DEVICE_CTRL_RESUME,
            (void *)&result)) != RT_EOK)
        {
            break;
        }
        if ((ret = accel->control(accel, RT_DEVICE_CTRL_ADC_RESULT, \
            (void *)&result)) != RT_EOK)
        {
            break;
        }

        data->x += accelOffset.x - 0x800;
        data->y += accelOffset.y - 0x800;
        data->z += accelOffset.z - 0x800;
        if (lowResolution)
        {
            data->x >>= 4;
            data->y >>= 4;
            data->z >>= 4;
        }

        /* --------- IIC interface --------- */
#elif (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
        if (lowResolution || \
            ((accelConfig & ACCEL_MASK_RANGE) != MCTL_RANGE_8G))
        {
            rt_int8_t buf[3];

            buf[0] = XOUT8;
            if (accel->read(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, \
                sizeof(buf)) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
            data->x = buf[0];
            data->y = buf[1];
            data->z = buf[2];
        }
        else
        {
            rt_uint8_t buf[6];
            rt_uint16_t *temp = (rt_uint16_t *)&buf;

            buf[0] = XOUTL;
            if (accel->read(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, \
                sizeof(buf)) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
            data->x = (*temp & 0x200) ? ((rt_uint32_t)*temp | ~0x3FF) : \
                ((rt_uint32_t)*temp & 0x3FF);
            data->y = (*++temp & 0x200) ? ((rt_uint32_t)*temp | ~0x3FF) : \
                ((rt_uint32_t)*temp & 0x3FF);
            data->z = (*++temp & 0x200) ? ((rt_uint32_t)*temp | ~0x3FF) : \
                ((rt_uint32_t)*temp & 0x3FF);
        }
#endif
        return RT_EOK;
    } while (0);

    accel_debug("Accel err: Get data failed!\n");
    return ret;
}

/***************************************************************************//**
 * @brief
 *   Accelerometer timeout interrupt handler
 *
 * @details
 *
 * @note
 *
 * @param[in] parameter
 *  Parameter
 ******************************************************************************/
static void efm_accel_timer(void* parameter)
{
    accelInTime = false;
}

#if (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
/***************************************************************************//**
 * @brief
 *  Accelerometer level and pulse detection interrupts handler
 *
 * @details
 *
 * @note
 *
 * @param[in] device
 *  Pointer to device descriptor
 ******************************************************************************/
static void efm_accel_isr(rt_device_t device)
{
    rt_uint8_t buf[2];

    if ((accelConfig & ACCEL_MASK_MODE) != ACCEL_MODE_MEASUREMENT)
    {
        /* Read detection source */
        buf[0] = DETSRC;
        if (accel->read(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 1) != 1)
        {
            accel_debug("Accel: read error\n");
            return;
        }
        accel_debug("Accel: DETSRC %x\n", buf[0]);

        /* Reset the interrupt flags: Part 1 */
        buf[0] = INTRST;
        buf[1] = INTRST_INT_1 | INTRST_INT_2;
        accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2);

        /* Read status to waste some time */
        buf[0] = STATUS;
        if (accel->read(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 1) != 1)
        {
            accel_debug("Accel: read error\n");
            return;
        }
        accel_debug("Accel: STATUS %x\n", buf[0]);

        /* Reset the interrupt flags: Part 2 */
        buf[0] = INTRST;
        buf[1] = 0x00;
        accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2);
    }
}

/***************************************************************************//**
 * @brief
 *  Accelerometer configuration function
 *
 * @details
 *
 * @note
 *
 * @param[in] config
 *  Configuration options
 *
 * @param[in] level_threshold
 *  Level detection threshold
 *
 * @param[in] pulse_threshold
 *  Pulse detection threshold
 *
 * @param[in] pulse_duration
 *  Time window for 1st pulse
 *
 * @param[in] pulse_latency
 *  Pulse latency Time
 *
 * @param[in] pulse_duration2
 *  Time window for 2nd pulse
 *
 * @return
 *   Error code
 ******************************************************************************/
rt_err_t efm_accel_config(rt_uint32_t config,
    rt_uint8_t level_threshold,
    rt_uint8_t pulse_threshold,
    rt_uint8_t pulse_duration,
    rt_uint8_t pulse_latency,
    rt_uint8_t pulse_duration2)
{
    rt_err_t ret;
    rt_uint8_t buf[2];
    rt_uint8_t mode, mctl_reg, ctl1_reg, ctl2_reg;

    ret = RT_EOK;
    mctl_reg = 0;
    ctl1_reg = 0;
    ctl2_reg = 0;

    /* Modify MCTL */
    mode = config & ACCEL_MASK_MODE;
    switch (mode)
    {
    case ACCEL_MODE_STANDBY:
        mctl_reg |= MCTL_MODE_STANDBY;
        break;
    case ACCEL_MODE_MEASUREMENT:
        mctl_reg |= MCTL_MODE_MEASUREMENT;
        break;
    case ACCEL_MODE_LEVEL:
        mctl_reg |= MCTL_MODE_LEVEL;
        break;
    case ACCEL_MODE_PULSE:
        mctl_reg |= MCTL_MODE_PULSE;
        break;
    default:
        return -RT_ERROR;
    }

    switch (config & ACCEL_MASK_RANGE)
    {
    case ACCEL_RANGE_8G:
        mctl_reg |= MCTL_RANGE_8G;
        break;
    case ACCEL_RANGE_4G:
        mctl_reg |= MCTL_RANGE_4G;
        break;
    case ACCEL_RANGE_2G:
        mctl_reg |= MCTL_RANGE_2G;
        break;
    default:
        return -RT_ERROR;
    }

    if ((mode == ACCEL_MODE_LEVEL) || (mode == ACCEL_MODE_PULSE))
    {
        mctl_reg |= MCTL_PIN_INT1;
    }

    /* Modify CTL1 */
    if (config & ACCEL_INTPIN_INVERSE)
    {
        ctl1_reg |= CTL1_INTPIN_INVERSE;
    }

    switch (config & ACCEL_MASK_INT)
    {
    case ACCEL_INT_LEVEL_PULSE:
        ctl1_reg |= CTL1_INT_LEVEL_PULSE;
        break;
    case ACCEL_INT_PULSE_LEVEL:
        ctl1_reg |= CTL1_INT_PULSE_LEVEL;
        break;
    case ACCEL_INT_SINGLE_DOUBLE:
        ctl1_reg |= CTL1_INT_SINGLE_DOUBLE;
        break;
    default:
        break;
    }

    switch (config & ACCEL_MASK_DISABLE)
    {
    case ACCEL_DISABLE_X:
        ctl1_reg |= CTL1_X_DISABLE;
        break;
    case ACCEL_DISABLE_Y:
        ctl1_reg |= CTL1_Y_DISABLE;
        break;
    case ACCEL_DISABLE_Z:
        ctl1_reg |= CTL1_Z_DISABLE;
        break;
    default:
        break;
    }

    if (config & ACCEL_THRESHOLD_INTEGER)
    {
        ctl1_reg |= CTL1_THRESHOLD_INTEGER;
    }

    if (config & ACCEL_BANDWIDTH_125HZ)
    {
        ctl1_reg |= CTL1_BANDWIDTH_125HZ;
    }

    /* Modify CTL2 */
    if (config & ACCEL_LEVEL_AND)
    {
        ctl2_reg |= CTL2_LEVEL_AND;
    }
    if (config & ACCEL_PULSE_AND)
    {
        ctl2_reg |= CTL2_PULSE_AND;
    }
    if (config & ACCEL_DRIVE_STRONG)
    {
        ctl2_reg |= CTL2_DRIVE_STRONG;
    }

    do
    {
        /* Write registers */
        buf[0] = MCTL;
        buf[1] = mctl_reg;
        if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
        {
            ret = -RT_ERROR;
            break;
        }
        accel_debug("Accel: MCTL %x\n", mctl_reg);

        buf[0] = CTL1;
        buf[1] = ctl1_reg;
        if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
        {
            ret = -RT_ERROR;
            break;
        }
        accel_debug("Accel: CTL1 %x\n", ctl1_reg);

        buf[0] = CTL2;
        buf[1] = ctl2_reg;
        if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
        {
            ret = -RT_ERROR;
            break;
        }
        accel_debug("Accel: CTL2 %x\n", ctl2_reg);
        accelConfig = config;

        if (mode == ACCEL_MODE_PULSE)
        {
            buf[0] = PDTH;
            buf[1] = pulse_threshold;
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
            accel_debug("Accel: PDTH %x\n", buf[1]);

            buf[0] = PW;
            buf[1] = pulse_duration;
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
            accel_debug("Accel: PW %x\n", buf[1]);

            buf[0] = LT;
            buf[1] = pulse_latency;
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
            accel_debug("Accel: LT %x\n", buf[1]);

            buf[0] = TW;
            buf[1] = pulse_duration2;
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
            accel_debug("Accel: TW %x\n", buf[1]);
        }

        if ((mode == ACCEL_MODE_LEVEL) || (mode == ACCEL_MODE_PULSE))
        {
            efm32_irq_hook_init_t hook;

            /* Reset the interrupt flags: Part 1 */
            buf[0] = INTRST;
            buf[1] = INTRST_INT_1 | INTRST_INT_2;
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
            {
                ret = -RT_ERROR;
                break;
            }

            /* Set level detection threshold */
            buf[0] = LDTH;
            if (config & ACCEL_THRESHOLD_INTEGER)
            {
                buf[1] = level_threshold;
            }
            else
            {
                buf[1] = level_threshold & 0x7f;
            }
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
            accel_debug("Accel: LDTH %x\n", buf[1]);

            /* Config interrupt */
            hook.type       = efm32_irq_type_gpio;
            hook.unit       = ACCEL_INT1_PIN;
            hook.cbFunc     = efm_accel_isr;
            hook.userPtr    = RT_NULL;
            efm32_irq_hook_register(&hook);
            hook.unit       = ACCEL_INT2_PIN;
            efm32_irq_hook_register(&hook);
            /* Clear pending interrupt */
            BITBAND_Peripheral(&(GPIO->IFC), ACCEL_INT1_PIN, 0x1UL);
            BITBAND_Peripheral(&(GPIO->IFC), ACCEL_INT2_PIN, 0x1UL);
            /* Set raising edge interrupt and clear/enable it */
            GPIO_IntConfig(
                ACCEL_INT1_PORT,
                ACCEL_INT1_PIN,
                true,
                false,
                true);
            GPIO_IntConfig(
                ACCEL_INT2_PORT,
                ACCEL_INT2_PIN,
                true,
                false,
                true);
            if (((rt_uint8_t)ACCEL_INT1_PORT % 2) || \
                ((rt_uint8_t)ACCEL_INT2_PORT % 2))
            {
                NVIC_ClearPendingIRQ(GPIO_ODD_IRQn);
                NVIC_SetPriority(GPIO_ODD_IRQn, EFM32_IRQ_PRI_DEFAULT);
                NVIC_EnableIRQ(GPIO_ODD_IRQn);
            }
            if (!((rt_uint8_t)ACCEL_INT1_PORT % 2) || \
                !((rt_uint8_t)ACCEL_INT2_PORT % 2))
            {
                NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn);
                NVIC_SetPriority(GPIO_EVEN_IRQn, EFM32_IRQ_PRI_DEFAULT);
                NVIC_EnableIRQ(GPIO_EVEN_IRQn);
            }

            /* Reset the interrupt flags: Part 2 */
            buf[0] = INTRST;
            buf[1] = 0x00;
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, (void *)buf, 2) == 0)
            {
                ret = -RT_ERROR;
                break;
            }
        }
    } while (0);

    return ret;
}

#endif

/***************************************************************************//**
 * @brief
 *   Accelerometer auto-zero calibration function
 *
 * @details
 *
 * @note
 *
 * @param[in] mode
 *  0, simple mode (assuming the device is placed on flat surface)
 *  1, interaction method
 *
 * @param[in] period
 *  Time period to perform auto-zero calibration
 *
 * @return
 *   Error code
 ******************************************************************************/
rt_err_t efm_accel_auto_zero(rt_uint8_t mode, rt_tick_t period)
{
    RT_ASSERT(accel != RT_NULL);

    rt_timer_t calTimer;
    struct efm32_accel_result_t min = {0, 0, 0};
    struct efm32_accel_result_t max = {0, 0, 0};
    struct efm32_accel_result_t temp, sum;
    rt_int32_t simpleOffset[] = ACCEL_CAL_1G_VALUE;
    rt_uint8_t cmd[7] = {0};
    rt_uint8_t i, j;

    /* Reset offset */
#if (EFM32_USING_ACCEL == EFM32_INTERFACE_ADC)
    accelOffset.x = 0;
    accelOffset.y = 0;
    accelOffset.z = 0;

#elif (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
    cmd[0] = XOFFL;
    if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, cmd, sizeof(cmd)) == 0)
    {
        return -RT_ERROR;
    }
#endif

    if (mode == ACCEL_CAL_SIMPLE)
    {
        /* Simple mode */
        for (j = 0; j < ACCEL_CAL_ROUND; j++)
        {
            sum.x = 0x0;
            sum.y = 0x0;
            sum.z = 0x0;

            for (i = 0; i < ACCEL_CAL_SAMPLES; i++)
            {
#if (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
                /* Waiting for data ready */
                while(!GPIO_PinInGet(ACCEL_INT1_PORT, ACCEL_INT1_PIN));
#endif
                if (efm_accel_get_data(&temp, false) != RT_EOK)
                {
                    return -RT_ERROR;
                }
                sum.x += temp.x;
                sum.y += temp.y;
                sum.z += temp.z;
            }

#if (EFM32_USING_ACCEL == EFM32_INTERFACE_ADC)
            temp.x = sum.x / ACCEL_CAL_SAMPLES;
            temp.y = sum.y / ACCEL_CAL_SAMPLES;
            temp.z = sum.z / ACCEL_CAL_SAMPLES - simpleOffset[ACCEL_G_SELECT];
            if ((temp.x == 0) && (temp.y == 0) && \
                (temp.z == 0))
            {
                accel_debug("Accel: Offset %+d %+d %+d\n",
                    accelOffset.x, accelOffset.y, accelOffset.z);
                break;
            }
            accelOffset.x -= temp.x;
            accelOffset.y -= temp.y;
            accelOffset.z -= temp.z;

#elif (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
            temp.x = sum.x / (ACCEL_CAL_SAMPLES >> 1);
            temp.y = sum.y / (ACCEL_CAL_SAMPLES >> 1);
            temp.z = sum.z / (ACCEL_CAL_SAMPLES >> 1) \
                - (simpleOffset[ACCEL_G_SELECT] << 1);
            if ((temp.x == 0) && (temp.y == 0) && \
                (temp.z == 0))
            {
                break;
            }

            /* Set offset drift registers */
            max.x -= temp.x;
            max.y -= temp.y;
            max.z -= temp.z;
            *(rt_int16_t *)&cmd[1] = (rt_int16_t)max.x;
            *(rt_int16_t *)&cmd[3] = (rt_int16_t)max.y;
            *(rt_int16_t *)&cmd[5] = (rt_int16_t)max.z;
            if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, cmd, sizeof(cmd)) == 0)
            {
                return -RT_ERROR;
            }
            accel_debug("Accel: Offset %+d %+d %+d\n", *(rt_int16_t *)&cmd[1], \
                *(rt_int16_t *)&cmd[3], *(rt_int16_t *)&cmd[5]);
#endif
            rt_thread_sleep(1);
        }
    }
    else
    {
        /* Interact mode */
        if ((calTimer = rt_timer_create(
            "cal_tmr",
            efm_accel_timer,
            RT_NULL,
            period,
            RT_TIMER_FLAG_ONE_SHOT)) == RT_NULL)
        {
            accel_debug("Accel err: Create timer failed!\n");
            return -RT_ERROR;
        }

        accelInTime = true;
        rt_timer_start(calTimer);
        do
        {
            sum.x = 0x0;
            sum.y = 0x0;
            sum.z = 0x0;

            for (i = 0; i < ACCEL_CAL_SAMPLES; i++)
            {
#if (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
                /* Waiting for data ready */
                while(!GPIO_PinInGet(ACCEL_INT1_PORT, ACCEL_INT1_PIN));
#endif
                if (efm_accel_get_data(&temp, false) != RT_EOK)
                {
                    return -RT_ERROR;
                }
                sum.x += temp.x;
                sum.y += temp.y;
                sum.z += temp.z;
            }
            sum.x /= ACCEL_CAL_SAMPLES;
            sum.y /= ACCEL_CAL_SAMPLES;
            sum.z /= ACCEL_CAL_SAMPLES;
            if (sum.x < min.x)
            {
                min.x = sum.x;
            }
            if (sum.y < min.y)
            {
                min.y = sum.y;
            }
            if (sum.z < min.z)
            {
                min.z = sum.z;
            }
            if (sum.x > max.x)
            {
                max.x = sum.x;
            }
            if (sum.y > max.y)
            {
                max.y = sum.y;
            }
            if (sum.z > max.z)
            {
                max.z = sum.z;
            }
            rt_thread_sleep(1);
        } while (accelInTime);

        accel_debug("Accel: Min %+d %+d %+d, max %+d %+d %+d\n",
            min.x, min.y, min.z, max.x, max.y, max.z);

#if (EFM32_USING_ACCEL == EFM32_INTERFACE_ADC)
        accelOffset.x = -((min.x + max.x) >> 1);
        accelOffset.y = -((min.y + max.y) >> 1);
        accelOffset.z = -((min.z + max.z) >> 1);

    accel_debug("Accel: Offset %+d %+d %+d\n",
        accelOffset.x, accelOffset.y, accelOffset.z);

#elif (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
        /* Set offset drift registers */
        *(rt_int16_t *)&cmd[1] = (rt_int16_t)-(min.x + max.x);
        *(rt_int16_t *)&cmd[3] = (rt_int16_t)-(min.y + max.y);
        *(rt_int16_t *)&cmd[5] = (rt_int16_t)-(min.z + max.z);
        if (accel->write(accel, ACCEL_IIC_SLAVE_ADDRESS, cmd, sizeof(cmd)) == 0)
        {
            return -RT_ERROR;
        }

    accel_debug("Accel: Offset %+d %+d %+d\n",
        *(rt_int16_t *)&cmd[1], *(rt_int16_t *)&cmd[3], *(rt_int16_t *)&cmd[5]);
#endif

        rt_timer_delete(calTimer);
    }

    return RT_EOK;
}

/***************************************************************************//**
 * @brief
 *   Initialize the accelerometer
 *
 * @details
 *
 * @note
 *
 * @return
 *   Error code
 ******************************************************************************/
rt_err_t efm_accel_init(void)
{
    rt_err_t ret;

    ret = RT_EOK;
    do
    {
        /* Find ADC device */
        accel = rt_device_find(ACCEL_USING_DEVICE_NAME);
        if (accel == RT_NULL)
        {
            accel_debug("Accel err: Can't find device: %s!\n", ACCEL_USING_DEVICE_NAME);
            ret = -RT_ERROR;
            break;
        }
        accel_debug("Accel: Find device %s\n", ACCEL_USING_DEVICE_NAME);

        /* --------- ADC interface --------- */
#if (EFM32_USING_ACCEL == EFM32_INTERFACE_ADC)
        ADC_InitScan_TypeDef scanInit = ADC_INITSCAN_DEFAULT;

 #if defined(EFM32_GXXX_DK)
        /* Enable accelerometer */
        DVK_enablePeripheral(DVK_ACCEL);
            /* Select g-range */
  #if (ACCEL_G_SELECT == 0)
        DVK_disablePeripheral(DVK_ACCEL_GSEL);
  #elif (ACCEL_G_SELECT == 1)
        DVK_enablePeripheral(DVK_ACCEL_GSEL);
  #else
  #error "Wrong value for ACCEL_G_SELECT"
  #endif
 #endif
        /* Init ADC for scan mode */
        scanInit.reference = adcRefVDD;
        scanInit.input = ACCEL_X_ADC_CH | ACCEL_Y_ADC_CH | ACCEL_Z_ADC_CH;

        control.scan.init = &scanInit;
        if ((ret = accel->control(accel, RT_DEVICE_CTRL_ADC_MODE, \
            (void *)&control)) != RT_EOK)
        {
            break;
        }

        /* --------- IIC interface --------- */
#elif (EFM32_USING_ACCEL == EFM32_INTERFACE_IIC)
        rt_uint8_t cmd[2];

        /* Initialize */
        if ((ret = accel->control(accel, RT_DEVICE_CTRL_IIC_SETTING, \
            (void *)&control)) != RT_EOK)
        {
            break;
        }

        if (efm_accel_config(
            ACCEL_MODE_MEASUREMENT | ACCEL_RANGE_2G,
            EFM32_NO_DATA,
            EFM32_NO_DATA,
            EFM32_NO_DATA,
            EFM32_NO_DATA,
            EFM32_NO_DATA) != RT_EOK)
        {
            break;
        }

        /* Config interrupt pin1 */
        GPIO_PinModeSet(ACCEL_INT1_PORT, ACCEL_INT1_PIN, gpioModeInput, 0);
        /* Config interrupt pin2 */
        GPIO_PinModeSet(ACCEL_INT2_PORT, ACCEL_INT2_PIN, gpioModeInput, 0);
#endif

        accel_debug("Accel: Init OK\n");
        return RT_EOK;
    } while (0);

    accel_debug("Accel err: Init failed!\n");
    return -RT_ERROR;
}

/*******************************************************************************
 *  Export to FINSH
 ******************************************************************************/
#ifdef RT_USING_FINSH
#include <finsh.h>

void accel_cal(rt_uint8_t mode, rt_uint32_t second)
{
    if (efm_accel_auto_zero(mode, RT_TICK_PER_SECOND * second) != RT_EOK)
    {
        rt_kprintf("Error occurred.");
        return;
    }

    rt_kprintf("Calibration done.\n");
}
FINSH_FUNCTION_EXPORT(accel_cal, auto-zero calibration.)

void list_accel(void)
{
    struct efm32_accel_result_t data;

    efm_accel_get_data(&data, false);
    rt_kprintf("X: %d, Y: %d, Z: %d\n", data.x, data.y, data.z);
}
FINSH_FUNCTION_EXPORT(list_accel, list accelerometer info.)

void test_accel(rt_uint8_t mode)
{
    if (mode == 0)
    {
        if (efm_accel_config(
            ACCEL_MODE_LEVEL | ACCEL_RANGE_8G | ACCEL_INT_LEVEL_PULSE | \
            ACCEL_SOURCE_LEVEL_X | ACCEL_SOURCE_LEVEL_Y,
            0x1f,
            EFM32_NO_DATA,
            EFM32_NO_DATA,
            EFM32_NO_DATA,
            EFM32_NO_DATA) != RT_EOK)
        {
            rt_kprintf("efm_accel_config(): error\n");
            return;
        }
    }
    else
    {
        if (efm_accel_config(
            ACCEL_MODE_PULSE | ACCEL_RANGE_8G | ACCEL_INT_SINGLE_DOUBLE | \
            ACCEL_SOURCE_PULSE_X | ACCEL_SOURCE_PULSE_Y,
            0x1f,
            0x1f,
            200,
            255,
            255) != RT_EOK)
        {
            rt_kprintf("efm_accel_config(): error\n");
            return;
        }
    }
}
FINSH_FUNCTION_EXPORT(test_accel, list accelerometer info.)
#endif

#endif
/***************************************************************************//**
 * @}
 ******************************************************************************/