michaelh/zephyr
1
0
Fork 0
Code Releases Activity

sensor: add ms5607 sensor

Browse source 
Implement a driver for the te connectivity ms5607 pressure and
temperature sensor.

Signed-off-by: Thomas Schmid <tom@lfence.de>
This commit is contained in:
Thomas Schmid 2019-09-30 22:24:57 +02:00 • committed by Maureen Helm
commit 9a06428244
10 changed files with 719 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
drivers/sensor/CMakeLists.txt
View file

@ -44,6 +44,7 @@ add_subdirectory_ifdef(CONFIG_MAX30101 max30101)
add_subdirectory_ifdef(CONFIG_MAX44009 max44009)
add_subdirectory_ifdef(CONFIG_MCP9808 mcp9808)
add_subdirectory_ifdef(CONFIG_MPU6050 mpu6050)
add_subdirectory_ifdef(CONFIG_MS5607 ms5607)
add_subdirectory_ifdef(CONFIG_MS5837 ms5837)
add_subdirectory_ifdef(CONFIG_OPT3001 opt3001)
add_subdirectory_ifdef(CONFIG_PMS7003 pms7003)

2
drivers/sensor/Kconfig
View file

@ -112,6 +112,8 @@ source "drivers/sensor/mpu6050/Kconfig"
source "drivers/sensor/ms5837/Kconfig"
source "drivers/sensor/ms5607/Kconfig"
source "drivers/sensor/nrf5/Kconfig"
source "drivers/sensor/opt3001/Kconfig"

5
drivers/sensor/ms5607/CMakeLists.txt Normal file
View file

@ -0,0 +1,5 @@
# Copyright (c) 2019 Thomas Schmid <tom@lfence.de>
# SPDX-License-Identifier: Apache-2.0
zephyr_library_sources_ifdef(CONFIG_MS5607 ms5607.c)
zephyr_library_sources_ifdef(CONFIG_MS5607 ms5607_spi.c)

57
drivers/sensor/ms5607/Kconfig Normal file
View file

@ -0,0 +1,57 @@
# MS5607 pressure sensor configuration options
# Copyright (c) 2019 Thomas Schmid <tom@lfence.de>
# SPDX-License-Identifier: Apache-2.0
menuconfig MS5607
bool "MS5607 pressure and temperature sensor"
depends on SPI
help
Enable driver for MS5607 pressure and temperature sensor.
if MS5607
choice
prompt "Pressure oversampling."
default MS5607_PRES_OVER_2048X
config MS5607_PRES_OVER_256X
bool "x256"
config MS5607_PRES_OVER_512X
bool "x512"
config MS5607_PRES_OVER_1024X
bool "x1024"
config MS5607_PRES_OVER_2048X
bool "x2048"
config MS5607_PRES_OVER_4096X
bool "x4096"
endchoice
choice
prompt "Temperature oversampling."
default MS5607_TEMP_OVER_2048X
config MS5607_TEMP_OVER_256X
bool "x256"
config MS5607_TEMP_OVER_512X
bool "x512"
config MS5607_TEMP_OVER_1024X
bool "x1024"
config MS5607_TEMP_OVER_2048X
bool "x2048"
config MS5607_TEMP_OVER_4096X
bool "x4096"
endchoice
endif # MS5607

333
drivers/sensor/ms5607/ms5607.c Normal file
View file

