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 |
|---|---|---|---|---|---|---|---|---|
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/rohm/bd8lb600fs/Kconfig"
source "drivers/sensor/rohm/bh1750/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/rohm/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 54 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BD8LB600FS_BD8LB600FS_DIAGNOSTICS_H_
#define ZEPHYR_DRIVERS_SENSOR_BD8LB600FS_BD8LB600FS_DIAGNOSTICS_H_
#include <zephyr/device.h>
struct bd8lb600fs_diagnostics_data {
/* open load detection */
uint32_t old;
/* over current protection or thermal shutdown*/
uint32_t ocp_or_tsd;
};
struct bd8lb600fs_diagnostics_config {
const struct device *parent_dev;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_BD8LB600FS_BD8LB600FS_DIAGNOSTICS_H_ */
``` | /content/code_sandbox/drivers/sensor/rohm/bd8lb600fs/bd8lb600fs_diagnostics.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 150 |
```c
/*
*
*/
#define DT_DRV_COMPAT we_wsen_pdus
#include <stdlib.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include "wsen_pdus.h"
LOG_MODULE_REGISTER(WSEN_PDUS, CONFIG_SENSOR_LOG_LEVEL);
static int pdus_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct pdus_config *const config = dev->config;
struct pdus_data *data = dev->data;
float pressure;
float temperature;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (PDUS_getPressureAndTemperature_float(&data->sensor_interface,
config->sensor_type, &pressure,
&temperature) != WE_SUCCESS) {
LOG_ERR("Failed to fetch data sample");
return -EIO;
}
data->pressure_k_pa = pressure;
data->temperature_deg_c = temperature;
return 0;
}
static int pdus_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *value)
{
struct pdus_data *data = dev->data;
if (chan == SENSOR_CHAN_PRESS) {
value->val1 = (int32_t)data->pressure_k_pa;
value->val2 = (((int32_t)(data->pressure_k_pa * 1000)) % 1000) * 1000;
} else if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
value->val1 = (int32_t)data->temperature_deg_c;
value->val2 =
(((int32_t)(data->temperature_deg_c * 1000)) % 1000) * 1000;
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api pdus_driver_api = { .sample_fetch = pdus_sample_fetch,
.channel_get = pdus_channel_get };
static int pdus_init(const struct device *dev)
{
const struct pdus_config *const config = dev->config;
struct pdus_data *data = dev->data;
/* Initialize WE sensor interface */
PDUS_getDefaultInterface(&data->sensor_interface);
data->sensor_interface.interfaceType = WE_i2c;
switch (data->sensor_interface.interfaceType) {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
case WE_i2c:
data->sensor_interface.handle = (void *)&config->bus_cfg.i2c;
break;
#endif
default:
LOG_ERR("Invalid interface type");
return -EINVAL;
}
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "PDUS driver enabled without any devices"
#endif
/*
* Main instantiation macro.
*/
#define PDUS_DEFINE(inst) \
static struct pdus_data pdus_data_##inst; \
static const struct pdus_config pdus_config_##inst = \
{ \
.bus_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
.sensor_type = (PDUS_SensorType_t) DT_INST_ENUM_IDX(inst, sensor_type) \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
pdus_init, \
NULL, \
&pdus_data_##inst, \
&pdus_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&pdus_driver_api);
DT_INST_FOREACH_STATUS_OKAY(PDUS_DEFINE)
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_pdus/wsen_pdus.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 756 |
```unknown
config BD8LB600FS_DIAGNOSTICS
bool "Sensors of BD8LB600FS"
default y
depends on DT_HAS_ROHM_BD8LB600FS_DIAGNOSTICS_ENABLED
select MFD
help
Enable driver for the open load detection, over current
protection and thermal shutdown sensors of the low side
switch BD8LB600FS.
``` | /content/code_sandbox/drivers/sensor/rohm/bd8lb600fs/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 83 |
```c
/*
*
*/
#define DT_DRV_COMPAT rohm_bd8lb600fs_diagnostics
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/mfd/bd8lb600fs.h>
#include <zephyr/drivers/sensor/bd8lb600fs.h>
#include <zephyr/logging/log.h>
#include "bd8lb600fs_diagnostics.h"
LOG_MODULE_REGISTER(BD8LB600FS_DIAGNOSTICS, CONFIG_SENSOR_LOG_LEVEL);
static int bd8lb600fs_diagnostics_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct bd8lb600fs_diagnostics_config *config = dev->config;
struct bd8lb600fs_diagnostics_data *data = dev->data;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
return mfd_bd8lb600fs_get_output_diagnostics(config->parent_dev, &data->old,
&data->ocp_or_tsd);
}
static int bd8lb600fs_diagnostics_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct bd8lb600fs_diagnostics_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_BD8LB600FS_OPEN_LOAD:
val->val1 = data->old;
val->val2 = 0;
return 0;
case SENSOR_CHAN_BD8LB600FS_OVER_CURRENT_OR_THERMAL_SHUTDOWN:
val->val1 = data->ocp_or_tsd;
val->val2 = 0;
return 0;
default:
LOG_ERR("%s: requesting unsupported channel %i", dev->name, chan);
return -ENOTSUP;
}
}
static const struct sensor_driver_api bd8lb600fs_diagnostics_driver_api = {
.sample_fetch = bd8lb600fs_diagnostics_sample_fetch,
.channel_get = bd8lb600fs_diagnostics_channel_get,
};
static int bd8lb600fs_diagnostics_init(const struct device *dev)
{
const struct bd8lb600fs_diagnostics_config *config = dev->config;
if (!device_is_ready(config->parent_dev)) {
LOG_ERR("%s: parent device is not ready", dev->name);
return -ENODEV;
}
return 0;
}
#define BD8LB600FS_DIAGNOSTICS_DEFINE(inst) \
static struct bd8lb600fs_diagnostics_data bd8lb600fs_diagnostics_data_##inst; \
\
static const struct bd8lb600fs_diagnostics_config bd8lb600fs_diagnostics_config_##inst = { \
.parent_dev = DEVICE_DT_GET(DT_PARENT(DT_DRV_INST(inst))), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE( \
inst, bd8lb600fs_diagnostics_init, NULL, &bd8lb600fs_diagnostics_data_##inst, \
&bd8lb600fs_diagnostics_config_##inst, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&bd8lb600fs_diagnostics_driver_api);
DT_INST_FOREACH_STATUS_OKAY(BD8LB600FS_DIAGNOSTICS_DEFINE)
``` | /content/code_sandbox/drivers/sensor/rohm/bd8lb600fs/bd8lb600fs_diagnostics.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 666 |
```unknown
# BH1750 ambient light sensor configuration options
config BH1750
bool "BH1750 ambient light sensor"
default y
depends on DT_HAS_ROHM_BH1750_ENABLED
select I2C
help
Enable driver for BH1750 ambient light sensor.
``` | /content/code_sandbox/drivers/sensor/rohm/bh1750/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 59 |
```c
/*
*
*/
#define DT_DRV_COMPAT rohm_bh1750
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <zephyr/devicetree.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
LOG_MODULE_REGISTER(BH1750, CONFIG_SENSOR_LOG_LEVEL);
#define BH1750_CONTINUOUS_HIGH_RES_MODE 0x10
#define BH1750_CONTINUOUS_HIGH_RES_MODE_2 0x11
#define BH1750_CONTINUOUS_LOW_RES_MODE 0x13
#define BH1750_ONE_TIME_HIGH_RES_MODE 0x20
#define BH1750_ONE_TIME_HIGH_RES_MODE_2 0x21
#define BH1750_ONE_TIME_LOW_RES_MODE 0x23
#define BH1750_MTREG_HIGH_BYTE 0x40
#define BH1750_MTREG_LOW_BYTE 0x60
#define BH1750_MTREG_HIGH_BYTE_MASK 0xE0
#define BH1750_MTREG_LOW_BYTE_MASK 0x1F
#define BH1750_DEFAULT_MTREG 69U
#define BH1750_LOW_RES_MODE_MAX_WAIT 24U
#define BH1750_HIGH_RES_MODE_MAX_WAIT 180U
#define BH1750_LOW_RES_MODE_TYPICAL_WAIT 16U
#define BH1750_HIGH_RES_MODE_TYPICAL_WAIT 120U
#define BH1750_LOW_RES_DTS_ENUM 0U
#define BH1750_HIGH_RES_DTS_ENUM 1U
#define BH1750_HIGH_RES_2_DTS_ENUM 2U
struct bh1750_dev_config {
struct i2c_dt_spec bus;
uint8_t resolution;
uint8_t mtreg;
};
struct bh1750_data {
uint16_t sample;
};
static int bh1750_opcode_read(const struct device *dev, uint8_t opcode,
uint16_t *val)
{
const struct bh1750_dev_config *cfg = dev->config;
int rc;
rc = i2c_burst_read_dt(&cfg->bus, opcode, (uint8_t *)val, 2);
if (rc < 0) {
return rc;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
static int bh1750_opcode_write(const struct device *dev, uint8_t opcode)
{
const struct bh1750_dev_config *cfg = dev->config;
return i2c_write_dt(&cfg->bus, &opcode, 1);
}
static int bh1750_mtreg_write(const struct device *dev, uint8_t mtreg)
{
int rc;
uint8_t high_byte = mtreg & BH1750_MTREG_HIGH_BYTE_MASK;
uint8_t low_byte = mtreg & BH1750_MTREG_LOW_BYTE_MASK;
rc = bh1750_opcode_write(dev, BH1750_MTREG_HIGH_BYTE | (high_byte >> 5));
if (rc < 0) {
LOG_ERR("%s, Failed to write high byte of mtreg!",
dev->name);
return rc;
}
rc = bh1750_opcode_write(dev, BH1750_MTREG_LOW_BYTE | low_byte);
if (rc < 0) {
LOG_ERR("%s, Failed to write low byte of mtreg!",
dev->name);
return rc;
}
return 0;
}
static uint8_t bh1750_get_mode_from_dts_device(const struct device *dev)
{
const struct bh1750_dev_config *cfg = dev->config;
if (cfg->resolution == BH1750_HIGH_RES_2_DTS_ENUM) {
return BH1750_ONE_TIME_HIGH_RES_MODE_2;
} else if (cfg->resolution == BH1750_HIGH_RES_DTS_ENUM) {
return BH1750_ONE_TIME_HIGH_RES_MODE;
} else {
return BH1750_ONE_TIME_LOW_RES_MODE;
}
}
static int bh1750_get_wait_time_from_dts_device(const struct device *dev)
{
const struct bh1750_dev_config *cfg = dev->config;
if (cfg->resolution == BH1750_HIGH_RES_2_DTS_ENUM) {
return BH1750_HIGH_RES_MODE_MAX_WAIT;
} else if (cfg->resolution == BH1750_HIGH_RES_DTS_ENUM) {
return BH1750_HIGH_RES_MODE_MAX_WAIT;
} else {
return BH1750_LOW_RES_MODE_MAX_WAIT;
}
}
static int bh1750_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct bh1750_dev_config *cfg = dev->config;
struct bh1750_data *drv_data = dev->data;
const int max_wait = bh1750_get_wait_time_from_dts_device(dev);
const uint8_t mode = bh1750_get_mode_from_dts_device(dev);
int rc;
int wait_time;
if (chan != SENSOR_CHAN_ALL &&
chan != SENSOR_CHAN_LIGHT) {
return -ENOTSUP;
}
/* Start the measurement */
rc = bh1750_opcode_write(dev, mode);
if (rc < 0) {
LOG_ERR("%s, Failed to start measurement!",
dev->name);
return rc;
}
/* Calculate measurement time */
wait_time = (max_wait * (cfg->mtreg * 10000 / BH1750_DEFAULT_MTREG)) / 10000;
/* Wait for the measurement to be stored in the sensor memory */
k_msleep(wait_time);
/* Fetch result */
rc = bh1750_opcode_read(dev, mode, &drv_data->sample);
if (rc < 0) {
LOG_ERR("%s: Failed to read measurement result!",
dev->name);
return rc;
}
return 0;
}
static int bh1750_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct bh1750_dev_config *cfg = dev->config;
struct bh1750_data *drv_data = dev->data;
uint32_t tmp;
if (chan != SENSOR_CHAN_ALL &&
chan != SENSOR_CHAN_LIGHT) {
return -ENOTSUP;
}
/* See datasheet (Technical note 11046EDT01), page 11
* path_to_url
* for more information how to convert raw sample to lx
*/
tmp = (drv_data->sample * 1000 / 12) * (BH1750_DEFAULT_MTREG * 100 / cfg->mtreg);
if (cfg->resolution == BH1750_HIGH_RES_2_DTS_ENUM) {
tmp /= 2;
}
val->val1 = tmp / 10000;
val->val2 = (tmp % 10000) * 100;
return 0;
}
static const struct sensor_driver_api bh1750_driver_api = {
.sample_fetch = bh1750_sample_fetch,
.channel_get = bh1750_channel_get
};
static int bh1750_init(const struct device *dev)
{
const struct bh1750_dev_config *cfg = dev->config;
if (!device_is_ready(cfg->bus.bus)) {
LOG_ERR("I2C dev %s not ready", cfg->bus.bus->name);
return -ENODEV;
}
if (cfg->mtreg != BH1750_DEFAULT_MTREG) {
bh1750_mtreg_write(dev, cfg->mtreg);
}
return 0;
}
#define DEFINE_BH1750(_num) \
static struct bh1750_data bh1750_data_##_num; \
static const struct bh1750_dev_config bh1750_config_##_num = { \
.bus = I2C_DT_SPEC_INST_GET(_num), \
.mtreg = DT_INST_PROP(_num, mtreg), \
.resolution = DT_INST_PROP(_num, resolution) \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(_num, bh1750_init, NULL, \
&bh1750_data_##_num, &bh1750_config_##_num, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &bh1750_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_BH1750)
``` | /content/code_sandbox/drivers/sensor/rohm/bh1750/bh1750.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,747 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/adi/adltc2990/Kconfig"
source "drivers/sensor/adi/adt7310/Kconfig"
source "drivers/sensor/adi/adt7420/Kconfig"
source "drivers/sensor/adi/adxl345/Kconfig"
source "drivers/sensor/adi/adxl362/Kconfig"
source "drivers/sensor/adi/adxl367/Kconfig"
source "drivers/sensor/adi/adxl372/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/adi/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 117 |
```c
/* adxl372_i2c.c - I2C routines for ADXL372 driver
*/
/*
*
*/
#define DT_DRV_COMPAT adi_adxl372
#include <string.h>
#include <zephyr/logging/log.h>
#include "adxl372.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(ADXL372, CONFIG_SENSOR_LOG_LEVEL);
static int adxl372_bus_access(const struct device *dev, uint8_t reg,
void *data, size_t length)
{
const struct adxl372_dev_config *config = dev->config;
if (reg & ADXL372_READ) {
return i2c_burst_read_dt(&config->i2c,
ADXL372_TO_I2C_REG(reg),
(uint8_t *) data, length);
} else {
if (length != 1) {
return -EINVAL;
}
return i2c_reg_write_byte_dt(&config->i2c,
ADXL372_TO_I2C_REG(reg),
*(uint8_t *)data);
}
}
static int adxl372_i2c_reg_read(const struct device *dev, uint8_t reg_addr,
uint8_t *reg_data)
{
return adxl372_bus_access(dev, ADXL372_REG_READ(reg_addr), reg_data, 1);
}
static int adxl372_i2c_reg_read_multiple(const struct device *dev,
uint8_t reg_addr,
uint8_t *reg_data,
uint16_t count)
{
return adxl372_bus_access(dev, ADXL372_REG_READ(reg_addr),
reg_data, count);
}
static int adxl372_i2c_reg_write(const struct device *dev,
uint8_t reg_addr,
uint8_t reg_data)
{
return adxl372_bus_access(dev, ADXL372_REG_WRITE(reg_addr),
®_data, 1);
}
int adxl372_i2c_reg_write_mask(const struct device *dev,
uint8_t reg_addr,
uint32_t mask,
uint8_t data)
{
int ret;
uint8_t tmp;
ret = adxl372_i2c_reg_read(dev, reg_addr, &tmp);
if (ret) {
return ret;
}
tmp &= ~mask;
tmp |= data;
return adxl372_i2c_reg_write(dev, reg_addr, tmp);
}
static const struct adxl372_transfer_function adxl372_i2c_transfer_fn = {
.read_reg_multiple = adxl372_i2c_reg_read_multiple,
.write_reg = adxl372_i2c_reg_write,
.read_reg = adxl372_i2c_reg_read,
.write_reg_mask = adxl372_i2c_reg_write_mask,
};
int adxl372_i2c_init(const struct device *dev)
{
struct adxl372_data *data = dev->data;
const struct adxl372_dev_config *config = dev->config;
data->hw_tf = &adxl372_i2c_transfer_fn;
if (!device_is_ready(config->i2c.bus)) {
return -ENODEV;
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/adi/adxl372/adxl372_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 673 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADXL372_ADXL372_H_
#define ZEPHYR_DRIVERS_SENSOR_ADXL372_ADXL372_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.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) */
/*
* ADXL372 registers definition
*/
#define ADXL372_DEVID 0x00u /* Analog Devices accelerometer ID */
#define ADXL372_DEVID_MST 0x01u /* Analog Devices MEMS device ID */
#define ADXL372_PARTID 0x02u /* Device ID */
#define ADXL372_REVID 0x03u /* product revision ID*/
#define ADXL372_STATUS_1 0x04u /* Status register 1 */
#define ADXL372_STATUS_2 0x05u /* Status register 2 */
#define ADXL372_FIFO_ENTRIES_2 0x06u /* Valid data samples in the FIFO */
#define ADXL372_FIFO_ENTRIES_1 0x07u /* Valid data samples in the FIFO */
#define ADXL372_X_DATA_H 0x08u /* X-axis acceleration data [11:4] */
#define ADXL372_X_DATA_L 0x09u /* X-axis acceleration data [3:0] */
#define ADXL372_Y_DATA_H 0x0Au /* Y-axis acceleration data [11:4] */
#define ADXL372_Y_DATA_L 0x0Bu /* Y-axis acceleration data [3:0] */
#define ADXL372_Z_DATA_H 0x0Cu /* Z-axis acceleration data [11:4] */
#define ADXL372_Z_DATA_L 0x0Du /* Z-axis acceleration data [3:0] */
#define ADXL372_X_MAXPEAK_H 0x15u /* X-axis MaxPeak acceleration data */
#define ADXL372_X_MAXPEAK_L 0x16u /* X-axis MaxPeak acceleration data */
#define ADXL372_Y_MAXPEAK_H 0x17u /* Y-axis MaxPeak acceleration data */
#define ADXL372_Y_MAXPEAK_L 0x18u /* Y-axis MaxPeak acceleration data */
#define ADXL372_Z_MAXPEAK_H 0x19u /* Z-axis MaxPeak acceleration data */
#define ADXL372_Z_MAXPEAK_L 0x1Au /* Z-axis MaxPeak acceleration data */
#define ADXL372_OFFSET_X 0x20u /* X axis offset */
#define ADXL372_OFFSET_Y 0x21u /* Y axis offset */
#define ADXL372_OFFSET_Z 0x22u /* Z axis offset */
#define ADXL372_X_THRESH_ACT_H 0x23u /* X axis Activity Threshold [15:8] */
#define ADXL372_X_THRESH_ACT_L 0x24u /* X axis Activity Threshold [7:0] */
#define ADXL372_Y_THRESH_ACT_H 0x25u /* Y axis Activity Threshold [15:8] */
#define ADXL372_Y_THRESH_ACT_L 0x26u /* Y axis Activity Threshold [7:0] */
#define ADXL372_Z_THRESH_ACT_H 0x27u /* Z axis Activity Threshold [15:8] */
#define ADXL372_Z_THRESH_ACT_L 0x28u /* Z axis Activity Threshold [7:0] */
#define ADXL372_TIME_ACT 0x29u /* Activity Time */
#define ADXL372_X_THRESH_INACT_H 0x2Au /* X axis Inactivity Threshold */
#define ADXL372_X_THRESH_INACT_L 0x2Bu /* X axis Inactivity Threshold */
#define ADXL372_Y_THRESH_INACT_H 0x2Cu /* Y axis Inactivity Threshold */
#define ADXL372_Y_THRESH_INACT_L 0x2Du /* Y axis Inactivity Threshold */
#define ADXL372_Z_THRESH_INACT_H 0x2Eu /* Z axis Inactivity Threshold */
#define ADXL372_Z_THRESH_INACT_L 0x2Fu /* Z axis Inactivity Threshold */
#define ADXL372_TIME_INACT_H 0x30u /* Inactivity Time [15:8] */
#define ADXL372_TIME_INACT_L 0x31u /* Inactivity Time [7:0] */
#define ADXL372_X_THRESH_ACT2_H 0x32u /* X axis Activity2 Threshold [15:8] */
#define ADXL372_X_THRESH_ACT2_L 0x33u /* X axis Activity2 Threshold [7:0] */
#define ADXL372_Y_THRESH_ACT2_H 0x34u /* Y axis Activity2 Threshold [15:8] */
#define ADXL372_Y_THRESH_ACT2_L 0x35u /* Y axis Activity2 Threshold [7:0] */
#define ADXL372_Z_THRESH_ACT2_H 0x36u /* Z axis Activity2 Threshold [15:8] */
#define ADXL372_Z_THRESH_ACT2_L 0x37u /* Z axis Activity2 Threshold [7:0] */
#define ADXL372_HPF 0x38u /* High Pass Filter */
#define ADXL372_FIFO_SAMPLES 0x39u /* FIFO Samples */
#define ADXL372_FIFO_CTL 0x3Au /* FIFO Control */
#define ADXL372_INT1_MAP 0x3Bu /* Interrupt 1 mapping control */
#define ADXL372_INT2_MAP 0x3Cu /* Interrupt 2 mapping control */
#define ADXL372_TIMING 0x3Du /* Timing */
#define ADXL372_MEASURE 0x3Eu /* Measure */
#define ADXL372_POWER_CTL 0x3Fu /* Power control */
#define ADXL372_SELF_TEST 0x40u /* Self Test */
#define ADXL372_RESET 0x41u /* Reset */
#define ADXL372_FIFO_DATA 0x42u /* FIFO Data */
#define ADXL372_DEVID_VAL 0xADu /* Analog Devices accelerometer ID */
#define ADXL372_MST_DEVID_VAL 0x1Du /* Analog Devices MEMS device ID */
#define ADXL372_PARTID_VAL 0xFAu /* Device ID */
#define ADXL372_REVID_VAL 0x02u /* product revision ID*/
#define ADXL372_RESET_CODE 0x52u /* Writing code 0x52 resets the device */
#define ADXL372_READ 0x01u
#define ADXL372_REG_READ(x) (((x & 0xFF) << 1) | ADXL372_READ)
#define ADXL372_REG_WRITE(x) ((x & 0xFF) << 1)
#define ADXL372_TO_I2C_REG(x) ((x) >> 1)
/* ADXL372_POWER_CTL */
#define ADXL372_POWER_CTL_INSTANT_ON_TH_MSK BIT(5)
#define ADXL372_POWER_CTL_INSTANT_ON_TH_MODE(x) (((x) & 0x1) << 5)
#define ADXL372_POWER_CTL_FIL_SETTLE_MSK BIT(4)
#define ADXL372_POWER_CTL_FIL_SETTLE_MODE(x) (((x) & 0x1) << 4)
#define ADXL372_POWER_CTL_LPF_DIS_MSK BIT(3)
#define ADXL372_POWER_CTL_LPF_DIS_MODE(x) (((x) & 0x1) << 3)
#define ADXL372_POWER_CTL_HPF_DIS_MSK BIT(2)
#define ADXL372_POWER_CTL_HPF_DIS_MODE(x) (((x) & 0x1) << 2)
#define ADXL372_POWER_CTL_MODE_MSK GENMASK(1, 0)
#define ADXL372_POWER_CTL_MODE(x) (((x) & 0x3) << 0)
/* ADXL372_MEASURE */
#define ADXL372_MEASURE_AUTOSLEEP_MSK BIT(6)
#define ADXL372_MEASURE_AUTOSLEEP_MODE(x) (((x) & 0x1) << 6)
#define ADXL372_MEASURE_LINKLOOP_MSK GENMASK(5, 4)
#define ADXL372_MEASURE_LINKLOOP_MODE(x) (((x) & 0x3) << 4)
#define ADXL372_MEASURE_LOW_NOISE_MSK BIT(3)
#define ADXL372_MEASURE_LOW_NOISE_MODE(x) (((x) & 0x1) << 3)
#define ADXL372_MEASURE_BANDWIDTH_MSK GENMASK(2, 0)
#define ADXL372_MEASURE_BANDWIDTH_MODE(x) (((x) & 0x7) << 0)
/* ADXL372_TIMING */
#define ADXL372_TIMING_ODR_MSK GENMASK(7, 5)
#define ADXL372_TIMING_ODR_MODE(x) (((x) & 0x7) << 5)
#define ADXL372_TIMING_WAKE_UP_RATE_MSK GENMASK(4, 2)
#define ADXL372_TIMING_WAKE_UP_RATE_MODE(x) (((x) & 0x7) << 2)
#define ADXL372_TIMING_EXT_CLK_MSK BIT(1)
#define ADXL372_TIMING_EXT_CLK_MODE(x) (((x) & 0x1) << 1)
#define ADXL372_TIMING_EXT_SYNC_MSK BIT(0)
#define ADXL372_TIMING_EXT_SYNC_MODE(x) (((x) & 0x1) << 0)
/* ADXL372_FIFO_CTL */
#define ADXL372_FIFO_CTL_FORMAT_MSK GENMASK(5, 3)
#define ADXL372_FIFO_CTL_FORMAT_MODE(x) (((x) & 0x7) << 3)
#define ADXL372_FIFO_CTL_MODE_MSK GENMASK(2, 1)
#define ADXL372_FIFO_CTL_MODE_MODE(x) (((x) & 0x3) << 1)
#define ADXL372_FIFO_CTL_SAMPLES_MSK BIT(0)
#define ADXL372_FIFO_CTL_SAMPLES_MODE(x) (((x) > 0xFF) ? 1 : 0)
/* ADXL372_STATUS_1 */
#define ADXL372_STATUS_1_DATA_RDY(x) (((x) >> 0) & 0x1)
#define ADXL372_STATUS_1_FIFO_RDY(x) (((x) >> 1) & 0x1)
#define ADXL372_STATUS_1_FIFO_FULL(x) (((x) >> 2) & 0x1)
#define ADXL372_STATUS_1_FIFO_OVR(x) (((x) >> 3) & 0x1)
#define ADXL372_STATUS_1_USR_NVM_BUSY(x) (((x) >> 5) & 0x1)
#define ADXL372_STATUS_1_AWAKE(x) (((x) >> 6) & 0x1)
#define ADXL372_STATUS_1_ERR_USR_REGS(x) (((x) >> 7) & 0x1)
/* ADXL372_STATUS_2 */
#define ADXL372_STATUS_2_INACT(x) (((x) >> 4) & 0x1)
#define ADXL372_STATUS_2_ACTIVITY(x) (((x) >> 5) & 0x1)
#define ADXL372_STATUS_2_ACTIVITY2(x) (((x) >> 6) & 0x1)
/* ADXL372_INT1_MAP */
#define ADXL372_INT1_MAP_DATA_RDY_MSK BIT(0)
#define ADXL372_INT1_MAP_DATA_RDY_MODE(x) (((x) & 0x1) << 0)
#define ADXL372_INT1_MAP_FIFO_RDY_MSK BIT(1)
#define ADXL372_INT1_MAP_FIFO_RDY_MODE(x) (((x) & 0x1) << 1)
#define ADXL372_INT1_MAP_FIFO_FULL_MSK BIT(2)
#define ADXL372_INT1_MAP_FIFO_FULL_MODE(x) (((x) & 0x1) << 2)
#define ADXL372_INT1_MAP_FIFO_OVR_MSK BIT(3)
#define ADXL372_INT1_MAP_FIFO_OVR_MODE(x) (((x) & 0x1) << 3)
#define ADXL372_INT1_MAP_INACT_MSK BIT(4)
#define ADXL372_INT1_MAP_INACT_MODE(x) (((x) & 0x1) << 4)
#define ADXL372_INT1_MAP_ACT_MSK BIT(5)
#define ADXL372_INT1_MAP_ACT_MODE(x) (((x) & 0x1) << 5)
#define ADXL372_INT1_MAP_AWAKE_MSK BIT(6)
#define ADXL372_INT1_MAP_AWAKE_MODE(x) (((x) & 0x1) << 6)
#define ADXL372_INT1_MAP_LOW_MSK BIT(7)
#define ADXL372_INT1_MAP_LOW_MODE(x) (((x) & 0x1) << 7)
/* ADXL372_INT2_MAP */
#define ADXL372_INT2_MAP_DATA_RDY_MSK BIT(0)
#define ADXL372_INT2_MAP_DATA_RDY_MODE(x) (((x) & 0x1) << 0)
#define ADXL372_INT2_MAP_FIFO_RDY_MSK BIT(1)
#define ADXL372_INT2_MAP_FIFO_RDY_MODE(x) (((x) & 0x1) << 1)
#define ADXL372_INT2_MAP_FIFO_FULL_MSK BIT(2)
#define ADXL372_INT2_MAP_FIFO_FULL_MODE(x) (((x) & 0x1) << 2)
#define ADXL372_INT2_MAP_FIFO_OVR_MSK BIT(3)
#define ADXL372_INT2_MAP_FIFO_OVR_MODE(x) (((x) & 0x1) << 3)
#define ADXL372_INT2_MAP_INACT_MSK BIT(4)
#define ADXL372_INT2_MAP_INACT_MODE(x) (((x) & 0x1) << 4)
#define ADXL372_INT2_MAP_ACT_MSK BIT(5)
#define ADXL372_INT2_MAP_ACT_MODE(x) (((x) & 0x1) << 5)
#define ADXL372_INT2_MAP_AWAKE_MSK BIT(6)
#define ADXL372_INT2_MAP_AWAKE_MODE(x) (((x) & 0x1) << 6)
#define ADXL372_INT2_MAP_LOW_MSK BIT(7)
#define ADXL372_INT2_MAP_LOW_MODE(x) (((x) & 0x1) << 7)
/* ADXL372_HPF */
#define ADXL372_HPF_CORNER(x) (((x) & 0x3) << 0)
enum adxl372_axis {
ADXL372_X_AXIS,
ADXL372_Y_AXIS,
ADXL372_Z_AXIS
};
enum adxl372_op_mode {
ADXL372_STANDBY,
ADXL372_WAKE_UP,
ADXL372_INSTANT_ON,
ADXL372_FULL_BW_MEASUREMENT
};
enum adxl372_bandwidth {
ADXL372_BW_200HZ,
ADXL372_BW_400HZ,
ADXL372_BW_800HZ,
ADXL372_BW_1600HZ,
ADXL372_BW_3200HZ,
ADXL372_BW_LPF_DISABLED = 0xC,
};
enum adxl372_hpf_corner {
ADXL372_HPF_CORNER_0,
ADXL372_HPF_CORNER_1,
ADXL372_HPF_CORNER_2,
ADXL372_HPF_CORNER_3,
ADXL372_HPF_DISABLED,
};
enum adxl372_act_proc_mode {
ADXL372_DEFAULT,
ADXL372_LINKED,
ADXL372_LOOPED
};
enum adxl372_odr {
ADXL372_ODR_400HZ,
ADXL372_ODR_800HZ,
ADXL372_ODR_1600HZ,
ADXL372_ODR_3200HZ,
ADXL372_ODR_6400HZ
};
enum adxl372_instant_on_th_mode {
ADXL372_INSTANT_ON_LOW_TH,
ADXL372_INSTANT_ON_HIGH_TH
};
enum adxl372_wakeup_rate {
ADXL372_WUR_52ms,
ADXL372_WUR_104ms,
ADXL372_WUR_208ms,
ADXL372_WUR_512ms,
ADXL372_WUR_2048ms,
ADXL372_WUR_4096ms,
ADXL372_WUR_8192ms,
ADXL372_WUR_24576ms
};
enum adxl372_filter_settle {
ADXL372_FILTER_SETTLE_370,
ADXL372_FILTER_SETTLE_16
};
enum adxl372_fifo_format {
ADXL372_XYZ_FIFO,
ADXL372_X_FIFO,
ADXL372_Y_FIFO,
ADXL372_XY_FIFO,
ADXL372_Z_FIFO,
ADXL372_XZ_FIFO,
ADXL372_YZ_FIFO,
ADXL372_XYZ_PEAK_FIFO,
};
enum adxl372_fifo_mode {
ADXL372_FIFO_BYPASSED,
ADXL372_FIFO_STREAMED,
ADXL372_FIFO_TRIGGERED,
ADXL372_FIFO_OLD_SAVED
};
struct adxl372_fifo_config {
enum adxl372_fifo_mode fifo_mode;
enum adxl372_fifo_format fifo_format;
uint16_t fifo_samples;
};
struct adxl372_activity_threshold {
uint16_t thresh;
bool referenced;
bool enable;
};
struct adxl372_xyz_accel_data {
int16_t x;
int16_t y;
int16_t z;
};
struct adxl372_transfer_function {
int (*read_reg_multiple)(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint16_t len);
int (*write_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t value);
int (*read_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t *value);
int (*write_reg_mask)(const struct device *dev, uint8_t reg_addr,
uint32_t mask, uint8_t value);
};
struct adxl372_data {
struct adxl372_xyz_accel_data sample;
const struct adxl372_transfer_function *hw_tf;
struct adxl372_fifo_config fifo_config;
enum adxl372_act_proc_mode act_proc_mode;
#ifdef CONFIG_ADXL372_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t th_handler;
const struct sensor_trigger *th_trigger;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trigger;
const struct device *dev;
#if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADXL372_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_ADXL372_TRIGGER */
};
struct adxl372_dev_config {
#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
int (*bus_init)(const struct device *dev);
#ifdef CONFIG_ADXL372_TRIGGER
struct gpio_dt_spec interrupt;
#endif
enum adxl372_bandwidth bw;
enum adxl372_hpf_corner hpf;
enum adxl372_odr odr;
bool max_peak_detect_mode;
/* Device Settings */
bool autosleep;
struct adxl372_activity_threshold activity_th;
struct adxl372_activity_threshold activity2_th;
struct adxl372_activity_threshold inactivity_th;
struct adxl372_fifo_config fifo_config;
enum adxl372_wakeup_rate wur;
enum adxl372_instant_on_th_mode th_mode;
enum adxl372_filter_settle filter_settle;
enum adxl372_op_mode op_mode;
uint16_t inactivity_time;
uint8_t activity_time;
uint8_t int1_config;
uint8_t int2_config;
};
int adxl372_spi_init(const struct device *dev);
int adxl372_i2c_init(const struct device *dev);
#ifdef CONFIG_ADXL372_TRIGGER
int adxl372_get_status(const struct device *dev,
uint8_t *status1, uint8_t *status2, uint16_t *fifo_entries);
int adxl372_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int adxl372_init_interrupt(const struct device *dev);
#endif /* CONFIG_ADXL372_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_ADXL372_ADXL372_H_ */
``` | /content/code_sandbox/drivers/sensor/adi/adxl372/adxl372.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,529 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adxl372
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <string.h>
#include <zephyr/init.h>
#include <zephyr/sys/printk.h>
#include <zephyr/sys/__assert.h>
#include <stdlib.h>
#include <zephyr/logging/log.h>
#include "adxl372.h"
LOG_MODULE_REGISTER(ADXL372, CONFIG_SENSOR_LOG_LEVEL);
/**
* Set the threshold for activity detection for a single axis
* @param dev - The device structure.
* @param axis_reg_h - The high part of the activity register.
* @param act - The activity config structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_activity_threshold(const struct device *dev,
uint8_t axis_reg_h,
const struct adxl372_activity_threshold *act)
{
int ret;
uint8_t val;
struct adxl372_data *data = dev->data;
ret = data->hw_tf->write_reg(dev, axis_reg_h++, act->thresh >> 3);
if (ret) {
return ret;
}
switch (axis_reg_h) {
case ADXL372_X_THRESH_ACT_L:
case ADXL372_X_THRESH_INACT_L:
case ADXL372_X_THRESH_ACT2_L:
val = (act->thresh << 5) | (act->referenced << 1) | act->enable;
break;
default:
val = (act->thresh << 5) | act->enable;
}
return data->hw_tf->write_reg(dev, axis_reg_h, val);
}
/**
* Set the threshold for activity detection for all 3-axis
* @param dev - The device structure.
* @param axis_reg_h - The high part of the activity register.
* @param act - The activity config structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_activity_threshold_xyz(const struct device *dev,
uint8_t axis_reg_h,
const struct adxl372_activity_threshold *act)
{
int i, ret;
for (i = 0; i < 3; i++) {
ret = adxl372_set_activity_threshold(dev, axis_reg_h, act);
if (ret) {
return ret;
}
axis_reg_h += 2U;
}
return 0;
}
/**
* Set the mode of operation.
* @param dev - The device structure.
* @param op_mode - Mode of operation.
* Accepted values: ADXL372_STANDBY
* ADXL372_WAKE_UP
* ADXL372_INSTANT_ON
* ADXL372_FULL_BW_MEASUREMENT
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_op_mode(const struct device *dev,
enum adxl372_op_mode op_mode)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL372_POWER_CTL,
ADXL372_POWER_CTL_MODE_MSK,
ADXL372_POWER_CTL_MODE(op_mode));
}
/**
* Autosleep. When set to 1, autosleep is enabled, and the device enters
* wake-up mode automatically upon detection of inactivity.
* @param dev - The device structure.
* @param enable - Accepted values: true
* false
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_autosleep(const struct device *dev, bool enable)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL372_MEASURE,
ADXL372_MEASURE_AUTOSLEEP_MSK,
ADXL372_MEASURE_AUTOSLEEP_MODE(enable));
}
/**
* Select the desired output signal bandwidth.
* @param dev - The device structure.
* @param bw - bandwidth.
* Accepted values: ADXL372_BW_200HZ
* ADXL372_BW_400HZ
* ADXL372_BW_800HZ
* ADXL372_BW_1600HZ
* ADXL372_BW_3200HZ
* ADXL372_BW_LPF_DISABLED
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_bandwidth(const struct device *dev,
enum adxl372_bandwidth bw)
{
int ret;
uint8_t mask;
struct adxl372_data *data = dev->data;
if (bw == ADXL372_BW_LPF_DISABLED) {
mask = ADXL372_POWER_CTL_LPF_DIS_MSK;
} else {
mask = 0U;
}
ret = data->hw_tf->write_reg_mask(dev, ADXL372_POWER_CTL,
ADXL372_POWER_CTL_LPF_DIS_MSK, mask);
if (ret) {
return ret;
}
return data->hw_tf->write_reg_mask(dev, ADXL372_MEASURE,
ADXL372_MEASURE_BANDWIDTH_MSK,
ADXL372_MEASURE_BANDWIDTH_MODE(bw));
}
/**
* Select the desired high-pass filter corner.
* @param dev - The device structure.
* @param c - bandwidth.
* Accepted values: ADXL372_HPF_CORNER_0
* ADXL372_HPF_CORNER_1
* ADXL372_HPF_CORNER_2
* ADXL372_HPF_CORNER_3
* ADXL372_HPF_DISABLED
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_hpf_corner(const struct device *dev,
enum adxl372_hpf_corner c)
{
int ret;
uint8_t mask;
struct adxl372_data *data = dev->data;
if (c == ADXL372_HPF_DISABLED) {
mask = ADXL372_POWER_CTL_HPF_DIS_MSK;
} else {
mask = 0U;
}
ret = data->hw_tf->write_reg_mask(dev, ADXL372_POWER_CTL,
ADXL372_POWER_CTL_HPF_DIS_MSK, mask);
if (ret) {
return ret;
}
return data->hw_tf->write_reg(dev, ADXL372_HPF, ADXL372_HPF_CORNER(c));
}
/**
* Link/Loop Activity Processing.
* @param dev - The device structure.
* @param mode - Mode of operation.
* Accepted values: ADXL372_DEFAULT
* ADXL372_LINKED
* ADXL372_LOOPED
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_act_proc_mode(const struct device *dev,
enum adxl372_act_proc_mode mode)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL372_MEASURE,
ADXL372_MEASURE_LINKLOOP_MSK,
ADXL372_MEASURE_LINKLOOP_MODE(mode));
}
/**
* Set Output data rate.
* @param dev - The device structure.
* @param odr - Output data rate.
* Accepted values: ADXL372_ODR_400HZ
* ADXL372_ODR_800HZ
* ADXL372_ODR_1600HZ
* ADXL372_ODR_3200HZ
* ADXL372_ODR_6400HZ
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_odr(const struct device *dev, enum adxl372_odr odr)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL372_TIMING,
ADXL372_TIMING_ODR_MSK,
ADXL372_TIMING_ODR_MODE(odr));
}
/**
* Select instant on threshold
* @param dev - The device structure.
* @param mode - 0 = low threshold, 1 = high threshold.
* Accepted values: ADXL372_INSTANT_ON_LOW_TH
* ADXL372_INSTANT_ON_HIGH_TH
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_instant_on_th(const struct device *dev,
enum adxl372_instant_on_th_mode mode)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL372_POWER_CTL,
ADXL372_POWER_CTL_INSTANT_ON_TH_MSK,
ADXL372_POWER_CTL_INSTANT_ON_TH_MODE(mode));
}
/**
* Set the Timer Rate for Wake-Up Mode.
* @param dev - The device structure.
* @param wur - wake up mode rate
* Accepted values: ADXL372_WUR_52ms
* ADXL372_WUR_104ms
* ADXL372_WUR_208ms
* ADXL372_WUR_512ms
* ADXL372_WUR_2048ms
* ADXL372_WUR_4096ms
* ADXL372_WUR_8192ms
* ADXL372_WUR_24576ms
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_wakeup_rate(const struct device *dev,
enum adxl372_wakeup_rate wur)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL372_TIMING,
ADXL372_TIMING_WAKE_UP_RATE_MSK,
ADXL372_TIMING_WAKE_UP_RATE_MODE(wur));
}
/**
* Set the activity timer
* @param dev - The device structure.
* @param time - The value set in this register.
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_activity_time(const struct device *dev, uint8_t time)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg(dev, ADXL372_TIME_ACT, time);
}
/**
* Set the inactivity timer
* @param dev - The device structure.
* @param time - is the 16-bit value set by the TIME_INACT_L register
* (eight LSBs) and the TIME_INACT_H register (eight MSBs).
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_inactivity_time(const struct device *dev,
uint16_t time)
{
int ret;
struct adxl372_data *data = dev->data;
ret = data->hw_tf->write_reg(dev, ADXL372_TIME_INACT_H, time >> 8);
if (ret) {
return ret;
}
return data->hw_tf->write_reg(dev, ADXL372_TIME_INACT_L, time & 0xFF);
}
/**
* Set the filter settling period.
* @param dev - The device structure.
* @param mode - settle period
* Accepted values: ADXL372_FILTER_SETTLE_370
* ADXL372_FILTER_SETTLE_16
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_set_filter_settle(const struct device *dev,
enum adxl372_filter_settle mode)
{
struct adxl372_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL372_POWER_CTL,
ADXL372_POWER_CTL_FIL_SETTLE_MSK,
ADXL372_POWER_CTL_FIL_SETTLE_MODE(mode));
}
/**
* Configure the INT1 and INT2 interrupt pins.
* @param dev - The device structure.
* @param int1 - INT1 interrupt pins.
* @param int2 - INT2 interrupt pins.
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_interrupt_config(const struct device *dev,
uint8_t int1,
uint8_t int2)
{
int ret;
struct adxl372_data *data = dev->data;
ret = data->hw_tf->write_reg(dev, ADXL372_INT1_MAP, int1);
if (ret) {
return ret;
}
return data->hw_tf->write_reg(dev, ADXL372_INT2_MAP, int2);
}
/**
* Get the STATUS, STATUS2, FIFO_ENTRIES and FIFO_ENTRIES2 registers data
* @param dev - The device structure.
* @param status1 - Data stored in the STATUS1 register
* @param status2 - Data stored in the STATUS2 register
* @param fifo_entries - Number of valid data samples present in the
* FIFO buffer (0 to 512)
* @return 0 in case of success, negative error code otherwise.
*/
int adxl372_get_status(const struct device *dev,
uint8_t *status1,
uint8_t *status2,
uint16_t *fifo_entries)
{
struct adxl372_data *data = dev->data;
uint8_t buf[4], length = 1U;
int ret;
if (status2) {
length++;
}
if (fifo_entries) {
length += 2U;
}
ret = data->hw_tf->read_reg_multiple(dev, ADXL372_STATUS_1, buf, length);
*status1 = buf[0];
if (status2) {
*status2 = buf[1];
}
if (fifo_entries) {
*fifo_entries = ((buf[2] & 0x3) << 8) | buf[3];
}
return ret;
}
/**
* Software reset.
* @param dev - The device structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_reset(const struct device *dev)
{
int ret;
struct adxl372_data *data = dev->data;
ret = adxl372_set_op_mode(dev, ADXL372_STANDBY);
if (ret) {
return ret;
}
/* Writing code 0x52 resets the device */
ret = data->hw_tf->write_reg(dev, ADXL372_RESET, ADXL372_RESET_CODE);
k_sleep(K_MSEC(1));
return ret;
}
/**
* Configure the operating parameters for the FIFO.
* @param dev - The device structure.
* @param mode - FIFO Mode. Specifies FIFO operating mode.
* Accepted values: ADXL372_FIFO_BYPASSED
* ADXL372_FIFO_STREAMED
* ADXL372_FIFO_TRIGGERED
* ADXL372_FIFO_OLD_SAVED
* @param format - FIFO Format. Specifies the data is stored in the FIFO buffer.
* Accepted values: ADXL372_XYZ_FIFO
* ADXL372_X_FIFO
* ADXL372_Y_FIFO
* ADXL372_XY_FIFO
* ADXL372_Z_FIFO
* ADXL372_XZ_FIFO
* ADXL372_YZ_FIFO
* ADXL372_XYZ_PEAK_FIFO
* @param fifo_samples - FIFO Samples. Watermark number of FIFO samples that
* triggers a FIFO_FULL condition when reached.
* Values range from 0 to 512.
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_configure_fifo(const struct device *dev,
enum adxl372_fifo_mode mode,
enum adxl372_fifo_format format,
uint16_t fifo_samples)
{
struct adxl372_data *data = dev->data;
uint8_t fifo_config;
int ret;
if (fifo_samples > 512) {
return -EINVAL;
}
/*
* All FIFO modes must be configured while in standby mode.
*/
ret = adxl372_set_op_mode(dev, ADXL372_STANDBY);
if (ret) {
return ret;
}
fifo_config = (ADXL372_FIFO_CTL_FORMAT_MODE(format) |
ADXL372_FIFO_CTL_MODE_MODE(mode) |
ADXL372_FIFO_CTL_SAMPLES_MODE(fifo_samples));
ret = data->hw_tf->write_reg(dev, ADXL372_FIFO_CTL, fifo_config);
if (ret) {
return ret;
}
ret = data->hw_tf->write_reg(dev, ADXL372_FIFO_SAMPLES, fifo_samples & 0xFF);
if (ret) {
return ret;
}
data->fifo_config.fifo_format = format;
data->fifo_config.fifo_mode = mode;
data->fifo_config.fifo_samples = fifo_samples;
return 0;
}
/**
* Retrieve 3-axis acceleration data
* @param dev - The device structure.
* @param maxpeak - Retrieve the highest magnitude (x, y, z) sample recorded
* since the last read of the MAXPEAK registers
* @param accel_data - pointer to a variable of type adxl372_xyz_accel_data
* where (x, y, z) acceleration data will be stored.
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl372_get_accel_data(const struct device *dev, bool maxpeak,
struct adxl372_xyz_accel_data *accel_data)
{
struct adxl372_data *data = dev->data;
uint8_t buf[6];
uint8_t status1;
int ret;
if (!IS_ENABLED(CONFIG_ADXL372_TRIGGER)) {
do {
adxl372_get_status(dev, &status1, NULL, NULL);
} while (!(ADXL372_STATUS_1_DATA_RDY(status1)));
}
ret = data->hw_tf->read_reg_multiple(dev, maxpeak ? ADXL372_X_MAXPEAK_H :
ADXL372_X_DATA_H, buf, 6);
accel_data->x = (buf[0] << 8) | (buf[1] & 0xF0);
accel_data->y = (buf[2] << 8) | (buf[3] & 0xF0);
accel_data->z = (buf[4] << 8) | (buf[5] & 0xF0);
return ret;
}
static int adxl372_attr_set_odr(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
enum adxl372_odr odr;
switch (val->val1) {
case 400:
odr = ADXL372_ODR_400HZ;
break;
case 800:
odr = ADXL372_ODR_800HZ;
break;
case 1600:
odr = ADXL372_ODR_1600HZ;
break;
case 3200:
odr = ADXL372_ODR_3200HZ;
break;
case 6400:
odr = ADXL372_ODR_6400HZ;
break;
default:
return -EINVAL;
}
return adxl372_set_odr(dev, odr);
}
static int adxl372_attr_set_thresh(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct adxl372_dev_config *cfg = dev->config;
struct adxl372_activity_threshold threshold;
int64_t llvalue;
int32_t value;
int64_t micro_ms2 = val->val1 * 1000000LL + val->val2;
uint8_t reg;
llvalue = llabs((micro_ms2 * 10) / SENSOR_G);
if (llvalue > 2047) {
return -EINVAL;
}
value = (int32_t) llvalue;
threshold.thresh = value;
threshold.enable = cfg->activity_th.enable;
threshold.referenced = cfg->activity_th.referenced;
if (attr == SENSOR_ATTR_UPPER_THRESH) {
reg = ADXL372_X_THRESH_ACT_H;
} else {
reg = ADXL372_X_THRESH_INACT_H;
}
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
return adxl372_set_activity_threshold(dev, reg, &threshold);
case SENSOR_CHAN_ACCEL_Y:
return adxl372_set_activity_threshold(dev, reg + 2, &threshold);
case SENSOR_CHAN_ACCEL_Z:
return adxl372_set_activity_threshold(dev, reg + 4, &threshold);
case SENSOR_CHAN_ACCEL_XYZ:
return adxl372_set_activity_threshold_xyz(dev, reg, &threshold);
default:
LOG_ERR("attr_set() not supported on this channel");
return -ENOTSUP;
}
}
static int adxl372_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return adxl372_attr_set_odr(dev, chan, attr, val);
case SENSOR_ATTR_UPPER_THRESH:
case SENSOR_ATTR_LOWER_THRESH:
return adxl372_attr_set_thresh(dev, chan, attr, val);
default:
return -ENOTSUP;
}
}
static int adxl372_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct adxl372_dev_config *cfg = dev->config;
struct adxl372_data *data = dev->data;
return adxl372_get_accel_data(dev, cfg->max_peak_detect_mode,
&data->sample);
}
static void adxl372_accel_convert(struct sensor_value *val, int16_t value)
{
/*
* Sensor resolution is 100mg/LSB, 12-bit value needs to be right
* shifted by 4 or divided by 16. Overall this results in a scale of 160
*/
int32_t micro_ms2 = value * (SENSOR_G / (16 * 1000 / 100));
val->val1 = micro_ms2 / 1000000;
val->val2 = micro_ms2 % 1000000;
}
static int adxl372_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct adxl372_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
adxl372_accel_convert(val, data->sample.x);
break;
case SENSOR_CHAN_ACCEL_Y:
adxl372_accel_convert(val, data->sample.y);
break;
case SENSOR_CHAN_ACCEL_Z:
adxl372_accel_convert(val, data->sample.z);
break;
case SENSOR_CHAN_ACCEL_XYZ:
adxl372_accel_convert(val++, data->sample.x);
adxl372_accel_convert(val++, data->sample.y);
adxl372_accel_convert(val, data->sample.z);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api adxl372_api_funcs = {
.attr_set = adxl372_attr_set,
.sample_fetch = adxl372_sample_fetch,
.channel_get = adxl372_channel_get,
#ifdef CONFIG_ADXL372_TRIGGER
.trigger_set = adxl372_trigger_set,
#endif
};
static int adxl372_probe(const struct device *dev)
{
const struct adxl372_dev_config *cfg = dev->config;
struct adxl372_data *data = dev->data;
uint8_t dev_id, part_id;
int ret;
ret = data->hw_tf->read_reg(dev, ADXL372_DEVID, &dev_id);
if (ret) {
return ret;
}
ret = data->hw_tf->read_reg(dev, ADXL372_PARTID, &part_id);
if (ret) {
return ret;
}
if (dev_id != ADXL372_DEVID_VAL || part_id != ADXL372_PARTID_VAL) {
LOG_ERR("failed to read id (0x%X:0x%X)", dev_id, part_id);
return -ENODEV;
}
#ifdef CONFIG_ADXL372_TRIGGER
data->act_proc_mode = ADXL372_LINKED,
#else
data->act_proc_mode = ADXL372_LOOPED,
#endif
/* Device settings */
ret = adxl372_set_op_mode(dev, ADXL372_STANDBY);
if (ret) {
return ret;
}
ret = adxl372_reset(dev);
if (ret) {
return ret;
}
ret = adxl372_set_hpf_corner(dev, cfg->hpf);
if (ret) {
return ret;
}
ret = adxl372_set_bandwidth(dev, cfg->bw);
if (ret) {
return ret;
}
ret = adxl372_set_odr(dev, cfg->odr);
if (ret) {
return ret;
}
ret = adxl372_set_wakeup_rate(dev, cfg->wur);
if (ret) {
return ret;
}
ret = adxl372_set_autosleep(dev, cfg->autosleep);
if (ret) {
return ret;
}
ret = adxl372_set_instant_on_th(dev, cfg->th_mode);
if (ret) {
return ret;
}
ret = adxl372_set_activity_threshold_xyz(dev, ADXL372_X_THRESH_ACT_H,
&cfg->activity_th);
if (ret) {
return ret;
}
ret = adxl372_set_activity_threshold_xyz(dev, ADXL372_X_THRESH_INACT_H,
&cfg->inactivity_th);
if (ret) {
return ret;
}
ret = adxl372_set_activity_time(dev, cfg->activity_time);
if (ret) {
return ret;
}
ret = adxl372_set_inactivity_time(dev, cfg->inactivity_time);
if (ret) {
return ret;
}
ret = adxl372_set_filter_settle(dev, cfg->filter_settle);
if (ret) {
return ret;
}
ret = adxl372_configure_fifo(dev, cfg->fifo_config.fifo_mode,
cfg->fifo_config.fifo_format,
cfg->fifo_config.fifo_samples);
if (ret) {
return ret;
}
#ifdef CONFIG_ADXL372_TRIGGER
if (adxl372_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt!");
return -EIO;
}
#endif
ret = adxl372_interrupt_config(dev, cfg->int1_config, cfg->int2_config);
if (ret) {
return ret;
}
ret = adxl372_set_op_mode(dev, cfg->op_mode);
if (ret) {
return ret;
}
return adxl372_set_act_proc_mode(dev, data->act_proc_mode);
}
static int adxl372_init(const struct device *dev)
{
int ret;
const struct adxl372_dev_config *cfg = dev->config;
ret = cfg->bus_init(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize sensor bus");
return ret;
}
if (adxl372_probe(dev) < 0) {
return -ENODEV;
}
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "ADXL372 driver enabled without any devices"
#endif
/*
* Device creation macro, shared by ADXL372_DEFINE_SPI() and
* ADXL372_DEFINE_I2C().
*/
#define ADXL372_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
adxl372_init, \
NULL, \
&adxl372_data_##inst, \
&adxl372_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&adxl372_api_funcs);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_ADXL372_TRIGGER
#define ADXL372_CFG_IRQ(inst) \
.interrupt = GPIO_DT_SPEC_INST_GET(inst, int1_gpios),
#else
#define ADXL372_CFG_IRQ(inst)
#endif /* CONFIG_ADXL372_TRIGGER */
#define ADXL372_CONFIG(inst) \
.bw = DT_INST_PROP(inst, bw), \
.hpf = DT_INST_PROP(inst, hpf), \
.odr = DT_INST_PROP(inst, odr), \
.max_peak_detect_mode = IS_ENABLED(CONFIG_ADXL372_PEAK_DETECT_MODE), \
.th_mode = ADXL372_INSTANT_ON_LOW_TH, \
.autosleep = false, \
.wur = ADXL372_WUR_52ms, \
.activity_th.thresh = CONFIG_ADXL372_ACTIVITY_THRESHOLD / 100, \
.activity_th.referenced = \
IS_ENABLED(CONFIG_ADXL372_REFERENCED_ACTIVITY_DETECTION_MODE), \
.activity_th.enable = 1, \
.activity_time = CONFIG_ADXL372_ACTIVITY_TIME, \
.inactivity_th.thresh = CONFIG_ADXL372_INACTIVITY_THRESHOLD / 100, \
.inactivity_th.referenced = \
IS_ENABLED(CONFIG_ADXL372_REFERENCED_ACTIVITY_DETECTION_MODE), \
.inactivity_th.enable = 1, \
.inactivity_time = CONFIG_ADXL372_INACTIVITY_TIME, \
.filter_settle = ADXL372_FILTER_SETTLE_370, \
.fifo_config.fifo_mode = ADXL372_FIFO_STREAMED, \
.fifo_config.fifo_format = ADXL372_XYZ_PEAK_FIFO, \
.fifo_config.fifo_samples = 128, \
.op_mode = ADXL372_FULL_BW_MEASUREMENT, \
#define ADXL372_CONFIG_SPI(inst) \
{ \
.bus_init = adxl372_spi_init, \
.spi = SPI_DT_SPEC_INST_GET(inst, SPI_WORD_SET(8) | \
SPI_TRANSFER_MSB, 0), \
ADXL372_CONFIG(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
(ADXL372_CFG_IRQ(inst)), ()) \
}
#define ADXL372_DEFINE_SPI(inst) \
static struct adxl372_data adxl372_data_##inst; \
static const struct adxl372_dev_config adxl372_config_##inst = \
ADXL372_CONFIG_SPI(inst); \
ADXL372_DEVICE_INIT(inst)
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define ADXL372_CONFIG_I2C(inst) \
{ \
.bus_init = adxl372_i2c_init, \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
ADXL372_CONFIG(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
(ADXL372_CFG_IRQ(inst)), ()) \
}
#define ADXL372_DEFINE_I2C(inst) \
static struct adxl372_data adxl372_data_##inst; \
static const struct adxl372_dev_config adxl372_config_##inst = \
ADXL372_CONFIG_I2C(inst); \
ADXL372_DEVICE_INIT(inst)
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define ADXL372_DEFINE(inst) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(ADXL372_DEFINE_SPI(inst)), \
(ADXL372_DEFINE_I2C(inst)))
DT_INST_FOREACH_STATUS_OKAY(ADXL372_DEFINE)
``` | /content/code_sandbox/drivers/sensor/adi/adxl372/adxl372.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,793 |
```c
/* adxl372_spi.c - SPI routines for ADXL372 driver
*/
/*
*
*/
#define DT_DRV_COMPAT adi_adxl372
#include <string.h>
#include <zephyr/logging/log.h>
#include "adxl372.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
LOG_MODULE_DECLARE(ADXL372, CONFIG_SENSOR_LOG_LEVEL);
static int adxl372_bus_access(const struct device *dev, uint8_t reg,
void *data, size_t length)
{
const struct adxl372_dev_config *config = dev->config;
const struct spi_buf buf[2] = {
{
.buf = ®,
.len = 1
}, {
.buf = data,
.len = length
}
};
struct spi_buf_set tx = {
.buffers = buf,
};
if (reg & ADXL372_READ) {
const struct spi_buf_set rx = {
.buffers = buf,
.count = 2
};
tx.count = 1;
return spi_transceive_dt(&config->spi, &tx, &rx);
}
tx.count = 2;
return spi_write_dt(&config->spi, &tx);
}
static int adxl372_spi_reg_read(const struct device *dev, uint8_t reg_addr,
uint8_t *reg_data)
{
return adxl372_bus_access(dev, ADXL372_REG_READ(reg_addr), reg_data, 1);
}
static int adxl372_spi_reg_read_multiple(const struct device *dev,
uint8_t reg_addr,
uint8_t *reg_data,
uint16_t count)
{
return adxl372_bus_access(dev, ADXL372_REG_READ(reg_addr),
reg_data, count);
}
static int adxl372_spi_reg_write(const struct device *dev,
uint8_t reg_addr,
uint8_t reg_data)
{
return adxl372_bus_access(dev, ADXL372_REG_WRITE(reg_addr),
®_data, 1);
}
int adxl372_spi_reg_write_mask(const struct device *dev,
uint8_t reg_addr,
uint32_t mask,
uint8_t data)
{
int ret;
uint8_t tmp;
ret = adxl372_spi_reg_read(dev, reg_addr, &tmp);
if (ret) {
return ret;
}
tmp &= ~mask;
tmp |= data;
return adxl372_spi_reg_write(dev, reg_addr, tmp);
}
static const struct adxl372_transfer_function adxl372_spi_transfer_fn = {
.read_reg_multiple = adxl372_spi_reg_read_multiple,
.write_reg = adxl372_spi_reg_write,
.read_reg = adxl372_spi_reg_read,
.write_reg_mask = adxl372_spi_reg_write_mask,
};
int adxl372_spi_init(const struct device *dev)
{
struct adxl372_data *data = dev->data;
const struct adxl372_dev_config *config = dev->config;
data->hw_tf = &adxl372_spi_transfer_fn;
if (!spi_is_ready_dt(&config->spi)) {
return -ENODEV;
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/adi/adxl372/adxl372_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 678 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adxl372
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "adxl372.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ADXL372, CONFIG_SENSOR_LOG_LEVEL);
static void adxl372_thread_cb(const struct device *dev)
{
const struct adxl372_dev_config *cfg = dev->config;
struct adxl372_data *drv_data = dev->data;
uint8_t status1, status2;
int ret;
/* Clear the status */
if (adxl372_get_status(dev, &status1, &status2, NULL) < 0) {
return;
}
if (drv_data->th_handler != NULL) {
/* In max peak mode we wait until we settle below the inactivity
* threshold and then call the trigger handler.
*/
if (cfg->max_peak_detect_mode &&
ADXL372_STATUS_2_INACT(status2)) {
drv_data->th_handler(dev, drv_data->th_trigger);
} else if (!cfg->max_peak_detect_mode &&
(ADXL372_STATUS_2_INACT(status2) ||
ADXL372_STATUS_2_ACTIVITY(status2))) {
drv_data->th_handler(dev, drv_data->th_trigger);
}
}
if ((drv_data->drdy_handler != NULL) &&
ADXL372_STATUS_1_DATA_RDY(status1)) {
drv_data->drdy_handler(dev, drv_data->drdy_trigger);
}
ret = gpio_pin_interrupt_configure_dt(&cfg->interrupt,
GPIO_INT_EDGE_TO_ACTIVE);
__ASSERT(ret == 0, "Interrupt configuration failed");
}
static void adxl372_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct adxl372_data *drv_data =
CONTAINER_OF(cb, struct adxl372_data, gpio_cb);
const struct adxl372_dev_config *cfg = drv_data->dev->config;
gpio_pin_interrupt_configure_dt(&cfg->interrupt, GPIO_INT_DISABLE);
#if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
#if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD)
static void adxl372_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct adxl372_data *drv_data = p1;
while (true) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
adxl372_thread_cb(drv_data->dev);
}
}
#elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD)
static void adxl372_work_cb(struct k_work *work)
{
struct adxl372_data *drv_data =
CONTAINER_OF(work, struct adxl372_data, work);
adxl372_thread_cb(drv_data->dev);
}
#endif
int adxl372_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct adxl372_dev_config *cfg = dev->config;
struct adxl372_data *drv_data = dev->data;
uint8_t int_mask, int_en, status1, status2;
int ret;
ret = gpio_pin_interrupt_configure_dt(&cfg->interrupt,
GPIO_INT_DISABLE);
if (ret < 0) {
return ret;
}
switch (trig->type) {
case SENSOR_TRIG_THRESHOLD:
drv_data->th_handler = handler;
drv_data->th_trigger = trig;
int_mask = ADXL372_INT1_MAP_ACT_MSK |
ADXL372_INT1_MAP_INACT_MSK;
break;
case SENSOR_TRIG_DATA_READY:
drv_data->drdy_handler = handler;
drv_data->drdy_trigger = trig;
int_mask = ADXL372_INT1_MAP_DATA_RDY_MSK;
break;
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
if (handler) {
int_en = int_mask;
} else {
int_en = 0U;
}
ret = drv_data->hw_tf->write_reg_mask(dev, ADXL372_INT1_MAP, int_mask, int_en);
if (ret < 0) {
return ret;
}
ret = adxl372_get_status(dev, &status1, &status2, NULL); /* Clear status */
if (ret < 0) {
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&cfg->interrupt,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
return 0;
}
int adxl372_init_interrupt(const struct device *dev)
{
const struct adxl372_dev_config *cfg = dev->config;
struct adxl372_data *drv_data = dev->data;
int ret;
if (!gpio_is_ready_dt(&cfg->interrupt)) {
LOG_ERR("GPIO port %s not ready", cfg->interrupt.port->name);
return -EINVAL;
}
ret = gpio_pin_configure_dt(&cfg->interrupt, GPIO_INPUT);
if (ret < 0) {
return ret;
}
gpio_init_callback(&drv_data->gpio_cb,
adxl372_gpio_callback,
BIT(cfg->interrupt.pin));
ret = gpio_add_callback(cfg->interrupt.port, &drv_data->gpio_cb);
if (ret < 0) {
LOG_ERR("Failed to set gpio callback!");
return ret;
}
drv_data->dev = dev;
#if defined(CONFIG_ADXL372_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_ADXL372_THREAD_STACK_SIZE,
adxl372_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_ADXL372_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = adxl372_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/adi/adxl372/adxl372_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,356 |
```unknown
# Micropower, 3-Axis, +/-200g Digital Accelerometer
menuconfig ADXL372
bool "ADXL372 Three Axis High-g I2C/SPI accelerometer"
default y
depends on DT_HAS_ADI_ADXL372_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ADI_ADXL372),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ADI_ADXL372),spi)
help
Enable driver for ADXL372 Three-Axis Digital Accelerometers.
if ADXL372
choice ADXL372_OP_MODE
prompt "Operating mode"
default ADXL372_PEAK_DETECT_MODE
config ADXL372_PEAK_DETECT_MODE
bool "Max Peak detect mode"
help
In most high-g applications, a single (3-axis) acceleration sample at
the peak of an impact event contains sufficient information
about the event, and the full acceleration history is not required.
In this mode the device returns only the over threshold
Peak Acceleration between two consecutive sample fetches.
config ADXL372_MEASUREMENT_MODE
bool "Measurement Mode"
help
In this mode, acceleration data is provided continuously at the
output data rate (ODR).
endchoice
config ADXL372_ACTIVITY_THRESHOLD
int "Activity threshold in mg"
range 0 200000
default 500
help
Threshold for activity detection.
config ADXL372_INACTIVITY_THRESHOLD
int "In-activity threshold in mg"
range 0 200000
default 400
help
Threshold for in-activity detection.
config ADXL372_ACTIVITY_TIME
int "Activity time"
range 0 $(UINT8_MAX)
default 1
help
The activity timer implements a robust activity detection that
minimizes false positive motion triggers. When the timer is used,
only sustained motion can trigger activity detection.
Number of multiples of 3.3 ms activity timer for which above threshold
acceleration is required to detect activity. It is 3.3 ms per code
for 6400 Hz ODR, and it is 6.6 ms per code for 3200 Hz ODR and below.
config ADXL372_INACTIVITY_TIME
int "In-activity time"
range 0 $(UINT8_MAX)
default 2
help
The time that all enabled axes must be lower than the inactivity
threshold for an inactivity event to be detected. Number of multiples
of 26 ms inactivity timer for which below threshold acceleration is
required to detect inactivity. It is 26 ms per code for 3200 Hz ODR
and below, and it is 13 ms per code for 6400 Hz ODR.
config ADXL372_REFERENCED_ACTIVITY_DETECTION_MODE
bool "Use referenced activity/in-activity detection"
default y
help
Activity detection can be configured as referenced or absolute.
When using absolute activity detection, acceleration samples are
compared directly to a user set threshold to determine whether
motion is present. In many applications, it is advantageous for
activity detection to be based not on an absolute threshold,
but on a deviation from a reference point or orientation.
choice ADXL372_TRIGGER_MODE
prompt "Trigger mode"
default ADXL372_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config ADXL372_TRIGGER_NONE
bool "No trigger"
config ADXL372_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ADXL372_TRIGGER
config ADXL372_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ADXL372_TRIGGER
endchoice
config ADXL372_TRIGGER
bool
config ADXL372_THREAD_PRIORITY
int "Thread priority"
depends on ADXL372_TRIGGER_OWN_THREAD && ADXL372_TRIGGER
default 10
help
Priority of thread used by the driver to handle interrupts.
config ADXL372_THREAD_STACK_SIZE
int "Thread stack size"
depends on ADXL372_TRIGGER_OWN_THREAD && ADXL372_TRIGGER
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # ADXL372
``` | /content/code_sandbox/drivers/sensor/adi/adxl372/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 888 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adxl362
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "adxl362.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ADXL362, CONFIG_SENSOR_LOG_LEVEL);
static void adxl362_thread_cb(const struct device *dev)
{
struct adxl362_data *drv_data = dev->data;
uint8_t status_buf;
/* Clears activity and inactivity interrupt */
if (adxl362_get_status(dev, &status_buf)) {
LOG_ERR("Unable to get status.");
return;
}
k_mutex_lock(&drv_data->trigger_mutex, K_FOREVER);
if (drv_data->inact_handler != NULL) {
if (ADXL362_STATUS_CHECK_INACT(status_buf)) {
drv_data->inact_handler(dev, drv_data->inact_trigger);
}
}
if (drv_data->act_handler != NULL) {
if (ADXL362_STATUS_CHECK_ACTIVITY(status_buf)) {
drv_data->act_handler(dev, drv_data->act_trigger);
}
}
if (drv_data->drdy_handler != NULL &&
ADXL362_STATUS_CHECK_DATA_READY(status_buf)) {
drv_data->drdy_handler(dev, drv_data->drdy_trigger);
}
k_mutex_unlock(&drv_data->trigger_mutex);
}
static void adxl362_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct adxl362_data *drv_data =
CONTAINER_OF(cb, struct adxl362_data, gpio_cb);
#if defined(CONFIG_ADXL362_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ADXL362_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
#if defined(CONFIG_ADXL362_TRIGGER_OWN_THREAD)
static void adxl362_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct adxl362_data *drv_data = p1;
while (true) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
adxl362_thread_cb(drv_data->dev);
}
}
#elif defined(CONFIG_ADXL362_TRIGGER_GLOBAL_THREAD)
static void adxl362_work_cb(struct k_work *work)
{
struct adxl362_data *drv_data =
CONTAINER_OF(work, struct adxl362_data, work);
adxl362_thread_cb(drv_data->dev);
}
#endif
int adxl362_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct adxl362_data *drv_data = dev->data;
const struct adxl362_config *config = dev->config;
uint8_t int_mask, int_en, status_buf;
if (!config->interrupt.port) {
return -ENOTSUP;
}
switch (trig->type) {
case SENSOR_TRIG_MOTION:
k_mutex_lock(&drv_data->trigger_mutex, K_FOREVER);
drv_data->act_handler = handler;
drv_data->act_trigger = trig;
k_mutex_unlock(&drv_data->trigger_mutex);
int_mask = ADXL362_INTMAP1_ACT;
/* Clear activity and inactivity interrupts */
adxl362_get_status(dev, &status_buf);
break;
case SENSOR_TRIG_STATIONARY:
k_mutex_lock(&drv_data->trigger_mutex, K_FOREVER);
drv_data->inact_handler = handler;
drv_data->inact_trigger = trig;
k_mutex_unlock(&drv_data->trigger_mutex);
int_mask = ADXL362_INTMAP1_INACT;
/* Clear activity and inactivity interrupts */
adxl362_get_status(dev, &status_buf);
break;
case SENSOR_TRIG_DATA_READY:
k_mutex_lock(&drv_data->trigger_mutex, K_FOREVER);
drv_data->drdy_handler = handler;
drv_data->drdy_trigger = trig;
k_mutex_unlock(&drv_data->trigger_mutex);
int_mask = ADXL362_INTMAP1_DATA_READY;
adxl362_clear_data_ready(dev);
break;
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
if (handler) {
int_en = int_mask;
} else {
int_en = 0U;
}
return adxl362_reg_write_mask(dev, ADXL362_REG_INTMAP1, int_mask, int_en);
}
int adxl362_init_interrupt(const struct device *dev)
{
const struct adxl362_config *cfg = dev->config;
struct adxl362_data *drv_data = dev->data;
int ret;
k_mutex_init(&drv_data->trigger_mutex);
if (!gpio_is_ready_dt(&cfg->interrupt)) {
LOG_ERR("GPIO port %s not ready", cfg->interrupt.port->name);
return -ENODEV;
}
ret = adxl362_set_interrupt_mode(dev, CONFIG_ADXL362_INTERRUPT_MODE);
if (ret < 0) {
return ret;
}
ret = gpio_pin_configure_dt(&cfg->interrupt, GPIO_INPUT);
if (ret < 0) {
return ret;
}
gpio_init_callback(&drv_data->gpio_cb,
adxl362_gpio_callback,
BIT(cfg->interrupt.pin));
ret = gpio_add_callback(cfg->interrupt.port, &drv_data->gpio_cb);
if (ret < 0) {
return ret;
}
drv_data->dev = dev;
#if defined(CONFIG_ADXL362_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_ADXL362_THREAD_STACK_SIZE,
adxl362_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_ADXL362_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ADXL362_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = adxl362_work_cb;
#endif
ret = gpio_pin_interrupt_configure_dt(&cfg->interrupt,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/adi/adxl362/adxl362_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,364 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADXL362_ADXL362_H_
#define ZEPHYR_DRIVERS_SENSOR_ADXL362_ADXL362_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/spi.h>
#define ADXL362_SLAVE_ID 1
/* ADXL362 communication commands */
#define ADXL362_WRITE_REG 0x0A
#define ADXL362_READ_REG 0x0B
#define ADXL362_WRITE_FIFO 0x0D
/* Registers */
#define ADXL362_REG_DEVID_AD 0x00
#define ADXL362_REG_DEVID_MST 0x01
#define ADXL362_REG_PARTID 0x02
#define ADXL362_REG_REVID 0x03
#define ADXL362_REG_XDATA 0x08
#define ADXL362_REG_YDATA 0x09
#define ADXL362_REG_ZDATA 0x0A
#define ADXL362_REG_STATUS 0x0B
#define ADXL362_REG_FIFO_L 0x0C
#define ADXL362_REG_FIFO_H 0x0D
#define ADXL362_REG_XDATA_L 0x0E
#define ADXL362_REG_XDATA_H 0x0F
#define ADXL362_REG_YDATA_L 0x10
#define ADXL362_REG_YDATA_H 0x11
#define ADXL362_REG_ZDATA_L 0x12
#define ADXL362_REG_ZDATA_H 0x13
#define ADXL362_REG_TEMP_L 0x14
#define ADXL362_REG_TEMP_H 0x15
#define ADXL362_REG_SOFT_RESET 0x1F
#define ADXL362_REG_THRESH_ACT_L 0x20
#define ADXL362_REG_THRESH_ACT_H 0x21
#define ADXL362_REG_TIME_ACT 0x22
#define ADXL362_REG_THRESH_INACT_L 0x23
#define ADXL362_REG_THRESH_INACT_H 0x24
#define ADXL362_REG_TIME_INACT_L 0x25
#define ADXL362_REG_TIME_INACT_H 0x26
#define ADXL362_REG_ACT_INACT_CTL 0x27
#define ADXL362_REG_FIFO_CTL 0x28
#define ADXL362_REG_FIFO_SAMPLES 0x29
#define ADXL362_REG_INTMAP1 0x2A
#define ADXL362_REG_INTMAP2 0x2B
#define ADXL362_REG_FILTER_CTL 0x2C
#define ADXL362_REG_POWER_CTL 0x2D
#define ADXL362_REG_SELF_TEST 0x2E
/* ADXL362_REG_STATUS definitions */
#define ADXL362_STATUS_ERR_USER_REGS (1 << 7)
#define ADXL362_STATUS_AWAKE (1 << 6)
#define ADXL362_STATUS_INACT (1 << 5)
#define ADXL362_STATUS_ACT (1 << 4)
#define ADXL362_STATUS_FIFO_OVERRUN (1 << 3)
#define ADXL362_STATUS_FIFO_WATERMARK (1 << 2)
#define ADXL362_STATUS_FIFO_RDY (1 << 1)
#define ADXL362_STATUS_DATA_RDY (1 << 0)
/* ADXL362_REG_ACT_INACT_CTL definitions */
#define ADXL362_ACT_INACT_CTL_LINKLOOP(x) (((x) & 0x3) << 4)
#define ADXL362_ACT_INACT_CTL_INACT_REF (1 << 3)
#define ADXL362_ACT_INACT_CTL_INACT_EN (1 << 2)
#define ADXL362_ACT_INACT_CTL_ACT_REF (1 << 1)
#define ADXL362_ACT_INACT_CTL_ACT_EN (1 << 0)
/* ADXL362_ACT_INACT_CTL_LINKLOOP(x) options */
#define ADXL362_MODE_DEFAULT 0
#define ADXL362_MODE_LINK 1
#define ADXL362_MODE_LOOP 3
/* ADXL362_REG_FIFO_CTL */
#define ADXL362_FIFO_CTL_AH (1 << 3)
#define ADXL362_FIFO_CTL_FIFO_TEMP (1 << 2)
#define ADXL362_FIFO_CTL_FIFO_MODE(x) (((x) & 0x3) << 0)
/* ADXL362_FIFO_CTL_FIFO_MODE(x) options */
#define ADXL362_FIFO_DISABLE 0
#define ADXL362_FIFO_OLDEST_SAVED 1
#define ADXL362_FIFO_STREAM 2
#define ADXL362_FIFO_TRIGGERED 3
/* ADXL362_REG_INTMAP1 */
#define ADXL362_INTMAP1_INT_LOW (1 << 7)
#define ADXL362_INTMAP1_AWAKE (1 << 6)
#define ADXL362_INTMAP1_INACT (1 << 5)
#define ADXL362_INTMAP1_ACT (1 << 4)
#define ADXL362_INTMAP1_FIFO_OVERRUN (1 << 3)
#define ADXL362_INTMAP1_FIFO_WATERMARK (1 << 2)
#define ADXL362_INTMAP1_FIFO_READY (1 << 1)
#define ADXL362_INTMAP1_DATA_READY (1 << 0)
/* ADXL362_REG_INTMAP2 definitions */
#define ADXL362_INTMAP2_INT_LOW (1 << 7)
#define ADXL362_INTMAP2_AWAKE (1 << 6)
#define ADXL362_INTMAP2_INACT (1 << 5)
#define ADXL362_INTMAP2_ACT (1 << 4)
#define ADXL362_INTMAP2_FIFO_OVERRUN (1 << 3)
#define ADXL362_INTMAP2_FIFO_WATERMARK (1 << 2)
#define ADXL362_INTMAP2_FIFO_READY (1 << 1)
#define ADXL362_INTMAP2_DATA_READY (1 << 0)
/* ADXL362_REG_FILTER_CTL definitions */
#define ADXL362_FILTER_CTL_RANGE(x) (((x) & 0x3) << 6)
#define ADXL362_FILTER_CTL_RES (1 << 5)
#define ADXL362_FILTER_CTL_HALF_BW (1 << 4)
#define ADXL362_FILTER_CTL_EXT_SAMPLE (1 << 3)
#define ADXL362_FILTER_CTL_ODR(x) (((x) & 0x7) << 0)
/* ADXL362_FILTER_CTL_RANGE(x) options */
#define ADXL362_RANGE_2G 0 /* +/-2 g */
#define ADXL362_RANGE_4G 1 /* +/-4 g */
#define ADXL362_RANGE_8G 2 /* +/-8 g */
/* ADXL362_FILTER_CTL_ODR(x) options */
#define ADXL362_ODR_12_5_HZ 0 /* 12.5 Hz */
#define ADXL362_ODR_25_HZ 1 /* 25 Hz */
#define ADXL362_ODR_50_HZ 2 /* 50 Hz */
#define ADXL362_ODR_100_HZ 3 /* 100 Hz */
#define ADXL362_ODR_200_HZ 4 /* 200 Hz */
#define ADXL362_ODR_400_HZ 5 /* 400 Hz */
/* ADXL362_REG_POWER_CTL definitions */
#define ADXL362_POWER_CTL_RES (1 << 7)
#define ADXL362_POWER_CTL_EXT_CLK (1 << 6)
#define ADXL362_POWER_CTL_LOW_NOISE(x) (((x) & 0x3) << 4)
#define ADXL362_POWER_CTL_WAKEUP (1 << 3)
#define ADXL362_POWER_CTL_AUTOSLEEP (1 << 2)
#define ADXL362_POWER_CTL_MEASURE(x) (((x) & 0x3) << 0)
/* ADXL362_POWER_CTL_LOW_NOISE(x) options */
#define ADXL362_NOISE_MODE_NORMAL 0
#define ADXL362_NOISE_MODE_LOW 1
#define ADXL362_NOISE_MODE_ULTRALOW 2
/* ADXL362_POWER_CTL_MEASURE(x) options */
#define ADXL362_MEASURE_STANDBY 0
#define ADXL362_MEASURE_ON 2
/* ADXL362_REG_SELF_TEST */
#define ADXL362_SELF_TEST_ST (1 << 0)
/* ADXL362 device information */
#define ADXL362_DEVICE_AD 0xAD
#define ADXL362_DEVICE_MST 0x1D
#define ADXL362_PART_ID 0xF2
/* ADXL362 Reset settings */
#define ADXL362_RESET_KEY 0x52
/* ADXL362 Status check */
#define ADXL362_STATUS_CHECK_DATA_READY(x) (((x) >> 0) & 0x1)
#define ADXL362_STATUS_CHECK_INACT(x) (((x) >> 5) & 0x1)
#define ADXL362_STATUS_CHECK_ACTIVITY(x) (((x) >> 4) & 0x1)
/* ADXL362 scale factors from specifications */
#define ADXL362_ACCEL_2G_LSB_PER_G 1000
#define ADXL362_ACCEL_4G_LSB_PER_G 500
#define ADXL362_ACCEL_8G_LSB_PER_G 235
/* ADXL362 temperature sensor specifications */
#define ADXL362_TEMP_MC_PER_LSB 65
#define ADXL362_TEMP_BIAS_LSB 350
#define ADXL362_TEMP_BIAS_TEST_CONDITION 25
struct adxl362_config {
struct spi_dt_spec bus;
#if defined(CONFIG_ADXL362_TRIGGER)
struct gpio_dt_spec interrupt;
uint8_t int1_config;
uint8_t int2_config;
#endif
uint8_t power_ctl;
};
struct adxl362_data {
union {
int16_t acc_xyz[3];
struct {
int16_t acc_x;
int16_t acc_y;
int16_t acc_z;
};
} __packed;
int16_t temp;
uint8_t selected_range;
#if defined(CONFIG_ADXL362_TRIGGER)
const struct device *dev;
struct gpio_callback gpio_cb;
struct k_mutex trigger_mutex;
sensor_trigger_handler_t inact_handler;
const struct sensor_trigger *inact_trigger;
sensor_trigger_handler_t act_handler;
const struct sensor_trigger *act_trigger;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trigger;
#if defined(CONFIG_ADXL362_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADXL362_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ADXL362_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_ADXL362_TRIGGER */
};
#if defined(CONFIG_ADXL362_ACCEL_RANGE_RUNTIME) ||\
defined(CONFIG_ADXL362_ACCEL_RANGE_2G)
# define ADXL362_DEFAULT_RANGE_ACC ADXL362_RANGE_2G
#elif defined(CONFIG_ADXL362_ACCEL_RANGE_4G)
# define ADXL362_DEFAULT_RANGE_ACC ADXL362_RANGE_4G
#else
# define ADXL362_DEFAULT_RANGE_ACC ADXL362_RANGE_8G
#endif
#if defined(CONFIG_ADXL362_ACCEL_ODR_RUNTIME) ||\
defined(CONFIG_ADXL362_ACCEL_ODR_12_5)
# define ADXL362_DEFAULT_ODR_ACC ADXL362_ODR_12_5_HZ
#elif defined(CONFIG_ADXL362_ACCEL_ODR_25)
# define ADXL362_DEFAULT_ODR_ACC ADXL362_ODR_25_HZ
#elif defined(CONFIG_ADXL362_ACCEL_ODR_50)
# define ADXL362_DEFAULT_ODR_ACC ADXL362_ODR_50_HZ
#elif defined(CONFIG_ADXL362_ACCEL_ODR_100)
# define ADXL362_DEFAULT_ODR_ACC ADXL362_ODR_100_HZ
#elif defined(CONFIG_ADXL362_ACCEL_ODR_200)
# define ADXL362_DEFAULT_ODR_ACC ADXL362_ODR_200_HZ
#else
# define ADXL362_DEFAULT_ODR_ACC ADXL362_ODR_400_HZ
#endif
#ifdef CONFIG_ADXL362_TRIGGER
int adxl362_reg_write_mask(const struct device *dev,
uint8_t reg_addr, uint8_t mask, uint8_t data);
int adxl362_get_status(const struct device *dev, uint8_t *status);
int adxl362_interrupt_activity_enable(const struct device *dev);
int adxl362_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int adxl362_init_interrupt(const struct device *dev);
int adxl362_set_interrupt_mode(const struct device *dev, uint8_t mode);
int adxl362_clear_data_ready(const struct device *dev);
#endif /* CONFIG_ADT7420_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_ADXL362_ADXL362_H_ */
``` | /content/code_sandbox/drivers/sensor/adi/adxl362/adxl362.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,795 |
```unknown
# ADXL362 Three-Axis Digital Accelerometers
menuconfig ADXL362
bool "ADXL362 sensor"
default y
depends on DT_HAS_ADI_ADXL362_ENABLED
select SPI
help
Enable driver for ADXL362 Three-Axis Digital Accelerometers.
if ADXL362
choice
prompt "Accelerometer range setting"
default ADXL362_ACCEL_RANGE_RUNTIME
config ADXL362_ACCEL_RANGE_RUNTIME
bool "Set at runtime."
config ADXL362_ACCEL_RANGE_2G
bool "2G"
config ADXL362_ACCEL_RANGE_4G
bool "4G"
config ADXL362_ACCEL_RANGE_8G
bool "8G"
endchoice
choice
prompt "Accelerometer sampling frequency."
default ADXL362_ACCEL_ODR_RUNTIME
config ADXL362_ACCEL_ODR_RUNTIME
bool "Set at runtime."
config ADXL362_ACCEL_ODR_12_5
bool "12.5 Hz"
config ADXL362_ACCEL_ODR_25
bool "25 Hz"
config ADXL362_ACCEL_ODR_50
bool "50 Hz"
config ADXL362_ACCEL_ODR_100
bool "100 Hz"
config ADXL362_ACCEL_ODR_200
bool "200 Hz"
config ADXL362_ACCEL_ODR_400
bool "400 Hz"
endchoice
choice
prompt "Trigger mode"
default ADXL362_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config ADXL362_TRIGGER_NONE
bool "No trigger"
config ADXL362_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ADXL362_TRIGGER
config ADXL362_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ADXL362_TRIGGER
endchoice
config ADXL362_TRIGGER
bool
config ADXL362_THREAD_PRIORITY
int "Thread priority"
depends on ADXL362_TRIGGER_OWN_THREAD && ADXL362_TRIGGER
default 10
help
Priority of thread used by the driver to handle interrupts.
config ADXL362_THREAD_STACK_SIZE
int "Thread stack size"
depends on ADXL362_TRIGGER_OWN_THREAD && ADXL362_TRIGGER
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config ADXL362_ACTIVITY_THRESHOLD
int "Upper threshold value"
default 1000
help
Unsigned value that the adxl362 samples are
compared to in activity trigger mode.
config ADXL362_ACTIVITY_TIME
int "Upper threshold time"
default 1
help
8 bit value written to the activity timer register
0 to 254, seconds is this value div by ODR
config ADXL362_INACTIVITY_THRESHOLD
int "Lower threshold value"
default 100
help
Unsigned value that the adxl362 samples are
compared to in inactivity trigger mode.
config ADXL362_INACTIVITY_TIME
int "Lower threshold time"
default 1
help
16 bit value written to the activity timer register
0 to 65535, seconds is this value div by ODR
config ADXL362_INTERRUPT_MODE
int "Activity and inactivity interrupt mode"
default 0
help
Unsigned value that sets the ADXL362 in different
interrupt modes.
0 - Default mode
1 - Linked mode
3 - Loop mode
config ADXL362_ABS_REF_MODE
int "Absolute or referenced interrupt"
default 0
help
Unsigned value that sets the ADXL362 interrupt
mode in either absolute or referenced mode.
0 - Absolute mode
1 - Referenced mode
endif # ADXL362
``` | /content/code_sandbox/drivers/sensor/adi/adxl362/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 791 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "adt7420.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ADT7420, CONFIG_SENSOR_LOG_LEVEL);
static void setup_int(const struct device *dev,
bool enable)
{
const struct adt7420_dev_config *cfg = dev->config;
gpio_flags_t flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, flags);
}
static void handle_int(const struct device *dev)
{
struct adt7420_data *drv_data = dev->data;
setup_int(dev, false);
#if defined(CONFIG_ADT7420_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ADT7420_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void process_int(const struct device *dev)
{
struct adt7420_data *drv_data = dev->data;
const struct adt7420_dev_config *cfg = dev->config;
uint8_t status;
/* Clear the status */
if (i2c_reg_read_byte_dt(&cfg->i2c,
ADT7420_REG_STATUS, &status) < 0) {
return;
}
if (drv_data->th_handler != NULL) {
drv_data->th_handler(dev, drv_data->th_trigger);
}
setup_int(dev, true);
/* Check for pin that asserted while we were offline */
int pv = gpio_pin_get_dt(&cfg->int_gpio);
if (pv > 0) {
handle_int(dev);
}
}
static void adt7420_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct adt7420_data *drv_data =
CONTAINER_OF(cb, struct adt7420_data, gpio_cb);
handle_int(drv_data->dev);
}
#if defined(CONFIG_ADT7420_TRIGGER_OWN_THREAD)
static void adt7420_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct adt7420_data *drv_data = p1;
while (true) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
process_int(drv_data->dev);
}
}
#elif defined(CONFIG_ADT7420_TRIGGER_GLOBAL_THREAD)
static void adt7420_work_cb(struct k_work *work)
{
struct adt7420_data *drv_data =
CONTAINER_OF(work, struct adt7420_data, work);
process_int(drv_data->dev);
}
#endif
int adt7420_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct adt7420_data *drv_data = dev->data;
const struct adt7420_dev_config *cfg = dev->config;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
setup_int(dev, false);
if (trig->type != SENSOR_TRIG_THRESHOLD) {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
drv_data->th_handler = handler;
if (handler != NULL) {
drv_data->th_trigger = trig;
setup_int(dev, true);
/* Check whether already asserted */
int pv = gpio_pin_get_dt(&cfg->int_gpio);
if (pv > 0) {
handle_int(dev);
}
}
return 0;
}
int adt7420_init_interrupt(const struct device *dev)
{
struct adt7420_data *drv_data = dev->data;
const struct adt7420_dev_config *cfg = dev->config;
int rc;
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;
}
gpio_init_callback(&drv_data->gpio_cb,
adt7420_gpio_callback,
BIT(cfg->int_gpio.pin));
rc = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT | cfg->int_gpio.dt_flags);
if (rc < 0) {
return rc;
}
rc = gpio_add_callback(cfg->int_gpio.port, &drv_data->gpio_cb);
if (rc < 0) {
return rc;
}
drv_data->dev = dev;
#if defined(CONFIG_ADT7420_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_ADT7420_THREAD_STACK_SIZE,
adt7420_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_ADT7420_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ADT7420_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = adt7420_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/adi/adt7420/adt7420_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,127 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADT7420_ADT7420_H_
#define ZEPHYR_DRIVERS_SENSOR_ADT7420_ADT7420_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
/* ADT7420 registers */
#define ADT7420_REG_TEMP_MSB 0x00 /* Temperature value MSB */
#define ADT7420_REG_TEMP_LSB 0x01 /* Temperature value LSB */
#define ADT7420_REG_STATUS 0x02 /* Status */
#define ADT7420_REG_CONFIG 0x03 /* Configuration */
#define ADT7420_REG_T_HIGH_MSB 0x04 /* Temperature HIGH setpoint MSB */
#define ADT7420_REG_T_HIGH_LSB 0x05 /* Temperature HIGH setpoint LSB */
#define ADT7420_REG_T_LOW_MSB 0x06 /* Temperature LOW setpoint MSB */
#define ADT7420_REG_T_LOW_LSB 0x07 /* Temperature LOW setpoint LSB */
#define ADT7420_REG_T_CRIT_MSB 0x08 /* Temperature CRIT setpoint MSB */
#define ADT7420_REG_T_CRIT_LSB 0x09 /* Temperature CRIT setpoint LSB */
#define ADT7420_REG_HIST 0x0A /* Temperature HYST setpoint */
#define ADT7420_REG_ID 0x0B /* ID */
#define ADT7420_REG_RESET 0x2F /* Software reset */
/* ADT7420_REG_STATUS definition */
#define ADT7420_STATUS_T_LOW BIT(4)
#define ADT7420_STATUS_T_HIGH BIT(5)
#define ADT7420_STATUS_T_CRIT BIT(6)
#define ADT7420_STATUS_RDY BIT(7)
/* ADT7420_REG_CONFIG definition */
#define ADT7420_CONFIG_FAULT_QUEUE(x) ((x) & 0x3)
#define ADT7420_CONFIG_CT_POL BIT(2)
#define ADT7420_CONFIG_INT_POL BIT(3)
#define ADT7420_CONFIG_INT_CT_MODE BIT(4)
#define ADT7420_CONFIG_OP_MODE(x) (((x) & 0x3) << 5)
#define ADT7420_CONFIG_RESOLUTION BIT(7)
/* ADT7420_CONFIG_FAULT_QUEUE(x) options */
#define ADT7420_FAULT_QUEUE_1_FAULT 0
#define ADT7420_FAULT_QUEUE_2_FAULTS 1
#define ADT7420_FAULT_QUEUE_3_FAULTS 2
#define ADT7420_FAULT_QUEUE_4_FAULTS 3
/* ADT7420_CONFIG_OP_MODE(x) options */
#define ADT7420_OP_MODE_CONT_CONV 0
#define ADT7420_OP_MODE_ONE_SHOT 1
#define ADT7420_OP_MODE_1_SPS 2
#define ADT7420_OP_MODE_SHUTDOWN 3
/* ADT7420 default ID */
#define ADT7420_DEFAULT_ID 0xCB
/* scale in micro degrees Celsius */
#define ADT7420_TEMP_SCALE 15625
struct adt7420_data {
int16_t sample;
#ifdef CONFIG_ADT7420_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t th_handler;
const struct sensor_trigger *th_trigger;
const struct device *dev;
#if defined(CONFIG_ADT7420_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADT7420_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ADT7420_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_ADT7420_TRIGGER */
};
struct adt7420_dev_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_ADT7420_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
#ifdef CONFIG_ADT7420_TRIGGER
int adt7420_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int adt7420_init_interrupt(const struct device *dev);
#endif /* CONFIG_ADT7420_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_ADT7420_ADT7420_H_ */
``` | /content/code_sandbox/drivers/sensor/adi/adt7420/adt7420.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 892 |
```unknown
# ADT7420 temperature sensor configuration options
menuconfig ADT7420
bool "ADT7420 Temperature Sensor"
default y
depends on DT_HAS_ADI_ADT7420_ENABLED
select I2C
help
Enable the driver for Analog Devices ADT7420 High-Accuracy
16-bit Digital I2C Temperature Sensors.
if ADT7420
config ADT7420_TEMP_HYST
int "Temperature hysteresis in C"
range 0 15
default 5
help
Specify the temperature hysteresis in C for the THIGH, TLOW,
and TCRIT temperature limits.
config ADT7420_TEMP_CRIT
int "Critical overtemperature in C"
range -40 150
default 147
help
The critical overtemperature pin asserts when the temperature
exceeds this value. The default value of 147 is the reset default
of the ADT7420.
choice
prompt "Trigger mode"
default ADT7420_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config ADT7420_TRIGGER_NONE
bool "No trigger"
config ADT7420_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ADT7420_TRIGGER
config ADT7420_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ADT7420_TRIGGER
endchoice
config ADT7420_TRIGGER
bool
config ADT7420_THREAD_PRIORITY
int "Thread priority"
depends on ADT7420_TRIGGER_OWN_THREAD && ADT7420_TRIGGER
default 10
help
Priority of thread used by the driver to handle interrupts.
config ADT7420_THREAD_STACK_SIZE
int "Thread stack size"
depends on ADT7420_TRIGGER_OWN_THREAD && ADT7420_TRIGGER
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # ADT7420
``` | /content/code_sandbox/drivers/sensor/adi/adt7420/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 422 |
```c
/* adxl362.c - ADXL362 Three-Axis Digital Accelerometers */
/*
*
*/
#define DT_DRV_COMPAT adi_adxl362
#include <zephyr/kernel.h>
#include <zephyr/devicetree.h>
#include <string.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/logging/log.h>
#include "adxl362.h"
LOG_MODULE_REGISTER(ADXL362, CONFIG_SENSOR_LOG_LEVEL);
static int adxl362_reg_access(const struct device *dev, uint8_t cmd,
uint8_t reg_addr, void *data, size_t length)
{
const struct adxl362_config *cfg = dev->config;
uint8_t access[2] = { cmd, reg_addr };
const struct spi_buf buf[2] = {
{
.buf = access,
.len = 2
},
{
.buf = data,
.len = length
}
};
struct spi_buf_set tx = {
.buffers = buf,
};
if (cmd == ADXL362_READ_REG) {
const struct spi_buf_set rx = {
.buffers = buf,
.count = 2
};
tx.count = 1;
return spi_transceive_dt(&cfg->bus, &tx, &rx);
}
tx.count = 2;
return spi_write_dt(&cfg->bus, &tx);
}
static inline int adxl362_set_reg(const struct device *dev,
uint16_t register_value,
uint8_t register_address, uint8_t count)
{
return adxl362_reg_access(dev, ADXL362_WRITE_REG,
register_address, ®ister_value, count);
}
int adxl362_reg_write_mask(const struct device *dev, uint8_t register_address,
uint8_t mask, uint8_t data)
{
int ret;
uint8_t tmp;
ret = adxl362_reg_access(dev, ADXL362_READ_REG,
register_address, &tmp, 1);
if (ret) {
return ret;
}
tmp &= ~mask;
tmp |= data;
return adxl362_reg_access(dev, ADXL362_WRITE_REG,
register_address, &tmp, 1);
}
static inline int adxl362_get_reg(const struct device *dev, uint8_t *read_buf,
uint8_t register_address, uint8_t count)
{
return adxl362_reg_access(dev, ADXL362_READ_REG,
register_address, read_buf, count);
}
#if defined(CONFIG_ADXL362_TRIGGER)
static int adxl362_interrupt_config(const struct device *dev,
uint8_t int1,
uint8_t int2)
{
int ret;
ret = adxl362_reg_access(dev, ADXL362_WRITE_REG,
ADXL362_REG_INTMAP1, &int1, 1);
if (ret) {
return ret;
}
return ret = adxl362_reg_access(dev, ADXL362_WRITE_REG,
ADXL362_REG_INTMAP2, &int2, 1);
}
int adxl362_get_status(const struct device *dev, uint8_t *status)
{
return adxl362_get_reg(dev, status, ADXL362_REG_STATUS, 1);
}
int adxl362_clear_data_ready(const struct device *dev)
{
uint8_t buf;
/* Reading any data register clears the data ready interrupt */
return adxl362_get_reg(dev, &buf, ADXL362_REG_XDATA, 1);
}
#endif
static int adxl362_software_reset(const struct device *dev)
{
return adxl362_set_reg(dev, ADXL362_RESET_KEY,
ADXL362_REG_SOFT_RESET, 1);
}
#if defined(CONFIG_ADXL362_ACCEL_ODR_RUNTIME)
/*
* Output data rate map with allowed frequencies:
* freq = freq_int + freq_milli / 1000
*
* Since we don't need a finer frequency resolution than milliHz, use uint16_t
* to save some flash.
*/
static const struct {
uint16_t freq_int;
uint16_t freq_milli; /* User should convert to uHz before setting the
* SENSOR_ATTR_SAMPLING_FREQUENCY attribute.
*/
} adxl362_odr_map[] = {
{ 12, 500 },
{ 25, 0 },
{ 50, 0 },
{ 100, 0 },
{ 200, 0 },
{ 400, 0 },
};
static int adxl362_freq_to_odr_val(uint16_t freq_int, uint16_t freq_milli)
{
size_t i;
/* An ODR of 0 Hz is not allowed */
if (freq_int == 0U && freq_milli == 0U) {
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(adxl362_odr_map); i++) {
if (freq_int < adxl362_odr_map[i].freq_int ||
(freq_int == adxl362_odr_map[i].freq_int &&
freq_milli <= adxl362_odr_map[i].freq_milli)) {
return i;
}
}
return -EINVAL;
}
#endif /* CONFIG_ADXL362_ACCEL_ODR_RUNTIME */
#if defined(CONFIG_ADXL362_ACCEL_RANGE_RUNTIME)
static const struct adxl362_range {
uint16_t range;
uint8_t reg_val;
} adxl362_acc_range_map[] = {
{2, ADXL362_RANGE_2G},
{4, ADXL362_RANGE_4G},
{8, ADXL362_RANGE_8G},
};
static int32_t adxl362_range_to_reg_val(uint16_t range)
{
int i;
for (i = 0; i < ARRAY_SIZE(adxl362_acc_range_map); i++) {
if (range <= adxl362_acc_range_map[i].range) {
return adxl362_acc_range_map[i].reg_val;
}
}
return -EINVAL;
}
#endif /* CONFIG_ADXL362_ACCEL_RANGE_RUNTIME */
static int adxl362_set_range(const struct device *dev, uint8_t range)
{
struct adxl362_data *adxl362_data = dev->data;
uint8_t old_filter_ctl;
uint8_t new_filter_ctl;
int ret;
ret = adxl362_get_reg(dev, &old_filter_ctl, ADXL362_REG_FILTER_CTL, 1);
if (ret) {
return ret;
}
new_filter_ctl = old_filter_ctl & ~ADXL362_FILTER_CTL_RANGE(0x3);
new_filter_ctl = new_filter_ctl | ADXL362_FILTER_CTL_RANGE(range);
ret = adxl362_set_reg(dev, new_filter_ctl, ADXL362_REG_FILTER_CTL, 1);
if (ret) {
return ret;
}
adxl362_data->selected_range = range;
return 0;
}
static int adxl362_set_output_rate(const struct device *dev, uint8_t out_rate)
{
int ret;
uint8_t old_filter_ctl;
uint8_t new_filter_ctl;
ret = adxl362_get_reg(dev, &old_filter_ctl, ADXL362_REG_FILTER_CTL, 1);
if (ret) {
return ret;
}
new_filter_ctl = old_filter_ctl & ~ADXL362_FILTER_CTL_ODR(0x7);
new_filter_ctl = new_filter_ctl | ADXL362_FILTER_CTL_ODR(out_rate);
return adxl362_set_reg(dev, new_filter_ctl, ADXL362_REG_FILTER_CTL, 1);
}
static int axl362_acc_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#if defined(CONFIG_ADXL362_ACCEL_RANGE_RUNTIME)
case SENSOR_ATTR_FULL_SCALE:
{
int range_reg;
range_reg = adxl362_range_to_reg_val(sensor_ms2_to_g(val));
if (range_reg < 0) {
LOG_DBG("invalid range requested.");
return -ENOTSUP;
}
return adxl362_set_range(dev, range_reg);
}
break;
#endif
#if defined(CONFIG_ADXL362_ACCEL_ODR_RUNTIME)
case SENSOR_ATTR_SAMPLING_FREQUENCY:
{
int out_rate;
out_rate = adxl362_freq_to_odr_val(val->val1,
val->val2 / 1000);
if (out_rate < 0) {
LOG_DBG("invalid output rate.");
return -ENOTSUP;
}
return adxl362_set_output_rate(dev, out_rate);
}
break;
#endif
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int adxl362_attr_set_thresh(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
uint8_t reg;
uint16_t threshold = val->val1;
size_t ret;
if (chan != SENSOR_CHAN_ACCEL_X &&
chan != SENSOR_CHAN_ACCEL_Y &&
chan != SENSOR_CHAN_ACCEL_Z) {
return -EINVAL;
}
if (threshold > 2047) {
return -EINVAL;
}
/* Configure motion threshold. */
if (attr == SENSOR_ATTR_UPPER_THRESH) {
reg = ADXL362_REG_THRESH_ACT_L;
} else {
reg = ADXL362_REG_THRESH_INACT_L;
}
ret = adxl362_set_reg(dev, (threshold & 0x7FF), reg, 2);
return ret;
}
static int adxl362_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_UPPER_THRESH:
case SENSOR_ATTR_LOWER_THRESH:
return adxl362_attr_set_thresh(dev, chan, attr, val);
case SENSOR_ATTR_HYSTERESIS:
{
uint16_t timeout = val->val1;
return adxl362_set_reg(dev, timeout, ADXL362_REG_TIME_INACT_L, 2);
}
default:
/* Do nothing */
break;
}
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
return axl362_acc_config(dev, chan, attr, val);
default:
LOG_DBG("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int adxl362_fifo_setup(const struct device *dev, uint8_t mode,
uint16_t water_mark_lvl, uint8_t en_temp_read)
{
uint8_t write_val;
int ret;
write_val = ADXL362_FIFO_CTL_FIFO_MODE(mode) |
(en_temp_read * ADXL362_FIFO_CTL_FIFO_TEMP) |
ADXL362_FIFO_CTL_AH;
ret = adxl362_set_reg(dev, write_val, ADXL362_REG_FIFO_CTL, 1);
if (ret) {
return ret;
}
ret = adxl362_set_reg(dev, water_mark_lvl, ADXL362_REG_FIFO_SAMPLES, 1);
if (ret) {
return ret;
}
return 0;
}
static int adxl362_setup_activity_detection(const struct device *dev,
uint8_t ref_or_abs,
uint16_t threshold,
uint8_t time)
{
uint8_t old_act_inact_reg;
uint8_t new_act_inact_reg;
int ret;
/**
* mode
* must be one of the following:
* ADXL362_FIFO_DISABLE - FIFO is disabled.
* ADXL362_FIFO_OLDEST_SAVED - Oldest saved mode.
* ADXL362_FIFO_STREAM - Stream mode.
* ADXL362_FIFO_TRIGGERED - Triggered mode.
* water_mark_lvl
* Specifies the number of samples to store in the FIFO.
* en_temp_read
* Store Temperature Data to FIFO.
* 1 - temperature data is stored in the FIFO
* together with x-, y- and x-axis data.
* 0 - temperature data is skipped.
*/
/* Configure motion threshold and activity timer. */
ret = adxl362_set_reg(dev, (threshold & 0x7FF),
ADXL362_REG_THRESH_ACT_L, 2);
if (ret) {
return ret;
}
ret = adxl362_set_reg(dev, time, ADXL362_REG_TIME_ACT, 1);
if (ret) {
return ret;
}
/* Enable activity interrupt and select a referenced or absolute
* configuration.
*/
ret = adxl362_get_reg(dev, &old_act_inact_reg,
ADXL362_REG_ACT_INACT_CTL, 1);
if (ret) {
return ret;
}
new_act_inact_reg = old_act_inact_reg & ~ADXL362_ACT_INACT_CTL_ACT_REF;
new_act_inact_reg |= ADXL362_ACT_INACT_CTL_ACT_EN |
(ref_or_abs * ADXL362_ACT_INACT_CTL_ACT_REF);
ret = adxl362_set_reg(dev, new_act_inact_reg,
ADXL362_REG_ACT_INACT_CTL, 1);
if (ret) {
return ret;
}
return 0;
}
static int adxl362_setup_inactivity_detection(const struct device *dev,
uint8_t ref_or_abs,
uint16_t threshold,
uint16_t time)
{
uint8_t old_act_inact_reg;
uint8_t new_act_inact_reg;
int ret;
/* Configure motion threshold and inactivity timer. */
ret = adxl362_set_reg(dev, (threshold & 0x7FF),
ADXL362_REG_THRESH_INACT_L, 2);
if (ret) {
return ret;
}
ret = adxl362_set_reg(dev, time, ADXL362_REG_TIME_INACT_L, 2);
if (ret) {
return ret;
}
/* Enable inactivity interrupt and select a referenced or
* absolute configuration.
*/
ret = adxl362_get_reg(dev, &old_act_inact_reg,
ADXL362_REG_ACT_INACT_CTL, 1);
if (ret) {
return ret;
}
new_act_inact_reg = old_act_inact_reg &
~ADXL362_ACT_INACT_CTL_INACT_REF;
new_act_inact_reg |= ADXL362_ACT_INACT_CTL_INACT_EN |
(ref_or_abs * ADXL362_ACT_INACT_CTL_INACT_REF);
ret = adxl362_set_reg(dev, new_act_inact_reg,
ADXL362_REG_ACT_INACT_CTL, 1);
if (ret) {
return ret;
}
return 0;
}
int adxl362_set_interrupt_mode(const struct device *dev, uint8_t mode)
{
uint8_t old_act_inact_reg;
uint8_t new_act_inact_reg;
int ret;
LOG_DBG("Mode: %d", mode);
if (mode != ADXL362_MODE_DEFAULT &&
mode != ADXL362_MODE_LINK &&
mode != ADXL362_MODE_LOOP) {
LOG_ERR("Wrong mode");
return -EINVAL;
}
/* Select desired interrupt mode. */
ret = adxl362_get_reg(dev, &old_act_inact_reg,
ADXL362_REG_ACT_INACT_CTL, 1);
if (ret) {
return ret;
}
new_act_inact_reg = old_act_inact_reg &
~ADXL362_ACT_INACT_CTL_LINKLOOP(3);
new_act_inact_reg |= old_act_inact_reg |
ADXL362_ACT_INACT_CTL_LINKLOOP(mode);
ret = adxl362_set_reg(dev, new_act_inact_reg,
ADXL362_REG_ACT_INACT_CTL, 1);
if (ret) {
return ret;
}
return 0;
}
static int adxl362_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct adxl362_data *data = dev->data;
int16_t buf[4];
int ret;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
ret = adxl362_get_reg(dev, (uint8_t *)buf, ADXL362_REG_XDATA_L,
sizeof(buf));
if (ret) {
return ret;
}
data->acc_x = sys_le16_to_cpu(buf[0]);
data->acc_y = sys_le16_to_cpu(buf[1]);
data->acc_z = sys_le16_to_cpu(buf[2]);
data->temp = sys_le16_to_cpu(buf[3]);
return 0;
}
static inline int adxl362_range_to_scale(int range)
{
/* See table 1 in specifications section of datasheet */
switch (range) {
case ADXL362_RANGE_2G:
return ADXL362_ACCEL_2G_LSB_PER_G;
case ADXL362_RANGE_4G:
return ADXL362_ACCEL_4G_LSB_PER_G;
case ADXL362_RANGE_8G:
return ADXL362_ACCEL_8G_LSB_PER_G;
default:
return -EINVAL;
}
}
static void adxl362_accel_convert(struct sensor_value *val, int accel,
int range)
{
int scale = adxl362_range_to_scale(range);
long micro_ms2 = accel * SENSOR_G / scale;
__ASSERT_NO_MSG(scale != -EINVAL);
val->val1 = micro_ms2 / 1000000;
val->val2 = micro_ms2 % 1000000;
}
static void adxl362_temp_convert(struct sensor_value *val, int temp)
{
/* See sensitivity and bias specifications in table 1 of datasheet */
int milli_c = (temp - ADXL362_TEMP_BIAS_LSB) * ADXL362_TEMP_MC_PER_LSB +
(ADXL362_TEMP_BIAS_TEST_CONDITION * 1000);
val->val1 = milli_c / 1000;
val->val2 = (milli_c % 1000) * 1000;
}
static int adxl362_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct adxl362_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X: /* Acceleration on the X axis, in m/s^2. */
adxl362_accel_convert(val, data->acc_x, data->selected_range);
break;
case SENSOR_CHAN_ACCEL_Y: /* Acceleration on the Y axis, in m/s^2. */
adxl362_accel_convert(val, data->acc_y, data->selected_range);
break;
case SENSOR_CHAN_ACCEL_Z: /* Acceleration on the Z axis, in m/s^2. */
adxl362_accel_convert(val, data->acc_z, data->selected_range);
break;
case SENSOR_CHAN_ACCEL_XYZ: /* Acceleration on the XYZ axis, in m/s^2. */
for (size_t i = 0; i < 3; i++) {
adxl362_accel_convert(&val[i], data->acc_xyz[i], data->selected_range);
}
break;
case SENSOR_CHAN_DIE_TEMP: /* Temperature in degrees Celsius. */
adxl362_temp_convert(val, data->temp);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api adxl362_api_funcs = {
.attr_set = adxl362_attr_set,
.sample_fetch = adxl362_sample_fetch,
.channel_get = adxl362_channel_get,
#ifdef CONFIG_ADXL362_TRIGGER
.trigger_set = adxl362_trigger_set,
#endif
};
static int adxl362_chip_init(const struct device *dev)
{
const struct adxl362_config *config = dev->config;
int ret;
/* Configures activity detection.
* Referenced/Absolute Activity or Inactivity Select.
* 0 - absolute mode.
* 1 - referenced mode.
* threshold
* 11-bit unsigned value that the adxl362 samples are
* compared to.
* time
* 8-bit value written to the activity timer register.
* The amount of time (in seconds) is:
* time / ODR,
* where ODR - is the output data rate.
*/
ret =
adxl362_setup_activity_detection(dev,
CONFIG_ADXL362_ABS_REF_MODE,
CONFIG_ADXL362_ACTIVITY_THRESHOLD,
CONFIG_ADXL362_ACTIVITY_TIME);
if (ret) {
return ret;
}
/* Configures inactivity detection.
* Referenced/Absolute Activity or Inactivity Select.
* 0 - absolute mode.
* 1 - referenced mode.
* threshold
* 11-bit unsigned value that the adxl362 samples are
* compared to.
* time
* 16-bit value written to the activity timer register.
* The amount of time (in seconds) is:
* time / ODR,
* where ODR - is the output data rate.
*/
ret =
adxl362_setup_inactivity_detection(dev,
CONFIG_ADXL362_ABS_REF_MODE,
CONFIG_ADXL362_INACTIVITY_THRESHOLD,
CONFIG_ADXL362_INACTIVITY_TIME);
if (ret) {
return ret;
}
/* Configures the FIFO feature. */
ret = adxl362_fifo_setup(dev, ADXL362_FIFO_DISABLE, 0, 0);
if (ret) {
return ret;
}
/* Selects the measurement range.
* options are:
* ADXL362_RANGE_2G - +-2 g
* ADXL362_RANGE_4G - +-4 g
* ADXL362_RANGE_8G - +-8 g
*/
ret = adxl362_set_range(dev, ADXL362_DEFAULT_RANGE_ACC);
if (ret) {
return ret;
}
/* Selects the Output Data Rate of the device.
* Options are:
* ADXL362_ODR_12_5_HZ - 12.5Hz
* ADXL362_ODR_25_HZ - 25Hz
* ADXL362_ODR_50_HZ - 50Hz
* ADXL362_ODR_100_HZ - 100Hz
* ADXL362_ODR_200_HZ - 200Hz
* ADXL362_ODR_400_HZ - 400Hz
*/
ret = adxl362_set_output_rate(dev, ADXL362_DEFAULT_ODR_ACC);
if (ret) {
return ret;
}
/* Places the device into measure mode, enable wakeup mode and autosleep if desired. */
LOG_DBG("setting pwrctl: 0x%02x", config->power_ctl);
ret = adxl362_set_reg(dev, config->power_ctl, ADXL362_REG_POWER_CTL, 1);
if (ret) {
return ret;
}
return 0;
}
/**
* @brief Initializes communication with the device and checks if the part is
* present by reading the device id.
*
* @return 0 - the initialization was successful and the device is present;
* -1 - an error occurred.
*
*/
static int adxl362_init(const struct device *dev)
{
const struct adxl362_config *config = dev->config;
uint8_t value = 0;
int err;
if (!spi_is_ready_dt(&config->bus)) {
LOG_DBG("spi device not ready: %s", config->bus.bus->name);
return -EINVAL;
}
err = adxl362_software_reset(dev);
if (err) {
LOG_ERR("adxl362_software_reset failed, error %d", err);
return -ENODEV;
}
k_sleep(K_MSEC(5));
(void)adxl362_get_reg(dev, &value, ADXL362_REG_PARTID, 1);
if (value != ADXL362_PART_ID) {
LOG_ERR("wrong part_id: %d", value);
return -ENODEV;
}
if (adxl362_chip_init(dev) < 0) {
return -ENODEV;
}
#if defined(CONFIG_ADXL362_TRIGGER)
if (config->interrupt.port) {
if (adxl362_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt!");
return -EIO;
}
if (adxl362_interrupt_config(dev,
config->int1_config,
config->int2_config) < 0) {
LOG_ERR("Failed to configure interrupt");
return -EIO;
}
}
#endif
return 0;
}
#define ADXL362_DEFINE(inst) \
static struct adxl362_data adxl362_data_##inst; \
\
static const struct adxl362_config adxl362_config_##inst = { \
.bus = SPI_DT_SPEC_INST_GET(inst, SPI_WORD_SET(8) | SPI_TRANSFER_MSB, 0), \
.power_ctl = ADXL362_POWER_CTL_MEASURE(ADXL362_MEASURE_ON) | \
(DT_INST_PROP(inst, wakeup_mode) * ADXL362_POWER_CTL_WAKEUP) | \
(DT_INST_PROP(inst, autosleep) * ADXL362_POWER_CTL_AUTOSLEEP), \
IF_ENABLED(CONFIG_ADXL362_TRIGGER, \
(.interrupt = GPIO_DT_SPEC_INST_GET_OR(inst, int1_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, adxl362_init, NULL, &adxl362_data_##inst, \
&adxl362_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &adxl362_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(ADXL362_DEFINE)
``` | /content/code_sandbox/drivers/sensor/adi/adxl362/adxl362.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,609 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adt7420
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include "adt7420.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ADT7420, CONFIG_SENSOR_LOG_LEVEL);
static int adt7420_temp_reg_read(const struct device *dev, uint8_t reg,
int16_t *val)
{
const struct adt7420_dev_config *cfg = dev->config;
if (i2c_burst_read_dt(&cfg->i2c, reg, (uint8_t *) val, 2) < 0) {
return -EIO;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
static int adt7420_temp_reg_write(const struct device *dev, uint8_t reg,
int16_t val)
{
const struct adt7420_dev_config *cfg = dev->config;
uint8_t buf[3] = {reg, val >> 8, val & 0xFF};
return i2c_write_dt(&cfg->i2c, buf, sizeof(buf));
}
static int adt7420_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct adt7420_dev_config *cfg = dev->config;
uint8_t val8, reg = 0U;
uint16_t rate;
int64_t value;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
rate = val->val1 * 1000 + val->val2 / 1000; /* rate in mHz */
switch (rate) {
case 240:
val8 = ADT7420_OP_MODE_CONT_CONV;
break;
case 1000:
val8 = ADT7420_OP_MODE_1_SPS;
break;
default:
return -EINVAL;
}
if (i2c_reg_update_byte_dt(&cfg->i2c,
ADT7420_REG_CONFIG,
ADT7420_CONFIG_OP_MODE(~0),
ADT7420_CONFIG_OP_MODE(val8)) < 0) {
LOG_DBG("Failed to set attribute!");
return -EIO;
}
return 0;
case SENSOR_ATTR_UPPER_THRESH:
reg = ADT7420_REG_T_HIGH_MSB;
__fallthrough;
case SENSOR_ATTR_LOWER_THRESH:
if (!reg) {
reg = ADT7420_REG_T_LOW_MSB;
}
if ((val->val1 > 150) || (val->val1 < -40)) {
return -EINVAL;
}
value = (int64_t)val->val1 * 1000000 + val->val2;
value = (value / ADT7420_TEMP_SCALE) << 1;
if (adt7420_temp_reg_write(dev, reg, value) < 0) {
LOG_DBG("Failed to set attribute!");
return -EIO;
}
return 0;
default:
return -ENOTSUP;
}
return 0;
}
static int adt7420_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct adt7420_data *drv_data = dev->data;
int16_t value;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_AMBIENT_TEMP);
if (adt7420_temp_reg_read(dev, ADT7420_REG_TEMP_MSB, &value) < 0) {
return -EIO;
}
drv_data->sample = value >> 1; /* use 15-bit only */
return 0;
}
static int adt7420_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct adt7420_data *drv_data = dev->data;
int32_t value;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
value = (int32_t)drv_data->sample * ADT7420_TEMP_SCALE;
val->val1 = value / 1000000;
val->val2 = value % 1000000;
return 0;
}
static const struct sensor_driver_api adt7420_driver_api = {
.attr_set = adt7420_attr_set,
.sample_fetch = adt7420_sample_fetch,
.channel_get = adt7420_channel_get,
#ifdef CONFIG_ADT7420_TRIGGER
.trigger_set = adt7420_trigger_set,
#endif
};
static int adt7420_probe(const struct device *dev)
{
const struct adt7420_dev_config *cfg = dev->config;
uint8_t value;
int ret;
ret = i2c_reg_read_byte_dt(&cfg->i2c, ADT7420_REG_ID, &value);
if (ret) {
return ret;
}
if (value != ADT7420_DEFAULT_ID) {
return -ENODEV;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c,
ADT7420_REG_CONFIG, ADT7420_CONFIG_RESOLUTION |
ADT7420_CONFIG_OP_MODE(ADT7420_OP_MODE_CONT_CONV));
if (ret) {
return ret;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c,
ADT7420_REG_HIST, CONFIG_ADT7420_TEMP_HYST);
if (ret) {
return ret;
}
ret = adt7420_temp_reg_write(dev, ADT7420_REG_T_CRIT_MSB,
(CONFIG_ADT7420_TEMP_CRIT * 1000000 /
ADT7420_TEMP_SCALE) << 1);
if (ret) {
return ret;
}
#ifdef CONFIG_ADT7420_TRIGGER
if (cfg->int_gpio.port) {
ret = adt7420_init_interrupt(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupt!");
return ret;
}
}
#endif
return 0;
}
static int adt7420_init(const struct device *dev)
{
const struct adt7420_dev_config *cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -EINVAL;
}
return adt7420_probe(dev);
}
#define ADT7420_DEFINE(inst) \
static struct adt7420_data adt7420_data_##inst; \
\
static const struct adt7420_dev_config adt7420_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
\
IF_ENABLED(CONFIG_ADT7420_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, adt7420_init, NULL, &adt7420_data_##inst, \
&adt7420_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &adt7420_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(ADT7420_DEFINE)
``` | /content/code_sandbox/drivers/sensor/adi/adt7420/adt7420.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,630 |
```objective-c
/*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADLTC2990_H
#define ZEPHYR_DRIVERS_SENSOR_ADLTC2990_H
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
enum adltc2990_monitor_pins {
V1,
V2,
V3,
V4,
INTERNAL_TEMPERATURE,
SUPPLY_VOLTAGE
};
enum adltc2990_monitoring_type {
NOTHING,
VOLTAGE_DIFFERENTIAL,
VOLTAGE_SINGLEENDED,
TEMPERATURE
};
union voltage_divider_resistors {
struct {
uint32_t v1_r1_r2[2];
uint32_t v2_r1_r2[2];
};
struct {
uint32_t v3_r1_r2[2];
uint32_t v4_r1_r2[2];
};
};
struct pins_configuration {
uint32_t pins_current_resistor;
union voltage_divider_resistors voltage_divider_resistors;
};
struct adltc2990_data {
int32_t internal_temperature;
int32_t supply_voltage;
int32_t pins_v1_v2_values[2];
int32_t pins_v3_v4_values[2];
};
struct adltc2990_config {
struct i2c_dt_spec bus;
uint8_t temp_format;
uint8_t acq_format;
uint8_t measurement_mode[2];
struct pins_configuration pins_v1_v2;
struct pins_configuration pins_v3_v4;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_ADLTC2990_H */
``` | /content/code_sandbox/drivers/sensor/adi/adltc2990/adltc2990.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 358 |
```objective-c
/*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADLTC2990_ADLTC2990_EMUL_H
#define ZEPHYR_DRIVERS_SENSOR_ADLTC2990_ADLTC2990_EMUL_H
#include <zephyr/drivers/emul.h>
#include <zephyr/drivers/i2c.h>
void adltc2990_emul_set_reg(const struct emul *target, uint8_t reg_addr, const uint8_t *val);
void adltc2990_emul_get_reg(const struct emul *target, uint8_t reg_addr, uint8_t *val);
void adltc2990_emul_reset(const struct emul *target);
#endif /* ZEPHYR_DRIVERS_SENSOR_ADLTC2990_ADLTC2990_EMUL_H */
``` | /content/code_sandbox/drivers/sensor/adi/adltc2990/adltc2990_emul.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 166 |
```unknown
# ADLTC2990 Quad I2C Voltage, Current and Temperature sensor configuration options
config ADLTC2990
bool "ADLTC2990 Quad I2C Voltage, Current and Temperature Monitor"
default y
depends on DT_HAS_ADI_ADLTC2990_ENABLED
select I2C
help
Enable the driver for Analog Devices LTC2990
Quad I2C Voltage, Current and Temperature Monitor.
config EMUL_ADLTC2990
bool "Emulator for ADLTC2990"
default y
depends on ADLTC2990
depends on EMUL
help
Enable ADLTC2990 emulator.
``` | /content/code_sandbox/drivers/sensor/adi/adltc2990/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 141 |
```objective-c
/*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADLTC2990_REG_H
#define ZEPHYR_DRIVERS_SENSOR_ADLTC2990_REG_H
#define ADLTC2990_REG_STATUS 0x00U
#define ADLTC2990_REG_CONTROL 0x01U
#define ADLTC2990_REG_TRIGGER 0x02U
#define ADLTC2990_REG_UNUSED 0x03U
#define ADLTC2990_REG_INTERNAL_TEMP_MSB 0x04U
#define ADLTC2990_REG_INTERNAL_TEMP_LSB 0x05U
#define ADLTC2990_REG_V1_MSB 0x06U
#define ADLTC2990_REG_V1_LSB 0x07U
#define ADLTC2990_REG_V2_MSB 0x08U
#define ADLTC2990_REG_V2_LSB 0x09U
#define ADLTC2990_REG_V3_MSB 0x0AU
#define ADLTC2990_REG_V3_LSB 0x0BU
#define ADLTC2990_REG_V4_MSB 0x0CU
#define ADLTC2990_REG_V4_LSB 0x0DU
#define ADLTC2990_REG_VCC_MSB 0x0EU
#define ADLTC2990_REG_VCC_LSB 0x0FU
#define ADLTC2990_VOLTAGE_SINGLE_ENDED_VALUES 2U
#define ADLTC2990_VOLTAGE_DIFF_VALUES 1U
#define ADLTC2990_TEMP_VALUES 1U
#define ADLTC2990_CURRENT_VALUES 1U
#define ADLTC2990_MICROOHM_CONVERSION_FACTOR 1000000U
#define ADLTC2990_MODE_V1_V2_TR2 0U
#define ADLTC2990_MODE_V1_MINUS_V2_TR2 1U
#define ADLTC2990_MODE_V1_MINUS_V2_V3_V4 2U
#define ADLTC2990_MODE_TR1_V3_V4 3U
#define ADLTC2990_MODE_TR1_V3_MINUS_V4 4U
#define ADLTC2990_MODE_TR1_TR2 5U
#define ADLTC2990_MODE_V1_MINUS_V2_V3_MINUS_V4 6U
#define ADLTC2990_MODE_V1_V2_V3_V4 7U
#define ADLTC2990_MEASURE_INTERNAL_TEMPERATURE_ONLY 0U
#define ADLTC2990_MEASURE_PINS_V1_V2_ONLY 1U
#define ADLTC2990_MEASURE_PINS_V3_V4_ONLY 2U
#define ADLTC2990_MEASURE_ALL_PINS_PER_MODE_2_0 3U
#define ADLTC2990_VOLTAGE_SINGLEENDED_CONVERSION_FACTOR 30518U
#define ADLTC2990_VOLTAGE_DIFFERENTIAL_CONVERSION_FACTOR 1942U
#define ADLTC2990_TEMPERATURE_CONVERSION_FACTOR 62500U
#define ADLTC2990_MODE_2_0_MAX_VALUE 7U
#define ADLTC2990_MODE_4_3_MAX_VALUE 3U
#define ADLTC2990_TEMPERATURE_FORMAT_CELSIUS 0U
#endif /* ZEPHYR_DRIVERS_SENSOR_ADLTC2990_REG_H */
``` | /content/code_sandbox/drivers/sensor/adi/adltc2990/adltc2990_reg.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 727 |
```c
/*
*/
#define DT_DRV_COMPAT adi_adltc2990
#include <zephyr/device.h>
#include <zephyr/drivers/emul.h>
#include <zephyr/drivers/emul_sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/i2c_emul.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/util.h>
#include "adltc2990.h"
#include "adltc2990_reg.h"
#include "adltc2990_emul.h"
LOG_MODULE_DECLARE(adltc2990, CONFIG_SENSOR_LOG_LEVEL);
#define ADLTC2990_NUM_REGS ADLTC2990_REG_VCC_LSB
struct adltc2990_emul_data {
uint8_t reg[ADLTC2990_NUM_REGS];
};
struct adltc2990_emul_cfg {
};
void adltc2990_emul_set_reg(const struct emul *target, uint8_t reg_addr, const uint8_t *val)
{
struct adltc2990_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr <= ADLTC2990_NUM_REGS);
memcpy(data->reg + reg_addr, val, 1);
}
void adltc2990_emul_get_reg(const struct emul *target, uint8_t reg_addr, uint8_t *val)
{
struct adltc2990_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr <= ADLTC2990_NUM_REGS);
memcpy(val, data->reg + reg_addr, 1);
}
void adltc2990_emul_reset(const struct emul *target)
{
struct adltc2990_emul_data *data = target->data;
memset(data->reg, 0, ADLTC2990_NUM_REGS);
}
static int adltc2990_emul_handle_write(const struct emul *target, uint8_t regn, uint8_t value)
{
struct adltc2990_emul_data *data = target->data;
switch (regn) {
case ADLTC2990_REG_CONTROL:
data->reg[ADLTC2990_REG_CONTROL] = value;
break;
case ADLTC2990_REG_TRIGGER:
data->reg[ADLTC2990_REG_TRIGGER] = value;
break;
default:
break;
}
return 0;
}
static int adltc2990_emul_transfer_i2c(const struct emul *target, struct i2c_msg *msgs,
int num_msgs, int addr)
{
struct adltc2990_emul_data *data = target->data;
i2c_dump_msgs_rw(target->dev, msgs, num_msgs, addr, false);
if (num_msgs < 1) {
LOG_ERR("Invalid number of messages: %d", num_msgs);
return -EIO;
}
if (FIELD_GET(I2C_MSG_READ, msgs->flags)) {
LOG_ERR("Unexpected read");
return -EIO;
}
if (msgs->len < 1) {
LOG_ERR("Unexpected msg0 length %d", msgs->len);
return -EIO;
}
uint8_t regn = msgs->buf[0];
bool is_read = FIELD_GET(I2C_MSG_READ, msgs->flags) == 1;
bool is_stop = FIELD_GET(I2C_MSG_STOP, msgs->flags) == 1;
if (!is_stop && !is_read) {
/* First message was a write with the register number, check next message */
msgs++;
is_read = FIELD_GET(I2C_MSG_READ, msgs->flags) == 1;
is_stop = FIELD_GET(I2C_MSG_STOP, msgs->flags) == 1;
}
if (is_read) {
for (int i = 0; i < msgs->len; ++i) {
msgs->buf[i] = data->reg[regn + i];
}
} else {
int rc = adltc2990_emul_handle_write(target, regn, msgs->buf[1]);
if (rc != 0) {
return rc;
}
}
return 0;
};
static int adltc2990_emul_init(const struct emul *target, const struct device *parent)
{
ARG_UNUSED(parent);
adltc2990_emul_reset(target);
return 0;
}
static const struct i2c_emul_api adltc2990_emul_api_i2c = {
.transfer = adltc2990_emul_transfer_i2c,
};
#define ADLTC2990_EMUL(n) \
const struct adltc2990_emul_cfg adltc2990_emul_cfg_##n; \
struct adltc2990_emul_data adltc2990_emul_data_##n; \
EMUL_DT_INST_DEFINE(n, adltc2990_emul_init, &adltc2990_emul_data_##n, \
&adltc2990_emul_cfg_##n, &adltc2990_emul_api_i2c, NULL)
DT_INST_FOREACH_STATUS_OKAY(ADLTC2990_EMUL)
``` | /content/code_sandbox/drivers/sensor/adi/adltc2990/adltc2990_emul.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,105 |
```c
/*
*/
#define DT_DRV_COMPAT adi_adltc2990
#include <zephyr/sys/util.h>
#include <zephyr/drivers/i2c.h>
#include "adltc2990_reg.h"
#include "adltc2990.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(adltc2990, CONFIG_SENSOR_LOG_LEVEL);
static enum adltc2990_monitoring_type adltc2990_get_v1_v2_measurement_modes(uint8_t mode_4_3,
uint8_t mode_2_0)
{
if (mode_2_0 > ADLTC2990_MODE_2_0_MAX_VALUE || mode_4_3 > ADLTC2990_MODE_4_3_MAX_VALUE) {
LOG_ERR("Invalid Measurement Mode");
return -EINVAL;
}
if (mode_4_3 == ADLTC2990_MEASURE_INTERNAL_TEMPERATURE_ONLY ||
mode_4_3 == ADLTC2990_MEASURE_PINS_V3_V4_ONLY) {
return NOTHING;
}
enum adltc2990_monitoring_type type = NOTHING;
switch (mode_2_0) {
case ADLTC2990_MODE_V1_V2_TR2:
case ADLTC2990_MODE_V1_V2_V3_V4: {
type = VOLTAGE_SINGLEENDED;
break;
}
case ADLTC2990_MODE_V1_MINUS_V2_TR2:
case ADLTC2990_MODE_V1_MINUS_V2_V3_V4:
case ADLTC2990_MODE_V1_MINUS_V2_V3_MINUS_V4: {
type = VOLTAGE_DIFFERENTIAL;
break;
}
case ADLTC2990_MODE_TR1_V3_V4:
case ADLTC2990_MODE_TR1_V3_MINUS_V4: {
case ADLTC2990_MODE_TR1_TR2:
type = TEMPERATURE;
break;
}
default: {
break;
}
}
return type;
}
static enum adltc2990_monitoring_type adltc2990_get_v3_v4_measurement_modes(uint8_t mode_4_3,
uint8_t mode_2_0)
{
if (mode_2_0 > ADLTC2990_MODE_2_0_MAX_VALUE || mode_4_3 > ADLTC2990_MODE_4_3_MAX_VALUE) {
LOG_ERR("Invalid Measurement Mode");
return -EINVAL;
}
if (mode_4_3 == ADLTC2990_MEASURE_INTERNAL_TEMPERATURE_ONLY ||
mode_4_3 == ADLTC2990_MEASURE_PINS_V1_V2_ONLY) {
return NOTHING;
}
enum adltc2990_monitoring_type type = NOTHING;
switch (mode_2_0) {
case ADLTC2990_MODE_V1_V2_TR2:
case ADLTC2990_MODE_V1_MINUS_V2_TR2:
case ADLTC2990_MODE_TR1_TR2: {
type = TEMPERATURE;
break;
}
case ADLTC2990_MODE_V1_MINUS_V2_V3_V4:
case ADLTC2990_MODE_TR1_V3_V4:
case ADLTC2990_MODE_V1_V2_V3_V4: {
type = VOLTAGE_SINGLEENDED;
break;
}
case ADLTC2990_MODE_TR1_V3_MINUS_V4:
case ADLTC2990_MODE_V1_MINUS_V2_V3_MINUS_V4: {
type = VOLTAGE_DIFFERENTIAL;
break;
}
default: {
break;
}
}
return type;
}
static int adltc2990_is_busy(const struct device *dev, bool *is_busy)
{
const struct adltc2990_config *cfg = dev->config;
uint8_t status_reg = 0;
int ret;
ret = i2c_reg_read_byte_dt(&cfg->bus, ADLTC2990_REG_STATUS, &status_reg);
if (ret) {
return ret;
}
*is_busy = status_reg & BIT(0);
return 0;
}
static void adltc2990_get_v1_v2_val(const struct device *dev, struct sensor_value *val,
uint8_t num_values, uint8_t *const offset_index)
{
struct adltc2990_data *data = dev->data;
for (uint8_t index = 0; index < num_values; index++) {
val[index].val1 = data->pins_v1_v2_values[index] / 1000000;
val[index].val2 = data->pins_v1_v2_values[index] % 1000000;
*offset_index = index + 1;
}
}
static void adltc2990_get_v3_v4_val(const struct device *dev, struct sensor_value *val,
uint8_t num_values, uint8_t const *const offset)
{
struct adltc2990_data *data = dev->data;
uint8_t offset_index = *offset;
for (uint8_t index = 0; index < num_values; index++) {
val[index + offset_index].val1 = data->pins_v3_v4_values[index] / 1000000;
val[index + offset_index].val2 = data->pins_v3_v4_values[index] % 1000000;
}
}
static int adltc2990_trigger_measurement(const struct device *dev)
{
const struct adltc2990_config *cfg = dev->config;
return i2c_reg_write_byte_dt(&cfg->bus, ADLTC2990_REG_TRIGGER, 0x1);
}
static int adltc2990_fetch_property_value(const struct device *dev,
enum adltc2990_monitoring_type type,
enum adltc2990_monitor_pins pin,
int32_t *output)
{
const struct adltc2990_config *cfg = dev->config;
uint8_t msb_value = 0, lsb_value = 0;
uint8_t msb_address, lsb_address;
switch (pin) {
case V1: {
msb_address = ADLTC2990_REG_V1_MSB;
lsb_address = ADLTC2990_REG_V1_LSB;
break;
}
case V2: {
msb_address = ADLTC2990_REG_V2_MSB;
lsb_address = ADLTC2990_REG_V2_LSB;
break;
}
case V3: {
msb_address = ADLTC2990_REG_V3_MSB;
lsb_address = ADLTC2990_REG_V3_LSB;
break;
}
case V4: {
msb_address = ADLTC2990_REG_V4_MSB;
lsb_address = ADLTC2990_REG_V4_LSB;
break;
}
case INTERNAL_TEMPERATURE: {
msb_address = ADLTC2990_REG_INTERNAL_TEMP_MSB;
lsb_address = ADLTC2990_REG_INTERNAL_TEMP_LSB;
break;
}
case SUPPLY_VOLTAGE: {
msb_address = ADLTC2990_REG_VCC_MSB;
lsb_address = ADLTC2990_REG_VCC_LSB;
break;
}
default: {
LOG_ERR("Trying to access illegal register");
return -EINVAL;
}
}
int ret;
ret = i2c_reg_read_byte_dt(&cfg->bus, msb_address, &msb_value);
if (ret) {
return ret;
}
ret = i2c_reg_read_byte_dt(&cfg->bus, lsb_address, &lsb_value);
if (ret) {
return ret;
}
uint16_t conversion_factor;
uint8_t negative_bit_index = 14U, sensor_val_divisor = 100U;
if (type == VOLTAGE_SINGLEENDED) {
conversion_factor = ADLTC2990_VOLTAGE_SINGLEENDED_CONVERSION_FACTOR;
} else if (type == VOLTAGE_DIFFERENTIAL) {
conversion_factor = ADLTC2990_VOLTAGE_DIFFERENTIAL_CONVERSION_FACTOR;
} else if (type == TEMPERATURE) {
conversion_factor = ADLTC2990_TEMPERATURE_CONVERSION_FACTOR;
if (cfg->temp_format == ADLTC2990_TEMPERATURE_FORMAT_CELSIUS) {
negative_bit_index = 12U;
}
sensor_val_divisor = 1U;
} else {
LOG_ERR("unknown type");
return -EINVAL;
}
int16_t value = (msb_value << 8) + lsb_value;
int32_t voltage_value = (value << (31 - negative_bit_index)) >> (31 - negative_bit_index);
*output = (voltage_value * conversion_factor) / sensor_val_divisor;
return 0;
}
static int adltc2990_init(const struct device *dev)
{
const struct adltc2990_config *cfg = dev->config;
if (!i2c_is_ready_dt(&cfg->bus)) {
LOG_ERR("I2C bus %s not ready", cfg->bus.bus->name);
return -ENODEV;
}
const uint8_t ctrl_reg_setting = cfg->temp_format << 7 | cfg->acq_format << 6 | 0 << 5 |
cfg->measurement_mode[1] << 3 | cfg->measurement_mode[0];
LOG_DBG("Setting Control Register to: 0x%x", ctrl_reg_setting);
int err = i2c_reg_write_byte_dt(&cfg->bus, ADLTC2990_REG_CONTROL, ctrl_reg_setting);
if (err < 0) {
LOG_ERR("configuring for single bus failed: %d", err);
return err;
}
LOG_INF("Initializing ADLTC2990 with name %s", dev->name);
return 0;
}
static int adltc2990_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct adltc2990_data *data = dev->data;
const struct adltc2990_config *cfg = dev->config;
enum adltc2990_monitoring_type mode_v1_v2 = adltc2990_get_v1_v2_measurement_modes(
cfg->measurement_mode[1], cfg->measurement_mode[0]);
enum adltc2990_monitoring_type mode_v3_v4 = adltc2990_get_v3_v4_measurement_modes(
cfg->measurement_mode[1], cfg->measurement_mode[0]);
float voltage_divider_ratio;
int ret;
int32_t value;
switch (chan) {
case SENSOR_CHAN_DIE_TEMP: {
ret = adltc2990_fetch_property_value(dev, TEMPERATURE, INTERNAL_TEMPERATURE,
&value);
if (ret) {
return ret;
}
data->internal_temperature = value;
break;
}
case SENSOR_CHAN_CURRENT: {
if (!(mode_v1_v2 == VOLTAGE_DIFFERENTIAL || mode_v3_v4 == VOLTAGE_DIFFERENTIAL)) {
LOG_ERR("Sensor is not configured to measure Current");
return -EINVAL;
}
if (mode_v1_v2 == VOLTAGE_DIFFERENTIAL) {
ret = adltc2990_fetch_property_value(dev, VOLTAGE_DIFFERENTIAL, V1, &value);
if (ret) {
return ret;
}
data->pins_v1_v2_values[0] =
value * (ADLTC2990_MICROOHM_CONVERSION_FACTOR /
(float)cfg->pins_v1_v2.pins_current_resistor);
}
if (mode_v3_v4 == VOLTAGE_DIFFERENTIAL) {
ret = adltc2990_fetch_property_value(dev, VOLTAGE_DIFFERENTIAL, V3, &value);
if (ret) {
return ret;
}
data->pins_v3_v4_values[0] = value * (ADLTC2990_MICROOHM_CONVERSION_FACTOR /
(float)cfg->pins_v3_v4.pins_current_resistor);
}
break;
}
case SENSOR_CHAN_VOLTAGE: {
ret = adltc2990_fetch_property_value(dev, VOLTAGE_SINGLEENDED, SUPPLY_VOLTAGE,
&value);
if (ret) {
return ret;
}
data->supply_voltage = value + 2500000;
if (mode_v1_v2 == VOLTAGE_DIFFERENTIAL) {
ret = adltc2990_fetch_property_value(dev, VOLTAGE_DIFFERENTIAL, V1, &value);
if (ret) {
return ret;
}
data->pins_v1_v2_values[0] = value;
} else if (mode_v1_v2 == VOLTAGE_SINGLEENDED) {
uint32_t v1_r1 = cfg->pins_v1_v2.voltage_divider_resistors.v1_r1_r2[0];
uint32_t v1_r2 = cfg->pins_v1_v2.voltage_divider_resistors.v1_r1_r2[1];
voltage_divider_ratio = (v1_r1 + v1_r2) / (float)v1_r2;
ret = adltc2990_fetch_property_value(dev, VOLTAGE_SINGLEENDED, V1, &value);
if (ret) {
return ret;
}
data->pins_v1_v2_values[0] = value * voltage_divider_ratio;
uint32_t v2_r1 = cfg->pins_v1_v2.voltage_divider_resistors.v2_r1_r2[0];
uint32_t v2_r2 = cfg->pins_v1_v2.voltage_divider_resistors.v2_r1_r2[1];
voltage_divider_ratio = (v2_r1 + v2_r2) / (float)v2_r2;
ret = adltc2990_fetch_property_value(dev, VOLTAGE_SINGLEENDED, V2, &value);
if (ret) {
return ret;
}
data->pins_v1_v2_values[1] = value * voltage_divider_ratio;
}
if (mode_v3_v4 == VOLTAGE_DIFFERENTIAL) {
ret = adltc2990_fetch_property_value(dev, VOLTAGE_DIFFERENTIAL, V3, &value);
if (ret) {
return ret;
}
data->pins_v3_v4_values[0] = value;
} else if (mode_v3_v4 == VOLTAGE_SINGLEENDED) {
uint32_t v3_r1 = cfg->pins_v3_v4.voltage_divider_resistors.v3_r1_r2[0];
uint32_t v3_r2 = cfg->pins_v3_v4.voltage_divider_resistors.v3_r1_r2[1];
voltage_divider_ratio = (v3_r1 + v3_r2) / (float)v3_r2;
ret = adltc2990_fetch_property_value(dev, VOLTAGE_SINGLEENDED, V3, &value);
if (ret) {
return ret;
}
data->pins_v3_v4_values[0] = value * voltage_divider_ratio;
uint32_t v4_r1 = cfg->pins_v3_v4.voltage_divider_resistors.v4_r1_r2[0];
uint32_t v4_r2 = cfg->pins_v3_v4.voltage_divider_resistors.v4_r1_r2[1];
voltage_divider_ratio = (v4_r1 + v4_r2) / (float)v4_r2;
ret = adltc2990_fetch_property_value(dev, VOLTAGE_SINGLEENDED, V4, &value);
if (ret) {
return ret;
}
data->pins_v3_v4_values[1] = value * voltage_divider_ratio;
}
break;
}
case SENSOR_CHAN_AMBIENT_TEMP: {
if (!(mode_v1_v2 == TEMPERATURE || mode_v3_v4 == TEMPERATURE)) {
LOG_ERR("Sensor is not configured to measure Ambient Temperature");
return -EINVAL;
}
if (mode_v1_v2 == TEMPERATURE) {
ret = adltc2990_fetch_property_value(dev, TEMPERATURE, V1, &value);
if (ret) {
return ret;
}
data->pins_v1_v2_values[0] = value;
}
if (mode_v3_v4 == TEMPERATURE) {
ret = adltc2990_fetch_property_value(dev, TEMPERATURE, V3, &value);
if (ret) {
return ret;
}
data->pins_v3_v4_values[0] = value;
}
break;
}
case SENSOR_CHAN_ALL: {
bool is_busy;
ret = adltc2990_is_busy(dev, &is_busy);
if (ret) {
return ret;
}
if (is_busy) {
LOG_INF("ADLTC2990 conversion ongoing");
return -EBUSY;
}
adltc2990_trigger_measurement(dev);
break;
}
default: {
LOG_ERR("does not measure channel: %d", chan);
return -ENOTSUP;
}
}
return 0;
}
static int adltc2990_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
if (val == NULL) {
LOG_ERR("Argument of type sensor_value* cannot be null ");
return -EINVAL;
}
struct adltc2990_data *data = dev->data;
const struct adltc2990_config *cfg = dev->config;
enum adltc2990_monitoring_type mode_v1_v2 = adltc2990_get_v1_v2_measurement_modes(
cfg->measurement_mode[1], cfg->measurement_mode[0]);
enum adltc2990_monitoring_type mode_v3_v4 = adltc2990_get_v3_v4_measurement_modes(
cfg->measurement_mode[1], cfg->measurement_mode[0]);
uint8_t offset_index = 0, num_values_v1_v2 = 0, num_values_v3_v4 = 0;
switch (chan) {
case SENSOR_CHAN_DIE_TEMP: {
val->val1 = (data->internal_temperature) / 1000000;
val->val2 = (data->internal_temperature) % 1000000;
LOG_DBG("Internal Temperature Value is:%d.%d", val->val1, val->val2);
break;
}
case SENSOR_CHAN_VOLTAGE: {
if (mode_v1_v2 == VOLTAGE_SINGLEENDED) {
LOG_DBG("Getting V1,V2");
num_values_v1_v2 = ADLTC2990_VOLTAGE_SINGLE_ENDED_VALUES;
} else if (mode_v1_v2 == VOLTAGE_DIFFERENTIAL) {
LOG_DBG("Getting V3-V4");
num_values_v1_v2 = ADLTC2990_VOLTAGE_DIFF_VALUES;
}
if (mode_v3_v4 == VOLTAGE_SINGLEENDED) {
LOG_DBG("Getting V3,V4");
num_values_v3_v4 = ADLTC2990_VOLTAGE_SINGLE_ENDED_VALUES;
} else if (mode_v3_v4 == VOLTAGE_DIFFERENTIAL) {
LOG_DBG("Getting V3-V4");
num_values_v3_v4 = ADLTC2990_VOLTAGE_DIFF_VALUES;
}
/* Add VCC to the last index */
val[num_values_v1_v2 + num_values_v3_v4].val1 = data->supply_voltage / 1000000;
val[num_values_v1_v2 + num_values_v3_v4].val2 = data->supply_voltage % 1000000;
break;
}
case SENSOR_CHAN_CURRENT: {
if (!(mode_v1_v2 == VOLTAGE_DIFFERENTIAL || mode_v3_v4 == VOLTAGE_DIFFERENTIAL)) {
LOG_ERR("Sensor is not configured to measure Current");
return -EINVAL;
}
if (mode_v1_v2 == VOLTAGE_DIFFERENTIAL && mode_v3_v4 == VOLTAGE_DIFFERENTIAL) {
LOG_DBG("Getting I12 and I34");
num_values_v1_v2 = ADLTC2990_CURRENT_VALUES;
num_values_v3_v4 = ADLTC2990_CURRENT_VALUES;
} else if (mode_v1_v2 == VOLTAGE_DIFFERENTIAL) {
LOG_DBG("Getting I12");
num_values_v1_v2 = ADLTC2990_CURRENT_VALUES;
} else if (mode_v3_v4 == VOLTAGE_DIFFERENTIAL) {
LOG_DBG("Getting I34");
num_values_v3_v4 = ADLTC2990_CURRENT_VALUES;
}
break;
}
case SENSOR_CHAN_AMBIENT_TEMP: {
if (!(mode_v1_v2 == TEMPERATURE || mode_v3_v4 == TEMPERATURE)) {
LOG_ERR("Sensor is not configured to measure Ambient Temperature");
return -EINVAL;
}
if (mode_v1_v2 == TEMPERATURE && mode_v3_v4 == TEMPERATURE) {
LOG_DBG("Getting T12 and T34");
num_values_v1_v2 = ADLTC2990_TEMP_VALUES;
num_values_v3_v4 = ADLTC2990_TEMP_VALUES;
} else if (mode_v1_v2 == TEMPERATURE) {
LOG_DBG("Getting T12");
num_values_v1_v2 = ADLTC2990_TEMP_VALUES;
} else if (mode_v3_v4 == TEMPERATURE) {
LOG_DBG("Getting T34");
num_values_v3_v4 = ADLTC2990_TEMP_VALUES;
}
break;
}
default: {
return -ENOTSUP;
}
}
adltc2990_get_v1_v2_val(dev, val, num_values_v1_v2, &offset_index);
adltc2990_get_v3_v4_val(dev, val, num_values_v3_v4, &offset_index);
return 0;
}
static const struct sensor_driver_api adltc2990_driver_api = {
.sample_fetch = adltc2990_sample_fetch,
.channel_get = adltc2990_channel_get,
};
#define ADLTC2990_DEFINE(inst) \
static struct adltc2990_data adltc2990_data_##inst; \
static const struct adltc2990_config adltc2990_config_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
.temp_format = DT_INST_PROP(inst, temperature_format), \
.acq_format = DT_INST_PROP(inst, acquistion_format), \
.measurement_mode = DT_INST_PROP(inst, measurement_mode), \
.pins_v1_v2.pins_current_resistor = \
DT_INST_PROP_OR(inst, pins_v1_v2_current_resistor, 1), \
.pins_v1_v2.voltage_divider_resistors.v1_r1_r2 = \
DT_INST_PROP_OR(inst, pin_v1_voltage_divider_resistors, NULL), \
.pins_v1_v2.voltage_divider_resistors.v2_r1_r2 = \
DT_INST_PROP_OR(inst, pin_v2_voltage_divider_resistors, NULL), \
.pins_v3_v4.pins_current_resistor = \
DT_INST_PROP_OR(inst, pins_v3_v4_current_resistor, 1), \
.pins_v3_v4.voltage_divider_resistors.v3_r1_r2 = \
DT_INST_PROP_OR(inst, pin_v3_voltage_divider_resistors, NULL), \
.pins_v3_v4.voltage_divider_resistors.v4_r1_r2 = \
DT_INST_PROP_OR(inst, pin_v4_voltage_divider_resistors, NULL)}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, adltc2990_init, NULL, &adltc2990_data_##inst, \
&adltc2990_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &adltc2990_driver_api);
DT_INST_FOREACH_STATUS_OKAY(ADLTC2990_DEFINE)
``` | /content/code_sandbox/drivers/sensor/adi/adltc2990/adltc2990.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,285 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adt7310
#include <string.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include "adt7310.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ADT7310, CONFIG_SENSOR_LOG_LEVEL);
#define ADT7310_READ_CMD BIT(6)
#define ADT7310_WRITE_CMD 0
#define ADT7310_REG_STATUS 0x00
#define ADT7310_REG_CONFIG 0x01
#define ADT7310_REG_TEMP 0x02
#define ADT7310_REG_ID 0x03
#define ADT7310_REG_HYST 0x05
#define ADT7310_REG_THRESH_HIGH 0x06
#define ADT7310_REG_THRESH_LOW 0x07
#define ADT7310_ID 0xc0
#define ADT7310_CONFIG_OP_MODE_MASK (0x3 << 5)
#define ADT7310_CONFIG_OP_MODE_CONTINUOUS (0x0 << 5)
#define ADT7310_CONFIG_OP_MODE_1SPS (0x2 << 5)
#define ADT7310_HYSTERESIS_TEMP_MAX 15
#define ADT7310_CONFIG_RESOLUTION_16BIT BIT(7)
#define ADT7310_CONFIG_INT_COMPARATOR_MODE BIT(4)
/* Continuous conversion time = 240ms -> 1/0.240*1000000 */
#define ADT7310_MAX_SAMPLE_RATE 4166666
/* The quantization step size at 16-bit resolution is 0.0078125. */
/* Ref ADT7310 Reference manual */
#define ADT7310_SAMPLE_TO_MICRO_DEG(x) ((x) * 15625 >> 1)
#define ADT7310_MICRO_DEG_TO_SAMPLE(x) ((x) / 15625 << 1)
static int adt7310_temp_reg_read(const struct device *dev, uint8_t reg, int16_t *val)
{
const struct adt7310_dev_config *cfg = dev->config;
uint8_t cmd_buf[3] = { ADT7310_READ_CMD | (reg << 3) };
int ret;
const struct spi_buf tx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf rx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf_set tx = { .buffers = &tx_buf, .count = 1 };
const struct spi_buf_set rx = { .buffers = &rx_buf, .count = 1 };
ret = spi_transceive_dt(&cfg->bus, &tx, &rx);
if (ret < 0) {
return ret;
}
memcpy(val, cmd_buf + 1, 2);
*val = sys_be16_to_cpu(*val);
return 0;
}
static int adt7310_temp_reg_write(const struct device *dev, uint8_t reg, int16_t val)
{
const struct adt7310_dev_config *cfg = dev->config;
uint8_t cmd_buf[3];
const struct spi_buf tx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf rx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf_set tx = { .buffers = &tx_buf, .count = 1 };
const struct spi_buf_set rx = { .buffers = &rx_buf, .count = 1 };
cmd_buf[0] = ADT7310_WRITE_CMD | (reg << 3);
val = sys_cpu_to_be16(val);
memcpy(&cmd_buf[1], &val, sizeof(val));
return spi_transceive_dt(&cfg->bus, &tx, &rx);
}
static int adt7310_reg_read(const struct device *dev, uint8_t reg, uint8_t *val)
{
const struct adt7310_dev_config *cfg = dev->config;
uint8_t cmd_buf[2] = { ADT7310_READ_CMD | (reg << 3) };
const struct spi_buf tx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf rx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf_set tx = { .buffers = &tx_buf, .count = 1 };
const struct spi_buf_set rx = { .buffers = &rx_buf, .count = 1 };
int ret;
ret = spi_transceive_dt(&cfg->bus, &tx, &rx);
if (ret < 0) {
return ret;
}
*val = cmd_buf[1];
return 0;
}
static int adt7310_reg_write(const struct device *dev, uint8_t reg, uint8_t val)
{
const struct adt7310_dev_config *cfg = dev->config;
uint8_t cmd_buf[2] = { ADT7310_WRITE_CMD | (reg << 3), val };
const struct spi_buf tx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf rx_buf = { .buf = cmd_buf, .len = sizeof(cmd_buf) };
const struct spi_buf_set tx = { .buffers = &tx_buf, .count = 1 };
const struct spi_buf_set rx = { .buffers = &rx_buf, .count = 1 };
return spi_transceive_dt(&cfg->bus, &tx, &rx);
}
static int adt7310_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct adt7310_data *drv_data = dev->data;
int16_t value;
int ret;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
ret = adt7310_temp_reg_read(dev, ADT7310_REG_TEMP, &value);
if (ret < 0) {
return ret;
}
drv_data->sample = value;
return 0;
}
static int adt7310_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
int32_t value;
struct adt7310_data *drv_data = dev->data;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
value = ADT7310_SAMPLE_TO_MICRO_DEG((int32_t)drv_data->sample);
val->val1 = value / 1000000;
val->val2 = value % 1000000;
return 0;
}
static int adt7310_update_reg(const struct device *dev, uint8_t reg, uint8_t value, uint8_t mask)
{
int ret;
uint8_t reg_value;
ret = adt7310_reg_read(dev, reg, ®_value);
if (ret < 0) {
return ret;
}
reg_value &= ~mask;
reg_value |= value;
return adt7310_reg_write(dev, reg, reg_value);
}
static int adt7310_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
int32_t rate, value;
uint8_t reg = 0;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
if (val->val1 > INT32_MAX/1000000 - 1 || val->val1 < INT32_MIN/1000000 + 1) {
return -EINVAL;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
rate = val->val1 * 1000000 + val->val2;
if (rate > ADT7310_MAX_SAMPLE_RATE || rate < 0) {
return -EINVAL;
}
if (rate > 1000000) {
return adt7310_update_reg(dev, ADT7310_REG_CONFIG,
ADT7310_CONFIG_OP_MODE_CONTINUOUS,
ADT7310_CONFIG_OP_MODE_MASK);
} else {
return adt7310_update_reg(dev, ADT7310_REG_CONFIG,
ADT7310_CONFIG_OP_MODE_1SPS,
ADT7310_CONFIG_OP_MODE_MASK);
}
case SENSOR_ATTR_HYSTERESIS:
if (val->val1 < 0 || val->val1 > ADT7310_HYSTERESIS_TEMP_MAX || val->val2 != 0) {
return -EINVAL;
}
return adt7310_reg_write(dev, ADT7310_REG_HYST, val->val1);
case SENSOR_ATTR_UPPER_THRESH:
reg = ADT7310_REG_THRESH_HIGH;
__fallthrough;
case SENSOR_ATTR_LOWER_THRESH:
if (!reg) {
reg = ADT7310_REG_THRESH_LOW;
}
value = val->val1 * 1000000 + val->val2;
value = ADT7310_MICRO_DEG_TO_SAMPLE(value);
if (value < INT16_MIN || value > INT16_MAX) {
return -EINVAL;
}
return adt7310_temp_reg_write(dev, reg, value);
default:
return -ENOTSUP;
}
return 0;
}
static int adt7310_probe(const struct device *dev)
{
uint8_t value;
int ret;
ret = adt7310_reg_read(dev, ADT7310_REG_ID, &value);
if (ret) {
return ret;
}
value &= 0xf8;
if (value != ADT7310_ID) {
LOG_ERR("Invalid device ID");
return -ENODEV;
}
return adt7310_reg_write(dev, ADT7310_REG_CONFIG,
ADT7310_CONFIG_RESOLUTION_16BIT |
ADT7310_CONFIG_INT_COMPARATOR_MODE);
}
static int adt7310_init(const struct device *dev)
{
const struct adt7310_dev_config *cfg = dev->config;
int ret;
if (!spi_is_ready_dt(&cfg->bus)) {
LOG_ERR("SPI bus %s not ready", cfg->bus.bus->name);
return -ENODEV;
}
ret = adt7310_probe(dev);
if (ret) {
return ret;
}
#if defined(CONFIG_ADT7310_TRIGGER)
if (cfg->int_gpio.port) {
ret = adt7310_init_interrupt(dev);
if (ret) {
LOG_ERR("Failed to initialize interrupt");
return ret;
}
}
#endif
return ret;
}
static const struct sensor_driver_api adt7310_driver_api = {
.attr_set = adt7310_attr_set,
.sample_fetch = adt7310_sample_fetch,
.channel_get = adt7310_channel_get,
#if defined(CONFIG_ADT7310_TRIGGER)
.trigger_set = adt7310_trigger_set,
#endif
};
#define ADT7310_DEFINE(inst) \
static struct adt7310_data adt7310_data_##inst; \
\
static const struct adt7310_dev_config adt7310_config_##inst = { \
.bus = SPI_DT_SPEC_INST_GET( \
inst, \
(SPI_WORD_SET(8) | SPI_TRANSFER_MSB | SPI_MODE_CPOL | SPI_MODE_CPHA), 0), \
\
IF_ENABLED(CONFIG_ADT7310_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, {0}),))}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, adt7310_init, NULL, &adt7310_data_##inst, \
&adt7310_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &adt7310_driver_api);
DT_INST_FOREACH_STATUS_OKAY(ADT7310_DEFINE)
``` | /content/code_sandbox/drivers/sensor/adi/adt7310/adt7310.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,570 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADT7310_H_
#define ZEPHYR_DRIVERS_SENSOR_ADT7310_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
int adt7310_init_interrupt(const struct device *dev);
int adt7310_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
struct adt7310_data {
int16_t sample;
#ifdef CONFIG_ADT7310_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t th_handler;
const struct sensor_trigger *th_trigger;
const struct device *dev;
#ifdef CONFIG_ADT7310_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADT7310_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif CONFIG_ADT7310_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
#endif /* CONFIG_ADT7310_TRIGGER */
};
struct adt7310_dev_config {
struct spi_dt_spec bus;
#ifdef CONFIG_ADT7310_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
#endif /* ZEPHYR_DRIVERS_SENSOR_ADT7310_H_ */
``` | /content/code_sandbox/drivers/sensor/adi/adt7310/adt7310.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 270 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#include <zephyr/types.h>
#include "adt7310.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ADT7310, CONFIG_SENSOR_LOG_LEVEL);
static void adt7310_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins)
{
struct adt7310_data *drv_data = CONTAINER_OF(cb, struct adt7310_data, gpio_cb);
#if defined(CONFIG_ADT7310_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ADT7310_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
#if defined(CONFIG_ADT7310_TRIGGER_OWN_THREAD)
static void adt7310_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct adt7310_data *drv_data = p1;
while (true) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
if (drv_data->th_handler != NULL) {
drv_data->th_handler(drv_data->dev, drv_data->th_trigger);
}
}
}
#elif defined(CONFIG_ADT7310_TRIGGER_GLOBAL_THREAD)
static void adt7310_work_cb(struct k_work *work)
{
struct adt7310_data *drv_data = CONTAINER_OF(work, struct adt7310_data, work);
if (drv_data->th_handler != NULL) {
drv_data->th_handler(drv_data->dev, drv_data->th_trigger);
}
}
#endif
int adt7310_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct adt7310_data *drv_data = dev->data;
const struct adt7310_dev_config *cfg = dev->config;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
if (trig->type != SENSOR_TRIG_THRESHOLD) {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
/* disable the interrupt but ignore error if it's first */
/* time this function is called */
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_DISABLE);
drv_data->th_handler = handler;
if (handler != NULL) {
int value, ret;
gpio_flags_t flags = GPIO_INT_EDGE_TO_ACTIVE;
drv_data->th_trigger = trig;
ret = gpio_pin_interrupt_configure_dt(&cfg->int_gpio, flags);
if (ret) {
drv_data->th_handler = NULL;
return ret;
}
value = gpio_pin_get_dt(&cfg->int_gpio);
if (value > 0) {
#if defined(CONFIG_ADT7310_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ADT7310_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
}
return 0;
}
int adt7310_init_interrupt(const struct device *dev)
{
struct adt7310_data *drv_data = dev->data;
const struct adt7310_dev_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;
}
gpio_init_callback(&drv_data->gpio_cb, adt7310_gpio_callback, BIT(cfg->int_gpio.pin));
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT | GPIO_ACTIVE_LOW);
if (ret < 0) {
return ret;
}
ret = gpio_add_callback(cfg->int_gpio.port, &drv_data->gpio_cb);
if (ret < 0) {
return ret;
}
drv_data->dev = dev;
#if defined(CONFIG_ADT7310_TRIGGER_OWN_THREAD)
k_sem_init(&drv_data->gpio_sem, 0, 1);
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_ADT7310_THREAD_STACK_SIZE,
adt7310_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_ADT7310_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ADT7310_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = adt7310_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/adi/adt7310/adt7310_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,012 |
```unknown
# ADT7310 temperature sensor configuration options
menuconfig ADT7310
bool "ADT7310 Temperature Sensor"
default y
depends on DT_HAS_ADI_ADT7310_ENABLED
select SPI
help
Enable the driver for Analog Devices ADT7310 High-Accuracy
16-bit Digital SPI Temperature Sensors.
if ADT7310
config ADT7310_TRIGGER
bool
depends on GPIO
choice
prompt "Sets trigger mode"
default ADT7310_TRIGGER_NONE
help
Sets thread type for the interrupt handler.
config ADT7310_TRIGGER_NONE
bool "No trigger"
config ADT7310_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
select ADT7310_TRIGGER
help
Use a global thread for the interrupt handler.
config ADT7310_TRIGGER_OWN_THREAD
bool "Use own thread"
select ADT7310_TRIGGER
help
Use a separate thread for the interrupt handler.
endchoice
if ADT7310_TRIGGER_OWN_THREAD
config ADT7310_THREAD_PRIORITY
int "Thread priority of the interrupt handler"
default 1
help
Thread priority of the interrupt handler. A higher number implies a
higher priority. The thread is cooperative and will not be interrupted by
another thread until execution is released.
config ADT7310_THREAD_STACK_SIZE
int "Stack size of the interrupt handler thread"
default 1024
help
Stack size of the interrupt handler thread.
endif # ADT7310_TRIGGER_OWN_THREAD
endif # ADT7310
``` | /content/code_sandbox/drivers/sensor/adi/adt7310/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 329 |
```c
/* adxl367_i2c.c - I2C routines for ADXL367 driver
*/
/*
*
*/
#define DT_DRV_COMPAT adi_adxl367
#include <string.h>
#include <zephyr/logging/log.h>
#include "adxl367.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(ADXL367, CONFIG_SENSOR_LOG_LEVEL);
static int adxl367_bus_access(const struct device *dev, uint8_t reg,
void *data, size_t length)
{
const struct adxl367_dev_config *config = dev->config;
if ((reg & ADXL367_READ) != 0) {
return i2c_burst_read_dt(&config->i2c,
ADXL367_TO_REG(reg),
(uint8_t *) data, length);
} else {
if (length != 1)
return -EINVAL;
return i2c_reg_write_byte_dt(&config->i2c,
ADXL367_TO_REG(reg),
*(uint8_t *)data);
}
}
static int adxl367_i2c_reg_read(const struct device *dev, uint8_t reg_addr,
uint8_t *reg_data)
{
return adxl367_bus_access(dev, ADXL367_REG_READ(reg_addr), reg_data, 1);
}
static int adxl367_i2c_reg_read_multiple(const struct device *dev,
uint8_t reg_addr,
uint8_t *reg_data,
uint16_t count)
{
return adxl367_bus_access(dev, ADXL367_REG_READ(reg_addr),
reg_data, count);
}
static int adxl367_i2c_reg_write(const struct device *dev,
uint8_t reg_addr,
uint8_t reg_data)
{
return adxl367_bus_access(dev, ADXL367_REG_WRITE(reg_addr),
®_data, 1);
}
int adxl367_i2c_reg_write_mask(const struct device *dev,
uint8_t reg_addr,
uint32_t mask,
uint8_t data)
{
int ret;
uint8_t tmp;
ret = adxl367_i2c_reg_read(dev, reg_addr, &tmp);
if (ret != 0) {
return ret;
}
tmp &= ~mask;
tmp |= data;
return adxl367_i2c_reg_write(dev, reg_addr, tmp);
}
static const struct adxl367_transfer_function adxl367_i2c_transfer_fn = {
.read_reg_multiple = adxl367_i2c_reg_read_multiple,
.write_reg = adxl367_i2c_reg_write,
.read_reg = adxl367_i2c_reg_read,
.write_reg_mask = adxl367_i2c_reg_write_mask,
};
int adxl367_i2c_init(const struct device *dev)
{
struct adxl367_data *data = dev->data;
const struct adxl367_dev_config *config = dev->config;
data->hw_tf = &adxl367_i2c_transfer_fn;
if (!i2c_is_ready_dt(&config->i2c)) {
return -ENODEV;
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/adi/adxl367/adxl367_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 673 |
```c
/* adxl367_spi.c - SPI routines for ADXL367 driver
*/
/*
*
*/
#define DT_DRV_COMPAT adi_adxl367
#include <string.h>
#include <zephyr/logging/log.h>
#include "adxl367.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
LOG_MODULE_DECLARE(ADXL367, CONFIG_SENSOR_LOG_LEVEL);
static int adxl367_bus_access(const struct device *dev, uint8_t reg,
void *data, size_t length)
{
const struct adxl367_dev_config *config = dev->config;
uint8_t rw_reg, addr_reg;
if ((reg & ADXL367_READ) != 0) {
rw_reg = ADXL367_SPI_READ_REG;
} else {
rw_reg = ADXL367_SPI_WRITE_REG;
}
addr_reg = ADXL367_TO_REG(reg);
const struct spi_buf buf[3] = {
{
.buf = &rw_reg,
.len = 1
}, {
.buf = &addr_reg,
.len = 1
}, {
.buf = data,
.len = length
}
};
struct spi_buf_set tx = {
.buffers = buf,
};
if ((reg & ADXL367_READ) != 0) {
const struct spi_buf_set rx = {
.buffers = buf,
.count = 3
};
tx.count = 2;
return spi_transceive_dt(&config->spi, &tx, &rx);
}
tx.count = 3;
return spi_write_dt(&config->spi, &tx);
}
static int adxl367_spi_reg_read(const struct device *dev, uint8_t reg_addr,
uint8_t *reg_data)
{
return adxl367_bus_access(dev, ADXL367_REG_READ(reg_addr), reg_data, 1);
}
static int adxl367_spi_reg_read_multiple(const struct device *dev,
uint8_t reg_addr,
uint8_t *reg_data,
uint16_t count)
{
return adxl367_bus_access(dev, ADXL367_REG_READ(reg_addr),
reg_data, count);
}
static int adxl367_spi_reg_write(const struct device *dev,
uint8_t reg_addr,
uint8_t reg_data)
{
return adxl367_bus_access(dev, ADXL367_REG_WRITE(reg_addr),
®_data, 1);
}
int adxl367_spi_reg_write_mask(const struct device *dev,
uint8_t reg_addr,
uint32_t mask,
uint8_t data)
{
int ret;
uint8_t tmp;
ret = adxl367_spi_reg_read(dev, reg_addr, &tmp);
if (ret != 0) {
return ret;
}
tmp &= ~mask;
tmp |= data;
return adxl367_spi_reg_write(dev, reg_addr, tmp);
}
static const struct adxl367_transfer_function adxl367_spi_transfer_fn = {
.read_reg_multiple = adxl367_spi_reg_read_multiple,
.write_reg = adxl367_spi_reg_write,
.read_reg = adxl367_spi_reg_read,
.write_reg_mask = adxl367_spi_reg_write_mask,
};
int adxl367_spi_init(const struct device *dev)
{
struct adxl367_data *data = dev->data;
const struct adxl367_dev_config *config = dev->config;
data->hw_tf = &adxl367_spi_transfer_fn;
if (!spi_is_ready_dt(&config->spi)) {
return -ENODEV;
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/adi/adxl367/adxl367_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 768 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adxl367
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "adxl367.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ADXL367, CONFIG_SENSOR_LOG_LEVEL);
static void adxl367_thread_cb(const struct device *dev)
{
const struct adxl367_dev_config *cfg = dev->config;
struct adxl367_data *drv_data = dev->data;
uint8_t status;
int ret;
/* Clear the status */
ret = drv_data->hw_tf->read_reg(dev, ADXL367_STATUS, &status);
if (ret != 0) {
return;
}
if (drv_data->th_handler != NULL) {
if (((FIELD_GET(ADXL367_STATUS_INACT, status)) != 0) ||
(FIELD_GET(ADXL367_STATUS_ACT, status)) != 0) {
drv_data->th_handler(dev, drv_data->th_trigger);
}
}
if ((drv_data->drdy_handler != NULL) &&
(FIELD_GET(ADXL367_STATUS_DATA_RDY, status) != 0)) {
drv_data->drdy_handler(dev, drv_data->drdy_trigger);
}
ret = gpio_pin_interrupt_configure_dt(&cfg->interrupt,
GPIO_INT_EDGE_TO_ACTIVE);
__ASSERT(ret == 0, "Interrupt configuration failed");
}
static void adxl367_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct adxl367_data *drv_data =
CONTAINER_OF(cb, struct adxl367_data, gpio_cb);
const struct adxl367_dev_config *cfg = drv_data->dev->config;
gpio_pin_interrupt_configure_dt(&cfg->interrupt, GPIO_INT_DISABLE);
#if defined(CONFIG_ADXL367_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ADXL367_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
#if defined(CONFIG_ADXL367_TRIGGER_OWN_THREAD)
static void adxl367_thread(struct adxl367_data *drv_data)
{
while (true) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
adxl367_thread_cb(drv_data->dev);
}
}
#elif defined(CONFIG_ADXL367_TRIGGER_GLOBAL_THREAD)
static void adxl367_work_cb(struct k_work *work)
{
struct adxl367_data *drv_data =
CONTAINER_OF(work, struct adxl367_data, work);
adxl367_thread_cb(drv_data->dev);
}
#endif
int adxl367_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct adxl367_dev_config *cfg = dev->config;
struct adxl367_data *drv_data = dev->data;
uint8_t int_mask, int_en, status;
int ret;
ret = gpio_pin_interrupt_configure_dt(&cfg->interrupt,
GPIO_INT_DISABLE);
if (ret != 0) {
return ret;
}
switch (trig->type) {
case SENSOR_TRIG_THRESHOLD:
drv_data->th_handler = handler;
drv_data->th_trigger = trig;
int_mask = ADXL367_ACT_INT | ADXL367_INACT_INT;
break;
case SENSOR_TRIG_DATA_READY:
drv_data->drdy_handler = handler;
drv_data->drdy_trigger = trig;
int_mask = ADXL367_DATA_RDY;
break;
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
if (handler != NULL) {
int_en = int_mask;
} else {
int_en = 0U;
}
ret = drv_data->hw_tf->write_reg_mask(dev, ADXL367_INTMAP1_LOWER, int_mask, int_en);
if (ret != 0) {
return ret;
}
/* Clear status */
ret = drv_data->hw_tf->read_reg(dev, ADXL367_STATUS, &status);
if (ret != 0) {
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&cfg->interrupt,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret != 0) {
return ret;
}
return 0;
}
int adxl367_init_interrupt(const struct device *dev)
{
const struct adxl367_dev_config *cfg = dev->config;
struct adxl367_data *drv_data = dev->data;
int ret;
if (!gpio_is_ready_dt(&cfg->interrupt)) {
LOG_ERR("GPIO port %s not ready", cfg->interrupt.port->name);
return -EINVAL;
}
ret = gpio_pin_configure_dt(&cfg->interrupt, GPIO_INPUT);
if (ret != 0) {
return ret;
}
gpio_init_callback(&drv_data->gpio_cb,
adxl367_gpio_callback,
BIT(cfg->interrupt.pin));
ret = gpio_add_callback(cfg->interrupt.port, &drv_data->gpio_cb);
if (ret != 0) {
LOG_ERR("Failed to set gpio callback!");
return ret;
}
drv_data->dev = dev;
#if defined(CONFIG_ADXL367_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_ADXL367_THREAD_STACK_SIZE,
(k_thread_entry_t)adxl367_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_ADXL367_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ADXL367_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = adxl367_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/adi/adxl367/adxl367_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,258 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADXL367_ADXL367_H_
#define ZEPHYR_DRIVERS_SENSOR_ADXL367_ADXL367_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.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) */
/*
* ADXL367 registers definition
*/
#define ADXL367_DEVID 0x00u /* Analog Devices accelerometer ID */
#define ADXL367_DEVID_MST 0x01u /* Analog Devices MEMS device ID */
#define ADXL367_PART_ID 0x02u /* Device ID */
#define ADXL367_REV_ID 0x03u /* product revision ID*/
#define ADXL367_SERIAL_NR_3 0x04u /* Serial Number 3 */
#define ADXL367_SERIAL_NR_2 0x05u /* Serial Number 2 */
#define ADXL367_SERIAL_NR_1 0x06u /* Serial Number 1 */
#define ADXL367_SERIAL_NR_0 0x07u /* Serial Number 0 */
#define ADXL367_XDATA 0x08u /* X-axis acceleration data [13:6] */
#define ADXL367_YDATA 0x09u /* Y-axis acceleration data [13:6] */
#define ADXL367_ZDATA 0x0Au /* Z-axis acceleration data [13:6] */
#define ADXL367_STATUS 0x0Bu /* Status */
#define ADXL367_FIFO_ENTRIES_L 0x0Cu /* FIFO Entries Low */
#define ADXL367_FIFO_ENTRIES_H 0x0Du /* FIFO Entries High */
#define ADXL367_X_DATA_H 0x0Eu /* X-axis acceleration data [13:6] */
#define ADXL367_X_DATA_L 0x0Fu /* X-axis acceleration data [5:0] */
#define ADXL367_Y_DATA_H 0x10u /* Y-axis acceleration data [13:6] */
#define ADXL367_Y_DATA_L 0x11u /* Y-axis acceleration data [5:0] */
#define ADXL367_Z_DATA_H 0x12u /* Z-axis acceleration data [13:6] */
#define ADXL367_Z_DATA_L 0x13u /* Z-axis acceleration data [5:0] */
#define ADXL367_TEMP_H 0x14u /* Temperate data [13:6] */
#define ADXL367_TEMP_L 0x15u /* Temperate data [5:0] */
#define ADXL367_EX_ADC_H 0x16u /* Extended ADC data [13:6] */
#define ADXL367_EX_ADC_L 0x17u /* Extended ADC data [5:0] */
#define ADXL367_I2C_FIFO_DATA 0x18u /* I2C FIFO Data address */
#define ADXL367_SOFT_RESET 0x1Fu /* Software reset register */
#define ADXL367_THRESH_ACT_H 0x20u /* Activity Threshold [12:6] */
#define ADXL367_THRESH_ACT_L 0x21u /* Activity Threshold [5:0] */
#define ADXL367_TIME_ACT 0x22u /* Activity Time */
#define ADXL367_THRESH_INACT_H 0x23u /* Inactivity Threshold [12:6] */
#define ADXL367_THRESH_INACT_L 0x24u /* Inactivity Threshold [5:0] */
#define ADXL367_TIME_INACT_H 0x25u /* Inactivity Time [12:6] */
#define ADXL367_TIME_INACT_L 0x26u /* Inactivity Time [5:0] */
#define ADXL367_ACT_INACT_CTL 0x27u /* Activity Inactivity Control */
#define ADXL367_FIFO_CONTROL 0x28u /* FIFO Control */
#define ADXL367_FIFO_SAMPLES 0x29u /* FIFO Samples */
#define ADXL367_INTMAP1_LOWER 0x2Au /* Interrupt 1 mapping control lower */
#define ADXL367_INTMAP2_LOWER 0x2Bu /* Interrupt 2 mapping control lower */
#define ADXL367_FILTER_CTL 0x2Cu /* Filter Control register */
#define ADXL367_POWER_CTL 0x2Du /* Power Control register */
#define ADXL367_SELF_TEST 0x2Eu /* Self Test */
#define ADXL367_TAP_THRESH 0x2Fu /* Tap Threshold */
#define ADXL367_TAP_DUR 0x30u /* Tap Duration */
#define ADXL367_TAP_LATENT 0x31u /* Tap Latency */
#define ADXL367_TAP_WINDOW 0x32u /* Tap Window */
#define ADXL367_X_OFFSET 0x33u /* X-axis offset */
#define ADXL367_Y_OFFSET 0x34u /* Y-axis offset */
#define ADXL367_Z_OFFSET 0x35u /* Z-axis offset */
#define ADXL367_X_SENS 0x36u /* X-axis user sensitivity */
#define ADXL367_Y_SENS 0x37u /* Y-axis user sensitivity */
#define ADXL367_Z_SENS 0x38u /* Z-axis user sensitivity */
#define ADXL367_TIMER_CTL 0x39u /* Timer Control */
#define ADXL367_INTMAP1_UPPER 0x3Au /* Interrupt 1 mapping control upper */
#define ADXL367_INTMAP2_UPPER 0x3Bu /* Interrupt 2 mapping control upper */
#define ADXL367_ADC_CTL 0x3Cu /* ADC Control Register */
#define ADXL367_TEMP_CTL 0x3Du /* Temperature Control Register */
#define ADXL367_TEMP_ADC_OTH_H 0x3Eu /* Temperature ADC Over Threshold [12:6]*/
#define ADXL367_TEMP_ADC_OTH_L 0x3Fu /* Temperature ADC Over Threshold [5:0]*/
#define ADXL367_TEMP_ADC_UTH_H 0x40u /* Temperature ADC Under Threshold [12:6]*/
#define ADXL367_TEMP_ADC_UTH_L 0x41u /* Temperature ADC Under Threshold [5:0]*/
#define ADXL367_TEMP_ADC_TIMER 0x42u /* Temperature Activiy Inactivity Timer */
#define ADXL367_AXIS_MASK 0x43u /* Axis Mask Register */
#define ADXL367_STATUS_COPY 0x44u /* Status Copy Register */
#define ADXL367_STATUS2 0x45u /* Status 2 Register */
#define ADXL367_DEVID_VAL 0xADu /* Analog Devices accelerometer ID */
#define ADXL367_MST_DEVID_VAL 0x1Du /* Analog Devices MEMS device ID */
#define ADXL367_PARTID_VAL 0xF7u /* Device ID */
#define ADXL367_REVID_VAL 0x03u /* product revision ID*/
#define ADXL367_RESET_CODE 0x52u /* Writing code 0x52 resets the device */
#define ADXL367_READ 0x01u
#define ADXL367_REG_READ(x) (((x & 0xFF) << 1) | ADXL367_READ)
#define ADXL367_REG_WRITE(x) ((x & 0xFF) << 1)
#define ADXL367_TO_REG(x) ((x) >> 1)
#define ADXL367_SPI_WRITE_REG 0x0Au
#define ADXL367_SPI_READ_REG 0x0Bu
#define ADXL367_ABSOLUTE 0x00
#define ADXL367_REFERENCED 0x01
/* ADXL367_POWER_CTL */
#define ADXL367_POWER_CTL_EXT_CLK_MSK BIT(6)
#define ADXL367_POWER_CTL_NOISE_MSK GENMASK(5, 4)
#define ADXL367_POWER_CTL_WAKEUP_MSK BIT(3)
#define ADXL367_POWER_CTL_AUTOSLEEP_MSK BIT(2)
#define ADXL367_POWER_CTL_MEASURE_MSK GENMASK(1, 0)
/* ADXL367_ACT_INACT_CTL */
#define ADXL367_ACT_INACT_CTL_LINKLOOP_MSK GENMASK(5, 4)
#define ADXL367_ACT_INACT_CTL_INACT_REF_MSK BIT(3)
#define ADXL367_ACT_INACT_CTL_INACT_EN_MSK BIT(2)
#define ADXL367_ACT_INACT_CTL_ACT_REF_MSK BIT(1)
#define ADXL367_ACT_INACT_CTL_ACT_EN_MSK BIT(0)
/* ADXL367_ACT_INACT_CTL_INACT_EN options */
#define ADXL367_NO_INACTIVITY_DETECTION_ENABLED 0x0
#define ADXL367_INACTIVITY_ENABLE 0x1
#define ADXL367_NO_INACTIVITY_DETECTION_ENABLED_2 0x2
#define ADXL367_REFERENCED_INACTIVITY_ENABLE 0x3
/* ADXL367_ACT_INACT_CTL_ACT_EN options */
#define ADXL367_NO_ACTIVITY_DETECTION 0x0
#define ADXL367_ACTIVITY_ENABLE 0x1
#define ADXL367_NO_ACTIVITY_DETECTION_2 0x2
#define ADXL367_REFERENCED_ACTIVITY_ENABLE 0x3
#define ADXL367_TEMP_OFFSET 1185
#define ADXL367_TEMP_25C 165
#define ADXL367_TEMP_SCALE 18518518LL
#define ADXL367_TEMP_SCALE_DIV 1000000000
#define ADXL367_THRESH_H_MSK GENMASK(6, 0)
#define ADXL367_THRESH_L_MSK GENMASK(7, 2)
/* ADXL367_REG_TEMP_CTL definitions. */
#define ADXL367_TEMP_INACT_EN_MSK BIT(3)
#define ADXL367_TEMP_ACT_EN_MSK BIT(1)
#define ADXL367_TEMP_EN_MSK BIT(0)
/* ADXL367_SELF_TEST */
#define ADXL367_SELF_TEST_ST_FORCE_MSK BIT(1)
#define ADXL367_SELF_TEST_ST_MSK BIT(0)
/* ADXL367_REG_FILTER_CTL definitions */
#define ADXL367_FILTER_CTL_RANGE_MSK GENMASK(7, 6)
#define ADXL367_FILTER_I2C_HS BIT(5)
#define ADXL367_FILTER_CTL_RES BIT(4)
#define ADXL367_FILTER_CTL_EXT_SAMPLE BIT(3)
#define ADXL367_FILTER_CTL_ODR_MSK GENMASK(2, 0)
/* ADXL367_REG_FIFO_CONTROL */
#define ADXL367_FIFO_CONTROL_FIFO_CHANNEL_MSK GENMASK(6, 3)
#define ADXL367_FIFO_CONTROL_FIFO_SAMPLES_MSK BIT(2)
#define ADXL367_FIFO_CONTROL_FIFO_MODE_MSK GENMASK(1, 0)
/* ADXL367_REG_ADC_CTL definitions. */
#define ADXL367_FIFO_8_12BIT_MSK GENMASK(7, 6)
#define ADXL367_ADC_INACT_EN BIT(3)
#define ADXL367_ADC_ACT_EN BIT(1)
#define ADXL367_ADC_EN BIT(0)
/* ADXL367_REG_STATUS definitions */
#define ADXL367_STATUS_ERR_USER_REGS BIT(7)
#define ADXL367_STATUS_AWAKE BIT(6)
#define ADXL367_STATUS_INACT BIT(5)
#define ADXL367_STATUS_ACT BIT(4)
#define ADXL367_STATUS_FIFO_OVERRUN BIT(3)
#define ADXL367_STATUS_FIFO_WATERMARK BIT(2)
#define ADXL367_STATUS_FIFO_RDY BIT(1)
#define ADXL367_STATUS_DATA_RDY BIT(0)
/* ADXL367_INTMAP_LOWER */
#define ADXL367_INT_LOW BIT(7)
#define ADXL367_AWAKE_INT BIT(6)
#define ADXL367_INACT_INT BIT(5)
#define ADXL367_ACT_INT BIT(4)
#define ADXL367_FIFO_OVERRUN BIT(3)
#define ADXL367_FIFO_WATERMARK BIT(2)
#define ADXL367_FIFO_RDY BIT(1)
#define ADXL367_DATA_RDY BIT(0)
/* ADXL367_INTMAP_UPPER */
#define ADXL367_ERR_FUSE BIT(7)
#define ADXL367_ERR_USER_REGS BIT(6)
#define ADXL367_KPALV_TIMER BIT(4)
#define ADXL367_TEMP_ADC_HI BIT(3)
#define ADXL367_TEMP_ADC_LOW BIT(2)
#define ADXL367_TAP_TWO BIT(1)
#define ADXL367_TAP_ONE BIT(0)
/* Min change = 90mg. Sensitivity = 4LSB / mg */
#define ADXL367_SELF_TEST_MIN (90 * 100 / 25)
/* Max change = 270mg. Sensitivity = 4LSB / mg */
#define ADXL367_SELF_TEST_MAX (270 * 100 / 25)
enum adxl367_axis {
ADXL367_X_AXIS,
ADXL367_Y_AXIS,
ADXL367_Z_AXIS
};
enum adxl367_op_mode {
ADXL367_STANDBY = 0,
ADXL367_MEASURE = 2,
};
enum adxl367_range {
ADXL367_2G_RANGE,
ADXL367_4G_RANGE,
ADXL367_8G_RANGE,
};
enum adxl367_act_proc_mode {
ADXL367_DEFAULT = 0,
ADXL367_LINKED = 1,
ADXL367_LOOPED = 3,
};
enum adxl367_odr {
ADXL367_ODR_12P5HZ,
ADXL367_ODR_25HZ,
ADXL367_ODR_50HZ,
ADXL367_ODR_100HZ,
ADXL367_ODR_200HZ,
ADXL367_ODR_400HZ,
};
enum adxl367_fifo_format {
ADXL367_FIFO_FORMAT_XYZ,
ADXL367_FIFO_FORMAT_X,
ADXL367_FIFO_FORMAT_Y,
ADXL367_FIFO_FORMAT_Z,
ADXL367_FIFO_FORMAT_XYZT,
ADXL367_FIFO_FORMAT_XT,
ADXL367_FIFO_FORMAT_YT,
ADXL367_FIFO_FORMAT_ZT,
ADXL367_FIFO_FORMAT_XYZA,
ADXL367_FIFO_FORMAT_XA,
ADXL367_FIFO_FORMAT_YA,
ADXL367_FIFO_FORMAT_ZA
};
enum adxl367_fifo_mode {
ADXL367_FIFO_DISABLED,
ADXL367_OLDEST_SAVED,
ADXL367_STREAM_MODE,
ADXL367_TRIGGERED_MODE
};
enum adxl367_fifo_read_mode {
ADXL367_12B_CHID,
ADXL367_8B,
ADXL367_12B,
ADXL367_14B_CHID
};
struct adxl367_fifo_config {
enum adxl367_fifo_mode fifo_mode;
enum adxl367_fifo_format fifo_format;
enum adxl367_fifo_read_mode fifo_read_mode;
uint16_t fifo_samples;
};
struct adxl367_activity_threshold {
uint16_t value;
bool referenced;
bool enable;
};
struct adxl367_xyz_accel_data {
int16_t x;
int16_t y;
int16_t z;
};
struct adxl367_transfer_function {
int (*read_reg_multiple)(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint16_t len);
int (*write_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t value);
int (*read_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t *value);
int (*write_reg_mask)(const struct device *dev, uint8_t reg_addr,
uint32_t mask, uint8_t value);
};
struct adxl367_data {
struct adxl367_xyz_accel_data sample;
int16_t temp_val;
const struct adxl367_transfer_function *hw_tf;
struct adxl367_fifo_config fifo_config;
enum adxl367_act_proc_mode act_proc_mode;
enum adxl367_range range;
#ifdef CONFIG_ADXL367_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t th_handler;
const struct sensor_trigger *th_trigger;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trigger;
const struct device *dev;
#if defined(CONFIG_ADXL367_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADXL367_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ADXL367_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_ADXL367_TRIGGER */
};
struct adxl367_dev_config {
#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
int (*bus_init)(const struct device *dev);
#ifdef CONFIG_ADXL367_TRIGGER
struct gpio_dt_spec interrupt;
#endif
enum adxl367_odr odr;
/* Device Settings */
bool autosleep;
bool low_noise;
bool temp_en;
struct adxl367_activity_threshold activity_th;
struct adxl367_activity_threshold inactivity_th;
struct adxl367_fifo_config fifo_config;
enum adxl367_range range;
enum adxl367_op_mode op_mode;
uint16_t inactivity_time;
uint8_t activity_time;
};
int adxl367_spi_init(const struct device *dev);
int adxl367_i2c_init(const struct device *dev);
int adxl367_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int adxl367_init_interrupt(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_ADXL367_ADXL367_H_ */
``` | /content/code_sandbox/drivers/sensor/adi/adxl367/adxl367.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,832 |
```unknown
# Micropower, 3-Axis, +/-200g Digital Accelerometer
menuconfig ADXL367
bool "ADXL367 Three Axis High-g I2C/SPI accelerometer"
default y
depends on DT_HAS_ADI_ADXL367_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ADI_ADXL367),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ADI_ADXL367),spi)
help
Enable driver for ADXL367 Three-Axis Digital Accelerometers.
if ADXL367
choice ADXL367_OP_MODE
prompt "Operating mode"
default ADXL367_MEASUREMENT_MODE
config ADXL367_MEASUREMENT_MODE
bool "Measurement Mode"
help
In this mode, acceleration data is provided continuously at the
output data rate (ODR).
endchoice
config ADXL367_ACTIVITY_THRESHOLD
int "Activity threshold in raw value"
range 0 8191
default 100
help
Threshold for activity detection.
config ADXL367_INACTIVITY_THRESHOLD
int "In-activity threshold in raw value"
range 0 8191
default 100
help
Threshold for in-activity detection.
config ADXL367_ACTIVITY_TIME
int "Activity time"
range 0 $(UINT8_MAX)
default 100
help
The activity timer implements a robust activity detection that
minimizes false positive motion triggers. When the timer is used,
only sustained motion can trigger activity detection. Value is the
number of samples. For example, at 100Hz ODR, 100 value translates
to 1 second.
config ADXL367_INACTIVITY_TIME
int "In-activity time"
range 0 $(UINT16_MAX)
default 100
help
The time that all enabled axes must be lower than the inactivity
threshold for an inactivity event to be detected. Value is the
number of samples. For example, at 100Hz ODR, 100 value translates
to 1 second.
config ADXL367_ACTIVITY_DETECTION_MODE
bool "Use activity detection"
default y
help
Enable Activity detection.
config ADXL367_INACTIVITY_DETECTION_MODE
bool "Use inactivity detection"
default y
help
Enable Inactivity detection.
config ADXL367_REFERENCED_ACTIVITY_DETECTION_MODE
bool "Use referenced activity detection"
default y
help
Activity detection can be configured as referenced or absolute.
When using absolute activity detection, acceleration samples are
compared directly to a user set threshold to determine whether
motion is present.
config ADXL367_REFERENCED_INACTIVITY_DETECTION_MODE
bool "Use referenced inactivity detection"
default y
help
Inactivity detection can be configured as referenced or absolute.
When using absolute inactivity detection, acceleration samples are
compared directly to a user set threshold to determine whether
motion is present.
choice ADXL367_TRIGGER_MODE
prompt "Trigger mode"
default ADXL367_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config ADXL367_TRIGGER_NONE
bool "No trigger"
config ADXL367_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ADXL367_TRIGGER
config ADXL367_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ADXL367_TRIGGER
endchoice
config ADXL367_TRIGGER
bool
config ADXL367_THREAD_PRIORITY
int "Thread priority"
depends on ADXL367_TRIGGER_OWN_THREAD && ADXL367_TRIGGER
default 10
help
Priority of thread used by the driver to handle interrupts.
config ADXL367_THREAD_STACK_SIZE
int "Thread stack size"
depends on ADXL367_TRIGGER_OWN_THREAD && ADXL367_TRIGGER
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # ADXL367
``` | /content/code_sandbox/drivers/sensor/adi/adxl367/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 827 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adxl367
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <string.h>
#include <zephyr/init.h>
#include <zephyr/sys/printk.h>
#include <zephyr/sys/__assert.h>
#include <stdlib.h>
#include <zephyr/logging/log.h>
#include "adxl367.h"
LOG_MODULE_REGISTER(ADXL367, CONFIG_SENSOR_LOG_LEVEL);
static const uint8_t adxl367_scale_mul[3] = {1, 2, 4};
static uint8_t samples_per_set;
/**
* @brief Configures activity detection.
*
* @param dev - The device structure.
* @param th - Structure holding the activity threshold information:
* Enable/Disable Activity detection
* Enable/Disable Referenced Activity detection
* Set Threshold value
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_setup_activity_detection(const struct device *dev,
const struct adxl367_activity_threshold *th)
{
struct adxl367_data *data = dev->data;
int ret;
ret = data->hw_tf->write_reg_mask(dev, ADXL367_ACT_INACT_CTL,
ADXL367_ACT_INACT_CTL_ACT_EN_MSK |
ADXL367_ACT_INACT_CTL_ACT_REF_MSK,
FIELD_PREP(ADXL367_ACT_INACT_CTL_ACT_EN_MSK, th->enable) |
FIELD_PREP(ADXL367_ACT_INACT_CTL_ACT_REF_MSK,
th->referenced));
if (ret != 0) {
return ret;
}
ret = data->hw_tf->write_reg_mask(dev, ADXL367_THRESH_ACT_H, ADXL367_THRESH_H_MSK,
FIELD_PREP(ADXL367_THRESH_H_MSK, th->value >> 6));
if (ret != 0) {
return ret;
}
return data->hw_tf->write_reg_mask(dev, ADXL367_THRESH_ACT_L, ADXL367_THRESH_L_MSK,
FIELD_PREP(ADXL367_THRESH_L_MSK, th->value & 0x3F));
}
/**
* @brief Configures activity detection.
*
* @param dev - The device structure.
* @param th - Structure holding the inactivity threshold information:
* Enable/Disable inactivity detection
* Enable/Disable Referenced inactivity detection
* Set Threshold value
*
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_setup_inactivity_detection(const struct device *dev,
const struct adxl367_activity_threshold *th)
{
struct adxl367_data *data = dev->data;
int ret;
ret = data->hw_tf->write_reg_mask(dev, ADXL367_ACT_INACT_CTL,
ADXL367_ACT_INACT_CTL_INACT_EN_MSK |
ADXL367_ACT_INACT_CTL_INACT_REF_MSK,
FIELD_PREP(ADXL367_ACT_INACT_CTL_INACT_EN_MSK,
th->enable) |
FIELD_PREP(ADXL367_ACT_INACT_CTL_INACT_REF_MSK,
th->referenced));
if (ret != 0) {
return ret;
}
ret = data->hw_tf->write_reg_mask(dev, ADXL367_THRESH_INACT_H, ADXL367_THRESH_H_MSK,
FIELD_PREP(ADXL367_THRESH_H_MSK, th->value >> 6));
if (ret != 0) {
return ret;
}
return data->hw_tf->write_reg_mask(dev, ADXL367_THRESH_INACT_L, ADXL367_THRESH_L_MSK,
FIELD_PREP(ADXL367_THRESH_L_MSK, th->value & 0x3F));
}
/**
* @brief Set the mode of operation.
*
* @param dev - The device structure.
* @param op_mode - Mode of operation.
* Accepted values: ADXL367_STANDBY
* ADXL367_MEASURE
*
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_set_op_mode(const struct device *dev,
enum adxl367_op_mode op_mode)
{
struct adxl367_data *data = dev->data;
int ret;
ret = data->hw_tf->write_reg_mask(dev, ADXL367_POWER_CTL,
ADXL367_POWER_CTL_MEASURE_MSK,
FIELD_PREP(ADXL367_POWER_CTL_MEASURE_MSK, op_mode));
if (ret != 0) {
return ret;
}
if (op_mode == ADXL367_MEASURE) {
/* Wait 100 ms to allow the acceleration outputs to settle */
k_sleep(K_MSEC(100));
}
return 0;
}
/**
* @brief Autosleep. When set to 1, autosleep is enabled, and the device enters
* wake-up mode automatically upon detection of inactivity.
*
* @param dev - The device structure.
* @param enable - Accepted values: true
* false
*
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_set_autosleep(const struct device *dev, bool enable)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL367_POWER_CTL,
ADXL367_POWER_CTL_AUTOSLEEP_MSK,
FIELD_PREP(ADXL367_POWER_CTL_AUTOSLEEP_MSK, enable));
}
/**
* @brief Noise Mode. When set to 1, low noise mode is enabled
*
* @param dev - The device structure.
* @param enable - Accepted values: true
* false
*
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_set_low_noise(const struct device *dev, bool enable)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL367_POWER_CTL,
ADXL367_POWER_CTL_NOISE_MSK,
FIELD_PREP(ADXL367_POWER_CTL_NOISE_MSK, enable));
}
/**
* @brief Link/Loop Activity Processing.
*
* @param dev - The device structure.
* @param mode - Mode of operation.
* Accepted values: ADXL367_DEFAULT
* ADXL367_LINKED
* ADXL367_LOOPED
*
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_set_act_proc_mode(const struct device *dev,
enum adxl367_act_proc_mode mode)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL367_ACT_INACT_CTL,
ADXL367_ACT_INACT_CTL_LINKLOOP_MSK,
FIELD_PREP(ADXL367_ACT_INACT_CTL_LINKLOOP_MSK, mode));
}
/**
* @brief Selects the Output Data Rate of the device.
* @param dev - The device structure.
* @param odr - Output Data Rate option.
* Accepted values: ADXL367_ODR_12P5HZ,
* ADXL367_ODR_25HZ,
* ADXL367_ODR_50HZ,
* ADXL367_ODR_100HZ,
* ADXL367_ODR_200HZ,
* ADXL367_ODR_400HZ
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_set_output_rate(const struct device *dev, enum adxl367_odr odr)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev,
ADXL367_FILTER_CTL,
ADXL367_FILTER_CTL_ODR_MSK,
FIELD_PREP(ADXL367_FILTER_CTL_ODR_MSK, odr));
}
/**
* @brief Selects the measurement range.
*
* @param dev - The device structure.
* @param range - Range option.
* Accepted values: ADXL367_2G_RANGE, +/- 2g
* ADXL367_4G_RANGE, +/- 4g
* ADXL367_8G_RANGE +/- 8g
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_set_range(const struct device *dev, enum adxl367_range range)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev,
ADXL367_FILTER_CTL,
ADXL367_FILTER_CTL_RANGE_MSK,
FIELD_PREP(ADXL367_FILTER_CTL_RANGE_MSK, range));
}
/**
* @brief Set the activity timer
*
* @param dev - The device structure.
* @param time - The value set in this register.
*
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_set_activity_time(const struct device *dev, uint8_t time)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg(dev, ADXL367_TIME_ACT, time);
}
/**
* Set the inactivity timer
* @param dev - The device structure.
* @param time - is the 16-bit value set by the TIME_INACT_L register
* (eight LSBs) and the TIME_INACT_H register (eight MSBs).
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_set_inactivity_time(const struct device *dev,
uint16_t time)
{
int ret;
struct adxl367_data *data = dev->data;
ret = data->hw_tf->write_reg(dev, ADXL367_TIME_INACT_H, time >> 8);
if (ret != 0) {
return ret;
}
return data->hw_tf->write_reg(dev, ADXL367_TIME_INACT_L, time & 0xFF);
}
/**
* @brief Performs self test.
*
* @param dev - The device structure.
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_self_test(const struct device *dev)
{
int ret;
struct adxl367_data *data = dev->data;
const struct adxl367_dev_config *cfg = dev->config;
int16_t x_axis_1, x_axis_2, dif, min, max;
uint8_t read_val[2];
uint32_t st_delay_ms;
/* 4 / ODR value in ms */
switch (cfg->odr) {
case ADXL367_ODR_12P5HZ:
st_delay_ms = 320;
break;
case ADXL367_ODR_25HZ:
st_delay_ms = 160;
break;
case ADXL367_ODR_50HZ:
st_delay_ms = 80;
break;
case ADXL367_ODR_100HZ:
st_delay_ms = 40;
break;
case ADXL367_ODR_200HZ:
st_delay_ms = 20;
break;
case ADXL367_ODR_400HZ:
st_delay_ms = 10;
break;
default:
return -EINVAL;
}
ret = adxl367_set_op_mode(dev, ADXL367_MEASURE);
if (ret != 0) {
return ret;
}
ret = data->hw_tf->write_reg_mask(dev, ADXL367_SELF_TEST, ADXL367_SELF_TEST_ST_MSK,
FIELD_PREP(ADXL367_SELF_TEST_ST_MSK, 1));
if (ret != 0) {
return ret;
}
/* 4 / ODR */
k_sleep(K_MSEC(st_delay_ms));
ret = data->hw_tf->read_reg_multiple(dev, ADXL367_X_DATA_H, read_val, 2);
if (ret != 0) {
return ret;
}
x_axis_1 = ((int16_t)read_val[0] << 6) + (read_val[1] >> 2);
/* extend sign to 16 bits */
if ((x_axis_1 & BIT(13)) != 0) {
x_axis_1 |= GENMASK(15, 14);
}
ret = data->hw_tf->write_reg_mask(dev, ADXL367_SELF_TEST,
ADXL367_SELF_TEST_ST_FORCE_MSK,
FIELD_PREP(ADXL367_SELF_TEST_ST_FORCE_MSK, 1));
if (ret != 0) {
return ret;
}
/* 4 / ODR */
k_sleep(K_MSEC(st_delay_ms));
ret = data->hw_tf->read_reg_multiple(dev, ADXL367_X_DATA_H, read_val, 2);
if (ret != 0) {
return ret;
}
x_axis_2 = ((int16_t)read_val[0] << 6) + (read_val[1] >> 2);
/* extend sign to 16 bits */
if ((x_axis_2 & BIT(13)) != 0)
x_axis_2 |= GENMASK(15, 14);
ret = adxl367_set_op_mode(dev, ADXL367_STANDBY);
if (ret != 0) {
return ret;
}
ret = data->hw_tf->write_reg_mask(dev, ADXL367_SELF_TEST, ADXL367_SELF_TEST_ST_FORCE_MSK |
ADXL367_SELF_TEST_ST_MSK,
FIELD_PREP(ADXL367_SELF_TEST_ST_FORCE_MSK, 0) |
FIELD_PREP(ADXL367_SELF_TEST_ST_MSK, 0));
if (ret != 0) {
return ret;
}
dif = x_axis_2 - x_axis_1;
min = ADXL367_SELF_TEST_MIN * adxl367_scale_mul[data->range];
max = ADXL367_SELF_TEST_MAX * adxl367_scale_mul[data->range];
if ((dif >= min) && (dif <= max)) {
LOG_INF("ADXL367 passed self-test\n");
ret = 0;
} else {
LOG_ERR("ADXL367 failed self-test\n");
ret = -EINVAL;
}
return ret;
}
/**
* @brief Enables temperature reading.
*
* @param dev - The device structure.
* @param enable - 1 - ENABLE
* 2 - DISABLE
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_temp_read_en(const struct device *dev, bool enable)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev,
ADXL367_TEMP_CTL,
ADXL367_TEMP_EN_MSK,
FIELD_PREP(ADXL367_TEMP_EN_MSK, enable));
}
/**
* @brief Sets the number of FIFO sample sets.
*
* @param dev - The device structure.
* @param sets_nb - Sample sets number. For example, if ADXL367_FIFO_FORMAT_XYZ
* is selected, a value of 2 will represent 6 entries.
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_set_fifo_sample_sets_nb(const struct device *dev,
uint16_t sets_nb)
{
struct adxl367_data *data = dev->data;
int ret;
uint8_t fifo_samples_msb = sets_nb & BIT(9) ? 1U : 0U;
/* bit 9 goes to FIFO_SAMPLES from ADXL367_FIFO_CONTROL */
ret = data->hw_tf->write_reg_mask(dev, ADXL367_FIFO_CONTROL,
ADXL367_FIFO_CONTROL_FIFO_SAMPLES_MSK,
FIELD_PREP(ADXL367_FIFO_CONTROL_FIFO_SAMPLES_MSK,
fifo_samples_msb));
if (ret != 0) {
return ret;
}
/* write last 8 bits to ADXL367_FIFO_SAMPLES */
return data->hw_tf->write_reg(dev, ADXL367_FIFO_SAMPLES, sets_nb & 0xFF);
}
/**
* @brief Sets FIFO mode.
*
* @param dev - The device structure.
* @param mode - FIFO mode.
* Accepted values: ADXL367_FIFO_DISABLED,
* ADXL367_OLDEST_SAVED,
* ADXL367_STREAM_MODE,
* ADXL367_TRIGGERED_MODE
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_set_fifo_mode(const struct device *dev,
enum adxl367_fifo_mode mode)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev,
ADXL367_FIFO_CONTROL,
ADXL367_FIFO_CONTROL_FIFO_MODE_MSK,
FIELD_PREP(ADXL367_FIFO_CONTROL_FIFO_MODE_MSK, mode));
}
/**
* @brief Sets FIFO read mode.
*
* @param dev - The device structure.
* @param read_mode - FIFO read mode.
* Accepted values: ADXL367_12B_CHID,
* ADXL367_8B,
* ADXL367_12B,
* ADXL367_14B_CHID
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_set_fifo_read_mode(const struct device *dev,
enum adxl367_fifo_read_mode read_mode)
{
struct adxl367_data *data = dev->data;
return data->hw_tf->write_reg_mask(dev, ADXL367_ADC_CTL,
ADXL367_FIFO_8_12BIT_MSK,
FIELD_PREP(ADXL367_FIFO_8_12BIT_MSK, read_mode));
}
/**
* @brief Sets FIFO format.
*
* @param dev - The device structure.
* @param format - FIFO format.
* Accepted values: ADXL367_FIFO_FORMAT_XYZ,
* ADXL367_FIFO_FORMAT_X,
* ADXL367_FIFO_FORMAT_Y,
* ADXL367_FIFO_FORMAT_Z,
* ADXL367_FIFO_FORMAT_XYZT,
* ADXL367_FIFO_FORMAT_XT,
* ADXL367_FIFO_FORMAT_YT,
* ADXL367_FIFO_FORMAT_ZT,
* ADXL367_FIFO_FORMAT_XYZA,
* ADXL367_FIFO_FORMAT_XA,
* ADXL367_FIFO_FORMAT_YA,
* ADXL367_FIFO_FORMAT_ZA
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_set_fifo_format(const struct device *dev,
enum adxl367_fifo_format format)
{
int ret;
struct adxl367_data *data = dev->data;
ret = data->hw_tf->write_reg_mask(dev,
ADXL367_FIFO_CONTROL,
ADXL367_FIFO_CONTROL_FIFO_CHANNEL_MSK,
FIELD_PREP(ADXL367_FIFO_CONTROL_FIFO_CHANNEL_MSK, format));
if (ret != 0) {
return ret;
}
switch (format) {
case ADXL367_FIFO_FORMAT_XYZ:
samples_per_set = 3;
break;
case ADXL367_FIFO_FORMAT_X:
case ADXL367_FIFO_FORMAT_Y:
case ADXL367_FIFO_FORMAT_Z:
samples_per_set = 1;
break;
case ADXL367_FIFO_FORMAT_XYZT:
case ADXL367_FIFO_FORMAT_XYZA:
samples_per_set = 4;
break;
case ADXL367_FIFO_FORMAT_XT:
case ADXL367_FIFO_FORMAT_YT:
case ADXL367_FIFO_FORMAT_ZT:
case ADXL367_FIFO_FORMAT_XA:
case ADXL367_FIFO_FORMAT_YA:
case ADXL367_FIFO_FORMAT_ZA:
samples_per_set = 2;
break;
default:
return -EINVAL;
}
return 0;
}
/**
* @brief Configures the FIFO feature. Uses ADXL367_14B_CHID read mode as
* default.
*
* @param dev - The device structure.
* @param mode - FIFO mode selection.
* Example: ADXL367_FIFO_DISABLED,
* ADXL367_OLDEST_SAVED,
* ADXL367_STREAM_MODE,
* ADXL367_TRIGGERED_MODE
* @param format - FIFO format selection.
* Example: ADXL367_FIFO_FORMAT_XYZ,
* ADXL367_FIFO_FORMAT_X,
* ADXL367_FIFO_FORMAT_Y,
* ADXL367_FIFO_FORMAT_Z,
* ADXL367_FIFO_FORMAT_XYZT,
* ADXL367_FIFO_FORMAT_XT,
* ADXL367_FIFO_FORMAT_YT,
* ADXL367_FIFO_FORMAT_ZT,
* ADXL367_FIFO_FORMAT_XYZA,
* ADXL367_FIFO_FORMAT_XA,
* ADXL367_FIFO_FORMAT_YA,
* ADXL367_FIFO_FORMAT_ZA
* @param read_mode - FIFO read mode.
* Accepted values: ADXL367_12B_CHID,
* ADXL367_8B,
* ADXL367_12B,
* ADXL367_14B_CHID
* @param sets_nb - Specifies the number of samples sets to store in the FIFO.
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_fifo_setup(const struct device *dev,
enum adxl367_fifo_mode mode,
enum adxl367_fifo_format format,
enum adxl367_fifo_read_mode read_mode,
uint8_t sets_nb)
{
int ret;
ret = adxl367_set_fifo_mode(dev, mode);
if (ret != 0) {
return ret;
}
ret = adxl367_set_fifo_format(dev, format);
if (ret != 0) {
return ret;
}
ret = adxl367_set_fifo_sample_sets_nb(dev, sets_nb);
if (ret != 0) {
return ret;
}
return adxl367_set_fifo_read_mode(dev, read_mode);
}
/**
* @brief Software reset.
*
* @param dev - The device structure.
*
* @return 0 in case of success, negative error code otherwise.
*/
static int adxl367_reset(const struct device *dev)
{
int ret;
struct adxl367_data *data = dev->data;
ret = adxl367_set_op_mode(dev, ADXL367_STANDBY);
if (ret != 0) {
return ret;
}
/* Writing code 0x52 resets the device */
ret = data->hw_tf->write_reg(dev, ADXL367_SOFT_RESET, ADXL367_RESET_CODE);
if (ret != 0) {
return ret;
}
/* Delay required after performing software reset */
k_sleep(K_MSEC(8));
return ret;
}
/**
* @brief Reads the 3-axis raw data from the accelerometer.
*
* @param dev - The device structure.
* @param accel_data - store the XYZ axis accelerometer data.
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_get_accel_data(const struct device *dev,
struct adxl367_xyz_accel_data *accel_data)
{
int ret;
uint8_t xyz_values[6] = { 0 };
uint8_t reg_data, nready = 1U;
struct adxl367_data *data = dev->data;
while (nready != 0) {
ret = data->hw_tf->read_reg(dev, ADXL367_STATUS, ®_data);
if (ret != 0) {
return ret;
}
if ((reg_data & ADXL367_STATUS_DATA_RDY) != 0) {
nready = 0U;
}
}
ret = data->hw_tf->read_reg_multiple(dev, ADXL367_X_DATA_H, xyz_values, 6);
if (ret != 0) {
return ret;
}
/* result is 14 bits long, ignore last 2 bits from low byte */
accel_data->x = ((int16_t)xyz_values[0] << 6) + (xyz_values[1] >> 2);
accel_data->y = ((int16_t)xyz_values[2] << 6) + (xyz_values[3] >> 2);
accel_data->z = ((int16_t)xyz_values[4] << 6) + (xyz_values[5] >> 2);
/* extend sign to 16 bits */
if ((accel_data->x & BIT(13)) != 0) {
accel_data->x |= GENMASK(15, 14);
}
if ((accel_data->y & BIT(13)) != 0) {
accel_data->y |= GENMASK(15, 14);
}
if ((accel_data->z & BIT(13)) != 0) {
accel_data->z |= GENMASK(15, 14);
}
return 0;
}
/**
* @brief Reads the raw temperature of the device. If ADXL367_TEMP_EN is not
* set, use adxl367_temp_read_en() first to enable temperature reading.
*
* @param dev - The device structure.
* @param raw_temp - Raw value of temperature.
*
* @return 0 in case of success, negative error code otherwise.
*/
int adxl367_get_temp_data(const struct device *dev, int16_t *raw_temp)
{
int ret;
uint8_t temp[2] = { 0 };
uint8_t reg_data, nready = 1U;
struct adxl367_data *data = dev->data;
while (nready != 0) {
ret = data->hw_tf->read_reg(dev, ADXL367_STATUS, ®_data);
if (ret != 0) {
return ret;
}
if ((reg_data & ADXL367_STATUS_DATA_RDY) != 0) {
nready = 0U;
}
}
ret = data->hw_tf->read_reg_multiple(dev, ADXL367_TEMP_H, temp, 2);
if (ret != 0) {
return ret;
}
*raw_temp = ((int16_t)temp[0] << 6) + (temp[1] >> 2);
/* extend sign to 16 bits */
if ((*raw_temp & BIT(13)) != 0) {
*raw_temp |= GENMASK(15, 14);
}
return 0;
}
static int adxl367_attr_set_thresh(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct adxl367_dev_config *cfg = dev->config;
struct adxl367_activity_threshold threshold;
int64_t llvalue;
int32_t value;
int64_t micro_ms2 = val->val1 * 1000000LL + val->val2;
llvalue = llabs((micro_ms2 * 10) / SENSOR_G);
value = (int32_t) llvalue;
threshold.value = value;
threshold.enable = cfg->activity_th.enable;
threshold.referenced = cfg->activity_th.referenced;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
if (attr == SENSOR_ATTR_UPPER_THRESH) {
return adxl367_setup_activity_detection(dev, &threshold);
} else {
return adxl367_setup_inactivity_detection(dev, &threshold);
}
default:
LOG_ERR("attr_set() not supported on this channel");
return -ENOTSUP;
}
}
static int adxl367_attr_set_odr(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
enum adxl367_odr odr;
switch (val->val1) {
case 12:
case 13:
odr = ADXL367_ODR_12P5HZ;
break;
case 25:
odr = ADXL367_ODR_25HZ;
break;
case 50:
odr = ADXL367_ODR_50HZ;
break;
case 100:
odr = ADXL367_ODR_100HZ;
break;
case 200:
odr = ADXL367_ODR_200HZ;
break;
case 400:
odr = ADXL367_ODR_400HZ;
break;
default:
return -EINVAL;
}
return adxl367_set_output_rate(dev, odr);
}
static int adxl367_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return adxl367_attr_set_odr(dev, chan, attr, val);
case SENSOR_ATTR_UPPER_THRESH:
case SENSOR_ATTR_LOWER_THRESH:
return adxl367_attr_set_thresh(dev, chan, attr, val);
default:
return -ENOTSUP;
}
}
static int adxl367_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct adxl367_data *data = dev->data;
int ret;
ret = adxl367_get_accel_data(dev, &data->sample);
if (ret != 0) {
return ret;
}
return adxl367_get_temp_data(dev, &data->temp_val);
}
static void adxl367_accel_convert(const struct device *dev,
struct sensor_value *val, int16_t value)
{
struct adxl367_data *data = dev->data;
int64_t micro_ms2 = value * (SENSOR_G * 250 / 10000 *
adxl367_scale_mul[data->range] / 1000);
val->val1 = micro_ms2 / 1000000;
val->val2 = micro_ms2 % 1000000;
}
static void adxl367_temp_convert(struct sensor_value *val, int16_t value)
{
int64_t temp_data = (value + ADXL367_TEMP_OFFSET) * ADXL367_TEMP_SCALE;
val->val1 = temp_data / ADXL367_TEMP_SCALE_DIV;
val->val2 = temp_data % ADXL367_TEMP_SCALE_DIV;
}
static int adxl367_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct adxl367_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
adxl367_accel_convert(dev, val, data->sample.x);
break;
case SENSOR_CHAN_ACCEL_Y:
adxl367_accel_convert(dev, val, data->sample.y);
break;
case SENSOR_CHAN_ACCEL_Z:
adxl367_accel_convert(dev, val, data->sample.z);
break;
case SENSOR_CHAN_ACCEL_XYZ:
adxl367_accel_convert(dev, val++, data->sample.x);
adxl367_accel_convert(dev, val++, data->sample.y);
adxl367_accel_convert(dev, val, data->sample.z);
break;
case SENSOR_CHAN_DIE_TEMP:
adxl367_temp_convert(val, data->temp_val);
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api adxl367_api_funcs = {
.attr_set = adxl367_attr_set,
.sample_fetch = adxl367_sample_fetch,
.channel_get = adxl367_channel_get,
#ifdef CONFIG_ADXL367_TRIGGER
.trigger_set = adxl367_trigger_set,
#endif
};
static int adxl367_probe(const struct device *dev)
{
const struct adxl367_dev_config *cfg = dev->config;
struct adxl367_data *data = dev->data;
uint8_t dev_id, part_id;
int ret;
ret = adxl367_reset(dev);
if (ret != 0) {
return ret;
}
ret = data->hw_tf->read_reg(dev, ADXL367_DEVID, &dev_id);
if (ret != 0) {
return ret;
}
ret = data->hw_tf->read_reg(dev, ADXL367_PART_ID, &part_id);
if (ret != 0) {
return ret;
}
if (dev_id != ADXL367_DEVID_VAL || part_id != ADXL367_PARTID_VAL) {
LOG_ERR("failed to read id (0x%X:0x%X)\n", dev_id, part_id);
return -ENODEV;
}
data->range = cfg->range;
#ifdef CONFIG_ADXL367_TRIGGER
data->act_proc_mode = ADXL367_LINKED;
#else
data->act_proc_mode = ADXL367_LOOPED;
#endif
ret = adxl367_self_test(dev);
if (ret != 0) {
return ret;
}
ret = adxl367_temp_read_en(dev, cfg->temp_en);
if (ret != 0) {
return ret;
}
ret = adxl367_set_autosleep(dev, cfg->autosleep);
if (ret != 0) {
return ret;
}
ret = adxl367_set_low_noise(dev, cfg->low_noise);
if (ret != 0) {
return ret;
}
ret = adxl367_setup_activity_detection(dev, &cfg->activity_th);
if (ret != 0) {
return ret;
}
ret = adxl367_setup_inactivity_detection(dev, &cfg->inactivity_th);
if (ret != 0) {
return ret;
}
ret = adxl367_set_activity_time(dev, cfg->activity_time);
if (ret != 0) {
return ret;
}
ret = adxl367_set_inactivity_time(dev, cfg->inactivity_time);
if (ret != 0) {
return ret;
}
ret = adxl367_set_output_rate(dev, cfg->odr);
if (ret != 0) {
return ret;
}
ret = adxl367_fifo_setup(dev, cfg->fifo_config.fifo_mode,
cfg->fifo_config.fifo_format,
cfg->fifo_config.fifo_read_mode,
cfg->fifo_config.fifo_samples);
if (ret != 0) {
return ret;
}
if (IS_ENABLED(CONFIG_ADXL367_TRIGGER)) {
ret = adxl367_init_interrupt(dev);
if (ret != 0) {
LOG_ERR("Failed to initialize interrupt!");
return -EIO;
}
}
ret = adxl367_set_op_mode(dev, cfg->op_mode);
if (ret != 0) {
return ret;
}
ret = adxl367_set_range(dev, data->range);
if (ret != 0) {
return ret;
}
return adxl367_set_act_proc_mode(dev, data->act_proc_mode);
}
static int adxl367_init(const struct device *dev)
{
int ret;
const struct adxl367_dev_config *cfg = dev->config;
ret = cfg->bus_init(dev);
if (ret != 0) {
LOG_ERR("Failed to initialize sensor bus\n");
return ret;
}
return adxl367_probe(dev);
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "ADXL367 driver enabled without any devices"
#endif
/*
* Device creation macro, shared by ADXL367_DEFINE_SPI() and
* ADXL367_DEFINE_I2C().
*/
#define ADXL367_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
adxl367_init, \
NULL, \
&adxl367_data_##inst, \
&adxl367_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&adxl367_api_funcs);
#ifdef CONFIG_ADXL367_TRIGGER
#define ADXL367_CFG_IRQ(inst) \
.interrupt = GPIO_DT_SPEC_INST_GET(inst, int1_gpios),
#else
#define ADXL367_CFG_IRQ(inst)
#endif /* CONFIG_ADXL367_TRIGGER */
#define ADXL367_CONFIG(inst) \
.odr = DT_INST_PROP(inst, odr), \
.autosleep = false, \
.low_noise = false, \
.temp_en = true, \
.range = ADXL367_2G_RANGE, \
.activity_th.value = CONFIG_ADXL367_ACTIVITY_THRESHOLD, \
.activity_th.referenced = \
IS_ENABLED(CONFIG_ADXL367_REFERENCED_ACTIVITY_DETECTION_MODE), \
.activity_th.enable = \
IS_ENABLED(CONFIG_ADXL367_ACTIVITY_DETECTION_MODE), \
.activity_time = CONFIG_ADXL367_ACTIVITY_TIME, \
.inactivity_th.value = CONFIG_ADXL367_INACTIVITY_THRESHOLD, \
.inactivity_th.referenced = \
IS_ENABLED(CONFIG_ADXL367_REFERENCED_INACTIVITY_DETECTION_MODE),\
.inactivity_th.enable = \
IS_ENABLED(CONFIG_ADXL367_INACTIVITY_DETECTION_MODE), \
.inactivity_time = CONFIG_ADXL367_INACTIVITY_TIME, \
.fifo_config.fifo_mode = ADXL367_FIFO_DISABLED, \
.fifo_config.fifo_format = ADXL367_FIFO_FORMAT_XYZ, \
.fifo_config.fifo_samples = 128, \
.fifo_config.fifo_read_mode = ADXL367_14B_CHID, \
.op_mode = ADXL367_MEASURE,
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#define ADXL367_CONFIG_SPI(inst) \
{ \
.bus_init = adxl367_spi_init, \
.spi = SPI_DT_SPEC_INST_GET(inst, SPI_WORD_SET(8) | \
SPI_TRANSFER_MSB, 0), \
ADXL367_CONFIG(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
(ADXL367_CFG_IRQ(inst)), ()) \
}
#define ADXL367_DEFINE_SPI(inst) \
static struct adxl367_data adxl367_data_##inst; \
static const struct adxl367_dev_config adxl367_config_##inst = \
ADXL367_CONFIG_SPI(inst); \
ADXL367_DEVICE_INIT(inst)
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define ADXL367_CONFIG_I2C(inst) \
{ \
.bus_init = adxl367_i2c_init, \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
ADXL367_CONFIG(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
(ADXL367_CFG_IRQ(inst)), ()) \
}
#define ADXL367_DEFINE_I2C(inst) \
static struct adxl367_data adxl367_data_##inst; \
static const struct adxl367_dev_config adxl367_config_##inst = \
ADXL367_CONFIG_I2C(inst); \
ADXL367_DEVICE_INIT(inst)
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define ADXL367_DEFINE(inst) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(ADXL367_DEFINE_SPI(inst)), \
(ADXL367_DEFINE_I2C(inst)))
DT_INST_FOREACH_STATUS_OKAY(ADXL367_DEFINE)
``` | /content/code_sandbox/drivers/sensor/adi/adxl367/adxl367.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 8,415 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ADX345_ADX345_H_
#define ZEPHYR_DRIVERS_SENSOR_ADX345_ADX345_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.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
#include <zephyr/sys/util.h>
/* ADXL345 communication commands */
#define ADXL345_WRITE_CMD 0x00
#define ADXL345_READ_CMD 0x80
#define ADXL345_MULTIBYTE_FLAG 0x40
/* Registers */
#define ADXL345_DEVICE_ID_REG 0x00
#define ADXL345_RATE_REG 0x2c
#define ADXL345_POWER_CTL_REG 0x2d
#define ADXL345_DATA_FORMAT_REG 0x31
#define ADXL345_X_AXIS_DATA_0_REG 0x32
#define ADXL345_FIFO_CTL_REG 0x38
#define ADXL345_FIFO_STATUS_REG 0x39
#define ADXL345_PART_ID 0xe5
#define ADXL345_RANGE_2G 0x0
#define ADXL345_RANGE_4G 0x1
#define ADXL345_RANGE_8G 0x2
#define ADXL345_RANGE_16G 0x3
#define ADXL345_RATE_25HZ 0x8
#define ADXL345_ENABLE_MEASURE_BIT (1 << 3)
#define ADXL345_FIFO_STREAM_MODE (1 << 7)
#define ADXL345_FIFO_COUNT_MASK 0x3f
#define ADXL345_COMPLEMENT 0xfc00
#define ADXL345_MAX_FIFO_SIZE 32
struct adxl345_dev_data {
unsigned int sample_number;
int16_t bufx[ADXL345_MAX_FIFO_SIZE];
int16_t bufy[ADXL345_MAX_FIFO_SIZE];
int16_t bufz[ADXL345_MAX_FIFO_SIZE];
};
struct adxl345_sample {
int16_t x;
int16_t y;
int16_t z;
};
union adxl345_bus {
#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
};
typedef bool (*adxl345_bus_is_ready_fn)(const union adxl345_bus *bus);
typedef int (*adxl345_reg_access_fn)(const struct device *dev, uint8_t cmd,
uint8_t reg_addr, uint8_t *data, size_t length);
struct adxl345_dev_config {
const union adxl345_bus bus;
adxl345_bus_is_ready_fn bus_is_ready;
adxl345_reg_access_fn reg_access;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_ADX345_ADX345_H_ */
``` | /content/code_sandbox/drivers/sensor/adi/adxl345/adxl345.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 648 |
```unknown
# ADXL345, 3-Axis, +/-16g Digital Accelerometer
config ADXL345
bool "ADXL345 Three Axis accelerometer"
default y
depends on DT_HAS_ADI_ADXL345_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ADI_ADXL345),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ADI_ADXL345),spi)
help
Enable driver for ADXL345 Three-Axis Digital Accelerometer.
``` | /content/code_sandbox/drivers/sensor/adi/adxl345/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 110 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/asahi_kasei/ak8975/Kconfig"
source "drivers/sensor/asahi_kasei/akm09918c/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 58 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_AK8975_AK8975_H_
#define ZEPHYR_DRIVERS_SENSOR_AK8975_AK8975_H_
#include <zephyr/device.h>
#define AK8975_REG_CHIP_ID 0x00
#define AK8975_CHIP_ID 0x48
#define AK8975_REG_DATA_START 0x03
#define AK8975_REG_CNTL 0x0A
#define AK8975_MODE_MEASURE 0x01
#define AK8975_MODE_FUSE_ACCESS 0x0F
#define AK8975_REG_ADJ_DATA_START 0x10
#define AK8975_MEASURE_TIME_US 9000
#define AK8975_MICRO_GAUSS_PER_BIT 3000
struct ak8975_data {
int16_t x_sample;
int16_t y_sample;
int16_t z_sample;
uint8_t x_adj;
uint8_t y_adj;
uint8_t z_adj;
};
struct ak8975_config {
struct i2c_dt_spec i2c;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_AK8975_AK8975_H_ */
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/ak8975/ak8975.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 249 |
```unknown
# AK8975 magnetometer configuration options
config AK8975
bool "AK8975 Magnetometer"
default y
depends on DT_HAS_ASAHI_KASEI_AK8975_ENABLED
select I2C
help
Enable driver for AK8975 magnetometer.
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/ak8975/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 60 |
```c
/*
*
*/
#define DT_DRV_COMPAT adi_adxl345
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/__assert.h>
#include "adxl345.h"
LOG_MODULE_REGISTER(ADXL345, CONFIG_SENSOR_LOG_LEVEL);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
static bool adxl345_bus_is_ready_i2c(const union adxl345_bus *bus)
{
return device_is_ready(bus->i2c.bus);
}
static int adxl345_reg_access_i2c(const struct device *dev, uint8_t cmd, uint8_t reg_addr,
uint8_t *data, size_t length)
{
const struct adxl345_dev_config *cfg = dev->config;
if (cmd == ADXL345_READ_CMD) {
return i2c_burst_read_dt(&cfg->bus.i2c, reg_addr, data, length);
} else {
return i2c_burst_write_dt(&cfg->bus.i2c, reg_addr, data, length);
}
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
static bool adxl345_bus_is_ready_spi(const union adxl345_bus *bus)
{
return spi_is_ready_dt(&bus->spi);
}
static int adxl345_reg_access_spi(const struct device *dev, uint8_t cmd, uint8_t reg_addr,
uint8_t *data, size_t length)
{
const struct adxl345_dev_config *cfg = dev->config;
uint8_t access = reg_addr | cmd | (length == 1 ? 0 : ADXL345_MULTIBYTE_FLAG);
const struct spi_buf buf[2] = {{.buf = &access, .len = 1}, {.buf = data, .len = length}};
const struct spi_buf_set rx = {.buffers = buf, .count = ARRAY_SIZE(buf)};
struct spi_buf_set tx = {
.buffers = buf,
.count = 2,
};
if (cmd == ADXL345_READ_CMD) {
tx.count = 1;
return spi_transceive_dt(&cfg->bus.spi, &tx, &rx);
} else {
return spi_write_dt(&cfg->bus.spi, &tx);
}
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
static inline int adxl345_reg_access(const struct device *dev, uint8_t cmd, uint8_t addr,
uint8_t *data, size_t len)
{
const struct adxl345_dev_config *cfg = dev->config;
return cfg->reg_access(dev, cmd, addr, data, len);
}
static inline int adxl345_reg_write(const struct device *dev, uint8_t addr, uint8_t *data,
uint8_t len)
{
return adxl345_reg_access(dev, ADXL345_WRITE_CMD, addr, data, len);
}
static inline int adxl345_reg_read(const struct device *dev, uint8_t addr, uint8_t *data,
uint8_t len)
{
return adxl345_reg_access(dev, ADXL345_READ_CMD, addr, data, len);
}
static inline int adxl345_reg_write_byte(const struct device *dev, uint8_t addr, uint8_t val)
{
return adxl345_reg_write(dev, addr, &val, 1);
}
static inline int adxl345_reg_read_byte(const struct device *dev, uint8_t addr, uint8_t *buf)
{
return adxl345_reg_read(dev, addr, buf, 1);
}
static inline bool adxl345_bus_is_ready(const struct device *dev)
{
const struct adxl345_dev_config *cfg = dev->config;
return cfg->bus_is_ready(&cfg->bus);
}
static int adxl345_read_sample(const struct device *dev,
struct adxl345_sample *sample)
{
int16_t raw_x, raw_y, raw_z;
uint8_t axis_data[6];
int rc = adxl345_reg_read(dev, ADXL345_X_AXIS_DATA_0_REG, axis_data, 6);
if (rc < 0) {
LOG_ERR("Samples read failed with rc=%d\n", rc);
return rc;
}
raw_x = axis_data[0] | (axis_data[1] << 8);
raw_y = axis_data[2] | (axis_data[3] << 8);
raw_z = axis_data[4] | (axis_data[5] << 8);
sample->x = raw_x;
sample->y = raw_y;
sample->z = raw_z;
return 0;
}
static void adxl345_accel_convert(struct sensor_value *val, int16_t sample)
{
if (sample & BIT(9)) {
sample |= ADXL345_COMPLEMENT;
}
val->val1 = ((sample * SENSOR_G) / 32) / 1000000;
val->val2 = ((sample * SENSOR_G) / 32) % 1000000;
}
static int adxl345_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct adxl345_dev_data *data = dev->data;
struct adxl345_sample sample;
uint8_t samples_count;
int rc;
data->sample_number = 0;
rc = adxl345_reg_read_byte(dev, ADXL345_FIFO_STATUS_REG, &samples_count);
if (rc < 0) {
LOG_ERR("Failed to read FIFO status rc = %d\n", rc);
return rc;
}
__ASSERT_NO_MSG(samples_count <= ARRAY_SIZE(data->bufx));
for (uint8_t s = 0; s < samples_count; s++) {
rc = adxl345_read_sample(dev, &sample);
if (rc < 0) {
LOG_ERR("Failed to fetch sample rc=%d\n", rc);
return rc;
}
data->bufx[s] = sample.x;
data->bufy[s] = sample.y;
data->bufz[s] = sample.z;
}
return samples_count;
}
static int adxl345_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct adxl345_dev_data *data = dev->data;
if (data->sample_number >= ARRAY_SIZE(data->bufx)) {
data->sample_number = 0;
}
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
adxl345_accel_convert(val, data->bufx[data->sample_number]);
data->sample_number++;
break;
case SENSOR_CHAN_ACCEL_Y:
adxl345_accel_convert(val, data->bufy[data->sample_number]);
data->sample_number++;
break;
case SENSOR_CHAN_ACCEL_Z:
adxl345_accel_convert(val, data->bufz[data->sample_number]);
data->sample_number++;
break;
case SENSOR_CHAN_ACCEL_XYZ:
adxl345_accel_convert(val++, data->bufx[data->sample_number]);
adxl345_accel_convert(val++, data->bufy[data->sample_number]);
adxl345_accel_convert(val, data->bufz[data->sample_number]);
data->sample_number++;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api adxl345_api_funcs = {
.sample_fetch = adxl345_sample_fetch,
.channel_get = adxl345_channel_get,
};
static int adxl345_init(const struct device *dev)
{
int rc;
struct adxl345_dev_data *data = dev->data;
uint8_t dev_id;
data->sample_number = 0;
if (!adxl345_bus_is_ready(dev)) {
LOG_ERR("bus not ready");
return -ENODEV;
}
rc = adxl345_reg_read_byte(dev, ADXL345_DEVICE_ID_REG, &dev_id);
if (rc < 0 || dev_id != ADXL345_PART_ID) {
LOG_ERR("Read PART ID failed: 0x%x\n", rc);
return -ENODEV;
}
rc = adxl345_reg_write_byte(dev, ADXL345_FIFO_CTL_REG, ADXL345_FIFO_STREAM_MODE);
if (rc < 0) {
LOG_ERR("FIFO enable failed\n");
return -EIO;
}
rc = adxl345_reg_write_byte(dev, ADXL345_DATA_FORMAT_REG, ADXL345_RANGE_16G);
if (rc < 0) {
LOG_ERR("Data format set failed\n");
return -EIO;
}
rc = adxl345_reg_write_byte(dev, ADXL345_RATE_REG, ADXL345_RATE_25HZ);
if (rc < 0) {
LOG_ERR("Rate setting failed\n");
return -EIO;
}
rc = adxl345_reg_write_byte(dev, ADXL345_POWER_CTL_REG, ADXL345_ENABLE_MEASURE_BIT);
if (rc < 0) {
LOG_ERR("Enable measure bit failed\n");
return -EIO;
}
return 0;
}
#define ADXL345_CONFIG_SPI(inst) \
{ \
.bus = {.spi = SPI_DT_SPEC_INST_GET(inst, \
SPI_WORD_SET(8) | \
SPI_TRANSFER_MSB | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA, \
0)}, \
.bus_is_ready = adxl345_bus_is_ready_spi, \
.reg_access = adxl345_reg_access_spi, \
}
#define ADXL345_CONFIG_I2C(inst) \
{ \
.bus = {.i2c = I2C_DT_SPEC_INST_GET(inst)}, \
.bus_is_ready = adxl345_bus_is_ready_i2c, \
.reg_access = adxl345_reg_access_i2c, \
}
#define ADXL345_DEFINE(inst) \
static struct adxl345_dev_data adxl345_data_##inst; \
\
static const struct adxl345_dev_config adxl345_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), (ADXL345_CONFIG_SPI(inst)), \
(ADXL345_CONFIG_I2C(inst))); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, adxl345_init, NULL, \
&adxl345_data_##inst, &adxl345_config_##inst, POST_KERNEL,\
CONFIG_SENSOR_INIT_PRIORITY, &adxl345_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(ADXL345_DEFINE)
``` | /content/code_sandbox/drivers/sensor/adi/adxl345/adxl345.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,282 |
```c
/*
*
*/
#define DT_DRV_COMPAT asahi_kasei_ak8975
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
#include "ak8975.h"
LOG_MODULE_REGISTER(AK8975, CONFIG_SENSOR_LOG_LEVEL);
static int ak8975_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct ak8975_data *drv_data = dev->data;
const struct ak8975_config *drv_config = dev->config;
uint8_t buf[6];
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (i2c_reg_write_byte_dt(&drv_config->i2c, AK8975_REG_CNTL, AK8975_MODE_MEASURE) < 0) {
LOG_ERR("Failed to start measurement.");
return -EIO;
}
k_busy_wait(AK8975_MEASURE_TIME_US);
if (i2c_burst_read_dt(&drv_config->i2c, AK8975_REG_DATA_START, buf, 6) < 0) {
LOG_ERR("Failed to read sample data.");
return -EIO;
}
drv_data->x_sample = sys_le16_to_cpu(buf[0] | (buf[1] << 8));
drv_data->y_sample = sys_le16_to_cpu(buf[2] | (buf[3] << 8));
drv_data->z_sample = sys_le16_to_cpu(buf[4] | (buf[5] << 8));
return 0;
}
static void ak8975_convert(struct sensor_value *val, int16_t sample,
uint8_t adjustment)
{
int32_t conv_val;
conv_val = sample * AK8975_MICRO_GAUSS_PER_BIT *
((uint16_t)adjustment + 128) / 256;
val->val1 = conv_val / 1000000;
val->val2 = conv_val % 1000000;
}
static int ak8975_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct ak8975_data *drv_data = dev->data;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_MAGN_XYZ ||
chan == SENSOR_CHAN_MAGN_X ||
chan == SENSOR_CHAN_MAGN_Y ||
chan == SENSOR_CHAN_MAGN_Z);
if (chan == SENSOR_CHAN_MAGN_XYZ) {
ak8975_convert(val, drv_data->x_sample, drv_data->x_adj);
ak8975_convert(val + 1, drv_data->y_sample, drv_data->y_adj);
ak8975_convert(val + 2, drv_data->z_sample, drv_data->z_adj);
} else if (chan == SENSOR_CHAN_MAGN_X) {
ak8975_convert(val, drv_data->x_sample, drv_data->x_adj);
} else if (chan == SENSOR_CHAN_MAGN_Y) {
ak8975_convert(val, drv_data->y_sample, drv_data->y_adj);
} else if (chan == SENSOR_CHAN_MAGN_Z) {
ak8975_convert(val, drv_data->z_sample, drv_data->z_adj);
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api ak8975_driver_api = {
.sample_fetch = ak8975_sample_fetch,
.channel_get = ak8975_channel_get,
};
static int ak8975_read_adjustment_data(const struct device *dev)
{
struct ak8975_data *drv_data = dev->data;
const struct ak8975_config *drv_config = dev->config;
uint8_t buf[3];
if (i2c_reg_write_byte_dt(&drv_config->i2c, AK8975_REG_CNTL, AK8975_MODE_FUSE_ACCESS) < 0) {
LOG_ERR("Failed to set chip in fuse access mode.");
return -EIO;
}
if (i2c_burst_read_dt(&drv_config->i2c, AK8975_REG_ADJ_DATA_START, buf, 3) < 0) {
LOG_ERR("Failed to read adjustment data.");
return -EIO;
}
drv_data->x_adj = buf[0];
drv_data->y_adj = buf[1];
drv_data->z_adj = buf[2];
return 0;
}
int ak8975_init(const struct device *dev)
{
const struct ak8975_config *drv_config = dev->config;
uint8_t id;
if (!device_is_ready(drv_config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
/* check chip ID */
if (i2c_reg_read_byte_dt(&drv_config->i2c, AK8975_REG_CHIP_ID, &id) < 0) {
LOG_ERR("Failed to read chip ID.");
return -EIO;
}
if (id != AK8975_CHIP_ID) {
LOG_ERR("Invalid chip ID.");
return -EINVAL;
}
if (ak8975_read_adjustment_data(dev) < 0) {
return -EIO;
}
return 0;
}
#define AK8975_DEFINE(inst) \
static struct ak8975_data ak8975_data_##inst; \
\
static const struct ak8975_config ak8975_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, ak8975_init, NULL, \
&ak8975_data_##inst, &ak8975_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&ak8975_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(AK8975_DEFINE)
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/ak8975/ak8975.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,306 |
```c
/*
*
*/
#include <zephyr/logging/log.h>
#include <zephyr/rtio/work.h>
#include "akm09918c.h"
LOG_MODULE_DECLARE(AKM09918C, CONFIG_SENSOR_LOG_LEVEL);
void akm09918c_submit_sync(struct rtio_iodev_sqe *iodev_sqe)
{
const struct sensor_read_config *cfg = iodev_sqe->sqe.iodev->data;
const struct device *dev = cfg->sensor;
uint32_t min_buf_len = sizeof(struct akm09918c_encoded_data);
int rc;
uint8_t *buf;
uint32_t buf_len;
struct akm09918c_encoded_data *edata;
/* Get the buffer for the frame, it may be allocated dynamically by the rtio context */
rc = rtio_sqe_rx_buf(iodev_sqe, min_buf_len, min_buf_len, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get a read buffer of size %u bytes", min_buf_len);
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
edata = (struct akm09918c_encoded_data *)buf;
edata->header.timestamp = k_ticks_to_ns_floor64(k_uptime_ticks());
rc = akm09918c_sample_fetch_helper(dev, SENSOR_CHAN_MAGN_XYZ, &edata->readings[0],
&edata->readings[1], &edata->readings[2]);
if (rc != 0) {
LOG_ERR("Failed to fetch samples");
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
rtio_iodev_sqe_ok(iodev_sqe, 0);
}
void akm09918c_submit(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe)
{
struct rtio_work_req *req = rtio_work_req_alloc();
__ASSERT_NO_MSG(req);
rtio_work_req_submit(req, iodev_sqe, akm09918c_submit_sync);
}
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/akm09918c_async.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 448 |
```c
/*
*/
#define DT_DRV_COMPAT asahi_kasei_akm09918c
#include <zephyr/device.h>
#include <zephyr/drivers/emul.h>
#include <zephyr/drivers/emul_sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/i2c_emul.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/util.h>
#include "akm09918c.h"
#include "akm09918c_emul.h"
#include "akm09918c_reg.h"
LOG_MODULE_DECLARE(AKM09918C, CONFIG_SENSOR_LOG_LEVEL);
#define NUM_REGS AKM09918C_REG_TS2
struct akm09918c_emul_data {
uint8_t reg[NUM_REGS];
};
struct akm09918c_emul_cfg {
};
void akm09918c_emul_set_reg(const struct emul *target, uint8_t reg_addr, const uint8_t *val,
size_t count)
{
struct akm09918c_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr + count < NUM_REGS);
memcpy(data->reg + reg_addr, val, count);
}
void akm09918c_emul_get_reg(const struct emul *target, uint8_t reg_addr, uint8_t *val, size_t count)
{
struct akm09918c_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr + count < NUM_REGS);
memcpy(val, data->reg + reg_addr, count);
}
void akm09918c_emul_reset(const struct emul *target)
{
struct akm09918c_emul_data *data = target->data;
memset(data->reg, 0, NUM_REGS);
data->reg[AKM09918C_REG_WIA1] = AKM09918C_WIA1;
data->reg[AKM09918C_REG_WIA2] = AKM09918C_WIA2;
}
static int akm09918c_emul_handle_write(const struct emul *target, uint8_t regn, uint8_t value)
{
struct akm09918c_emul_data *data = target->data;
switch (regn) {
case AKM09918C_REG_CNTL2:
data->reg[AKM09918C_REG_CNTL2] = value;
break;
case AKM09918C_REG_CNTL3:
if (FIELD_GET(AKM09918C_CNTL3_SRST, value) == 1) {
akm09918c_emul_reset(target);
}
break;
}
return 0;
}
static int akm09918c_emul_transfer_i2c(const struct emul *target, struct i2c_msg *msgs,
int num_msgs, int addr)
{
struct akm09918c_emul_data *data = target->data;
i2c_dump_msgs_rw(target->dev, msgs, num_msgs, addr, false);
if (num_msgs < 1) {
LOG_ERR("Invalid number of messages: %d", num_msgs);
return -EIO;
}
if (FIELD_GET(I2C_MSG_READ, msgs->flags)) {
LOG_ERR("Unexpected read");
return -EIO;
}
if (msgs->len < 1) {
LOG_ERR("Unexpected msg0 length %d", msgs->len);
return -EIO;
}
uint8_t regn = msgs->buf[0];
bool is_read = FIELD_GET(I2C_MSG_READ, msgs->flags) == 1;
bool is_stop = FIELD_GET(I2C_MSG_STOP, msgs->flags) == 1;
if (!is_stop && !is_read) {
/* First message was a write with the register number, check next message */
msgs++;
is_read = FIELD_GET(I2C_MSG_READ, msgs->flags) == 1;
is_stop = FIELD_GET(I2C_MSG_STOP, msgs->flags) == 1;
}
if (is_read) {
/* Read data */
uint8_t mode = data->reg[AKM09918C_REG_CNTL2];
for (int i = 0; i < msgs->len; ++i) {
msgs->buf[i] = data->reg[regn + i];
if (regn + i == AKM09918C_REG_TMPS &&
mode == AKM09918C_CNTL2_SINGLE_MEASURE) {
/* Reading the TMPS register clears the DRDY bit */
data->reg[AKM09918C_REG_ST1] = 0;
}
}
} else {
/* Write data */
int rc = akm09918c_emul_handle_write(target, regn, msgs->buf[1]);
if (rc != 0) {
return rc;
}
}
return 0;
}
static int akm09918c_emul_init(const struct emul *target, const struct device *parent)
{
ARG_UNUSED(parent);
akm09918c_emul_reset(target);
return 0;
}
static int akm09918c_emul_backend_set_channel(const struct emul *target, struct sensor_chan_spec ch,
const q31_t *value, int8_t shift)
{
if (!target || !target->data) {
return -EINVAL;
}
struct akm09918c_emul_data *data = target->data;
uint8_t reg;
switch (ch.chan_type) {
case SENSOR_CHAN_MAGN_X:
reg = AKM09918C_REG_HXL;
break;
case SENSOR_CHAN_MAGN_Y:
reg = AKM09918C_REG_HYL;
break;
case SENSOR_CHAN_MAGN_Z:
reg = AKM09918C_REG_HZL;
break;
/* This function only supports setting single channels, so skip MAGN_XYZ */
default:
return -ENOTSUP;
}
/* Set the ST1 register to show we have data */
data->reg[AKM09918C_REG_ST1] |= AKM09918C_ST1_DRDY;
/* Convert fixed-point Gauss values into microgauss and then into its bit representation */
int32_t microgauss =
(shift < 0 ? ((int64_t)*value >> -shift) : ((int64_t)*value << shift)) * 1000000 /
((int64_t)INT32_MAX + 1);
int16_t reg_val =
CLAMP(microgauss, AKM09918C_MAGN_MIN_MICRO_GAUSS, AKM09918C_MAGN_MAX_MICRO_GAUSS) /
AKM09918C_MICRO_GAUSS_PER_BIT;
/* Insert reading into registers */
data->reg[reg] = reg_val & 0xFF;
data->reg[reg + 1] = (reg_val >> 8) & 0xFF;
return 0;
}
static int akm09918c_emul_backend_get_sample_range(const struct emul *target,
struct sensor_chan_spec ch, q31_t *lower,
q31_t *upper, q31_t *epsilon, int8_t *shift)
{
ARG_UNUSED(target);
if (!lower || !upper || !epsilon || !shift) {
return -EINVAL;
}
switch (ch.chan_type) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
/* +/- 49.12 Gs is the measurement range. 0.0015 Gs is the granularity */
*shift = 6;
*upper = (int64_t)(49.12 * ((int64_t)INT32_MAX + 1)) >> *shift;
*lower = -*upper;
*epsilon = (int64_t)(0.0015 * ((int64_t)INT32_MAX + 1)) >> *shift;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct i2c_emul_api akm09918c_emul_api_i2c = {
.transfer = akm09918c_emul_transfer_i2c,
};
static const struct emul_sensor_driver_api akm09918c_emul_sensor_driver_api = {
.set_channel = akm09918c_emul_backend_set_channel,
.get_sample_range = akm09918c_emul_backend_get_sample_range,
};
#define AKM09918C_EMUL(n) \
const struct akm09918c_emul_cfg akm09918c_emul_cfg_##n; \
struct akm09918c_emul_data akm09918c_emul_data_##n; \
EMUL_DT_INST_DEFINE(n, akm09918c_emul_init, &akm09918c_emul_data_##n, \
&akm09918c_emul_cfg_##n, &akm09918c_emul_api_i2c, \
&akm09918c_emul_sensor_driver_api)
DT_INST_FOREACH_STATUS_OKAY(AKM09918C_EMUL)
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/akm09918c_emul.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,948 |
```c
/*
*/
#include "akm09918c.h"
#define DT_DRV_COMPAT asahi_kasei_akm09918c
static int akm09918c_decoder_get_frame_count(const uint8_t *buffer,
struct sensor_chan_spec chan_spec,
uint16_t *frame_count)
{
ARG_UNUSED(buffer);
ARG_UNUSED(chan_spec);
/* This sensor lacks a FIFO; there will always only be one frame at a time. */
*frame_count = 1;
return 0;
}
static int akm09918c_decoder_get_size_info(struct sensor_chan_spec chan_spec, size_t *base_size,
size_t *frame_size)
{
switch (chan_spec.chan_type) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
*base_size = sizeof(struct sensor_three_axis_data);
*frame_size = sizeof(struct sensor_three_axis_sample_data);
return 0;
default:
return -ENOTSUP;
}
}
/** Fixed shift value to use. All channels (MAGN_X, _Y, and _Z) have the same fixed range of
* +/- 49.12 Gauss.
*/
#define AKM09918C_SHIFT (6)
static int akm09918c_convert_raw_to_q31(int16_t reading, q31_t *out)
{
int64_t intermediate = ((int64_t)reading * AKM09918C_MICRO_GAUSS_PER_BIT) *
((int64_t)INT32_MAX + 1) /
((1 << AKM09918C_SHIFT) * INT64_C(1000000));
*out = CLAMP(intermediate, INT32_MIN, INT32_MAX);
return 0;
}
static int akm09918c_decoder_decode(const uint8_t *buffer, struct sensor_chan_spec chan_spec,
uint32_t *fit, uint16_t max_count, void *data_out)
{
const struct akm09918c_encoded_data *edata = (const struct akm09918c_encoded_data *)buffer;
if (*fit != 0) {
return 0;
}
switch (chan_spec.chan_type) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ: {
struct sensor_three_axis_data *out = data_out;
out->header.base_timestamp_ns = edata->header.timestamp;
out->header.reading_count = 1;
out->shift = AKM09918C_SHIFT;
akm09918c_convert_raw_to_q31(edata->readings[0], &out->readings[0].x);
akm09918c_convert_raw_to_q31(edata->readings[1], &out->readings[0].y);
akm09918c_convert_raw_to_q31(edata->readings[2], &out->readings[0].z);
*fit = 1;
return 1;
}
default:
return -EINVAL;
}
}
SENSOR_DECODER_API_DT_DEFINE() = {
.get_frame_count = akm09918c_decoder_get_frame_count,
.get_size_info = akm09918c_decoder_get_size_info,
.decode = akm09918c_decoder_decode,
};
int akm09918c_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder)
{
ARG_UNUSED(dev);
*decoder = &SENSOR_DECODER_NAME();
return 0;
}
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/akm09918c_decoder.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 755 |
```objective-c
/*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_EMUL_H
#define ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_EMUL_H
#include <zephyr/drivers/emul.h>
/**
* @brief Set one or more register values
*
* @param target The target emulator to modify
* @param reg_addr The starting address of the register to modify
* @param in One or more bytes to write to the registers
* @param count The number of bytes to write
*/
void akm09918c_emul_set_reg(const struct emul *target, uint8_t reg_addr, const uint8_t *val,
size_t count);
/**
* @brief Get the values of one or more register values
*
* @param target The target emulator to read
* @param reg_addr The starting address of the register to read
* @param out Buffer to write the register values into
* @param count The number of bytes to read
*/
void akm09918c_emul_get_reg(const struct emul *target, uint8_t reg_addr, uint8_t *val,
size_t count);
/**
* @brief Reset the emulator
*
* @param target The target emulator to reset
*/
void akm09918c_emul_reset(const struct emul *target);
#endif /* ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_EMUL_H */
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/akm09918c_emul.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 310 |
```unknown
config AKM09918C
bool "AKM09918C Magnetometer"
default y
depends on DT_HAS_ASAHI_KASEI_AKM09918C_ENABLED
select I2C
select RTIO_WORKQ if SENSOR_ASYNC_API
help
Enable driver for AK8975 magnetometer.
config EMUL_AKM09918C
bool "Emulator for AKM09918C"
default y
depends on AKM09918C
depends on EMUL
help
Enable the hardware emulator for the AKM09918C. Doing so allows exercising
sensor APIs for this magnetometer in native_sim and qemu.
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 138 |
```objective-c
/*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_H_
#define ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_H_
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/rtio/rtio.h>
#include "akm09918c_reg.h"
/* Time it takes to get a measurement in single-measure mode */
#define AKM09918C_MEASURE_TIME_US 9000
/* Conversion values */
#define AKM09918C_MICRO_GAUSS_PER_BIT INT64_C(1500)
/* Maximum and minimum raw register values for magnetometer data per datasheet */
#define AKM09918C_MAGN_MAX_DATA_REG (32752)
#define AKM09918C_MAGN_MIN_DATA_REG (-32752)
/* Maximum and minimum magnetometer values in microgauss. +/-32752 is the maximum range of the
* data registers (slightly less than the range of int16). This works out to +/- 49,128,000 uGs
*/
#define AKM09918C_MAGN_MAX_MICRO_GAUSS (AKM09918C_MAGN_MAX_DATA_REG * AKM09918C_MICRO_GAUSS_PER_BIT)
#define AKM09918C_MAGN_MIN_MICRO_GAUSS (AKM09918C_MAGN_MIN_DATA_REG * AKM09918C_MICRO_GAUSS_PER_BIT)
struct akm09918c_data {
int16_t x_sample;
int16_t y_sample;
int16_t z_sample;
uint8_t mode;
};
struct akm09918c_config {
struct i2c_dt_spec i2c;
};
static inline uint8_t akm09918c_hz_to_reg(const struct sensor_value *val)
{
if (val->val1 >= 100) {
return AKM09918C_CNTL2_CONTINUOUS_4;
} else if (val->val1 >= 50) {
return AKM09918C_CNTL2_CONTINUOUS_3;
} else if (val->val1 >= 20) {
return AKM09918C_CNTL2_CONTINUOUS_2;
} else if (val->val1 > 0) {
return AKM09918C_CNTL2_CONTINUOUS_1;
} else {
return AKM09918C_CNTL2_PWR_DOWN;
}
}
static inline void akm09918c_reg_to_hz(uint8_t reg, struct sensor_value *val)
{
val->val1 = 0;
val->val2 = 0;
switch (reg) {
case AKM09918C_CNTL2_CONTINUOUS_1:
val->val1 = 10;
break;
case AKM09918C_CNTL2_CONTINUOUS_2:
val->val1 = 20;
break;
case AKM09918C_CNTL2_CONTINUOUS_3:
val->val1 = 50;
break;
case AKM09918C_CNTL2_CONTINUOUS_4:
val->val1 = 100;
break;
}
}
/*
* RTIO types
*/
struct akm09918c_decoder_header {
uint64_t timestamp;
} __attribute__((__packed__));
struct akm09918c_encoded_data {
struct akm09918c_decoder_header header;
int16_t readings[3];
};
int akm09918c_sample_fetch_helper(const struct device *dev, enum sensor_channel chan, int16_t *x,
int16_t *y, int16_t *z);
int akm09918c_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder);
void akm09918c_submit(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe);
#endif /* ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_H_ */
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/akm09918c.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 842 |
```objective-c
/*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_REG_H
#define ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_REG_H
#include <zephyr/sys/util_macro.h>
#define AKM09918C_REG_WIA1 0x00
#define AKM09918C_REG_WIA2 0x01
#define AKM09918C_REG_RSV1 0x02
#define AKM09918C_REG_RSV2 0x03
#define AKM09918C_REG_ST1 0x10
#define AKM09918C_REG_HXL 0x11
#define AKM09918C_REG_HXH 0x12
#define AKM09918C_REG_HYL 0x13
#define AKM09918C_REG_HYH 0x14
#define AKM09918C_REG_HZL 0x15
#define AKM09918C_REG_HZH 0x16
#define AKM09918C_REG_TMPS 0x17
#define AKM09918C_REG_ST2 0x18
#define AKM09918C_REG_CNTL1 0x30
#define AKM09918C_REG_CNTL2 0x31
#define AKM09918C_REG_CNTL3 0x32
#define AKM09918C_REG_TS1 0x33
#define AKM09918C_REG_TS2 0x34
/* Who-I-Am register values */
#define AKM09918C_WIA1 0x48
#define AKM09918C_WIA2 0x0c
/* ST1 values */
#define AKM09918C_ST1_DRDY BIT(0)
#define AKM09918C_ST1_DOR BIT(1)
/* CNTL2 values */
#define AKM09918C_CNTL2_PWR_DOWN 0x00
#define AKM09918C_CNTL2_SINGLE_MEASURE BIT(0)
#define AKM09918C_CNTL2_CONTINUOUS_1 BIT(1)
#define AKM09918C_CNTL2_CONTINUOUS_2 BIT(2)
#define AKM09918C_CNTL2_CONTINUOUS_3 (BIT(1) | BIT(2))
#define AKM09918C_CNTL2_CONTINUOUS_4 BIT(3)
/* CNTL3 values */
#define AKM09918C_CNTL3_SRST BIT(0)
#endif /* ZEPHYR_DRIVERS_SENSOR_AKM09918C_AKM09918C_REG_H */
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/akm09918c_reg.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 557 |
```c
/*
*/
#define DT_DRV_COMPAT asahi_kasei_akm09918c
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor_data_types.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
#include "akm09918c.h"
#include "akm09918c_reg.h"
LOG_MODULE_REGISTER(AKM09918C, CONFIG_SENSOR_LOG_LEVEL);
/**
* @brief Perform the bus transaction to fetch samples
*
* @param dev Sensor device to operate on
* @param chan Channel ID to fetch
* @param x Location to write X channel sample.
* @param y Location to write Y channel sample.
* @param z Location to write Z channel sample.
* @return int 0 if successful or error code
*/
int akm09918c_sample_fetch_helper(const struct device *dev, enum sensor_channel chan, int16_t *x,
int16_t *y, int16_t *z)
{
struct akm09918c_data *data = dev->data;
const struct akm09918c_config *cfg = dev->config;
uint8_t buf[9] = {0};
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_MAGN_X && chan != SENSOR_CHAN_MAGN_Y &&
chan != SENSOR_CHAN_MAGN_Z && chan != SENSOR_CHAN_MAGN_XYZ) {
LOG_DBG("Invalid channel %d", chan);
return -EINVAL;
}
if (data->mode == AKM09918C_CNTL2_PWR_DOWN) {
if (i2c_reg_write_byte_dt(&cfg->i2c, AKM09918C_REG_CNTL2,
AKM09918C_CNTL2_SINGLE_MEASURE) != 0) {
LOG_ERR("Failed to start measurement.");
return -EIO;
}
/* Wait for sample */
LOG_DBG("Waiting for sample...");
k_usleep(AKM09918C_MEASURE_TIME_US);
}
/* We have to read through the TMPS register or the data_ready bit won't clear */
if (i2c_burst_read_dt(&cfg->i2c, AKM09918C_REG_ST1, buf, ARRAY_SIZE(buf)) != 0) {
LOG_ERR("Failed to read sample data.");
return -EIO;
}
if (FIELD_GET(AKM09918C_ST1_DRDY, buf[0]) == 0) {
LOG_ERR("Data not ready, st1=0x%02x", buf[0]);
return -EBUSY;
}
*x = sys_le16_to_cpu(buf[1] | (buf[2] << 8));
*y = sys_le16_to_cpu(buf[3] | (buf[4] << 8));
*z = sys_le16_to_cpu(buf[5] | (buf[6] << 8));
return 0;
}
static int akm09918c_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct akm09918c_data *data = dev->data;
return akm09918c_sample_fetch_helper(dev, chan, &data->x_sample, &data->y_sample,
&data->z_sample);
}
static void akm09918c_convert(struct sensor_value *val, int16_t sample)
{
int64_t conv_val = sample * AKM09918C_MICRO_GAUSS_PER_BIT;
val->val1 = conv_val / 1000000;
val->val2 = conv_val - (val->val1 * 1000000);
}
static int akm09918c_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct akm09918c_data *data = dev->data;
if (chan == SENSOR_CHAN_MAGN_XYZ) {
akm09918c_convert(val, data->x_sample);
akm09918c_convert(val + 1, data->y_sample);
akm09918c_convert(val + 2, data->z_sample);
} else if (chan == SENSOR_CHAN_MAGN_X) {
akm09918c_convert(val, data->x_sample);
} else if (chan == SENSOR_CHAN_MAGN_Y) {
akm09918c_convert(val, data->y_sample);
} else if (chan == SENSOR_CHAN_MAGN_Z) {
akm09918c_convert(val, data->z_sample);
} else {
LOG_DBG("Invalid channel %d", chan);
return -ENOTSUP;
}
return 0;
}
static int akm09918c_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
struct akm09918c_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (attr != SENSOR_ATTR_SAMPLING_FREQUENCY) {
LOG_WRN("Invalid attribute %d", attr);
return -EINVAL;
}
akm09918c_reg_to_hz(data->mode, val);
break;
default:
LOG_WRN("Invalid channel %d", chan);
return -EINVAL;
}
return 0;
}
static int akm09918c_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct akm09918c_config *cfg = dev->config;
struct akm09918c_data *data = dev->data;
int res;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (attr != SENSOR_ATTR_SAMPLING_FREQUENCY) {
LOG_WRN("Invalid attribute %d", attr);
return -EINVAL;
}
uint8_t mode = akm09918c_hz_to_reg(val);
res = i2c_reg_write_byte_dt(&cfg->i2c, AKM09918C_REG_CNTL2, mode);
if (res != 0) {
LOG_ERR("Failed to set sample frequency");
return -EIO;
}
data->mode = mode;
break;
default:
LOG_WRN("Invalid channel %d", chan);
return -EINVAL;
}
return 0;
}
static inline int akm09918c_check_who_am_i(const struct i2c_dt_spec *i2c)
{
uint8_t buffer[2];
int rc;
rc = i2c_burst_read_dt(i2c, AKM09918C_REG_WIA1, buffer, ARRAY_SIZE(buffer));
if (rc != 0) {
LOG_ERR("Failed to read who-am-i register (rc=%d)", rc);
return -EIO;
}
if (buffer[0] != AKM09918C_WIA1 || buffer[1] != AKM09918C_WIA2) {
LOG_ERR("Wrong who-am-i value");
return -EINVAL;
}
return 0;
}
static int akm09918c_init(const struct device *dev)
{
const struct akm09918c_config *cfg = dev->config;
struct akm09918c_data *data = dev->data;
int rc;
if (!i2c_is_ready_dt(&cfg->i2c)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
/* Soft reset the chip */
rc = i2c_reg_write_byte_dt(&cfg->i2c, AKM09918C_REG_CNTL3,
FIELD_PREP(AKM09918C_CNTL3_SRST, 1));
if (rc != 0) {
LOG_ERR("Failed to soft reset");
return -EIO;
}
/* check chip ID */
rc = akm09918c_check_who_am_i(&cfg->i2c);
if (rc != 0) {
return rc;
}
data->mode = AKM09918C_CNTL2_PWR_DOWN;
return 0;
}
static const struct sensor_driver_api akm09918c_driver_api = {
.sample_fetch = akm09918c_sample_fetch,
.channel_get = akm09918c_channel_get,
.attr_get = akm09918c_attr_get,
.attr_set = akm09918c_attr_set,
#ifdef CONFIG_SENSOR_ASYNC_API
.submit = akm09918c_submit,
.get_decoder = akm09918c_get_decoder,
#endif
};
#define AKM09918C_DEFINE(inst) \
static struct akm09918c_data akm09918c_data_##inst; \
\
static const struct akm09918c_config akm09918c_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, akm09918c_init, NULL, &akm09918c_data_##inst, \
&akm09918c_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &akm09918c_driver_api);
DT_INST_FOREACH_STATUS_OKAY(AKM09918C_DEFINE)
``` | /content/code_sandbox/drivers/sensor/asahi_kasei/akm09918c/akm09918c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,039 |
```c
/*
*
*/
#define DT_DRV_COMPAT renesas_hs300x
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#define HS300X_STATUS_MASK (BIT(0) | BIT(1))
LOG_MODULE_REGISTER(HS300X, CONFIG_SENSOR_LOG_LEVEL);
struct hs300x_config {
struct i2c_dt_spec bus;
};
struct hs300x_data {
int16_t t_sample;
uint16_t rh_sample;
};
static int hs300x_read_sample(const struct device *dev, uint16_t *t_sample, uint16_t *rh_sample)
{
const struct hs300x_config *cfg = dev->config;
uint8_t rx_buf[4];
int rc;
rc = i2c_read_dt(&cfg->bus, rx_buf, sizeof(rx_buf));
if (rc < 0) {
LOG_ERR("Failed to read data from device.");
return rc;
}
if ((rx_buf[3] & HS300X_STATUS_MASK) != 0) {
LOG_ERR("Stale data");
return -EIO;
}
*rh_sample = sys_get_be16(rx_buf);
*t_sample = sys_get_be16(&rx_buf[2]);
/* Remove status bits (only present in temperature value)*/
*t_sample >>= 2;
return 0;
}
static int hs300x_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct hs300x_data *data = dev->data;
const struct hs300x_config *cfg = dev->config;
int rc;
uint8_t df_dummy = 0x0;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP &&
chan != SENSOR_CHAN_HUMIDITY) {
return -ENOTSUP;
}
/*
* By default, the sensor should be factory-programmed to operate in Sleep Mode.
* A Measurement Request (MR) command is required to exit the sensor
* from its sleep state. An MR command should consist of the 7-bit address followed
* by an eighth bit set to 0 (write). However, many I2C controllers cannot generate
* merely the address byte with no data. To overcome this limitation the MR command
* should be followed by a dummy byte (zero value).
*/
rc = i2c_write_dt(&cfg->bus, (const uint8_t *)&df_dummy, 1);
if (rc < 0) {
LOG_ERR("Failed to start measurement.");
return rc;
}
/*
* According to datasheet maximum time to make temperature and humidity
* measurements is 33ms, add a little safety margin...
*/
k_msleep(50);
rc = hs300x_read_sample(dev, &data->t_sample, &data->rh_sample);
if (rc < 0) {
LOG_ERR("Failed to fetch data.");
return rc;
}
return 0;
}
static void hs300x_temp_convert(struct sensor_value *val, int16_t raw)
{
int32_t micro_c;
/*
* Convert to micro Celsius. See datasheet "Calculating Humidity and
* Temperature Output" section for more details on processing sample data.
*/
micro_c = (((int64_t)raw * 165000000) / 16383) - 40000000;
val->val1 = micro_c / 1000000;
val->val2 = micro_c % 1000000;
}
static void hs300x_rh_convert(struct sensor_value *val, uint16_t raw)
{
int32_t micro_rh;
/*
* Convert to micro %RH. See datasheet "Calculating Humidity and
* Temperature Output" section for more details on processing sample data.
*/
micro_rh = ((uint64_t)raw * 100000000) / 16383;
val->val1 = micro_rh / 1000000;
val->val2 = micro_rh % 1000000;
}
static int hs300x_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct hs300x_data *data = dev->data;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
hs300x_temp_convert(val, data->t_sample);
} else if (chan == SENSOR_CHAN_HUMIDITY) {
hs300x_rh_convert(val, data->rh_sample);
} else {
return -ENOTSUP;
}
return 0;
}
static int hs300x_init(const struct device *dev)
{
const struct hs300x_config *cfg = dev->config;
if (!i2c_is_ready_dt(&cfg->bus)) {
LOG_ERR("I2C dev %s not ready", cfg->bus.bus->name);
return -ENODEV;
}
return 0;
}
static const struct sensor_driver_api hs300x_driver_api = {.sample_fetch = hs300x_sample_fetch,
.channel_get = hs300x_channel_get};
#define DEFINE_HS300X(n) \
static struct hs300x_data hs300x_data_##n; \
\
static const struct hs300x_config hs300x_config_##n = {.bus = I2C_DT_SPEC_INST_GET(n)}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, hs300x_init, NULL, &hs300x_data_##n, &hs300x_config_##n, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&hs300x_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_HS300X)
``` | /content/code_sandbox/drivers/sensor/hs300x/hs300x.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,235 |
```unknown
# Renesas HS300x temperature and humidity sensor configuration options
config HS300X
bool "HS300x Temperature and Humidity Sensor"
default y
depends on DT_HAS_RENESAS_HS300X_ENABLED
select I2C
help
Enable driver for HS300x temperature and humidity sensors.
``` | /content/code_sandbox/drivers/sensor/hs300x/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 66 |
```unknown
config A01NYUB
bool "DFRobot A01NYUB distance sensor"
default y
depends on DT_HAS_DFROBOT_A01NYUB_ENABLED
depends on UART_INTERRUPT_DRIVEN
select UART_USE_RUNTIME_CONFIGURE
help
Enable driver for the DFRobot A01NYUB distance sensor.
``` | /content/code_sandbox/drivers/sensor/a01nyub/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 68 |
```c
/*
*
*
* Datasheet:
* path_to_url
*
*/
#define DT_DRV_COMPAT dfrobot_a01nyub
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
LOG_MODULE_REGISTER(a01nyub_sensor, CONFIG_SENSOR_LOG_LEVEL);
#define A01NYUB_BUF_LEN 4
#define A01NYUB_CHECKSUM_IDX 3
#define A01NYUB_HEADER 0xff
const struct uart_config uart_cfg_a01nyub = {
.baudrate = 9600,
.parity = UART_CFG_PARITY_NONE,
.stop_bits = UART_CFG_STOP_BITS_1,
.data_bits = UART_CFG_DATA_BITS_8,
.flow_ctrl = UART_CFG_FLOW_CTRL_NONE
};
struct a01nyub_data {
/* Max data length is 16 bits */
uint16_t data;
uint8_t xfer_bytes;
uint8_t rd_data[A01NYUB_BUF_LEN];
};
struct a01nyub_cfg {
const struct device *uart_dev;
uart_irq_callback_user_data_t cb;
};
static void a01nyub_uart_flush(const struct device *uart_dev)
{
uint8_t c;
while (uart_fifo_read(uart_dev, &c, 1) > 0) {
continue;
}
}
static uint8_t a01nyub_checksum(const uint8_t *data)
{
uint16_t cs = 0;
for (uint8_t i = 0; i < A01NYUB_BUF_LEN - 1; i++) {
cs += data[i];
}
return (uint8_t) (cs & 0x00FF);
}
static inline int a01nyub_poll_data(const struct device *dev)
{
struct a01nyub_data *data = dev->data;
uint8_t checksum;
checksum = a01nyub_checksum(data->rd_data);
if (checksum != data->rd_data[A01NYUB_CHECKSUM_IDX]) {
LOG_DBG("Checksum mismatch: calculated 0x%x != data checksum 0x%x",
checksum,
data->rd_data[A01NYUB_CHECKSUM_IDX]);
LOG_DBG("Data bytes: (%x,%x,%x,%x)",
data->rd_data[0],
data->rd_data[1],
data->rd_data[2],
data->rd_data[3]);
return -EBADMSG;
}
data->data = (data->rd_data[1]<<8) + data->rd_data[2];
return 0;
}
static int a01nyub_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct a01nyub_data *data = dev->data;
if (chan != SENSOR_CHAN_DISTANCE) {
return -ENOTSUP;
}
/* val1 is meters, val2 is microns. Both are int32_t
* data->data is in mm and units of uint16_t
*/
val->val1 = (uint32_t) (data->data / (uint16_t) 1000);
val->val2 = (uint32_t) ((data->data % 1000) * 1000);
return 0;
}
static int a01nyub_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (chan == SENSOR_CHAN_DISTANCE || chan == SENSOR_CHAN_ALL) {
return a01nyub_poll_data(dev);
}
return -ENOTSUP;
}
static const struct sensor_driver_api a01nyub_api_funcs = {
.sample_fetch = a01nyub_sample_fetch,
.channel_get = a01nyub_channel_get,
};
static void a01nyub_uart_isr(const struct device *uart_dev, void *user_data)
{
const struct device *dev = user_data;
struct a01nyub_data *data = dev->data;
if (uart_dev == NULL) {
LOG_DBG("UART device is NULL");
return;
}
if (!uart_irq_update(uart_dev)) {
LOG_DBG("Unable to start processing interrupts");
return;
}
if (uart_irq_rx_ready(uart_dev)) {
data->xfer_bytes += uart_fifo_read(uart_dev, &data->rd_data[data->xfer_bytes],
A01NYUB_BUF_LEN - data->xfer_bytes);
/* The first byte should be A01NYUB_HEADER for a valid read.
* If we do not read A01NYUB_HEADER on what we think is the
* first byte, then reset the number of bytes read until we do
*/
if ((data->rd_data[0] != A01NYUB_HEADER) & (data->xfer_bytes == 1)) {
LOG_DBG("First byte not header! Resetting # of bytes read.");
data->xfer_bytes = 0;
}
if (data->xfer_bytes == A01NYUB_BUF_LEN) {
LOG_DBG("Read (0x%x,0x%x,0x%x,0x%x)",
data->rd_data[0],
data->rd_data[1],
data->rd_data[2],
data->rd_data[3]);
a01nyub_uart_flush(uart_dev);
data->xfer_bytes = 0;
}
}
}
static int a01nyub_init(const struct device *dev)
{
const struct a01nyub_cfg *cfg = dev->config;
int ret = 0;
uart_irq_rx_disable(cfg->uart_dev);
uart_irq_tx_disable(cfg->uart_dev);
a01nyub_uart_flush(cfg->uart_dev);
LOG_DBG("Initializing A01NYUB driver");
ret = uart_configure(cfg->uart_dev, &uart_cfg_a01nyub);
if (ret == -ENOSYS) {
LOG_ERR("Unable to configure UART port");
return -ENOSYS;
}
ret = uart_irq_callback_user_data_set(cfg->uart_dev, cfg->cb, (void *)dev);
if (ret < 0) {
if (ret == -ENOTSUP) {
LOG_ERR("Interrupt-driven UART API support not enabled");
} else if (ret == -ENOSYS) {
LOG_ERR("UART device does not support interrupt-driven API");
} else {
LOG_ERR("Error setting UART callback: %d", ret);
}
return ret;
}
uart_irq_rx_enable(cfg->uart_dev);
return ret;
}
#define A01NYUB_INIT(inst) \
\
static struct a01nyub_data a01nyub_data_##inst; \
\
static const struct a01nyub_cfg a01nyub_cfg_##inst = { \
.uart_dev = DEVICE_DT_GET(DT_INST_BUS(inst)), \
.cb = a01nyub_uart_isr, \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, a01nyub_init, NULL, \
&a01nyub_data_##inst, &a01nyub_cfg_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &a01nyub_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(A01NYUB_INIT)
``` | /content/code_sandbox/drivers/sensor/a01nyub/a01nyub.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,573 |
```unknown
# ExplorIR-M CO2 sensor configuration options
config EXPLORIR_M
bool "ExplorIR-M CO2 Sensor"
default y
depends on DT_HAS_GSS_EXPLORIR_M_ENABLED
depends on UART_INTERRUPT_DRIVEN
select UART
help
Enable driver for ExplorIR-M CO2 Sensor.
``` | /content/code_sandbox/drivers/sensor/explorir_m/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/nordic/npm1300_charger/Kconfig"
source "drivers/sensor/nordic/qdec_nrfx/Kconfig"
source "drivers/sensor/nordic/temp/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/nordic/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 66 |
```unknown
#
config NPM1300_CHARGER
bool "NPM1300 Charger"
default y
depends on DT_HAS_NORDIC_NPM1300_CHARGER_ENABLED
select I2C
select MFD
select REQUIRES_FULL_LIBC
help
Enable NPM1300 charger driver.
``` | /content/code_sandbox/drivers/sensor/nordic/npm1300_charger/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 64 |
```c
/*
*
*
* Datasheet:
* path_to_url
*
*/
#define DT_DRV_COMPAT gss_explorir_m
#include <stdio.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/explorir_m.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(explorir_m_sensor, CONFIG_SENSOR_LOG_LEVEL);
#define EXPLORIR_M_BEGIN_CHAR ' '
#define EXPLORIR_M_SET_FILTER_CHAR 'A'
#define EXPLORIR_M_GET_FILTER_CHAR 'a'
#define EXPLORIR_M_MODE_CHAR 'K'
#define EXPLORIR_M_CO2_FILTERED_CHAR 'Z'
#define EXPLORIR_M_SCALING_CHAR '.'
#define EXPLORIR_M_NOT_RECOGNISED_CHAR '?'
#define EXPLORIR_M_SEPARATOR_CHAR ' '
#define EXPLORIR_M_PRE_END_CHAR '\r'
#define EXPLORIR_M_END_CHAR '\n'
#define EXPLORIR_M_TYPE_INDEX 1
#define EXPLORIR_M_VALUE_INDEX 3
#define EXPLORIR_M_BUFFER_LENGTH 16
#define EXPLORIR_M_MAX_RESPONSE_DELAY 200 /* Add margin to the specified 100 in datasheet */
#define EXPLORIR_M_CO2_VALID_DELAY 1200
struct explorir_m_data {
struct k_mutex uart_mutex;
struct k_sem uart_rx_sem;
uint16_t filtered;
uint16_t scaling;
uint8_t read_index;
uint8_t read_buffer[EXPLORIR_M_BUFFER_LENGTH];
};
struct explorir_m_cfg {
const struct device *uart_dev;
uart_irq_callback_user_data_t cb;
};
enum explorir_m_uart_set_usage {
EXPLORIR_M_SET_NONE,
EXPLORIR_M_SET_VAL_ONE,
EXPLORIR_M_SET_VAL_ONE_TWO,
};
enum EXPLORIR_M_MODE {
EXPLORIR_M_MODE_COMMAND,
EXPLORIR_M_MODE_STREAM,
EXPLORIR_M_MODE_POLL,
};
static void explorir_m_uart_flush(const struct device *uart_dev)
{
uint8_t tmp;
while (uart_fifo_read(uart_dev, &tmp, 1) > 0) {
continue;
}
}
static void explorir_m_uart_flush_until_end(const struct device *uart_dev)
{
uint8_t tmp;
uint32_t uptime;
uptime = k_uptime_get_32();
do {
uart_poll_in(uart_dev, &tmp);
} while (tmp != EXPLORIR_M_END_CHAR &&
k_uptime_get_32() - uptime < EXPLORIR_M_MAX_RESPONSE_DELAY);
}
static void explorir_m_buffer_reset(struct explorir_m_data *data)
{
memset(data->read_buffer, 0, data->read_index);
data->read_index = 0;
}
static int explorir_m_buffer_verify(const struct explorir_m_data *data, char type)
{
char buffer_type = data->read_buffer[EXPLORIR_M_TYPE_INDEX];
if (data->read_buffer[0] == EXPLORIR_M_NOT_RECOGNISED_CHAR) {
LOG_WRN("Sensor did not recognise the command");
return -EIO;
}
if (buffer_type != type) {
LOG_WRN("Expected type %c but got %c", type, buffer_type);
return -EIO;
}
if (data->read_buffer[0] != EXPLORIR_M_BEGIN_CHAR ||
data->read_buffer[2] != EXPLORIR_M_SEPARATOR_CHAR ||
data->read_buffer[data->read_index - 2] != EXPLORIR_M_PRE_END_CHAR) {
LOG_HEXDUMP_WRN(data->read_buffer, data->read_index, "Invalid buffer");
return -EIO;
}
return 0;
}
static int explorir_m_buffer_process(struct explorir_m_data *data, char type,
struct sensor_value *val)
{
if (explorir_m_buffer_verify(data, type) != 0) {
return -EIO;
}
switch (type) {
case EXPLORIR_M_SET_FILTER_CHAR:
case EXPLORIR_M_MODE_CHAR:
break;
case EXPLORIR_M_CO2_FILTERED_CHAR:
data->scaling = strtol(&data->read_buffer[EXPLORIR_M_VALUE_INDEX], NULL, 10);
break;
case EXPLORIR_M_SCALING_CHAR:
data->filtered = strtol(&data->read_buffer[EXPLORIR_M_VALUE_INDEX], NULL, 10);
break;
case EXPLORIR_M_GET_FILTER_CHAR:
val->val1 = strtol(&data->read_buffer[EXPLORIR_M_VALUE_INDEX], NULL, 10);
break;
default:
LOG_ERR("Unknown type %c/0x%02x", type, type);
return -EIO;
}
return 0;
}
static void explorir_m_uart_isr(const struct device *uart_dev, void *user_data)
{
const struct device *dev = user_data;
struct explorir_m_data *data = dev->data;
int rc, read_len;
if (!device_is_ready(uart_dev)) {
LOG_DBG("UART device is not ready");
return;
}
if (!uart_irq_update(uart_dev)) {
LOG_DBG("Unable to process interrupts");
return;
}
if (!uart_irq_rx_ready(uart_dev)) {
LOG_DBG("No RX data");
return;
}
read_len = EXPLORIR_M_BUFFER_LENGTH - data->read_index;
rc = uart_fifo_read(uart_dev, &data->read_buffer[data->read_index], read_len);
if (rc < 0 || rc == read_len) {
LOG_ERR("UART read failed: %d", rc < 0 ? rc : -ERANGE);
explorir_m_uart_flush(uart_dev);
LOG_HEXDUMP_WRN(data->read_buffer, data->read_index, "Discarding");
explorir_m_buffer_reset(data);
} else {
data->read_index += rc;
if (data->read_buffer[data->read_index - 1] != EXPLORIR_M_END_CHAR) {
return;
}
}
k_sem_give(&data->uart_rx_sem);
}
static void explorir_m_uart_terminate(const struct device *uart_dev)
{
uart_poll_out(uart_dev, EXPLORIR_M_PRE_END_CHAR);
uart_poll_out(uart_dev, EXPLORIR_M_END_CHAR);
}
static int explorir_m_await_receive(struct explorir_m_data *data)
{
int rc = k_sem_take(&data->uart_rx_sem, K_MSEC(EXPLORIR_M_MAX_RESPONSE_DELAY));
/* Reset semaphore if sensor did not respond within maximum specified response time */
if (rc == -EAGAIN) {
k_sem_reset(&data->uart_rx_sem);
}
return rc;
}
static int explorir_m_uart_transceive(const struct device *dev, char type, struct sensor_value *val,
enum explorir_m_uart_set_usage set)
{
const struct explorir_m_cfg *cfg = dev->config;
struct explorir_m_data *data = dev->data;
char buf[EXPLORIR_M_BUFFER_LENGTH];
int rc, len;
if (val == NULL && set != EXPLORIR_M_SET_NONE) {
LOG_ERR("val is NULL but set is not NONE");
return -EINVAL;
}
k_mutex_lock(&data->uart_mutex, K_FOREVER);
explorir_m_buffer_reset(data);
uart_poll_out(cfg->uart_dev, type);
if (set == EXPLORIR_M_SET_VAL_ONE) {
len = snprintf(buf, EXPLORIR_M_BUFFER_LENGTH, "%c%u", EXPLORIR_M_SEPARATOR_CHAR,
val->val1);
} else if (set == EXPLORIR_M_SET_VAL_ONE_TWO) {
len = snprintf(buf, EXPLORIR_M_BUFFER_LENGTH, "%c%u%c%u", EXPLORIR_M_SEPARATOR_CHAR,
val->val1, EXPLORIR_M_SEPARATOR_CHAR, val->val2);
} else {
len = 0;
}
if (len == EXPLORIR_M_BUFFER_LENGTH) {
LOG_WRN("Set value truncated");
}
for (int i = 0; i != len; i++) {
uart_poll_out(cfg->uart_dev, buf[i]);
}
explorir_m_uart_terminate(cfg->uart_dev);
rc = explorir_m_await_receive(data);
if (rc != 0) {
LOG_WRN("%c did not receive a response: %d", type, rc);
}
if (rc == 0) {
rc = explorir_m_buffer_process(data, type, val);
}
k_mutex_unlock(&data->uart_mutex);
return rc;
}
static int explorir_m_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
if (chan != SENSOR_CHAN_CO2) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_EXPLORIR_M_FILTER:
return explorir_m_uart_transceive(dev, EXPLORIR_M_GET_FILTER_CHAR, val,
EXPLORIR_M_SET_NONE);
default:
return -ENOTSUP;
}
}
static int explorir_m_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_CO2) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_EXPLORIR_M_FILTER:
if (val->val1 < 0 || val->val1 > 255) {
return -ERANGE;
}
return explorir_m_uart_transceive(dev, EXPLORIR_M_SET_FILTER_CHAR,
(struct sensor_value *)val,
EXPLORIR_M_SET_VAL_ONE);
default:
return -ENOTSUP;
}
}
static int explorir_m_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
if (chan != SENSOR_CHAN_CO2 && chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
return explorir_m_uart_transceive(dev, EXPLORIR_M_CO2_FILTERED_CHAR, NULL,
EXPLORIR_M_SET_NONE);
}
static int explorir_m_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct explorir_m_data *data = dev->data;
if (chan != SENSOR_CHAN_CO2) {
return -ENOTSUP;
}
if (k_uptime_get() < EXPLORIR_M_CO2_VALID_DELAY) {
return -EAGAIN;
}
val->val1 = data->filtered * data->scaling;
val->val2 = 0;
return 0;
}
static const struct sensor_driver_api explorir_m_api_funcs = {
.attr_set = explorir_m_attr_set,
.attr_get = explorir_m_attr_get,
.sample_fetch = explorir_m_sample_fetch,
.channel_get = explorir_m_channel_get,
};
static int explorir_m_init(const struct device *dev)
{
const struct explorir_m_cfg *cfg = dev->config;
struct explorir_m_data *data = dev->data;
struct sensor_value val;
int rc;
LOG_DBG("Initializing %s", dev->name);
if (!device_is_ready(cfg->uart_dev)) {
return -ENODEV;
}
k_mutex_init(&data->uart_mutex);
k_sem_init(&data->uart_rx_sem, 0, 1);
uart_irq_rx_disable(cfg->uart_dev);
uart_irq_tx_disable(cfg->uart_dev);
rc = uart_irq_callback_user_data_set(cfg->uart_dev, cfg->cb, (void *)dev);
if (rc != 0) {
LOG_ERR("UART IRQ setup failed: %d", rc);
return rc;
}
/* Terminate garbled tx due to GPIO setup or crash during unfinished send */
explorir_m_uart_terminate(cfg->uart_dev);
explorir_m_uart_flush_until_end(cfg->uart_dev);
uart_irq_rx_enable(cfg->uart_dev);
val.val1 = EXPLORIR_M_MODE_POLL;
explorir_m_uart_transceive(dev, EXPLORIR_M_MODE_CHAR, &val, EXPLORIR_M_SET_VAL_ONE);
explorir_m_uart_transceive(dev, EXPLORIR_M_SCALING_CHAR, NULL, EXPLORIR_M_SET_NONE);
return rc;
}
#define EXPLORIR_M_INIT(n) \
\
static struct explorir_m_data explorir_m_data_##n; \
\
static const struct explorir_m_cfg explorir_m_cfg_##n = { \
.uart_dev = DEVICE_DT_GET(DT_INST_BUS(n)), \
.cb = explorir_m_uart_isr, \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, explorir_m_init, NULL, &explorir_m_data_##n, \
&explorir_m_cfg_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &explorir_m_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(EXPLORIR_M_INIT)
``` | /content/code_sandbox/drivers/sensor/explorir_m/explorir_m.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,837 |
```c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/drivers/pinctrl.h>
#include <soc.h>
#include <nrfx_qdec.h>
#include <hal/nrf_gpio.h>
#include <zephyr/logging/log.h>
#include <zephyr/irq.h>
LOG_MODULE_REGISTER(qdec_nrfx, CONFIG_SENSOR_LOG_LEVEL);
#define DT_DRV_COMPAT nordic_nrf_qdec
#define FULL_ANGLE 360
/* limit range to avoid overflow when converting steps to degrees */
#define ACC_MAX (INT_MAX / FULL_ANGLE)
#define ACC_MIN (INT_MIN / FULL_ANGLE)
struct qdec_nrfx_data {
int32_t acc;
sensor_trigger_handler_t data_ready_handler;
const struct sensor_trigger *data_ready_trigger;
};
struct qdec_nrfx_config {
nrfx_qdec_t qdec;
nrfx_qdec_config_t config;
void (*irq_connect)(void);
const struct pinctrl_dev_config *pcfg;
uint32_t enable_pin;
int32_t steps;
};
static void accumulate(struct qdec_nrfx_data *data, int32_t acc)
{
unsigned int key = irq_lock();
bool overflow = ((acc > 0) && (ACC_MAX - acc < data->acc)) ||
((acc < 0) && (ACC_MIN - acc > data->acc));
if (!overflow) {
data->acc += acc;
}
irq_unlock(key);
}
static int qdec_nrfx_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct qdec_nrfx_config *config = dev->config;
struct qdec_nrfx_data *data = dev->data;
int32_t acc;
uint32_t accdbl;
if ((chan != SENSOR_CHAN_ALL) && (chan != SENSOR_CHAN_ROTATION)) {
return -ENOTSUP;
}
nrfx_qdec_accumulators_read(&config->qdec, &acc, &accdbl);
accumulate(data, acc);
return 0;
}
static int qdec_nrfx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct qdec_nrfx_data *data = dev->data;
const struct qdec_nrfx_config *config = dev->config;
unsigned int key;
int32_t acc;
if (chan != SENSOR_CHAN_ROTATION) {
return -ENOTSUP;
}
key = irq_lock();
acc = data->acc;
data->acc = 0;
irq_unlock(key);
val->val1 = (acc * FULL_ANGLE) / config->steps;
val->val2 = (acc * FULL_ANGLE) - (val->val1 * config->steps);
if (val->val2 != 0) {
val->val2 *= 1000000;
val->val2 /= config->steps;
}
return 0;
}
static int qdec_nrfx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct qdec_nrfx_data *data = dev->data;
unsigned int key;
if (trig->type != SENSOR_TRIG_DATA_READY) {
return -ENOTSUP;
}
if ((trig->chan != SENSOR_CHAN_ALL) &&
(trig->chan != SENSOR_CHAN_ROTATION)) {
return -ENOTSUP;
}
key = irq_lock();
data->data_ready_handler = handler;
data->data_ready_trigger = trig;
irq_unlock(key);
return 0;
}
static void qdec_nrfx_event_handler(nrfx_qdec_event_t event, void *p_context)
{
const struct device *dev = p_context;
struct qdec_nrfx_data *dev_data = dev->data;
sensor_trigger_handler_t handler;
const struct sensor_trigger *trig;
unsigned int key;
switch (event.type) {
case NRF_QDEC_EVENT_REPORTRDY:
accumulate(dev_data, event.data.report.acc);
key = irq_lock();
handler = dev_data->data_ready_handler;
trig = dev_data->data_ready_trigger;
irq_unlock(key);
if (handler) {
handler(dev, trig);
}
break;
default:
LOG_ERR("unhandled event (0x%x)", event.type);
break;
}
}
static void qdec_nrfx_gpio_ctrl(const struct device *dev, bool enable)
{
const struct qdec_nrfx_config *config = dev->config;
if (config->enable_pin != NRF_QDEC_PIN_NOT_CONNECTED) {
uint32_t val = (enable)?(0):(1);
nrf_gpio_pin_write(config->enable_pin, val);
nrf_gpio_cfg_output(config->enable_pin);
}
}
static const struct sensor_driver_api qdec_nrfx_driver_api = {
.sample_fetch = qdec_nrfx_sample_fetch,
.channel_get = qdec_nrfx_channel_get,
.trigger_set = qdec_nrfx_trigger_set,
};
#ifdef CONFIG_PM_DEVICE
static int qdec_nrfx_pm_action(const struct device *dev,
enum pm_device_action action)
{
const struct qdec_nrfx_config *config = dev->config;
int ret = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
ret = pinctrl_apply_state(config->pcfg,
PINCTRL_STATE_DEFAULT);
if (ret < 0) {
return ret;
}
qdec_nrfx_gpio_ctrl(dev, true);
nrfx_qdec_enable(&config->qdec);
break;
case PM_DEVICE_ACTION_TURN_OFF:
/* device must be uninitialized */
nrfx_qdec_uninit(&config->qdec);
ret = pinctrl_apply_state(config->pcfg,
PINCTRL_STATE_SLEEP);
if (ret < 0) {
return ret;
}
break;
case PM_DEVICE_ACTION_SUSPEND:
/* device must be suspended */
nrfx_qdec_disable(&config->qdec);
qdec_nrfx_gpio_ctrl(dev, false);
ret = pinctrl_apply_state(config->pcfg,
PINCTRL_STATE_SLEEP);
if (ret < 0) {
return ret;
}
break;
default:
return -ENOTSUP;
}
return ret;
}
#endif /* CONFIG_PM_DEVICE */
static int qdec_nrfx_init(const struct device *dev)
{
const struct qdec_nrfx_config *dev_config = dev->config;
dev_config->irq_connect();
int err = pinctrl_apply_state(dev_config->pcfg, PINCTRL_STATE_DEFAULT);
if (err < 0) {
return err;
}
nrfx_err_t nerr = nrfx_qdec_init(&dev_config->qdec,
&dev_config->config,
qdec_nrfx_event_handler,
(void *)dev);
if (nerr == NRFX_ERROR_INVALID_STATE) {
LOG_ERR("qdec already in use");
return -EBUSY;
} else if (nerr != NRFX_SUCCESS) {
LOG_ERR("failed to initialize qdec");
return -EFAULT;
}
qdec_nrfx_gpio_ctrl(dev, true);
nrfx_qdec_enable(&dev_config->qdec);
return 0;
}
#define QDEC(idx) DT_NODELABEL(qdec##idx)
#define QDEC_PROP(idx, prop) DT_PROP(QDEC(idx), prop)
#define SENSOR_NRFX_QDEC_DEVICE(idx) \
NRF_DT_CHECK_NODE_HAS_PINCTRL_SLEEP(QDEC(idx)); \
BUILD_ASSERT(QDEC_PROP(idx, steps) > 0, \
"Wrong QDEC"#idx" steps setting in dts. Only positive number valid"); \
BUILD_ASSERT(QDEC_PROP(idx, steps) <= 2048, \
"Wrong QDEC"#idx" steps setting in dts. Overflow possible"); \
static void irq_connect##idx(void) \
{ \
IRQ_CONNECT(DT_IRQN(QDEC(idx)), DT_IRQ(QDEC(idx), priority), \
nrfx_isr, nrfx_qdec_##idx##_irq_handler, 0); \
} \
static struct qdec_nrfx_data qdec_##idx##_data; \
PINCTRL_DT_DEFINE(QDEC(idx)); \
static struct qdec_nrfx_config qdec_##idx##_config = { \
.qdec = NRFX_QDEC_INSTANCE(idx), \
.config = { \
.reportper = NRF_QDEC_REPORTPER_40, \
.sampleper = NRF_QDEC_SAMPLEPER_2048US, \
.skip_gpio_cfg = true, \
.skip_psel_cfg = true, \
.ledpre = QDEC_PROP(idx, led_pre), \
.ledpol = NRF_QDEC_LEPOL_ACTIVE_HIGH, \
.reportper_inten = true, \
}, \
.irq_connect = irq_connect##idx, \
.pcfg = PINCTRL_DT_DEV_CONFIG_GET(QDEC(idx)), \
.enable_pin = DT_PROP_OR(QDEC(idx), enable_pin, NRF_QDEC_PIN_NOT_CONNECTED), \
.steps = QDEC_PROP(idx, steps), \
}; \
PM_DEVICE_DT_DEFINE(QDEC(idx), qdec_nrfx_pm_action); \
SENSOR_DEVICE_DT_DEFINE(QDEC(idx), \
qdec_nrfx_init, \
PM_DEVICE_DT_GET(QDEC(idx)), \
&qdec_##idx##_data, \
&qdec_##idx##_config, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&qdec_nrfx_driver_api)
#ifdef CONFIG_HAS_HW_NRF_QDEC0
SENSOR_NRFX_QDEC_DEVICE(0);
#endif
#ifdef CONFIG_HAS_HW_NRF_QDEC1
SENSOR_NRFX_QDEC_DEVICE(1);
#endif
#ifdef CONFIG_HAS_HW_NRF_QDEC20
SENSOR_NRFX_QDEC_DEVICE(20);
#endif
#ifdef CONFIG_HAS_HW_NRF_QDEC21
SENSOR_NRFX_QDEC_DEVICE(21);
#endif
#ifdef CONFIG_HAS_HW_NRF_QDEC130
SENSOR_NRFX_QDEC_DEVICE(130);
#endif
#ifdef CONFIG_HAS_HW_NRF_QDEC131
SENSOR_NRFX_QDEC_DEVICE(131);
#endif
``` | /content/code_sandbox/drivers/sensor/nordic/qdec_nrfx/qdec_nrfx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,227 |
```unknown
config QDEC_NRFX
bool "Nordic QDEC nrfx driver"
default y
depends on DT_HAS_NORDIC_NRF_QDEC_ENABLED
select NRFX_QDEC0 if HAS_HW_NRF_QDEC0
select NRFX_QDEC1 if HAS_HW_NRF_QDEC1
select NRFX_QDEC20 if HAS_HW_NRF_QDEC20
select NRFX_QDEC21 if HAS_HW_NRF_QDEC21
select NRFX_QDEC130 if HAS_HW_NRF_QDEC130
select NRFX_QDEC131 if HAS_HW_NRF_QDEC131
select PINCTRL
help
Enable support for nrfx QDEC driver for nRF MCU series.
``` | /content/code_sandbox/drivers/sensor/nordic/qdec_nrfx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 149 |
```c
/*
*
*/
#define DT_DRV_COMPAT nordic_nrf_temp_nrfs
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/__assert.h>
#include <nrfs_temp.h>
LOG_MODULE_REGISTER(temp_nrfs, CONFIG_SENSOR_LOG_LEVEL);
struct temp_nrfs_data {
struct k_sem measure_sem;
struct k_mutex mutex;
int32_t raw_temp;
#ifdef CONFIG_TEMP_NRFS_TRIGGER
struct sensor_trigger trigger;
sensor_trigger_handler_t handler;
const struct device *dev;
struct sensor_value sampling_freq;
struct sensor_value up_threshold;
struct sensor_value low_threshold;
#endif
#if defined(CONFIG_TEMP_NRFS_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_TEMP_NRFS_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem event_sem;
#elif defined(CONFIG_TEMP_NRFS_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
};
#ifdef CONFIG_TEMP_NRFS_TRIGGER
#define DEFAULT_SAMPLING_FREQ { 1, 0 }
#define DEFAULT_UP_THRESHOLD { 25, 0 }
#define DEFAULT_LOW_THRESHOLD { 0, 0 }
static void temp_nrfs_handle_event(const struct device *dev)
{
struct temp_nrfs_data *data = dev->data;
struct sensor_trigger trigger;
sensor_trigger_handler_t handler;
k_mutex_lock(&data->mutex, K_FOREVER);
trigger = data->trigger;
handler = data->handler;
k_mutex_unlock(&data->mutex);
if (handler) {
handler(dev, &trigger);
}
}
#if defined(CONFIG_TEMP_NRFS_TRIGGER_OWN_THREAD)
static void temp_nrfs_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct temp_nrfs_data *data = p1;
while (1) {
k_sem_take(&data->event_sem, K_FOREVER);
temp_nrfs_handle_event(data->dev);
}
}
#elif defined(CONFIG_TEMP_NRFS_TRIGGER_GLOBAL_THREAD)
static void temp_nrfs_work_handler(struct k_work *work)
{
struct temp_nrfs_data *data =
CONTAINER_OF(work, struct temp_nrfs_data, work);
temp_nrfs_handle_event(data->dev);
}
#endif
static uint16_t to_measure_rate_ms(const struct sensor_value *freq_val)
{
uint32_t measure_rate_ms = (MSEC_PER_SEC * 1000) /
(uint32_t)sensor_value_to_milli(freq_val);
return (uint16_t)MIN(measure_rate_ms, UINT16_MAX);
}
static int32_t to_raw_temp(const struct sensor_value *temp_val)
{
int32_t temp_mul_100 = (int32_t)(sensor_value_to_milli(temp_val) / 10);
return nrfs_temp_to_raw(temp_mul_100);
}
static int api_sensor_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct temp_nrfs_data *data = dev->data;
nrfs_err_t err;
if (trig->chan != SENSOR_CHAN_ALL &&
trig->chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
switch (trig->type) {
case SENSOR_TRIG_THRESHOLD:
k_mutex_lock(&data->mutex, K_FOREVER);
data->trigger = *trig;
data->handler = handler;
k_mutex_unlock(&data->mutex);
if (handler) {
err = nrfs_temp_subscribe(
to_measure_rate_ms(&data->sampling_freq),
to_raw_temp(&data->low_threshold),
to_raw_temp(&data->up_threshold),
data);
} else {
err = nrfs_temp_unsubscribe();
}
switch (err) {
case NRFS_SUCCESS:
break;
case NRFS_ERR_INVALID_STATE:
return -EAGAIN;
default:
return -EIO;
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int api_sensor_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct temp_nrfs_data *data = dev->data;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
if (sensor_value_to_milli(val) <= 0) {
return -EINVAL;
}
data->sampling_freq = *val;
break;
case SENSOR_ATTR_UPPER_THRESH:
data->up_threshold = *val;
break;
case SENSOR_ATTR_LOWER_THRESH:
data->low_threshold = *val;
break;
default:
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_TEMP_NRFS_TRIGGER */
static void sensor_handler(nrfs_temp_evt_t const *p_evt, void *context)
{
ARG_UNUSED(context);
struct temp_nrfs_data *data = context;
switch (p_evt->type) {
case NRFS_TEMP_EVT_MEASURE_DONE:
data->raw_temp = p_evt->raw_temp;
k_sem_give(&data->measure_sem);
break;
#ifdef CONFIG_TEMP_NRFS_TRIGGER
case NRFS_TEMP_EVT_CHANGE:
data->raw_temp = p_evt->raw_temp;
#if defined(CONFIG_TEMP_NRFS_TRIGGER_OWN_THREAD)
k_sem_give(&data->event_sem);
#elif defined(CONFIG_TEMP_NRFS_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
break;
#endif /* CONFIG_TEMP_NRFS_TRIGGER */
default:
LOG_DBG("Temperature handler - unsupported event: 0x%x",
p_evt->type);
break;
}
}
static int api_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct temp_nrfs_data *data = dev->data;
int nrfs_rc;
int rc = 0;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
nrfs_rc = nrfs_temp_measure_request(data);
switch (nrfs_rc) {
case NRFS_SUCCESS:
k_sem_take(&data->measure_sem, K_FOREVER);
LOG_DBG("Temperature sample: %d", data->raw_temp);
break;
case NRFS_ERR_INVALID_STATE:
LOG_DBG("Backend is not ready, try again.");
rc = -EAGAIN;
break;
default:
LOG_DBG("Measure request failed: %d", nrfs_rc);
rc = -EIO;
break;
}
k_mutex_unlock(&data->mutex);
return rc;
}
static int api_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct temp_nrfs_data *data = dev->data;
if (chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
int32_t uval = nrfs_temp_from_raw(data->raw_temp);
val->val1 = uval / 100;
val->val2 = (abs(uval) % 100) * 10000;
LOG_DBG("Temperature: %d.%02u[C]", uval / 100, abs(uval) % 100);
return 0;
}
static int temp_nrfs_init(const struct device *dev)
{
int rc;
rc = nrfs_temp_init(sensor_handler);
if (rc < 0) {
return rc;
}
#if defined(CONFIG_TEMP_NRFS_TRIGGER_OWN_THREAD)
struct temp_nrfs_data *data = dev->data;
k_thread_create(&data->thread, data->thread_stack,
CONFIG_TEMP_NRFS_THREAD_STACK_SIZE,
temp_nrfs_thread,
data, NULL, NULL,
K_PRIO_COOP(CONFIG_TEMP_NRFS_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&data->thread, dev->name);
#endif
return 0;
}
static const struct sensor_driver_api temp_nrfs_drv_api = {
#ifdef CONFIG_TEMP_NRFS_TRIGGER
.attr_set = api_sensor_attr_set,
.trigger_set = api_sensor_trigger_set,
#endif
.sample_fetch = api_sample_fetch,
.channel_get = api_channel_get
};
static struct temp_nrfs_data temp_nrfs_drv_data = {
.mutex = Z_MUTEX_INITIALIZER(temp_nrfs_drv_data.mutex),
.measure_sem = Z_SEM_INITIALIZER(temp_nrfs_drv_data.measure_sem, 0, 1),
#ifdef CONFIG_TEMP_NRFS_TRIGGER
.dev = DEVICE_DT_INST_GET(0),
.sampling_freq = DEFAULT_SAMPLING_FREQ,
.up_threshold = DEFAULT_UP_THRESHOLD,
.low_threshold = DEFAULT_LOW_THRESHOLD,
#endif
#if defined(CONFIG_TEMP_NRFS_TRIGGER_OWN_THREAD)
.event_sem = Z_SEM_INITIALIZER(temp_nrfs_drv_data.event_sem, 0, 1),
#elif defined(CONFIG_TEMP_NRFS_TRIGGER_GLOBAL_THREAD)
.work = Z_WORK_INITIALIZER(temp_nrfs_work_handler),
#endif
};
DEVICE_DT_INST_DEFINE(0, temp_nrfs_init, NULL,
&temp_nrfs_drv_data, NULL,
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY,
&temp_nrfs_drv_api);
``` | /content/code_sandbox/drivers/sensor/nordic/temp/temp_nrfs.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,939 |
```c
/*
*/
#define DT_DRV_COMPAT nordic_npm1300_charger
#include <math.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/mfd/npm1300.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/linear_range.h>
#include <zephyr/drivers/sensor/npm1300_charger.h>
struct npm1300_charger_config {
const struct device *mfd;
int32_t term_microvolt;
int32_t term_warm_microvolt;
int32_t current_microamp;
int32_t dischg_limit_microamp;
int32_t vbus_limit_microamp;
int32_t temp_thresholds[4U];
int32_t dietemp_thresholds[2U];
uint32_t thermistor_ohms;
uint16_t thermistor_beta;
uint8_t thermistor_idx;
uint8_t trickle_sel;
uint8_t iterm_sel;
bool charging_enable;
bool vbatlow_charge_enable;
bool disable_recharge;
};
struct npm1300_charger_data {
uint16_t voltage;
uint16_t current;
uint16_t temp;
uint16_t dietemp;
uint8_t status;
uint8_t error;
uint8_t ibat_stat;
uint8_t vbus_stat;
};
/* nPM1300 base addresses */
#define CHGR_BASE 0x03U
#define ADC_BASE 0x05U
#define VBUS_BASE 0x02U
/* nPM1300 charger register offsets */
#define CHGR_OFFSET_ERR_CLR 0x00U
#define CHGR_OFFSET_EN_SET 0x04U
#define CHGR_OFFSET_EN_CLR 0x05U
#define CHGR_OFFSET_DIS_SET 0x06U
#define CHGR_OFFSET_ISET 0x08U
#define CHGR_OFFSET_ISET_DISCHG 0x0AU
#define CHGR_OFFSET_VTERM 0x0CU
#define CHGR_OFFSET_VTERM_R 0x0DU
#define CHGR_OFFSET_TRICKLE_SEL 0x0EU
#define CHGR_OFFSET_ITERM_SEL 0x0FU
#define CHGR_OFFSET_NTC_TEMPS 0x10U
#define CHGR_OFFSET_DIE_TEMPS 0x18U
#define CHGR_OFFSET_CHG_STAT 0x34U
#define CHGR_OFFSET_ERR_REASON 0x36U
#define CHGR_OFFSET_VBATLOW_EN 0x50U
/* nPM1300 ADC register offsets */
#define ADC_OFFSET_TASK_VBAT 0x00U
#define ADC_OFFSET_TASK_TEMP 0x01U
#define ADC_OFFSET_TASK_DIE 0x02U
#define ADC_OFFSET_CONFIG 0x09U
#define ADC_OFFSET_NTCR_SEL 0x0AU
#define ADC_OFFSET_TASK_AUTO 0x0CU
#define ADC_OFFSET_RESULTS 0x10U
#define ADC_OFFSET_IBAT_EN 0x24U
/* nPM1300 VBUS register offsets */
#define VBUS_OFFSET_ILIMUPDATE 0x00U
#define VBUS_OFFSET_ILIM 0x01U
#define VBUS_OFFSET_ILIMSTARTUP 0x02U
#define VBUS_OFFSET_DETECT 0x05U
#define VBUS_OFFSET_STATUS 0x07U
/* Ibat status */
#define IBAT_STAT_DISCHARGE 0x04U
#define IBAT_STAT_CHARGE_TRICKLE 0x0CU
#define IBAT_STAT_CHARGE_COOL 0x0DU
#define IBAT_STAT_CHARGE_NORMAL 0x0FU
struct adc_results_t {
uint8_t ibat_stat;
uint8_t msb_vbat;
uint8_t msb_ntc;
uint8_t msb_die;
uint8_t msb_vsys;
uint8_t lsb_a;
uint8_t reserved1;
uint8_t reserved2;
uint8_t msb_ibat;
uint8_t msb_vbus;
uint8_t lsb_b;
} __packed;
/* ADC result masks */
#define ADC_MSB_SHIFT 2U
#define ADC_LSB_MASK 0x03U
#define ADC_LSB_VBAT_SHIFT 0U
#define ADC_LSB_NTC_SHIFT 2U
#define ADC_LSB_DIE_SHIFT 4U
#define ADC_LSB_IBAT_SHIFT 4U
/* NTC temp masks */
#define NTCTEMP_MSB_SHIFT 2U
#define NTCTEMP_LSB_MASK 0x03U
/* dietemp masks */
#define DIETEMP_MSB_SHIFT 2U
#define DIETEMP_LSB_MASK 0x03U
/* VBUS masks */
#define DETECT_HI_MASK 0x0AU
#define DETECT_HI_CURRENT 1500000
#define DETECT_LO_CURRENT 500000
/* Dietemp calculation constants */
#define DIETEMP_OFFSET_MDEGC 394670
#define DIETEMP_FACTOR_MUL 3963000
#define DIETEMP_FACTOR_DIV 5000
/* Linear range for charger terminal voltage */
static const struct linear_range charger_volt_ranges[] = {
LINEAR_RANGE_INIT(3500000, 50000, 0U, 3U), LINEAR_RANGE_INIT(4000000, 50000, 4U, 13U)};
/* Linear range for charger current */
static const struct linear_range charger_current_range = LINEAR_RANGE_INIT(32000, 2000, 16U, 400U);
/* Linear range for Discharge limit */
static const struct linear_range discharge_limit_range = LINEAR_RANGE_INIT(268090, 3230, 83U, 415U);
/* Linear range for vbusin current limit */
static const struct linear_range vbus_current_ranges[] = {
LINEAR_RANGE_INIT(100000, 0, 1U, 1U), LINEAR_RANGE_INIT(500000, 100000, 5U, 15U)};
static void calc_temp(const struct npm1300_charger_config *const config, uint16_t code,
struct sensor_value *valp)
{
/* Ref: Datasheet Figure 42: Battery temperature (Kelvin) */
float log_result = log((1024.f / (float)code) - 1);
float inv_temp_k = (1.f / 298.15f) - (log_result / (float)config->thermistor_beta);
float temp = (1.f / inv_temp_k) - 273.15f;
valp->val1 = (int32_t)temp;
valp->val2 = (int32_t)(fmodf(temp, 1.f) * 1000000.f);
}
static void calc_dietemp(const struct npm1300_charger_config *const config, uint16_t code,
struct sensor_value *valp)
{
/* Ref: Datasheet Figure 36: Die temperature (Celcius) */
int32_t temp =
DIETEMP_OFFSET_MDEGC - (((int32_t)code * DIETEMP_FACTOR_MUL) / DIETEMP_FACTOR_DIV);
valp->val1 = temp / 1000;
valp->val2 = (temp % 1000) * 1000;
}
static uint32_t calc_ntc_res(const struct npm1300_charger_config *const config, int32_t temp_mdegc)
{
float inv_t0 = 1.f / 298.15f;
float temp = (float)temp_mdegc / 1000.f;
float inv_temp_k = 1.f / (temp + 273.15f);
return config->thermistor_ohms *
exp((float)config->thermistor_beta * (inv_temp_k - inv_t0));
}
static uint16_t adc_get_res(uint8_t msb, uint8_t lsb, uint16_t lsb_shift)
{
return ((uint16_t)msb << ADC_MSB_SHIFT) | ((lsb >> lsb_shift) & ADC_LSB_MASK);
}
static void calc_current(const struct npm1300_charger_config *const config,
struct npm1300_charger_data *const data, struct sensor_value *valp)
{
int32_t full_scale_ma;
int32_t current;
switch (data->ibat_stat) {
case IBAT_STAT_DISCHARGE:
full_scale_ma = config->dischg_limit_microamp / 1000;
break;
case IBAT_STAT_CHARGE_TRICKLE:
/* Fallthrough */
case IBAT_STAT_CHARGE_COOL:
/* Fallthrough */
case IBAT_STAT_CHARGE_NORMAL:
full_scale_ma = -config->current_microamp / 800;
break;
default:
full_scale_ma = 0;
break;
}
current = (data->current * full_scale_ma) / 1024;
valp->val1 = current / 1000;
valp->val2 = (current % 1000) * 1000;
}
int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *valp)
{
const struct npm1300_charger_config *const config = dev->config;
struct npm1300_charger_data *const data = dev->data;
int32_t tmp;
switch ((uint32_t)chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
tmp = data->voltage * 5000 / 1024;
valp->val1 = tmp / 1000;
valp->val2 = (tmp % 1000) * 1000;
break;
case SENSOR_CHAN_GAUGE_TEMP:
calc_temp(config, data->temp, valp);
break;
case SENSOR_CHAN_GAUGE_AVG_CURRENT:
calc_current(config, data, valp);
break;
case SENSOR_CHAN_NPM1300_CHARGER_STATUS:
valp->val1 = data->status;
valp->val2 = 0;
break;
case SENSOR_CHAN_NPM1300_CHARGER_ERROR:
valp->val1 = data->error;
valp->val2 = 0;
break;
case SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT:
valp->val1 = config->current_microamp / 1000000;
valp->val2 = config->current_microamp % 1000000;
break;
case SENSOR_CHAN_GAUGE_MAX_LOAD_CURRENT:
valp->val1 = config->dischg_limit_microamp / 1000000;
valp->val2 = config->dischg_limit_microamp % 1000000;
break;
case SENSOR_CHAN_DIE_TEMP:
calc_dietemp(config, data->dietemp, valp);
break;
default:
return -ENOTSUP;
}
return 0;
}
int npm1300_charger_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct npm1300_charger_config *const config = dev->config;
struct npm1300_charger_data *data = dev->data;
struct adc_results_t results;
int ret;
/* Read charge status and error reason */
ret = mfd_npm1300_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_CHG_STAT, &data->status);
if (ret != 0) {
return ret;
}
ret = mfd_npm1300_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_ERR_REASON, &data->error);
if (ret != 0) {
return ret;
}
/* Read adc results */
ret = mfd_npm1300_reg_read_burst(config->mfd, ADC_BASE, ADC_OFFSET_RESULTS, &results,
sizeof(results));
if (ret != 0) {
return ret;
}
data->voltage = adc_get_res(results.msb_vbat, results.lsb_a, ADC_LSB_VBAT_SHIFT);
data->temp = adc_get_res(results.msb_ntc, results.lsb_a, ADC_LSB_NTC_SHIFT);
data->dietemp = adc_get_res(results.msb_die, results.lsb_a, ADC_LSB_DIE_SHIFT);
data->current = adc_get_res(results.msb_ibat, results.lsb_b, ADC_LSB_IBAT_SHIFT);
data->ibat_stat = results.ibat_stat;
/* Trigger ntc and die temperature measurements */
ret = mfd_npm1300_reg_write2(config->mfd, ADC_BASE, ADC_OFFSET_TASK_TEMP, 1U, 1U);
if (ret != 0) {
return ret;
}
/* Trigger current and voltage measurement */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_VBAT, 1U);
if (ret != 0) {
return ret;
}
/* Read vbus status */
ret = mfd_npm1300_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_STATUS, &data->vbus_stat);
if (ret != 0) {
return ret;
}
return ret;
}
static int set_ntc_thresholds(const struct npm1300_charger_config *const config)
{
for (uint8_t idx = 0U; idx < 4U; idx++) {
if (config->temp_thresholds[idx] < INT32_MAX) {
uint32_t res = calc_ntc_res(config, config->temp_thresholds[idx]);
/* Ref: Datasheet Figure 14: Equation for battery temperature */
uint16_t code = (1024 * res) / (res + config->thermistor_ohms);
int ret = mfd_npm1300_reg_write2(
config->mfd, CHGR_BASE, CHGR_OFFSET_NTC_TEMPS + (idx * 2U),
code >> NTCTEMP_MSB_SHIFT, code & NTCTEMP_LSB_MASK);
if (ret != 0) {
return ret;
}
}
}
return 0;
}
static int set_dietemp_thresholds(const struct npm1300_charger_config *const config)
{
for (uint8_t idx = 0U; idx < 2U; idx++) {
if (config->dietemp_thresholds[idx] < INT32_MAX) {
/* Ref: Datasheet section 6.2.6: Charger thermal regulation */
int32_t numerator =
(DIETEMP_OFFSET_MDEGC - config->dietemp_thresholds[idx]) *
DIETEMP_FACTOR_DIV;
uint16_t code = DIV_ROUND_CLOSEST(numerator, DIETEMP_FACTOR_MUL);
int ret = mfd_npm1300_reg_write2(
config->mfd, CHGR_BASE, CHGR_OFFSET_DIE_TEMPS + (idx * 2U),
code >> DIETEMP_MSB_SHIFT, code & DIETEMP_LSB_MASK);
if (ret != 0) {
return ret;
}
}
}
return 0;
}
static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct npm1300_charger_config *const config = dev->config;
uint8_t data;
int ret;
switch ((uint32_t)chan) {
case SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT:
if (attr != SENSOR_ATTR_CONFIGURATION) {
return -ENOTSUP;
}
ret = mfd_npm1300_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, &data);
if (ret == 0) {
val->val1 = data;
val->val2 = 0U;
}
return ret;
case SENSOR_CHAN_CURRENT:
if (attr != SENSOR_ATTR_UPPER_THRESH) {
return -ENOTSUP;
}
ret = mfd_npm1300_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_DETECT, &data);
if (ret < 0) {
return ret;
}
if (data == 0U) {
/* No charger connected */
val->val1 = 0;
val->val2 = 0;
} else if ((data & DETECT_HI_MASK) != 0U) {
/* CC1 or CC2 indicate 1.5A or 3A capability */
val->val1 = DETECT_HI_CURRENT / 1000000;
val->val2 = DETECT_HI_CURRENT % 1000000;
} else {
val->val1 = DETECT_LO_CURRENT / 1000000;
val->val2 = DETECT_LO_CURRENT % 1000000;
}
return 0;
default:
return -ENOTSUP;
}
}
static int npm1300_charger_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct npm1300_charger_config *const config = dev->config;
int ret;
if (attr != SENSOR_ATTR_CONFIGURATION) {
return -ENOTSUP;
}
switch ((uint32_t)chan) {
case SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT:
if (val->val1 == 0) {
/* Disable charging */
return mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_CLR,
1U);
}
/* Clear any errors and enable charging */
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_ERR_CLR, 1U);
if (ret != 0) {
return ret;
}
return mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, 1U);
case SENSOR_CHAN_CURRENT:
/* Set vbus current limit */
int32_t current = (val->val1 * 1000000) + val->val2;
uint16_t idx;
ret = linear_range_group_get_win_index(vbus_current_ranges,
ARRAY_SIZE(vbus_current_ranges), current,
current, &idx);
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIM, idx);
if (ret != 0) {
return ret;
}
/* Switch to new current limit, this will be reset automatically on USB removal */
return mfd_npm1300_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIMUPDATE, 1U);
default:
return -ENOTSUP;
}
}
int npm1300_charger_init(const struct device *dev)
{
const struct npm1300_charger_config *const config = dev->config;
uint16_t idx;
int ret;
if (!device_is_ready(config->mfd)) {
return -ENODEV;
}
/* Configure temperature thresholds */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_NTCR_SEL,
config->thermistor_idx + 1U);
if (ret != 0) {
return ret;
}
ret = set_ntc_thresholds(config);
if (ret != 0) {
return ret;
}
ret = set_dietemp_thresholds(config);
if (ret != 0) {
return ret;
}
/* Configure termination voltages */
ret = linear_range_group_get_win_index(charger_volt_ranges, ARRAY_SIZE(charger_volt_ranges),
config->term_microvolt, config->term_microvolt,
&idx);
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VTERM, idx);
if (ret != 0) {
return ret;
}
ret = linear_range_group_get_win_index(charger_volt_ranges, ARRAY_SIZE(charger_volt_ranges),
config->term_warm_microvolt,
config->term_warm_microvolt, &idx);
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VTERM_R, idx);
if (ret != 0) {
return ret;
}
/* Set current, allow rounding down to closest value */
ret = linear_range_get_win_index(&charger_current_range,
config->current_microamp - charger_current_range.step,
config->current_microamp, &idx);
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write2(config->mfd, CHGR_BASE, CHGR_OFFSET_ISET, idx / 2U, idx & 1U);
if (ret != 0) {
return ret;
}
/* Set discharge limit, allow rounding down to closest value */
ret = linear_range_get_win_index(&discharge_limit_range,
config->dischg_limit_microamp - discharge_limit_range.step,
config->dischg_limit_microamp, &idx);
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write2(config->mfd, CHGR_BASE, CHGR_OFFSET_ISET_DISCHG, idx / 2U,
idx & 1U);
if (ret != 0) {
return ret;
}
/* Configure vbus current limit */
ret = linear_range_group_get_win_index(vbus_current_ranges, ARRAY_SIZE(vbus_current_ranges),
config->vbus_limit_microamp,
config->vbus_limit_microamp, &idx);
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIMSTARTUP, idx);
if (ret != 0) {
return ret;
}
/* Configure trickle voltage threshold */
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_TRICKLE_SEL,
config->trickle_sel);
if (ret != 0) {
return ret;
}
/* Configure termination current */
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_ITERM_SEL,
config->iterm_sel);
if (ret != 0) {
return ret;
}
/* Enable current measurement */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_IBAT_EN, 1U);
if (ret != 0) {
return ret;
}
/* Trigger current and voltage measurement */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_VBAT, 1U);
if (ret != 0) {
return ret;
}
/* Trigger ntc and die temperature measurements */
ret = mfd_npm1300_reg_write2(config->mfd, ADC_BASE, ADC_OFFSET_TASK_TEMP, 1U, 1U);
if (ret != 0) {
return ret;
}
/* Enable automatic temperature measurements during charging */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_AUTO, 1U);
if (ret != 0) {
return ret;
}
/* Enable charging at low battery if configured */
if (config->vbatlow_charge_enable) {
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VBATLOW_EN, 1U);
if (ret != 0) {
return ret;
}
}
/* Disable automatic recharging if configured */
if (config->disable_recharge) {
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_DIS_SET, 1U);
if (ret != 0) {
return ret;
}
}
/* Enable charging if configured */
if (config->charging_enable) {
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, 1U);
if (ret != 0) {
return ret;
}
}
return 0;
}
static const struct sensor_driver_api npm1300_charger_battery_driver_api = {
.sample_fetch = npm1300_charger_sample_fetch,
.channel_get = npm1300_charger_channel_get,
.attr_set = npm1300_charger_attr_set,
.attr_get = npm1300_charger_attr_get,
};
#define NPM1300_CHARGER_INIT(n) \
static struct npm1300_charger_data npm1300_charger_data_##n; \
\
static const struct npm1300_charger_config npm1300_charger_config_##n = { \
.mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \
.term_microvolt = DT_INST_PROP(n, term_microvolt), \
.term_warm_microvolt = \
DT_INST_PROP_OR(n, term_warm_microvolt, DT_INST_PROP(n, term_microvolt)), \
.current_microamp = DT_INST_PROP(n, current_microamp), \
.dischg_limit_microamp = DT_INST_PROP(n, dischg_limit_microamp), \
.vbus_limit_microamp = DT_INST_PROP(n, vbus_limit_microamp), \
.thermistor_ohms = DT_INST_PROP(n, thermistor_ohms), \
.thermistor_idx = DT_INST_ENUM_IDX(n, thermistor_ohms), \
.thermistor_beta = DT_INST_PROP(n, thermistor_beta), \
.charging_enable = DT_INST_PROP(n, charging_enable), \
.trickle_sel = DT_INST_ENUM_IDX(n, trickle_microvolt), \
.iterm_sel = DT_INST_ENUM_IDX(n, term_current_percent), \
.vbatlow_charge_enable = DT_INST_PROP(n, vbatlow_charge_enable), \
.disable_recharge = DT_INST_PROP(n, disable_recharge), \
.dietemp_thresholds = {DT_INST_PROP_OR(n, dietemp_stop_millidegrees, INT32_MAX), \
DT_INST_PROP_OR(n, dietemp_resume_millidegrees, \
INT32_MAX)}, \
.temp_thresholds = {DT_INST_PROP_OR(n, thermistor_cold_millidegrees, INT32_MAX), \
DT_INST_PROP_OR(n, thermistor_cool_millidegrees, INT32_MAX), \
DT_INST_PROP_OR(n, thermistor_warm_millidegrees, INT32_MAX), \
DT_INST_PROP_OR(n, thermistor_hot_millidegrees, INT32_MAX)}}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, &npm1300_charger_init, NULL, &npm1300_charger_data_##n, \
&npm1300_charger_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&npm1300_charger_battery_driver_api);
DT_INST_FOREACH_STATUS_OKAY(NPM1300_CHARGER_INIT)
``` | /content/code_sandbox/drivers/sensor/nordic/npm1300_charger/npm1300_charger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,850 |
```c
/*
*
*/
#define DT_DRV_COMPAT nordic_nrf_temp
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/clock_control.h>
#include <zephyr/drivers/clock_control/nrf_clock_control.h>
#include <zephyr/logging/log.h>
#include <hal/nrf_temp.h>
#include <zephyr/irq.h>
LOG_MODULE_REGISTER(temp_nrf5, CONFIG_SENSOR_LOG_LEVEL);
/* The nRF5 temperature device returns measurements in 0.25C
* increments. Scale to mDegrees C.
*/
#define TEMP_NRF5_TEMP_SCALE (1000000 / 4)
struct temp_nrf5_data {
struct k_sem device_sync_sem;
struct k_mutex mutex;
int32_t sample;
struct onoff_manager *clk_mgr;
};
static void hfclk_on_callback(struct onoff_manager *mgr,
struct onoff_client *cli,
uint32_t state,
int res)
{
nrf_temp_task_trigger(NRF_TEMP, NRF_TEMP_TASK_START);
}
static int temp_nrf5_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct temp_nrf5_data *data = dev->data;
struct onoff_client cli;
int r;
/* Error if before sensor initialized */
if (data->clk_mgr == NULL) {
return -EAGAIN;
}
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
sys_notify_init_callback(&cli.notify, hfclk_on_callback);
r = onoff_request(data->clk_mgr, &cli);
__ASSERT_NO_MSG(r >= 0);
k_sem_take(&data->device_sync_sem, K_FOREVER);
r = onoff_release(data->clk_mgr);
__ASSERT_NO_MSG(r >= 0);
data->sample = nrf_temp_result_get(NRF_TEMP);
LOG_DBG("sample: %d", data->sample);
nrf_temp_task_trigger(NRF_TEMP, NRF_TEMP_TASK_STOP);
k_mutex_unlock(&data->mutex);
return 0;
}
static int temp_nrf5_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct temp_nrf5_data *data = dev->data;
int32_t uval;
if (chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
uval = data->sample * TEMP_NRF5_TEMP_SCALE;
val->val1 = uval / 1000000;
val->val2 = uval % 1000000;
LOG_DBG("Temperature:%d,%d", val->val1, val->val2);
return 0;
}
static void temp_nrf5_isr(const void *arg)
{
const struct device *dev = (const struct device *)arg;
struct temp_nrf5_data *data = dev->data;
nrf_temp_event_clear(NRF_TEMP, NRF_TEMP_EVENT_DATARDY);
k_sem_give(&data->device_sync_sem);
}
static const struct sensor_driver_api temp_nrf5_driver_api = {
.sample_fetch = temp_nrf5_sample_fetch,
.channel_get = temp_nrf5_channel_get,
};
static int temp_nrf5_init(const struct device *dev)
{
struct temp_nrf5_data *data = dev->data;
/* A null clk_mgr indicates sensor has not been initialized */
data->clk_mgr =
z_nrf_clock_control_get_onoff(CLOCK_CONTROL_NRF_SUBSYS_HF);
__ASSERT_NO_MSG(data->clk_mgr);
k_sem_init(&data->device_sync_sem, 0, K_SEM_MAX_LIMIT);
k_mutex_init(&data->mutex);
IRQ_CONNECT(
DT_INST_IRQN(0),
DT_INST_IRQ(0, priority),
temp_nrf5_isr,
DEVICE_DT_INST_GET(0),
0);
irq_enable(DT_INST_IRQN(0));
nrf_temp_int_enable(NRF_TEMP, NRF_TEMP_INT_DATARDY_MASK);
return 0;
}
#define NRF_TEMP_DEFINE(inst) \
static struct temp_nrf5_data temp_nrf5_data_##inst; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, temp_nrf5_init, NULL, \
&temp_nrf5_data_##inst, NULL, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &temp_nrf5_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(NRF_TEMP_DEFINE)
``` | /content/code_sandbox/drivers/sensor/nordic/temp/temp_nrf5.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 955 |
```unknown
# nRF temperature sensor configuration options
config TEMP_NRF5_FORCE_ALT
bool
depends on SOC_COMPATIBLE_NRF
help
This option can be enabled to force an alternative implementation
of the temperature sensor driver.
config TEMP_NRF5
bool "nRF5 Temperature Sensor"
default y
depends on DT_HAS_NORDIC_NRF_TEMP_ENABLED
depends on MULTITHREADING || TEMP_NRF5_FORCE_ALT
help
Enable driver for nRF5 temperature sensor.
config TEMP_NRFS
bool "nRF Temperature Sensor accessed via nrfs"
default y
depends on DT_HAS_NORDIC_NRF_TEMP_NRFS_ENABLED
depends on NRFS
help
Enable driver for nRF temperature sensor accessed through the nRF
Services (nrfs) layer.
if TEMP_NRFS
module = TEMP_NRFS
thread_priority = 10
thread_stack_size = 1024
source "drivers/sensor/Kconfig.trigger_template"
endif # TEMP_NRFS
``` | /content/code_sandbox/drivers/sensor/nordic/temp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 210 |
```unknown
# Atmel SAM MCU family Quadrature Decoder (TC) driver configuration options
#
#
config QDEC_SAM
bool "Atmel SAM QDEC driver"
default y
depends on DT_HAS_ATMEL_SAM_TC_QDEC_ENABLED
depends on SOC_FAMILY_ATMEL_SAM
help
Atmel SAM MCU family Quadrature Decoder (TC) driver.
``` | /content/code_sandbox/drivers/sensor/qdec_sam/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 79 |
```c
/*
*
*/
#define DT_DRV_COMPAT atmel_sam_tc_qdec
/** @file
* @brief Atmel SAM MCU family Quadrature Decoder (QDEC/TC) driver.
*/
#include <errno.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <soc.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/clock_control/atmel_sam_pmc.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(qdec_sam, CONFIG_SENSOR_LOG_LEVEL);
/* Device constant configuration parameters */
struct qdec_sam_dev_cfg {
Tc *regs;
const struct atmel_sam_pmc_config clock_cfg[TCCHANNEL_NUMBER];
const struct pinctrl_dev_config *pcfg;
};
/* Device run time data */
struct qdec_sam_dev_data {
uint16_t position;
};
static int qdec_sam_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct qdec_sam_dev_cfg *const dev_cfg = dev->config;
struct qdec_sam_dev_data *const dev_data = dev->data;
Tc *const tc = dev_cfg->regs;
TcChannel *tc_ch0 = &tc->TcChannel[0];
/* Read position register content */
dev_data->position = tc_ch0->TC_CV;
return 0;
}
static int qdec_sam_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct qdec_sam_dev_data *const dev_data = dev->data;
if (chan == SENSOR_CHAN_ROTATION) {
val->val1 = dev_data->position;
val->val2 = 0;
} else {
return -ENOTSUP;
}
return 0;
}
static void qdec_sam_start(Tc *const tc)
{
TcChannel *tc_ch0 = &tc->TcChannel[0];
/* Enable Channel 0 Clock and reset counter*/
tc_ch0->TC_CCR = TC_CCR_CLKEN
| TC_CCR_SWTRG;
}
static void qdec_sam_configure(const struct device *dev)
{
const struct qdec_sam_dev_cfg *const dev_cfg = dev->config;
Tc *const tc = dev_cfg->regs;
TcChannel *tc_ch0 = &tc->TcChannel[0];
/* Clock, Trigger Edge, Trigger and Mode Selection */
tc_ch0->TC_CMR = TC_CMR_TCCLKS_XC0
| TC_CMR_ETRGEDG_NONE
| TC_CMR_ABETRG;
/* Enable QDEC in Position Mode*/
tc->TC_BMR = TC_BMR_QDEN
| TC_BMR_POSEN
| TC_BMR_EDGPHA
| TC_BMR_MAXFILT(1);
qdec_sam_start(tc);
}
static int qdec_sam_initialize(const struct device *dev)
{
__ASSERT_NO_MSG(dev != NULL);
const struct qdec_sam_dev_cfg *const dev_cfg = dev->config;
int retval;
/* Connect pins to the peripheral */
retval = pinctrl_apply_state(dev_cfg->pcfg, PINCTRL_STATE_DEFAULT);
if (retval < 0) {
return retval;
}
for (int i = 0; i < ARRAY_SIZE(dev_cfg->clock_cfg); i++) {
/* Enable TC clock in PMC */
(void)clock_control_on(SAM_DT_PMC_CONTROLLER,
(clock_control_subsys_t)&dev_cfg->clock_cfg[i]);
}
qdec_sam_configure(dev);
LOG_INF("Device %s initialized", dev->name);
return 0;
}
static const struct sensor_driver_api qdec_sam_driver_api = {
.sample_fetch = qdec_sam_fetch,
.channel_get = qdec_sam_get,
};
#define QDEC_SAM_INIT(n) \
PINCTRL_DT_INST_DEFINE(n); \
static const struct qdec_sam_dev_cfg qdec##n##_sam_config = { \
.regs = (Tc *)DT_REG_ADDR(DT_INST_PARENT(n)), \
.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \
.clock_cfg = SAM_DT_CLOCKS_PMC_CFG(DT_INST_PARENT(n)), \
}; \
\
static struct qdec_sam_dev_data qdec##n##_sam_data; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, qdec_sam_initialize, NULL, \
&qdec##n##_sam_data, &qdec##n##_sam_config, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&qdec_sam_driver_api);
DT_INST_FOREACH_STATUS_OKAY(QDEC_SAM_INIT)
``` | /content/code_sandbox/drivers/sensor/qdec_sam/qdec_sam.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,048 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_MHZ19B_MHZ19B
#define ZEPHYR_DRIVERS_SENSOR_MHZ19B_MHZ19B
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/uart.h>
#define MHZ19B_BUF_LEN 9
#define MHZ19B_TX_CMD_IDX 2
#define MHZ19B_RX_CMD_IDX 1
#define MHZ19B_CHECKSUM_IDX 8
/* Arbitrary max duration to wait for the response */
#define MHZ19B_WAIT K_SECONDS(1)
enum mhz19b_cmd_idx {
/* Command to poll for CO2 */
MHZ19B_CMD_IDX_GET_CO2,
/* Read range */
MHZ19B_CMD_IDX_GET_RANGE,
/* Get ABC status */
MHZ19B_CMD_IDX_GET_ABC,
/* Enable ABC */
MHZ19B_CMD_IDX_SET_ABC_ON,
/* Disable ABC */
MHZ19B_CMD_IDX_SET_ABC_OFF,
/* Set detection range to 2000 ppm */
MHZ19B_CMD_IDX_SET_RANGE_2000,
/* Set detection range to 5000 ppm */
MHZ19B_CMD_IDX_SET_RANGE_5000,
/* Set detection range to 10000 ppm */
MHZ19B_CMD_IDX_SET_RANGE_10000,
/* Number of supported commands */
MHZ19B_CMD_IDX_MAX,
};
struct mhz19b_data {
/* Max data length is 16 bits */
uint16_t data;
/* Command buf length is 9 */
uint8_t xfer_bytes;
bool has_rsp;
uint8_t rd_data[MHZ19B_BUF_LEN];
struct k_sem tx_sem;
struct k_sem rx_sem;
enum mhz19b_cmd_idx cmd_idx;
};
struct mhz19b_cfg {
const struct device *uart_dev;
uint16_t range;
bool abc_on;
uart_irq_callback_user_data_t cb;
};
#define MHZ19B_HEADER 0xff
#define MHZ19B_RESERVED 0x01
#define MHZ19B_NULL 0x00
#define MHZ19B_NULL_1 MHZ19B_NULL
#define MHZ19B_NULL_2 MHZ19B_NULL, MHZ19B_NULL_1
#define MHZ19B_NULL_3 MHZ19B_NULL, MHZ19B_NULL_2
#define MHZ19B_NULL_4 MHZ19B_NULL, MHZ19B_NULL_3
#define MHZ19B_NULL_5 MHZ19B_NULL, MHZ19B_NULL_4
#define MHZ19B_NULL_COUNT(c) MHZ19B_NULL_##c
#define MHZ19B_ABC_ON 0xA0
#define MHZ19B_ABC_OFF 0x00
#define MHZ19B_RANGE_2000 0x07, 0xD0
#define MHZ19B_RANGE_5000 0x13, 0x88
#define MHZ19B_RANGE_10000 0x27, 0x10
enum mhz19b_cmd {
MHZ19B_CMD_SET_ABC = 0x79,
MHZ19B_CMD_GET_ABC = 0x7D,
MHZ19B_CMD_GET_CO2 = 0x86,
MHZ19B_CMD_SET_RANGE = 0x99,
MHZ19B_CMD_GET_RANGE = 0x9B,
};
#endif /* ZEPHYR_DRIVERS_SENSOR_MHZ19B_MHZ19B */
``` | /content/code_sandbox/drivers/sensor/mhz19b/mhz19b.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 735 |
```unknown
config MHZ19B
bool "Winsen CO2 sensor"
default y
depends on DT_HAS_WINSEN_MHZ19B_ENABLED
depends on UART_INTERRUPT_DRIVEN
help
Enable driver for the MHZ19B CO2 Sensor.
``` | /content/code_sandbox/drivers/sensor/mhz19b/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 55 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/bosch/bma280/Kconfig"
source "drivers/sensor/bosch/bma4xx/Kconfig"
source "drivers/sensor/bosch/bmc150_magn/Kconfig"
source "drivers/sensor/bosch/bme280/Kconfig"
source "drivers/sensor/bosch/bme680/Kconfig"
source "drivers/sensor/bosch/bmg160/Kconfig"
source "drivers/sensor/bosch/bmi08x/Kconfig"
source "drivers/sensor/bosch/bmi160/Kconfig"
source "drivers/sensor/bosch/bmi270/Kconfig"
source "drivers/sensor/bosch/bmi323/Kconfig"
source "drivers/sensor/bosch/bmm150/Kconfig"
source "drivers/sensor/bosch/bmp388/Kconfig"
source "drivers/sensor/bosch/bmp581/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/bosch/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 208 |
```c
/* Bosch BMG160 gyro driver, trigger implementation
*
*
*
* Datasheet:
* path_to_url
*/
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "bmg160.h"
extern struct bmg160_device_data bmg160_data;
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(BMG160, CONFIG_SENSOR_LOG_LEVEL);
static inline int setup_int(const struct device *dev,
bool enable)
{
const struct bmg160_device_config *cfg = dev->config;
return gpio_pin_interrupt_configure_dt(&cfg->int_gpio,
enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE);
}
static void bmg160_gpio_callback(const struct device *port,
struct gpio_callback *cb,
uint32_t pin)
{
struct bmg160_device_data *bmg160 =
CONTAINER_OF(cb, struct bmg160_device_data, gpio_cb);
ARG_UNUSED(port);
ARG_UNUSED(pin);
#if defined(CONFIG_BMG160_TRIGGER_OWN_THREAD)
k_sem_give(&bmg160->trig_sem);
#elif defined(CONFIG_BMG160_TRIGGER_GLOBAL_THREAD)
k_work_submit(&bmg160->work);
#endif
}
static int bmg160_anymotion_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct bmg160_device_data *bmg160 = dev->data;
uint8_t anymotion_en = 0U;
if (handler) {
anymotion_en = BMG160_ANY_EN_X |
BMG160_ANY_EN_Y |
BMG160_ANY_EN_Z;
}
if (bmg160_update_byte(dev, BMG160_REG_ANY_EN,
BMG160_ANY_EN_MASK, anymotion_en) < 0) {
return -EIO;
}
bmg160->anymotion_handler = handler;
bmg160->anymotion_trig = trig;
return 0;
}
static int bmg160_drdy_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct bmg160_device_data *bmg160 = dev->data;
if (bmg160_update_byte(dev, BMG160_REG_INT_EN0,
BMG160_DATA_EN,
handler ? BMG160_DATA_EN : 0) < 0) {
return -EIO;
}
bmg160->drdy_handler = handler;
bmg160->drdy_trig = trig;
return 0;
}
int bmg160_slope_config(const struct device *dev, enum sensor_attribute attr,
const struct sensor_value *val)
{
struct bmg160_device_data *bmg160 = dev->data;
if (attr == SENSOR_ATTR_SLOPE_TH) {
uint16_t any_th_dps, range_dps;
uint8_t any_th_reg_val;
any_th_dps = sensor_rad_to_degrees(val);
range_dps = BMG160_SCALE_TO_RANGE(bmg160->scale);
any_th_reg_val = any_th_dps * 2000U / range_dps;
/* the maximum slope depends on selected range */
if (any_th_dps > range_dps / 16U) {
return -ENOTSUP;
}
return bmg160_write_byte(dev, BMG160_REG_THRES,
any_th_dps & BMG160_THRES_MASK);
} else if (attr == SENSOR_ATTR_SLOPE_DUR) {
/* slope duration can be 4, 8, 12 or 16 samples */
if (val->val1 != 4 && val->val1 != 8 &&
val->val1 != 12 && val->val1 != 16) {
return -ENOTSUP;
}
return bmg160_write_byte(dev, BMG160_REG_ANY_EN,
(val->val1 << BMG160_ANY_DURSAMPLE_POS) &
BMG160_ANY_DURSAMPLE_MASK);
}
return -ENOTSUP;
}
int bmg160_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct bmg160_device_config *config = dev->config;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (trig->type == SENSOR_TRIG_DELTA) {
return bmg160_anymotion_set(dev, trig, handler);
} else if (trig->type == SENSOR_TRIG_DATA_READY) {
return bmg160_drdy_set(dev, trig, handler);
}
return -ENOTSUP;
}
static int bmg160_handle_anymotion_int(const struct device *dev)
{
struct bmg160_device_data *bmg160 = dev->data;
if (bmg160->anymotion_handler) {
bmg160->anymotion_handler(dev, bmg160->anymotion_trig);
}
return 0;
}
static int bmg160_handle_dataready_int(const struct device *dev)
{
struct bmg160_device_data *bmg160 = dev->data;
if (bmg160->drdy_handler) {
bmg160->drdy_handler(dev, bmg160->drdy_trig);
}
return 0;
}
static void bmg160_handle_int(const struct device *dev)
{
uint8_t status_int[4];
if (bmg160_read(dev, BMG160_REG_INT_STATUS0, status_int, 4) < 0) {
return;
}
if (status_int[0] & BMG160_ANY_INT) {
bmg160_handle_anymotion_int(dev);
} else {
bmg160_handle_dataready_int(dev);
}
}
#ifdef CONFIG_BMG160_TRIGGER_OWN_THREAD
static K_KERNEL_STACK_DEFINE(bmg160_thread_stack, CONFIG_BMG160_THREAD_STACK_SIZE);
static struct k_thread bmg160_thread;
static void bmg160_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct bmg160_device_data *bmg160 = p1;
while (true) {
k_sem_take(&bmg160->trig_sem, K_FOREVER);
bmg160_handle_int(bmg160->dev);
}
}
#endif
#ifdef CONFIG_BMG160_TRIGGER_GLOBAL_THREAD
static void bmg160_work_cb(struct k_work *work)
{
struct bmg160_device_data *bmg160 =
CONTAINER_OF(work, struct bmg160_device_data, work);
bmg160_handle_int(bmg160->dev);
}
#endif
int bmg160_trigger_init(const struct device *dev)
{
const struct bmg160_device_config *cfg = dev->config;
struct bmg160_device_data *bmg160 = dev->data;
int ret;
/* set INT1 pin to: push-pull, active low */
if (bmg160_write_byte(dev, BMG160_REG_INT_EN1, 0) < 0) {
LOG_DBG("Failed to select interrupt pins type.");
return -EIO;
}
/* set interrupt mode to non-latched */
if (bmg160_write_byte(dev, BMG160_REG_INT_RST_LATCH, 0) < 0) {
LOG_DBG("Failed to set the interrupt mode.");
return -EIO;
}
/* map anymotion and high rate interrupts to INT1 pin */
if (bmg160_write_byte(dev, BMG160_REG_INT_MAP0,
BMG160_INT1_ANY | BMG160_INT1_HIGH) < 0) {
LOG_DBG("Unable to map interrupts.");
return -EIO;
}
/* map data ready, FIFO and FastOffset interrupts to INT1 pin */
if (bmg160_write_byte(dev, BMG160_REG_INT_MAP1,
BMG160_INT1_DATA | BMG160_INT1_FIFO |
BMG160_INT1_FAST_OFFSET) < 0) {
LOG_DBG("Unable to map interrupts.");
return -EIO;
}
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
bmg160->dev = dev;
#if defined(CONFIG_BMG160_TRIGGER_OWN_THREAD)
k_sem_init(&bmg160->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&bmg160_thread, bmg160_thread_stack,
CONFIG_BMG160_THREAD_STACK_SIZE,
bmg160_thread_main,
bmg160, NULL, NULL,
K_PRIO_COOP(CONFIG_BMG160_THREAD_PRIORITY), 0,
K_NO_WAIT);
#elif defined(CONFIG_BMG160_TRIGGER_GLOBAL_THREAD)
bmg160->work.handler = bmg160_work_cb;
#endif
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
gpio_init_callback(&bmg160->gpio_cb, bmg160_gpio_callback,
BIT(cfg->int_gpio.pin));
ret = gpio_add_callback(cfg->int_gpio.port, &bmg160->gpio_cb);
if (ret < 0) {
return ret;
}
return setup_int(dev, true);
}
``` | /content/code_sandbox/drivers/sensor/bosch/bmg160/bmg160_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,985 |
```c
/*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT winsen_mhz19b
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/mhz19b.h>
#include "mhz19b.h"
LOG_MODULE_REGISTER(mhz19b, CONFIG_SENSOR_LOG_LEVEL);
/* Table of supported MH-Z19B commands with precomputed checksum */
static const uint8_t mhz19b_cmds[MHZ19B_CMD_IDX_MAX][MHZ19B_BUF_LEN] = {
[MHZ19B_CMD_IDX_GET_CO2] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_GET_CO2, MHZ19B_NULL_COUNT(5), 0x79
},
[MHZ19B_CMD_IDX_GET_RANGE] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_GET_RANGE, MHZ19B_NULL_COUNT(5), 0x64
},
[MHZ19B_CMD_IDX_GET_ABC] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_GET_ABC, MHZ19B_NULL_COUNT(5), 0x82
},
[MHZ19B_CMD_IDX_SET_ABC_ON] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_SET_ABC, MHZ19B_ABC_ON,
MHZ19B_NULL_COUNT(4), 0xE6
},
[MHZ19B_CMD_IDX_SET_ABC_OFF] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_SET_ABC, MHZ19B_ABC_OFF,
MHZ19B_NULL_COUNT(4), 0x86
},
[MHZ19B_CMD_IDX_SET_RANGE_2000] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_SET_RANGE, MHZ19B_NULL_COUNT(3),
MHZ19B_RANGE_2000, 0x8F
},
[MHZ19B_CMD_IDX_SET_RANGE_5000] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_SET_RANGE, MHZ19B_NULL_COUNT(3),
MHZ19B_RANGE_5000, 0xCB
},
[MHZ19B_CMD_IDX_SET_RANGE_10000] = {
MHZ19B_HEADER, MHZ19B_RESERVED, MHZ19B_CMD_SET_RANGE, MHZ19B_NULL_COUNT(3),
MHZ19B_RANGE_10000, 0x2F
},
};
static void mhz19b_uart_flush(const struct device *uart_dev)
{
uint8_t c;
while (uart_fifo_read(uart_dev, &c, 1) > 0) {
continue;
}
}
static uint8_t mhz19b_checksum(const uint8_t *data)
{
uint8_t cs = 0;
for (uint8_t i = 1; i < MHZ19B_BUF_LEN - 1; i++) {
cs += data[i];
}
return 0xff - cs + 1;
}
static int mhz19b_send_cmd(const struct device *dev, enum mhz19b_cmd_idx cmd_idx, bool has_rsp)
{
struct mhz19b_data *data = dev->data;
const struct mhz19b_cfg *cfg = dev->config;
int ret;
/* Make sure last command has been transferred */
ret = k_sem_take(&data->tx_sem, MHZ19B_WAIT);
if (ret) {
return ret;
}
data->cmd_idx = cmd_idx;
data->has_rsp = has_rsp;
k_sem_reset(&data->rx_sem);
uart_irq_tx_enable(cfg->uart_dev);
if (has_rsp) {
uart_irq_rx_enable(cfg->uart_dev);
ret = k_sem_take(&data->rx_sem, MHZ19B_WAIT);
}
return ret;
}
static inline int mhz19b_send_config(const struct device *dev, enum mhz19b_cmd_idx cmd_idx)
{
struct mhz19b_data *data = dev->data;
int ret;
ret = mhz19b_send_cmd(dev, cmd_idx, true);
if (ret < 0) {
return ret;
}
if (data->rd_data[MHZ19B_RX_CMD_IDX] != mhz19b_cmds[data->cmd_idx][MHZ19B_TX_CMD_IDX]) {
return -EINVAL;
}
return 0;
}
static inline int mhz19b_poll_data(const struct device *dev, enum mhz19b_cmd_idx cmd_idx)
{
struct mhz19b_data *data = dev->data;
uint8_t checksum;
int ret;
ret = mhz19b_send_cmd(dev, cmd_idx, true);
if (ret < 0) {
return ret;
}
checksum = mhz19b_checksum(data->rd_data);
if (checksum != data->rd_data[MHZ19B_CHECKSUM_IDX]) {
LOG_DBG("Checksum mismatch: 0x%x != 0x%x", checksum,
data->rd_data[MHZ19B_CHECKSUM_IDX]);
return -EBADMSG;
}
switch (cmd_idx) {
case MHZ19B_CMD_IDX_GET_CO2:
data->data = sys_get_be16(&data->rd_data[2]);
break;
case MHZ19B_CMD_IDX_GET_RANGE:
data->data = sys_get_be16(&data->rd_data[4]);
break;
case MHZ19B_CMD_IDX_GET_ABC:
data->data = data->rd_data[7];
break;
default:
return -EINVAL;
}
return 0;
}
static int mhz19b_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct mhz19b_data *data = dev->data;
if (chan != SENSOR_CHAN_CO2) {
return -ENOTSUP;
}
val->val1 = (int32_t)data->data;
val->val2 = 0;
return 0;
}
static int mhz19b_attr_full_scale_cfg(const struct device *dev, int range)
{
switch (range) {
case 2000:
LOG_DBG("Configure range to %d", range);
return mhz19b_send_config(dev, MHZ19B_CMD_IDX_SET_RANGE_2000);
case 5000:
LOG_DBG("Configure range to %d", range);
return mhz19b_send_config(dev, MHZ19B_CMD_IDX_SET_RANGE_5000);
case 10000:
LOG_DBG("Configure range to %d", range);
return mhz19b_send_config(dev, MHZ19B_CMD_IDX_SET_RANGE_10000);
default:
return -ENOTSUP;
}
}
static int mhz19b_attr_abc_cfg(const struct device *dev, bool on)
{
if (on) {
LOG_DBG("%s ABC", "Enable");
return mhz19b_send_config(dev, MHZ19B_CMD_IDX_SET_ABC_ON);
}
LOG_DBG("%s ABC", "Disable");
return mhz19b_send_config(dev, MHZ19B_CMD_IDX_SET_ABC_OFF);
}
static int mhz19b_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_CO2) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return mhz19b_attr_full_scale_cfg(dev, val->val1);
case SENSOR_ATTR_MHZ19B_ABC:
return mhz19b_attr_abc_cfg(dev, val->val1);
default:
return -ENOTSUP;
}
}
static int mhz19b_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
struct mhz19b_data *data = dev->data;
int ret;
if (chan != SENSOR_CHAN_CO2) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
ret = mhz19b_poll_data(dev, MHZ19B_CMD_IDX_GET_RANGE);
break;
case SENSOR_ATTR_MHZ19B_ABC:
ret = mhz19b_poll_data(dev, MHZ19B_CMD_IDX_GET_ABC);
break;
default:
return -ENOTSUP;
}
val->val1 = (int32_t)data->data;
val->val2 = 0;
return ret;
}
static int mhz19b_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
if (chan == SENSOR_CHAN_CO2 || chan == SENSOR_CHAN_ALL) {
return mhz19b_poll_data(dev, MHZ19B_CMD_IDX_GET_CO2);
}
return -ENOTSUP;
}
static const struct sensor_driver_api mhz19b_api_funcs = {
.attr_set = mhz19b_attr_set,
.attr_get = mhz19b_attr_get,
.sample_fetch = mhz19b_sample_fetch,
.channel_get = mhz19b_channel_get,
};
static void mhz19b_uart_isr(const struct device *uart_dev, void *user_data)
{
const struct device *dev = user_data;
struct mhz19b_data *data = dev->data;
ARG_UNUSED(user_data);
if (uart_dev == NULL) {
return;
}
if (!uart_irq_update(uart_dev)) {
return;
}
if (uart_irq_rx_ready(uart_dev)) {
data->xfer_bytes += uart_fifo_read(uart_dev, &data->rd_data[data->xfer_bytes],
MHZ19B_BUF_LEN - data->xfer_bytes);
if (data->xfer_bytes == MHZ19B_BUF_LEN) {
data->xfer_bytes = 0;
uart_irq_rx_disable(uart_dev);
k_sem_give(&data->rx_sem);
if (data->has_rsp) {
k_sem_give(&data->tx_sem);
}
}
}
if (uart_irq_tx_ready(uart_dev)) {
data->xfer_bytes +=
uart_fifo_fill(uart_dev, &mhz19b_cmds[data->cmd_idx][data->xfer_bytes],
MHZ19B_BUF_LEN - data->xfer_bytes);
if (data->xfer_bytes == MHZ19B_BUF_LEN) {
data->xfer_bytes = 0;
uart_irq_tx_disable(uart_dev);
if (!data->has_rsp) {
k_sem_give(&data->tx_sem);
}
}
}
}
static int mhz19b_init(const struct device *dev)
{
struct mhz19b_data *data = dev->data;
const struct mhz19b_cfg *cfg = dev->config;
int ret;
uart_irq_rx_disable(cfg->uart_dev);
uart_irq_tx_disable(cfg->uart_dev);
mhz19b_uart_flush(cfg->uart_dev);
uart_irq_callback_user_data_set(cfg->uart_dev, cfg->cb, (void *)dev);
k_sem_init(&data->rx_sem, 0, 1);
k_sem_init(&data->tx_sem, 1, 1);
/* Configure default detection range */
ret = mhz19b_attr_full_scale_cfg(dev, cfg->range);
if (ret != 0) {
LOG_ERR("Error setting default range %d", cfg->range);
return ret;
}
/* Configure ABC logic */
ret = mhz19b_attr_abc_cfg(dev, cfg->abc_on);
if (ret != 0) {
LOG_ERR("Error setting default ABC %s", cfg->abc_on ? "on" : "off");
}
return ret;
}
#define MHZ19B_INIT(inst) \
\
static struct mhz19b_data mhz19b_data_##inst; \
\
static const struct mhz19b_cfg mhz19b_cfg_##inst = { \
.uart_dev = DEVICE_DT_GET(DT_INST_BUS(inst)), \
.range = DT_INST_PROP(inst, maximum_range), \
.abc_on = DT_INST_PROP(inst, abc_on), \
.cb = mhz19b_uart_isr, \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, mhz19b_init, NULL, \
&mhz19b_data_##inst, &mhz19b_cfg_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &mhz19b_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(MHZ19B_INIT)
``` | /content/code_sandbox/drivers/sensor/mhz19b/mhz19b.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,742 |
```objective-c
/* Bosch BMG160 gyro driver */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BMG160_BMG160_H_
#define ZEPHYR_DRIVERS_SENSOR_BMG160_BMG160_H_
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
/* registers */
#define BMG160_REG_CHIPID 0x00
#define BMG160_REG_RATE_X 0x02
#define BMG160_REG_RATE_Y 0x04
#define BMG160_REG_RATE_Z 0x06
#define BMG160_REG_TEMP 0x08
#define BMG160_REG_INT_STATUS0 0x09
#define BMG160_REG_INT_STATUS1 0x0A
#define BMG160_REG_INT_STATUS2 0x0B
#define BMG160_REG_INT_STATUS3 0x0C
#define BMG160_REG_FIFO_STATUS 0x0E
#define BMG160_REG_RANGE 0x0F
#define BMG160_REG_BW 0x10
#define BMG160_REG_LPM1 0x11
#define BMG160_REG_LPM2 0x12
#define BMG160_REG_RATE_HBW 0x13
#define BMG160_REG_BGW_SOFTRESET 0x14
#define BMG160_REG_INT_EN0 0x15
#define BMG160_REG_INT_EN1 0x16
#define BMG160_REG_INT_MAP0 0x17
#define BMG160_REG_INT_MAP1 0x18
#define BMG160_REG_INT_MAP2 0x19
#define BMG160_REG_FILTER 0x1A
#define BMG160_REG_THRES 0x1B
#define BMG160_REG_ANY_EN 0x1C
#define BMG160_REG_FIFO_WM 0x1E
#define BMG160_REG_INT_RST_LATCH 0x21
#define BMG160_REG_HIGH_TH_X 0x22
#define BMG160_REG_HIGH_DUR_X 0x23
#define BMG160_REG_HIGH_TH_Y 0x24
#define BMG160_REG_HIGH_DUR_Y 0x25
#define BMG160_REG_HIGH_TH_Z 0x26
#define BMG160_REG_HIGH_DUR_Z 0x27
#define BMG160_REG_SOC 0x31
#define BMG160_REG_A_FOC 0x32
#define BMG160_REG_TRIM_NVM_CTRL 0x33
#define BMG160_REG_BGW_SPI3_WDT 0x34
#define BMG160_REG_OFC1 0x36
#define BMG160_REG_OFC2 0x37
#define BMG160_REG_OFC3 0x38
#define BMG160_REG_OFC4 0x39
#define BMG160_REG_TRIM_GP0 0x3A
#define BMG160_REG_TRIM_GP1 0x3B
#define BMG160_REG_TRIM_BIST 0x3C
#define BMG160_REG_TRIM_FIFO_CONFIG0 0x3D
#define BMG160_REG_TRIM_FIFO_CONFIG1 0x3E
#define BMG160_REG_TRIM_FIFO_DATA 0x3F
/* bitfields */
/* BMG160_REG_INT_STATUS0 */
#define BMG160_HIGH_INT BIT(1)
#define BMG160_ANY_INT BIT(2)
/* BMG160_REG_INT_STATUS1 */
#define BMG160_FIFO_INT BIT(4)
#define BMG160_FAST_OFFSET_INT BIT(5)
#define BMG160_AUTO_OFFSET_INT BIT(6)
#define BMG160_DATA_INT BIT(7)
/* BMG160_REG_INT_STATUS2 */
#define BMG160_ANY_FIRST_X BIT(0)
#define BMG160_ANY_FIRST_Y BIT(1)
#define BMG160_ANY_FIRST_Z BIT(2)
#define BMG160_ANY_SIGN BIT(3)
/* BMG160_REG_INT_STATUS3 */
#define BMG160_HIGH_FIRST_X BIT(0)
#define BMG160_HIGH_FIRST_Y BIT(1)
#define BMG160_HIGH_FIRST_Z BIT(2)
#define BMG160_HIGH_SIGN BIT(3)
/* BMG160_REG_FIFO_STATUS */
#define BMG160_FIFO_FRAME_COUNTER_MASK 0x7F
#define BMG160_FIFO_OVERRUN BIT(7)
/* BMG160_REG_INT_EN_0 */
#define BMG160_AUTO_OFFSET_EN BIT(2)
#define BMG160_FIFO_EN BIT(6)
#define BMG160_DATA_EN BIT(7)
/* BMG160_REG_INT_EN_1 */
#define BMG160_INT1_LVL BIT(0)
#define BMG160_INT1_OD BIT(1)
#define BMG160_INT2_LVL BIT(2)
#define BMG160_INT2_OD BIT(3)
/* BMG160_REG_INT_MAP0 */
#define BMG160_INT1_ANY BIT(1)
#define BMG160_INT1_HIGH BIT(3)
/* BMG160_REG_INT_MAP1 */
#define BMG160_INT1_DATA BIT(0)
#define BMG160_INT1_FAST_OFFSET BIT(1)
#define BMG160_INT1_FIFO BIT(2)
#define BMG160_INT1_AUTO_OFFSET BIT(3)
#define BMG160_INT2_AUTO_OFFSET BIT(4)
#define BMG160_INT2_FIFO BIT(5)
#define BMG160_INT2_FAST_OFFSET BIT(6)
#define BMG160_INT2_DATA BIT(7)
/* BMG160_REG_ANY_EN */
#define BMG160_AWAKE_DUR_POS 6
#define BMG160_AWAKE_DUR_MASK (0x3 << 6)
#define BMG160_ANY_DURSAMPLE_POS 4
#define BMG160_ANY_DURSAMPLE_MASK (0x3 << 4)
#define BMG160_ANY_EN_Z BIT(2)
#define BMG160_ANY_EN_Y BIT(1)
#define BMG160_ANY_EN_X BIT(0)
#define BMG160_ANY_EN_MASK 0x7
/* BMG160_REG_INT_RST_LATCH */
#define BMG160_RESET_INT BIT(7)
#define BMG160_OFFSET_RESET BIT(6)
#define BMG160_LATCH_STATUS_BIT BIT(4)
#define BMG160_LATCH_INT_MASK 0x0F
/* BMG160_REG_THRES */
#define BMG160_THRES_MASK 0x7F
/* other */
#define BMG160_CHIP_ID 0x0F
#define BMG160_RESET 0xB6
#define BMG160_RANGE_TO_SCALE(range_dps) \
((2 * range_dps * SENSOR_PI) / 180LL / 65536LL)
#define BMG160_SCALE_TO_RANGE(scale) \
(((scale * 90LL * 65536LL) + SENSOR_PI / 2) / SENSOR_PI)
/* default settings, based on menuconfig options */
#if defined(CONFIG_BMG160_RANGE_RUNTIME) ||\
defined(CONFIG_BMG160_RANGE_2000DPS)
# define BMG160_DEFAULT_RANGE 0
#elif defined(CONFIG_BMG160_RANGE_1000DPS)
# define BMG160_DEFAULT_RANGE 1
#elif defined(CONFIG_BMG160_RANGE_500DPS)
# define BMG160_DEFAULT_RANGE 2
#elif defined(CONFIG_BMG160_RANGE_250DPS)
# define BMG160_DEFAULT_RANGE 3
#else
# define BMG160_DEFAULT_RANGE 4
#endif
#if defined(CONFIG_BMG160_ODR_RUNTIME) ||\
defined(CONFIG_BMG160_ODR_100)
# define BMG160_DEFAULT_ODR 5
#elif defined(CONFIG_BMG160_ODR_200)
# define BMG160_DEFAULT_ODR 4
#elif defined(CONFIG_BMG160_ODR_400)
# define BMG160_DEFAULT_ODR 3
#elif defined(CONFIG_BMG160_ODR_1000)
# define BMG160_DEFAULT_ODR 2
#else
# define BMG160_DEFAULT_ODR 1
#endif
#if defined(CONFIG_BMG160_I2C_SPEED_STANDARD)
#define BMG160_BUS_SPEED I2C_SPEED_STANDARD
#elif defined(CONFIG_BMG160_I2C_SPEED_FAST)
#define BMG160_BUS_SPEED I2C_SPEED_FAST
#endif
/* end of default settings */
struct bmg160_device_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_BMG160_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
struct bmg160_device_data {
#ifdef CONFIG_BMG160_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
#endif
#ifdef CONFIG_BMG160_TRIGGER_OWN_THREAD
struct k_sem trig_sem;
#endif
struct k_sem sem;
#ifdef CONFIG_BMG160_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
#ifdef CONFIG_BMG160_TRIGGER
sensor_trigger_handler_t anymotion_handler;
const struct sensor_trigger *anymotion_trig;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trig;
#endif
int16_t raw_gyro_xyz[3];
uint16_t scale;
uint8_t range_idx;
int8_t raw_temp;
};
int bmg160_trigger_init(const struct device *dev);
int bmg160_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int bmg160_read(const struct device *dev, uint8_t reg_addr, uint8_t *data,
uint8_t len);
int bmg160_read_byte(const struct device *dev, uint8_t reg_addr,
uint8_t *byte);
int bmg160_update_byte(const struct device *dev, uint8_t reg_addr,
uint8_t mask,
uint8_t value);
int bmg160_write_byte(const struct device *dev, uint8_t reg_addr,
uint8_t data);
int bmg160_slope_config(const struct device *dev, enum sensor_attribute attr,
const struct sensor_value *val);
#endif /* ZEPHYR_DRIVERS_SENSOR_BMG160_BMG160_H_ */
``` | /content/code_sandbox/drivers/sensor/bosch/bmg160/bmg160.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,187 |
```unknown
# Bosch BMG160 gyroscope configuration options
menuconfig BMG160
bool "Bosch BMG160 gyroscope support"
default y
depends on DT_HAS_BOSCH_BMG160_ENABLED
select I2C
help
Enable Bosch BMG160 gyroscope support.
if BMG160
choice
prompt "BMG160 I2C bus speed"
default BMG160_I2C_SPEED_STANDARD
config BMG160_I2C_SPEED_STANDARD
bool "Standard"
help
Standard bus speed of up to 100kHz.
config BMG160_I2C_SPEED_FAST
bool "Fast"
help
Fast bus speed of up to 400KHz.
endchoice
choice
prompt "Trigger mode"
default BMG160_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config BMG160_TRIGGER_NONE
bool "No trigger"
config BMG160_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
select BMG160_TRIGGER
config BMG160_TRIGGER_OWN_THREAD
bool "Use own thread"
select BMG160_TRIGGER
endchoice
config BMG160_TRIGGER
bool
config BMG160_THREAD_PRIORITY
int "Own thread priority"
depends on BMG160_TRIGGER_OWN_THREAD
default 10
help
The priority of the thread used for handling interrupts.
config BMG160_THREAD_STACK_SIZE
int "Own thread stack size"
depends on BMG160_TRIGGER_OWN_THREAD
default 1024
help
The thread stack size.
choice
prompt "Gyroscope range setting."
default BMG160_RANGE_RUNTIME
config BMG160_RANGE_RUNTIME
bool "Set at runtime."
config BMG160_RANGE_2000DPS
bool "2000 DPS"
config BMG160_RANGE_1000DPS
bool "1000 DPS"
config BMG160_RANGE_500DPS
bool "500 DPS"
config BMG160_RANGE_250DPS
bool "250 DPS"
config BMG160_RANGE_125DPS
bool "125 DPS"
endchoice
choice
prompt "Gyroscope sampling frequency."
default BMG160_ODR_RUNTIME
config BMG160_ODR_RUNTIME
bool "Set at runtime."
config BMG160_ODR_100
bool "100 Hz"
config BMG160_ODR_200
bool "200 Hz"
config BMG160_ODR_400
bool "400 Hz"
config BMG160_ODR_1000
bool "1000 Hz"
config BMG160_ODR_2000
bool "2000 Hz"
endchoice
endif # BMG160
``` | /content/code_sandbox/drivers/sensor/bosch/bmg160/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 553 |
```c
/* Bosch BMG160 gyro driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT bosch_bmg160
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include "bmg160.h"
LOG_MODULE_REGISTER(BMG160, CONFIG_SENSOR_LOG_LEVEL);
static inline int bmg160_bus_config(const struct device *dev)
{
const struct bmg160_device_config *dev_cfg = dev->config;
uint32_t i2c_cfg;
i2c_cfg = I2C_MODE_CONTROLLER | I2C_SPEED_SET(BMG160_BUS_SPEED);
return i2c_configure(dev_cfg->i2c.bus, i2c_cfg);
}
int bmg160_read(const struct device *dev, uint8_t reg_addr, uint8_t *data,
uint8_t len)
{
const struct bmg160_device_config *dev_cfg = dev->config;
struct bmg160_device_data *bmg160 = dev->data;
int ret = 0;
bmg160_bus_config(dev);
k_sem_take(&bmg160->sem, K_FOREVER);
if (i2c_burst_read_dt(&dev_cfg->i2c,
reg_addr, data, len) < 0) {
ret = -EIO;
}
k_sem_give(&bmg160->sem);
return ret;
}
int bmg160_read_byte(const struct device *dev, uint8_t reg_addr,
uint8_t *byte)
{
return bmg160_read(dev, reg_addr, byte, 1);
}
static int bmg160_write(const struct device *dev, uint8_t reg_addr,
uint8_t *data,
uint8_t len)
{
const struct bmg160_device_config *dev_cfg = dev->config;
struct bmg160_device_data *bmg160 = dev->data;
int ret = 0;
bmg160_bus_config(dev);
k_sem_take(&bmg160->sem, K_FOREVER);
if (i2c_burst_write_dt(&dev_cfg->i2c,
reg_addr, data, len) < 0) {
ret = -EIO;
}
k_sem_give(&bmg160->sem);
return ret;
}
int bmg160_write_byte(const struct device *dev, uint8_t reg_addr,
uint8_t byte)
{
return bmg160_write(dev, reg_addr, &byte, 1);
}
int bmg160_update_byte(const struct device *dev, uint8_t reg_addr,
uint8_t mask,
uint8_t value)
{
const struct bmg160_device_config *dev_cfg = dev->config;
struct bmg160_device_data *bmg160 = dev->data;
int ret = 0;
bmg160_bus_config(dev);
k_sem_take(&bmg160->sem, K_FOREVER);
if (i2c_reg_update_byte_dt(&dev_cfg->i2c,
reg_addr, mask, value) < 0) {
ret = -EIO;
}
k_sem_give(&bmg160->sem);
return ret;
}
/* Allowed range values, in degrees/sec. */
static const int16_t bmg160_gyro_range_map[] = {2000, 1000, 500, 250, 125};
#define BMG160_GYRO_RANGE_MAP_SIZE ARRAY_SIZE(bmg160_gyro_range_map)
/* Allowed sampling frequencies, in Hz */
static const int16_t bmg160_sampling_freq_map[] = {2000, 1000, 400, 200, 100};
#define BMG160_SAMPLING_FREQ_MAP_SIZE ARRAY_SIZE(bmg160_sampling_freq_map)
static int bmg160_is_val_valid(int16_t val, const int16_t *val_map,
uint16_t map_size)
{
int i;
for (i = 0; i < map_size; i++) {
if (val == val_map[i]) {
return i;
}
}
return -1;
}
static int bmg160_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct bmg160_device_data *bmg160 = dev->data;
#ifdef CONFIG_BMG160_TRIGGER
const struct bmg160_device_config *config = dev->config;
#endif
int idx;
uint16_t range_dps;
if (chan != SENSOR_CHAN_GYRO_XYZ) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
range_dps = sensor_rad_to_degrees(val);
idx = bmg160_is_val_valid(range_dps,
bmg160_gyro_range_map,
BMG160_GYRO_RANGE_MAP_SIZE);
if (idx < 0) {
return -ENOTSUP;
}
if (bmg160_write_byte(dev, BMG160_REG_RANGE, idx) < 0) {
return -EIO;
}
bmg160->scale = BMG160_RANGE_TO_SCALE(range_dps);
return 0;
case SENSOR_ATTR_SAMPLING_FREQUENCY:
idx = bmg160_is_val_valid(val->val1,
bmg160_sampling_freq_map,
BMG160_SAMPLING_FREQ_MAP_SIZE);
if (idx < 0) {
return -ENOTSUP;
}
/*
* The sampling frequencies values start at 1, i.e. a
* sampling frequency of 2000Hz translates to BW value
* of 1. Hence the 1 added to the index received.
*/
if (bmg160_write_byte(dev, BMG160_REG_BW, idx + 1) < 0) {
return -EIO;
}
return 0;
#ifdef CONFIG_BMG160_TRIGGER
case SENSOR_ATTR_SLOPE_TH:
case SENSOR_ATTR_SLOPE_DUR:
if (!config->int_gpio.port) {
return -ENOTSUP;
}
return bmg160_slope_config(dev, attr, val);
#endif
default:
return -ENOTSUP;
}
}
static int bmg160_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct bmg160_device_data *bmg160 = dev->data;
union {
uint8_t raw[7];
struct {
uint16_t x_axis;
uint16_t y_axis;
uint16_t z_axis;
uint8_t temp;
};
} buf __aligned(2);
/* do a burst read, to fetch all axis data */
if (bmg160_read(dev, BMG160_REG_RATE_X, buf.raw, sizeof(buf)) < 0) {
return -EIO;
}
bmg160->raw_gyro_xyz[0] = sys_le16_to_cpu(buf.x_axis);
bmg160->raw_gyro_xyz[1] = sys_le16_to_cpu(buf.y_axis);
bmg160->raw_gyro_xyz[2] = sys_le16_to_cpu(buf.z_axis);
bmg160->raw_temp = buf.temp;
return 0;
}
static void bmg160_to_fixed_point(struct bmg160_device_data *bmg160,
enum sensor_channel chan, int16_t raw,
struct sensor_value *val)
{
if (chan == SENSOR_CHAN_DIE_TEMP) {
val->val1 = 23 + (raw / 2);
val->val2 = (raw % 2) * 500000;
} else {
int32_t converted_val = raw * bmg160->scale;
val->val1 = converted_val / 1000000;
val->val2 = converted_val % 1000000;
}
}
static int bmg160_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct bmg160_device_data *bmg160 = dev->data;
int16_t raw_val;
int i;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
raw_val = bmg160->raw_gyro_xyz[chan - SENSOR_CHAN_GYRO_X];
bmg160_to_fixed_point(bmg160, chan, raw_val, val);
return 0;
case SENSOR_CHAN_GYRO_XYZ:
/* return all channel values, in one read */
for (i = 0; i < 3; i++, val++) {
raw_val = bmg160->raw_gyro_xyz[i];
bmg160_to_fixed_point(bmg160, chan, raw_val, val);
}
return 0;
case SENSOR_CHAN_DIE_TEMP:
bmg160_to_fixed_point(bmg160, chan, bmg160->raw_temp, val);
return 0;
default:
return -ENOTSUP;
}
}
static const struct sensor_driver_api bmg160_api = {
.attr_set = bmg160_attr_set,
#ifdef CONFIG_BMG160_TRIGGER
.trigger_set = bmg160_trigger_set,
#endif
.sample_fetch = bmg160_sample_fetch,
.channel_get = bmg160_channel_get,
};
int bmg160_init(const struct device *dev)
{
const struct bmg160_device_config *cfg = dev->config;
struct bmg160_device_data *bmg160 = dev->data;
uint8_t chip_id = 0U;
uint16_t range_dps;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
k_sem_init(&bmg160->sem, 1, K_SEM_MAX_LIMIT);
if (bmg160_read_byte(dev, BMG160_REG_CHIPID, &chip_id) < 0) {
LOG_DBG("Failed to read chip id.");
return -EIO;
}
if (chip_id != BMG160_CHIP_ID) {
LOG_DBG("Unsupported chip detected (0x%x)!", chip_id);
return -ENODEV;
}
/* reset the chip */
bmg160_write_byte(dev, BMG160_REG_BGW_SOFTRESET, BMG160_RESET);
k_busy_wait(1000); /* wait for the chip to come up */
if (bmg160_write_byte(dev, BMG160_REG_RANGE,
BMG160_DEFAULT_RANGE) < 0) {
LOG_DBG("Failed to set range.");
return -EIO;
}
range_dps = bmg160_gyro_range_map[BMG160_DEFAULT_RANGE];
bmg160->scale = BMG160_RANGE_TO_SCALE(range_dps);
if (bmg160_write_byte(dev, BMG160_REG_BW, BMG160_DEFAULT_ODR) < 0) {
LOG_DBG("Failed to set sampling frequency.");
return -EIO;
}
/* disable interrupts */
if (bmg160_write_byte(dev, BMG160_REG_INT_EN0, 0) < 0) {
LOG_DBG("Failed to disable all interrupts.");
return -EIO;
}
#ifdef CONFIG_BMG160_TRIGGER
if (cfg->int_gpio.port) {
bmg160_trigger_init(dev);
}
#endif
return 0;
}
#define BMG160_DEFINE(inst) \
static struct bmg160_device_data bmg160_data_##inst; \
\
static const struct bmg160_device_config bmg160_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_BMG160_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
\
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, bmg160_init, NULL, \
&bmg160_data_##inst, &bmg160_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &bmg160_api); \
DT_INST_FOREACH_STATUS_OKAY(BMG160_DEFINE)
``` | /content/code_sandbox/drivers/sensor/bosch/bmg160/bmg160.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,597 |
```unknown
#
#
#
config BMP581
bool "BMP581 barometric pressure sensor"
depends on DT_HAS_BOSCH_BMP581_ENABLED
select I2C
default y
``` | /content/code_sandbox/drivers/sensor/bosch/bmp581/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 39 |
```objective-c
/*
*
*
* Driver is developed to be used with Zephyr. And it only supports i2c interface.
*
* Author: Talha Can Havadar <havadartalha@gmail.com>
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BMP581_BMP581_H_
#define ZEPHYR_DRIVERS_SENSOR_BMP581_BMP581_H_
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/util.h>
#include <zephyr/types.h>
#include <zephyr/drivers/sensor/bmp581_user.h>
#define DT_DRV_COMPAT bosch_bmp581
/* UTILITY MACROS */
#define BMP5_SET_LOW_BYTE 0x00FFu
#define BMP5_SET_HIGH_BYTE 0xFF00u
/* BIT SLICE GET AND SET FUNCTIONS */
#define BMP5_GET_BITSLICE(regvar, bitname) ((regvar & bitname##_MSK) >> bitname##_POS)
#define BMP5_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK))
#define BMP5_GET_LSB(var) (uint8_t)(var & BMP5_SET_LOW_BYTE)
#define BMP5_GET_MSB(var) (uint8_t)((var & BMP5_SET_HIGH_BYTE) >> 8)
#define BMP5_SET_BIT_VAL_0(reg_data, bitname) (reg_data & ~(bitname##_MSK))
#define BMP5_SET_BITS_POS_0(reg_data, bitname, data) \
((reg_data & ~(bitname##_MSK)) | (data & bitname##_MSK))
#define BMP5_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK))
#define BMP5_OK 0
#define BMP5_ENABLE 1u
#define BMP5_DISABLE 0u
/* BMP5 Registers */
#define BMP5_REG_CHIP_ID 0x01
#define BMP5_REG_REV_ID 0x02
#define BMP5_REG_CHIP_STATUS 0x11
#define BMP5_REG_DRIVE_CONFIG 0x13
#define BMP5_REG_INT_CONFIG 0x14
#define BMP5_REG_INT_SOURCE 0x15
#define BMP5_REG_FIFO_CONFIG 0x16
#define BMP5_REG_FIFO_COUNT 0x17
#define BMP5_REG_FIFO_SEL 0x18
#define BMP5_REG_TEMP_DATA_XLSB 0x1D
#define BMP5_REG_TEMP_DATA_LSB 0x1E
#define BMP5_REG_TEMP_DATA_MSB 0x1F
#define BMP5_REG_PRESS_DATA_XLSB 0x20
#define BMP5_REG_PRESS_DATA_LSB 0x21
#define BMP5_REG_PRESS_DATA_MSB 0x22
#define BMP5_REG_INT_STATUS 0x27
#define BMP5_REG_STATUS 0x28
#define BMP5_REG_FIFO_DATA 0x29
#define BMP5_REG_NVM_ADDR 0x2B
#define BMP5_REG_NVM_DATA_LSB 0x2C
#define BMP5_REG_NVM_DATA_MSB 0x2D
#define BMP5_REG_DSP_CONFIG 0x30
#define BMP5_REG_DSP_IIR 0x31
#define BMP5_REG_OOR_THR_P_LSB 0x32
#define BMP5_REG_OOR_THR_P_MSB 0x33
#define BMP5_REG_OOR_RANGE 0x34
#define BMP5_REG_OOR_CONFIG 0x35
#define BMP5_REG_OSR_CONFIG 0x36
#define BMP5_REG_ODR_CONFIG 0x37
#define BMP5_REG_OSR_EFF 0x38
#define BMP5_REG_CMD 0x7E
/* endof BMP5 Registers */
/* Chip id of BMP5 */
#define BMP5_CHIP_ID_PRIM 0x50
#define BMP5_CHIP_ID_SEC 0x51
/* I2C addresses */
#define BMP5_I2C_ADDR_PRIM 0x46
#define BMP5_I2C_ADDR_SEC 0x47
/* NVM addresses */
#define BMP5_NVM_START_ADDR 0x20
#define BMP5_NVM_END_ADDR 0x22
/* Interface settings */
#define BMP5_SPI_RD_MASK 0x80
/* Delay definition */
#define BMP5_DELAY_US_SOFT_RESET 2000
#define BMP5_DELAY_US_STANDBY 2500
#define BMP5_DELAY_US_NVM_READY_READ 800
#define BMP5_DELAY_US_NVM_READY_WRITE 10000
/* Soft reset command */
#define BMP5_SOFT_RESET_CMD 0xB6
/*! NVM command */
#define BMP5_NVM_FIRST_CMND 0x5D
#define BMP5_NVM_READ_ENABLE_CMND 0xA5
#define BMP5_NVM_WRITE_ENABLE_CMND 0xA0
/* Deepstandby enable/disable */
#define BMP5_DEEP_ENABLED 0
#define BMP5_DEEP_DISABLED 1
/*! Fifo frame configuration */
#define BMP5_FIFO_EMPTY 0X7F
#define BMP5_FIFO_MAX_THRESHOLD_P_T_MODE 0x0F
#define BMP5_FIFO_MAX_THRESHOLD_P_MODE 0x1F
/* Macro is used to bypass both iir_t and iir_p together */
#define BMP5_IIR_BYPASS 0xC0
/* Pressure Out-of-range count limit */
#define BMP5_OOR_COUNT_LIMIT_1 0x00
#define BMP5_OOR_COUNT_LIMIT_3 0x01
#define BMP5_OOR_COUNT_LIMIT_7 0x02
#define BMP5_OOR_COUNT_LIMIT_15 0x03
/* Interrupt configurations */
#define BMP5_INT_MODE_PULSED 0
#define BMP5_INT_MODE_LATCHED 1
#define BMP5_INT_POL_ACTIVE_LOW 0
#define BMP5_INT_POL_ACTIVE_HIGH 1
#define BMP5_INT_OD_PUSHPULL 0
#define BMP5_INT_OD_OPENDRAIN 1
/* NVM and Interrupt status asserted macros */
#define BMP5_INT_ASSERTED_DRDY 0x01
#define BMP5_INT_ASSERTED_FIFO_FULL 0x02
#define BMP5_INT_ASSERTED_FIFO_THRES 0x04
#define BMP5_INT_ASSERTED_PRESSURE_OOR 0x08
#define BMP5_INT_ASSERTED_POR_SOFTRESET_COMPLETE 0x10
#define BMP5_INT_NVM_RDY 0x02
#define BMP5_INT_NVM_ERR 0x04
#define BMP5_INT_NVM_CMD_ERR 0x08
/* Interrupt configurations */
#define BMP5_INT_MODE_MSK 0x01
#define BMP5_INT_POL_MSK 0x02
#define BMP5_INT_POL_POS 1
#define BMP5_INT_OD_MSK 0x04
#define BMP5_INT_OD_POS 2
#define BMP5_INT_EN_MSK 0x08
#define BMP5_INT_EN_POS 3
#define BMP5_INT_DRDY_EN_MSK 0x01
#define BMP5_INT_FIFO_FULL_EN_MSK 0x02
#define BMP5_INT_FIFO_FULL_EN_POS 1
#define BMP5_INT_FIFO_THRES_EN_MSK 0x04
#define BMP5_INT_FIFO_THRES_EN_POS 2
#define BMP5_INT_OOR_PRESS_EN_MSK 0x08
#define BMP5_INT_OOR_PRESS_EN_POS 3
/* ODR configuration */
#define BMP5_ODR_MSK 0x7C
#define BMP5_ODR_POS 2
/* OSR configurations */
#define BMP5_TEMP_OS_MSK 0x07
#define BMP5_PRESS_OS_MSK 0x38
#define BMP5_PRESS_OS_POS 3
/* Pressure enable */
#define BMP5_PRESS_EN_MSK 0x40
#define BMP5_PRESS_EN_POS 6
/* IIR configurations */
#define BMP5_SET_IIR_TEMP_MSK 0x07
#define BMP5_SET_IIR_PRESS_MSK 0x38
#define BMP5_SET_IIR_PRESS_POS 3
#define BMP5_OOR_SEL_IIR_PRESS_MSK 0x80
#define BMP5_OOR_SEL_IIR_PRESS_POS 7
#define BMP5_SHDW_SET_IIR_TEMP_MSK 0x08
#define BMP5_SHDW_SET_IIR_TEMP_POS 3
#define BMP5_SHDW_SET_IIR_PRESS_MSK 0x20
#define BMP5_SHDW_SET_IIR_PRESS_POS 5
#define BMP5_SET_FIFO_IIR_TEMP_MSK 0x10
#define BMP5_SET_FIFO_IIR_TEMP_POS 4
#define BMP5_SET_FIFO_IIR_PRESS_MSK 0x40
#define BMP5_SET_FIFO_IIR_PRESS_POS 6
#define BMP5_IIR_FLUSH_FORCED_EN_MSK 0x04
#define BMP5_IIR_FLUSH_FORCED_EN_POS 2
/* Effective OSR configurations and ODR valid status */
#define BMP5_OSR_TEMP_EFF_MSK 0x07
#define BMP5_OSR_PRESS_EFF_MSK 0x38
#define BMP5_OSR_PRESS_EFF_POS 3
#define BMP5_ODR_IS_VALID_MSK 0x80
#define BMP5_ODR_IS_VALID_POS 7
/* Powermode */
#define BMP5_POWERMODE_MSK 0x03
#define BMP5_DEEP_DISABLE_MSK 0x80
#define BMP5_DEEP_DISABLE_POS 7
/* Fifo configurations */
#define BMP5_FIFO_THRESHOLD_MSK 0x1F
#define BMP5_FIFO_MODE_MSK 0x20
#define BMP5_FIFO_MODE_POS 5
#define BMP5_FIFO_DEC_SEL_MSK 0x1C
#define BMP5_FIFO_DEC_SEL_POS 2
#define BMP5_FIFO_COUNT_MSK 0x3F
#define BMP5_FIFO_FRAME_SEL_MSK 0x03
/* Out-of-range configuration */
#define BMP5_OOR_THR_P_LSB_MSK 0x0000FF
#define BMP5_OOR_THR_P_MSB_MSK 0x00FF00
#define BMP5_OOR_THR_P_XMSB_MSK 0x010000
#define BMP5_OOR_THR_P_XMSB_POS 16
/* Macro to mask xmsb value of oor threshold from register(0x35) value */
#define BMP5_OOR_THR_P_XMSB_REG_MSK 0x01
#define BMP5_OOR_COUNT_LIMIT_MSK 0xC0
#define BMP5_OOR_COUNT_LIMIT_POS 6
/* NVM configuration */
#define BMP5_NVM_ADDR_MSK 0x3F
#define BMP5_NVM_PROG_EN_MSK 0x40
#define BMP5_NVM_PROG_EN_POS 6
#define BMP5_NVM_DATA_LSB_MSK 0x00FF
#define BMP5_NVM_DATA_MSB_MSK 0xFF00
/*!
* @brief OSR, ODR and pressure configuration structure
*/
struct bmp581_osr_odr_press_config {
/*! Temperature oversampling
* Assignable macros :
* - BMP5_OVERSAMPLING_1X
* - BMP5_OVERSAMPLING_2X
* - BMP5_OVERSAMPLING_4X
* - BMP5_OVERSAMPLING_8X
* - BMP5_OVERSAMPLING_16X
* - BMP5_OVERSAMPLING_32X
* - BMP5_OVERSAMPLING_64X
* - BMP5_OVERSAMPLING_128X
*/
uint8_t osr_t;
/*! Pressure oversampling
* Assignable macros :
* - BMP5_OVERSAMPLING_1X
* - BMP5_OVERSAMPLING_2X
* - BMP5_OVERSAMPLING_4X
* - BMP5_OVERSAMPLING_8X
* - BMP5_OVERSAMPLING_16X
* - BMP5_OVERSAMPLING_32X
* - BMP5_OVERSAMPLING_64X
* - BMP5_OVERSAMPLING_128X
*/
uint8_t osr_p;
/*! Enable pressure
* BMP5_ENABLE = Enables pressure data
* BMP5_DISABLE = Disables pressure data
*/
uint8_t press_en;
/*! Output Data Rate */
uint8_t odr;
};
struct bmp581_sample {
struct sensor_value pressure;
struct sensor_value temperature;
};
struct bmp581_data {
uint8_t chip_id;
struct bmp581_sample last_sample;
struct bmp581_osr_odr_press_config osr_odr_press_config;
};
struct bmp581_config {
struct i2c_dt_spec i2c;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_BMP581_BMP581_H_ */
``` | /content/code_sandbox/drivers/sensor/bosch/bmp581/bmp581.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,712 |
```c
/*
*
*/
#include "bmp581.h"
#include <math.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/check.h>
LOG_MODULE_REGISTER(bmp581, CONFIG_SENSOR_LOG_LEVEL);
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "BMP581 driver enabled without any devices"
#endif
static int power_up_check(const struct device *dev);
static int get_nvm_status(uint8_t *nvm_status, const struct device *dev);
static int get_interrupt_status(uint8_t *int_status, const struct device *dev);
static int validate_chip_id(struct bmp581_data *drv);
static int get_osr_odr_press_config(struct bmp581_osr_odr_press_config *osr_odr_press_cfg,
const struct device *dev);
static int set_osr_config(const struct sensor_value *osr, enum sensor_channel chan,
const struct device *dev);
static int set_odr_config(const struct sensor_value *odr, const struct device *dev);
static int soft_reset(const struct device *dev);
static int set_iir_config(const struct sensor_value *iir, const struct device *dev);
static int get_power_mode(enum bmp5_powermode *powermode, const struct device *dev);
static int set_power_mode(enum bmp5_powermode powermode, const struct device *dev);
static int set_power_mode(enum bmp5_powermode powermode, const struct device *dev)
{
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
int ret = BMP5_OK;
uint8_t odr = 0;
enum bmp5_powermode current_powermode;
CHECKIF(dev == NULL) {
return -EINVAL;
}
ret = get_power_mode(¤t_powermode, dev);
if (ret != BMP5_OK) {
LOG_ERR("Couldnt set the power mode because something went wrong when getting the "
"current power mode.");
return ret;
}
if (current_powermode != BMP5_POWERMODE_STANDBY) {
/*
* Device should be set to standby before transitioning to forced mode or normal
* mode or continuous mode.
*/
ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &odr);
if (ret == BMP5_OK) {
/* Setting deep_dis = 1(BMP5_DEEP_DISABLED) disables the deep standby mode
*/
odr = BMP5_SET_BITSLICE(odr, BMP5_DEEP_DISABLE, BMP5_DEEP_DISABLED);
odr = BMP5_SET_BITS_POS_0(odr, BMP5_POWERMODE, BMP5_POWERMODE_STANDBY);
ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr);
if (ret != BMP5_OK) {
LOG_DBG("Failed to set power mode to BMP5_POWERMODE_STANDBY.");
return ret;
}
}
}
/* lets update the power mode */
switch (powermode) {
case BMP5_POWERMODE_STANDBY:
/* this change is already done so we can just return */
ret = BMP5_OK;
break;
case BMP5_POWERMODE_DEEP_STANDBY:
LOG_DBG("Setting power mode to DEEP STANDBY is not supported, current power mode "
"is BMP5_POWERMODE_STANDBY.");
ret = -ENOTSUP;
break;
case BMP5_POWERMODE_NORMAL:
case BMP5_POWERMODE_FORCED:
case BMP5_POWERMODE_CONTINUOUS:
odr = BMP5_SET_BITSLICE(odr, BMP5_DEEP_DISABLE, BMP5_DEEP_DISABLED);
odr = BMP5_SET_BITS_POS_0(odr, BMP5_POWERMODE, powermode);
ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr);
break;
default:
/* invalid power mode */
ret = -EINVAL;
break;
}
return ret;
}
static int get_power_mode(enum bmp5_powermode *powermode, const struct device *dev)
{
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
int ret = BMP5_OK;
CHECKIF(powermode == NULL || dev == NULL) {
return -EINVAL;
}
uint8_t reg = 0;
uint8_t raw_power_mode = 0;
ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, ®);
if (ret != BMP5_OK) {
LOG_DBG("Failed to read odr config to get power mode!");
return ret;
}
raw_power_mode = BMP5_GET_BITS_POS_0(reg, BMP5_POWERMODE);
switch (raw_power_mode) {
case BMP5_POWERMODE_STANDBY: {
/* Getting deep disable status */
uint8_t deep_dis = BMP5_GET_BITSLICE(reg, BMP5_DEEP_DISABLE);
/* Checking deepstandby status only when powermode is in standby mode */
/* If deep_dis = 0(BMP5_DEEP_ENABLED) then deepstandby mode is enabled.
* If deep_dis = 1(BMP5_DEEP_DISABLED) then deepstandby mode is disabled
*/
if (deep_dis == BMP5_DEEP_ENABLED) {
/* TODO: check if it is really deep standby */
*powermode = BMP5_POWERMODE_DEEP_STANDBY;
} else {
*powermode = BMP5_POWERMODE_STANDBY;
}
break;
}
case BMP5_POWERMODE_NORMAL:
*powermode = BMP5_POWERMODE_NORMAL;
break;
case BMP5_POWERMODE_FORCED:
*powermode = BMP5_POWERMODE_FORCED;
break;
case BMP5_POWERMODE_CONTINUOUS:
*powermode = BMP5_POWERMODE_CONTINUOUS;
break;
default:
/* invalid power mode */
ret = -EINVAL;
LOG_DBG("Something went wrong invalid powermode!");
break;
}
return ret;
}
static int power_up_check(const struct device *dev)
{
int8_t rslt = 0;
uint8_t nvm_status = 0;
CHECKIF(dev == NULL) {
return -EINVAL;
}
rslt = get_nvm_status(&nvm_status, dev);
if (rslt == BMP5_OK) {
/* Check if nvm_rdy status = 1 and nvm_err status = 0 to proceed */
if ((nvm_status & BMP5_INT_NVM_RDY) && (!(nvm_status & BMP5_INT_NVM_ERR))) {
rslt = BMP5_OK;
} else {
rslt = -EFAULT;
}
}
return rslt;
}
static int get_interrupt_status(uint8_t *int_status, const struct device *dev)
{
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
CHECKIF(int_status == NULL || dev == NULL) {
return -EINVAL;
}
return i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_INT_STATUS, int_status);
}
static int get_nvm_status(uint8_t *nvm_status, const struct device *dev)
{
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
CHECKIF(nvm_status == NULL || dev == NULL) {
return -EINVAL;
}
return i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_STATUS, nvm_status);
}
static int validate_chip_id(struct bmp581_data *drv)
{
int8_t rslt = 0;
CHECKIF(drv == NULL) {
return -EINVAL;
}
if ((drv->chip_id == BMP5_CHIP_ID_PRIM) || (drv->chip_id == BMP5_CHIP_ID_SEC)) {
rslt = BMP5_OK;
} else {
drv->chip_id = 0;
rslt = -ENODEV;
}
return rslt;
}
/*!
* This API gets the configuration for oversampling of temperature, oversampling of
* pressure and ODR configuration along with pressure enable.
*/
static int get_osr_odr_press_config(struct bmp581_osr_odr_press_config *osr_odr_press_cfg,
const struct device *dev)
{
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
/* Variable to store the function result */
int8_t rslt = 0;
/* Variable to store OSR and ODR config */
uint8_t reg_data[2] = {0};
CHECKIF(osr_odr_press_cfg == NULL || dev == NULL) {
return -EINVAL;
}
/* Get OSR and ODR configuration in burst read */
rslt = i2c_burst_read_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, reg_data, 2);
if (rslt == BMP5_OK) {
osr_odr_press_cfg->osr_t = BMP5_GET_BITS_POS_0(reg_data[0], BMP5_TEMP_OS);
osr_odr_press_cfg->osr_p = BMP5_GET_BITSLICE(reg_data[0], BMP5_PRESS_OS);
osr_odr_press_cfg->press_en = BMP5_GET_BITSLICE(reg_data[0], BMP5_PRESS_EN);
osr_odr_press_cfg->odr = BMP5_GET_BITSLICE(reg_data[1], BMP5_ODR);
}
return rslt;
}
static int set_osr_config(const struct sensor_value *osr, enum sensor_channel chan,
const struct device *dev)
{
CHECKIF(osr == NULL || dev == NULL) {
return -EINVAL;
}
struct bmp581_data *drv = (struct bmp581_data *)dev->data;
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
int ret = 0;
uint8_t oversampling = osr->val1;
uint8_t press_en = osr->val2 != 0; /* if it is not 0 then pressure is enabled */
uint8_t osr_val = 0;
ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, &osr_val);
if (ret == BMP5_OK) {
switch (chan) {
case SENSOR_CHAN_ALL:
osr_val = BMP5_SET_BITS_POS_0(osr_val, BMP5_TEMP_OS, oversampling);
osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_OS, oversampling);
osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_EN, press_en);
break;
case SENSOR_CHAN_PRESS:
osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_OS, oversampling);
osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_EN, press_en);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
osr_val = BMP5_SET_BITS_POS_0(osr_val, BMP5_TEMP_OS, oversampling);
break;
default:
ret = -ENOTSUP;
break;
}
if (ret == BMP5_OK) {
ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, osr_val);
get_osr_odr_press_config(&drv->osr_odr_press_config, dev);
}
}
return ret;
}
static int set_odr_config(const struct sensor_value *odr, const struct device *dev)
{
CHECKIF(odr == NULL || dev == NULL) {
return -EINVAL;
}
struct bmp581_data *drv = (struct bmp581_data *)dev->data;
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
int ret = 0;
uint8_t odr_val = 0;
ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &odr_val);
if (ret != BMP5_OK) {
return ret;
}
odr_val = BMP5_SET_BITSLICE(odr_val, BMP5_ODR, odr->val1);
ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr_val);
get_osr_odr_press_config(&drv->osr_odr_press_config, dev);
return ret;
}
static int soft_reset(const struct device *dev)
{
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
int ret = 0;
const uint8_t reset_cmd = BMP5_SOFT_RESET_CMD;
uint8_t int_status = 0;
CHECKIF(dev == NULL) {
return -EINVAL;
}
ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_CMD, reset_cmd);
if (ret == BMP5_OK) {
k_usleep(BMP5_DELAY_US_SOFT_RESET);
ret = get_interrupt_status(&int_status, dev);
if (ret == BMP5_OK) {
if (int_status & BMP5_INT_ASSERTED_POR_SOFTRESET_COMPLETE) {
ret = BMP5_OK;
} else {
ret = -EFAULT;
}
}
} else {
LOG_DBG("Failed perform soft-reset.");
}
return ret;
}
static int bmp581_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
CHECKIF(dev == NULL) {
return -EINVAL;
}
if (chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
struct bmp581_data *drv = (struct bmp581_data *)dev->data;
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
uint8_t data[6];
int ret = 0;
ret = i2c_burst_read_dt(&conf->i2c, BMP5_REG_TEMP_DATA_XLSB, data, 6);
if (ret == BMP5_OK) {
/* convert raw sensor data to sensor_value. Shift the decimal part by 1 decimal
* place to compensate for the conversion in sensor_value_to_double()
*/
drv->last_sample.temperature.val1 = data[2];
drv->last_sample.temperature.val2 = (data[1] << 8 | data[0]) * 10;
if (drv->osr_odr_press_config.press_en == BMP5_ENABLE) {
uint32_t raw_pressure = (uint32_t)((uint32_t)(data[5] << 16) |
(uint16_t)(data[4] << 8) | data[3]);
/* convert raw sensor data to sensor_value. Shift the decimal part by
* 4 decimal places to compensate for the conversion in
* sensor_value_to_double()
*/
drv->last_sample.pressure.val1 = raw_pressure >> 6;
drv->last_sample.pressure.val2 = (raw_pressure & BIT_MASK(6)) * 10000;
} else {
drv->last_sample.pressure.val1 = 0;
drv->last_sample.pressure.val2 = 0;
}
}
return ret;
}
static int bmp581_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
CHECKIF(dev == NULL || val == NULL) {
return -EINVAL;
}
struct bmp581_data *drv = (struct bmp581_data *)dev->data;
switch (chan) {
case SENSOR_CHAN_PRESS:
/* returns pressure in Pa */
*val = drv->last_sample.pressure;
return BMP5_OK;
case SENSOR_CHAN_AMBIENT_TEMP:
/* returns temperature in Celcius */
*val = drv->last_sample.temperature;
return BMP5_OK;
default:
return -ENOTSUP;
}
}
static int set_iir_config(const struct sensor_value *iir, const struct device *dev)
{
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
int ret = BMP5_OK;
CHECKIF((iir == NULL) | (dev == NULL)) {
return -EINVAL;
}
/* Variable to store existing powermode */
enum bmp5_powermode prev_powermode;
ret = get_power_mode(&prev_powermode, dev);
if (ret != BMP5_OK) {
LOG_DBG("Not able to get current power mode.");
return ret;
}
/* IIR configuration is writable only during STANDBY mode(as per datasheet) */
set_power_mode(BMP5_POWERMODE_STANDBY, dev);
/* update IIR config */
uint8_t dsp_config[2];
ret = i2c_burst_read_dt(&conf->i2c, BMP5_REG_DSP_CONFIG, dsp_config, 2);
if (ret != BMP5_OK) {
LOG_DBG("Failed to read dsp config register.");
return ret;
}
/* Put IIR filtered values in data registers */
dsp_config[0] = BMP5_SET_BITSLICE(dsp_config[0], BMP5_SHDW_SET_IIR_TEMP, BMP5_ENABLE);
dsp_config[0] = BMP5_SET_BITSLICE(dsp_config[0], BMP5_SHDW_SET_IIR_PRESS, BMP5_ENABLE);
/* Configure IIR filter */
dsp_config[1] = iir->val1;
dsp_config[1] = BMP5_SET_BITSLICE(dsp_config[1], BMP5_SET_IIR_PRESS, iir->val2);
/* Set IIR configuration */
ret = i2c_burst_write_dt(&conf->i2c, BMP5_REG_DSP_CONFIG, dsp_config, 2);
if (ret != BMP5_OK) {
LOG_DBG("Failed to configure IIR filter.");
return ret;
}
/* Restore previous power mode if it is not standby already */
if (prev_powermode != BMP5_POWERMODE_STANDBY) {
ret = set_power_mode(prev_powermode, dev);
}
return ret;
}
static int bmp581_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
CHECKIF(dev == NULL || val == NULL) {
return -EINVAL;
}
int ret;
switch ((int)attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
ret = set_odr_config(val, dev);
break;
case SENSOR_ATTR_OVERSAMPLING:
ret = set_osr_config(val, chan, dev);
break;
case BMP5_ATTR_POWER_MODE: {
enum bmp5_powermode powermode = (enum bmp5_powermode)val->val1;
ret = set_power_mode(powermode, dev);
break;
}
case BMP5_ATTR_IIR_CONFIG:
ret = set_iir_config(val, dev);
break;
default:
ret = -ENOTSUP;
break;
}
return ret;
}
static int bmp581_init(const struct device *dev)
{
CHECKIF(dev == NULL) {
return -EINVAL;
}
struct bmp581_data *drv = (struct bmp581_data *)dev->data;
struct bmp581_config *conf = (struct bmp581_config *)dev->config;
int ret = -1;
/* Reset the chip id. */
drv->chip_id = 0;
memset(&drv->osr_odr_press_config, 0, sizeof(drv->osr_odr_press_config));
memset(&drv->last_sample, 0, sizeof(drv->last_sample));
soft_reset(dev);
ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_CHIP_ID, &drv->chip_id);
if (ret != BMP5_OK) {
return ret;
}
if (drv->chip_id != 0) {
ret = power_up_check(dev);
if (ret == BMP5_OK) {
ret = validate_chip_id(drv);
if (ret != BMP5_OK) {
LOG_ERR("Unexpected chip id (%x). Expected (%x or %x)",
drv->chip_id, BMP5_CHIP_ID_PRIM, BMP5_CHIP_ID_SEC);
}
}
} else {
/* that means something went wrong */
LOG_ERR("Unexpected chip id (%x). Expected (%x or %x)", drv->chip_id,
BMP5_CHIP_ID_PRIM, BMP5_CHIP_ID_SEC);
return -EINVAL;
}
return ret;
}
static const struct sensor_driver_api bmp581_driver_api = {.sample_fetch = bmp581_sample_fetch,
.channel_get = bmp581_channel_get,
.attr_set = bmp581_attr_set};
#define BMP581_CONFIG(i) \
static const struct bmp581_config bmp581_config_##i = { \
.i2c = I2C_DT_SPEC_INST_GET(i), \
}
#define BMP581_INIT(i) \
static struct bmp581_data bmp581_data_##i; \
BMP581_CONFIG(i); \
\
SENSOR_DEVICE_DT_INST_DEFINE(i, bmp581_init, NULL, &bmp581_data_##i, &bmp581_config_##i, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&bmp581_driver_api);
DT_INST_FOREACH_STATUS_OKAY(BMP581_INIT)
``` | /content/code_sandbox/drivers/sensor/bosch/bmp581/bmp581.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,633 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BME280_BME280_H_
#define ZEPHYR_DRIVERS_SENSOR_BME280_BME280_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/rtio/rtio.h>
#define DT_DRV_COMPAT bosch_bme280
#define BME280_BUS_SPI DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define BME280_BUS_I2C DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
union bme280_bus {
#if BME280_BUS_SPI
struct spi_dt_spec spi;
#endif
#if BME280_BUS_I2C
struct i2c_dt_spec i2c;
#endif
};
typedef int (*bme280_bus_check_fn)(const union bme280_bus *bus);
typedef int (*bme280_reg_read_fn)(const union bme280_bus *bus,
uint8_t start, uint8_t *buf, int size);
typedef int (*bme280_reg_write_fn)(const union bme280_bus *bus,
uint8_t reg, uint8_t val);
struct bme280_bus_io {
bme280_bus_check_fn check;
bme280_reg_read_fn read;
bme280_reg_write_fn write;
};
#if BME280_BUS_SPI
#define BME280_SPI_OPERATION (SPI_WORD_SET(8) | SPI_TRANSFER_MSB | \
SPI_MODE_CPOL | SPI_MODE_CPHA)
extern const struct bme280_bus_io bme280_bus_io_spi;
#endif
#if BME280_BUS_I2C
extern const struct bme280_bus_io bme280_bus_io_i2c;
#endif
#define BME280_REG_PRESS_MSB 0xF7
#define BME280_REG_COMP_START 0x88
#define BME280_REG_HUM_COMP_PART1 0xA1
#define BME280_REG_HUM_COMP_PART2 0xE1
#define BME280_REG_ID 0xD0
#define BME280_REG_CONFIG 0xF5
#define BME280_REG_CTRL_MEAS 0xF4
#define BME280_REG_CTRL_HUM 0xF2
#define BME280_REG_STATUS 0xF3
#define BME280_REG_RESET 0xE0
#define BMP280_CHIP_ID_SAMPLE_1 0x56
#define BMP280_CHIP_ID_SAMPLE_2 0x57
#define BMP280_CHIP_ID_MP 0x58
#define BME280_CHIP_ID 0x60
#define BME280_MODE_SLEEP 0x00
#define BME280_MODE_FORCED 0x01
#define BME280_MODE_NORMAL 0x03
#define BME280_SPI_3W_DISABLE 0x00
#define BME280_CMD_SOFT_RESET 0xB6
#define BME280_STATUS_MEASURING 0x08
#define BME280_STATUS_IM_UPDATE 0x01
#if defined CONFIG_BME280_MODE_NORMAL
#define BME280_MODE BME280_MODE_NORMAL
#elif defined CONFIG_BME280_MODE_FORCED
#define BME280_MODE BME280_MODE_FORCED
#endif
#if defined CONFIG_BME280_TEMP_OVER_1X
#define BME280_TEMP_OVER (1 << 5)
#elif defined CONFIG_BME280_TEMP_OVER_2X
#define BME280_TEMP_OVER (2 << 5)
#elif defined CONFIG_BME280_TEMP_OVER_4X
#define BME280_TEMP_OVER (3 << 5)
#elif defined CONFIG_BME280_TEMP_OVER_8X
#define BME280_TEMP_OVER (4 << 5)
#elif defined CONFIG_BME280_TEMP_OVER_16X
#define BME280_TEMP_OVER (5 << 5)
#endif
#if defined CONFIG_BME280_PRESS_OVER_1X
#define BME280_PRESS_OVER (1 << 2)
#elif defined CONFIG_BME280_PRESS_OVER_2X
#define BME280_PRESS_OVER (2 << 2)
#elif defined CONFIG_BME280_PRESS_OVER_4X
#define BME280_PRESS_OVER (3 << 2)
#elif defined CONFIG_BME280_PRESS_OVER_8X
#define BME280_PRESS_OVER (4 << 2)
#elif defined CONFIG_BME280_PRESS_OVER_16X
#define BME280_PRESS_OVER (5 << 2)
#endif
#if defined CONFIG_BME280_HUMIDITY_OVER_1X
#define BME280_HUMIDITY_OVER 1
#elif defined CONFIG_BME280_HUMIDITY_OVER_2X
#define BME280_HUMIDITY_OVER 2
#elif defined CONFIG_BME280_HUMIDITY_OVER_4X
#define BME280_HUMIDITY_OVER 3
#elif defined CONFIG_BME280_HUMIDITY_OVER_8X
#define BME280_HUMIDITY_OVER 4
#elif defined CONFIG_BME280_HUMIDITY_OVER_16X
#define BME280_HUMIDITY_OVER 5
#endif
#if defined CONFIG_BME280_STANDBY_05MS
#define BME280_STANDBY 0
#elif defined CONFIG_BME280_STANDBY_62MS
#define BME280_STANDBY (1 << 5)
#elif defined CONFIG_BME280_STANDBY_125MS
#define BME280_STANDBY (2 << 5)
#elif defined CONFIG_BME280_STANDBY_250MS
#define BME280_STANDBY (3 << 5)
#elif defined CONFIG_BME280_STANDBY_500MS
#define BME280_STANDBY (4 << 5)
#elif defined CONFIG_BME280_STANDBY_1000MS
#define BME280_STANDBY (5 << 5)
#elif defined CONFIG_BME280_STANDBY_2000MS
#define BME280_STANDBY (6 << 5)
#elif defined CONFIG_BME280_STANDBY_4000MS
#define BME280_STANDBY (7 << 5)
#endif
#if defined CONFIG_BME280_FILTER_OFF
#define BME280_FILTER 0
#elif defined CONFIG_BME280_FILTER_2
#define BME280_FILTER (1 << 2)
#elif defined CONFIG_BME280_FILTER_4
#define BME280_FILTER (2 << 2)
#elif defined CONFIG_BME280_FILTER_8
#define BME280_FILTER (3 << 2)
#elif defined CONFIG_BME280_FILTER_16
#define BME280_FILTER (4 << 2)
#endif
#define BME280_CTRL_MEAS_VAL (BME280_PRESS_OVER | \
BME280_TEMP_OVER | \
BME280_MODE)
#define BME280_CONFIG_VAL (BME280_STANDBY | \
BME280_FILTER | \
BME280_SPI_3W_DISABLE)
#define BME280_CTRL_MEAS_OFF_VAL (BME280_PRESS_OVER | \
BME280_TEMP_OVER | \
BME280_MODE_SLEEP)
struct bme280_reading {
/* Compensated values. */
int32_t comp_temp;
uint32_t comp_press;
uint32_t comp_humidity;
};
struct bme280_data {
/* Compensation parameters. */
uint16_t dig_t1;
int16_t dig_t2;
int16_t dig_t3;
uint16_t dig_p1;
int16_t dig_p2;
int16_t dig_p3;
int16_t dig_p4;
int16_t dig_p5;
int16_t dig_p6;
int16_t dig_p7;
int16_t dig_p8;
int16_t dig_p9;
uint8_t dig_h1;
int16_t dig_h2;
uint8_t dig_h3;
int16_t dig_h4;
int16_t dig_h5;
int8_t dig_h6;
/* Carryover between temperature and pressure/humidity compensation. */
int32_t t_fine;
uint8_t chip_id;
struct bme280_reading reading;
};
/*
* RTIO
*/
struct bme280_decoder_header {
uint64_t timestamp;
} __attribute__((__packed__));
struct bme280_encoded_data {
struct bme280_decoder_header header;
struct {
/** Set if `temp` has data */
uint8_t has_temp: 1;
/** Set if `press` has data */
uint8_t has_press: 1;
/** Set if `humidity` has data */
uint8_t has_humidity: 1;
} __attribute__((__packed__));
struct bme280_reading reading;
};
int bme280_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder);
void bme280_submit(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe);
int bme280_sample_fetch(const struct device *dev,
enum sensor_channel chan);
int bme280_sample_fetch_helper(const struct device *dev,
enum sensor_channel chan,
struct bme280_reading *reading);
#endif /* ZEPHYR_DRIVERS_SENSOR_BME280_BME280_H_ */
``` | /content/code_sandbox/drivers/sensor/bosch/bme280/bme280.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,993 |
```c
/*
*
*/
#include <zephyr/rtio/work.h>
#include <zephyr/logging/log.h>
#include "bme280.h"
LOG_MODULE_DECLARE(BME280, CONFIG_SENSOR_LOG_LEVEL);
void bme280_submit_sync(struct rtio_iodev_sqe *iodev_sqe)
{
uint32_t min_buf_len = sizeof(struct bme280_encoded_data);
int rc;
uint8_t *buf;
uint32_t buf_len;
const struct sensor_read_config *cfg = iodev_sqe->sqe.iodev->data;
const struct device *dev = cfg->sensor;
const struct sensor_chan_spec *const channels = cfg->channels;
const size_t num_channels = cfg->count;
rc = rtio_sqe_rx_buf(iodev_sqe, min_buf_len, min_buf_len, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get a read buffer of size %u bytes", min_buf_len);
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
struct bme280_encoded_data *edata;
edata = (struct bme280_encoded_data *)buf;
edata->header.timestamp = k_ticks_to_ns_floor64(k_uptime_ticks());
edata->has_temp = 0;
edata->has_humidity = 0;
edata->has_press = 0;
/* Check if the requested channels are supported */
for (size_t i = 0; i < num_channels; i++) {
switch (channels[i].chan_type) {
case SENSOR_CHAN_AMBIENT_TEMP:
edata->has_temp = 1;
break;
case SENSOR_CHAN_HUMIDITY:
edata->has_humidity = 1;
break;
case SENSOR_CHAN_PRESS:
edata->has_press = 1;
break;
case SENSOR_CHAN_ALL:
edata->has_temp = 1;
edata->has_humidity = 1;
edata->has_press = 1;
break;
default:
continue;
break;
}
}
rc = bme280_sample_fetch_helper(dev, SENSOR_CHAN_ALL, &edata->reading);
if (rc != 0) {
LOG_ERR("Failed to fetch samples");
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
rtio_iodev_sqe_ok(iodev_sqe, 0);
}
void bme280_submit(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe)
{
struct rtio_work_req *req = rtio_work_req_alloc();
__ASSERT_NO_MSG(req);
rtio_work_req_submit(req, iodev_sqe, bme280_submit_sync);
}
``` | /content/code_sandbox/drivers/sensor/bosch/bme280/bme280_async.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 593 |
```c
/*
*
*/
/*
* Bus-specific functionality for BME280s accessed via I2C.
*/
#include "bme280.h"
#if BME280_BUS_I2C
static int bme280_bus_check_i2c(const union bme280_bus *bus)
{
return device_is_ready(bus->i2c.bus) ? 0 : -ENODEV;
}
static int bme280_reg_read_i2c(const union bme280_bus *bus,
uint8_t start, uint8_t *buf, int size)
{
return i2c_burst_read_dt(&bus->i2c, start, buf, size);
}
static int bme280_reg_write_i2c(const union bme280_bus *bus,
uint8_t reg, uint8_t val)
{
return i2c_reg_write_byte_dt(&bus->i2c, reg, val);
}
const struct bme280_bus_io bme280_bus_io_i2c = {
.check = bme280_bus_check_i2c,
.read = bme280_reg_read_i2c,
.write = bme280_reg_write_i2c,
};
#endif /* BME280_BUS_I2C */
``` | /content/code_sandbox/drivers/sensor/bosch/bme280/bme280_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 249 |
```c
/* bme280.c - Driver for Bosch BME280 temperature and pressure sensor */
/*
*
*/
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "bme280.h"
LOG_MODULE_REGISTER(BME280, CONFIG_SENSOR_LOG_LEVEL);
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "BME280 driver enabled without any devices"
#endif
struct bme280_config {
union bme280_bus bus;
const struct bme280_bus_io *bus_io;
};
static inline int bme280_bus_check(const struct device *dev)
{
const struct bme280_config *cfg = dev->config;
return cfg->bus_io->check(&cfg->bus);
}
static inline int bme280_reg_read(const struct device *dev,
uint8_t start, uint8_t *buf, int size)
{
const struct bme280_config *cfg = dev->config;
return cfg->bus_io->read(&cfg->bus, start, buf, size);
}
static inline int bme280_reg_write(const struct device *dev, uint8_t reg,
uint8_t val)
{
const struct bme280_config *cfg = dev->config;
return cfg->bus_io->write(&cfg->bus, reg, val);
}
/*
* Compensation code taken from BME280 datasheet, Section 4.2.3
* "Compensation formula".
*/
static int32_t bme280_compensate_temp(struct bme280_data *data, int32_t adc_temp)
{
int32_t var1, var2;
var1 = (((adc_temp >> 3) - ((int32_t)data->dig_t1 << 1)) *
((int32_t)data->dig_t2)) >> 11;
var2 = (((((adc_temp >> 4) - ((int32_t)data->dig_t1)) *
((adc_temp >> 4) - ((int32_t)data->dig_t1))) >> 12) *
((int32_t)data->dig_t3)) >> 14;
data->t_fine = var1 + var2;
return (data->t_fine * 5 + 128) >> 8;
}
static uint32_t bme280_compensate_press(struct bme280_data *data, int32_t adc_press)
{
int64_t var1, var2, p;
var1 = ((int64_t)data->t_fine) - 128000;
var2 = var1 * var1 * (int64_t)data->dig_p6;
var2 = var2 + ((var1 * (int64_t)data->dig_p5) << 17);
var2 = var2 + (((int64_t)data->dig_p4) << 35);
var1 = ((var1 * var1 * (int64_t)data->dig_p3) >> 8) +
((var1 * (int64_t)data->dig_p2) << 12);
var1 = (((((int64_t)1) << 47) + var1)) * ((int64_t)data->dig_p1) >> 33;
/* Avoid exception caused by division by zero. */
if (var1 == 0) {
return 0;
}
p = 1048576 - adc_press;
p = (((p << 31) - var2) * 3125) / var1;
var1 = (((int64_t)data->dig_p9) * (p >> 13) * (p >> 13)) >> 25;
var2 = (((int64_t)data->dig_p8) * p) >> 19;
p = ((p + var1 + var2) >> 8) + (((int64_t)data->dig_p7) << 4);
return (uint32_t)p;
}
static uint32_t bme280_compensate_humidity(struct bme280_data *data,
int32_t adc_humidity)
{
int32_t h;
h = (data->t_fine - ((int32_t)76800));
h = ((((adc_humidity << 14) - (((int32_t)data->dig_h4) << 20) -
(((int32_t)data->dig_h5) * h)) + ((int32_t)16384)) >> 15) *
(((((((h * ((int32_t)data->dig_h6)) >> 10) * (((h *
((int32_t)data->dig_h3)) >> 11) + ((int32_t)32768))) >> 10) +
((int32_t)2097152)) * ((int32_t)data->dig_h2) + 8192) >> 14);
h = (h - (((((h >> 15) * (h >> 15)) >> 7) *
((int32_t)data->dig_h1)) >> 4));
h = (h > 419430400 ? 419430400 : h);
return (uint32_t)(h >> 12);
}
static int bme280_wait_until_ready(const struct device *dev)
{
uint8_t status = 0;
int ret;
/* Wait for NVM to copy and measurement to be completed */
do {
k_sleep(K_MSEC(3));
ret = bme280_reg_read(dev, BME280_REG_STATUS, &status, 1);
if (ret < 0) {
return ret;
}
} while (status & (BME280_STATUS_MEASURING | BME280_STATUS_IM_UPDATE));
return 0;
}
int bme280_sample_fetch_helper(const struct device *dev,
enum sensor_channel chan, struct bme280_reading *reading)
{
struct bme280_data *dev_data = dev->data;
uint8_t buf[8];
int32_t adc_press, adc_temp, adc_humidity;
int size = 6;
int ret;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
#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
#ifdef CONFIG_BME280_MODE_FORCED
ret = bme280_reg_write(dev, BME280_REG_CTRL_MEAS, BME280_CTRL_MEAS_VAL);
if (ret < 0) {
return ret;
}
#endif
ret = bme280_wait_until_ready(dev);
if (ret < 0) {
return ret;
}
if (dev_data->chip_id == BME280_CHIP_ID) {
size = 8;
}
ret = bme280_reg_read(dev, BME280_REG_PRESS_MSB, buf, size);
if (ret < 0) {
return ret;
}
adc_press = (buf[0] << 12) | (buf[1] << 4) | (buf[2] >> 4);
adc_temp = (buf[3] << 12) | (buf[4] << 4) | (buf[5] >> 4);
reading->comp_temp = bme280_compensate_temp(dev_data, adc_temp);
reading->comp_press = bme280_compensate_press(dev_data, adc_press);
if (dev_data->chip_id == BME280_CHIP_ID) {
adc_humidity = (buf[6] << 8) | buf[7];
reading->comp_humidity = bme280_compensate_humidity(dev_data, adc_humidity);
}
return 0;
}
int bme280_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct bme280_data *data = dev->data;
return bme280_sample_fetch_helper(dev, chan, &data->reading);
}
static int bme280_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct bme280_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
/*
* comp_temp has a resolution of 0.01 degC. So
* 5123 equals 51.23 degC.
*/
val->val1 = data->reading.comp_temp / 100;
val->val2 = data->reading.comp_temp % 100 * 10000;
break;
case SENSOR_CHAN_PRESS:
/*
* comp_press has 24 integer bits and 8
* fractional. Output value of 24674867 represents
* 24674867/256 = 96386.2 Pa = 963.862 hPa
*/
val->val1 = (data->reading.comp_press >> 8) / 1000U;
val->val2 = (data->reading.comp_press >> 8) % 1000 * 1000U +
(((data->reading.comp_press & 0xff) * 1000U) >> 8);
break;
case SENSOR_CHAN_HUMIDITY:
/* The BMP280 doesn't have a humidity sensor */
if (data->chip_id != BME280_CHIP_ID) {
return -ENOTSUP;
}
/*
* comp_humidity has 22 integer bits and 10
* fractional. Output value of 47445 represents
* 47445/1024 = 46.333 %RH
*/
val->val1 = (data->reading.comp_humidity >> 10);
val->val2 = (((data->reading.comp_humidity & 0x3ff) * 1000U * 1000U) >> 10);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api bme280_api_funcs = {
.sample_fetch = bme280_sample_fetch,
.channel_get = bme280_channel_get,
#ifdef CONFIG_SENSOR_ASYNC_API
.submit = bme280_submit,
.get_decoder = bme280_get_decoder,
#endif
};
static int bme280_read_compensation(const struct device *dev)
{
struct bme280_data *data = dev->data;
uint16_t buf[12];
uint8_t hbuf[7];
int err = 0;
err = bme280_reg_read(dev, BME280_REG_COMP_START,
(uint8_t *)buf, sizeof(buf));
if (err < 0) {
LOG_DBG("COMP_START read failed: %d", err);
return err;
}
data->dig_t1 = sys_le16_to_cpu(buf[0]);
data->dig_t2 = sys_le16_to_cpu(buf[1]);
data->dig_t3 = sys_le16_to_cpu(buf[2]);
data->dig_p1 = sys_le16_to_cpu(buf[3]);
data->dig_p2 = sys_le16_to_cpu(buf[4]);
data->dig_p3 = sys_le16_to_cpu(buf[5]);
data->dig_p4 = sys_le16_to_cpu(buf[6]);
data->dig_p5 = sys_le16_to_cpu(buf[7]);
data->dig_p6 = sys_le16_to_cpu(buf[8]);
data->dig_p7 = sys_le16_to_cpu(buf[9]);
data->dig_p8 = sys_le16_to_cpu(buf[10]);
data->dig_p9 = sys_le16_to_cpu(buf[11]);
if (data->chip_id == BME280_CHIP_ID) {
err = bme280_reg_read(dev, BME280_REG_HUM_COMP_PART1,
&data->dig_h1, 1);
if (err < 0) {
LOG_DBG("HUM_COMP_PART1 read failed: %d", err);
return err;
}
err = bme280_reg_read(dev, BME280_REG_HUM_COMP_PART2, hbuf, 7);
if (err < 0) {
LOG_DBG("HUM_COMP_PART2 read failed: %d", err);
return err;
}
data->dig_h2 = (hbuf[1] << 8) | hbuf[0];
data->dig_h3 = hbuf[2];
data->dig_h4 = (hbuf[3] << 4) | (hbuf[4] & 0x0F);
data->dig_h5 = ((hbuf[4] >> 4) & 0x0F) | (hbuf[5] << 4);
data->dig_h6 = hbuf[6];
}
return 0;
}
static int bme280_chip_init(const struct device *dev)
{
struct bme280_data *data = dev->data;
int err;
err = bme280_bus_check(dev);
if (err < 0) {
LOG_DBG("bus check failed: %d", err);
return err;
}
err = bme280_reg_read(dev, BME280_REG_ID, &data->chip_id, 1);
if (err < 0) {
LOG_DBG("ID read failed: %d", err);
return err;
}
if (data->chip_id == BME280_CHIP_ID) {
LOG_DBG("ID OK");
} else if (data->chip_id == BMP280_CHIP_ID_MP ||
data->chip_id == BMP280_CHIP_ID_SAMPLE_1) {
LOG_DBG("ID OK (BMP280)");
} else {
LOG_DBG("bad chip id 0x%x", data->chip_id);
return -ENOTSUP;
}
err = bme280_reg_write(dev, BME280_REG_RESET, BME280_CMD_SOFT_RESET);
if (err < 0) {
LOG_DBG("Soft-reset failed: %d", err);
}
err = bme280_wait_until_ready(dev);
if (err < 0) {
return err;
}
err = bme280_read_compensation(dev);
if (err < 0) {
return err;
}
if (data->chip_id == BME280_CHIP_ID) {
err = bme280_reg_write(dev, BME280_REG_CTRL_HUM,
BME280_HUMIDITY_OVER);
if (err < 0) {
LOG_DBG("CTRL_HUM write failed: %d", err);
return err;
}
}
err = bme280_reg_write(dev, BME280_REG_CTRL_MEAS,
BME280_CTRL_MEAS_VAL);
if (err < 0) {
LOG_DBG("CTRL_MEAS write failed: %d", err);
return err;
}
err = bme280_reg_write(dev, BME280_REG_CONFIG,
BME280_CONFIG_VAL);
if (err < 0) {
LOG_DBG("CONFIG write failed: %d", err);
return err;
}
/* Wait for the sensor to be ready */
k_sleep(K_MSEC(1));
LOG_DBG("\"%s\" OK", dev->name);
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int bme280_pm_action(const struct device *dev,
enum pm_device_action action)
{
int ret = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
/* Re-initialize the chip */
ret = bme280_chip_init(dev);
break;
case PM_DEVICE_ACTION_SUSPEND:
/* Put the chip into sleep mode */
ret = bme280_reg_write(dev,
BME280_REG_CTRL_MEAS,
BME280_CTRL_MEAS_OFF_VAL);
if (ret < 0) {
LOG_DBG("CTRL_MEAS write failed: %d", ret);
}
break;
default:
return -ENOTSUP;
}
return ret;
}
#endif /* CONFIG_PM_DEVICE */
/* Initializes a struct bme280_config for an instance on a SPI bus. */
#define BME280_CONFIG_SPI(inst) \
{ \
.bus.spi = SPI_DT_SPEC_INST_GET( \
inst, BME280_SPI_OPERATION, 0), \
.bus_io = &bme280_bus_io_spi, \
}
/* Initializes a struct bme280_config for an instance on an I2C bus. */
#define BME280_CONFIG_I2C(inst) \
{ \
.bus.i2c = I2C_DT_SPEC_INST_GET(inst), \
.bus_io = &bme280_bus_io_i2c, \
}
/*
* Main instantiation macro, which selects the correct bus-specific
* instantiation macros for the instance.
*/
#define BME280_DEFINE(inst) \
static struct bme280_data bme280_data_##inst; \
static const struct bme280_config bme280_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(BME280_CONFIG_SPI(inst)), \
(BME280_CONFIG_I2C(inst))); \
\
PM_DEVICE_DT_INST_DEFINE(inst, bme280_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
bme280_chip_init, \
PM_DEVICE_DT_INST_GET(inst), \
&bme280_data_##inst, \
&bme280_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&bme280_api_funcs);
/* Create the struct device for every status "okay" node in the devicetree. */
DT_INST_FOREACH_STATUS_OKAY(BME280_DEFINE)
``` | /content/code_sandbox/drivers/sensor/bosch/bme280/bme280.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,818 |
```c
/*
*/
#include "bme280.h"
#include <math.h>
static int bme280_decoder_get_frame_count(const uint8_t *buffer,
struct sensor_chan_spec chan_spec,
uint16_t *frame_count)
{
const struct bme280_encoded_data *edata = (const struct bme280_encoded_data *)buffer;
int32_t ret = -ENOTSUP;
if (chan_spec.chan_idx != 0) {
return ret;
}
/* This sensor lacks a FIFO; there will always only be one frame at a time. */
switch (chan_spec.chan_type) {
case SENSOR_CHAN_AMBIENT_TEMP:
*frame_count = edata->has_temp ? 1 : 0;
break;
case SENSOR_CHAN_PRESS:
*frame_count = edata->has_press ? 1 : 0;
break;
case SENSOR_CHAN_HUMIDITY:
*frame_count = edata->has_humidity ? 1 : 0;
break;
default:
return ret;
}
if (*frame_count > 0) {
ret = 0;
}
return ret;
}
static int bme280_decoder_get_size_info(struct sensor_chan_spec chan_spec, size_t *base_size,
size_t *frame_size)
{
switch (chan_spec.chan_type) {
case SENSOR_CHAN_AMBIENT_TEMP:
case SENSOR_CHAN_HUMIDITY:
case SENSOR_CHAN_PRESS:
*base_size = sizeof(struct sensor_q31_sample_data);
*frame_size = sizeof(struct sensor_q31_sample_data);
return 0;
default:
return -ENOTSUP;
}
}
#define BME280_HUM_SHIFT (22)
#define BME280_PRESS_SHIFT (24)
#define BME280_TEMP_SHIFT (24)
static void bme280_convert_double_to_q31(double reading, int32_t shift, q31_t *out)
{
reading = reading * pow(2, 31 - shift);
int64_t reading_round = (reading < 0) ? (reading - 0.5) : (reading + 0.5);
int32_t reading_q31 = CLAMP(reading_round, INT32_MIN, INT32_MAX);
if (reading_q31 < 0) {
reading_q31 = abs(reading_q31);
reading_q31 = ~reading_q31;
reading_q31++;
}
*out = reading_q31;
}
/* Refer to bme280.c bme280_channel_get() */
static void bme280_convert_signed_temp_raw_to_q31(int32_t reading, q31_t *out)
{
double temp_double = reading / 100.0;
bme280_convert_double_to_q31(temp_double, BME280_TEMP_SHIFT, out);
}
static void bme280_convert_unsigned_pressure_raw_to_q31(uint32_t reading, q31_t *out)
{
double press_double = (reading / 256.0) / 1000.0; /* Pa -> hPa */
bme280_convert_double_to_q31(press_double, BME280_PRESS_SHIFT, out);
}
static void bme280_convert_unsigned_humidity_raw_to_q31(uint32_t reading, q31_t *out)
{
double hum_double = (reading / 1024.0);
bme280_convert_double_to_q31(hum_double, BME280_HUM_SHIFT, out);
}
static int bme280_decoder_decode(const uint8_t *buffer, struct sensor_chan_spec chan_spec,
uint32_t *fit, uint16_t max_count, void *data_out)
{
const struct bme280_encoded_data *edata = (const struct bme280_encoded_data *)buffer;
if (*fit != 0) {
return 0;
}
struct sensor_q31_data *out = data_out;
out->header.base_timestamp_ns = edata->header.timestamp;
out->header.reading_count = 1;
switch (chan_spec.chan_type) {
case SENSOR_CHAN_AMBIENT_TEMP:
if (edata->has_temp) {
bme280_convert_signed_temp_raw_to_q31(edata->reading.comp_temp,
&out->readings[0].temperature);
out->shift = BME280_TEMP_SHIFT;
} else {
return -ENODATA;
}
break;
case SENSOR_CHAN_PRESS:
if (edata->has_press) {
bme280_convert_unsigned_pressure_raw_to_q31(edata->reading.comp_press,
&out->readings[0].pressure);
out->shift = BME280_PRESS_SHIFT;
} else {
return -ENODATA;
}
break;
case SENSOR_CHAN_HUMIDITY:
if (edata->has_humidity) {
bme280_convert_unsigned_humidity_raw_to_q31(edata->reading.comp_humidity,
&out->readings[0].humidity);
out->shift = BME280_HUM_SHIFT;
} else {
return -ENODATA;
}
break;
default:
return -EINVAL;
}
*fit = 1;
return 1;
}
SENSOR_DECODER_API_DT_DEFINE() = {
.get_frame_count = bme280_decoder_get_frame_count,
.get_size_info = bme280_decoder_get_size_info,
.decode = bme280_decoder_decode,
};
int bme280_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder)
{
ARG_UNUSED(dev);
*decoder = &SENSOR_DECODER_NAME();
return 0;
}
``` | /content/code_sandbox/drivers/sensor/bosch/bme280/bme280_decoder.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,167 |
```c
/*
*
*/
/*
* Bus-specific functionality for BME280s accessed via SPI.
*/
#include <zephyr/logging/log.h>
#include "bme280.h"
#if BME280_BUS_SPI
LOG_MODULE_DECLARE(BME280, CONFIG_SENSOR_LOG_LEVEL);
static int bme280_bus_check_spi(const union bme280_bus *bus)
{
return spi_is_ready_dt(&bus->spi) ? 0 : -ENODEV;
}
static int bme280_reg_read_spi(const union bme280_bus *bus,
uint8_t start, uint8_t *buf, int size)
{
uint8_t addr;
const struct spi_buf tx_buf = {
.buf = &addr,
.len = 1
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
struct spi_buf rx_buf[2];
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = ARRAY_SIZE(rx_buf)
};
int i;
rx_buf[0].buf = NULL;
rx_buf[0].len = 1;
rx_buf[1].len = 1;
for (i = 0; i < size; i++) {
int ret;
addr = (start + i) | 0x80;
rx_buf[1].buf = &buf[i];
ret = spi_transceive_dt(&bus->spi, &tx, &rx);
if (ret) {
LOG_DBG("spi_transceive FAIL %d\n", ret);
return ret;
}
}
return 0;
}
static int bme280_reg_write_spi(const union bme280_bus *bus,
uint8_t reg, uint8_t val)
{
uint8_t cmd[] = { reg & 0x7F, val };
const struct spi_buf tx_buf = {
.buf = cmd,
.len = sizeof(cmd)
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
int ret;
ret = spi_write_dt(&bus->spi, &tx);
if (ret) {
LOG_DBG("spi_write FAIL %d\n", ret);
return ret;
}
return 0;
}
const struct bme280_bus_io bme280_bus_io_spi = {
.check = bme280_bus_check_spi,
.read = bme280_reg_read_spi,
.write = bme280_reg_write_spi,
};
#endif /* BME280_BUS_SPI */
``` | /content/code_sandbox/drivers/sensor/bosch/bme280/bme280_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 540 |
```unknown
# BMP280 temperature and pressure sensor configuration options
menuconfig BME280
bool "BME280/BMP280 sensor"
default y
depends on DT_HAS_BOSCH_BME280_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_BOSCH_BME280),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_BOSCH_BME280),spi)
select RTIO_WORKQ if SENSOR_ASYNC_API
help
Enable driver for BME280 I2C-based or SPI-based temperature and pressure sensor.
if BME280
choice
prompt "BME280 sampling mode"
default BME280_MODE_NORMAL
help
Select sampling mode. In normal mode continuous measurements are
performed, whereas in forced mode only single measurement is performed.
config BME280_MODE_NORMAL
bool "normal"
config BME280_MODE_FORCED
bool "forced"
endchoice
choice
prompt "BME280 temperature oversampling"
default BME280_TEMP_OVER_2X
help
Select temperature oversampling for the BME280 sensor. Higher values
lead to more accurate readings, but higher power consumption.
config BME280_TEMP_OVER_1X
bool "x1"
config BME280_TEMP_OVER_2X
bool "x2"
config BME280_TEMP_OVER_4X
bool "x4"
config BME280_TEMP_OVER_8X
bool "x8"
config BME280_TEMP_OVER_16X
bool "x16"
endchoice
choice
prompt "BME280 pressure oversampling"
default BME280_PRESS_OVER_16X
help
Select pressure oversampling for the BME280 sensor. Higher values
lead to more accurate readings, but higher power consumption.
config BME280_PRESS_OVER_1X
bool "x1"
config BME280_PRESS_OVER_2X
bool "x2"
config BME280_PRESS_OVER_4X
bool "x4"
config BME280_PRESS_OVER_8X
bool "x8"
config BME280_PRESS_OVER_16X
bool "x16"
endchoice
choice
prompt "BME280 humidity oversampling"
default BME280_HUMIDITY_OVER_16X
help
Select humidity oversampling for the BME280 sensor. Higher values
lead to more accurate readings, but higher power consumption.
config BME280_HUMIDITY_OVER_1X
bool "x1"
config BME280_HUMIDITY_OVER_2X
bool "x2"
config BME280_HUMIDITY_OVER_4X
bool "x4"
config BME280_HUMIDITY_OVER_8X
bool "x8"
config BME280_HUMIDITY_OVER_16X
bool "x16"
endchoice
choice
prompt "BME280 standby time"
default BME280_STANDBY_1000MS
help
Select standby time between measurements for the BME280 sensor.
Higher values lead to lower power consumption.
config BME280_STANDBY_05MS
bool "0.5ms"
config BME280_STANDBY_62MS
bool "62.5ms"
config BME280_STANDBY_125MS
bool "125ms"
config BME280_STANDBY_250MS
bool "250ms"
config BME280_STANDBY_500MS
bool "500ms"
config BME280_STANDBY_1000MS
bool "1000ms"
config BME280_STANDBY_2000MS
bool "2000ms BMP280 / 10ms BME280"
config BME280_STANDBY_4000MS
bool "4000ms BMP280 / 20ms BME280"
endchoice
choice
prompt "BME280 filter coefficient"
default BME280_FILTER_4
help
Select the filter coefficient for the BME280 sensor.
config BME280_FILTER_OFF
bool "filter off"
config BME280_FILTER_2
bool "2"
config BME280_FILTER_4
bool "4"
config BME280_FILTER_8
bool "8"
config BME280_FILTER_16
bool "16"
endchoice
endif # BME280
``` | /content/code_sandbox/drivers/sensor/bosch/bme280/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 921 |
```c
/* Bosch BMA4xx 3-axis accelerometer driver
*
*
*/
#define DT_DRV_COMPAT bosch_bma4xx
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include "bma4xx.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(bma4xx, CONFIG_SENSOR_LOG_LEVEL);
static int bma4xx_i2c_read_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct bma4xx_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->bus_cfg.i2c, reg_addr, value,
len);
}
static int bma4xx_i2c_write_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct bma4xx_config *cfg = dev->config;
return i2c_burst_write_dt(&cfg->bus_cfg.i2c, reg_addr, value,
len);
}
static int bma4xx_i2c_read_reg(const struct device *dev, uint8_t reg_addr,
uint8_t *value)
{
const struct bma4xx_config *cfg = dev->config;
return i2c_reg_read_byte_dt(&cfg->bus_cfg.i2c, reg_addr, value);
}
static int bma4xx_i2c_write_reg(const struct device *dev, uint8_t reg_addr,
uint8_t value)
{
const struct bma4xx_config *cfg = dev->config;
return i2c_reg_write_byte_dt(&cfg->bus_cfg.i2c, reg_addr, value);
}
static int bma4xx_i2c_update_reg(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value)
{
const struct bma4xx_config *cfg = dev->config;
return i2c_reg_update_byte_dt(&cfg->bus_cfg.i2c, reg_addr, mask, value);
}
static const struct bma4xx_hw_operations i2c_ops = {
.read_data = bma4xx_i2c_read_data,
.write_data = bma4xx_i2c_write_data,
.read_reg = bma4xx_i2c_read_reg,
.write_reg = bma4xx_i2c_write_reg,
.update_reg = bma4xx_i2c_update_reg,
};
int bma4xx_i2c_init(const struct device *dev)
{
struct bma4xx_data *data = dev->data;
const struct bma4xx_config *cfg = dev->config;
if (!device_is_ready(cfg->bus_cfg.i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
data->hw_ops = &i2c_ops;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/bosch/bma4xx/bma4xx_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 637 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BMA4XX_BMA4XX_H_
#define ZEPHYR_DRIVERS_SENSOR_BMA4XX_BMA4XX_H_
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.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) */
/*
* Register definitions
*/
#define BMA4XX_REG_CHIP_ID (0x00)
#define BMA4XX_REG_ERROR (0x02)
#define BMA4XX_REG_STATUS (0x03)
#define BMA4XX_REG_DATA_0 (0x0A)
#define BMA4XX_REG_DATA_1 (0x0B)
#define BMA4XX_REG_DATA_2 (0x0C)
#define BMA4XX_REG_DATA_3 (0x0D)
#define BMA4XX_REG_DATA_4 (0x0E)
#define BMA4XX_REG_DATA_5 (0x0F)
#define BMA4XX_REG_DATA_6 (0x10)
#define BMA4XX_REG_DATA_7 (0x11)
#define BMA4XX_REG_DATA_8 (0x12)
#define BMA4XX_REG_DATA_9 (0x13)
#define BMA4XX_REG_DATA_10 (0x14)
#define BMA4XX_REG_DATA_11 (0x15)
#define BMA4XX_REG_DATA_12 (0x16)
#define BMA4XX_REG_DATA_13 (0x17)
#define BMA4XX_REG_SENSORTIME_0 (0x18)
#define BMA4XX_REG_INT_STAT_0 (0x1C)
#define BMA4XX_REG_INT_STAT_1 (0x1D)
#define BMA4XX_REG_STEP_CNT_OUT_0 (0x1E)
#define BMA4XX_REG_HIGH_G_OUT (0x1F)
#define BMA4XX_REG_TEMPERATURE (0x22)
#define BMA4XX_REG_FIFO_LENGTH_0 (0x24)
#define BMA4XX_REG_FIFO_LENGTH_1 (0x25)
#define BMA4XX_REG_FIFO_DATA (0x26)
#define BMA4XX_REG_ACTIVITY_OUT (0x27)
#define BMA4XX_REG_ORIENTATION_OUT (0x28)
#define BMA4XX_REG_ACCEL_CONFIG (0x40)
#define BMA4XX_REG_ACCEL_RANGE (0x41)
#define BMA4XX_REG_AUX_CONFIG (0x44)
#define BMA4XX_REG_FIFO_DOWN (0x45)
#define BMA4XX_REG_FIFO_WTM_0 (0x46)
#define BMA4XX_REG_FIFO_CONFIG_0 (0x48)
#define BMA4XX_REG_FIFO_CONFIG_1 (0x49)
#define BMA4XX_REG_AUX_DEV_ID (0x4B)
#define BMA4XX_REG_AUX_IF_CONF (0x4C)
#define BMA4XX_REG_AUX_RD (0x4D)
#define BMA4XX_REG_AUX_WR (0x4E)
#define BMA4XX_REG_AUX_WR_DATA (0x4F)
#define BMA4XX_REG_INT1_IO_CTRL (0x53)
#define BMA4XX_REG_INT2_IO_CTRL (0x54)
#define BMA4XX_REG_INT_LATCH (0x55)
#define BMA4XX_REG_INT_MAP_1 (0x56)
#define BMA4XX_REG_INT_MAP_2 (0x57)
#define BMA4XX_REG_INT_MAP_DATA (0x58)
#define BMA4XX_REG_INIT_CTRL (0x59)
#define BMA4XX_REG_RESERVED_REG_5B (0x5B)
#define BMA4XX_REG_RESERVED_REG_5C (0x5C)
#define BMA4XX_REG_FEATURE_CONFIG (0x5E)
#define BMA4XX_REG_IF_CONFIG (0x6B)
#define BMA4XX_REG_ACC_SELF_TEST (0x6D)
#define BMA4XX_REG_NV_CONFIG (0x70)
#define BMA4XX_REG_OFFSET_0 (0x71)
#define BMA4XX_REG_OFFSET_1 (0x72)
#define BMA4XX_REG_OFFSET_2 (0x73)
#define BMA4XX_REG_POWER_CONF (0x7C)
#define BMA4XX_REG_POWER_CTRL (0x7D)
#define BMA4XX_REG_CMD (0x7E)
/*
* Bit positions and masks
*/
#define BMA4XX_BIT_ADV_PWR_SAVE BIT(0)
#define BMA4XX_MASK_ACC_CONF_ODR GENMASK(3, 0)
#define BMA4XX_MASK_ACC_CONF_BWP GENMASK(6, 4)
#define BMA4XX_SHIFT_ACC_CONF_BWP (4)
#define BMA4XX_MASK_ACC_RANGE GENMASK(1, 0)
#define BMA4XX_BIT_ACC_PERF_MODE BIT(7)
#define BMA4XX_BIT_ACC_EN BIT(2)
/* INT_STATUS_1 accelerometer data ready to interrupt */
#define BMA4XX_ACC_DRDY_INT BIT(7)
/* CMD: Clears all data in FIFO, does not change FIFO_CONFIG and FIFO_DOWNS register */
#define BMA4XX_CMD_FIFO_FLUSH (0xB0)
/* FIFO_CONFIG_1 enable: Store Accelerometer data in FIFO (all 3 axes) */
#define BMA4XX_FIFO_ACC_EN BIT(6)
/* Bandwidth parameters */
#define BMA4XX_BWP_OSR4_AVG1 (0x0)
#define BMA4XX_BWP_OSR2_AVG2 (0x1)
#define BMA4XX_BWP_NORM_AVG4 (0x2)
#define BMA4XX_BWP_CIC_AVG8 (0x3)
#define BMA4XX_BWP_RES_AVG16 (0x4)
#define BMA4XX_BWP_RES_AVG32 (0x5)
#define BMA4XX_BWP_RES_AVG64 (0x6)
#define BMA4XX_BWP_RES_AVG128 (0x7)
/* Full-scale ranges */
#define BMA4XX_RANGE_2G (0x0)
#define BMA4XX_RANGE_4G (0x1)
#define BMA4XX_RANGE_8G (0x2)
#define BMA4XX_RANGE_16G (0x3)
/* Output data rates (ODR) */
#define BMA4XX_ODR_RESERVED (0x00)
#define BMA4XX_ODR_0_78125 (0x01)
#define BMA4XX_ODR_1_5625 (0x02)
#define BMA4XX_ODR_3_125 (0x03)
#define BMA4XX_ODR_6_25 (0x04)
#define BMA4XX_ODR_12_5 (0x05)
#define BMA4XX_ODR_25 (0x06)
#define BMA4XX_ODR_50 (0x07)
#define BMA4XX_ODR_100 (0x08)
#define BMA4XX_ODR_200 (0x09)
#define BMA4XX_ODR_400 (0x0a)
#define BMA4XX_ODR_800 (0x0b)
#define BMA4XX_ODR_1600 (0x0c)
#define BMA4XX_ODR_3200 (0x0d)
#define BMA4XX_ODR_6400 (0x0e)
#define BMA4XX_ODR_12800 (0x0f)
/*
* BMA4xx commands
*/
#define BMA4XX_CMD_SOFT_RESET (0xB6)
#define BMA4XX_CHIP_ID_BMA422 (0x12)
#define BMA4XX_CHIP_ID_BMA423 (0x13)
/*
* Other constants
*/
/* Each bit count is 3.9mG or 3900uG */
#define BMA4XX_OFFSET_MICROG_PER_BIT (3900)
#define BMA4XX_OFFSET_MICROG_MIN (INT8_MIN * BMA4XX_OFFSET_MICROG_PER_BIT)
#define BMA4XX_OFFSET_MICROG_MAX (INT8_MAX * BMA4XX_OFFSET_MICROG_PER_BIT)
/* Range is -104C to 150C. Use shift of 8 (+/-256) */
#define BMA4XX_TEMP_SHIFT (8)
/* The total number of used registers specified in bma422 datasheet is 7E */
#define BMA4XX_NUM_REGS 0x7E
/*
* Types
*/
union bma4xx_bus_cfg {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
};
struct bma4xx_config {
int (*bus_init)(const struct device *dev);
const union bma4xx_bus_cfg bus_cfg;
};
/** Used to implement bus-specific R/W operations. See bma4xx_i2c.c and
* bma4xx_spi.c.
*/
struct bma4xx_hw_operations {
int (*read_data)(const struct device *dev, uint8_t reg_addr, uint8_t *value, uint8_t len);
int (*write_data)(const struct device *dev, uint8_t reg_addr, uint8_t *value, uint8_t len);
int (*read_reg)(const struct device *dev, uint8_t reg_addr, uint8_t *value);
int (*write_reg)(const struct device *dev, uint8_t reg_addr, uint8_t value);
int (*update_reg)(const struct device *dev, uint8_t reg_addr, uint8_t mask, uint8_t value);
};
struct bma4xx_data {
/** Current full-scale range setting as a register value */
uint8_t accel_fs_range;
/** Current bandwidth parameter (BWP) as a register value */
uint8_t accel_bwp;
/** Current output data rate as a register value */
uint8_t accel_odr;
/** Pointer to bus-specific I/O API */
const struct bma4xx_hw_operations *hw_ops;
/** Chip ID value stored in BMA4XX_REG_CHIP_ID */
uint8_t chip_id;
};
/*
* RTIO types
*/
struct bma4xx_decoder_header {
uint64_t timestamp;
uint8_t is_fifo: 1;
uint8_t accel_fs: 2;
uint8_t reserved: 5;
} __attribute__((__packed__));
struct bma4xx_encoded_data {
struct bma4xx_decoder_header header;
struct {
/** Set if `accel_xyz` has data */
uint8_t has_accel: 1;
/** Set if `temp` has data */
uint8_t has_temp: 1;
uint8_t reserved: 6;
} __attribute__((__packed__));
int16_t accel_xyz[3];
#ifdef CONFIG_BMA4XX_TEMPERATURE
int8_t temp;
#endif /* CONFIG_BMA4XX_TEMPERATURE */
};
int bma4xx_spi_init(const struct device *dev);
int bma4xx_i2c_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_BMA4XX_BMA4XX_H_ */
``` | /content/code_sandbox/drivers/sensor/bosch/bma4xx/bma4xx.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,547 |
```c
/* Bosch BMA4xx 3-axis accelerometer driver
*
*
*/
#define DT_DRV_COMPAT bosch_bma4xx
#include <zephyr/drivers/spi.h>
#include <zephyr/logging/log.h>
#include "bma4xx.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
LOG_MODULE_DECLARE(bma4xx, CONFIG_SENSOR_LOG_LEVEL);
static int bma4xx_spi_read_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
return -ENOTSUP;
}
static int bma4xx_spi_write_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
return -ENOTSUP;
}
static int bma4xx_spi_read_reg(const struct device *dev, uint8_t reg_addr,
uint8_t *value)
{
return -ENOTSUP;
}
static int bma4xx_spi_write_reg(const struct device *dev, uint8_t reg_addr,
uint8_t value)
{
return -ENOTSUP;
}
static int bma4xx_spi_update_reg(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value)
{
return -ENOTSUP;
}
static const struct bma4xx_hw_operations spi_ops = {
.read_data = bma4xx_spi_read_data,
.write_data = bma4xx_spi_write_data,
.read_reg = bma4xx_spi_read_reg,
.write_reg = bma4xx_spi_write_reg,
.update_reg = bma4xx_spi_update_reg,
};
int bma4xx_spi_init(const struct device *dev)
{
struct bma4xx_data *data = dev->data;
const struct bma4xx_config *cfg = dev->config;
if (!device_is_ready(cfg->bus_cfg.spi.bus)) {
LOG_ERR("SPI bus device is not ready");
return -ENODEV;
}
data->hw_ops = &spi_ops;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/bosch/bma4xx/bma4xx_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 449 |
```objective-c
/*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BMA4XX_BMA4XX_EMUL_H_
#define ZEPHYR_DRIVERS_SENSOR_BMA4XX_BMA4XX_EMUL_H_
#include <zephyr/drivers/emul.h>
#include "zephyr/dsp/types.h"
#ifdef __cplusplus
extern "C" {
#endif
/** Set the sensor's current acceleration reading. */
void bma4xx_emul_set_accel_data(const struct emul *target, q31_t value, int8_t shift, int8_t reg);
/**
* Return the current interrupt configuration.
*
* Provided pointers are out-parameters for the INT1_IO_CTRL register and
* whether interrupts are in latched mode. The return value is the current value
* of the INT_MAP_DATA register.
*/
uint8_t bma4xx_emul_get_interrupt_config(const struct emul *emul, uint8_t *int1_io_ctrl,
bool *latched_mode);
#ifdef __cplusplus
}
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_BMA4XX_BMA4XX_EMUL_H_ */
``` | /content/code_sandbox/drivers/sensor/bosch/bma4xx/bma4xx_emul.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 232 |
```c
/* Bosch BMA4xx 3-axis accelerometer driver
*
*
*/
#define DT_DRV_COMPAT bosch_bma4xx
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
#include <zephyr/rtio/work.h>
LOG_MODULE_REGISTER(bma4xx, CONFIG_SENSOR_LOG_LEVEL);
#include "bma4xx.h"
/**
* @brief Helper for converting m/s^2 offset values into register values
*/
static int bma4xx_offset_to_reg_val(const struct sensor_value *val, uint8_t *reg_val)
{
int32_t ug = sensor_ms2_to_ug(val);
if (ug < BMA4XX_OFFSET_MICROG_MIN || ug > BMA4XX_OFFSET_MICROG_MAX) {
return -ERANGE;
}
*reg_val = ug / BMA4XX_OFFSET_MICROG_PER_BIT;
return 0;
}
/**
* @brief Set the X, Y, or Z axis offsets.
*/
static int bma4xx_attr_set_offset(const struct device *dev, enum sensor_channel chan,
const struct sensor_value *val)
{
struct bma4xx_data *bma4xx = dev->data;
uint8_t reg_addr;
uint8_t reg_val[3];
int rc;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
reg_addr = BMA4XX_REG_OFFSET_0 + (chan - SENSOR_CHAN_ACCEL_X);
rc = bma4xx_offset_to_reg_val(val, ®_val[0]);
if (rc) {
return rc;
}
return bma4xx->hw_ops->write_reg(dev, reg_addr, reg_val[0]);
case SENSOR_CHAN_ACCEL_XYZ:
/* Expect val to point to an array of three sensor_values */
reg_addr = BMA4XX_REG_OFFSET_0;
for (int i = 0; i < 3; i++) {
rc = bma4xx_offset_to_reg_val(&val[i], ®_val[i]);
if (rc) {
return rc;
}
}
return bma4xx->hw_ops->write_data(dev, reg_addr, (uint8_t *)reg_val,
sizeof(reg_val));
default:
return -ENOTSUP;
}
}
static const uint32_t odr_to_reg_map[] = {
0, /* Invalid */
781250, /* 0.78125 Hz (25/32) => 0x1 */
1562500, /* 1.5625 Hz (25/16) => 0x2 */
3125000, /* 3.125 Hz (25/8) => 0x3 */
6250000, /* 6.25 Hz (25/4) => 0x4 */
12500000, /* 12.5 Hz (25/2) => 0x5 */
25000000, /* 25 Hz => 0x6 */
50000000, /* 50 Hz => 0x7*/
100000000, /* 100 Hz => 0x8*/
200000000, /* 200 Hz => 0x9*/
400000000, /* 400 Hz => 0xa*/
800000000, /* 800 Hz => 0xb*/
1600000000, /* 1600 Hz => 0xc*/
};
/**
* @brief Convert an ODR rate in Hz to a register value
*/
static int bma4xx_odr_to_reg(uint32_t microhertz, uint8_t *reg_val)
{
if (microhertz == 0) {
/* Illegal ODR value */
return -ERANGE;
}
for (uint8_t i = 0; i < ARRAY_SIZE(odr_to_reg_map); i++) {
if (microhertz <= odr_to_reg_map[i]) {
*reg_val = i;
return 0;
}
}
/* Requested ODR too high */
return -ERANGE;
}
/**
* Set the sensor's acceleration offset (per axis). Use bma4xx_commit_nvm() to save these
* offsets to nonvolatile memory so they are automatically set during power-on-reset.
*/
static int bma4xx_attr_set_odr(const struct device *dev, const struct sensor_value *val)
{
struct bma4xx_data *bma4xx = dev->data;
int status;
uint8_t reg_val;
/* Convert ODR Hz value to microhertz and round up to closest register setting */
status = bma4xx_odr_to_reg(val->val1 * 1000000 + val->val2, ®_val);
if (status < 0) {
return status;
}
status = bma4xx->hw_ops->update_reg(dev, BMA4XX_REG_ACCEL_CONFIG, BMA4XX_MASK_ACC_CONF_ODR,
reg_val);
if (status < 0) {
return status;
}
bma4xx->accel_odr = reg_val;
return 0;
}
static const uint32_t fs_to_reg_map[] = {
2000000, /* +/-2G => 0x0 */
4000000, /* +/-4G => 0x1 */
8000000, /* +/-8G => 0x2 */
16000000, /* +/-16G => 0x3 */
};
static int bma4xx_fs_to_reg(int32_t range_ug, uint8_t *reg_val)
{
if (range_ug == 0) {
/* Illegal value */
return -ERANGE;
}
range_ug = abs(range_ug);
for (uint8_t i = 0; i < 4; i++) {
if (range_ug <= fs_to_reg_map[i]) {
*reg_val = i;
return 0;
}
}
/* Requested range too high */
return -ERANGE;
}
/**
* Set the sensor's full-scale range
*/
static int bma4xx_attr_set_range(const struct device *dev, const struct sensor_value *val)
{
struct bma4xx_data *bma4xx = dev->data;
int status;
uint8_t reg_val;
/* Convert m/s^2 to micro-G's and find closest register setting */
status = bma4xx_fs_to_reg(sensor_ms2_to_ug(val), ®_val);
if (status < 0) {
return status;
}
status = bma4xx->hw_ops->update_reg(dev, BMA4XX_REG_ACCEL_RANGE, BMA4XX_MASK_ACC_RANGE,
reg_val);
if (status < 0) {
return status;
}
bma4xx->accel_fs_range = reg_val;
return 0;
}
/**
* Set the sensor's bandwidth parameter (one of BMA4XX_BWP_*)
*/
static int bma4xx_attr_set_bwp(const struct device *dev, const struct sensor_value *val)
{
/* Require that `val2` is unused, and that `val1` is in range of a valid BWP */
if (val->val2 || val->val1 < BMA4XX_BWP_OSR4_AVG1 || val->val1 > BMA4XX_BWP_RES_AVG128) {
return -EINVAL;
}
struct bma4xx_data *bma4xx = dev->data;
return bma4xx->hw_ops->update_reg(dev, BMA4XX_REG_ACCEL_CONFIG, BMA4XX_MASK_ACC_CONF_BWP,
(((uint8_t)val->val1) << BMA4XX_SHIFT_ACC_CONF_BWP));
}
/**
* @brief Implement the sensor API attribute set method.
*/
static int bma4xx_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return bma4xx_attr_set_odr(dev, val);
case SENSOR_ATTR_FULL_SCALE:
return bma4xx_attr_set_range(dev, val);
case SENSOR_ATTR_OFFSET:
return bma4xx_attr_set_offset(dev, chan, val);
case SENSOR_ATTR_CONFIGURATION:
/* Use for setting the bandwidth parameter (BWP) */
return bma4xx_attr_set_bwp(dev, val);
default:
return -ENOTSUP;
}
}
/**
* Internal device initialization function for both bus types.
*/
static int bma4xx_chip_init(const struct device *dev)
{
struct bma4xx_data *bma4xx = dev->data;
const struct bma4xx_config *cfg = dev->config;
int status;
/* Sensor bus-specific initialization */
status = cfg->bus_init(dev);
if (status) {
LOG_ERR("bus_init failed: %d", status);
return status;
}
/* Read Chip ID */
status = bma4xx->hw_ops->read_reg(dev, BMA4XX_REG_CHIP_ID, &bma4xx->chip_id);
if (status) {
LOG_ERR("could not read chip_id: %d", status);
return status;
}
LOG_DBG("chip_id is 0x%02x", bma4xx->chip_id);
if (bma4xx->chip_id != BMA4XX_CHIP_ID_BMA422) {
LOG_WRN("Driver tested for BMA422. Check for unintended operation.");
}
/* Issue soft reset command */
status = bma4xx->hw_ops->write_reg(dev, BMA4XX_REG_CMD, BMA4XX_CMD_SOFT_RESET);
if (status) {
LOG_ERR("Could not soft-reset chip: %d", status);
return status;
}
k_sleep(K_USEC(1000));
/* Default is: range = +/-4G, ODR = 100 Hz, BWP = "NORM_AVG4" */
bma4xx->accel_fs_range = BMA4XX_RANGE_4G;
bma4xx->accel_bwp = BMA4XX_BWP_NORM_AVG4;
bma4xx->accel_odr = BMA4XX_ODR_100;
/* Switch to performance power mode */
status = bma4xx->hw_ops->update_reg(dev, BMA4XX_REG_ACCEL_CONFIG, BMA4XX_BIT_ACC_PERF_MODE,
BMA4XX_BIT_ACC_PERF_MODE);
if (status) {
LOG_ERR("Could not enable performance power save mode: %d", status);
return status;
}
/* Enable accelerometer */
status = bma4xx->hw_ops->update_reg(dev, BMA4XX_REG_POWER_CTRL, BMA4XX_BIT_ACC_EN,
BMA4XX_BIT_ACC_EN);
if (status) {
LOG_ERR("Could not enable accel: %d", status);
return status;
}
return status;
}
/*
* Sample fetch and conversion
*/
/**
* @brief Read accelerometer data from the BMA4xx
*/
static int bma4xx_sample_fetch(const struct device *dev, int16_t *x, int16_t *y, int16_t *z)
{
struct bma4xx_data *bma4xx = dev->data;
uint8_t read_data[6];
int status;
/* Burst read regs DATA_8 through DATA_13, which holds the accel readings */
status = bma4xx->hw_ops->read_data(dev, BMA4XX_REG_DATA_8, (uint8_t *)&read_data,
BMA4XX_REG_DATA_13 - BMA4XX_REG_DATA_8 + 1);
if (status < 0) {
LOG_ERR("Cannot read accel data: %d", status);
return status;
}
LOG_DBG("Raw values [0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x]", read_data[0],
read_data[1], read_data[2], read_data[3], read_data[4], read_data[5]);
/* Values in accel_data[N] are left-aligned and will read 16x actual */
*x = ((int16_t)read_data[1] << 4) | FIELD_GET(GENMASK(7, 4), read_data[0]);
*y = ((int16_t)read_data[3] << 4) | FIELD_GET(GENMASK(7, 4), read_data[2]);
*z = ((int16_t)read_data[5] << 4) | FIELD_GET(GENMASK(7, 4), read_data[4]);
LOG_DBG("XYZ reg vals are %d, %d, %d", *x, *y, *z);
return 0;
}
#ifdef CONFIG_BMA4XX_TEMPERATURE
/**
* @brief Read temperature register on BMA4xx
*/
static int bma4xx_temp_fetch(const struct device *dev, int8_t *temp)
{
struct bma4xx_data *bma4xx = dev->data;
int status;
status = bma4xx->hw_ops->read_reg(dev, BMA4XX_REG_TEMPERATURE, temp);
if (status) {
LOG_ERR("could not read temp reg: %d", status);
return status;
}
LOG_DBG("temp reg val is %d", *temp);
return 0;
}
#endif
/*
* RTIO submit and encoding
*/
static void bma4xx_submit_one_shot(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe)
{
struct bma4xx_data *bma4xx = dev->data;
const struct sensor_read_config *cfg = iodev_sqe->sqe.iodev->data;
const struct sensor_chan_spec *const channels = cfg->channels;
const size_t num_channels = cfg->count;
uint32_t min_buf_len = sizeof(struct bma4xx_encoded_data);
struct bma4xx_encoded_data *edata;
uint8_t *buf;
uint32_t buf_len;
int rc;
/* Get the buffer for the frame, it may be allocated dynamically by the rtio context */
rc = rtio_sqe_rx_buf(iodev_sqe, min_buf_len, min_buf_len, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get a read buffer of size %u bytes", min_buf_len);
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
/* Prepare response */
edata = (struct bma4xx_encoded_data *)buf;
edata->header.is_fifo = false;
edata->header.accel_fs = bma4xx->accel_fs_range;
edata->header.timestamp = k_ticks_to_ns_floor64(k_uptime_ticks());
edata->has_accel = 0;
edata->has_temp = 0;
/* Determine what channels we need to fetch */
for (int i = 0; i < num_channels; i++) {
if (channels[i].chan_idx != 0) {
LOG_ERR("Only channel index 0 supported");
rtio_iodev_sqe_err(iodev_sqe, -ENOTSUP);
return;
}
switch (channels[i].chan_type) {
case SENSOR_CHAN_ALL:
edata->has_accel = 1;
#ifdef CONFIG_BMA4XX_TEMPERATURE
edata->has_temp = 1;
#endif /* CONFIG_BMA4XX_TEMPERATURE */
break;
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
edata->has_accel = 1;
break;
#ifdef CONFIG_BMA4XX_TEMPERATURE
case SENSOR_CHAN_DIE_TEMP:
edata->has_temp = 1;
break;
#endif /* CONFIG_BMA4XX_TEMPERATURE */
default:
LOG_ERR("Requested unsupported channel type %d, idx %d",
channels[i].chan_type, channels[i].chan_idx);
rtio_iodev_sqe_err(iodev_sqe, -ENOTSUP);
return;
}
}
if (edata->has_accel) {
rc = bma4xx_sample_fetch(dev, &edata->accel_xyz[0], &edata->accel_xyz[1],
&edata->accel_xyz[2]);
if (rc != 0) {
LOG_ERR("Failed to fetch accel samples");
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
}
#ifdef CONFIG_BMA4XX_TEMPERATURE
if (edata->has_temp) {
rc = bma4xx_temp_fetch(dev, &edata->temp);
if (rc != 0) {
LOG_ERR("Failed to fetch temp sample");
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
}
#endif /* CONFIG_BMA4XX_TEMPERATURE */
rtio_iodev_sqe_ok(iodev_sqe, 0);
}
static void bma4xx_submit_sync(struct rtio_iodev_sqe *iodev_sqe)
{
const struct sensor_read_config *cfg = iodev_sqe->sqe.iodev->data;
const struct device *dev = cfg->sensor;
/* TODO: Add streaming support */
if (!cfg->is_streaming) {
bma4xx_submit_one_shot(dev, iodev_sqe);
} else {
rtio_iodev_sqe_err(iodev_sqe, -ENOTSUP);
}
}
static void bma4xx_submit(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe)
{
struct rtio_work_req *req = rtio_work_req_alloc();
__ASSERT_NO_MSG(req);
rtio_work_req_submit(req, iodev_sqe, bma4xx_submit_sync);
}
/*
* RTIO decoder
*/
static int bma4xx_decoder_get_frame_count(const uint8_t *buffer, struct sensor_chan_spec ch,
uint16_t *frame_count)
{
const struct bma4xx_encoded_data *edata = (const struct bma4xx_encoded_data *)buffer;
const struct bma4xx_decoder_header *header = &edata->header;
if (ch.chan_idx != 0) {
return -ENOTSUP;
}
if (!header->is_fifo) {
switch (ch.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
*frame_count = edata->has_accel ? 1 : 0;
return 0;
case SENSOR_CHAN_DIE_TEMP:
*frame_count = edata->has_temp ? 1 : 0;
return 0;
default:
return -ENOTSUP;
}
return 0;
}
/* FIFO (streaming) mode operation is not yet supported */
return -ENOTSUP;
}
static int bma4xx_decoder_get_size_info(struct sensor_chan_spec ch, size_t *base_size,
size_t *frame_size)
{
switch (ch.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
*base_size = sizeof(struct sensor_three_axis_data);
*frame_size = sizeof(struct sensor_three_axis_sample_data);
return 0;
case SENSOR_CHAN_DIE_TEMP:
*base_size = sizeof(struct sensor_q31_data);
*frame_size = sizeof(struct sensor_q31_sample_data);
return 0;
default:
return -ENOTSUP;
}
}
static int bma4xx_get_shift(struct sensor_chan_spec ch, uint8_t accel_fs, int8_t *shift)
{
switch (ch.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
switch (accel_fs) {
case BMA4XX_RANGE_2G:
/* 2 G's = 19.62 m/s^2. Use shift of 5 (+/-32) */
*shift = 5;
return 0;
case BMA4XX_RANGE_4G:
*shift = 6;
return 0;
case BMA4XX_RANGE_8G:
*shift = 7;
return 0;
case BMA4XX_RANGE_16G:
*shift = 8;
return 0;
default:
return -EINVAL;
}
case SENSOR_CHAN_DIE_TEMP:
*shift = BMA4XX_TEMP_SHIFT;
return 0;
default:
return -EINVAL;
}
}
static void bma4xx_convert_raw_accel_to_q31(int16_t raw_val, q31_t *out)
{
/* The full calculation is (assuming floating math):
* value_ms2 = raw_value * range * 9.8065 / BIT(11)
* We can treat 'range * 9.8065' as a scale, the scale is calculated by first getting 1g
* represented as a q31 value with the same shift as our result:
* 1g = (9.8065 * BIT(31)) >> shift
* Next, we need to multiply it by our range in g, which for this driver is one of
* [2, 4, 8, 16] and maps to a left shift of [1, 2, 3, 4]:
* 1g <<= log2(range)
* Note we used a right shift by 'shift' and left shift by log2(range). 'shift' is
* [5, 6, 7, 8] for range values [2, 4, 8, 16] since it's the final shift in m/s2. It is
* calculated via:
* shift = ceil(log2(range * 9.8065))
* This means that we can shorten the above 1g alterations to:
* 1g = (1g >> ceil(log2(range * 9.8065))) << log2(range)
* For the range values [2, 4, 8, 16], the following is true:
* (x >> ceil(log2(range * 9.8065))) << log2(range)
* = x >> 4
* Since the range cancels out in the right and left shift, we've now reduced the following:
* range * 9.8065 = 9.8065 * BIT(31 - 4)
* All that's left is to divide by the bma4xx's maximum range BIT(11).
*/
const int64_t scale = (int64_t)(9.8065 * BIT64(31 - 4));
*out = CLAMP(((int64_t)raw_val * scale) >> 11, INT32_MIN, INT32_MAX);
}
#ifdef CONFIG_BMA4XX_TEMPERATURE
/**
* @brief Convert the 8-bit temp register value into a Q31 celsius value
*/
static void bma4xx_convert_raw_temp_to_q31(int8_t raw_val, q31_t *out)
{
/* Value of 0 equals 23 degrees C. Each bit count equals 1 degree C */
int64_t intermediate =
((int64_t)raw_val + 23) * ((int64_t)INT32_MAX + 1) / (1 << BMA4XX_TEMP_SHIFT);
*out = CLAMP(intermediate, INT32_MIN, INT32_MAX);
}
#endif /* CONFIG_BMA4XX_TEMPERATURE */
static int bma4xx_one_shot_decode(const uint8_t *buffer, struct sensor_chan_spec ch,
uint32_t *fit, uint16_t max_count, void *data_out)
{
const struct bma4xx_encoded_data *edata = (const struct bma4xx_encoded_data *)buffer;
const struct bma4xx_decoder_header *header = &edata->header;
int rc;
if (*fit != 0) {
return 0;
}
if (max_count == 0 || ch.chan_idx != 0) {
return -EINVAL;
}
switch (ch.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ: {
if (!edata->has_accel) {
return -ENODATA;
}
struct sensor_three_axis_data *out = (struct sensor_three_axis_data *)data_out;
out->header.base_timestamp_ns = edata->header.timestamp;
out->header.reading_count = 1;
rc = bma4xx_get_shift((struct sensor_chan_spec){.chan_type = SENSOR_CHAN_ACCEL_XYZ,
.chan_idx = 0},
header->accel_fs, &out->shift);
if (rc != 0) {
return -EINVAL;
}
bma4xx_convert_raw_accel_to_q31(edata->accel_xyz[0], &out->readings[0].x);
bma4xx_convert_raw_accel_to_q31(edata->accel_xyz[1], &out->readings[0].y);
bma4xx_convert_raw_accel_to_q31(edata->accel_xyz[2], &out->readings[0].z);
*fit = 1;
return 1;
}
#ifdef CONFIG_BMA4XX_TEMPERATURE
case SENSOR_CHAN_DIE_TEMP: {
if (!edata->has_temp) {
return -ENODATA;
}
struct sensor_q31_data *out = (struct sensor_q31_data *)data_out;
out->header.base_timestamp_ns = edata->header.timestamp;
out->header.reading_count = 1;
rc = bma4xx_get_shift(SENSOR_CHAN_DIE_TEMP, 0, &out->shift);
if (rc != 0) {
return -EINVAL;
}
bma4xx_convert_raw_temp_to_q31(edata->temp, &out->readings[0].temperature);
*fit = 1;
return 1;
}
#endif /* CONFIG_BMA4XX_TEMPERATURE */
default:
return -EINVAL;
}
}
static int bma4xx_decoder_decode(const uint8_t *buffer, struct sensor_chan_spec ch,
uint32_t *fit, uint16_t max_count,
void *data_out)
{
const struct bma4xx_decoder_header *header = (const struct bma4xx_decoder_header *)buffer;
if (header->is_fifo) {
/* FIFO (streaming) mode operation is not yet supported */
return -ENOTSUP;
}
return bma4xx_one_shot_decode(buffer, ch, fit, max_count, data_out);
}
SENSOR_DECODER_API_DT_DEFINE() = {
.get_frame_count = bma4xx_decoder_get_frame_count,
.get_size_info = bma4xx_decoder_get_size_info,
.decode = bma4xx_decoder_decode,
};
static int bma4xx_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder)
{
ARG_UNUSED(dev);
*decoder = &SENSOR_DECODER_NAME();
return 0;
}
/*
* Sensor driver API
*/
static const struct sensor_driver_api bma4xx_driver_api = {
.attr_set = bma4xx_attr_set,
.submit = bma4xx_submit,
.get_decoder = bma4xx_get_decoder,
};
/*
* Device instantiation macros
*/
/* Initializes a struct bma4xx_config for an instance on a SPI bus.
* SPI operation is not currently supported.
*/
#define BMA4XX_CONFIG_SPI(inst) \
{ \
.bus_cfg.spi = SPI_DT_SPEC_INST_GET(inst, 0, 0), .bus_init = &bma_spi_init, \
}
/* Initializes a struct bma4xx_config for an instance on an I2C bus. */
#define BMA4XX_CONFIG_I2C(inst) \
{ \
.bus_cfg.i2c = I2C_DT_SPEC_INST_GET(inst), .bus_init = &bma4xx_i2c_init, \
}
/*
* Main instantiation macro, which selects the correct bus-specific
* instantiation macros for the instance.
*/
#define BMA4XX_DEFINE(inst) \
static struct bma4xx_data bma4xx_data_##inst; \
static const struct bma4xx_config bma4xx_config_##inst = COND_CODE_1( \
DT_INST_ON_BUS(inst, spi), (BMA4XX_CONFIG_SPI(inst)), (BMA4XX_CONFIG_I2C(inst))); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, bma4xx_chip_init, NULL, &bma4xx_data_##inst, \
&bma4xx_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &bma4xx_driver_api);
DT_INST_FOREACH_STATUS_OKAY(BMA4XX_DEFINE)
``` | /content/code_sandbox/drivers/sensor/bosch/bma4xx/bma4xx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,353 |
```c
/*
*/
#include "bma4xx.h"
#include "bma4xx_emul.h"
#include "zephyr/sys/util.h"
#include <errno.h>
#include <stdint.h>
#include <string.h>
#include <zephyr/device.h>
#include <zephyr/drivers/emul.h>
#include <zephyr/drivers/emul_sensor.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/i2c_emul.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/math_extras.h>
#define DT_DRV_COMPAT bosch_bma4xx
LOG_MODULE_REGISTER(bma4xx_emul, CONFIG_SENSOR_LOG_LEVEL);
struct bma4xx_emul_data {
/* Holds register data. */
uint8_t regs[BMA4XX_NUM_REGS];
};
struct bma4xx_emul_cfg {
};
void bma4xx_emul_set_reg(const struct emul *target, uint8_t reg_addr, const uint8_t *val,
size_t count)
{
struct bma4xx_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr + count <= BMA4XX_NUM_REGS);
memcpy(data->regs + reg_addr, val, count);
}
void bma4xx_emul_get_reg(const struct emul *target, uint8_t reg_addr, uint8_t *val, size_t count)
{
struct bma4xx_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr + count <= BMA4XX_NUM_REGS);
memcpy(val, data->regs + reg_addr, count);
}
uint8_t bma4xx_emul_get_interrupt_config(const struct emul *target, uint8_t *int1_io_ctrl,
bool *latched_mode)
{
struct bma4xx_emul_data *data = target->data;
*int1_io_ctrl = data->regs[BMA4XX_REG_INT1_IO_CTRL];
*latched_mode = data->regs[BMA4XX_REG_INT_LATCH];
return data->regs[BMA4XX_REG_INT_MAP_DATA];
}
static int bma4xx_emul_read_byte(const struct emul *target, int reg, uint8_t *val, int bytes)
{
bma4xx_emul_get_reg(target, reg, val, bytes);
return 0;
}
static int bma4xx_emul_write_byte(const struct emul *target, int reg, uint8_t val, int bytes)
{
struct bma4xx_emul_data *data = target->data;
if (bytes != 1) {
LOG_ERR("multi-byte writes are not supported");
return -ENOTSUP;
}
switch (reg) {
case BMA4XX_REG_ACCEL_CONFIG:
if ((val & 0xF0) != 0xA0) {
LOG_ERR("unsupported acc_bwp/acc_perf_mode: %#x", val);
return -EINVAL;
}
data->regs[reg] = val & GENMASK(1, 0);
return 0;
case BMA4XX_REG_ACCEL_RANGE:
if ((val & GENMASK(1, 0)) != val) {
LOG_ERR("reserved bits set in ACC_RANGE write: %#x", val);
return -EINVAL;
}
data->regs[reg] = val;
return 0;
case BMA4XX_REG_FIFO_CONFIG_1:
if (val & ~BMA4XX_FIFO_ACC_EN) {
LOG_ERR("unsupported bits set in FIFO_CONFIG_1"
" write: %#x",
val);
return -EINVAL;
}
data->regs[reg] = (val & BMA4XX_FIFO_ACC_EN) != 0;
return 0;
case BMA4XX_REG_INT1_IO_CTRL:
data->regs[reg] = val;
return 0;
case BMA4XX_REG_INT_LATCH:
if ((val & ~1) != 0) {
LOG_ERR("reserved bits set in INT_LATCH: %#x", val);
return -EINVAL;
}
data->regs[reg] = (val & 1) == 1;
return 0;
case BMA4XX_REG_INT_MAP_DATA:
data->regs[reg] = val;
return 0;
case BMA4XX_REG_NV_CONFIG:
if (val & GENMASK(7, 4)) {
LOG_ERR("reserved bits set in NV_CONF write: %#x", val);
return -EINVAL;
}
data->regs[reg] = val;
return 0;
case BMA4XX_REG_OFFSET_0:
case BMA4XX_REG_OFFSET_1:
case BMA4XX_REG_OFFSET_2:
data->regs[reg] = val;
return 0;
case BMA4XX_REG_POWER_CTRL:
if ((val & ~BMA4XX_BIT_ACC_EN) != 0) {
LOG_ERR("unhandled bits in POWER_CTRL write: %#x", val);
return -ENOTSUP;
}
data->regs[reg] = (val & BMA4XX_BIT_ACC_EN) != 0;
return 0;
case BMA4XX_REG_CMD:
if (val == BMA4XX_CMD_FIFO_FLUSH) { /* fifo_flush */
data->regs[BMA4XX_REG_FIFO_DATA] = 0;
data->regs[BMA4XX_REG_FIFO_LENGTH_0] = 0;
data->regs[BMA4XX_REG_FIFO_LENGTH_1] = 0;
return 0;
}
break;
}
LOG_WRN("unhandled I2C write to register %#x", reg);
return -ENOTSUP;
}
static int bma4xx_emul_init(const struct emul *target, const struct device *parent)
{
struct bma4xx_emul_data *data = target->data;
data->regs[BMA4XX_REG_CHIP_ID] = BMA4XX_CHIP_ID_BMA422;
data->regs[BMA4XX_REG_ACCEL_RANGE] = BMA4XX_RANGE_4G;
return 0;
}
static int bma4xx_emul_transfer_i2c(const struct emul *target, struct i2c_msg *msgs, int num_msgs,
int addr)
{
__ASSERT_NO_MSG(msgs && num_msgs);
if (num_msgs != 2) {
return 0;
}
i2c_dump_msgs_rw(target->dev, msgs, num_msgs, addr, false);
if (msgs->flags & I2C_MSG_READ) {
LOG_ERR("Unexpected read");
return -EIO;
}
if (msgs->len != 1) {
LOG_ERR("Unexpected msg0 length %d", msgs->len);
return -EIO;
}
uint32_t reg = msgs->buf[0];
msgs++;
if (msgs->flags & I2C_MSG_READ) {
/* Reads from regs in target->data to msgs->buf */
bma4xx_emul_read_byte(target, reg, msgs->buf, msgs->len);
} else {
/* Writes msgs->buf[0] to regs in target->data */
bma4xx_emul_write_byte(target, reg, msgs->buf[0], msgs->len);
}
return 0;
};
void bma4xx_emul_set_accel_data(const struct emul *target, q31_t value, int8_t shift, int8_t reg)
{
struct bma4xx_emul_data *data = target->data;
/* floor(9.80665 * 2^(314)) q31_t in (-2^4, 2^4) => range_g = shift of 4 */
int64_t g = 1316226282;
int64_t range_g = 4;
int64_t intermediate, unshifted;
int16_t reg_val;
/* 0x00 -> +/-2g; 0x01 -> +/-4g; 0x02 -> +/-8g; 0x03 -> +/- 16g; */
int64_t accel_range = (2 << data->regs[BMA4XX_REG_ACCEL_RANGE]);
unshifted = shift < 0 ? ((int64_t)value >> -shift) : ((int64_t)value << shift);
intermediate = (unshifted * BIT(11)) / (g << range_g);
intermediate /= accel_range;
reg_val = CLAMP(intermediate, -2048, 2047);
/* lsb register uses top 12 of 16 bits to hold value so shift by 4 to fill it */
data->regs[reg] = FIELD_GET(GENMASK(3, 0), reg_val) << 4;
data->regs[reg + 1] = FIELD_GET(GENMASK(11, 4), reg_val);
}
static int bma4xx_emul_backend_set_channel(const struct emul *target, struct sensor_chan_spec ch,
const q31_t *value, int8_t shift)
{
if (!target || !target->data) {
return -EINVAL;
}
struct bma4xx_emul_data *data = target->data;
switch (ch.chan_type) {
case SENSOR_CHAN_ACCEL_X:
bma4xx_emul_set_accel_data(target, value[0], shift, BMA4XX_REG_DATA_8);
break;
case SENSOR_CHAN_ACCEL_Y:
bma4xx_emul_set_accel_data(target, value[0], shift, BMA4XX_REG_DATA_10);
break;
case SENSOR_CHAN_ACCEL_Z:
bma4xx_emul_set_accel_data(target, value[0], shift, BMA4XX_REG_DATA_12);
break;
case SENSOR_CHAN_ACCEL_XYZ:
bma4xx_emul_set_accel_data(target, value[0], shift, BMA4XX_REG_DATA_8);
bma4xx_emul_set_accel_data(target, value[1], shift, BMA4XX_REG_DATA_10);
bma4xx_emul_set_accel_data(target, value[2], shift, BMA4XX_REG_DATA_12);
default:
return -ENOTSUP;
}
/* Set data ready flag */
data->regs[BMA4XX_REG_INT_STAT_1] |= BMA4XX_ACC_DRDY_INT;
return 0;
}
static int bma4xx_emul_backend_get_sample_range(const struct emul *target,
struct sensor_chan_spec ch, q31_t *lower,
q31_t *upper, q31_t *epsilon, int8_t *shift)
{
if (!lower || !upper || !epsilon || !shift) {
return -EINVAL;
}
switch (ch.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
break;
default:
return -ENOTSUP;
}
struct bma4xx_emul_data *data = target->data;
switch (data->regs[BMA4XX_REG_ACCEL_RANGE]) {
case BMA4XX_RANGE_2G:
*shift = 5;
*upper = (q31_t)(2 * 9.80665 * BIT(31 - 5));
*lower = -*upper;
/* (1 << (31 - shift) >> 12) * 2 (where 2 comes from 2g range) */
*epsilon = BIT(31 - 5 - 12 + 1);
break;
case BMA4XX_RANGE_4G:
*shift = 6;
*upper = (q31_t)(4 * 9.80665 * BIT(31 - 6));
*lower = -*upper;
/* (1 << (31 - shift) >> 12) * 4 (where 4 comes from 4g range) */
*epsilon = BIT(31 - 6 - 12 + 2);
break;
case BMA4XX_RANGE_8G:
*shift = 7;
*upper = (q31_t)(8 * 9.80665 * BIT(31 - 7));
*lower = -*upper;
/* (1 << (31 - shift) >> 12) * 8 (where 8 comes from 8g range) */
*epsilon = BIT(31 - 7 - 12 + 3);
break;
case BMA4XX_RANGE_16G:
*shift = 8;
*upper = (q31_t)(16 * 9.80665 * BIT(31 - 8));
*lower = -*upper;
/* (1 << (31 - shift) >> 12) * 16 (where 16 comes from 16g range) */
*epsilon = BIT(31 - 8 - 12 + 4);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct emul_sensor_driver_api bma4xx_emul_sensor_driver_api = {
.set_channel = bma4xx_emul_backend_set_channel,
.get_sample_range = bma4xx_emul_backend_get_sample_range,
};
static struct i2c_emul_api bma4xx_emul_api_i2c = {
.transfer = bma4xx_emul_transfer_i2c,
};
#define INIT_BMA4XX(n) \
static struct bma4xx_emul_data bma4xx_emul_data_##n = {}; \
static const struct bma4xx_emul_cfg bma4xx_emul_cfg_##n = {}; \
EMUL_DT_INST_DEFINE(n, bma4xx_emul_init, &bma4xx_emul_data_##n, &bma4xx_emul_cfg_##n, \
&bma4xx_emul_api_i2c, &bma4xx_emul_sensor_driver_api);
DT_INST_FOREACH_STATUS_OKAY(INIT_BMA4XX)
``` | /content/code_sandbox/drivers/sensor/bosch/bma4xx/bma4xx_emul.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,024 |
```unknown
# BMA4XX 3-axis accelerometer config options
#
#
config BMA4XX
bool "BMA4XX 3-axis acceleration sensor"
default y
depends on DT_HAS_BOSCH_BMA4XX_ENABLED
depends on SENSOR_ASYNC_API
select I2C
select RTIO_WORKQ
help
Enable driver for Bosch BMA4XX (I2C-based)
config BMA4XX_TEMPERATURE
bool "Allow reading the BMA4XX die temperature"
default n
depends on BMA4XX
help
Allow reading the BMA4xx's on-chip temperature sensor. This creates
extra bus activity and increases code size.
config EMUL_BMA4XX
bool "Emulator for the BMA4XX"
default y
depends on BMA4XX
depends on EMUL
help
Enable the hardware emulator for the BMA4XX. Doing so allows exercising
sensor APIs for this sensor in native_sim and qemu.
``` | /content/code_sandbox/drivers/sensor/bosch/bma4xx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 212 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "bmc150_magn.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(BMC150_MAGN, CONFIG_SENSOR_LOG_LEVEL);
static inline void setup_drdy(const struct device *dev,
bool enable)
{
const struct bmc150_magn_config *const cfg =
dev->config;
gpio_pin_interrupt_configure_dt(&cfg->int_gpio,
enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE);
}
int bmc150_magn_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config * const config =
dev->config;
uint8_t state;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
#if defined(CONFIG_BMC150_MAGN_TRIGGER_DRDY)
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,
BMC150_MAGN_REG_INT_DRDY,
BMC150_MAGN_MASK_DRDY_EN,
state << BMC150_MAGN_SHIFT_DRDY_EN)
< 0) {
LOG_DBG("failed to set DRDY interrupt");
return -EIO;
}
setup_drdy(dev, true);
}
#endif
return 0;
}
static void bmc150_magn_gpio_drdy_callback(const struct device *dev,
struct gpio_callback *cb,
uint32_t pins)
{
struct bmc150_magn_data *data =
CONTAINER_OF(cb, struct bmc150_magn_data, gpio_cb);
ARG_UNUSED(pins);
setup_drdy(data->dev, false);
k_sem_give(&data->sem);
}
static void bmc150_magn_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct bmc150_magn_data *data = p1;
const struct bmc150_magn_config *config = data->dev->config;
uint8_t reg_val;
while (1) {
k_sem_take(&data->sem, K_FOREVER);
while (i2c_reg_read_byte_dt(&config->i2c,
BMC150_MAGN_REG_INT_STATUS,
®_val) < 0) {
LOG_DBG("failed to clear data ready interrupt");
}
if (data->handler_drdy) {
data->handler_drdy(data->dev, data->trigger_drdy);
}
setup_drdy(data->dev, true);
}
}
static int bmc150_magn_set_drdy_polarity(const struct device *dev, int state)
{
const struct bmc150_magn_config *config = dev->config;
if (state) {
state = 1;
}
return i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_INT_DRDY,
BMC150_MAGN_MASK_DRDY_DR_POLARITY,
state << BMC150_MAGN_SHIFT_DRDY_DR_POLARITY);
}
int bmc150_magn_init_interrupt(const struct device *dev)
{
const struct bmc150_magn_config * const config =
dev->config;
struct bmc150_magn_data *data = dev->data;
#if defined(CONFIG_BMC150_MAGN_TRIGGER_DRDY)
if (bmc150_magn_set_drdy_polarity(dev, 0) < 0) {
LOG_DBG("failed to set DR polarity");
return -EIO;
}
if (i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_INT_DRDY,
BMC150_MAGN_MASK_DRDY_EN,
0 << BMC150_MAGN_SHIFT_DRDY_EN) < 0) {
LOG_DBG("failed to set data ready interrupt enabled bit");
return -EIO;
}
#endif
data->handler_drdy = NULL;
k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_BMC150_MAGN_TRIGGER_THREAD_STACK,
bmc150_magn_thread_main,
data, 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_INT_EDGE_TO_ACTIVE);
gpio_init_callback(&data->gpio_cb,
bmc150_magn_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 -EIO;
}
data->dev = dev;
return 0;
}
``` | /content/code_sandbox/drivers/sensor/bosch/bmc150_magn/bmc150_magn_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,160 |
```unknown
# BMC150 magnetometer sensor configuration options
menuconfig BMC150_MAGN
bool "BMC150_MAGN I2C Magnetometer Chip"
default y
depends on DT_HAS_BOSCH_BMC150_MAGN_ENABLED
select I2C
help
Enable driver for BMC150 I2C-based magnetometer sensor.
if BMC150_MAGN
menu "Attributes"
choice
prompt "Default preset"
default BMC150_MAGN_PRESET_REGULAR
help
Specify the default preset (x/y oversampling, z oversampling, sampling
frequency).
config BMC150_MAGN_PRESET_LOW_POWER
bool "Low power (3, 3, 10)"
config BMC150_MAGN_PRESET_REGULAR
bool "Regular (9, 15, 10)"
config BMC150_MAGN_PRESET_ENHANCED_REGULAR
bool "Enhanced regular (15, 27, 10)"
config BMC150_MAGN_PRESET_HIGH_ACCURACY
bool "High accuracy (47, 83, 20)"
endchoice
config BMC150_MAGN_SAMPLING_RATE_RUNTIME
bool "Dynamic sampling rate"
help
Enable alteration of sampling rate attribute at runtime.
config BMC150_MAGN_SAMPLING_REP_XY
bool "Dynamic XY oversampling"
help
Enable alteration of XY oversampling at runtime.
config BMC150_MAGN_SAMPLING_REP_Z
bool "Dynamic Z oversampling"
help
Enable alteration of Z oversampling at runtime.
endmenu
config BMC150_MAGN_TRIGGER
bool "Triggers"
depends on GPIO
help
Enable triggers for BMC150 magnetometer
config BMC150_MAGN_TRIGGER_THREAD_STACK
int "Thread stack size"
depends on BMC150_MAGN_TRIGGER
default 1024
help
Specify the internal thread stack size.
config BMC150_MAGN_TRIGGER_DRDY
bool "Data ready trigger"
depends on BMC150_MAGN_TRIGGER
help
Enable data ready interrupt for BMC150 magnetometer
endif # BMC150_MAGN
``` | /content/code_sandbox/drivers/sensor/bosch/bmc150_magn/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 423 |
```objective-c
/* sensor_bmc150_magn.h - header file for BMC150 magnetometer sensor driver */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BMC150_MAGN_BMC150_MAGN_H_
#define ZEPHYR_DRIVERS_SENSOR_BMC150_MAGN_BMC150_MAGN_H_
#include <zephyr/types.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#define BMC150_MAGN_REG_CHIP_ID 0x40
#define BMC150_MAGN_CHIP_ID_VAL 0x32
#define BMC150_MAGN_REG_X_L 0x42
#define BMC150_MAGN_REG_X_M 0x43
#define BMC150_MAGN_REG_Y_L 0x44
#define BMC150_MAGN_REG_Y_M 0x45
#define BMC150_MAGN_SHIFT_XY_L 3
#define BMC150_MAGN_REG_Z_L 0x46
#define BMC150_MAGN_REG_Z_M 0x47
#define BMC150_MAGN_SHIFT_Z_L 1
#define BMC150_MAGN_REG_RHALL_L 0x48
#define BMC150_MAGN_REG_RHALL_M 0x49
#define BMC150_MAGN_SHIFT_RHALL_L 2
#define BMC150_MAGN_REG_INT_STATUS 0x4A
#define BMC150_MAGN_REG_POWER 0x4B
#define BMC150_MAGN_MASK_POWER_CTL BIT(0)
#define BMC150_MAGN_REG_OPMODE_ODR 0x4C
#define BMC150_MAGN_MASK_OPMODE (BIT(2) | BIT(1))
#define BMC150_MAGN_SHIFT_OPMODE 1
#define BMC150_MAGN_MODE_NORMAL 0x00
#define BMC150_MAGN_MODE_FORCED 0x01
#define BMC150_MAGN_MODE_SLEEP 0x03
#define BMC150_MAGN_MASK_ODR (BIT(5) | BIT(4) | BIT(3))
#define BMC150_MAGN_SHIFT_ODR 3
#define BMC150_MAGN_REG_LOW_THRESH 0x4F
#define BMC150_MAGN_REG_HIGH_THRESH 0x50
#define BMC150_MAGN_REG_REP_XY 0x51
#define BMC150_MAGN_REG_REP_Z 0x52
#define BMC150_MAGN_REG_REP_DATAMASK 0xFF
#define BMC150_MAGN_REG_TRIM_START 0x5D
#define BMC150_MAGN_REG_TRIM_END 0x71
#define BMC150_MAGN_XY_OVERFLOW_VAL -4096
#define BMC150_MAGN_Z_OVERFLOW_VAL -16384
#define BMC150_MAGN_REGVAL_TO_REPXY(regval) (((regval) * 2) + 1)
#define BMC150_MAGN_REGVAL_TO_REPZ(regval) ((regval) + 1)
#define BMC150_MAGN_REPXY_TO_REGVAL(rep) (((rep) - 1) / 2)
#define BMC150_MAGN_REPZ_TO_REGVAL(rep) ((rep) - 1)
#define BMC150_MAGN_REG_INT 0x4D
#define BMC150_MAGN_REG_INT_DRDY 0x4E
#define BMC150_MAGN_MASK_DRDY_EN BIT(7)
#define BMC150_MAGN_SHIFT_DRDY_EN 7
#define BMC150_MAGN_MASK_DRDY_INT3 BIT(6)
#define BMC150_MAGN_MASK_DRDY_Z_EN BIT(5)
#define BMC150_MAGN_MASK_DRDY_Y_EN BIT(4)
#define BMC150_MAGN_MASK_DRDY_X_EN BIT(3)
#define BMC150_MAGN_MASK_DRDY_DR_POLARITY BIT(2)
#define BMC150_MAGN_SHIFT_DRDY_DR_POLARITY 2
#define BMC150_MAGN_MASK_DRDY_LATCHING BIT(1)
#define BMC150_MAGN_MASK_DRDY_INT3_POLARITY BIT(0)
#if defined(CONFIG_BMC150_MAGN_SAMPLING_REP_XY) || \
defined(CONFIG_BMC150_MAGN_SAMPLING_REP_Z)
#define BMC150_MAGN_SET_ATTR_REP
#endif
#if defined(CONFIG_BMC150_MAGN_SAMPLING_RATE_RUNTIME) || \
defined(BMC150_MAGN_SET_ATTR_REP)
#define BMC150_MAGN_SET_ATTR
#endif
struct bmc150_magn_config {
struct i2c_dt_spec i2c;
#if defined(CONFIG_BMC150_MAGN_TRIGGER_DRDY)
struct gpio_dt_spec int_gpio;
#endif
};
struct bmc150_magn_trim_regs {
int8_t x1;
int8_t y1;
uint16_t reserved1;
uint8_t reserved2;
int16_t z4;
int8_t x2;
int8_t y2;
uint16_t reserved3;
int16_t z2;
uint16_t z1;
uint16_t xyz1;
int16_t z3;
int8_t xy2;
uint8_t xy1;
} __packed;
struct bmc150_magn_data {
struct k_sem sem;
#if defined(CONFIG_BMC150_MAGN_TRIGGER)
K_KERNEL_STACK_MEMBER(thread_stack,
CONFIG_BMC150_MAGN_TRIGGER_THREAD_STACK);
struct k_thread thread;
#endif
#if defined(CONFIG_BMC150_MAGN_TRIGGER_DRDY)
const struct device *gpio_drdy;
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *trigger_drdy;
sensor_trigger_handler_t handler_drdy;
#endif
struct bmc150_magn_trim_regs tregs;
int rep_xy, rep_z, odr, max_odr;
int sample_x, sample_y, sample_z;
};
enum bmc150_magn_power_modes {
BMC150_MAGN_POWER_MODE_SUSPEND,
BMC150_MAGN_POWER_MODE_SLEEP,
BMC150_MAGN_POWER_MODE_NORMAL,
};
enum bmc150_magn_presets {
LOW_POWER_PRESET,
REGULAR_PRESET,
ENHANCED_REGULAR_PRESET,
HIGH_ACCURACY_PRESET
};
#if defined(CONFIG_BMC150_MAGN_PRESET_LOW_POWER)
#define BMC150_MAGN_DEFAULT_PRESET LOW_POWER_PRESET
#elif defined(CONFIG_BMC150_MAGN_PRESET_REGULAR)
#define BMC150_MAGN_DEFAULT_PRESET REGULAR_PRESET
#elif defined(CONFIG_BMC150_MAGN_PRESET_ENHANCED_REGULAR)
#define BMC150_MAGN_DEFAULT_PRESET ENHANCED_REGULAR_PRESET
#elif defined(CONFIG_BMC150_MAGN_PRESET_HIGH_ACCURACY)
#define BMC150_MAGN_DEFAULT_PRESET HIGH_ACCURACY_PRESET
#endif
enum bmc150_magn_axis {
BMC150_MAGN_AXIS_X,
BMC150_MAGN_AXIS_Y,
BMC150_MAGN_AXIS_Z,
BMC150_MAGN_RHALL,
BMC150_MAGN_AXIS_XYZ_MAX = BMC150_MAGN_RHALL,
BMC150_MAGN_AXIS_XYZR_MAX,
};
#if defined(CONFIG_BMC150_MAGN_TRIGGER)
int bmc150_magn_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int bmc150_magn_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_BMC150_MAGN_BMC150_MAGN_H_ */
``` | /content/code_sandbox/drivers/sensor/bosch/bmc150_magn/bmc150_magn.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,553 |
```c
/* bmc150_magn.c - Driver for Bosch BMC150 magnetometer sensor */
/*
*
* This code is based on bmm050.c from:
* path_to_url
*
*/
#define DT_DRV_COMPAT bosch_bmc150_magn
#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 "bmc150_magn.h"
LOG_MODULE_REGISTER(BMC150_MAGN, CONFIG_SENSOR_LOG_LEVEL);
static const struct {
int freq;
uint8_t reg_val;
} bmc150_magn_samp_freq_table[] = { {2, 0x01},
{6, 0x02},
{8, 0x03},
{10, 0x00},
{15, 0x04},
{20, 0x05},
{25, 0x06},
{30, 0x07} };
static const struct bmc150_magn_preset {
uint8_t rep_xy;
uint8_t rep_z;
uint8_t odr;
} bmc150_magn_presets_table[] = {
[LOW_POWER_PRESET] = {3, 3, 10},
[REGULAR_PRESET] = {9, 15, 10},
[ENHANCED_REGULAR_PRESET] = {15, 27, 10},
[HIGH_ACCURACY_PRESET] = {47, 83, 20}
};
static int bmc150_magn_set_power_mode(const struct device *dev,
enum bmc150_magn_power_modes mode,
int state)
{
const struct bmc150_magn_config *config = dev->config;
switch (mode) {
case BMC150_MAGN_POWER_MODE_SUSPEND:
if (i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_POWER,
BMC150_MAGN_MASK_POWER_CTL,
!state) < 0) {
return -EIO;
}
k_busy_wait(USEC_PER_MSEC * 5U);
return 0;
case BMC150_MAGN_POWER_MODE_SLEEP:
return i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_OPMODE_ODR,
BMC150_MAGN_MASK_OPMODE,
BMC150_MAGN_MODE_SLEEP <<
BMC150_MAGN_SHIFT_OPMODE);
break;
case BMC150_MAGN_POWER_MODE_NORMAL:
return i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_OPMODE_ODR,
BMC150_MAGN_MASK_OPMODE,
BMC150_MAGN_MODE_NORMAL <<
BMC150_MAGN_SHIFT_OPMODE);
break;
}
return -ENOTSUP;
}
static int bmc150_magn_set_odr(const struct device *dev, uint8_t val)
{
const struct bmc150_magn_config *config = dev->config;
uint8_t i;
for (i = 0U; i < ARRAY_SIZE(bmc150_magn_samp_freq_table); ++i) {
if (val <= bmc150_magn_samp_freq_table[i].freq) {
return i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_OPMODE_ODR,
BMC150_MAGN_MASK_ODR,
bmc150_magn_samp_freq_table[i].reg_val
<< BMC150_MAGN_SHIFT_ODR);
}
}
return -ENOTSUP;
}
#if defined(BMC150_MAGN_SET_ATTR)
static int bmc150_magn_read_rep_xy(const struct device *dev)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config *config = dev->config;
uint8_t reg_val;
if (i2c_reg_read_byte_dt(&config->i2c,
BMC150_MAGN_REG_REP_XY, ®_val) < 0) {
return -EIO;
}
data->rep_xy = BMC150_MAGN_REGVAL_TO_REPXY((int)(reg_val));
return 0;
}
static int bmc150_magn_read_rep_z(const struct device *dev)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config *config = dev->config;
uint8_t reg_val;
if (i2c_reg_read_byte_dt(&config->i2c,
BMC150_MAGN_REG_REP_Z, ®_val) < 0) {
return -EIO;
}
data->rep_z = BMC150_MAGN_REGVAL_TO_REPZ((int)(reg_val));
return 0;
}
static int bmc150_magn_compute_max_odr(const struct device *dev, int rep_xy,
int rep_z, int *max_odr)
{
struct bmc150_magn_data *data = dev->data;
if (rep_xy == 0) {
if (data->rep_xy <= 0) {
if (bmc150_magn_read_rep_xy(dev) < 0) {
return -EIO;
}
}
rep_xy = data->rep_xy;
}
if (rep_z == 0) {
if (data->rep_z <= 0) {
if (bmc150_magn_read_rep_z(dev) < 0) {
return -EIO;
}
}
rep_z = data->rep_z;
}
*max_odr = 1000000 / (145 * rep_xy + 500 * rep_z + 980);
return 0;
}
#endif
#if defined(BMC150_MAGN_SET_ATTR_REP)
static int bmc150_magn_read_odr(const struct device *dev)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config *config = dev->config;
uint8_t i, odr_val, reg_val;
if (i2c_reg_read_byte_dt(&config->i2c,
BMC150_MAGN_REG_OPMODE_ODR, ®_val) < 0) {
return -EIO;
}
odr_val = (reg_val & BMC150_MAGN_MASK_ODR) >> BMC150_MAGN_SHIFT_ODR;
for (i = 0U; i < ARRAY_SIZE(bmc150_magn_samp_freq_table); ++i) {
if (bmc150_magn_samp_freq_table[i].reg_val == odr_val) {
data->odr = bmc150_magn_samp_freq_table[i].freq;
return 0;
}
}
return -ENOTSUP;
}
#endif
#if defined(CONFIG_BMC150_MAGN_SAMPLING_REP_XY)
static int bmc150_magn_write_rep_xy(const struct device *dev, int val)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_REP_XY,
BMC150_MAGN_REG_REP_DATAMASK,
BMC150_MAGN_REPXY_TO_REGVAL(val)) < 0) {
return -EIO;
}
data->rep_xy = val;
return 0;
}
#endif
#if defined(CONFIG_BMC150_MAGN_SAMPLING_REP_Z)
static int bmc150_magn_write_rep_z(const struct device *dev, int val)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c,
BMC150_MAGN_REG_REP_Z,
BMC150_MAGN_REG_REP_DATAMASK,
BMC150_MAGN_REPZ_TO_REGVAL(val)) < 0) {
return -EIO;
}
data->rep_z = val;
return 0;
}
#endif
/*
* Datasheet part 4.3.4, provided by Bosch here:
* path_to_url
*/
static int32_t bmc150_magn_compensate_xy(struct bmc150_magn_trim_regs *tregs,
int16_t xy, uint16_t rhall, bool is_x)
{
int8_t txy1, txy2;
int16_t val;
if (xy == BMC150_MAGN_XY_OVERFLOW_VAL) {
return INT32_MIN;
}
if (!rhall) {
rhall = tregs->xyz1;
}
if (is_x) {
txy1 = tregs->x1;
txy2 = tregs->x2;
} else {
txy1 = tregs->y1;
txy2 = tregs->y2;
}
val = ((int16_t)(((uint16_t)((((int32_t)tregs->xyz1) << 14) / rhall)) -
((uint16_t)0x4000)));
val = ((int16_t)((((int32_t)xy) * ((((((((int32_t)tregs->xy2) *
((((int32_t)val) * ((int32_t)val)) >> 7)) + (((int32_t)val) *
((int32_t)(((int16_t)tregs->xy1) << 7)))) >> 9) +
((int32_t)0x100000)) * ((int32_t)(((int16_t)txy2) +
((int16_t)0xA0)))) >> 12)) >> 13)) + (((int16_t)txy1) << 3);
return (int32_t)val;
}
static int32_t bmc150_magn_compensate_z(struct bmc150_magn_trim_regs *tregs,
int16_t z, uint16_t rhall)
{
int32_t val;
if (z == BMC150_MAGN_Z_OVERFLOW_VAL) {
return INT32_MIN;
}
val = (((((int32_t)(z - tregs->z4)) << 15) - ((((int32_t)tregs->z3) *
((int32_t)(((int16_t)rhall) - ((int16_t)tregs->xyz1)))) >> 2)) /
(tregs->z2 + ((int16_t)(((((int32_t)tregs->z1) *
((((int16_t)rhall) << 1))) + (1 << 15)) >> 16))));
return val;
}
static int bmc150_magn_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config *config = dev->config;
uint16_t values[BMC150_MAGN_AXIS_XYZR_MAX];
int16_t raw_x, raw_y, raw_z;
uint16_t rhall;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_MAGN_XYZ);
if (i2c_burst_read_dt(&config->i2c,
BMC150_MAGN_REG_X_L, (uint8_t *)values,
sizeof(values)) < 0) {
LOG_ERR("failed to read sample");
return -EIO;
}
raw_x = (int16_t)sys_le16_to_cpu(values[BMC150_MAGN_AXIS_X]) >>
BMC150_MAGN_SHIFT_XY_L;
raw_y = (int16_t)sys_le16_to_cpu(values[BMC150_MAGN_AXIS_Y]) >>
BMC150_MAGN_SHIFT_XY_L;
raw_z = (int16_t)sys_le16_to_cpu(values[BMC150_MAGN_AXIS_Z]) >>
BMC150_MAGN_SHIFT_Z_L;
rhall = sys_le16_to_cpu(values[BMC150_MAGN_RHALL]) >>
BMC150_MAGN_SHIFT_RHALL_L;
data->sample_x = bmc150_magn_compensate_xy(&data->tregs, raw_x, rhall,
true);
data->sample_y = bmc150_magn_compensate_xy(&data->tregs, raw_y, rhall,
false);
data->sample_z = bmc150_magn_compensate_z(&data->tregs, raw_z, rhall);
return 0;
}
static void bmc150_magn_convert(struct sensor_value *val, int raw_val)
{
/* val = raw_val / 1600 */
val->val1 = raw_val / 1600;
val->val2 = ((int32_t)raw_val * (1000000 / 1600)) % 1000000;
}
static int bmc150_magn_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct bmc150_magn_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
bmc150_magn_convert(val, data->sample_x);
break;
case SENSOR_CHAN_MAGN_Y:
bmc150_magn_convert(val, data->sample_y);
break;
case SENSOR_CHAN_MAGN_Z:
bmc150_magn_convert(val, data->sample_z);
break;
case SENSOR_CHAN_MAGN_XYZ:
bmc150_magn_convert(val, data->sample_x);
bmc150_magn_convert(val + 1, data->sample_y);
bmc150_magn_convert(val + 2, data->sample_z);
break;
default:
return -ENOTSUP;
}
return 0;
}
#if defined(BMC150_MAGN_SET_ATTR_REP)
static inline int bmc150_magn_attr_set_rep(const struct device *dev,
enum sensor_channel chan,
const struct sensor_value *val)
{
struct bmc150_magn_data *data = dev->data;
int max_odr;
switch (chan) {
#if defined(CONFIG_BMC150_MAGN_SAMPLING_REP_XY)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
if (val->val1 < 1 || val->val1 > 511) {
return -EINVAL;
}
if (bmc150_magn_compute_max_odr(dev, val->val1, 0,
&max_odr) < 0) {
return -EIO;
}
if (data->odr <= 0) {
if (bmc150_magn_read_odr(dev) < 0) {
return -EIO;
}
}
if (data->odr > max_odr) {
return -EINVAL;
}
if (bmc150_magn_write_rep_xy(dev, val->val1) < 0) {
return -EIO;
}
break;
#endif
#if defined(CONFIG_BMC150_MAGN_SAMPLING_REP_Z)
case SENSOR_CHAN_MAGN_Z:
if (val->val1 < 1 || val->val1 > 256) {
return -EINVAL;
}
if (bmc150_magn_compute_max_odr(dev, 0, val->val1,
&max_odr) < 0) {
return -EIO;
}
if (data->odr <= 0) {
if (bmc150_magn_read_odr(dev) < 0) {
return -EIO;
}
}
if (data->odr > max_odr) {
return -EINVAL;
}
if (bmc150_magn_write_rep_z(dev, val->val1) < 0) {
return -EIO;
}
break;
#endif
default:
return -EINVAL;
}
return 0;
}
#endif
#if defined(BMC150_MAGN_SET_ATTR)
static int bmc150_magn_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct bmc150_magn_data *data = dev->data;
switch (attr) {
#if defined(CONFIG_BMC150_MAGN_SAMPLING_RATE_RUNTIME)
case SENSOR_ATTR_SAMPLING_FREQUENCY:
if (data->max_odr <= 0) {
if (bmc150_magn_compute_max_odr(dev, 0, 0,
&data->max_odr) < 0) {
return -EIO;
}
}
if (data->max_odr < val->val1) {
LOG_ERR("not supported with current oversampling");
return -ENOTSUP;
}
if (bmc150_magn_set_odr(dev, (uint8_t)(val->val1)) < 0) {
return -EIO;
}
break;
#endif
#if defined(BMC150_MAGN_SET_ATTR_REP)
case SENSOR_ATTR_OVERSAMPLING:
bmc150_magn_attr_set_rep(dev, chan, val);
break;
#endif
default:
return -EINVAL;
}
return 0;
}
#endif
static const struct sensor_driver_api bmc150_magn_api_funcs = {
#if defined(BMC150_MAGN_SET_ATTR)
.attr_set = bmc150_magn_attr_set,
#endif
.sample_fetch = bmc150_magn_sample_fetch,
.channel_get = bmc150_magn_channel_get,
#if defined(CONFIG_BMC150_MAGN_TRIGGER_DRDY)
.trigger_set = bmc150_magn_trigger_set,
#endif
};
static int bmc150_magn_init_chip(const struct device *dev)
{
struct bmc150_magn_data *data = dev->data;
const struct bmc150_magn_config *config = dev->config;
uint8_t chip_id;
struct bmc150_magn_preset preset;
bmc150_magn_set_power_mode(dev, BMC150_MAGN_POWER_MODE_NORMAL, 0);
bmc150_magn_set_power_mode(dev, BMC150_MAGN_POWER_MODE_SUSPEND, 1);
if (bmc150_magn_set_power_mode(dev, BMC150_MAGN_POWER_MODE_SUSPEND, 0)
< 0) {
LOG_ERR("failed to bring up device from suspend mode");
return -EIO;
}
if (i2c_reg_read_byte_dt(&config->i2c,
BMC150_MAGN_REG_CHIP_ID, &chip_id) < 0) {
LOG_ERR("failed reading chip id");
goto err_poweroff;
}
if (chip_id != BMC150_MAGN_CHIP_ID_VAL) {
LOG_ERR("invalid chip id 0x%x", chip_id);
goto err_poweroff;
}
LOG_ERR("chip id 0x%x", chip_id);
preset = bmc150_magn_presets_table[BMC150_MAGN_DEFAULT_PRESET];
if (bmc150_magn_set_odr(dev, preset.odr) < 0) {
LOG_ERR("failed to set ODR to %d",
preset.odr);
goto err_poweroff;
}
if (i2c_reg_write_byte_dt(&config->i2c,
BMC150_MAGN_REG_REP_XY,
BMC150_MAGN_REPXY_TO_REGVAL(preset.rep_xy))
< 0) {
LOG_ERR("failed to set REP XY to %d",
preset.rep_xy);
goto err_poweroff;
}
if (i2c_reg_write_byte_dt(&config->i2c,
BMC150_MAGN_REG_REP_Z,
BMC150_MAGN_REPZ_TO_REGVAL(preset.rep_z)) < 0) {
LOG_ERR("failed to set REP Z to %d",
preset.rep_z);
goto err_poweroff;
}
if (bmc150_magn_set_power_mode(dev, BMC150_MAGN_POWER_MODE_NORMAL, 1)
< 0) {
LOG_ERR("failed to power on device");
goto err_poweroff;
}
if (i2c_burst_read_dt(&config->i2c,
BMC150_MAGN_REG_TRIM_START, (uint8_t *)&data->tregs,
sizeof(data->tregs)) < 0) {
LOG_ERR("failed to read trim regs");
goto err_poweroff;
}
data->rep_xy = 0;
data->rep_z = 0;
data->odr = 0;
data->max_odr = 0;
data->sample_x = 0;
data->sample_y = 0;
data->sample_z = 0;
data->tregs.xyz1 = sys_le16_to_cpu(data->tregs.xyz1);
data->tregs.z1 = sys_le16_to_cpu(data->tregs.z1);
data->tregs.z2 = sys_le16_to_cpu(data->tregs.z2);
data->tregs.z3 = sys_le16_to_cpu(data->tregs.z3);
data->tregs.z4 = sys_le16_to_cpu(data->tregs.z4);
return 0;
err_poweroff:
bmc150_magn_set_power_mode(dev, BMC150_MAGN_POWER_MODE_NORMAL, 0);
bmc150_magn_set_power_mode(dev, BMC150_MAGN_POWER_MODE_SUSPEND, 1);
return -EIO;
}
static int bmc150_magn_init(const struct device *dev)
{
const struct bmc150_magn_config * const config =
dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
if (bmc150_magn_init_chip(dev) < 0) {
LOG_ERR("failed to initialize chip");
return -EIO;
}
#if defined(CONFIG_BMC150_MAGN_TRIGGER_DRDY)
if (config->int_gpio.port) {
if (bmc150_magn_init_interrupt(dev) < 0) {
LOG_ERR("failed to initialize interrupts");
return -EINVAL;
}
}
#endif
return 0;
}
#define BMC150_MAGN_DEFINE(inst) \
static struct bmc150_magn_data bmc150_magn_data_##inst; \
\
static const struct bmc150_magn_config bmc150_magn_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_BMC150_MAGN_TRIGGER_DRDY, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, drdy_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, bmc150_magn_init, NULL, \
&bmc150_magn_data_##inst, &bmc150_magn_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &bmc150_magn_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(BMC150_MAGN_DEFINE)
``` | /content/code_sandbox/drivers/sensor/bosch/bmc150_magn/bmc150_magn.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,974 |
```c
/*
*
*/
/*
* Bus-specific functionality for BMM150s accessed via SPI.
*/
#include <zephyr/logging/log.h>
#include "bmm150.h"
#if BMM150_BUS_SPI
LOG_MODULE_DECLARE(BMM150, CONFIG_SENSOR_LOG_LEVEL);
static int bmm150_bus_check_spi(const union bmm150_bus *bus)
{
return spi_is_ready_dt(&bus->spi) ? 0 : -ENODEV;
}
static int bmm150_reg_read_spi(const union bmm150_bus *bus,
uint8_t start, uint8_t *buf, int size)
{
uint8_t addr;
const struct spi_buf tx_buf = {
.buf = &addr,
.len = 1
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
struct spi_buf rx_buf[2];
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = ARRAY_SIZE(rx_buf)
};
int i;
rx_buf[0].buf = NULL;
rx_buf[0].len = 1;
rx_buf[1].len = 1;
for (i = 0; i < size; i++) {
int ret;
addr = (start + i) | 0x80;
rx_buf[1].buf = &buf[i];
ret = spi_transceive_dt(&bus->spi, &tx, &rx);
if (ret) {
LOG_DBG("spi_transceive FAIL %d\n", ret);
return ret;
}
}
return 0;
}
static int bmm150_reg_write_spi(const union bmm150_bus *bus,
uint8_t reg, uint8_t val)
{
uint8_t cmd[] = { reg & 0x7F, val };
const struct spi_buf tx_buf = {
.buf = cmd,
.len = sizeof(cmd)
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
int ret;
ret = spi_write_dt(&bus->spi, &tx);
if (ret) {
LOG_DBG("spi_write FAIL %d\n", ret);
return ret;
}
return 0;
}
const struct bmm150_bus_io bmm150_bus_io_spi = {
.check = bmm150_bus_check_spi,
.read = bmm150_reg_read_spi,
.write = bmm150_reg_write_spi,
};
#endif /* BMM150_BUS_SPI */
``` | /content/code_sandbox/drivers/sensor/bosch/bmm150/bmm150_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 540 |
```objective-c
/* sensor_bmm150.h - header file for BMM150 Geomagnetic sensor driver */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BMM150_BMM150_H_
#define ZEPHYR_DRIVERS_SENSOR_BMM150_BMM150_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/i2c.h>
#define DT_DRV_COMPAT bosch_bmm150
#define BMM150_BUS_SPI DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define BMM150_BUS_I2C DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
union bmm150_bus {
#if BMM150_BUS_SPI
struct spi_dt_spec spi;
#endif
#if BMM150_BUS_I2C
struct i2c_dt_spec i2c;
#endif
};
typedef int (*bmm150_bus_check_fn)(const union bmm150_bus *bus);
typedef int (*bmm150_reg_read_fn)(const union bmm150_bus *bus,
uint8_t start, uint8_t *buf, int size);
typedef int (*bmm150_reg_write_fn)(const union bmm150_bus *bus,
uint8_t reg, uint8_t val);
struct bmm150_bus_io {
bmm150_bus_check_fn check;
bmm150_reg_read_fn read;
bmm150_reg_write_fn write;
};
#if BMM150_BUS_SPI
#define BMM150_SPI_OPERATION (SPI_WORD_SET(8) | SPI_TRANSFER_MSB | \
SPI_MODE_CPOL | SPI_MODE_CPHA)
extern const struct bmm150_bus_io bmm150_bus_io_spi;
#endif
#if BMM150_BUS_I2C
extern const struct bmm150_bus_io bmm150_bus_io_i2c;
#endif
#include <zephyr/types.h>
#include <zephyr/drivers/i2c.h>
#include <stdint.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/drivers/gpio.h>
#define BMM150_REG_CHIP_ID 0x40
#define BMM150_CHIP_ID_VAL 0x32
#define BMM150_REG_X_L 0x42
#define BMM150_REG_X_M 0x43
#define BMM150_REG_Y_L 0x44
#define BMM150_REG_Y_M 0x45
#define BMM150_SHIFT_XY_L 3
#define BMM150_REG_Z_L 0x46
#define BMM150_REG_Z_M 0x47
#define BMM150_SHIFT_Z_L 1
#define BMM150_REG_RHALL_L 0x48
#define BMM150_REG_RHALL_M 0x49
#define BMM150_SHIFT_RHALL_L 2
#define BMM150_REG_INT_STATUS 0x4A
#define BMM150_REG_POWER 0x4B
#define BMM150_MASK_POWER_CTL BIT(0)
#define BMM150_MASK_SOFT_RESET (BIT(7) | BIT(1))
#define BMM150_SOFT_RESET BMM150_MASK_SOFT_RESET
#define BMM150_REG_OPMODE_ODR 0x4C
#define BMM150_MASK_OPMODE (BIT(2) | BIT(1))
#define BMM150_SHIFT_OPMODE 1
#define BMM150_MODE_NORMAL 0x00
#define BMM150_MODE_FORCED 0x01
#define BMM150_MODE_SLEEP 0x03
#define BMM150_MASK_ODR (BIT(5) | BIT(4) | BIT(3))
#define BMM150_SHIFT_ODR 3
#define BMM150_REG_LOW_THRESH 0x4F
#define BMM150_REG_HIGH_THRESH 0x50
#define BMM150_REG_REP_XY 0x51
#define BMM150_REG_REP_Z 0x52
#define BMM150_REG_REP_DATAMASK 0xFF
#define BMM150_REG_TRIM_START 0x5D
#define BMM150_REG_TRIM_END 0x71
#define BMM150_XY_OVERFLOW_VAL -4096
#define BMM150_Z_OVERFLOW_VAL -16384
#define BMM150_REGVAL_TO_REPXY(regval) (((regval) * 2) + 1)
#define BMM150_REGVAL_TO_REPZ(regval) ((regval) + 1)
#define BMM150_REPXY_TO_REGVAL(rep) (((rep) - 1) / 2)
#define BMM150_REPZ_TO_REGVAL(rep) BMM150_REPXY_TO_REGVAL(rep)
#define BMM150_REG_INT 0x4D
#define BMM150_REG_INT_DRDY 0x4E
#define BMM150_MASK_DRDY_EN BIT(7)
#define BMM150_SHIFT_DRDY_EN 7
#define BMM150_DRDY_INT3 BIT(6)
#define BMM150_MASK_DRDY_Z_EN BIT(5)
#define BMM150_MASK_DRDY_Y_EN BIT(4)
#define BMM150_MASK_DRDY_X_EN BIT(3)
#define BMM150_MASK_DRDY_DR_POLARITY BIT(2)
#define BMM150_SHIFT_DRDY_DR_POLARITY 2
#define BMM150_MASK_DRDY_LATCHING BIT(1)
#define BMM150_MASK_DRDY_INT3_POLARITY BIT(0)
#if defined(CONFIG_BMM150_SAMPLING_REP_XY) || \
defined(CONFIG_BMM150_SAMPLING_REP_Z)
#define BMM150_SET_ATTR_REP
#endif
#if defined(CONFIG_BMM150_SAMPLING_RATE_RUNTIME) || \
defined(BMM150_MAGN_SET_ATTR_REP)
#define BMM150_MAGN_SET_ATTR
#endif
struct bmm150_trim_regs {
int8_t x1;
int8_t y1;
uint16_t reserved1;
uint8_t reserved2;
int16_t z4;
int8_t x2;
int8_t y2;
uint16_t reserved3;
int16_t z2;
uint16_t z1;
uint16_t xyz1;
int16_t z3;
int8_t xy2;
uint8_t xy1;
} __packed;
struct bmm150_config {
union bmm150_bus bus;
const struct bmm150_bus_io *bus_io;
#ifdef CONFIG_BMM150_TRIGGER
struct gpio_dt_spec drdy_int;
#endif
};
struct bmm150_data {
struct bmm150_trim_regs tregs;
int rep_xy, rep_z, odr, max_odr;
int sample_x, sample_y, sample_z;
#if defined(CONFIG_BMM150_TRIGGER)
struct gpio_callback gpio_cb;
#endif
#ifdef CONFIG_BMM150_TRIGGER_OWN_THREAD
struct k_sem sem;
#endif
#ifdef CONFIG_BMM150_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
#if defined(CONFIG_BMM150_TRIGGER_GLOBAL_THREAD) || \
defined(CONFIG_BMM150_TRIGGER_DIRECT)
const struct device *dev;
#endif
#ifdef CONFIG_BMM150_TRIGGER
const struct sensor_trigger *drdy_trigger;
sensor_trigger_handler_t drdy_handler;
#endif /* CONFIG_BMM150_TRIGGER */
};
enum bmm150_axis {
BMM150_AXIS_X,
BMM150_AXIS_Y,
BMM150_AXIS_Z,
BMM150_RHALL,
BMM150_AXIS_XYZ_MAX = BMM150_RHALL,
BMM150_AXIS_XYZR_MAX
};
enum bmm150_presets {
BMM150_LOW_POWER_PRESET,
BMM150_REGULAR_PRESET,
BMM150_ENHANCED_REGULAR_PRESET,
BMM150_HIGH_ACCURACY_PRESET
};
#if defined(CONFIG_BMM150_PRESET_LOW_POWER)
#define BMM150_DEFAULT_PRESET BMM150_LOW_POWER_PRESET
#elif defined(CONFIG_BMM150_PRESET_REGULAR)
#define BMM150_DEFAULT_PRESET BMM150_REGULAR_PRESET
#elif defined(CONFIG_BMM150_PRESET_ENHANCED_REGULAR)
#define BMM150_DEFAULT_PRESET BMM150_ENHANCED_REGULAR_PRESET
#elif defined(CONFIG_BMM150_PRESET_HIGH_ACCURACY)
#define BMM150_DEFAULT_PRESET BMM150_HIGH_ACCURACY_PRESET
#endif
/* Power On Reset time - from OFF to Suspend (Max) */
#define BMM150_POR_TIME K_MSEC(1)
/* Start-Up Time - from suspend to sleep (Max) */
#define BMM150_START_UP_TIME K_MSEC(3)
int bmm150_trigger_mode_init(const struct device *dev);
int bmm150_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int bmm150_reg_update_byte(const struct device *dev, uint8_t reg,
uint8_t mask, uint8_t value);
#endif /* __SENSOR_BMM150_H__ */
``` | /content/code_sandbox/drivers/sensor/bosch/bmm150/bmm150.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,960 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.