michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: sensor: lsm303dlhc magnetometer driver

Browse source 
Enable magnetometer measurement

Signed-off-by: Philémon Jaermann <p.jaermann@gmail.com>
This commit is contained in:
Philémon Jaermann 2018-03-01 21:54:36 +01:00 • committed by Maureen Helm
commit 43bc39e140
6 changed files with 271 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

6
drivers/sensor/lsm303dlhc_magn/CMakeLists.txt Normal file
View file

@ -0,0 +1,6 @@
#
# Copyright (c) 2018 Philémon Jaermann
#
# SPDX-License-Identifier: Apache-2.0
zephyr_sources_ifdef(CONFIG_LSM303DLHC_MAGN lsm303dlhc_magn.c)

42
drivers/sensor/lsm303dlhc_magn/Kconfig Normal file
View file

@ -0,0 +1,42 @@
# Kconfig - LSM303DLHC Three Axis Magnetometer configuration options
#
# Copyright (c) 2018 Philémon Jaermann
#
# SPDX-License-Identifier: Apache-2.0
#
menuconfig LSM303DLHC_MAGN
bool "LSM303DLHC Three Axis Magnetometer"
depends on I2C
help
Enable driver for LSM303DLHC I2C-based triaxial magnetometer sensor.
config LSM303DLHC_MAGN_RANGE
int "Magnetometer measurement range"
depends on LSM303DLHC_MAGN
range 1 7
default 1
help
1: +/-1.3 gauss
2: +/-1.9 gauss
3: +/-2.5 gauss
4: +/-4 gauss
5: +/-4.7 gauss
6: +/-5.6 gauss
7: +/-8.1 gauss
config LSM303DLHC_MAGN_ODR
int "Data rate frequency"
depends on LSM303DLHC_MAGN
range 0 7
default 0
help
0: 0.75Hz
1: 1.5 Hz
2: 3Hz
3: 7.5Hz
4: 15Hz
5: 30Hz
6: 75Hz
7: 220Hz

141
drivers/sensor/lsm303dlhc_magn/lsm303dlhc_magn.c Normal file
View file