@ -0,0 +1,333 @@
/*
* Copyright (c) 2019 Thomas Schmid <tom@lfence.de>
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <init.h>
#include <kernel.h>
#include <sys/byteorder.h>
#include <drivers/sensor.h>
#include <sys/__assert.h>
#include "ms5607.h"
#define LOG_LEVEL CONFIG_SENSOR_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(ms5607);
static void ms5607_compensate(struct ms5607_data *data,
const s32_t adc_temperature,
const s32_t adc_pressure)
{
s64_t dT;
s64_t OFF;
s64_t SENS;
s64_t temp_sq;
s64_t Ti;
s64_t OFFi;
s64_t SENSi;
/* first order compensation as per datasheet
* (https://www.te.com/usa-en/product-CAT-BLPS0035.html) section
* PRESSURE AND TEMPERATURE CALCULATION
*/
dT = adc_temperature - ((u32_t)(data->t_ref) << 8);
data->temperature = 2000 + (dT * data->tempsens) / (1ll << 23);
OFF = ((s64_t)(data->off_t1) << 17) + (dT * data->tco) / (1ll << 6);
SENS = ((s64_t)(data->sens_t1) << 16) + (dT * data->tcs) / (1ll << 7);
/* Second order compensation as per datasheet
* (https://www.te.com/usa-en/product-CAT-BLPS0035.html) section
* SECOND ORDER TEMPERATURE COMPENSATION
*/
temp_sq = (data->temperature - 2000) * (data->temperature - 2000);
if (data->temperature < 2000) {
Ti = (dT * dT) / (1ll << 31);
OFFi = (61ll * temp_sq) / (1ll << 4);
SENSi = 2ll * temp_sq;
if (data->temperature < -1500) {
temp_sq = (data->temperature + 1500) *
(data->temperature + 1500);
OFFi += 15ll * temp_sq;
SENSi += 8ll * temp_sq;
}
} else {
SENSi = 0;
OFFi = 0;
Ti = 0;
}
OFF -= OFFi;
SENS -= SENSi;
data->temperature -= Ti;
data->pressure = (SENS * (s64_t)adc_pressure / (1ll << 21) - OFF) /
(1ll << 15);
}
static int ms5607_read_prom(const struct ms5607_data *data, u8_t cmd,
u16_t *val)
{
int err;
err = data->tf->read_prom(data, cmd, val);
if (err < 0) {
LOG_ERR("Error reading prom");
return err;
}
return 0;
}
static int ms5607_get_measurement(const struct ms5607_data *data,
u32_t *val,
u8_t cmd,
u8_t delay)
{
int err;
*val = 0U;
err = data->tf->start_conversion(data, cmd);
if (err < 0) {
return err;
}
k_sleep(delay);
err = data->tf->read_adc(data, val);
if (err < 0) {
return err;
}
return 0;
}
static int ms5607_sample_fetch(struct device *dev, enum sensor_channel channel)
{
struct ms5607_data *data = dev->driver_data;
int err;
u32_t adc_pressure, adc_temperature;
__ASSERT_NO_MSG(channel == SENSOR_CHAN_ALL);
err = ms5607_get_measurement(data,
&adc_pressure,
data->pressure_conv_cmd,
data->pressure_conv_delay);
if (err < 0) {
return err;
}
err = ms5607_get_measurement(data,
&adc_temperature,
data->temperature_conv_cmd,
data->temperature_conv_delay);
if (err < 0) {
return err;
}
ms5607_compensate(data, adc_temperature, adc_pressure);
return 0;
}
static int ms5607_channel_get(struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct ms5607_data *data = dev->driver_data;
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
val->val1 = data->temperature / 100;
val->val2 = data->temperature % 100 * 10000;
break;
case SENSOR_CHAN_PRESS:
val->val1 = data->pressure / 100;
val->val2 = data->pressure % 100 * 10000;
break;
default:
return -EINVAL;
}
return 0;
}
static int ms5607_attr_set(struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct ms5607_data *data = dev->driver_data;
u8_t p_conv_cmd, t_conv_cmd, conv_delay;
if (attr != SENSOR_ATTR_OVERSAMPLING) {
return -ENOTSUP;
}
switch (val->val1) {
case 4096:
p_conv_cmd = MS5607_CMD_CONV_P_4096;
t_conv_cmd = MS5607_CMD_CONV_T_4096;
conv_delay = 9U;
break;
case 2048:
p_conv_cmd = MS5607_CMD_CONV_P_2048;
t_conv_cmd = MS5607_CMD_CONV_T_2048;
conv_delay = 5U;
break;
case 1024:
p_conv_cmd = MS5607_CMD_CONV_P_1024;
t_conv_cmd = MS5607_CMD_CONV_T_1024;
conv_delay = 3U;
break;
case 512:
p_conv_cmd = MS5607_CMD_CONV_P_512;
t_conv_cmd = MS5607_CMD_CONV_T_512;
conv_delay = 2U;
break;
case 256:
p_conv_cmd = MS5607_CMD_CONV_P_256;
t_conv_cmd = MS5607_CMD_CONV_T_256;
conv_delay = 1U;
break;
default:
LOG_ERR("invalid oversampling rate %d", val->val1);
return -EINVAL;
}
switch (chan) {
case SENSOR_CHAN_ALL:
data->pressure_conv_cmd = p_conv_cmd;
data->temperature_conv_cmd = t_conv_cmd;
data->temperature_conv_delay = conv_delay;
data->pressure_conv_delay = conv_delay;
break;
case SENSOR_CHAN_PRESS:
data->pressure_conv_cmd = p_conv_cmd;
data->pressure_conv_delay = conv_delay;
break;
case SENSOR_CHAN_AMBIENT_TEMP:
data->temperature_conv_cmd = t_conv_cmd;
data->temperature_conv_delay = conv_delay;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct ms5607_config ms5607_config = {
.ms5607_device_name = DT_INST_0_MEAS_MS5607_BUS_NAME,
};
static int ms5607_init(struct device *dev)
{
const struct ms5607_config *const config = dev->config->config_info;
struct ms5607_data *data = dev->driver_data;
struct sensor_value val;
int err;
data->ms5607_device = device_get_binding(config->ms5607_device_name);
if (!data->ms5607_device) {
LOG_ERR("master not found: %s", config->ms5607_device_name);
return -EINVAL;
}
#ifdef DT_MEAS_MS5607_BUS_SPI
ms5607_spi_init(dev);
#else
BUILD_ASSERT_MSG(1, "I2c interface not implemented yet");
#endif
data->pressure = 0;
data->temperature = 0;
val.val1 = MS5607_PRES_OVER_DEFAULT;
err = ms5607_attr_set(dev, SENSOR_CHAN_PRESS, SENSOR_ATTR_OVERSAMPLING,
&val);
if (err < 0) {
return err;
}
val.val1 = MS5607_TEMP_OVER_DEFAULT;
err = ms5607_attr_set(dev, SENSOR_CHAN_AMBIENT_TEMP,
SENSOR_ATTR_OVERSAMPLING, &val);
if (err < 0) {
return err;
}
err = data->tf->reset(data);
if (err < 0) {
return err;
}
k_sleep(K_MSEC(2));
err = ms5607_read_prom(data, MS5607_CMD_CONV_READ_OFF_T1,
&data->off_t1);
if (err < 0) {
return err;
}
LOG_DBG("OFF_T1: %d", data->off_t1);
err = ms5607_read_prom(data, MS5607_CMD_CONV_READ_SENSE_T1,
&data->sens_t1);
if (err < 0) {
return err;
}
LOG_DBG("SENSE_T1: %d", data->sens_t1);
err = ms5607_read_prom(data, MS5607_CMD_CONV_READ_T_REF, &data->t_ref);
if (err < 0) {
return err;
}
LOG_DBG("T_REF: %d", data->t_ref);
err = ms5607_read_prom(data, MS5607_CMD_CONV_READ_TCO, &data->tco);
if (err < 0) {
return err;
}
LOG_DBG("TCO: %d", data->tco);
err = ms5607_read_prom(data, MS5607_CMD_CONV_READ_TCS, &data->tcs);
if (err < 0) {
return err;
}
LOG_DBG("TCS: %d", data->tcs);
err = ms5607_read_prom(data, MS5607_CMD_CONV_READ_TEMPSENS,
&data->tempsens);
if (err < 0) {
return err;
}
LOG_DBG("TEMPSENS: %d", data->tempsens);
return 0;
}
static const struct sensor_driver_api ms5607_api_funcs = {
.attr_set = ms5607_attr_set,
.sample_fetch = ms5607_sample_fetch,
.channel_get = ms5607_channel_get,
};
static struct ms5607_data ms5607_data;
DEVICE_AND_API_INIT(ms5607,
DT_INST_0_MEAS_MS5607_LABEL,
ms5607_init,
&ms5607_data,
&ms5607_config,
POST_KERNEL,
CONFIG_SENSOR_INIT_PRIORITY,
&ms5607_api_funcs);

105
drivers/sensor/ms5607/ms5607.h Normal file
View file

@ -0,0 +1,105 @@
/*
* Copyright (c) 2019 Thomas Schmid <tom@lfence.de>
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef __SENSOR_MS5607_H__
#define __SENSOR_MS5607_H__
#include <zephyr/types.h>
#include <device.h>
#define MS5607_CMD_RESET 0x1E
#define MS5607_CMD_CONV_P_256 0x40
#define MS5607_CMD_CONV_P_512 0x42
#define MS5607_CMD_CONV_P_1024 0x44
#define MS5607_CMD_CONV_P_2048 0x46
#define MS5607_CMD_CONV_P_4096 0x48
#define MS5607_CMD_CONV_T_256 0x50
#define MS5607_CMD_CONV_T_512 0x52
#define MS5607_CMD_CONV_T_1024 0x54
#define MS5607_CMD_CONV_T_2048 0x56
#define MS5607_CMD_CONV_T_4096 0x58
#define MS5607_CMD_CONV_READ_ADC 0x00
#define MS5607_CMD_CONV_READ_SENSE_T1 0xA2
#define MS5607_CMD_CONV_READ_OFF_T1 0xA4
#define MS5607_CMD_CONV_READ_TCS 0xA6
#define MS5607_CMD_CONV_READ_TCO 0xA8
#define MS5607_CMD_CONV_READ_T_REF 0xAA
#define MS5607_CMD_CONV_READ_TEMPSENS 0xAC
#define MS5607_CMD_CONV_READ_CRC 0xAE
#if defined(CONFIG_MS5607_PRES_OVER_256X)
#define MS5607_PRES_OVER_DEFAULT 256
#elif defined(CONFIG_MS5607_PRES_OVER_512X)
#define MS5607_PRES_OVER_DEFAULT 512
#elif defined(CONFIG_MS5607_PRES_OVER_1024X)
#define MS5607_PRES_OVER_DEFAULT 1024
#elif defined(CONFIG_MS5607_PRES_OVER_2048X)
#define MS5607_PRES_OVER_DEFAULT 2048
#elif defined(CONFIG_MS5607_PRES_OVER_4096X)
#define MS5607_PRES_OVER_DEFAULT 4096
#else
#define MS5607_PRES_OVER_DEFAULT 2048
#endif
#if defined(CONFIG_MS5607_TEMP_OVER_256X)
#define MS5607_TEMP_OVER_DEFAULT 256
#elif defined(CONFIG_MS5607_TEMP_OVER_512X)
#define MS5607_TEMP_OVER_DEFAULT 512
#elif defined(CONFIG_MS5607_TEMP_OVER_1024X)
#define MS5607_TEMP_OVER_DEFAULT 1024
#elif defined(CONFIG_MS5607_TEMP_OVER_2048X)
#define MS5607_TEMP_OVER_DEFAULT 2048
#elif defined(CONFIG_MS5607_TEMP_OVER_4096X)
#define MS5607_TEMP_OVER_DEFAULT 4096
#else
#define MS5607_TEMP_OVER_DEFAULT 2048
#endif
#ifdef DT_MEAS_MS5607_BUS_SPI
int ms5607_spi_init(struct device *dev);
#else
/* I2c Interface not implemented yet */
BUILD_ASSERT_MSG(1, "I2c interface not implemented yet");
#endif
struct ms5607_config {
char *ms5607_device_name;
};
struct ms5607_data {
struct device *ms5607_device;
const struct ms5607_transfer_function *tf;
/* Calibration values */
u16_t sens_t1;
u16_t off_t1;
u16_t tcs;
u16_t tco;
u16_t t_ref;
u16_t tempsens;
/* Measured values */
s32_t pressure;
s32_t temperature;
/* conversion commands */
u8_t pressure_conv_cmd;
u8_t temperature_conv_cmd;
u8_t pressure_conv_delay;
u8_t temperature_conv_delay;
};
struct ms5607_transfer_function {
int (*reset)(const struct ms5607_data *data);
int (*read_prom)(const struct ms5607_data *data, u8_t cmd, u16_t *val);
int (*start_conversion)(const struct ms5607_data *data, u8_t cmd);
int (*read_adc)(const struct ms5607_data *data, u32_t *val);
};
#endif /* __SENSOR_MS607_H__*/

193
drivers/sensor/ms5607/ms5607_spi.c Normal file
View file

@ -0,0 +1,193 @@
/*
* Copyright (c) 2019 Thomas Schmid <tom@lfence.de>
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#include <drivers/spi.h>
#include <sys/byteorder.h>
#include "ms5607.h"
#define LOG_LEVEL CONFIG_SENSOR_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_DECLARE(ms5607);
#ifdef DT_MEAS_MS5607_BUS_SPI
#if defined(DT_INST_0_MEAS_MS5607_CS_GPIOS_CONTROLLER)
static struct spi_cs_control ms5607_cs_ctrl;
#endif
#define SPI_CS NULL
static struct spi_config ms5607_spi_conf = {
.frequency = DT_INST_0_MEAS_MS5607_SPI_MAX_FREQUENCY,
.operation = (SPI_OP_MODE_MASTER | SPI_WORD_SET(8) |
SPI_MODE_CPOL | SPI_MODE_CPHA |
SPI_TRANSFER_MSB |
SPI_LINES_SINGLE),
.slave = DT_INST_0_MEAS_MS5607_BASE_ADDRESS,
.cs = SPI_CS,
};
static int ms5607_spi_raw_cmd(const struct ms5607_data *data, u8_t cmd)
{
const struct spi_buf buf = {
.buf = &cmd,
.len = 1,
};
const struct spi_buf_set buf_set = {
.buffers = &buf,
.count = 1,
};
return spi_write(data->ms5607_device, &ms5607_spi_conf, &buf_set);
}
static int ms5607_spi_reset(const struct ms5607_data *data)
{
int err = ms5607_spi_raw_cmd(data, MS5607_CMD_RESET);
if (err < 0) {
return err;
}
k_sleep(K_MSEC(3));
return 0;
}
static int ms5607_spi_read_prom(const struct ms5607_data *data, u8_t cmd,
u16_t *val)
{
int err;
u8_t tx[3] = { cmd, 0, 0 };
const struct spi_buf tx_buf = {
.buf = tx,
.len = 3,
};
union {
struct {
u8_t pad;
u16_t prom_value;
} __packed;
u8_t rx[3];
} rx;
const struct spi_buf rx_buf = {
.buf = &rx,
.len = 3,
};
const struct spi_buf_set rx_buf_set = {
.buffers = &rx_buf,
.count = 1,
};
const struct spi_buf_set tx_buf_set = {
.buffers = &tx_buf,
.count = 1,
};
err = spi_transceive(data->ms5607_device,
&ms5607_spi_conf,
&tx_buf_set,
&rx_buf_set);
if (err < 0) {
return err;
}
*val = sys_be16_to_cpu(rx.prom_value);
return 0;
}
static int ms5607_spi_start_conversion(const struct ms5607_data *data, u8_t cmd)
{
return ms5607_spi_raw_cmd(data, cmd);
}
static int ms5607_spi_read_adc(const struct ms5607_data *data, u32_t *val)
{
int err;
u8_t tx[4] = { MS5607_CMD_CONV_READ_ADC, 0, 0, 0 };
const struct spi_buf tx_buf = {
.buf = tx,
.len = 4,
};
union {
struct {
u32_t adc_value;
} __packed;
u8_t rx[4];
} rx;
const struct spi_buf rx_buf = {
.buf = &rx,
.len = 4,
};
const struct spi_buf_set rx_buf_set = {
.buffers = &rx_buf,
.count = 1,
};
const struct spi_buf_set tx_buf_set = {
.buffers = &tx_buf,
.count = 1,
};
err = spi_transceive(data->ms5607_device,
&ms5607_spi_conf,
&tx_buf_set,
&rx_buf_set);
if (err < 0) {
return err;
}
rx.rx[0] = 0;
*val = sys_be32_to_cpu(rx.adc_value);
return 0;
}
static const struct ms5607_transfer_function ms5607_spi_transfer_function = {
.reset = ms5607_spi_reset,
.read_prom = ms5607_spi_read_prom,
.start_conversion = ms5607_spi_start_conversion,
.read_adc = ms5607_spi_read_adc,
};
int ms5607_spi_init(struct device *dev)
{
struct ms5607_data *data = dev->driver_data;
data->tf = &ms5607_spi_transfer_function;
#if defined(DT_INST_0_MEAS_MS5607_CS_GPIOS_CONTROLLER)
ms5607_cs_ctrl.gpio_dev = device_get_binding(
DT_INST_0_MEAS_MS5607_CS_GPIOS_CONTROLLER);
if (!ms5607_cs_ctrl.gpio_dev) {
LOG_ERR("Unable to get GPIO SPI CS device");
return -ENODEV;
}
ms5607_cs_ctrl.gpio_pin = DT_INST_0_MEAS_MS5607_CS_GPIOS_PIN;
ms5607_cs_ctrl.delay = 0U;
ms5607_spi_conf.cs = &ms5607_cs_ctrl;
LOG_DBG("SPI GPIO CS configured on %s:%u",
DT_INST_0_MEAS_MS5607_CS_GPIOS_CONTROLLER,
DT_INST_0_MEAS_MS5607_CS_GPIOS_PIN);
#endif
return 0;
}
#endif

12
dts/bindings/sensor/meas,ms5607-spi.yaml Normal file
View file

@ -0,0 +1,12 @@
# Copyright (c) 2019, Thomas Schmid <tom@lfence.de>
# SPDX-License-Identifier: Apache-2.0
title: TE Connectivity digital pressure sensor MS5607
description: |
TE Connectivity MS5607 digital pressure and temperature sensor.
The Datasheet is at https://www.te.com/usa-en/product-CAT-BLPS0035.html
compatible: "meas,ms5607"
include: spi-device.yaml

10
tests/drivers/build_all/dts_fixup.h
View file

@ -545,3 +545,13 @@
#define DT_INST_0_ATMEL_AT25_READ_ONLY 0
#define DT_INST_0_ATMEL_AT25_TIMEOUT 5
#endif
#ifndef DT_INST_0_MEAS_MS5607_LABEL
#define DT_INST_0_MEAS_MS5607_LABEL ""
#define DT_INST_0_MEAS_MS5607_BUS_NAME ""
#define DT_INST_0_MEAS_MS5607_CS_GPIOS_CONTROLLER 0
#define DT_INST_0_MEAS_MS5607_CS_GPIOS_PIN 0
#define DT_INST_0_MEAS_MS5607_BASE_ADDRESS 0
#define DT_INST_0_MEAS_MS5607_SPI_MAX_FREQUENCY 10000
#define DT_MEAS_MS5607_SPI 1
#endif

1
tests/drivers/build_all/sensors_i_z.conf
View file

@ -24,6 +24,7 @@ CONFIG_MAX30101=y
CONFIG_MAX44009=y
CONFIG_MCP9808=y
CONFIG_MPU6050=y
CONFIG_MS5607=y
CONFIG_OPT3001=y
CONFIG_SHT3XD=y
CONFIG_SI7006=y