text stringlengths 9 39.2M | dir stringlengths 25 226 | lang stringclasses 163 values | created_date timestamp[s] | updated_date timestamp[s] | repo_name stringclasses 751 values | repo_full_name stringclasses 752 values | star int64 1.01k 183k | len_tokens int64 1 18.5M |
|---|---|---|---|---|---|---|---|---|
```objective-c
/*
*
*/
#ifndef __SENSOR_MS5607_H__
#define __SENSOR_MS5607_H__
#include <zephyr/types.h>
#include <zephyr/device.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#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
/* Forward declaration */
struct ms5607_config;
struct ms5607_transfer_function {
int (*bus_check)(const struct ms5607_config *cfg);
int (*reset)(const struct ms5607_config *cfg);
int (*read_prom)(const struct ms5607_config *cfg, uint8_t cmd, uint16_t *val);
int (*start_conversion)(const struct ms5607_config *cfg, uint8_t cmd);
int (*read_adc)(const struct ms5607_config *cfg, uint32_t *val);
};
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
extern const struct ms5607_transfer_function ms5607_i2c_transfer_function;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
extern const struct ms5607_transfer_function ms5607_spi_transfer_function;
#endif
struct ms5607_config {
const struct ms5607_transfer_function *tf;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif
} bus_cfg;
};
struct ms5607_data {
/* Calibration values */
uint16_t sens_t1;
uint16_t off_t1;
uint16_t tcs;
uint16_t tco;
uint16_t t_ref;
uint16_t tempsens;
/* Measured values */
int32_t pressure;
int32_t temperature;
/* conversion commands */
uint8_t pressure_conv_cmd;
uint8_t temperature_conv_cmd;
uint8_t pressure_conv_delay;
uint8_t temperature_conv_delay;
};
#endif /* __SENSOR_MS607_H__*/
``` | /content/code_sandbox/drivers/sensor/meas/ms5607/ms5607.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,013 |
```c
/*
*
*/
#define DT_DRV_COMPAT meas_ms5607
#include <string.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include "ms5607.h"
#define LOG_LEVEL CONFIG_SENSOR_LOG_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ms5607);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
static int ms5607_i2c_raw_cmd(const struct ms5607_config *config, uint8_t cmd)
{
return i2c_write_dt(&config->bus_cfg.i2c, &cmd, 1);
}
static int ms5607_i2c_reset(const struct ms5607_config *config)
{
int err = ms5607_i2c_raw_cmd(config, MS5607_CMD_RESET);
if (err < 0) {
return err;
}
return 0;
}
static int ms5607_i2c_read_prom(const struct ms5607_config *config, uint8_t cmd,
uint16_t *val)
{
uint8_t valb[2];
int err;
err = i2c_burst_read_dt(&config->bus_cfg.i2c, cmd, valb, sizeof(valb));
if (err < 0) {
return err;
}
*val = sys_get_be16(valb);
return 0;
}
static int ms5607_i2c_start_conversion(const struct ms5607_config *config, uint8_t cmd)
{
return ms5607_i2c_raw_cmd(config, cmd);
}
static int ms5607_i2c_read_adc(const struct ms5607_config *config, uint32_t *val)
{
int err;
uint8_t valb[3];
err = i2c_burst_read_dt(&config->bus_cfg.i2c, MS5607_CMD_CONV_READ_ADC, valb, sizeof(valb));
if (err < 0) {
return err;
}
*val = (valb[0] << 16) + (valb[1] << 8) + valb[2];
return 0;
}
static int ms5607_i2c_check(const struct ms5607_config *config)
{
if (!device_is_ready(config->bus_cfg.i2c.bus)) {
LOG_DBG("I2C bus device not ready");
return -ENODEV;
}
return 0;
}
const struct ms5607_transfer_function ms5607_i2c_transfer_function = {
.bus_check = ms5607_i2c_check,
.reset = ms5607_i2c_reset,
.read_prom = ms5607_i2c_read_prom,
.start_conversion = ms5607_i2c_start_conversion,
.read_adc = ms5607_i2c_read_adc,
};
#endif
``` | /content/code_sandbox/drivers/sensor/meas/ms5607/ms5607_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 588 |
```unknown
# MS5607 pressure sensor configuration options
menuconfig MS5607
bool "MS5607 pressure and temperature sensor"
default y
depends on DT_HAS_MEAS_MS5607_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_MEAS_MS5607),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_MEAS_MS5607),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
``` | /content/code_sandbox/drivers/sensor/meas/ms5607/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 324 |
```c
/*
*
*/
#define DT_DRV_COMPAT meas_ms5607
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include "ms5607.h"
#define LOG_LEVEL CONFIG_SENSOR_LOG_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ms5607);
static void ms5607_compensate(struct ms5607_data *data,
const int32_t adc_temperature,
const int32_t adc_pressure)
{
int64_t dT;
int64_t OFF;
int64_t SENS;
int64_t temp_sq;
int64_t Ti;
int64_t OFFi;
int64_t SENSi;
/* first order compensation as per datasheet
* (path_to_url section
* PRESSURE AND TEMPERATURE CALCULATION
*/
dT = adc_temperature - ((int32_t)(data->t_ref) << 8);
data->temperature = 2000 + (dT * data->tempsens) / (1ll << 23);
OFF = ((int64_t)(data->off_t1) << 17) + (dT * data->tco) / (1ll << 6);
SENS = ((int64_t)(data->sens_t1) << 16) + (dT * data->tcs) / (1ll << 7);
/* Second order compensation as per datasheet
* (path_to_url section
* SECOND ORDER TEMPERATURE COMPENSATION
*/
temp_sq = (int64_t)(data->temperature - 2000) *
(int64_t)(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 = (int64_t)(data->temperature + 1500) *
(int64_t)(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 * (int64_t)adc_pressure / (1ll << 21) - OFF) /
(1ll << 15);
}
static int ms5607_read_prom(const struct ms5607_config *config, uint8_t cmd,
uint16_t *val)
{
int err;
err = config->tf->read_prom(config, cmd, val);
if (err < 0) {
LOG_ERR("Error reading prom");
return err;
}
return 0;
}
static int ms5607_get_measurement(const struct ms5607_config *config,
uint32_t *val,
uint8_t cmd,
uint8_t delay)
{
int err;
*val = 0U;
err = config->tf->start_conversion(config, cmd);
if (err < 0) {
return err;
}
k_msleep(delay);
err = config->tf->read_adc(config, val);
if (err < 0) {
return err;
}
return 0;
}
static int ms5607_sample_fetch(const struct device *dev,
enum sensor_channel channel)
{
const struct ms5607_config *config = dev->config;
struct ms5607_data *data = dev->data;
int err;
uint32_t adc_pressure, adc_temperature;
__ASSERT_NO_MSG(channel == SENSOR_CHAN_ALL);
err = ms5607_get_measurement(config,
&adc_pressure,
data->pressure_conv_cmd,
data->pressure_conv_delay);
if (err < 0) {
return err;
}
err = ms5607_get_measurement(config,
&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(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct ms5607_data *data = dev->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 -ENOTSUP;
}
return 0;
}
static int ms5607_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct ms5607_data *data = dev->data;
uint8_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 int ms5607_init(const struct device *dev)
{
const struct ms5607_config *const config = dev->config;
struct ms5607_data *data = dev->data;
struct sensor_value val;
int err;
err = config->tf->bus_check(config);
if (err < 0) {
return err;
}
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 = config->tf->reset(config);
if (err < 0) {
return err;
}
k_sleep(K_MSEC(2));
err = ms5607_read_prom(config, 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(config, 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(config, 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(config, MS5607_CMD_CONV_READ_TCO, &data->tco);
if (err < 0) {
return err;
}
LOG_DBG("TCO: %d", data->tco);
err = ms5607_read_prom(config, MS5607_CMD_CONV_READ_TCS, &data->tcs);
if (err < 0) {
return err;
}
LOG_DBG("TCS: %d", data->tcs);
err = ms5607_read_prom(config, 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,
};
#define MS5607_SPI_OPERATION (SPI_OP_MODE_MASTER | SPI_WORD_SET(8) | \
SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_TRANSFER_MSB)
/* Initializes a struct ms5607_config for an instance on a SPI bus. */
#define MS5607_CONFIG_SPI(inst) \
{ \
.tf = &ms5607_spi_transfer_function, \
.bus_cfg.spi = SPI_DT_SPEC_INST_GET(inst, \
MS5607_SPI_OPERATION, \
0), \
}
/* Initializes a struct ms5607_config for an instance on a I2C bus. */
#define MS5607_CONFIG_I2C(inst) \
{ \
.tf = &ms5607_i2c_transfer_function, \
.bus_cfg.i2c = I2C_DT_SPEC_INST_GET(inst), \
}
/*
* Main instantiation macro, which selects the correct bus-specific
* instantiation macros for the instance.
*/
#define MS5607_DEFINE(inst) \
static struct ms5607_data ms5607_data_##inst; \
static const struct ms5607_config ms5607_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(MS5607_CONFIG_SPI(inst)), \
(MS5607_CONFIG_I2C(inst))); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
ms5607_init, \
NULL, \
&ms5607_data_##inst, \
&ms5607_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&ms5607_api_funcs);
/* Create the struct device for every status "okay" node in the devicetree. */
DT_INST_FOREACH_STATUS_OKAY(MS5607_DEFINE)
``` | /content/code_sandbox/drivers/sensor/meas/ms5607/ms5607.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,560 |
```unknown
# LM77 temperature sensor configuration
#
menuconfig LM77
bool "LM77 Temperature Sensor"
default y
depends on DT_HAS_LM77_ENABLED
default $(dt_compat_enabled,lm77)
select I2C
help
Enable driver for the LM77 digital temperature sensor with 2-wire
interface.
config LM77_TRIGGER
bool "Trigger support"
depends on LM77
default y
help
Enable trigger support for the LM77 digital temperature sensor.
Trigger events are based on the LM77 INT signal (configured for event
interrupt mode). After a trigger event the LM77 temperature must be
read in order to reset and rearm the trigger.
if LM77_TRIGGER
config LM77_TRIGGER_THREAD_STACK_SIZE
int "Stack size for the trigger workqueue thread"
default 512
help
Size of the stack used for the internal trigger workqueue thread.
config LM77_TRIGGER_THREAD_PRIO
int "Priority for the trigger workqueue thread"
default 0
help
Priority level for the internal trigger workqueue thread.
endif # LM77_TRIGGER
``` | /content/code_sandbox/drivers/sensor/lm77/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 230 |
```unknown
# LM35 temperature sensor config
config LM35
bool "LM35 Temperature Sensor"
default y
depends on DT_HAS_LM35_ENABLED
select ADC
help
Enable the driver for the LM35 digital temperature Sensor
``` | /content/code_sandbox/drivers/sensor/lm35/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 49 |
```c
/*
*
*/
#define DT_DRV_COMPAT lm35
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#define LM35_GAIN ADC_GAIN_1
#define LM35_REF ADC_REF_INTERNAL
LOG_MODULE_REGISTER(LM35, CONFIG_SENSOR_LOG_LEVEL);
struct lm35_data {
uint16_t raw;
};
struct lm35_config {
const struct device *adc;
uint8_t adc_channel;
struct adc_sequence adc_seq;
struct adc_channel_cfg ch_cfg;
};
static int lm35_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
const struct lm35_config *cfg = dev->config;
return adc_read(cfg->adc, &cfg->adc_seq);
}
static int lm35_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
int err;
struct lm35_data *data = dev->data;
const struct lm35_config *cfg = dev->config;
int32_t mv = data->raw;
err = adc_raw_to_millivolts(adc_ref_internal(cfg->adc), cfg->ch_cfg.gain,
cfg->adc_seq.resolution, &mv);
if (err) {
return err;
}
/* LM35 computes linearly 10mV per 1 degree C */
val->val1 = mv / 10;
val->val2 = (mv % 10) * 100000;
return 0;
}
static const struct sensor_driver_api lm35_driver_api = {
.sample_fetch = lm35_sample_fetch,
.channel_get = lm35_channel_get,
};
static int lm35_init(const struct device *dev)
{
const struct lm35_config *cfg = dev->config;
if (!device_is_ready(cfg->adc)) {
LOG_ERR("ADC device is not ready.");
return -EINVAL;
}
adc_channel_setup(cfg->adc, &cfg->ch_cfg);
return 0;
}
#define LM35_INST(inst) \
static struct lm35_data lm35_data_##inst; \
\
static const struct lm35_config lm35_cfg_##inst = { \
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(inst)), \
.adc_channel = DT_INST_IO_CHANNELS_INPUT(inst), \
.adc_seq = \
{ \
.channels = BIT(DT_INST_IO_CHANNELS_INPUT(inst)), \
.buffer = &lm35_data_##inst.raw, \
.buffer_size = sizeof(lm35_data_##inst.raw), \
.resolution = DT_INST_PROP(inst, resolution), \
}, \
.ch_cfg = { \
.gain = LM35_GAIN, \
.reference = LM35_REF, \
.acquisition_time = ADC_ACQ_TIME_DEFAULT, \
.channel_id = DT_INST_IO_CHANNELS_INPUT(inst), \
}}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lm35_init, NULL, &lm35_data_##inst, &lm35_cfg_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &lm35_driver_api);
DT_INST_FOREACH_STATUS_OKAY(LM35_INST)
``` | /content/code_sandbox/drivers/sensor/lm35/lm35.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 763 |
```c
/*
*
*/
#define DT_DRV_COMPAT lm77
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
LOG_MODULE_REGISTER(lm77, CONFIG_SENSOR_LOG_LEVEL);
/*
* Only compile in trigger support if enabled in Kconfig and at least one
* enabled lm77 devicetree node has the int-gpios property.
*/
#define LM77_TRIGGER_SUPPORT \
(CONFIG_LM77_TRIGGER && DT_ANY_INST_HAS_PROP_STATUS_OKAY(int_gpios))
/* LM77 registers */
#define LM77_REG_TEMP 0x00U
#define LM77_REG_CONFIG 0x01U
#define LM77_REG_THYST 0x02U
#define LM77_REG_TCRIT 0x03U
#define LM77_REG_TLOW 0x04U
#define LM77_REG_THIGH 0x05U
/* LM77 configuration register bits */
union lm77_reg_config {
uint8_t reg;
struct {
uint8_t shutdown : 1;
uint8_t int_mode : 1;
uint8_t tcrita_pol : 1;
uint8_t int_pol : 1;
uint8_t fault_queue : 1;
uint8_t reserved : 3;
} __packed;
};
struct lm77_config {
struct i2c_dt_spec i2c;
union lm77_reg_config config_dt;
#if LM77_TRIGGER_SUPPORT
struct gpio_dt_spec int_gpio;
#endif /* LM77_TRIGGER_SUPPORT */
};
struct lm77_data {
int16_t temp;
#if LM77_TRIGGER_SUPPORT
const struct device *dev;
struct k_work_q workq;
struct k_work work;
struct gpio_callback int_gpio_cb;
const struct sensor_trigger *trigger;
sensor_trigger_handler_t trigger_handler;
K_KERNEL_STACK_MEMBER(stack, CONFIG_LM77_TRIGGER_THREAD_STACK_SIZE);
#endif /* LM77_TRIGGER_SUPPORT */
};
static int lm77_write_config(const struct device *dev, uint8_t value)
{
const struct lm77_config *config = dev->config;
uint8_t buf[2] = { LM77_REG_CONFIG, value };
return i2c_write_dt(&config->i2c, buf, sizeof(buf));
}
static int lm77_read_temp(const struct device *dev, uint8_t reg, int16_t *value)
{
const struct lm77_config *config = dev->config;
uint8_t buf[2];
int err;
err = i2c_write_read_dt(&config->i2c, ®, sizeof(reg), &buf, sizeof(buf));
if (err < 0) {
LOG_ERR("failed to read temperature register 0x%02x (err %d)", reg, err);
return err;
}
*value = sys_get_be16(buf);
return 0;
}
static int lm77_write_temp(const struct device *dev, uint8_t reg, int16_t value)
{
const struct lm77_config *config = dev->config;
uint8_t buf[3] = { reg, value >> 8, value };
return i2c_write_dt(&config->i2c, buf, sizeof(buf));
}
static void lm77_sensor_value_to_temp(const struct sensor_value *val, int16_t *temp)
{
/* Integer part in degrees Celsius (LSB = 0.5 degrees Celsius) */
*temp = val->val1 << 1;
/* Fractional part in micro degrees Celsius */
*temp += (val->val2 * 2) / 1000000;
/* Shift up to include "status" bits */
*temp <<= 3;
}
static void lm77_temp_to_sensor_value(int16_t temp, struct sensor_value *val)
{
/* Shift down to remove "status" bits (LSB = 0.5 degrees Celsius) */
temp = (temp >> 3) * 5;
/* Integer part in degrees Celsius */
val->val1 = temp / 10;
/* Fractional part in micro degrees Celsius */
val->val2 = temp % 10;
val->val2 *= 100000;
}
static int lm77_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
int16_t temp = 0;
uint8_t reg;
int err;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_LOWER_THRESH:
reg = LM77_REG_TLOW;
break;
case SENSOR_ATTR_UPPER_THRESH:
reg = LM77_REG_THIGH;
break;
case SENSOR_ATTR_ALERT:
reg = LM77_REG_TCRIT;
break;
case SENSOR_ATTR_HYSTERESIS:
reg = LM77_REG_THYST;
break;
default:
return -ENOTSUP;
}
lm77_sensor_value_to_temp(val, &temp);
err = lm77_write_temp(dev, reg, temp);
if (err < 0) {
LOG_ERR("failed to write register 0x%02x (err %d)", reg, err);
return err;
}
return 0;
}
static int lm77_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
int16_t temp;
uint8_t reg;
int err;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_LOWER_THRESH:
reg = LM77_REG_TLOW;
break;
case SENSOR_ATTR_UPPER_THRESH:
reg = LM77_REG_THIGH;
break;
case SENSOR_ATTR_ALERT:
reg = LM77_REG_TCRIT;
break;
case SENSOR_ATTR_HYSTERESIS:
reg = LM77_REG_THYST;
break;
default:
return -ENOTSUP;
}
err = lm77_read_temp(dev, reg, &temp);
if (err < 0) {
LOG_ERR("failed to read register 0x%02x (err %d)", reg, err);
return err;
}
lm77_temp_to_sensor_value(temp, val);
return 0;
}
#if LM77_TRIGGER_SUPPORT
static int lm77_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lm77_config *config = dev->config;
struct lm77_data *data = dev->data;
gpio_flags_t flags;
int err;
__ASSERT_NO_MSG(trig != NULL);
if (trig->type != SENSOR_TRIG_THRESHOLD || trig->chan != SENSOR_CHAN_AMBIENT_TEMP ||
config->int_gpio.port == NULL) {
return -ENOTSUP;
}
if (handler != NULL) {
flags = GPIO_INT_EDGE_TO_ACTIVE;
} else {
flags = GPIO_INT_DISABLE;
}
err = gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
if (err < 0) {
LOG_ERR("failed to configure INT GPIO IRQ (err %d)", err);
return err;
}
data->trigger = trig;
data->trigger_handler = handler;
return 0;
}
static void lm77_trigger_work_handler(struct k_work *item)
{
struct lm77_data *data = CONTAINER_OF(item, struct lm77_data, work);
sensor_trigger_handler_t handler = data->trigger_handler;
if (handler != NULL) {
handler(data->dev, (struct sensor_trigger *)data->trigger);
}
}
static void lm77_int_gpio_callback_handler(const struct device *port,
struct gpio_callback *cb,
gpio_port_pins_t pins)
{
struct lm77_data *data = CONTAINER_OF(cb, struct lm77_data, int_gpio_cb);
ARG_UNUSED(port);
ARG_UNUSED(pins);
k_work_submit_to_queue(&data->workq, &data->work);
}
#endif /* LM77_TRIGGER_SUPPORT */
static int lm77_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct lm77_data *data = dev->data;
int16_t temp;
int err;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
err = lm77_read_temp(dev, LM77_REG_TEMP, &temp);
if (err < 0) {
LOG_ERR("failed to read temperature (err %d)", err);
return err;
}
data->temp = temp;
return 0;
}
static int lm77_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct lm77_data *data = dev->data;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
lm77_temp_to_sensor_value(data->temp, val);
return 0;
}
static const struct sensor_driver_api lm77_driver_api = {
.attr_set = lm77_attr_set,
.attr_get = lm77_attr_get,
#if LM77_TRIGGER_SUPPORT
.trigger_set = lm77_trigger_set,
#endif /* LM77_TRIGGER_SUPPORT */
.sample_fetch = lm77_sample_fetch,
.channel_get = lm77_channel_get,
};
static int lm77_init(const struct device *dev)
{
const struct lm77_config *config = dev->config;
int err;
#if LM77_TRIGGER_SUPPORT
struct lm77_data *data = dev->data;
#endif /* LM77_TRIGGER_SUPPORT */
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2c bus not ready");
return -EINVAL;
}
err = lm77_write_config(dev, config->config_dt.reg);
if (err < 0) {
LOG_ERR("failed to write configuration (err %d)", err);
return err;
}
#if LM77_TRIGGER_SUPPORT
data->dev = dev;
k_work_queue_start(&data->workq, data->stack, K_THREAD_STACK_SIZEOF(data->stack),
CONFIG_LM77_TRIGGER_THREAD_PRIO, NULL);
k_thread_name_set(&data->workq.thread, "lm77_trigger");
k_work_init(&data->work, lm77_trigger_work_handler);
if (config->int_gpio.port != NULL) {
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("INT GPIO not ready");
return -EINVAL;
}
err = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
if (err < 0) {
LOG_ERR("failed to configure INT GPIO (err %d)", err);
return err;
}
gpio_init_callback(&data->int_gpio_cb, lm77_int_gpio_callback_handler,
BIT(config->int_gpio.pin));
err = gpio_add_callback(config->int_gpio.port, &data->int_gpio_cb);
if (err < 0) {
LOG_ERR("failed to add INT GPIO callback (err %d)", err);
return err;
}
}
#endif /* LM77_TRIGGER_SUPPORT */
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int lm77_pm_action(const struct device *dev,
enum pm_device_action action)
{
const struct lm77_config *config = dev->config;
union lm77_reg_config creg = config->config_dt;
int err;
switch (action) {
case PM_DEVICE_ACTION_SUSPEND:
creg.shutdown = 1;
break;
case PM_DEVICE_ACTION_RESUME:
creg.shutdown = 0;
break;
default:
return -ENOTSUP;
}
err = lm77_write_config(dev, creg.reg);
if (err < 0) {
LOG_ERR("failed to write configuration (err %d)", err);
return err;
}
return 0;
}
#endif /* CONFIG_PM_DEVICE */
#if LM77_TRIGGER_SUPPORT
#define LM77_INT_GPIO_INIT(n) .int_gpio = GPIO_DT_SPEC_INST_GET_OR(n, int_gpios, { 0 })
#else /* LM77_TRIGGER_SUPPORT */
#define LM77_INT_GPIO_INIT(n)
#endif /* ! LM77_TRIGGER_SUPPORT */
#define LM77_INIT(n) \
static struct lm77_data lm77_data_##n; \
\
static const struct lm77_config lm77_config_##n = { \
.i2c = I2C_DT_SPEC_INST_GET(n), \
.config_dt = { \
.shutdown = 0, \
.int_mode = DT_INST_NODE_HAS_PROP(n, int_gpios), \
.tcrita_pol = DT_INST_PROP(n, tcrita_inverted), \
.int_pol = DT_INST_PROP(n, int_inverted), \
.fault_queue = DT_INST_PROP(n, enable_fault_queue), \
.reserved = 0, \
}, \
LM77_INT_GPIO_INIT(n) \
}; \
\
PM_DEVICE_DT_INST_DEFINE(n, lm77_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, lm77_init, \
PM_DEVICE_DT_INST_GET(n), \
&lm77_data_##n, \
&lm77_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lm77_driver_api);
DT_INST_FOREACH_STATUS_OKAY(LM77_INIT)
``` | /content/code_sandbox/drivers/sensor/lm77/lm77.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,877 |
```unknown
# LTR-F216A light sensor configuration options
config LTR_F216A
bool "LiteOn LTR-F216A Light Sensor"
default y
depends on DT_HAS_LTR_F216A_ENABLED
select I2C
help
Enable driver for LiteOn LTR-F216A light sensors.
``` | /content/code_sandbox/drivers/sensor/ltrf216a/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 67 |
```c
/*
*
*/
#define DT_DRV_COMPAT ltr_f216a
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util_macro.h>
LOG_MODULE_REGISTER(ltrf216a, CONFIG_SENSOR_LOG_LEVEL);
/*
* Driver for I2C illuminance sensor LiteOn LTR-F216A.
*
* Datasheet:
* <path_to_url
* 7bit Address 0x53
* 8bit Address 0xA6 read
* 8bit Address 0xA7 write
* NOT IMPLEMENTED:
* - Interrupt
* - Modifying Gain (using default x3)
* - Modifying Resolution (using default 100ms)
* - Modifying Measurement Rate (using default 100ms)
* - Modifying Window Factor (using default 1)
*/
#define LTRF216A_ALS_RESET_MASK BIT(4)
#define LTRF216A_ALS_ENABLE_MASK BIT(1)
#define LTRF216A_ALS_DATA_STATUS BIT(3)
/* Part Number ID 7:4 0b1011 = 0xB */
/* Revision ID 3:0 0b0001 = 0x1*/
#define LTRF216A_PART_ID_VALUE 0xB1
#define LTRF216A_MAIN_CTRL 0x00
#define LTRF216A_ALS_MEAS_RES 0x04
#define LTRF216A_ALS_GAIN 0x05
#define LTRF216A_PART_ID 0x06
#define LTRF216A_MAIN_STATUS 0x07
#define LTRF216A_ALS_CLEAR_DATA_0 0x0a
#define LTRF216A_ALS_CLEAR_DATA_1 0x0b
#define LTRF216A_ALS_CLEAR_DATA_2 0x0c
#define LTRF216A_ALS_DATA_0 0x0d
#define LTRF216A_ALS_DATA_1 0x0e
#define LTRF216A_ALS_DATA_2 0x0f
#define LTRF216A_INT_CFG 0x19
#define LTRF216A_INT_PST 0x1a
#define LTRF216A_ALS_THRES_UP_0 0x21
#define LTRF216A_ALS_THRES_UP_1 0x22
#define LTRF216A_ALS_THRES_UP_2 0x23
#define LTRF216A_ALS_THRES_LOW_0 0x24
#define LTRF216A_ALS_THRES_LOW_1 0x25
#define LTRF216A_ALS_THRES_LOW_2 0x26
#define LTRF216A_WIN_FAC 1
#define LTRF216A_NUMBER_DATA_REGISTERS 3
struct ltrf216a_data {
uint8_t sample[3];
};
struct ltrf216a_config {
struct i2c_dt_spec i2c;
};
static int ltrf216a_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ltrf216a_data *drv_data = dev->data;
const struct ltrf216a_config *config = dev->config;
uint8_t status;
int result;
uint8_t value;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_LIGHT);
value = LTRF216A_ALS_ENABLE_MASK;
result = i2c_reg_write_byte_dt(&config->i2c, LTRF216A_MAIN_CTRL, LTRF216A_ALS_ENABLE_MASK);
if (result != 0) {
LOG_ERR("ltfr216a: enable failed");
return result;
}
result = i2c_reg_read_byte_dt(&config->i2c, LTRF216A_MAIN_STATUS, &status);
if (result != 0) {
LOG_ERR("ltfr216a: read main status failed");
return -EIO;
}
if ((status & LTRF216A_ALS_DATA_STATUS) == 0) {
LOG_WRN("ltfr216a: main status not ready");
return -EBUSY;
}
if (i2c_burst_read_dt(&config->i2c, LTRF216A_ALS_DATA_0, drv_data->sample,
LTRF216A_NUMBER_DATA_REGISTERS) != 0) {
LOG_ERR("ltfr216a: reading samples failed");
return -EIO;
}
return 0;
}
static int ltrf216a_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ltrf216a_data *drv_data = dev->data;
if (chan != SENSOR_CHAN_LIGHT) {
return -ENOTSUP;
}
uint32_t greendata = sys_get_le24(drv_data->sample);
/*
* 0.45 -> 45 / 100, multiplied by 1000000 for millilux
* gain 3 (default), integration time 100ms=1
*/
uint64_t microlux = ((uint64_t)greendata * 45000 * LTRF216A_WIN_FAC * 10) / (3 * 1);
val->val1 = microlux / 1000000;
val->val2 = microlux % 1000000;
return 0;
}
static const struct sensor_driver_api ltrf216a_driver_api = {
.sample_fetch = ltrf216a_sample_fetch,
.channel_get = ltrf216a_channel_get,
};
static int ltrf216a_chip_init(const struct device *dev)
{
const struct ltrf216a_config *config = dev->config;
uint8_t value;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
if (i2c_reg_read_byte_dt(&config->i2c, LTRF216A_PART_ID, &value) != 0) {
return -EIO;
}
if (value != LTRF216A_PART_ID_VALUE) {
LOG_ERR("Bad manufacturer id 0x%x", value);
return -ENOTSUP;
}
return 0;
}
#define LTRF216A_DEFINE(inst) \
static struct ltrf216a_data ltrf216a_data_##inst; \
\
static const struct ltrf216a_config ltrf216a_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, ltrf216a_chip_init, NULL, <rf216a_data_##inst, \
<rf216a_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, <rf216a_driver_api);
DT_INST_FOREACH_STATUS_OKAY(LTRF216A_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ltrf216a/ltrf216a.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,561 |
```c
/* sensor_sx9500.c - Driver for Semtech SX9500 SAR proximity chip */
/*
*
*/
#define DT_DRV_COMPAT semtech_sx9500
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "sx9500.h"
LOG_MODULE_REGISTER(SX9500, CONFIG_SENSOR_LOG_LEVEL);
static uint8_t sx9500_reg_defaults[] = {
/*
* First number is register address to write to. The chip
* auto-increments the address for subsequent values in a single
* write message.
*/
SX9500_REG_PROX_CTRL1,
0x43, /* Shield enabled, small range. */
0x77, /* x8 gain, 167kHz frequency, finest resolution. */
0x40, /* Doze enabled, 2x scan period doze, no raw filter. */
0x30, /* Average threshold. */
0x0f, /* Debouncer off, lowest average negative filter,
* highest average positive filter.
*/
0x0e, /* Proximity detection threshold: 280 */
0x00, /* No automatic compensation, compensate each pin
* independently, proximity hysteresis: 32, close
* debouncer off, far debouncer off.
*/
0x00, /* No stuck timeout, no periodic compensation. */
};
static int sx9500_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct sx9500_data *data = dev->data;
const struct sx9500_config *cfg = dev->config;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_PROX);
return i2c_reg_read_byte_dt(&cfg->i2c, SX9500_REG_STAT, &data->prox_stat);
}
static int sx9500_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct sx9500_data *data = (struct sx9500_data *) dev->data;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_PROX);
if (chan != SENSOR_CHAN_PROX) {
return -ENOTSUP;
}
val->val1 = !!(data->prox_stat &
(1 << (4 + CONFIG_SX9500_PROX_CHANNEL)));
val->val2 = 0;
return 0;
}
static const struct sensor_driver_api sx9500_api_funcs = {
.sample_fetch = sx9500_sample_fetch,
.channel_get = sx9500_channel_get,
#ifdef CONFIG_SX9500_TRIGGER
.trigger_set = sx9500_trigger_set,
#endif
};
static int sx9500_init_chip(const struct device *dev)
{
const struct sx9500_config *cfg = dev->config;
uint8_t val;
if (i2c_write_dt(&cfg->i2c, sx9500_reg_defaults,
sizeof(sx9500_reg_defaults))
< 0) {
return -EIO;
}
/* No interrupts active. We only activate them when an
* application registers a trigger.
*/
if (i2c_reg_write_byte_dt(&cfg->i2c, SX9500_REG_IRQ_MSK, 0) < 0) {
return -EIO;
}
/* Read irq source reg to clear reset status. */
if (i2c_reg_read_byte_dt(&cfg->i2c, SX9500_REG_IRQ_SRC, &val) < 0) {
return -EIO;
}
return i2c_reg_write_byte_dt(&cfg->i2c, SX9500_REG_PROX_CTRL0,
1 << CONFIG_SX9500_PROX_CHANNEL);
}
int sx9500_init(const struct device *dev)
{
const struct sx9500_config *cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
if (sx9500_init_chip(dev) < 0) {
LOG_DBG("sx9500: failed to initialize chip");
return -EINVAL;
}
#ifdef CONFIG_SX9500_TRIGGER
if (cfg->int_gpio.port) {
if (sx9500_setup_interrupt(dev) < 0) {
LOG_DBG("sx9500: failed to setup interrupt");
return -EINVAL;
}
}
#endif
return 0;
}
#define SX9500_DEFINE(inst) \
struct sx9500_data sx9500_data_##inst; \
\
static const struct sx9500_config sx9500_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_SX9500_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, sx9500_init, NULL, \
&sx9500_data_##inst, &sx9500_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &sx9500_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(SX9500_DEFINE)
``` | /content/code_sandbox/drivers/sensor/sx9500/sx9500.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,177 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SX9500_SX9500_H_
#define ZEPHYR_DRIVERS_SENSOR_SX9500_SX9500_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#define SX9500_REG_IRQ_SRC 0x00
#define SX9500_REG_STAT 0x01
#define SX9500_REG_IRQ_MSK 0x03
#define SX9500_REG_PROX_CTRL0 0x06
#define SX9500_REG_PROX_CTRL1 0x07
/* These are used both in the IRQ_SRC register, to identify which
* interrupt occur, and in the IRQ_MSK register, to enable specific
* interrupts.
*/
#define SX9500_CONV_DONE_IRQ (1 << 3)
#define SX9500_NEAR_FAR_IRQ ((1 << 5) | (1 << 6))
struct sx9500_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_SX9500_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
struct sx9500_data {
uint8_t prox_stat;
struct gpio_callback gpio_cb;
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
struct k_sem sem;
#endif
#ifdef CONFIG_SX9500_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
#ifdef CONFIG_SX9500_TRIGGER
const struct device *dev;
const struct sensor_trigger *trigger_drdy;
const struct sensor_trigger *trigger_near_far;
sensor_trigger_handler_t handler_drdy;
sensor_trigger_handler_t handler_near_far;
#endif
};
#ifdef CONFIG_SX9500_TRIGGER
int sx9500_setup_interrupt(const struct device *dev);
int sx9500_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#else
static inline int sx9500_setup_interrupt(const struct device *dev)
{
return 0;
}
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_SX9500_SX9500_H_ */
``` | /content/code_sandbox/drivers/sensor/sx9500/sx9500.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 440 |
```unknown
# SX9500 SAR proximity sensor configuration options
menuconfig SX9500
bool "SX9500 I2C SAR Proximity Chip"
default y
depends on DT_HAS_SEMTECH_SX9500_ENABLED
select I2C
help
Enable driver for SX9500 I2C-based SAR proximity sensor.
if SX9500
config SX9500_PROX_CHANNEL
int "Proximity channel to use"
default 3
help
The SX9500 offers 4 separate proximity channels. Choose which one
you are using. Valid numbers are 0 to 3.
choice
prompt "SX9500 trigger mode"
default SX9500_TRIGGER_GLOBAL_THREAD
config SX9500_TRIGGER_NONE
bool "No trigger"
config SX9500_TRIGGER_GLOBAL_THREAD
depends on GPIO
select SX9500_TRIGGER
bool "Use global thread"
config SX9500_TRIGGER_OWN_THREAD
depends on GPIO
select SX9500_TRIGGER
bool "Use own thread"
endchoice
config SX9500_TRIGGER
bool
config SX9500_THREAD_STACK_SIZE
int "Sensor delayed work thread stack size"
depends on SX9500_TRIGGER_OWN_THREAD
default 1024
config SX9500_THREAD_PRIORITY
int "Thread priority"
depends on SX9500_TRIGGER_OWN_THREAD
default 10
endif # SX9500
``` | /content/code_sandbox/drivers/sensor/sx9500/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 288 |
```c
/*
*
*/
#define DT_DRV_COMPAT sciosense_ens160
#include <zephyr/drivers/spi.h>
#include "ens160.h"
LOG_MODULE_DECLARE(ENS160, CONFIG_SENSOR_LOG_LEVEL);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define ENS160_SPI_READ_BIT BIT(0)
static int ens160_read_reg_spi(const struct device *dev, uint8_t reg, uint8_t *val)
{
const struct ens160_config *config = dev->config;
uint8_t tx_buffer = (reg << 1) | ENS160_SPI_READ_BIT;
const struct spi_buf tx_buf = {
.buf = &tx_buffer,
.len = 1,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1,
};
struct spi_buf rx_buf[2] = {
{
.buf = NULL,
.len = 1,
},
{
.buf = val,
.len = 1,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2,
};
return spi_transceive_dt(&config->spi, &tx, &rx);
}
static int ens160_read_data_spi(const struct device *dev, uint8_t start, uint8_t *data, size_t len)
{
const struct ens160_config *config = dev->config;
uint8_t tx_buffer = (start << 1) | ENS160_SPI_READ_BIT;
const struct spi_buf tx_buf = {
.buf = &tx_buffer,
.len = 1,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1,
};
struct spi_buf rx_buf[2] = {
{
.buf = NULL,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2,
};
return spi_transceive_dt(&config->spi, &tx, &rx);
}
static int ens160_write_reg_spi(const struct device *dev, uint8_t reg, uint8_t val)
{
const struct ens160_config *config = dev->config;
uint8_t tx_buffer = reg << 1;
const struct spi_buf buf[2] = {
{
.buf = &tx_buffer,
.len = 1,
},
{
.buf = &val,
.len = 1,
}
};
const struct spi_buf_set tx = {
.buffers = buf,
.count = 2,
};
return spi_write_dt(&config->spi, &tx);
}
static int ens160_write_data_spi(const struct device *dev, uint8_t reg, uint8_t *data, size_t len)
{
const struct ens160_config *config = dev->config;
uint8_t tx_buffer = reg << 1;
const struct spi_buf buf[2] = {
{
.buf = &tx_buffer,
.len = 1,
},
{
.buf = &data,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = buf,
.count = 2,
};
return spi_write_dt(&config->spi, &tx);
}
const struct ens160_transfer_function ens160_spi_transfer_function = {
.read_reg = ens160_read_reg_spi,
.read_data = ens160_read_data_spi,
.write_reg = ens160_write_reg_spi,
.write_data = ens160_write_data_spi,
};
int ens160_spi_init(const struct device *dev)
{
const struct ens160_config *config = dev->config;
struct ens160_data *data = dev->data;
if (!spi_is_ready_dt(&config->spi)) {
LOG_DBG("SPI bus not ready");
return -ENODEV;
}
data->tf = &ens160_spi_transfer_function;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/ens160/ens160_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 895 |
```c
/*
*
*/
#define DT_DRV_COMPAT semtech_sx9500
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include "sx9500.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(SX9500, CONFIG_SENSOR_LOG_LEVEL);
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
static K_KERNEL_STACK_DEFINE(sx9500_thread_stack, CONFIG_SX9500_THREAD_STACK_SIZE);
static struct k_thread sx9500_thread;
#endif
int sx9500_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct sx9500_data *data = dev->data;
const struct sx9500_config *cfg = dev->config;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
if (i2c_reg_update_byte_dt(&cfg->i2c,
SX9500_REG_IRQ_MSK,
SX9500_CONV_DONE_IRQ,
SX9500_CONV_DONE_IRQ) < 0) {
return -EIO;
}
data->handler_drdy = handler;
data->trigger_drdy = trig;
break;
case SENSOR_TRIG_NEAR_FAR:
if (i2c_reg_update_byte_dt(&cfg->i2c,
SX9500_REG_IRQ_MSK,
SX9500_NEAR_FAR_IRQ,
SX9500_NEAR_FAR_IRQ) < 0) {
return -EIO;
}
data->handler_near_far = handler;
data->trigger_near_far = trig;
break;
default:
return -EINVAL;
}
return 0;
}
static void sx9500_gpio_thread_cb(const struct device *dev)
{
struct sx9500_data *data = dev->data;
const struct sx9500_config *cfg = dev->config;
uint8_t reg_val;
if (i2c_reg_read_byte_dt(&cfg->i2c, SX9500_REG_IRQ_SRC, ®_val) < 0) {
LOG_DBG("sx9500: error reading IRQ source register");
return;
}
if ((reg_val & SX9500_CONV_DONE_IRQ) && data->handler_drdy) {
data->handler_drdy(dev, data->trigger_drdy);
}
if ((reg_val & SX9500_NEAR_FAR_IRQ) && data->handler_near_far) {
data->handler_near_far(dev, data->trigger_near_far);
}
}
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
static void sx9500_gpio_cb(const struct device *port,
struct gpio_callback *cb, uint32_t pins)
{
struct sx9500_data *data =
CONTAINER_OF(cb, struct sx9500_data, gpio_cb);
ARG_UNUSED(pins);
k_sem_give(&data->sem);
}
static void sx9500_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct sx9500_data *data = p1;
while (1) {
k_sem_take(&data->sem, K_FOREVER);
sx9500_gpio_thread_cb(data->dev);
}
}
#else /* CONFIG_SX9500_TRIGGER_GLOBAL_THREAD */
static void sx9500_gpio_cb(const struct device *port,
struct gpio_callback *cb, uint32_t pins)
{
struct sx9500_data *data =
CONTAINER_OF(cb, struct sx9500_data, gpio_cb);
ARG_UNUSED(pins);
k_work_submit(&data->work);
}
#endif /* CONFIG_SX9500_TRIGGER_GLOBAL_THREAD */
#ifdef CONFIG_SX9500_TRIGGER_GLOBAL_THREAD
static void sx9500_work_cb(struct k_work *work)
{
struct sx9500_data *data =
CONTAINER_OF(work, struct sx9500_data, work);
sx9500_gpio_thread_cb(data->dev);
}
#endif
int sx9500_setup_interrupt(const struct device *dev)
{
struct sx9500_data *data = dev->data;
const struct sx9500_config *cfg = dev->config;
int ret;
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);
#else
data->work.handler = sx9500_work_cb;
#endif
data->dev = dev;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name,
cfg->int_gpio.port->name);
return -ENODEV;
}
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
return ret;
}
gpio_init_callback(&data->gpio_cb, sx9500_gpio_cb, BIT(cfg->int_gpio.pin));
ret = gpio_add_callback(cfg->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
k_thread_create(&sx9500_thread, sx9500_thread_stack,
CONFIG_SX9500_THREAD_STACK_SIZE,
sx9500_thread_main, data, 0, NULL,
K_PRIO_COOP(CONFIG_SX9500_THREAD_PRIORITY),
0, K_NO_WAIT);
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/sx9500/sx9500_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,211 |
```c
/*
*
*/
#define DT_DRV_COMPAT sciosense_ens160
#include <zephyr/drivers/i2c.h>
#include "ens160.h"
LOG_MODULE_DECLARE(ENS160, CONFIG_SENSOR_LOG_LEVEL);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
static int ens160_read_reg_i2c(const struct device *dev, uint8_t reg, uint8_t *val)
{
const struct ens160_config *config = dev->config;
return i2c_reg_read_byte_dt(&config->i2c, reg, val);
}
static int ens160_read_data_i2c(const struct device *dev, uint8_t reg, uint8_t *data, size_t len)
{
const struct ens160_config *config = dev->config;
return i2c_burst_read_dt(&config->i2c, reg, data, len);
}
static int ens160_write_reg_i2c(const struct device *dev, uint8_t reg, uint8_t val)
{
const struct ens160_config *config = dev->config;
return i2c_reg_write_byte_dt(&config->i2c, reg, val);
}
static int ens160_write_data_i2c(const struct device *dev, uint8_t reg, uint8_t *data, size_t len)
{
const struct ens160_config *config = dev->config;
__ASSERT(len == 2, "Only 2 byte write are supported");
uint8_t buff[] = {reg, data[0], data[1]};
return i2c_write_dt(&config->i2c, buff, sizeof(buff));
}
const struct ens160_transfer_function ens160_i2c_transfer_function = {
.read_reg = ens160_read_reg_i2c,
.read_data = ens160_read_data_i2c,
.write_reg = ens160_write_reg_i2c,
.write_data = ens160_write_data_i2c,
};
int ens160_i2c_init(const struct device *dev)
{
const struct ens160_config *config = dev->config;
struct ens160_data *data = dev->data;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_DBG("I2C bus device not ready");
return -ENODEV;
}
data->tf = &ens160_i2c_transfer_function;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/ens160/ens160_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 506 |
```c
/*
*
*/
#define DT_DRV_COMPAT sciosense_ens160
#include <zephyr/kernel.h>
#include "ens160.h"
LOG_MODULE_DECLARE(ENS160, CONFIG_SENSOR_LOG_LEVEL);
static inline void ens160_setup_int(const struct device *dev, bool enable)
{
const struct ens160_config *config = dev->config;
gpio_flags_t flags = enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
(void)gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
}
static void ens160_gpio_callback(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
struct ens160_data *data = CONTAINER_OF(cb, struct ens160_data, gpio_cb);
ens160_setup_int(data->dev, false);
#if defined(CONFIG_ENS160_TRIGGER_OWN_THREAD)
k_sem_give(&data->gpio_sem);
#elif defined(CONFIG_ENS160_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void ens160_thread_cb(const struct device *dev)
{
struct ens160_data *data = dev->data;
uint8_t status;
int ret;
ret = data->tf->read_reg(dev, ENS160_REG_DEVICE_STATUS, &status);
if (ret < 0) {
return;
}
if (FIELD_GET(ENS160_STATUS_NEWDAT, status) != 0x01) {
LOG_ERR("Data is not ready");
return;
}
if (data->data_ready_handler != NULL) {
data->data_ready_handler(dev, data->data_ready_trigger);
}
ens160_setup_int(dev, true);
}
#ifdef CONFIG_ENS160_TRIGGER_OWN_THREAD
static void ens160_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct ens160_data *data = p1;
while (1) {
k_sem_take(&data->gpio_sem, K_FOREVER);
ens160_thread_cb(data->dev);
}
}
#endif /* CONFIG_ENS160_TRIGGER_OWN_THREAD */
#ifdef CONFIG_ENS160_TRIGGER_GLOBAL_THREAD
static void ens160_work_cb(struct k_work *work)
{
struct ens160_data *data = CONTAINER_OF(work, struct ens160_data, work);
ens160_thread_cb(data->dev);
}
#endif /* CONFIG_ENS160_TRIGGER_GLOBAL_THREAD */
int ens160_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct ens160_config *config = dev->config;
struct ens160_data *data = dev->data;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
ens160_setup_int(dev, false);
if (trig->type == SENSOR_TRIG_DATA_READY) {
data->data_ready_handler = handler;
data->data_ready_trigger = trig;
}
ens160_setup_int(dev, true);
return 0;
}
int ens160_init_interrupt(const struct device *dev)
{
const struct ens160_config *config = dev->config;
struct ens160_data *data = dev->data;
int ret;
uint8_t int_cfg = ENS160_CONFIG_INTEN | ENS160_CONFIG_INTDAT | ENS160_CONFIG_INT_CFG;
ret = data->tf->write_reg(dev, ENS160_REG_CONFIG, int_cfg);
if (ret < 0) {
LOG_ERR("Failed to write to config register");
return -EIO;
}
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name, config->int_gpio.port->name);
return -ENODEV;
}
gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
gpio_init_callback(&data->gpio_cb, ens160_gpio_callback, BIT(config->int_gpio.pin));
ret = gpio_add_callback(config->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
LOG_ERR("Failed to set gpio callback");
return -EIO;
}
ret = gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
data->dev = dev;
#if defined(CONFIG_ENS160_TRIGGER_OWN_THREAD)
k_sem_init(&data->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_ENS160_THREAD_STACK_SIZE,
ens160_thread, data, NULL, NULL, K_PRIO_COOP(CONFIG_ENS160_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ENS160_TRIGGER_GLOBAL_THREAD)
data->work.handler = ens160_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/ens160/ens160_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,002 |
```c
/*
*
*/
#define DT_DRV_COMPAT sciosense_ens160
#include <zephyr/drivers/sensor/ens160.h>
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <zephyr/pm/pm.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include "ens160.h"
LOG_MODULE_REGISTER(ENS160, CONFIG_SENSOR_LOG_LEVEL);
static int ens160_set_temperature(const struct device *dev, const struct sensor_value *val)
{
struct ens160_data *data = dev->data;
uint8_t buf[2];
int64_t temp;
int ret;
/* Recommended operation: -5 to 60 degrees Celsius */
if (!IN_RANGE(val->val1, -5, 60)) {
LOG_ERR("Invalid temperature value");
return -EINVAL;
}
/* Convert temperature from Celsius to Kelvin */
temp = sensor_value_to_micro(val) + 273150000U;
/* Temperature is stored in 64 * Kelvin */
temp *= 64;
sys_put_le16(DIV_ROUND_CLOSEST(temp, 1000000U), buf);
ret = data->tf->write_data(dev, ENS160_REG_TEMP_IN, buf, 2U);
if (ret < 0) {
LOG_ERR("Failed to write temperature");
return ret;
}
return 0;
}
static int ens160_set_humidity(const struct device *dev, const struct sensor_value *val)
{
struct ens160_data *data = dev->data;
uint8_t buf[2];
uint64_t rh;
int ret;
/* Recommended operation: 20 to 80% RH */
if (!IN_RANGE(val->val1, 20, 80)) {
LOG_ERR("Invalid RH value");
return -EINVAL;
}
rh = sensor_value_to_micro(val);
/* RH value is stored in 512 * %RH */
rh *= 512;
sys_put_le16(DIV_ROUND_CLOSEST(rh, 1000000U), buf);
ret = data->tf->write_data(dev, ENS160_REG_RH_IN, buf, 2U);
if (ret < 0) {
LOG_ERR("Failed to write RH");
return ret;
}
return 0;
}
static bool ens160_new_data(const struct device *dev)
{
struct ens160_data *data = dev->data;
uint8_t status;
int ret;
ret = data->tf->read_reg(dev, ENS160_REG_DEVICE_STATUS, &status);
if (ret < 0) {
return ret;
}
return FIELD_GET(ENS160_STATUS_NEWDAT, status) != 0;
}
static int ens160_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ens160_data *data = dev->data;
uint16_t le16_buffer;
uint8_t buffer;
int ret;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_CO2 ||
chan == SENSOR_CHAN_VOC ||
chan == (enum sensor_channel)SENSOR_CHAN_ENS160_AQI);
if (!IS_ENABLED(CONFIG_ENS160_TRIGGER)) {
WAIT_FOR(ens160_new_data(dev), ENS160_TIMEOUT_US, k_msleep(10));
}
ret = data->tf->read_data(dev, ENS160_REG_DATA_ECO2, (uint8_t *)&le16_buffer,
sizeof(le16_buffer));
if (ret < 0) {
LOG_ERR("Failed to fetch CO2");
return ret;
}
data->eco2 = sys_le16_to_cpu(le16_buffer);
ret = data->tf->read_data(dev, ENS160_REG_DATA_TVOC, (uint8_t *)&le16_buffer,
sizeof(le16_buffer));
if (ret < 0) {
LOG_ERR("Failed to fetch VOC");
return ret;
}
data->tvoc = sys_le16_to_cpu(le16_buffer);
ret = data->tf->read_reg(dev, ENS160_REG_DATA_AQI, &buffer);
if (ret < 0) {
LOG_ERR("Failed to fetch AQI");
return ret;
}
data->aqi = FIELD_GET(ENS160_DATA_AQI_UBA, buffer);
return 0;
}
static int ens160_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ens160_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_CO2:
val->val1 = data->eco2;
val->val2 = 0;
break;
case SENSOR_CHAN_VOC:
val->val1 = data->tvoc;
val->val2 = 0;
break;
case SENSOR_CHAN_ENS160_AQI:
val->val1 = data->aqi;
val->val2 = 0;
break;
default:
return -ENOTSUP;
}
return 0;
}
static int ens160_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
int ret = 0;
switch ((uint32_t)attr) {
case SENSOR_ATTR_ENS160_TEMP:
ret = ens160_set_temperature(dev, val);
break;
case SENSOR_ATTR_ENS160_RH:
ret = ens160_set_humidity(dev, val);
break;
default:
return -ENOTSUP;
}
return ret;
}
static const struct sensor_driver_api ens160_driver_api = {
.sample_fetch = ens160_sample_fetch,
.channel_get = ens160_channel_get,
.attr_set = ens160_attr_set,
#ifdef CONFIG_ENS160_TRIGGER
.trigger_set = ens160_trigger_set,
#endif
};
static int ens160_init(const struct device *dev)
{
const struct ens160_config *config = dev->config;
struct ens160_data *data = dev->data;
uint8_t fw_version[3];
uint16_t part_id;
uint8_t status;
int ret;
ret = config->bus_init(dev);
if (ret < 0) {
return ret;
}
ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_RESET);
if (ret < 0) {
LOG_ERR("Failed to reset the device");
return ret;
}
k_msleep(ENS160_BOOTING_TIME_MS);
ret = data->tf->read_data(dev, ENS160_REG_PART_ID, (uint8_t *)&part_id, sizeof(part_id));
if (ret < 0) {
LOG_ERR("Failed to read Part ID");
return -EIO;
}
if (sys_le16_to_cpu(part_id) != ENS160_PART_ID) {
LOG_ERR("Part ID is invalid. Expected: 0x%x; read: 0x%x", ENS160_PART_ID, part_id);
return -EIO;
}
ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_IDLE);
if (ret < 0) {
LOG_ERR("Failed to set operation mode");
return ret;
}
k_msleep(ENS160_BOOTING_TIME_MS);
ret = data->tf->write_reg(dev, ENS160_REG_COMMAND, ENS160_COMMAND_CLRGPR);
if (ret < 0) {
LOG_ERR("Failed to clear GPR registers");
return ret;
}
ret = data->tf->write_reg(dev, ENS160_REG_COMMAND, ENS160_COMMAND_GET_APPVER);
if (ret < 0) {
LOG_ERR("Failed to write GET_APPVER command");
return ret;
}
k_msleep(ENS160_BOOTING_TIME_MS);
ret = data->tf->read_data(dev, ENS160_REG_GPR_READ4, fw_version, sizeof(fw_version));
if (ret < 0) {
LOG_ERR("Failed to read firmware version");
return ret;
}
LOG_INF("Firmware version: %u.%u.%u", fw_version[2], fw_version[1], fw_version[0]);
#ifdef CONFIG_ENS160_TRIGGER
ret = ens160_init_interrupt(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupt");
return ret;
}
#endif /* CONFIG_ENS160_TRIGGER */
ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_STANDARD);
if (ret < 0) {
LOG_ERR("Failed to set operation mode");
return ret;
}
k_msleep(ENS160_BOOTING_TIME_MS);
ret = data->tf->read_reg(dev, ENS160_REG_DEVICE_STATUS, &status);
if (ret < 0) {
LOG_ERR("Failed to read device status");
return ret;
}
if (FIELD_GET(ENS160_STATUS_VALIDITY_FLAG, status) != ENS160_STATUS_NORMAL) {
LOG_ERR("Status 0x%02x is invalid", status);
return -EINVAL;
}
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int ens160_pm_action(const struct device *dev, enum pm_device_action action)
{
struct ens160_data *data = dev->data;
int ret = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_IDLE);
k_msleep(ENS160_BOOTING_TIME_MS);
ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_STANDARD);
break;
case PM_DEVICE_ACTION_SUSPEND:
ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_DEEP_SLEEP);
break;
default:
return -ENOTSUP;
}
k_msleep(ENS160_BOOTING_TIME_MS);
return ret;
}
#endif
#define ENS160_SPI_OPERATION \
(SPI_OP_MODE_MASTER | SPI_WORD_SET(8) | SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_TRANSFER_MSB)
#define ENS160_CONFIG_SPI(inst) \
.bus_init = &ens160_spi_init, \
.spi = SPI_DT_SPEC_INST_GET(inst, ENS160_SPI_OPERATION, 0),
#define ENS160_CONFIG_I2C(inst) \
.bus_init = &ens160_i2c_init, \
.i2c = I2C_DT_SPEC_INST_GET(inst),
#define ENS160_DEFINE(inst) \
static struct ens160_data ens160_data_##inst; \
static const struct ens160_config ens160_config_##inst = { \
IF_ENABLED(CONFIG_ENS160_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET(inst, int_gpios),)) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(ENS160_CONFIG_SPI(inst)), \
(ENS160_CONFIG_I2C(inst))) \
}; \
\
PM_DEVICE_DT_INST_DEFINE(inst, ens160_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, ens160_init, PM_DEVICE_DT_INST_GET(inst), \
&ens160_data_##inst, &ens160_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &ens160_driver_api);
DT_INST_FOREACH_STATUS_OKAY(ENS160_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ens160/ens160.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,432 |
```unknown
menuconfig ENS160
bool "ENS160 multi-gas sensor"
default y
depends on DT_HAS_SCIOSENSE_ENS160_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_SCIOSENSE_ENS160),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_SCIOSENSE_ENS160),spi)
help
Enable driver for ENS160 Digital Metal Oxide Multi-Gas Sensor.
if ENS160
choice
prompt "Trigger Mode"
default ENS160_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config ENS160_TRIGGER_NONE
bool "No trigger"
config ENS160_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ENS160_TRIGGER
config ENS160_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ENS160_TRIGGER
endchoice # Trigger Mode
config ENS160_TRIGGER
bool
config ENS160_THREAD_PRIORITY
int "Thread priority"
depends on ENS160_TRIGGER_OWN_THREAD && ENS160_TRIGGER
default 10
help
Priority of thread used by the driver to handle interrupts.
config ENS160_THREAD_STACK_SIZE
int "Thread stack size"
depends on ENS160_TRIGGER_OWN_THREAD && ENS160_TRIGGER
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # ENS160
``` | /content/code_sandbox/drivers/sensor/ens160/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 314 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ENS160_ENS160_H_
#define ZEPHYR_DRIVERS_SENSOR_ENS160_ENS160_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif
/* Registers */
#define ENS160_REG_PART_ID 0x00
#define ENS160_REG_OPMODE 0x10
#define ENS160_REG_CONFIG 0x11
#define ENS160_REG_COMMAND 0x12
#define ENS160_REG_TEMP_IN 0x13
#define ENS160_REG_RH_IN 0x15
#define ENS160_REG_DEVICE_STATUS 0x20
#define ENS160_REG_DATA_AQI 0x21
#define ENS160_REG_DATA_TVOC 0x22
#define ENS160_REG_DATA_ECO2 0x24
#define ENS160_REG_DATA_T 0x30
#define ENS160_REG_DATA_RH 0x32
#define ENS160_REG_DATA_MISR 0x38
#define ENS160_REG_GPR_WRITE0 0x40
#define ENS160_REG_GPR_WRITE1 0x41
#define ENS160_REG_GPR_WRITE2 0x42
#define ENS160_REG_GPR_WRITE3 0x43
#define ENS160_REG_GPR_WRITE4 0x44
#define ENS160_REG_GPR_WRITE5 0x45
#define ENS160_REG_GPR_WRITE6 0x46
#define ENS160_REG_GPR_WRITE7 0x47
#define ENS160_REG_GPR_READ0 0x48
#define ENS160_REG_GPR_READ1 0x49
#define ENS160_REG_GPR_READ2 0x4A
#define ENS160_REG_GPR_READ3 0x4B
#define ENS160_REG_GPR_READ4 0x4C
#define ENS160_REG_GPR_READ5 0x4D
#define ENS160_REG_GPR_READ6 0x4E
#define ENS160_REG_GPR_READ7 0x4F
#define ENS160_PART_ID 0x160
#define ENS160_TIMEOUT_US (1000000U)
#define ENS160_BOOTING_TIME_MS (10U)
/* Operation modes */
#define ENS160_OPMODE_DEEP_SLEEP 0x00
#define ENS160_OPMODE_IDLE 0x01
#define ENS160_OPMODE_STANDARD 0x02
#define ENS160_OPMODE_RESET 0xF0
/* Device status */
#define ENS160_STATUS_STATER BIT(6)
#define ENS160_STATUS_VALIDITY_FLAG GENMASK(3, 2)
#define ENS160_STATUS_NEWDAT BIT(1)
#define ENS160_STATUS_NORMAL 0x00
#define ENS160_STATUS_WARM_UP 0x01
#define ENS160_STATUS_START_UP 0x02
#define ENS160_STATUS_INVALID 0x03
/* Commands */
#define ENS160_COMMAND_NOP 0x00
#define ENS160_COMMAND_GET_APPVER 0x0E
#define ENS160_COMMAND_CLRGPR 0xCC
/* Config register fields */
#define ENS160_CONFIG_INTPOL BIT(6)
#define ENS160_CONFIG_INT_CFG BIT(5)
#define ENS160_CONFIG_INTGPR BIT(3)
#define ENS160_CONFIG_INTDAT BIT(1)
#define ENS160_CONFIG_INTEN BIT(0)
#define ENS160_DATA_AQI_UBA GENMASK(2, 0)
struct ens160_config {
int (*bus_init)(const struct device *dev);
const union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif
};
#ifdef CONFIG_ENS160_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
struct ens160_transfer_function {
int (*read_reg)(const struct device *dev, uint8_t reg, uint8_t *val);
int (*read_data)(const struct device *dev, uint8_t reg, uint8_t *data, size_t len);
int (*write_reg)(const struct device *dev, uint8_t reg, uint8_t val);
int (*write_data)(const struct device *dev, uint8_t reg, uint8_t *data, size_t len);
};
struct ens160_data {
uint16_t eco2;
uint16_t tvoc;
uint8_t aqi;
const struct ens160_transfer_function *tf;
#ifdef CONFIG_ENS160_TRIGGER
struct gpio_callback gpio_cb;
const struct device *dev;
sensor_trigger_handler_t data_ready_handler;
const struct sensor_trigger *data_ready_trigger;
#if defined(CONFIG_ENS160_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ENS160_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ENS160_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_ENS160_TRIGGER */
};
#ifdef CONFIG_ENS160_TRIGGER
int ens160_trigger_set(const struct device *dev, const struct sensor_trigger *trigg,
sensor_trigger_handler_t handler);
int ens160_init_interrupt(const struct device *dev);
#endif
int ens160_i2c_init(const struct device *dev);
int ens160_spi_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_ENS160_ENS160_H_ */
``` | /content/code_sandbox/drivers/sensor/ens160/ens160.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,280 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/silabs/si7006/Kconfig"
source "drivers/sensor/silabs/si7055/Kconfig"
source "drivers/sensor/silabs/si7060/Kconfig"
source "drivers/sensor/silabs/si7210/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/silabs/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 82 |
```unknown
menuconfig SI7055
bool "Si7055 Temperature Sensor"
default y
depends on DT_HAS_SILABS_SI7055_ENABLED
select I2C
select CRC
help
Enable I2C-based driver for Si7055 Temperature Sensor.
if SI7055
config SI7055_ENABLE_CHECKSUM
bool "SI7055 Checksum On Measurement"
help
Validates the additional checksum byte for temperature measurements.
endif # SI7055
``` | /content/code_sandbox/drivers/sensor/silabs/si7055/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 97 |
```objective-c
/*
*
*/
#ifndef _SI7055_H
#define _SI7055_H
/* Si7055 register addresses */
#define SI7055_MEAS_TEMP_MASTER_MODE 0xE3
#define SI7055_MEAS_TEMP_NO_MASTER_MODE 0xF3
#define SI7055_RESET 0xFE
#define SI7055_READ_ID_LOW_0 0xFA
#define SI7055_READ_ID_LOW_1 0x0F
#define SI7055_READ_ID_HIGH_0 0xFC
#define SI7055_READ_ID_HIGH_1 0xC9
#define SI7055_FIRMWARE_0 0x84
#define SI7055_FIRMWARE_1 0xB8
/* Si7055 temperature conversion factors and constants */
#define SI7055_CONV_FACTOR_1 17572
#define SI7055_CONV_FACTOR_2 4685
#define SI7055_MULTIPLIER 10000
#define SI7055_DIVIDER 1000000
/* Si7055 buffer sizes and locations */
#define SI7055_TEMPERATURE_READ_NO_CHECKSUM_SIZE 0x02
#define SI7055_TEMPERATURE_READ_WITH_CHECKSUM_SIZE 0x03
#define SI7055_TEMPERATURE_DATA_BYTE_0 0x0
#define SI7055_TEMPERATURE_DATA_BYTE_1 0x1
/* Si7055 Checksum constants */
#define SI7055_CRC_POLY 0x31
#define SI7055_CRC_SIZE sizeof(uint8_t)
#define SI7055_CRC_INIT 0x0
#define SI7055_DATA_SIZE (sizeof(uint8_t) * 2)
#endif /* _SI7055_H */
``` | /content/code_sandbox/drivers/sensor/silabs/si7055/si7055.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 357 |
```unknown
# Si7210 Hall Effect Magnetic Position and Temperature Sensor configuration options
config SI7210
bool "Si7210 Hall Effect Magnetic Position and Temperature Sensor"
default y
depends on DT_HAS_SILABS_SI7210_ENABLED
select I2C
help
Enable driver for Si7210 Hall Effect Magnetic Position and Temperature Sensor.
``` | /content/code_sandbox/drivers/sensor/silabs/si7210/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```c
/*
*
*/
#define DT_DRV_COMPAT silabs_si7055
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/i2c.h>
#include "si7055.h"
#if CONFIG_SI7055_ENABLE_CHECKSUM
#include <zephyr/sys/crc.h>
#endif
LOG_MODULE_REGISTER(si7055, CONFIG_SENSOR_LOG_LEVEL);
struct si7055_data {
uint16_t temperature;
};
struct si7055_config {
struct i2c_dt_spec i2c;
};
/**
* @brief function to get temperature
*
* @return int 0 on success
* -EIO for I/O and checksum errors
*/
static int si7055_get_temperature(const struct device *dev)
{
struct si7055_data *si_data = dev->data;
const struct si7055_config *config = dev->config;
int retval;
#if CONFIG_SI7055_ENABLE_CHECKSUM
uint8_t temp[SI7055_TEMPERATURE_READ_WITH_CHECKSUM_SIZE];
#else
uint8_t temp[SI7055_TEMPERATURE_READ_NO_CHECKSUM_SIZE];
#endif
retval = i2c_burst_read_dt(&config->i2c, SI7055_MEAS_TEMP_MASTER_MODE,
temp, sizeof(temp));
/* Refer to
* path_to_url
*/
if (retval == 0) {
#if CONFIG_SI7055_ENABLE_CHECKSUM
if (crc8(temp, SI7055_DATA_SIZE, SI7055_CRC_POLY,
SI7055_CRC_INIT, false) != temp[SI7055_DATA_SIZE]){
LOG_ERR("checksum failed.\n");
return(-EIO);
}
#endif
si_data->temperature = (temp[SI7055_TEMPERATURE_DATA_BYTE_0]
<< 8) |
temp[SI7055_TEMPERATURE_DATA_BYTE_1];
} else {
LOG_ERR("read register err");
}
return retval;
}
/**
* @brief fetch a sample from the sensor
*
* @return 0
*/
static int si7055_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
int retval;
retval = si7055_get_temperature(dev);
return retval;
}
/**
* @brief sensor value get
*
* @return -ENOTSUP for unsupported channels
*/
static int si7055_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct si7055_data *si_data = dev->data;
/* Refer to
* path_to_url
*/
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
int32_t temp_ucelcius = (((SI7055_CONV_FACTOR_1 *
(int32_t)si_data->temperature) /
(__UINT16_MAX__ + 1)) -
SI7055_CONV_FACTOR_2) *
SI7055_MULTIPLIER;
val->val1 = temp_ucelcius / SI7055_DIVIDER;
val->val2 = temp_ucelcius % SI7055_DIVIDER;
LOG_DBG("temperature = val1:%d, val2:%d",
val->val1, val->val2);
return 0;
} else {
return -ENOTSUP;
}
}
static const struct sensor_driver_api si7055_api = {
.sample_fetch = &si7055_sample_fetch,
.channel_get = &si7055_channel_get,
};
/**
* @brief initialize the sensor
*
* @return 0 for success
*/
static int si7055_init(const struct device *dev)
{
const struct si7055_config *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
LOG_DBG("si7055 init ok");
return 0;
}
#define SI7055_DEFINE(inst) \
static struct si7055_data si7055_data_##inst; \
\
static const struct si7055_config si7055_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, si7055_init, NULL, \
&si7055_data_##inst, &si7055_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &si7055_api); \
DT_INST_FOREACH_STATUS_OKAY(SI7055_DEFINE)
``` | /content/code_sandbox/drivers/sensor/silabs/si7055/si7055.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 984 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/drivers/i2c.h>
#include <stdio.h>
#include <stdlib.h>
#include <zephyr/sys/util.h>
#include "si7006.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(si7006, CONFIG_SENSOR_LOG_LEVEL);
struct si7006_data {
uint16_t temperature;
uint16_t humidity;
};
struct si7006_config {
struct i2c_dt_spec i2c;
/** Use "read temp" vs "read old temp" command, the latter only with SiLabs sensors. */
uint8_t read_temp_cmd;
};
/**
* @brief function to get relative humidity
*
* @return int 0 on success
*/
static int si7006_get_humidity(const struct device *dev)
{
struct si7006_data *si_data = dev->data;
const struct si7006_config *config = dev->config;
int retval;
uint16_t hum;
retval = i2c_burst_read_dt(&config->i2c, SI7006_MEAS_REL_HUMIDITY_MASTER_MODE,
(uint8_t *)&hum, sizeof(hum));
if (retval == 0) {
si_data->humidity = sys_be16_to_cpu(hum) & ~3;
} else {
LOG_ERR("read register err: %d", retval);
}
return retval;
}
/**
* @brief function to get temperature
*
* Note that for Si7006 type sensors, si7006_get_humidity must be called before
* calling si7006_get_temperature, as the get old temperature command is used.
*
* @return int 0 on success
*/
static int si7006_get_temperature(const struct device *dev)
{
struct si7006_data *si_data = dev->data;
const struct si7006_config *config = dev->config;
uint16_t temp;
int retval;
retval = i2c_burst_read_dt(&config->i2c, config->read_temp_cmd,
(uint8_t *)&temp, sizeof(temp));
if (retval == 0) {
si_data->temperature = sys_be16_to_cpu(temp) & ~3;
} else {
LOG_ERR("read register err: %d", retval);
}
return retval;
}
/**
* @brief fetch a sample from the sensor
*
* @return 0
*/
static int si7006_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
int retval;
retval = si7006_get_humidity(dev);
if (retval == 0) {
retval = si7006_get_temperature(dev);
}
return retval;
}
/**
* @brief sensor value get
*
* @return -ENOTSUP for unsupported channels
*/
static int si7006_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct si7006_data *si_data = dev->data;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
/* Raw formula: (temp * 175.72) / 65536 - 46.85
* To use integer math, scale the 175.72 factor by 128 and move the offset to
* inside the division. This gives us:
*
* (temp * 175.72 * 128 - 46.86 * 128 * 65536) / (65536 * 128)
* The constants can be calculated now:
* (temp * 22492 - 393006285) / 2^23
*
* There is a very small amount of round-off error in the factor of 22492. To
* compenstate, a constant of 5246 is used to center the error about 0, thus
* reducing the overall MSE.
*/
/* Temperature value times two to the 23rd power, i.e. temp_23 = temp << 23 */
const int32_t temp_23 = si_data->temperature * 22492 - (393006285 - 5246);
/* Integer component of temperature */
int32_t temp_int = temp_23 >> 23;
/* Fractional component of temperature */
int32_t temp_frac = temp_23 & BIT_MASK(23);
/* Deal with the split twos-complement / BCD format oddness with negatives */
if (temp_23 < 0) {
temp_int += 1;
temp_frac -= BIT(23);
}
val->val1 = temp_int;
/* Remove a constant factor of 64 from (temp_frac * 1000000) >> 23 */
val->val2 = (temp_frac * 15625ULL) >> 17;
LOG_DBG("temperature %u = val1:%d, val2:%d", si_data->temperature,
val->val1, val->val2);
return 0;
} else if (chan == SENSOR_CHAN_HUMIDITY) {
/* Humidity times two to the 16th power. Offset of -6 not applied yet. */
const uint32_t rh_16 = si_data->humidity * 125U;
/* Integer component of humidity */
const int16_t rh_int = rh_16 >> 16;
/* Fraction component of humidity */
const uint16_t rh_frac = rh_16 & BIT_MASK(16);
val->val1 = rh_int - 6; /* Apply offset now */
/* Remove a constant factor of 64 from (rh_frac * 1000000) >> 16 */
val->val2 = (rh_frac * 15625) >> 10;
/* Deal with the split twos-complement / BCD format oddness with negatives */
if (val->val1 < 0) {
val->val1 += 1;
val->val2 -= 1000000;
}
LOG_DBG("humidity %u = val1:%d, val2:%d", si_data->humidity, val->val1, val->val2);
return 0;
} else {
return -ENOTSUP;
}
}
static const struct sensor_driver_api si7006_api = {
.sample_fetch = &si7006_sample_fetch,
.channel_get = &si7006_channel_get,
};
/**
* @brief initialize the sensor
*
* @return 0 for success
*/
static int si7006_init(const struct device *dev)
{
const struct si7006_config *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
LOG_DBG("si7006 init ok");
return 0;
}
#define SI7006_DEFINE(inst, name, temp_cmd) \
static struct si7006_data si7006_data_##name##_##inst; \
\
static const struct si7006_config si7006_config_##name##_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.read_temp_cmd = temp_cmd, \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, si7006_init, NULL, \
&si7006_data_##name##_##inst, \
&si7006_config_##name##_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&si7006_api);
#define DT_DRV_COMPAT silabs_si7006
DT_INST_FOREACH_STATUS_OKAY_VARGS(SI7006_DEFINE, DT_DRV_COMPAT, SI7006_READ_OLD_TEMP);
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT sensirion_sht21
DT_INST_FOREACH_STATUS_OKAY_VARGS(SI7006_DEFINE, DT_DRV_COMPAT, SI7006_MEAS_TEMP_MASTER_MODE);
``` | /content/code_sandbox/drivers/sensor/silabs/si7006/si7006.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,741 |
```objective-c
/*
*
*/
#ifndef _SI7006_H
#define _SI7006_H
/* Si7006 register addresses */
#define SI7006_MEAS_REL_HUMIDITY_MASTER_MODE 0xE5
#define SI7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE 0xF5
#define SI7006_MEAS_TEMP_MASTER_MODE 0xE3
#define SI7006_MEAS_TEMP_NO_MASTER_MODE 0xF3
#define SI7006_READ_OLD_TEMP 0xE0
#define SI7006_RESET 0xFE
#define SI7006_WRITE_HUMIDITY_TEMP_CONTR 0xE6
#define SI7006_READ_HUMIDITY_TEMP_CONTR 0xE7
#define SI7006_WRITE_HEATER_CONTR 0x51
#define SI7006_READ_HEATER_CONTR 0x11
#define SI7006_READ_ID_LOW_0 0xFA
#define SI7006_READ_ID_LOW_1 0x0F
#define SI7006_READ_ID_HIGH_0 0xFC
#define SI7006_READ_ID_HIGH_1 0xC9
#define SI7006_FIRMWARE_0 0x84
#define SI7006_FIRMWARE_1 0xB8
#endif /* _SI7006_H */
``` | /content/code_sandbox/drivers/sensor/silabs/si7006/si7006.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 279 |
```unknown
config SI7006
bool "SHT21, Si7006, and HTU21D Humidity and Temperature Sensors"
default y
depends on DT_HAS_SILABS_SI7006_ENABLED || DT_HAS_SENSIRION_SHT21_ENABLED
select I2C
help
Enable I2C-based driver for several humidity and temperature sensors
compatible with the Sensirion SHT21, such as the Silicon Labs
Si7006/13/20/21 and Measurement Specialties HTU21D
``` | /content/code_sandbox/drivers/sensor/silabs/si7006/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 111 |
```objective-c
/*
*
*/
#ifndef _SI7060_H
#define _SI7060_H
/* Si7060 register addresses */
#define SI7060_REG_CHIP_INFO 0xC0
#define SI7060_REG_TEMP_HIGH 0xC1
#define SI7060_REG_TEMP_LOW 0xC2
#define SI7060_REG_CONFIG 0xC4
#define SI7060_CHIP_ID_VALUE 0x01
#define SI7060_ONE_BURST_VALUE 0x04
#endif /* _SI7060_H */
``` | /content/code_sandbox/drivers/sensor/silabs/si7060/si7060.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 106 |
```c
/*
*
*/
#define DT_DRV_COMPAT silabs_si7210
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(SI7210, CONFIG_SENSOR_LOG_LEVEL);
/* Register addresses */
#define SI7210_REG_CHIPID 0xC0
#define SI7210_REG_DSPSIGM 0xC1
#define SI7210_REG_DSPSIGL 0xC2
#define SI7210_REG_DSPSIGSEL 0xC3
#define SI7210_REG_POWER_CTRL 0xC4
#define SI7210_REG_ARAUTOINC 0xC5
#define SI7210_REG_CTRL1 0xC6
#define SI7210_REG_CTRL2 0xC7
#define SI7210_REG_SLTIME 0xC8
#define SI7210_REG_CTRL3 0xC9
#define SI7210_REG_A0 0xCA
#define SI7210_REG_A1 0xCB
#define SI7210_REG_A2 0xCC
#define SI7210_REG_CTRL4 0xCD
#define SI7210_REG_A3 0xCE
#define SI7210_REG_A4 0xCF
#define SI7210_REG_A5 0xD0
#define SI7210_REG_OTP_ADDR 0xE1
#define SI7210_REG_OTP_DATA 0xE2
#define SI7210_REG_OTP_CTRL 0xE3
#define SI7210_REG_TM_FG 0xE4
/* Registers bits */
#define SI7210_BIT_DSPSIGSEL_MAG 0x00
#define SI7210_BIT_DSPSIGSEL_TEMP 0x01
#define SI7210_BIT_POWER_CTRL_MEAS 0x80
#define SI7210_BIT_POWER_CTRL_USESTORE 0x08
#define SI7210_BIT_POWER_CTRL_ONEBURST 0x04
#define SI7210_BIT_POWER_CTRL_STOP 0x02
#define SI7210_BIT_POWER_CTRL_SLEEP 0x01
#define SI7210_BIT_CTRL3_SLTIMEENA 0x01
#define SI7210_BIT_CTRL3_SLTFAST 0x02
#define SI7210_BIT_OTP_CTRL_READEN 0x02
#define SI7210_BIT_OTP_CTRL_BUSY 0x01
/* OT registers */
#define SI7210_OTPREG_DEF_CTRL1 0x04
#define SI7210_OTPREG_DEF_CTRL2 0x05
#define SI7210_OTPREG_DEF_SLTIME 0x06
#define SI7210_OTPREG_DEF_CTRL3 0x08
#define SI7210_OTPREG_DEF_A0 0x09
#define SI7210_OTPREG_DEF_A1 0x0A
#define SI7210_OTPREG_DEF_A2 0x0B
#define SI7210_OTPREG_DEF_CTRL4 0x0C
#define SI7210_OTPREG_DEF_A3 0x0D
#define SI7210_OTPREG_DEF_A4 0x0E
#define SI7210_OTPREG_DEF_A5 0x0F
#define SI7210_OTPREG_PART_BASE 0x14
#define SI7210_OTPREG_PART_VARIANT 0x15
#define SI7210_OTPREG_SN1 0x18
#define SI7210_OTPREG_SN2 0x19
#define SI7210_OTPREG_SN3 0x1A
#define SI7210_OTPREG_SN4 0x1B
#define SI7210_OTPREG_TEMP_OFFSET 0x1D
#define SI7210_OTPREG_TEMP_GAIN 0x1E
#define SI7210_OTPREG_200G_SCALE_A0 0x21
#define SI7210_OTPREG_200G_SCALE_A1 0x22
#define SI7210_OTPREG_200G_SCALE_A2 0x23
#define SI7210_OTPREG_200G_SCALE_A3 0x24
#define SI7210_OTPREG_200G_SCALE_A4 0x25
#define SI7210_OTPREG_200G_SCALE_A5 0x26
#define SI7210_OTPREG_2000G_SCALE_A0 0x27
#define SI7210_OTPREG_2000G_SCALE_A1 0x28
#define SI7210_OTPREG_2000G_SCALE_A2 0x29
#define SI7210_OTPREG_2000G_SCALE_A3 0x30
#define SI7210_OTPREG_2000G_SCALE_A4 0x31
#define SI7210_OTPREG_2000G_SCALE_A5 0x32
enum si7210_scale {
si7210_scale_200G,
si7210_scale_2000G,
};
struct si7210_config {
struct i2c_dt_spec bus;
};
struct si7210_data {
int8_t otp_temp_offset;
int8_t otp_temp_gain;
enum si7210_scale scale;
uint8_t reg_dspsigsel;
uint8_t reg_arautoinc;
uint16_t mag_sample;
uint16_t temp_sample;
};
/* Put the chip into sleep mode */
static int si7210_sleep(const struct device *dev)
{
const struct si7210_config *config = dev->config;
struct si7210_data *data = dev->data;
int rc;
/*
* Disable measurements during sleep. This overrides the other fields of
* the register, but they get reloaded from OTP during wake-up.
*/
rc = i2c_reg_write_byte_dt(&config->bus, SI7210_REG_CTRL3, 0);
if (rc < 0) {
LOG_ERR("Failed to disable SLTIME");
return rc;
}
/* Go to sleep mode */
rc = i2c_reg_write_byte_dt(&config->bus, SI7210_REG_POWER_CTRL,
SI7210_BIT_POWER_CTRL_SLEEP);
if (rc < 0) {
LOG_ERR("Failed to go to sleep mode");
return rc;
}
/* Going to sleep mode resets some registers */
data->reg_dspsigsel = 0x00;
data->reg_arautoinc = 0x00;
return 0;
}
/* Wake a chip from idle or sleep mode */
static int si7210_wakeup(const struct device *dev)
{
const struct si7210_config *config = dev->config;
uint8_t val;
int rc;
/*
* Read one byte from the chip to wake it up. The shorter alternative
* is to write a zero byte length message, but it might not be
* supported by all I2C controllers.
*/
rc = i2c_read_dt(&config->bus, &val, 1);
if (rc < 0) {
LOG_ERR("Failed to go wake-up chip");
return rc;
}
return 0;
}
/*
* The Si7210 device do not have a reset function, but most of the registers
* are reloaded when exiting from sleep mode.
*/
static int si7210_reset(const struct device *dev)
{
int rc;
rc = si7210_sleep(dev);
if (rc < 0) {
return rc;
}
rc = si7210_wakeup(dev);
return rc;
}
static int si7210_otp_reg_read_byte(const struct device *dev,
uint8_t otp_reg_addr, uint8_t *value)
{
const struct si7210_config *config = dev->config;
int rc;
rc = i2c_reg_write_byte_dt(&config->bus, SI7210_REG_OTP_ADDR, otp_reg_addr);
if (rc) {
LOG_ERR("Failed to write OTP address register");
return rc;
}
rc = i2c_reg_write_byte_dt(&config->bus, SI7210_REG_OTP_CTRL, SI7210_BIT_OTP_CTRL_READEN);
if (rc) {
LOG_ERR("Failed to write OTP control register");
return rc;
}
/*
* No need to check for the data availability (SI7210_REG_OTP_CTRL, bit
* !BUSY), as the I2C bus timing ensure the data is available (see
* datasheet).
*/
rc = i2c_reg_read_byte_dt(&config->bus, SI7210_REG_OTP_DATA, value);
if (rc) {
LOG_ERR("Failed to read OTP data register");
return rc;
}
return 0;
}
static int si7210_read_sn(const struct device *dev, uint32_t *sn)
{
uint32_t val = 0;
for (int reg = SI7210_OTPREG_SN1; reg <= SI7210_OTPREG_SN4; reg++) {
uint8_t val8;
int rc;
rc = si7210_otp_reg_read_byte(dev, reg, &val8);
if (rc < 0) {
return rc;
}
val = (val << 8) | val8;
}
*sn = val;
return 0;
}
/* Set the DSPSIGSEL register unless it already has the correct value */
static int si7210_set_dspsigsel(const struct device *dev, uint8_t value)
{
const struct si7210_config *config = dev->config;
struct si7210_data *data = dev->data;
int rc;
if (data->reg_dspsigsel == value) {
return 0;
}
rc = i2c_reg_write_byte_dt(&config->bus, SI7210_REG_DSPSIGSEL, value);
if (rc < 0) {
LOG_ERR("Failed to select channel");
return rc;
}
data->reg_dspsigsel = value;
return 0;
}
/* Set the ARAUTOINC register unless it already has the correct value */
static int si7210_set_arautoinc(const struct device *dev, uint8_t value)
{
const struct si7210_config *config = dev->config;
struct si7210_data *data = dev->data;
int rc;
if (data->reg_arautoinc == value) {
return 0;
}
rc = i2c_reg_write_byte_dt(&config->bus, SI7210_REG_ARAUTOINC, value);
if (rc < 0) {
LOG_ERR("Failed to set the auto increment register");
return rc;
}
data->reg_arautoinc = value;
return 0;
}
static int si7210_sample_fetch_one(const struct device *dev, uint8_t channel, uint16_t *dspsig)
{
const struct si7210_config *config = dev->config;
uint16_t val;
int rc;
/* Select the channel */
rc = si7210_set_dspsigsel(dev, channel);
if (rc < 0) {
return rc;
}
/* Enable auto increment to be able to read DSPSIGM and DSPSIGL sequentially */
rc = si7210_set_arautoinc(dev, 1);
if (rc < 0) {
return rc;
}
/* Start a single conversion */
rc = i2c_reg_write_byte_dt(&config->bus, SI7210_REG_POWER_CTRL,
SI7210_BIT_POWER_CTRL_ONEBURST);
if (rc < 0) {
LOG_ERR("Failed to write power control register");
return rc;
}
/*
* No need to wait for the conversion to end, the I2C bus guarantees
* the timing (even at 400kHz)
*/
/* Read DSPSIG in one burst as auto increment is enabled */
rc = i2c_burst_read_dt(&config->bus, SI7210_REG_DSPSIGM, (uint8_t *)&val, sizeof(val));
if (rc < 0) {
LOG_ERR("Failed to read sample data");
return rc;
}
*dspsig = sys_be16_to_cpu(val) & 0x7fff;
return 0;
}
static int si7210_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct si7210_data *data = dev->data;
uint16_t dspsig;
int rc;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_AMBIENT_TEMP ||
chan == SENSOR_CHAN_MAGN_Z);
#ifdef CONFIG_PM_DEVICE
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
/* Do not allow sample fetching from suspended state */
if (state == PM_DEVICE_STATE_SUSPENDED)
return -EIO;
#endif
/* Prevent going into suspend in the middle of the conversion */
pm_device_busy_set(dev);
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_AMBIENT_TEMP) {
rc = si7210_sample_fetch_one(dev, SI7210_BIT_DSPSIGSEL_TEMP, &dspsig);
if (rc < 0) {
return rc;
}
data->temp_sample = dspsig >> 3;
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_MAGN_Z) {
rc = si7210_sample_fetch_one(dev, SI7210_BIT_DSPSIGSEL_MAG, &dspsig);
if (rc < 0) {
return rc;
}
data->mag_sample = dspsig;
}
pm_device_busy_clear(dev);
return 0;
}
static int si7210_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct si7210_data *data = dev->data;
int64_t tmp;
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
/* type conversion */
tmp = data->temp_sample;
/* temperature_raw = -3.83e-6 * value^2 + 0.16094 * value - 279.80 */
tmp = (-383 * tmp * tmp) / 100 + (160940 * tmp) - 279800000;
/* temperature = (1 + gain / 2048) * temperature_raw + offset / 16 */
tmp = (tmp * (2048 + data->otp_temp_gain)) / 2048;
tmp = tmp + (data->otp_temp_offset * 62500);
/*
* Additional offset of -0.222 x VDD. The datasheet recommends
* to use VDD = 3.3V if not known.
*/
tmp -= 732600;
val->val1 = tmp / 1000000;
val->val2 = tmp % 1000000;
break;
case SENSOR_CHAN_MAGN_Z:
/* type conversion */
tmp = data->mag_sample;
if (data->scale == si7210_scale_200G) {
/*
* Formula in mT (datasheet) for the 20mT scale: (value - 16384) * 0.00125
* => Formula in G for the 200G scale: (value - 16384) * 0.0125
*/
tmp = (tmp - 16384) * 12500;
} else {
/*
* Formula in mT (datasheet) for the 200mT scale: (value - 16384) * 0.0125
* => Formula in G for the 2000G scale: (value - 16384) * 0.125
*/
tmp = (tmp - 16384) * 1250;
}
val->val1 = tmp / 1000000;
val->val2 = tmp % 1000000;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api si7210_api_funcs = {
.sample_fetch = si7210_sample_fetch,
.channel_get = si7210_channel_get,
};
#ifdef CONFIG_PM_DEVICE
static int si7210_pm_action(const struct device *dev,
enum pm_device_action action)
{
int rc;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
/* Wake-up the chip */
rc = si7210_wakeup(dev);
break;
case PM_DEVICE_ACTION_SUSPEND:
/* Put the chip into sleep mode */
rc = si7210_sleep(dev);
break;
default:
return -ENOTSUP;
}
return rc;
}
#endif /* CONFIG_PM_DEVICE */
static int si7210_init(const struct device *dev)
{
const struct si7210_config *config = dev->config;
struct si7210_data *data = dev->data;
uint8_t chipid, part_base, part_variant;
uint32_t sn;
char rev;
int rc;
if (!device_is_ready(config->bus.bus)) {
LOG_ERR("I2C bus %s not ready!", config->bus.bus->name);
return -ENODEV;
}
/* Possibly wakeup device */
rc = si7210_wakeup(dev);
if (rc < 0) {
LOG_ERR("Failed to wake-up device");
return rc;
}
/* Read chip ID */
rc = i2c_reg_read_byte_dt(&config->bus, SI7210_REG_CHIPID, &chipid);
if (rc < 0) {
LOG_ERR("Failed to read chip ID");
return rc;
}
if ((chipid & 0xf0) != 0x10) {
LOG_ERR("Unsupported device ID");
return -EINVAL;
}
switch (chipid & 0x0f) {
case 0x04:
rev = 'B';
break;
default:
LOG_WRN("Unknown revision %d", chipid & 0x0f);
rev = '.';
}
/* Read part number */
rc = si7210_otp_reg_read_byte(dev, SI7210_OTPREG_PART_BASE, &part_base);
if (rc < 0) {
return rc;
}
rc = si7210_otp_reg_read_byte(dev, SI7210_OTPREG_PART_VARIANT, &part_variant);
if (rc < 0) {
return rc;
}
/* Read serial number */
rc = si7210_read_sn(dev, &sn);
if (rc < 0) {
return rc;
}
LOG_INF("Found Si72%02d-%c-%02d S/N %08x, at I2C address 0x%x",
part_base, rev, part_variant, sn, config->bus.addr);
/* Set default scale depending on the part variant */
data->scale = (part_variant == 5 || part_variant == 15) ?
si7210_scale_2000G : si7210_scale_200G;
/* Read temperature adjustment values */
rc = si7210_otp_reg_read_byte(dev, SI7210_OTPREG_TEMP_OFFSET, &data->otp_temp_offset);
if (rc < 0) {
return rc;
}
rc = si7210_otp_reg_read_byte(dev, SI7210_OTPREG_TEMP_GAIN, &data->otp_temp_gain);
if (rc < 0) {
return rc;
}
/* Reset the device */
rc = si7210_reset(dev);
if (rc < 0) {
LOG_ERR("Failed to reset the device");
return rc;
}
return 0;
}
/* Main instantiation macro */
#define DEFINE_SI7210(inst) \
static struct si7210_data si7210_data_##inst; \
static const struct si7210_config si7210_config_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
}; \
PM_DEVICE_DT_INST_DEFINE(inst, si7210_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, si7210_init, PM_DEVICE_DT_INST_GET(inst), \
&si7210_data_##inst, &si7210_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &si7210_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_SI7210)
``` | /content/code_sandbox/drivers/sensor/silabs/si7210/si7210.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,342 |
```unknown
# SI7060 temperature sensor configuration options
config SI7060
bool "SI7060 Temperature Sensor"
default y
depends on DT_HAS_SILABS_SI7060_ENABLED
select I2C
help
Enable driver for SI7060 temperature sensors.
``` | /content/code_sandbox/drivers/sensor/silabs/si7060/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 56 |
```c
/*
*
*/
#define DT_DRV_COMPAT silabs_si7060
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "si7060.h"
#define SIGN_BIT_MASK 0x7F
LOG_MODULE_REGISTER(si7060, CONFIG_SENSOR_LOG_LEVEL);
struct si7060_data {
uint16_t temperature;
};
struct si7060_config {
struct i2c_dt_spec i2c;
};
static int si7060_reg_read(const struct device *dev, uint8_t reg, uint8_t *val)
{
const struct si7060_config *config = dev->config;
if (i2c_reg_read_byte_dt(&config->i2c, reg, val)) {
return -EIO;
}
return 0;
}
static int si7060_reg_write(const struct device *dev, uint8_t reg, uint8_t val)
{
const struct si7060_config *config = dev->config;
return i2c_reg_write_byte_dt(&config->i2c, reg, val);
}
static int si7060_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct si7060_data *drv_data = dev->data;
if (si7060_reg_write(dev, SI7060_REG_CONFIG,
SI7060_ONE_BURST_VALUE) != 0) {
return -EIO;
}
int retval;
uint8_t dspsigm;
uint8_t dspsigl;
retval = si7060_reg_read(dev, SI7060_REG_TEMP_HIGH, &dspsigm);
retval += si7060_reg_read(dev, SI7060_REG_TEMP_LOW, &dspsigl);
if (retval == 0) {
drv_data->temperature = (256 * (dspsigm & SIGN_BIT_MASK))
+ dspsigl;
} else {
LOG_ERR("Read register err");
}
LOG_DBG("Sample_fetch retval: %d", retval);
return retval;
}
static int si7060_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct si7060_data *drv_data = dev->data;
int32_t uval;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
uval = ((55 * 160) + (drv_data->temperature - 16384)) >> 4;
val->val1 = uval / 10;
val->val2 = (uval % 10) * 100000;
LOG_DBG("Temperature = val1:%d, val2:%d", val->val1, val->val2);
return 0;
} else {
return -ENOTSUP;
}
}
static const struct sensor_driver_api si7060_api = {
.sample_fetch = &si7060_sample_fetch,
.channel_get = &si7060_channel_get,
};
static int si7060_chip_init(const struct device *dev)
{
const struct si7060_config *config = dev->config;
uint8_t value;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
if (si7060_reg_read(dev, SI7060_REG_CHIP_INFO, &value) != 0) {
return -EIO;
}
if ((value >> 4) != SI7060_CHIP_ID_VALUE) {
LOG_ERR("Bad chip id 0x%x", value);
return -ENOTSUP;
}
return 0;
}
static int si7060_init(const struct device *dev)
{
if (si7060_chip_init(dev) < 0) {
return -EINVAL;
}
return 0;
}
#define SI7060_DEFINE(inst) \
static struct si7060_data si7060_data_##inst; \
\
static const struct si7060_config si7060_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, si7060_init, NULL, \
&si7060_data_##inst, &si7060_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &si7060_api); \
DT_INST_FOREACH_STATUS_OKAY(SI7060_DEFINE)
``` | /content/code_sandbox/drivers/sensor/silabs/si7060/si7060.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 948 |
```objective-c
/*
*
*/
#ifndef NTC_THERMISTOR_H
#define NTC_THERMISTOR_H
#include <zephyr/types.h>
struct ntc_compensation {
const int32_t temp_c;
const uint32_t ohm;
};
struct ntc_type {
const struct ntc_compensation *comp;
int n_comp;
};
struct ntc_config {
bool connected_positive;
uint32_t pullup_uv;
uint32_t pullup_ohm;
uint32_t pulldown_ohm;
struct ntc_type type;
};
/**
* @brief Converts ohm to temperature in milli centigrade
*
* @param type: Pointer to ntc_type table info
* @param ohm: Read resistance of NTC thermistor
*
* @return temperature in milli centigrade
*/
int32_t ntc_get_temp_mc(const struct ntc_type *type, unsigned int ohm);
/**
* @brief Calculate the resistance read from NTC Thermistor
*
* @param cfg: NTC Thermistor configuration
* @sample_mv: Measured voltage in mV
*
* @return Thermistor resistance
*/
uint32_t ntc_get_ohm_of_thermistor(const struct ntc_config *cfg, int sample_mv);
#endif /* NTC_THERMISTOR_H */
``` | /content/code_sandbox/drivers/sensor/ntc_thermistor/ntc_thermistor.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 274 |
```c
/*
*
*/
#include <limits.h>
#include <stdlib.h>
#include <zephyr/devicetree.h>
#include "ntc_thermistor.h"
/**
* fixp_linear_interpolate() - interpolates a value from two known points
*
* @x0: x value of point 0
* @y0: y value of point 0
* @x1: x value of point 1
* @y1: y value of point 1
* @x: the linear interpolant
*/
static int ntc_fixp_linear_interpolate(int x0, int y0, int x1, int y1, int x)
{
if (y0 == y1 || x == x0) {
return y0;
}
if (x1 == x0 || x == x1) {
return y1;
}
return y0 + ((y1 - y0) * (x - x0) / (x1 - x0));
}
/**
* ntc_lookup_comp() - Finds indicies where ohm falls between
*
* @ohm: key value search is looking for
* @i_low: return Lower interval index value
* @i_high: return Higher interval index value
*/
static void ntc_lookup_comp(const struct ntc_type *type, unsigned int ohm, int *i_low, int *i_high)
{
int low = 0;
int high = type->n_comp - 1;
if (ohm > type->comp[low].ohm) {
high = low;
} else if (ohm < type->comp[high].ohm) {
low = high;
}
while (high - low > 1) {
int mid = (low + high) / 2;
if (ohm > type->comp[mid].ohm) {
high = mid;
} else {
low = mid;
}
}
*i_low = low;
*i_high = high;
}
/**
* ntc_get_ohm_of_thermistor() - Calculate the resistance read from NTC Thermistor
*
* @cfg: NTC Thermistor configuration
* @sample_mv: Measured voltage in mV
*/
uint32_t ntc_get_ohm_of_thermistor(const struct ntc_config *cfg, int sample_mv)
{
int pullup_mv = cfg->pullup_uv / 1000;
uint32_t ohm;
if (sample_mv <= 0) {
return cfg->connected_positive ? INT_MAX : 0;
}
if (sample_mv >= pullup_mv) {
return cfg->connected_positive ? 0 : INT_MAX;
}
if (cfg->connected_positive) {
ohm = cfg->pulldown_ohm * (pullup_mv - sample_mv) / sample_mv;
} else {
ohm = cfg->pullup_ohm * sample_mv / (pullup_mv - sample_mv);
}
return ohm;
}
int32_t ntc_get_temp_mc(const struct ntc_type *type, unsigned int ohm)
{
int low, high;
int temp;
ntc_lookup_comp(type, ohm, &low, &high);
/*
* First multiplying the table temperatures with 1000 to get to
* millicentigrades (which is what we want) and then interpolating
* will give the best precision.
*/
temp = ntc_fixp_linear_interpolate(type->comp[low].ohm, type->comp[low].temp_c * 1000,
type->comp[high].ohm, type->comp[high].temp_c * 1000,
ohm);
return temp;
}
``` | /content/code_sandbox/drivers/sensor/ntc_thermistor/ntc_thermistor_calc.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 800 |
```unknown
#
config NTC_THERMISTOR
bool "NTC Thermistor"
default y
depends on DT_HAS_NTC_THERMISTOR_GENERIC_ENABLED || \
DT_HAS_EPCOS_B57861S0103A039_ENABLED || \
DT_HAS_MURATA_NCP15WB473_ENABLED || \
DT_HAS_TDK_NTCG163JF103FT1_ENABLED || \
DT_HAS_MURATA_NCP15XH103_ENABLED
select ADC
help
Enable driver for Zephyr NTC Thermistor.
``` | /content/code_sandbox/drivers/sensor/ntc_thermistor/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 116 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/st/hts221/Kconfig"
source "drivers/sensor/st/i3g4250d/Kconfig"
source "drivers/sensor/st/iis2dh/Kconfig"
source "drivers/sensor/st/iis2dlpc/Kconfig"
source "drivers/sensor/st/iis2iclx/Kconfig"
source "drivers/sensor/st/iis2mdc/Kconfig"
source "drivers/sensor/st/iis328dq/Kconfig"
source "drivers/sensor/st/iis3dhhc/Kconfig"
source "drivers/sensor/st/ism330dhcx/Kconfig"
source "drivers/sensor/st/lis2de12/Kconfig"
source "drivers/sensor/st/lis2dh/Kconfig"
source "drivers/sensor/st/lis2ds12/Kconfig"
source "drivers/sensor/st/lis2du12/Kconfig"
source "drivers/sensor/st/lis2dux12/Kconfig"
source "drivers/sensor/st/lis2dw12/Kconfig"
source "drivers/sensor/st/lis2mdl/Kconfig"
source "drivers/sensor/st/lis3mdl/Kconfig"
source "drivers/sensor/st/lps22hb/Kconfig"
source "drivers/sensor/st/lps22hh/Kconfig"
source "drivers/sensor/st/lps25hb/Kconfig"
source "drivers/sensor/st/lps2xdf/Kconfig"
source "drivers/sensor/st/lsm303dlhc_magn/Kconfig"
source "drivers/sensor/st/lsm6ds0/Kconfig"
source "drivers/sensor/st/lsm6dsl/Kconfig"
source "drivers/sensor/st/lsm6dso/Kconfig"
source "drivers/sensor/st/lsm6dso16is/Kconfig"
source "drivers/sensor/st/lsm6dsv16x/Kconfig"
source "drivers/sensor/st/lsm9ds0_gyro/Kconfig"
source "drivers/sensor/st/lsm9ds0_mfd/Kconfig"
source "drivers/sensor/st/lsm9ds1/Kconfig"
source "drivers/sensor/st/qdec_stm32/Kconfig"
source "drivers/sensor/st/stm32_digi_temp/Kconfig"
source "drivers/sensor/st/stm32_temp/Kconfig"
source "drivers/sensor/st/stm32_vbat/Kconfig"
source "drivers/sensor/st/stm32_vref/Kconfig"
source "drivers/sensor/st/stts22h/Kconfig"
source "drivers/sensor/st/stts751/Kconfig"
source "drivers/sensor/st/vl53l0x/Kconfig"
source "drivers/sensor/st/vl53l1x/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/st/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 568 |
```unknown
# ST Microelectronics IIS328DQ 3-axis accelerometer driver
menuconfig IIS328DQ
bool "IIS328DQ I2C/SPI accelerometer sensor driver"
default y
depends on DT_HAS_ST_IIS328DQ_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS328DQ),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS328DQ),spi)
select HAS_STMEMSC
select USE_STDC_IIS328DQ
help
Enable driver for IIS328DQ accelerometer sensor driver
if IIS328DQ
module = IIS328DQ
thread_priority = 10
thread_stack_size = 1024
source "drivers/sensor/Kconfig.trigger_template"
if IIS328DQ_TRIGGER
config IIS328DQ_THRESHOLD
bool "Threshold detection"
help
Enable threshold interrupts
endif # IIS328DQ_TRIGGER
endif # IIS328DQ
``` | /content/code_sandbox/drivers/sensor/st/iis328dq/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 228 |
```c
/*
*
*/
#include <zephyr/drivers/adc.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/pm/device_runtime.h>
#include <zephyr/logging/log.h>
#include "ntc_thermistor.h"
LOG_MODULE_REGISTER(NTC_THERMISTOR, CONFIG_SENSOR_LOG_LEVEL);
struct ntc_thermistor_data {
struct k_mutex mutex;
int32_t raw;
int32_t sample_val;
};
struct ntc_thermistor_config {
const struct adc_dt_spec adc_channel;
const struct ntc_config ntc_cfg;
};
static int ntc_thermistor_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ntc_thermistor_data *data = dev->data;
const struct ntc_thermistor_config *cfg = dev->config;
enum pm_device_state pm_state;
int32_t val_mv;
int res;
struct adc_sequence sequence = {
.options = NULL,
.buffer = &data->raw,
.buffer_size = sizeof(data->raw),
.calibrate = false,
};
(void)pm_device_state_get(dev, &pm_state);
if (pm_state != PM_DEVICE_STATE_ACTIVE) {
return -EIO;
}
k_mutex_lock(&data->mutex, K_FOREVER);
adc_sequence_init_dt(&cfg->adc_channel, &sequence);
res = adc_read(cfg->adc_channel.dev, &sequence);
if (!res) {
val_mv = data->raw;
res = adc_raw_to_millivolts_dt(&cfg->adc_channel, &val_mv);
data->sample_val = val_mv;
}
k_mutex_unlock(&data->mutex);
return res;
}
static int ntc_thermistor_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ntc_thermistor_data *data = dev->data;
const struct ntc_thermistor_config *cfg = dev->config;
uint32_t ohm;
int32_t temp;
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
ohm = ntc_get_ohm_of_thermistor(&cfg->ntc_cfg, data->sample_val);
temp = ntc_get_temp_mc(&cfg->ntc_cfg.type, ohm);
val->val1 = temp / 1000;
val->val2 = (temp % 1000) * 1000;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api ntc_thermistor_driver_api = {
.sample_fetch = ntc_thermistor_sample_fetch,
.channel_get = ntc_thermistor_channel_get,
};
static int ntc_thermistor_init(const struct device *dev)
{
const struct ntc_thermistor_config *cfg = dev->config;
int err;
if (!adc_is_ready_dt(&cfg->adc_channel)) {
LOG_ERR("ADC controller device is not ready\n");
return -ENODEV;
}
err = adc_channel_setup_dt(&cfg->adc_channel);
if (err < 0) {
LOG_ERR("Could not setup channel err(%d)\n", err);
return err;
}
#ifdef CONFIG_PM_DEVICE_RUNTIME
pm_device_init_suspended(dev);
err = pm_device_runtime_enable(dev);
if (err) {
LOG_ERR("Failed to enable runtime power management");
return err;
}
#endif
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int ntc_thermistor_pm_action(const struct device *dev, enum pm_device_action action)
{
switch (action) {
case PM_DEVICE_ACTION_TURN_ON:
case PM_DEVICE_ACTION_RESUME:
case PM_DEVICE_ACTION_TURN_OFF:
case PM_DEVICE_ACTION_SUSPEND:
return 0;
default:
return -ENOTSUP;
}
}
#endif
#define NTC_THERMISTOR_DEFINE0(inst, id, _comp, _n_comp) \
static struct ntc_thermistor_data ntc_thermistor_driver_##id##inst; \
\
static const struct ntc_thermistor_config ntc_thermistor_cfg_##id##inst = { \
.adc_channel = ADC_DT_SPEC_INST_GET(inst), \
.ntc_cfg = \
{ \
.pullup_uv = DT_INST_PROP(inst, pullup_uv), \
.pullup_ohm = DT_INST_PROP(inst, pullup_ohm), \
.pulldown_ohm = DT_INST_PROP(inst, pulldown_ohm), \
.connected_positive = DT_INST_PROP(inst, connected_positive), \
.type = { \
.comp = _comp, \
.n_comp = _n_comp, \
}, \
}, \
}; \
\
PM_DEVICE_DT_INST_DEFINE(inst, ntc_thermistor_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE( \
inst, ntc_thermistor_init, PM_DEVICE_DT_INST_GET(inst), \
&ntc_thermistor_driver_##id##inst, &ntc_thermistor_cfg_##id##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &ntc_thermistor_driver_api);
#define NTC_THERMISTOR_DEFINE(inst, id, comp) \
NTC_THERMISTOR_DEFINE0(inst, id, comp, ARRAY_SIZE(comp))
/* ntc-thermistor-generic */
#define DT_DRV_COMPAT ntc_thermistor_generic
#define NTC_THERMISTOR_GENERIC_DEFINE(inst) \
static const uint32_t comp_##inst[] = DT_INST_PROP(inst, zephyr_compensation_table); \
NTC_THERMISTOR_DEFINE0(inst, DT_DRV_COMPAT, (struct ntc_compensation *)comp_##inst, \
ARRAY_SIZE(comp_##inst) / 2)
DT_INST_FOREACH_STATUS_OKAY(NTC_THERMISTOR_GENERIC_DEFINE)
/* epcos,b57861s0103a039 */
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT epcos_b57861s0103a039
static __unused const struct ntc_compensation comp_epcos_b57861s0103a039[] = {
{ -25, 146676 },
{ -15, 78875 },
{ -5, 44424 },
{ 5, 26075 },
{ 15, 15881 },
{ 25, 10000 },
{ 35, 6488 },
{ 45, 4326 },
{ 55, 2956 },
{ 65, 2066 },
{ 75, 1474 },
{ 85, 1072 },
{ 95, 793 },
{ 105, 596 },
{ 115, 454 },
{ 125, 351 },
};
DT_INST_FOREACH_STATUS_OKAY_VARGS(NTC_THERMISTOR_DEFINE, DT_DRV_COMPAT,
comp_epcos_b57861s0103a039)
/* murata,ncp15wb473 */
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT murata_ncp15wb473
static __unused const struct ntc_compensation comp_murata_ncp15wb473[] = {
{ -25, 655802 },
{ -15, 360850 },
{ -5, 206463 },
{ 5, 122259 },
{ 15, 74730 },
{ 25, 47000 },
{ 35, 30334 },
{ 45, 20048 },
{ 55, 13539 },
{ 65, 9328 },
{ 75, 6544 },
{ 85, 4674 },
{ 95, 3388 },
{ 105, 2494 },
{ 115, 1860 },
{ 125, 1406 },
};
DT_INST_FOREACH_STATUS_OKAY_VARGS(NTC_THERMISTOR_DEFINE, DT_DRV_COMPAT,
comp_murata_ncp15wb473)
/* tdk,ntcg163jf103ft1 */
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT tdk_ntcg163jf103ft1
static __unused const struct ntc_compensation comp_tdk_ntcg163jf103ft1[] = {
{ -25, 86560 },
{ -15, 53460 },
{ -5, 33930 },
{ 5, 22070 },
{ 15, 14700 },
{ 25, 10000 },
{ 35, 6942 },
{ 45, 4911 },
{ 55, 3536 },
{ 65, 2588 },
{ 75, 1924 },
{ 85, 1451 },
{ 95, 1110 },
{ 105, 860 },
{ 115, 674 },
{ 125, 534 },
};
DT_INST_FOREACH_STATUS_OKAY_VARGS(NTC_THERMISTOR_DEFINE, DT_DRV_COMPAT,
comp_tdk_ntcg163jf103ft1)
/* murata,ncp15xh103 */
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT murata_ncp15xh103
static __unused const struct ntc_compensation comp_murata_ncp15xh103[] = {
{ -25, 87558 },
{ -15, 53649 },
{ -5, 33892 },
{ 5, 22021 },
{ 15, 14673 },
{ 25, 10000 },
{ 35, 6947 },
{ 45, 4916 },
{ 55, 3535 },
{ 64, 2586 },
{ 75, 1924 },
{ 85, 1452 },
{ 95, 1109 },
{ 105, 858 },
{ 115, 671 },
{ 125, 531 },
};
DT_INST_FOREACH_STATUS_OKAY_VARGS(NTC_THERMISTOR_DEFINE, DT_DRV_COMPAT,
comp_murata_ncp15xh103)
``` | /content/code_sandbox/drivers/sensor/ntc_thermistor/ntc_thermistor.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,257 |
```objective-c
/* ST Microelectronics IIS328DQ 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_IIS328DQ_IIS328DQ_H_
#define ZEPHYR_DRIVERS_SENSOR_IIS328DQ_IIS328DQ_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <stmemsc.h>
#include "iis328dq_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
/**
* struct iis328dq_dev_config - iis328dq hw configuration
* @bus_name: Pointer to bus master identifier.
* @pm: Power mode (lis2dh_powermode).
* @irq_dev_name: Pointer to GPIO PORT identifier.
* @irq_pin: GPIO pin number connected to sensor int pin.
* @drdy_int: Sensor drdy int (int1/int2).
*/
struct iis328dq_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t range;
#ifdef CONFIG_IIS328DQ_TRIGGER
const struct gpio_dt_spec gpio_int1;
const struct gpio_dt_spec gpio_int2;
/* interrupt pad to be used for DRDY interrupts, or -1 if not configured */
int8_t drdy_pad;
#ifdef CONFIG_IIS328DQ_THRESHOLD
/* interrupt pad to be used for threshold interrupts, or -1 if not configured */
int8_t threshold_pad;
#endif /* CONFIG_IIS328DQ_THRESHOLD */
#endif /* CONFIG_IIS328DQ_TRIGGER */
};
/* sensor data */
struct iis328dq_data {
const struct device *dev;
int16_t acc[3];
/* sensitivity in mg/LSB */
uint8_t gain;
#ifdef CONFIG_IIS328DQ_TRIGGER
struct gpio_callback int1_cb;
struct gpio_callback int2_cb;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trig;
#ifdef CONFIG_IIS328DQ_THRESHOLD
sensor_trigger_handler_t threshold_handler;
const struct sensor_trigger *threshold_trig;
#endif /* CONFIG_IIS328DQ_THRESHOLD */
#if defined(CONFIG_IIS328DQ_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS328DQ_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS328DQ_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif /* CONFIG_IIS328DQ_TRIGGER_GLOBAL_THREAD */
#endif /* CONFIG_IIS328DQ_TRIGGER */
};
#ifdef CONFIG_IIS328DQ_TRIGGER
int iis328dq_init_interrupt(const struct device *dev);
int iis328dq_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* CONFIG_IIS328DQ_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_IIS328DQ_IIS328DQ_H_ */
``` | /content/code_sandbox/drivers/sensor/st/iis328dq/iis328dq.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 736 |
```c
/* ST Microelectronics IIS328DQ 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis328dq
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "iis328dq.h"
LOG_MODULE_DECLARE(IIS328DQ, CONFIG_SENSOR_LOG_LEVEL);
static int iis328dq_set_int_pad_state(const struct device *dev, uint8_t pad, bool enable)
{
const struct iis328dq_config *cfg = dev->config;
int state = enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
if (pad == 1) {
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int1, state);
} else if (pad == 2) {
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int2, state);
} else {
return -EINVAL;
}
}
/**
* iis328dq_enable_int - enable selected int pin to generate interrupt
*/
static int iis328dq_enable_int(const struct device *dev, const struct sensor_trigger *trig,
int enable)
{
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
if (cfg->drdy_pad == 1) {
/* route DRDY to PAD1 */
if (iis328dq_pin_int1_route_set(ctx, IIS328DQ_PAD1_DRDY) != 0) {
return -EIO;
}
} else if (cfg->drdy_pad == 2) {
/* route DRDY to PAD2 */
if (iis328dq_pin_int2_route_set(ctx, IIS328DQ_PAD2_DRDY) != 0) {
return -EIO;
}
} else {
LOG_ERR("No interrupt pin configured for DRDY in devicetree");
return -ENOTSUP;
}
return iis328dq_set_int_pad_state(dev, cfg->drdy_pad, enable);
#ifdef CONFIG_IIS328DQ_THRESHOLD
case SENSOR_TRIG_THRESHOLD: {
/* set up internal INT1 for lower thresholds */
int1_on_th_conf_t int1_conf = {0};
switch (trig->chan) {
case SENSOR_CHAN_ACCEL_X:
int1_conf.int1_xlie = 1;
break;
case SENSOR_CHAN_ACCEL_Y:
int1_conf.int1_ylie = 1;
break;
case SENSOR_CHAN_ACCEL_Z:
int1_conf.int1_zlie = 1;
break;
case SENSOR_CHAN_ACCEL_XYZ:
int1_conf.int1_xlie = 1;
int1_conf.int1_ylie = 1;
int1_conf.int1_zlie = 1;
break;
default:
LOG_ERR("Invalid sensor channel %d", trig->chan);
return -EINVAL;
}
if (iis328dq_int1_on_threshold_conf_set(ctx, int1_conf) != 0) {
return -EIO;
}
/* set up internal INT2 for uppper thresholds */
int2_on_th_conf_t int2_conf = {0};
int2_conf.int2_xhie = int1_conf.int1_xlie;
int2_conf.int2_yhie = int1_conf.int1_ylie;
int2_conf.int2_zhie = int1_conf.int1_zlie;
if (iis328dq_int2_on_threshold_conf_set(ctx, int2_conf) != 0) {
return -EIO;
}
if (cfg->threshold_pad == 1) {
/* route both internal interrupts to PAD1 */
if (iis328dq_pin_int1_route_set(ctx, IIS328DQ_PAD1_INT1_OR_INT2_SRC) != 0) {
return -EIO;
}
} else if (cfg->threshold_pad == 2) {
/* route both internal interrupts to PAD2 */
if (iis328dq_pin_int2_route_set(ctx, IIS328DQ_PAD2_INT1_OR_INT2_SRC) != 0) {
return -EIO;
}
} else {
LOG_ERR("No interrupt pin configured for DRDY in devicetree");
return -ENOTSUP;
}
return iis328dq_set_int_pad_state(dev, cfg->threshold_pad, enable);
}
#endif /* CONFIG_IIS328DQ_THRESHOLD */
default:
LOG_ERR("Unsupported trigger interrupt route %d", trig->type);
return -ENOTSUP;
}
return 0;
}
/**
* iis328dq_trigger_set - link external trigger to event data ready
*/
int iis328dq_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct iis328dq_data *iis328dq = dev->data;
int16_t raw[3];
int state = (handler != NULL) ? PROPERTY_ENABLE : PROPERTY_DISABLE;
if (!cfg->gpio_int1.port && !cfg->gpio_int2.port) {
/* no interrupts configured */
return -ENOTSUP;
}
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
iis328dq->drdy_handler = handler;
iis328dq->drdy_trig = trig;
if (state) {
/* dummy read: re-trigger interrupt */
iis328dq_acceleration_raw_get(ctx, raw);
}
break;
#ifdef CONFIG_IIS328DQ_THRESHOLD
case SENSOR_TRIG_THRESHOLD:
iis328dq->threshold_handler = handler;
iis328dq->threshold_trig = trig;
break;
#endif /* CONFIG_IIS328DQ_THRESHOLD */
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
return iis328dq_enable_int(dev, trig, state);
}
/**
* iis328dq_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void iis328dq_handle_interrupt(const struct device *dev)
{
const struct iis328dq_config *cfg = dev->config;
struct iis328dq_data *data = dev->data;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
iis328dq_status_reg_t status;
iis328dq_int1_src_t sources1;
iis328dq_int2_src_t sources2;
iis328dq_status_reg_get(ctx, &status);
if (status.zyxda) {
if (data->drdy_handler) {
data->drdy_handler(dev, data->drdy_trig);
}
iis328dq_set_int_pad_state(dev, cfg->drdy_pad, true);
}
#ifdef CONFIG_IIS328DQ_THRESHOLD
iis328dq_int1_src_get(ctx, &sources1);
iis328dq_int2_src_get(ctx, &sources2);
if (sources1.ia || sources2.ia) {
if (data->threshold_handler) {
data->threshold_handler(dev, data->threshold_trig);
}
iis328dq_set_int_pad_state(dev, cfg->threshold_pad, true);
}
#endif /* CONFIG_IIS328DQ_THRESHOLD */
}
static void iis328dq_int1_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins)
{
struct iis328dq_data *iis328dq = CONTAINER_OF(cb, struct iis328dq_data, int1_cb);
ARG_UNUSED(pins);
iis328dq_set_int_pad_state(iis328dq->dev, 1, true);
#if defined(CONFIG_IIS328DQ_TRIGGER_OWN_THREAD)
k_sem_give(&iis328dq->gpio_sem);
#elif defined(CONFIG_IIS328DQ_TRIGGER_GLOBAL_THREAD)
k_work_submit(&iis328dq->work);
#endif /* CONFIG_IIS328DQ_TRIGGER_OWN_THREAD */
}
static void iis328dq_int2_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins)
{
struct iis328dq_data *iis328dq = CONTAINER_OF(cb, struct iis328dq_data, int2_cb);
ARG_UNUSED(pins);
iis328dq_set_int_pad_state(iis328dq->dev, 2, true);
#if defined(CONFIG_IIS328DQ_TRIGGER_OWN_THREAD)
k_sem_give(&iis328dq->gpio_sem);
#elif defined(CONFIG_IIS328DQ_TRIGGER_GLOBAL_THREAD)
k_work_submit(&iis328dq->work);
#endif /* CONFIG_IIS328DQ_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_IIS328DQ_TRIGGER_OWN_THREAD
static void iis328dq_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct iis328dq_data *iis328dq = p1;
while (1) {
k_sem_take(&iis328dq->gpio_sem, K_FOREVER);
iis328dq_handle_interrupt(iis328dq->dev);
}
}
#endif /* CONFIG_IIS328DQ_TRIGGER_OWN_THREAD */
#ifdef CONFIG_IIS328DQ_TRIGGER_GLOBAL_THREAD
static void iis328dq_work_cb(struct k_work *work)
{
struct iis328dq_data *iis328dq = CONTAINER_OF(work, struct iis328dq_data, work);
iis328dq_handle_interrupt(iis328dq->dev);
}
#endif /* CONFIG_IIS328DQ_TRIGGER_GLOBAL_THREAD */
int iis328dq_init_interrupt(const struct device *dev)
{
struct iis328dq_data *iis328dq = dev->data;
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
if (!cfg->gpio_int1.port && !cfg->gpio_int2.port) {
/* no interrupts configured, nothing to do */
return 0;
}
/* setup data ready gpio interrupt (INT1 and INT2) */
if (cfg->gpio_int1.port) {
if (!gpio_is_ready_dt(&cfg->gpio_int1)) {
LOG_ERR("INT_1 pin is not ready");
return -EINVAL;
}
}
if (cfg->gpio_int2.port) {
if (!gpio_is_ready_dt(&cfg->gpio_int2)) {
LOG_ERR("INT_2 pin is not ready");
return -EINVAL;
}
}
#if defined(CONFIG_IIS328DQ_TRIGGER_OWN_THREAD)
k_sem_init(&iis328dq->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&iis328dq->thread, iis328dq->thread_stack,
CONFIG_IIS328DQ_THREAD_STACK_SIZE, iis328dq_thread, iis328dq, NULL, NULL,
K_PRIO_COOP(CONFIG_IIS328DQ_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_IIS328DQ_TRIGGER_GLOBAL_THREAD)
iis328dq->work.handler = iis328dq_work_cb;
#endif /* CONFIG_IIS328DQ_TRIGGER_OWN_THREAD */
if (cfg->gpio_int1.port) {
ret = gpio_pin_configure_dt(&cfg->gpio_int1, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure INT_1 gpio");
return ret;
}
gpio_init_callback(&iis328dq->int1_cb, iis328dq_int1_gpio_callback,
BIT(cfg->gpio_int1.pin));
if (gpio_add_callback(cfg->gpio_int1.port, &iis328dq->int1_cb) < 0) {
LOG_ERR("Could not set INT1 callback");
return -EIO;
}
}
if (cfg->gpio_int2.port) {
ret = gpio_pin_configure_dt(&cfg->gpio_int2, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure INT_2 gpio");
return ret;
}
gpio_init_callback(&iis328dq->int2_cb, iis328dq_int2_gpio_callback,
BIT(cfg->gpio_int2.pin));
if (gpio_add_callback(cfg->gpio_int2.port, &iis328dq->int2_cb) < 0) {
LOG_ERR("Could not set INT2 callback");
return -EIO;
}
}
if (iis328dq_int1_notification_set(ctx, IIS328DQ_INT1_PULSED) != 0) {
return -EIO;
}
if (iis328dq_int2_notification_set(ctx, IIS328DQ_INT2_PULSED) != 0) {
return -EIO;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/iis328dq/iis328dq_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,840 |
```c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/gpio.h>
#include "lsm9ds0_gyro.h"
extern struct lsm9ds0_gyro_data lsm9ds0_gyro_data;
LOG_MODULE_DECLARE(LSM9DS0_GYRO, CONFIG_SENSOR_LOG_LEVEL);
static inline void setup_drdy(const struct device *dev,
bool enable)
{
const struct lsm9ds0_gyro_config *cfg = dev->config;
gpio_pin_interrupt_configure_dt(&cfg->int_gpio,
enable ? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE);
}
int lsm9ds0_gyro_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct lsm9ds0_gyro_data *data = dev->data;
const struct lsm9ds0_gyro_config * const config =
dev->config;
uint8_t state;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (trig->type == SENSOR_TRIG_DATA_READY) {
setup_drdy(dev, false);
state = 0U;
if (handler) {
state = 1U;
}
data->handler_drdy = handler;
data->trigger_drdy = trig;
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_CTRL_REG3_G,
LSM9DS0_GYRO_MASK_CTRL_REG3_G_I2_DRDY,
state << LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_I2_DRDY)
< 0) {
LOG_DBG("failed to set DRDY interrupt");
return -EIO;
}
setup_drdy(dev, true);
return 0;
}
return -ENOTSUP;
}
static void lsm9ds0_gyro_gpio_drdy_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lsm9ds0_gyro_data *data =
CONTAINER_OF(cb, struct lsm9ds0_gyro_data, gpio_cb);
setup_drdy(data->dev, false);
k_sem_give(&data->sem);
}
static void lsm9ds0_gyro_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
const struct device *dev = p1;
struct lsm9ds0_gyro_data *data = dev->data;
while (1) {
k_sem_take(&data->sem, K_FOREVER);
if (data->handler_drdy) {
data->handler_drdy(dev, data->trigger_drdy);
}
setup_drdy(dev, true);
}
}
int lsm9ds0_gyro_init_interrupt(const struct device *dev)
{
const struct lsm9ds0_gyro_config * const config =
dev->config;
struct lsm9ds0_gyro_data *data = dev->data;
data->dev = dev;
k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_LSM9DS0_GYRO_THREAD_STACK_SIZE,
lsm9ds0_gyro_thread_main,
(void *)dev, NULL, NULL, K_PRIO_COOP(10), 0, K_NO_WAIT);
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
gpio_init_callback(&data->gpio_cb,
lsm9ds0_gyro_gpio_drdy_callback,
BIT(config->int_gpio.pin));
if (gpio_add_callback(config->int_gpio.port, &data->gpio_cb) < 0) {
LOG_DBG("failed to set gpio callback");
return -EINVAL;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds0_gyro/lsm9ds0_gyro_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 933 |
```c
/* ST Microelectronics IIS328DQ 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis328dq
#include <string.h>
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#elif DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif
#include "iis328dq.h"
LOG_MODULE_REGISTER(IIS328DQ, CONFIG_SENSOR_LOG_LEVEL);
/**
* iis328dq_set_odr - set new Full Scale (in g)
*/
static int iis328dq_set_range(const struct device *dev, uint8_t fs)
{
int err;
struct iis328dq_data *iis328dq = dev->data;
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
iis328dq_fs_t fs_reg;
uint8_t gain;
if (fs <= 2) {
fs_reg = IIS328DQ_2g;
gain = 1;
} else if (fs <= 4) {
fs_reg = IIS328DQ_4g;
gain = 2;
} else if (fs <= 8) {
fs_reg = IIS328DQ_8g;
gain = 4;
} else {
LOG_ERR("FS too high");
return -ENOTSUP;
}
err = iis328dq_full_scale_set(ctx, fs_reg);
if (!err) {
iis328dq->gain = gain;
}
return err;
}
/**
* iis328dq_set_odr - set new Output Data Rate/sampling frequency (in Hz)
*/
static int iis328dq_set_odr(const struct device *dev, uint16_t odr)
{
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
iis328dq_dr_t odr_reg;
if (odr == 0U) {
odr_reg = IIS328DQ_ODR_OFF;
} else if (odr <= 1) {
odr_reg = IIS328DQ_ODR_1Hz;
} else if (odr <= 2) {
/* not sure what "5Hz2" is about, datasheet says PM=0b100 is 2Hz
* path_to_url
*/
odr_reg = IIS328DQ_ODR_5Hz2;
} else if (odr <= 5) {
odr_reg = IIS328DQ_ODR_5Hz;
} else if (odr <= 10) {
odr_reg = IIS328DQ_ODR_10Hz;
} else if (odr <= 50) {
odr_reg = IIS328DQ_ODR_50Hz;
} else if (odr <= 100) {
odr_reg = IIS328DQ_ODR_100Hz;
} else if (odr <= 400) {
odr_reg = IIS328DQ_ODR_400Hz;
} else if (odr <= 1000) {
odr_reg = IIS328DQ_ODR_1kHz;
} else {
LOG_ERR("ODR too high");
return -ENOTSUP;
}
if (iis328dq_data_rate_set(ctx, odr_reg) != 0) {
LOG_ERR("Failed to set ODR");
return -EIO;
}
return 0;
}
static inline void iis328dq_convert(struct sensor_value *val, int raw_val, uint8_t gain)
{
int64_t dval;
/* Gain is in mg/LSB */
/* Convert to m/s^2 */
dval = ((int64_t)raw_val * gain * SENSOR_G) / 1000LL;
val->val1 = dval / 1000000LL;
val->val2 = dval % 1000000LL;
}
static inline void iis328dq_channel_get_acc(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
int i;
uint8_t ofs_start, ofs_stop;
struct iis328dq_data *iis328dq = dev->data;
struct sensor_value *pval = val;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_ACCEL_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_ACCEL_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U;
ofs_stop = 2U;
break;
}
for (i = ofs_start; i <= ofs_stop; i++) {
iis328dq_convert(pval++, iis328dq->acc[i], iis328dq->gain);
}
}
static int iis328dq_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
iis328dq_channel_get_acc(dev, chan, val);
return 0;
default:
LOG_DBG("Channel not supported");
break;
}
return -ENOTSUP;
}
#ifdef CONFIG_IIS328DQ_THRESHOLD
static int iis328dq_set_threshold(const struct device *dev, bool is_lower,
const struct sensor_value *val)
{
int err;
const struct iis328dq_config *cfg = dev->config;
struct iis328dq_data *iis328dq = dev->data;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (val->val1 < 0 || val->val2 < 0) {
/* thresholds are absolute */
return -EINVAL;
}
int64_t micro_ms2 = (val->val1 * INT64_C(1000000)) + val->val2;
/* factor guessed from similar-looking LIS2DH12 datasheet */
uint8_t mg_per_digit = iis328dq->gain * 16;
int16_t val_raw = (micro_ms2 * 1000LL) / SENSOR_G / mg_per_digit;
if (is_lower) {
/* internal INT1 handles lower threshold */
err = iis328dq_int1_treshold_set(ctx, val_raw);
if (err) {
LOG_ERR("Could not set INT1_THS to 0x%02X, error %d", val_raw, err);
return err;
}
} else {
/* internal INT2 handles lower threshold */
err = iis328dq_int2_treshold_set(ctx, val_raw);
if (err) {
LOG_ERR("Could not set INT2_THS to 0x%02X, error %d", val_raw, err);
return err;
}
}
return 0;
}
static int iis328dq_set_duration(const struct device *dev, uint16_t dur)
{
int err;
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (dur > 0x7F) {
LOG_WRN("Duration value %u too large", dur);
return -EINVAL;
}
err = iis328dq_int1_dur_set(ctx, dur);
if (err) {
LOG_ERR("Could not set INT1_DUR to 0x%02X, error %d", dur, err);
return err;
}
err = iis328dq_int2_dur_set(ctx, dur);
if (err) {
LOG_ERR("Could not set INT2_DUR to 0x%02X, error %d", dur, err);
return err;
}
return 0;
}
#endif /* CONFIG_IIS328DQ_THRESHOLD */
#define IIS328DQ_ATTR_DURATION SENSOR_ATTR_PRIV_START
static int iis328dq_dev_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return iis328dq_set_range(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis328dq_set_odr(dev, val->val1);
#ifdef CONFIG_IIS328DQ_THRESHOLD
case SENSOR_ATTR_LOWER_THRESH:
case SENSOR_ATTR_UPPER_THRESH:
if (chan != SENSOR_CHAN_ACCEL_XYZ) {
LOG_ERR("Threshold cannot be set per-channel");
return -ENOTSUP;
}
return iis328dq_set_threshold(dev, attr == SENSOR_ATTR_LOWER_THRESH, val);
case IIS328DQ_ATTR_DURATION:
if (chan != SENSOR_CHAN_ACCEL_XYZ) {
LOG_ERR("Duration cannot be set per-channel");
return -ENOTSUP;
}
return iis328dq_set_duration(dev, val->val1);
#endif /* CONFIG_IIS328DQ_THRESHOLD */
default:
LOG_DBG("Acc attribute not supported");
break;
}
return -ENOTSUP;
}
static int iis328dq_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_ALL:
return iis328dq_dev_config(dev, chan, attr, val);
default:
LOG_DBG("Attr not supported on %d channel", chan);
break;
}
return -ENOTSUP;
}
static int iis328dq_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct iis328dq_data *iis328dq = dev->data;
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int16_t buf[3];
/* fetch raw data sample */
if (iis328dq_acceleration_raw_get(ctx, buf) < 0) {
LOG_DBG("Failed to fetch raw data sample");
return -EIO;
}
iis328dq->acc[0] = buf[0] >> 4;
iis328dq->acc[1] = buf[1] >> 4;
iis328dq->acc[2] = buf[2] >> 4;
return 0;
}
static const struct sensor_driver_api iis328dq_driver_api = {
.attr_set = iis328dq_attr_set,
#if CONFIG_IIS328DQ_TRIGGER
.trigger_set = iis328dq_trigger_set,
#endif /* CONFIG_IIS328DQ_TRIGGER */
.sample_fetch = iis328dq_sample_fetch,
.channel_get = iis328dq_channel_get,
};
static int iis328dq_init(const struct device *dev)
{
struct iis328dq_data *iis328dq = dev->data;
const struct iis328dq_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t reg_value;
iis328dq->dev = dev;
/* check chip ID */
if (iis328dq_device_id_get(ctx, ®_value) < 0) {
return -EIO;
}
if (reg_value != IIS328DQ_ID) {
LOG_ERR("Invalid chip ID");
return -EINVAL;
}
/* reset device */
if (iis328dq_boot_set(ctx, PROPERTY_ENABLE) < 0) {
return -EIO;
}
k_sleep(K_MSEC(100));
if (iis328dq_boot_get(ctx, ®_value) < 0) {
return -EIO;
}
if (reg_value != PROPERTY_DISABLE) {
LOG_ERR("BOOT did not deassert");
return -EIO;
}
if (iis328dq_block_data_update_set(ctx, PROPERTY_ENABLE) < 0) {
return -EIO;
}
/* set default odr to 12.5Hz acc */
if (iis328dq_set_odr(dev, 12) < 0) {
LOG_ERR("odr init error (12.5 Hz)");
return -EIO;
}
if (iis328dq_set_range(dev, cfg->range) < 0) {
LOG_ERR("range init error %d", cfg->range);
return -EIO;
}
#ifdef CONFIG_IIS328DQ_TRIGGER
if (iis328dq_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupts");
return -EIO;
}
#endif /* CONFIG_IIS328DQ_TRIGGER */
return 0;
}
/*
* Device creation macro, shared by IIS328DQ_DEFINE_SPI() and
* IIS328DQ_DEFINE_I2C().
*/
#define IIS328DQ_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, iis328dq_init, NULL, &iis328dq_data_##inst, \
&iis328dq_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &iis328dq_driver_api);
#ifdef CONFIG_IIS328DQ_TRIGGER
#ifdef CONFIG_IIS328DQ_THRESHOLD
#define IIS328DQ_CFG_IRQ_THRESHOLD(inst) \
.threshold_pad = DT_INST_PROP_OR(inst, threshold_int_pad, -1),
#else
#define IIS328DQ_CFG_IRQ_THRESHOLD(inst)
#endif /* CONFIG_IIS328DQ_THRESHOLD */
#define IIS328DQ_CFG_IRQ(inst) \
.gpio_int1 = GPIO_DT_SPEC_INST_GET_OR(inst, int1_gpios, {0}), \
.gpio_int2 = GPIO_DT_SPEC_INST_GET_OR(inst, int2_gpios, {0}), \
.drdy_pad = DT_INST_PROP_OR(inst, drdy_int_pad, -1), IIS328DQ_CFG_IRQ_THRESHOLD(inst)
#else
#define IIS328DQ_CFG_IRQ(inst)
#endif /* CONFIG_IIS328DQ_TRIGGER */
#define IIS328DQ_CONFIG_COMMON(inst) \
.range = DT_INST_PROP(inst, range), \
IF_ENABLED(UTIL_OR(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
DT_INST_NODE_HAS_PROP(inst, int2_gpios)), \
(IIS328DQ_CFG_IRQ(inst)))
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#define IIS328DQ_SPI_OPERATION \
(SPI_WORD_SET(8) | SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA)
#define IIS328DQ_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI_INCR(&iis328dq_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = \
{ \
.spi = SPI_DT_SPEC_INST_GET(inst, IIS328DQ_SPI_OPERATION, \
0), \
}, \
IIS328DQ_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define IIS328DQ_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C_INCR(&iis328dq_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = \
{ \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
IIS328DQ_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define IIS328DQ_DEFINE(inst) \
static struct iis328dq_data iis328dq_data_##inst; \
static const struct iis328dq_config iis328dq_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), (IIS328DQ_CONFIG_SPI(inst)), \
(IIS328DQ_CONFIG_I2C(inst))); \
IIS328DQ_DEVICE_INIT(inst) \
IF_ENABLED(DT_INST_NODE_HAS_PROP(inst, drdy_int_pad), \
(BUILD_ASSERT( \
DT_INST_NODE_HAS_PROP( \
inst, CONCAT(int, DT_INST_PROP(inst, drdy_int_pad), _gpios)), \
"No GPIO pin defined for IIS328DQ DRDY interrupt");)) \
IF_ENABLED(DT_INST_NODE_HAS_PROP(inst, threshold_int_pad), \
(BUILD_ASSERT(DT_INST_NODE_HAS_PROP( \
inst, CONCAT(int, DT_INST_PROP(inst, threshold_int_pad), \
_gpios)), \
"No GPIO pin defined for IIS328DQ threshold interrupt");)) \
IF_ENABLED( \
UTIL_AND(DT_INST_NODE_HAS_PROP(inst, drdy_int_pad), \
DT_INST_NODE_HAS_PROP(inst, threshold_int_pad)), \
(BUILD_ASSERT( \
DT_INST_PROP(inst, drdy_int_pad) != \
DT_INST_PROP(inst, threshold_int_pad), \
"IIS328DQ DRDY interrupt and threshold interrupt cannot share a pin");))
DT_INST_FOREACH_STATUS_OKAY(IIS328DQ_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/iis328dq/iis328dq.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,868 |
```unknown
# LSM9DS0 gyroscope sensor configuration options
menuconfig LSM9DS0_GYRO
bool "LSM9DS0 I2C gyroscope Chip"
default y
depends on DT_HAS_ST_LSM9DS0_GYRO_ENABLED
select I2C
help
Enable driver for LSM9DS0 I2C-based gyroscope sensor.
if LSM9DS0_GYRO
menu "Attributes"
choice
prompt "Default full-scale"
default LSM9DS0_GYRO_FULLSCALE_245
help
Specify the default full-scale.
config LSM9DS0_GYRO_FULLSCALE_245
bool "245 DPS"
config LSM9DS0_GYRO_FULLSCALE_500
bool "500 DPS"
config LSM9DS0_GYRO_FULLSCALE_2000
bool "2000 DPS"
endchoice
config LSM9DS0_GYRO_FULLSCALE_RUNTIME
bool "Dynamic full-scale"
help
Enable alteration of full-scale attribute at runtime.
choice
prompt "Default sampling rate frequency"
default LSM9DS0_GYRO_SAMPLING_RATE_95
help
Specify the default sampling rate frequency.
config LSM9DS0_GYRO_SAMPLING_RATE_95
bool "95 Hz"
config LSM9DS0_GYRO_SAMPLING_RATE_190
bool "190 Hz"
config LSM9DS0_GYRO_SAMPLING_RATE_380
bool "380 Hz"
config LSM9DS0_GYRO_SAMPLING_RATE_760
bool "760 Hz"
endchoice
config LSM9DS0_GYRO_SAMPLING_RATE_RUNTIME
bool "Dynamic sampling rate"
help
Enable alteration of sampling rate frequency at runtime.
endmenu
config LSM9DS0_GYRO_TRIGGERS
bool "Triggers"
depends on GPIO
config LSM9DS0_GYRO_THREAD_STACK_SIZE
int "Thread stack size"
depends on LSM9DS0_GYRO_TRIGGERS
default 1024
help
Specify the internal thread stack size.
config LSM9DS0_GYRO_TRIGGER_DRDY
bool "Data ready trigger"
depends on LSM9DS0_GYRO_TRIGGERS
endif # LSM9DS0_GYRO
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds0_gyro/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 452 |
```objective-c
/* sensor_lsm9ds0_gyro.h - header file for LSM9DS0 gyroscope sensor driver */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM9DS0_GYRO_LSM9DS0_GYRO_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM9DS0_GYRO_LSM9DS0_GYRO_H_
#include <zephyr/types.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#define DEG2RAD 0.017453292519943295769236907684
#define LSM9DS0_GYRO_REG_WHO_AM_I_G 0x0F
#define LSM9DS0_GYRO_VAL_WHO_AM_I_G 0xD4
#define LSM9DS0_GYRO_REG_CTRL_REG1_G 0x20
#define LSM9DS0_GYRO_MASK_CTRL_REG1_G_DR (BIT(7) | BIT(6))
#define LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_DR 6
#define LSM9DS0_GYRO_MASK_CTRL_REG1_G_BW (BIT(5) | BIT(4))
#define LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_BW 4
#define LSM9DS0_GYRO_MASK_CTRL_REG1_G_PD BIT(3)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_PD 3
#define LSM9DS0_GYRO_MASK_CTRL_REG1_G_ZEN BIT(2)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_ZEN 2
#define LSM9DS0_GYRO_MASK_CTRL_REG1_G_XEN BIT(1)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_XEN 1
#define LSM9DS0_GYRO_MASK_CTRL_REG1_G_YEN BIT(0)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_YEN 0
#define LSM9DS0_GYRO_REG_CTRL_REG2_G 0x21
#define LSM9DS0_GYRO_MASK_CTRL_REG2_G_HPM (BIT(5) | BIT(4))
#define LSM9DS0_GYRO_SHIFT_CTRL_REG2_G_HPM 4
#define LSM9DS0_GYRO_MASK_CTRL_REG2_G_HPCF (BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_GYRO_REG_CTRL_REG3_G 0x22
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_I1_INT1 BIT(7)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_I1_INT1 7
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_I1_BOOT BIT(6)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_I1_BOOT 6
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_H_L BIT(5)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_H_L 5
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_PP_OD BIT(4)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_PP_OD 4
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_I2_DRDY BIT(3)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_I2_DRDY 3
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_I2_WTM BIT(2)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_I2_WTM 2
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_I2_OR BIT(1)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_I2_OR 1
#define LSM9DS0_GYRO_MASK_CTRL_REG3_G_I2_E BIT(0)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG3_G_I2_E 0
#define LSM9DS0_GYRO_REG_CTRL_REG4_G 0x23
#define LSM9DS0_GYRO_MASK_CTRL_REG4_G_BDU BIT(7)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_BDU 7
#define LSM9DS0_GYRO_MASK_CTRL_REG4_G_BLE BIT(6)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_BLE 6
#define LSM9DS0_GYRO_MASK_CTRL_REG4_G_FS (BIT(5) | BIT(4))
#define LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_FS 4
#define LSM9DS0_GYRO_MASK_CTRL_REG4_G_ST (BIT(2) | BIT(1))
#define LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_ST 1
#define LSM9DS0_GYRO_REG_CTRL_REG5_G 0x24
#define LSM9DS0_GYRO_MASK_CTRL_REG5_G_BOOT BIT(7)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG5_G_BOOT 7
#define LSM9DS0_GYRO_MASK_CTRL_REG5_G_FIFO_EN BIT(6)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG5_G_FIFO_EN 6
#define LSM9DS0_GYRO_MASK_CTRL_REG5_G_HPEN BIT(4)
#define LSM9DS0_GYRO_SHIFT_CTRL_REG5_G_HPEN 4
#define LSM9DS0_GYRO_MASK_CTRL_REG5_G_INT1_SEL (BIT(3) | BIT(2))
#define LSM9DS0_GYRO_SHIFT_CTRL_REG5_G_INT1_SEL 2
#define LSM9DS0_GYRO_MASK_CTRL_REG5_G_OUT_SEL (BIT(1) | BIT(0))
#define LSM9DS0_GYRO_SHIFT_CTRL_REG5_G_OUT_SEL 0
#define LSM9DS0_GYRO_REG_DATACAPTURE_G 0x25
#define LSM9DS0_GYRO_REG_STATUS_REG_G 0x27
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_ZYXOR BIT(7)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_ZYXOR 7
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_ZOR BIT(6)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_ZOR 6
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_YOR BIT(5)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_YOR 5
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_XOR BIT(4)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_XOR 4
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_ZYXDA BIT(3)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_ZYXDA 3
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_ZDA BIT(2)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_ZDA 2
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_YDA BIT(1)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_YDA 1
#define LSM9DS0_GYRO_MASK_STATUS_REG_G_XDA BIT(0)
#define LSM9DS0_GYRO_SHIFT_STATUS_REG_G_XDA 0
#define LSM9DS0_GYRO_REG_OUT_X_L_G 0x28
#define LSM9DS0_GYRO_REG_OUT_X_H_G 0x29
#define LSM9DS0_GYRO_REG_OUT_Y_L_G 0x2A
#define LSM9DS0_GYRO_REG_OUT_Y_H_G 0x2B
#define LSM9DS0_GYRO_REG_OUT_Z_L_G 0x2C
#define LSM9DS0_GYRO_REG_OUT_Z_H_G 0x2D
#define LSM9DS0_GYRO_REG_FIFO_CTRL_REG_G 0x2E
#define LSM9DS0_GYRO_MASK_FIFO_CTRL_REG_G_FM (BIT(7) | BIT(6) | BIT(5))
#define LSM9DS0_GYRO_SHIFT_FIFO_CTRL_REG_G_FM 5
#define LSM9DS0_GYRO_MASK_FIFO_CTRL_REG_G_WTM (BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM9DS0_GYRO_SHIFT_FIFO_CTRL_REG_G_WTM 0
#define LSM9DS0_GYRO_REG_FIFO_SRC_REG_G 0x2F
#define LSM9DS0_GYRO_MASK_FIFO_SRC_REG_G_WTM BIT(7)
#define LSM9DS0_GYRO_SHIFT_FIFO_SRC_REG_G_WTM 7
#define LSM9DS0_GYRO_MASK_FIFO_SRC_REG_G_OVRN BIT(6)
#define LSM9DS0_GYRO_SHIFT_FIFO_SRC_REG_G_OVRN 6
#define LSM9DS0_GYRO_MASK_FIFO_SRC_REG_G_EMPTY BIT(5)
#define LSM9DS0_GYRO_SHIFT_FIFO_SRC_REG_G_EMPTY 5
#define LSM9DS0_GYRO_MASK_FIFO_SRC_REG_G_FSS (BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM9DS0_GYRO_SHIFT_FIFO_SRC_REG_G_FSS 0
#define LSM9DS0_GYRO_REG_INT1_CFG_G 0x30
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_ANDOR BIT(7)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_ANDOR 7
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_LIR BIT(6)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_LIR 6
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_ZHIE BIT(5)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_ZHIE 5
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_ZLIE BIT(4)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_ZLIE 4
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_YHIE BIT(3)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_YHIE 3
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_YLIE BIT(2)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_YLIE 2
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_XHIE BIT(1)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_XHIE 1
#define LSM9DS0_GYRO_MASK_INT1_CFG_G_XLIE BIT(0)
#define LSM9DS0_GYRO_SHIFT_INT1_CFG_G_XLIE 0
#define LSM9DS0_GYRO_REG_INT1_SRC_G 0x31
#define LSM9DS0_GYRO_MASK_INT1_SRC_G_IA BIT(6)
#define LSM9DS0_GYRO_SHIFT_INT1_SRC_G_IA 6
#define LSM9DS0_GYRO_MASK_INT1_SRC_G_ZH BIT(5)
#define LSM9DS0_GYRO_SHIFT_INT1_SRC_G_ZH 5
#define LSM9DS0_GYRO_MASK_INT1_SRC_G_ZL BIT(4)
#define LSM9DS0_GYRO_SHIFT_INT1_SRC_G_ZL 4
#define LSM9DS0_GYRO_MASK_INT1_SRC_G_YH BIT(3)
#define LSM9DS0_GYRO_SHIFT_INT1_SRC_G_YH 3
#define LSM9DS0_GYRO_MASK_INT1_SRC_G_YL BIT(2)
#define LSM9DS0_GYRO_SHIFT_INT1_SRC_G_YL 2
#define LSM9DS0_GYRO_MASK_INT1_SRC_G_XH BIT(1)
#define LSM9DS0_GYRO_SHIFT_INT1_SRC_G_XH 1
#define LSM9DS0_GYRO_MASK_INT1_SRC_G_XL BIT(0)
#define LSM9DS0_GYRO_SHIFT_INT1_SRC_G_XL 0
#define LSM9DS0_GYRO_REG_INT1_THS_XH_G 0x32
#define LSM9DS0_GYRO_MASK_INT1_THS_XH_G (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_GYRO_REG_INT1_THS_XL_G 0x33
#define LSM9DS0_GYRO_REG_INT1_THS_YH_G 0x34
#define LSM9DS0_GYRO_MASK_INT1_THS_YH_G (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_GYRO_REG_INT1_THS_YL_G 0x35
#define LSM9DS0_GYRO_REG_INT1_THS_ZH_G 0x36
#define LSM9DS0_GYRO_MASK_INT1_THS_ZH_G (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_GYRO_REG_INT1_THS_ZL_G 0x37
#define LSM9DS0_GYRO_REG_INT1_DURATION_G 0x38
#define LSM9DS0_GYRO_MASK_INT1_DURATION_G_WAIT BIT(7)
#define LSM9DS0_GYRO_SHIFT_INT1_DURATION_G_WAIT 7
#define LSM9DS0_GYRO_MASK_INT1_DURATION_G_D (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_GYRO_SHIFT_INT1_DURATION_G_D 0
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_245)
#define LSM9DS0_GYRO_DEFAULT_FULLSCALE 0
#elif defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_500)
#define LSM9DS0_GYRO_DEFAULT_FULLSCALE 1
#elif defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_2000)
#define LSM9DS0_GYRO_DEFAULT_FULLSCALE 2
#endif
#if defined(CONFIG_LSM9DS0_GYRO_SAMPLING_RATE_95)
#define LSM9DS0_GYRO_DEFAULT_SAMPLING_RATE 0
#elif defined(CONFIG_LSM9DS0_GYRO_SAMPLING_RATE_190)
#define LSM9DS0_GYRO_DEFAULT_SAMPLING_RATE 1
#elif defined(CONFIG_LSM9DS0_GYRO_SAMPLING_RATE_380)
#define LSM9DS0_GYRO_DEFAULT_SAMPLING_RATE 2
#elif defined(CONFIG_LSM9DS0_GYRO_SAMPLING_RATE_760)
#define LSM9DS0_GYRO_DEFAULT_SAMPLING_RATE 3
#endif
#if defined(CONFIG_LSM9DS0_GYRO_SAMPLING_RATE_RUNTIME) || \
defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
#define LSM9DS0_GYRO_SET_ATTR
#endif
struct lsm9ds0_gyro_config {
struct i2c_dt_spec i2c;
#if CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY
struct gpio_dt_spec int_gpio;
#endif
};
struct lsm9ds0_gyro_data {
#if defined(CONFIG_LSM9DS0_GYRO_TRIGGERS)
struct k_sem sem;
#endif
#if defined(CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY)
K_KERNEL_STACK_MEMBER(thread_stack,
CONFIG_LSM9DS0_GYRO_THREAD_STACK_SIZE);
struct k_thread thread;
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *trigger_drdy;
sensor_trigger_handler_t handler_drdy;
#endif
int sample_x, sample_y, sample_z;
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
uint8_t sample_fs;
uint8_t fs;
#endif
};
#if defined(CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY)
int lsm9ds0_gyro_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lsm9ds0_gyro_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM9DS0_GYRO_LSM9DS0_GYRO_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds0_gyro/lsm9ds0_gyro.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,543 |
```c
/* lps25hb.c - Driver for LPS25HB pressure and temperature sensor */
/*
*
*/
#define DT_DRV_COMPAT st_lps25hb_press
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lps25hb.h"
LOG_MODULE_REGISTER(LPS25HB, CONFIG_SENSOR_LOG_LEVEL);
static inline int lps25hb_power_ctrl(const struct device *dev, uint8_t value)
{
const struct lps25hb_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->i2c, LPS25HB_REG_CTRL_REG1,
LPS25HB_MASK_CTRL_REG1_PD,
value << LPS25HB_SHIFT_CTRL_REG1_PD);
}
static inline int lps25hb_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lps25hb_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->i2c, LPS25HB_REG_CTRL_REG1,
LPS25HB_MASK_CTRL_REG1_ODR,
odr << LPS25HB_SHIFT_CTRL_REG1_ODR);
}
static int lps25hb_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct lps25hb_data *data = dev->data;
const struct lps25hb_config *config = dev->config;
uint8_t out[5];
int offset;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
for (offset = 0; offset < sizeof(out); ++offset) {
if (i2c_reg_read_byte_dt(&config->i2c,
LPS25HB_REG_PRESS_OUT_XL + offset,
out + offset) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
}
data->sample_press = (int32_t)((uint32_t)(out[0]) |
((uint32_t)(out[1]) << 8) |
((uint32_t)(out[2]) << 16));
data->sample_temp = (int16_t)((uint16_t)(out[3]) |
((uint16_t)(out[4]) << 8));
return 0;
}
static inline void lps25hb_press_convert(struct sensor_value *val,
int32_t raw_val)
{
/* Pressure sensitivity is 4096 LSB/hPa */
/* Also convert hPa into kPa */
val->val1 = raw_val / 40960;
/* For the decimal part use (3125 / 128) as a factor instead of
* (1000000 / 40960) to avoid int32 overflow
*/
val->val2 = (raw_val % 40960) * 3125 / 128;
}
static inline void lps25hb_temp_convert(struct sensor_value *val,
int16_t raw_val)
{
int32_t uval;
/* val = raw_val / 480 + 42.5 */
uval = (int32_t)raw_val * 1000000 / 480 + 42500000;
val->val1 = (raw_val * 10 / 480 + 425) / 10;
val->val2 = uval % 1000000;
}
static int lps25hb_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lps25hb_data *data = dev->data;
if (chan == SENSOR_CHAN_PRESS) {
lps25hb_press_convert(val, data->sample_press);
} else if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
lps25hb_temp_convert(val, data->sample_temp);
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lps25hb_api_funcs = {
.sample_fetch = lps25hb_sample_fetch,
.channel_get = lps25hb_channel_get,
};
static int lps25hb_init_chip(const struct device *dev)
{
const struct lps25hb_config *config = dev->config;
uint8_t chip_id;
lps25hb_power_ctrl(dev, 0);
k_busy_wait(USEC_PER_MSEC * 50U);
if (lps25hb_power_ctrl(dev, 1) < 0) {
LOG_DBG("failed to power on device");
return -EIO;
}
k_busy_wait(USEC_PER_MSEC * 20U);
if (i2c_reg_read_byte_dt(&config->i2c, LPS25HB_REG_WHO_AM_I,
&chip_id) < 0) {
LOG_DBG("failed reading chip id");
goto err_poweroff;
}
if (chip_id != LPS25HB_VAL_WHO_AM_I) {
LOG_DBG("invalid chip id 0x%x", chip_id);
goto err_poweroff;
}
LOG_DBG("chip id 0x%x", chip_id);
if (lps25hb_set_odr_raw(dev, LPS25HB_DEFAULT_SAMPLING_RATE)
< 0) {
LOG_DBG("failed to set sampling rate");
goto err_poweroff;
}
if (i2c_reg_update_byte_dt(&config->i2c, LPS25HB_REG_CTRL_REG1,
LPS25HB_MASK_CTRL_REG1_BDU,
(1 << LPS25HB_SHIFT_CTRL_REG1_BDU)) < 0) {
LOG_DBG("failed to set BDU");
goto err_poweroff;
}
return 0;
err_poweroff:
lps25hb_power_ctrl(dev, 0);
return -EIO;
}
static int lps25hb_init(const struct device *dev)
{
const struct lps25hb_config * const config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
if (lps25hb_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
return 0;
}
#define LPS25HB_DEFINE(inst) \
static struct lps25hb_data lps25hb_data_##inst; \
\
static const struct lps25hb_config lps25hb_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lps25hb_init, NULL, \
&lps25hb_data_##inst, &lps25hb_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &lps25hb_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(LPS25HB_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lps25hb/lps25hb.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,506 |
```c
/* lsm9ds0_gyro.c - Driver for LSM9DS0 gyroscope sensor */
/*
*
*/
#define DT_DRV_COMPAT st_lsm9ds0_gyro
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lsm9ds0_gyro.h"
LOG_MODULE_REGISTER(LSM9DS0_GYRO, CONFIG_SENSOR_LOG_LEVEL);
static inline int lsm9ds0_gyro_power_ctrl(const struct device *dev, int power,
int x_en, int y_en, int z_en)
{
const struct lsm9ds0_gyro_config *config = dev->config;
uint8_t state = (power << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_PD) |
(x_en << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_XEN) |
(y_en << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_YEN) |
(z_en << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_ZEN);
return i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_CTRL_REG1_G,
LSM9DS0_GYRO_MASK_CTRL_REG1_G_PD |
LSM9DS0_GYRO_MASK_CTRL_REG1_G_XEN |
LSM9DS0_GYRO_MASK_CTRL_REG1_G_YEN |
LSM9DS0_GYRO_MASK_CTRL_REG1_G_ZEN,
state);
}
static int lsm9ds0_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm9ds0_gyro_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_CTRL_REG4_G,
LSM9DS0_GYRO_MASK_CTRL_REG4_G_FS,
fs << LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_FS) < 0) {
return -EIO;
}
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
data->fs = fs;
#endif
return 0;
}
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
static const struct {
int fs;
uint8_t reg_val;
} lsm9ds0_gyro_fs_table[] = { {245, 0},
{500, 1},
{2000, 2} };
static int lsm9ds0_gyro_set_fs(const struct device *dev, int fs)
{
int i;
for (i = 0; i < ARRAY_SIZE(lsm9ds0_gyro_fs_table); ++i) {
if (fs <= lsm9ds0_gyro_fs_table[i].fs) {
return lsm9ds0_gyro_set_fs_raw(dev, lsm9ds0_gyro_fs_table[i].reg_val);
}
}
return -ENOTSUP;
}
#endif
static inline int lsm9ds0_gyro_set_odr_raw(const struct device *dev,
uint8_t odr)
{
const struct lsm9ds0_gyro_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_CTRL_REG1_G,
LSM9DS0_GYRO_MASK_CTRL_REG1_G_DR,
odr << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_BW);
}
#if defined(CONFIG_LSM9DS0_GYRO_SAMPLING_RATE_RUNTIME)
static const struct {
int freq;
uint8_t reg_val;
} lsm9ds0_gyro_samp_freq_table[] = { {95, 0},
{190, 1},
{380, 2},
{760, 3} };
static int lsm9ds0_gyro_set_odr(const struct device *dev, int odr)
{
int i;
for (i = 0; i < ARRAY_SIZE(lsm9ds0_gyro_samp_freq_table); ++i) {
if (odr <= lsm9ds0_gyro_samp_freq_table[i].freq) {
return lsm9ds0_gyro_set_odr_raw(dev,
lsm9ds0_gyro_samp_freq_table[i].
reg_val);
}
}
return -ENOTSUP;
}
#endif
static int lsm9ds0_gyro_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct lsm9ds0_gyro_data *data = dev->data;
const struct lsm9ds0_gyro_config *config = dev->config;
uint8_t x_l, x_h, y_l, y_h, z_l, z_h;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_GYRO_XYZ);
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_OUT_X_L_G,
&x_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_OUT_X_H_G,
&x_h) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_OUT_Y_L_G,
&y_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_OUT_Y_H_G,
&y_h) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_OUT_Z_L_G,
&z_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_OUT_Z_H_G,
&z_h) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
data->sample_x = (int16_t)((uint16_t)(x_l) | ((uint16_t)(x_h) << 8));
data->sample_y = (int16_t)((uint16_t)(y_l) | ((uint16_t)(y_h) << 8));
data->sample_z = (int16_t)((uint16_t)(z_l) | ((uint16_t)(z_h) << 8));
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
data->sample_fs = data->fs;
#endif
return 0;
}
static inline void lsm9ds0_gyro_convert(struct sensor_value *val, int raw_val,
float numerator)
{
double dval;
dval = (double)(raw_val) * (double)numerator / 1000.0 * DEG2RAD;
val->val1 = (int32_t)dval;
val->val2 = ((int32_t)(dval * 1000000)) % 1000000;
}
static inline int lsm9ds0_gyro_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm9ds0_gyro_data *data,
float numerator)
{
switch (chan) {
case SENSOR_CHAN_GYRO_X:
lsm9ds0_gyro_convert(val, data->sample_x, numerator);
break;
case SENSOR_CHAN_GYRO_Y:
lsm9ds0_gyro_convert(val, data->sample_y, numerator);
break;
case SENSOR_CHAN_GYRO_Z:
lsm9ds0_gyro_convert(val, data->sample_z, numerator);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm9ds0_gyro_convert(val, data->sample_x, numerator);
lsm9ds0_gyro_convert(val + 1, data->sample_y, numerator);
lsm9ds0_gyro_convert(val + 2, data->sample_z, numerator);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm9ds0_gyro_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm9ds0_gyro_data *data = dev->data;
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
switch (data->sample_fs) {
case 0:
return lsm9ds0_gyro_get_channel(chan, val, data, 8.75f);
case 1:
return lsm9ds0_gyro_get_channel(chan, val, data, 17.50f);
default:
return lsm9ds0_gyro_get_channel(chan, val, data, 70.0f);
}
#elif defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_245)
return lsm9ds0_gyro_get_channel(chan, val, data, 8.75f);
#elif defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_500)
return lsm9ds0_gyro_get_channel(chan, val, data, 17.50f);
#elif defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_2000)
return lsm9ds0_gyro_get_channel(chan, val, data, 70.0f);
#endif
return 0;
}
#if defined(LSM9DS0_GYRO_SET_ATTR)
static int lsm9ds0_gyro_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
case SENSOR_ATTR_FULL_SCALE:
if (lsm9ds0_gyro_set_fs(dev, sensor_rad_to_degrees(val)) < 0) {
LOG_DBG("full-scale value not supported");
return -EIO;
}
break;
#endif
#if defined(CONFIG_LSM9DS0_GYRO_SAMPLING_RATE_RUNTIME)
case SENSOR_ATTR_SAMPLING_FREQUENCY:
if (lsm9ds0_gyro_set_odr(dev, val->val1) < 0) {
LOG_DBG("sampling frequency value not supported");
return -EIO;
}
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
#endif
static const struct sensor_driver_api lsm9ds0_gyro_api_funcs = {
.sample_fetch = lsm9ds0_gyro_sample_fetch,
.channel_get = lsm9ds0_gyro_channel_get,
#if defined(LSM9DS0_GYRO_SET_ATTR)
.attr_set = lsm9ds0_gyro_attr_set,
#endif
#if defined(CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY)
.trigger_set = lsm9ds0_gyro_trigger_set,
#endif
};
static int lsm9ds0_gyro_init_chip(const struct device *dev)
{
const struct lsm9ds0_gyro_config *config = dev->config;
uint8_t chip_id;
if (lsm9ds0_gyro_power_ctrl(dev, 0, 0, 0, 0) < 0) {
LOG_DBG("failed to power off device");
return -EIO;
}
if (lsm9ds0_gyro_power_ctrl(dev, 1, 1, 1, 1) < 0) {
LOG_DBG("failed to power on device");
return -EIO;
}
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_WHO_AM_I_G,
&chip_id) < 0) {
LOG_DBG("failed reading chip id");
goto err_poweroff;
}
if (chip_id != LSM9DS0_GYRO_VAL_WHO_AM_I_G) {
LOG_DBG("invalid chip id 0x%x", chip_id);
goto err_poweroff;
}
LOG_DBG("chip id 0x%x", chip_id);
if (lsm9ds0_gyro_set_fs_raw(dev, LSM9DS0_GYRO_DEFAULT_FULLSCALE) < 0) {
LOG_DBG("failed to set full-scale");
goto err_poweroff;
}
if (lsm9ds0_gyro_set_odr_raw(dev, LSM9DS0_GYRO_DEFAULT_SAMPLING_RATE)
< 0) {
LOG_DBG("failed to set sampling rate");
goto err_poweroff;
}
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_GYRO_REG_CTRL_REG4_G,
LSM9DS0_GYRO_MASK_CTRL_REG4_G_BDU |
LSM9DS0_GYRO_MASK_CTRL_REG4_G_BLE,
(1 << LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_BDU) |
(0 << LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_BLE))
< 0) {
LOG_DBG("failed to set BDU and BLE");
goto err_poweroff;
}
return 0;
err_poweroff:
lsm9ds0_gyro_power_ctrl(dev, 0, 0, 0, 0);
return -EIO;
}
static int lsm9ds0_gyro_init(const struct device *dev)
{
const struct lsm9ds0_gyro_config * const config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
if (lsm9ds0_gyro_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
#if defined(CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY)
if (config->int_gpio.port) {
if (lsm9ds0_gyro_init_interrupt(dev) < 0) {
LOG_DBG("failed to initialize interrupts");
return -EIO;
}
}
#endif
return 0;
}
#define LSM9DS0_GYRO_DEFINE(inst) \
static struct lsm9ds0_gyro_data lsm9ds0_gyro_data_##inst; \
\
static const struct lsm9ds0_gyro_config lsm9ds0_gyro_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, irq_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lsm9ds0_gyro_init, NULL, \
&lsm9ds0_gyro_data_##inst, &lsm9ds0_gyro_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&lsm9ds0_gyro_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(LSM9DS0_GYRO_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds0_gyro/lsm9ds0_gyro.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,224 |
```unknown
menuconfig LPS25HB
bool "LPS25HB pressure and temperature"
default y
depends on DT_HAS_ST_LPS25HB_PRESS_ENABLED
select I2C
help
Enable driver for LPS25HB I2C-based pressure and temperature
sensor.
config LPS25HB_SAMPLING_RATE
int "Output data rate"
default 25
depends on LPS25HB
help
Sensor output data rate expressed in samples per second.
Data rates supported by the chip are 1, 7, 13, 25.
``` | /content/code_sandbox/drivers/sensor/st/lps25hb/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 121 |
```objective-c
/* sensor_lps25hb.h - header file for LPS25HB pressure and temperature
* sensor driver
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LPS25HB_LPS25HB_H_
#define ZEPHYR_DRIVERS_SENSOR_LPS25HB_LPS25HB_H_
#include <zephyr/types.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#define LPS25HB_REG_WHO_AM_I 0x0F
#define LPS25HB_VAL_WHO_AM_I 0xBD
#define LPS25HB_REG_REF_P_XL 0x08
#define LPS25HB_REG_REF_P_L 0x09
#define LPS25HB_REG_REF_P_H 0x0A
#define LPS25HB_REG_RES_CONF 0x10
#define LPS25HB_MASK_RES_CONF_AVGT (BIT(3) | BIT(2))
#define LPS25HB_SHIFT_RES_CONF_AVGT 2
#define LPS25HB_MASK_RES_CONF_AVGP (BIT(1) | BIT(0))
#define LPS25HB_SHIFT_RES_CONF_AVGP 0
#define LPS25HB_REG_CTRL_REG1 0x20
#define LPS25HB_MASK_CTRL_REG1_PD BIT(7)
#define LPS25HB_SHIFT_CTRL_REG1_PD 7
#define LPS25HB_MASK_CTRL_REG1_ODR (BIT(6) | BIT(5) | BIT(4))
#define LPS25HB_SHIFT_CTRL_REG1_ODR 4
#define LPS25HB_MASK_CTRL_REG1_DIFF_EN BIT(3)
#define LPS25HB_SHIFT_CTRL_REG1_DIFF_EN 3
#define LPS25HB_MASK_CTRL_REG1_BDU BIT(2)
#define LPS25HB_SHIFT_CTRL_REG1_BDU 2
#define LPS25HB_MASK_CTRL_REG1_RESET_AZ BIT(1)
#define LPS25HB_SHIFT_CTRL_REG1_RESET_AZ 1
#define LPS25HB_MASK_CTRL_REG1_SIM BIT(0)
#define LPS25HB_SHIFT_CTRL_REG1_SIM 0
#define LPS25HB_REG_CTRL_REG2 0x21
#define LPS25HB_MASK_CTRL_REG2_BOOT BIT(7)
#define LPS25HB_SHIFT_CTRL_REG2_BOOT 7
#define LPS25HB_MASK_CTRL_REG2_FIFO_EN BIT(6)
#define LPS25HB_SHIFT_CTRL_REG2_FIFO_EN 6
#define LPS25HB_MASK_CTRL_REG2_STOP_ON_FTH BIT(5)
#define LPS25HB_SHIFT_CTRL_REG2_STOP_ON_FTH 5
#define LPS25HB_MASK_CTRL_REG2_FIFO_MEAN_DEC BIT(4)
#define LPS25HB_SHIFT_CTRL_REG2_FIFO_MEAN_DEC 4
#define LPS25HB_MASK_CTRL_REG2_I2C_EN BIT(3)
#define LPS25HB_SHIFT_CTRL_REG2_I2C_EN 3
#define LPS25HB_MASK_CTRL_REG2_SWRESET BIT(2)
#define LPS25HB_SHIFT_CTRL_REG2_SWRESET 2
#define LPS25HB_MASK_CTRL_REG2_AUTOZERO BIT(1)
#define LPS25HB_SHIFT_CTRL_REG2_AUTOZERO 1
#define LPS25HB_MASK_CTRL_REG2_ONE_SHOT BIT(0)
#define LPS25HB_SHIFT_CTRL_REG2_ONE_SHOT 0
#define LPS25HB_REG_CTRL_REG3 0x22
#define LPS25HB_MASK_CTRL_REG3_INT_H_L BIT(7)
#define LPS25HB_SHIFT_CTRL_REG3_INT_H_L 7
#define LPS25HB_MASK_CTRL_REG3_PP_OD BIT(6)
#define LPS25HB_SHIFT_CTRL_REG3_PP_OD 6
#define LPS25HB_MASK_CTRL_REG3_INT_S (BIT(1) | BIT(0))
#define LPS25HB_SHIFT_CTRL_REG_INT_S 0
#define LPS25HB_REG_CTRL_REG4 0x23
#define LPS25HB_MASK_CTRL_REG4_F_EMPTY BIT(3)
#define LPS25HB_SHIFT_CTRL_REG4_F_EMPTY 3
#define LPS25HB_MASK_CTRL_REG4_F_FTH BIT(2)
#define LPS25HB_SHIFT_CTRL_REG4_F_FTH 2
#define LPS25HB_MASK_CTRL_REG4_F_OVR BIT(1)
#define LPS25HB_SHIFT_CTRL_REG4_F_OVR 1
#define LPS25HB_MASK_CTRL_REG4_DRDY BIT(0)
#define LPS25HB_SHIFT_CTRL_REG4_DRDY 0
#define LPS25HB_REG_INTERRUPT_CFG 0x24
#define LPS25HB_MASK_INTERRUPT_CFG_LIR BIT(2)
#define LPS25HB_SHIFT_INTERRUPT_CFG_LIR 2
#define LPS25HB_MASK_INTERRUPT_CFG_PL_E BIT(1)
#define LPS25HB_SHIFT_INTERRUPT_CFG_PL_E 1
#define LPS25HB_MASK_INTERRUPT_CFG_PH_E BIT(0)
#define LPS25HB_SHIFT_INTERRUPT_CFG_PH_E 0
#define LPS25HB_REG_INT_SOURCE 0x25
#define LPS25HB_MASK_INT_SOURCE_IA BIT(2)
#define LPS25HB_SHIFT_INT_SOURCE_IA 2
#define LPS25HB_MASK_INT_SOURCE_PL BIT(1)
#define LPS25HB_SHIFT_INT_SOURCE_PL 1
#define LPS25HB_MASK_INT_SOURCE_PH BIT(0)
#define LPS25HB_SHIFT_INT_SOURCE_PH 0
#define LPS25HB_REG_STATUS_REG 0x27
#define LPS25HB_MASK_STATUS_REG_P_OR BIT(5)
#define LPS25HB_SHIFT_STATUS_REG_P_OR 5
#define LPS25HB_MASK_STATUS_REG_T_OR BIT(4)
#define LPS25HB_SHIFT_STATUS_REG_T_OR 4
#define LPS25HB_MASK_STATUS_REG_P_DA BIT(1)
#define LPS25HB_SHIFT_STATUS_REG_P_DA 1
#define LPS25HB_MASK_STATUS_REG_T_DA BIT(0)
#define LPS25HB_SHIFT_STATUS_REG_T_DA 0
#define LPS25HB_REG_PRESS_OUT_XL 0x28
#define LPS25HB_REG_PRESS_OUT_L 0x29
#define LPS25HB_REG_PRESS_OUT_H 0x2A
#define LPS25HB_REG_TEMP_OUT_L 0x2B
#define LPS25HB_REG_TEMP_OUT_H 0x2C
#define LPS25HB_REG_FIFO_CTRL 0x2E
#define LPS25HB_MASK_FIFO_CTRL_F_MODE (BIT(7) | BIT(6) | BIT(5))
#define LPS25HB_SHIFT_FIFO_CTRL_F_MODE 5
#define LPS25HB_MASK_FIFO_CTRL_WTM_POINT (BIT(4) | BIT(3) | BIT(2) | \
BIT(2) | BIT(1) | BIT(0))
#define LPS25HB_SHIFT_FIFO_CTRL_WTM_POINT 0
#define LPS25HB_REG_FIFO_STATUS 0x2F
#define LPS25HB_MASK_FIFO_STATUS_FTH_FIFO BIT(7)
#define LPS25HB_SHIFT_FIFO_STATUS_FTH_FIFO 7
#define LPS25HB_MASK_FIFO_STATUS_OVR BIT(6)
#define LPS25HB_SHIFT_FIFO_STATUS_OVR 6
#define LPS25HB_MASK_FIFO_STATUS_EMPTY_FIFO BIT(5)
#define LPS25HB_SHIFT_FIFO_STATUS_EMPTY_FIFO 5
#define LPS25HB_MASK_FIFO_STATUS_FSS (BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LPS25HB_SHIFT_FIFO_STATUS_FSS 0
#define LPS25HB_REG_THS_P_L 0x30
#define LPS25HB_REG_THS_P_H 0x31
#define LPS25HB_REG_RPDS_L 0x39
#define LPS25HB_REG_RPDS_H 0x3A
#if CONFIG_LPS25HB_SAMPLING_RATE == 1
#define LPS25HB_DEFAULT_SAMPLING_RATE 1
#elif CONFIG_LPS25HB_SAMPLING_RATE == 7
#define LPS25HB_DEFAULT_SAMPLING_RATE 2
#elif CONFIG_LPS25HB_SAMPLING_RATE == 13
#define LPS25HB_DEFAULT_SAMPLING_RATE 3
#elif CONFIG_LPS25HB_SAMPLING_RATE == 25
#define LPS25HB_DEFAULT_SAMPLING_RATE 4
#endif
struct lps25hb_config {
struct i2c_dt_spec i2c;
};
struct lps25hb_data {
int32_t sample_press;
int16_t sample_temp;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_LPS25HB_LPS25HB_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lps25hb/lps25hb.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,906 |
```objective-c
/* ST Microelectronics LIS2DU12 3-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LIS2DU12_LIS2DU12_H_
#define ZEPHYR_DRIVERS_SENSOR_LIS2DU12_LIS2DU12_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "lis2du12_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define LIS2DU12_EN_BIT 0x01
#define LIS2DU12_DIS_BIT 0x00
/* Accel sensor sensitivity grain is 61 ug/LSB */
#define GAIN_UNIT_XL (61LL)
#define SENSOR_G_DOUBLE (SENSOR_G / 1000000.0)
struct lis2du12_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t accel_pm;
uint8_t accel_odr;
uint8_t accel_range;
uint8_t drdy_pulsed;
#ifdef CONFIG_LIS2DU12_TRIGGER
const struct gpio_dt_spec int1_gpio;
const struct gpio_dt_spec int2_gpio;
uint8_t drdy_pin;
bool trig_enabled;
#endif /* CONFIG_LIS2DU12_TRIGGER */
};
union samples {
uint8_t raw[6];
struct {
int16_t axis[3];
};
} __aligned(2);
struct lis2du12_data {
const struct device *dev;
int16_t acc[3];
uint32_t acc_gain;
uint16_t accel_freq;
uint8_t accel_fs;
#ifdef CONFIG_LIS2DU12_TRIGGER
struct gpio_dt_spec *drdy_gpio;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy_acc;
const struct sensor_trigger *trig_drdy_acc;
#if defined(CONFIG_LIS2DU12_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DU12_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2DU12_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LIS2DU12_TRIGGER */
};
#ifdef CONFIG_LIS2DU12_TRIGGER
int lis2du12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lis2du12_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LIS2DU12_LIS2DU12_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lis2du12/lis2du12.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 673 |
```unknown
# ST Microelectronics LIS2DU12 3-axis accelerometer sensor driver
menuconfig LIS2DU12
bool "LIS2DU12 I2C/SPI smartxl Chip"
default y
depends on DT_HAS_ST_LIS2DU12_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DU12),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DU12),spi)
select HAS_STMEMSC
select USE_STDC_LIS2DU12
help
Enable driver for LIS2DU12 smartxl sensor.
if LIS2DU12
module = LIS2DU12
thread_priority = 10
thread_stack_size = 1024
source "drivers/sensor/Kconfig.trigger_template"
endif # LIS2DU12
``` | /content/code_sandbox/drivers/sensor/st/lis2du12/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 186 |
```c
/* ST Microelectronics LIS2DU12 3-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2du12
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lis2du12.h"
LOG_MODULE_DECLARE(LIS2DU12, CONFIG_SENSOR_LOG_LEVEL);
/**
* lis2du12_enable_xl_int - XL enable selected int pin to generate interrupt
*/
static int lis2du12_enable_xl_int(const struct device *dev, int enable)
{
const struct lis2du12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
if (enable) {
lis2du12_md_t md;
lis2du12_data_t xl_data;
/* dummy read: re-trigger interrupt */
md.fs = cfg->accel_range;
lis2du12_data_get(ctx, &md, &xl_data);
}
/* set interrupt */
if (cfg->drdy_pin == 1) {
lis2du12_pin_int_route_t val;
ret = lis2du12_pin_int1_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int1_route_get error");
return ret;
}
val.drdy_xl = 1;
ret = lis2du12_pin_int1_route_set(ctx, &val);
} else {
lis2du12_pin_int_route_t val;
ret = lis2du12_pin_int2_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int2_route_get error");
return ret;
}
val.drdy_xl = 1;
ret = lis2du12_pin_int2_route_set(ctx, &val);
}
return ret;
}
/**
* lis2du12_trigger_set - link external trigger to event data ready
*/
int lis2du12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lis2du12_config *cfg = dev->config;
struct lis2du12_data *lis2du12 = dev->data;
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
switch (trig->chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lis2du12->handler_drdy_acc = handler;
lis2du12->trig_drdy_acc = trig;
if (handler) {
return lis2du12_enable_xl_int(dev, LIS2DU12_EN_BIT);
}
return lis2du12_enable_xl_int(dev, LIS2DU12_DIS_BIT);
default:
return -ENOTSUP;
}
}
/**
* lis2du12_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void lis2du12_handle_interrupt(const struct device *dev)
{
struct lis2du12_data *lis2du12 = dev->data;
const struct lis2du12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2du12_status_t status;
while (1) {
if (lis2du12_status_get(ctx, &status) < 0) {
LOG_ERR("failed reading status reg");
return;
}
if (status.drdy_xl == 0) {
break;
}
if ((status.drdy_xl) && (lis2du12->handler_drdy_acc != NULL)) {
lis2du12->handler_drdy_acc(dev, lis2du12->trig_drdy_acc);
}
}
gpio_pin_interrupt_configure_dt(lis2du12->drdy_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void lis2du12_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis2du12_data *lis2du12 =
CONTAINER_OF(cb, struct lis2du12_data, gpio_cb);
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(lis2du12->drdy_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_LIS2DU12_TRIGGER_OWN_THREAD)
k_sem_give(&lis2du12->gpio_sem);
#elif defined(CONFIG_LIS2DU12_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2du12->work);
#endif /* CONFIG_LIS2DU12_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_LIS2DU12_TRIGGER_OWN_THREAD
static void lis2du12_thread(struct lis2du12_data *lis2du12)
{
while (1) {
k_sem_take(&lis2du12->gpio_sem, K_FOREVER);
lis2du12_handle_interrupt(lis2du12->dev);
}
}
#endif /* CONFIG_LIS2DU12_TRIGGER_OWN_THREAD */
#ifdef CONFIG_LIS2DU12_TRIGGER_GLOBAL_THREAD
static void lis2du12_work_cb(struct k_work *work)
{
struct lis2du12_data *lis2du12 =
CONTAINER_OF(work, struct lis2du12_data, work);
lis2du12_handle_interrupt(lis2du12->dev);
}
#endif /* CONFIG_LIS2DU12_TRIGGER_GLOBAL_THREAD */
int lis2du12_init_interrupt(const struct device *dev)
{
struct lis2du12_data *lis2du12 = dev->data;
const struct lis2du12_config *cfg = dev->config;
int ret;
lis2du12->drdy_gpio = (cfg->drdy_pin == 1) ?
(struct gpio_dt_spec *)&cfg->int1_gpio :
(struct gpio_dt_spec *)&cfg->int2_gpio;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(lis2du12->drdy_gpio)) {
LOG_ERR("Cannot get pointer to drdy_gpio device (%p)",
lis2du12->drdy_gpio);
return -EINVAL;
}
#if defined(CONFIG_LIS2DU12_TRIGGER_OWN_THREAD)
k_sem_init(&lis2du12->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lis2du12->thread, lis2du12->thread_stack,
CONFIG_LIS2DU12_THREAD_STACK_SIZE,
(k_thread_entry_t)lis2du12_thread, lis2du12,
NULL, NULL, K_PRIO_COOP(CONFIG_LIS2DU12_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&lis2du12->thread, dev->name);
#elif defined(CONFIG_LIS2DU12_TRIGGER_GLOBAL_THREAD)
lis2du12->work.handler = lis2du12_work_cb;
#endif /* CONFIG_LIS2DU12_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(lis2du12->drdy_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio: %d", ret);
return ret;
}
gpio_init_callback(&lis2du12->gpio_cb,
lis2du12_gpio_callback,
BIT(lis2du12->drdy_gpio->pin));
if (gpio_add_callback(lis2du12->drdy_gpio->port, &lis2du12->gpio_cb) < 0) {
LOG_ERR("Could not set gpio callback");
return -EIO;
}
return gpio_pin_interrupt_configure_dt(lis2du12->drdy_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lis2du12/lis2du12_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,677 |
```c
/* ST Microelectronics IIS3DHHC accelerometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis3dhhc
#include <string.h>
#include "iis3dhhc.h"
#include <zephyr/logging/log.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define IIS3DHHC_SPI_READ (1 << 7)
LOG_MODULE_DECLARE(IIS3DHHC, CONFIG_SENSOR_LOG_LEVEL);
static int iis3dhhc_spi_read(const struct device *dev, uint8_t reg, uint8_t *data, uint16_t len)
{
const struct iis3dhhc_config *config = dev->config;
uint8_t buffer_tx[2] = { reg | IIS3DHHC_SPI_READ, 0 };
const struct spi_buf tx_buf = {
.buf = buffer_tx,
.len = 2,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
const struct spi_buf rx_buf[2] = {
{
.buf = NULL,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2
};
if (spi_transceive_dt(&config->spi, &tx, &rx)) {
return -EIO;
}
return 0;
}
static int iis3dhhc_spi_write(const struct device *dev, uint8_t reg, uint8_t *data, uint16_t len)
{
const struct iis3dhhc_config *config = dev->config;
uint8_t buffer_tx[1] = { reg & ~IIS3DHHC_SPI_READ };
const struct spi_buf tx_buf[2] = {
{
.buf = buffer_tx,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = tx_buf,
.count = 2
};
if (spi_write_dt(&config->spi, &tx)) {
return -EIO;
}
return 0;
}
stmdev_ctx_t iis3dhhc_spi_ctx = {
.read_reg = (stmdev_read_ptr) iis3dhhc_spi_read,
.write_reg = (stmdev_write_ptr) iis3dhhc_spi_write,
.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay,
};
int iis3dhhc_spi_init(const struct device *dev)
{
struct iis3dhhc_data *data = dev->data;
const struct iis3dhhc_config *config = dev->config;
if (!spi_is_ready_dt(&config->spi)) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
};
data->ctx = &iis3dhhc_spi_ctx;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/st/iis3dhhc/iis3dhhc_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 697 |
```c
/* ST Microelectronics IIS3DHHC accelerometer senor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis3dhhc
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "iis3dhhc.h"
LOG_MODULE_REGISTER(IIS3DHHC, CONFIG_SENSOR_LOG_LEVEL);
static int iis3dhhc_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct iis3dhhc_data *data = dev->data;
int16_t raw_accel[3];
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
iis3dhhc_acceleration_raw_get(data->ctx, raw_accel);
data->acc[0] = sys_le16_to_cpu(raw_accel[0]);
data->acc[1] = sys_le16_to_cpu(raw_accel[1]);
data->acc[2] = sys_le16_to_cpu(raw_accel[2]);
return 0;
}
static inline void iis3dhhc_convert(struct sensor_value *val,
int16_t raw_val)
{
int64_t micro_ms2;
/* Convert to m/s^2 */
micro_ms2 = ((iis3dhhc_from_lsb_to_mg(raw_val) * SENSOR_G) / 1000LL);
val->val1 = micro_ms2 / 1000000LL;
val->val2 = micro_ms2 % 1000000LL;
}
static inline void iis3dhhc_channel_get_acc(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
int i;
uint8_t ofs_start, ofs_stop;
struct iis3dhhc_data *iis3dhhc = dev->data;
struct sensor_value *pval = val;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_ACCEL_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_ACCEL_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U; ofs_stop = 2U;
break;
}
for (i = ofs_start; i <= ofs_stop ; i++) {
iis3dhhc_convert(pval++, iis3dhhc->acc[i]);
}
}
static int iis3dhhc_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
iis3dhhc_channel_get_acc(dev, chan, val);
return 0;
default:
LOG_DBG("Channel not supported");
break;
}
return -ENOTSUP;
}
static int iis3dhhc_odr_set(const struct device *dev,
const struct sensor_value *val)
{
struct iis3dhhc_data *data = dev->data;
iis3dhhc_norm_mod_en_t en;
switch (val->val1) {
case 0:
en = IIS3DHHC_POWER_DOWN;
break;
case 1000:
en = IIS3DHHC_1kHz1;
break;
default:
return -EIO;
}
if (iis3dhhc_data_rate_set(data->ctx, en)) {
LOG_DBG("failed to set sampling rate");
return -EIO;
}
return 0;
}
static int iis3dhhc_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL) {
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis3dhhc_odr_set(dev, val);
default:
LOG_DBG("operation not supported.");
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api iis3dhhc_api_funcs = {
.attr_set = iis3dhhc_attr_set,
.sample_fetch = iis3dhhc_sample_fetch,
.channel_get = iis3dhhc_channel_get,
#if CONFIG_IIS3DHHC_TRIGGER
.trigger_set = iis3dhhc_trigger_set,
#endif
};
static int iis3dhhc_init_chip(const struct device *dev)
{
struct iis3dhhc_data *data = dev->data;
uint8_t chip_id, rst;
if (iis3dhhc_device_id_get(data->ctx, &chip_id) < 0) {
LOG_DBG("Failed reading chip id");
return -EIO;
}
if (chip_id != IIS3DHHC_ID) {
LOG_DBG("Invalid chip id 0x%x", chip_id);
return -EIO;
}
/*
* Restore default configuration
*/
iis3dhhc_reset_set(data->ctx, PROPERTY_ENABLE);
do {
iis3dhhc_reset_get(data->ctx, &rst);
} while (rst);
/* Enable Block Data Update */
iis3dhhc_block_data_update_set(data->ctx, PROPERTY_ENABLE);
/* Set Output Data Rate */
#ifdef CONFIG_IIS3DHHC_NORM_MODE
iis3dhhc_data_rate_set(data->ctx, 1);
#else
iis3dhhc_data_rate_set(data->ctx, 0);
#endif
/* Enable temperature compensation */
iis3dhhc_offset_temp_comp_set(data->ctx, PROPERTY_ENABLE);
return 0;
}
static int iis3dhhc_init(const struct device *dev)
{
const struct iis3dhhc_config * const config = dev->config;
if (!spi_is_ready_dt(&config->spi)) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
}
config->bus_init(dev);
if (iis3dhhc_init_chip(dev) < 0) {
LOG_DBG("Failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_IIS3DHHC_TRIGGER
if (config->int_gpio.port) {
if (iis3dhhc_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
return 0;
}
#define IIS3DHHC_DEFINE(inst) \
static struct iis3dhhc_data iis3dhhc_data_##inst; \
\
static const struct iis3dhhc_config iis3dhhc_config_##inst = { \
IF_ENABLED(CONFIG_IIS3DHHC_TRIGGER, \
(COND_CODE_1(CONFIG_IIS3DHHC_DRDY_INT1, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_BY_IDX(inst, \
irq_gpios, \
0),), \
(.int_gpio = GPIO_DT_SPEC_INST_GET_BY_IDX(inst, \
irq_gpios, \
1),)))) \
\
.bus_init = iis3dhhc_spi_init, \
.spi = SPI_DT_SPEC_INST_GET(inst, SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | SPI_MODE_CPHA | \
SPI_WORD_SET(8), 0U), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, iis3dhhc_init, NULL, \
&iis3dhhc_data_##inst, &iis3dhhc_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &iis3dhhc_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(IIS3DHHC_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/iis3dhhc/iis3dhhc.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,771 |
```c
/* ST Microelectronics LIS2DU12 3-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2du12
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lis2du12.h"
LOG_MODULE_REGISTER(LIS2DU12, CONFIG_SENSOR_LOG_LEVEL);
static const float lis2du12_odr_map[14] = {
0.0f, 1.6f, 3.0f, 6.0f, 6.0f, 12.5f, 25.0f,
50.0f, 100.0f, 200.0f, 400.0f, 800.0f, 0.0f, 0.0f};
static int lis2du12_freq_to_odr_val(const struct device *dev, uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lis2du12_odr_map); i++) {
if (freq <= lis2du12_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static const uint16_t lis2du12_accel_fs_map[] = {2, 4, 8, 16};
static int lis2du12_accel_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lis2du12_accel_fs_map); i++) {
if (range == lis2du12_accel_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static inline int lis2du12_reboot(const struct device *dev)
{
const struct lis2du12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2du12_status_t status;
uint8_t tries = 10;
if (lis2du12_init_set(ctx, LIS2DU12_RESET) < 0) {
return -EIO;
}
do {
if (!--tries) {
LOG_ERR("sw reset timed out");
return -ETIMEDOUT;
}
k_usleep(50);
if (lis2du12_status_get(ctx, &status) < 0) {
return -EIO;
}
} while (status.sw_reset != 0);
if (lis2du12_init_set(ctx, LIS2DU12_DRV_RDY) < 0) {
return -EIO;
}
return 0;
}
static int lis2du12_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lis2du12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2du12_data *data = dev->data;
lis2du12_md_t mode;
if (lis2du12_mode_get(ctx, &mode) < 0) {
return -EIO;
}
mode.fs = fs;
if (lis2du12_mode_set(ctx, &mode) < 0) {
return -EIO;
}
data->accel_fs = fs;
return 0;
}
static int lis2du12_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lis2du12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2du12_data *data = dev->data;
lis2du12_md_t mode;
if (lis2du12_mode_get(ctx, &mode) < 0) {
return -EIO;
}
mode.odr = odr;
if (lis2du12_mode_set(ctx, &mode) < 0) {
return -EIO;
}
data->accel_freq = odr;
return 0;
}
static int lis2du12_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lis2du12_freq_to_odr_val(dev, freq);
if (odr < 0) {
return odr;
}
if (lis2du12_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
static int lis2du12_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lis2du12_data *data = dev->data;
fs = lis2du12_accel_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lis2du12_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer full-scale");
return -EIO;
}
data->acc_gain = lis2du12_accel_fs_map[fs] * GAIN_UNIT_XL / 2;
return 0;
}
static int lis2du12_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lis2du12_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lis2du12_accel_odr_set(dev, val->val1);
default:
LOG_WRN("Accel attribute %d not supported.", attr);
return -ENOTSUP;
}
return 0;
}
static int lis2du12_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lis2du12_accel_config(dev, chan, attr, val);
default:
LOG_WRN("attribute %d not supported on this channel.", chan);
return -ENOTSUP;
}
return 0;
}
static int lis2du12_sample_fetch_accel(const struct device *dev)
{
const struct lis2du12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2du12_data *data = dev->data;
lis2du12_data_t xl_data;
lis2du12_md_t md;
md.fs = cfg->accel_range;
if (lis2du12_data_get(ctx, &md, &xl_data) < 0) {
LOG_ERR("Failed to read sample");
return -EIO;
}
data->acc[0] = xl_data.xl.raw[0];
data->acc[1] = xl_data.xl.raw[1];
data->acc[2] = xl_data.xl.raw[2];
return 0;
}
static int lis2du12_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lis2du12_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_ALL:
lis2du12_sample_fetch_accel(dev);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lis2du12_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)(raw_val) * sensitivity * SENSOR_G_DOUBLE;
val->val1 = (int32_t)(dval / 1000000);
val->val2 = (int32_t)(dval % 1000000);
}
static inline int lis2du12_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lis2du12_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lis2du12_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
lis2du12_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
lis2du12_accel_convert(val, data->acc[2], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 3; i++) {
lis2du12_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lis2du12_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lis2du12_data *data)
{
return lis2du12_accel_get_channel(chan, val, data, data->acc_gain);
}
static int lis2du12_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lis2du12_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lis2du12_accel_channel_get(chan, val, data);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lis2du12_driver_api = {
.attr_set = lis2du12_attr_set,
#if CONFIG_LIS2DU12_TRIGGER
.trigger_set = lis2du12_trigger_set,
#endif
.sample_fetch = lis2du12_sample_fetch,
.channel_get = lis2du12_channel_get,
};
static int lis2du12_init_chip(const struct device *dev)
{
const struct lis2du12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2du12_data *lis2du12 = dev->data;
lis2du12_id_t chip_id;
uint8_t odr, fs;
if (lis2du12_id_get(ctx, &chip_id) < 0) {
LOG_ERR("Failed reading chip id");
return -EIO;
}
LOG_INF("chip id 0x%x", chip_id.whoami);
if (chip_id.whoami != LIS2DU12_ID) {
LOG_ERR("Invalid chip id 0x%x", chip_id.whoami);
return -EIO;
}
/* reboot device */
if (lis2du12_reboot(dev) < 0) {
return -EIO;
}
/* set FS from DT */
fs = cfg->accel_range;
LOG_DBG("accel range is %d", fs);
if (lis2du12_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer range %d", fs);
return -EIO;
}
lis2du12->acc_gain = lis2du12_accel_fs_map[fs] * GAIN_UNIT_XL / 2;
/* set odr from DT (the only way to go in high performance) */
odr = cfg->accel_odr;
LOG_DBG("accel odr is %d", odr);
if (lis2du12_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer odr %d", odr);
return -EIO;
}
return 0;
}
static int lis2du12_init(const struct device *dev)
{
#ifdef CONFIG_LIS2DU12_TRIGGER
const struct lis2du12_config *cfg = dev->config;
#endif
struct lis2du12_data *data = dev->data;
LOG_INF("Initialize device %s", dev->name);
data->dev = dev;
if (lis2du12_init_chip(dev) < 0) {
LOG_ERR("failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_LIS2DU12_TRIGGER
if (cfg->trig_enabled) {
if (lis2du12_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
return 0;
}
/*
* Device creation macro, shared by LIS2DU12_DEFINE_SPI() and
* LIS2DU12_DEFINE_I2C().
*/
#define LIS2DU12_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lis2du12_init, \
NULL, \
&lis2du12_data_##inst, \
&lis2du12_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lis2du12_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LIS2DU12_TRIGGER
#define LIS2DU12_CFG_IRQ(inst) \
.trig_enabled = true, \
.int1_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int1_gpios, { 0 }), \
.int2_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int2_gpios, { 0 }), \
.drdy_pulsed = DT_INST_PROP(inst, drdy_pulsed), \
.drdy_pin = DT_INST_PROP(inst, drdy_pin)
#else
#define LIS2DU12_CFG_IRQ(inst)
#endif /* CONFIG_LIS2DU12_TRIGGER */
#define LIS2DU12_SPI_OP (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LIS2DU12_CONFIG_COMMON(inst) \
.accel_odr = DT_INST_PROP(inst, accel_odr), \
.accel_range = DT_INST_PROP(inst, accel_range), \
IF_ENABLED(UTIL_OR(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
DT_INST_NODE_HAS_PROP(inst, int2_gpios)), \
(LIS2DU12_CFG_IRQ(inst)))
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#define LIS2DU12_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lis2du12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
LIS2DU12_SPI_OP, \
0), \
}, \
LIS2DU12_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LIS2DU12_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lis2du12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LIS2DU12_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LIS2DU12_DEFINE(inst) \
static struct lis2du12_data lis2du12_data_##inst; \
static const struct lis2du12_config lis2du12_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LIS2DU12_CONFIG_SPI(inst)), \
(LIS2DU12_CONFIG_I2C(inst))); \
LIS2DU12_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LIS2DU12_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis2du12/lis2du12.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,489 |
```objective-c
/* ST Microelectronics IIS3DHHC accelerometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_IIS3DHHC_IIS3DHHC_H_
#define ZEPHYR_DRIVERS_SENSOR_IIS3DHHC_IIS3DHHC_H_
#include <stdint.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "iis3dhhc_reg.h"
struct iis3dhhc_config {
int (*bus_init)(const struct device *dev);
#ifdef CONFIG_IIS3DHHC_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif
};
struct iis3dhhc_data {
int16_t acc[3];
stmdev_ctx_t *ctx;
#ifdef CONFIG_IIS3DHHC_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy;
const struct sensor_trigger *trig_drdy;
const struct device *dev;
#if defined(CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS3DHHC_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS3DHHC_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_IIS3DHHC_TRIGGER */
};
int iis3dhhc_spi_init(const struct device *dev);
#ifdef CONFIG_IIS3DHHC_TRIGGER
int iis3dhhc_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int iis3dhhc_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_IIS3DHHC_IIS3DHHC_H_ */
``` | /content/code_sandbox/drivers/sensor/st/iis3dhhc/iis3dhhc.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 434 |
```c
/* ST Microelectronics IIS3DHHC accelerometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis3dhhc
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "iis3dhhc.h"
LOG_MODULE_DECLARE(IIS3DHHC, CONFIG_SENSOR_LOG_LEVEL);
/**
* iis3dhhc_enable_int - enable selected int pin to generate interrupt
*/
static int iis3dhhc_enable_int(const struct device *dev, int enable)
{
struct iis3dhhc_data *iis3dhhc = dev->data;
/* set interrupt */
#ifdef CONFIG_IIS3DHHC_DRDY_INT1
return iis3dhhc_drdy_on_int1_set(iis3dhhc->ctx, enable);
#else
return iis3dhhc_drdy_on_int2_set(iis3dhhc->ctx, enable);
#endif
}
/**
* iis3dhhc_trigger_set - link external trigger to event data ready
*/
int iis3dhhc_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct iis3dhhc_data *iis3dhhc = dev->data;
const struct iis3dhhc_config *config = dev->config;
int16_t raw[3];
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_ACCEL_XYZ) {
iis3dhhc->handler_drdy = handler;
iis3dhhc->trig_drdy = trig;
if (handler) {
/* dummy read: re-trigger interrupt */
iis3dhhc_acceleration_raw_get(iis3dhhc->ctx, raw);
return iis3dhhc_enable_int(dev, PROPERTY_ENABLE);
} else {
return iis3dhhc_enable_int(dev, PROPERTY_DISABLE);
}
}
return -ENOTSUP;
}
/**
* iis3dhhc_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void iis3dhhc_handle_interrupt(const struct device *dev)
{
struct iis3dhhc_data *iis3dhhc = dev->data;
const struct iis3dhhc_config *cfg = dev->config;
if (iis3dhhc->handler_drdy != NULL) {
iis3dhhc->handler_drdy(dev, iis3dhhc->trig_drdy);
}
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
static void iis3dhhc_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct iis3dhhc_data *iis3dhhc =
CONTAINER_OF(cb, struct iis3dhhc_data, gpio_cb);
const struct iis3dhhc_config *cfg = iis3dhhc->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD)
k_sem_give(&iis3dhhc->gpio_sem);
#elif defined(CONFIG_IIS3DHHC_TRIGGER_GLOBAL_THREAD)
k_work_submit(&iis3dhhc->work);
#endif /* CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD
static void iis3dhhc_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct iis3dhhc_data *iis3dhhc = p1;
while (1) {
k_sem_take(&iis3dhhc->gpio_sem, K_FOREVER);
iis3dhhc_handle_interrupt(iis3dhhc->dev);
}
}
#endif /* CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD */
#ifdef CONFIG_IIS3DHHC_TRIGGER_GLOBAL_THREAD
static void iis3dhhc_work_cb(struct k_work *work)
{
struct iis3dhhc_data *iis3dhhc =
CONTAINER_OF(work, struct iis3dhhc_data, work);
iis3dhhc_handle_interrupt(iis3dhhc->dev);
}
#endif /* CONFIG_IIS3DHHC_TRIGGER_GLOBAL_THREAD */
int iis3dhhc_init_interrupt(const struct device *dev)
{
struct iis3dhhc_data *iis3dhhc = dev->data;
const struct iis3dhhc_config *cfg = dev->config;
int ret;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name, cfg->int_gpio.port->name);
return -ENODEV;
}
iis3dhhc->dev = dev;
#if defined(CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD)
k_sem_init(&iis3dhhc->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&iis3dhhc->thread, iis3dhhc->thread_stack,
CONFIG_IIS3DHHC_THREAD_STACK_SIZE,
iis3dhhc_thread, iis3dhhc,
NULL, NULL, K_PRIO_COOP(CONFIG_IIS3DHHC_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_IIS3DHHC_TRIGGER_GLOBAL_THREAD)
iis3dhhc->work.handler = iis3dhhc_work_cb;
#endif /* CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&iis3dhhc->gpio_cb, iis3dhhc_gpio_callback, BIT(cfg->int_gpio.pin));
if (gpio_add_callback(cfg->int_gpio.port, &iis3dhhc->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* enable interrupt on int1/int2 in pulse mode */
if (iis3dhhc_drdy_notification_mode_set(iis3dhhc->ctx, IIS3DHHC_PULSED)) {
return -EIO;
}
return gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/iis3dhhc/iis3dhhc_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,468 |
```unknown
# ST Microelectronics IIS3DHHC accelerometer sensor
menuconfig IIS3DHHC
bool "IIS3DHHC accelerometer sensor"
default y
depends on DT_HAS_ST_IIS3DHHC_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select SPI
select HAS_STMEMSC
select USE_STDC_IIS3DHHC
help
Enable driver for IIS3DHHC SPI-based accelerometer sensor.
if IIS3DHHC
choice IIS3DHHC_TRIGGER_MODE
prompt "Trigger mode"
default IIS3DHHC_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config IIS3DHHC_TRIGGER_NONE
bool "No trigger"
config IIS3DHHC_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select IIS3DHHC_TRIGGER
config IIS3DHHC_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select IIS3DHHC_TRIGGER
endchoice # IIS3DHHC_TRIGGER_MODE
config IIS3DHHC_TRIGGER
bool
config IIS3DHHC_THREAD_PRIORITY
int "Thread priority"
depends on IIS3DHHC_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config IIS3DHHC_THREAD_STACK_SIZE
int "Thread stack size"
depends on IIS3DHHC_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
menu "Attributes"
config IIS3DHHC_NORM_MODE
bool "Sensor at 1KHz"
default y
config IIS3DHHC_DRDY_INT1
bool "Data ready interrupt to INT1 pin"
depends on IIS3DHHC_TRIGGER
default y
help
Say Y to route data ready interrupt to INT1 pin. Say N to route to
INT2 pin.
endmenu
endif # IIS3DHHC
``` | /content/code_sandbox/drivers/sensor/st/iis3dhhc/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 425 |
```c
/* ST Microelectronics STMEMS hal i/f
*
*
*
* zephyrproject-rtos/modules/hal/st/sensor/stmemsc/
*/
#include "stmemsc.h"
void stmemsc_mdelay(uint32_t millisec)
{
k_msleep(millisec);
}
``` | /content/code_sandbox/drivers/sensor/st/stmemsc/stmemsc_mdelay.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 62 |
```c
/* ST Microelectronics STMEMS hal i/f
*
*
*
* zephyrproject-rtos/modules/hal/st/sensor/stmemsc/
*/
#include "stmemsc.h"
int stmemsc_i3c_read(void *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
struct i3c_device_desc *target = **(struct i3c_device_desc ***)stmemsc;
return i3c_burst_read(target, reg_addr, value, len);
}
int stmemsc_i3c_write(void *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
struct i3c_device_desc *target = **(struct i3c_device_desc ***)stmemsc;
return i3c_burst_write(target, reg_addr, value, len);
}
``` | /content/code_sandbox/drivers/sensor/st/stmemsc/stmemsc_i3c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 187 |
```c
/* ST Microelectronics STMEMS hal i/f
*
*
*
* zephyrproject-rtos/modules/hal/st/sensor/stmemsc/
*/
#include "stmemsc.h"
#define SPI_READ (1 << 7)
/* Enable address auto-increment on some stmemsc sensors */
#define STMEMSC_SPI_ADDR_AUTO_INCR BIT(6)
/*
* SPI read
*/
int stmemsc_spi_read(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
uint8_t buffer_tx[2] = { reg_addr | SPI_READ, 0 };
/* write 1 byte with reg addr (msb at 1) + 1 dummy byte */
const struct spi_buf tx_buf = { .buf = buffer_tx, .len = 2, };
const struct spi_buf_set tx = { .buffers = &tx_buf, .count = 1 };
/*
* transaction #1: dummy read to skip first byte
* transaction #2: read "len" byte of data
*/
const struct spi_buf rx_buf[2] = {
{ .buf = NULL, .len = 1, },
{ .buf = value, .len = len, }
};
const struct spi_buf_set rx = { .buffers = rx_buf, .count = 2 };
return spi_transceive_dt(stmemsc, &tx, &rx);
}
/*
* SPI write
*/
int stmemsc_spi_write(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
uint8_t buffer_tx[1] = { reg_addr & ~SPI_READ };
/*
* transaction #1: write 1 byte with reg addr (msb at 0)
* transaction #2: write "len" byte of data
*/
const struct spi_buf tx_buf[2] = {
{ .buf = buffer_tx, .len = 1, },
{ .buf = value, .len = len, }
};
const struct spi_buf_set tx = { .buffers = tx_buf, .count = 2 };
return spi_write_dt(stmemsc, &tx);
}
int stmemsc_spi_read_incr(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
reg_addr |= STMEMSC_SPI_ADDR_AUTO_INCR;
return stmemsc_spi_read(stmemsc, reg_addr, value, len);
}
int stmemsc_spi_write_incr(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
reg_addr |= STMEMSC_SPI_ADDR_AUTO_INCR;
return stmemsc_spi_write(stmemsc, reg_addr, value, len);
}
``` | /content/code_sandbox/drivers/sensor/st/stmemsc/stmemsc_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 622 |
```c
/* ST Microelectronics STMEMS hal i/f
*
*
*
* zephyrproject-rtos/modules/hal/st/sensor/stmemsc/
*/
#include "stmemsc.h"
/* Enable address auto-increment on some stmemsc sensors */
#define STMEMSC_I2C_ADDR_AUTO_INCR BIT(7)
int stmemsc_i2c_read(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
return i2c_burst_read_dt(stmemsc, reg_addr, value, len);
}
int stmemsc_i2c_write(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
return i2c_burst_write_dt(stmemsc, reg_addr, value, len);
}
int stmemsc_i2c_read_incr(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
reg_addr |= STMEMSC_I2C_ADDR_AUTO_INCR;
return stmemsc_i2c_read(stmemsc, reg_addr, value, len);
}
int stmemsc_i2c_write_incr(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len)
{
reg_addr |= STMEMSC_I2C_ADDR_AUTO_INCR;
return stmemsc_i2c_write(stmemsc, reg_addr, value, len);
}
``` | /content/code_sandbox/drivers/sensor/st/stmemsc/stmemsc_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 338 |
```objective-c
/* ST Microelectronics STMEMS hal i/f
*
*
*
* zephyrproject-rtos/modules/hal/st/sensor/stmemsc/
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_STMEMSC_STMEMSC_H_
#define ZEPHYR_DRIVERS_SENSOR_STMEMSC_STMEMSC_H_
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/i3c.h>
#include <zephyr/drivers/spi.h>
void stmemsc_mdelay(uint32_t millisec);
#ifdef CONFIG_I2C
/*
* Populate the stmdev_ctx_t structure pointed by stmdev_ctx_ptr with
* standard stmemsc i2c APIs.
*/
#define STMEMSC_CTX_I2C(stmdev_ctx_ptr) \
.ctx = { \
.read_reg = (stmdev_read_ptr)stmemsc_i2c_read, \
.write_reg = (stmdev_write_ptr)stmemsc_i2c_write, \
.mdelay = (stmdev_mdelay_ptr)stmemsc_mdelay, \
.handle = (void *)stmdev_ctx_ptr \
}
int stmemsc_i2c_read(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
int stmemsc_i2c_write(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
/*
* Populate the stmdev_ctx_t structure pointed by stmdev_ctx_ptr with
* specific stmemsc i2c APIs that set reg_addr MSB to '1' in order to allow
* multiple read/write operations. This is common in some STMEMSC drivers
*/
#define STMEMSC_CTX_I2C_INCR(stmdev_ctx_ptr) \
.ctx = { \
.read_reg = (stmdev_read_ptr)stmemsc_i2c_read_incr, \
.write_reg = (stmdev_write_ptr)stmemsc_i2c_write_incr, \
.mdelay = (stmdev_mdelay_ptr)stmemsc_mdelay, \
.handle = (void *)stmdev_ctx_ptr \
}
int stmemsc_i2c_read_incr(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
int stmemsc_i2c_write_incr(const struct i2c_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
/*
* Populate the stmdev_ctx_t structure pointed by stmdev_ctx_ptr with
* custom stmemsc i2c APIs specified by driver.
*/
#define STMEMSC_CTX_I2C_CUSTOM(stmdev_ctx_ptr, i2c_rd_api, i2c_wr_api) \
.ctx = { \
.read_reg = (stmdev_read_ptr)i2c_rd_api, \
.write_reg = (stmdev_write_ptr)i2c_wr_api, \
.mdelay = (stmdev_mdelay_ptr)stmemsc_mdelay, \
.handle = (void *)stmdev_ctx_ptr \
}
#endif
#ifdef CONFIG_I3C
/*
* Populate the stmdev_ctx_t structure pointed by stmdev_ctx_ptr with
* standard stmemsc i3c APIs.
*/
#define STMEMSC_CTX_I3C(stmdev_ctx_ptr) \
.ctx = { \
.read_reg = (stmdev_read_ptr)stmemsc_i3c_read, \
.write_reg = (stmdev_write_ptr)stmemsc_i3c_write, \
.mdelay = (stmdev_mdelay_ptr)stmemsc_mdelay, \
.handle = (void *)stmdev_ctx_ptr \
}
int stmemsc_i3c_read(void *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
int stmemsc_i3c_write(void *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
#endif
#ifdef CONFIG_SPI
/*
* Populate the stmdev_ctx_t structure pointed by stmdev_ctx_ptr with
* stmemsc spi APIs.
*/
#define STMEMSC_CTX_SPI(stmdev_ctx_ptr) \
.ctx = { \
.read_reg = (stmdev_read_ptr)stmemsc_spi_read, \
.write_reg = (stmdev_write_ptr)stmemsc_spi_write, \
.mdelay = (stmdev_mdelay_ptr)stmemsc_mdelay, \
.handle = (void *)stmdev_ctx_ptr \
}
int stmemsc_spi_read(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
int stmemsc_spi_write(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
/*
* Populate the stmdev_ctx_t structure pointed by stmdev_ctx_ptr with
* specific stmemsc sp APIs that set reg_addr bit6 to '1' in order to allow
* multiple read/write operations. This is common in some STMEMSC drivers
*/
#define STMEMSC_CTX_SPI_INCR(stmdev_ctx_ptr) \
.ctx = { \
.read_reg = (stmdev_read_ptr)stmemsc_spi_read_incr, \
.write_reg = (stmdev_write_ptr)stmemsc_spi_write_incr, \
.mdelay = (stmdev_mdelay_ptr)stmemsc_mdelay, \
.handle = (void *)stmdev_ctx_ptr \
}
int stmemsc_spi_read_incr(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
int stmemsc_spi_write_incr(const struct spi_dt_spec *stmemsc,
uint8_t reg_addr, uint8_t *value, uint8_t len);
/*
* Populate the stmdev_ctx_t structure pointed by stmdev_ctx_ptr with
* custom stmemsc spi APIs specified by driver.
*/
#define STMEMSC_CTX_SPI_CUSTOM(stmdev_ctx_ptr, spi_rd_api, spi_wr_api) \
.ctx = { \
.read_reg = (stmdev_read_ptr)spi_rd_api, \
.write_reg = (stmdev_write_ptr)spi_wr_api, \
.mdelay = (stmdev_mdelay_ptr)stmemsc_mdelay, \
.handle = (void *)stmdev_ctx_ptr \
}
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_STMEMSC_STMEMSC_H_ */
``` | /content/code_sandbox/drivers/sensor/st/stmemsc/stmemsc.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,505 |
```c
/* ST Microelectronics ISM330DHCX 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_ism330dhcx
#include <string.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include "ism330dhcx.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(ISM330DHCX, CONFIG_SENSOR_LOG_LEVEL);
static int ism330dhcx_i2c_read(const struct device *dev, uint8_t reg_addr, uint8_t *value,
uint8_t len)
{
const struct ism330dhcx_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->i2c, reg_addr, value, len);
}
static int ism330dhcx_i2c_write(const struct device *dev, uint8_t reg_addr, uint8_t *value,
uint8_t len)
{
const struct ism330dhcx_config *cfg = dev->config;
return i2c_burst_write_dt(&cfg->i2c, reg_addr, value, len);
}
int ism330dhcx_i2c_init(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
const struct ism330dhcx_config *cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("I2C bus device is not ready");
return -ENODEV;
};
data->ctx_i2c.read_reg = (stmdev_read_ptr) ism330dhcx_i2c_read;
data->ctx_i2c.write_reg = (stmdev_write_ptr) ism330dhcx_i2c_write;
data->ctx_i2c.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay;
data->ctx = &data->ctx_i2c;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/st/ism330dhcx/ism330dhcx_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 448 |
```c
/* ST Microelectronics ISM330DHCX 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_ism330dhcx
#include <string.h>
#include "ism330dhcx.h"
#include <zephyr/logging/log.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define ISM330DHCX_SPI_READ (1 << 7)
LOG_MODULE_DECLARE(ISM330DHCX, CONFIG_SENSOR_LOG_LEVEL);
static int ism330dhcx_spi_read(const struct device *dev, uint8_t reg_addr, uint8_t *value,
uint8_t len)
{
const struct ism330dhcx_config *cfg = dev->config;
uint8_t buffer_tx[2] = { reg_addr | ISM330DHCX_SPI_READ, 0 };
const struct spi_buf tx_buf = {
.buf = buffer_tx,
.len = 2,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
const struct spi_buf rx_buf[2] = {
{
.buf = NULL,
.len = 1,
},
{
.buf = value,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2
};
if (len > 64) {
return -EIO;
}
if (spi_transceive_dt(&cfg->spi, &tx, &rx)) {
return -EIO;
}
return 0;
}
static int ism330dhcx_spi_write(const struct device *dev, uint8_t reg_addr, uint8_t *value,
uint8_t len)
{
const struct ism330dhcx_config *cfg = dev->config;
uint8_t buffer_tx[1] = { reg_addr & ~ISM330DHCX_SPI_READ };
const struct spi_buf tx_buf[2] = {
{
.buf = buffer_tx,
.len = 1,
},
{
.buf = value,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = tx_buf,
.count = 2
};
if (len > 64) {
return -EIO;
}
if (spi_write_dt(&cfg->spi, &tx)) {
return -EIO;
}
return 0;
}
int ism330dhcx_spi_init(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
const struct ism330dhcx_config *cfg = dev->config;
if (!spi_is_ready_dt(&cfg->spi)) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
};
data->ctx_spi.read_reg = (stmdev_read_ptr) ism330dhcx_spi_read;
data->ctx_spi.write_reg = (stmdev_write_ptr) ism330dhcx_spi_write;
data->ctx_spi.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay;
data->ctx = &data->ctx_spi;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/st/ism330dhcx/ism330dhcx_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 722 |
```c
/* ST Microelectronics ISM330DHCX 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_ism330dhcx
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util_macro.h>
#include <zephyr/logging/log.h>
#include "ism330dhcx.h"
LOG_MODULE_REGISTER(ISM330DHCX, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t ism330dhcx_odr_map[] = {0, 12, 26, 52, 104, 208, 416, 833,
1660, 3330, 6660};
static int ism330dhcx_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(ism330dhcx_odr_map); i++) {
if (freq <= ism330dhcx_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static int ism330dhcx_odr_to_freq_val(uint16_t odr)
{
/* for valid index, return value from map */
if (odr < ARRAY_SIZE(ism330dhcx_odr_map)) {
return ism330dhcx_odr_map[odr];
}
/* invalid index, return last entry */
return ism330dhcx_odr_map[ARRAY_SIZE(ism330dhcx_odr_map) - 1];
}
static const uint16_t ism330dhcx_accel_fs_map[] = {2, 16, 4, 8};
static const uint16_t ism330dhcx_accel_fs_sens[] = {1, 8, 2, 4};
static int ism330dhcx_accel_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(ism330dhcx_accel_fs_map); i++) {
if (range == ism330dhcx_accel_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
/*
* Following arrays are initialized in order to mimic
* the ism330dhcx_fs_g_t enum:
*
* typedef enum
* {
* ISM330DHCX_125dps = 2,
* ISM330DHCX_250dps = 0,
* ISM330DHCX_500dps = 4,
* ISM330DHCX_1000dps = 8,
* ISM330DHCX_2000dps = 12,
* ISM330DHCX_4000dps = 1,
* } ism330dhcx_fs_g_t;
*/
static const uint16_t ism330dhcx_gyro_fs_map[] = {
250, 4000, 125, 0, 500,
0, 0, 0, 1000,
0, 0, 0, 2000
};
static const uint16_t ism330dhcx_gyro_fs_sens[] = {
2, 32, 1, 0, 4,
0, 0, 0, 8,
0, 0, 0, 16
};
static int ism330dhcx_gyro_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(ism330dhcx_gyro_fs_map); i++) {
if (range == ism330dhcx_gyro_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static inline int ism330dhcx_reboot(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
if (ism330dhcx_boot_set(data->ctx, 1) < 0) {
return -EIO;
}
/* Wait sensor turn-on time as per datasheet */
k_busy_wait(35 * USEC_PER_MSEC);
return 0;
}
static int ism330dhcx_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
struct ism330dhcx_data *data = dev->data;
if (ism330dhcx_xl_full_scale_set(data->ctx, fs) < 0) {
return -EIO;
}
data->accel_fs = fs;
return 0;
}
static int ism330dhcx_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
struct ism330dhcx_data *data = dev->data;
if (ism330dhcx_xl_data_rate_set(data->ctx, odr) < 0) {
return -EIO;
}
data->accel_freq = ism330dhcx_odr_to_freq_val(odr);
return 0;
}
static int ism330dhcx_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
struct ism330dhcx_data *data = dev->data;
if (ism330dhcx_gy_full_scale_set(data->ctx, fs) < 0) {
return -EIO;
}
return 0;
}
static int ism330dhcx_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
struct ism330dhcx_data *data = dev->data;
if (ism330dhcx_gy_data_rate_set(data->ctx, odr) < 0) {
return -EIO;
}
return 0;
}
static int ism330dhcx_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = ism330dhcx_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (ism330dhcx_accel_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
static int ism330dhcx_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct ism330dhcx_data *data = dev->data;
fs = ism330dhcx_accel_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (ism330dhcx_accel_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
data->acc_gain = (ism330dhcx_accel_fs_sens[fs] * GAIN_UNIT_XL);
return 0;
}
static int ism330dhcx_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return ism330dhcx_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return ism330dhcx_accel_odr_set(dev, val->val1);
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int ism330dhcx_gyro_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = ism330dhcx_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (ism330dhcx_gyro_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
return 0;
}
static int ism330dhcx_gyro_range_set(const struct device *dev, int32_t range)
{
int fs;
struct ism330dhcx_data *data = dev->data;
fs = ism330dhcx_gyro_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (ism330dhcx_gyro_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
data->gyro_gain = (ism330dhcx_gyro_fs_sens[fs] * GAIN_UNIT_G);
return 0;
}
static int ism330dhcx_gyro_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return ism330dhcx_gyro_range_set(dev, sensor_rad_to_degrees(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return ism330dhcx_gyro_odr_set(dev, val->val1);
default:
LOG_DBG("Gyro attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int ism330dhcx_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return ism330dhcx_accel_config(dev, chan, attr, val);
case SENSOR_CHAN_GYRO_XYZ:
return ism330dhcx_gyro_config(dev, chan, attr, val);
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
case SENSOR_CHAN_MAGN_XYZ:
case SENSOR_CHAN_PRESS:
case SENSOR_CHAN_HUMIDITY:
return ism330dhcx_shub_config(dev, chan, attr, val);
#endif /* CONFIG_ISM330DHCX_SENSORHUB */
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int ism330dhcx_sample_fetch_accel(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
int16_t buf[3];
if (ism330dhcx_acceleration_raw_get(data->ctx, buf) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
data->acc[0] = sys_le16_to_cpu(buf[0]);
data->acc[1] = sys_le16_to_cpu(buf[1]);
data->acc[2] = sys_le16_to_cpu(buf[2]);
return 0;
}
static int ism330dhcx_sample_fetch_gyro(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
int16_t buf[3];
if (ism330dhcx_angular_rate_raw_get(data->ctx, buf) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
data->gyro[0] = sys_le16_to_cpu(buf[0]);
data->gyro[1] = sys_le16_to_cpu(buf[1]);
data->gyro[2] = sys_le16_to_cpu(buf[2]);
return 0;
}
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
static int ism330dhcx_sample_fetch_temp(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
int16_t buf;
if (ism330dhcx_temperature_raw_get(data->ctx, &buf) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
data->temp_sample = sys_le16_to_cpu(buf);
return 0;
}
#endif
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
static int ism330dhcx_sample_fetch_shub(const struct device *dev)
{
if (ism330dhcx_shub_fetch_external_devs(dev) < 0) {
LOG_DBG("failed to read ext shub devices");
return -EIO;
}
return 0;
}
#endif /* CONFIG_ISM330DHCX_SENSORHUB */
static int ism330dhcx_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
ism330dhcx_sample_fetch_accel(dev);
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
ism330dhcx_sample_fetch_shub(dev);
#endif
break;
case SENSOR_CHAN_GYRO_XYZ:
ism330dhcx_sample_fetch_gyro(dev);
break;
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
ism330dhcx_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
ism330dhcx_sample_fetch_accel(dev);
ism330dhcx_sample_fetch_gyro(dev);
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
ism330dhcx_sample_fetch_temp(dev);
#endif
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
ism330dhcx_sample_fetch_shub(dev);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void ism330dhcx_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)(raw_val) * sensitivity;
sensor_ug_to_ms2(dval, val);
}
static inline int ism330dhcx_accel_get_channel(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val, uint32_t sensitivity)
{
struct ism330dhcx_data *data = dev->data;
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ism330dhcx_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
ism330dhcx_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
ism330dhcx_accel_convert(val, data->acc[2], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 3; i++) {
ism330dhcx_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int ism330dhcx_accel_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ism330dhcx_data *data = dev->data;
return ism330dhcx_accel_get_channel(dev, chan, val, data->acc_gain);
}
static inline void ism330dhcx_gyro_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in udps/LSB */
/* So, calculate value in 10 udps unit and then to rad/s */
dval = (int64_t)(raw_val) * sensitivity / 10;
sensor_10udegrees_to_rad(dval, val);
}
static inline int ism330dhcx_gyro_get_channel(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val, uint32_t sensitivity)
{
struct ism330dhcx_data *data = dev->data;
uint8_t i;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
ism330dhcx_gyro_convert(val, data->gyro[0], sensitivity);
break;
case SENSOR_CHAN_GYRO_Y:
ism330dhcx_gyro_convert(val, data->gyro[1], sensitivity);
break;
case SENSOR_CHAN_GYRO_Z:
ism330dhcx_gyro_convert(val, data->gyro[2], sensitivity);
break;
case SENSOR_CHAN_GYRO_XYZ:
for (i = 0; i < 3; i++) {
ism330dhcx_gyro_convert(val++, data->gyro[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int ism330dhcx_gyro_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ism330dhcx_data *data = dev->data;
return ism330dhcx_gyro_get_channel(dev, chan, val, data->gyro_gain);
}
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
static void ism330dhcx_gyro_channel_get_temp(const struct device *dev,
struct sensor_value *val)
{
struct ism330dhcx_data *data = dev->data;
/* val = temp_sample / 256 + 25 */
val->val1 = data->temp_sample / 256 + 25;
val->val2 = (data->temp_sample % 256) * (1000000 / 256);
}
#endif
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
static inline void ism330dhcx_magn_convert(struct sensor_value *val, int raw_val,
uint16_t sensitivity)
{
double dval;
/* Sensitivity is exposed in ugauss/LSB */
dval = (double)(raw_val * sensitivity);
val->val1 = (int32_t)dval / 1000000;
val->val2 = (int32_t)dval % 1000000;
}
static inline int ism330dhcx_magn_get_channel(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ism330dhcx_data *data = dev->data;
int16_t sample[3];
int idx;
idx = ism330dhcx_shub_get_idx(SENSOR_CHAN_MAGN_XYZ);
if (idx < 0) {
LOG_DBG("external magn not supported");
return -ENOTSUP;
}
sample[0] = (int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8));
sample[1] = (int16_t)(data->ext_data[idx][2] |
(data->ext_data[idx][3] << 8));
sample[2] = (int16_t)(data->ext_data[idx][4] |
(data->ext_data[idx][5] << 8));
switch (chan) {
case SENSOR_CHAN_MAGN_X:
ism330dhcx_magn_convert(val, sample[0], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Y:
ism330dhcx_magn_convert(val, sample[1], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Z:
ism330dhcx_magn_convert(val, sample[2], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_XYZ:
ism330dhcx_magn_convert(val, sample[0], data->magn_gain);
ism330dhcx_magn_convert(val + 1, sample[1], data->magn_gain);
ism330dhcx_magn_convert(val + 2, sample[2], data->magn_gain);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void ism330dhcx_hum_convert(const struct device *dev, struct sensor_value *val)
{
struct ism330dhcx_data *data = dev->data;
float rh;
int16_t raw_val;
struct hts221_data *ht = &data->hts221;
int idx;
idx = ism330dhcx_shub_get_idx(SENSOR_CHAN_HUMIDITY);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = ((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
/* find relative humidty by linear interpolation */
rh = (ht->y1 - ht->y0) * raw_val + ht->x1 * ht->y0 - ht->x0 * ht->y1;
rh /= (ht->x1 - ht->x0);
/* convert humidity to integer and fractional part */
val->val1 = rh;
val->val2 = rh * 1000000;
}
static inline void ism330dhcx_press_convert(const struct device *dev, struct sensor_value *val)
{
struct ism330dhcx_data *data = dev->data;
int32_t raw_val;
int idx;
idx = ism330dhcx_shub_get_idx(SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = (int32_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8) |
(data->ext_data[idx][2] << 16));
/* Pressure sensitivity is 4096 LSB/hPa */
/* Convert raw_val to val in kPa */
val->val1 = (raw_val >> 12) / 10;
val->val2 = (raw_val >> 12) % 10 * 100000 +
(((int32_t)((raw_val) & 0x0FFF) * 100000L) >> 12);
}
static inline void ism330dhcx_temp_convert(const struct device *dev, struct sensor_value *val)
{
struct ism330dhcx_data *data = dev->data;
int16_t raw_val;
int idx;
idx = ism330dhcx_shub_get_idx(SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = (int16_t)(data->ext_data[idx][3] |
(data->ext_data[idx][4] << 8));
/* Temperature sensitivity is 100 LSB/deg C */
val->val1 = raw_val / 100;
val->val2 = (int32_t)raw_val % 100 * (10000);
}
#endif
static int ism330dhcx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
ism330dhcx_accel_channel_get(dev, chan, val);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
ism330dhcx_gyro_channel_get(dev, chan, val);
break;
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
ism330dhcx_gyro_channel_get_temp(dev, val);
break;
#endif
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
ism330dhcx_magn_get_channel(dev, chan, val);
break;
case SENSOR_CHAN_HUMIDITY:
ism330dhcx_hum_convert(dev, val);
break;
case SENSOR_CHAN_PRESS:
ism330dhcx_press_convert(dev, val);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
ism330dhcx_temp_convert(dev, val);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api ism330dhcx_api_funcs = {
.attr_set = ism330dhcx_attr_set,
#if CONFIG_ISM330DHCX_TRIGGER
.trigger_set = ism330dhcx_trigger_set,
#endif
.sample_fetch = ism330dhcx_sample_fetch,
.channel_get = ism330dhcx_channel_get,
};
static int ism330dhcx_init_chip(const struct device *dev)
{
const struct ism330dhcx_config * const cfg = dev->config;
struct ism330dhcx_data *ism330dhcx = dev->data;
uint8_t chip_id;
ism330dhcx->dev = dev;
if (ism330dhcx_device_id_get(ism330dhcx->ctx, &chip_id) < 0) {
LOG_DBG("Failed reading chip id");
return -EIO;
}
LOG_INF("chip id 0x%x", chip_id);
if (chip_id != ISM330DHCX_ID) {
LOG_DBG("Invalid chip id 0x%x", chip_id);
return -EIO;
}
/* reset device */
if (ism330dhcx_reset_set(ism330dhcx->ctx, 1) < 0) {
return -EIO;
}
k_busy_wait(100);
LOG_DBG("accel range is %d", cfg->accel_range);
if (ism330dhcx_accel_range_set(dev, cfg->accel_range) < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
LOG_DBG("accel odr is %d", cfg->accel_odr);
if (ism330dhcx_accel_set_odr_raw(dev, cfg->accel_odr) < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
LOG_DBG("gyro range is %d", cfg->gyro_range);
if (ism330dhcx_gyro_range_set(dev, cfg->gyro_range) < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
LOG_DBG("gyro odr is %d", cfg->gyro_odr);
ism330dhcx->gyro_freq = ism330dhcx_odr_to_freq_val(cfg->gyro_odr);
if (ism330dhcx_gyro_set_odr_raw(dev, cfg->gyro_odr) < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
/* Set FIFO bypass mode */
if (ism330dhcx_fifo_mode_set(ism330dhcx->ctx, ISM330DHCX_BYPASS_MODE) < 0) {
LOG_DBG("failed to set FIFO mode");
return -EIO;
}
if (ism330dhcx_block_data_update_set(ism330dhcx->ctx, 1) < 0) {
LOG_DBG("failed to set BDU mode");
return -EIO;
}
return 0;
}
static int ism330dhcx_init(const struct device *dev)
{
const struct ism330dhcx_config * const config = dev->config;
config->bus_init(dev);
if (ism330dhcx_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_ISM330DHCX_TRIGGER
if (config->drdy_gpio.port) {
if (ism330dhcx_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
#ifdef CONFIG_ISM330DHCX_SENSORHUB
if (ism330dhcx_shub_init(dev) < 0) {
LOG_DBG("failed to initialize external chip");
return -EIO;
}
#endif
return 0;
}
#define ISM330DHCX_DEFINE(inst) \
static struct ism330dhcx_data ism330dhcx_data_##inst; \
\
static const struct ism330dhcx_config ism330dhcx_config_##inst = { \
.accel_odr = DT_INST_PROP(inst, accel_odr), \
.accel_range = DT_INST_PROP(inst, accel_range), \
.gyro_odr = DT_INST_PROP(inst, gyro_odr), \
.gyro_range = DT_INST_PROP(inst, gyro_range), \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(.bus_init = ism330dhcx_spi_init, \
.spi = SPI_DT_SPEC_INST_GET(inst, SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | SPI_MODE_CPHA | \
SPI_WORD_SET(8), 0),), \
()) \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), \
(.bus_init = ism330dhcx_i2c_init, \
.i2c = I2C_DT_SPEC_INST_GET(inst),), \
()) \
IF_ENABLED(CONFIG_ISM330DHCX_TRIGGER, \
(.drdy_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, drdy_gpios, { 0 }), \
.int_pin = DT_INST_PROP_OR(inst, int_pin, 0),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, ism330dhcx_init, NULL, \
&ism330dhcx_data_##inst, &ism330dhcx_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &ism330dhcx_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(ISM330DHCX_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/ism330dhcx/ism330dhcx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,369 |
```c
/* ST Microelectronics ISM330DHCX 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_ism330dhcx
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "ism330dhcx.h"
LOG_MODULE_DECLARE(ISM330DHCX, CONFIG_SENSOR_LOG_LEVEL);
#define ISM330DHCX_SHUB_DATA_OUT 0x02
#define ISM330DHCX_SHUB_SLV0_ADDR 0x15
#define ISM330DHCX_SHUB_SLV0_SUBADDR 0x16
#define ISM330DHCX_SHUB_SLV0_CONFIG 0x17
#define ISM330DHCX_SHUB_SLV1_ADDR 0x18
#define ISM330DHCX_SHUB_SLV1_SUBADDR 0x19
#define ISM330DHCX_SHUB_SLV1_CONFIG 0x1A
#define ISM330DHCX_SHUB_SLV2_ADDR 0x1B
#define ISM330DHCX_SHUB_SLV2_SUBADDR 0x1C
#define ISM330DHCX_SHUB_SLV2_CONFIG 0x1D
#define ISM330DHCX_SHUB_SLV3_ADDR 0x1E
#define ISM330DHCX_SHUB_SLV3_SUBADDR 0x1F
#define ISM330DHCX_SHUB_SLV3_CONFIG 0x20
#define ISM330DHCX_SHUB_SLV0_DATAWRITE 0x21
#define ISM330DHCX_SHUB_STATUS_MASTER 0x22
#define ISM330DHCX_SHUB_STATUS_SLV0_NACK BIT(3)
#define ISM330DHCX_SHUB_STATUS_ENDOP BIT(0)
#define ISM330DHCX_SHUB_SLVX_WRITE 0x0
#define ISM330DHCX_SHUB_SLVX_READ 0x1
static uint8_t num_ext_dev;
static uint8_t shub_ext[ISM330DHCX_SHUB_MAX_NUM_SLVS];
static int ism330dhcx_shub_write_slave_reg(const struct device *dev, uint8_t slv_addr,
uint8_t slv_reg, uint8_t *value, uint16_t len);
static int ism330dhcx_shub_read_slave_reg(const struct device *dev, uint8_t slv_addr,
uint8_t slv_reg, uint8_t *value, uint16_t len);
static void ism330dhcx_shub_enable(const struct device *dev, uint8_t enable);
/*
* LIS2MDL magn device specific part
*/
#if defined(CONFIG_ISM330DHCX_EXT_LIS2MDL) || defined(CONFIG_ISM330DHCX_EXT_IIS2MDC)
#define LIS2MDL_CFG_REG_A 0x60
#define LIS2MDL_CFG_REG_B 0x61
#define LIS2MDL_CFG_REG_C 0x62
#define LIS2MDL_STATUS_REG 0x67
#define LIS2MDL_SW_RESET 0x20
#define LIS2MDL_ODR_10HZ 0x00
#define LIS2MDL_ODR_100HZ 0x0C
#define LIS2MDL_OFF_CANC 0x02
#define LIS2MDL_SENSITIVITY 1500
static int ism330dhcx_lis2mdl_init(const struct device *dev, uint8_t i2c_addr)
{
struct ism330dhcx_data *data = dev->data;
uint8_t mag_cfg[2];
data->magn_gain = LIS2MDL_SENSITIVITY;
/* sw reset device */
mag_cfg[0] = LIS2MDL_SW_RESET;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LIS2MDL_CFG_REG_A, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
/* configure mag */
mag_cfg[0] = LIS2MDL_ODR_10HZ;
mag_cfg[1] = LIS2MDL_OFF_CANC;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LIS2MDL_CFG_REG_A, mag_cfg, 2);
return 0;
}
static const uint16_t lis2mdl_map[] = {10, 20, 50, 100};
static int ism330dhcx_lis2mdl_odr_set(const struct device *dev, uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lis2mdl_map); odr++) {
if (freq == lis2mdl_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lis2mdl_map)) {
LOG_DBG("shub: LIS2MDL freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 2);
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LIS2MDL_CFG_REG_A, &cfg, 1);
ism330dhcx_shub_enable(dev, 1);
return 0;
}
static int ism330dhcx_lis2mdl_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan, enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return ism330dhcx_lis2mdl_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LIS2MDL attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_ISM330DHCX_EXT_LIS2MDL || CONFIG_ISM330DHCX_EXT_IIS2MDC */
/*
* HTS221 humidity device specific part
*/
#ifdef CONFIG_ISM330DHCX_EXT_HTS221
#define HTS221_AUTOINCREMENT BIT(7)
#define HTS221_REG_CTRL1 0x20
#define HTS221_ODR_1HZ 0x01
#define HTS221_BDU 0x04
#define HTS221_PD 0x80
#define HTS221_REG_CONV_START 0x30
static int ism330dhcx_hts221_read_conv_data(const struct device *dev, uint8_t i2c_addr)
{
struct ism330dhcx_data *data = dev->data;
uint8_t buf[16], i;
struct hts221_data *ht = &data->hts221;
for (i = 0; i < sizeof(buf); i += 7) {
unsigned char len = MIN(7, sizeof(buf) - i);
if (ism330dhcx_shub_read_slave_reg(dev, i2c_addr, (HTS221_REG_CONV_START + i)
| HTS221_AUTOINCREMENT, &buf[i],
len) < 0) {
LOG_DBG("shub: failed to read hts221 conv data");
return -EIO;
}
}
ht->y0 = buf[0] / 2;
ht->y1 = buf[1] / 2;
ht->x0 = sys_le16_to_cpu(buf[6] | (buf[7] << 8));
ht->x1 = sys_le16_to_cpu(buf[10] | (buf[11] << 8));
return 0;
}
static int ism330dhcx_hts221_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t hum_cfg;
/* configure ODR and BDU */
hum_cfg = HTS221_ODR_1HZ | HTS221_BDU | HTS221_PD;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, HTS221_REG_CTRL1, &hum_cfg, 1);
return ism330dhcx_hts221_read_conv_data(dev, i2c_addr);
}
static const uint16_t hts221_map[] = {0, 1, 7, 12};
static int ism330dhcx_hts221_odr_set(const struct device *dev, uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(hts221_map); odr++) {
if (freq == hts221_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(hts221_map)) {
LOG_DBG("shub: HTS221 freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = odr | HTS221_BDU | HTS221_PD;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, HTS221_REG_CTRL1, &cfg, 1);
ism330dhcx_shub_enable(dev, 1);
return 0;
}
static int ism330dhcx_hts221_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan, enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return ism330dhcx_hts221_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: HTS221 attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_ISM330DHCX_EXT_HTS221 */
/*
* LPS22HB baro/temp device specific part
*/
#ifdef CONFIG_ISM330DHCX_EXT_LPS22HB
#define LPS22HB_CTRL_REG1 0x10
#define LPS22HB_CTRL_REG2 0x11
#define LPS22HB_SW_RESET 0x04
#define LPS22HB_ODR_10HZ 0x20
#define LPS22HB_LPF_EN 0x08
#define LPS22HB_BDU_EN 0x02
static int ism330dhcx_lps22hb_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HB_SW_RESET;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LPS22HB_CTRL_REG2, baro_cfg, 1);
k_sleep(K_MSEC(1)); /* turn-on time in ms */
/* configure device */
baro_cfg[0] = LPS22HB_ODR_10HZ | LPS22HB_LPF_EN | LPS22HB_BDU_EN;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LPS22HB_CTRL_REG1, baro_cfg, 1);
return 0;
}
#endif /* CONFIG_ISM330DHCX_EXT_LPS22HB */
/*
* LPS22HH baro/temp device specific part
*/
#ifdef CONFIG_ISM330DHCX_EXT_LPS22HH
#define LPS22HH_CTRL_REG1 0x10
#define LPS22HH_CTRL_REG2 0x11
#define LPS22HH_SW_RESET 0x04
#define LPS22HH_IF_ADD_INC 0x10
#define LPS22HH_ODR_10HZ 0x20
#define LPS22HH_LPF_EN 0x08
#define LPS22HH_BDU_EN 0x02
static int ism330dhcx_lps22hh_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HH_SW_RESET;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LPS22HH_CTRL_REG2, baro_cfg, 1);
k_sleep(K_MSEC(100)); /* turn-on time in ms */
/* configure device */
baro_cfg[0] = LPS22HH_IF_ADD_INC;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LPS22HH_CTRL_REG2, baro_cfg, 1);
baro_cfg[0] = LPS22HH_ODR_10HZ | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LPS22HH_CTRL_REG1, baro_cfg, 1);
return 0;
}
static const uint16_t lps22hh_map[] = {0, 1, 10, 25, 50, 75, 100, 200};
static int ism330dhcx_lps22hh_odr_set(const struct device *dev, uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lps22hh_map); odr++) {
if (freq == lps22hh_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lps22hh_map)) {
LOG_DBG("shub: LPS22HH freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 4) | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
ism330dhcx_shub_write_slave_reg(dev, i2c_addr, LPS22HH_CTRL_REG1, &cfg, 1);
ism330dhcx_shub_enable(dev, 1);
return 0;
}
static int ism330dhcx_lps22hh_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan, enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return ism330dhcx_lps22hh_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LPS22HH attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_ISM330DHCX_EXT_LPS22HH */
/* List of supported external sensors */
static struct ism330dhcx_shub_slist {
enum sensor_channel type;
uint8_t i2c_addr[2];
uint8_t ext_i2c_addr;
uint8_t wai_addr;
uint8_t wai_val;
uint8_t out_data_addr;
uint8_t out_data_len;
uint8_t sh_out_reg;
int (*dev_init)(const struct device *dev, uint8_t i2c_addr);
int (*dev_conf)(const struct device *dev, uint8_t i2c_addr, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val);
} ism330dhcx_shub_slist[] = {
#if defined(CONFIG_ISM330DHCX_EXT_LIS2MDL) || defined(CONFIG_ISM330DHCX_EXT_IIS2MDC)
{
/* LIS2MDL */
.type = SENSOR_CHAN_MAGN_XYZ,
.i2c_addr = { 0x1E },
.wai_addr = 0x4F,
.wai_val = 0x40,
.out_data_addr = 0x68,
.out_data_len = 0x06,
.dev_init = (ism330dhcx_lis2mdl_init),
.dev_conf = (ism330dhcx_lis2mdl_conf),
},
#endif /* CONFIG_ISM330DHCX_EXT_LIS2MDL || CONFIG_ISM330DHCX_EXT_IIS2MDC */
#ifdef CONFIG_ISM330DHCX_EXT_HTS221
{
/* HTS221 */
.type = SENSOR_CHAN_HUMIDITY,
.i2c_addr = { 0x5F },
.wai_addr = 0x0F,
.wai_val = 0xBC,
.out_data_addr = 0x28 | HTS221_AUTOINCREMENT,
.out_data_len = 0x02,
.dev_init = (ism330dhcx_hts221_init),
.dev_conf = (ism330dhcx_hts221_conf),
},
#endif /* CONFIG_ISM330DHCX_EXT_HTS221 */
#ifdef CONFIG_ISM330DHCX_EXT_LPS22HB
{
/* LPS22HB */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB1,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (ism330dhcx_lps22hb_init),
},
#endif /* CONFIG_ISM330DHCX_EXT_LPS22HB */
#ifdef CONFIG_ISM330DHCX_EXT_LPS22HH
{
/* LPS22HH */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB3,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (ism330dhcx_lps22hh_init),
.dev_conf = (ism330dhcx_lps22hh_conf),
},
#endif /* CONFIG_ISM330DHCX_EXT_LPS22HH */
};
static inline void ism330dhcx_shub_wait_completed(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
ism330dhcx_status_master_t status;
do {
k_msleep(1);
ism330dhcx_sh_status_get(data->ctx, &status);
} while (status.sens_hub_endop == 0);
}
static inline void ism330dhcx_shub_embedded_en(const struct device *dev, bool on)
{
struct ism330dhcx_data *data = dev->data;
if (on) {
(void) ism330dhcx_mem_bank_set(data->ctx, ISM330DHCX_SENSOR_HUB_BANK);
} else {
(void) ism330dhcx_mem_bank_set(data->ctx, ISM330DHCX_USER_BANK);
}
k_busy_wait(150);
}
static int ism330dhcx_shub_read_embedded_regs(const struct device *dev, uint8_t reg_addr,
uint8_t *value, int len)
{
struct ism330dhcx_data *data = dev->data;
ism330dhcx_shub_embedded_en(dev, true);
if (ism330dhcx_read_reg(data->ctx, reg_addr, value, len) < 0) {
LOG_DBG("shub: failed to read external reg: %02x", reg_addr);
ism330dhcx_shub_embedded_en(dev, false);
return -EIO;
}
ism330dhcx_shub_embedded_en(dev, false);
return 0;
}
static int ism330dhcx_shub_write_embedded_regs(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
struct ism330dhcx_data *data = dev->data;
ism330dhcx_shub_embedded_en(dev, true);
if (ism330dhcx_write_reg(data->ctx, reg_addr, value, len) < 0) {
LOG_DBG("shub: failed to write external reg: %02x", reg_addr);
ism330dhcx_shub_embedded_en(dev, false);
return -EIO;
}
ism330dhcx_shub_embedded_en(dev, false);
return 0;
}
static void ism330dhcx_shub_enable(const struct device *dev, uint8_t enable)
{
struct ism330dhcx_data *data = dev->data;
/* Enable Accel @26hz */
if (!data->accel_freq) {
uint8_t odr = (enable) ? 2 : 0;
if (ism330dhcx_xl_data_rate_set(data->ctx, odr) < 0) {
LOG_DBG("shub: failed to set XL sampling rate");
return;
}
}
ism330dhcx_shub_embedded_en(dev, true);
if (ism330dhcx_sh_master_set(data->ctx, enable) < 0) {
LOG_DBG("shub: failed to set master on");
ism330dhcx_shub_embedded_en(dev, false);
return;
}
ism330dhcx_shub_embedded_en(dev, false);
}
/* must be called with master on */
static int ism330dhcx_shub_check_slv0_nack(const struct device *dev)
{
uint8_t status;
if (ism330dhcx_shub_read_embedded_regs(dev, ISM330DHCX_SHUB_STATUS_MASTER, &status, 1) <
0) {
LOG_DBG("shub: error reading embedded reg");
return -EIO;
}
if (status & (ISM330DHCX_SHUB_STATUS_SLV0_NACK)) {
LOG_DBG("shub: SLV0 nacked");
return -EIO;
}
return 0;
}
/*
* use SLV0 for generic read to slave device
*/
static int ism330dhcx_shub_read_slave_reg(const struct device *dev, uint8_t slv_addr,
uint8_t slv_reg, uint8_t *value, uint16_t len)
{
struct ism330dhcx_data *data = dev->data;
uint8_t slave[3];
slave[0] = (slv_addr << 1) | ISM330DHCX_SHUB_SLVX_READ;
slave[1] = slv_reg;
slave[2] = (len & 0x7);
if (ism330dhcx_shub_write_embedded_regs(dev, ISM330DHCX_SHUB_SLV0_ADDR, slave, 3) < 0) {
LOG_DBG("shub: error writing embedded reg");
return -EIO;
}
/* turn SH on */
ism330dhcx_shub_enable(dev, 1);
ism330dhcx_shub_wait_completed(dev);
if (ism330dhcx_shub_check_slv0_nack(dev) < 0) {
ism330dhcx_shub_enable(dev, 0);
return -EIO;
}
/* read data from external slave */
ism330dhcx_shub_embedded_en(dev, true);
if (ism330dhcx_read_reg(data->ctx, ISM330DHCX_SHUB_DATA_OUT,
value, len) < 0) {
LOG_DBG("shub: error reading sensor data");
ism330dhcx_shub_embedded_en(dev, false);
return -EIO;
}
ism330dhcx_shub_embedded_en(dev, false);
ism330dhcx_shub_enable(dev, 0);
return 0;
}
/*
* use SLV0 to configure slave device
*/
static int ism330dhcx_shub_write_slave_reg(const struct device *dev, uint8_t slv_addr,
uint8_t slv_reg, uint8_t *value, uint16_t len)
{
uint8_t slv_cfg[3];
uint8_t cnt = 0U;
while (cnt < len) {
slv_cfg[0] = (slv_addr << 1) & ~ISM330DHCX_SHUB_SLVX_READ;
slv_cfg[1] = slv_reg + cnt;
if (ism330dhcx_shub_write_embedded_regs(dev, ISM330DHCX_SHUB_SLV0_ADDR, slv_cfg,
2) < 0) {
LOG_DBG("shub: error writing embedded reg");
return -EIO;
}
slv_cfg[0] = value[cnt];
if (ism330dhcx_shub_write_embedded_regs(dev, ISM330DHCX_SHUB_SLV0_DATAWRITE,
slv_cfg, 1) < 0) {
LOG_DBG("shub: error writing embedded reg");
return -EIO;
}
/* turn SH on */
ism330dhcx_shub_enable(dev, 1);
ism330dhcx_shub_wait_completed(dev);
if (ism330dhcx_shub_check_slv0_nack(dev) < 0) {
ism330dhcx_shub_enable(dev, 0);
return -EIO;
}
ism330dhcx_shub_enable(dev, 0);
cnt++;
}
/* Put SLV0 in IDLE mode */
slv_cfg[0] = 0x7;
slv_cfg[1] = 0x0;
slv_cfg[2] = 0x0;
if (ism330dhcx_shub_write_embedded_regs(dev, ISM330DHCX_SHUB_SLV0_ADDR, slv_cfg, 3) < 0) {
LOG_DBG("shub: error writing embedded reg");
return -EIO;
}
return 0;
}
/*
* SLAVEs configurations:
*
* - SLAVE 0: used for configuring all slave devices
* - SLAVE 1: used as data read channel for external slave device #1
* - SLAVE 2: used as data read channel for external slave device #2
* - SLAVE 3: used for generic reads while data channel is enabled
*/
static int ism330dhcx_shub_set_data_channel(const struct device *dev)
{
struct ism330dhcx_data *data = dev->data;
uint8_t n, i, slv_cfg[6];
struct ism330dhcx_shub_slist *sp;
/* Set data channel for slave devices */
for (n = 0; n < num_ext_dev; n++) {
sp = &ism330dhcx_shub_slist[shub_ext[n]];
i = n * 3;
slv_cfg[i] = (sp->ext_i2c_addr << 1) | ISM330DHCX_SHUB_SLVX_READ;
slv_cfg[i + 1] = sp->out_data_addr;
slv_cfg[i + 2] = sp->out_data_len;
}
if (ism330dhcx_shub_write_embedded_regs(dev, ISM330DHCX_SHUB_SLV1_ADDR, slv_cfg,
n * 3) < 0) {
LOG_DBG("shub: error writing embedded reg");
return -EIO;
}
/* Configure the master */
ism330dhcx_aux_sens_on_t aux = ISM330DHCX_SLV_0_1_2;
if (ism330dhcx_sh_slave_connected_set(data->ctx, aux) < 0) {
LOG_DBG("shub: error setting aux sensors");
return -EIO;
}
ism330dhcx_write_once_t wo = ISM330DHCX_ONLY_FIRST_CYCLE;
if (ism330dhcx_sh_write_mode_set(data->ctx, wo) < 0) {
LOG_DBG("shub: error setting write once");
return -EIO;
}
/* turn SH on */
ism330dhcx_shub_enable(dev, 1);
ism330dhcx_shub_wait_completed(dev);
return 0;
}
int ism330dhcx_shub_get_idx(enum sensor_channel type)
{
uint8_t n;
struct ism330dhcx_shub_slist *sp;
for (n = 0; n < num_ext_dev; n++) {
sp = &ism330dhcx_shub_slist[shub_ext[n]];
if (sp->type == type) {
return n;
}
}
return -ENOTSUP;
}
int ism330dhcx_shub_fetch_external_devs(const struct device *dev)
{
uint8_t n;
struct ism330dhcx_data *data = dev->data;
struct ism330dhcx_shub_slist *sp;
/* read data from external slave */
ism330dhcx_shub_embedded_en(dev, true);
for (n = 0; n < num_ext_dev; n++) {
sp = &ism330dhcx_shub_slist[shub_ext[n]];
if (ism330dhcx_read_reg(data->ctx, sp->sh_out_reg,
data->ext_data[n], sp->out_data_len) < 0) {
LOG_DBG("shub: failed to read sample");
ism330dhcx_shub_embedded_en(dev, false);
return -EIO;
}
}
ism330dhcx_shub_embedded_en(dev, false);
return 0;
}
int ism330dhcx_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct ism330dhcx_shub_slist *sp = NULL;
uint8_t n;
for (n = 0; n < num_ext_dev; n++) {
sp = &ism330dhcx_shub_slist[shub_ext[n]];
if (sp->type == chan) {
break;
}
}
if (n == num_ext_dev) {
LOG_DBG("shub: chan not supported");
return -ENOTSUP;
}
if (sp == NULL || sp->dev_conf == NULL) {
LOG_DBG("shub: chan not configurable");
return -ENOTSUP;
}
return sp->dev_conf(dev, sp->ext_i2c_addr, chan, attr, val);
}
int ism330dhcx_shub_init(const struct device *dev)
{
uint8_t i, n = 0, regn;
uint8_t chip_id;
struct ism330dhcx_shub_slist *sp;
for (n = 0; n < ARRAY_SIZE(ism330dhcx_shub_slist); n++) {
if (num_ext_dev >= ISM330DHCX_SHUB_MAX_NUM_SLVS) {
break;
}
chip_id = 0;
sp = &ism330dhcx_shub_slist[n];
/*
* The external sensor may have different I2C address.
* So, try them one by one until we read the correct
* chip ID.
*/
for (i = 0U; i < ARRAY_SIZE(sp->i2c_addr); i++) {
if (ism330dhcx_shub_read_slave_reg(dev, sp->i2c_addr[i], sp->wai_addr,
&chip_id, 1) < 0) {
continue;
}
if (chip_id == sp->wai_val) {
break;
}
}
if (i >= ARRAY_SIZE(sp->i2c_addr)) {
LOG_DBG("shub: invalid chip id 0x%x", chip_id);
continue;
}
LOG_INF("shub: Ext Device Chip Id: 0x%02x", chip_id);
sp->ext_i2c_addr = sp->i2c_addr[i];
shub_ext[num_ext_dev++] = n;
}
if (num_ext_dev == 0) {
LOG_ERR("shub: no slave devices found");
return -EINVAL;
}
/* init external devices */
for (n = 0, regn = 0; n < num_ext_dev; n++) {
sp = &ism330dhcx_shub_slist[shub_ext[n]];
sp->sh_out_reg = ISM330DHCX_SHUB_DATA_OUT + regn;
regn += sp->out_data_len;
sp->dev_init(dev, sp->ext_i2c_addr);
}
ism330dhcx_shub_set_data_channel(dev);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/ism330dhcx/ism330dhcx_shub.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,140 |
```objective-c
/* ST Microelectronics ISM330DHCX 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ISM330DHCX_ISM330DHCX_H_
#define ZEPHYR_DRIVERS_SENSOR_ISM330DHCX_ISM330DHCX_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "ism330dhcx_reg.h"
#define ISM330DHCX_EN_BIT 0x01
#define ISM330DHCX_DIS_BIT 0x00
/* Accel sensor sensitivity grain is 61 ug/LSB */
#define GAIN_UNIT_XL (61LL)
/* Gyro sensor sensitivity grain is 4.375 udps/LSB */
#define GAIN_UNIT_G (4375LL)
struct ism330dhcx_config {
int (*bus_init)(const struct device *dev);
uint8_t accel_odr;
uint16_t gyro_odr;
uint8_t accel_range;
uint16_t gyro_range;
#ifdef CONFIG_ISM330DHCX_TRIGGER
uint8_t int_pin;
struct gpio_dt_spec drdy_gpio;
#endif /* CONFIG_ISM330DHCX_TRIGGER */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#elif DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
};
union samples {
uint8_t raw[6];
struct {
int16_t axis[3];
};
} __aligned(2);
#define ISM330DHCX_SHUB_MAX_NUM_SLVS 2
struct ism330dhcx_data {
const struct device *dev;
int16_t acc[3];
uint32_t acc_gain;
int16_t gyro[3];
uint32_t gyro_gain;
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
int temp_sample;
#endif
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
uint8_t ext_data[2][6];
uint16_t magn_gain;
struct hts221_data {
int16_t x0;
int16_t x1;
int16_t y0;
int16_t y1;
} hts221;
#endif /* CONFIG_ISM330DHCX_SENSORHUB */
stmdev_ctx_t *ctx;
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
stmdev_ctx_t ctx_i2c;
#elif DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
stmdev_ctx_t ctx_spi;
#endif
uint16_t accel_freq;
uint8_t accel_fs;
uint16_t gyro_freq;
uint8_t gyro_fs;
#ifdef CONFIG_ISM330DHCX_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy_acc;
const struct sensor_trigger *trig_drdy_acc;
sensor_trigger_handler_t handler_drdy_gyr;
const struct sensor_trigger *trig_drdy_gyr;
sensor_trigger_handler_t handler_drdy_temp;
const struct sensor_trigger *trig_drdy_temp;
#if defined(CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ISM330DHCX_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_ISM330DHCX_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_ISM330DHCX_TRIGGER */
};
int ism330dhcx_spi_init(const struct device *dev);
int ism330dhcx_i2c_init(const struct device *dev);
#if defined(CONFIG_ISM330DHCX_SENSORHUB)
int ism330dhcx_shub_init(const struct device *dev);
int ism330dhcx_shub_fetch_external_devs(const struct device *dev);
int ism330dhcx_shub_get_idx(enum sensor_channel type);
int ism330dhcx_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
#endif /* CONFIG_ISM330DHCX_SENSORHUB */
#ifdef CONFIG_ISM330DHCX_TRIGGER
int ism330dhcx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int ism330dhcx_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_ISM330DHCX_ISM330DHCX_H_ */
``` | /content/code_sandbox/drivers/sensor/st/ism330dhcx/ism330dhcx.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,025 |
```unknown
# ST Microelectronics ISM330DHCX 6-axis IMU sensor driver
menuconfig ISM330DHCX
bool "ISM330DHCX I2C/SPI accelerometer and gyroscope Chip"
default y
depends on DT_HAS_ST_ISM330DHCX_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_ISM330DHCX),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_ISM330DHCX),spi)
select HAS_STMEMSC
select USE_STDC_ISM330DHCX
help
Enable driver for ISM330DHCX accelerometer and gyroscope
sensor.
if ISM330DHCX
choice ISM330DHCX_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config ISM330DHCX_TRIGGER_NONE
bool "No trigger"
config ISM330DHCX_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ISM330DHCX_TRIGGER
config ISM330DHCX_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ISM330DHCX_TRIGGER
endchoice
config ISM330DHCX_TRIGGER
bool
if ISM330DHCX_TRIGGER
config ISM330DHCX_THREAD_PRIORITY
int "Thread priority"
depends on ISM330DHCX_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config ISM330DHCX_THREAD_STACK_SIZE
int "Thread stack size"
depends on ISM330DHCX_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # ISM330DHCX_TRIGGER
config ISM330DHCX_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
config ISM330DHCX_SENSORHUB
bool "I2C sensorhub feature"
help
Enable/disable internal sensorhub. You can enable
a maximum of two external sensors (if more than two are enabled
the system would enumerate only the first two found)
if ISM330DHCX_SENSORHUB
config ISM330DHCX_EXT_LIS2MDL
bool "LIS2MDL as external sensor"
config ISM330DHCX_EXT_IIS2MDC
bool "IIS2MDC as external sensor"
config ISM330DHCX_EXT_LPS22HH
bool "LPS22HH as external sensor"
config ISM330DHCX_EXT_HTS221
bool "HTS221 as external sensor"
config ISM330DHCX_EXT_LPS22HB
bool "LPS22HB as external sensor"
endif # ISM330DHCX_SENSORHUB
endif # ISM330DHCX
``` | /content/code_sandbox/drivers/sensor/st/ism330dhcx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 636 |
```c
/* ST Microelectronics ISM330DHCX 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_ism330dhcx
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "ism330dhcx.h"
LOG_MODULE_DECLARE(ISM330DHCX, CONFIG_SENSOR_LOG_LEVEL);
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
/**
* ism330dhcx_enable_t_int - TEMP enable selected int pin to generate interrupt
*/
static int ism330dhcx_enable_t_int(const struct device *dev, int enable)
{
const struct ism330dhcx_config *cfg = dev->config;
struct ism330dhcx_data *ism330dhcx = dev->data;
ism330dhcx_pin_int2_route_t int2_route;
if (enable) {
int16_t buf;
/* dummy read: re-trigger interrupt */
ism330dhcx_temperature_raw_get(ism330dhcx->ctx, &buf);
}
/* set interrupt (TEMP DRDY interrupt is only on INT2) */
if (cfg->int_pin == 1)
return -EIO;
ism330dhcx_read_reg(ism330dhcx->ctx, ISM330DHCX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
int2_route.int2_ctrl.int2_drdy_temp = enable;
return ism330dhcx_write_reg(ism330dhcx->ctx, ISM330DHCX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
}
#endif
/**
* ism330dhcx_enable_xl_int - XL enable selected int pin to generate interrupt
*/
static int ism330dhcx_enable_xl_int(const struct device *dev, int enable)
{
const struct ism330dhcx_config *cfg = dev->config;
struct ism330dhcx_data *ism330dhcx = dev->data;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
ism330dhcx_acceleration_raw_get(ism330dhcx->ctx, buf);
}
/* set interrupt */
if (cfg->int_pin == 1) {
ism330dhcx_pin_int1_route_t int1_route;
ism330dhcx_read_reg(ism330dhcx->ctx, ISM330DHCX_INT1_CTRL,
(uint8_t *)&int1_route.int1_ctrl, 1);
int1_route.int1_ctrl.int1_drdy_xl = enable;
return ism330dhcx_write_reg(ism330dhcx->ctx, ISM330DHCX_INT1_CTRL,
(uint8_t *)&int1_route.int1_ctrl, 1);
} else {
ism330dhcx_pin_int2_route_t int2_route;
ism330dhcx_read_reg(ism330dhcx->ctx, ISM330DHCX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
int2_route.int2_ctrl.int2_drdy_xl = enable;
return ism330dhcx_write_reg(ism330dhcx->ctx, ISM330DHCX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
}
}
/**
* ism330dhcx_enable_g_int - Gyro enable selected int pin to generate interrupt
*/
static int ism330dhcx_enable_g_int(const struct device *dev, int enable)
{
const struct ism330dhcx_config *cfg = dev->config;
struct ism330dhcx_data *ism330dhcx = dev->data;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
ism330dhcx_angular_rate_raw_get(ism330dhcx->ctx, buf);
}
/* set interrupt */
if (cfg->int_pin == 1) {
ism330dhcx_pin_int1_route_t int1_route;
ism330dhcx_read_reg(ism330dhcx->ctx, ISM330DHCX_INT1_CTRL,
(uint8_t *)&int1_route.int1_ctrl, 1);
int1_route.int1_ctrl.int1_drdy_g = enable;
return ism330dhcx_write_reg(ism330dhcx->ctx, ISM330DHCX_INT1_CTRL,
(uint8_t *)&int1_route.int1_ctrl, 1);
} else {
ism330dhcx_pin_int2_route_t int2_route;
ism330dhcx_read_reg(ism330dhcx->ctx, ISM330DHCX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
int2_route.int2_ctrl.int2_drdy_g = enable;
return ism330dhcx_write_reg(ism330dhcx->ctx, ISM330DHCX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
}
}
/**
* ism330dhcx_trigger_set - link external trigger to event data ready
*/
int ism330dhcx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct ism330dhcx_data *ism330dhcx = dev->data;
const struct ism330dhcx_config *cfg = dev->config;
if (!cfg->drdy_gpio.port) {
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_ACCEL_XYZ) {
ism330dhcx->handler_drdy_acc = handler;
ism330dhcx->trig_drdy_acc = trig;
if (handler) {
return ism330dhcx_enable_xl_int(dev, ISM330DHCX_EN_BIT);
} else {
return ism330dhcx_enable_xl_int(dev, ISM330DHCX_DIS_BIT);
}
} else if (trig->chan == SENSOR_CHAN_GYRO_XYZ) {
ism330dhcx->handler_drdy_gyr = handler;
ism330dhcx->trig_drdy_gyr = trig;
if (handler) {
return ism330dhcx_enable_g_int(dev, ISM330DHCX_EN_BIT);
} else {
return ism330dhcx_enable_g_int(dev, ISM330DHCX_DIS_BIT);
}
}
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
else if (trig->chan == SENSOR_CHAN_DIE_TEMP) {
ism330dhcx->handler_drdy_temp = handler;
ism330dhcx->trig_drdy_temp = trig;
if (handler) {
return ism330dhcx_enable_t_int(dev, ISM330DHCX_EN_BIT);
} else {
return ism330dhcx_enable_t_int(dev, ISM330DHCX_DIS_BIT);
}
}
#endif
return -ENOTSUP;
}
/**
* ism330dhcx_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void ism330dhcx_handle_interrupt(const struct device *dev)
{
struct ism330dhcx_data *ism330dhcx = dev->data;
const struct ism330dhcx_config *cfg = dev->config;
ism330dhcx_status_reg_t status;
while (1) {
if (ism330dhcx_status_reg_get(ism330dhcx->ctx, &status) < 0) {
LOG_DBG("failed reading status reg");
return;
}
if ((status.xlda == 0) && (status.gda == 0)
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
&& (status.tda == 0)
#endif
) {
break;
}
if ((status.xlda) && (ism330dhcx->handler_drdy_acc != NULL)) {
ism330dhcx->handler_drdy_acc(dev, ism330dhcx->trig_drdy_acc);
}
if ((status.gda) && (ism330dhcx->handler_drdy_gyr != NULL)) {
ism330dhcx->handler_drdy_gyr(dev, ism330dhcx->trig_drdy_gyr);
}
#if defined(CONFIG_ISM330DHCX_ENABLE_TEMP)
if ((status.tda) && (ism330dhcx->handler_drdy_temp != NULL)) {
ism330dhcx->handler_drdy_temp(dev, ism330dhcx->trig_drdy_temp);
}
#endif
}
gpio_pin_interrupt_configure_dt(&cfg->drdy_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
static void ism330dhcx_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct ism330dhcx_data *ism330dhcx =
CONTAINER_OF(cb, struct ism330dhcx_data, gpio_cb);
const struct ism330dhcx_config *cfg = ism330dhcx->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->drdy_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD)
k_sem_give(&ism330dhcx->gpio_sem);
#elif defined(CONFIG_ISM330DHCX_TRIGGER_GLOBAL_THREAD)
k_work_submit(&ism330dhcx->work);
#endif /* CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD
static void ism330dhcx_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct ism330dhcx_data *ism330dhcx = p1;
while (1) {
k_sem_take(&ism330dhcx->gpio_sem, K_FOREVER);
ism330dhcx_handle_interrupt(ism330dhcx->dev);
}
}
#endif /* CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD */
#ifdef CONFIG_ISM330DHCX_TRIGGER_GLOBAL_THREAD
static void ism330dhcx_work_cb(struct k_work *work)
{
struct ism330dhcx_data *ism330dhcx =
CONTAINER_OF(work, struct ism330dhcx_data, work);
ism330dhcx_handle_interrupt(ism330dhcx->dev);
}
#endif /* CONFIG_ISM330DHCX_TRIGGER_GLOBAL_THREAD */
int ism330dhcx_init_interrupt(const struct device *dev)
{
struct ism330dhcx_data *ism330dhcx = dev->data;
const struct ism330dhcx_config *cfg = dev->config;
int ret;
if (!gpio_is_ready_dt(&cfg->drdy_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
#if defined(CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD)
k_sem_init(&ism330dhcx->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&ism330dhcx->thread, ism330dhcx->thread_stack,
CONFIG_ISM330DHCX_THREAD_STACK_SIZE,
ism330dhcx_thread,
ism330dhcx, NULL, NULL,
K_PRIO_COOP(CONFIG_ISM330DHCX_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ISM330DHCX_TRIGGER_GLOBAL_THREAD)
ism330dhcx->work.handler = ism330dhcx_work_cb;
#endif /* CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->drdy_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&ism330dhcx->gpio_cb, ism330dhcx_gpio_callback, BIT(cfg->drdy_gpio.pin));
if (gpio_add_callback(cfg->drdy_gpio.port, &ism330dhcx->gpio_cb) < 0) {
LOG_ERR("Could not set gpio callback");
return -EIO;
}
/* enable interrupt on int1/int2 in pulse mode */
if (ism330dhcx_data_ready_mode_set(ism330dhcx->ctx,
ISM330DHCX_DRDY_PULSED) < 0) {
LOG_ERR("Could not set pulse mode");
return -EIO;
}
return gpio_pin_interrupt_configure_dt(&cfg->drdy_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/ism330dhcx/ism330dhcx_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,760 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LIS3MDL_LIS3MDL_H_
#define ZEPHYR_DRIVERS_SENSOR_LIS3MDL_LIS3MDL_H_
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
#include <zephyr/types.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#define LIS3MDL_REG_WHO_AM_I 0x0F
#define LIS3MDL_CHIP_ID 0x3D
#define LIS3MDL_REG_CTRL1 0x20
#define LIS3MDL_TEMP_EN_MASK BIT(7)
#define LIS3MDL_TEMP_EN_SHIFT 7
#define LIS3MDL_OM_MASK (BIT(6) | BIT(5))
#define LIS3MDL_OM_SHIFT 5
#define LIS3MDL_MAG_DO_MASK (BIT(4) | BIT(3) | BIT(2))
#define LIS3MDL_DO_SHIFT 2
#define LIS3MDL_FAST_ODR_MASK BIT(1)
#define LIS3MDL_FAST_ODR_SHIFT 1
#define LIS3MDL_ST_MASK BIT(0)
#define LIS3MDL_ST_SHIFT 0
#define LIS3MDL_ODR_BITS(om_bits, do_bits, fast_odr) \
(((om_bits) << LIS3MDL_OM_SHIFT) | \
((do_bits) << LIS3MDL_DO_SHIFT) | \
((fast_odr) << LIS3MDL_FAST_ODR_SHIFT))
#define LIS3MDL_REG_CTRL2 0x21
#define LIS3MDL_FS_MASK (BIT(6) | BIT(5))
#define LIS3MDL_FS_SHIFT 5
#define LIS3MDL_REBOOT_MASK BIT(3)
#define LIS3MDL_REBOOT_SHIFT 3
#define LIS3MDL_SOFT_RST_MASK BIT(2)
#define LIS3MDL_SOFT_RST_SHIFT 2
#define LIS3MDL_FS_IDX ((CONFIG_LIS3MDL_FS / 4) - 1)
/* guard against invalid CONFIG_LIS3MDL_FS values */
#if CONFIG_LIS3MDL_FS % 4 != 0 || LIS3MDL_FS_IDX < -1 || LIS3MDL_FS_IDX >= 4
#error "Invalid value for CONFIG_LIS3MDL_FS"
#endif
#define LIS3MDL_REG_CTRL3 0x22
#define LIS3MDL_LP_MASK BIT(5)
#define LIS3MDL_LP_SHIFT 5
#define LIS3MDL_SIM_MASK BIT(2)
#define LIS3MDL_SIM_SHIFT 2
#define LIS3MDL_MD_MASK (BIT(1) | BIT(0))
#define LIS3MDL_MD_SHIFT 0
#define LIS3MDL_MD_CONTINUOUS 0
#define LIS3MDL_MD_SINGLE 1
#define LIS3MDL_MD_POWER_DOWN 2
#define LIS3MDL_MD_POWER_DOWN_AUTO 3
#define LIS3MDL_REG_CTRL4 0x23
#define LIS3MDL_OMZ_MASK (BIT(3) | BIT(2))
#define LIS3MDL_OMZ_SHIFT 2
#define LIS3MDL_BLE_MASK BIT(1)
#define LIS3MDL_BLE_SHIFT 1
#define LIS3MDL_REG_CTRL5 0x24
#define LIS3MDL_FAST_READ_MASK BIT(7)
#define LIS3MDL_FAST_READ_SHIFT 7
#define LIS3MDL_BDU_MASK BIT(6)
#define LIS3MDL_BDU_SHIFT 6
#define LIS3MDL_BDU_EN (1 << LIS3MDL_BDU_SHIFT)
#define LIS3MDL_REG_SAMPLE_START 0x28
#define LIS3MDL_REG_INT_CFG 0x30
#define LIS3MDL_INT_X_EN BIT(7)
#define LIS3MDL_INT_Y_EN BIT(6)
#define LIS3MDL_INT_Z_EN BIT(5)
#define LIS3MDL_INT_XYZ_EN \
(LIS3MDL_INT_X_EN | LIS3MDL_INT_Y_EN | LIS3MDL_INT_Z_EN)
static const char * const lis3mdl_odr_strings[] = {
"0.625", "1.25", "2.5", "5", "10", "20",
"40", "80", "155", "300", "560", "1000"
};
static const uint8_t lis3mdl_odr_bits[] = {
LIS3MDL_ODR_BITS(0, 0, 0), /* 0.625 Hz */
LIS3MDL_ODR_BITS(0, 1, 0), /* 1.25 Hz */
LIS3MDL_ODR_BITS(0, 2, 0), /* 2.5 Hz */
LIS3MDL_ODR_BITS(0, 3, 0), /* 5 Hz */
LIS3MDL_ODR_BITS(0, 4, 0), /* 10 Hz */
LIS3MDL_ODR_BITS(0, 5, 0), /* 20 Hz */
LIS3MDL_ODR_BITS(0, 6, 0), /* 40 Hz */
LIS3MDL_ODR_BITS(0, 7, 0), /* 80 Hz */
LIS3MDL_ODR_BITS(3, 0, 1), /* 155 Hz */
LIS3MDL_ODR_BITS(2, 0, 1), /* 300 Hz */
LIS3MDL_ODR_BITS(1, 0, 1), /* 560 Hz */
LIS3MDL_ODR_BITS(0, 0, 1) /* 1000 Hz */
};
static const uint16_t lis3mdl_magn_gain[] = {
6842, 3421, 2281, 1711
};
struct lis3mdl_data {
int16_t x_sample;
int16_t y_sample;
int16_t z_sample;
int16_t temp_sample;
#ifdef CONFIG_LIS3MDL_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_LIS3MDL_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS3MDL_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_LIS3MDL_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LIS3MDL_TRIGGER */
};
struct lis3mdl_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_LIS3MDL_TRIGGER
struct gpio_dt_spec irq_gpio;
#endif
};
#ifdef CONFIG_LIS3MDL_TRIGGER
int lis3mdl_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lis3mdl_sample_fetch(const struct device *dev, enum sensor_channel chan);
int lis3mdl_init_interrupt(const struct device *dev);
#endif
#endif /* __SENSOR_LIS3MDL__ */
``` | /content/code_sandbox/drivers/sensor/st/lis3mdl/lis3mdl.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,559 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_lis3mdl_magn
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "lis3mdl.h"
LOG_MODULE_DECLARE(LIS3MDL, CONFIG_SENSOR_LOG_LEVEL);
int lis3mdl_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct lis3mdl_data *drv_data = dev->data;
const struct lis3mdl_config *config = dev->config;
int16_t buf[3];
int ret;
if (!config->irq_gpio.port) {
return -ENOTSUP;
}
__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
/* dummy read: re-trigger interrupt */
ret = i2c_burst_read_dt(&config->i2c, LIS3MDL_REG_SAMPLE_START,
(uint8_t *)buf, 6);
if (ret != 0) {
return ret;
}
gpio_pin_interrupt_configure_dt(&config->irq_gpio, GPIO_INT_DISABLE);
drv_data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
drv_data->data_ready_trigger = trig;
gpio_pin_interrupt_configure_dt(&config->irq_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
return 0;
}
static void lis3mdl_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis3mdl_data *drv_data =
CONTAINER_OF(cb, struct lis3mdl_data, gpio_cb);
const struct lis3mdl_config *config = drv_data->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&config->irq_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_LIS3MDL_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_LIS3MDL_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void lis3mdl_thread_cb(const struct device *dev)
{
struct lis3mdl_data *drv_data = dev->data;
const struct lis3mdl_config *config = dev->config;
if (drv_data->data_ready_handler != NULL) {
drv_data->data_ready_handler(dev,
drv_data->data_ready_trigger);
}
gpio_pin_interrupt_configure_dt(&config->irq_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
#ifdef CONFIG_LIS3MDL_TRIGGER_OWN_THREAD
static void lis3mdl_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lis3mdl_data *drv_data = p1;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
lis3mdl_thread_cb(drv_data->dev);
}
}
#endif
#ifdef CONFIG_LIS3MDL_TRIGGER_GLOBAL_THREAD
static void lis3mdl_work_cb(struct k_work *work)
{
struct lis3mdl_data *drv_data =
CONTAINER_OF(work, struct lis3mdl_data, work);
lis3mdl_thread_cb(drv_data->dev);
}
#endif
int lis3mdl_init_interrupt(const struct device *dev)
{
struct lis3mdl_data *drv_data = dev->data;
const struct lis3mdl_config *config = dev->config;
if (!gpio_is_ready_dt(&config->irq_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
gpio_pin_configure_dt(&config->irq_gpio, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb,
lis3mdl_gpio_callback,
BIT(config->irq_gpio.pin));
if (gpio_add_callback(config->irq_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback.");
return -EIO;
}
/* clear data ready interrupt line by reading sample data */
if (lis3mdl_sample_fetch(dev, SENSOR_CHAN_ALL) < 0) {
LOG_DBG("Could not clear data ready interrupt line.");
return -EIO;
}
drv_data->dev = dev;
#if defined(CONFIG_LIS3MDL_TRIGGER_OWN_THREAD)
k_sem_init(&drv_data->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_LIS3MDL_THREAD_STACK_SIZE,
lis3mdl_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_LIS3MDL_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_LIS3MDL_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = lis3mdl_work_cb;
#endif
gpio_pin_interrupt_configure_dt(&config->irq_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/lis3mdl/lis3mdl_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,071 |
```unknown
menuconfig LIS3MDL
bool "LIS3MDL magnetometer"
default y
depends on DT_HAS_ST_LIS3MDL_MAGN_ENABLED
select I2C
help
Enable driver for LIS3MDL I2C-based magnetometer.
if LIS3MDL
choice LIS3MDL_TRIGGER_MODE
prompt "Trigger mode"
default LIS3MDL_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config LIS3MDL_TRIGGER_NONE
bool "No trigger"
config LIS3MDL_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LIS3MDL_TRIGGER
config LIS3MDL_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LIS3MDL_TRIGGER
endchoice # LIS3MDL_TRIGGER_MODE
config LIS3MDL_TRIGGER
bool
config LIS3MDL_THREAD_PRIORITY
int "Thread priority"
depends on LIS3MDL_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LIS3MDL_THREAD_STACK_SIZE
int "Thread stack size"
depends on LIS3MDL_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config LIS3MDL_ODR
string "Output data rate"
default "0.625"
help
Magnetometer output data rate expressed in samples per second.
Data rates supported by the chip are 0.625, 1.25, 2.5, 5, 10, 20,
40, 80, 155, 300, 560 and 1000.
config LIS3MDL_FS
int "Full-scale range"
default 4
help
Magnetometer full-scale range.
An X value for the config represents a range of +/- X gauss. Valid
values are 4, 8, 12 and 16.
endif # LIS3MDL
``` | /content/code_sandbox/drivers/sensor/st/lis3mdl/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 431 |
```c
/* ST Microelectronics STTS751 temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_stts751
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "stts751.h"
LOG_MODULE_DECLARE(STTS751, CONFIG_SENSOR_LOG_LEVEL);
/**
* stts751_enable_int - enable selected int pin to generate interrupt
*/
static int stts751_enable_int(const struct device *dev, int enable)
{
struct stts751_data *stts751 = dev->data;
uint8_t en = (enable) ? 0 : 1;
return stts751_pin_event_route_set(stts751->ctx, en);
}
/**
* stts751_trigger_set - link external trigger to event data ready
*/
int stts751_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct stts751_data *stts751 = dev->data;
const struct stts751_config *config = dev->config;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_ALL) {
stts751->thsld_handler = handler;
stts751->thsld_trigger = trig;
if (handler) {
return stts751_enable_int(dev, 1);
} else {
return stts751_enable_int(dev, 0);
}
}
return -ENOTSUP;
}
/**
* stts751_handle_interrupt - handle the thsld event
* read data and call handler if registered any
*/
static void stts751_handle_interrupt(const struct device *dev)
{
struct stts751_data *stts751 = dev->data;
const struct stts751_config *cfg = dev->config;
stts751_status_t status;
stts751_status_reg_get(stts751->ctx, &status);
if (stts751->thsld_handler != NULL &&
(status.t_high || status.t_low)) {
stts751->thsld_handler(dev, stts751->thsld_trigger);
}
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
static void stts751_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct stts751_data *stts751 =
CONTAINER_OF(cb, struct stts751_data, gpio_cb);
const struct stts751_config *cfg = stts751->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_STTS751_TRIGGER_OWN_THREAD)
k_sem_give(&stts751->gpio_sem);
#elif defined(CONFIG_STTS751_TRIGGER_GLOBAL_THREAD)
k_work_submit(&stts751->work);
#endif /* CONFIG_STTS751_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_STTS751_TRIGGER_OWN_THREAD
static void stts751_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct stts751_data *stts751 = p1;
while (1) {
k_sem_take(&stts751->gpio_sem, K_FOREVER);
stts751_handle_interrupt(stts751->dev);
}
}
#endif /* CONFIG_STTS751_TRIGGER_OWN_THREAD */
#ifdef CONFIG_STTS751_TRIGGER_GLOBAL_THREAD
static void stts751_work_cb(struct k_work *work)
{
struct stts751_data *stts751 =
CONTAINER_OF(work, struct stts751_data, work);
stts751_handle_interrupt(stts751->dev);
}
#endif /* CONFIG_STTS751_TRIGGER_GLOBAL_THREAD */
int stts751_init_interrupt(const struct device *dev)
{
struct stts751_data *stts751 = dev->data;
const struct stts751_config *cfg = dev->config;
int ret;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
#if defined(CONFIG_STTS751_TRIGGER_OWN_THREAD)
k_sem_init(&stts751->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&stts751->thread, stts751->thread_stack,
CONFIG_STTS751_THREAD_STACK_SIZE,
stts751_thread, stts751,
NULL, NULL, K_PRIO_COOP(CONFIG_STTS751_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_STTS751_TRIGGER_GLOBAL_THREAD)
stts751->work.handler = stts751_work_cb;
#endif /* CONFIG_STTS751_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&stts751->gpio_cb, stts751_gpio_callback, BIT(cfg->int_gpio.pin));
if (gpio_add_callback(cfg->int_gpio.port, &stts751->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* Enable interrupt on high temperature */
float temp_hi = (float) CONFIG_STTS751_TEMP_HI_THRESHOLD;
float temp_lo = (float) CONFIG_STTS751_TEMP_LO_THRESHOLD;
stts751_high_temperature_threshold_set(stts751->ctx,
stts751_from_celsius_to_lsb(temp_hi));
stts751_low_temperature_threshold_set(stts751->ctx,
stts751_from_celsius_to_lsb(temp_lo));
return gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/stts751/stts751_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,223 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_lis3mdl_magn
#include <zephyr/drivers/i2c.h>
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <string.h>
#include <zephyr/logging/log.h>
#include "lis3mdl.h"
LOG_MODULE_REGISTER(LIS3MDL, CONFIG_SENSOR_LOG_LEVEL);
static void lis3mdl_convert(struct sensor_value *val, int16_t raw_val,
uint16_t divider)
{
/* val = raw_val / divider */
val->val1 = raw_val / divider;
val->val2 = (((int64_t)raw_val % divider) * 1000000L) / divider;
}
static int lis3mdl_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lis3mdl_data *drv_data = dev->data;
if (chan == SENSOR_CHAN_MAGN_XYZ) {
/* magn_val = sample / magn_gain */
lis3mdl_convert(val, drv_data->x_sample,
lis3mdl_magn_gain[LIS3MDL_FS_IDX]);
lis3mdl_convert(val + 1, drv_data->y_sample,
lis3mdl_magn_gain[LIS3MDL_FS_IDX]);
lis3mdl_convert(val + 2, drv_data->z_sample,
lis3mdl_magn_gain[LIS3MDL_FS_IDX]);
} else if (chan == SENSOR_CHAN_MAGN_X) {
lis3mdl_convert(val, drv_data->x_sample,
lis3mdl_magn_gain[LIS3MDL_FS_IDX]);
} else if (chan == SENSOR_CHAN_MAGN_Y) {
lis3mdl_convert(val, drv_data->y_sample,
lis3mdl_magn_gain[LIS3MDL_FS_IDX]);
} else if (chan == SENSOR_CHAN_MAGN_Z) {
lis3mdl_convert(val, drv_data->z_sample,
lis3mdl_magn_gain[LIS3MDL_FS_IDX]);
} else if (chan == SENSOR_CHAN_DIE_TEMP) {
/* temp_val = 25 + sample / 8 */
lis3mdl_convert(val, drv_data->temp_sample, 8);
val->val1 += 25;
} else {
return -ENOTSUP;
}
return 0;
}
int lis3mdl_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct lis3mdl_data *drv_data = dev->data;
const struct lis3mdl_config *config = dev->config;
int16_t buf[4];
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
/* fetch magnetometer sample */
if (i2c_burst_read_dt(&config->i2c, LIS3MDL_REG_SAMPLE_START,
(uint8_t *)buf, 8) < 0) {
LOG_DBG("Failed to fetch magnetometer sample.");
return -EIO;
}
/*
* the chip doesn't allow fetching temperature data in
* the same read as magnetometer data, so do another
* burst read to fetch the temperature sample
*/
if (i2c_burst_read_dt(&config->i2c, LIS3MDL_REG_SAMPLE_START + 6,
(uint8_t *)(buf + 3), 2) < 0) {
LOG_DBG("Failed to fetch temperature sample.");
return -EIO;
}
drv_data->x_sample = sys_le16_to_cpu(buf[0]);
drv_data->y_sample = sys_le16_to_cpu(buf[1]);
drv_data->z_sample = sys_le16_to_cpu(buf[2]);
drv_data->temp_sample = sys_le16_to_cpu(buf[3]);
return 0;
}
static const struct sensor_driver_api lis3mdl_driver_api = {
#if CONFIG_LIS3MDL_TRIGGER
.trigger_set = lis3mdl_trigger_set,
#endif
.sample_fetch = lis3mdl_sample_fetch,
.channel_get = lis3mdl_channel_get,
};
int lis3mdl_init(const struct device *dev)
{
const struct lis3mdl_config *config = dev->config;
uint8_t chip_cfg[6];
uint8_t id, idx;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
/* check chip ID */
if (i2c_reg_read_byte_dt(&config->i2c, LIS3MDL_REG_WHO_AM_I, &id) < 0) {
LOG_ERR("Failed to read chip ID.");
return -EIO;
}
if (id != LIS3MDL_CHIP_ID) {
LOG_ERR("Invalid chip ID.");
return -EINVAL;
}
/* check if CONFIG_LIS3MDL_ODR is valid */
for (idx = 0U; idx < ARRAY_SIZE(lis3mdl_odr_strings); idx++) {
if (!strcmp(lis3mdl_odr_strings[idx], CONFIG_LIS3MDL_ODR)) {
break;
}
}
if (idx == ARRAY_SIZE(lis3mdl_odr_strings)) {
LOG_ERR("Invalid ODR value.");
return -EINVAL;
}
/* Configure sensor */
chip_cfg[0] = LIS3MDL_REG_CTRL1;
chip_cfg[1] = LIS3MDL_TEMP_EN_MASK | lis3mdl_odr_bits[idx];
chip_cfg[2] = LIS3MDL_FS_IDX << LIS3MDL_FS_SHIFT;
chip_cfg[3] = LIS3MDL_MD_CONTINUOUS;
chip_cfg[4] = ((lis3mdl_odr_bits[idx] & LIS3MDL_OM_MASK) >>
LIS3MDL_OM_SHIFT) << LIS3MDL_OMZ_SHIFT;
chip_cfg[5] = LIS3MDL_BDU_EN;
if (i2c_write_dt(&config->i2c, chip_cfg, 6) < 0) {
LOG_DBG("Failed to configure chip.");
return -EIO;
}
#ifdef CONFIG_LIS3MDL_TRIGGER
if (config->irq_gpio.port) {
if (lis3mdl_init_interrupt(dev) < 0) {
LOG_DBG("Failed to initialize interrupts.");
return -EIO;
}
}
#endif
return 0;
}
#define LIS3MDL_DEFINE(inst) \
static struct lis3mdl_data lis3mdl_data_##inst; \
\
static struct lis3mdl_config lis3mdl_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_LIS3MDL_TRIGGER, \
(.irq_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, irq_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lis3mdl_init, NULL, \
&lis3mdl_data_##inst, &lis3mdl_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &lis3mdl_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(LIS3MDL_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis3mdl/lis3mdl.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,570 |
```objective-c
/* ST Microelectronics STTS751 temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_STTS751_STTS751_H_
#define ZEPHYR_DRIVERS_SENSOR_STTS751_STTS751_H_
#include <stdint.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "stts751_reg.h"
struct stts751_config {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
int (*bus_init)(const struct device *dev);
#ifdef CONFIG_STTS751_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
struct stts751_data {
const struct device *dev;
int16_t sample_temp;
stmdev_ctx_t *ctx;
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
stmdev_ctx_t ctx_i2c;
#endif
#ifdef CONFIG_STTS751_TRIGGER
struct gpio_callback gpio_cb;
const struct sensor_trigger *thsld_trigger;
sensor_trigger_handler_t thsld_handler;
#if defined(CONFIG_STTS751_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_STTS751_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_STTS751_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_STTS751_TRIGGER */
};
int stts751_i2c_init(const struct device *dev);
#ifdef CONFIG_STTS751_TRIGGER
int stts751_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int stts751_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_STTS751_STTS751_H_ */
``` | /content/code_sandbox/drivers/sensor/st/stts751/stts751.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 419 |
```c
/* ST Microelectronics STTS751 temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_stts751
#include <string.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include "stts751.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(STTS751, CONFIG_SENSOR_LOG_LEVEL);
static int stts751_i2c_read(const struct device *dev, uint8_t reg_addr, uint8_t *value,
uint16_t len)
{
const struct stts751_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->i2c, reg_addr, value, len);
}
static int stts751_i2c_write(const struct device *dev, uint8_t reg_addr, uint8_t *value,
uint16_t len)
{
const struct stts751_config *cfg = dev->config;
return i2c_burst_write_dt(&cfg->i2c, reg_addr, value, len);
}
int stts751_i2c_init(const struct device *dev)
{
struct stts751_data *data = dev->data;
data->ctx_i2c.read_reg = (stmdev_read_ptr) stts751_i2c_read;
data->ctx_i2c.write_reg = (stmdev_write_ptr) stts751_i2c_write;
data->ctx_i2c.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay,
data->ctx = &data->ctx_i2c;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/st/stts751/stts751_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 369 |
```c
/* ST Microelectronics STTS751 temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_stts751
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "stts751.h"
LOG_MODULE_REGISTER(STTS751, CONFIG_SENSOR_LOG_LEVEL);
static inline int stts751_set_odr_raw(const struct device *dev, uint8_t odr)
{
struct stts751_data *data = dev->data;
return stts751_temp_data_rate_set(data->ctx, odr);
}
static int stts751_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct stts751_data *data = dev->data;
int16_t raw_temp;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (stts751_temperature_raw_get(data->ctx, &raw_temp) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
data->sample_temp = raw_temp;
return 0;
}
static inline void stts751_temp_convert(struct sensor_value *val,
int16_t raw_val)
{
val->val1 = raw_val / 256;
val->val2 = ((int32_t)raw_val % 256) * 10000;
}
static int stts751_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct stts751_data *data = dev->data;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
stts751_temp_convert(val, data->sample_temp);
} else {
return -ENOTSUP;
}
return 0;
}
static const struct {
int32_t rate;
int32_t rate_dec;
} stts751_map[] = {
{0, 62500},
{0, 125000},
{0, 250000},
{0, 500000},
{1, 0},
{2, 0},
{4, 0},
{8, 0},
{16, 0},
{32, 0},
};
static int stts751_odr_set(const struct device *dev,
const struct sensor_value *val)
{
int odr;
for (odr = 0; odr < ARRAY_SIZE(stts751_map); odr++) {
if (val->val1 == stts751_map[odr].rate &&
val->val2 == stts751_map[odr].rate_dec) {
break;
}
}
if (odr == ARRAY_SIZE(stts751_map)) {
LOG_DBG("bad frequency");
return -EINVAL;
}
if (stts751_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set sampling rate");
return -EIO;
}
return 0;
}
static int stts751_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL) {
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return stts751_odr_set(dev, val);
default:
LOG_DBG("operation not supported.");
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api stts751_api_funcs = {
.attr_set = stts751_attr_set,
.sample_fetch = stts751_sample_fetch,
.channel_get = stts751_channel_get,
#if CONFIG_STTS751_TRIGGER
.trigger_set = stts751_trigger_set,
#endif
};
static int stts751_init_chip(const struct device *dev)
{
struct stts751_data *data = dev->data;
stts751_id_t chip_id;
if (stts751_device_id_get(data->ctx, &chip_id) < 0) {
LOG_DBG("Failed reading chip id");
return -EIO;
}
if (chip_id.manufacturer_id != STTS751_ID_MAN) {
LOG_DBG("Invalid chip id 0x%x", chip_id.manufacturer_id);
return -EIO;
}
if (stts751_set_odr_raw(dev, CONFIG_STTS751_SAMPLING_RATE) < 0) {
LOG_DBG("Failed to set sampling rate");
return -EIO;
}
if (stts751_resolution_set(data->ctx, STTS751_11bit) < 0) {
LOG_DBG("Failed to set resolution");
return -EIO;
}
return 0;
}
static int stts751_init(const struct device *dev)
{
const struct stts751_config * const config = dev->config;
struct stts751_data *data = dev->data;
data->dev = dev;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
config->bus_init(dev);
if (stts751_init_chip(dev) < 0) {
LOG_DBG("Failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_STTS751_TRIGGER
if (config->int_gpio.port) {
if (stts751_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
return 0;
}
#define STTS751_DEFINE(inst) \
static struct stts751_data stts751_data_##inst; \
\
static const struct stts751_config stts751_config_##inst = { \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), \
(.i2c = I2C_DT_SPEC_INST_GET(inst), \
.bus_init = stts751_i2c_init,), \
()) \
IF_ENABLED(CONFIG_STTS751_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, drdy_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, stts751_init, NULL, \
&stts751_data_##inst, &stts751_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &stts751_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(STTS751_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/stts751/stts751.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,445 |
```unknown
# ST Microelectronics STTS751 temperature sensor
menuconfig STTS751
bool "STTS751 temperature sensor"
default y
depends on DT_HAS_ST_STTS751_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C
select HAS_STMEMSC
select USE_STDC_STTS751
help
Enable driver for STTS751 I2C-based temperature sensor.
if STTS751
choice STTS751_TRIGGER_MODE
prompt "Trigger mode"
default STTS751_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config STTS751_TRIGGER_NONE
bool "No trigger"
config STTS751_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select STTS751_TRIGGER
config STTS751_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select STTS751_TRIGGER
endchoice # STTS751_TRIGGER_MODE
config STTS751_TRIGGER
bool
config STTS751_THREAD_PRIORITY
int "Thread priority"
depends on STTS751_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config STTS751_THREAD_STACK_SIZE
int "Thread stack size"
depends on STTS751_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
menu "Attributes"
config STTS751_TEMP_HI_THRESHOLD
depends on STTS751_TRIGGER
int "High temperature threshold alarm"
default 50
help
HIGH temperature threshold to trigger an alarm
config STTS751_TEMP_LO_THRESHOLD
depends on STTS751_TRIGGER
int "Low temperature threshold alarm"
default 10
help
LOW temperature threshold to trigger an alarm
config STTS751_SAMPLING_RATE
int "Output data rate"
range 0 9
default 4
help
Sensor output data rate expressed in conversions per second.
Data rates supported by the chip are:
0: 1 conv every 16 sec
1: 1 conv every 8 sec
2: 1 conv every 4 sec
3: 1 conv every 2 sec
4: 1 conv every sec
5: 2 convs every sec
6: 4 convs every sec
7: 8 convs every sec
8: 16 convs every sec
9: 32 convs every sec
endmenu
endif # STTS751
``` | /content/code_sandbox/drivers/sensor/st/stts751/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 553 |
```c
/* ST Microelectronics LIS2DS12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2ds12
#include <zephyr/logging/log.h>
#include "lis2ds12.h"
LOG_MODULE_DECLARE(LIS2DS12, CONFIG_SENSOR_LOG_LEVEL);
static void lis2ds12_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis2ds12_data *data =
CONTAINER_OF(cb, struct lis2ds12_data, gpio_cb);
const struct lis2ds12_config *cfg = data->dev->config;
int ret;
ARG_UNUSED(pins);
ret = gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
}
#if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void lis2ds12_handle_drdy_int(const struct device *dev)
{
struct lis2ds12_data *data = dev->data;
if (data->data_ready_handler != NULL) {
data->data_ready_handler(dev, data->data_ready_trigger);
}
}
static void lis2ds12_handle_int(const struct device *dev)
{
const struct lis2ds12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2ds12_all_sources_t sources;
int ret;
lis2ds12_all_sources_get(ctx, &sources);
if (sources.status_dup.drdy) {
lis2ds12_handle_drdy_int(dev);
}
ret = gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
}
}
#ifdef CONFIG_LIS2DS12_TRIGGER_OWN_THREAD
static void lis2ds12_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lis2ds12_data *data = p1;
while (1) {
k_sem_take(&data->trig_sem, K_FOREVER);
lis2ds12_handle_int(data->dev);
}
}
#endif
#ifdef CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD
static void lis2ds12_work_cb(struct k_work *work)
{
struct lis2ds12_data *data =
CONTAINER_OF(work, struct lis2ds12_data, work);
lis2ds12_handle_int(data->dev);
}
#endif
static int lis2ds12_init_interrupt(const struct device *dev)
{
const struct lis2ds12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2ds12_pin_int1_route_t route;
int err;
/* Enable pulsed mode */
err = lis2ds12_int_notification_set(ctx, LIS2DS12_INT_PULSED);
if (err < 0) {
return err;
}
/* route data-ready interrupt on int1 */
err = lis2ds12_pin_int1_route_get(ctx, &route);
if (err < 0) {
return err;
}
route.int1_drdy = 1;
err = lis2ds12_pin_int1_route_set(ctx, route);
if (err < 0) {
return err;
}
return 0;
}
int lis2ds12_trigger_init(const struct device *dev)
{
struct lis2ds12_data *data = dev->data;
const struct lis2ds12_config *cfg = dev->config;
int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(&cfg->gpio_int)) {
if (cfg->gpio_int.port) {
LOG_ERR("%s: device %s is not ready", dev->name,
cfg->gpio_int.port->name);
return -ENODEV;
}
LOG_DBG("%s: gpio_int not defined in DT", dev->name);
return 0;
}
data->dev = dev;
ret = gpio_pin_configure_dt(&cfg->gpio_int, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
LOG_INF("%s: int on %s.%02u", dev->name, cfg->gpio_int.port->name,
cfg->gpio_int.pin);
gpio_init_callback(&data->gpio_cb,
lis2ds12_gpio_callback,
BIT(cfg->gpio_int.pin));
ret = gpio_add_callback(cfg->gpio_int.port, &data->gpio_cb);
if (ret < 0) {
LOG_ERR("Could not set gpio callback");
return ret;
}
#if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_LIS2DS12_THREAD_STACK_SIZE,
lis2ds12_thread,
data, NULL, NULL,
K_PRIO_COOP(CONFIG_LIS2DS12_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD)
data->work.handler = lis2ds12_work_cb;
#endif
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
GPIO_INT_EDGE_TO_ACTIVE);
}
int lis2ds12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct lis2ds12_data *data = dev->data;
const struct lis2ds12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int16_t raw[3];
int ret;
__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
if (cfg->gpio_int.port == NULL) {
LOG_ERR("trigger_set is not supported");
return -ENOTSUP;
}
ret = gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
return ret;
}
data->data_ready_handler = handler;
if (handler == NULL) {
LOG_WRN("lis2ds12: no handler");
return 0;
}
/* re-trigger lost interrupt */
lis2ds12_acceleration_raw_get(ctx, raw);
data->data_ready_trigger = trig;
lis2ds12_init_interrupt(dev);
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lis2ds12/lis2ds12_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,489 |
```objective-c
/* ST Microelectronics LIS2DS12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LIS2DS12_LIS2DS12_H_
#define ZEPHYR_DRIVERS_SENSOR_LIS2DS12_LIS2DS12_H_
#include <zephyr/types.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <stmemsc.h>
#include "lis2ds12_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
/* Return ODR reg value based on data rate set */
#define LIS2DS12_ODR_TO_REG(_odr) \
((_odr <= 1) ? 1 : \
((31 - __builtin_clz(_odr / 25))) + 3)
struct lis2ds12_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t range;
uint8_t pm;
uint8_t odr;
#ifdef CONFIG_LIS2DS12_TRIGGER
struct gpio_dt_spec gpio_int;
#endif
};
struct lis2ds12_data {
int sample_x;
int sample_y;
int sample_z;
float gain;
#ifdef CONFIG_LIS2DS12_TRIGGER
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
const struct device *dev;
#if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DS12_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LIS2DS12_TRIGGER */
};
#ifdef CONFIG_LIS2DS12_TRIGGER
int lis2ds12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lis2ds12_trigger_init(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LIS2DS12_LIS2DS12_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lis2ds12/lis2ds12.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 559 |
```unknown
# ST Microelectronics LIS2DS12 3-axis accelerometer driver
menuconfig LIS2DS12
bool "LIS2DS12 I2C/SPI accelerometer sensor driver"
default y
depends on DT_HAS_ST_LIS2DS12_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DS12),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DS12),spi)
select HAS_STMEMSC
select USE_STDC_LIS2DS12
help
Enable driver for LIS2DS12 accelerometer sensor driver
if LIS2DS12
choice LIS2DS12_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config LIS2DS12_TRIGGER_NONE
bool "No trigger"
config LIS2DS12_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LIS2DS12_TRIGGER
config LIS2DS12_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LIS2DS12_TRIGGER
endchoice
config LIS2DS12_TRIGGER
bool
config LIS2DS12_THREAD_PRIORITY
int "Thread priority"
depends on LIS2DS12_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LIS2DS12_THREAD_STACK_SIZE
int "Thread stack size"
depends on LIS2DS12_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config LIS2DS12_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
endif # LIS2DS12
``` | /content/code_sandbox/drivers/sensor/st/lis2ds12/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 372 |
```objective-c
/*
*
*/
#ifndef __SENSOR_LSM303DLHC_MAGN_
#define __SENSOR_LSM303DLHC_MAGN_
#include <zephyr/drivers/i2c.h>
#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_XY 1100
#define LSM303DLHC_MAGN_LSB_GAUSS_Z 980
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 2)
#define LSM303DLHC_MAGN_LSB_GAUSS_XY 855
#define LSM303DLHC_MAGN_LSB_GAUSS_Z 760
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 3)
#define LSM303DLHC_MAGN_LSB_GAUSS_XY 670
#define LSM303DLHC_MAGN_LSB_GAUSS_Z 600
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 4)
#define LSM303DLHC_MAGN_LSB_GAUSS_XY 450
#define LSM303DLHC_MAGN_LSB_GAUSS_Z 400
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 5)
#define LSM303DLHC_MAGN_LSB_GAUSS_XY 400
#define LSM303DLHC_MAGN_LSB_GAUSS_Z 355
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 6)
#define LSM303DLHC_MAGN_LSB_GAUSS_XY 330
#define LSM303DLHC_MAGN_LSB_GAUSS_Z 295
#elif (CONFIG_LSM303DLHC_MAGN_RANGE == 7)
#define LSM303DLHC_MAGN_LSB_GAUSS_XY 230
#define LSM303DLHC_MAGN_LSB_GAUSS_Z 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 {
int16_t magn_x;
int16_t magn_y;
int16_t magn_z;
};
struct lsm303dlhc_magn_config {
struct i2c_dt_spec i2c;
};
#endif /* _SENSOR_LSM303DLHC_MAGN_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm303dlhc_magn/lsm303dlhc_magn.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 991 |
```c
/* ST Microelectronics LIS2DS12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2ds12
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/dt-bindings/sensor/lis2ds12.h>
#include "lis2ds12.h"
LOG_MODULE_REGISTER(LIS2DS12, CONFIG_SENSOR_LOG_LEVEL);
static int lis2ds12_set_odr(const struct device *dev, uint8_t odr)
{
const struct lis2ds12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2ds12_odr_t val;
/* check if power off */
if (odr == 0U) {
LOG_DBG("%s: set power-down", dev->name);
return lis2ds12_xl_data_rate_set(ctx, LIS2DS12_XL_ODR_OFF);
}
/*
* odr >= 1600Hz are available in HF mode only
* 12,5Hz <= odr <= 800Hz are available in LP and HR mode only
* odr == 1Hz is available in LP mode only
*/
if ((odr >= LIS2DS12_DT_ODR_1600Hz && cfg->pm != LIS2DS12_DT_HIGH_FREQUENCY) ||
(odr < LIS2DS12_DT_ODR_1600Hz && cfg->pm == LIS2DS12_DT_HIGH_FREQUENCY) ||
(odr == LIS2DS12_DT_ODR_1Hz_LP && cfg->pm != LIS2DS12_DT_LOW_POWER)) {
LOG_ERR("%s: bad odr and pm combination", dev->name);
return -ENOTSUP;
}
switch (odr) {
case 1:
val = LIS2DS12_XL_ODR_1Hz_LP;
break;
case 2:
val = (cfg->pm == 1) ? LIS2DS12_XL_ODR_12Hz5_LP :
LIS2DS12_XL_ODR_12Hz5_HR;
break;
case 3:
val = (cfg->pm == 1) ? LIS2DS12_XL_ODR_25Hz_LP :
LIS2DS12_XL_ODR_25Hz_HR;
break;
case 4:
val = (cfg->pm == 1) ? LIS2DS12_XL_ODR_50Hz_LP :
LIS2DS12_XL_ODR_50Hz_HR;
break;
case 5:
val = (cfg->pm == 1) ? LIS2DS12_XL_ODR_100Hz_LP :
LIS2DS12_XL_ODR_100Hz_HR;
break;
case 6:
val = (cfg->pm == 1) ? LIS2DS12_XL_ODR_200Hz_LP :
LIS2DS12_XL_ODR_200Hz_HR;
break;
case 7:
val = (cfg->pm == 1) ? LIS2DS12_XL_ODR_400Hz_LP :
LIS2DS12_XL_ODR_400Hz_HR;
break;
case 8:
val = (cfg->pm == 1) ? LIS2DS12_XL_ODR_800Hz_LP :
LIS2DS12_XL_ODR_800Hz_HR;
break;
case 9:
val = LIS2DS12_XL_ODR_1k6Hz_HF;
break;
case 10:
val = LIS2DS12_XL_ODR_3k2Hz_HF;
break;
case 11:
val = LIS2DS12_XL_ODR_6k4Hz_HF;
break;
default:
LOG_ERR("%s: bad odr %d", dev->name, odr);
return -ENOTSUP;
}
return lis2ds12_xl_data_rate_set(ctx, val);
}
static int lis2ds12_set_range(const struct device *dev, uint8_t range)
{
int err;
struct lis2ds12_data *data = dev->data;
const struct lis2ds12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
switch (range) {
default:
case 2U:
err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_2g);
data->gain = lis2ds12_from_fs2g_to_mg(1);
break;
case 4U:
err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_4g);
data->gain = lis2ds12_from_fs4g_to_mg(1);
break;
case 8U:
err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_8g);
data->gain = lis2ds12_from_fs8g_to_mg(1);
break;
case 16U:
err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_16g);
data->gain = lis2ds12_from_fs16g_to_mg(1);
break;
}
return err;
}
static int lis2ds12_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lis2ds12_set_range(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
LOG_DBG("%s: set odr to %d Hz", dev->name, val->val1);
return lis2ds12_set_odr(dev, LIS2DS12_ODR_TO_REG(val->val1));
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lis2ds12_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lis2ds12_accel_config(dev, chan, attr, val);
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int lis2ds12_sample_fetch_accel(const struct device *dev)
{
struct lis2ds12_data *data = dev->data;
const struct lis2ds12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int16_t buf[3];
/* fetch raw data sample */
if (lis2ds12_acceleration_raw_get(ctx, buf) < 0) {
LOG_ERR("Failed to fetch raw data sample");
return -EIO;
}
data->sample_x = sys_le16_to_cpu(buf[0]);
data->sample_y = sys_le16_to_cpu(buf[1]);
data->sample_z = sys_le16_to_cpu(buf[2]);
return 0;
}
static int lis2ds12_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lis2ds12_sample_fetch_accel(dev);
break;
#if defined(CONFIG_LIS2DS12_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
/* ToDo:
lis2ds12_sample_fetch_temp(dev)
*/
break;
#endif
case SENSOR_CHAN_ALL:
lis2ds12_sample_fetch_accel(dev);
#if defined(CONFIG_LIS2DS12_ENABLE_TEMP)
/* ToDo:
lis2ds12_sample_fetch_temp(dev)
*/
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lis2ds12_convert(struct sensor_value *val, int raw_val,
float gain)
{
int64_t dval;
/* Gain is in mg/LSB */
/* Convert to m/s^2 */
dval = ((int64_t)raw_val * gain * SENSOR_G) / 1000;
val->val1 = dval / 1000000LL;
val->val2 = dval % 1000000LL;
}
static inline int lis2ds12_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lis2ds12_data *data,
float gain)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lis2ds12_convert(val, data->sample_x, gain);
break;
case SENSOR_CHAN_ACCEL_Y:
lis2ds12_convert(val, data->sample_y, gain);
break;
case SENSOR_CHAN_ACCEL_Z:
lis2ds12_convert(val, data->sample_z, gain);
break;
case SENSOR_CHAN_ACCEL_XYZ:
lis2ds12_convert(val, data->sample_x, gain);
lis2ds12_convert(val + 1, data->sample_y, gain);
lis2ds12_convert(val + 2, data->sample_z, gain);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lis2ds12_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lis2ds12_data *data = dev->data;
return lis2ds12_get_channel(chan, val, data, data->gain);
}
static const struct sensor_driver_api lis2ds12_driver_api = {
.attr_set = lis2ds12_attr_set,
#if defined(CONFIG_LIS2DS12_TRIGGER)
.trigger_set = lis2ds12_trigger_set,
#endif
.sample_fetch = lis2ds12_sample_fetch,
.channel_get = lis2ds12_channel_get,
};
static int lis2ds12_init(const struct device *dev)
{
const struct lis2ds12_config * const cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t chip_id;
int ret;
/* check chip ID */
ret = lis2ds12_device_id_get(ctx, &chip_id);
if (ret < 0) {
LOG_ERR("%s: Not able to read dev id", dev->name);
return ret;
}
if (chip_id != LIS2DS12_ID) {
LOG_ERR("%s: Invalid chip ID 0x%02x", dev->name, chip_id);
return -EINVAL;
}
/* reset device */
ret = lis2ds12_reset_set(ctx, PROPERTY_ENABLE);
if (ret < 0) {
return ret;
}
k_busy_wait(100);
LOG_DBG("%s: chip id 0x%x", dev->name, chip_id);
#ifdef CONFIG_LIS2DS12_TRIGGER
ret = lis2ds12_trigger_init(dev);
if (ret < 0) {
LOG_ERR("%s: Failed to initialize triggers", dev->name);
return ret;
}
#endif
/* set sensor default pm and odr */
LOG_DBG("%s: pm: %d, odr: %d", dev->name, cfg->pm, cfg->odr);
ret = lis2ds12_set_odr(dev, (cfg->pm == 0) ? 0 : cfg->odr);
if (ret < 0) {
LOG_ERR("%s: odr init error (12.5 Hz)", dev->name);
return ret;
}
/* set sensor default scale */
LOG_DBG("%s: range is %d", dev->name, cfg->range);
ret = lis2ds12_set_range(dev, cfg->range);
if (ret < 0) {
LOG_ERR("%s: range init error %d", dev->name, cfg->range);
return ret;
}
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LIS2DS12 driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LIS2DS12_DEFINE_SPI() and
* LIS2DS12_DEFINE_I2C().
*/
#define LIS2DS12_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lis2ds12_init, \
NULL, \
&lis2ds12_data_##inst, \
&lis2ds12_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lis2ds12_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LIS2DS12_TRIGGER
#define LIS2DS12_CFG_IRQ(inst) \
.gpio_int = GPIO_DT_SPEC_INST_GET(inst, irq_gpios),
#else
#define LIS2DS12_CFG_IRQ(inst)
#endif /* CONFIG_LIS2DS12_TRIGGER */
#define LIS2DS12_CONFIG_COMMON(inst) \
.range = DT_INST_PROP(inst, range), \
.pm = DT_INST_PROP(inst, power_mode), \
.odr = DT_INST_PROP(inst, odr), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
(LIS2DS12_CFG_IRQ(inst)), ())
#define LIS2DS12_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LIS2DS12_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lis2ds12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
LIS2DS12_SPI_OPERATION, \
0), \
}, \
LIS2DS12_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LIS2DS12_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lis2ds12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LIS2DS12_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LIS2DS12_DEFINE(inst) \
static struct lis2ds12_data lis2ds12_data_##inst; \
static const struct lis2ds12_config lis2ds12_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LIS2DS12_CONFIG_SPI(inst)), \
(LIS2DS12_CONFIG_I2C(inst))); \
LIS2DS12_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LIS2DS12_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis2ds12/lis2ds12.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,334 |
```unknown
# LSM303DLHC Three Axis Magnetometer configuration options
menuconfig LSM303DLHC_MAGN
bool "LSM303DLHC Three Axis Magnetometer"
default y
depends on DT_HAS_ST_LSM303DLHC_MAGN_ENABLED
select 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
``` | /content/code_sandbox/drivers/sensor/st/lsm303dlhc_magn/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 293 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_lsm303dlhc_magn
#include <zephyr/drivers/i2c.h>
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(lsm303dlhc_magn, CONFIG_SENSOR_LOG_LEVEL);
#include "lsm303dlhc_magn.h"
static int lsm303dlhc_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct lsm303dlhc_magn_config *config = dev->config;
struct lsm303dlhc_magn_data *drv_data = dev->data;
uint8_t magn_buf[6];
uint8_t status;
/* Check data ready flag */
if (i2c_reg_read_byte_dt(&config->i2c, LSM303DLHC_SR_REG_M,
&status) < 0) {
LOG_ERR("Failed to read status register.");
return -EIO;
}
if (!(status & LSM303DLHC_MAGN_DRDY)) {
LOG_ERR("Sensor data not available.");
return -EIO;
}
if (i2c_burst_read_dt(&config->i2c, LSM303DLHC_REG_MAGN_X_LSB,
magn_buf, 6) < 0) {
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_xy(struct sensor_value *val,
int64_t raw_val)
{
val->val1 = raw_val / LSM303DLHC_MAGN_LSB_GAUSS_XY;
val->val2 = (1000000 * raw_val / LSM303DLHC_MAGN_LSB_GAUSS_XY) % 1000000;
}
static void lsm303dlhc_convert_z(struct sensor_value *val,
int64_t raw_val)
{
val->val1 = raw_val / LSM303DLHC_MAGN_LSB_GAUSS_Z;
val->val2 = (1000000 * raw_val / LSM303DLHC_MAGN_LSB_GAUSS_Z) % 1000000;
}
static int lsm303dlhc_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm303dlhc_magn_data *drv_data = dev->data;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
lsm303dlhc_convert_xy(val, drv_data->magn_x);
break;
case SENSOR_CHAN_MAGN_Y:
lsm303dlhc_convert_xy(val, drv_data->magn_y);
break;
case SENSOR_CHAN_MAGN_Z:
lsm303dlhc_convert_z(val, drv_data->magn_z);
break;
case SENSOR_CHAN_MAGN_XYZ:
lsm303dlhc_convert_xy(val, drv_data->magn_x);
lsm303dlhc_convert_xy(val + 1, drv_data->magn_y);
lsm303dlhc_convert_z(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(const struct device *dev)
{
const struct lsm303dlhc_magn_config *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
/* Set magnetometer output data rate */
if (i2c_reg_write_byte_dt(&config->i2c, LSM303DLHC_CRA_REG_M,
LSM303DLHC_MAGN_ODR_BITS) < 0) {
LOG_ERR("Failed to configure chip.");
return -EIO;
}
/* Set magnetometer full scale range */
if (i2c_reg_write_byte_dt(&config->i2c, LSM303DLHC_CRB_REG_M,
LSM303DLHC_MAGN_FS_BITS) < 0) {
LOG_ERR("Failed to set magnetometer full scale range.");
return -EIO;
}
/* Continuous update */
if (i2c_reg_write_byte_dt(&config->i2c, LSM303DLHC_MR_REG_M,
LSM303DLHC_MAGN_CONT_UPDATE) < 0) {
LOG_ERR("Failed to enable continuous data update.");
return -EIO;
}
return 0;
}
#define LSM303DLHC_MAGN_DEFINE(inst) \
static struct lsm303dlhc_magn_data lsm303dlhc_magn_data_##inst; \
\
static const struct lsm303dlhc_magn_config lsm303dlhc_magn_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lsm303dlhc_magn_init, NULL, \
&lsm303dlhc_magn_data_##inst, &lsm303dlhc_magn_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&lsm303dlhc_magn_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(LSM303DLHC_MAGN_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm303dlhc_magn/lsm303dlhc_magn.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,244 |
```c
/* lsm6ds0.c - Driver for LSM6DS0 accelerometer, gyroscope and
* temperature sensor
*/
/*
*
*/
#define DT_DRV_COMPAT st_lsm6ds0
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lsm6ds0.h"
LOG_MODULE_REGISTER(LSM6DS0, CONFIG_SENSOR_LOG_LEVEL);
static inline int lsm6ds0_reboot(const struct device *dev)
{
const struct lsm6ds0_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG8,
LSM6DS0_MASK_CTRL_REG8_BOOT,
1 << LSM6DS0_SHIFT_CTRL_REG8_BOOT) < 0) {
return -EIO;
}
k_busy_wait(USEC_PER_MSEC * 50U);
return 0;
}
static inline int lsm6ds0_accel_axis_ctrl(const struct device *dev, int x_en,
int y_en, int z_en)
{
const struct lsm6ds0_config *config = dev->config;
uint8_t state = (x_en << LSM6DS0_SHIFT_CTRL_REG5_XL_XEN_XL) |
(y_en << LSM6DS0_SHIFT_CTRL_REG5_XL_YEN_XL) |
(z_en << LSM6DS0_SHIFT_CTRL_REG5_XL_ZEN_XL);
return i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG5_XL,
LSM6DS0_MASK_CTRL_REG5_XL_XEN_XL |
LSM6DS0_MASK_CTRL_REG5_XL_YEN_XL |
LSM6DS0_MASK_CTRL_REG5_XL_ZEN_XL,
state);
}
static int lsm6ds0_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6ds0_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG6_XL,
LSM6DS0_MASK_CTRL_REG6_XL_FS_XL,
fs << LSM6DS0_SHIFT_CTRL_REG6_XL_FS_XL) < 0) {
return -EIO;
}
return 0;
}
static int lsm6ds0_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6ds0_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG6_XL,
LSM6DS0_MASK_CTRL_REG6_XL_ODR_XL,
odr << LSM6DS0_SHIFT_CTRL_REG6_XL_ODR_XL) < 0) {
return -EIO;
}
return 0;
}
static inline int lsm6ds0_gyro_axis_ctrl(const struct device *dev, int x_en,
int y_en,
int z_en)
{
const struct lsm6ds0_config *config = dev->config;
uint8_t state = (x_en << LSM6DS0_SHIFT_CTRL_REG4_XEN_G) |
(y_en << LSM6DS0_SHIFT_CTRL_REG4_YEN_G) |
(z_en << LSM6DS0_SHIFT_CTRL_REG4_ZEN_G);
return i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG4,
LSM6DS0_MASK_CTRL_REG4_XEN_G |
LSM6DS0_MASK_CTRL_REG4_YEN_G |
LSM6DS0_MASK_CTRL_REG4_ZEN_G,
state);
}
static int lsm6ds0_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6ds0_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG1_G,
LSM6DS0_MASK_CTRL_REG1_G_FS_G,
fs << LSM6DS0_SHIFT_CTRL_REG1_G_FS_G) < 0) {
return -EIO;
}
return 0;
}
static int lsm6ds0_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6ds0_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG1_G,
LSM6DS0_MASK_CTRL_REG1_G_ODR_G,
odr << LSM6DS0_SHIFT_CTRL_REG1_G_ODR_G) < 0) {
return -EIO;
}
return 0;
}
static int lsm6ds0_sample_fetch_accel(const struct device *dev)
{
struct lsm6ds0_data *data = dev->data;
const struct lsm6ds0_config *config = dev->config;
uint8_t buf[6];
if (i2c_burst_read_dt(&config->i2c, LSM6DS0_REG_OUT_X_L_XL, buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
data->accel_sample_x = (int16_t)((uint16_t)(buf[0]) |
((uint16_t)(buf[1]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
data->accel_sample_y = (int16_t)((uint16_t)(buf[2]) |
((uint16_t)(buf[3]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
data->accel_sample_z = (int16_t)((uint16_t)(buf[4]) |
((uint16_t)(buf[5]) << 8));
#endif
return 0;
}
static int lsm6ds0_sample_fetch_gyro(const struct device *dev)
{
struct lsm6ds0_data *data = dev->data;
const struct lsm6ds0_config *config = dev->config;
uint8_t buf[6];
if (i2c_burst_read_dt(&config->i2c, LSM6DS0_REG_OUT_X_L_G, buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
data->gyro_sample_x = (int16_t)((uint16_t)(buf[0]) |
((uint16_t)(buf[1]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
data->gyro_sample_y = (int16_t)((uint16_t)(buf[2]) |
((uint16_t)(buf[3]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
data->gyro_sample_z = (int16_t)((uint16_t)(buf[4]) |
((uint16_t)(buf[5]) << 8));
#endif
return 0;
}
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
static int lsm6ds0_sample_fetch_temp(const struct device *dev)
{
struct lsm6ds0_data *data = dev->data;
const struct lsm6ds0_config *config = dev->config;
uint8_t buf[2];
if (i2c_burst_read_dt(&config->i2c, LSM6DS0_REG_OUT_TEMP_L, buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
data->temp_sample = (int16_t)((uint16_t)(buf[0]) |
((uint16_t)(buf[1]) << 8));
return 0;
}
#endif
static int lsm6ds0_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_ACCEL_XYZ ||
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
chan == SENSOR_CHAN_DIE_TEMP ||
#endif
chan == SENSOR_CHAN_GYRO_XYZ);
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lsm6ds0_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm6ds0_sample_fetch_gyro(dev);
break;
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6ds0_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lsm6ds0_sample_fetch_accel(dev);
lsm6ds0_sample_fetch_gyro(dev);
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
lsm6ds0_sample_fetch_temp(dev);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6ds0_accel_convert(struct sensor_value *val, int raw_val,
float scale)
{
double dval;
dval = (double)(raw_val) * (double)scale / 32767.0;
val->val1 = (int32_t)dval;
val->val2 = ((int32_t)(dval * 1000000)) % 1000000;
}
static inline int lsm6ds0_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6ds0_data *data,
float scale)
{
switch (chan) {
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
case SENSOR_CHAN_ACCEL_X:
lsm6ds0_accel_convert(val, data->accel_sample_x, scale);
break;
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
case SENSOR_CHAN_ACCEL_Y:
lsm6ds0_accel_convert(val, data->accel_sample_y, scale);
break;
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
case SENSOR_CHAN_ACCEL_Z:
lsm6ds0_accel_convert(val, data->accel_sample_z, scale);
break;
#endif
case SENSOR_CHAN_ACCEL_XYZ:
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
lsm6ds0_accel_convert(val, data->accel_sample_x, scale);
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
lsm6ds0_accel_convert(val + 1, data->accel_sample_y, scale);
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
lsm6ds0_accel_convert(val + 2, data->accel_sample_z, scale);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6ds0_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6ds0_data *data)
{
return lsm6ds0_accel_get_channel(chan, val, data,
LSM6DS0_DEFAULT_ACCEL_FULLSCALE_FACTOR);
}
static inline void lsm6ds0_gyro_convert(struct sensor_value *val, int raw_val,
float numerator)
{
double dval;
dval = (double)(raw_val) * (double)numerator / 1000.0 * SENSOR_DEG2RAD_DOUBLE;
val->val1 = (int32_t)dval;
val->val2 = ((int32_t)(dval * 1000000)) % 1000000;
}
static inline int lsm6ds0_gyro_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6ds0_data *data,
float numerator)
{
switch (chan) {
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
case SENSOR_CHAN_GYRO_X:
lsm6ds0_gyro_convert(val, data->gyro_sample_x, numerator);
break;
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
case SENSOR_CHAN_GYRO_Y:
lsm6ds0_gyro_convert(val, data->gyro_sample_y, numerator);
break;
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
case SENSOR_CHAN_GYRO_Z:
lsm6ds0_gyro_convert(val, data->gyro_sample_z, numerator);
break;
#endif
case SENSOR_CHAN_GYRO_XYZ:
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
lsm6ds0_gyro_convert(val, data->gyro_sample_x, numerator);
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
lsm6ds0_gyro_convert(val + 1, data->gyro_sample_y, numerator);
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
lsm6ds0_gyro_convert(val + 2, data->gyro_sample_z, numerator);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6ds0_gyro_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6ds0_data *data)
{
return lsm6ds0_gyro_get_channel(chan, val, data,
LSM6DS0_DEFAULT_GYRO_FULLSCALE_FACTOR);
}
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
static void lsm6ds0_gyro_channel_get_temp(struct sensor_value *val,
struct lsm6ds0_data *data)
{
/* val = temp_sample / 16 + 25 */
val->val1 = data->temp_sample / 16 + 25;
val->val2 = (data->temp_sample % 16) * (1000000 / 16);
}
#endif
static int lsm6ds0_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm6ds0_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lsm6ds0_accel_channel_get(chan, val, data);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
lsm6ds0_gyro_channel_get(chan, val, data);
break;
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6ds0_gyro_channel_get_temp(val, data);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lsm6ds0_api_funcs = {
.sample_fetch = lsm6ds0_sample_fetch,
.channel_get = lsm6ds0_channel_get,
};
static int lsm6ds0_init_chip(const struct device *dev)
{
const struct lsm6ds0_config *config = dev->config;
uint8_t chip_id;
if (lsm6ds0_reboot(dev) < 0) {
LOG_DBG("failed to reboot device");
return -EIO;
}
if (i2c_reg_read_byte_dt(&config->i2c, LSM6DS0_REG_WHO_AM_I, &chip_id) < 0) {
LOG_DBG("failed reading chip id");
return -EIO;
}
if (chip_id != LSM6DS0_VAL_WHO_AM_I) {
LOG_DBG("invalid chip id 0x%x", chip_id);
return -EIO;
}
LOG_DBG("chip id 0x%x", chip_id);
if (lsm6ds0_accel_axis_ctrl(dev, LSM6DS0_ACCEL_ENABLE_X_AXIS,
LSM6DS0_ACCEL_ENABLE_Y_AXIS,
LSM6DS0_ACCEL_ENABLE_Z_AXIS) < 0) {
LOG_DBG("failed to set accelerometer axis");
return -EIO;
}
if (lsm6ds0_accel_set_fs_raw(dev, LSM6DS0_DEFAULT_ACCEL_FULLSCALE)
< 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
if (lsm6ds0_accel_set_odr_raw(dev, LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE)
< 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
if (lsm6ds0_gyro_axis_ctrl(dev, LSM6DS0_GYRO_ENABLE_X_AXIS,
LSM6DS0_GYRO_ENABLE_Y_AXIS,
LSM6DS0_GYRO_ENABLE_Z_AXIS) < 0) {
LOG_DBG("failed to set gyroscope axis");
return -EIO;
}
if (lsm6ds0_gyro_set_fs_raw(dev, LSM6DS0_DEFAULT_GYRO_FULLSCALE)
< 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
if (lsm6ds0_gyro_set_odr_raw(dev, LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE)
< 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG8,
LSM6DS0_MASK_CTRL_REG8_BDU |
LSM6DS0_MASK_CTRL_REG8_BLE |
LSM6DS0_MASK_CTRL_REG8_IF_ADD_INC,
(1 << LSM6DS0_SHIFT_CTRL_REG8_BDU) |
(0 << LSM6DS0_SHIFT_CTRL_REG8_BLE) |
(1 << LSM6DS0_SHIFT_CTRL_REG8_IF_ADD_INC))
< 0) {
LOG_DBG("failed to set BDU, BLE and burst");
return -EIO;
}
return 0;
}
static int lsm6ds0_init(const struct device *dev)
{
const struct lsm6ds0_config * const config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
if (lsm6ds0_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
return 0;
}
#define LSM6DS0_DEFINE(inst) \
static struct lsm6ds0_data lsm6ds0_data_##inst; \
\
static const struct lsm6ds0_config lsm6ds0_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lsm6ds0_init, NULL, \
&lsm6ds0_data_##inst, &lsm6ds0_config_##inst, POST_KERNEL,\
CONFIG_SENSOR_INIT_PRIORITY, &lsm6ds0_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(LSM6DS0_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm6ds0/lsm6ds0.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,180 |
```objective-c
/* sensor_lsm6ds0.h - header file for LSM6DS0 accelerometer, gyroscope and
* temperature sensor driver
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM6DS0_LSM6DS0_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM6DS0_LSM6DS0_H_
#include <zephyr/types.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#define LSM6DS0_REG_ACT_THS 0x04
#define LSM6DS0_MASK_ACT_THS_SLEEP_ON_INACT_EN BIT(7)
#define LSM6DS0_SHIFT_ACT_THS_SLEEP_ON_INACT_EN 7
#define LSM6DS0_MASK_ACT_THS_ACT_THS (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DS0_SHIFT_ACT_THS_ACT_THS 0
#define LSM6DS0_REG_ACT_DUR 0x05
#define LSM6DS0_REG_INT_GEN_CFG_XL 0x06
#define LSM6DS0_MASK_INT_GEN_CFG_XL_AOI_XL BIT(7)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_AOI_XL 7
#define LSM6DSO_MASK_INT_GEN_CFG_XL_6D BIT(6)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_6D 6
#define LSM6DS0_MASK_INT_GEN_CFG_XL_ZHIE_XL BIT(5)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_ZHIE_XL 5
#define LSM6DS0_MASK_INT_GEN_CFG_XL_ZLIE_XL BIT(4)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_ZLIE_XL 4
#define LSM6DS0_MASK_INT_GEN_CFG_XL_YHIE_XL BIT(3)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_YHIE_XL 3
#define LSM6DS0_MASK_INT_GEN_CFG_XL_YLIE_XL BIT(2)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_YLIE_XL 2
#define LSM6DS0_MASK_INT_GEN_CFG_XL_XHIE_XL BIT(1)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_XHIE_XL 1
#define LSM6DS0_MASK_INT_GEN_CFG_XL_XLIE_XL BIT(0)
#define LSM6DS0_SHIFT_INT_GEN_CFG_XL_XLIE_XL 0
#define LSM6DS0_REG_INT_GEN_THS_X_XL 0x07
#define LSM6DS0_REG_INT_GEN_THS_Y_XL 0x08
#define LSM6DS0_REG_INT_GEN_THS_Z_XL 0x09
#define LSM6DS0_REG_INT_GEN_DUR_XL 0x0A
#define LSM6DS0_REG_REFERENCE_G 0x0B
#define LSM6DS0_REG_INT_CTRL 0x0C
#define LSM6DS0_MASK_INT_CTRL_INT_IG_G BIT(7)
#define LSM6DS0_SHIFT_INT_CTRL_INT_IG_G 7
#define LSM6DS0_MASK_INT_CTRL_INT_IG_XL BIT(6)
#define LSM6DS0_SHIFT_INT_CTRL_INT_IG_XL 6
#define LSM6DS0_MASK_INT_CTRL_INT_FSS5 BIT(5)
#define LSM6DS0_SHIFT_INT_CTRL_INT_FSS5 5
#define LSM6DS0_MASK_INT_CTRL_INT_OVR BIT(4)
#define LSM6DS0_SHIFT_INT_CTRL_INT_OVR 4
#define LSM6DS0_MASK_INT_CTRL_INT_FTH BIT(3)
#define LSM6DS0_SHIFT_INT_CTRL_INT_FTH 3
#define LSM6DS0_MASK_INT_CTRL_INT_BOOT BIT(2)
#define LSM6DS0_SHIFT_INT_CTRL_INT_BOOT 2
#define LSM6DS0_MASK_INT_CTRL_INT_DRDY_G BIT(1)
#define LSM6DS0_SHIFT_INT_CTRL_INT_DRDY_G 1
#define LSM6DS0_MASK_INT_CTRL_INT_DRDY_XL BIT(0)
#define LSM6DS0_SHIFT_INT_CTRL_INT_DRDY_XL 0
#define LSM6DS0_REG_WHO_AM_I 0x0F
#define LSM6DS0_VAL_WHO_AM_I 0x68
#define LSM6DS0_REG_CTRL_REG1_G 0x10
#define LSM6DS0_MASK_CTRL_REG1_G_ODR_G (BIT(7) | BIT(6) | BIT(5))
#define LSM6DS0_SHIFT_CTRL_REG1_G_ODR_G 5
#define LSM6DS0_MASK_CTRL_REG1_G_FS_G (BIT(4) | BIT(3))
#define LSM6DS0_SHIFT_CTRL_REG1_G_FS_G 3
#define LSM6DS0_MASK_CTRL_REG1_G_BW_G (BIT(1) | BIT(0))
#define LSM6DS0_SHIFT_CTRL_REG1_G_BW_G 0
#define LSM6DS0_REG_CTRL_REG2_G 0x11
#define LSM6DS0_MASK_CTRL_REG2_G_INT_SEL (BIT(3) | BIT(2))
#define LSM6DS0_SHIFT_CTRL_REG2_G_INT_SEL 2
#define LSM6DS0_MASK_CTRL_REG2_G_OUT_SEL (BIT(1) | BIT(0))
#define LSM6DS0_SHIFT_CTRL_REG2_G_OUT_SEL 0
#define LSM6DS0_REG_CTRL_REG3_G 0x12
#define LSM6DS0_MASK_CTRL_REG3_G_LP_MODE BIT(7)
#define LSM6DS0_SHIFT_CTRL_REG3_G_LP_MODE 7
#define LSM6DS0_MASK_CTRL_REG3_G_HP_EN BIT(6)
#define LSM6DS0_SHIFT_CTRL_REG3_G_HP_EN 6
#define LSM6DS0_MASK_CTRL_REG3_G_HPCF_G (BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DS0_SHIFT_CTRL_REG3_G_HPCF_G 0
#define LSM6DS0_REG_ORIENT_CFG_G 0x13
#define LSM6DS0_MASK_ORIENT_CFG_G_SIGNX_G BIT(5)
#define LSM6DS0_SHIFT_ORIENT_CFG_G_SIGNX_G 5
#define LSM6DS0_MASK_ORIENT_CFG_G_SIGNY_G BIT(4)
#define LSM6DS0_SHIFT_ORIENT_CFG_G_SIGNY_G 4
#define LSM6DS0_MASK_ORIENT_CFG_G_SIGNZ_G BIT(3)
#define LSM6DS0_SHIFT_ORIENT_CFG_G_SIGNZ_G 3
#define LSM6DS0_MASK_ORIENT_CFG_ORIENT (BIT(2) | BIT(1) | BIT(0))
#define LSM6DS0_SHIFT_ORIENT_CFG_ORIENT 0
#define LSM6DS0_REG_INT_GEN_SRC_G 0x14
#define LSM6DS0_MASK_INT_GEN_SRC_G_IA_G BIT(6)
#define LSM6DS0_SHIFT_INT_GEN_SRC_G_IA_G 6
#define LSM6DS0_MASK_INT_GEN_SRC_G_ZH_G BIT(5)
#define LSM6DS0_SHIFT_INT_GEN_SRC_G_ZH_G 5
#define LSM6DS0_MASK_INT_GEN_SRC_G_ZL_G BIT(4)
#define LSM6DS0_SHIFT_INT_GEN_SRC_G_ZL_G 4
#define LSM6DS0_MASK_INT_GEN_SRC_G_YH_G BIT(3)
#define LSM6DS0_SHIFT_INT_GEN_SRC_G_YH_G 3
#define LSM6DS0_MASK_INT_GEN_SRC_G_YL_G BIT(2)
#define LSM6DS0_SHIFT_INT_GEN_SRC_G_YL_G 2
#define LSM6DS0_MASK_INT_GEN_SRC_G_XH_G BIT(1)
#define LSM6DS0_SHIFT_INT_GEN_SRC_G_XH_G 1
#define LSM6DS0_MASK_INT_GEN_SRC_G_XL_G BIT(0)
#define LSM6DS0_SHIFT_INT_GEN_SRC_G_XL_G 0
#define LSM6DS0_REG_OUT_TEMP_L 0x15
#define LSM6DS0_REG_OUT_TEMP_H 0x16
#define LSM6DS0_REG_STATUS_REG_G 0x17
#define LSM6DS0_MASK_STATUS_REG_G_IG_XL BIT(6)
#define LSM6DS0_SHIFT_STATUS_REG_G_IG_XL 6
#define LSM6DS0_MASK_STATUS_REG_G_IG_G BIT(5)
#define LSM6DS0_SHIFT_STATUS_REG_G_IG_G 5
#define LSM6DS0_MASK_STATUS_REG_G_INACT BIT(4)
#define LSM6DS0_SHIFT_STATUS_REG_G_INACT 4
#define LSM6DS0_MASK_STATUS_REG_G_BOOT_STATUS BIT(3)
#define LSM6DS0_SHIFT_STATUS_REG_G_BOOT_STATUS 3
#define LSM6DS0_MASK_STATUS_REG_G_TDA BIT(2)
#define LSM6DS0_SHIFT_STATUS_REG_G_TDA 2
#define LSM6DS0_MASK_STATUS_REG_G_GDA BIT(1)
#define LSM6DS0_SHIFT_STATUS_REG_G_GDA 1
#define LSM6DS0_MASK_STATUS_REG_G_XLDA BIT(0)
#define LSM6DS0_SHIFT_STATUS_REG_G_XLDA 0
#define LSM6DS0_REG_OUT_X_L_G 0x18
#define LSM6DS0_REG_OUT_X_H_G 0x19
#define LSM6DS0_REG_OUT_Y_L_G 0x1A
#define LSM6DS0_REG_OUT_Y_H_G 0x1B
#define LSM6DS0_REG_OUT_Z_L_G 0x1C
#define LSM6DS0_REG_OUT_Z_H_G 0x1D
#define LSM6DS0_REG_CTRL_REG4 0x1E
#define LSM6DS0_MASK_CTRL_REG4_ZEN_G BIT(5)
#define LSM6DS0_SHIFT_CTRL_REG4_ZEN_G 5
#define LSM6DS0_MASK_CTRL_REG4_YEN_G BIT(4)
#define LSM6DS0_SHIFT_CTRL_REG4_YEN_G 4
#define LSM6DS0_MASK_CTRL_REG4_XEN_G BIT(3)
#define LSM6DS0_SHIFT_CTRL_REG4_XEN_G 3
#define LSM6DS0_MASK_CTRL_REG4_LIR_XL1 BIT(1)
#define LSM6DS0_SHIFT_CTRL_REG4_LIR_XL1 1
#define LSM6DS0_MASK_CTRL_REG4_4D_XL1 BIT(0)
#define LSM6DS0_SHIFT_CTRL_REG4_4D_XL1 0
#define LSM6DS0_REG_CTRL_REG5_XL 0x1F
#define LSM6DS0_MASK_CTRL_REG5_XL_DEC (BIT(7) | BIT(6))
#define LSM6DS0_SHIFT_CTRL_REG5_XL_DEC 6
#define LSM6DS0_MASK_CTRL_REG5_XL_ZEN_XL BIT(5)
#define LSM6DS0_SHIFT_CTRL_REG5_XL_ZEN_XL 5
#define LSM6DS0_MASK_CTRL_REG5_XL_YEN_XL BIT(4)
#define LSM6DS0_SHIFT_CTRL_REG5_XL_YEN_XL 4
#define LSM6DS0_MASK_CTRL_REG5_XL_XEN_XL BIT(3)
#define LSM6DS0_SHIFT_CTRL_REG5_XL_XEN_XL 3
#define LSM6DS0_REG_CTRL_REG6_XL 0x20
#define LSM6DS0_MASK_CTRL_REG6_XL_ODR_XL (BIT(7) | BIT(6) | BIT(5))
#define LSM6DS0_SHIFT_CTRL_REG6_XL_ODR_XL 5
#define LSM6DS0_MASK_CTRL_REG6_XL_FS_XL (BIT(4) | BIT(3))
#define LSM6DS0_SHIFT_CTRL_REG6_XL_FS_XL 3
#define LSM6DS0_MASK_CTRL_REG6_XL_BW_SCAL_ODR BIT(2)
#define LSM6DS0_SHIFT_CTRL_REG6_XL_BW_SCAL_ODR 2
#define LSM6DS0_MASK_CTRL_REG6_XL_BW_XL (BIT(1) | BIT(0))
#define LSM6DS0_SHIFT_CTRL_REG6_XL_BW_XL 0
#define LSM6DS0_REG_CTRL_REG7_XL 0x21
#define LSM6DS0_MASK_CTRL_REG7_XL_HR BIT(7)
#define LSM6DS0_SHIFT_CTRL_REG7_XL_HR 7
#define LSM6DS0_MASK_CTRL_REG7_XL_DCF (BIT(6) | BIT(5))
#define LSM6DS0_SHIFT_CTRL_REG7_XL_DCF 5
#define LSM6DS0_MASK_CTRL_REG7_XL_FDS BIT(2)
#define LSM6DS0_SHIFT_CTRL_REG7_XL_FDS 2
#define LSM6DS0_MASK_CTRL_REG7_XL_HPIS1 BIT(0)
#define LSM6DS0_SHIFT_CTRL_REG7_XL_HPIS 0
#define LSM6DS0_REG_CTRL_REG8 0x22
#define LSM6DS0_MASK_CTRL_REG8_BOOT BIT(7)
#define LSM6DS0_SHIFT_CTRL_REG8_BOOT 7
#define LSM6DS0_MASK_CTRL_REG8_BDU BIT(6)
#define LSM6DS0_SHIFT_CTRL_REG8_BDU 6
#define LSM6DS0_MASK_CTRL_REG8_H_LACTIVE BIT(5)
#define LSM6DS0_SHIFT_CTRL_REG8_H_LACTIVE 5
#define LSM6DS0_MASK_CTRL_REG8_PP_OD BIT(4)
#define LSM6DS0_SHIFT_CTRL_REG8_PP_OD 4
#define LSM6DS0_MASK_CTRL_REG8_SIM BIT(3)
#define LSM6DS0_SHIFT_CTRL_REG8_SIM 3
#define LSM6DS0_MASK_CTRL_REG8_IF_ADD_INC BIT(2)
#define LSM6DS0_SHIFT_CTRL_REG8_IF_ADD_INC 2
#define LSM6DS0_MASK_CTRL_REG8_BLE BIT(1)
#define LSM6DS0_SHIFT_CTRL_REG8_BLE 1
#define LSM6DS0_MASK_CTRL_REG8_SW_RESET BIT(0)
#define LSM6DS0_SHIFT_CTRL_REG8_SW_RESET 0
#define LSM6DS0_REG_CTRL_REG9 0x23
#define LSM6DS0_MASK_CTRL_REG9_SLEEP_G BIT(6)
#define LSM6DS0_SHIFT_CTRL_REG9_SLEEP_G 6
#define LSM6DS0_MASK_CTRL_REG9_FIFO_TEMP_EN BIT(4)
#define LSM6DS0_SHIFT_CTRL_REG9_FIFO_TEMP_EN 4
#define LSM6DS0_MASK_CTRL_REG9_DRDY_MASK_BIT BIT(3)
#define LSM6DS0_SHIFT_CTRL_REG9_DRDY_MASK_BIT 3
#define LSM6DS0_MASK_CTRL_REG9_DRDY_I2C_DIS BIT(2)
#define LSM6DS0_SHIFT_CTRL_REG9_DRDY_I2C_DIS 2
#define LSM6DS0_MASK_CTRL_REG9_FIFO_EN BIT(1)
#define LSM6DS0_SHIFT_CTRL_REG9_FIFO_EN 1
#define LSM6DS0_MASK_CTRL_REG9_STOP_ON_FTH BIT(0)
#define LSM6DS0_SHIFT_CTRL_REG9_STOP_ON_FTH 0
#define LSM6DS0_REG_CTRL_REG10 0x24
#define LSM6DS0_MASK_CTRL_REG10_ST_G BIT(2)
#define LSM6DS0_SHIFT_CTRL_REG10_ST_G 2
#define LSM6DS0_MASK_CTRL_REG10_ST_XL BIT(0)
#define LSM6DS0_SHIFT_CTRL_REG10_ST_XL 0
#define LSM6DS0_REG_INT_GEN_SRC_XL 0x26
#define LSM6DS0_MASK_INT_GEN_SRC_XL_IA_XL BIT(6)
#define LSM6DS0_SHIFT_INT_GEN_SRC_XL_IA_XL 6
#define LSM6DS0_MASK_INT_GEN_SRC_XL_ZH_XL BIT(5)
#define LSM6DS0_SHIFT_INT_GEN_SRC_XL_ZH_XL 5
#define LSM6DS0_MASK_INT_GEN_SRC_XL_ZL_XL BIT(4)
#define LSM6DS0_SHIFT_INT_GEN_SRC_XL_ZL_XL 4
#define LSM6DS0_MASK_INT_GEN_SRC_XL_YH_XL BIT(3)
#define LSM6DS0_SHIFT_INT_GEN_SRC_XL_YH_XL 3
#define LSM6DS0_MASK_INT_GEN_SRC_XL_YL_XL BIT(2)
#define LSM6DS0_SHIFT_INT_GEN_SRC_XL_YL_XL 2
#define LSM6DS0_MASK_INT_GEN_SRC_XL_XH_XL BIT(1)
#define LSM6DS0_SHIFT_INT_GEN_SRC_XL_XH_XL 1
#define LSM6DS0_MASK_INT_GEN_SRC_XL_XL_XL BIT(0)
#define LSM6DS0_SHIFT_INT_GEN_SRC_XL_XL_XL 0
#define LSM6DS0_REG_STATUS_REG_XL 0x27
#define LSM6DS0_MASK_STATUS_REG_XL_IG_XL BIT(6)
#define LSM6DS0_SHIFT_STATUS_REG_XL_IG_XL 6
#define LSM6DS0_MASK_STATUS_REG_XL_IG_G BIT(5)
#define LSM6DS0_SHIFT_STATUS_REG_XL_IG_G 5
#define LSM6DS0_MASK_STATUS_REG_XL_INACT BIT(4)
#define LSM6DS0_SHIFT_STATUS_REG_XL_INACT 4
#define LSM6DS0_MASK_STATUS_REG_XL_BOOT_STATUS BIT(3)
#define LSM6DS0_SHIFT_STATUS_REG_XL_BOOT_STATUS 3
#define LSM6DS0_MASK_STATUS_REG_XL_TDA BIT(2)
#define LSM6DS0_SHIFT_STATUS_REG_XL_TDA 2
#define LSM6DS0_MASK_STATUS_REG_XL_GDA BIT(1)
#define LSM6DS0_SHIFT_STATUS_REG_XL_GDA 1
#define LSM6DS0_MASK_STATUS_REG_XL_XLDA BIT(0)
#define LSM6DS0_SHIFT_STATUS_REG_XL_XLDA 0
#define LSM6DS0_REG_OUT_X_L_XL 0x28
#define LSM6DS0_REG_OUT_X_H_XL 0x29
#define LSM6DS0_REG_OUT_Y_L_XL 0x2A
#define LSM6DS0_REG_OUT_Y_H_XL 0x2B
#define LSM6DS0_REG_OUT_Z_L_XL 0x2C
#define LSM6DS0_REG_OUT_Z_H_XL 0x2D
#define LSM6DS0_REG_FIFO_CTRL 0x2E
#define LSM6DS0_MASK_FIFO_CTRL_FMODE (BIT(7) | BIT(6) | BIT(5))
#define LSM6DS0_SHIFT_FIFO_CTRL_FMODE 5
#define LSM6DS0_MASK_FIFO_CTRL_FTH (BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM6DS0_SHIFT_FIFO_CTRL_FTH 0
#define LSM6DS0_REG_FIFO_SRC 0x2F
#define LSM6DS0_MASK_FIFO_SRC_FTH BIT(7)
#define LSM6DS0_SHIFT_FIFO_SRC_FTH 7
#define LSM6DS0_MASK_FIFO_SRC_OVRN BIT(6)
#define LSM6DS0_SHIFT_FIFO_SRC_OVRN 6
#define LSM6DS0_MASK_FIFO_SRC_FSS (BIT(5) | BIT(4) | BIT(3) | \
BIT(2) | BIT(1) | BIT(0))
#define LSM6DS0_SHIFT_FIFO_SRC_FSS 0
#define LSM6DS0_REG_INT_GEN_CFG_G 0x30
#define LSM6DS0_MASK_INT_GEN_CFG_G_AOI_G BIT(7)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_AOI_G 7
#define LSM6DS0_MASK_INT_GEN_CFG_G_LIR_G BIT(6)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_LIR_G 6
#define LSM6DS0_MASK_INT_GEN_CFG_G_ZHIE_G BIT(5)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_ZHIE_G 5
#define LSM6DS0_MASK_INT_GEN_CFG_G_ZLIE_G BIT(4)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_ZLIE_G 4
#define LSM6DS0_MASK_INT_GEN_CFG_G_YHIE_G BIT(3)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_YHIE_G 3
#define LSM6DS0_MASK_INT_GEN_CFG_G_YLIE_G BIT(2)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_YLIE_G 2
#define LSM6DS0_MASK_INT_GEN_CFG_G_XHIE_G BIT(1)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_XHIE_G 1
#define LSM6DS0_MASK_INT_GEN_CFG_G_XLIE_G BIT(0)
#define LSM6DS0_SHIFT_INT_GEN_CFG_G_XLIE_G 0
#define LSM6DS0_REG_INT_GEN_THS_XH_G 0x31
#define LSM6DS0_MASK_INT_GEN_THS_XH_G_DCRM_G BIT(7)
#define LSM6DS0_SHIFT_INT_GEN_THS_XH_G_DCRM_G 7
#define LSM6DS0_REG_INT_GEN_THS_XL_G 0x32
#define LSM6DS0_REG_INT_GEN_THS_YH_G 0x33
#define LSM6DS0_REG_INT_GEN_THS_YL_G 0x34
#define LSM6DS0_REG_INT_GEN_THS_ZH_G 0x35
#define LSM6DS0_REG_INT_GEN_THS_ZL_G 0x36
#define LSM6DS0_REG_INT_GEN_DUR_G 0x37
#define LSM6DS0_MASK_INT_GEN_DUR_G_WAIT_G BIT(7)
#define LSM6DS0_SHIFT_INT_GEN_DUR_G_WAIT_G 7
#define SENSOR_G_DOUBLE (SENSOR_G / 1000000.0)
#define SENSOR_PI_DOUBLE (SENSOR_PI / 1000000.0)
#define SENSOR_DEG2RAD_DOUBLE (SENSOR_PI_DOUBLE / 180)
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
#define LSM6DS0_ACCEL_ENABLE_X_AXIS 1
#else
#define LSM6DS0_ACCEL_ENABLE_X_AXIS 0
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
#define LSM6DS0_ACCEL_ENABLE_Y_AXIS 1
#else
#define LSM6DS0_ACCEL_ENABLE_Y_AXIS 0
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
#define LSM6DS0_ACCEL_ENABLE_Z_AXIS 1
#else
#define LSM6DS0_ACCEL_ENABLE_Z_AXIS 0
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
#define LSM6DS0_GYRO_ENABLE_X_AXIS 1
#else
#define LSM6DS0_GYRO_ENABLE_X_AXIS 0
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
#define LSM6DS0_GYRO_ENABLE_Y_AXIS 1
#else
#define LSM6DS0_GYRO_ENABLE_Y_AXIS 0
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
#define LSM6DS0_GYRO_ENABLE_Z_AXIS 1
#else
#define LSM6DS0_GYRO_ENABLE_Z_AXIS 0
#endif
#if CONFIG_LSM6DS0_ACCEL_FULLSCALE == 2
#define LSM6DS0_ACCEL_FULLSCALE_2G
#elif CONFIG_LSM6DS0_ACCEL_FULLSCALE == 4
#define LSM6DS0_ACCEL_FULLSCALE_4G
#elif CONFIG_LSM6DS0_ACCEL_FULLSCALE == 8
#define LSM6DS0_ACCEL_FULLSCALE_8G
#elif CONFIG_LSM6DS0_ACCEL_FULLSCALE == 16
#define LSM6DS0_ACCEL_FULLSCALE_16G
#endif
#if defined(LSM6DS0_ACCEL_FULLSCALE_2G)
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE 0
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE_FACTOR (2.0 * SENSOR_G_DOUBLE)
#elif defined(LSM6DS0_ACCEL_FULLSCALE_4G)
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE 2
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE_FACTOR (4.0 * SENSOR_G_DOUBLE)
#elif defined(LSM6DS0_ACCEL_FULLSCALE_8G)
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE 3
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE_FACTOR (8.0 * SENSOR_G_DOUBLE)
#elif defined(LSM6DS0_ACCEL_FULLSCALE_16G)
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE 1
#define LSM6DS0_DEFAULT_ACCEL_FULLSCALE_FACTOR (16.0 * SENSOR_G_DOUBLE)
#endif
#if CONFIG_LSM6DS0_ACCEL_SAMPLING_RATE == 0
#define LSM6DS0_ACCEL_SAMPLING_RATE_0
#elif CONFIG_LSM6DS0_ACCEL_SAMPLING_RATE == 10
#define LSM6DS0_ACCEL_SAMPLING_RATE_10
#elif CONFIG_LSM6DS0_ACCEL_SAMPLING_RATE == 50
#define LSM6DS0_ACCEL_SAMPLING_RATE_50
#elif CONFIG_LSM6DS0_ACCEL_SAMPLING_RATE == 119
#define LSM6DS0_ACCEL_SAMPLING_RATE_119
#elif CONFIG_LSM6DS0_ACCEL_SAMPLING_RATE == 238
#define LSM6DS0_ACCEL_SAMPLING_RATE_238
#elif CONFIG_LSM6DS0_ACCEL_SAMPLING_RATE == 476
#define LSM6DS0_ACCEL_SAMPLING_RATE_476
#elif CONFIG_LSM6DS0_ACCEL_SAMPLING_RATE == 952
#define LSM6DS0_ACCEL_SAMPLING_RATE_952
#endif
#if defined(LSM6DS0_ACCEL_SAMPLING_RATE_0)
#define LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE 0
#elif defined(LSM6DS0_ACCEL_SAMPLING_RATE_10)
#define LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE 1
#elif defined(LSM6DS0_ACCEL_SAMPLING_RATE_50)
#define LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE 2
#elif defined(LSM6DS0_ACCEL_SAMPLING_RATE_119)
#define LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE 3
#elif defined(LSM6DS0_ACCEL_SAMPLING_RATE_238)
#define LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE 4
#elif defined(LSM6DS0_ACCEL_SAMPLING_RATE_476)
#define LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE 5
#elif defined(LSM6DS0_ACCEL_SAMPLING_RATE_952)
#define LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE 6
#endif
#if CONFIG_LSM6DS0_GYRO_FULLSCALE == 245
#define LSM6DS0_GYRO_FULLSCALE_245
#elif CONFIG_LSM6DS0_GYRO_FULLSCALE == 500
#define LSM6DS0_GYRO_FULLSCALE_500
#elif CONFIG_LSM6DS0_GYRO_FULLSCALE == 2000
#define LSM6DS0_GYRO_FULLSCALE_2000
#endif
#if defined(LSM6DS0_GYRO_FULLSCALE_245)
#define LSM6DS0_DEFAULT_GYRO_FULLSCALE 0
#define LSM6DS0_DEFAULT_GYRO_FULLSCALE_FACTOR 8.75
#elif defined(LSM6DS0_GYRO_FULLSCALE_500)
#define LSM6DS0_DEFAULT_GYRO_FULLSCALE 1
#define LSM6DS0_DEFAULT_GYRO_FULLSCALE_FACTOR 17.50
#elif defined(LSM6DS0_GYRO_FULLSCALE_2000)
#define LSM6DS0_DEFAULT_GYRO_FULLSCALE 3
#define LSM6DS0_DEFAULT_GYRO_FULLSCALE_FACTOR 70.0
#endif
#if CONFIG_LSM6DS0_GYRO_SAMPLING_RATE == 0
#define LSM6DS0_GYRO_SAMPLING_RATE_0
#elif CONFIG_LSM6DS0_GYRO_SAMPLING_RATE == 15
#define LSM6DS0_GYRO_SAMPLING_RATE_14_9
#elif CONFIG_LSM6DS0_GYRO_SAMPLING_RATE == 60
#define LSM6DS0_GYRO_SAMPLING_RATE_59_5
#elif CONFIG_LSM6DS0_GYRO_SAMPLING_RATE == 119
#define LSM6DS0_GYRO_SAMPLING_RATE_119
#elif CONFIG_LSM6DS0_GYRO_SAMPLING_RATE == 238
#define LSM6DS0_GYRO_SAMPLING_RATE_238
#elif CONFIG_LSM6DS0_GYRO_SAMPLING_RATE == 476
#define LSM6DS0_GYRO_SAMPLING_RATE_476
#elif CONFIG_LSM6DS0_GYRO_SAMPLING_RATE == 952
#define LSM6DS0_GYRO_SAMPLING_RATE_952
#endif
#if defined(LSM6DS0_GYRO_SAMPLING_RATE_0)
#define LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE 0
#elif defined(LSM6DS0_GYRO_SAMPLING_RATE_14_9)
#define LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE 1
#elif defined(LSM6DS0_GYRO_SAMPLING_RATE_59_5)
#define LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE 2
#elif defined(LSM6DS0_GYRO_SAMPLING_RATE_119)
#define LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE 3
#elif defined(LSM6DS0_GYRO_SAMPLING_RATE_238)
#define LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE 4
#elif defined(LSM6DS0_GYRO_SAMPLING_RATE_476)
#define LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE 5
#elif defined(LSM6DS0_GYRO_SAMPLING_RATE_952)
#define LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE 6
#endif
struct lsm6ds0_config {
struct i2c_dt_spec i2c;
};
struct lsm6ds0_data {
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
int accel_sample_x;
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
int accel_sample_y;
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
int accel_sample_z;
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
int gyro_sample_x;
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
int gyro_sample_y;
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
int gyro_sample_z;
#endif
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
int temp_sample;
#endif
};
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM6DS0_LSM6DS0_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm6ds0/lsm6ds0.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,677 |
```unknown
# LSM6DS0 accelerometer and gyroscope sensor configuration
# options
menuconfig LSM6DS0
bool "LSM6DS0 I2C accelerometer and gyroscope Chip"
default y
depends on DT_HAS_ST_LSM6DS0_ENABLED
select I2C
help
Enable driver for LSM6DS0 I2C-based accelerometer and gyroscope
sensor.
if LSM6DS0
config LSM6DS0_ACCEL_ENABLE_X_AXIS
bool "Accelerometer X axis"
default y
help
Enable/disable accelerometer X axis totally by stripping everything
related in driver.
config LSM6DS0_ACCEL_ENABLE_Y_AXIS
bool "Accelerometer Y axis"
default y
help
Enable/disable accelerometer Y axis totally by stripping everything
related in driver.
config LSM6DS0_ACCEL_ENABLE_Z_AXIS
bool "Accelerometer Z axis"
default y
help
Enable/disable accelerometer Z axis totally by stripping everything
related in driver.
config LSM6DS0_GYRO_ENABLE_X_AXIS
bool "Gyroscope X axis"
default y
help
Enable/disable gyroscope X axis totally by stripping everything
related in driver.
config LSM6DS0_GYRO_ENABLE_Y_AXIS
bool "Gyroscope Y axis"
default y
help
Enable/disable gyroscope Y axis totally by stripping everything
related in driver.
config LSM6DS0_GYRO_ENABLE_Z_AXIS
bool "Gyroscope Z axis"
default y
help
Enable/disable gyroscope Z axis totally by stripping everything
related in driver.
config LSM6DS0_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature totally by stripping everything related in
driver.
menu "Attributes"
config LSM6DS0_GYRO_FULLSCALE
int "Gyroscope full-scale range"
default 245
help
Specify the default gyroscope full-scale range.
An X value for the config represents a range of +/- X degree per
second. Valid values are 245, 500 and 2000.
config LSM6DS0_GYRO_SAMPLING_RATE
int "Output data rate"
default 15
help
Specify the default gyroscope output data rate expressed in samples
per second (Hz).
Data rates supported by the chip are 0, 15, 60, 119, 238, 476,
952.
config LSM6DS0_ACCEL_FULLSCALE
int "Accelerometer full-scale range"
default 2
help
Specify the default accelerometer full-scale range.
An X value for the config represents a range of +/- X G. Valid values
are 2, 4, 8 and 16.
config LSM6DS0_ACCEL_SAMPLING_RATE
int "Output data rate"
default 10
help
Specify the default accelerometer output data rate expressed in
samples per second (Hz).
Data rates supported by the chip are 0, 10, 50, 119, 238, 476, 952.
endmenu
endif # LSM6DS0
``` | /content/code_sandbox/drivers/sensor/st/lsm6ds0/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 644 |
```unknown
# STM32 digital temperature sensor configuration options
config STM32_DIGI_TEMP
bool "STM32 Digital Temperature Sensor"
default y
depends on DT_HAS_ST_STM32_DIGI_TEMP_ENABLED
depends on SOC_FAMILY_STM32
help
Enable the driver for STM32 digital temperature sensor. This sensor
is different from the STM32 analog temperature sensor, which is read
by an ADC. While both drivers have similar code footprint, the analog
temperature driver also requires the ADC driver to be enabled. The
sensors differ in precision, accuracy and power consumption. Users
are encouraged to consult the datasheet to select the sensor that
best suits their needs.
``` | /content/code_sandbox/drivers/sensor/st/stm32_digi_temp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 145 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_HTS221_HTS221_H_
#define ZEPHYR_DRIVERS_SENSOR_HTS221_HTS221_H_
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
#include <zephyr/types.h>
#include <stmemsc.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include "hts221_reg.h"
#define HTS221_AUTOINCREMENT_ADDR BIT(7)
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
struct hts221_data {
int16_t rh_sample;
int16_t t_sample;
uint8_t h0_rh_x2;
uint8_t h1_rh_x2;
uint16_t t0_degc_x8;
uint16_t t1_degc_x8;
int16_t h0_t0_out;
int16_t h1_t0_out;
int16_t t0_out;
int16_t t1_out;
#ifdef CONFIG_HTS221_TRIGGER
const struct device *dev;
struct gpio_callback drdy_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_HTS221_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_HTS221_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem drdy_sem;
#elif defined(CONFIG_HTS221_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_HTS221_TRIGGER */
};
struct hts221_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
#ifdef CONFIG_HTS221_TRIGGER
const struct gpio_dt_spec gpio_drdy;
const struct gpio_dt_spec gpio_int;
#endif /* CONFIG_HTS221_TRIGGER */
};
#ifdef CONFIG_HTS221_TRIGGER
int hts221_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int hts221_init_interrupt(const struct device *dev);
#endif /* CONFIG_HTS221_TRIGGER */
int hts221_spi_init(const struct device *dev);
int hts221_i2c_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_HTS221_HTS221_H_ */
``` | /content/code_sandbox/drivers/sensor/st/hts221/hts221.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 579 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_stm32_digi_temp
#include <zephyr/device.h>
#include <zephyr/pm/device.h>
#include <zephyr/drivers/clock_control/stm32_clock_control.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(stm32_digi_temp, CONFIG_SENSOR_LOG_LEVEL);
/* Constants */
#define ONE_MHZ 1000000 /* Hz */
#define TS1_T0_VAL0 30 /* C */
#define TS1_T0_VAL1 130 /* C */
#define SAMPLING_TIME 15 /* best precision */
struct stm32_digi_temp_data {
struct k_sem sem_isr;
struct k_mutex mutex;
/* Peripheral clock frequency */
uint32_t pclk_freq;
/* Engineering value of the frequency measured at T0 in Hz */
uint32_t t0_freq;
/* Engineering value of the T0 temperature in C */
uint16_t t0;
/* Engineering value of the ramp coefficient in Hz / C */
uint16_t ramp_coeff;
/* Raw sensor value */
uint16_t raw;
};
struct stm32_digi_temp_config {
/* DTS instance. */
DTS_TypeDef *base;
/* Clock configuration. */
struct stm32_pclken pclken;
/* Interrupt configuration. */
void (*irq_config)(const struct device *dev);
};
static void stm32_digi_temp_isr(const struct device *dev)
{
struct stm32_digi_temp_data *data = dev->data;
const struct stm32_digi_temp_config *cfg = dev->config;
DTS_TypeDef *dts = cfg->base;
/* Clear interrupt */
SET_BIT(dts->ICIFR, DTS_ICIFR_TS1_CITEF);
/* Give semaphore */
k_sem_give(&data->sem_isr);
}
static int stm32_digi_temp_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct stm32_digi_temp_config *cfg = dev->config;
struct stm32_digi_temp_data *data = dev->data;
DTS_TypeDef *dts = cfg->base;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
/* Wait for the sensor to be ready (~40S delay after enabling it) */
while (READ_BIT(dts->SR, DTS_SR_TS1_RDY) == 0) {
k_yield();
}
/* Trigger a measurement */
SET_BIT(dts->CFGR1, DTS_CFGR1_TS1_START);
CLEAR_BIT(dts->CFGR1, DTS_CFGR1_TS1_START);
/* Wait for interrupt */
k_sem_take(&data->sem_isr, K_FOREVER);
/* Read value */
data->raw = READ_REG(dts->DR);
k_mutex_unlock(&data->mutex);
return 0;
}
static int stm32_digi_temp_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct stm32_digi_temp_data *data = dev->data;
float meas_freq, temp;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
meas_freq = ((float)data->pclk_freq * SAMPLING_TIME) / data->raw;
temp = data->t0 + (meas_freq - data->t0_freq) / data->ramp_coeff;
return sensor_value_from_float(val, temp);
}
static void stm32_digi_temp_configure(const struct device *dev)
{
const struct stm32_digi_temp_config *cfg = dev->config;
struct stm32_digi_temp_data *data = dev->data;
DTS_TypeDef *dts = cfg->base;
int clk_div;
/* Use the prescaler to obtain an internal frequency lower than 1 MHz.
* Allowed values are between 0 and 127.
*/
clk_div = MIN(DIV_ROUND_UP(data->pclk_freq, ONE_MHZ), 127);
MODIFY_REG(dts->CFGR1, DTS_CFGR1_HSREF_CLK_DIV_Msk,
clk_div << DTS_CFGR1_HSREF_CLK_DIV_Pos);
/* Select PCLK as reference clock */
MODIFY_REG(dts->CFGR1, DTS_CFGR1_REFCLK_SEL_Msk,
0 << DTS_CFGR1_REFCLK_SEL_Pos);
/* Select trigger */
MODIFY_REG(dts->CFGR1, DTS_CFGR1_TS1_INTRIG_SEL_Msk,
0 << DTS_CFGR1_TS1_INTRIG_SEL_Pos);
/* Set sampling time */
MODIFY_REG(dts->CFGR1, DTS_CFGR1_TS1_SMP_TIME_Msk,
SAMPLING_TIME << DTS_CFGR1_TS1_SMP_TIME_Pos);
}
static void stm32_digi_temp_enable(const struct device *dev)
{
const struct stm32_digi_temp_config *cfg = dev->config;
DTS_TypeDef *dts = cfg->base;
/* Enable the sensor */
SET_BIT(dts->CFGR1, DTS_CFGR1_TS1_EN);
/* Enable interrupt */
SET_BIT(dts->ITENR, DTS_ITENR_TS1_ITEEN);
}
#ifdef CONFIG_PM_DEVICE
static void stm32_digi_temp_disable(const struct device *dev)
{
const struct stm32_digi_temp_config *cfg = dev->config;
DTS_TypeDef *dts = cfg->base;
/* Disable interrupt */
CLEAR_BIT(dts->ITENR, DTS_ITENR_TS1_ITEEN);
/* Disable the sensor */
CLEAR_BIT(dts->CFGR1, DTS_CFGR1_TS1_EN);
}
#endif
static int stm32_digi_temp_init(const struct device *dev)
{
const struct stm32_digi_temp_config *cfg = dev->config;
struct stm32_digi_temp_data *data = dev->data;
DTS_TypeDef *dts = cfg->base;
/* enable clock for subsystem */
const struct device *const clk = DEVICE_DT_GET(STM32_CLOCK_CONTROL_NODE);
if (!device_is_ready(clk)) {
LOG_ERR("Clock control device not ready");
return -ENODEV;
}
if (clock_control_on(clk, (clock_control_subsys_t) &cfg->pclken) != 0) {
LOG_ERR("Could not enable DTS clock");
return -EIO;
}
/* Save the peripheral clock frequency in the data structure to avoid
* querying it for each call to the channel_get method.
*/
if (clock_control_get_rate(clk, (clock_control_subsys_t) &cfg->pclken,
&data->pclk_freq) < 0) {
LOG_ERR("Failed call clock_control_get_rate(pclken)");
return -EIO;
}
/* Save the calibration data in the data structure to avoid reading
* them for each call to the channel_get method, as this requires
* enabling the peripheral clock.
*/
data->ramp_coeff = dts->RAMPVALR & DTS_RAMPVALR_TS1_RAMP_COEFF;
data->t0_freq = (dts->T0VALR1 & DTS_T0VALR1_TS1_FMT0) * 100; /* 0.1 kHz -> Hz */
/* T0 temperature from the datasheet */
switch (dts->T0VALR1 >> DTS_T0VALR1_TS1_T0_Pos) {
case 0:
data->t0 = TS1_T0_VAL0;
break;
case 1:
data->t0 = TS1_T0_VAL1;
break;
default:
LOG_ERR("Unknown T0 temperature value");
return -EIO;
}
/* Init mutex and semaphore */
k_mutex_init(&data->mutex);
k_sem_init(&data->sem_isr, 0, 1);
/* Configure and enable the sensor */
cfg->irq_config(dev);
stm32_digi_temp_configure(dev);
stm32_digi_temp_enable(dev);
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int stm32_digi_temp_pm_action(const struct device *dev, enum pm_device_action action)
{
const struct stm32_digi_temp_config *cfg = dev->config;
const struct device *const clk = DEVICE_DT_GET(STM32_CLOCK_CONTROL_NODE);
int err;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
/* enable clock */
err = clock_control_on(clk, (clock_control_subsys_t)&cfg->pclken);
if (err != 0) {
LOG_ERR("Could not enable DTS clock");
return err;
}
/* Enable sensor */
stm32_digi_temp_enable(dev);
break;
case PM_DEVICE_ACTION_SUSPEND:
/* Disable sensor */
stm32_digi_temp_disable(dev);
/* Stop device clock */
err = clock_control_off(clk, (clock_control_subsys_t)&cfg->pclken);
if (err != 0) {
LOG_ERR("Could not disable DTS clock");
return err;
}
break;
default:
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_PM_DEVICE */
static const struct sensor_driver_api stm32_digi_temp_driver_api = {
.sample_fetch = stm32_digi_temp_sample_fetch,
.channel_get = stm32_digi_temp_channel_get,
};
#define STM32_DIGI_TEMP_INIT(index) \
static void stm32_digi_temp_irq_config_func_##index(const struct device *dev) \
{ \
IRQ_CONNECT(DT_INST_IRQN(index), \
DT_INST_IRQ(index, priority), \
stm32_digi_temp_isr, DEVICE_DT_INST_GET(index), 0); \
irq_enable(DT_INST_IRQN(index)); \
} \
\
static struct stm32_digi_temp_data stm32_digi_temp_dev_data_##index; \
\
static const struct stm32_digi_temp_config stm32_digi_temp_dev_config_##index = { \
.base = (DTS_TypeDef *)DT_INST_REG_ADDR(index), \
.pclken = { \
.enr = DT_INST_CLOCKS_CELL(index, bits), \
.bus = DT_INST_CLOCKS_CELL(index, bus) \
}, \
.irq_config = stm32_digi_temp_irq_config_func_##index, \
}; \
\
PM_DEVICE_DT_INST_DEFINE(index, stm32_digi_temp_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(index, stm32_digi_temp_init, \
PM_DEVICE_DT_INST_GET(index), \
&stm32_digi_temp_dev_data_##index, \
&stm32_digi_temp_dev_config_##index, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&stm32_digi_temp_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(STM32_DIGI_TEMP_INIT)
``` | /content/code_sandbox/drivers/sensor/st/stm32_digi_temp/stm32_digi_temp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,394 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_hts221
#include <zephyr/device.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include "hts221.h"
LOG_MODULE_DECLARE(HTS221, CONFIG_SENSOR_LOG_LEVEL);
static inline void setup_drdy(const struct device *dev,
bool enable)
{
const struct hts221_config *cfg = dev->config;
unsigned int flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, flags);
}
static inline void handle_drdy(const struct device *dev)
{
struct hts221_data *data = dev->data;
setup_drdy(dev, false);
#if defined(CONFIG_HTS221_TRIGGER_OWN_THREAD)
k_sem_give(&data->drdy_sem);
#elif defined(CONFIG_HTS221_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void process_drdy(const struct device *dev)
{
struct hts221_data *data = dev->data;
if (data->data_ready_handler != NULL) {
data->data_ready_handler(dev, data->data_ready_trigger);
}
if (data->data_ready_handler != NULL) {
setup_drdy(dev, true);
}
}
int hts221_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct hts221_data *data = dev->data;
const struct hts221_config *cfg = dev->config;
__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
setup_drdy(dev, false);
data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
data->data_ready_trigger = trig;
setup_drdy(dev, true);
/* If DRDY is active we probably won't get the rising edge, so
* invoke the callback manually.
*/
if (gpio_pin_get_dt(&cfg->gpio_drdy) > 0) {
handle_drdy(dev);
}
return 0;
}
static void hts221_drdy_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct hts221_data *data =
CONTAINER_OF(cb, struct hts221_data, drdy_cb);
ARG_UNUSED(pins);
handle_drdy(data->dev);
}
#ifdef CONFIG_HTS221_TRIGGER_OWN_THREAD
static void hts221_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct hts221_data *data = p1;
while (1) {
k_sem_take(&data->drdy_sem, K_FOREVER);
process_drdy(data->dev);
}
}
#endif
#ifdef CONFIG_HTS221_TRIGGER_GLOBAL_THREAD
static void hts221_work_cb(struct k_work *work)
{
struct hts221_data *data =
CONTAINER_OF(work, struct hts221_data, work);
process_drdy(data->dev);
}
#endif
int hts221_init_interrupt(const struct device *dev)
{
struct hts221_data *data = dev->data;
const struct hts221_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int status;
if (cfg->gpio_drdy.port == NULL) {
LOG_DBG("gpio_drdy not defined in DT");
return 0;
}
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
LOG_ERR("device %s is not ready", cfg->gpio_drdy.port->name);
return -ENODEV;
}
data->dev = dev;
/* setup data ready gpio interrupt */
status = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (status < 0) {
LOG_ERR("Could not configure %s.%02u",
cfg->gpio_drdy.port->name, cfg->gpio_drdy.pin);
return status;
}
gpio_init_callback(&data->drdy_cb,
hts221_drdy_callback,
BIT(cfg->gpio_drdy.pin));
status = gpio_add_callback(cfg->gpio_drdy.port, &data->drdy_cb);
if (status < 0) {
LOG_ERR("Could not set gpio callback.");
return status;
}
/* enable data-ready interrupt */
status = hts221_drdy_on_int_set(ctx, 1);
if (status < 0) {
LOG_ERR("Could not enable data-ready interrupt.");
return status;
}
#if defined(CONFIG_HTS221_TRIGGER_OWN_THREAD)
k_sem_init(&data->drdy_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_HTS221_THREAD_STACK_SIZE,
hts221_thread, data,
NULL, NULL, K_PRIO_COOP(CONFIG_HTS221_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_HTS221_TRIGGER_GLOBAL_THREAD)
data->work.handler = hts221_work_cb;
#endif
setup_drdy(dev, true);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/hts221/hts221_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,145 |
```unknown
menuconfig HTS221
bool "HTS221 temperature and humidity sensor"
default y
depends on DT_HAS_ST_HTS221_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_HTS221),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_HTS221),spi)
select HAS_STMEMSC
select USE_STDC_HTS221
help
Enable driver for HTS221 I2C/SPI-based temperature and humidity sensor.
if HTS221
choice HTS221_TRIGGER_MODE
prompt "Trigger mode"
default HTS221_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config HTS221_TRIGGER_NONE
bool "No trigger"
config HTS221_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select HTS221_TRIGGER
config HTS221_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select HTS221_TRIGGER
endchoice # HTS221_TRIGGER_MODE
config HTS221_TRIGGER
bool
config HTS221_THREAD_PRIORITY
int "Thread priority"
depends on HTS221_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config HTS221_THREAD_STACK_SIZE
int "Thread stack size"
depends on HTS221_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config HTS221_ODR
string "Output data rate"
default "1"
help
Sensor output data rate expressed in samples per second.
Data rates supported by the chip are 1, 7 and 12.5.
endif # HTS221
``` | /content/code_sandbox/drivers/sensor/st/hts221/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 381 |
```objective-c
/* ST Microelectronics LSM6DSO 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM6DSO_LSM6DSO_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM6DSO_LSM6DSO_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "lsm6dso_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define LSM6DSO_EN_BIT 0x01
#define LSM6DSO_DIS_BIT 0x00
/* Accel sensor sensitivity grain is 61 ug/LSB */
#define GAIN_UNIT_XL (61LL)
/* Gyro sensor sensitivity grain is 4.375 udps/LSB */
#define GAIN_UNIT_G (4375LL)
struct lsm6dso_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t accel_pm;
uint8_t accel_odr;
#define ACCEL_RANGE_DOUBLE BIT(7)
#define ACCEL_RANGE_MASK BIT_MASK(6)
uint8_t accel_range;
uint8_t gyro_pm;
uint8_t gyro_odr;
uint8_t gyro_range;
uint8_t drdy_pulsed;
#ifdef CONFIG_LSM6DSO_TRIGGER
const struct gpio_dt_spec gpio_drdy;
uint8_t int_pin;
bool trig_enabled;
#endif /* CONFIG_LSM6DSO_TRIGGER */
};
#define LSM6DSO_SHUB_MAX_NUM_TARGETS 3
struct lsm6dso_data {
const struct device *dev;
int16_t acc[3];
uint32_t acc_gain;
int16_t gyro[3];
uint32_t gyro_gain;
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
int16_t temp_sample;
#endif
#if defined(CONFIG_LSM6DSO_SENSORHUB)
uint8_t ext_data[LSM6DSO_SHUB_MAX_NUM_TARGETS][6];
uint16_t magn_gain;
struct hts221_data {
int16_t x0;
int16_t x1;
int16_t y0;
int16_t y1;
} hts221;
bool shub_inited;
uint8_t num_ext_dev;
uint8_t shub_ext[LSM6DSO_SHUB_MAX_NUM_TARGETS];
#endif /* CONFIG_LSM6DSO_SENSORHUB */
uint16_t accel_freq;
uint8_t accel_fs;
uint16_t gyro_freq;
uint8_t gyro_fs;
#ifdef CONFIG_LSM6DSO_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy_acc;
const struct sensor_trigger *trig_drdy_acc;
sensor_trigger_handler_t handler_drdy_gyr;
const struct sensor_trigger *trig_drdy_gyr;
sensor_trigger_handler_t handler_drdy_temp;
const struct sensor_trigger *trig_drdy_temp;
#if defined(CONFIG_LSM6DSO_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LSM6DSO_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LSM6DSO_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LSM6DSO_TRIGGER */
};
#if defined(CONFIG_LSM6DSO_SENSORHUB)
int lsm6dso_shub_init(const struct device *dev);
int lsm6dso_shub_fetch_external_devs(const struct device *dev);
int lsm6dso_shub_get_idx(const struct device *dev, enum sensor_channel type);
int lsm6dso_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
#endif /* CONFIG_LSM6DSO_SENSORHUB */
#ifdef CONFIG_LSM6DSO_TRIGGER
int lsm6dso_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lsm6dso_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM6DSO_LSM6DSO_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso/lsm6dso.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,036 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_hts221
#include <zephyr/drivers/i2c.h>
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <string.h>
#include <zephyr/logging/log.h>
#include "hts221.h"
LOG_MODULE_REGISTER(HTS221, CONFIG_SENSOR_LOG_LEVEL);
struct str2odr {
const char *str;
hts221_odr_t odr;
};
static const struct str2odr hts221_odrs[] = {
{ "1", HTS221_ODR_1Hz },
{ "7", HTS221_ODR_7Hz },
{ "12.5", HTS221_ODR_12Hz5 },
};
static int hts221_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct hts221_data *data = dev->data;
int32_t conv_val;
/*
* see "Interpreting humidity and temperature readings" document
* for more details
*/
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
conv_val = (int32_t)(data->t1_degc_x8 - data->t0_degc_x8) *
(data->t_sample - data->t0_out) /
(data->t1_out - data->t0_out) +
data->t0_degc_x8;
/* convert temperature x8 to degrees Celsius */
val->val1 = conv_val / 8;
val->val2 = (conv_val % 8) * (1000000 / 8);
} else if (chan == SENSOR_CHAN_HUMIDITY) {
conv_val = (int32_t)(data->h1_rh_x2 - data->h0_rh_x2) *
(data->rh_sample - data->h0_t0_out) /
(data->h1_t0_out - data->h0_t0_out) +
data->h0_rh_x2;
/* convert humidity x2 to percent */
val->val1 = conv_val / 2;
val->val2 = (conv_val % 2) * 500000;
} else {
return -ENOTSUP;
}
return 0;
}
static int hts221_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct hts221_data *data = dev->data;
const struct hts221_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t buf[4];
int status;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
status = hts221_read_reg(ctx, HTS221_HUMIDITY_OUT_L |
HTS221_AUTOINCREMENT_ADDR, buf, 4);
if (status < 0) {
LOG_ERR("Failed to fetch data sample.");
return status;
}
data->rh_sample = sys_le16_to_cpu(buf[0] | (buf[1] << 8));
data->t_sample = sys_le16_to_cpu(buf[2] | (buf[3] << 8));
return 0;
}
static int hts221_read_conversion_data(const struct device *dev)
{
struct hts221_data *data = dev->data;
const struct hts221_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t buf[16];
int status;
status = hts221_read_reg(ctx, HTS221_H0_RH_X2 |
HTS221_AUTOINCREMENT_ADDR, buf, 16);
if (status < 0) {
LOG_ERR("Failed to read conversion data.");
return status;
}
data->h0_rh_x2 = buf[0];
data->h1_rh_x2 = buf[1];
data->t0_degc_x8 = sys_le16_to_cpu(buf[2] | ((buf[5] & 0x3) << 8));
data->t1_degc_x8 = sys_le16_to_cpu(buf[3] | ((buf[5] & 0xC) << 6));
data->h0_t0_out = sys_le16_to_cpu(buf[6] | (buf[7] << 8));
data->h1_t0_out = sys_le16_to_cpu(buf[10] | (buf[11] << 8));
data->t0_out = sys_le16_to_cpu(buf[12] | (buf[13] << 8));
data->t1_out = sys_le16_to_cpu(buf[14] | (buf[15] << 8));
return 0;
}
static const struct sensor_driver_api hts221_driver_api = {
#ifdef CONFIG_HTS221_TRIGGER
.trigger_set = hts221_trigger_set,
#endif
.sample_fetch = hts221_sample_fetch,
.channel_get = hts221_channel_get,
};
int hts221_init(const struct device *dev)
{
const struct hts221_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t id, idx;
int status;
/* check chip ID */
status = hts221_device_id_get(ctx, &id);
if (status < 0) {
LOG_ERR("Failed to read chip ID.");
return status;
}
if (id != HTS221_ID) {
LOG_ERR("Invalid chip ID.");
return -EINVAL;
}
/* check if CONFIG_HTS221_ODR is valid */
for (idx = 0U; idx < ARRAY_SIZE(hts221_odrs); idx++) {
if (!strcmp(hts221_odrs[idx].str, CONFIG_HTS221_ODR)) {
break;
}
}
if (idx == ARRAY_SIZE(hts221_odrs)) {
LOG_ERR("Invalid ODR value %s.", CONFIG_HTS221_ODR);
return -EINVAL;
}
status = hts221_data_rate_set(ctx, hts221_odrs[idx].odr);
if (status < 0) {
LOG_ERR("Could not set output data rate");
return status;
}
status = hts221_block_data_update_set(ctx, 1);
if (status < 0) {
LOG_ERR("Could not set BDU bit");
return status;
}
status = hts221_power_on_set(ctx, 1);
if (status < 0) {
LOG_ERR("Could not set PD bit");
return status;
}
/*
* the device requires about 2.2 ms to download the flash content
* into the volatile mem
*/
k_sleep(K_MSEC(3));
status = hts221_read_conversion_data(dev);
if (status < 0) {
LOG_ERR("Failed to read conversion data.");
return status;
}
#ifdef CONFIG_HTS221_TRIGGER
status = hts221_init_interrupt(dev);
if (status < 0) {
LOG_ERR("Failed to initialize interrupt.");
return status;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "HTS221 driver enabled without any devices"
#endif
/*
* Device creation macros
*/
#define HTS221_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
hts221_init, \
NULL, \
&hts221_data_##inst, \
&hts221_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&hts221_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_HTS221_TRIGGER
#define HTS221_CFG_IRQ(inst) \
.gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, drdy_gpios)
#else
#define HTS221_CFG_IRQ(inst)
#endif /* CONFIG_HTS221_TRIGGER */
#define HTS221_CONFIG_COMMON(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(HTS221_CFG_IRQ(inst)), ())
#define HTS221_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA | \
SPI_HALF_DUPLEX) \
#define HTS221_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&hts221_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
HTS221_SPI_OPERATION, \
0), \
}, \
HTS221_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define HTS221_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&hts221_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
HTS221_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define HTS221_DEFINE(inst) \
static struct hts221_data hts221_data_##inst; \
static const struct hts221_config hts221_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(HTS221_CONFIG_SPI(inst)), \
(HTS221_CONFIG_I2C(inst))); \
HTS221_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(HTS221_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/hts221/hts221.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,174 |
```c
/* ST Microelectronics LSM6DSO 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dso
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lsm6dso.h"
LOG_MODULE_DECLARE(LSM6DSO, CONFIG_SENSOR_LOG_LEVEL);
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
/**
* lsm6dso_enable_t_int - TEMP enable selected int pin to generate interrupt
*/
static int lsm6dso_enable_t_int(const struct device *dev, int enable)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso_int2_ctrl_t int2_ctrl;
if (enable) {
int16_t buf;
/* dummy read: re-trigger interrupt */
lsm6dso_temperature_raw_get(ctx, &buf);
}
/* set interrupt (TEMP DRDY interrupt is only on INT2) */
if (cfg->int_pin == 1)
return -EIO;
lsm6dso_read_reg(ctx, LSM6DSO_INT2_CTRL, (uint8_t *)&int2_ctrl, 1);
int2_ctrl.int2_drdy_temp = enable;
return lsm6dso_write_reg(ctx, LSM6DSO_INT2_CTRL,
(uint8_t *)&int2_ctrl, 1);
}
#endif
/**
* lsm6dso_enable_xl_int - XL enable selected int pin to generate interrupt
*/
static int lsm6dso_enable_xl_int(const struct device *dev, int enable)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
lsm6dso_acceleration_raw_get(ctx, buf);
}
/* set interrupt */
if (cfg->int_pin == 1) {
lsm6dso_int1_ctrl_t int1_ctrl;
lsm6dso_read_reg(ctx, LSM6DSO_INT1_CTRL,
(uint8_t *)&int1_ctrl, 1);
int1_ctrl.int1_drdy_xl = enable;
return lsm6dso_write_reg(ctx, LSM6DSO_INT1_CTRL,
(uint8_t *)&int1_ctrl, 1);
} else {
lsm6dso_int2_ctrl_t int2_ctrl;
lsm6dso_read_reg(ctx, LSM6DSO_INT2_CTRL,
(uint8_t *)&int2_ctrl, 1);
int2_ctrl.int2_drdy_xl = enable;
return lsm6dso_write_reg(ctx, LSM6DSO_INT2_CTRL,
(uint8_t *)&int2_ctrl, 1);
}
}
/**
* lsm6dso_enable_g_int - Gyro enable selected int pin to generate interrupt
*/
static int lsm6dso_enable_g_int(const struct device *dev, int enable)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
lsm6dso_angular_rate_raw_get(ctx, buf);
}
/* set interrupt */
if (cfg->int_pin == 1) {
lsm6dso_int1_ctrl_t int1_ctrl;
lsm6dso_read_reg(ctx, LSM6DSO_INT1_CTRL,
(uint8_t *)&int1_ctrl, 1);
int1_ctrl.int1_drdy_g = enable;
return lsm6dso_write_reg(ctx, LSM6DSO_INT1_CTRL,
(uint8_t *)&int1_ctrl, 1);
} else {
lsm6dso_int2_ctrl_t int2_ctrl;
lsm6dso_read_reg(ctx, LSM6DSO_INT2_CTRL,
(uint8_t *)&int2_ctrl, 1);
int2_ctrl.int2_drdy_g = enable;
return lsm6dso_write_reg(ctx, LSM6DSO_INT2_CTRL,
(uint8_t *)&int2_ctrl, 1);
}
}
/**
* lsm6dso_trigger_set - link external trigger to event data ready
*/
int lsm6dso_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lsm6dso_config *cfg = dev->config;
struct lsm6dso_data *lsm6dso = dev->data;
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_ACCEL_XYZ) {
lsm6dso->handler_drdy_acc = handler;
lsm6dso->trig_drdy_acc = trig;
if (handler) {
return lsm6dso_enable_xl_int(dev, LSM6DSO_EN_BIT);
} else {
return lsm6dso_enable_xl_int(dev, LSM6DSO_DIS_BIT);
}
} else if (trig->chan == SENSOR_CHAN_GYRO_XYZ) {
lsm6dso->handler_drdy_gyr = handler;
lsm6dso->trig_drdy_gyr = trig;
if (handler) {
return lsm6dso_enable_g_int(dev, LSM6DSO_EN_BIT);
} else {
return lsm6dso_enable_g_int(dev, LSM6DSO_DIS_BIT);
}
}
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
else if (trig->chan == SENSOR_CHAN_DIE_TEMP) {
lsm6dso->handler_drdy_temp = handler;
lsm6dso->trig_drdy_temp = trig;
if (handler) {
return lsm6dso_enable_t_int(dev, LSM6DSO_EN_BIT);
} else {
return lsm6dso_enable_t_int(dev, LSM6DSO_DIS_BIT);
}
}
#endif
return -ENOTSUP;
}
/**
* lsm6dso_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void lsm6dso_handle_interrupt(const struct device *dev)
{
struct lsm6dso_data *lsm6dso = dev->data;
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso_status_reg_t status;
while (1) {
if (lsm6dso_status_reg_get(ctx, &status) < 0) {
LOG_DBG("failed reading status reg");
return;
}
if ((status.xlda == 0) && (status.gda == 0)
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
&& (status.tda == 0)
#endif
) {
break;
}
if ((status.xlda) && (lsm6dso->handler_drdy_acc != NULL)) {
lsm6dso->handler_drdy_acc(dev, lsm6dso->trig_drdy_acc);
}
if ((status.gda) && (lsm6dso->handler_drdy_gyr != NULL)) {
lsm6dso->handler_drdy_gyr(dev, lsm6dso->trig_drdy_gyr);
}
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
if ((status.tda) && (lsm6dso->handler_drdy_temp != NULL)) {
lsm6dso->handler_drdy_temp(dev, lsm6dso->trig_drdy_temp);
}
#endif
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void lsm6dso_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lsm6dso_data *lsm6dso =
CONTAINER_OF(cb, struct lsm6dso_data, gpio_cb);
const struct lsm6dso_config *cfg = lsm6dso->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, GPIO_INT_DISABLE);
#if defined(CONFIG_LSM6DSO_TRIGGER_OWN_THREAD)
k_sem_give(&lsm6dso->gpio_sem);
#elif defined(CONFIG_LSM6DSO_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lsm6dso->work);
#endif /* CONFIG_LSM6DSO_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_LSM6DSO_TRIGGER_OWN_THREAD
static void lsm6dso_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lsm6dso_data *lsm6dso = p1;
while (1) {
k_sem_take(&lsm6dso->gpio_sem, K_FOREVER);
lsm6dso_handle_interrupt(lsm6dso->dev);
}
}
#endif /* CONFIG_LSM6DSO_TRIGGER_OWN_THREAD */
#ifdef CONFIG_LSM6DSO_TRIGGER_GLOBAL_THREAD
static void lsm6dso_work_cb(struct k_work *work)
{
struct lsm6dso_data *lsm6dso =
CONTAINER_OF(work, struct lsm6dso_data, work);
lsm6dso_handle_interrupt(lsm6dso->dev);
}
#endif /* CONFIG_LSM6DSO_TRIGGER_GLOBAL_THREAD */
int lsm6dso_init_interrupt(const struct device *dev)
{
struct lsm6dso_data *lsm6dso = dev->data;
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -EINVAL;
}
#if defined(CONFIG_LSM6DSO_TRIGGER_OWN_THREAD)
k_sem_init(&lsm6dso->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lsm6dso->thread, lsm6dso->thread_stack,
CONFIG_LSM6DSO_THREAD_STACK_SIZE,
lsm6dso_thread, lsm6dso,
NULL, NULL, K_PRIO_COOP(CONFIG_LSM6DSO_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&lsm6dso->thread, "lsm6dso");
#elif defined(CONFIG_LSM6DSO_TRIGGER_GLOBAL_THREAD)
lsm6dso->work.handler = lsm6dso_work_cb;
#endif /* CONFIG_LSM6DSO_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&lsm6dso->gpio_cb,
lsm6dso_gpio_callback,
BIT(cfg->gpio_drdy.pin));
if (gpio_add_callback(cfg->gpio_drdy.port, &lsm6dso->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* set data ready mode on int1/int2 */
LOG_DBG("drdy_pulsed is %d", (int)cfg->drdy_pulsed);
lsm6dso_dataready_pulsed_t mode = cfg->drdy_pulsed ? LSM6DSO_DRDY_PULSED :
LSM6DSO_DRDY_LATCHED;
ret = lsm6dso_data_ready_mode_set(ctx, mode);
if (ret < 0) {
LOG_ERR("drdy_pulsed config error %d", (int)cfg->drdy_pulsed);
return ret;
}
return gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso/lsm6dso_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,753 |
```c
/* ST Microelectronics LSM6DSO 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dso
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "lsm6dso.h"
LOG_MODULE_DECLARE(LSM6DSO, CONFIG_SENSOR_LOG_LEVEL);
static int lsm6dso_shub_write_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len);
static int lsm6dso_shub_read_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len);
static void lsm6dso_shub_enable(const struct device *dev, uint8_t enable);
/* ST HAL skips this register, only supports it via the slower lsm6dso_sh_status_get() */
static int32_t lsm6dso_sh_status_mainpage_get(stmdev_ctx_t *ctx, lsm6dso_status_master_t *val)
{
return lsm6dso_read_reg(ctx, LSM6DSO_STATUS_MASTER_MAINPAGE, (uint8_t *)val, 1);
}
/*
* LIS2MDL magn device specific part
*/
#ifdef CONFIG_LSM6DSO_EXT_LIS2MDL
#define LIS2MDL_CFG_REG_A 0x60
#define LIS2MDL_CFG_REG_B 0x61
#define LIS2MDL_CFG_REG_C 0x62
#define LIS2MDL_STATUS_REG 0x67
#define LIS2MDL_SW_RESET 0x20
#define LIS2MDL_ODR_10HZ 0x00
#define LIS2MDL_ODR_100HZ 0x0C
#define LIS2MDL_OFF_CANC 0x02
#define LIS2MDL_SENSITIVITY 1500
static int lsm6dso_lis2mdl_init(const struct device *dev, uint8_t i2c_addr)
{
struct lsm6dso_data *data = dev->data;
uint8_t mag_cfg[2];
data->magn_gain = LIS2MDL_SENSITIVITY;
/* sw reset device */
mag_cfg[0] = LIS2MDL_SW_RESET;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
/* configure mag */
mag_cfg[0] = LIS2MDL_ODR_10HZ;
mag_cfg[1] = LIS2MDL_OFF_CANC;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 2);
return 0;
}
static const uint16_t lis2mdl_map[] = {10, 20, 50, 100};
static int lsm6dso_lis2mdl_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lis2mdl_map); odr++) {
if (freq == lis2mdl_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lis2mdl_map)) {
LOG_DBG("shub: LIS2MDL freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 2);
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, &cfg, 1);
lsm6dso_shub_enable(dev, 1);
return 0;
}
static int lsm6dso_lis2mdl_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dso_lis2mdl_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LIS2MDL attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSO_EXT_LIS2MDL */
/*
* HTS221 humidity device specific part
*/
#ifdef CONFIG_LSM6DSO_EXT_HTS221
#define HTS221_AUTOINCREMENT BIT(7)
#define HTS221_REG_CTRL1 0x20
#define HTS221_ODR_1HZ 0x01
#define HTS221_BDU 0x04
#define HTS221_PD 0x80
#define HTS221_REG_CONV_START 0x30
static int lsm6dso_hts221_read_conv_data(const struct device *dev,
uint8_t i2c_addr)
{
struct lsm6dso_data *data = dev->data;
uint8_t buf[16], i;
struct hts221_data *ht = &data->hts221;
for (i = 0; i < sizeof(buf); i += 7) {
unsigned char len = MIN(7, sizeof(buf) - i);
if (lsm6dso_shub_read_target_reg(dev, i2c_addr,
(HTS221_REG_CONV_START + i) |
HTS221_AUTOINCREMENT,
&buf[i], len) < 0) {
LOG_DBG("shub: failed to read hts221 conv data");
return -EIO;
}
}
ht->y0 = buf[0] / 2;
ht->y1 = buf[1] / 2;
ht->x0 = sys_le16_to_cpu(buf[6] | (buf[7] << 8));
ht->x1 = sys_le16_to_cpu(buf[10] | (buf[11] << 8));
return 0;
}
static int lsm6dso_hts221_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t hum_cfg;
/* configure ODR and BDU */
hum_cfg = HTS221_ODR_1HZ | HTS221_BDU | HTS221_PD;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &hum_cfg, 1);
return lsm6dso_hts221_read_conv_data(dev, i2c_addr);
}
static const uint16_t hts221_map[] = {0, 1, 7, 12};
static int lsm6dso_hts221_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(hts221_map); odr++) {
if (freq == hts221_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(hts221_map)) {
LOG_DBG("shub: HTS221 freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = odr | HTS221_BDU | HTS221_PD;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &cfg, 1);
lsm6dso_shub_enable(dev, 1);
return 0;
}
static int lsm6dso_hts221_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dso_hts221_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: HTS221 attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSO_EXT_HTS221 */
/*
* LPS22HB baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSO_EXT_LPS22HB
#define LPS22HB_CTRL_REG1 0x10
#define LPS22HB_CTRL_REG2 0x11
#define LPS22HB_SW_RESET 0x04
#define LPS22HB_ODR_10HZ 0x20
#define LPS22HB_LPF_EN 0x08
#define LPS22HB_BDU_EN 0x02
static int lsm6dso_lps22hb_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HB_SW_RESET;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LPS22HB_CTRL_REG2, baro_cfg, 1);
k_sleep(K_MSEC(1)); /* turn-on time in ms */
/* configure device */
baro_cfg[0] = LPS22HB_ODR_10HZ | LPS22HB_LPF_EN | LPS22HB_BDU_EN;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LPS22HB_CTRL_REG1, baro_cfg, 1);
return 0;
}
#endif /* CONFIG_LSM6DSO_EXT_LPS22HB */
/*
* LPS22HH baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSO_EXT_LPS22HH
#define LPS22HH_CTRL_REG1 0x10
#define LPS22HH_CTRL_REG2 0x11
#define LPS22HH_SW_RESET 0x04
#define LPS22HH_IF_ADD_INC 0x10
#define LPS22HH_ODR_10HZ 0x20
#define LPS22HH_LPF_EN 0x08
#define LPS22HH_BDU_EN 0x02
static int lsm6dso_lps22hh_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HH_SW_RESET;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG2, baro_cfg, 1);
k_sleep(K_MSEC(100)); /* turn-on time in ms */
/* configure device */
baro_cfg[0] = LPS22HH_IF_ADD_INC;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG2, baro_cfg, 1);
baro_cfg[0] = LPS22HH_ODR_10HZ | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, baro_cfg, 1);
return 0;
}
static const uint16_t lps22hh_map[] = {0, 1, 10, 25, 50, 75, 100, 200};
static int lsm6dso_lps22hh_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lps22hh_map); odr++) {
if (freq == lps22hh_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lps22hh_map)) {
LOG_DBG("shub: LPS22HH freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 4) | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
lsm6dso_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, &cfg, 1);
lsm6dso_shub_enable(dev, 1);
return 0;
}
static int lsm6dso_lps22hh_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dso_lps22hh_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LPS22HH attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSO_EXT_LPS22HH */
/* List of supported external sensors */
static struct lsm6dso_shub_slist {
enum sensor_channel type;
uint8_t i2c_addr[2];
uint8_t ext_i2c_addr;
uint8_t wai_addr;
uint8_t wai_val;
uint8_t out_data_addr;
uint8_t out_data_len;
uint8_t sh_out_reg;
int (*dev_init)(const struct device *dev, uint8_t i2c_addr);
int (*dev_conf)(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan, enum sensor_attribute attr,
const struct sensor_value *val);
} lsm6dso_shub_slist[] = {
#ifdef CONFIG_LSM6DSO_EXT_LIS2MDL
{
/* LIS2MDL */
.type = SENSOR_CHAN_MAGN_XYZ,
.i2c_addr = { 0x1E },
.wai_addr = 0x4F,
.wai_val = 0x40,
.out_data_addr = 0x68,
.out_data_len = 0x06,
.dev_init = (lsm6dso_lis2mdl_init),
.dev_conf = (lsm6dso_lis2mdl_conf),
},
#endif /* CONFIG_LSM6DSO_EXT_LIS2MDL */
#ifdef CONFIG_LSM6DSO_EXT_HTS221
{
/* HTS221 */
.type = SENSOR_CHAN_HUMIDITY,
.i2c_addr = { 0x5F },
.wai_addr = 0x0F,
.wai_val = 0xBC,
.out_data_addr = 0x28 | HTS221_AUTOINCREMENT,
.out_data_len = 0x02,
.dev_init = (lsm6dso_hts221_init),
.dev_conf = (lsm6dso_hts221_conf),
},
#endif /* CONFIG_LSM6DSO_EXT_HTS221 */
#ifdef CONFIG_LSM6DSO_EXT_LPS22HB
{
/* LPS22HB */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB1,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dso_lps22hb_init),
},
#endif /* CONFIG_LSM6DSO_EXT_LPS22HB */
#ifdef CONFIG_LSM6DSO_EXT_LPS22HH
{
/* LPS22HH */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB3,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dso_lps22hh_init),
.dev_conf = (lsm6dso_lps22hh_conf),
},
#endif /* CONFIG_LSM6DSO_EXT_LPS22HH */
};
static int lsm6dso_shub_wait_completed(stmdev_ctx_t *ctx)
{
lsm6dso_status_master_t status;
int tries = 200; /* Should be max ~160 ms, from 2 cycles at slowest ODR 12.5 Hz */
do {
if (!--tries) {
LOG_DBG("shub: Timeout waiting for operation to complete");
return -ETIMEDOUT;
}
k_msleep(1);
lsm6dso_sh_status_mainpage_get(ctx, &status);
} while (status.sens_hub_endop == 0);
return 1;
}
static void lsm6dso_shub_enable(const struct device *dev, uint8_t enable)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *data = dev->data;
/* Enable Accel @26hz */
if (!data->accel_freq) {
uint8_t odr = (enable) ? 2 : 0;
if (lsm6dso_xl_data_rate_set(ctx, odr) < 0) {
LOG_DBG("shub: failed to set XL sampling rate");
return;
}
}
if (enable) {
lsm6dso_status_master_t status;
/* Clear any pending status flags */
lsm6dso_sh_status_mainpage_get(ctx, &status);
}
if (lsm6dso_sh_master_set(ctx, enable) < 0) {
LOG_DBG("shub: failed to set master on");
lsm6dso_mem_bank_set(ctx, LSM6DSO_USER_BANK);
return;
}
if (!enable) {
/* wait 300us (necessary per AN5192 7.2.1) */
k_busy_wait(300);
}
}
/* must be called with master on */
static int lsm6dso_shub_check_slv0_nack(stmdev_ctx_t *ctx)
{
lsm6dso_status_master_t status;
if (lsm6dso_sh_status_get(ctx, &status) < 0) {
LOG_DBG("shub: error reading embedded reg");
return -EIO;
}
if (status.slave0_nack) {
LOG_DBG("shub: TRGT 0 nacked");
return -EIO;
}
return 0;
}
/*
* use TRGT 0 for generic read to target device
*/
static int lsm6dso_shub_read_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso_sh_cfg_read_t trgt_cfg;
trgt_cfg.slv_add = trgt_addr;
trgt_cfg.slv_subadd = trgt_reg;
trgt_cfg.slv_len = len;
lsm6dso_sh_slv_cfg_read(ctx, 0, &trgt_cfg);
/* turn SH on, wait for shub i2c read to finish */
lsm6dso_shub_enable(dev, 1);
lsm6dso_shub_wait_completed(ctx);
/* read data from external target */
if (lsm6dso_sh_read_data_raw_get(ctx, value, len) < 0) {
LOG_DBG("shub: error reading sensor data");
return -EIO;
}
if (lsm6dso_shub_check_slv0_nack(ctx) < 0) {
lsm6dso_shub_enable(dev, 0);
return -EIO;
}
lsm6dso_shub_enable(dev, 0);
return 0;
}
/*
* use TRGT 0 to configure target device
*/
static int lsm6dso_shub_write_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso_sh_cfg_write_t trgt_cfg;
uint8_t cnt = 0U;
lsm6dso_shub_enable(dev, 0);
while (cnt < len) {
trgt_cfg.slv0_add = trgt_addr;
trgt_cfg.slv0_subadd = trgt_reg + cnt;
trgt_cfg.slv0_data = value[cnt];
lsm6dso_sh_cfg_write(ctx, &trgt_cfg);
/* turn SH on, wait for shub i2c write to finish */
lsm6dso_shub_enable(dev, 1);
lsm6dso_shub_wait_completed(ctx);
if (lsm6dso_shub_check_slv0_nack(ctx) < 0) {
lsm6dso_shub_enable(dev, 0);
return -EIO;
}
lsm6dso_shub_enable(dev, 0);
cnt++;
}
/* Put TRGT 0 in IDLE mode */
trgt_cfg.slv0_add = 0x7;
trgt_cfg.slv0_subadd = 0x0;
trgt_cfg.slv0_data = 0x0;
lsm6dso_sh_cfg_write(ctx, &trgt_cfg);
return 0;
}
/*
* TARGETs configurations:
*
* - TARGET 0: used for configuring all target devices
* - TARGET 1: used as data read channel for external target device #1
* - TARGET 2: used as data read channel for external target device #2
* - TARGET 3: used for generic reads while data channel is enabled
*/
static int lsm6dso_shub_set_data_channel(const struct device *dev)
{
struct lsm6dso_data *data = dev->data;
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t n;
struct lsm6dso_shub_slist *sp;
lsm6dso_sh_cfg_read_t trgt_cfg;
/* Configure shub data channels to access external targets */
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso_shub_slist[data->shub_ext[n]];
trgt_cfg.slv_add = sp->ext_i2c_addr;
trgt_cfg.slv_subadd = sp->out_data_addr;
trgt_cfg.slv_len = sp->out_data_len;
if (lsm6dso_sh_slv_cfg_read(ctx, n + 1, &trgt_cfg) < 0) {
LOG_DBG("shub: error configuring shub for ext targets");
return -EIO;
}
}
/* Configure the master */
lsm6dso_aux_sens_on_t aux = LSM6DSO_SLV_0_1_2;
if (lsm6dso_sh_slave_connected_set(ctx, aux) < 0) {
LOG_DBG("shub: error setting aux sensors");
return -EIO;
}
/* turn SH on, no need to wait for 1st shub i2c read, if any, to complete */
lsm6dso_shub_enable(dev, 1);
return 0;
}
int lsm6dso_shub_get_idx(const struct device *dev, enum sensor_channel type)
{
uint8_t n;
struct lsm6dso_data *data = dev->data;
struct lsm6dso_shub_slist *sp;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso_shub_slist[data->shub_ext[n]];
if (sp->type == type) {
return n;
}
}
LOG_ERR("shub: dev %s type %d not supported", dev->name, type);
return -ENOTSUP;
}
int lsm6dso_shub_fetch_external_devs(const struct device *dev)
{
uint8_t n;
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *data = dev->data;
struct lsm6dso_shub_slist *sp;
/* read data from external target */
if (lsm6dso_mem_bank_set(ctx, LSM6DSO_SENSOR_HUB_BANK) < 0) {
LOG_DBG("failed to enter SENSOR_HUB bank");
return -EIO;
}
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso_shub_slist[data->shub_ext[n]];
if (lsm6dso_read_reg(ctx, sp->sh_out_reg,
data->ext_data[n], sp->out_data_len) < 0) {
LOG_DBG("shub: failed to read sample");
(void) lsm6dso_mem_bank_set(ctx, LSM6DSO_USER_BANK);
return -EIO;
}
}
return lsm6dso_mem_bank_set(ctx, LSM6DSO_USER_BANK);
}
int lsm6dso_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct lsm6dso_data *data = dev->data;
struct lsm6dso_shub_slist *sp = NULL;
uint8_t n;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso_shub_slist[data->shub_ext[n]];
if (sp->type == chan) {
break;
}
}
if (n == data->num_ext_dev) {
LOG_DBG("shub: %s chan %d not supported", dev->name, chan);
return -ENOTSUP;
}
if (sp == NULL || sp->dev_conf == NULL) {
LOG_DBG("shub: chan not configurable");
return -ENOTSUP;
}
return sp->dev_conf(dev, sp->ext_i2c_addr, chan, attr, val);
}
int lsm6dso_shub_init(const struct device *dev)
{
struct lsm6dso_data *data = dev->data;
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t i, n = 0, regn;
uint8_t chip_id;
struct lsm6dso_shub_slist *sp;
LOG_INF("shub: start sensorhub for %s", dev->name);
/* This must be set or lsm6dso_shub_write_target_reg() will repeatedly write the same reg */
if (lsm6dso_sh_write_mode_set(ctx, LSM6DSO_ONLY_FIRST_CYCLE) < 0) {
LOG_DBG("shub: error setting write once");
return -EIO;
}
for (n = 0; n < ARRAY_SIZE(lsm6dso_shub_slist); n++) {
if (data->num_ext_dev >= LSM6DSO_SHUB_MAX_NUM_TARGETS) {
break;
}
chip_id = 0;
sp = &lsm6dso_shub_slist[n];
/*
* The external sensor may have different I2C address.
* So, try them one by one until we read the correct
* chip ID.
*/
for (i = 0U; i < ARRAY_SIZE(sp->i2c_addr); i++) {
if (lsm6dso_shub_read_target_reg(dev,
sp->i2c_addr[i],
sp->wai_addr,
&chip_id, 1) < 0) {
LOG_DBG("shub: failed reading chip id");
continue;
}
if (chip_id == sp->wai_val) {
break;
}
}
if (i >= ARRAY_SIZE(sp->i2c_addr)) {
LOG_DBG("shub: invalid chip id 0x%x", chip_id);
continue;
}
LOG_INF("shub: Ext Device Chip Id: %02x", chip_id);
sp->ext_i2c_addr = sp->i2c_addr[i];
data->shub_ext[data->num_ext_dev++] = n;
}
LOG_DBG("shub: dev %s - num_ext_dev %d", dev->name, data->num_ext_dev);
if (data->num_ext_dev == 0) {
LOG_ERR("shub: no target devices found");
return -EINVAL;
}
/* init external devices */
for (n = 0, regn = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso_shub_slist[data->shub_ext[n]];
sp->sh_out_reg = LSM6DSO_SENSOR_HUB_1 + regn;
regn += sp->out_data_len;
sp->dev_init(dev, sp->ext_i2c_addr);
}
lsm6dso_shub_set_data_channel(dev);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso/lsm6dso_shub.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,603 |
```c
/* ST Microelectronics LSM6DSO 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dso
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lsm6dso.h"
LOG_MODULE_REGISTER(LSM6DSO, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t lsm6dso_odr_map[] = {0, 12, 26, 52, 104, 208, 417, 833,
1667, 3333, 6667};
static int lsm6dso_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dso_odr_map); i++) {
if (freq <= lsm6dso_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static int lsm6dso_odr_to_freq_val(uint16_t odr)
{
/* for valid index, return value from map */
if (odr < ARRAY_SIZE(lsm6dso_odr_map)) {
return lsm6dso_odr_map[odr];
}
/* invalid index, return last entry */
return lsm6dso_odr_map[ARRAY_SIZE(lsm6dso_odr_map) - 1];
}
static const uint16_t lsm6dso_accel_fs_map[] = {2, 16, 4, 8};
static int lsm6dso_accel_range_to_fs_val(int32_t range, bool double_range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dso_accel_fs_map); i++) {
if (range == (lsm6dso_accel_fs_map[i] << double_range)) {
return i;
}
}
return -EINVAL;
}
static int lsm6dso_accel_fs_val_to_gain(int fs, bool double_range)
{
/* Range of 2G has a LSB of GAIN_UNIT_XL, thus divide by 2 */
return double_range ?
lsm6dso_accel_fs_map[fs] * GAIN_UNIT_XL :
lsm6dso_accel_fs_map[fs] * GAIN_UNIT_XL / 2;
}
static const uint16_t lsm6dso_gyro_fs_map[] = {250, 125, 500, 0, 1000, 0, 2000};
static const uint16_t lsm6dso_gyro_fs_sens[] = {2, 1, 4, 0, 8, 0, 16};
static int lsm6dso_gyro_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dso_gyro_fs_map); i++) {
if (range == lsm6dso_gyro_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static inline int lsm6dso_reboot(const struct device *dev)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dso_boot_set(ctx, 1) < 0) {
return -EIO;
}
/* Wait sensor turn-on time as per datasheet */
k_busy_wait(35 * USEC_PER_MSEC);
return 0;
}
static int lsm6dso_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *data = dev->data;
if (lsm6dso_xl_full_scale_set(ctx, fs) < 0) {
return -EIO;
}
data->accel_fs = fs;
return 0;
}
static int lsm6dso_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *data = dev->data;
if (lsm6dso_xl_data_rate_set(ctx, odr) < 0) {
return -EIO;
}
data->accel_freq = lsm6dso_odr_to_freq_val(odr);
return 0;
}
static int lsm6dso_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dso_gy_full_scale_set(ctx, fs) < 0) {
return -EIO;
}
return 0;
}
static int lsm6dso_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dso_gy_data_rate_set(ctx, odr) < 0) {
return -EIO;
}
return 0;
}
static int lsm6dso_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lsm6dso_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (lsm6dso_accel_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
static int lsm6dso_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dso_data *data = dev->data;
const struct lsm6dso_config *cfg = dev->config;
bool range_double = !!(cfg->accel_range & ACCEL_RANGE_DOUBLE);
fs = lsm6dso_accel_range_to_fs_val(range, range_double);
if (fs < 0) {
return fs;
}
if (lsm6dso_accel_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
data->acc_gain = lsm6dso_accel_fs_val_to_gain(fs, range_double);
return 0;
}
static int lsm6dso_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm6dso_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dso_accel_odr_set(dev, val->val1);
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dso_gyro_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lsm6dso_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (lsm6dso_gyro_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
return 0;
}
static int lsm6dso_gyro_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dso_data *data = dev->data;
fs = lsm6dso_gyro_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lsm6dso_gyro_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
data->gyro_gain = (lsm6dso_gyro_fs_sens[fs] * GAIN_UNIT_G);
return 0;
}
static int lsm6dso_gyro_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm6dso_gyro_range_set(dev, sensor_rad_to_degrees(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dso_gyro_odr_set(dev, val->val1);
default:
LOG_DBG("Gyro attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dso_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
#if defined(CONFIG_LSM6DSO_SENSORHUB)
struct lsm6dso_data *data = dev->data;
#endif /* CONFIG_LSM6DSO_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lsm6dso_accel_config(dev, chan, attr, val);
case SENSOR_CHAN_GYRO_XYZ:
return lsm6dso_gyro_config(dev, chan, attr, val);
#if defined(CONFIG_LSM6DSO_SENSORHUB)
case SENSOR_CHAN_MAGN_XYZ:
case SENSOR_CHAN_PRESS:
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("shub not inited.");
return -ENOTSUP;
}
return lsm6dso_shub_config(dev, chan, attr, val);
#endif /* CONFIG_LSM6DSO_SENSORHUB */
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dso_sample_fetch_accel(const struct device *dev)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *data = dev->data;
if (lsm6dso_acceleration_raw_get(ctx, data->acc) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
static int lsm6dso_sample_fetch_gyro(const struct device *dev)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *data = dev->data;
if (lsm6dso_angular_rate_raw_get(ctx, data->gyro) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
static int lsm6dso_sample_fetch_temp(const struct device *dev)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *data = dev->data;
if (lsm6dso_temperature_raw_get(ctx, &data->temp_sample) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
#endif
#if defined(CONFIG_LSM6DSO_SENSORHUB)
static int lsm6dso_sample_fetch_shub(const struct device *dev)
{
if (lsm6dso_shub_fetch_external_devs(dev) < 0) {
LOG_DBG("failed to read ext shub devices");
return -EIO;
}
return 0;
}
#endif /* CONFIG_LSM6DSO_SENSORHUB */
static int lsm6dso_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
#if defined(CONFIG_LSM6DSO_SENSORHUB)
struct lsm6dso_data *data = dev->data;
#endif /* CONFIG_LSM6DSO_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dso_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm6dso_sample_fetch_gyro(dev);
break;
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dso_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lsm6dso_sample_fetch_accel(dev);
lsm6dso_sample_fetch_gyro(dev);
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
lsm6dso_sample_fetch_temp(dev);
#endif
#if defined(CONFIG_LSM6DSO_SENSORHUB)
if (data->shub_inited) {
lsm6dso_sample_fetch_shub(dev);
}
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6dso_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)(raw_val) * sensitivity;
sensor_ug_to_ms2(dval, val);
}
static inline int lsm6dso_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lsm6dso_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
lsm6dso_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
lsm6dso_accel_convert(val, data->acc[2], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 3; i++) {
lsm6dso_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dso_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso_data *data)
{
return lsm6dso_accel_get_channel(chan, val, data, data->acc_gain);
}
static inline void lsm6dso_gyro_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in udps/LSB */
/* So, calculate value in 10 udps unit and then to rad/s */
dval = (int64_t)(raw_val) * sensitivity / 10;
sensor_10udegrees_to_rad(dval, val);
}
static inline int lsm6dso_gyro_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
lsm6dso_gyro_convert(val, data->gyro[0], sensitivity);
break;
case SENSOR_CHAN_GYRO_Y:
lsm6dso_gyro_convert(val, data->gyro[1], sensitivity);
break;
case SENSOR_CHAN_GYRO_Z:
lsm6dso_gyro_convert(val, data->gyro[2], sensitivity);
break;
case SENSOR_CHAN_GYRO_XYZ:
for (i = 0; i < 3; i++) {
lsm6dso_gyro_convert(val++, data->gyro[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dso_gyro_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso_data *data)
{
return lsm6dso_gyro_get_channel(chan, val, data, data->gyro_gain);
}
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
static void lsm6dso_gyro_channel_get_temp(struct sensor_value *val,
struct lsm6dso_data *data)
{
/* val = temp_sample / 256 + 25 */
val->val1 = data->temp_sample / 256 + 25;
val->val2 = (data->temp_sample % 256) * (1000000 / 256);
}
#endif
#if defined(CONFIG_LSM6DSO_SENSORHUB)
static inline void lsm6dso_magn_convert(struct sensor_value *val, int raw_val,
uint16_t sensitivity)
{
double dval;
/* Sensitivity is exposed in ugauss/LSB */
dval = (double)(raw_val * sensitivity);
val->val1 = (int32_t)dval / 1000000;
val->val2 = (int32_t)dval % 1000000;
}
static inline int lsm6dso_magn_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso_data *data)
{
int16_t sample[3];
int idx;
idx = lsm6dso_shub_get_idx(data->dev, SENSOR_CHAN_MAGN_XYZ);
if (idx < 0) {
LOG_DBG("external magn not supported");
return -ENOTSUP;
}
sample[0] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
sample[1] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][2] |
(data->ext_data[idx][3] << 8)));
sample[2] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][4] |
(data->ext_data[idx][5] << 8)));
switch (chan) {
case SENSOR_CHAN_MAGN_X:
lsm6dso_magn_convert(val, sample[0], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Y:
lsm6dso_magn_convert(val, sample[1], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Z:
lsm6dso_magn_convert(val, sample[2], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_XYZ:
lsm6dso_magn_convert(val, sample[0], data->magn_gain);
lsm6dso_magn_convert(val + 1, sample[1], data->magn_gain);
lsm6dso_magn_convert(val + 2, sample[2], data->magn_gain);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6dso_hum_convert(struct sensor_value *val,
struct lsm6dso_data *data)
{
float rh;
int16_t raw_val;
struct hts221_data *ht = &data->hts221;
int idx;
idx = lsm6dso_shub_get_idx(data->dev, SENSOR_CHAN_HUMIDITY);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le16_to_cpu((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
/* find relative humidty by linear interpolation */
rh = (ht->y1 - ht->y0) * raw_val + ht->x1 * ht->y0 - ht->x0 * ht->y1;
rh /= (ht->x1 - ht->x0);
/* convert humidity to integer and fractional part */
val->val1 = rh;
val->val2 = rh * 1000000;
}
static inline void lsm6dso_press_convert(struct sensor_value *val,
struct lsm6dso_data *data)
{
int32_t raw_val;
int idx;
idx = lsm6dso_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le32_to_cpu((int32_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8) |
(data->ext_data[idx][2] << 16)));
/* Pressure sensitivity is 4096 LSB/hPa */
/* Convert raw_val to val in kPa */
val->val1 = (raw_val >> 12) / 10;
val->val2 = (raw_val >> 12) % 10 * 100000 +
(((int32_t)((raw_val) & 0x0FFF) * 100000L) >> 12);
}
static inline void lsm6dso_temp_convert(struct sensor_value *val,
struct lsm6dso_data *data)
{
int16_t raw_val;
int idx;
idx = lsm6dso_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le16_to_cpu((int16_t)(data->ext_data[idx][3] |
(data->ext_data[idx][4] << 8)));
/* Temperature sensitivity is 100 LSB/deg C */
val->val1 = raw_val / 100;
val->val2 = (int32_t)raw_val % 100 * (10000);
}
#endif
static int lsm6dso_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm6dso_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dso_accel_channel_get(chan, val, data);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
lsm6dso_gyro_channel_get(chan, val, data);
break;
#if defined(CONFIG_LSM6DSO_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dso_gyro_channel_get_temp(val, data);
break;
#endif
#if defined(CONFIG_LSM6DSO_SENSORHUB)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso_magn_get_channel(chan, val, data);
break;
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso_hum_convert(val, data);
break;
case SENSOR_CHAN_PRESS:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso_press_convert(val, data);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso_temp_convert(val, data);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lsm6dso_driver_api = {
.attr_set = lsm6dso_attr_set,
#if CONFIG_LSM6DSO_TRIGGER
.trigger_set = lsm6dso_trigger_set,
#endif
.sample_fetch = lsm6dso_sample_fetch,
.channel_get = lsm6dso_channel_get,
};
static int lsm6dso_init_chip(const struct device *dev)
{
const struct lsm6dso_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso_data *lsm6dso = dev->data;
uint8_t chip_id, master_on;
uint8_t odr, fs;
/* All registers except 0x01 are different between banks, including the WHO_AM_I
* register and the register used for a SW reset. If the lsm6dso wasn't on the user
* bank when it reset, then both the chip id check and the sw reset will fail unless we
* set the bank now.
*/
if (lsm6dso_mem_bank_set(ctx, LSM6DSO_USER_BANK) < 0) {
LOG_DBG("Failed to set user bank");
return -EIO;
}
if (lsm6dso_device_id_get(ctx, &chip_id) < 0) {
LOG_DBG("Failed reading chip id");
return -EIO;
}
LOG_INF("chip id 0x%x", chip_id);
if (chip_id != LSM6DSO_ID) {
LOG_DBG("Invalid chip id 0x%x", chip_id);
return -EIO;
}
/* I3C disable stay preserved after s/w reset */
if (lsm6dso_i3c_disable_set(ctx, LSM6DSO_I3C_DISABLE) < 0) {
LOG_DBG("Failed to disable I3C");
return -EIO;
}
/* Per AN5192 7.2.1, " when applying the software reset procedure, the I2C master
* must be disabled, followed by a 300 s wait."
*/
if (lsm6dso_sh_master_get(ctx, &master_on) < 0) {
LOG_DBG("Failed to get I2C_MASTER status");
return -EIO;
}
if (master_on) {
LOG_DBG("Disable shub before reset");
lsm6dso_sh_master_set(ctx, 0);
k_busy_wait(300);
}
/* reset device */
if (lsm6dso_reset_set(ctx, 1) < 0) {
return -EIO;
}
k_busy_wait(100);
/* set accel power mode */
LOG_DBG("accel pm is %d", cfg->accel_pm);
switch (cfg->accel_pm) {
default:
case 0:
lsm6dso_xl_power_mode_set(ctx, LSM6DSO_HIGH_PERFORMANCE_MD);
break;
case 1:
lsm6dso_xl_power_mode_set(ctx, LSM6DSO_LOW_NORMAL_POWER_MD);
break;
case 2:
lsm6dso_xl_power_mode_set(ctx, LSM6DSO_ULTRA_LOW_POWER_MD);
break;
}
fs = cfg->accel_range & ACCEL_RANGE_MASK;
LOG_DBG("accel range is %d", fs);
if (lsm6dso_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer range %d", fs);
return -EIO;
}
lsm6dso->acc_gain = lsm6dso_accel_fs_val_to_gain(fs, cfg->accel_range & ACCEL_RANGE_DOUBLE);
odr = cfg->accel_odr;
LOG_DBG("accel odr is %d", odr);
lsm6dso->accel_freq = lsm6dso_odr_to_freq_val(odr);
if (lsm6dso_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer odr %d", odr);
return -EIO;
}
/* set gyro power mode */
LOG_DBG("gyro pm is %d", cfg->gyro_pm);
switch (cfg->gyro_pm) {
default:
case 0:
lsm6dso_gy_power_mode_set(ctx, LSM6DSO_GY_HIGH_PERFORMANCE);
break;
case 1:
lsm6dso_gy_power_mode_set(ctx, LSM6DSO_GY_NORMAL);
break;
}
fs = cfg->gyro_range;
LOG_DBG("gyro range is %d", fs);
if (lsm6dso_gyro_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set gyroscope range %d", fs);
return -EIO;
}
lsm6dso->gyro_gain = (lsm6dso_gyro_fs_sens[fs] * GAIN_UNIT_G);
odr = cfg->gyro_odr;
LOG_DBG("gyro odr is %d", odr);
lsm6dso->gyro_freq = lsm6dso_odr_to_freq_val(odr);
if (lsm6dso_gyro_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set gyroscope odr %d", odr);
return -EIO;
}
/* Set FIFO bypass mode */
if (lsm6dso_fifo_mode_set(ctx, LSM6DSO_BYPASS_MODE) < 0) {
LOG_DBG("failed to set FIFO mode");
return -EIO;
}
if (lsm6dso_block_data_update_set(ctx, 1) < 0) {
LOG_DBG("failed to set BDU mode");
return -EIO;
}
return 0;
}
static int lsm6dso_init(const struct device *dev)
{
#ifdef CONFIG_LSM6DSO_TRIGGER
const struct lsm6dso_config *cfg = dev->config;
#endif
struct lsm6dso_data *data = dev->data;
LOG_INF("Initialize device %s", dev->name);
data->dev = dev;
if (lsm6dso_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_LSM6DSO_TRIGGER
if (cfg->trig_enabled) {
if (lsm6dso_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
#ifdef CONFIG_LSM6DSO_SENSORHUB
data->shub_inited = true;
if (lsm6dso_shub_init(dev) < 0) {
LOG_INF("shub: no external chips found");
data->shub_inited = false;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LSM6DSO driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LSM6DSO_DEFINE_SPI() and
* LSM6DSO_DEFINE_I2C().
*/
#define LSM6DSO_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lsm6dso_init, \
NULL, \
&lsm6dso_data_##inst, \
&lsm6dso_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lsm6dso_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LSM6DSO_TRIGGER
#define LSM6DSO_CFG_IRQ(inst) \
.trig_enabled = true, \
.gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, irq_gpios), \
.int_pin = DT_INST_PROP(inst, int_pin)
#else
#define LSM6DSO_CFG_IRQ(inst)
#endif /* CONFIG_LSM6DSO_TRIGGER */
#define LSM6DSO_SPI_OP (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LSM6DSO_CONFIG_COMMON(inst) \
.accel_pm = DT_INST_PROP(inst, accel_pm), \
.accel_odr = DT_INST_PROP(inst, accel_odr), \
.accel_range = DT_INST_PROP(inst, accel_range) | \
(DT_INST_NODE_HAS_COMPAT(inst, st_lsm6dso32) ? \
ACCEL_RANGE_DOUBLE : 0), \
.gyro_pm = DT_INST_PROP(inst, gyro_pm), \
.gyro_odr = DT_INST_PROP(inst, gyro_odr), \
.gyro_range = DT_INST_PROP(inst, gyro_range), \
.drdy_pulsed = DT_INST_PROP(inst, drdy_pulsed), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
(LSM6DSO_CFG_IRQ(inst)), ())
#define LSM6DSO_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lsm6dso_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
LSM6DSO_SPI_OP, \
0), \
}, \
LSM6DSO_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LSM6DSO_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lsm6dso_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LSM6DSO_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LSM6DSO_DEFINE(inst) \
static struct lsm6dso_data lsm6dso_data_##inst; \
static const struct lsm6dso_config lsm6dso_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LSM6DSO_CONFIG_SPI(inst)), \
(LSM6DSO_CONFIG_I2C(inst))); \
LSM6DSO_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LSM6DSO_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso/lsm6dso.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,675 |
```unknown
# ST Microelectronics LSM6DSO 6-axis IMU sensor driver
menuconfig LSM6DSO
bool "LSM6DSO I2C/SPI accelerometer and gyroscope Chip"
default y
depends on DT_HAS_ST_LSM6DSO_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSO),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSO),spi)
select HAS_STMEMSC
select USE_STDC_LSM6DSO
help
Enable driver for LSM6DSO accelerometer and gyroscope
sensor.
if LSM6DSO
choice LSM6DSO_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config LSM6DSO_TRIGGER_NONE
bool "No trigger"
config LSM6DSO_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LSM6DSO_TRIGGER
config LSM6DSO_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LSM6DSO_TRIGGER
endchoice
config LSM6DSO_TRIGGER
bool
if LSM6DSO_TRIGGER
config LSM6DSO_THREAD_PRIORITY
int "Thread priority"
depends on LSM6DSO_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LSM6DSO_THREAD_STACK_SIZE
int "Thread stack size"
depends on LSM6DSO_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # LSM6DSO_TRIGGER
config LSM6DSO_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
config LSM6DSO_SENSORHUB
bool "I2C sensorhub feature"
help
Enable/disable internal sensorhub. You can enable
a maximum of two external sensors (if more than two are enabled
the system would enumerate only the first two found)
if LSM6DSO_SENSORHUB
config LSM6DSO_EXT_LIS2MDL
bool "LIS2MDL as external sensor"
default y
config LSM6DSO_EXT_LPS22HH
bool "LPS22HH as external sensor"
default y
config LSM6DSO_EXT_HTS221
bool "HTS221 as external sensor"
config LSM6DSO_EXT_LPS22HB
bool "LPS22HB as external sensor"
endif # LSM6DSO_SENSORHUB
endif # LSM6DSO
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 561 |
```objective-c
/* ST Microelectronics STTS22H temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_STTS22H_STTS22H_H_
#define ZEPHYR_DRIVERS_SENSOR_STTS22H_STTS22H_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "stts22h_reg.h"
#include <zephyr/drivers/i2c.h>
struct stts22h_config {
stmdev_ctx_t ctx;
const struct i2c_dt_spec i2c;
#ifdef CONFIG_STTS22H_TRIGGER
const struct gpio_dt_spec int_gpio;
#endif
uint8_t temp_hi;
uint8_t temp_lo;
uint8_t odr;
};
struct stts22h_data {
const struct device *dev;
int16_t sample_temp;
#ifdef CONFIG_STTS22H_TRIGGER
struct gpio_callback gpio_cb;
const struct sensor_trigger *thsld_trigger;
sensor_trigger_handler_t thsld_handler;
#if defined(CONFIG_STTS22H_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_STTS22H_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_STTS22H_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_STTS22H_TRIGGER */
};
#ifdef CONFIG_STTS22H_TRIGGER
int stts22h_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int stts22h_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_STTS22H_STTS22H_H_ */
``` | /content/code_sandbox/drivers/sensor/st/stts22h/stts22h.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 379 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.