@ -0,0 +1,141 @@
/*
* Copyright (c) 2018 Philémon Jaermann
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <i2c.h>
#include <init.h>
#include <sensor.h>
#include <logging/sys_log.h>
#include "lsm303dlhc_magn.h"
static int lsm303dlhc_sample_fetch(struct device *dev,
enum sensor_channel chan)
{
const struct lsm303dlhc_magn_config *config = dev->config->config_info;
struct lsm303dlhc_magn_data *drv_data = dev->driver_data;
u8_t magn_buf[6];
u8_t status;
/* Check data ready flag */
if (i2c_reg_read_byte(drv_data->i2c,
config->i2c_address,
LSM303DLHC_SR_REG_M,
&status) < 0) {
SYS_LOG_ERR("Failed to read status register.");
return -EIO;
}
if (!(status & LSM303DLHC_MAGN_DRDY)) {
SYS_LOG_ERR("Sensor data not available.");
return -EIO;
}
if (i2c_burst_read(drv_data->i2c,
config->i2c_address,
LSM303DLHC_REG_MAGN_X_LSB,
magn_buf, 6) < 0) {
SYS_LOG_ERR("Could not read magn axis data.");
return -EIO;
}
drv_data->magn_x = (magn_buf[0] << 8) | magn_buf[1];
drv_data->magn_y = (magn_buf[4] << 8) | magn_buf[5];
drv_data->magn_z = (magn_buf[2] << 8) | magn_buf[3];
return 0;
}
static void lsm303dlhc_convert(struct sensor_value *val,
s64_t raw_val)
{
val->val1 = raw_val / LSM303DLHC_MAGN_LSB_GAUSS;
val->val2 = (1000000 * raw_val / LSM303DLHC_MAGN_LSB_GAUSS) % 1000000;
}
static int lsm303dlhc_channel_get(struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm303dlhc_magn_data *drv_data = dev->driver_data;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
lsm303dlhc_convert(val, drv_data->magn_x);
break;
case SENSOR_CHAN_MAGN_Y:
lsm303dlhc_convert(val, drv_data->magn_y);
break;
case SENSOR_CHAN_MAGN_Z:
lsm303dlhc_convert(val, drv_data->magn_z);
break;
case SENSOR_CHAN_MAGN_XYZ:
lsm303dlhc_convert(val, drv_data->magn_x);
lsm303dlhc_convert(val + 1, drv_data->magn_y);
lsm303dlhc_convert(val + 2, drv_data->magn_z);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lsm303dlhc_magn_driver_api = {
.sample_fetch = lsm303dlhc_sample_fetch,
.channel_get = lsm303dlhc_channel_get,
};
static int lsm303dlhc_magn_init(struct device *dev)
{
const struct lsm303dlhc_magn_config *config = dev->config->config_info;
struct lsm303dlhc_magn_data *drv_data = dev->driver_data;
drv_data->i2c = device_get_binding(config->i2c_name);
if (drv_data->i2c == NULL) {
SYS_LOG_ERR("Could not get pointer to %s device",
config->i2c_name);
return -ENODEV;
}
/* Set magnetometer output data rate */
if (i2c_reg_write_byte(drv_data->i2c,
config->i2c_address,
LSM303DLHC_CRA_REG_M,
LSM303DLHC_MAGN_ODR_BITS) < 0) {
SYS_LOG_ERR("Failed to configure chip.");
return -EIO;
}
/* Set magnetometer full scale range */
if (i2c_reg_write_byte(drv_data->i2c,
config->i2c_address,
LSM303DLHC_CRB_REG_M,
LSM303DLHC_MAGN_FS_BITS) < 0) {
SYS_LOG_ERR("Failed to set magnetometer full scale range.");
return -EIO;
}
/* Continuous update */
if (i2c_reg_write_byte(drv_data->i2c,
config->i2c_address,
LSM303DLHC_MR_REG_M,
LSM303DLHC_MAGN_CONT_UPDATE) < 0) {
SYS_LOG_ERR("Failed to enable continuous data update.");
return -EIO;
}
return 0;
}
static const struct lsm303dlhc_magn_config lsm303dlhc_magn_config = {
.i2c_name = CONFIG_LSM303DLHC_MAGN_I2C_MASTER_DEV,
.i2c_address = CONFIG_LSM303DLHC_MAGN_I2C_ADDR,
};
static struct lsm303dlhc_magn_data lsm303dlhc_magn_driver;
DEVICE_AND_API_INIT(lsm303dlhc_magn, CONFIG_LSM303DLHC_MAGN_NAME,
lsm303dlhc_magn_init, &lsm303dlhc_magn_driver,
&lsm303dlhc_magn_config, POST_KERNEL,
CONFIG_SENSOR_INIT_PRIORITY, &lsm303dlhc_magn_driver_api);

79
drivers/sensor/lsm303dlhc_magn/lsm303dlhc_magn.h Normal file
View file

@ -0,0 +1,79 @@
/*
* Copyright (c) 2018 Philémon Jaermann
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef __SENSOR_LSM303DLHC_MAGN_
#define __SENSOR_LSM303DLHC_MAGN_
#define LSM303_DLHC_MAGN_X_EN_BIT BIT(0)
#define LSM303DLHC_MAGN_Y_EN_BIT BIT(1)
#define LSM303DLHC_MAGN_Z_EN_BIT BIT(2)
#define LSM303DLHC_MAGN_EN_BITS (LSM303_DLHC_MAGN_X_EN_BIT | \
LSM303DLHC_MAGN_Y_EN_BIT | \
LSM303DLHC_MAGN_Z_EN_BIT)
#if (CONFIG_LSM303DLHC_MAGN_ODR == 0)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 134
#elif (CONFIG_LSM303DLHC_MAGN_ODR == 1)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 67
#elif (CONFIG_LSM303DLHC_MAGN_ODR == 2)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 34
#elif (CONFIG_LSM303DLHC_MAGN_ODR == 3)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 14
#elif (CONFIG_LSM303DLHC_MAGN_ODR == 4)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 7
#elif (CONFIG_LSM303DLHC_MAGN_ODR == 5)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 4
#elif (CONFIG_LSM303DLHC_MAGN_ODR == 6)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 2
#elif (CONFIG_LSM303DLHC_MAGN_ODR == 7)
#define LSM303DLHC_MAGN_DRDY_WAIT_TIME 1
#endif
#define LSM303DLHC_MAGN_ODR_SHIFT 2
#define LSM303DLHC_MAGN_ODR_BITS (CONFIG_LSM303DLHC_MAGN_ODR << \
LSM303DLHC_MAGN_ODR_SHIFT)
#if (CONFIG_LSM303DLHC_MAGN_RANGE == 1)
#define LSM303DLHC_MAGN_LSB_GAUSS 1100
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 2)
#define LSM303DLHC_MAGN_LSB_GAUSS 760
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 3)
#define LSM303DLHC_MAGN_LSB_GAUSS 600
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 4)
#define LSM303DLHC_MAGN_LSB_GAUSS 400
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 5)
#define LSM303DLHC_MAGN_LSB_GAUSS 355
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 6)
#define LSM303DLHC_MAGN_LSB_GAUSS 295
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 7)
#define LSM303DLHC_MAGN_LSB_GAUSS 205
#endif
#define LSM303DLHC_MAGN_FS_SHIFT 5
#define LSM303DLHC_MAGN_FS_BITS (CONFIG_LSM303DLHC_MAGN_RANGE << \
LSM303DLHC_MAGN_FS_SHIFT)
#define LSM303DLHC_MAGN_CONT_UPDATE 0x00
#define LSM303DLHC_MAGN_DRDY BIT(0)
#define LSM303DLHC_CRA_REG_M 0x00
#define LSM303DLHC_CRB_REG_M 0x01
#define LSM303DLHC_MR_REG_M 0x02
#define LSM303DLHC_REG_MAGN_X_LSB 0x03
#define LSM303DLHC_SR_REG_M 0x09
struct lsm303dlhc_magn_data {
struct device *i2c;
s16_t magn_x;
s16_t magn_y;
s16_t magn_z;
};
struct lsm303dlhc_magn_config {
char *i2c_name;
u8_t i2c_address;
};
#endif /* _SENSOR_LSM303DLHC_MAGN_ */