text stringlengths 9 39.2M | dir stringlengths 25 226 | lang stringclasses 163 values | created_date timestamp[s] | updated_date timestamp[s] | repo_name stringclasses 751 values | repo_full_name stringclasses 752 values | star int64 1.01k 183k | len_tokens int64 1 18.5M |
|---|---|---|---|---|---|---|---|---|
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42670_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42670_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#define ICM42670_BUS_SPI DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(invensense_icm42670, spi)
#define ICM42670_BUS_I2C DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(invensense_icm42670, i2c)
union icm42670_bus {
#if ICM42670_BUS_SPI
struct spi_dt_spec spi;
#endif
#if ICM42670_BUS_I2C
struct i2c_dt_spec i2c;
#endif
};
typedef int (*icm42670_bus_check_fn)(const union icm42670_bus *bus);
typedef int (*icm42670_reg_read_fn)(const union icm42670_bus *bus,
uint16_t reg, uint8_t *data, size_t size);
typedef int (*icm42670_reg_write_fn)(const union icm42670_bus *bus,
uint16_t reg, uint8_t data);
typedef int (*icm42670_reg_update_fn)(const union icm42670_bus *bus,
uint16_t reg, uint8_t mask, uint8_t data);
struct icm42670_bus_io {
icm42670_bus_check_fn check;
icm42670_reg_read_fn read;
icm42670_reg_write_fn write;
icm42670_reg_update_fn update;
};
#if ICM42670_BUS_SPI
extern const struct icm42670_bus_io icm42670_bus_io_spi;
#endif
#if ICM42670_BUS_I2C
extern const struct icm42670_bus_io icm42670_bus_io_i2c;
#endif
struct icm42670_data {
int16_t accel_x;
int16_t accel_y;
int16_t accel_z;
uint16_t accel_sensitivity_shift;
uint16_t accel_hz;
uint16_t accel_fs;
int16_t gyro_x;
int16_t gyro_y;
int16_t gyro_z;
uint16_t gyro_sensitivity_x10;
uint16_t gyro_hz;
uint16_t gyro_fs;
int16_t temp;
#ifdef CONFIG_ICM42670_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t data_ready_handler;
const struct sensor_trigger *data_ready_trigger;
struct k_mutex mutex;
#endif
#ifdef CONFIG_ICM42670_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ICM42670_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#endif
#ifdef CONFIG_ICM42670_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
};
struct icm42670_config {
union icm42670_bus bus;
const struct icm42670_bus_io *bus_io;
struct gpio_dt_spec gpio_int;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42670_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/icm42670.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 657 |
```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 "amg88xx.h"
extern struct amg88xx_data amg88xx_driver;
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(AMG88XX, CONFIG_SENSOR_LOG_LEVEL);
static inline void amg88xx_setup_int(const struct amg88xx_config *cfg,
bool enable)
{
unsigned int flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, flags);
}
int amg88xx_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct amg88xx_config *config = dev->config;
int16_t int_level = (val->val1 * 1000000 + val->val2) /
AMG88XX_TREG_LSB_SCALING;
uint8_t intl_reg;
uint8_t inth_reg;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
LOG_DBG("set threshold to %d", int_level);
if (attr == SENSOR_ATTR_UPPER_THRESH) {
intl_reg = AMG88XX_INTHL;
inth_reg = AMG88XX_INTHH;
} else if (attr == SENSOR_ATTR_LOWER_THRESH) {
intl_reg = AMG88XX_INTLL;
inth_reg = AMG88XX_INTLH;
} else {
return -ENOTSUP;
}
if (i2c_reg_write_byte_dt(&config->i2c,
intl_reg, (uint8_t)int_level)) {
LOG_DBG("Failed to set INTxL attribute!");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
inth_reg, (uint8_t)(int_level >> 8))) {
LOG_DBG("Failed to set INTxH attribute!");
return -EIO;
}
return 0;
}
static void amg88xx_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct amg88xx_data *drv_data =
CONTAINER_OF(cb, struct amg88xx_data, gpio_cb);
const struct amg88xx_config *config = drv_data->dev->config;
amg88xx_setup_int(config, false);
#if defined(CONFIG_AMG88XX_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_AMG88XX_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void amg88xx_thread_cb(const struct device *dev)
{
struct amg88xx_data *drv_data = dev->data;
const struct amg88xx_config *config = dev->config;
uint8_t status;
if (i2c_reg_read_byte_dt(&config->i2c,
AMG88XX_STAT, &status) < 0) {
return;
}
if (drv_data->drdy_handler != NULL) {
drv_data->drdy_handler(dev, drv_data->drdy_trigger);
}
if (drv_data->th_handler != NULL) {
drv_data->th_handler(dev, drv_data->th_trigger);
}
amg88xx_setup_int(config, true);
}
#ifdef CONFIG_AMG88XX_TRIGGER_OWN_THREAD
static void amg88xx_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct amg88xx_data *drv_data = p1;
while (42) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
amg88xx_thread_cb(drv_data->dev);
}
}
#endif
#ifdef CONFIG_AMG88XX_TRIGGER_GLOBAL_THREAD
static void amg88xx_work_cb(struct k_work *work)
{
struct amg88xx_data *drv_data =
CONTAINER_OF(work, struct amg88xx_data, work);
amg88xx_thread_cb(drv_data->dev);
}
#endif
int amg88xx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct amg88xx_data *drv_data = dev->data;
const struct amg88xx_config *config = dev->config;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (i2c_reg_write_byte_dt(&config->i2c,
AMG88XX_INTC, AMG88XX_INTC_DISABLED)) {
return -EIO;
}
amg88xx_setup_int(config, false);
if (trig->type == SENSOR_TRIG_THRESHOLD) {
drv_data->th_handler = handler;
drv_data->th_trigger = trig;
} else {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
amg88xx_setup_int(config, true);
if (i2c_reg_write_byte_dt(&config->i2c,
AMG88XX_INTC, AMG88XX_INTC_ABS_MODE)) {
return -EIO;
}
return 0;
}
int amg88xx_init_interrupt(const struct device *dev)
{
struct amg88xx_data *drv_data = dev->data;
const struct amg88xx_config *config = dev->config;
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name,
config->int_gpio.port->name);
return -ENODEV;
}
gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT | config->int_gpio.dt_flags);
gpio_init_callback(&drv_data->gpio_cb,
amg88xx_gpio_callback,
BIT(config->int_gpio.pin));
if (gpio_add_callback(config->int_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
drv_data->dev = dev;
#if defined(CONFIG_AMG88XX_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_AMG88XX_THREAD_STACK_SIZE,
amg88xx_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_AMG88XX_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_AMG88XX_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = amg88xx_work_cb;
#endif
amg88xx_setup_int(config, true);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/amg88xx/amg88xx_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,514 |
```c
/*
*
*/
#define DT_DRV_COMPAT invensense_icp10125
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#ifdef CONFIG_ICP10125_CHECK_CRC
#include <zephyr/sys/crc.h>
#endif /* CONFIG_ICP10125_CHECK_CRC */
LOG_MODULE_REGISTER(ICP10125, CONFIG_SENSOR_LOG_LEVEL);
#define CRC_POLY 0x31
#define SENSOR_DATA_SIZE 2
#define AMBIENT_TEMP_DATA_NUM 1
#define PRESS_DATA_NUM 2
#define PRESS_AND_AMBIENT_TEMP_DATA_NUM (AMBIENT_TEMP_DATA_NUM + PRESS_DATA_NUM)
enum {
LOW_POWER,
NORMAL,
LOW_NOISE,
ULTRA_LOW_NOISE,
NUM_MEASURE_MODE
};
struct icp10125_data {
uint16_t raw_ambient_temp;
uint32_t raw_press;
float sensor_constants[4];
};
struct icp10125_dev_config {
struct i2c_dt_spec i2c;
uint8_t ambient_temp_mode;
uint8_t press_mode;
};
struct icp10125_cmd {
uint8_t data[2];
};
struct icp10125_sensor_data {
uint8_t data[2];
uint8_t crc;
};
struct icp10125_otp_read_setup {
struct icp10125_cmd cmd;
uint8_t data[3];
} __packed __aligned(1);
/* ambient temperature measurement command for each mode.
* (Section 5.2 MEASUREMENT COMMANDS in the Datasheet)
*/
static const struct icp10125_cmd ambient_temp_measurement_cmds[] = {
{{0x60, 0x9C}}, {{0x68, 0x25}}, {{0x70, 0xDF}}, {{0x78, 0x66}}
};
/* pressure measurement command for each mode.
* (Section 5.2 MEASUREMENT COMMANDS in the Datasheet)
*/
static const struct icp10125_cmd press_measurement_cmds[] = {
{{0x40, 0x1A}}, {{0x48, 0xA3}}, {{0x50, 0x59}}, {{0x59, 0xE0}}
};
/* Request preparation for OTP data read. It should issue before data read request.
* (Section 5.2 MEASUREMENT COMMANDS in the Datasheet)
*/
static const struct icp10125_otp_read_setup otp_read_setup = {
.cmd = {{0xC5, 0x95}},
.data = {0x00, 0x66, 0x9C}
};
/* OTP data read request.
* After issue this command 2byte x 4 sensor constant value can readable.
*/
static const struct icp10125_cmd otp_read_request_cmd = {{0xC7, 0xF7}};
/* The max conversion time for each modes.
* (Section 2.2 OPERATION MODES in the Datasheet)
*/
static const uint32_t conv_time_max[] = {1800, 6300, 23800, 94500};
/* The typical conversion time for each modes.
* (Section 2.2 OPERATION MODES in the Datasheet)
*/
static const uint32_t conv_time_typ[] = {1600, 5600, 20800, 83200};
/* The Datasheet has no mention of the constants and formulas.
* Instead, it shows only how to use it in the sample code.
* Since there is no detailed description in the ICP10125 product manual,
* the calculation of the pressure implements is the same as shown in
* the 5.11 SAMPLE CODE: EXAMPLE C SYNTAX
*/
static void icp10125_calculate_conversion_constants(const float *p_LUT, float *A, float *B,
float *C)
{
const float p_Pa[] = {45000.0, 80000.0, 105000.0};
*C = (p_LUT[0] * p_LUT[1] * (p_Pa[0] - p_Pa[1]) +
p_LUT[1] * p_LUT[2] * (p_Pa[1] - p_Pa[2]) +
p_LUT[2] * p_LUT[0] * (p_Pa[2] - p_Pa[0])) /
(p_LUT[2] * (p_Pa[0] - p_Pa[1]) + p_LUT[0] * (p_Pa[1] - p_Pa[2]) +
p_LUT[1] * (p_Pa[2] - p_Pa[0]));
*A = (p_Pa[0] * p_LUT[0] - p_Pa[1] * p_LUT[1] - (p_Pa[1] - p_Pa[0]) * (*C)) /
(p_LUT[0] - p_LUT[1]);
*B = (p_Pa[0] - (*A)) * (p_LUT[0] + (*C));
}
static float icp10125_calc_calibrated_ambient_temp(const struct icp10125_data *data)
{
return -45.f + 175.f / 65536.f * data->raw_ambient_temp;
}
static float icp10125_calc_calibrated_press(const struct icp10125_data *data)
{
const float quadr_factor = 1 / 16777216.0;
const float offst_factor = 2048.0;
const float LUT_lower = 3.5 * (1 << 20);
const float LUT_upper = 11.5 * (1 << 20);
float t;
float in[3];
float A, B, C;
t = data->raw_ambient_temp - 32768.f;
in[0] = LUT_lower + (data->sensor_constants[0] * t * t) * quadr_factor;
in[1] = offst_factor * data->sensor_constants[3] +
(data->sensor_constants[1] * t * t) * quadr_factor;
in[2] = LUT_upper + (data->sensor_constants[2] * t * t) * quadr_factor;
icp10125_calculate_conversion_constants(in, &A, &B, &C);
return A + B / (C + data->raw_press);
}
/* End of porting the 5.11 SAMPLE CODE: EXAMPLE C SYNTAX */
static int icp10125_read_otp(const struct device *dev)
{
struct icp10125_data *data = dev->data;
struct icp10125_sensor_data sensor_data;
const struct icp10125_dev_config *cfg = dev->config;
int rc = 0;
rc = i2c_write_dt(&cfg->i2c, (uint8_t *)&otp_read_setup, sizeof(otp_read_setup));
if (rc < 0) {
LOG_ERR("Failed to write otp_read_setup.\n");
return rc;
}
for (size_t i = 0; i < ARRAY_SIZE(data->sensor_constants); i++) {
rc = i2c_write_dt(&cfg->i2c, (uint8_t *)&otp_read_request_cmd,
sizeof(otp_read_request_cmd));
if (rc < 0) {
LOG_ERR("Failed to write otp_read_request.\n");
return rc;
}
rc = i2c_read_dt(&cfg->i2c, (uint8_t *)&sensor_data, sizeof(sensor_data));
if (rc < 0) {
LOG_ERR("Failed to read otp_read_request.\n");
return rc;
}
data->sensor_constants[i] = sys_get_be16(sensor_data.data);
}
return 0;
}
#ifdef CONFIG_ICP10125_CHECK_CRC
static int icp10125_check_crc(const uint8_t *data, const size_t len)
{
/* Details of CRC are described in Chapter 5 Section 8 of the product
* specifications.
*/
return crc8(data, len, CRC_POLY, 0xFF, false);
}
#endif
static int icp10125_measure(const struct i2c_dt_spec *i2c, const struct icp10125_cmd *cmds,
const uint8_t mode, struct icp10125_sensor_data *sensor_data,
const size_t data_num)
{
int rc = 0;
rc = i2c_write_dt(i2c, (uint8_t *)&cmds[mode], sizeof(cmds[mode]));
if (rc < 0) {
LOG_ERR("Failed to start measurement.\n");
return rc;
}
/* Wait for the sensor to become readable.
* First wait for the typical time and then read.
* If that fails, wait until the time to surely became readable.
*/
k_sleep(K_USEC(conv_time_typ[mode]));
if (i2c_read_dt(i2c, (uint8_t *)sensor_data, sizeof(sensor_data[0]) * data_num) < 0) {
k_sleep(K_USEC(conv_time_max[mode] - conv_time_typ[mode]));
rc = i2c_read_dt(i2c, (uint8_t *)sensor_data, sizeof(sensor_data[0]) * data_num);
if (rc < 0) {
LOG_ERR("Failed to read measurement.\n");
return rc;
}
}
#ifdef CONFIG_ICP10125_CHECK_CRC
/* Calculate CRC from Chapter 5 Section 8 of ICP10125 Product manuals. */
for (size_t i = 0; i < data_num; i++) {
if (!icp10125_check_crc(sensor_data[i].data, SENSOR_DATA_SIZE)) {
LOG_ERR("Sensor data has invalid CRC.\n");
return -EIO;
}
}
#endif /* CONFIG_ICP10125_CHECK_CRC */
return 0;
}
static int icp10125_sample_fetch(const struct device *dev, const enum sensor_channel chan)
{
struct icp10125_data *data = dev->data;
const struct icp10125_dev_config *cfg = dev->config;
uint8_t endian_conversion[3];
struct icp10125_sensor_data sensor_data[PRESS_AND_AMBIENT_TEMP_DATA_NUM] = {0};
int rc = 0;
if (!(chan == SENSOR_CHAN_AMBIENT_TEMP || chan == SENSOR_CHAN_PRESS ||
chan == SENSOR_CHAN_ALL)) {
return -ENOTSUP;
}
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
rc = icp10125_measure(&cfg->i2c, ambient_temp_measurement_cmds,
cfg->ambient_temp_mode, sensor_data, AMBIENT_TEMP_DATA_NUM);
if (rc < 0) {
return rc;
}
data->raw_ambient_temp = sys_get_be16(sensor_data[0].data);
} else {
rc = icp10125_measure(&cfg->i2c, press_measurement_cmds, cfg->press_mode,
sensor_data, PRESS_AND_AMBIENT_TEMP_DATA_NUM);
if (rc < 0) {
return rc;
}
endian_conversion[0] = sensor_data[0].data[0];
endian_conversion[1] = sensor_data[0].data[1];
endian_conversion[2] = sensor_data[1].data[0];
data->raw_press = sys_get_be24(endian_conversion);
data->raw_ambient_temp = sys_get_be16(sensor_data[2].data);
}
return 0;
}
static void icp10125_convert_press_value(struct icp10125_data *data, struct sensor_value *val)
{
sensor_value_from_float(val, icp10125_calc_calibrated_press(data) / 1000.f);
}
static void icp10125_convert_ambient_temp_value(struct icp10125_data *data,
struct sensor_value *val)
{
sensor_value_from_float(val, icp10125_calc_calibrated_ambient_temp(data));
}
static int icp10125_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct icp10125_data *data = dev->data;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
icp10125_convert_ambient_temp_value(data, val);
} else if (chan == SENSOR_CHAN_PRESS) {
icp10125_convert_press_value(data, val);
} else {
return -ENOTSUP;
}
return 0;
}
static int icp10125_init(const struct device *dev)
{
int rc = icp10125_read_otp(dev);
if (rc < 0) {
return rc;
}
return 0;
}
static const struct sensor_driver_api icp10125_api_funcs = {
.sample_fetch = icp10125_sample_fetch,
.channel_get = icp10125_channel_get,
};
#define ICP10125_DEFINE(inst) \
static struct icp10125_data icp10125_drv_##inst; \
static const struct icp10125_dev_config icp10125_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.ambient_temp_mode = DT_INST_ENUM_IDX(inst, temperature_measurement_mode), \
.press_mode = DT_INST_ENUM_IDX(inst, pressure_measurement_mode)}; \
DEVICE_DT_INST_DEFINE(inst, icp10125_init, NULL, &icp10125_drv_##inst, \
&icp10125_config_##inst, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&icp10125_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(ICP10125_DEFINE)
``` | /content/code_sandbox/drivers/sensor/tdk/icp10125/icp10125.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,938 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_AMG88XX_AMG88XX_H_
#define ZEPHYR_DRIVERS_SENSOR_AMG88XX_AMG88XX_H_
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#define AMG88XX_PCLT 0x00 /* Setting Power control register */
#define AMG88XX_RST 0x01 /* Reset register */
#define AMG88XX_FPSC 0x02 /* Setting frame rate register */
#define AMG88XX_INTC 0x03 /* Setting interrupt control register */
#define AMG88XX_STAT 0x04 /* Status register */
#define AMG88XX_SCLR 0x05 /* Status clear register */
#define AMG88XX_AVE 0x07 /* Setting average register */
#define AMG88XX_INTHL 0x08 /* Interrupt level upper limit [7:0] */
#define AMG88XX_INTHH 0x09 /* Interrupt level upper limit [11:8] */
#define AMG88XX_INTLL 0x0a /* Interrupt level lower limit [7:0] */
#define AMG88XX_INTLH 0x0b /* Interrupt level lower limit [11:8] */
#define AMG88XX_INTSL 0x0c /* Interrupt hysteresis level [7:0] */
#define AMG88XX_INTSH 0x0d /* Interrupt hysteresis level [11:8] */
#define AMG88XX_TTHL 0x0e /* Thermistor temperature data [7:0] */
#define AMG88XX_TTHH 0x0f /* Thermistor temperature data [10:8] */
#define AMG88XX_INT0 0x10 /* Pixel 1..8 Interrupt Result */
#define AMG88XX_INT1 0x11 /* Pixel 9..16 Interrupt Result */
#define AMG88XX_INT2 0x12 /* Pixel 17..24 Interrupt Result */
#define AMG88XX_INT3 0x13 /* Pixel 25..32 Interrupt Result */
#define AMG88XX_INT4 0x14 /* Pixel 33..40 Interrupt Result */
#define AMG88XX_INT5 0x15 /* Pixel 41..48 Interrupt Result */
#define AMG88XX_INT6 0x16 /* Pixel 49..56 Interrupt Result */
#define AMG88XX_INT7 0x17 /* Pixel 57..64 Interrupt Result */
#define AMG88XX_OUTPUT_BASE 0x80 /* Base address for the output values */
#define AMG88XX_PCLT_NORMAL_MODE 0x00
#define AMG88XX_PCLT_SLEEP_MODE 0x10
#define AMG88XX_PCLT_STAND_BY_60S_MODE 0x20
#define AMG88XX_PCLT_STAND_BY_10S_MODE 0x21
#define AMG88XX_RST_FLAG_RST 0x30
#define AMG88XX_RST_INITIAL_RST 0x3F
#define AMG88XX_FPSC_10FPS 0x00
#define AMG88XX_FPSC_1FPS 0x01
#define AMG88XX_INTC_DISABLED 0x00
#define AMG88XX_INTC_DIFF_MODE 0x01
#define AMG88XX_INTC_ABS_MODE 0x03
#define AMG88XX_STAT_INTF_MASK 0x02
#define AMG88XX_STAT_OVF_IRS_MASK 0x04
#define AMG88XX_SCLR_INTCLR_MASK 0x02
#define AMG88XX_SCLR_OVS_CLR_MASK 0x04
#define AMG88XX_AVE_MAMOD_MASK 0x20
/* 1 LSB is equivalent to 0.25 degree Celsius scaled to micro degrees */
#define AMG88XX_TREG_LSB_SCALING 250000
#define AMG88XX_WAIT_MODE_CHANGE_US 50000
#define AMG88XX_WAIT_INITIAL_RESET_US 2000
struct amg88xx_config {
const struct i2c_dt_spec i2c;
#ifdef CONFIG_AMG88XX_TRIGGER
const struct gpio_dt_spec int_gpio;
#endif
};
struct amg88xx_data {
int16_t sample[64];
#ifdef CONFIG_AMG88XX_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trigger;
sensor_trigger_handler_t th_handler;
const struct sensor_trigger *th_trigger;
#if defined(CONFIG_AMG88XX_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_AMG88XX_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_AMG88XX_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_AMG88XX_TRIGGER */
};
#ifdef CONFIG_AMG88XX_TRIGGER
int amg88xx_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
int amg88xx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int amg88xx_init_interrupt(const struct device *dev);
#endif /* CONFIG_AMG88XX_TRIGGER */
#endif
``` | /content/code_sandbox/drivers/sensor/amg88xx/amg88xx.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,152 |
```unknown
# AMG88XX infrared thermopile sensor configuration options
menuconfig AMG88XX
bool "AMG88XX Infrared Thermopile Sensor"
default y
depends on DT_HAS_PANASONIC_AMG88XX_ENABLED
select I2C
help
Enable driver for AMG88XX infrared thermopile sensor.
if AMG88XX
choice
prompt "Trigger mode"
default AMG88XX_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config AMG88XX_TRIGGER_NONE
bool "No trigger"
config AMG88XX_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select AMG88XX_TRIGGER
config AMG88XX_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select AMG88XX_TRIGGER
endchoice
config AMG88XX_TRIGGER
bool
config AMG88XX_THREAD_PRIORITY
int "Thread priority"
depends on AMG88XX_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config AMG88XX_THREAD_STACK_SIZE
int "Thread stack size"
depends on AMG88XX_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # AMG88XX
``` | /content/code_sandbox/drivers/sensor/amg88xx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 285 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SB_TSI_SB_TSI_H_
#define ZEPHYR_DRIVERS_SENSOR_SB_TSI_SB_TSI_H_
#define SB_TSI_TEMP_INT 0x01
#define SB_TSI_TEMP_DEC 0x10
#define SB_TSI_TEMP_DEC_SHIFT 5
#define SB_TSI_TEMP_DEC_SCALE 8
#endif
``` | /content/code_sandbox/drivers/sensor/amd_sb_tsi/sb_tsi.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 80 |
```c
/*
*
*/
#define DT_DRV_COMPAT panasonic_amg88xx
#include <string.h>
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.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 <zephyr/logging/log.h>
#include "amg88xx.h"
LOG_MODULE_REGISTER(AMG88XX, CONFIG_SENSOR_LOG_LEVEL);
static int amg88xx_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct amg88xx_data *drv_data = dev->data;
const struct amg88xx_config *config = dev->config;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_AMBIENT_TEMP);
if (i2c_burst_read_dt(&config->i2c,
AMG88XX_OUTPUT_BASE,
(uint8_t *)drv_data->sample,
sizeof(drv_data->sample))) {
return -EIO;
}
return 0;
}
static int amg88xx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct amg88xx_data *drv_data = dev->data;
size_t len = ARRAY_SIZE(drv_data->sample);
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
for (size_t idx = 0; idx < len; idx++) {
/* fix negative values */
if (drv_data->sample[idx] & (1 << 11)) {
drv_data->sample[idx] |= 0xF000;
}
val[idx].val1 = (((int32_t)drv_data->sample[idx]) *
AMG88XX_TREG_LSB_SCALING) / 1000000;
val[idx].val2 = (((int32_t)drv_data->sample[idx]) *
AMG88XX_TREG_LSB_SCALING) % 1000000;
}
return 0;
}
static int amg88xx_init_device(const struct device *dev)
{
const struct amg88xx_config *config = dev->config;
uint8_t tmp;
if (i2c_reg_read_byte_dt(&config->i2c,
AMG88XX_PCLT, &tmp)) {
LOG_ERR("Failed to read Power mode");
return -EIO;
}
LOG_DBG("Power mode 0x%02x", tmp);
if (tmp != AMG88XX_PCLT_NORMAL_MODE) {
if (i2c_reg_write_byte_dt(&config->i2c,
AMG88XX_PCLT,
AMG88XX_PCLT_NORMAL_MODE)) {
return -EIO;
}
k_busy_wait(AMG88XX_WAIT_MODE_CHANGE_US);
}
if (i2c_reg_write_byte_dt(&config->i2c,
AMG88XX_RST, AMG88XX_RST_INITIAL_RST)) {
return -EIO;
}
k_busy_wait(AMG88XX_WAIT_INITIAL_RESET_US);
if (i2c_reg_write_byte_dt(&config->i2c,
AMG88XX_FPSC, AMG88XX_FPSC_10FPS)) {
return -EIO;
}
LOG_DBG("");
return 0;
}
int amg88xx_init(const struct device *dev)
{
const struct amg88xx_config *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -EINVAL;
}
if (amg88xx_init_device(dev) < 0) {
LOG_ERR("Failed to initialize device!");
return -EIO;
}
#ifdef CONFIG_AMG88XX_TRIGGER
if (amg88xx_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt!");
return -EIO;
}
#endif
return 0;
}
static const struct sensor_driver_api amg88xx_driver_api = {
#ifdef CONFIG_AMG88XX_TRIGGER
.attr_set = amg88xx_attr_set,
.trigger_set = amg88xx_trigger_set,
#endif
.sample_fetch = amg88xx_sample_fetch,
.channel_get = amg88xx_channel_get,
};
#define AMG88XX_DEFINE(inst) \
static struct amg88xx_data amg88xx_data_##inst; \
\
static const struct amg88xx_config amg88xx_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_AMG88XX_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, amg88xx_init, NULL, \
&amg88xx_data_##inst, &amg88xx_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &amg88xx_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(AMG88XX_DEFINE)
``` | /content/code_sandbox/drivers/sensor/amg88xx/amg88xx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,138 |
```unknown
# SB-TSI configuration options
config AMD_SB_TSI
bool "AMD SB Temperature Sensor Interface"
default y
depends on DT_HAS_AMD_SB_TSI_ENABLED
select I2C
help
Enable the driver for SB Temperature Sensor Interface. This
is an I2C temperature sensor on AMD SoCs.
config EMUL_AMD_SB_TSI
bool "Emulator for AMD SB-TSI"
default y
depends on AMD_SB_TSI
depends on EMUL
help
Enable the hardware emulator for the AMD SB-TSI.
``` | /content/code_sandbox/drivers/sensor/amd_sb_tsi/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 117 |
```c
/*
*
*/
#define DT_DRV_COMPAT amd_sb_tsi
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/pm/device_runtime.h>
#include <zephyr/logging/log.h>
#include "sb_tsi.h"
LOG_MODULE_REGISTER(AMD_SB_TSI, CONFIG_SENSOR_LOG_LEVEL);
struct sb_tsi_data {
uint8_t sample_int;
uint8_t sample_dec;
};
struct sb_tsi_config {
struct i2c_dt_spec i2c;
};
static int sb_tsi_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct sb_tsi_data *data = dev->data;
const struct sb_tsi_config *config = dev->config;
enum pm_device_state pm_state;
int res;
(void)pm_device_state_get(dev, &pm_state);
if (pm_state != PM_DEVICE_STATE_ACTIVE) {
return -EIO;
}
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
/*
* ReadOrder specifies the order for atomically reading the temp.
* The reset value is 0, which means reading Int latches Dec.
*/
res = i2c_reg_read_byte_dt(&config->i2c, SB_TSI_TEMP_INT, &data->sample_int);
if (res) {
return res;
}
res = i2c_reg_read_byte_dt(&config->i2c, SB_TSI_TEMP_DEC, &data->sample_dec);
if (res) {
return res;
}
return 0;
}
static int sb_tsi_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct sb_tsi_data *data = dev->data;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
val->val1 = data->sample_int;
val->val2 = (data->sample_dec >> SB_TSI_TEMP_DEC_SHIFT) *
(1000000 / SB_TSI_TEMP_DEC_SCALE);
return 0;
}
static const struct sensor_driver_api sb_tsi_driver_api = {
.sample_fetch = sb_tsi_sample_fetch,
.channel_get = sb_tsi_channel_get,
};
static int sb_tsi_init(const struct device *dev)
{
const struct sb_tsi_config *config = dev->config;
int res = 0;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_ERR("I2C device not ready");
return -ENODEV;
}
#ifdef CONFIG_PM_DEVICE_RUNTIME
pm_device_init_suspended(dev);
res = pm_device_runtime_enable(dev);
if (res) {
LOG_ERR("Failed to enable runtime power management");
}
#endif
return res;
}
#ifdef CONFIG_PM_DEVICE
static int sb_tsi_pm_action(const struct device *dev, enum pm_device_action action)
{
switch (action) {
case PM_DEVICE_ACTION_TURN_ON:
case PM_DEVICE_ACTION_RESUME:
case PM_DEVICE_ACTION_TURN_OFF:
case PM_DEVICE_ACTION_SUSPEND:
return 0;
default:
return -ENOTSUP;
}
}
#endif
#define SB_TSI_INST(inst) \
static struct sb_tsi_data sb_tsi_data_##inst; \
static const struct sb_tsi_config sb_tsi_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
PM_DEVICE_DT_INST_DEFINE(inst, sb_tsi_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, sb_tsi_init, PM_DEVICE_DT_INST_GET(inst), \
&sb_tsi_data_##inst, &sb_tsi_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &sb_tsi_driver_api);
DT_INST_FOREACH_STATUS_OKAY(SB_TSI_INST)
``` | /content/code_sandbox/drivers/sensor/amd_sb_tsi/sb_tsi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 842 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/nxp/fxas21002/Kconfig"
source "drivers/sensor/nxp/fxls8974/Kconfig"
source "drivers/sensor/nxp/fxos8700/Kconfig"
source "drivers/sensor/nxp/mcux_acmp/Kconfig"
source "drivers/sensor/nxp/mcux_lpcmp/Kconfig"
source "drivers/sensor/nxp/nxp_kinetis_temp/Kconfig"
source "drivers/sensor/nxp/nxp_tempmon/Kconfig"
source "drivers/sensor/nxp/qdec_mcux/Kconfig"
source "drivers/sensor/nxp/qdec_nxp_s32/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/nxp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 157 |
```c
/*
*/
#define DT_DRV_COMPAT amd_sb_tsi
#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 "sb_tsi.h"
LOG_MODULE_DECLARE(AMD_SB_TSI, CONFIG_SENSOR_LOG_LEVEL);
#define NUM_REGS 128
struct sb_tsi_emul_data {
uint8_t reg[NUM_REGS];
};
static void sb_tsi_emul_set_reg(const struct emul *target, uint8_t reg, uint8_t val)
{
struct sb_tsi_emul_data *data = target->data;
__ASSERT_NO_MSG(reg < NUM_REGS);
data->reg[reg] = val;
}
static uint8_t sb_tsi_emul_get_reg(const struct emul *target, uint8_t reg)
{
struct sb_tsi_emul_data *data = target->data;
__ASSERT_NO_MSG(reg < NUM_REGS);
return data->reg[reg];
}
static void sb_tsi_emul_reset(const struct emul *target)
{
struct sb_tsi_emul_data *data = target->data;
memset(data->reg, 0, NUM_REGS);
}
static int sb_tsi_emul_transfer_i2c(const struct emul *target, struct i2c_msg *msgs,
int num_msgs, int addr)
{
/* Largely copied from emul_bmi160.c */
unsigned int val;
int reg;
__ASSERT_NO_MSG(msgs && num_msgs);
i2c_dump_msgs_rw(target->dev, msgs, num_msgs, addr, false);
switch (num_msgs) {
case 2:
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;
}
reg = msgs->buf[0];
/* Now process the 'read' part of the message */
msgs++;
if (msgs->flags & I2C_MSG_READ) {
switch (msgs->len) {
case 1:
val = sb_tsi_emul_get_reg(target, reg);
msgs->buf[0] = val;
break;
default:
LOG_ERR("Unexpected msg1 length %d", msgs->len);
return -EIO;
}
} else {
if (msgs->len != 1) {
LOG_ERR("Unexpected msg1 length %d", msgs->len);
}
sb_tsi_emul_set_reg(target, reg, msgs->buf[0]);
}
break;
default:
LOG_ERR("Invalid number of messages: %d", num_msgs);
return -EIO;
}
return 0;
}
static int sb_tsi_emul_init(const struct emul *target, const struct device *parent)
{
sb_tsi_emul_reset(target);
return 0;
}
static int sb_tsi_emul_set_channel(const struct emul *target, struct sensor_chan_spec ch,
const q31_t *value, int8_t shift)
{
struct sb_tsi_emul_data *data = target->data;
int64_t scaled_value;
int32_t millicelsius;
int32_t reg_value;
if (ch.chan_type != SENSOR_CHAN_AMBIENT_TEMP && ch.chan_idx != 0) {
return -ENOTSUP;
}
scaled_value = (int64_t)*value << shift;
millicelsius = scaled_value * 1000 / ((int64_t)INT32_MAX + 1);
reg_value = CLAMP(millicelsius / 125, 0, 0x7ff);
data->reg[SB_TSI_TEMP_INT] = reg_value >> 3;
data->reg[SB_TSI_TEMP_DEC] = (reg_value & 0x7) << 5;
return 0;
}
static int sb_tsi_emul_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 (ch.chan_type != SENSOR_CHAN_AMBIENT_TEMP || ch.chan_idx != 0) {
return -ENOTSUP;
}
*shift = 8;
*lower = 0;
*upper = (int64_t)(255.875 * ((int64_t)INT32_MAX + 1)) >> *shift;
*epsilon = (int64_t)(0.125 * ((int64_t)INT32_MAX + 1)) >> *shift;
return 0;
}
static const struct i2c_emul_api sb_tsi_emul_api_i2c = {
.transfer = sb_tsi_emul_transfer_i2c,
};
static const struct emul_sensor_driver_api sb_tsi_emul_api_sensor = {
.set_channel = sb_tsi_emul_set_channel,
.get_sample_range = sb_tsi_emul_get_sample_range,
};
#define SB_TSI_EMUL(n) \
struct sb_tsi_emul_data sb_tsi_emul_data_##n; \
EMUL_DT_INST_DEFINE(n, sb_tsi_emul_init, &sb_tsi_emul_data_##n, NULL, \
&sb_tsi_emul_api_i2c, &sb_tsi_emul_api_sensor)
DT_INST_FOREACH_STATUS_OKAY(SB_TSI_EMUL)
``` | /content/code_sandbox/drivers/sensor/amd_sb_tsi/sb_tsi_emul.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,204 |
```objective-c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#define FXOS8700_BUS_I2C (1<<0)
#define FXOS8700_BUS_SPI (1<<1)
#define FXOS8700_REG_STATUS 0x00
#define FXOS8700_REG_OUTXMSB 0x01
#define FXOS8700_REG_INT_SOURCE 0x0c
#define FXOS8700_REG_WHOAMI 0x0d
#define FXOS8700_REG_XYZ_DATA_CFG 0x0e
#define FXOS8700_REG_FF_MT_CFG 0x15
#define FXOS8700_REG_FF_MT_SRC 0x16
#define FXOS8700_REG_FF_MT_THS 0x17
#define FXOS8700_REG_FF_MT_COUNT 0x18
#define FXOS8700_REG_PULSE_CFG 0x21
#define FXOS8700_REG_PULSE_SRC 0x22
#define FXOS8700_REG_PULSE_THSX 0x23
#define FXOS8700_REG_PULSE_THSY 0x24
#define FXOS8700_REG_PULSE_THSZ 0x25
#define FXOS8700_REG_PULSE_TMLT 0x26
#define FXOS8700_REG_PULSE_LTCY 0x27
#define FXOS8700_REG_PULSE_WIND 0x28
#define FXOS8700_REG_CTRLREG1 0x2a
#define FXOS8700_REG_CTRLREG2 0x2b
#define FXOS8700_REG_CTRLREG3 0x2c
#define FXOS8700_REG_CTRLREG4 0x2d
#define FXOS8700_REG_CTRLREG5 0x2e
#define FXOS8700_REG_M_OUTXMSB 0x33
#define FXOS8700_REG_TEMP 0x51
#define FXOS8700_REG_M_CTRLREG1 0x5b
#define FXOS8700_REG_M_CTRLREG2 0x5c
#define FXOS8700_REG_M_INT_SRC 0x5e
#define FXOS8700_REG_M_VECM_CFG 0x69
#define FXOS8700_REG_M_VECM_THS_MSB 0x6a
#define FXOS8700_REG_M_VECM_THS_LSB 0x6b
/* Devices that are compatible with this driver: */
#define WHOAMI_ID_MMA8451 0x1A
#define WHOAMI_ID_MMA8652 0x4A
#define WHOAMI_ID_MMA8653 0x5A
#define WHOAMI_ID_FXOS8700 0xC7
#define FXOS8700_DRDY_MASK (1 << 0)
#define FXOS8700_MAG_VECM_INT1_MASK (1 << 0)
#define FXOS8700_VECM_MASK (1 << 1)
#define FXOS8700_MOTION_MASK (1 << 2)
#define FXOS8700_PULSE_MASK (1 << 3)
#define FXOS8700_XYZ_DATA_CFG_FS_MASK 0x03
#define FXOS8700_PULSE_SRC_DPE (1 << 3)
#define FXOS8700_CTRLREG1_ACTIVE_MASK 0x01
#define FXOS8700_CTRLREG1_DR_MASK (7 << 3)
#define FXOS8700_CTRLREG1_DR_RATE_800 0
#define FXOS8700_CTRLREG1_DR_RATE_400 (1 << 3)
#define FXOS8700_CTRLREG1_DR_RATE_200 (2 << 3)
#define FXOS8700_CTRLREG1_DR_RATE_100 (3 << 3)
#define FXOS8700_CTRLREG1_DR_RATE_50 (4 << 3)
#define FXOS8700_CTRLREG1_DR_RATE_12_5 (5 << 3)
#define FXOS8700_CTRLREG1_DR_RATE_6_25 (6 << 3)
#define FXOS8700_CTRLREG1_DR_RATE_1_56 (7 << 3)
#define FXOS8700_CTRLREG2_RST_MASK 0x40
#define FXOS8700_CTRLREG2_MODS_MASK 0x03
#define FXOS8700_FF_MT_CFG_ELE BIT(7)
#define FXOS8700_FF_MT_CFG_OAE BIT(6)
#define FXOS8700_FF_MT_CFG_ZEFE BIT(5)
#define FXOS8700_FF_MT_CFG_YEFE BIT(4)
#define FXOS8700_FF_MT_CFG_XEFE BIT(3)
#define FXOS8700_FF_MT_THS_MASK 0x7f
#define FXOS8700_FF_MT_THS_SCALE (SENSOR_G * 63000LL / 1000000LL)
#define FXOS8700_M_CTRLREG1_MODE_MASK 0x03
#define FXOS8700_M_CTRLREG2_AUTOINC_MASK (1 << 5)
#define FXOS8700_NUM_ACCEL_CHANNELS 3
#define FXOS8700_NUM_MAG_CHANNELS 3
#define FXOS8700_NUM_HYBRID_CHANNELS 6
#define FXOS8700_MAX_NUM_CHANNELS 6
#define FXOS8700_BYTES_PER_CHANNEL_NORMAL 2
#define FXOS8700_BYTES_PER_CHANNEL_FAST 1
#define FXOS8700_MAX_NUM_BYTES (FXOS8700_BYTES_PER_CHANNEL_NORMAL * \
FXOS8700_MAX_NUM_CHANNELS)
enum fxos8700_power {
FXOS8700_POWER_STANDBY = 0,
FXOS8700_POWER_ACTIVE,
};
enum fxos8700_mode {
FXOS8700_MODE_ACCEL = 0,
FXOS8700_MODE_MAGN = 1,
FXOS8700_MODE_HYBRID = 3,
};
enum fxos8700_power_mode {
FXOS8700_PM_NORMAL = 0,
FXOS8700_PM_LOW_NOISE_LOW_POWER,
FXOS8700_PM_HIGH_RESOLUTION,
FXOS8700_PM_LOW_POWER,
};
enum fxos8700_channel {
FXOS8700_CHANNEL_ACCEL_X = 0,
FXOS8700_CHANNEL_ACCEL_Y,
FXOS8700_CHANNEL_ACCEL_Z,
FXOS8700_CHANNEL_MAGN_X,
FXOS8700_CHANNEL_MAGN_Y,
FXOS8700_CHANNEL_MAGN_Z,
};
/* FXOS8700 specific triggers */
enum fxos_trigger_type {
FXOS8700_TRIG_M_VECM,
};
struct fxos8700_io_ops {
int (*read)(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
int (*byte_read)(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int (*byte_write)(const struct device *dev,
uint8_t reg,
uint8_t byte);
int (*reg_field_update)(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
};
union fxos8700_bus_cfg {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
};
struct fxos8700_config {
const union fxos8700_bus_cfg bus_cfg;
const struct fxos8700_io_ops *ops;
#ifdef CONFIG_FXOS8700_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
struct gpio_dt_spec reset_gpio;
enum fxos8700_mode mode;
enum fxos8700_power_mode power_mode;
uint8_t range;
uint8_t start_addr;
uint8_t start_channel;
uint8_t num_channels;
#ifdef CONFIG_FXOS8700_PULSE
uint8_t pulse_cfg;
uint8_t pulse_ths[3];
uint8_t pulse_tmlt;
uint8_t pulse_ltcy;
uint8_t pulse_wind;
#endif
#ifdef CONFIG_FXOS8700_MAG_VECM
uint8_t mag_vecm_cfg;
uint8_t mag_vecm_ths[2];
#endif
uint8_t inst_on_bus;
};
struct fxos8700_data {
struct k_sem sem;
#ifdef CONFIG_FXOS8700_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trig;
#endif
#ifdef CONFIG_FXOS8700_PULSE
sensor_trigger_handler_t tap_handler;
const struct sensor_trigger *tap_trig;
sensor_trigger_handler_t double_tap_handler;
const struct sensor_trigger *double_tap_trig;
#endif
#ifdef CONFIG_FXOS8700_MOTION
sensor_trigger_handler_t motion_handler;
const struct sensor_trigger *motion_trig;
#endif
#ifdef CONFIG_FXOS8700_MAG_VECM
sensor_trigger_handler_t m_vecm_handler;
const struct sensor_trigger *m_vecm_trig;
#endif
#ifdef CONFIG_FXOS8700_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_FXOS8700_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#endif
#ifdef CONFIG_FXOS8700_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
int16_t raw[FXOS8700_MAX_NUM_CHANNELS];
#ifdef CONFIG_FXOS8700_TEMP
int8_t temp;
#endif
uint8_t whoami;
};
int fxos8700_get_power(const struct device *dev, enum fxos8700_power *power);
int fxos8700_set_power(const struct device *dev, enum fxos8700_power power);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
int fxos8700_byte_write_spi(const struct device *dev,
uint8_t reg,
uint8_t byte);
int fxos8700_byte_read_spi(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int fxos8700_reg_field_update_spi(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
int fxos8700_read_spi(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
int fxos8700_byte_write_i2c(const struct device *dev,
uint8_t reg,
uint8_t byte);
int fxos8700_byte_read_i2c(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int fxos8700_reg_field_update_i2c(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
int fxos8700_read_i2c(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
#endif
#if CONFIG_FXOS8700_TRIGGER
int fxos8700_trigger_init(const struct device *dev);
int fxos8700_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif
``` | /content/code_sandbox/drivers/sensor/nxp/fxos8700/fxos8700.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,484 |
```unknown
# FXOS8700 6-axis accelerometer/magnetometer
menuconfig FXOS8700
bool "FXOS8700 accelerometer/magnetometer driver"
default y
depends on DT_HAS_NXP_FXOS8700_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_NXP_FXOS8700),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_NXP_FXOS8700),spi)
help
Enable driver for the FXOS8700 accelerometer/magnetometer.
The driver also supports MMA8451Q, MMA8652FC and MMA8653FC
accelerometers. If the driver is used with one of these
accelerometers then the Accelerometer-only mode should be selected."
if FXOS8700
choice FXOS8700_MODE
prompt "Mode"
default FXOS8700_MODE_HYBRID
config FXOS8700_MODE_ACCEL
bool "Accelerometer-only mode"
config FXOS8700_MODE_MAGN
bool "Magnetometer-only mode"
config FXOS8700_MODE_HYBRID
bool "Hybrid (accel+mag) mode"
endchoice
config FXOS8700_TEMP
bool "Temperature"
depends on FXOS8700_MODE_MAGN || FXOS8700_MODE_HYBRID
help
Enable the temperature sensor. Note that the temperature sensor is
uncalibrated and its output for a given temperature may vary from one
device to the next.
choice
prompt "Trigger mode"
default FXOS8700_TRIGGER_NONE
config FXOS8700_TRIGGER_NONE
bool "No trigger"
config FXOS8700_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
select FXOS8700_TRIGGER
config FXOS8700_TRIGGER_OWN_THREAD
bool "Use own thread"
select FXOS8700_TRIGGER
endchoice
config FXOS8700_TRIGGER
bool
config FXOS8700_DRDY_INT1
bool "Data ready interrupt to INT1 pin"
depends on FXOS8700_TRIGGER
help
Say Y to route data ready interrupt to INT1 pin. Say N to route to
INT2 pin.
if FXOS8700_TRIGGER
config FXOS8700_THREAD_PRIORITY
int "Own thread priority"
depends on FXOS8700_TRIGGER_OWN_THREAD
default 10
config FXOS8700_THREAD_STACK_SIZE
int "Own thread stack size"
depends on FXOS8700_TRIGGER_OWN_THREAD
default 1024
menuconfig FXOS8700_PULSE
bool "Pulse detection"
help
Enable pulse detection
if FXOS8700_PULSE
config FXOS8700_PULSE_INT1
bool "Pulse interrupt to INT1 pin"
help
Say Y to route pulse interrupt to INT1 pin. Say N to route to INT2 pin.
endif # FXOS8700_PULSE
menuconfig FXOS8700_MOTION
bool "Motion detection"
help
Enable motion detection
config FXOS8700_MOTION_INT1
bool "Motion interrupt to INT1 pin"
depends on FXOS8700_MOTION
help
Say Y to route motion interrupt to INT1 pin. Say N to route to INT2 pin.
menuconfig FXOS8700_MAG_VECM
bool "Magnetic vector-magnitude detection"
help
Enable magnetic vector-magnitude detection
if FXOS8700_MAG_VECM
config FXOS8700_MAG_VECM_INT1
bool "Magnetic vector-magnitude interrupt to INT1 pin"
help
Say Y to route magnetic vector-magnitude interrupt to INT1 pin.
Say N to route to INT2 pin.
endif # FXOS8700_MAG_VECM
endif # FXOS8700_TRIGGER
endif # FXOS8700
``` | /content/code_sandbox/drivers/sensor/nxp/fxos8700/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 797 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_fxos8700
#include "fxos8700.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(FXOS8700, CONFIG_SENSOR_LOG_LEVEL);
static void fxos8700_gpio_callback(const struct device *dev,
struct gpio_callback *cb,
uint32_t pin_mask)
{
struct fxos8700_data *data =
CONTAINER_OF(cb, struct fxos8700_data, gpio_cb);
const struct fxos8700_config *config = data->dev->config;
if ((pin_mask & BIT(config->int_gpio.pin)) == 0U) {
return;
}
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_FXOS8700_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_FXOS8700_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static int fxos8700_handle_drdy_int(const struct device *dev)
{
struct fxos8700_data *data = dev->data;
if (data->drdy_handler) {
data->drdy_handler(dev, data->drdy_trig);
}
return 0;
}
#ifdef CONFIG_FXOS8700_PULSE
static int fxos8700_handle_pulse_int(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
sensor_trigger_handler_t handler = NULL;
const struct sensor_trigger *trig = NULL;
uint8_t pulse_source;
k_sem_take(&data->sem, K_FOREVER);
if (config->ops->byte_read(dev, FXOS8700_REG_PULSE_SRC,
&pulse_source)) {
LOG_ERR("Could not read pulse source");
}
k_sem_give(&data->sem);
if (pulse_source & FXOS8700_PULSE_SRC_DPE) {
handler = data->double_tap_handler;
trig = data->double_tap_trig;
} else {
handler = data->tap_handler;
trig = data->tap_trig;
}
if (handler) {
handler(dev, trig);
}
return 0;
}
#endif
#ifdef CONFIG_FXOS8700_MOTION
static int fxos8700_handle_motion_int(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
sensor_trigger_handler_t handler = data->motion_handler;
uint8_t motion_source;
k_sem_take(&data->sem, K_FOREVER);
if (config->ops->byte_read(dev, FXOS8700_REG_FF_MT_SRC,
&motion_source)) {
LOG_ERR("Could not read pulse source");
}
k_sem_give(&data->sem);
if (handler) {
LOG_DBG("FF_MT_SRC 0x%x", motion_source);
handler(dev, data->motion_trig);
}
return 0;
}
#endif
#ifdef CONFIG_FXOS8700_MAG_VECM
static int fxos8700_handle_m_vecm_int(const struct device *dev)
{
struct fxos8700_data *data = dev->data;
if (data->m_vecm_handler) {
data->m_vecm_handler(dev, data->m_vecm_trig);
}
return 0;
}
#endif
static void fxos8700_handle_int(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
uint8_t int_source;
/* Interrupt status register */
k_sem_take(&data->sem, K_FOREVER);
if (config->ops->byte_read(dev, FXOS8700_REG_INT_SOURCE,
&int_source)) {
LOG_ERR("Could not read interrupt source");
int_source = 0U;
}
k_sem_give(&data->sem);
if (int_source & FXOS8700_DRDY_MASK) {
fxos8700_handle_drdy_int(dev);
}
#ifdef CONFIG_FXOS8700_PULSE
if (int_source & FXOS8700_PULSE_MASK) {
fxos8700_handle_pulse_int(dev);
}
#endif
#ifdef CONFIG_FXOS8700_MOTION
if (int_source & FXOS8700_MOTION_MASK) {
fxos8700_handle_motion_int(dev);
}
#endif
#ifdef CONFIG_FXOS8700_MAG_VECM
/* Magnetometer interrupt source register */
k_sem_take(&data->sem, K_FOREVER);
if (config->ops->byte_read(dev, FXOS8700_REG_M_INT_SRC,
&int_source)) {
LOG_ERR("Could not read magnetometer interrupt source");
int_source = 0U;
}
k_sem_give(&data->sem);
if (int_source & FXOS8700_VECM_MASK) {
fxos8700_handle_m_vecm_int(dev);
}
#endif
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
#ifdef CONFIG_FXOS8700_TRIGGER_OWN_THREAD
static void fxos8700_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct fxos8700_data *data = p1;
while (true) {
k_sem_take(&data->trig_sem, K_FOREVER);
fxos8700_handle_int(data->dev);
}
}
#endif
#ifdef CONFIG_FXOS8700_TRIGGER_GLOBAL_THREAD
static void fxos8700_work_handler(struct k_work *work)
{
struct fxos8700_data *data =
CONTAINER_OF(work, struct fxos8700_data, work);
fxos8700_handle_int(data->dev);
}
#endif
int fxos8700_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
enum fxos8700_power power = FXOS8700_POWER_STANDBY;
uint8_t mask;
int ret = 0;
k_sem_take(&data->sem, K_FOREVER);
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
mask = FXOS8700_DRDY_MASK;
data->drdy_handler = handler;
data->drdy_trig = trig;
break;
#ifdef CONFIG_FXOS8700_PULSE
case SENSOR_TRIG_TAP:
mask = FXOS8700_PULSE_MASK;
data->tap_handler = handler;
data->tap_trig = trig;
break;
case SENSOR_TRIG_DOUBLE_TAP:
mask = FXOS8700_PULSE_MASK;
data->double_tap_handler = handler;
data->double_tap_trig = trig;
break;
#endif
#ifdef CONFIG_FXOS8700_MOTION
case SENSOR_TRIG_DELTA:
mask = FXOS8700_MOTION_MASK;
data->motion_handler = handler;
data->motion_trig = trig;
break;
#endif
#ifdef CONFIG_FXOS8700_MAG_VECM
case FXOS8700_TRIG_M_VECM:
mask = FXOS8700_VECM_MASK;
data->m_vecm_handler = handler;
data->m_vecm_trig = trig;
break;
#endif
default:
LOG_ERR("Unsupported sensor trigger");
ret = -ENOTSUP;
goto exit;
}
/* The sensor must be in standby mode when writing the configuration
* registers, therefore get the current power mode so we can restore it
* later.
*/
if (fxos8700_get_power(dev, &power)) {
LOG_ERR("Could not get power mode");
ret = -EIO;
goto exit;
}
/* Put the sensor in standby mode */
if (fxos8700_set_power(dev, FXOS8700_POWER_STANDBY)) {
LOG_ERR("Could not set standby mode");
ret = -EIO;
goto exit;
}
/* Configure the sensor interrupt */
if (config->ops->reg_field_update(dev, FXOS8700_REG_CTRLREG4, mask,
handler ? mask : 0)) {
LOG_ERR("Could not configure interrupt");
ret = -EIO;
goto exit;
}
/* Restore the previous power mode */
if (fxos8700_set_power(dev, power)) {
LOG_ERR("Could not restore power mode");
ret = -EIO;
goto exit;
}
exit:
k_sem_give(&data->sem);
return ret;
}
#ifdef CONFIG_FXOS8700_PULSE
static int fxos8700_pulse_init(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
if (config->ops->byte_write(dev, FXOS8700_REG_PULSE_CFG,
config->pulse_cfg)) {
return -EIO;
}
if (config->ops->byte_write(dev, FXOS8700_REG_PULSE_THSX,
config->pulse_ths[0])) {
return -EIO;
}
if (config->ops->byte_write(dev, FXOS8700_REG_PULSE_THSY,
config->pulse_ths[1])) {
return -EIO;
}
if (config->ops->byte_write(dev, FXOS8700_REG_PULSE_THSZ,
config->pulse_ths[2])) {
return -EIO;
}
if (config->ops->byte_write(dev, FXOS8700_REG_PULSE_TMLT,
config->pulse_tmlt)) {
return -EIO;
}
if (config->ops->byte_write(dev, FXOS8700_REG_PULSE_LTCY,
config->pulse_ltcy)) {
return -EIO;
}
if (config->ops->byte_write(dev, FXOS8700_REG_PULSE_WIND,
config->pulse_wind)) {
return -EIO;
}
return 0;
}
#endif
#ifdef CONFIG_FXOS8700_MOTION
static int fxos8700_motion_init(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
/* Set Mode 4, Motion detection with ELE = 1, OAE = 1 */
if (config->ops->byte_write(dev,
FXOS8700_REG_FF_MT_CFG,
FXOS8700_FF_MT_CFG_ELE |
FXOS8700_FF_MT_CFG_OAE |
FXOS8700_FF_MT_CFG_ZEFE |
FXOS8700_FF_MT_CFG_YEFE |
FXOS8700_FF_MT_CFG_XEFE)) {
return -EIO;
}
/* Set motion threshold to maximimum */
if (config->ops->byte_write(dev, FXOS8700_REG_FF_MT_THS,
FXOS8700_REG_FF_MT_THS)) {
return -EIO;
}
return 0;
}
#endif
#ifdef CONFIG_FXOS8700_MAG_VECM
static int fxos8700_m_vecm_init(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
uint8_t m_vecm_cfg = config->mag_vecm_cfg;
/* Route the interrupt to INT1 pin */
#if CONFIG_FXOS8700_MAG_VECM_INT1
m_vecm_cfg |= FXOS8700_MAG_VECM_INT1_MASK;
#endif
/* Set magnetic vector-magnitude function */
if (config->ops->byte_write(dev, FXOS8700_REG_M_VECM_CFG,
m_vecm_cfg)) {
LOG_ERR("Could not set magnetic vector-magnitude function");
return -EIO;
}
/* Set magnetic vector-magnitude function threshold values:
* handle both MSB and LSB registers
*/
if (config->ops->byte_write(dev, FXOS8700_REG_M_VECM_THS_MSB,
config->mag_vecm_ths[0])) {
LOG_ERR("Could not set magnetic vector-magnitude function threshold MSB value");
return -EIO;
}
if (config->ops->byte_write(dev, FXOS8700_REG_M_VECM_THS_LSB,
config->mag_vecm_ths[1])) {
LOG_ERR("Could not set magnetic vector-magnitude function threshold LSB value");
return -EIO;
}
return 0;
}
#endif
int fxos8700_trigger_init(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
uint8_t ctrl_reg5;
int ret;
data->dev = dev;
#if defined(CONFIG_FXOS8700_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_FXOS8700_THREAD_STACK_SIZE,
fxos8700_thread_main,
data, NULL, NULL,
K_PRIO_COOP(CONFIG_FXOS8700_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_FXOS8700_TRIGGER_GLOBAL_THREAD)
data->work.handler = fxos8700_work_handler;
#endif
/* Route the interrupts to INT1/INT2 pins */
ctrl_reg5 = 0U;
#if CONFIG_FXOS8700_DRDY_INT1
ctrl_reg5 |= FXOS8700_DRDY_MASK;
#endif
#if CONFIG_FXOS8700_PULSE_INT1
ctrl_reg5 |= FXOS8700_PULSE_MASK;
#endif
#if CONFIG_FXOS8700_MOTION_INT1
ctrl_reg5 |= FXOS8700_MOTION_MASK;
#endif
if (config->ops->byte_write(dev, FXOS8700_REG_CTRLREG5,
ctrl_reg5)) {
LOG_ERR("Could not configure interrupt pin routing");
return -EIO;
}
#ifdef CONFIG_FXOS8700_PULSE
if (fxos8700_pulse_init(dev)) {
LOG_ERR("Could not configure pulse");
return -EIO;
}
#endif
#ifdef CONFIG_FXOS8700_MOTION
if (fxos8700_motion_init(dev)) {
LOG_ERR("Could not configure motion");
return -EIO;
}
#endif
#ifdef CONFIG_FXOS8700_MAG_VECM
if (fxos8700_m_vecm_init(dev)) {
LOG_ERR("Could not configure magnetic vector-magnitude");
return -EIO;
}
#endif
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
ret = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
if (ret < 0) {
return ret;
}
gpio_init_callback(&data->gpio_cb, fxos8700_gpio_callback,
BIT(config->int_gpio.pin));
ret = gpio_add_callback(config->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/nxp/fxos8700/fxos8700_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,279 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_kinetis_acmp
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/mcux_acmp.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <fsl_acmp.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/irq.h>
LOG_MODULE_REGISTER(mcux_acmp, CONFIG_SENSOR_LOG_LEVEL);
#define MCUX_ACMP_DAC_LEVELS 256
#define MCUX_ACMP_INPUT_CHANNELS 8
/*
* Ensure the underlying MCUX definitions match the driver shim
* assumptions. This saves us from converting between integers and
* MCUX enumerations for sensor attributes.
*/
#if MCUX_ACMP_HAS_OFFSET
BUILD_ASSERT(kACMP_OffsetLevel0 == 0);
BUILD_ASSERT(kACMP_OffsetLevel1 == 1);
#endif /* MCUX_ACMP_HAS_OFFSET */
BUILD_ASSERT(kACMP_HysteresisLevel0 == 0);
BUILD_ASSERT(kACMP_HysteresisLevel1 == 1);
BUILD_ASSERT(kACMP_HysteresisLevel2 == 2);
BUILD_ASSERT(kACMP_HysteresisLevel3 == 3);
BUILD_ASSERT(kACMP_VrefSourceVin1 == 0);
BUILD_ASSERT(kACMP_VrefSourceVin2 == 1);
#if MCUX_ACMP_HAS_INPSEL || MCUX_ACMP_HAS_INNSEL
BUILD_ASSERT(kACMP_PortInputFromDAC == 0);
BUILD_ASSERT(kACMP_PortInputFromMux == 1);
#endif /* MCUX_ACMP_HAS_INPSEL || MCUX_ACMP_HAS_INNSEL */
struct mcux_acmp_config {
CMP_Type *base;
acmp_filter_config_t filter;
const struct pinctrl_dev_config *pincfg;
#ifdef CONFIG_MCUX_ACMP_TRIGGER
void (*irq_config_func)(const struct device *dev);
#endif /* CONFIG_MCUX_ACMP_TRIGGER */
bool high_speed : 1;
bool unfiltered : 1;
bool output : 1;
bool window : 1;
};
struct mcux_acmp_data {
acmp_config_t config;
acmp_channel_config_t channels;
acmp_dac_config_t dac;
#if MCUX_ACMP_HAS_DISCRETE_MODE
acmp_discrete_mode_config_t discrete_config;
#endif
#ifdef CONFIG_MCUX_ACMP_TRIGGER
const struct device *dev;
sensor_trigger_handler_t rising_handler;
const struct sensor_trigger *rising_trigger;
sensor_trigger_handler_t falling_handler;
const struct sensor_trigger *falling_trigger;
struct k_work work;
volatile uint32_t status;
#endif /* CONFIG_MCUX_ACMP_TRIGGER */
bool cout;
};
static int mcux_acmp_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct mcux_acmp_config *config = dev->config;
struct mcux_acmp_data *data = dev->data;
int32_t val1;
__ASSERT_NO_MSG(val != NULL);
if ((int16_t)chan != SENSOR_CHAN_MCUX_ACMP_OUTPUT) {
return -ENOTSUP;
}
if (val->val2 != 0) {
return -EINVAL;
}
val1 = val->val1;
switch ((int16_t)attr) {
#if MCUX_ACMP_HAS_OFFSET
case SENSOR_ATTR_MCUX_ACMP_OFFSET_LEVEL:
if (val1 >= kACMP_OffsetLevel0 &&
val1 <= kACMP_OffsetLevel1) {
LOG_DBG("offset = %d", val1);
data->config.offsetMode = val1;
ACMP_Init(config->base, &data->config);
ACMP_Enable(config->base, true);
} else {
return -EINVAL;
}
break;
#endif /* MCUX_ACMP_HAS_OFFSET */
case SENSOR_ATTR_MCUX_ACMP_HYSTERESIS_LEVEL:
if (val1 >= kACMP_HysteresisLevel0 &&
val1 <= kACMP_HysteresisLevel3) {
LOG_DBG("hysteresis = %d", val1);
data->config.hysteresisMode = val1;
ACMP_Init(config->base, &data->config);
ACMP_Enable(config->base, true);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_DAC_VOLTAGE_REFERENCE:
if (val1 >= kACMP_VrefSourceVin1 &&
val1 <= kACMP_VrefSourceVin2) {
LOG_DBG("vref = %d", val1);
data->dac.referenceVoltageSource = val1;
ACMP_SetDACConfig(config->base, &data->dac);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_DAC_VALUE:
if (val1 >= 0 && val1 < MCUX_ACMP_DAC_LEVELS) {
LOG_DBG("dac = %d", val1);
data->dac.DACValue = val1;
ACMP_SetDACConfig(config->base, &data->dac);
} else {
return -EINVAL;
}
break;
#if MCUX_ACMP_HAS_INPSEL
case SENSOR_ATTR_MCUX_ACMP_POSITIVE_PORT_INPUT:
if (val1 >= kACMP_PortInputFromDAC &&
val1 <= kACMP_PortInputFromMux) {
LOG_DBG("pport = %d", val1);
data->channels.positivePortInput = val1;
ACMP_SetChannelConfig(config->base, &data->channels);
} else {
return -EINVAL;
}
break;
#endif /* MCUX_ACMP_HAS_INPSEL */
case SENSOR_ATTR_MCUX_ACMP_POSITIVE_MUX_INPUT:
if (val1 >= 0 && val1 < MCUX_ACMP_INPUT_CHANNELS) {
LOG_DBG("pmux = %d", val1);
data->channels.plusMuxInput = val1;
ACMP_SetChannelConfig(config->base, &data->channels);
} else {
return -EINVAL;
}
break;
#if MCUX_ACMP_HAS_INNSEL
case SENSOR_ATTR_MCUX_ACMP_NEGATIVE_PORT_INPUT:
if (val1 >= kACMP_PortInputFromDAC &&
val1 <= kACMP_PortInputFromMux) {
LOG_DBG("nport = %d", val1);
data->channels.negativePortInput = val1;
ACMP_SetChannelConfig(config->base, &data->channels);
} else {
return -EINVAL;
}
break;
#endif /* MCUX_ACMP_HAS_INNSEL */
case SENSOR_ATTR_MCUX_ACMP_NEGATIVE_MUX_INPUT:
if (val1 >= 0 && val1 < MCUX_ACMP_INPUT_CHANNELS) {
LOG_DBG("nmux = %d", val1);
data->channels.minusMuxInput = val1;
ACMP_SetChannelConfig(config->base, &data->channels);
} else {
return -EINVAL;
}
break;
#if MCUX_ACMP_HAS_DISCRETE_MODE
case SENSOR_ATTR_MCUX_ACMP_POSITIVE_DISCRETE_MODE:
if (val1 <= 1 && val1 >= 0) {
LOG_DBG("pdiscrete = %d", val1);
data->discrete_config.enablePositiveChannelDiscreteMode = val1;
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_NEGATIVE_DISCRETE_MODE:
if (val1 <= 1 && val1 >= 0) {
LOG_DBG("ndiscrete = %d", val1);
data->discrete_config.enableNegativeChannelDiscreteMode = val1;
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_CLOCK:
if (val1 <= kACMP_DiscreteClockFast && val1 >= kACMP_DiscreteClockSlow) {
LOG_DBG("discreteClk = %d", val1);
data->discrete_config.clockSource = val1;
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_ENABLE_RESISTOR_DIVIDER:
if (val1 <= 1 && val1 >= 0) {
LOG_DBG("discreteClk = %d", val1);
data->discrete_config.enableResistorDivider = val1;
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_SAMPLE_TIME:
if (val1 <= kACMP_DiscreteSampleTimeAs256T &&
val1 >= kACMP_DiscreteSampleTimeAs1T) {
LOG_DBG("discrete sampleTime = %d", val1);
data->discrete_config.sampleTime = val1;
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_PHASE1_TIME:
if (val1 <= kACMP_DiscretePhaseTimeAlt7 && val1 >= kACMP_DiscretePhaseTimeAlt0) {
LOG_DBG("discrete phase1Time = %d", val1);
data->discrete_config.phase1Time = val1;
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_PHASE2_TIME:
if (val1 <= kACMP_DiscretePhaseTimeAlt7 && val1 >= kACMP_DiscretePhaseTimeAlt0) {
LOG_DBG("discrete phase2Time = %d", val1);
data->discrete_config.phase2Time = val1;
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
} else {
return -EINVAL;
}
break;
#endif /* MCUX_ACMP_HAS_DISCRETE_MODE */
default:
return -ENOTSUP;
}
return 0;
}
static int mcux_acmp_attr_get(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
struct sensor_value *val)
{
struct mcux_acmp_data *data = dev->data;
__ASSERT_NO_MSG(val != NULL);
if ((int16_t)chan != SENSOR_CHAN_MCUX_ACMP_OUTPUT) {
return -ENOTSUP;
}
switch ((int16_t)attr) {
#if MCUX_ACMP_HAS_OFFSET
case SENSOR_ATTR_MCUX_ACMP_OFFSET_LEVEL:
val->val1 = data->config.offsetMode;
break;
#endif /* MCUX_ACMP_HAS_OFFSET */
case SENSOR_ATTR_MCUX_ACMP_HYSTERESIS_LEVEL:
val->val1 = data->config.hysteresisMode;
break;
case SENSOR_ATTR_MCUX_ACMP_DAC_VOLTAGE_REFERENCE:
val->val1 = data->dac.referenceVoltageSource;
break;
case SENSOR_ATTR_MCUX_ACMP_DAC_VALUE:
val->val1 = data->dac.DACValue;
break;
#if MCUX_ACMP_HAS_INPSEL
case SENSOR_ATTR_MCUX_ACMP_POSITIVE_PORT_INPUT:
val->val1 = data->channels.positivePortInput;
break;
#endif /* MCUX_ACMP_HAS_INPSEL */
case SENSOR_ATTR_MCUX_ACMP_POSITIVE_MUX_INPUT:
val->val1 = data->channels.plusMuxInput;
break;
#if MCUX_ACMP_HAS_INNSEL
case SENSOR_ATTR_MCUX_ACMP_NEGATIVE_PORT_INPUT:
val->val1 = data->channels.negativePortInput;
break;
#endif /* MCUX_ACMP_HAS_INNSEL */
case SENSOR_ATTR_MCUX_ACMP_NEGATIVE_MUX_INPUT:
val->val1 = data->channels.minusMuxInput;
break;
#if MCUX_ACMP_HAS_DISCRETE_MODE
case SENSOR_ATTR_MCUX_ACMP_POSITIVE_DISCRETE_MODE:
val->val1 = data->discrete_config.enablePositiveChannelDiscreteMode;
break;
case SENSOR_ATTR_MCUX_ACMP_NEGATIVE_DISCRETE_MODE:
val->val1 = data->discrete_config.enableNegativeChannelDiscreteMode;
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_CLOCK:
val->val1 = data->discrete_config.clockSource;
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_ENABLE_RESISTOR_DIVIDER:
val->val1 = data->discrete_config.enableResistorDivider;
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_SAMPLE_TIME:
val->val1 = data->discrete_config.sampleTime;
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_PHASE1_TIME:
val->val1 = data->discrete_config.phase1Time;
break;
case SENSOR_ATTR_MCUX_ACMP_DISCRETE_PHASE2_TIME:
val->val1 = data->discrete_config.phase2Time;
break;
#endif /* MCUX_ACMP_HAS_DISCRETE_MODE */
default:
return -ENOTSUP;
}
val->val2 = 0;
return 0;
}
static int mcux_acmp_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct mcux_acmp_config *config = dev->config;
struct mcux_acmp_data *data = dev->data;
uint32_t status;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_ALL &&
(int16_t)chan != SENSOR_CHAN_MCUX_ACMP_OUTPUT) {
return -ENOTSUP;
}
status = ACMP_GetStatusFlags(config->base);
data->cout = status & kACMP_OutputAssertEventFlag;
return 0;
}
static int mcux_acmp_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct mcux_acmp_data *data = dev->data;
__ASSERT_NO_MSG(val != NULL);
if ((int16_t)chan != SENSOR_CHAN_MCUX_ACMP_OUTPUT) {
return -ENOTSUP;
}
val->val1 = data->cout ? 1 : 0;
val->val2 = 0;
return 0;
}
#ifdef CONFIG_MCUX_ACMP_TRIGGER
static int mcux_acmp_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct mcux_acmp_data *data = dev->data;
__ASSERT_NO_MSG(trig != NULL);
if ((int16_t)trig->chan != SENSOR_CHAN_MCUX_ACMP_OUTPUT) {
return -ENOTSUP;
}
switch ((int16_t)trig->type) {
case SENSOR_TRIG_MCUX_ACMP_OUTPUT_RISING:
data->rising_handler = handler;
data->rising_trigger = trig;
break;
case SENSOR_TRIG_MCUX_ACMP_OUTPUT_FALLING:
data->falling_handler = handler;
data->falling_trigger = trig;
break;
default:
return -ENOTSUP;
}
return 0;
}
static void mcux_acmp_trigger_work_handler(struct k_work *item)
{
const struct sensor_trigger *trigger;
struct mcux_acmp_data *data =
CONTAINER_OF(item, struct mcux_acmp_data, work);
sensor_trigger_handler_t handler = NULL;
if (data->status & kACMP_OutputRisingEventFlag) {
handler = data->rising_handler;
trigger = data->rising_trigger;
} else if (data->status & kACMP_OutputFallingEventFlag) {
handler = data->falling_handler;
trigger = data->falling_trigger;
}
if (handler) {
handler(data->dev, trigger);
}
}
static void mcux_acmp_isr(const struct device *dev)
{
const struct mcux_acmp_config *config = dev->config;
struct mcux_acmp_data *data = dev->data;
data->status = ACMP_GetStatusFlags(config->base);
ACMP_ClearStatusFlags(config->base, data->status);
LOG_DBG("isr status = 0x%08x", data->status);
k_work_submit(&data->work);
}
#endif /* CONFIG_MCUX_ACMP_TRIGGER */
static int mcux_acmp_init(const struct device *dev)
{
const struct mcux_acmp_config *config = dev->config;
struct mcux_acmp_data *data = dev->data;
int err;
err = pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT);
if (err) {
return err;
}
ACMP_GetDefaultConfig(&data->config);
data->config.enableHighSpeed = config->high_speed;
data->config.useUnfilteredOutput = config->unfiltered;
data->config.enablePinOut = config->output;
ACMP_Init(config->base, &data->config);
#if MCUX_ACMP_HAS_DISCRETE_MODE
ACMP_GetDefaultDiscreteModeConfig(&data->discrete_config);
ACMP_SetDiscreteModeConfig(config->base, &data->discrete_config);
#endif
ACMP_EnableWindowMode(config->base, config->window);
ACMP_SetFilterConfig(config->base, &config->filter);
ACMP_SetChannelConfig(config->base, &data->channels);
/* Disable DAC */
ACMP_SetDACConfig(config->base, NULL);
#ifdef CONFIG_MCUX_ACMP_TRIGGER
data->dev = dev;
k_work_init(&data->work, mcux_acmp_trigger_work_handler);
config->irq_config_func(dev);
ACMP_EnableInterrupts(config->base,
kACMP_OutputRisingInterruptEnable |
kACMP_OutputFallingInterruptEnable);
#endif /* CONFIG_MCUX_ACMP_TRIGGER */
ACMP_Enable(config->base, true);
return 0;
}
static const struct sensor_driver_api mcux_acmp_driver_api = {
.attr_set = mcux_acmp_attr_set,
.attr_get = mcux_acmp_attr_get,
#ifdef CONFIG_MCUX_ACMP_TRIGGER
.trigger_set = mcux_acmp_trigger_set,
#endif /* CONFIG_MCUX_ACMP_TRIGGER */
.sample_fetch = mcux_acmp_sample_fetch,
.channel_get = mcux_acmp_channel_get,
};
#define MCUX_ACMP_DECLARE_CONFIG(n, config_func_init) \
static const struct mcux_acmp_config mcux_acmp_config_##n = { \
.base = (CMP_Type *)DT_INST_REG_ADDR(n), \
.filter = { \
.enableSample = DT_INST_PROP(n, nxp_enable_sample), \
.filterCount = DT_INST_PROP_OR(n, nxp_filter_count, 0), \
.filterPeriod = DT_INST_PROP_OR(n, nxp_filter_period, 0), \
}, \
.high_speed = DT_INST_PROP(n, nxp_high_speed_mode), \
.unfiltered = DT_INST_PROP(n, nxp_use_unfiltered_output), \
.output = DT_INST_PROP(n, nxp_enable_output_pin), \
.window = DT_INST_PROP(n, nxp_window_mode), \
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \
config_func_init \
}
#ifdef CONFIG_MCUX_ACMP_TRIGGER
#define MCUX_ACMP_CONFIG_FUNC(n) \
static void mcux_acmp_config_func_##n(const struct device *dev) \
{ \
IRQ_CONNECT(DT_INST_IRQN(n), \
DT_INST_IRQ(n, priority), \
mcux_acmp_isr, \
DEVICE_DT_INST_GET(n), 0); \
irq_enable(DT_INST_IRQN(n)); \
}
#define MCUX_ACMP_CONFIG_FUNC_INIT(n) \
.irq_config_func = mcux_acmp_config_func_##n
#define MCUX_ACMP_INIT_CONFIG(n) \
MCUX_ACMP_DECLARE_CONFIG(n, MCUX_ACMP_CONFIG_FUNC_INIT(n))
#else /* !CONFIG_MCUX_ACMP_TRIGGER */
#define MCUX_ACMP_CONFIG_FUNC(n)
#define MCUX_ACMP_CONFIG_FUNC_INIT
#define MCUX_ACMP_INIT_CONFIG(n) \
MCUX_ACMP_DECLARE_CONFIG(n, MCUX_ACMP_CONFIG_FUNC_INIT)
#endif /* !CONFIG_MCUX_ACMP_TRIGGER */
#define MCUX_ACMP_INIT(n) \
static struct mcux_acmp_data mcux_acmp_data_##n; \
\
static const struct mcux_acmp_config mcux_acmp_config_##n; \
\
PINCTRL_DT_INST_DEFINE(n); \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, &mcux_acmp_init, \
NULL, \
&mcux_acmp_data_##n, \
&mcux_acmp_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&mcux_acmp_driver_api); \
MCUX_ACMP_CONFIG_FUNC(n) \
MCUX_ACMP_INIT_CONFIG(n);
DT_INST_FOREACH_STATUS_OKAY(MCUX_ACMP_INIT)
``` | /content/code_sandbox/drivers/sensor/nxp/mcux_acmp/mcux_acmp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,641 |
```unknown
# NXP MCUX analog comparator (ACMP) configuration options
config MCUX_ACMP
bool "NXP MCUX Analog Comparator (ACMP)"
default y
depends on DT_HAS_NXP_KINETIS_ACMP_ENABLED
select PINCTRL
help
Enable driver for the NXP MCUX Analog Comparator (ACMP).
config MCUX_ACMP_TRIGGER
bool "Trigger support"
depends on MCUX_ACMP
help
Enable trigger support for the NXP MCUX Analog Comparator
(ACMP).
``` | /content/code_sandbox/drivers/sensor/nxp/mcux_acmp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 111 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_fxos8700
#include "fxos8700.h"
#include <zephyr/sys/util.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <stdlib.h>
LOG_MODULE_REGISTER(FXOS8700, CONFIG_SENSOR_LOG_LEVEL);
/* Convert the range (8g, 4g, 2g) to the encoded FS register field value */
#define RANGE2FS(x) (__builtin_ctz(x) - 1)
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define DIR_READ(a) ((a) & 0x7f)
#define DIR_WRITE(a) ((a) | BIT(7))
#define ADDR_7(a) ((a) & BIT(7))
int fxos8700_transceive(const struct device *dev,
void *data, size_t length)
{
const struct fxos8700_config *cfg = dev->config;
const struct spi_buf buf = { .buf = data, .len = length };
const struct spi_buf_set s = { .buffers = &buf, .count = 1 };
return spi_transceive_dt(&cfg->bus_cfg.spi, &s, &s);
}
int fxos8700_read_spi(const struct device *dev,
uint8_t reg,
void *data,
size_t length)
{
const struct fxos8700_config *cfg = dev->config;
/* Reads must clock out a dummy byte after sending the address. */
uint8_t reg_buf[3] = { DIR_READ(reg), ADDR_7(reg), 0 };
const struct spi_buf buf[2] = {
{ .buf = reg_buf, .len = 3 },
{ .buf = data, .len = length }
};
const struct spi_buf_set tx = { .buffers = buf, .count = 1 };
const struct spi_buf_set rx = { .buffers = buf, .count = 2 };
return spi_transceive_dt(&cfg->bus_cfg.spi, &tx, &rx);
}
int fxos8700_byte_read_spi(const struct device *dev,
uint8_t reg,
uint8_t *byte)
{
/* Reads must clock out a dummy byte after sending the address. */
uint8_t data[] = { DIR_READ(reg), ADDR_7(reg), 0};
int ret;
ret = fxos8700_transceive(dev, data, sizeof(data));
*byte = data[2];
return ret;
}
int fxos8700_byte_write_spi(const struct device *dev,
uint8_t reg,
uint8_t byte)
{
uint8_t data[] = { DIR_WRITE(reg), ADDR_7(reg), byte };
return fxos8700_transceive(dev, data, sizeof(data));
}
int fxos8700_reg_field_update_spi(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val)
{
uint8_t old_val;
if (fxos8700_byte_read_spi(dev, reg, &old_val) < 0) {
return -EIO;
}
return fxos8700_byte_write_spi(dev, reg, (old_val & ~mask) | (val & mask));
}
static const struct fxos8700_io_ops fxos8700_spi_ops = {
.read = fxos8700_read_spi,
.byte_read = fxos8700_byte_read_spi,
.byte_write = fxos8700_byte_write_spi,
.reg_field_update = fxos8700_reg_field_update_spi,
};
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
int fxos8700_read_i2c(const struct device *dev,
uint8_t reg,
void *data,
size_t length)
{
const struct fxos8700_config *config = dev->config;
return i2c_burst_read_dt(&config->bus_cfg.i2c, reg, data, length);
}
int fxos8700_byte_read_i2c(const struct device *dev,
uint8_t reg,
uint8_t *byte)
{
const struct fxos8700_config *config = dev->config;
return i2c_reg_read_byte_dt(&config->bus_cfg.i2c, reg, byte);
}
int fxos8700_byte_write_i2c(const struct device *dev,
uint8_t reg,
uint8_t byte)
{
const struct fxos8700_config *config = dev->config;
return i2c_reg_write_byte_dt(&config->bus_cfg.i2c, reg, byte);
}
int fxos8700_reg_field_update_i2c(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val)
{
const struct fxos8700_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->bus_cfg.i2c, reg, mask, val);
}
static const struct fxos8700_io_ops fxos8700_i2c_ops = {
.read = fxos8700_read_i2c,
.byte_read = fxos8700_byte_read_i2c,
.byte_write = fxos8700_byte_write_i2c,
.reg_field_update = fxos8700_reg_field_update_i2c,
};
#endif
static int fxos8700_set_odr(const struct device *dev,
const struct sensor_value *val)
{
const struct fxos8700_config *config = dev->config;
uint8_t dr;
enum fxos8700_power power;
#ifdef CONFIG_FXOS8700_MODE_HYBRID
/* ODR is halved in hybrid mode */
if (val->val1 == 400 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_800;
} else if (val->val1 == 200 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_400;
} else if (val->val1 == 100 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_200;
} else if (val->val1 == 50 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_100;
} else if (val->val1 == 25 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_50;
} else if (val->val1 == 6 && val->val2 == 250000) {
dr = FXOS8700_CTRLREG1_DR_RATE_12_5;
} else if (val->val1 == 3 && val->val2 == 125000) {
dr = FXOS8700_CTRLREG1_DR_RATE_6_25;
} else if (val->val1 == 0 && val->val2 == 781300) {
dr = FXOS8700_CTRLREG1_DR_RATE_1_56;
} else {
return -EINVAL;
}
#else
if (val->val1 == 800 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_800;
} else if (val->val1 == 400 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_400;
} else if (val->val1 == 200 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_200;
} else if (val->val1 == 100 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_100;
} else if (val->val1 == 50 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_50;
} else if (val->val1 == 12 && val->val2 == 500000) {
dr = FXOS8700_CTRLREG1_DR_RATE_12_5;
} else if (val->val1 == 6 && val->val2 == 250000) {
dr = FXOS8700_CTRLREG1_DR_RATE_6_25;
} else if (val->val1 == 1 && val->val2 == 562500) {
dr = FXOS8700_CTRLREG1_DR_RATE_1_56;
} else {
return -EINVAL;
}
#endif
LOG_DBG("Set ODR to 0x%x", dr);
/*
* Modify FXOS8700_REG_CTRLREG1 can only occur when the device
* is in standby mode. Get the current power mode to restore it later.
*/
if (fxos8700_get_power(dev, &power)) {
LOG_ERR("Could not get power mode");
return -EIO;
}
/* Set standby power mode */
if (fxos8700_set_power(dev, FXOS8700_POWER_STANDBY)) {
LOG_ERR("Could not set standby");
return -EIO;
}
/* Change the attribute and restore power mode. */
return config->ops->reg_field_update(dev, FXOS8700_REG_CTRLREG1,
FXOS8700_CTRLREG1_DR_MASK | FXOS8700_CTRLREG1_ACTIVE_MASK,
dr | power);
}
static int fxos8700_set_mt_ths(const struct device *dev,
const struct sensor_value *val)
{
#ifdef CONFIG_FXOS8700_MOTION
const struct fxos8700_config *config = dev->config;
uint64_t micro_ms2 = abs(val->val1 * 1000000LL + val->val2);
uint64_t ths = micro_ms2 / FXOS8700_FF_MT_THS_SCALE;
if (ths > FXOS8700_FF_MT_THS_MASK) {
LOG_ERR("Threshold value is out of range");
return -EINVAL;
}
LOG_DBG("Set FF_MT_THS to %d", (uint8_t)ths);
return config->ops->reg_field_update(dev, FXOS8700_REG_FF_MT_THS,
FXOS8700_FF_MT_THS_MASK, (uint8_t)ths);
#else
return -ENOTSUP;
#endif
}
static int fxos8700_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
return fxos8700_set_odr(dev, val);
} else if (attr == SENSOR_ATTR_SLOPE_TH) {
return fxos8700_set_mt_ths(dev, val);
} else {
return -ENOTSUP;
}
return 0;
}
static int fxos8700_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
uint8_t buffer[FXOS8700_MAX_NUM_BYTES];
uint8_t num_bytes;
int16_t *raw;
int ret = 0;
int i;
if (chan != SENSOR_CHAN_ALL) {
LOG_ERR("Unsupported sensor channel");
return -ENOTSUP;
}
k_sem_take(&data->sem, K_FOREVER);
/* Read all the channels in one I2C/SPI transaction. The number of bytes to
* read and the starting register address depend on the mode
* configuration (accel-only, mag-only, or hybrid).
*/
num_bytes = config->num_channels * FXOS8700_BYTES_PER_CHANNEL_NORMAL;
__ASSERT(num_bytes <= sizeof(buffer), "Too many bytes to read");
if (config->ops->read(dev, config->start_addr, buffer, num_bytes)) {
LOG_ERR("Could not fetch sample");
ret = -EIO;
goto exit;
}
/* Parse the buffer into raw channel data (16-bit integers). To save
* RAM, store the data in raw format and wait to convert to the
* normalized sensor_value type until later.
*/
__ASSERT(config->start_channel + config->num_channels
<= ARRAY_SIZE(data->raw),
"Too many channels");
raw = &data->raw[config->start_channel];
for (i = 0; i < num_bytes; i += 2) {
*raw++ = (buffer[i] << 8) | (buffer[i+1]);
}
#ifdef CONFIG_FXOS8700_TEMP
if (config->ops->byte_read(dev, FXOS8700_REG_TEMP,
&data->temp)) {
LOG_ERR("Could not fetch temperature");
ret = -EIO;
goto exit;
}
#endif
exit:
k_sem_give(&data->sem);
return ret;
}
static void fxos8700_accel_convert(struct sensor_value *val, int16_t raw,
uint8_t range)
{
uint8_t frac_bits;
int64_t micro_ms2;
/* The range encoding is convenient to compute the number of fractional
* bits:
* - 2g mode (fs = 0) has 14 fractional bits
* - 4g mode (fs = 1) has 13 fractional bits
* - 8g mode (fs = 2) has 12 fractional bits
*/
frac_bits = 14 - RANGE2FS(range);
/* Convert units to micro m/s^2. Intermediate results before the shift
* are 40 bits wide.
*/
micro_ms2 = (raw * SENSOR_G) >> frac_bits;
/* The maximum possible value is 8g, which in units of micro m/s^2
* always fits into 32-bits. Cast down to int32_t so we can use a
* faster divide.
*/
val->val1 = (int32_t) micro_ms2 / 1000000;
val->val2 = (int32_t) micro_ms2 % 1000000;
}
static void fxos8700_magn_convert(struct sensor_value *val, int16_t raw)
{
int32_t micro_g;
/* Convert units to micro Gauss. Raw magnetic data always has a
* resolution of 0.1 uT/LSB, which is equivalent to 0.001 G/LSB.
*/
micro_g = raw * 1000;
val->val1 = micro_g / 1000000;
val->val2 = micro_g % 1000000;
}
#ifdef CONFIG_FXOS8700_TEMP
static void fxos8700_temp_convert(struct sensor_value *val, int8_t raw)
{
int32_t micro_c;
/* Convert units to micro Celsius. Raw temperature data always has a
* resolution of 0.96 deg C/LSB.
*/
micro_c = raw * 960 * 1000;
val->val1 = micro_c / 1000000;
val->val2 = micro_c % 1000000;
}
#endif
static int fxos8700_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
int start_channel;
int num_channels;
int16_t *raw;
int ret;
int i;
k_sem_take(&data->sem, K_FOREVER);
/* Start with an error return code by default, then clear it if we find
* a supported sensor channel.
*/
ret = -ENOTSUP;
/* If we're in an accelerometer-enabled mode (accel-only or hybrid),
* then convert raw accelerometer data to the normalized sensor_value
* type.
*/
if (config->mode != FXOS8700_MODE_MAGN) {
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
start_channel = FXOS8700_CHANNEL_ACCEL_X;
num_channels = 1;
break;
case SENSOR_CHAN_ACCEL_Y:
start_channel = FXOS8700_CHANNEL_ACCEL_Y;
num_channels = 1;
break;
case SENSOR_CHAN_ACCEL_Z:
start_channel = FXOS8700_CHANNEL_ACCEL_Z;
num_channels = 1;
break;
case SENSOR_CHAN_ACCEL_XYZ:
start_channel = FXOS8700_CHANNEL_ACCEL_X;
num_channels = 3;
break;
default:
start_channel = 0;
num_channels = 0;
break;
}
raw = &data->raw[start_channel];
for (i = 0; i < num_channels; i++) {
fxos8700_accel_convert(val++, *raw++, config->range);
}
if (num_channels > 0) {
ret = 0;
}
}
/* If we're in an magnetometer-enabled mode (mag-only or hybrid), then
* convert raw magnetometer data to the normalized sensor_value type.
*/
if (config->mode != FXOS8700_MODE_ACCEL) {
switch (chan) {
case SENSOR_CHAN_MAGN_X:
start_channel = FXOS8700_CHANNEL_MAGN_X;
num_channels = 1;
break;
case SENSOR_CHAN_MAGN_Y:
start_channel = FXOS8700_CHANNEL_MAGN_Y;
num_channels = 1;
break;
case SENSOR_CHAN_MAGN_Z:
start_channel = FXOS8700_CHANNEL_MAGN_Z;
num_channels = 1;
break;
case SENSOR_CHAN_MAGN_XYZ:
start_channel = FXOS8700_CHANNEL_MAGN_X;
num_channels = 3;
break;
default:
start_channel = 0;
num_channels = 0;
break;
}
raw = &data->raw[start_channel];
for (i = 0; i < num_channels; i++) {
fxos8700_magn_convert(val++, *raw++);
}
if (num_channels > 0) {
ret = 0;
}
#ifdef CONFIG_FXOS8700_TEMP
if (chan == SENSOR_CHAN_DIE_TEMP) {
fxos8700_temp_convert(val, data->temp);
ret = 0;
}
#endif
}
if (ret != 0) {
LOG_ERR("Unsupported sensor channel");
}
k_sem_give(&data->sem);
return ret;
}
int fxos8700_get_power(const struct device *dev, enum fxos8700_power *power)
{
const struct fxos8700_config *config = dev->config;
uint8_t val;
if (config->ops->byte_read(dev, FXOS8700_REG_CTRLREG1, &val)) {
LOG_ERR("Could not get power setting");
return -EIO;
}
val &= FXOS8700_M_CTRLREG1_MODE_MASK;
*power = val;
return 0;
}
int fxos8700_set_power(const struct device *dev, enum fxos8700_power power)
{
const struct fxos8700_config *config = dev->config;
return config->ops->reg_field_update(dev, FXOS8700_REG_CTRLREG1,
FXOS8700_CTRLREG1_ACTIVE_MASK, power);
}
static int fxos8700_init(const struct device *dev)
{
const struct fxos8700_config *config = dev->config;
struct fxos8700_data *data = dev->data;
struct sensor_value odr = {.val1 = 6, .val2 = 250000};
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
if (config->inst_on_bus == FXOS8700_BUS_I2C) {
if (!device_is_ready(config->bus_cfg.i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
}
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
if (config->inst_on_bus == FXOS8700_BUS_SPI) {
if (!device_is_ready(config->bus_cfg.spi.bus)) {
LOG_ERR("SPI bus device not ready");
return -ENODEV;
}
}
#endif
if (config->reset_gpio.port) {
/* Pulse RST pin high to perform a hardware reset of
* the sensor.
*/
if (!gpio_is_ready_dt(&config->reset_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
gpio_pin_configure_dt(&config->reset_gpio, GPIO_OUTPUT_INACTIVE);
gpio_pin_set_dt(&config->reset_gpio, 1);
/* The datasheet does not mention how long to pulse
* the RST pin high in order to reset. Stay on the
* safe side and pulse for 1 millisecond.
*/
k_busy_wait(USEC_PER_MSEC);
gpio_pin_set_dt(&config->reset_gpio, 0);
} else {
/* Software reset the sensor. Upon issuing a software
* reset command over the I2C interface, the sensor
* immediately resets and does not send any
* acknowledgment (ACK) of the written byte to the
* master. Therefore, do not check the return code of
* the I2C transaction.
*/
config->ops->byte_write(dev, FXOS8700_REG_CTRLREG2,
FXOS8700_CTRLREG2_RST_MASK);
}
/* The sensor requires us to wait 1 ms after a reset before
* attempting further communications.
*/
k_busy_wait(USEC_PER_MSEC);
/*
* Read the WHOAMI register to make sure we are talking to FXOS8700 or
* compatible device and not some other type of device that happens to
* have the same I2C address.
*/
if (config->ops->byte_read(dev, FXOS8700_REG_WHOAMI,
&data->whoami)) {
LOG_ERR("Could not get WHOAMI value");
return -EIO;
}
switch (data->whoami) {
case WHOAMI_ID_MMA8451:
case WHOAMI_ID_MMA8652:
case WHOAMI_ID_MMA8653:
if (config->mode != FXOS8700_MODE_ACCEL) {
LOG_ERR("Device 0x%x supports only "
"accelerometer mode",
data->whoami);
return -EIO;
}
break;
case WHOAMI_ID_FXOS8700:
LOG_DBG("Device ID 0x%x", data->whoami);
break;
default:
LOG_ERR("Unknown Device ID 0x%x", data->whoami);
return -EIO;
}
if (fxos8700_set_odr(dev, &odr)) {
LOG_ERR("Could not set default data rate");
return -EIO;
}
if (config->ops->reg_field_update(dev, FXOS8700_REG_CTRLREG2,
FXOS8700_CTRLREG2_MODS_MASK,
config->power_mode)) {
LOG_ERR("Could not set power scheme");
return -EIO;
}
/* Set the mode (accel-only, mag-only, or hybrid) */
if (config->ops->reg_field_update(dev, FXOS8700_REG_M_CTRLREG1,
FXOS8700_M_CTRLREG1_MODE_MASK,
config->mode)) {
LOG_ERR("Could not set mode");
return -EIO;
}
/* Set hybrid autoincrement so we can read accel and mag channels in
* one I2C/SPI transaction.
*/
if (config->ops->reg_field_update(dev, FXOS8700_REG_M_CTRLREG2,
FXOS8700_M_CTRLREG2_AUTOINC_MASK,
FXOS8700_M_CTRLREG2_AUTOINC_MASK)) {
LOG_ERR("Could not set hybrid autoincrement");
return -EIO;
}
/* Set the full-scale range */
if (config->ops->reg_field_update(dev, FXOS8700_REG_XYZ_DATA_CFG,
FXOS8700_XYZ_DATA_CFG_FS_MASK,
RANGE2FS(config->range))) {
LOG_ERR("Could not set range");
return -EIO;
}
k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);
#if CONFIG_FXOS8700_TRIGGER
if (fxos8700_trigger_init(dev)) {
LOG_ERR("Could not initialize interrupts");
return -EIO;
}
#endif
/* Set active */
if (fxos8700_set_power(dev, FXOS8700_POWER_ACTIVE)) {
LOG_ERR("Could not set active");
return -EIO;
}
k_sem_give(&data->sem);
LOG_DBG("Init complete");
return 0;
}
static const struct sensor_driver_api fxos8700_driver_api = {
.sample_fetch = fxos8700_sample_fetch,
.channel_get = fxos8700_channel_get,
.attr_set = fxos8700_attr_set,
#if CONFIG_FXOS8700_TRIGGER
.trigger_set = fxos8700_trigger_set,
#endif
};
#define FXOS8700_MODE_PROPS_ACCEL \
.mode = FXOS8700_MODE_ACCEL, \
.start_addr = FXOS8700_REG_OUTXMSB, \
.start_channel = FXOS8700_CHANNEL_ACCEL_X, \
.num_channels = FXOS8700_NUM_ACCEL_CHANNELS,
#define FXOS8700_MODE_PROPS_MAGN \
.mode = FXOS8700_MODE_MAGN, \
.start_addr = FXOS8700_REG_M_OUTXMSB, \
.start_channel = FXOS8700_CHANNEL_MAGN_X, \
.num_channels = FXOS8700_NUM_MAG_CHANNELS,
#define FXOS8700_MODE_PROPS_HYBRID \
.mode = FXOS8700_MODE_HYBRID, \
.start_addr = FXOS8700_REG_OUTXMSB, \
.start_channel = FXOS8700_CHANNEL_ACCEL_X, \
.num_channels = FXOS8700_NUM_HYBRID_CHANNELS, \
#define FXOS8700_MODE(n) \
COND_CODE_1(CONFIG_FXOS8700_MODE_ACCEL, \
(FXOS8700_MODE_PROPS_ACCEL), \
(COND_CODE_1(CONFIG_FXOS8700_MODE_MAGN, \
(FXOS8700_MODE_PROPS_MAGN), \
(FXOS8700_MODE_PROPS_HYBRID))))
#define FXOS8700_RESET_PROPS(n) \
.reset_gpio = GPIO_DT_SPEC_INST_GET(n, reset_gpios),
#define FXOS8700_RESET(n) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(n, reset_gpios), \
(FXOS8700_RESET_PROPS(n)), \
())
#define FXOS8700_INTM_PROPS(n, m) \
.int_gpio = GPIO_DT_SPEC_INST_GET(n, int##m##_gpios),
#define FXOS8700_INT_PROPS(n) \
COND_CODE_1(CONFIG_FXOS8700_DRDY_INT1, \
(FXOS8700_INTM_PROPS(n, 1)), \
(FXOS8700_INTM_PROPS(n, 2)))
#define FXOS8700_INT(n) \
COND_CODE_1(CONFIG_FXOS8700_TRIGGER, \
(FXOS8700_INT_PROPS(n)), \
())
#define FXOS8700_PULSE_PROPS(n) \
.pulse_cfg = DT_INST_PROP(n, pulse_cfg), \
.pulse_ths[0] = DT_INST_PROP(n, pulse_thsx), \
.pulse_ths[1] = DT_INST_PROP(n, pulse_thsy), \
.pulse_ths[2] = DT_INST_PROP(n, pulse_thsz), \
.pulse_tmlt = DT_INST_PROP(n, pulse_tmlt), \
.pulse_ltcy = DT_INST_PROP(n, pulse_ltcy), \
.pulse_wind = DT_INST_PROP(n, pulse_wind),
#define FXOS8700_PULSE(n) \
COND_CODE_1(CONFIG_FXOS8700_PULSE, \
(FXOS8700_PULSE_PROPS(n)), \
())
#define FXOS8700_MAG_VECM_PROPS(n) \
.mag_vecm_cfg = DT_INST_PROP(n, mag_vecm_cfg), \
.mag_vecm_ths[0] = DT_INST_PROP(n, mag_vecm_ths_msb), \
.mag_vecm_ths[1] = DT_INST_PROP(n, mag_vecm_ths_lsb),
#define FXOS8700_MAG_VECM(n) \
COND_CODE_1(CONFIG_FXOS8700_MAG_VECM, \
(FXOS8700_MAG_VECM_PROPS(n)), \
())
#define FXOS8700_CONFIG_I2C(n) \
.bus_cfg = { .i2c = I2C_DT_SPEC_INST_GET(n) }, \
.ops = &fxos8700_i2c_ops, \
.power_mode = DT_INST_PROP(n, power_mode), \
.range = DT_INST_PROP(n, range), \
.inst_on_bus = FXOS8700_BUS_I2C,
#define FXOS8700_CONFIG_SPI(n) \
.bus_cfg = { .spi = SPI_DT_SPEC_INST_GET(n, \
SPI_OP_MODE_MASTER | SPI_WORD_SET(8), 0) }, \
.ops = &fxos8700_spi_ops, \
.power_mode = DT_INST_PROP(n, power_mode), \
.range = DT_INST_PROP(n, range), \
.inst_on_bus = FXOS8700_BUS_SPI, \
#define FXOS8700_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER) \
#define FXOS8700_INIT(n) \
static const struct fxos8700_config fxos8700_config_##n = { \
COND_CODE_1(DT_INST_ON_BUS(n, spi), \
(FXOS8700_CONFIG_SPI(n)), \
(FXOS8700_CONFIG_I2C(n))) \
FXOS8700_RESET(n) \
FXOS8700_MODE(n) \
FXOS8700_INT(n) \
FXOS8700_PULSE(n) \
FXOS8700_MAG_VECM(n) \
}; \
\
static struct fxos8700_data fxos8700_data_##n; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, \
fxos8700_init, \
NULL, \
&fxos8700_data_##n, \
&fxos8700_config_##n, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&fxos8700_driver_api);
DT_INST_FOREACH_STATUS_OKAY(FXOS8700_INIT)
``` | /content/code_sandbox/drivers/sensor/nxp/fxos8700/fxos8700.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,797 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_fxas21002
#include "fxas21002.h"
#include <zephyr/sys/util.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(FXAS21002, CONFIG_SENSOR_LOG_LEVEL);
/* Sample period in microseconds, indexed by output data rate encoding (DR) */
static const uint32_t sample_period[] = {
1250, 2500, 5000, 10000, 20000, 40000, 80000, 80000
};
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define DIR_READ(a) ((a) | BIT(7))
#define DIR_WRITE(a) ((a) & 0x7f)
static int fxas21002_transceive(const struct device *dev,
void *data, size_t length)
{
const struct fxas21002_config *cfg = dev->config;
const struct spi_buf buf = { .buf = data, .len = length };
const struct spi_buf_set s = { .buffers = &buf, .count = 1 };
return spi_transceive_dt(&cfg->bus_cfg.spi, &s, &s);
}
int fxas21002_read_spi(const struct device *dev,
uint8_t reg,
void *data,
size_t length)
{
const struct fxas21002_config *cfg = dev->config;
/* Reads must clock out a dummy byte after sending the address. */
uint8_t reg_buf[2] = { DIR_READ(reg), 0 };
const struct spi_buf buf[2] = {
{ .buf = reg_buf, .len = 3 },
{ .buf = data, .len = length }
};
const struct spi_buf_set tx = { .buffers = buf, .count = 1 };
const struct spi_buf_set rx = { .buffers = buf, .count = 2 };
return spi_transceive_dt(&cfg->bus_cfg.spi, &tx, &rx);
}
int fxas21002_byte_read_spi(const struct device *dev,
uint8_t reg,
uint8_t *byte)
{
/* Reads must clock out a dummy byte after sending the address. */
uint8_t data[] = { DIR_READ(reg), 0};
int ret;
ret = fxas21002_transceive(dev, data, sizeof(data));
*byte = data[1];
return ret;
}
int fxas21002_byte_write_spi(const struct device *dev,
uint8_t reg,
uint8_t byte)
{
uint8_t data[] = { DIR_WRITE(reg), byte };
return fxas21002_transceive(dev, data, sizeof(data));
}
int fxas21002_reg_field_update_spi(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val)
{
uint8_t old_val;
int rc = 0;
rc = fxas21002_byte_read_spi(dev, reg, &old_val);
if (rc != 0) {
return rc;
}
return fxas21002_byte_write_spi(dev, reg, (old_val & ~mask) | (val & mask));
}
static const struct fxas21002_io_ops fxas21002_spi_ops = {
.read = fxas21002_read_spi,
.byte_read = fxas21002_byte_read_spi,
.byte_write = fxas21002_byte_write_spi,
.reg_field_update = fxas21002_reg_field_update_spi,
};
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
int fxas21002_read_i2c(const struct device *dev,
uint8_t reg,
void *data,
size_t length)
{
const struct fxas21002_config *config = dev->config;
return i2c_burst_read_dt(&config->bus_cfg.i2c, reg, data, length);
}
int fxas21002_byte_read_i2c(const struct device *dev,
uint8_t reg,
uint8_t *byte)
{
const struct fxas21002_config *config = dev->config;
return i2c_reg_read_byte_dt(&config->bus_cfg.i2c, reg, byte);
}
int fxas21002_byte_write_i2c(const struct device *dev,
uint8_t reg,
uint8_t byte)
{
const struct fxas21002_config *config = dev->config;
return i2c_reg_write_byte_dt(&config->bus_cfg.i2c, reg, byte);
}
int fxas21002_reg_field_update_i2c(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val)
{
const struct fxas21002_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->bus_cfg.i2c, reg, mask, val);
}
static const struct fxas21002_io_ops fxas21002_i2c_ops = {
.read = fxas21002_read_i2c,
.byte_read = fxas21002_byte_read_i2c,
.byte_write = fxas21002_byte_write_i2c,
.reg_field_update = fxas21002_reg_field_update_i2c,
};
#endif
static int fxas21002_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct fxas21002_config *config = dev->config;
struct fxas21002_data *data = dev->data;
uint8_t buffer[FXAS21002_MAX_NUM_BYTES];
int16_t *raw;
int ret = 0;
int i;
if (chan != SENSOR_CHAN_ALL) {
LOG_ERR("Unsupported sensor channel");
return -ENOTSUP;
}
k_sem_take(&data->sem, K_FOREVER);
/* Read all the channels in one I2C transaction. */
if (config->ops->read(dev, FXAS21002_REG_OUTXMSB, buffer,
sizeof(buffer))) {
LOG_ERR("Could not fetch sample");
ret = -EIO;
goto exit;
}
/* Parse the buffer into raw channel data (16-bit integers). To save
* RAM, store the data in raw format and wait to convert to the
* normalized sensor_value type until later.
*/
raw = &data->raw[0];
for (i = 0; i < sizeof(buffer); i += 2) {
*raw++ = (buffer[i] << 8) | (buffer[i+1]);
}
exit:
k_sem_give(&data->sem);
return ret;
}
static void fxas21002_convert(struct sensor_value *val, int16_t raw,
enum fxas21002_range range)
{
int32_t micro_rad;
/* Convert units to micro radians per second.
* 62500 micro dps * 2*pi/360 = 1091 micro radians per second
*/
micro_rad = (raw * 1091) >> range;
val->val1 = micro_rad / 1000000;
val->val2 = micro_rad % 1000000;
}
static int fxas21002_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct fxas21002_config *config = dev->config;
struct fxas21002_data *data = dev->data;
int start_channel;
int num_channels;
int16_t *raw;
int ret;
int i;
k_sem_take(&data->sem, K_FOREVER);
/* Start with an error return code by default, then clear it if we find
* a supported sensor channel.
*/
ret = -ENOTSUP;
/* Convert raw gyroscope data to the normalized sensor_value type. */
switch (chan) {
case SENSOR_CHAN_GYRO_X:
start_channel = FXAS21002_CHANNEL_GYRO_X;
num_channels = 1;
break;
case SENSOR_CHAN_GYRO_Y:
start_channel = FXAS21002_CHANNEL_GYRO_Y;
num_channels = 1;
break;
case SENSOR_CHAN_GYRO_Z:
start_channel = FXAS21002_CHANNEL_GYRO_Z;
num_channels = 1;
break;
case SENSOR_CHAN_GYRO_XYZ:
start_channel = FXAS21002_CHANNEL_GYRO_X;
num_channels = 3;
break;
default:
start_channel = 0;
num_channels = 0;
break;
}
raw = &data->raw[start_channel];
for (i = 0; i < num_channels; i++) {
fxas21002_convert(val++, *raw++, config->range);
}
if (num_channels > 0) {
ret = 0;
}
if (ret != 0) {
LOG_ERR("Unsupported sensor channel");
}
k_sem_give(&data->sem);
return ret;
}
int fxas21002_get_power(const struct device *dev, enum fxas21002_power *power)
{
const struct fxas21002_config *config = dev->config;
uint8_t val = *power;
if (config->ops->byte_read(dev, FXAS21002_REG_CTRLREG1, &val)) {
LOG_ERR("Could not get power setting");
return -EIO;
}
val &= FXAS21002_CTRLREG1_POWER_MASK;
*power = val;
return 0;
}
int fxas21002_set_power(const struct device *dev, enum fxas21002_power power)
{
const struct fxas21002_config *config = dev->config;
return config->ops->reg_field_update(dev, FXAS21002_REG_CTRLREG1,
FXAS21002_CTRLREG1_POWER_MASK, power);
}
uint32_t fxas21002_get_transition_time(enum fxas21002_power start,
enum fxas21002_power end,
uint8_t dr)
{
uint32_t transition_time;
/* If not transitioning to active mode, then don't need to wait */
if (end != FXAS21002_POWER_ACTIVE) {
return 0;
}
/* Otherwise, the transition time depends on which state we're
* transitioning from. These times are defined by the datasheet.
*/
transition_time = sample_period[dr];
if (start == FXAS21002_POWER_READY) {
transition_time += 5000U;
} else {
transition_time += 60000U;
}
return transition_time;
}
static int fxas21002_init(const struct device *dev)
{
const struct fxas21002_config *config = dev->config;
struct fxas21002_data *data = dev->data;
uint32_t transition_time;
uint8_t whoami;
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
uint8_t ctrlreg1;
if (config->inst_on_bus == FXAS21002_BUS_I2C) {
if (!device_is_ready(config->bus_cfg.i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
}
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
if (config->inst_on_bus == FXAS21002_BUS_SPI) {
if (!device_is_ready(config->bus_cfg.spi.bus)) {
LOG_ERR("SPI bus device not ready");
return -ENODEV;
}
if (config->reset_gpio.port) {
/* Pulse RST pin high to perform a hardware reset of
* the sensor.
*/
if (!gpio_is_ready_dt(&config->reset_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
gpio_pin_configure_dt(&config->reset_gpio, GPIO_OUTPUT_INACTIVE);
gpio_pin_set_dt(&config->reset_gpio, 1);
/* The datasheet does not mention how long to pulse
* the RST pin high in order to reset. Stay on the
* safe side and pulse for 1 millisecond.
*/
k_busy_wait(USEC_PER_MSEC);
gpio_pin_set_dt(&config->reset_gpio, 0);
k_busy_wait(USEC_PER_MSEC);
}
}
#endif
/* Read the WHOAMI register to make sure we are talking to FXAS21002
* and not some other type of device that happens to have the same I2C
* address.
*/
if (config->ops->byte_read(dev, FXAS21002_REG_WHOAMI, &whoami)) {
LOG_ERR("Could not get WHOAMI value");
return -EIO;
}
if (whoami != config->whoami) {
LOG_ERR("WHOAMI value received 0x%x, expected 0x%x",
whoami, config->whoami);
return -EIO;
}
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
if (config->inst_on_bus == FXAS21002_BUS_I2C) {
/* Reset the sensor. Upon issuing a software reset command over the I2C
* interface, the sensor immediately resets and does not send any
* acknowledgment (ACK) of the written byte to the master. Therefore,
* do not check the return code of the I2C transaction.
*/
config->ops->byte_write(dev, FXAS21002_REG_CTRLREG1,
FXAS21002_CTRLREG1_RST_MASK);
/* Wait for the reset sequence to complete */
do {
if (config->ops->byte_read(dev, FXAS21002_REG_CTRLREG1,
&ctrlreg1)) {
LOG_ERR("Could not get ctrlreg1 value");
return -EIO;
}
} while (ctrlreg1 & FXAS21002_CTRLREG1_RST_MASK);
}
#endif
/* Set the full-scale range */
if (config->ops->reg_field_update(dev, FXAS21002_REG_CTRLREG0,
FXAS21002_CTRLREG0_FS_MASK, config->range)) {
LOG_ERR("Could not set range");
return -EIO;
}
/* Set the output data rate */
if (config->ops->reg_field_update(dev, FXAS21002_REG_CTRLREG1,
FXAS21002_CTRLREG1_DR_MASK,
config->dr << FXAS21002_CTRLREG1_DR_SHIFT)) {
LOG_ERR("Could not set output data rate");
return -EIO;
}
k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);
#if CONFIG_FXAS21002_TRIGGER
if (config->int_gpio.port) {
if (fxas21002_trigger_init(dev)) {
LOG_ERR("Could not initialize interrupts");
return -EIO;
}
}
#endif
/* Set active */
if (fxas21002_set_power(dev, FXAS21002_POWER_ACTIVE)) {
LOG_ERR("Could not set active");
return -EIO;
}
/* Wait the transition time from standby to active mode */
transition_time = fxas21002_get_transition_time(FXAS21002_POWER_STANDBY,
FXAS21002_POWER_ACTIVE,
config->dr);
k_busy_wait(transition_time);
k_sem_give(&data->sem);
LOG_DBG("Init complete");
return 0;
}
static const struct sensor_driver_api fxas21002_driver_api = {
.sample_fetch = fxas21002_sample_fetch,
.channel_get = fxas21002_channel_get,
#if CONFIG_FXAS21002_TRIGGER
.trigger_set = fxas21002_trigger_set,
#endif
};
#define FXAS21002_CONFIG_I2C(inst) \
.bus_cfg = { .i2c = I2C_DT_SPEC_INST_GET(inst) }, \
.ops = &fxas21002_i2c_ops, \
.inst_on_bus = FXAS21002_BUS_I2C, \
#define FXAS21002_CONFIG_SPI(inst) \
.bus_cfg = {.spi = SPI_DT_SPEC_INST_GET(inst, \
SPI_OP_MODE_MASTER | SPI_WORD_SET(8), 0) }, \
.ops = &fxas21002_spi_ops, \
.reset_gpio = GPIO_DT_SPEC_INST_GET(inst, reset_gpios), \
.inst_on_bus = FXAS21002_BUS_SPI, \
#define FXAS21002_DEFINE(inst) \
static struct fxas21002_data fxas21002_data_##inst; \
\
static const struct fxas21002_config fxas21002_config_##inst = { \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(FXAS21002_CONFIG_SPI(inst)), \
(FXAS21002_CONFIG_I2C(inst))) \
.whoami = CONFIG_FXAS21002_WHOAMI, \
.range = CONFIG_FXAS21002_RANGE, \
.dr = CONFIG_FXAS21002_DR, \
IF_ENABLED(CONFIG_FXAS21002_TRIGGER, \
(COND_CODE_1(CONFIG_FXAS21002_DRDY_INT1, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int1_gpios, \
{ 0 }),), \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int2_gpios, \
{ 0 }),)))) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, fxas21002_init, NULL, \
&fxas21002_data_##inst, &fxas21002_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&fxas21002_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(FXAS21002_DEFINE)
``` | /content/code_sandbox/drivers/sensor/nxp/fxas21002/fxas21002.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,819 |
```unknown
# FXAS21002 3-axis gyroscope
menuconfig FXAS21002
bool "FXAS21002 gyroscope driver"
default y
depends on DT_HAS_NXP_FXAS21002_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_NXP_FXAS21002),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_NXP_FXAS21002),spi)
help
Enable driver for the FXAS21002 gyroscope
if FXAS21002
config FXAS21002_WHOAMI
hex "WHOAMI value"
range 0x00 0xff
default 0xd7
help
The datasheet defines the value of the WHOAMI register, but some
pre-production devices can have a different value. It is unlikely you
should need to change this configuration option from the default.
config FXAS21002_RANGE
int "Full scale range"
range 0 3
default 0
help
Selects the full scale range
0: +/-2000 dps (62.5 mdps/LSB)
1: +/-1000 dps (31.25 mdps/LSB)
2: +/-500 dps (15.625 mdps/LSB)
3: +/-250 dps (7.8125 mdps/LSB)
config FXAS21002_DR
int "Output data rate"
range 0 7
default 3
help
Selects the output data rate
0: 800 Hz
1: 400 Hz
2: 200 Hz
3: 100 Hz
4: 50 Hz
5: 25 Hz
6: 12.5 Hz
7: 12.5 Hz
choice
prompt "Trigger mode"
default FXAS21002_TRIGGER_NONE
config FXAS21002_TRIGGER_NONE
bool "No trigger"
config FXAS21002_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
select FXAS21002_TRIGGER
config FXAS21002_TRIGGER_OWN_THREAD
bool "Use own thread"
select FXAS21002_TRIGGER
endchoice
config FXAS21002_TRIGGER
bool
if FXAS21002_TRIGGER
config FXAS21002_DRDY_INT1
bool "Data ready interrupt to INT1 pin"
help
Say Y to route data ready interrupt to INT1 pin. Say N to route to
INT2 pin.
config FXAS21002_THREAD_PRIORITY
int "Own thread priority"
depends on FXAS21002_TRIGGER_OWN_THREAD
default 10
config FXAS21002_THREAD_STACK_SIZE
int "Own thread stack size"
depends on FXAS21002_TRIGGER_OWN_THREAD
default 1024
endif # FXAS21002_TRIGGER
endif # FXAS21002
``` | /content/code_sandbox/drivers/sensor/nxp/fxas21002/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 612 |
```objective-c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#define FXAS21002_BUS_I2C (1<<0)
#define FXAS21002_BUS_SPI (1<<1)
#define FXAS21002_REG_STATUS 0x00
#define FXAS21002_REG_OUTXMSB 0x01
#define FXAS21002_REG_INT_SOURCE 0x0b
#define FXAS21002_REG_WHOAMI 0x0c
#define FXAS21002_REG_CTRLREG0 0x0d
#define FXAS21002_REG_CTRLREG1 0x13
#define FXAS21002_REG_CTRLREG2 0x14
#define FXAS21002_REG_CTRLREG3 0x15
#define FXAS21002_INT_SOURCE_DRDY_MASK (1 << 0)
#define FXAS21002_CTRLREG0_FS_MASK (3 << 0)
#define FXAS21002_CTRLREG1_DR_SHIFT 2
#define FXAS21002_CTRLREG1_POWER_MASK (3 << 0)
#define FXAS21002_CTRLREG1_DR_MASK (7 << FXAS21002_CTRLREG1_DR_SHIFT)
#define FXAS21002_CTRLREG1_RST_MASK (1 << 6)
#define FXAS21002_CTRLREG2_CFG_EN_MASK (1 << 2)
#define FXAS21002_CTRLREG2_CFG_DRDY_MASK (1 << 3)
#define FXAS21002_MAX_NUM_CHANNELS 3
#define FXAS21002_BYTES_PER_CHANNEL 2
#define FXAS21002_MAX_NUM_BYTES (FXAS21002_BYTES_PER_CHANNEL * \
FXAS21002_MAX_NUM_CHANNELS)
enum fxas21002_power {
FXAS21002_POWER_STANDBY = 0,
FXAS21002_POWER_READY = 1,
FXAS21002_POWER_ACTIVE = 3,
};
enum fxas21002_range {
FXAS21002_RANGE_2000DPS = 0,
FXAS21002_RANGE_1000DPS,
FXAS21002_RANGE_500DPS,
FXAS21002_RANGE_250DPS,
};
enum fxas21002_channel {
FXAS21002_CHANNEL_GYRO_X = 0,
FXAS21002_CHANNEL_GYRO_Y,
FXAS21002_CHANNEL_GYRO_Z,
};
struct fxas21002_io_ops {
int (*read)(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
int (*byte_read)(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int (*byte_write)(const struct device *dev,
uint8_t reg,
uint8_t byte);
int (*reg_field_update)(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
};
union fxas21002_bus_cfg {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
};
struct fxas21002_config {
const union fxas21002_bus_cfg bus_cfg;
const struct fxas21002_io_ops *ops;
#ifdef CONFIG_FXAS21002_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
struct gpio_dt_spec reset_gpio;
uint8_t whoami;
enum fxas21002_range range;
uint8_t dr;
uint8_t inst_on_bus;
};
struct fxas21002_data {
struct k_sem sem;
#ifdef CONFIG_FXAS21002_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trig;
#endif
#ifdef CONFIG_FXAS21002_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_FXAS21002_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#endif
#ifdef CONFIG_FXAS21002_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
int16_t raw[FXAS21002_MAX_NUM_CHANNELS];
};
int fxas21002_get_power(const struct device *dev, enum fxas21002_power *power);
int fxas21002_set_power(const struct device *dev, enum fxas21002_power power);
uint32_t fxas21002_get_transition_time(enum fxas21002_power start,
enum fxas21002_power end,
uint8_t dr);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
int fxas21002_byte_write_spi(const struct device *dev,
uint8_t reg,
uint8_t byte);
int fxas21002_byte_read_spi(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int fxas21002_reg_field_update_spi(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
int fxas21002_read_spi(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
int fxas21002_byte_write_i2c(const struct device *dev,
uint8_t reg,
uint8_t byte);
int fxas21002_byte_read_i2c(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int fxas21002_reg_field_update_i2c(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
int fxas21002_read_i2c(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
#endif
#if CONFIG_FXAS21002_TRIGGER
int fxas21002_trigger_init(const struct device *dev);
int fxas21002_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif
``` | /content/code_sandbox/drivers/sensor/nxp/fxas21002/fxas21002.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,345 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_tempmon
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/sensor.h>
/* OTP Controller Analog Register 1 for calibration values */
#define OCOTP_ANA1_ROOM_COUNT_SHIFT 20
#define OCOTP_ANA1_ROOM_COUNT_MASK (BIT_MASK(12) << OCOTP_ANA1_ROOM_COUNT_SHIFT)
#define OCOTP_ANA1_HOT_COUNT_SHIFT 8
#define OCOTP_ANA1_HOT_COUNT_MASK (BIT_MASK(12) << OCOTP_ANA1_HOT_COUNT_SHIFT)
#define OCOTP_ANA1_HOT_TEMP_SHIFT 0
#define OCOTP_ANA1_HOT_TEMP_MASK (BIT_MASK(8) << OCOTP_ANA1_HOT_TEMP_SHIFT)
#define TEMPMON_ROOM_TEMP 25.0f
struct nxp_tempmon_data {
uint8_t hot_temp;
uint16_t hot_cnt;
uint16_t room_cnt;
uint16_t temp_cnt;
};
struct nxp_tempmon_config {
TEMPMON_Type *base;
};
static int nxp_tempmon_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct nxp_tempmon_data *data = dev->data;
const struct nxp_tempmon_config *cfg = dev->config;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
/* Start the measure */
cfg->base->TEMPSENSE0 |= TEMPMON_TEMPSENSE0_MEASURE_TEMP_MASK;
/* Wait until measure is ready */
while (!(cfg->base->TEMPSENSE0 & TEMPMON_TEMPSENSE0_FINISHED_MASK)) {
}
data->temp_cnt = (cfg->base->TEMPSENSE0 & TEMPMON_TEMPSENSE0_TEMP_CNT_MASK) >>
TEMPMON_TEMPSENSE0_TEMP_CNT_SHIFT;
/* Stop the measure */
cfg->base->TEMPSENSE0 &= ~TEMPMON_TEMPSENSE0_MEASURE_TEMP_MASK;
return 0;
}
static int nxp_tempmon_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct nxp_tempmon_data *data = dev->data;
float temp;
if (chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
temp = (float)data->hot_temp - ((float)data->temp_cnt - (float)data->hot_cnt) *
(((float)data->hot_temp - TEMPMON_ROOM_TEMP) /
((float)data->room_cnt - (float)data->hot_cnt));
return sensor_value_from_double(val, temp);
}
static const struct sensor_driver_api nxp_tempmon_driver_api = {
.sample_fetch = nxp_tempmon_sample_fetch,
.channel_get = nxp_tempmon_channel_get,
};
static int nxp_tempmon_init(const struct device *dev)
{
struct nxp_tempmon_data *data = dev->data;
const struct nxp_tempmon_config *cfg = dev->config;
uint32_t ocotp_ana1;
/* Enable the temperature sensor */
cfg->base->TEMPSENSE0 &= ~TEMPMON_TEMPSENSE0_POWER_DOWN_MASK;
/* Single measure with no repeat mode */
cfg->base->TEMPSENSE1 = TEMPMON_TEMPSENSE1_MEASURE_FREQ(0);
/* Read calibration data */
ocotp_ana1 = OCOTP->ANA1;
data->hot_temp = (ocotp_ana1 & OCOTP_ANA1_HOT_TEMP_MASK) >> OCOTP_ANA1_HOT_TEMP_SHIFT;
data->hot_cnt = (ocotp_ana1 & OCOTP_ANA1_HOT_COUNT_MASK) >> OCOTP_ANA1_HOT_COUNT_SHIFT;
data->room_cnt = (ocotp_ana1 & OCOTP_ANA1_ROOM_COUNT_MASK) >> OCOTP_ANA1_ROOM_COUNT_SHIFT;
return 0;
}
static struct nxp_tempmon_data nxp_tempmon_dev_data = {
.hot_temp = 0,
.hot_cnt = 0,
.room_cnt = 0,
.temp_cnt = 0,
};
static const struct nxp_tempmon_config nxp_tempmon_dev_config = {
.base = (TEMPMON_Type *)DT_INST_REG_ADDR(0),
};
SENSOR_DEVICE_DT_INST_DEFINE(0, nxp_tempmon_init, NULL, &nxp_tempmon_dev_data,
&nxp_tempmon_dev_config, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY,
&nxp_tempmon_driver_api);
``` | /content/code_sandbox/drivers/sensor/nxp/nxp_tempmon/nxp_tempmon.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 950 |
```unknown
# NXP temperature monitor (TEMPMON)
config NXP_TEMPMON
bool "NXP temperature monitor (TEMPMON)"
default y
depends on DT_HAS_NXP_TEMPMON_ENABLED
help
Enable driver for the NXP temperature monitor (TEMPMON).
This is used to retrieve on-die operational temperature.
``` | /content/code_sandbox/drivers/sensor/nxp/nxp_tempmon/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 69 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_fxas21002
#include <zephyr/logging/log.h>
#include "fxas21002.h"
LOG_MODULE_DECLARE(FXAS21002, CONFIG_SENSOR_LOG_LEVEL);
static void fxas21002_gpio_callback(const struct device *dev,
struct gpio_callback *cb,
uint32_t pin_mask)
{
struct fxas21002_data *data =
CONTAINER_OF(cb, struct fxas21002_data, gpio_cb);
const struct fxas21002_config *config = data->dev->config;
if ((pin_mask & BIT(config->int_gpio.pin)) == 0U) {
return;
}
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_FXAS21002_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_FXAS21002_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static int fxas21002_handle_drdy_int(const struct device *dev)
{
struct fxas21002_data *data = dev->data;
if (data->drdy_handler) {
data->drdy_handler(dev, data->drdy_trig);
}
return 0;
}
static void fxas21002_handle_int(const struct device *dev)
{
const struct fxas21002_config *config = dev->config;
struct fxas21002_data *data = dev->data;
uint8_t int_source;
k_sem_take(&data->sem, K_FOREVER);
if (config->ops->byte_read(dev, FXAS21002_REG_INT_SOURCE,
&int_source)) {
LOG_ERR("Could not read interrupt source");
int_source = 0U;
}
k_sem_give(&data->sem);
if (int_source & FXAS21002_INT_SOURCE_DRDY_MASK) {
fxas21002_handle_drdy_int(dev);
}
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
#ifdef CONFIG_FXAS21002_TRIGGER_OWN_THREAD
static void fxas21002_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct fxas21002_data *data = p1;
while (true) {
k_sem_take(&data->trig_sem, K_FOREVER);
fxas21002_handle_int(data->dev);
}
}
#endif
#ifdef CONFIG_FXAS21002_TRIGGER_GLOBAL_THREAD
static void fxas21002_work_handler(struct k_work *work)
{
struct fxas21002_data *data =
CONTAINER_OF(work, struct fxas21002_data, work);
fxas21002_handle_int(data->dev);
}
#endif
int fxas21002_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct fxas21002_config *config = dev->config;
struct fxas21002_data *data = dev->data;
enum fxas21002_power power = FXAS21002_POWER_STANDBY;
uint32_t transition_time;
uint8_t mask;
int ret = 0;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
k_sem_take(&data->sem, K_FOREVER);
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
mask = FXAS21002_CTRLREG2_CFG_EN_MASK;
data->drdy_handler = handler;
data->drdy_trig = trig;
break;
default:
LOG_ERR("Unsupported sensor trigger");
ret = -ENOTSUP;
goto exit;
}
/* The sensor must be in standby or ready mode when writing the
* configuration registers, therefore get the current power mode so we
* can restore it later.
*/
if (fxas21002_get_power(dev, &power)) {
LOG_ERR("Could not get power mode");
ret = -EIO;
goto exit;
}
/* Put the sensor in ready mode */
if (fxas21002_set_power(dev, FXAS21002_POWER_READY)) {
LOG_ERR("Could not set ready mode");
ret = -EIO;
goto exit;
}
/* Configure the sensor interrupt */
if (config->ops->reg_field_update(dev, FXAS21002_REG_CTRLREG2, mask,
handler ? mask : 0)) {
LOG_ERR("Could not configure interrupt");
ret = -EIO;
goto exit;
}
/* Restore the previous power mode */
if (fxas21002_set_power(dev, power)) {
LOG_ERR("Could not restore power mode");
ret = -EIO;
goto exit;
}
/* Wait the transition time from ready mode */
transition_time = fxas21002_get_transition_time(FXAS21002_POWER_READY,
power,
config->dr);
k_busy_wait(transition_time);
exit:
k_sem_give(&data->sem);
return ret;
}
int fxas21002_trigger_init(const struct device *dev)
{
const struct fxas21002_config *config = dev->config;
struct fxas21002_data *data = dev->data;
uint8_t ctrl_reg2;
int ret;
data->dev = dev;
#if defined(CONFIG_FXAS21002_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_FXAS21002_THREAD_STACK_SIZE,
fxas21002_thread_main, data, 0, NULL,
K_PRIO_COOP(CONFIG_FXAS21002_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_FXAS21002_TRIGGER_GLOBAL_THREAD)
data->work.handler = fxas21002_work_handler;
#endif
/* Route the interrupts to INT1/INT2 pins */
ctrl_reg2 = 0U;
#if CONFIG_FXAS21002_DRDY_INT1
ctrl_reg2 |= FXAS21002_CTRLREG2_CFG_DRDY_MASK;
#endif
if (config->ops->byte_write(dev, FXAS21002_REG_CTRLREG2,
ctrl_reg2)) {
LOG_ERR("Could not configure interrupt pin routing");
return -EIO;
}
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
ret = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
if (ret < 0) {
return ret;
}
gpio_init_callback(&data->gpio_cb, fxas21002_gpio_callback,
BIT(config->int_gpio.pin));
ret = gpio_add_callback(config->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/nxp/fxas21002/fxas21002_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,500 |
```unknown
# NXP Kinetis temperature sensor configuration options
config TEMP_KINETIS
bool "NXP Kinetis Temperature Sensor"
default y
depends on DT_HAS_NXP_KINETIS_TEMPERATURE_ENABLED
depends on SOC_FAMILY_KINETIS
select ADC
help
Enable driver for NXP Kinetis temperature sensor.
if TEMP_KINETIS
config TEMP_KINETIS_RESOLUTION
int "ADC resolution"
default 16 if HAS_MCUX_ADC16
default 12 if HAS_MCUX_ADC12
help
ADC resolution to use for the temperature sensor and bandgap
voltage readings.
config TEMP_KINETIS_OVERSAMPLING
int "ADC oversampling"
default 0
range 0 5
help
ADC oversampling to use for the temperature sensor and
bandgap voltage readings. Oversampling can help in providing
more stable readings.
config TEMP_KINETIS_FILTER
bool "Digital filtering of ADC readings"
help
Enable weighted average digital filtering of the ADC
readings as per NXP AN3031.
endif # TEMP_KINETIS
``` | /content/code_sandbox/drivers/sensor/nxp/nxp_kinetis_temp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 230 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_kinetis_temperature
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(temp_kinetis, CONFIG_SENSOR_LOG_LEVEL);
/*
* Driver assumptions:
* - ADC samples are in uint16_t format
* - Both ADC channels (sensor and bandgap) are on the same ADC instance
*
* See NXP Application Note AN3031 for details on calculations.
*/
/* Two ADC samples required for each reading, sensor value and bandgap value */
#define TEMP_KINETIS_ADC_SAMPLES 2
struct temp_kinetis_config {
const struct device *adc;
uint8_t sensor_adc_ch;
uint8_t bandgap_adc_ch;
int bandgap_mv;
int vtemp25_mv;
int slope_cold_uv;
int slope_hot_uv;
struct adc_sequence adc_seq;
};
struct temp_kinetis_data {
uint16_t buffer[TEMP_KINETIS_ADC_SAMPLES];
};
static int temp_kinetis_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct temp_kinetis_config *config = dev->config;
struct temp_kinetis_data *data = dev->data;
#ifdef CONFIG_TEMP_KINETIS_FILTER
uint16_t previous[TEMP_KINETIS_ADC_SAMPLES];
int i;
#endif /* CONFIG_TEMP_KINETIS_FILTER */
int err;
/* Always read both sensor and bandgap voltage in one go */
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP &&
chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
#ifdef CONFIG_TEMP_KINETIS_FILTER
memcpy(previous, data->buffer, sizeof(previous));
#endif /* CONFIG_TEMP_KINETIS_FILTER */
err = adc_read(config->adc, &config->adc_seq);
if (err) {
LOG_ERR("failed to read ADC channels (err %d)", err);
return err;
}
LOG_DBG("sensor = %d, bandgap = %d", data->buffer[0], data->buffer[1]);
#ifdef CONFIG_TEMP_KINETIS_FILTER
if (previous[0] != 0 && previous[1] != 0) {
for (i = 0; i < ARRAY_SIZE(previous); i++) {
data->buffer[i] = (data->buffer[i] >> 1) +
(previous[i] >> 1);
}
LOG_DBG("sensor = %d, bandgap = %d (filtered)", data->buffer[0],
data->buffer[1]);
}
#endif /* CONFIG_TEMP_KINETIS_FILTER */
return 0;
}
static int temp_kinetis_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct temp_kinetis_config *config = dev->config;
struct temp_kinetis_data *data = dev->data;
uint16_t adcr_vdd = BIT_MASK(config->adc_seq.resolution);
uint16_t adcr_temp25;
int32_t temp_cc;
int32_t vdd_mv;
int slope_uv;
uint16_t adcr_100m;
if (chan != SENSOR_CHAN_VOLTAGE && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
/* VDD (or VREF, but AN3031 calls it VDD) in millivolts */
vdd_mv = (adcr_vdd * config->bandgap_mv) / data->buffer[1];
if (chan == SENSOR_CHAN_VOLTAGE) {
val->val1 = vdd_mv / 1000;
val->val2 = (vdd_mv % 1000) * 1000;
return 0;
}
/* ADC result for temperature = 25 degrees Celsius */
adcr_temp25 = (adcr_vdd * config->vtemp25_mv) / vdd_mv;
/* Determine which slope to use */
if (data->buffer[0] > adcr_temp25) {
slope_uv = config->slope_cold_uv;
} else {
slope_uv = config->slope_hot_uv;
}
adcr_100m = (adcr_vdd * slope_uv) / (vdd_mv * 10);
/* Temperature in centi degrees Celsius */
temp_cc = 2500 -
(((data->buffer[0] - adcr_temp25) * 10000) / adcr_100m);
val->val1 = temp_cc / 100;
val->val2 = (temp_cc % 100) * 10000;
return 0;
}
static const struct sensor_driver_api temp_kinetis_driver_api = {
.sample_fetch = temp_kinetis_sample_fetch,
.channel_get = temp_kinetis_channel_get,
};
static int temp_kinetis_init(const struct device *dev)
{
const struct temp_kinetis_config *config = dev->config;
struct temp_kinetis_data *data = dev->data;
int err;
int i;
const struct adc_channel_cfg ch_cfg[] = {
{
.gain = ADC_GAIN_1,
.reference = ADC_REF_INTERNAL,
.acquisition_time = ADC_ACQ_TIME_DEFAULT,
.channel_id = config->sensor_adc_ch,
.differential = 0,
},
{
.gain = ADC_GAIN_1,
.reference = ADC_REF_INTERNAL,
.acquisition_time = ADC_ACQ_TIME_DEFAULT,
.channel_id = config->bandgap_adc_ch,
.differential = 0,
},
};
memset(&data->buffer, 0, sizeof(data->buffer));
if (!device_is_ready(config->adc)) {
LOG_ERR("ADC device is not ready");
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(ch_cfg); i++) {
err = adc_channel_setup(config->adc, &ch_cfg[i]);
if (err) {
LOG_ERR("failed to configure ADC channel (err %d)",
err);
return err;
}
}
return 0;
}
BUILD_ASSERT(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) <= 1,
"unsupported temp instance");
#define TEMP_KINETIS_INIT(inst) \
BUILD_ASSERT(DT_INST_IO_CHANNELS_INPUT_BY_NAME(inst, sensor) < \
DT_INST_IO_CHANNELS_INPUT_BY_NAME(inst, bandgap), \
"This driver assumes sensor ADC channel to come before "\
"bandgap ADC channel"); \
\
static struct temp_kinetis_data temp_kinetis_data_0; \
\
static const struct temp_kinetis_config temp_kinetis_config_0 = {\
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(inst)),\
.sensor_adc_ch = \
DT_INST_IO_CHANNELS_INPUT_BY_NAME(inst, sensor),\
.bandgap_adc_ch = \
DT_INST_IO_CHANNELS_INPUT_BY_NAME(inst, bandgap),\
.bandgap_mv = DT_INST_PROP(0, bandgap_voltage) / 1000, \
.vtemp25_mv = DT_INST_PROP(0, vtemp25) / 1000, \
.slope_cold_uv = DT_INST_PROP(0, sensor_slope_cold), \
.slope_hot_uv = DT_INST_PROP(0, sensor_slope_hot), \
.adc_seq = { \
.options = NULL, \
.channels = \
BIT(DT_INST_IO_CHANNELS_INPUT_BY_NAME(inst, sensor)) | \
BIT(DT_INST_IO_CHANNELS_INPUT_BY_NAME(inst, bandgap)), \
.buffer = &temp_kinetis_data_0.buffer, \
.buffer_size = sizeof(temp_kinetis_data_0.buffer),\
.resolution = CONFIG_TEMP_KINETIS_RESOLUTION, \
.oversampling = CONFIG_TEMP_KINETIS_OVERSAMPLING,\
.calibrate = false, \
}, \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, temp_kinetis_init, \
NULL, \
&temp_kinetis_data_0, \
&temp_kinetis_config_0, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&temp_kinetis_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TEMP_KINETIS_INIT)
``` | /content/code_sandbox/drivers/sensor/nxp/nxp_kinetis_temp/temp_kinetis.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,809 |
```unknown
# NXP MCUX low power comparator (LPCMP) configuration options
config MCUX_LPCMP
bool "NXP LPCMP driver"
default y
depends on DT_HAS_NXP_LPCMP_ENABLED
select PINCTRL
help
Enable the MCUX LPCMP driver.
config MCUX_LPCMP_TRIGGER
bool "Trigger support"
depends on MCUX_LPCMP
help
Enable trigger support for the NXP LPCMP.
``` | /content/code_sandbox/drivers/sensor/nxp/mcux_lpcmp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 97 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_lpcmp
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <fsl_lpcmp.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/irq.h>
#include <zephyr/drivers/sensor/mcux_lpcmp.h>
#include <fsl_lpcmp.h>
LOG_MODULE_REGISTER(mcux_lpcmp, CONFIG_SENSOR_LOG_LEVEL);
struct mcux_lpcmp_config {
LPCMP_Type *base;
const struct pinctrl_dev_config *pincfg;
#ifdef CONFIG_MCUX_LPCMP_TRIGGER
void (*irq_config_func)(const struct device *dev);
#endif /* CONFIG_MCUX_LPCMP_TRIGGER */
bool output_enable: 1;
bool unfiltered: 1;
bool output_invert: 1;
lpcmp_hysteresis_mode_t hysteresis_level;
lpcmp_power_mode_t power_level;
lpcmp_functional_source_clock_t function_clock;
};
struct mcux_lpcmp_data {
lpcmp_config_t lpcmp_config;
lpcmp_dac_config_t dac_config;
lpcmp_filter_config_t filter_config;
lpcmp_window_control_config_t window_config;
#ifdef CONFIG_MCUX_LPCMP_TRIGGER
const struct device *dev;
const struct sensor_trigger *rising_trigger;
sensor_trigger_handler_t rising_handler;
const struct sensor_trigger *falling_trigger;
sensor_trigger_handler_t falling_handler;
struct k_work work;
volatile uint32_t status;
#endif /* CONFIG_MCUX_LPCMP_TRIGGER */
bool cout;
};
static int mcux_lpcmp_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct mcux_lpcmp_config *config = dev->config;
struct mcux_lpcmp_data *data = dev->data;
int32_t val1 = val->val1;
__ASSERT_NO_MSG(val != NULL);
if ((int16_t)chan != SENSOR_CHAN_MCUX_LPCMP_OUTPUT) {
return -ENOTSUP;
}
if (val->val2 != 0) {
return -EINVAL;
}
switch ((int16_t)attr) {
/** Analog input mux related attributes */
case SENSOR_ATTR_MCUX_LPCMP_POSITIVE_MUX_INPUT:
LOG_DBG("positive mux = %d", val1);
if (val1 >= 0 && val1 < 8) {
config->base->CCR2 = ((config->base->CCR2 & (~LPCMP_CCR2_PSEL_MASK)) |
LPCMP_CCR2_PSEL(val1));
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_NEGATIVE_MUX_INPUT:
LOG_DBG("negative mux = %d", val1);
if (val1 >= 0 && val1 < 8) {
config->base->CCR2 = ((config->base->CCR2 & (~LPCMP_CCR2_MSEL_MASK)) |
LPCMP_CCR2_MSEL(val1));
} else {
return -EINVAL;
}
break;
/** DAC related attributes */
case SENSOR_ATTR_MCUX_LPCMP_DAC_ENABLE:
LOG_DBG("dac enable = %d", val1);
if (val1 == 1) {
config->base->DCR |= LPCMP_DCR_DAC_EN_MASK;
} else if (val1 == 0) {
config->base->DCR &= ~LPCMP_DCR_DAC_EN_MASK;
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_DAC_HIGH_POWER_MODE_ENABLE:
LOG_DBG("dac power mode = %d", val1);
if ((val1 == 1) || (val1 == 0)) {
data->dac_config.enableLowPowerMode = (bool)val1;
LPCMP_SetDACConfig(config->base, &data->dac_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_DAC_REFERENCE_VOLTAGE_SOURCE:
LOG_DBG("dac vref = %d", val1);
if (val1 >= kLPCMP_VrefSourceVin1 && val1 <= kLPCMP_VrefSourceVin2) {
data->dac_config.referenceVoltageSource = val1;
LPCMP_SetDACConfig(config->base, &data->dac_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_DAC_OUTPUT_VOLTAGE:
LOG_DBG("dac value = %d", val1);
if (val1 >= 0 && val1 < 256) {
data->dac_config.DACValue = val1;
LPCMP_SetDACConfig(config->base, &data->dac_config);
} else {
return -EINVAL;
}
break;
/** Sample and filter related attributes */
case SENSOR_ATTR_MCUX_LPCMP_SAMPLE_ENABLE:
LOG_DBG("Filter sample enable = %d", val1);
if ((val1 == 1) || (val1 == 0)) {
data->filter_config.enableSample = (bool)val1;
LPCMP_SetFilterConfig(config->base, &data->filter_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_FILTER_COUNT:
LOG_DBG("sample count = %d", val1);
data->filter_config.filterSampleCount = val1;
LPCMP_SetFilterConfig(config->base, &data->filter_config);
break;
case SENSOR_ATTR_MCUX_LPCMP_FILTER_PERIOD:
LOG_DBG("sample period = %d", val1);
data->filter_config.filterSamplePeriod = val1;
LPCMP_SetFilterConfig(config->base, &data->filter_config);
break;
/** Window related attributes */
case SENSOR_ATTR_MCUX_LPCMP_COUTA_WINDOW_ENABLE:
LOG_DBG("Window enable = %d", val1);
if ((val1 == 1) || (val1 == 0)) {
LPCMP_EnableWindowMode(config->base, (bool)val1);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_COUTA_WINDOW_SIGNAL_INVERT_ENABLE:
LOG_DBG("Invert window signal = %d", val1);
if ((val1 == 1) || (val1 == 0)) {
data->window_config.enableInvertWindowSignal = (bool)val1;
LPCMP_SetWindowControl(config->base, &data->window_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_COUTA_SIGNAL:
LOG_DBG("COUTA signal = %d", val1);
if ((val1 >= (int32_t)kLPCMP_COUTASignalNoSet) &&
(val1 < (int32_t)kLPCMP_COUTASignalHigh)) {
data->window_config.COUTASignal = val1;
LPCMP_SetWindowControl(config->base, &data->window_config);
} else {
return -EINVAL;
}
break;
case SENSOR_ATTR_MCUX_LPCMP_COUT_EVENT_TO_CLOSE_WINDOW:
LOG_DBG("COUT event = %d", val1);
if ((val1 >= (int32_t)kLPCMP_CLoseWindowEventNoSet) &&
(val1 < (int32_t)kLPCMP_CLoseWindowEventBothEdge)) {
data->window_config.closeWindowEvent = val1;
LPCMP_SetWindowControl(config->base, &data->window_config);
} else {
return -EINVAL;
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int mcux_lpcmp_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct mcux_lpcmp_config *config = dev->config;
struct mcux_lpcmp_data *data = dev->data;
__ASSERT_NO_MSG(val != NULL);
if ((int16_t)chan != SENSOR_CHAN_MCUX_LPCMP_OUTPUT) {
return -ENOTSUP;
}
switch ((int16_t)attr) {
/** Analog mux related attributes */
case SENSOR_ATTR_MCUX_LPCMP_POSITIVE_MUX_INPUT:
val->val1 = (int32_t)((config->base->CCR2) &
LPCMP_CCR2_PSEL_MASK >> LPCMP_CCR2_PSEL_SHIFT);
break;
case SENSOR_ATTR_MCUX_LPCMP_NEGATIVE_MUX_INPUT:
val->val1 = (int32_t)((config->base->CCR2) &
LPCMP_CCR2_MSEL_MASK >> LPCMP_CCR2_MSEL_SHIFT);
break;
/** DAC related attributes */
case SENSOR_ATTR_MCUX_LPCMP_DAC_ENABLE:
val->val1 = (int32_t)((config->base->DCR) &
LPCMP_DCR_DAC_EN_MASK >> LPCMP_DCR_DAC_EN_SHIFT);
break;
case SENSOR_ATTR_MCUX_LPCMP_DAC_HIGH_POWER_MODE_ENABLE:
val->val1 = (int32_t)(data->dac_config.enableLowPowerMode);
break;
case SENSOR_ATTR_MCUX_LPCMP_DAC_REFERENCE_VOLTAGE_SOURCE:
val->val1 = (int32_t)(data->dac_config.referenceVoltageSource);
break;
case SENSOR_ATTR_MCUX_LPCMP_DAC_OUTPUT_VOLTAGE:
val->val1 = (int32_t)(data->dac_config.DACValue);
break;
/** Sample and filter related attributes */
case SENSOR_ATTR_MCUX_LPCMP_SAMPLE_ENABLE:
val->val1 = (int32_t)(data->filter_config.enableSample);
break;
case SENSOR_ATTR_MCUX_LPCMP_FILTER_COUNT:
val->val1 = (int32_t)(data->filter_config.filterSampleCount);
break;
case SENSOR_ATTR_MCUX_LPCMP_FILTER_PERIOD:
val->val1 = (int32_t)(data->filter_config.filterSamplePeriod);
break;
/** Window related attributes */
case SENSOR_ATTR_MCUX_LPCMP_COUTA_WINDOW_ENABLE:
val->val1 = (int32_t)((config->base->CCR1) &
LPCMP_CCR1_WINDOW_EN_MASK >> LPCMP_CCR1_WINDOW_EN_SHIFT);
break;
case SENSOR_ATTR_MCUX_LPCMP_COUTA_WINDOW_SIGNAL_INVERT_ENABLE:
val->val1 = (int32_t)(data->window_config.enableInvertWindowSignal);
break;
case SENSOR_ATTR_MCUX_LPCMP_COUTA_SIGNAL:
val->val1 = (int32_t)(data->window_config.COUTASignal);
break;
case SENSOR_ATTR_MCUX_LPCMP_COUT_EVENT_TO_CLOSE_WINDOW:
val->val1 = (int32_t)(data->window_config.closeWindowEvent);
break;
default:
return -ENOTSUP;
}
val->val2 = 0;
return 0;
}
static int mcux_lpcmp_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct mcux_lpcmp_config *config = dev->config;
struct mcux_lpcmp_data *data = dev->data;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_ALL && (int16_t)chan != SENSOR_CHAN_MCUX_LPCMP_OUTPUT) {
return -ENOTSUP;
}
data->cout = ((LPCMP_GetStatusFlags(config->base) &
(uint32_t)kLPCMP_OutputAssertEventFlag) == kLPCMP_OutputAssertEventFlag);
return 0;
}
static int mcux_lpcmp_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct mcux_lpcmp_data *data = dev->data;
__ASSERT_NO_MSG(val != NULL);
if ((int16_t)chan != SENSOR_CHAN_MCUX_LPCMP_OUTPUT) {
return -ENOTSUP;
}
val->val1 = data->cout ? 1 : 0;
val->val2 = 0;
return 0;
}
#ifdef CONFIG_MCUX_LPCMP_TRIGGER
static void mcux_lpcmp_isr(const struct device *dev)
{
const struct mcux_lpcmp_config *config = dev->config;
struct mcux_lpcmp_data *data = dev->data;
data->status = LPCMP_GetStatusFlags(config->base);
LPCMP_ClearStatusFlags(config->base, data->status);
k_work_submit(&data->work);
}
static int mcux_lpcmp_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct mcux_lpcmp_data *data = dev->data;
__ASSERT_NO_MSG(trig != NULL);
if ((int16_t)trig->chan != SENSOR_CHAN_MCUX_LPCMP_OUTPUT) {
return -ENOTSUP;
}
if ((int16_t)trig->type == SENSOR_TRIG_MCUX_LPCMP_OUTPUT_RISING) {
data->rising_handler = handler;
data->rising_trigger = trig;
} else if ((int16_t)trig->type == SENSOR_TRIG_MCUX_LPCMP_OUTPUT_FALLING) {
data->falling_handler = handler;
data->falling_trigger = trig;
} else {
return -ENOTSUP;
}
return 0;
}
static void mcux_lpcmp_trigger_work_handler(struct k_work *item)
{
struct mcux_lpcmp_data *data = CONTAINER_OF(item, struct mcux_lpcmp_data, work);
const struct sensor_trigger *trigger;
sensor_trigger_handler_t handler = NULL;
if (((data->status & kLPCMP_OutputRisingEventFlag) == kLPCMP_OutputRisingEventFlag) &&
((data->status & kLPCMP_OutputAssertEventFlag) == kLPCMP_OutputAssertEventFlag)) {
trigger = data->rising_trigger;
handler = data->rising_handler;
} else if (((data->status & kLPCMP_OutputFallingEventFlag) ==
kLPCMP_OutputFallingEventFlag) &&
((data->status & kLPCMP_OutputAssertEventFlag) !=
kLPCMP_OutputAssertEventFlag)) {
trigger = data->falling_trigger;
handler = data->falling_handler;
} else {
return;
}
if (handler) {
handler(data->dev, trigger);
}
}
#endif /* CONFIG_MCUX_LPCMP_TRIGGER */
static int mcux_lpcmp_init(const struct device *dev)
{
const struct mcux_lpcmp_config *config = dev->config;
struct mcux_lpcmp_data *data = dev->data;
int err;
err = pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT);
if (err) {
return err;
}
/* LPCMP configuration */
LPCMP_GetDefaultConfig(&data->lpcmp_config);
data->lpcmp_config.powerMode = config->power_level;
data->lpcmp_config.hysteresisMode = config->hysteresis_level;
data->lpcmp_config.enableOutputPin = config->output_enable;
data->lpcmp_config.enableInvertOutput = config->output_invert;
data->lpcmp_config.useUnfilteredOutput = config->unfiltered;
#if defined(FSL_FEATURE_LPCMP_HAS_CCR1_FUNC_CLK_SEL) && FSL_FEATURE_LPCMP_HAS_CCR1_FUNC_CLK_SEL
data->lpcmp_config.functionalSourceClock = config->function_clock;
#endif /* FSL_FEATURE_LPCMP_HAS_CCR1_FUNC_CLK_SEL */
LPCMP_Init(config->base, &data->lpcmp_config);
#ifdef CONFIG_MCUX_LPCMP_TRIGGER
data->dev = dev;
k_work_init(&data->work, mcux_lpcmp_trigger_work_handler);
config->irq_config_func(dev);
LPCMP_EnableInterrupts(config->base, kLPCMP_OutputRisingInterruptEnable |
kLPCMP_OutputFallingInterruptEnable);
#endif /* CONFIG_MCUX_LPCMP_TRIGGER */
LPCMP_Enable(config->base, true);
return 0;
}
static const struct sensor_driver_api mcux_lpcmp_driver_api = {
.attr_set = mcux_lpcmp_attr_set,
.attr_get = mcux_lpcmp_attr_get,
#ifdef CONFIG_MCUX_LPCMP_TRIGGER
.trigger_set = mcux_lpcmp_trigger_set,
#endif /* CONFIG_MCUX_LPCMP_TRIGGER */
.sample_fetch = mcux_lpcmp_sample_fetch,
.channel_get = mcux_lpcmp_channel_get,
};
#define MCUX_LPCMP_DECLARE_CONFIG(n, config_func_init) \
static const struct mcux_lpcmp_config mcux_lpcmp_config_##n = { \
.base = (LPCMP_Type *)DT_INST_REG_ADDR(n), \
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \
.output_enable = DT_INST_PROP_OR(n, enable_output_pin, 0), \
.unfiltered = DT_INST_PROP_OR(n, use_unfiltered_output, 0), \
.output_invert = DT_INST_PROP_OR(n, output_invert, 0), \
.hysteresis_level = DT_INST_PROP_OR(n, hysteresis_level, 0), \
.power_level = DT_INST_ENUM_IDX(n, power_level), \
.function_clock = DT_INST_ENUM_IDX(n, function_clock), \
config_func_init}
#ifdef CONFIG_MCUX_LPCMP_TRIGGER
#define MCUX_LPCMP_CONFIG_FUNC(n) \
static void mcux_lpcmp_config_func_##n(const struct device *dev) \
{ \
IRQ_CONNECT(DT_INST_IRQN(n), DT_INST_IRQ(n, priority), mcux_lpcmp_isr, \
DEVICE_DT_INST_GET(n), 0); \
irq_enable(DT_INST_IRQN(n)); \
}
#define MCUX_LPCMP_CONFIG_FUNC_INIT(n) .irq_config_func = mcux_lpcmp_config_func_##n
#define MCUX_LPCMP_INIT_CONFIG(n) MCUX_LPCMP_DECLARE_CONFIG(n, MCUX_LPCMP_CONFIG_FUNC_INIT(n))
#else /* CONFIG_MCUX_LPCMP_TRIGGER */
#define MCUX_LPCMP_CONFIG_FUNC(n)
#define MCUX_LPCMP_CONFIG_FUNC_INIT
#define MCUX_LPCMP_INIT_CONFIG(n) MCUX_LPCMP_DECLARE_CONFIG(n, MCUX_LPCMP_CONFIG_FUNC_INIT)
#endif /* !CONFIG_MCUX_LPCMP_TRIGGER */
#define MCUX_LPCMP_INIT(n) \
static struct mcux_lpcmp_data mcux_lpcmp_data_##n; \
static const struct mcux_lpcmp_config mcux_lpcmp_config_##n; \
PINCTRL_DT_INST_DEFINE(n); \
SENSOR_DEVICE_DT_INST_DEFINE(n, &mcux_lpcmp_init, NULL, &mcux_lpcmp_data_##n, \
&mcux_lpcmp_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &mcux_lpcmp_driver_api); \
MCUX_LPCMP_CONFIG_FUNC(n) \
MCUX_LPCMP_INIT_CONFIG(n);
DT_INST_FOREACH_STATUS_OKAY(MCUX_LPCMP_INIT)
``` | /content/code_sandbox/drivers/sensor/nxp/mcux_lpcmp/mcux_lpcmp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,207 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_fxls8974
#include "fxls8974.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(FXLS8974, CONFIG_SENSOR_LOG_LEVEL);
static void fxls8974_gpio_callback(const struct device *dev,
struct gpio_callback *cb,
uint32_t pin_mask)
{
struct fxls8974_data *data =
CONTAINER_OF(cb, struct fxls8974_data, gpio_cb);
const struct fxls8974_config *config = data->dev->config;
if ((pin_mask & BIT(config->int_gpio.pin)) == 0U) {
return;
}
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_FXLS8974_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_FXLS8974_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static int fxls8974_handle_drdy_int(const struct device *dev)
{
struct fxls8974_data *data = dev->data;
if (data->drdy_handler) {
data->drdy_handler(dev, data->drdy_trig);
}
return 0;
}
static void fxls8974_handle_int(const struct device *dev)
{
const struct fxls8974_config *config = dev->config;
fxls8974_handle_drdy_int(dev);
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_LEVEL_HIGH);
}
#ifdef CONFIG_FXLS8974_TRIGGER_OWN_THREAD
static void fxls8974_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct fxls8974_data *data = p1;
while (true) {
k_sem_take(&data->trig_sem, K_FOREVER);
fxls8974_handle_int(data->dev);
}
}
#endif
#ifdef CONFIG_FXLS8974_TRIGGER_GLOBAL_THREAD
static void fxls8974_work_handler(struct k_work *work)
{
struct fxls8974_data *data =
CONTAINER_OF(work, struct fxls8974_data, work);
fxls8974_handle_int(data->dev);
}
#endif
int fxls8974_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct fxls8974_data *data = dev->data;
int ret = 0;
k_sem_take(&data->sem, K_FOREVER);
/* Put the sensor in standby mode */
if (fxls8974_set_active(dev, FXLS8974_ACTIVE_OFF)) {
LOG_ERR("Could not set standby mode");
ret = -EIO;
goto exit;
}
if (trig->type == SENSOR_TRIG_DATA_READY) {
data->drdy_handler = handler;
data->drdy_trig = trig;
} else {
LOG_ERR("Unsupported sensor trigger");
ret = -ENOTSUP;
goto exit;
}
/* Restore the previous active mode */
if (fxls8974_set_active(dev, FXLS8974_ACTIVE_ON)) {
LOG_ERR("Could not restore active mode");
ret = -EIO;
goto exit;
}
exit:
k_sem_give(&data->sem);
return ret;
}
int fxls8974_trigger_init(const struct device *dev)
{
const struct fxls8974_config *config = dev->config;
struct fxls8974_data *data = dev->data;
int ret;
data->dev = dev;
#if defined(CONFIG_FXLS8974_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_FXLS8974_THREAD_STACK_SIZE,
fxls8974_thread_main,
data, NULL, NULL,
K_PRIO_COOP(CONFIG_FXLS8974_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_FXLS8974_TRIGGER_GLOBAL_THREAD)
data->work.handler = fxls8974_work_handler;
#endif
if (config->ops->byte_write(dev, FXLS8974_INTREG_EN,
FXLS8974_DRDY_MASK)) {
LOG_ERR("Could not enable interrupt");
return -EIO;
}
#if !(CONFIG_FXLS8974_DRDY_INT1)
if (config->ops->byte_write(dev, FXLS8974_INT_PIN_SEL_REG,
FXLS8974_DRDY_MASK)) {
LOG_ERR("Could not configure interrupt pin routing");
return -EIO;
}
#endif
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
ret = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
if (ret < 0) {
return ret;
}
gpio_init_callback(&data->gpio_cb, fxls8974_gpio_callback,
BIT(config->int_gpio.pin));
ret = gpio_add_callback(config->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
return ret;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/nxp/fxls8974/fxls8974_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,146 |
```c
/*
*
*/
#define DT_DRV_COMPAT nxp_fxls8974
#include "fxls8974.h"
#include <zephyr/sys/util.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <stdlib.h>
LOG_MODULE_REGISTER(FXLS8974, CONFIG_SENSOR_LOG_LEVEL);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define DIR_READ(a) ((a) & 0x7f)
#define DIR_WRITE(a) ((a) | BIT(7))
#define ADDR_7(a) ((a) & BIT(7))
int fxls8974_transceive(const struct device *dev,
void *data, size_t length)
{
const struct fxls8974_config *cfg = dev->config;
const struct spi_buf buf = { .buf = data, .len = length };
const struct spi_buf_set s = { .bufs = &buf, .count = 1 };
return spi_transceive_dt(&cfg->bus_cfg.spi, &s, &s);
}
int fxls8974_read_spi(const struct device *dev,
uint8_t reg,
void *data,
size_t length)
{
const struct fxls8974_config *cfg = dev->config;
/* Reads must clock out a dummy byte after sending the address. */
uint8_t reg_buf[3] = { DIR_READ(reg), ADDR_7(reg), 0 };
const struct spi_buf buf[2] = {
{ .buf = reg_buf, .len = 3 },
{ .buf = data, .len = length }
};
const struct spi_buf_set tx = { .bufs = buf, .count = 1 };
const struct spi_buf_set rx = { .bufs = buf, .count = 2 };
return spi_transceive_dt(&cfg->bus_cfg.spi, &tx, &rx);
}
int fxls8974_byte_read_spi(const struct device *dev,
uint8_t reg,
uint8_t *byte)
{
/* Reads must clock out a dummy byte after sending the address. */
uint8_t data[] = { DIR_READ(reg), ADDR_7(reg), 0};
int ret;
ret = fxls8974_transceive(dev, data, sizeof(data));
*byte = data[2];
return ret;
}
int fxls8974_byte_write_spi(const struct device *dev,
uint8_t reg,
uint8_t byte)
{
uint8_t data[] = { DIR_WRITE(reg), ADDR_7(reg), byte };
return fxls8974_transceive(dev, data, sizeof(data));
}
int fxls8974_reg_field_update_spi(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val)
{
uint8_t old_val;
if (fxls8974_byte_read_spi(dev, reg, &old_val) < 0) {
return -EIO;
}
return fxls8974_byte_write_spi(dev, reg, (old_val & ~mask) | (val & mask));
}
static const struct fxls8974_io_ops fxls8974_spi_ops = {
.read = fxls8974_read_spi,
.byte_read = fxls8974_byte_read_spi,
.byte_write = fxls8974_byte_write_spi,
.reg_field_update = fxls8974_reg_field_update_spi,
};
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
int fxls8974_read_i2c(const struct device *dev,
uint8_t reg,
void *data,
size_t length)
{
const struct fxls8974_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->bus_cfg.i2c, reg, data, length);
}
int fxls8974_byte_read_i2c(const struct device *dev,
uint8_t reg,
uint8_t *byte)
{
const struct fxls8974_config *cfg = dev->config;
return i2c_reg_read_byte_dt(&cfg->bus_cfg.i2c, reg, byte);
}
int fxls8974_byte_write_i2c(const struct device *dev,
uint8_t reg,
uint8_t byte)
{
const struct fxls8974_config *cfg = dev->config;
return i2c_reg_write_byte_dt(&cfg->bus_cfg.i2c, reg, byte);
}
int fxls8974_reg_field_update_i2c(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val)
{
const struct fxls8974_config *cfg = dev->config;
return i2c_reg_update_byte_dt(&cfg->bus_cfg.i2c, reg, mask, val);
}
static const struct fxls8974_io_ops fxls8974_i2c_ops = {
.read = fxls8974_read_i2c,
.byte_read = fxls8974_byte_read_i2c,
.byte_write = fxls8974_byte_write_i2c,
.reg_field_update = fxls8974_reg_field_update_i2c,
};
#endif
static int fxls8974_set_odr(const struct device *dev,
const struct sensor_value *val, enum fxls8974_wake mode)
{
const struct fxls8974_config *cfg = dev->config;
uint8_t odr;
/* val int32 */
switch (val->val1) {
case 3200:
odr = FXLS8974_CTRLREG3_ODR_RATE_3200;
break;
case 800:
odr = FXLS8974_CTRLREG3_ODR_RATE_800;
break;
case 400:
odr = FXLS8974_CTRLREG3_ODR_RATE_400;
break;
case 200:
odr = FXLS8974_CTRLREG3_ODR_RATE_200;
break;
case 100:
odr = FXLS8974_CTRLREG3_ODR_RATE_100;
break;
case 50:
odr = FXLS8974_CTRLREG3_ODR_RATE_50;
break;
case 25:
odr = FXLS8974_CTRLREG3_ODR_RATE_25;
break;
case 12:
if (val->val2 == 500000) {
odr = FXLS8974_CTRLREG3_ODR_RATE_12_5;
break;
}
return -EINVAL;
case 6:
if (val->val2 == 250000) {
odr = FXLS8974_CTRLREG3_ODR_RATE_6_25;
break;
}
return -EINVAL;
case 3:
if (val->val2 == 125000) {
odr = FXLS8974_CTRLREG3_ODR_RATE_3_125;
break;
}
return -EINVAL;
case 1:
if (val->val2 == 563000) {
odr = FXLS8974_CTRLREG3_ODR_RATE_1_563;
break;
}
return -EINVAL;
case 0:
if (val->val2 == 781000) {
odr = FXLS8974_CTRLREG3_ODR_RATE_0_781;
break;
}
return -EINVAL;
default:
return -EINVAL;
}
LOG_DBG("Set %s ODR to 0x%02x", (mode == FXLS8974_WAKE) ? "wake" : "sleep", odr);
/* Change the attribute and restore active mode. */
if (mode == FXLS8974_WAKE) {
return cfg->ops->reg_field_update(dev, FXLS8974_REG_CTRLREG3,
FXLS8974_CTRLREG3_WAKE_ODR_MASK,
odr<<4);
} else {
return cfg->ops->reg_field_update(dev, FXLS8974_REG_CTRLREG3,
FXLS8974_CTRLREG3_SLEEP_ODR_MASK,
odr);
}
}
static int fxls8974_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return fxls8974_set_odr(dev, val, FXLS8974_WAKE);
default:
return -ENOTSUP;
}
return 0;
}
static int fxls8974_sample_fetch(const struct device *dev, enum sensor_channel ch)
{
const struct fxls8974_config *cfg = dev->config;
struct fxls8974_data *data = dev->data;
uint8_t buf[FXLS8974_MAX_NUM_BYTES];
int16_t *raw;
int ret = 0;
int i;
k_sem_take(&data->sem, K_FOREVER);
/* Read all the accel channels in one I2C/SPI transaction. */
if (cfg->ops->read(dev, FXLS8974_REG_OUTXLSB, buf, FXLS8974_MAX_ACCEL_BYTES)) {
LOG_ERR("Could not fetch accelerometer data");
ret = -EIO;
goto exit;
}
if (cfg->ops->byte_read(dev, FXLS8974_REG_OUTTEMP, buf+FXLS8974_DATA_TEMP_OFFSET)) {
LOG_ERR("Could not fetch temperature");
ret = -EIO;
goto exit;
}
/* Parse the buf into raw channel data (16-bit integers). To save
* RAM, store the data in raw format and wait to convert to the
* normalized sensor_value type until later.
*/
__ASSERT(FXLS8974_MAX_NUM_CHANNELS <= ARRAY_SIZE(data->raw),
"Too many channels");
raw = &data->raw[FXLS8974_CHANNEL_ACCEL_X];
for (i = 0; i < FXLS8974_MAX_ACCEL_BYTES; i += 2) {
*raw++ = (buf[i+1] << 8) | (buf[i]);
}
*raw = *(buf+FXLS8974_MAX_ACCEL_BYTES);
exit:
k_sem_give(&data->sem);
return ret;
}
static void fxls8974_accel_convert(struct sensor_value *val, int16_t raw,
uint8_t fsr)
{
int64_t micro_ms2;
/* Convert units to micro m/s^2. */
micro_ms2 = (raw * SENSOR_G) >> fsr;
/* The maximum possible value is 16g, which in units of micro m/s^2
* always fits into 32-bits. Cast down to int32_t so we can use a
* faster divide.
*/
val->val1 = (int32_t) micro_ms2 / 1000000;
val->val2 = (int32_t) micro_ms2 % 1000000;
}
static int fxls8974_get_accel_data(const struct device *dev,
struct sensor_value *val, enum sensor_channel ch)
{
const struct fxls8974_config *cfg = dev->config;
struct fxls8974_data *data = dev->data;
int16_t *raw;
uint8_t fsr;
k_sem_take(&data->sem, K_FOREVER);
if (cfg->ops->byte_read(dev, FXLS8974_REG_CTRLREG1, &fsr)) {
LOG_ERR("Could not read scale settings");
return -EIO;
}
fsr = (fsr & FXLS8974_CTRLREG1_FSR_MASK) >> 1;
switch (fsr) {
case 0b00:
fsr = 10U;
break;
case 0b01:
fsr = 9U;
break;
case 0b10:
fsr = 8U;
break;
case 0b11:
fsr = 7U;
break;
}
if (ch == SENSOR_CHAN_ACCEL_XYZ) {
raw = &data->raw[FXLS8974_CHANNEL_ACCEL_X];
for (int i = 0; i < FXLS8974_MAX_ACCEL_CHANNELS; i++) {
fxls8974_accel_convert(val++, *raw++, fsr);
}
} else {
switch (ch) {
case SENSOR_CHAN_ACCEL_X:
raw = &data->raw[FXLS8974_CHANNEL_ACCEL_X];
break;
case SENSOR_CHAN_ACCEL_Y:
raw = &data->raw[FXLS8974_CHANNEL_ACCEL_Y];
break;
case SENSOR_CHAN_ACCEL_Z:
raw = &data->raw[FXLS8974_CHANNEL_ACCEL_Z];
break;
default:
return -ENOTSUP;
}
fxls8974_accel_convert(val, *raw, fsr);
}
k_sem_give(&data->sem);
return 0;
}
static int fxls8974_get_temp_data(const struct device *dev, struct sensor_value *val)
{
struct fxls8974_data *data = dev->data;
int16_t *raw;
k_sem_take(&data->sem, K_FOREVER);
raw = &data->raw[FXLS8974_CHANNEL_TEMP];
val->val1 = *raw+FXLS8974_ZERO_TEMP;
k_sem_give(&data->sem);
return 0;
}
static int fxls8974_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ALL:
if (fxls8974_get_accel_data(dev, val, SENSOR_CHAN_ACCEL_XYZ)) {
return -EIO;
}
val += FXLS8974_MAX_ACCEL_CHANNELS;
if (fxls8974_get_temp_data(dev, val)) {
return -EIO;
}
break;
case SENSOR_CHAN_ACCEL_XYZ:
return fxls8974_get_accel_data(dev, val, SENSOR_CHAN_ACCEL_XYZ);
case SENSOR_CHAN_ACCEL_X:
__fallthrough;
case SENSOR_CHAN_ACCEL_Y:
__fallthrough;
case SENSOR_CHAN_ACCEL_Z:
return fxls8974_get_accel_data(dev, val, chan);
case SENSOR_CHAN_AMBIENT_TEMP:
return fxls8974_get_temp_data(dev, val);
default:
LOG_ERR("Unsupported channel");
return -ENOTSUP;
}
return 0;
}
int fxls8974_get_active(const struct device *dev, enum fxls8974_active *active)
{
const struct fxls8974_config *cfg = dev->config;
uint8_t val;
if (cfg->ops->byte_read(dev, FXLS8974_REG_CTRLREG1, &val)) {
LOG_ERR("Could not get active setting");
return -EIO;
}
val &= FXLS8974_CTRLREG1_ACTIVE_MASK;
*active = val;
return 0;
}
int fxls8974_set_active(const struct device *dev, enum fxls8974_active active)
{
const struct fxls8974_config *cfg = dev->config;
return cfg->ops->reg_field_update(dev, FXLS8974_REG_CTRLREG1,
FXLS8974_CTRLREG1_ACTIVE_MASK, active);
}
static void fxls8974_print_config(const struct device *dev)
{
const struct fxls8974_config *cfg = dev->config;
uint8_t regVal[5];
if (cfg->ops->read(dev, FXLS8974_REG_CTRLREG1, regVal, 5)) {
LOG_ERR("Failed to read config registers");
}
LOG_DBG("Current config:\n\r"
"CFG: 0x%02x CFG2: 0x%02x CFG3: 0x%02x CFG4: 0x%02x CFG5: 0x%02x",
regVal[0], regVal[1], regVal[2], regVal[3], regVal[4]);
}
static int fxls8974_init(const struct device *dev)
{
const struct fxls8974_config *cfg = dev->config;
struct fxls8974_data *data = dev->data;
struct sensor_value odr = {.val1 = 6, .val2 = 250000};
uint8_t regVal;
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c_spec = cfg->bus_cfg.i2c;
if (cfg->inst_on_bus == FXLS8974_BUS_I2C) {
if (!i2c_is_ready_dt(&i2c_spec)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
}
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi_spec = cfg->bus_cfg.spi;
if (cfg->inst_on_bus == FXLS8974_BUS_SPI) {
if (!spi_is_ready_dt(&spi_spec)) {
LOG_ERR("SPI bus device not ready");
return -ENODEV;
}
}
#endif
/* Software reset the sensor. Upon issuing a software
* reset command over the I2C interface, the sensor
* immediately resets and does not send any
* acknowledgment (ACK) of the written byte to the
* master. Therefore, do not check the return code of
* the I2C transaction.
*/
cfg->ops->byte_write(dev, FXLS8974_REG_CTRLREG1,
FXLS8974_CTRLREG1_RST_MASK);
/* The sensor requires us to wait 1 ms after a reset before
* attempting further communications.
*/
k_busy_wait(USEC_PER_MSEC);
/*
* Read the WHOAMI register to make sure we are talking to FXLS8974 or
* compatible device and not some other type of device that happens to
* have the same I2C address.
*/
if (cfg->ops->byte_read(dev, FXLS8974_REG_WHOAMI,
&data->whoami)) {
LOG_ERR("Could not get WHOAMI value");
return -EIO;
}
if (data->whoami == WHOAMI_ID_FXLS8974) {
LOG_DBG("Device ID 0x%x, FXLS8974", data->whoami);
} else {
LOG_ERR("Unknown Device ID 0x%x", data->whoami);
return -EIO;
}
if (fxls8974_get_active(dev, (enum fxls8974_active *)®Val)) {
LOG_ERR("Failed to set standby mode");
return -EIO;
}
if (regVal != FXLS8974_ACTIVE_OFF) {
LOG_ERR("Not in standby mode");
return -EIO;
}
if (cfg->ops->byte_write(dev, FXLS8974_REG_CTRLREG4,
FXLS8974_CTRLREG4_INT_POL_HIGH)) {
LOG_ERR("Could not set up register 4");
return -EIO;
}
if (cfg->ops->byte_read(dev, FXLS8974_REG_CTRLREG4, ®Val)) {
LOG_ERR("Could not get CTRL_REG4 value");
return -EIO;
}
if (regVal != FXLS8974_CTRLREG4_INT_POL_HIGH) {
LOG_ERR("CTRLREG4 is not set up properly");
return -EIO;
}
if (fxls8974_set_odr(dev, &odr, FXLS8974_WAKE)) {
LOG_ERR("Could not set default data rate");
return -EIO;
}
/* Set the +-2G mode */
if (cfg->ops->byte_write(dev, FXLS8974_REG_CTRLREG1,
FXLS8974_CTRLREG1_FSR_2G)) {
LOG_ERR("Could not set range");
return -EIO;
}
if (cfg->ops->byte_read(dev, FXLS8974_REG_CTRLREG1,
®Val)) {
LOG_ERR("Could not ret CTRL_REG1 value");
return -EIO;
}
if ((regVal & FXLS8974_CTRLREG1_FSR_MASK) != FXLS8974_CTRLREG1_FSR_2G) {
LOG_ERR("Wrong range selected!");
return -EIO;
}
k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);
#if CONFIG_FXLS8974_TRIGGER
if (fxls8974_trigger_init(dev)) {
LOG_ERR("Could not initialize interrupts");
return -EIO;
}
#endif
if (fxls8974_set_active(dev, FXLS8974_ACTIVE_ON)) {
LOG_ERR("Could not set active mode");
return -EIO;
}
if (fxls8974_get_active(dev, (enum fxls8974_active *)®Val)) {
LOG_ERR("Failed to get active mode");
return -EIO;
}
if (regVal != FXLS8974_ACTIVE_ON) {
LOG_ERR("Not in active mode");
return -EIO;
}
fxls8974_print_config(dev);
k_sem_give(&data->sem);
LOG_DBG("Init complete");
return 0;
}
static const struct sensor_driver_api fxls8974_driver_api = {
.sample_fetch = fxls8974_sample_fetch,
.channel_get = fxls8974_channel_get,
.attr_set = fxls8974_attr_set,
#if CONFIG_FXLS8974_TRIGGER
.trigger_set = fxls8974_trigger_set,
#endif
};
#define FXLS8974_CONFIG_I2C(n) \
.bus_cfg = { .i2c = I2C_DT_SPEC_INST_GET(n) }, \
.ops = &fxls8974_i2c_ops, \
.range = DT_INST_PROP(n, range), \
.inst_on_bus = FXLS8974_BUS_I2C,
#define FXLS8974_CONFIG_SPI(n) \
.bus_cfg = { .spi = SPI_DT_SPEC_INST_GET(n, \
SPI_OP_MODE_MASTER | SPI_WORD_SET(8), 0) }, \
.ops = &fxls8974_spi_ops, \
.range = DT_INST_PROP(n, range), \
.inst_on_bus = FXLS8974_BUS_SPI, \
#define FXLS8974_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER) \
#define FXLS8974_INTM_PROPS(n, m) \
.int_gpio = GPIO_DT_SPEC_INST_GET(n, int##m##_gpios),
#define FXLS8974_INT_PROPS(n) \
COND_CODE_1(CONFIG_FXLS8974_DRDY_INT1, \
(FXLS8974_INTM_PROPS(n, 1)), \
(FXLS8974_INTM_PROPS(n, 2)))
#define FXLS8974_INT(n) \
COND_CODE_1(CONFIG_FXLS8974_TRIGGER, \
(FXLS8974_INT_PROPS(n)), \
())
#define FXLS8974_INIT(n) \
static const struct fxls8974_config fxls8974_config_##n = { \
COND_CODE_1(DT_INST_ON_BUS(n, spi), \
(FXLS8974_CONFIG_SPI(n)), \
(FXLS8974_CONFIG_I2C(n))) \
FXLS8974_INT(n) \
}; \
\
static struct fxls8974_data fxls8974_data_##n; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, \
fxls8974_init, \
NULL, \
&fxls8974_data_##n, \
&fxls8974_config_##n, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&fxls8974_driver_api);
DT_INST_FOREACH_STATUS_OKAY(FXLS8974_INIT)
``` | /content/code_sandbox/drivers/sensor/nxp/fxls8974/fxls8974.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,396 |
```objective-c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#define FXLS8974_BUS_I2C (1<<0)
#define FXLS8974_BUS_SPI (1<<1)
#define FXLS8974_REG_OUTXLSB 0x04
#define FXLS8974_REG_OUTTEMP 0x01
#define FXLS8974_REG_WHOAMI 0x13
#define FXLS8974_REG_CTRLREG1 0x15
#define FXLS8974_REG_CTRLREG2 0x16
#define FXLS8974_REG_CTRLREG3 0x17
#define FXLS8974_REG_CTRLREG4 0x18
#define FXLS8974_REG_CTRLREG5 0x19
#define WHOAMI_ID_FXLS8974 0x86
#define FXLS8974_CTRLREG1_ACTIVE_MASK 0x01
#define FXLS8974_CTRLREG1_RST_MASK 0x80
#define FXLS8974_CTRLREG1_FSR_MASK 0x06
#define FXLS8974_CTRLREG1_FSR_2G 0x00
#define FXLS8974_CTRLREG1_FSR_4G 0x02
#define FXLS8974_CTRLREG1_FSR_8G 0x04
#define FXLS8974_CTRLREG1_FSR_16G 0x06
#define FXLS8974_CTRLREG2_WAKE_PM_MASK 0xC0
#define FXLS8974_CTRLREG2_SLEEP_PM_MASK 0x30
#define FXLS8974_CTRLREG3_WAKE_ODR_MASK 0xF0
#define FXLS8974_CTRLREG3_SLEEP_ODR_MASK 0x0F
#define FXLS8974_CTRLREG3_ODR_RATE_3200 0x00
#define FXLS8974_CTRLREG3_ODR_RATE_1600 0x01
#define FXLS8974_CTRLREG3_ODR_RATE_800 0x02
#define FXLS8974_CTRLREG3_ODR_RATE_400 0x03
#define FXLS8974_CTRLREG3_ODR_RATE_200 0x04
#define FXLS8974_CTRLREG3_ODR_RATE_100 0x05
#define FXLS8974_CTRLREG3_ODR_RATE_50 0x06
#define FXLS8974_CTRLREG3_ODR_RATE_25 0x07
#define FXLS8974_CTRLREG3_ODR_RATE_12_5 0x08
#define FXLS8974_CTRLREG3_ODR_RATE_6_25 0x09
#define FXLS8974_CTRLREG3_ODR_RATE_3_125 0x0A
#define FXLS8974_CTRLREG3_ODR_RATE_1_563 0x0B
#define FXLS8974_CTRLREG3_ODR_RATE_0_781 0x0C
#define FXLS8974_CTRLREG4_INT_POL_HIGH 0x01
#define FXLS8974_INTREG_EN 0x20
#define FXLS8974_INT_PIN_SEL_REG 0x21
#define FXLS8974_DATA_ACCEL_X_OFFSET 0
#define FXLS8974_DATA_ACCEL_Y_OFFSET FXLS8974_BYTES_PER_CHANNEL_NORMAL
#define FXLS8974_DATA_ACCEL_Z_OFFSET 2*FXLS8974_BYTES_PER_CHANNEL_NORMAL
#define FXLS8974_DATA_TEMP_OFFSET 3*FXLS8974_BYTES_PER_CHANNEL_NORMAL
#define FXLS8974_ZERO_TEMP 25
#define FXLS8974_MAX_NUM_CHANNELS 4
#define FXLS8974_MAX_ACCEL_CHANNELS 3
#define FXLS8974_MAX_TEMP_CHANNELS 1
#define FXLS8974_BYTES_PER_CHANNEL_NORMAL 2
#define FXLS8974_BYTES_PER_CHANNEL_FAST 1
#define FXLS8974_MAX_ACCEL_BYTES (FXLS8974_MAX_ACCEL_CHANNELS*2)
#define FXLS8974_MAX_NUM_BYTES (FXLS8974_MAX_ACCEL_BYTES + FXLS8974_MAX_TEMP_CHANNELS)
#define FXLS8974_DRDY_MASK 0x80
enum fxls8974_active {
FXLS8974_ACTIVE_OFF = 0,
FXLS8974_ACTIVE_ON,
};
enum fxls8974_wake {
FXLS8974_WAKE = 0,
FXLS8974_SLEEP,
};
enum fxls8974_channel {
FXLS8974_CHANNEL_ACCEL_X = 0,
FXLS8974_CHANNEL_ACCEL_Y,
FXLS8974_CHANNEL_ACCEL_Z,
FXLS8974_CHANNEL_TEMP,
};
struct fxls8974_io_ops {
int (*read)(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
int (*byte_read)(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int (*byte_write)(const struct device *dev,
uint8_t reg,
uint8_t byte);
int (*reg_field_update)(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
};
union fxls8974_bus_cfg {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
};
struct fxls8974_config {
const union fxls8974_bus_cfg bus_cfg;
const struct fxls8974_io_ops *ops;
struct gpio_dt_spec reset_gpio;
uint8_t range;
uint8_t inst_on_bus;
#ifdef CONFIG_FXLS8974_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
struct fxls8974_data {
struct k_sem sem;
int16_t raw[FXLS8974_MAX_NUM_CHANNELS];
uint8_t whoami;
#ifdef CONFIG_FXLS8974_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trig;
#endif
#ifdef CONFIG_FXLS8974_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_FXLS8974_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#endif
#ifdef CONFIG_FXLS8974_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
};
int fxls8974_get_active(const struct device *dev, enum fxls8974_active *active);
int fxls8974_set_active(const struct device *dev, enum fxls8974_active active);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
int fxls8974_byte_write_spi(const struct device *dev,
uint8_t reg,
uint8_t byte);
int fxls8974_byte_read_spi(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int fxls8974_reg_field_update_spi(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
int fxls8974_read_spi(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
int fxls8974_byte_write_i2c(const struct device *dev,
uint8_t reg,
uint8_t byte);
int fxls8974_byte_read_i2c(const struct device *dev,
uint8_t reg,
uint8_t *byte);
int fxls8974_reg_field_update_i2c(const struct device *dev,
uint8_t reg,
uint8_t mask,
uint8_t val);
int fxls8974_read_i2c(const struct device *dev,
uint8_t reg,
void *data,
size_t length);
#endif
#if CONFIG_FXLS8974_TRIGGER
int fxls8974_trigger_init(const struct device *dev);
int fxls8974_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif
``` | /content/code_sandbox/drivers/sensor/nxp/fxls8974/fxls8974.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,806 |
```unknown
# FXLS8974 3-axis accelerometer
menuconfig FXLS8974
bool "FXLS8974 accelerometer driver"
default y
depends on DT_HAS_NXP_FXLS8974_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_NXP_FXLS8974),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_NXP_FXLS8974),spi)
help
Enable driver for the FXLS8974 accelerometer
if FXLS8974
choice
prompt "Trigger mode"
default FXLS8974_TRIGGER_NONE
config FXLS8974_TRIGGER_NONE
bool "No trigger"
config FXLS8974_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
select FXLS8974_TRIGGER
config FXLS8974_TRIGGER_OWN_THREAD
bool "Use own thread"
select FXLS8974_TRIGGER
endchoice
config FXLS8974_TRIGGER
bool
config FXLS8974_DRDY_INT1
bool "Data ready interrupt to INT1 pin"
depends on FXLS8974_TRIGGER
help
Say Y to route data ready interrupt to INT1 pin. Say N to route to
INT2 pin.
if FXLS8974_TRIGGER
config FXLS8974_THREAD_PRIORITY
int "Own thread priority"
depends on FXLS8974_TRIGGER_OWN_THREAD
default 10
config FXLS8974_THREAD_STACK_SIZE
int "Own thread stack size"
depends on FXLS8974_TRIGGER_OWN_THREAD
default 1024
endif # FXLS8974_TRIGGER
endif # FXLS8974
``` | /content/code_sandbox/drivers/sensor/nxp/fxls8974/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 337 |
```unknown
config QDEC_NXP_S32
bool "NXP Quad Decoder S32 drivers"
default y
depends on DT_HAS_NXP_QDEC_S32_ENABLED
select NXP_S32_EMIOS
help
Enable drivers for NXP S32 QUADRATURE DECODER
``` | /content/code_sandbox/drivers/sensor/nxp/qdec_nxp_s32/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 62 |
```c
/*
*/
#define DT_DRV_COMPAT nxp_mcux_qdec
#include <errno.h>
#include <stdint.h>
#include <fsl_enc.h>
#include <fsl_xbara.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/qdec_mcux.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(qdec_mcux, CONFIG_SENSOR_LOG_LEVEL);
struct qdec_mcux_config {
ENC_Type *base;
const struct pinctrl_dev_config *pincfg;
XBARA_Type *xbar;
size_t xbar_maps_len;
int xbar_maps[];
};
struct qdec_mcux_data {
enc_config_t qdec_config;
int32_t position;
uint16_t counts_per_revolution;
};
static enc_decoder_work_mode_t int_to_work_mode(int32_t val)
{
return val == 0 ? kENC_DecoderWorkAsNormalMode :
kENC_DecoderWorkAsSignalPhaseCountMode;
}
static int qdec_mcux_attr_set(const struct device *dev, enum sensor_channel ch,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct qdec_mcux_config *config = dev->config;
struct qdec_mcux_data *data = dev->data;
if (ch != SENSOR_CHAN_ROTATION) {
return -ENOTSUP;
}
switch ((enum sensor_attribute_qdec_mcux) attr) {
case SENSOR_ATTR_QDEC_MOD_VAL:
if (!IN_RANGE(val->val1, 1, UINT16_MAX)) {
LOG_ERR("SENSOR_ATTR_QDEC_MOD_VAL value invalid");
return -EINVAL;
}
data->counts_per_revolution = val->val1;
return 0;
case SENSOR_ATTR_QDEC_ENABLE_SINGLE_PHASE:
data->qdec_config.decoderWorkMode =
int_to_work_mode(val->val1);
WRITE_BIT(config->base->CTRL, ENC_CTRL_PH1_SHIFT, val->val1);
return 0;
default:
return -ENOTSUP;
}
}
static int qdec_mcux_attr_get(const struct device *dev, enum sensor_channel ch,
enum sensor_attribute attr, struct sensor_value *val)
{
struct qdec_mcux_data *data = dev->data;
if (ch != SENSOR_CHAN_ROTATION) {
return -ENOTSUP;
}
switch ((enum sensor_attribute_qdec_mcux) attr) {
case SENSOR_ATTR_QDEC_MOD_VAL:
val->val1 = data->counts_per_revolution;
return 0;
case SENSOR_ATTR_QDEC_ENABLE_SINGLE_PHASE:
val->val1 = data->qdec_config.decoderWorkMode ==
kENC_DecoderWorkAsNormalMode ? 0 : 1;
return 0;
default:
return -ENOTSUP;
}
}
static int qdec_mcux_fetch(const struct device *dev, enum sensor_channel ch)
{
const struct qdec_mcux_config *config = dev->config;
struct qdec_mcux_data *data = dev->data;
if (ch != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
/* Read position */
data->position = ENC_GetPositionValue(config->base);
LOG_DBG("pos %d", data->position);
return 0;
}
static int qdec_mcux_ch_get(const struct device *dev, enum sensor_channel ch,
struct sensor_value *val)
{
struct qdec_mcux_data *data = dev->data;
switch (ch) {
case SENSOR_CHAN_ROTATION:
sensor_value_from_float(val, (data->position * 360.0f)
/ data->counts_per_revolution);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api qdec_mcux_api = {
.attr_set = &qdec_mcux_attr_set,
.attr_get = &qdec_mcux_attr_get,
.sample_fetch = &qdec_mcux_fetch,
.channel_get = &qdec_mcux_ch_get,
};
static void init_inputs(const struct device *dev)
{
int i;
const struct qdec_mcux_config *config = dev->config;
i = pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT);
assert(i == 0);
/* Quadrature Encoder inputs are only accessible via crossbar */
XBARA_Init(config->xbar);
for (i = 0; i < config->xbar_maps_len; i += 2) {
XBARA_SetSignalsConnection(config->xbar, config->xbar_maps[i],
config->xbar_maps[i + 1]);
}
}
#define XBAR_PHANDLE(n) DT_INST_PHANDLE(n, xbar)
#define QDEC_CHECK_COND(n, p, min, max) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(n, p), ( \
BUILD_ASSERT(IN_RANGE(DT_INST_PROP(n, p), min, max), \
STRINGIFY(p) " value is out of range")), ())
#define QDEC_SET_COND(n, v, p) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(n, p), (v = DT_INST_PROP(n, p)), ())
#define QDEC_MCUX_INIT(n) \
\
BUILD_ASSERT((DT_PROP_LEN(XBAR_PHANDLE(n), xbar_maps) % 2) == 0, \
"xbar_maps length must be an even number"); \
QDEC_CHECK_COND(n, counts_per_revolution, 1, UINT16_MAX); \
QDEC_CHECK_COND(n, filter_sample_period, 0, UINT8_MAX); \
\
static struct qdec_mcux_data qdec_mcux_##n##_data = { \
.counts_per_revolution = DT_INST_PROP(n, counts_per_revolution) \
}; \
\
PINCTRL_DT_INST_DEFINE(n); \
\
static const struct qdec_mcux_config qdec_mcux_##n##_config = { \
.base = (ENC_Type *)DT_INST_REG_ADDR(n), \
.xbar = (XBARA_Type *)DT_REG_ADDR(XBAR_PHANDLE(n)), \
.xbar_maps_len = DT_PROP_LEN(XBAR_PHANDLE(n), xbar_maps), \
.xbar_maps = DT_PROP(XBAR_PHANDLE(n), xbar_maps), \
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \
}; \
\
static int qdec_mcux_##n##_init(const struct device *dev) \
{ \
const struct qdec_mcux_config *config = dev->config; \
struct qdec_mcux_data *data = dev->data; \
\
LOG_DBG("Initializing %s", dev->name); \
\
init_inputs(dev); \
\
ENC_GetDefaultConfig(&data->qdec_config); \
data->qdec_config.decoderWorkMode = int_to_work_mode( \
DT_INST_PROP(n, single_phase_mode)); \
QDEC_SET_COND(n, data->qdec_config.filterCount, filter_count); \
QDEC_SET_COND(n, data->qdec_config.filterSamplePeriod, \
filter_sample_period); \
LOG_DBG("Latency is %u filter clock cycles + 2 IPBus clock " \
"periods", data->qdec_config.filterSamplePeriod * \
(data->qdec_config.filterCount + 3)); \
ENC_Init(config->base, &data->qdec_config); \
\
/* Update the position counter with initial value. */ \
ENC_DoSoftwareLoadInitialPositionValue(config->base); \
\
return 0; \
} \
\
\
SENSOR_DEVICE_DT_INST_DEFINE(n, qdec_mcux_##n##_init, NULL, \
&qdec_mcux_##n##_data, &qdec_mcux_##n##_config, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&qdec_mcux_api); \
\
DT_INST_FOREACH_STATUS_OKAY(QDEC_MCUX_INIT)
``` | /content/code_sandbox/drivers/sensor/nxp/qdec_mcux/qdec_mcux.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,808 |
```unknown
config QDEC_MCUX
bool "NXP QDEC MCUX driver"
default y
depends on DT_HAS_NXP_MCUX_QDEC_ENABLED
select MCUX_XBARA
select PINCTRL
help
Enable support for NXP MCUX Quadrature Encoder driver.
``` | /content/code_sandbox/drivers/sensor/nxp/qdec_mcux/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 60 |
```c
/*
*
*/
#include <errno.h>
#include <stdint.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/arch/arch_interface.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#define EMIOS_CHANNEL_COUNT 2U
#define EMIOS_CW_CH_IDX 0
#define EMIOS_CCW_CH_IDX 1
/* LCU LUT control values for each of the 4 LC outputs */
/* These values decide the direction of motor rotation */
#define LCU_O0_LUT 0xAAAA
#define LCU_O1_LUT 0xCCCC
#define LCU_O2_LUT 0x4182
#define LCU_O3_LUT 0x2814
LOG_MODULE_REGISTER(nxp_qdec_s32, CONFIG_SENSOR_LOG_LEVEL);
#include <Emios_Icu_Ip.h>
#include <Trgmux_Ip.h>
#include <Lcu_Ip.h>
#define DT_DRV_COMPAT nxp_qdec_s32
typedef void (*emios_callback_t)(void);
/* Configuration variables from eMIOS Icu driver */
extern eMios_Icu_Ip_ChStateType eMios_Icu_Ip_ChState[EMIOS_ICU_IP_NUM_OF_CHANNELS_USED];
extern uint8 eMios_Icu_Ip_IndexInChState[EMIOS_ICU_IP_INSTANCE_COUNT][EMIOS_ICU_IP_NUM_OF_CHANNELS];
struct qdec_s32_config {
uint8_t emios_inst;
uint8_t emios_channels[EMIOS_CHANNEL_COUNT];
const struct pinctrl_dev_config *pincfg;
const Trgmux_Ip_InitType *trgmux_config;
const Lcu_Ip_InitType *lcu_config;
emios_callback_t emios_cw_overflow_cb;
emios_callback_t emios_ccw_overflow_cb;
};
struct qdec_s32_data {
uint32_t counter_CW;
uint32_t counter_CCW;
int32_t abs_counter;
double micro_ticks_per_rev;
uint32_t ticks_per_sec;
uint32_t emios_cw_overflow_count;
uint32_t emios_ccw_overflow_count;
};
static void qdec_emios_overflow_count_cw_callback(const struct device *dev)
{
struct qdec_s32_data *data = dev->data;
data->emios_cw_overflow_count++;
}
static void qdec_emios_overflow_count_ccw_callback(const struct device *dev)
{
struct qdec_s32_data *data = dev->data;
data->emios_ccw_overflow_count++;
}
static int qdec_s32_fetch(const struct device *dev, enum sensor_channel ch)
{
const struct qdec_s32_config *config = dev->config;
struct qdec_s32_data *data = dev->data;
if (ch != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
data->counter_CW = (uint32_t)(Emios_Icu_Ip_GetEdgeNumbers(
config->emios_inst, config->emios_channels[EMIOS_CW_CH_IDX])); /* CW counter */
data->counter_CCW = (uint32_t)(Emios_Icu_Ip_GetEdgeNumbers(
config->emios_inst, config->emios_channels[EMIOS_CCW_CH_IDX]));/* CCW counter*/
data->abs_counter = (int32_t)(
+(data->counter_CW + EMIOS_ICU_IP_COUNTER_MASK *
data->emios_cw_overflow_count)
-(data->counter_CCW + EMIOS_ICU_IP_COUNTER_MASK *
data->emios_ccw_overflow_count));
LOG_DBG("ABS_COUNT = %d CW = %u OverFlow_CW = %u CCW = %u Overflow_CCW = %u",
data->abs_counter, data->counter_CW,
data->emios_cw_overflow_count,
data->counter_CCW, data->emios_ccw_overflow_count);
return 0;
}
static int qdec_s32_ch_get(const struct device *dev, enum sensor_channel ch,
struct sensor_value *val)
{
struct qdec_s32_data *data = dev->data;
double rotation = (data->abs_counter * 2.0 * M_PI) / data->micro_ticks_per_rev;
switch (ch) {
case SENSOR_CHAN_ROTATION:
sensor_value_from_double(val, rotation);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api qdec_s32_api = {
.sample_fetch = &qdec_s32_fetch,
.channel_get = &qdec_s32_ch_get,
};
static int qdec_s32_initialize(const struct device *dev)
{
const struct qdec_s32_config *config = dev->config;
uint8_t emios_inst, emios_hw_ch_cw, emios_hw_ch_ccw;
pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT);
if (Trgmux_Ip_Init(config->trgmux_config)) {
LOG_ERR("Could not initialize Trgmux");
return -EINVAL;
}
LOG_DBG("TRGMUX ACCESS Input[0] =%d Output[0]=%d",
config->trgmux_config->paxLogicTrigger[0]->Input,
config->trgmux_config->paxLogicTrigger[0]->Output);
if (Lcu_Ip_Init(config->lcu_config)) {
LOG_ERR("Could not initialize Lcu");
return -EINVAL;
}
/* Unmask relevant LCU OUT Channels */
Lcu_Ip_SyncOutputValueType EncLcuEnable[4U];
EncLcuEnable[0].LogicOutputId = LCU_LOGIC_OUTPUT_0;
EncLcuEnable[0].Value = 1U;
EncLcuEnable[1].LogicOutputId = LCU_LOGIC_OUTPUT_1;
EncLcuEnable[1].Value = 1U;
EncLcuEnable[2].LogicOutputId = LCU_LOGIC_OUTPUT_2;
EncLcuEnable[2].Value = 1U;
EncLcuEnable[3].LogicOutputId = LCU_LOGIC_OUTPUT_3;
EncLcuEnable[3].Value = 1U;
Lcu_Ip_SetSyncOutputEnable(EncLcuEnable, 4U);
emios_inst = config->emios_inst;
emios_hw_ch_cw = config->emios_channels[EMIOS_CW_CH_IDX];
emios_hw_ch_ccw = config->emios_channels[EMIOS_CCW_CH_IDX];
/* Initialize the positions of the eMios hw channels used for QDEC
* to be beyond the eMios pwm hw channels. Currently only pwm and qdec
* are using the eMios channels so qdec ones are the last two.
*/
eMios_Icu_Ip_IndexInChState[emios_inst][emios_hw_ch_cw]
= EMIOS_ICU_IP_NUM_OF_CHANNELS_USED - 2;
eMios_Icu_Ip_IndexInChState[emios_inst][emios_hw_ch_ccw]
= EMIOS_ICU_IP_NUM_OF_CHANNELS_USED - 1;
/* Set Overflow Notification for eMIOS channels meant
* for Clockwise and Counterclock rotation counters
*/
eMios_Icu_Ip_ChState[eMios_Icu_Ip_IndexInChState[emios_inst][emios_hw_ch_cw]]
.eMiosOverflowNotification = config->emios_cw_overflow_cb;
eMios_Icu_Ip_ChState[eMios_Icu_Ip_IndexInChState[emios_inst][emios_hw_ch_ccw]]
.eMiosOverflowNotification = config->emios_ccw_overflow_cb;
Emios_Icu_Ip_SetInitialCounterValue(
config->emios_inst, config->emios_channels[EMIOS_CW_CH_IDX], (uint32_t)0x1U);
Emios_Icu_Ip_SetInitialCounterValue(
config->emios_inst, config->emios_channels[EMIOS_CCW_CH_IDX], (uint32_t)0x1U);
Emios_Icu_Ip_SetMaxCounterValue(config->emios_inst,
config->emios_channels[EMIOS_CW_CH_IDX],
EMIOS_ICU_IP_COUNTER_MASK);
Emios_Icu_Ip_SetMaxCounterValue(config->emios_inst,
config->emios_channels[EMIOS_CCW_CH_IDX],
EMIOS_ICU_IP_COUNTER_MASK);
/* This API sets MCB/EMIOS_ICU_MODE_EDGE_COUNTER mode */
Emios_Icu_Ip_EnableEdgeCount(config->emios_inst, config->emios_channels[EMIOS_CW_CH_IDX]);
Emios_Icu_Ip_EnableEdgeCount(config->emios_inst, config->emios_channels[EMIOS_CCW_CH_IDX]);
LOG_DBG("Init complete");
return 0;
}
#define EMIOS_NXP_S32_MCB_OVERFLOW_CALLBACK(n) \
static void qdec##n##_emios_overflow_count_cw_callback(void) \
{ \
qdec_emios_overflow_count_cw_callback(DEVICE_DT_INST_GET(n)); \
} \
\
static void qdec##n##_emios_overflow_count_ccw_callback(void) \
{ \
qdec_emios_overflow_count_ccw_callback(DEVICE_DT_INST_GET(n)); \
}
#define EMIOS_NXP_S32_INSTANCE_CHECK(idx, node_id) \
((DT_REG_ADDR(node_id) == IP_EMIOS_##idx##_BASE) ? idx : 0)
#define EMIOS_NXP_S32_GET_INSTANCE(node_id) \
LISTIFY(__DEBRACKET eMIOS_INSTANCE_COUNT, EMIOS_NXP_S32_INSTANCE_CHECK, (|), node_id)
#define LCU_NXP_S32_INSTANCE_CHECK(idx, node_id) \
((DT_REG_ADDR(node_id) == IP_LCU_##idx##_BASE) ? idx : 0)
#define LCU_NXP_S32_GET_INSTANCE(node_id) \
LISTIFY(__DEBRACKET LCU_INSTANCE_COUNT, LCU_NXP_S32_INSTANCE_CHECK, (|), node_id)
#define TRGMUX_NXP_S32_INSTANCE_CHECK(node_id) \
((DT_REG_ADDR(node_id) == IP_TRGMUX_BASE) ? 0 : -1)
#define TRGMUX_NXP_S32_GET_INSTANCE(node_id) TRGMUX_NXP_S32_INSTANCE_CHECK(node_id)
/* LCU Logic Input Configuration */
#define LogicInputCfg_Common(n, mux_sel_idx) \
{ \
.MuxSel = DT_INST_PROP_BY_IDX(n, lcu_mux_sel, mux_sel_idx), \
.SwSynMode = LCU_IP_SW_SYNC_IMMEDIATE, \
.SwValue = LCU_IP_SW_OVERRIDE_LOGIC_LOW, \
};
#define LogicInput_Config_Common(n, hw_lc_input_id, logic_input_n_cfg) \
{ \
.xLogicInputId = { \
.HwInstId = LCU_NXP_S32_GET_INSTANCE(DT_INST_PHANDLE(n, lcu)), \
.HwLcInputId = DT_INST_PROP_BY_IDX(n, lcu_input_idx, hw_lc_input_id), \
}, \
.pxLcInputConfig = &logic_input_n_cfg, \
};
/* LCU Logic Output Configuration */
#define LogicOutputCfg_Common(En_Debug_Mode, Lut_Control, Lut_Rise_Filt, Lut_Fall_Filt) \
{ \
.EnDebugMode = (boolean)En_Debug_Mode, \
.LutControl = Lut_Control, \
.LutRiseFilt = Lut_Rise_Filt, \
.LutFallFilt = Lut_Fall_Filt, \
.EnLutDma = (boolean)FALSE, \
.EnForceDma = (boolean)FALSE, \
.EnLutInt = (boolean)FALSE, \
.EnForceInt = (boolean)FALSE, \
.InvertOutput = (boolean)FALSE, \
.ForceSignalSel = 0U, \
.ClearForceMode = LCU_IP_CLEAR_FORCE_SIGNAL_IMMEDIATE, \
.ForceSyncSel = LCU_IP_SYNC_SEL_INPUT0, \
};
#define LogicOutput_Config_Common(n, logic_output_cfg, hw_lc_output_id) \
{ \
.xLogicOutputId = { \
.HwInstId = LCU_NXP_S32_GET_INSTANCE(DT_INST_PHANDLE(n, lcu)), \
.HwLcOutputId = hw_lc_output_id, \
.IntCallback = NULL_PTR, \
}, \
.pxLcOutputConfig = &logic_output_cfg, \
};
#define LCU_IP_INIT_CONFIG(n) \
const Lcu_Ip_LogicInputConfigType LogicInput##n##_0_Cfg = \
LogicInputCfg_Common(n, 0) \
const Lcu_Ip_LogicInputConfigType LogicInput##n##_1_Cfg = \
LogicInputCfg_Common(n, 1) \
const Lcu_Ip_LogicInputConfigType LogicInput##n##_2_Cfg = \
LogicInputCfg_Common(n, 2) \
const Lcu_Ip_LogicInputConfigType LogicInput##n##_3_Cfg = \
LogicInputCfg_Common(n, 3) \
\
const Lcu_Ip_LogicInputType LogicInput##n##_0_Config = \
LogicInput_Config_Common(n, 0, LogicInput##n##_0_Cfg) \
const Lcu_Ip_LogicInputType LogicInput##n##_1_Config = \
LogicInput_Config_Common(n, 1, LogicInput##n##_1_Cfg) \
const Lcu_Ip_LogicInputType LogicInput##n##_2_Config = \
LogicInput_Config_Common(n, 2, LogicInput##n##_2_Cfg) \
const Lcu_Ip_LogicInputType LogicInput##n##_3_Config = \
LogicInput_Config_Common(n, 3, LogicInput##n##_3_Cfg) \
\
const Lcu_Ip_LogicInputType \
*const Lcu_Ip_ppxLogicInputArray##n##_Config[LCU_IP_NOF_CFG_LOGIC_INPUTS] = { \
&LogicInput##n##_0_Config, \
&LogicInput##n##_1_Config, \
&LogicInput##n##_2_Config, \
&LogicInput##n##_3_Config, \
}; \
\
const Lcu_Ip_LogicOutputConfigType LogicOutput##n##_0_Cfg = LogicOutputCfg_Common( \
LCU_IP_DEBUG_DISABLE, LCU_O0_LUT, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 1), \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 2)) \
const Lcu_Ip_LogicOutputConfigType LogicOutput##n##_1_Cfg = LogicOutputCfg_Common( \
LCU_IP_DEBUG_DISABLE, LCU_O1_LUT, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 4), \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 5)) \
const Lcu_Ip_LogicOutputConfigType LogicOutput##n##_2_Cfg = LogicOutputCfg_Common( \
LCU_IP_DEBUG_ENABLE, LCU_O2_LUT, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 7), \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 8)) \
const Lcu_Ip_LogicOutputConfigType LogicOutput##n##_3_Cfg = LogicOutputCfg_Common( \
LCU_IP_DEBUG_ENABLE, LCU_O3_LUT, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 10), \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 11)) \
\
const Lcu_Ip_LogicOutputType LogicOutput##n##_0_Config = \
LogicOutput_Config_Common(n, LogicOutput##n##_0_Cfg, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 0)) \
const Lcu_Ip_LogicOutputType LogicOutput##n##_1_Config = \
LogicOutput_Config_Common(n, LogicOutput##n##_1_Cfg, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 3)) \
const Lcu_Ip_LogicOutputType LogicOutput##n##_2_Config = \
LogicOutput_Config_Common(n, LogicOutput##n##_2_Cfg, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 6)) \
const Lcu_Ip_LogicOutputType LogicOutput##n##_3_Config = \
LogicOutput_Config_Common(n, LogicOutput##n##_3_Cfg, \
DT_INST_PROP_BY_IDX(n, lcu_output_filter_config, 9)) \
\
const Lcu_Ip_LogicOutputType \
*const Lcu_Ip_ppxLogicOutputArray##n##_Config[LCU_IP_NOF_CFG_LOGIC_OUTPUTS] = { \
&LogicOutput##n##_0_Config, \
&LogicOutput##n##_1_Config, \
&LogicOutput##n##_2_Config, \
&LogicOutput##n##_3_Config, \
}; \
\
const Lcu_Ip_LogicInputConfigType Lcu_Ip_LogicInputResetConfig##n = { \
.MuxSel = LCU_IP_MUX_SEL_LOGIC_0, \
.SwSynMode = LCU_IP_SW_SYNC_IMMEDIATE, \
.SwValue = LCU_IP_SW_OVERRIDE_LOGIC_LOW, \
}; \
\
const Lcu_Ip_LogicOutputConfigType Lcu_Ip_LogicOutputResetConfig##n = \
LogicOutputCfg_Common(LCU_IP_DEBUG_DISABLE, 0U, 0U, 0U) \
\
const Lcu_Ip_LogicInstanceType LcuLogicInstance##n##_0_Config = { \
.HwInstId = LCU_NXP_S32_GET_INSTANCE(DT_INST_PHANDLE(n, lcu)), \
.NumLogicCellConfig = 0U, \
.ppxLogicCellConfigArray = NULL_PTR, \
.OperationMode = LCU_IP_INTERRUPT_MODE, \
}; \
const Lcu_Ip_LogicInstanceType \
*const Lcu_Ip_ppxLogicInstanceArray##n##_Config[LCU_IP_NOF_CFG_LOGIC_INSTANCES] = { \
&LcuLogicInstance##n##_0_Config, \
}; \
\
Lcu_Ip_HwOutputStateType HwOutput##n##_0_State_Config; \
Lcu_Ip_HwOutputStateType HwOutput##n##_1_State_Config; \
Lcu_Ip_HwOutputStateType HwOutput##n##_2_State_Config; \
Lcu_Ip_HwOutputStateType HwOutput##n##_3_State_Config; \
Lcu_Ip_HwOutputStateType \
*Lcu_Ip_ppxHwOutputStateArray##n##_Config[LCU_IP_NOF_CFG_LOGIC_OUTPUTS] = { \
&HwOutput##n##_0_State_Config, \
&HwOutput##n##_1_State_Config, \
&HwOutput##n##_2_State_Config, \
&HwOutput##n##_3_State_Config, \
}; \
\
const Lcu_Ip_InitType Lcu_Ip_Init_Config##n = { \
.ppxHwOutputStateArray = &Lcu_Ip_ppxHwOutputStateArray##n##_Config[0], \
.ppxLogicInstanceConfigArray = &Lcu_Ip_ppxLogicInstanceArray##n##_Config[0], \
.pxLogicOutputResetConfigArray = &Lcu_Ip_LogicOutputResetConfig##n, \
.pxLogicInputResetConfigArray = &Lcu_Ip_LogicInputResetConfig##n, \
.ppxLogicOutputConfigArray = &Lcu_Ip_ppxLogicOutputArray##n##_Config[0], \
.ppxLogicInputConfigArray = &Lcu_Ip_ppxLogicInputArray##n##_Config[0], \
};
#define Trgmux_Ip_LogicTrigger_Config(n, logic_channel, output, input) \
{ \
.LogicChannel = logic_channel, \
.Output = output, \
.Input = input, \
.HwInstId = TRGMUX_NXP_S32_GET_INSTANCE(DT_INST_PHANDLE(n, trgmux)), \
.Lock = (boolean)FALSE, \
};
#define TRGMUX_IP_INIT_CONFIG(n) \
const Trgmux_Ip_LogicTriggerType \
Trgmux_Ip_LogicTrigger##n##_0_Config = Trgmux_Ip_LogicTrigger_Config(n, \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 0), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 1), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 2)) \
const Trgmux_Ip_LogicTriggerType \
Trgmux_Ip_LogicTrigger##n##_1_Config = Trgmux_Ip_LogicTrigger_Config(n, \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 3), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 4), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 5)) \
const Trgmux_Ip_LogicTriggerType \
Trgmux_Ip_LogicTrigger##n##_2_Config = Trgmux_Ip_LogicTrigger_Config(n, \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 6), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 7), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 8)) \
const Trgmux_Ip_LogicTriggerType \
Trgmux_Ip_LogicTrigger##n##_3_Config = Trgmux_Ip_LogicTrigger_Config(n, \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 9), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 10), \
DT_INST_PROP_BY_IDX(n, trgmux_io_config, 11)) \
const Trgmux_Ip_InitType Trgmux_Ip_Init_##n##_Config = { \
.paxLogicTrigger = { \
&Trgmux_Ip_LogicTrigger##n##_0_Config, \
&Trgmux_Ip_LogicTrigger##n##_1_Config, \
&Trgmux_Ip_LogicTrigger##n##_2_Config, \
&Trgmux_Ip_LogicTrigger##n##_3_Config, \
}, \
};
#define QDEC_NXP_S32_INIT(n) \
\
static struct qdec_s32_data qdec_s32_##n##_data = { \
.micro_ticks_per_rev = (double)(DT_INST_PROP(n, micro_ticks_per_rev) / 1000000),\
.counter_CW = 1, \
.counter_CCW = 1, \
}; \
\
PINCTRL_DT_INST_DEFINE(n); \
TRGMUX_IP_INIT_CONFIG(n) \
LCU_IP_INIT_CONFIG(n) \
EMIOS_NXP_S32_MCB_OVERFLOW_CALLBACK(n) \
\
static const struct qdec_s32_config qdec_s32_##n##_config = { \
.emios_inst = EMIOS_NXP_S32_GET_INSTANCE(DT_INST_PHANDLE(n, emios)), \
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \
.trgmux_config = &Trgmux_Ip_Init_##n##_Config, \
.lcu_config = &Lcu_Ip_Init_Config##n, \
.emios_channels = {DT_INST_PROP_BY_IDX(n, emios_channels, EMIOS_CW_CH_IDX), \
DT_INST_PROP_BY_IDX(n, emios_channels, EMIOS_CCW_CH_IDX)}, \
.emios_cw_overflow_cb = &qdec##n##_emios_overflow_count_cw_callback, \
.emios_ccw_overflow_cb = &qdec##n##_emios_overflow_count_ccw_callback, \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, qdec_s32_initialize, NULL, &qdec_s32_##n##_data, \
&qdec_s32_##n##_config, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &qdec_s32_api);
DT_INST_FOREACH_STATUS_OKAY(QDEC_NXP_S32_INIT)
``` | /content/code_sandbox/drivers/sensor/nxp/qdec_nxp_s32/qdec_nxp_s32.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,768 |
```c
/* sensor_isl29035.c - trigger support for ISL29035 light sensor */
/*
*
*/
#define DT_DRV_COMPAT isil_isl29035
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include "isl29035.h"
extern struct isl29035_driver_data isl29035_data;
LOG_MODULE_DECLARE(ISL29035, CONFIG_SENSOR_LOG_LEVEL);
static inline void setup_int(const struct device *dev, bool enable)
{
const struct isl29035_config *config = dev->config;
unsigned int flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
}
static inline void handle_int(const struct device *dev)
{
struct isl29035_driver_data *drv_data = dev->data;
setup_int(dev, false);
#if defined(CONFIG_ISL29035_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ISL29035_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static uint16_t isl29035_lux_processed_to_raw(struct sensor_value const *val)
{
uint64_t raw_val;
/* raw_val = val * (2 ^ adc_data_bits) / lux_range */
raw_val = (((uint64_t)val->val1) << ISL29035_ADC_DATA_BITS) +
(((uint64_t)val->val2) << ISL29035_ADC_DATA_BITS) / 1000000U;
return raw_val / ISL29035_LUX_RANGE;
}
int isl29035_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct isl29035_config *config = dev->config;
uint8_t lsb_reg, msb_reg;
uint16_t raw_val;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (attr == SENSOR_ATTR_UPPER_THRESH) {
lsb_reg = ISL29035_INT_HT_LSB_REG;
msb_reg = ISL29035_INT_HT_MSB_REG;
} else if (attr == SENSOR_ATTR_LOWER_THRESH) {
lsb_reg = ISL29035_INT_LT_LSB_REG;
msb_reg = ISL29035_INT_LT_MSB_REG;
} else {
return -ENOTSUP;
}
raw_val = isl29035_lux_processed_to_raw(val);
if (i2c_reg_write_byte_dt(&config->i2c,
lsb_reg, raw_val & 0xFF) < 0 ||
i2c_reg_write_byte_dt(&config->i2c,
msb_reg, raw_val >> 8) < 0) {
LOG_DBG("Failed to set attribute.");
return -EIO;
}
return 0;
}
static void isl29035_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct isl29035_driver_data *drv_data =
CONTAINER_OF(cb, struct isl29035_driver_data, gpio_cb);
ARG_UNUSED(pins);
handle_int(drv_data->dev);
}
static void isl29035_thread_cb(const struct device *dev)
{
struct isl29035_driver_data *drv_data = dev->data;
const struct isl29035_config *config = dev->config;
uint8_t val;
/* clear interrupt */
if (i2c_reg_read_byte_dt(&config->i2c,
ISL29035_COMMAND_I_REG, &val) < 0) {
LOG_ERR("isl29035: Error reading command register");
return;
}
if (drv_data->th_handler != NULL) {
drv_data->th_handler(dev, drv_data->th_trigger);
}
setup_int(dev, true);
}
#ifdef CONFIG_ISL29035_TRIGGER_OWN_THREAD
static void isl29035_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
const struct device *dev = p1;
struct isl29035_driver_data *drv_data = dev->data;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
isl29035_thread_cb(dev);
}
}
#endif
#ifdef CONFIG_ISL29035_TRIGGER_GLOBAL_THREAD
static void isl29035_work_cb(struct k_work *work)
{
struct isl29035_driver_data *drv_data =
CONTAINER_OF(work, struct isl29035_driver_data, work);
isl29035_thread_cb(drv_data->dev);
}
#endif
int isl29035_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct isl29035_driver_data *drv_data = dev->data;
const struct isl29035_config *config = dev->config;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
/* disable interrupt callback while changing parameters */
setup_int(dev, false);
drv_data->th_handler = handler;
drv_data->th_trigger = trig;
/* enable interrupt callback */
setup_int(dev, true);
if (gpio_pin_get_dt(&config->int_gpio) > 0) {
handle_int(dev);
}
return 0;
}
int isl29035_init_interrupt(const struct device *dev)
{
struct isl29035_driver_data *drv_data = dev->data;
const struct isl29035_config *config = dev->config;
/* set interrupt persistence */
if (i2c_reg_update_byte_dt(&config->i2c,
ISL29035_COMMAND_I_REG,
ISL29035_INT_PRST_MASK,
ISL29035_INT_PRST_BITS) < 0) {
LOG_DBG("Failed to set interrupt persistence cycles.");
return -EIO;
}
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb,
isl29035_gpio_callback,
BIT(config->int_gpio.pin));
if (gpio_add_callback(config->int_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set gpio callback.");
return -EIO;
}
drv_data->dev = dev;
#if defined(CONFIG_ISL29035_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_ISL29035_THREAD_STACK_SIZE,
isl29035_thread,
(void *)dev, NULL, NULL,
K_PRIO_COOP(CONFIG_ISL29035_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_ISL29035_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = isl29035_work_cb;
#endif
setup_int(dev, true);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/isl29035/isl29035_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,509 |
```c
/* sensor_isl29035.c - driver for ISL29035 light sensor */
/*
*
*/
#define DT_DRV_COMPAT isil_isl29035
#include <zephyr/kernel.h>
#include <zephyr/init.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "isl29035.h"
LOG_MODULE_REGISTER(ISL29035, CONFIG_SENSOR_LOG_LEVEL);
static int isl29035_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct isl29035_driver_data *drv_data = dev->data;
const struct isl29035_config *config = dev->config;
uint8_t msb, lsb;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (i2c_reg_read_byte_dt(&config->i2c,
ISL29035_DATA_MSB_REG, &msb) < 0) {
return -EIO;
}
if (i2c_reg_read_byte_dt(&config->i2c, ISL29035_DATA_LSB_REG,
&lsb) < 0) {
return -EIO;
}
drv_data->data_sample = (msb << 8) + lsb;
return 0;
}
static int isl29035_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct isl29035_driver_data *drv_data = dev->data;
uint64_t tmp;
#if CONFIG_ISL29035_MODE_ALS
/* val = sample_val * lux_range / (2 ^ adc_data_bits) */
tmp = (uint64_t)drv_data->data_sample * ISL29035_LUX_RANGE;
val->val1 = tmp >> ISL29035_ADC_DATA_BITS;
tmp = (tmp & ISL29035_ADC_DATA_MASK) * 1000000U;
val->val2 = tmp >> ISL29035_ADC_DATA_BITS;
#elif CONFIG_ISL29035_MODE_IR
ARG_UNUSED(tmp);
val->val1 = drv_data->data_sample;
val->val2 = 0;
#endif
return 0;
}
static const struct sensor_driver_api isl29035_api = {
#if CONFIG_ISL29035_TRIGGER
.attr_set = &isl29035_attr_set,
.trigger_set = &isl29035_trigger_set,
#endif
.sample_fetch = &isl29035_sample_fetch,
.channel_get = &isl29035_channel_get,
};
static int isl29035_init(const struct device *dev)
{
struct isl29035_driver_data *drv_data = dev->data;
const struct isl29035_config *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
drv_data->data_sample = 0U;
/* clear blownout status bit */
if (i2c_reg_update_byte_dt(&config->i2c, ISL29035_ID_REG,
ISL29035_BOUT_MASK, 0) < 0) {
LOG_DBG("Failed to clear blownout status bit.");
return -EIO;
}
/* set command registers to set default attributes */
if (i2c_reg_write_byte_dt(&config->i2c,
ISL29035_COMMAND_I_REG, 0) < 0) {
LOG_DBG("Failed to clear COMMAND-I.");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
ISL29035_COMMAND_II_REG, 0) < 0) {
LOG_DBG("Failed to clear COMMAND-II.");
return -EIO;
}
/* set operation mode */
if (i2c_reg_update_byte_dt(&config->i2c,
ISL29035_COMMAND_I_REG,
ISL29035_OPMODE_MASK,
ISL29035_ACTIVE_OPMODE_BITS) < 0) {
LOG_DBG("Failed to set opmode.");
return -EIO;
}
/* set lux range */
if (i2c_reg_update_byte_dt(&config->i2c,
ISL29035_COMMAND_II_REG,
ISL29035_LUX_RANGE_MASK,
ISL29035_LUX_RANGE_BITS) < 0) {
LOG_DBG("Failed to set lux range.");
return -EIO;
}
/* set ADC resolution */
if (i2c_reg_update_byte_dt(&config->i2c,
ISL29035_COMMAND_II_REG,
ISL29035_ADC_RES_MASK,
ISL29035_ADC_RES_BITS) < 0) {
LOG_DBG("Failed to set ADC resolution.");
return -EIO;
}
#ifdef CONFIG_ISL29035_TRIGGER
if (config->int_gpio.port) {
if (isl29035_init_interrupt(dev) < 0) {
LOG_DBG("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
return 0;
}
#define ISL29035_DEFINE(inst) \
static struct isl29035_driver_data isl29035_data_##inst; \
\
static const struct isl29035_config isl29035_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_ISL29035_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, &isl29035_init, NULL, \
&isl29035_data_##inst, &isl29035_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &isl29035_api); \
DT_INST_FOREACH_STATUS_OKAY(ISL29035_DEFINE)
``` | /content/code_sandbox/drivers/sensor/isl29035/isl29035.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,263 |
```unknown
# ISL29035 light sensor configuration options
menuconfig ISL29035
bool "ISL29035 light sensor"
default y
depends on DT_HAS_ISIL_ISL29035_ENABLED
select I2C
help
Enable driver for the ISL29035 light sensor.
if ISL29035
config ISL29035_THREAD_PRIORITY
int "Thread priority"
default 10
help
Priority of thread used to handle the timer and threshold triggers.
choice
prompt "Full scale lux range"
default ISL29035_LUX_RANGE_1K
help
Maximum allowable lux value. Lower range values offer better
resolution.
config ISL29035_LUX_RANGE_1K
bool "1000"
config ISL29035_LUX_RANGE_4K
bool "4000"
config ISL29035_LUX_RANGE_16K
bool "16000"
config ISL29035_LUX_RANGE_64K
bool "64000"
endchoice
choice
prompt "Integration time"
default ISL29035_INTEGRATION_TIME_105K
help
The sampling period of the internal ADC of the light sensor.
Lower integration time values mean lower ADC resolution.
config ISL29035_INTEGRATION_TIME_26
bool "0.0256 ms"
config ISL29035_INTEGRATION_TIME_410
bool "0.41 ms"
config ISL29035_INTEGRATION_TIME_6500
bool "6.5 ms"
config ISL29035_INTEGRATION_TIME_105K
bool "105 ms"
endchoice
choice
prompt "Active sensing mode"
default ISL29035_MODE_ALS
help
Sensing mode in which the ISL29035 will function. The chip can be
configured either for either ambient light or infrared sensing.
config ISL29035_MODE_ALS
bool "ambient light"
help
Sensing mode for ambient light spectrum.
config ISL29035_MODE_IR
bool "infrared"
help
Sensing mode for infrared spectrum.
endchoice
choice
prompt "Trigger mode"
depends on ISL29035_MODE_ALS && GPIO
default ISL29035_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
Only available for ambient light sensing mode.
config ISL29035_TRIGGER_NONE
bool "No trigger"
config ISL29035_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ISL29035_TRIGGER
config ISL29035_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ISL29035_TRIGGER
endchoice
config ISL29035_TRIGGER
bool
config ISL29035_THREAD_PRIORITY
int "Thread priority"
depends on ISL29035_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config ISL29035_THREAD_STACK_SIZE
int "Thread stack size"
depends on ISL29035_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
choice
prompt "Interrupt persist cycles"
depends on ISL29035_TRIGGER
default ISL29035_INT_PERSIST_1
help
Number of consecutive integration cycles for which the data samples
need to remain outside the threshold window in order for the interrupt
to be triggered.
config ISL29035_INT_PERSIST_1
bool "1"
config ISL29035_INT_PERSIST_4
bool "4"
config ISL29035_INT_PERSIST_8
bool "8"
config ISL29035_INT_PERSIST_16
bool "16"
endchoice
endif # ISL29035
``` | /content/code_sandbox/drivers/sensor/isl29035/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 792 |
```objective-c
/* sensor_isl29035.h - header file for ISL29035 light sensor driver */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ISL29035_ISL29035_H_
#define ZEPHYR_DRIVERS_SENSOR_ISL29035_ISL29035_H_
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#define ISL29035_COMMAND_I_REG 0x00
#define ISL29035_OPMODE_SHIFT 5
#define ISL29035_OPMODE_MASK (7 << ISL29035_OPMODE_SHIFT)
#define ISL29035_INT_BIT_SHIFT 2
#define ISL29035_INT_BIT_MASK (1 << ISL29035_INT_BIT_SHIFT)
#define ISL29035_INT_PRST_SHIFT 0
#define ISL29035_INT_PRST_MASK (3 << ISL29035_INT_BIT_SHIFT)
#define ISL29035_OPMODE_OFF 0
#define ISL29035_OPMODE_ALS_ONCE 1
#define ISL29035_OPMODE_IR_ONCE 2
#define ISL29035_OPMODE_ALS_CONT 5
#define ISL29035_OPMODE_IR_CONT 6
#define ISL29035_COMMAND_II_REG 0x01
#define ISL29035_LUX_RANGE_SHIFT 0
#define ISL29035_LUX_RANGE_MASK (3 << ISL29035_LUX_RANGE_SHIFT)
#define ISL29035_ADC_RES_SHIFT 2
#define ISL29035_ADC_RES_MASK (3 << ISL29035_ADC_RES_SHIFT)
#define ISL29035_DATA_LSB_REG 0x02
#define ISL29035_DATA_MSB_REG 0x03
#define ISL29035_INT_LT_LSB_REG 0x04
#define ISL29035_INT_LT_MSB_REG 0x05
#define ISL29035_INT_HT_LSB_REG 0x06
#define ISL29035_INT_HT_MSB_REG 0x07
#define ISL29035_ID_REG 0x0F
#define ISL29035_BOUT_SHIFT 7
#define ISL29035_BOUT_MASK (1 << ISL29035_BOUT_SHIFT)
#define ISL29035_ID_SHIFT 3
#define ISL29035_ID_MASK (3 << ISL29035_ID_SHIFT)
#if CONFIG_ISL29035_MODE_ALS
#define ISL29035_ACTIVE_OPMODE ISL29035_OPMODE_ALS_CONT
#define ISL29035_ACTIVE_CHAN SENSOR_CHAN_LIGHT
#elif CONFIG_ISL29035_MODE_IR
#define ISL29035_ACTIVE_OPMODE ISL29035_OPMODE_IR_CONT
#define ISL29035_ACTIVE_CHAN SENSOR_CHAN_IR
#endif
#define ISL29035_ACTIVE_OPMODE_BITS \
(ISL29035_ACTIVE_OPMODE << ISL29035_OPMODE_SHIFT)
#if CONFIG_ISL29035_LUX_RANGE_1K
#define ISL29035_LUX_RANGE_IDX 0
#define ISL29035_LUX_RANGE 1000
#elif CONFIG_ISL29035_LUX_RANGE_4K
#define ISL29035_LUX_RANGE_IDX 1
#define ISL29035_LUX_RANGE 4000
#elif CONFIG_ISL29035_LUX_RANGE_16K
#define ISL29035_LUX_RANGE_IDX 2
#define ISL29035_LUX_RANGE 16000
#elif CONFIG_ISL29035_LUX_RANGE_64K
#define ISL29035_LUX_RANGE_IDX 3
#define ISL29035_LUX_RANGE 64000
#endif
#define ISL29035_LUX_RANGE_BITS \
(ISL29035_LUX_RANGE_IDX << ISL29035_LUX_RANGE_SHIFT)
#if CONFIG_ISL29035_INTEGRATION_TIME_26
#define ISL29035_ADC_RES_IDX 3
#elif CONFIG_ISL29035_INTEGRATION_TIME_410
#define ISL29035_ADC_RES_IDX 2
#elif CONFIG_ISL29035_INTEGRATION_TIME_6500
#define ISL29035_ADC_RES_IDX 1
#elif CONFIG_ISL29035_INTEGRATION_TIME_105K
#define ISL29035_ADC_RES_IDX 0
#endif
#define ISL29035_ADC_RES_BITS \
(ISL29035_ADC_RES_IDX << ISL29035_ADC_RES_SHIFT)
#define ISL29035_ADC_DATA_BITS (16 - 4 * ISL29035_ADC_RES_IDX)
#define ISL29035_ADC_DATA_MASK (0xFFFF >> (16 - ISL29035_ADC_DATA_BITS))
#if CONFIG_ISL29035_INT_PERSIST_1
#define ISL29035_INT_PRST_IDX 0
#define ISL29035_INT_PRST_CYCLES 1
#elif CONFIG_ISL29035_INT_PERSIST_4
#define ISL29035_INT_PRST_IDX 1
#define ISL29035_INT_PRST_CYCLES 4
#elif CONFIG_ISL29035_INT_PERSIST_8
#define ISL29035_INT_PRST_IDX 2
#define ISL29035_INT_PRST_CYCLES 8
#elif CONFIG_ISL29035_INT_PERSIST_16
#define ISL29035_INT_PRST_IDX 3
#define ISL29035_INT_PRST_CYCLES 16
#endif
#define ISL29035_INT_PRST_BITS \
(ISL29035_INT_PRST_IDX << ISL29035_INT_PRST_SHIFT)
struct isl29035_driver_data {
uint16_t data_sample;
#if CONFIG_ISL29035_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *th_trigger;
sensor_trigger_handler_t th_handler;
#if defined(CONFIG_ISL29035_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ISL29035_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_ISL29035_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_ISL29035_TRIGGER */
};
struct isl29035_config {
struct i2c_dt_spec i2c;
#if CONFIG_ISL29035_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
#ifdef CONFIG_ISL29035_TRIGGER
int isl29035_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
int isl29035_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int isl29035_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_ISL29035_ISL29035_H_ */
``` | /content/code_sandbox/drivers/sensor/isl29035/isl29035.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,495 |
```unknown
# Raspberry Pi Pico temperature sensor configuration options
config RPI_PICO_TEMP
bool "Raspberry Pi Pico CPU Temperature Sensor"
default y
depends on DT_HAS_RASPBERRYPI_PICO_TEMP_ENABLED
select ADC
help
Enable driver for Raspberry Pi Pico CPU temperature sensor.
``` | /content/code_sandbox/drivers/sensor/rpi_pico_temp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 64 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/vishay/vcnl36825t/Kconfig"
source "drivers/sensor/vishay/vcnl4040/Kconfig"
source "drivers/sensor/vishay/veml7700/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/vishay/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/logging/log.h>
#include <hardware/adc.h>
LOG_MODULE_REGISTER(rpi_pico_temp, CONFIG_SENSOR_LOG_LEVEL);
#define DT_DRV_COMPAT raspberrypi_pico_temp
struct rpi_pico_temp_config {
const struct device *adc;
const struct adc_channel_cfg ch_cfg;
const int32_t vbe;
const int32_t vbe_slope;
};
struct rpi_pico_temp_data {
struct adc_sequence adc_seq;
int16_t sample;
};
static int rpi_pico_temp_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct rpi_pico_temp_config *cfg = dev->config;
struct rpi_pico_temp_data *data = dev->data;
int rc;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
rc = adc_channel_setup(cfg->adc, &cfg->ch_cfg);
if (rc) {
LOG_DBG("Setup ADC channel %u failed with %d", cfg->ch_cfg.channel_id, rc);
return rc;
}
rc = adc_read(cfg->adc, &data->adc_seq);
return rc;
}
static int rpi_pico_temp_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct rpi_pico_temp_config *cfg = dev->config;
struct rpi_pico_temp_data *data = dev->data;
int32_t mv = 0;
int32_t work;
int rc;
if (chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
mv = data->sample;
rc = adc_raw_to_millivolts(adc_ref_internal(cfg->adc), cfg->ch_cfg.gain,
data->adc_seq.resolution, &mv);
if (rc) {
LOG_DBG("adc_raw_to_millivolts() failed %d", rc);
return rc;
}
/*
* Calculate CPU temperature from voltage by the equation:
* T = 27 - (ADC_Voltage - 0.706)/0.001721
*/
work = ((27 * (-cfg->vbe_slope)) - (mv * 1000 - cfg->vbe));
val->val1 = work / (-cfg->vbe_slope);
work -= val->val1 * (-cfg->vbe_slope);
val->val2 = work * 1000000 / (-cfg->vbe_slope);
return 0;
}
static const struct sensor_driver_api rpi_pico_temp_driver_api = {
.sample_fetch = rpi_pico_temp_sample_fetch,
.channel_get = rpi_pico_temp_channel_get,
};
static int rpi_pico_temp_init(const struct device *dev)
{
const struct rpi_pico_temp_config *cfg = dev->config;
if (!device_is_ready(cfg->adc)) {
LOG_ERR("Device %s is not ready", cfg->adc->name);
return -ENODEV;
}
adc_set_temp_sensor_enabled(true);
return 0;
}
#define RPI_PICO_TEMP_DEFINE(inst) \
static const struct rpi_pico_temp_config rpi_pico_temp_config_##inst = { \
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(inst)), \
.vbe = DT_INST_PROP(inst, vbe), \
.vbe_slope = DT_INST_PROP(inst, vbe_slope), \
.ch_cfg = \
{ \
.gain = ADC_GAIN_1, \
.reference = ADC_REF_INTERNAL, \
.acquisition_time = ADC_ACQ_TIME_DEFAULT, \
.channel_id = DT_INST_IO_CHANNELS_INPUT(inst), \
.differential = 0, \
}, \
}; \
static struct rpi_pico_temp_data rpi_pico_temp_dev_data_##inst = { \
.adc_seq = \
{ \
.channels = BIT(DT_INST_IO_CHANNELS_INPUT(inst)), \
.buffer = &rpi_pico_temp_dev_data_##inst.sample, \
.buffer_size = sizeof(rpi_pico_temp_dev_data_##inst.sample), \
.resolution = 12U, \
}, \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, rpi_pico_temp_init, NULL, \
&rpi_pico_temp_dev_data_##inst, &rpi_pico_temp_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&rpi_pico_temp_driver_api);
DT_INST_FOREACH_STATUS_OKAY(RPI_PICO_TEMP_DEFINE)
``` | /content/code_sandbox/drivers/sensor/rpi_pico_temp/rpi_pico_temp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,033 |
```unknown
# Vishay VEML7700 ambient light sensor driver options.
config VEML7700
bool "Vishay VEML7700 ambient light sensor"
default y
depends on DT_HAS_VISHAY_VEML7700_ENABLED
select I2C
help
Enable Vishay VEML7700 ambient light sensor driver.
``` | /content/code_sandbox/drivers/sensor/vishay/veml7700/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VCNL4040_VCNL4040_H_
#define ZEPHYR_DRIVERS_SENSOR_VCNL4040_VCNL4040_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
/* Registers all 16 bits */
#define VCNL4040_REG_ALS_CONF 0x00
#define VCNL4040_REG_ALS_THDH 0x01
#define VCNL4040_REG_ALS_THDL 0x02
#define VCNL4040_REG_PS_CONF 0x03
#define VCNL4040_REG_PS_MS 0x04
#define VCNL4040_REG_PS_CANC 0x05
#define VCNL4040_REG_PS_THDL 0x06
#define VCNL4040_REG_PS_THDH 0x07
#define VCNL4040_REG_PS_DATA 0x08
#define VCNL4040_REG_ALS_DATA 0x09
#define VCNL4040_REG_WHITE_DATA 0x0A
#define VCNL4040_REG_INT_FLAG 0x0B
#define VCNL4040_REG_DEVICE_ID 0x0C
#define VCNL4040_RW_REG_COUNT 0x08 /* [0x00, 0x07] */
#define VCNL4040_DEFAULT_ID 0x0186
#define VCNL4040_LED_I_POS 8
#define VCNL4040_PS_HD_POS 11
#define VCNL4040_PS_HD_MASK BIT(VCNL4040_PS_HD_POS)
#define VCNL4040_PS_DUTY_POS 6
#define VCNL4040_PS_IT_POS 1
#define VCNL4040_PS_SD_POS 0
#define VCNL4040_PS_SD_MASK BIT(VCNL4040_PS_SD_POS)
#define VCNL4040_ALS_IT_POS 6
#define VCNL4040_ALS_INT_EN_POS 1
#define VCNL4040_ALS_INT_EN_MASK BIT(VCNL4040_ALS_INT_EN_POS)
#define VCNL4040_ALS_SD_POS 0
#define VCNL4040_ALS_SD_MASK BIT(VCNL4040_ALS_SD_POS)
enum led_current {
VCNL4040_LED_CURRENT_50MA,
VCNL4040_LED_CURRENT_75MA,
VCNL4040_LED_CURRENT_100MA,
VCNL4040_LED_CURRENT_120MA,
VCNL4040_LED_CURRENT_140MA,
VCNL4040_LED_CURRENT_160MA,
VCNL4040_LED_CURRENT_180MA,
VCNL4040_LED_CURRENT_200MA,
};
enum led_duty_cycle {
VCNL4040_LED_DUTY_1_40,
VCNL4040_LED_DUTY_1_80,
VCNL4040_LED_DUTY_1_160,
VCNL4040_LED_DUTY_1_320,
};
enum ambient_integration_time {
VCNL4040_AMBIENT_INTEGRATION_TIME_80MS,
VCNL4040_AMBIENT_INTEGRATION_TIME_160MS,
VCNL4040_AMBIENT_INTEGRATION_TIME_320MS,
VCNL4040_AMBIENT_INTEGRATION_TIME_640MS,
};
enum proximity_integration_time {
VCNL4040_PROXIMITY_INTEGRATION_TIME_1T,
VCNL4040_PROXIMITY_INTEGRATION_TIME_1_5T,
VCNL4040_PROXIMITY_INTEGRATION_TIME_2T,
VCNL4040_PROXIMITY_INTEGRATION_TIME_2_5T,
VCNL4040_PROXIMITY_INTEGRATION_TIME_3T,
VCNL4040_PROXIMITY_INTEGRATION_TIME_3_5T,
VCNL4040_PROXIMITY_INTEGRATION_TIME_4T,
VCNL4040_PROXIMITY_INTEGRATION_TIME_8T,
};
enum proximity_type {
VCNL4040_PROXIMITY_INT_DISABLE,
VCNL4040_PROXIMITY_INT_CLOSE,
VCNL4040_PROXIMITY_INT_AWAY,
VCNL4040_PROXIMITY_INT_CLOSE_AWAY,
};
enum interrupt_type {
VCNL4040_PROXIMITY_AWAY = 1,
VCNL4040_PROXIMITY_CLOSE,
VCNL4040_AMBIENT_HIGH = 4,
VCNL4040_AMBIENT_LOW,
};
struct vcnl4040_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_VCNL4040_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
enum led_current led_i;
enum led_duty_cycle led_dc;
enum ambient_integration_time als_it;
enum proximity_integration_time proxy_it;
enum proximity_type proxy_type;
};
struct vcnl4040_data {
struct k_mutex mutex;
#ifdef CONFIG_VCNL4040_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
enum interrupt_type int_type;
sensor_trigger_handler_t proxy_handler;
const struct sensor_trigger *proxy_trigger;
sensor_trigger_handler_t als_handler;
const struct sensor_trigger *als_trigger;
#endif
#ifdef CONFIG_VCNL4040_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_VCNL4040_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#endif
#ifdef CONFIG_VCNL4040_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
uint16_t proximity;
uint16_t light;
float sensitivity;
};
int vcnl4040_read(const struct device *dev, uint8_t reg, uint16_t *out);
int vcnl4040_write(const struct device *dev, uint8_t reg, uint16_t value);
#ifdef CONFIG_VCNL4040_TRIGGER
int vcnl4040_trigger_init(const struct device *dev);
int vcnl4040_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
int vcnl4040_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif
#endif
``` | /content/code_sandbox/drivers/sensor/vishay/vcnl4040/vcnl4040.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,376 |
```c
/*
*
*/
#define DT_DRV_COMPAT vishay_vcnl4040
#include "vcnl4040.h"
#include <zephyr/pm/device.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
#include <stdlib.h>
LOG_MODULE_REGISTER(vcnl4040, CONFIG_SENSOR_LOG_LEVEL);
int vcnl4040_read(const struct device *dev, uint8_t reg, uint16_t *out)
{
const struct vcnl4040_config *config = dev->config;
uint8_t buff[2] = { 0 };
int ret = 0;
ret = i2c_write_read_dt(&config->i2c,
®, sizeof(reg), buff, sizeof(buff));
if (ret == 0) {
*out = sys_get_le16(buff);
}
return ret;
}
int vcnl4040_write(const struct device *dev, uint8_t reg, uint16_t value)
{
const struct vcnl4040_config *config = dev->config;
uint8_t buf[3];
int ret;
buf[0] = reg;
sys_put_le16(value, &buf[1]);
ret = i2c_write_dt(&config->i2c, buf, sizeof(buf));
if (ret < 0) {
LOG_ERR("write[%02X]: %u", reg, ret);
return ret;
}
return 0;
}
static int vcnl4040_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct vcnl4040_data *data = dev->data;
int ret = 0;
#ifdef CONFIG_VCNL4040_ENABLE_ALS
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_PROX ||
chan == SENSOR_CHAN_LIGHT);
#else
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_PROX);
#endif
k_mutex_lock(&data->mutex, K_FOREVER);
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_PROX) {
ret = vcnl4040_read(dev, VCNL4040_REG_PS_DATA,
&data->proximity);
if (ret < 0) {
LOG_ERR("Could not fetch proximity");
goto exit;
}
}
#ifdef CONFIG_VCNL4040_ENABLE_ALS
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_LIGHT) {
ret = vcnl4040_read(dev, VCNL4040_REG_ALS_DATA,
&data->light);
if (ret < 0) {
LOG_ERR("Could not fetch ambient light");
}
}
#endif
exit:
k_mutex_unlock(&data->mutex);
return ret;
}
static int vcnl4040_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct vcnl4040_data *data = dev->data;
int ret = 0;
k_mutex_lock(&data->mutex, K_FOREVER);
switch (chan) {
case SENSOR_CHAN_PROX:
val->val1 = data->proximity;
val->val2 = 0;
break;
#ifdef CONFIG_VCNL4040_ENABLE_ALS
case SENSOR_CHAN_LIGHT:
val->val1 = data->light * data->sensitivity;
val->val2 = 0;
break;
#endif
default:
ret = -ENOTSUP;
}
k_mutex_unlock(&data->mutex);
return ret;
}
static int vcnl4040_reg_setup(const struct device *dev)
{
const struct vcnl4040_config *config = dev->config;
uint16_t value[VCNL4040_RW_REG_COUNT] = { 0 };
uint8_t reg;
int ret = 0;
#ifdef CONFIG_VCNL4040_ENABLE_ALS
struct vcnl4040_data *data = dev->data;
/* Set ALS integration time */
value[VCNL4040_REG_ALS_CONF] = config->als_it << VCNL4040_ALS_IT_POS;
/* Clear ALS shutdown */
value[VCNL4040_REG_ALS_CONF] &= ~VCNL4040_ALS_SD_MASK;
/*
* scale the lux depending on the value of the integration time
* see page 8 of the VCNL4040 application note:
* path_to_url
*/
switch (config->als_it) {
case VCNL4040_AMBIENT_INTEGRATION_TIME_80MS:
data->sensitivity = 0.12;
break;
case VCNL4040_AMBIENT_INTEGRATION_TIME_160MS:
data->sensitivity = 0.06;
break;
case VCNL4040_AMBIENT_INTEGRATION_TIME_320MS:
data->sensitivity = 0.03;
break;
case VCNL4040_AMBIENT_INTEGRATION_TIME_640MS:
data->sensitivity = 0.015;
break;
default:
data->sensitivity = 1.0;
LOG_WRN("Cannot set ALS sensitivity from ALS_IT=%d",
config->als_it);
break;
}
#else
value[VCNL4040_REG_ALS_CONF] = VCNL4040_ALS_SD_MASK; /* default */
#endif
/* Set PS_HD */
value[VCNL4040_REG_PS_CONF] = VCNL4040_PS_HD_MASK;
/* Set duty cycle */
value[VCNL4040_REG_PS_CONF] |= config->led_dc << VCNL4040_PS_DUTY_POS;
/* Set integration time */
value[VCNL4040_REG_PS_CONF] |= config->proxy_it << VCNL4040_PS_IT_POS;
/* Clear proximity shutdown */
value[VCNL4040_REG_PS_CONF] &= ~VCNL4040_PS_SD_MASK;
/* Set LED current */
value[VCNL4040_REG_PS_MS] = config->led_i << VCNL4040_LED_I_POS;
for (reg = 0; reg < ARRAY_SIZE(value); reg++) {
ret |= vcnl4040_write(dev, reg, value[reg]);
}
return ret;
}
#ifdef CONFIG_PM_DEVICE
static int vcnl4040_pm_action(const struct device *dev,
enum pm_device_action action)
{
int ret = 0;
uint16_t ps_conf;
ret = vcnl4040_read(dev, VCNL4040_REG_PS_CONF, &ps_conf);
if (ret < 0)
return ret;
#ifdef CONFIG_VCNL4040_ENABLE_ALS
uint16_t als_conf;
ret = vcnl4040_read(dev, VCNL4040_REG_ALS_CONF, &als_conf);
if (ret < 0)
return ret;
#endif
switch (action) {
case PM_DEVICE_ACTION_RESUME:
/* Clear proximity shutdown */
ps_conf &= ~VCNL4040_PS_SD_MASK;
ret = vcnl4040_write(dev, VCNL4040_REG_PS_CONF,
ps_conf);
if (ret < 0)
return ret;
#ifdef CONFIG_VCNL4040_ENABLE_ALS
/* Clear als shutdown */
als_conf &= ~VCNL4040_ALS_SD_MASK;
ret = vcnl4040_write(dev, VCNL4040_REG_ALS_CONF,
als_conf);
if (ret < 0)
return ret;
#endif
break;
case PM_DEVICE_ACTION_SUSPEND:
/* Set proximity shutdown bit 0 */
ps_conf |= VCNL4040_PS_SD_MASK;
ret = vcnl4040_write(dev, VCNL4040_REG_PS_CONF,
ps_conf);
if (ret < 0)
return ret;
#ifdef CONFIG_VCNL4040_ENABLE_ALS
/* Clear als shutdown bit 0 */
als_conf |= VCNL4040_ALS_SD_MASK;
ret = vcnl4040_write(dev, VCNL4040_REG_ALS_CONF,
als_conf);
if (ret < 0)
return ret;
#endif
break;
default:
return -ENOTSUP;
}
return ret;
}
#endif
static int vcnl4040_init(const struct device *dev)
{
const struct vcnl4040_config *config = dev->config;
struct vcnl4040_data *data = dev->data;
uint16_t id;
/* Get the I2C device */
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
/* Check device id */
if (vcnl4040_read(dev, VCNL4040_REG_DEVICE_ID, &id)) {
LOG_ERR("Could not read device id");
return -EIO;
}
if (id != VCNL4040_DEFAULT_ID) {
LOG_ERR("Incorrect device id (%d)", id);
return -EIO;
}
if (vcnl4040_reg_setup(dev)) {
LOG_ERR("register setup");
return -EIO;
}
k_mutex_init(&data->mutex);
#if CONFIG_VCNL4040_TRIGGER
if (vcnl4040_trigger_init(dev)) {
LOG_ERR("Could not initialise interrupts");
return -EIO;
}
#endif
LOG_DBG("Init complete");
return 0;
}
static const struct sensor_driver_api vcnl4040_driver_api = {
.sample_fetch = vcnl4040_sample_fetch,
.channel_get = vcnl4040_channel_get,
#ifdef CONFIG_VCNL4040_TRIGGER
.attr_set = vcnl4040_attr_set,
.trigger_set = vcnl4040_trigger_set,
#endif
};
#define VCNL4040_DEFINE(inst) \
static struct vcnl4040_data vcnl4040_data_##inst; \
\
static const struct vcnl4040_config vcnl4040_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_VCNL4040_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
.led_i = DT_INST_ENUM_IDX(inst, led_current), \
.led_dc = DT_INST_ENUM_IDX(inst, led_duty_cycle), \
.als_it = DT_INST_ENUM_IDX(inst, als_it), \
.proxy_it = DT_INST_ENUM_IDX(inst, proximity_it), \
.proxy_type = DT_INST_ENUM_IDX(inst, proximity_trigger), \
}; \
\
PM_DEVICE_DT_INST_DEFINE(inst, vcnl4040_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, vcnl4040_init, PM_DEVICE_DT_INST_GET(inst), \
&vcnl4040_data_##inst, &vcnl4040_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &vcnl4040_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(VCNL4040_DEFINE)
``` | /content/code_sandbox/drivers/sensor/vishay/vcnl4040/vcnl4040.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,414 |
```unknown
# VCNL4040 Proximity and Ambient Light Sensor configuration options
menuconfig VCNL4040
bool "VCNL4040 Proximity and Ambient Light Sensor"
default y
depends on DT_HAS_VISHAY_VCNL4040_ENABLED
select I2C
help
Enable driver for VCNL4040 sensors.
if VCNL4040
config VCNL4040_ENABLE_ALS
bool "Ambient light sensor"
help
Enable Ambient Light Sense (ALS).
config VCNL4040_TRIGGER
bool
choice VCNL4040_TRIGGER
prompt "Trigger mode"
default VCNL4040_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config VCNL4040_TRIGGER_NONE
bool "No trigger"
config VCNL4040_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select VCNL4040_TRIGGER
config VCNL4040_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select VCNL4040_TRIGGER
endchoice
config VCNL4040_THREAD_PRIORITY
int "Thread priority"
depends on VCNL4040_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config VCNL4040_THREAD_STACK_SIZE
int "Thread stack size"
depends on VCNL4040_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # VCNL4040
``` | /content/code_sandbox/drivers/sensor/vishay/vcnl4040/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 333 |
```c
/*
*
*/
#define DT_DRV_COMPAT vishay_veml7700
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor/veml7700.h>
LOG_MODULE_REGISTER(VEML7700, CONFIG_SENSOR_LOG_LEVEL);
/*
* Bit mask to zero out all bits except 14 and 15.
* Those two are used for the high and low threshold
* interrupt flags in the ALS_INT register.
*/
#define VEML7700_ALS_INT_MASK (~BIT_MASK(14))
/*
* 16-bit command register addresses
*/
#define VEML7700_CMDCODE_ALS_CONF 0x00
#define VEML7700_CMDCODE_ALS_WH 0x01
#define VEML7700_CMDCODE_ALS_WL 0x02
#define VEML7700_CMDCODE_PSM 0x03
#define VEML7700_CMDCODE_ALS 0x04
#define VEML7700_CMDCODE_WHITE 0x05
#define VEML7700_CMDCODE_ALS_INT 0x06
/*
* Devicetree psm-mode property value for "PSM disabled"
*/
#define VEML7700_PSM_DISABLED 0x00
/*
* ALS integration time setting values.
*
* The enumerators of <tt>enum veml7700_als_it</tt> provide
* indices into this array to get the related value for the
* ALS_IT configuration bits.
*/
static const uint8_t veml7700_it_values[VEML7700_ALS_IT_ELEM_COUNT] = {
0x0C, /* 25 - 0b1100 */
0x08, /* 50 - 0b1000 */
0x00, /* 100 - 0b0000 */
0x01, /* 200 - 0b0001 */
0x02, /* 400 - 0b0010 */
0x03, /* 800 - 0b0011 */
};
/*
* Resolution matrix for values to convert between data provided
* by the sensor ("counts") and lux.
*
* These values depend on the current gain and integration time settings.
* The enumerators of <tt>enum veml7700_als_gain</tt> and <tt>enum veml7700_als_it</tt>
* are used for indices into this matrix.
*/
static const float veml7700_resolution[VEML7700_ALS_GAIN_ELEM_COUNT][VEML7700_ALS_IT_ELEM_COUNT] = {
/* 25ms 50ms 100ms 200ms 400ms 800ms Integration Time */
{0.2304f, 0.1152f, 0.0576f, 0.0288f, 0.0144f, 0.0072f}, /* Gain 1 */
{0.1152f, 0.0576f, 0.0288f, 0.0144f, 0.0072f, 0.0036f}, /* Gain 2 */
{1.8432f, 0.9216f, 0.4608f, 0.2304f, 0.1152f, 0.0576f}, /* Gain 1/8 */
{0.9216f, 0.4608f, 0.2304f, 0.1152f, 0.0576f, 0.0288f}, /* Gain 1/4 */
};
struct veml7700_config {
struct i2c_dt_spec bus;
uint8_t psm;
};
struct veml7700_data {
uint8_t shut_down;
enum veml7700_als_gain gain;
enum veml7700_als_it it;
enum veml7700_int_mode int_mode;
uint16_t thresh_high;
uint16_t thresh_low;
uint16_t als_counts;
uint32_t als_lux;
uint16_t white_counts;
uint32_t int_flags;
};
static bool is_veml7700_gain_in_range(uint32_t gain_selection)
{
return (gain_selection < VEML7700_ALS_GAIN_ELEM_COUNT);
}
static bool is_veml7700_it_in_range(uint32_t it_selection)
{
return (it_selection < VEML7700_ALS_IT_ELEM_COUNT);
}
/**
* @brief Waits for a specific amount of time which depends
* on the current integration time setting.
*
* According to datasheet for a measurement to complete one has
* to wait for at least the integration time. But tests showed
* that a much longer wait time is needed. Simply adding 50 or
* 100ms to the integration time is not enough so we doubled
* the integration time to get our wait time.
*
* This function is only called if the sensor is used in "single shot"
* measuring mode. In this mode the sensor measures on demand an
* measurements take time depending on the configures integration time.
* In continuous mode, activated by one of the power saving modes,
* you can always use the last sample value and no waiting is required.
*
* For more information see the "Designing the VEML7700 Into an Application"
* application notes about the power saving modes.
*/
static void veml7700_sleep_by_integration_time(const struct veml7700_data *data)
{
switch (data->it) {
case VEML7700_ALS_IT_25:
k_msleep(50);
break;
case VEML7700_ALS_IT_50:
k_msleep(100);
break;
case VEML7700_ALS_IT_100:
k_msleep(200);
break;
case VEML7700_ALS_IT_200:
k_msleep(400);
break;
case VEML7700_ALS_IT_400:
k_msleep(800);
break;
case VEML7700_ALS_IT_800:
k_msleep(1600);
break;
}
}
static int veml7700_counts_to_lux(const struct veml7700_data *data, uint16_t counts,
uint32_t *lux)
{
if (!is_veml7700_gain_in_range(data->gain) || !is_veml7700_it_in_range(data->it)) {
return -EINVAL;
}
*lux = counts * veml7700_resolution[data->gain][data->it];
return 0;
}
static int veml7700_lux_to_counts(const struct veml7700_data *data, uint32_t lux,
uint16_t *counts)
{
if (!is_veml7700_gain_in_range(data->gain) || !is_veml7700_it_in_range(data->it)) {
return -EINVAL;
}
*counts = lux / veml7700_resolution[data->gain][data->it];
return 0;
}
static int veml7700_check_gain(const struct sensor_value *val)
{
return val->val1 >= VEML7700_ALS_GAIN_1 && val->val1 <= VEML7700_ALS_GAIN_1_4;
}
static int veml7700_check_it(const struct sensor_value *val)
{
return val->val1 >= VEML7700_ALS_IT_25 && val->val1 <= VEML7700_ALS_IT_800;
}
static int veml7700_check_int_mode(const struct sensor_value *val)
{
return (val->val1 >= VEML7700_ALS_PERS_1 && val->val1 <= VEML7700_ALS_PERS_8) ||
val->val1 == VEML7700_INT_DISABLED;
}
static int veml7700_build_als_conf_param(const struct veml7700_data *data, uint16_t *return_value)
{
if (!is_veml7700_gain_in_range(data->gain) || !is_veml7700_it_in_range(data->it)) {
return -EINVAL;
}
uint16_t param = 0;
/* Bits 15:13 -> reserved */
/* Bits 12:11 -> gain selection (ALS_GAIN) */
param |= data->gain << 11;
/* Bit 10 -> reserved */
/* Bits 9:6 -> integration time (ALS_IT) */
param |= veml7700_it_values[data->it] << 6;
/* Bits 5:4 -> interrupt persistent protection (ALS_PERS) */
if (data->int_mode != VEML7700_INT_DISABLED) {
param |= data->int_mode << 4;
/* Bit 1 -> interrupt enable (ALS_INT_EN) */
param |= BIT(1);
}
/* Bits 3:2 -> reserved */
/* Bit 0 -> shut down setting (ALS_SD) */
if (data->shut_down) {
param |= BIT(0);
}
*return_value = param;
return 0;
}
static uint16_t veml7700_build_psm_param(const struct veml7700_config *conf)
{
/* We can directly use the devicetree configuration value. */
return conf->psm;
}
static int veml7700_write(const struct device *dev, uint8_t cmd, uint16_t data)
{
const struct veml7700_config *conf = dev->config;
uint8_t send_buf[3];
send_buf[0] = cmd; /* byte 0: command code */
sys_put_le16(data, &send_buf[1]); /* bytes 1,2: command arguments */
return i2c_write_dt(&conf->bus, send_buf, ARRAY_SIZE(send_buf));
}
static int veml7700_read(const struct device *dev, uint8_t cmd, uint16_t *data)
{
const struct veml7700_config *conf = dev->config;
uint8_t recv_buf[2];
int ret = i2c_write_read_dt(&conf->bus, &cmd, sizeof(cmd), &recv_buf, ARRAY_SIZE(recv_buf));
if (ret < 0) {
return ret;
}
*data = sys_get_le16(recv_buf);
return 0;
}
static int veml7700_write_als_conf(const struct device *dev)
{
const struct veml7700_data *data = dev->data;
uint16_t param;
int ret = 0;
ret = veml7700_build_als_conf_param(data, ¶m);
if (ret < 0) {
return ret;
}
LOG_DBG("Writing ALS configuration: 0x%04x", param);
return veml7700_write(dev, VEML7700_CMDCODE_ALS_CONF, param);
}
static int veml7700_write_psm(const struct device *dev)
{
const struct veml7700_config *conf = dev->config;
uint16_t psm_param;
psm_param = veml7700_build_psm_param(conf);
LOG_DBG("Writing PSM configuration: 0x%04x", psm_param);
return veml7700_write(dev, VEML7700_CMDCODE_PSM, psm_param);
}
static int veml7700_write_thresh_low(const struct device *dev)
{
const struct veml7700_data *data = dev->data;
LOG_DBG("Writing low threshold counts: %d", data->thresh_low);
return veml7700_write(dev, VEML7700_CMDCODE_ALS_WL, data->thresh_low);
}
static int veml7700_write_thresh_high(const struct device *dev)
{
const struct veml7700_data *data = dev->data;
LOG_DBG("Writing high threshold counts: %d", data->thresh_high);
return veml7700_write(dev, VEML7700_CMDCODE_ALS_WH, data->thresh_high);
}
static int veml7700_set_shutdown_flag(const struct device *dev, uint8_t new_val)
{
struct veml7700_data *data = dev->data;
uint8_t prev_sd;
int ret;
prev_sd = data->shut_down;
data->shut_down = new_val;
ret = veml7700_write_als_conf(dev);
if (ret < 0) {
data->shut_down = prev_sd;
}
return ret;
}
static int veml7700_fetch_als(const struct device *dev)
{
struct veml7700_data *data = dev->data;
uint16_t counts;
int ret;
ret = veml7700_read(dev, VEML7700_CMDCODE_ALS, &counts);
if (ret < 0) {
return ret;
}
data->als_counts = counts;
ret = veml7700_counts_to_lux(data, counts, &data->als_lux);
if (ret < 0) {
return ret;
}
LOG_DBG("Read ALS measurement: counts=%d, lux=%d", data->als_counts, data->als_lux);
return 0;
}
static int veml7700_fetch_white(const struct device *dev)
{
struct veml7700_data *data = dev->data;
uint16_t counts;
int ret;
ret = veml7700_read(dev, VEML7700_CMDCODE_WHITE, &counts);
if (ret < 0) {
return ret;
}
data->white_counts = counts;
LOG_DBG("Read White Light measurement: counts=%d", data->white_counts);
return 0;
}
static int veml7700_fetch_int_flags(const struct device *dev)
{
struct veml7700_data *data = dev->data;
uint16_t int_flags = 0;
int ret;
ret = veml7700_read(dev, VEML7700_CMDCODE_ALS_INT, &int_flags);
if (ret < 0) {
return ret;
}
data->int_flags = int_flags & VEML7700_ALS_INT_MASK;
LOG_DBG("Read int state: 0x%02x", data->int_flags);
return 0;
}
static int veml7700_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_LIGHT) {
return -ENOTSUP;
}
struct veml7700_data *data = dev->data;
int ret = 0;
if (attr == SENSOR_ATTR_LOWER_THRESH) {
ret = veml7700_lux_to_counts(data, val->val1, &data->thresh_low);
if (ret < 0) {
return ret;
}
return veml7700_write_thresh_low(dev);
} else if (attr == SENSOR_ATTR_UPPER_THRESH) {
ret = veml7700_lux_to_counts(data, val->val1, &data->thresh_high);
if (ret < 0) {
return ret;
}
return veml7700_write_thresh_high(dev);
} else if ((enum sensor_attribute_veml7700)attr == SENSOR_ATTR_VEML7700_GAIN) {
if (veml7700_check_gain(val)) {
data->gain = (enum veml7700_als_gain)val->val1;
return veml7700_write_als_conf(dev);
} else {
return -EINVAL;
}
} else if ((enum sensor_attribute_veml7700)attr == SENSOR_ATTR_VEML7700_ITIME) {
if (veml7700_check_it(val)) {
data->it = (enum veml7700_als_it)val->val1;
return veml7700_write_als_conf(dev);
} else {
return -EINVAL;
}
} else if ((enum sensor_attribute_veml7700)attr == SENSOR_ATTR_VEML7700_INT_MODE) {
if (veml7700_check_int_mode(val)) {
data->int_mode = (enum veml7700_int_mode)val->val1;
return veml7700_write_als_conf(dev);
} else {
return -EINVAL;
}
} else {
return -ENOTSUP;
}
}
static int veml7700_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
if (chan != SENSOR_CHAN_LIGHT) {
return -ENOTSUP;
}
struct veml7700_data *data = dev->data;
if (attr == SENSOR_ATTR_LOWER_THRESH) {
val->val1 = data->thresh_low;
} else if (attr == SENSOR_ATTR_UPPER_THRESH) {
val->val1 = data->thresh_high;
} else if ((enum sensor_attribute_veml7700)attr == SENSOR_ATTR_VEML7700_GAIN) {
val->val1 = data->gain;
} else if ((enum sensor_attribute_veml7700)attr == SENSOR_ATTR_VEML7700_ITIME) {
val->val1 = data->it;
} else if ((enum sensor_attribute_veml7700)attr == SENSOR_ATTR_VEML7700_INT_MODE) {
val->val1 = data->int_mode;
} else {
return -ENOTSUP;
}
val->val2 = 0;
return 0;
}
static int veml7700_perform_single_measurement(const struct device *dev)
{
struct veml7700_data *data = dev->data;
int ret;
/* Start sensor */
ret = veml7700_set_shutdown_flag(dev, 0);
if (ret < 0) {
return ret;
}
/* Wait for sensor to finish it's startup sequence */
k_msleep(5);
/* Wait for measurement to complete */
veml7700_sleep_by_integration_time(data);
/* Shut down sensor */
return veml7700_set_shutdown_flag(dev, 1);
}
static int veml7700_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct veml7700_config *conf = dev->config;
struct veml7700_data *data;
int ret;
/* Start sensor for new measurement if power saving mode is disabled */
if ((chan == SENSOR_CHAN_LIGHT || chan == SENSOR_CHAN_ALL) &&
conf->psm == VEML7700_PSM_DISABLED) {
ret = veml7700_perform_single_measurement(dev);
if (ret < 0) {
return ret;
}
}
if (chan == SENSOR_CHAN_LIGHT) {
return veml7700_fetch_als(dev);
} else if ((enum sensor_channel_veml7700)chan == SENSOR_CHAN_VEML7700_INTERRUPT) {
data = dev->data;
if (data->int_mode != VEML7700_INT_DISABLED) {
return veml7700_fetch_int_flags(dev);
} else {
return -ENOTSUP;
}
} else if ((enum sensor_channel_veml7700)chan == SENSOR_CHAN_VEML7700_WHITE_RAW_COUNTS) {
return veml7700_fetch_white(dev);
} else if (chan == SENSOR_CHAN_ALL) {
data = dev->data;
if (data->int_mode != VEML7700_INT_DISABLED) {
ret = veml7700_fetch_int_flags(dev);
if (ret < 0) {
return ret;
}
}
ret = veml7700_fetch_white(dev);
if (ret < 0) {
return ret;
}
return veml7700_fetch_als(dev);
} else {
return -ENOTSUP;
}
}
static int veml7700_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct veml7700_data *data = dev->data;
if (chan == SENSOR_CHAN_LIGHT) {
val->val1 = data->als_lux;
} else if ((enum sensor_channel_veml7700)chan == SENSOR_CHAN_VEML7700_RAW_COUNTS) {
val->val1 = data->als_counts;
} else if ((enum sensor_channel_veml7700)chan == SENSOR_CHAN_VEML7700_WHITE_RAW_COUNTS) {
val->val1 = data->white_counts;
} else if ((enum sensor_channel_veml7700)chan == SENSOR_CHAN_VEML7700_INTERRUPT) {
val->val1 = data->int_flags;
} else {
return -ENOTSUP;
}
val->val2 = 0;
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int veml7700_pm_action(const struct device *dev, enum pm_device_action action)
{
const struct veml7700_config *conf = dev->config;
if (conf->psm != VEML7700_PSM_DISABLED) {
switch (action) {
case PM_DEVICE_ACTION_SUSPEND:
return veml7700_set_shutdown_flag(dev, 1);
case PM_DEVICE_ACTION_RESUME:
return veml7700_set_shutdown_flag(dev, 0);
default:
return -ENOTSUP;
}
}
return 0;
}
#endif /* CONFIG_PM_DEVICE */
static int veml7700_init(const struct device *dev)
{
const struct veml7700_config *conf = dev->config;
struct veml7700_data *data = dev->data;
int ret;
if (!i2c_is_ready_dt(&conf->bus)) {
LOG_ERR("Device not ready");
return -ENODEV;
}
/* Initialize power saving mode */
ret = veml7700_write_psm(dev);
if (ret < 0) {
return ret;
}
/* Set initial data values */
data->thresh_low = 0;
data->thresh_high = 0xFFFF;
data->gain = VEML7700_ALS_GAIN_1_4;
data->it = VEML7700_ALS_IT_100;
data->int_mode = VEML7700_INT_DISABLED;
data->als_counts = 0;
data->als_lux = 0;
data->white_counts = 0;
data->shut_down = (conf->psm != VEML7700_PSM_DISABLED) ? 0 : 1;
/* Initialize sensor configuration */
ret = veml7700_write_thresh_low(dev);
if (ret < 0) {
return ret;
}
ret = veml7700_write_thresh_high(dev);
if (ret < 0) {
return ret;
}
ret = veml7700_write_als_conf(dev);
if (ret < 0) {
return ret;
}
return 0;
}
static const struct sensor_driver_api veml7700_api = {.sample_fetch = veml7700_sample_fetch,
.channel_get = veml7700_channel_get,
.attr_set = veml7700_attr_set,
.attr_get = veml7700_attr_get};
#define VEML7700_INIT(n) \
static struct veml7700_data veml7700_data_##n; \
\
static const struct veml7700_config veml7700_config_##n = { \
.bus = I2C_DT_SPEC_INST_GET(n), .psm = DT_INST_PROP(n, psm_mode)}; \
\
PM_DEVICE_DT_INST_DEFINE(n, veml7700_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, veml7700_init, PM_DEVICE_DT_INST_GET(n), \
&veml7700_data_##n, &veml7700_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &veml7700_api);
DT_INST_FOREACH_STATUS_OKAY(VEML7700_INIT)
``` | /content/code_sandbox/drivers/sensor/vishay/veml7700/veml7700.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,110 |
```c
/*
*
*/
#include "vcnl4040.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(vcnl4040, CONFIG_SENSOR_LOG_LEVEL);
static void vcnl4040_handle_cb(struct vcnl4040_data *data)
{
const struct vcnl4040_config *config = data->dev->config;
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_VCNL4040_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_VCNL4040_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void vcnl4040_gpio_callback(const struct device *dev,
struct gpio_callback *cb,
uint32_t pin_mask)
{
struct vcnl4040_data *data =
CONTAINER_OF(cb, struct vcnl4040_data, gpio_cb);
const struct vcnl4040_config *config = data->dev->config;
if ((pin_mask & BIT(config->int_gpio.pin)) == 0U) {
return;
}
vcnl4040_handle_cb(data);
}
static int vcnl4040_handle_proxy_int(const struct device *dev)
{
struct vcnl4040_data *data = dev->data;
if (data->proxy_handler != NULL) {
data->proxy_handler(dev, data->proxy_trigger);
}
return 0;
}
static int vcnl4040_handle_als_int(const struct device *dev)
{
struct vcnl4040_data *data = dev->data;
if (data->als_handler != NULL) {
data->als_handler(dev, data->als_trigger);
}
return 0;
}
static void vcnl4040_handle_int(const struct device *dev)
{
const struct vcnl4040_config *config = dev->config;
struct vcnl4040_data *data = dev->data;
uint16_t int_source;
if (vcnl4040_read(dev, VCNL4040_REG_INT_FLAG, &int_source)) {
LOG_ERR("Could not read interrupt source");
int_source = 0U;
}
data->int_type = int_source >> 8;
if (data->int_type == VCNL4040_PROXIMITY_AWAY ||
data->int_type == VCNL4040_PROXIMITY_CLOSE) {
vcnl4040_handle_proxy_int(dev);
} else if (data->int_type == VCNL4040_AMBIENT_HIGH ||
data->int_type == VCNL4040_AMBIENT_LOW) {
vcnl4040_handle_als_int(dev);
} else {
LOG_ERR("Unknown interrupt source %d", data->int_type);
}
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
#ifdef CONFIG_VCNL4040_TRIGGER_OWN_THREAD
static void vcnl4040_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct vcnl4040_data *data = p1;
while (true) {
k_sem_take(&data->trig_sem, K_FOREVER);
vcnl4040_handle_int(data->dev);
}
}
#endif
#ifdef CONFIG_VCNL4040_TRIGGER_GLOBAL_THREAD
static void vcnl4040_work_handler(struct k_work *work)
{
struct vcnl4040_data *data =
CONTAINER_OF(work, struct vcnl4040_data, work);
vcnl4040_handle_int(data->dev);
}
#endif
int vcnl4040_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct vcnl4040_data *data = dev->data;
const struct vcnl4040_config *config = dev->config;
int ret = 0;
if (config->int_gpio.port == NULL) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
if (chan == SENSOR_CHAN_PROX) {
if (attr == SENSOR_ATTR_UPPER_THRESH) {
if (vcnl4040_write(dev, VCNL4040_REG_PS_THDH,
(uint16_t)val->val1)) {
ret = -EIO;
goto exit;
}
ret = 0;
goto exit;
}
if (attr == SENSOR_ATTR_LOWER_THRESH) {
if (vcnl4040_write(dev, VCNL4040_REG_PS_THDL,
(uint16_t)val->val1)) {
ret = -EIO;
goto exit;
}
ret = 0;
goto exit;
}
}
#ifdef CONFIG_VCNL4040_ENABLE_ALS
if (chan == SENSOR_CHAN_LIGHT) {
if (attr == SENSOR_ATTR_UPPER_THRESH) {
if (vcnl4040_write(dev, VCNL4040_REG_ALS_THDH,
(uint16_t)val->val1)) {
ret = -EIO;
goto exit;
}
ret = 0;
goto exit;
}
if (attr == SENSOR_ATTR_LOWER_THRESH) {
if (vcnl4040_write(dev, VCNL4040_REG_ALS_THDL,
(uint16_t)val->val1)) {
ret = -EIO;
goto exit;
}
ret = 0;
goto exit;
}
}
#endif
ret = -ENOTSUP;
exit:
k_mutex_unlock(&data->mutex);
return ret;
}
int vcnl4040_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct vcnl4040_config *config = dev->config;
struct vcnl4040_data *data = dev->data;
uint16_t conf;
int ret = 0;
if (config->int_gpio.port == NULL) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
switch (trig->type) {
case SENSOR_TRIG_THRESHOLD:
if (trig->chan == SENSOR_CHAN_PROX) {
if (vcnl4040_read(dev, VCNL4040_REG_PS_CONF, &conf)) {
ret = -EIO;
goto exit;
}
/* Set interrupt bits 1:0 of high register */
conf |= config->proxy_type << 8;
if (vcnl4040_write(dev, VCNL4040_REG_PS_CONF, conf)) {
ret = -EIO;
goto exit;
}
data->proxy_handler = handler;
data->proxy_trigger = trig;
} else if (trig->chan == SENSOR_CHAN_LIGHT) {
#ifdef CONFIG_VCNL4040_ENABLE_ALS
if (vcnl4040_read(dev, VCNL4040_REG_ALS_CONF, &conf)) {
ret = -EIO;
goto exit;
}
/* ALS interrupt enable */
conf |= VCNL4040_ALS_INT_EN_MASK;
if (vcnl4040_write(dev, VCNL4040_REG_ALS_CONF, conf)) {
ret = -EIO;
goto exit;
}
data->als_handler = handler;
data->als_trigger = trig;
#else
ret = -ENOTSUP;
goto exit;
#endif
} else {
ret = -ENOTSUP;
goto exit;
}
break;
default:
LOG_ERR("Unsupported sensor trigger");
ret = -ENOTSUP;
goto exit;
}
exit:
k_mutex_unlock(&data->mutex);
return ret;
}
int vcnl4040_trigger_init(const struct device *dev)
{
const struct vcnl4040_config *config = dev->config;
struct vcnl4040_data *data = dev->data;
data->dev = dev;
if (config->int_gpio.port == NULL) {
LOG_DBG("instance '%s' doesn't support trigger mode", dev->name);
return 0;
}
/* Get the GPIO device */
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name,
config->int_gpio.port->name);
return -ENODEV;
}
#if defined(CONFIG_VCNL4040_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_VCNL4040_THREAD_STACK_SIZE,
vcnl4040_thread_main,
data, NULL, NULL,
K_PRIO_COOP(CONFIG_VCNL4040_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&data->thread, "VCNL4040 trigger");
#elif defined(CONFIG_VCNL4040_TRIGGER_GLOBAL_THREAD)
data->work.handler = vcnl4040_work_handler;
#endif
gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
gpio_init_callback(&data->gpio_cb, vcnl4040_gpio_callback,
BIT(config->int_gpio.pin));
if (gpio_add_callback(config->int_gpio.port, &data->gpio_cb) < 0) {
LOG_ERR("Failed to set gpio callback");
return -EIO;
}
gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (gpio_pin_get_dt(&config->int_gpio) > 0) {
vcnl4040_handle_cb(data);
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/vishay/vcnl4040/vcnl4040_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,081 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VCNL36825T_VCNL36825T_H_
#define ZEPHYR_DRIVERS_SENSOR_VCNL36825T_VCNL36825T_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#define VCNL36825T_REG_PS_CONF1 0x00
#define VCNL36825T_REG_PS_CONF2 0x03
#define VCNL36825T_REG_PS_CONF3 0x04
#define VCNL36825T_REG_PS_THDL 0x05
#define VCNL36825T_REG_PS_THDH 0x06
#define VCNL36825T_REG_PS_CANC 0x07
#define VCNL36825T_REG_PS_CONF4 0x08
#define VCNL36825T_REG_PS_DATA 0xF8
#define VCNL36825T_REG_INT_FLAG 0xF9
#define VCNL36825T_REG_DEV_ID 0xFA
#define VCNL36825T_REG_PS_AC_DATA 0xFB
/* default values */
#define VCNL36825T_CONF1_DEFAULT 0x0001
#define VCNL36825T_CONF2_DEFAULT 0x0000
#define VCNL36825T_CONF3_DEFAULT 0x0000
#define VCNL36825T_THDL_DEFAULT 0x0000
#define VCNL36825T_THDH_DEFAULT 0x0000
#define VCNL36825T_CANC_DEFAULT 0x0000
#define VCNL36825T_CONF4_DEFAULT 0x0000
/* PS_CONF1 */
#define VCNL36825T_PS_ON_POS 1
#define VCNL36825T_PS_CAL_POS 7
#define VCNL36825T_PS_ON_MSK GENMASK(1, 1)
#define VCNL36825T_PS_ON (1 << VCNL36825T_PS_ON_POS)
#define VCNL36825T_PS_OFF (0 << VCNL36825T_PS_ON_POS)
#define VCNL36825T_PS_CAL (1 << VCNL36825T_PS_CAL_POS)
/* PS_CONF2 */
#define VCNL36825T_PS_ST_POS 0
#define VCNL36825T_PS_PS_SMART_PERS_POS 1
#define VCNL36825T_PS_INT_POS 2
#define VCNL36825T_PS_PERS_POS 4
#define VCNL36825T_PS_PERIOD_POS 6
#define VCNL36825T_PS_HG_POS 10
#define VCNL36825T_PS_ITB_POS 11
#define VCNL36825T_PS_MPS_POS 12
#define VCNL36825T_PS_IT_POS 14
#define VCNL36825T_PS_ST_MSK GENMASK(0, 0)
#define VCNL36825T_PS_ST_START (0 << VCNL36825T_PS_ST_POS)
#define VCNL36825T_PS_ST_STOP (1 << VCNL36825T_PS_ST_POS)
#define VCNL36825T_PS_SMART_PERS_DISABLED (0 << VCNL36825T_PS_PS_SMART_PERS_POS)
#define VCNL36825T_PS_SMART_PERS_ENABLED (1 << VCNL36825T_PS_PS_SMART_PERS_POS)
#define VCNL36825T_PS_INT_DISABLE (0 << VCNL36825T_PS_INT_POS)
#define VCNL36825T_PS_INT_THDH_PERS_LATCHED (1 << VCNL36825T_PS_INT_POS)
#define VCNL36825T_PS_INT_THDH_FIRST_LATCHED (2 << VCNL36825T_PS_INT_POS)
#define VCNL36825T_PS_INT_ENABLED (3 << VCNL36825T_PS_INT_POS)
#define VCNL36825T_PS_PERS_1 (0 << VCNL36825T_PS_PERS_POS)
#define VCNL36825T_PS_PERS_2 (1 << VCNL36825T_PS_PERS_POS)
#define VCNL36825T_PS_PERS_3 (2 << VCNL36825T_PS_PERS_POS)
#define VCNL36825T_PS_PERS_4 (3 << VCNL36825T_PS_PERS_POS)
#define VCNL36825T_PS_PERIOD_10MS (0 << VCNL36825T_PS_PERIOD_POS)
#define VCNL36825T_PS_PERIOD_20MS (1 << VCNL36825T_PS_PERIOD_POS)
#define VCNL36825T_PS_PERIOD_40MS (2 << VCNL36825T_PS_PERIOD_POS)
#define VCNL36825T_PS_PERIOD_80MS (3 << VCNL36825T_PS_PERIOD_POS)
#define VCNL36825T_PS_HG_LOW (0 << VCNL36825T_PS_HG_POS)
#define VCNL36825T_PS_HG_HIGH (1 << VCNL36825T_PS_HG_POS)
#define VCNL36825T_PS_ITB_25us (0 << VCNL36825T_PS_ITB_POS)
#define VCNL36825T_PS_ITB_50us (1 << VCNL36825T_PS_ITB_POS)
#define VCNL36825T_MPS_PULSES_1 (0 << VCNL36825T_PS_MPS_POS)
#define VCNL36825T_MPS_PULSES_2 (1 << VCNL36825T_PS_MPS_POS)
#define VCNL36825T_MPS_PULSES_4 (2 << VCNL36825T_PS_MPS_POS)
#define VCNL36825T_MPS_PULSES_8 (4 << VCNL36825T_PS_MPS_POS)
#define VCNL36825T_PS_IT_1T (0 << VCNL36825T_PS_IT_POS)
#define VCNL36825T_PS_IT_2T (1 << VCNL36825T_PS_IT_POS)
#define VCNL36825T_PS_IT_4T (2 << VCNL36825T_PS_IT_POS)
#define VCNL36825T_PS_IT_8T (3 << VCNL36825T_PS_IT_POS)
/* PS_CONF3 */
#define VCNL36825T_PS_SP_INT_POS 2
#define VCNL36825T_PS_FORCENUM_POS 4
#define VCNL36825T_PS_TRIG_POS 5
#define VCNL36825T_PS_AF_POS 6
#define VCNL36825T_PS_I_VCSEL_POS 8
#define VCNL36825T_PS_HD_POS 12
#define VCNL36825T_PS_SC_POS 13
#define VCNL36825T_PS_TRIG_MSK GENMASK(5, 5)
#define VCNL36825T_PS_AF_MSK GENMASK(6, 6)
#define VCNL36825T_PS_SP_INT_DISABLED (0 << VCNL36825T_PS_SP_INT_POS)
#define VCNL36825T_PS_SP_INT_ENABLED (1 << VCNL36825T_PS_SP_INT_POS)
#define VCNL36825T_PS_FORCENUM_ONE_CYCLE (0 << VCNL36825T_PS_FORCENUM_POS)
#define VCNL36825T_PS_FORCENUM_TWO_CYCLES (1 << VCNL36825T_PS_FORCENUM_POS)
#define VCNL36825T_PS_TRIG_NONE (0 << VCNL36825T_PS_TRIG_POS)
#define VCNL36825T_PS_TRIG_ONCE (1 << VCNL36825T_PS_TRIG_POS)
#define VCNL36825T_PS_AF_AUTO (0 << VCNL36825T_PS_AF_POS)
#define VCNL36825T_PS_AF_FORCE (1 << VCNL36825T_PS_AF_POS)
#define VCNL36825T_PS_I_VCSEL_10MA (2 << VCNL36825T_PS_I_VCSEL_POS)
#define VCNL36825T_PS_I_VCSEL_12MA (3 << VCNL36825T_PS_I_VCSEL_POS)
#define VCNL36825T_PS_I_VCSEL_14MA (4 << VCNL36825T_PS_I_VCSEL_POS)
#define VCNL36825T_PS_I_VCSEL_16MA (5 << VCNL36825T_PS_I_VCSEL_POS)
#define VCNL36825T_PS_I_VCSEL_18MA (6 << VCNL36825T_PS_I_VCSEL_POS)
#define VCNL36825T_PS_I_VCSEL_20MA (7 << VCNL36825T_PS_I_VCSEL_POS)
#define VCNL36825T_PS_HD_12BIT (0 << VCNL36825T_PS_HD_POS)
#define VCNL36825T_PS_HD_16BIT (1 << VCNL36825T_PS_HD_POS)
#define VCNL36825T_PS_SC_DISABLED (0 << VCNL36825T_PS_SC_POS)
#define VCNL36825T_PS_SC_ENABLED (7 << VCNL36825T_PS_SC_POS)
/* PS CONF4 */
#define VCNL36825T_PS_AC_INT_POS 0
#define VCNL36825T_PS_AC_TRIG_POS 2
#define VCNL36825T_PS_AC_POS 3
#define VCNL36825T_PS_AC_NUM_POS 4
#define VCNL36825T_PS_AC_PERIOD_POS 6
#define VCNL36825T_PS_LPEN_POS 8
#define VCNL36825T_PS_LPPER_POS 9
#define VCNL36825T_PS_LPEN_MSK GENMASK(8, 8)
#define VCNL36825T_PS_AC_INT_DISABLED (0 << VCNL36825T_PS_AC_INT_POS)
#define VCNL36825T_PS_AC_INT_ENABLED (1 << VCNL36825T_PS_AC_INT_POS)
#define VCNL36825T_PS_AC_TRIG_DISABLED (0 << VCNL36825T_PS_AC_TRIG_POS)
#define VCNL36825T_PS_AC_TRIG_ONCE (1 << VCNL36825T_PS_AC_TRIG_POS)
#define VCNL36825T_PS_AC_DISABLED (0 << VCNL36825T_PS_AC_POS)
#define VCNL36825T_PS_AC_ENABLED (1 << VCNL36825T_PS_AC_POS)
#define VCNL36825T_PS_AC_NUM_1 (0 << VCNL36825T_PS_AC_NUM_POS)
#define VCNL36825T_PS_AC_NUM_2 (1 << VCNL36825T_PS_AC_NUM_POS)
#define VCNL36825T_PS_AC_NUM_4 (2 << VCNL36825T_PS_AC_NUM_POS)
#define VCNL36825T_PS_AC_NUM_8 (3 << VCNL36825T_PS_AC_NUM_POS)
#define VCNL36825T_PS_AC_PERIOD_3MS (0 << VCNL36825T_PS_AC_PERIOD_POS)
#define VCNL36825T_PS_AC_PERIOD_6MS (1 << VCNL36825T_PS_AC_PERIOD_POS)
#define VCNL36825T_PS_AC_PERIOD_12MS (2 << VCNL36825T_PS_AC_PERIOD_POS)
#define VCNL36825T_PS_AC_PERIOD_24MS (3 << VCNL36825T_PS_AC_PERIOD_POS)
#define VCNL36825T_PS_LPEN_DISABLED (0 << VCNL36825T_PS_LPEN_POS)
#define VCNL36825T_PS_LPEN_ENABLED (1 << VCNL36825T_PS_LPEN_POS)
#define VCNL36825T_PS_LPPER_40MS (0 << VCNL36825T_PS_LPPER_POS)
#define VCNL36825T_PS_LPPER_80MS (1 << VCNL36825T_PS_LPPER_POS)
#define VCNL36825T_PS_LPPER_160MS (2 << VCNL36825T_PS_LPPER_POS)
#define VCNL36825T_PS_LPPER_320MS (3 << VCNL36825T_PS_LPPER_POS)
/* PS_DATA */
#define VCNL36825T_PS_DATA_L_POS 0
#define VCNL36825T_PS_DATA_H_POS 8
#define VCNL36825T_PS_DATA_L_MSK GENMASK(7, 0)
#define VCNL36825T_PS_DATA_H_MSK GENMASK(11, 8)
#define VCNL36825T_OS_DATA_MSK (VCNL36825T_PS_DATA_L_MSK | VCNL36825T_PS_DATA_H_MSK)
/* INT_FLAG */
#define VCNL36825T_PS_IF_AWAY_POS 8
#define VCNL36825T_PS_IF_CLOSE_POS 9
#define VCNL36825T_PS_SPFLAG_POS 12
#define VCNL36825T_PS_ACFLAG_POS 13
#define VCNL36825T_PS_IF_AWAY_MSK GENMASK(8, 8)
#define VCNL36825T_PS_IF_CLOSE_MSK GENMASK(9, 9)
#define VCNL36825T_PS_SPFLAG_MSK GENMASK(12, 12)
#define VCNL36825T_PS_ACFLAG_MSK GENMASK(13, 13)
/* ID */
#define VCNL36825T_ID_POS 0
#define VCNL36825T_VERSION_CODE_POS 8
#define VCNL36825T_ID_MSK GENMASK(7, 0)
#define VCNL36825T_VERSION_CODE_MSK GENMASK(11, 8)
#define VCNL36825T_DEVICE_ID 0b00100110
/* PS_AC_DATA */
#define VCNL36825T_AC_DATA_L_POS 0
#define VCNL36825T_AC_DATA_H_POS 8
#define VCNL36825T_AC_SUN_POS 14
#define VCNL36825T_AC_BUSY_POS 15
#define VCNL36825T_AC_DATA_L_MSK GENMASK(7, 0)
#define VCNL36825T_AC_DATA_H_MSK GENMASK(11, 8)
#define VCNL36825T_AC_SUN_MSK GENMASK(14, 14)
#define VCNL36825T_AC_BUSY_MSK GENMASK(15, 15)
#define VCNL36825T_PS_PERIOD_VALUE_MAX_MS 80
#define VCNL36825T_PS_LPPER_VALUE_MIN_MS 40
/* see application note "Designing the VCNL36825T Into an Application": power up takes 2500 us */
#define VCNL36825T_POWER_UP_US 2500
#define VCNL36825T_FORCED_FACTOR_TIME_TO_TRIGGER 0.5
#define VCNL36825T_FORCED_FACTOR_DC_KILL_AMBIENT 3
#define VCNL36825T_FORCED_FACTOR_MEASUREMENT 1
#define VCNL36825T_FORCED_FACTOR_SHUTDOWN 1
#define VCNL36825T_FORCED_FACTOR_SCALE 10
#define VCNL36825T_FORCED_FACTOR_SUM \
((VCNL36825T_FORCED_FACTOR_TIME_TO_TRIGGER + VCNL36825T_FORCED_FACTOR_DC_KILL_AMBIENT + \
VCNL36825T_FORCED_FACTOR_MEASUREMENT + VCNL36825T_FORCED_FACTOR_SHUTDOWN) * \
VCNL36825T_FORCED_FACTOR_SCALE)
enum vcnl36825t_operation_mode {
VCNL36825T_OPERATION_MODE_AUTO,
VCNL36825T_OPERATION_MODE_FORCE,
};
enum vcnl36825t_measurement_period {
VCNL36825T_MEAS_PERIOD_10MS,
VCNL36825T_MEAS_PERIOD_20MS,
VCNL36825T_MEAS_PERIOD_40MS,
VCNL36825T_MEAS_PERIOD_80MS,
VCNL36825T_MEAS_PERIOD_160MS,
VCNL36825T_MEAS_PERIOD_320MS,
};
enum vcnl36825t_proximity_integration_time {
VCNL36825T_PROXIMITY_INTEGRATION_1T,
VCNL36825T_PROXIMITY_INTEGRATION_2T,
VCNL36825T_PROXIMITY_INTEGRATION_4T,
VCNL36825T_PROXIMITY_INTEGRATION_8T,
};
enum vcnl36825t_proximity_integration_duration {
VCNL36825T_PROXIMITY_INTEGRATION_DURATION_25us,
VCNL36825T_PROXIMITY_INTEGRATION_DURATION_50us,
};
enum vcnl36825t_multi_pulse {
VCNL38652T_MULTI_PULSE_1,
VCNL38652T_MULTI_PULSE_2,
VCNL38652T_MULTI_PULSE_4,
VCNL38652T_MULTI_PULSE_8,
};
enum vcnl38625t_laser_current {
VCNL36825T_LASER_CURRENT_10MS,
VCNL36825T_LASER_CURRENT_12MS,
VCNL36825T_LASER_CURRENT_14MS,
VCNL36825T_LASER_CURRENT_16MS,
VCNL36825T_LASER_CURRENT_18MS,
VCNL36825T_LASER_CURRENT_20MS,
};
struct vcnl36825t_config {
struct i2c_dt_spec i2c;
enum vcnl36825t_operation_mode operation_mode;
enum vcnl36825t_measurement_period period;
enum vcnl36825t_proximity_integration_time proximity_it;
enum vcnl36825t_proximity_integration_duration proximity_itb;
enum vcnl36825t_multi_pulse multi_pulse;
bool low_power;
bool high_gain;
enum vcnl38625t_laser_current laser_current;
bool high_dynamic_output;
bool sunlight_cancellation;
};
struct vcnl36825t_data {
uint16_t proximity;
int meas_timeout_us; /** wait time for finished measurement for "forced" operation mode */
};
#endif
``` | /content/code_sandbox/drivers/sensor/vishay/vcnl36825t/vcnl36825t.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,008 |
```unknown
# VCNL36825T Proximity Sensor configuration options
config VCNL36825T
bool "VCNL36825T Proximity Sensor"
default y
depends on DT_HAS_VISHAY_VCNL36825T_ENABLED
select I2C
help
Enable driver for VCNL36825T sensors.
``` | /content/code_sandbox/drivers/sensor/vishay/vcnl36825t/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```unknown
# F75303 temperature sensor configuration options
config F75303
bool "F75303 Temperature Sensor"
default y
depends on DT_HAS_FINTEK_F75303_ENABLED
select I2C
help
Enable the driver for Fintek F75303 Temperature Sensor.
This device has three temperature channels - one local (on-chip),
and two remote.
config EMUL_F75303
bool "Emulator for F75303"
default y
depends on F75303
depends on EMUL
help
Enable the hardware emulator for F75303 Temperature Sensor.
``` | /content/code_sandbox/drivers/sensor/f75303/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 126 |
```c
/*
*
*/
#define DT_DRV_COMPAT vishay_vcnl36825t
#include "vcnl36825t.h"
#include <stdlib.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
LOG_MODULE_REGISTER(VCNL36825T, CONFIG_SENSOR_LOG_LEVEL);
static int vcnl36825t_read(const struct i2c_dt_spec *spec, uint8_t reg_addr, uint16_t *value)
{
uint8_t rx_buf[2];
int rc;
rc = i2c_write_read_dt(spec, ®_addr, sizeof(reg_addr), rx_buf, sizeof(rx_buf));
if (rc < 0) {
return rc;
}
*value = sys_get_le16(rx_buf);
return 0;
}
static int vcnl36825t_write(const struct i2c_dt_spec *spec, uint8_t reg_addr, uint16_t value)
{
uint8_t tx_buf[3] = {reg_addr};
sys_put_le16(value, &tx_buf[1]);
return i2c_write_dt(spec, tx_buf, sizeof(tx_buf));
}
static int vcnl36825t_update(const struct i2c_dt_spec *spec, uint8_t reg_addr, uint16_t mask,
uint16_t value)
{
int rc;
uint16_t old_value, new_value;
rc = vcnl36825t_read(spec, reg_addr, &old_value);
if (rc < 0) {
return rc;
}
new_value = (old_value & ~mask) | (value & mask);
if (new_value == old_value) {
return 0;
}
return vcnl36825t_write(spec, reg_addr, new_value);
}
#if CONFIG_PM_DEVICE
static int vcnl36825t_pm_action(const struct device *dev, enum pm_device_action action)
{
const struct vcnl36825t_config *config = dev->config;
int rc;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF1, VCNL36825T_PS_ON_MSK,
VCNL36825T_PS_ON);
if (rc < 0) {
return rc;
}
if (config->low_power) {
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF4,
VCNL36825T_PS_LPEN_MSK, VCNL36825T_PS_LPEN_ENABLED);
if (rc < 0) {
return rc;
}
}
if (config->operation_mode == VCNL36825T_OPERATION_MODE_AUTO) {
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF3,
VCNL36825T_PS_AF_MSK, VCNL36825T_PS_AF_AUTO);
if (rc < 0) {
return rc;
}
}
k_usleep(VCNL36825T_POWER_UP_US);
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF2, VCNL36825T_PS_ST_MSK,
VCNL36825T_PS_ST_START);
if (rc < 0) {
return rc;
}
break;
case PM_DEVICE_ACTION_SUSPEND:
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF2, VCNL36825T_PS_ST_MSK,
VCNL36825T_PS_ST_STOP);
if (rc < 0) {
return rc;
}
if (config->operation_mode == VCNL36825T_OPERATION_MODE_AUTO) {
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF3,
VCNL36825T_PS_AF_MSK, VCNL36825T_PS_AF_FORCE);
if (rc < 0) {
return rc;
}
}
/* unset LPEN-bit if active, otherwise high current draw can be observed */
if (config->low_power) {
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF4,
VCNL36825T_PS_LPEN_MSK, VCNL36825T_PS_LPEN_DISABLED);
if (rc < 0) {
return rc;
}
}
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF1, VCNL36825T_PS_ON_MSK,
VCNL36825T_PS_OFF);
if (rc < 0) {
return rc;
}
break;
default:
LOG_ERR("action %d not supported", (int)action);
return -ENOTSUP;
}
return 0;
}
#endif
static int vcnl36825t_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct vcnl36825t_config *config = dev->config;
struct vcnl36825t_data *data = dev->data;
int rc;
#if CONFIG_PM_DEVICE
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return -EBUSY;
}
#endif
switch (chan) {
case SENSOR_CHAN_ALL:
case SENSOR_CHAN_PROX:
if (config->operation_mode == VCNL36825T_OPERATION_MODE_FORCE) {
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF3,
VCNL36825T_PS_TRIG_MSK, VCNL36825T_PS_TRIG_ONCE);
if (rc < 0) {
LOG_ERR("could not trigger proximity measurement %d", rc);
return rc;
}
k_usleep(data->meas_timeout_us);
}
rc = vcnl36825t_read(&config->i2c, VCNL36825T_REG_PS_DATA, &data->proximity);
if (rc < 0) {
LOG_ERR("could not fetch proximity measurement %d", rc);
return rc;
}
break;
default:
LOG_ERR("invalid sensor channel");
return -EINVAL;
}
return 0;
}
static int vcnl36825t_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct vcnl36825t_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ALL:
case SENSOR_CHAN_PROX:
val->val1 = data->proximity & VCNL36825T_OS_DATA_MSK;
val->val2 = 0;
break;
default:
return -ENOTSUP;
}
return 0;
}
/**
* @brief helper function to configure the registers
*
* @param dev pointer to the VCNL36825T instance
*/
static int vcnl36825t_init_registers(const struct device *dev)
{
const struct vcnl36825t_config *config = dev->config;
struct vcnl36825t_data *data = dev->data;
int rc;
uint16_t reg_value;
/* reset registers as defined by the datasheet */
const uint16_t resetValues[][2] = {
{VCNL36825T_REG_PS_CONF1, VCNL36825T_CONF1_DEFAULT},
{VCNL36825T_REG_PS_CONF2, VCNL36825T_CONF2_DEFAULT},
{VCNL36825T_REG_PS_CONF3, VCNL36825T_CONF3_DEFAULT},
{VCNL36825T_REG_PS_THDL, VCNL36825T_THDL_DEFAULT},
{VCNL36825T_REG_PS_THDH, VCNL36825T_THDH_DEFAULT},
{VCNL36825T_REG_PS_CANC, VCNL36825T_CANC_DEFAULT},
{VCNL36825T_REG_PS_CONF4, VCNL36825T_CONF4_DEFAULT},
};
for (size_t i = 0; i < ARRAY_SIZE(resetValues); ++i) {
vcnl36825t_write(&config->i2c, resetValues[i][0], resetValues[i][1]);
}
data->meas_timeout_us = 1;
/* PS_CONF1 */
reg_value = 0x01; /* must be set according to datasheet */
reg_value |= VCNL36825T_PS_ON;
rc = vcnl36825t_write(&config->i2c, VCNL36825T_REG_PS_CONF1, reg_value);
if (rc < 0) {
LOG_ERR("I2C for PS_ON returned %d", rc);
return -EIO;
}
reg_value |= VCNL36825T_PS_CAL;
reg_value |= 1 << 9; /* reserved, must be set by datasheet */
rc = vcnl36825t_write(&config->i2c, VCNL36825T_REG_PS_CONF1, reg_value);
if (rc < 0) {
LOG_ERR("I2C for PS_CAL returned %d", rc);
}
k_usleep(VCNL36825T_POWER_UP_US);
/* PS_CONF2 */
reg_value = 0;
switch (config->period) {
case VCNL36825T_MEAS_PERIOD_10MS:
reg_value |= VCNL36825T_PS_PERIOD_10MS;
break;
case VCNL36825T_MEAS_PERIOD_20MS:
reg_value |= VCNL36825T_PS_PERIOD_20MS;
break;
case VCNL36825T_MEAS_PERIOD_40MS:
reg_value |= VCNL36825T_PS_PERIOD_40MS;
break;
case VCNL36825T_MEAS_PERIOD_80MS:
__fallthrough;
default:
reg_value |= VCNL36825T_PS_PERIOD_80MS;
break;
}
reg_value |= VCNL36825T_PS_PERS_1;
reg_value |= VCNL36825T_PS_ST_STOP;
switch (config->proximity_it) {
case VCNL36825T_PROXIMITY_INTEGRATION_1T:
reg_value |= VCNL36825T_PS_IT_1T;
data->meas_timeout_us *= 1;
break;
case VCNL36825T_PROXIMITY_INTEGRATION_2T:
reg_value |= VCNL36825T_PS_IT_2T;
data->meas_timeout_us *= 2;
break;
case VCNL36825T_PROXIMITY_INTEGRATION_4T:
reg_value |= VCNL36825T_PS_IT_4T;
data->meas_timeout_us *= 4;
break;
case VCNL36825T_PROXIMITY_INTEGRATION_8T:
__fallthrough;
default:
reg_value |= VCNL36825T_PS_IT_8T;
data->meas_timeout_us *= 8;
break;
}
switch (config->multi_pulse) {
case VCNL38652T_MULTI_PULSE_1:
reg_value |= VCNL36825T_MPS_PULSES_1;
break;
case VCNL38652T_MULTI_PULSE_2:
reg_value |= VCNL36825T_MPS_PULSES_2;
break;
case VCNL38652T_MULTI_PULSE_4:
reg_value |= VCNL36825T_MPS_PULSES_4;
break;
case VCNL38652T_MULTI_PULSE_8:
__fallthrough;
default:
reg_value |= VCNL36825T_MPS_PULSES_8;
break;
}
switch (config->proximity_itb) {
case VCNL36825T_PROXIMITY_INTEGRATION_DURATION_25us:
reg_value |= VCNL36825T_PS_ITB_25us;
data->meas_timeout_us *= 25;
break;
case VCNL36825T_PROXIMITY_INTEGRATION_DURATION_50us:
__fallthrough;
default:
reg_value |= VCNL36825T_PS_ITB_50us;
data->meas_timeout_us *= 50;
break;
}
if (config->high_gain) {
reg_value |= VCNL36825T_PS_HG_HIGH;
}
rc = vcnl36825t_write(&config->i2c, VCNL36825T_REG_PS_CONF2, reg_value);
if (rc < 0) {
LOG_ERR("I2C for setting PS_CONF2 returned %d", rc);
return -EIO;
}
/* PS_CONF3 */
reg_value = 0;
if (config->operation_mode == VCNL36825T_OPERATION_MODE_FORCE) {
reg_value |= VCNL36825T_PS_AF_FORCE;
}
switch (config->laser_current) {
case VCNL36825T_LASER_CURRENT_10MS:
reg_value |= VCNL36825T_PS_I_VCSEL_10MA;
break;
case VCNL36825T_LASER_CURRENT_12MS:
reg_value |= VCNL36825T_PS_I_VCSEL_12MA;
break;
case VCNL36825T_LASER_CURRENT_14MS:
reg_value |= VCNL36825T_PS_I_VCSEL_14MA;
break;
case VCNL36825T_LASER_CURRENT_16MS:
reg_value |= VCNL36825T_PS_I_VCSEL_16MA;
break;
case VCNL36825T_LASER_CURRENT_18MS:
reg_value |= VCNL36825T_PS_I_VCSEL_18MA;
break;
case VCNL36825T_LASER_CURRENT_20MS:
__fallthrough;
default:
reg_value |= VCNL36825T_PS_I_VCSEL_20MA;
break;
}
if (config->high_dynamic_output) {
reg_value |= VCNL36825T_PS_HD_16BIT;
}
if (config->sunlight_cancellation) {
reg_value |= VCNL36825T_PS_SC_ENABLED;
}
rc = vcnl36825t_write(&config->i2c, VCNL36825T_REG_PS_CONF3, reg_value);
if (rc < 0) {
LOG_ERR("I2C for setting PS_CONF3 returned %d", rc);
return -EIO;
}
/* PS_CONF4 */
reg_value = 0;
if (config->low_power) {
reg_value |= VCNL36825T_PS_LPEN_ENABLED;
}
switch (config->period) {
case VCNL36825T_MEAS_PERIOD_40MS:
reg_value |= VCNL36825T_PS_LPPER_40MS;
break;
case VCNL36825T_MEAS_PERIOD_80MS:
reg_value |= VCNL36825T_PS_LPPER_80MS;
break;
case VCNL36825T_MEAS_PERIOD_160MS:
reg_value |= VCNL36825T_PS_LPPER_160MS;
break;
case VCNL36825T_MEAS_PERIOD_320MS:
__fallthrough;
default:
reg_value |= VCNL36825T_PS_LPPER_320MS;
break;
}
rc = vcnl36825t_write(&config->i2c, VCNL36825T_REG_PS_CONF4, reg_value);
if (rc < 0) {
LOG_ERR("I2C for setting PS_CONF4 returned %d", rc);
return -EIO;
}
/* calculate measurement timeout
* Note: always add 1 to prevent corner case losses due to precision.
*/
data->meas_timeout_us =
(data->meas_timeout_us * VCNL36825T_FORCED_FACTOR_SUM) /
(VCNL36825T_FORCED_FACTOR_SCALE) +
1;
return 0;
}
static int vcnl36825t_init(const struct device *dev)
{
const struct vcnl36825t_config *config = dev->config;
int rc;
uint16_t reg_value;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_ERR("device is not ready");
return -ENODEV;
}
rc = vcnl36825t_read(&config->i2c, VCNL36825T_REG_DEV_ID, ®_value);
if (rc < 0) {
LOG_ERR("could not read device id");
return rc;
}
if ((reg_value & VCNL36825T_ID_MSK) != VCNL36825T_DEVICE_ID) {
LOG_ERR("incorrect device id (%d)", reg_value);
return -EIO;
}
LOG_INF("version code: 0x%X",
(unsigned int)FIELD_GET(VCNL36825T_VERSION_CODE_MSK, reg_value));
rc = vcnl36825t_init_registers(dev);
if (rc < 0) {
return rc;
}
rc = vcnl36825t_update(&config->i2c, VCNL36825T_REG_PS_CONF2, VCNL36825T_PS_ST_MSK,
VCNL36825T_PS_ST_START);
if (rc < 0) {
LOG_ERR("error starting measurement");
return -EIO;
}
return 0;
}
static const struct sensor_driver_api vcnl36825t_driver_api = {
.sample_fetch = vcnl36825t_sample_fetch,
.channel_get = vcnl36825t_channel_get,
};
#define VCNL36825T_DEFINE(inst) \
BUILD_ASSERT(!DT_INST_PROP(inst, low_power) || (DT_INST_PROP(inst, measurement_period) >= \
VCNL36825T_PS_LPPER_VALUE_MIN_MS), \
"measurement-period must be greater/equal 40 ms in low-power mode"); \
BUILD_ASSERT( \
DT_INST_PROP(inst, low_power) || (DT_INST_PROP(inst, measurement_period) <= \
VCNL36825T_PS_PERIOD_VALUE_MAX_MS), \
"measurement-period must be less/equal 80 ms with deactivated low-power mode"); \
BUILD_ASSERT(!DT_INST_PROP(inst, low_power) || (DT_INST_ENUM_IDX(inst, operation_mode) == \
VCNL36825T_OPERATION_MODE_AUTO), \
"operation-mode \"force\" only available if low-power mode deactivated"); \
static struct vcnl36825t_data vcnl36825t_data_##inst; \
static const struct vcnl36825t_config vcnl36825t_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.operation_mode = DT_INST_ENUM_IDX(inst, operation_mode), \
.period = DT_INST_ENUM_IDX(inst, measurement_period), \
.proximity_it = DT_INST_ENUM_IDX(inst, proximity_it), \
.proximity_itb = DT_INST_ENUM_IDX(inst, proximity_itb), \
.multi_pulse = DT_INST_ENUM_IDX(inst, multi_pulse), \
.low_power = DT_INST_PROP(inst, low_power), \
.high_gain = DT_INST_PROP(inst, high_gain), \
.laser_current = DT_INST_ENUM_IDX(inst, laser_current), \
.high_dynamic_output = DT_INST_PROP(inst, high_dynamic_output), \
.sunlight_cancellation = DT_INST_PROP(inst, sunlight_cancellation), \
}; \
IF_ENABLED(CONFIG_PM_DEVICE, (PM_DEVICE_DT_INST_DEFINE(inst, vcnl36825t_pm_action))); \
SENSOR_DEVICE_DT_INST_DEFINE( \
inst, vcnl36825t_init, \
COND_CODE_1(CONFIG_PM_DEVICE, (PM_DEVICE_DT_INST_GET(inst)), (NULL)), \
&vcnl36825t_data_##inst, &vcnl36825t_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &vcnl36825t_driver_api);
DT_INST_FOREACH_STATUS_OKAY(VCNL36825T_DEFINE)
``` | /content/code_sandbox/drivers/sensor/vishay/vcnl36825t/vcnl36825t.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,473 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_F75303_F75303_H_
#define ZEPHYR_DRIVERS_SENSOR_F75303_F75303_H_
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
#define F75303_LOCAL_TEMP_H 0x00
#define F75303_REMOTE1_TEMP_H 0x01
#define F75303_REMOTE1_TEMP_L 0x10
#define F75303_REMOTE2_TEMP_H 0x23
#define F75303_REMOTE2_TEMP_L 0x24
#define F75303_LOCAL_TEMP_L 0x29
struct f75303_data {
uint16_t sample_local;
uint16_t sample_remote1;
uint16_t sample_remote2;
};
struct f75303_config {
struct i2c_dt_spec i2c;
};
#endif
``` | /content/code_sandbox/drivers/sensor/f75303/f75303.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 175 |
```c
/*
*/
#define DT_DRV_COMPAT fintek_f75303
#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/drivers/sensor/f75303.h>
#include "f75303.h"
LOG_MODULE_DECLARE(F75303, CONFIG_SENSOR_LOG_LEVEL);
#define NUM_REGS 128
struct f75303_emul_data {
uint8_t reg[NUM_REGS];
};
struct f75303_emul_cfg {
};
static void f75303_emul_set_reg(const struct emul *target, uint8_t reg, uint8_t val)
{
struct f75303_emul_data *data = target->data;
__ASSERT_NO_MSG(reg < NUM_REGS);
data->reg[reg] = val;
}
static uint8_t f75303_emul_get_reg(const struct emul *target, uint8_t reg)
{
struct f75303_emul_data *data = target->data;
__ASSERT_NO_MSG(reg < NUM_REGS);
return data->reg[reg];
}
static void f75303_emul_reset(const struct emul *target)
{
struct f75303_emul_data *data = target->data;
memset(data->reg, 0, NUM_REGS);
}
static int f75303_emul_transfer_i2c(const struct emul *target, struct i2c_msg *msgs,
int num_msgs, int addr)
{
/* Largely copied from emul_bmi160.c */
unsigned int val;
int reg;
__ASSERT_NO_MSG(msgs && num_msgs);
i2c_dump_msgs_rw(target->dev, msgs, num_msgs, addr, false);
switch (num_msgs) {
case 2:
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;
}
reg = msgs->buf[0];
/* Now process the 'read' part of the message */
msgs++;
if (msgs->flags & I2C_MSG_READ) {
switch (msgs->len) {
case 1:
val = f75303_emul_get_reg(target, reg);
msgs->buf[0] = val;
break;
default:
LOG_ERR("Unexpected msg1 length %d", msgs->len);
return -EIO;
}
} else {
if (msgs->len != 1) {
LOG_ERR("Unexpected msg1 length %d", msgs->len);
}
f75303_emul_set_reg(target, reg, msgs->buf[0]);
}
break;
default:
LOG_ERR("Invalid number of messages: %d", num_msgs);
return -EIO;
}
return 0;
}
static int f75303_emul_init(const struct emul *target, const struct device *parent)
{
f75303_emul_reset(target);
return 0;
}
static int f75303_emul_set_channel(const struct emul *target, struct sensor_chan_spec ch,
const q31_t *value, int8_t shift)
{
struct f75303_emul_data *data = target->data;
int64_t scaled_value;
int32_t millicelsius;
int32_t reg_value;
uint8_t reg_h, reg_l;
switch ((int32_t)ch.chan_type) {
case SENSOR_CHAN_AMBIENT_TEMP:
reg_h = F75303_LOCAL_TEMP_H;
reg_l = F75303_LOCAL_TEMP_L;
break;
case SENSOR_CHAN_F75303_REMOTE1:
reg_h = F75303_REMOTE1_TEMP_H;
reg_l = F75303_REMOTE1_TEMP_L;
break;
case SENSOR_CHAN_F75303_REMOTE2:
reg_h = F75303_REMOTE2_TEMP_H;
reg_l = F75303_REMOTE2_TEMP_L;
break;
default:
return -ENOTSUP;
}
scaled_value = (int64_t)*value << shift;
millicelsius = scaled_value * 1000 / ((int64_t)INT32_MAX + 1);
reg_value = CLAMP(millicelsius / 125, 0, 0x7ff);
data->reg[reg_h] = reg_value >> 3;
data->reg[reg_l] = (reg_value & 0x7) << 5;
return 0;
}
static int f75303_emul_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 (ch.chan_type != SENSOR_CHAN_AMBIENT_TEMP &&
ch.chan_type != (enum sensor_channel)SENSOR_CHAN_F75303_REMOTE1 &&
ch.chan_type != (enum sensor_channel)SENSOR_CHAN_F75303_REMOTE2) {
return -ENOTSUP;
}
*shift = 8;
*lower = 0;
*upper = (int64_t)(255.875 * ((int64_t)INT32_MAX + 1)) >> *shift;
*epsilon = (int64_t)(0.125 * ((int64_t)INT32_MAX + 1)) >> *shift;
return 0;
}
static const struct i2c_emul_api f75303_emul_api_i2c = {
.transfer = f75303_emul_transfer_i2c,
};
static const struct emul_sensor_driver_api f75303_emul_api_sensor = {
.set_channel = f75303_emul_set_channel,
.get_sample_range = f75303_emul_get_sample_range,
};
#define F75303_EMUL(n) \
const struct f75303_emul_cfg f75303_emul_cfg_##n; \
struct f75303_emul_data f75303_emul_data_##n; \
EMUL_DT_INST_DEFINE(n, f75303_emul_init, &f75303_emul_data_##n, \
&f75303_emul_cfg_##n, &f75303_emul_api_i2c, \
&f75303_emul_api_sensor);
DT_INST_FOREACH_STATUS_OKAY(F75303_EMUL)
``` | /content/code_sandbox/drivers/sensor/f75303/f75303_emul.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,386 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/aosong/ags10/Kconfig"
source "drivers/sensor/aosong/dht/Kconfig"
source "drivers/sensor/aosong/dht20/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/aosong/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 63 |
```c
/*
*
*/
#define DT_DRV_COMPAT fintek_f75303
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/pm/device_runtime.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor/f75303.h>
#include "f75303.h"
#define F75303_SAMPLE_INT_SHIFT 3
#define F75303_SAMPLE_FRAC_MASK GENMASK(2, 0)
#define F75303_SAMPLE_MICROCELSIUS_PER_BIT 125000
LOG_MODULE_REGISTER(F75303, CONFIG_SENSOR_LOG_LEVEL);
static int f75303_fetch(const struct i2c_dt_spec *i2c,
uint8_t off_h, uint8_t off_l, uint16_t *sample)
{
uint8_t val_h;
uint8_t val_l;
int res;
res = i2c_reg_read_byte_dt(i2c, off_h, &val_h);
if (res) {
return res;
}
res = i2c_reg_read_byte_dt(i2c, off_l, &val_l);
if (res) {
return res;
}
*sample = val_h << 3 | val_l >> 5;
return 0;
}
static int f75303_fetch_local(const struct device *dev)
{
struct f75303_data *data = dev->data;
const struct f75303_config *config = dev->config;
return f75303_fetch(&config->i2c,
F75303_LOCAL_TEMP_H,
F75303_LOCAL_TEMP_L,
&data->sample_local);
}
static int f75303_fetch_remote1(const struct device *dev)
{
struct f75303_data *data = dev->data;
const struct f75303_config *config = dev->config;
return f75303_fetch(&config->i2c,
F75303_REMOTE1_TEMP_H,
F75303_REMOTE1_TEMP_L,
&data->sample_remote1);
}
static int f75303_fetch_remote2(const struct device *dev)
{
struct f75303_data *data = dev->data;
const struct f75303_config *config = dev->config;
return f75303_fetch(&config->i2c,
F75303_REMOTE2_TEMP_H,
F75303_REMOTE2_TEMP_L,
&data->sample_remote2);
}
static int f75303_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
enum pm_device_state pm_state;
int res;
(void)pm_device_state_get(dev, &pm_state);
if (pm_state != PM_DEVICE_STATE_ACTIVE) {
return -EIO;
}
switch ((uint32_t)chan) {
case SENSOR_CHAN_ALL:
res = f75303_fetch_local(dev);
if (res) {
break;
}
res = f75303_fetch_remote1(dev);
if (res) {
break;
}
res = f75303_fetch_remote2(dev);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
return f75303_fetch_local(dev);
case SENSOR_CHAN_F75303_REMOTE1:
return f75303_fetch_remote1(dev);
case SENSOR_CHAN_F75303_REMOTE2:
return f75303_fetch_remote2(dev);
default:
return -ENOTSUP;
}
return res;
}
static int f75303_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct f75303_data *data = dev->data;
uint16_t sample;
switch ((uint32_t)chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
sample = data->sample_local;
break;
case SENSOR_CHAN_F75303_REMOTE1:
sample = data->sample_remote1;
break;
case SENSOR_CHAN_F75303_REMOTE2:
sample = data->sample_remote2;
break;
default:
return -ENOTSUP;
}
/*
* The reading is given in steps of 0.125 degrees celsius, i.e. the
* temperature in degrees celsius is equal to sample / 8.
*/
val->val1 = sample >> F75303_SAMPLE_INT_SHIFT;
val->val2 = (sample & F75303_SAMPLE_FRAC_MASK) * F75303_SAMPLE_MICROCELSIUS_PER_BIT;
return 0;
}
static const struct sensor_driver_api f75303_driver_api = {
.sample_fetch = f75303_sample_fetch,
.channel_get = f75303_channel_get,
};
static int f75303_init(const struct device *dev)
{
const struct f75303_config *config = dev->config;
int res = 0;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_ERR("I2C device not ready");
return -ENODEV;
}
#ifdef CONFIG_PM_DEVICE_RUNTIME
pm_device_init_suspended(dev);
res = pm_device_runtime_enable(dev);
if (res) {
LOG_ERR("Failed to enable runtime power management");
}
#endif
return res;
}
#ifdef CONFIG_PM_DEVICE
static int f75303_pm_action(const struct device *dev, enum pm_device_action action)
{
switch (action) {
case PM_DEVICE_ACTION_TURN_ON:
case PM_DEVICE_ACTION_RESUME:
case PM_DEVICE_ACTION_TURN_OFF:
case PM_DEVICE_ACTION_SUSPEND:
return 0;
default:
return -ENOTSUP;
}
}
#endif
#define F75303_INST(inst) \
static struct f75303_data f75303_data_##inst; \
static const struct f75303_config f75303_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
PM_DEVICE_DT_INST_DEFINE(inst, f75303_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, f75303_init, PM_DEVICE_DT_INST_GET(inst), \
&f75303_data_##inst, &f75303_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &f75303_driver_api);
DT_INST_FOREACH_STATUS_OKAY(F75303_INST)
``` | /content/code_sandbox/drivers/sensor/f75303/f75303.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,313 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_DHT_DHT_H_
#define ZEPHYR_DRIVERS_SENSOR_DHT_DHT_H_
#include <zephyr/device.h>
#define DHT_START_SIGNAL_DURATION 18000
#define DHT_SIGNAL_MAX_WAIT_DURATION 100
#define DHT_DATA_BITS_NUM 40
struct dht_data {
uint8_t sample[4];
};
struct dht_config {
struct gpio_dt_spec dio_gpio;
};
#endif
``` | /content/code_sandbox/drivers/sensor/aosong/dht/dht.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 100 |
```unknown
# DHT Temperature and Humidity Sensor configuration options
menuconfig DHT
bool "DHT Temperature and Humidity Sensor"
default y
depends on DT_HAS_AOSONG_DHT_ENABLED
depends on GPIO
help
Enable driver for the DHT temperature and humidity sensor family.
if DHT
config DHT_LOCK_IRQS
bool "Lock IRQs for sensor measurement"
help
Locks IRQs when taking sensor readings, this greatly improves the chances of getting a
reading successfully from the sensor at the cost of delayed interrupt servicing (e.g.
Bluetooth). Note that other systems might need to be adjusted to account for this.
endif # DHT
``` | /content/code_sandbox/drivers/sensor/aosong/dht/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 143 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_INCLUDE_DRIVERS_SENSOR_AGS10_H_
#define ZEPHYR_INCLUDE_DRIVERS_SENSOR_AGS10_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#define AGS10_CMD_DATA_ACQUISITION 0x00
#define AGS10_CMD_ZERO_POINT_CALIBRATION 0x01
#define AGS10_CMD_READ_VERSION 0x11
#define AGS10_CMD_READ_RESISTANCE 0x20
#define AGS10_CMD_MODIFY_SLAVE_ADDRESS 0x21
#define AGS10_REG_ZERO_POINT_CALIBRATION_RESET 0xFFFF /* Reset to the factory value */
#define AGS10_REG_ZERO_POINT_CALIBRATION_SET 0x0000 /* Set sensor resistance to zero-point */
#define AGS10_REG_STATUS_NRDY_READY 0x00 /* Device is ready */
#define AGS10_REG_STATUS_CH_PPB 0x00 /* Unit is PPB */
#define AGS10_MSK_STATUS 0x0F
#define AGS10_MSK_STATUS_NRDY 0x01
#define AGS10_MSK_STATUS_CH 0x0E
struct ags10_config {
struct i2c_dt_spec bus;
};
struct ags10_data {
uint32_t tvoc_ppb;
uint8_t status;
uint32_t version;
};
#ifdef __cplusplus
}
#endif
#endif /* ZEPHYR_INCLUDE_DRIVERS_SENSOR_AGS10_H_ */
``` | /content/code_sandbox/drivers/sensor/aosong/ags10/ags10.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 328 |
```c
/*
*
*/
#define DT_DRV_COMPAT aosong_dht
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <string.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include "dht.h"
LOG_MODULE_REGISTER(DHT, CONFIG_SENSOR_LOG_LEVEL);
/**
* @brief Measure duration of signal send by sensor
*
* @param drv_data Pointer to the driver data structure
* @param active Whether current signal is active
*
* @return duration in usec of signal being measured,
* -1 if duration exceeds DHT_SIGNAL_MAX_WAIT_DURATION
*/
static int8_t dht_measure_signal_duration(const struct device *dev,
bool active)
{
const struct dht_config *cfg = dev->config;
uint32_t elapsed_cycles;
uint32_t max_wait_cycles = (uint32_t)(
(uint64_t)DHT_SIGNAL_MAX_WAIT_DURATION *
(uint64_t)sys_clock_hw_cycles_per_sec() /
(uint64_t)USEC_PER_SEC
);
uint32_t start_cycles = k_cycle_get_32();
int rc;
do {
rc = gpio_pin_get_dt(&cfg->dio_gpio);
elapsed_cycles = k_cycle_get_32() - start_cycles;
if ((rc < 0)
|| (elapsed_cycles > max_wait_cycles)) {
return -1;
}
} while ((bool)rc == active);
return (uint64_t)elapsed_cycles *
(uint64_t)USEC_PER_SEC /
(uint64_t)sys_clock_hw_cycles_per_sec();
}
static int dht_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct dht_data *drv_data = dev->data;
const struct dht_config *cfg = dev->config;
int ret = 0;
int8_t signal_duration[DHT_DATA_BITS_NUM];
int8_t max_duration, min_duration, avg_duration;
uint8_t buf[5];
unsigned int i, j;
#if defined(CONFIG_DHT_LOCK_IRQS)
int lock;
#endif
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
/* assert to send start signal */
gpio_pin_set_dt(&cfg->dio_gpio, true);
#if defined(CONFIG_DHT_LOCK_IRQS)
lock = irq_lock();
#endif
k_busy_wait(DHT_START_SIGNAL_DURATION);
gpio_pin_set_dt(&cfg->dio_gpio, false);
/* switch to DIR_IN to read sensor signals */
gpio_pin_configure_dt(&cfg->dio_gpio, GPIO_INPUT);
/* wait for sensor active response */
if (dht_measure_signal_duration(dev, false) == -1) {
ret = -EIO;
goto cleanup;
}
/* read sensor response */
if (dht_measure_signal_duration(dev, true) == -1) {
ret = -EIO;
goto cleanup;
}
/* wait for sensor data start */
if (dht_measure_signal_duration(dev, false) == -1) {
ret = -EIO;
goto cleanup;
}
/* read sensor data */
for (i = 0U; i < DHT_DATA_BITS_NUM; i++) {
/* Active signal to indicate a new bit */
if (dht_measure_signal_duration(dev, true) == -1) {
ret = -EIO;
goto cleanup;
}
/* Inactive signal duration indicates bit value */
signal_duration[i] = dht_measure_signal_duration(dev, false);
if (signal_duration[i] == -1) {
ret = -EIO;
goto cleanup;
}
}
/*
* the datasheet says 20-40us HIGH signal duration for a 0 bit and
* 80us for a 1 bit; however, since dht_measure_signal_duration is
* not very precise, compute the threshold for deciding between a
* 0 bit and a 1 bit as the average between the minimum and maximum
* if the durations stored in signal_duration
*/
min_duration = signal_duration[0];
max_duration = signal_duration[0];
for (i = 1U; i < DHT_DATA_BITS_NUM; i++) {
if (min_duration > signal_duration[i]) {
min_duration = signal_duration[i];
}
if (max_duration < signal_duration[i]) {
max_duration = signal_duration[i];
}
}
avg_duration = ((int16_t)min_duration + (int16_t)max_duration) / 2;
/* store bits in buf */
j = 0U;
(void)memset(buf, 0, sizeof(buf));
for (i = 0U; i < DHT_DATA_BITS_NUM; i++) {
if (signal_duration[i] >= avg_duration) {
buf[j] = (buf[j] << 1) | 1;
} else {
buf[j] = buf[j] << 1;
}
if (i % 8 == 7U) {
j++;
}
}
/* verify checksum */
if (((buf[0] + buf[1] + buf[2] + buf[3]) & 0xFF) != buf[4]) {
LOG_DBG("Invalid checksum in fetched sample");
ret = -EIO;
} else {
memcpy(drv_data->sample, buf, 4);
}
cleanup:
#if defined(CONFIG_DHT_LOCK_IRQS)
irq_unlock(lock);
#endif
/* Switch to output inactive until next fetch. */
gpio_pin_configure_dt(&cfg->dio_gpio, GPIO_OUTPUT_INACTIVE);
return ret;
}
static int dht_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct dht_data *drv_data = dev->data;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_AMBIENT_TEMP
|| chan == SENSOR_CHAN_HUMIDITY);
/* see data calculation example from datasheet */
if (IS_ENABLED(DT_INST_PROP(0, dht22))) {
/*
* use both integral and decimal data bytes; resulted
* 16bit data has a resolution of 0.1 units
*/
int16_t raw_val, sign;
if (chan == SENSOR_CHAN_HUMIDITY) {
raw_val = (drv_data->sample[0] << 8)
+ drv_data->sample[1];
val->val1 = raw_val / 10;
val->val2 = (raw_val % 10) * 100000;
} else if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
raw_val = (drv_data->sample[2] << 8)
+ drv_data->sample[3];
sign = raw_val & 0x8000;
raw_val = raw_val & ~0x8000;
val->val1 = raw_val / 10;
val->val2 = (raw_val % 10) * 100000;
/* handle negative value */
if (sign) {
val->val1 = -val->val1;
val->val2 = -val->val2;
}
} else {
return -ENOTSUP;
}
} else {
/* use only integral data byte */
if (chan == SENSOR_CHAN_HUMIDITY) {
val->val1 = drv_data->sample[0];
val->val2 = 0;
} else if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
val->val1 = drv_data->sample[2];
val->val2 = 0;
} else {
return -ENOTSUP;
}
}
return 0;
}
static const struct sensor_driver_api dht_api = {
.sample_fetch = &dht_sample_fetch,
.channel_get = &dht_channel_get,
};
static int dht_init(const struct device *dev)
{
int rc = 0;
const struct dht_config *cfg = dev->config;
if (!gpio_is_ready_dt(&cfg->dio_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
rc = gpio_pin_configure_dt(&cfg->dio_gpio, GPIO_OUTPUT_INACTIVE);
return rc;
}
#define DHT_DEFINE(inst) \
static struct dht_data dht_data_##inst; \
\
static const struct dht_config dht_config_##inst = { \
.dio_gpio = GPIO_DT_SPEC_INST_GET(inst, dio_gpios), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, &dht_init, NULL, \
&dht_data_##inst, &dht_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &dht_api); \
DT_INST_FOREACH_STATUS_OKAY(DHT_DEFINE)
``` | /content/code_sandbox/drivers/sensor/aosong/dht/dht.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,925 |
```unknown
# AOSONG AGS10 TVOC sensor driver options.
config AGS10
bool "AOSONG AGS10 TVOC sensor"
default y
depends on DT_HAS_AOSONG_AGS10_ENABLED
select I2C
help
Enable AOSONG AGS10 TVOC sensor driver.
``` | /content/code_sandbox/drivers/sensor/aosong/ags10/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 69 |
```c
/*
*
*/
#define DT_DRV_COMPAT aosong_ags10
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/crc.h>
#include "ags10.h"
LOG_MODULE_REGISTER(AGS10, CONFIG_SENSOR_LOG_LEVEL);
#define AGS10_MAX_PAYLOAD_SIZE 5U /* Payload will be max 4 bytes + CRC (datasheet 3.1) */
static int ags10_read(const struct device *dev, uint8_t cmd, uint8_t *data, uint8_t rx_bytes)
{
if (rx_bytes > AGS10_MAX_PAYLOAD_SIZE) {
return -EINVAL;
}
const struct ags10_config *conf = dev->config;
uint8_t recv_buf[AGS10_MAX_PAYLOAD_SIZE] = {0};
int ret = i2c_write_read_dt(&conf->bus, &cmd, sizeof(cmd), &recv_buf, rx_bytes);
if (ret < 0) {
return ret;
}
memcpy(data, recv_buf, rx_bytes);
return 0;
}
static int ags10_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
if (chan != SENSOR_CHAN_VOC && chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
struct ags10_data *data = dev->data;
int ret = -ENOTSUP;
uint8_t recv_buf[5] = {0};
ret = ags10_read(dev, AGS10_CMD_DATA_ACQUISITION, recv_buf, 5);
if (ret == 0) {
/* If CRC is valid and data is valid too */
if (crc8(&recv_buf[0], 4, 0x31, 0xFF, false) == recv_buf[4] &&
((recv_buf[0] & AGS10_MSK_STATUS) == AGS10_REG_STATUS_NRDY_READY)) {
data->status = recv_buf[0] & AGS10_MSK_STATUS;
data->tvoc_ppb = sys_get_be24(&recv_buf[1]);
return 0;
}
LOG_WRN("Bad CRC or data not ready");
ret = -EIO;
}
return ret;
}
static int ags10_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ags10_data *data = dev->data;
if (chan == SENSOR_CHAN_VOC) {
val->val1 = data->tvoc_ppb;
} else {
return -ENOTSUP;
}
val->val2 = 0;
return 0;
}
static int ags10_init(const struct device *dev)
{
const struct ags10_config *conf = dev->config;
struct ags10_data *data = dev->data;
int ret;
if (!i2c_is_ready_dt(&conf->bus)) {
LOG_ERR("Device not ready");
return -ENODEV;
}
/* Set initial data values */
data->tvoc_ppb = 0;
data->status = 0xFF;
data->version = 0;
/* Read firmware version and check CRC */
uint8_t recv_buf[5] = {0};
ret = ags10_read(dev, AGS10_CMD_READ_VERSION, recv_buf, 5);
/* Bytes 0 to 2 are reserved, byte 3 is version, byte 4 is CRC */
if (ret == 0 && crc8(&recv_buf[0], 4, 0x31, 0xFF, false) == recv_buf[4]) {
data->version = recv_buf[3];
LOG_DBG("Sensor detected");
} else if (ret != 0) {
LOG_ERR("No reply from sensor");
ret = -ENODEV;
} else {
LOG_WRN("Bad CRC");
ret = -EIO;
}
return ret;
}
static const struct sensor_driver_api ags10_api = {.sample_fetch = ags10_sample_fetch,
.channel_get = ags10_channel_get};
#define AGS10_INIT(n) \
static struct ags10_data ags10_data_##n; \
\
static const struct ags10_config ags10_config_##n = { \
.bus = I2C_DT_SPEC_INST_GET(n), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, ags10_init, NULL, &ags10_data_##n, &ags10_config_##n, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &ags10_api);
DT_INST_FOREACH_STATUS_OKAY(AGS10_INIT)
``` | /content/code_sandbox/drivers/sensor/aosong/ags10/ags10.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,009 |
```unknown
# AOSONG DHT20 temperature and humidity sensor configuration options
# This driver can also be used for AHT20 or AM2301B which seem to be the same sensor
config DHT20
bool "DHT20 / AHT20 / AM2301B Temperature and Humidity Sensor"
default y
depends on DT_HAS_AOSONG_DHT20_ENABLED \
|| DT_HAS_AOSONG_AHT20_ENABLED \
|| DT_HAS_AOSONG_AM2301B_ENABLED
select I2C
help
Enable driver for DHT20 / AHT20 / AM2301B temperature and humidity sensors.
if DHT20
config DHT20_CRC
bool "Use CRC error detection"
default n
select CRC
help
Verify CRC byte in RX data
endif # DHT20
``` | /content/code_sandbox/drivers/sensor/aosong/dht20/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 178 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#if defined(CONFIG_DHT20_CRC)
#include <zephyr/sys/crc.h>
#endif
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#define DHT20_STATUS_REGISTER 0x71
#define DHT20_STATUS_MASK (BIT(0) | BIT(1))
#define DHT20_STATUS_MASK_CHECK 0x18
#define DHT20_STATUS_MASK_POLL_STATE 0x80
#define DHT20_MASK_RESET_REGISTER 0xB0
#define DHT20_TRIGGER_MEASUREMENT_COMMAND 0xAC, 0x33, 0x00
#define DHT20_TRIGGER_MEASUREMENT_BUFFER_LENGTH 3
/** CRC polynom (1 + X^4 + X^5 + X^8) */
#define DHT20_CRC_POLYNOM (BIT(0) | BIT(4) | BIT(5))
/*
* According to datasheet 7.4
* Reset register 0x1B, 0x1C and 0x1E
*/
#define DHT20_RESET_REGISTER_0 0x1B
#define DHT20_RESET_REGISTER_1 0x1C
#define DHT20_RESET_REGISTER_2 0x1E
/** Length of the buffer used for data measurement */
#define DHT20_MEASUREMENT_BUFFER_LENGTH 7
/** Wait some time after reset sequence (in ms) */
#define DHT20_RESET_SEQUENCE_WAIT_MS 10
/** Wait after power on (in ms) */
#define DHT20_POWER_ON_WAIT_MS 75
/** Wait during polling after power on (in ms) */
#define DHT20_INIT_POLL_STATUS_WAIT_MS 5
LOG_MODULE_REGISTER(DHT20, CONFIG_SENSOR_LOG_LEVEL);
struct dht20_config {
struct i2c_dt_spec bus;
};
struct dht20_data {
uint32_t t_sample;
uint32_t rh_sample;
};
/**
* @brief Read status register
*
* @param dev Pointer to the sensor device
* @param[out] status Pointer to which the status will be stored
* @return 0 if successful
*/
static inline int read_status(const struct device *dev, uint8_t *status)
{
const struct dht20_config *cfg = dev->config;
int rc;
uint8_t tx_buf[] = {DHT20_STATUS_REGISTER};
uint8_t rx_buf[1];
/* Write DHT20_STATUS_REGISTER then read to get status */
rc = i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
if (rc < 0) {
LOG_ERR("Failed to start measurement.");
return 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;
}
/* Retrieve status from rx_buf */
*status = rx_buf[0];
return rc;
}
static inline int reset_register(const struct device *dev, uint8_t reg)
{
const struct dht20_config *cfg = dev->config;
int rc;
uint8_t tx_buf[] = {reg, 0, 0};
uint8_t rx_buf[3];
/* Write and then read 3 bytes from device */
rc = i2c_write_read_dt(&cfg->bus, tx_buf, sizeof(tx_buf), rx_buf, sizeof(rx_buf));
if (rc < 0) {
LOG_ERR("Failed to reset register.");
return rc;
}
/* Write register again, using values read earlier */
tx_buf[0] = DHT20_MASK_RESET_REGISTER | reg;
tx_buf[1] = rx_buf[1];
tx_buf[2] = rx_buf[2];
rc = i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
if (rc < 0) {
LOG_ERR("Failed to reset register.");
return rc;
}
return rc;
}
static inline int reset_sensor(const struct device *dev)
{
int rc;
uint8_t status;
rc = read_status(dev, &status);
if (rc < 0) {
LOG_ERR("Failed to read status");
return rc;
}
if ((status & DHT20_STATUS_MASK_CHECK) != DHT20_STATUS_MASK_CHECK) {
/*
* According to datasheet 7.4
* Reset register 0x1B, 0x1C and 0x1E if status does not match expected value
*/
rc = reset_register(dev, DHT20_RESET_REGISTER_0);
if (rc < 0) {
return rc;
}
rc = reset_register(dev, DHT20_RESET_REGISTER_1);
if (rc < 0) {
return rc;
}
rc = reset_register(dev, DHT20_RESET_REGISTER_2);
if (rc < 0) {
return rc;
}
/* Wait 10ms after reset sequence */
k_msleep(DHT20_RESET_SEQUENCE_WAIT_MS);
}
return 0;
}
static int dht20_read_sample(const struct device *dev, uint32_t *t_sample, uint32_t *rh_sample)
{
const struct dht20_config *cfg = dev->config;
/*
* Datasheet shows content of the measurement data as follow
*
* +------+----------------------------------------+
* | Byte | Content |
* +------+----------------------------------------+
* | 0 | State |
* | 1 | Humidity |
* | 2 | Humidity |
* | 3 | Humidity (4 MSb) | Temperature (4 LSb) |
* | 4 | Temperature |
* | 5 | Temperature |
* | 6 | CRC |
* +------+----------------------------------------+
*/
uint8_t rx_buf[DHT20_MEASUREMENT_BUFFER_LENGTH];
int rc;
uint8_t status;
rc = i2c_read_dt(&cfg->bus, rx_buf, sizeof(rx_buf));
if (rc < 0) {
LOG_ERR("Failed to read data from device.");
return rc;
}
status = rx_buf[0];
/* Extract 20 bits for humidity data */
*rh_sample = sys_get_be24(&rx_buf[1]) >> 4;
/* Extract 20 bits for temperature data */
*t_sample = sys_get_be24(&rx_buf[3]) & 0x0FFFFF;
#if defined(CONFIG_DHT20_CRC)
/* Compute and check CRC with last byte of measurement data */
uint8_t crc = crc8(rx_buf, 6, DHT20_CRC_POLYNOM, 0xFF, false);
if (crc != rx_buf[6]) {
rc = -EIO;
}
#endif
return rc;
}
static int dht20_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct dht20_data *data = dev->data;
const struct dht20_config *cfg = dev->config;
int rc;
uint8_t tx_buf[DHT20_TRIGGER_MEASUREMENT_BUFFER_LENGTH] = {
DHT20_TRIGGER_MEASUREMENT_COMMAND};
uint8_t status;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP &&
chan != SENSOR_CHAN_HUMIDITY) {
return -ENOTSUP;
}
/* Reset sensor if needed */
reset_sensor(dev);
/* Send trigger measurement command */
rc = i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
if (rc < 0) {
LOG_ERR("Failed to start measurement.");
return rc;
}
/*
* According to datasheet maximum time to make temperature and humidity
* measurements is 80ms
*/
k_msleep(DHT20_POWER_ON_WAIT_MS);
do {
k_msleep(DHT20_INIT_POLL_STATUS_WAIT_MS);
rc = read_status(dev, &status);
if (rc < 0) {
LOG_ERR("Failed to read status.");
return rc;
}
} while ((status & DHT20_STATUS_MASK_POLL_STATE) != 0);
rc = dht20_read_sample(dev, &data->t_sample, &data->rh_sample);
if (rc < 0) {
LOG_ERR("Failed to fetch data.");
return rc;
}
return 0;
}
static void dht20_temp_convert(struct sensor_value *val, uint32_t raw)
{
int32_t micro_c;
/*
* Convert to micro Celsius
* DegCT = (S / 2^20) * 200 - 50
* uDegCT = (S * 1e6 * 200 - 50 * 1e6) / (1 << 20)
*/
micro_c = ((int64_t)raw * 1000000 * 200) / BIT(20) - 50 * 1000000;
val->val1 = micro_c / 1000000;
val->val2 = micro_c % 1000000;
}
static void dht20_rh_convert(struct sensor_value *val, uint32_t raw)
{
int32_t micro_rh;
/*
* Convert to micro %RH
* %RH = (S / 2^20) * 100%
* u%RH = (S * 1e6 * 100) / (1 << 20)
*/
micro_rh = ((uint64_t)raw * 1000000 * 100) / BIT(20);
val->val1 = micro_rh / 1000000;
val->val2 = micro_rh % 1000000;
}
static int dht20_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct dht20_data *data = dev->data;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
dht20_temp_convert(val, data->t_sample);
} else if (chan == SENSOR_CHAN_HUMIDITY) {
dht20_rh_convert(val, data->rh_sample);
} else {
return -ENOTSUP;
}
return 0;
}
static int dht20_init(const struct device *dev)
{
const struct dht20_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 dht20_driver_api = {.sample_fetch = dht20_sample_fetch,
.channel_get = dht20_channel_get};
#define DT_DRV_COMPAT aosong_dht20
#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
#define DEFINE_DHT20(n) \
static struct dht20_data dht20_data_##n; \
\
static const struct dht20_config dht20_config_##n = {.bus = I2C_DT_SPEC_INST_GET(n)}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, dht20_init, NULL, &dht20_data_##n, &dht20_config_##n, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &dht20_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_DHT20)
#endif
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT aosong_aht20
#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
#define DEFINE_AHT20(n) \
static struct dht20_data aht20_data_##n; \
\
static const struct dht20_config aht20_config_##n = {.bus = I2C_DT_SPEC_INST_GET(n)}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, dht20_init, NULL, &aht20_data_##n, &aht20_config_##n, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &dht20_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_AHT20)
#endif
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT aosong_am2301b
#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
#define DEFINE_AM2301B(n) \
static struct dht20_data am2301b_data_##n; \
\
static const struct dht20_config am2301b_config_##n = {.bus = I2C_DT_SPEC_INST_GET(n)}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, dht20_init, NULL, &am2301b_data_##n, &am2301b_config_##n, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &dht20_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_AM2301B)
#endif
#undef DT_DRV_COMPAT
``` | /content/code_sandbox/drivers/sensor/aosong/dht20/dht20.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,784 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_GROW_R502A_H_
#define ZEPHYR_DRIVERS_SENSOR_GROW_R502A_H_
/*
* @brief confirmation code present in acknowledgment packet
*
*################################################################################
*|Confirmation code | Definition |
*################################################################################
*|0x00 |commad execution complete |
*your_sha256_hash----------------
*|0x01 |error when receiving data package |
*your_sha256_hash----------------
*|0x02 |no finger on the sensor |
*your_sha256_hash----------------
*|0x03 |fail to enroll the finger |
*your_sha256_hash----------------
*|0x06 |fail to generate character file due to over-disorderly |
*| |fingerprint image |
*your_sha256_hash----------------
*|0x07 |fail to generate character file due to lackness of |
*| |character point or over-smallness of fingerprint image.|
*your_sha256_hash----------------
*|0x08 |finger doesnt match |
*your_sha256_hash----------------
*|0x09 |fail to find the matching finger |
*your_sha256_hash----------------
*|0x0A |fail to combine the character files |
*your_sha256_hash----------------
*|0x0B |addressing PageID is beyond the finger library |
*your_sha256_hash----------------
*|0x0C |error reading template from library or invalid |
*| |template |
*your_sha256_hash----------------
*|0x0D |error when uploading template |
*your_sha256_hash----------------
*|0x0E |Module cant receive the following data packages |
*your_sha256_hash----------------
*|0x0F |error when uploading image |
*your_sha256_hash----------------
*|0x10 |fail to delete the template |
*your_sha256_hash----------------
*|0x11 |fail to clear finger library |
*your_sha256_hash----------------
*|0x13 |wrong password! |
*your_sha256_hash----------------
*|0x15 |fail to generate image for the lackness of valid |
*| |primary image |
*your_sha256_hash----------------
*|0x18 |error when writing flash |
*your_sha256_hash----------------
*|0x1A |invalid register number |
*your_sha256_hash----------------
*|0x1B |incorrect configuration of register |
*your_sha256_hash----------------
*/
#define R502A_OK 0x00 /*commad execution complete*/
/*Package Identifier's definition*/
#define R502A_COMMAND_PACKET 0x1 /*Command packet*/
#define R502A_DATA_PACKET 0x2 /*Data packet, must follow command packet or acknowledge packet*/
#define R502A_ACK_PACKET 0x7 /*Acknowledge packet*/
#define R502A_END_DATA_PACKET 0x8 /*End of data packet*/
/*Instruction code's definition*/
#define R502A_GENIMAGE 0x01 /*Collect finger image*/
#define R502A_IMAGE2TZ 0x02 /*To generate character file from image*/
#define R502A_MATCH 0x03 /*Carry out precise matching of two templates*/
#define R502A_SEARCH 0x04 /*Search the finger library*/
#define R502A_REGMODEL 0x05 /*To combine character files and generate template*/
#define R502A_STORE 0x06 /*To store template*/
#define R502A_LOAD 0x07 /*To read/load template*/
#define R502A_UPCHAR 0x08 /*To upload template*/
#define R502A_DOWNCHAR 0x09 /*To download template*/
#define R502A_IMGUPLOAD 0x0A /*To upload image*/
#define R502A_DELETE 0x0C /*To delete template*/
#define R502A_EMPTYLIBRARY 0x0D /*To empty the library*/
#define R502A_SETSYSPARAM 0x0E /*To set system parameter*/
#define R502A_READSYSPARAM 0x0F /*To read system parameter*/
#define R502A_SETPASSWORD 0x12 /*To set password*/
#define R502A_VERIFYPASSWORD 0x13 /*To verify password*/
#define R502A_GETRANDOM 0x14 /*To generate a random code*/
#define R502A_TEMPLATECOUNT 0x1D /*To read finger template numbers*/
#define R502A_READTEMPLATEINDEX 0x1F /*Read fingerprint template index table*/
#define R502A_LED_CONFIG 0x35 /*Aura LED Config*/
#define R502A_CHECKSENSOR 0x36 /*Check sensor*/
#define R502A_SOFTRESET 0x3D /*Soft reset*/
#define R502A_HANDSHAKE 0x40 /*Handshake*/
#define R502A_BADPACKET 0xFE /* Bad packet was sent*/
#define R502A_NOT_MATCH_CC 0x08 /* templates of two buffers not matching*/
#define R502A_NOT_FOUND_CC 0x09 /*fail to find the matching finger*/
#define R502A_FINGER_MATCH_NOT_FOUND 0
#define R502A_FINGER_MATCH_FOUND 1
#define R502A_STARTCODE 0xEF01 /*Fixed value, High byte transferred first*/
#define R502A_DEFAULT_PASSWORD 0x00000000
#define R502A_DEFAULT_ADDRESS 0xFFFFFFFF
#define R502A_DEFAULT_CAPACITY 200
#define R502A_HANDSHAKE_BYTE 0x55
#define R02A_LIBRARY_START_IDX 0
#define R502A_STARTCODE_IDX 0
#define R502A_ADDRESS_IDX 2
#define R502A_PID_IDX 6 /* Package identifier index*/
#define R502A_PKG_LEN_IDX 7
#define R502A_CC_IDX 9 /* Confirmation code index*/
#define R502A_COMMON_ACK_LEN 12
#define R502A_STARTCODE_LEN 2
#define R502A_ADDRESS_LEN 4
#define R502A_PKG_LEN 2
#define R502A_CHECKSUM_LEN 2 /* Checksum length in uart packages*/
#define R502A_HEADER_LEN 9
#define R502A_CHAR_BUF_1 1
#define R502A_CHAR_BUF_2 2
#define R502A_CHAR_BUF_TOTAL 2
#define R502A_CHAR_BUF_SIZE 384 /* Maximum size of characteristic value buffer*/
#define R502A_TEMPLATE_SIZE 768 /* Maximum size of template, twice of CHAR_BUF*/
#define R502A_TEMPLATE_MAX_SIZE (R502A_CHAR_BUF_TOTAL * R502A_TEMPLATE_SIZE)
#define R502A_MAX_BUF_SIZE (CONFIG_R502A_DATA_PKT_SIZE + R502A_COMMON_ACK_LEN)
#define R502A_TEMPLATES_PER_PAGE 256
#define R502A_TEMP_TABLE_BUF_SIZE 32
#define R502A_DELETE_COUNT_OFFSET 1
#define R502A_DELAY 200
#define R502A_RETRY_DELAY 5
/*LED glow control code*/
enum r502a_led_ctrl_code {
R502A_LED_CTRL_BREATHING = 0x01,
R502A_LED_CTRL_FLASHING,
R502A_LED_CTRL_ON_ALWAYS,
R502A_LED_CTRL_OFF_ALWAYS,
R502A_LED_CTRL_ON_GRADUALLY,
R502A_LED_CTRL_OFF_GRADUALLY,
};
/* LED glow speed code
* if needed, use desired speed between 0-255
*/
enum r502a_led_speed {
R502A_LED_SPEED_MAX = 0x00,
R502A_LED_SPEED_HALF = 0x50,
R502A_LED_SPEED_MIN = 0xFF,
};
/* LED glowing cycle
* if needed, use desired cycle count between 1-255
*/
enum r502a_led_cycle {
R502A_LED_CYCLE_INFINITE = 0x00,
R502A_LED_CYCLE_1,
R502A_LED_CYCLE_2,
R502A_LED_CYCLE_3,
R502A_LED_CYCLE_4,
R502A_LED_CYCLE_5,
R502A_LED_CYCLE_255 = 0xFF,
};
struct r502a_led_params {
uint8_t ctrl_code;
uint8_t color_idx;
uint8_t speed; /* Speed 0x00-0xff */
uint8_t cycle; /* Number of cycles | 0-infinite, 1-255 */
};
union r502a_packet {
struct {
uint16_t start;
uint32_t addr;
uint8_t pid;
uint16_t len;
uint8_t data[CONFIG_R502A_DATA_PKT_SIZE];
} __packed;
uint8_t buf[R502A_MAX_BUF_SIZE];
};
struct r502a_buf {
uint8_t *data;
size_t len;
};
struct grow_r502a_data {
#ifdef CONFIG_GROW_R502A_TRIGGER
const struct device *gpio_dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t th_handler;
const struct sensor_trigger *th_trigger;
#if defined(CONFIG_GROW_R502A_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_GROW_R502A_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_GROW_R502A_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_GROW_R502A_TRIGGER */
struct r502a_buf tx_buf;
struct r502a_buf rx_buf;
uint16_t pkt_len;
struct k_mutex lock;
struct k_sem uart_tx_sem;
struct k_sem uart_rx_sem;
uint16_t template_count;
uint8_t led_color;
};
struct grow_r502a_config {
const struct device *dev;
struct gpio_dt_spec vin_gpios;
struct gpio_dt_spec act_gpios;
uint32_t comm_addr;
#ifdef CONFIG_GROW_R502A_TRIGGER
struct gpio_dt_spec int_gpios;
#endif /* CONFIG_GROW_R502A_TRIGGER */
};
#ifdef CONFIG_GROW_R502A_TRIGGER
int grow_r502a_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int grow_r502a_init_interrupt(const struct device *dev);
#endif /* CONFIG_GROW_R502A_TRIGGER */
#endif /*_GROW_R502A_H_*/
``` | /content/code_sandbox/drivers/sensor/grow_r502a/grow_r502a.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,142 |
```unknown
# GROW_R502A hzgrow Fingerprint sensor Configuration options
menuconfig GROW_R502A
bool "GROW_R502A Fingerprint Sensor"
default y
depends on DT_HAS_HZGROW_R502A_ENABLED
depends on UART_INTERRUPT_DRIVEN && SERIAL
help
Enable driver for GROW_R502A Fingerprint Sensor.
if GROW_R502A
config R502A_DATA_PKT_SIZE
int "Template data packet size"
default 128
help
Template data packet size for upload and download
to the sensor device.
valid values are:
32, 64, 128, 256.
choice
prompt "Trigger mode"
default GROW_R502A_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config GROW_R502A_TRIGGER_NONE
bool "No trigger"
config GROW_R502A_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select GROW_R502A_TRIGGER
config GROW_R502A_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select GROW_R502A_TRIGGER
endchoice
config GROW_R502A_TRIGGER
bool
config GROW_R502A_THREAD_PRIORITY
int "Thread priority"
depends on GROW_R502A_TRIGGER_OWN_THREAD && GROW_R502A_TRIGGER
default 10
help
Priority of thread used by the driver to handle interrupts.
config GROW_R502A_THREAD_STACK_SIZE
int "Thread stack size"
depends on GROW_R502A_TRIGGER_OWN_THREAD && GROW_R502A_TRIGGER
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config GROW_R502A_GPIO_POWER
bool "GROW_R502A sensor VCC and VT GPIO"
help
Enable control of vin-gpios and act-gpios.
endif # GROW_R502A
``` | /content/code_sandbox/drivers/sensor/grow_r502a/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 408 |
```c
/*
*
*/
#define DT_DRV_COMPAT hzgrow_r502a
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor/grow_r502a.h>
#include "grow_r502a.h"
LOG_MODULE_DECLARE(GROW_R502A, CONFIG_SENSOR_LOG_LEVEL);
static void setup_int(const struct device *dev, bool enable)
{
const struct grow_r502a_config *cfg = dev->config;
gpio_flags_t flags =
enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->int_gpios, flags);
}
static void process_int(const struct device *dev)
{
struct grow_r502a_data *drv_data = dev->data;
if (drv_data->th_handler != NULL) {
drv_data->th_handler(dev, drv_data->th_trigger);
}
setup_int(dev, true);
}
int grow_r502a_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct grow_r502a_data *drv_data = dev->data;
if ((enum sensor_trigger_type_grow_r502a)trig->type == SENSOR_TRIG_TOUCH) {
drv_data->th_handler = handler;
drv_data->th_trigger = trig;
setup_int(dev, true);
} else {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
return 0;
}
static void grow_r502a_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct grow_r502a_data *drv_data =
CONTAINER_OF(cb, struct grow_r502a_data, gpio_cb);
setup_int(drv_data->gpio_dev, false);
#if defined(CONFIG_GROW_R502A_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_GROW_R502A_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
#if defined(CONFIG_GROW_R502A_TRIGGER_OWN_THREAD)
static void grow_r502a_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct grow_r502a_data *drv_data = p1;
while (true) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
process_int(drv_data->gpio_dev);
}
}
#elif defined(CONFIG_GROW_R502A_TRIGGER_GLOBAL_THREAD)
static void grow_r502a_work_cb(struct k_work *work)
{
struct grow_r502a_data *drv_data =
CONTAINER_OF(work, struct grow_r502a_data, work);
process_int(drv_data->gpio_dev);
}
#endif
int grow_r502a_init_interrupt(const struct device *dev)
{
struct grow_r502a_data *drv_data = dev->data;
const struct grow_r502a_config *cfg = dev->config;
int rc;
if (!gpio_is_ready_dt(&cfg->int_gpios)) {
LOG_ERR("GPIO port %s not ready", cfg->int_gpios.port->name);
return -ENODEV;
}
rc = gpio_pin_configure_dt(&cfg->int_gpios, GPIO_INPUT);
if (rc < 0) {
return rc;
}
drv_data->gpio_dev = dev;
#if defined(CONFIG_GROW_R502A_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_GROW_R502A_THREAD_STACK_SIZE,
grow_r502a_thread, drv_data, NULL,
NULL, K_PRIO_COOP(CONFIG_GROW_R502A_THREAD_PRIORITY), 0,
K_NO_WAIT);
#elif defined(CONFIG_GROW_R502A_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = grow_r502a_work_cb;
#endif
gpio_init_callback(&drv_data->gpio_cb, grow_r502a_gpio_callback,
BIT(cfg->int_gpios.pin));
rc = gpio_add_callback(cfg->int_gpios.port, &drv_data->gpio_cb);
if (rc < 0) {
LOG_ERR("Could not set gpio callback.");
return rc;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/grow_r502a/grow_r502a_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 937 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/sensirion/sgp40/Kconfig"
source "drivers/sensor/sensirion/sht3xd/Kconfig"
source "drivers/sensor/sensirion/sht4x/Kconfig"
source "drivers/sensor/sensirion/shtcx/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/sensirion/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 85 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SHTCX_SHTCX_H_
#define ZEPHYR_DRIVERS_SENSOR_SHTCX_SHTCX_H_
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
/* common cmds */
#define SHTCX_CMD_READ_ID 0xEFC8
#define SHTCX_CMD_SOFT_RESET 0x805D
/* shtc3 only: */
#define SHTCX_CMD_SLEEP 0xB098
#define SHTCX_CMD_WAKEUP 0x3517
#define SHTCX_POWER_UP_TIME_US 240U
/* Soft reset time is 230us for shtc1 and 240us for shtc3 */
#define SHTCX_SOFT_RESET_TIME_US 240U
#define SHTCX_MAX_READ_LEN 6
#define SHTCX_WORD_LEN 2
#define SHTCX_CRC8_LEN 1
#define SHTC3_ID_MASK 0x083F
#define SHTC3_ID_VALUE 0x0807
#define SHTC1_ID_MASK 0x083F
#define SHTC1_ID_VALUE 0x0007
/* defines matching the related enums DT_ENUM_IDX: */
#define CHIP_SHTC1 0
#define CHIP_SHTC3 1
#define MEASURE_MODE_NORMAL 0
#define MEASURE_MODE_LOW_POWER 1
enum shtcx_chip {
SHTC1 = CHIP_SHTC1,
SHTC3 = CHIP_SHTC3,
};
enum shtcx_measure_mode {
NORMAL = MEASURE_MODE_NORMAL,
LOW_POWER = MEASURE_MODE_LOW_POWER,
};
struct shtcx_sample {
uint16_t temp;
uint16_t humidity;
} __packed __aligned(2);
struct shtcx_config {
struct i2c_dt_spec i2c;
enum shtcx_chip chip;
enum shtcx_measure_mode measure_mode;
bool clock_stretching;
};
struct shtcx_data {
struct shtcx_sample sample;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_SHTCX_SHTCX_H_ */
``` | /content/code_sandbox/drivers/sensor/sensirion/shtcx/shtcx.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 483 |
```c
/*
*
*/
#define DT_DRV_COMPAT sensirion_shtcx
#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/crc.h>
#include <zephyr/logging/log.h>
#include "shtcx.h"
LOG_MODULE_REGISTER(SHTCX, CONFIG_SENSOR_LOG_LEVEL);
/* all cmds read temp first: cmd[MEASURE_MODE][Clock_stretching_enabled] */
static const uint16_t measure_cmd[2][2] = {
{ 0x7866, 0x7CA2 },
{ 0x609C, 0x6458 },
};
/* measure_wait_us[shtcx_chip][MEASURE_MODE] */
static const uint16_t measure_wait_us[2][2] = {
/* shtc1: 14.4ms, 0.94ms */
{ 14400, 940 }, /* shtc1 */
/* shtc3: 12.1ms, 0.8ms */
{ 12100, 800 }, /* shtc3 */
};
/*
* CRC algorithm parameters were taken from the
* "Checksum Calculation" section of the datasheet.
*/
static uint8_t shtcx_compute_crc(uint16_t value)
{
uint8_t buf[2];
sys_put_be16(value, buf);
return crc8(buf, 2, 0x31, 0xFF, false);
}
/* val = -45 + 175 * sample / (2^16) */
static void shtcx_temperature_from_raw(uint16_t raw, struct sensor_value *val)
{
int32_t tmp;
tmp = (int32_t)raw * 175U - (45 << 16);
val->val1 = tmp / 0x10000;
/* x * 1.000.000 / 65.536 == x * 15625 / 2^10 */
val->val2 = ((tmp % 0x10000) * 15625) / 1024;
}
/* val = 100 * sample / (2^16) */
static void shtcx_humidity_from_raw(uint16_t raw, struct sensor_value *val)
{
uint32_t tmp;
tmp = (uint32_t)raw * 100U;
val->val1 = tmp / 0x10000;
/* x * 1.000.000 / 65.536 == x * 15625 / 1024 */
val->val2 = (tmp % 0x10000) * 15625U / 1024;
}
static int shtcx_write_command(const struct device *dev, uint16_t cmd)
{
const struct shtcx_config *cfg = dev->config;
uint8_t tx_buf[2];
sys_put_be16(cmd, tx_buf);
return i2c_write_dt(&cfg->i2c, tx_buf, sizeof(tx_buf));
}
static int shtcx_read_words(const struct device *dev, uint16_t cmd, uint16_t *data,
uint16_t num_words, uint16_t max_duration_us)
{
const struct shtcx_config *cfg = dev->config;
int status = 0;
uint32_t raw_len = num_words * (SHTCX_WORD_LEN + SHTCX_CRC8_LEN);
uint16_t temp16;
uint8_t rx_buf[SHTCX_MAX_READ_LEN];
int dst = 0;
status = shtcx_write_command(dev, cmd);
if (status != 0) {
LOG_DBG("Failed to initiate read");
return -EIO;
}
if (!cfg->clock_stretching) {
k_sleep(K_USEC(max_duration_us));
}
status = i2c_read_dt(&cfg->i2c, rx_buf, raw_len);
if (status != 0) {
LOG_DBG("Failed to read data");
return -EIO;
}
for (int i = 0; i < raw_len; i += (SHTCX_WORD_LEN + SHTCX_CRC8_LEN)) {
temp16 = sys_get_be16(&rx_buf[i]);
if (shtcx_compute_crc(temp16) != rx_buf[i+2]) {
LOG_DBG("invalid received invalid crc");
return -EIO;
}
data[dst++] = temp16;
}
return 0;
}
static int shtcx_sleep(const struct device *dev)
{
if (shtcx_write_command(dev, SHTCX_CMD_SLEEP) < 0) {
return -EIO;
}
return 0;
}
static int shtcx_wakeup(const struct device *dev)
{
if (shtcx_write_command(dev, SHTCX_CMD_WAKEUP)) {
return -EIO;
}
k_sleep(K_USEC(100));
return 0;
}
static int shtcx_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct shtcx_data *data = dev->data;
const struct shtcx_config *cfg = dev->config;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (cfg->chip == SHTC3) {
if (shtcx_wakeup(dev)) {
return -EIO;
}
}
if (shtcx_read_words(dev,
measure_cmd[cfg->measure_mode][cfg->clock_stretching],
(uint16_t *)&data->sample, 2,
measure_wait_us[cfg->chip][cfg->measure_mode]) < 0) {
LOG_DBG("Failed read measurements!");
return -EIO;
}
if (cfg->chip == SHTC3) {
if (shtcx_sleep(dev)) {
LOG_DBG("Failed to initiate sleep");
return -EIO;
}
}
return 0;
}
static int shtcx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct shtcx_data *data = dev->data;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
shtcx_temperature_from_raw(data->sample.temp, val);
} else if (chan == SENSOR_CHAN_HUMIDITY) {
shtcx_humidity_from_raw(data->sample.humidity, val);
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api shtcx_driver_api = {
.sample_fetch = shtcx_sample_fetch,
.channel_get = shtcx_channel_get,
};
static int shtcx_init(const struct device *dev)
{
const struct shtcx_config *cfg = dev->config;
uint16_t product_id;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
k_sleep(K_USEC(SHTCX_POWER_UP_TIME_US));
if (cfg->chip == SHTC3) {
if (shtcx_wakeup(dev)) {
LOG_ERR("Wakeup failed");
return -EIO;
}
}
if (shtcx_write_command(dev, SHTCX_CMD_SOFT_RESET) < 0) {
LOG_ERR("soft reset failed");
return -EIO;
}
k_sleep(K_USEC(SHTCX_SOFT_RESET_TIME_US));
if (shtcx_read_words(dev, SHTCX_CMD_READ_ID, &product_id, 1, 0) < 0) {
LOG_ERR("Failed to read product id!");
return -EIO;
}
if (cfg->chip == SHTC1) {
if ((product_id & SHTC1_ID_MASK) != SHTC1_ID_VALUE) {
LOG_ERR("Device is not a SHTC1");
return -EINVAL;
}
}
if (cfg->chip == SHTC3) {
if ((product_id & SHTC3_ID_MASK) != SHTC3_ID_VALUE) {
LOG_ERR("Device is not a SHTC3");
return -EINVAL;
}
shtcx_sleep(dev);
}
LOG_DBG("Clock-stretching enabled: %d", cfg->clock_stretching);
LOG_DBG("Measurement mode: %d", cfg->measure_mode);
LOG_DBG("Init SHTCX");
return 0;
}
#define SHTCX_CHIP(inst) \
(DT_INST_NODE_HAS_COMPAT(inst, sensirion_shtc1) ? CHIP_SHTC1 : CHIP_SHTC3)
#define SHTCX_CONFIG(inst) \
{ \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.chip = SHTCX_CHIP(inst), \
.measure_mode = DT_INST_ENUM_IDX(inst, measure_mode), \
.clock_stretching = DT_INST_PROP(inst, clock_stretching) \
}
#define SHTCX_DEFINE(inst) \
static struct shtcx_data shtcx_data_##inst; \
static struct shtcx_config shtcx_config_##inst = \
SHTCX_CONFIG(inst); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
shtcx_init, \
NULL, \
&shtcx_data_##inst, \
&shtcx_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&shtcx_driver_api);
DT_INST_FOREACH_STATUS_OKAY(SHTCX_DEFINE)
``` | /content/code_sandbox/drivers/sensor/sensirion/shtcx/shtcx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,060 |
```unknown
# SHTCX temperature and humidity sensor configuration options
config SHTCX
bool "SHTCX: SHTC1 and SHTC3 Temperature and Humidity Sensor"
default y
depends on DT_HAS_SENSIRION_SHTCX_ENABLED
select I2C
select CRC
help
Enable driver for SHTC1 and SHTC3 temperature and humidity sensors.
``` | /content/code_sandbox/drivers/sensor/sensirion/shtcx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 82 |
```c
/*
*
*/
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/led.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor/grow_r502a.h>
#include "grow_r502a.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(GROW_R502A, CONFIG_SENSOR_LOG_LEVEL);
static int transceive_packet(const struct device *dev, union r502a_packet *tx_packet,
union r502a_packet *rx_packet, uint16_t data_len)
{
const struct grow_r502a_config *cfg = dev->config;
struct grow_r502a_data *drv_data = dev->data;
if (tx_packet) {
uint16_t check_sum, pkg_len;
pkg_len = data_len + R502A_CHECKSUM_LEN;
check_sum = (pkg_len >> 8) + (pkg_len & 0xFF) + tx_packet->pid;
tx_packet->start = sys_cpu_to_be16(R502A_STARTCODE);
tx_packet->addr = sys_cpu_to_be32(cfg->comm_addr);
tx_packet->len = sys_cpu_to_be16(pkg_len);
for (int i = 0; i < data_len; i++) {
check_sum += tx_packet->data[i];
}
sys_put_be16(check_sum, &tx_packet->buf[data_len + R502A_HEADER_LEN]);
drv_data->tx_buf.len = pkg_len + R502A_HEADER_LEN;
drv_data->tx_buf.data = tx_packet->buf;
LOG_HEXDUMP_DBG(drv_data->tx_buf.data, drv_data->tx_buf.len, "TX");
uart_irq_tx_enable(cfg->dev);
if (k_sem_take(&drv_data->uart_tx_sem, K_MSEC(1500)) != 0) {
LOG_ERR("Tx data timeout");
return -ETIMEDOUT;
}
}
if (rx_packet) {
drv_data->rx_buf.data = rx_packet->buf;
drv_data->rx_buf.len = 0;
drv_data->pkt_len = R502A_HEADER_LEN;
uart_irq_rx_enable(cfg->dev);
if (k_sem_take(&drv_data->uart_rx_sem, K_MSEC(1500)) != 0) {
LOG_ERR("Rx data timeout");
return -ETIMEDOUT;
}
}
return 0;
}
static int r502a_validate_rx_packet(union r502a_packet *rx_packet)
{
uint16_t recv_cks = 0, calc_cks = 0;
uint8_t cks_start_idx;
if (sys_be16_to_cpu(rx_packet->start) == R502A_STARTCODE) {
LOG_DBG("startcode matched 0x%X", sys_be16_to_cpu(rx_packet->start));
} else {
LOG_ERR("startcode didn't match 0x%X", sys_be16_to_cpu(rx_packet->start));
return -EINVAL;
}
if (sys_be32_to_cpu(rx_packet->addr) == R502A_DEFAULT_ADDRESS) {
LOG_DBG("Address matched 0x%X", sys_be32_to_cpu(rx_packet->addr));
} else {
LOG_ERR("Address didn't match 0x%X", sys_be32_to_cpu(rx_packet->addr));
return -EINVAL;
}
switch (rx_packet->pid) {
case R502A_DATA_PACKET:
LOG_DBG("Data Packet Received 0x%X", rx_packet->pid);
break;
case R502A_END_DATA_PACKET:
LOG_DBG("End of Data Packet Received 0x%X", rx_packet->pid);
break;
case R502A_ACK_PACKET:
LOG_DBG("Acknowledgment Packet Received 0x%X", rx_packet->pid);
break;
default:
LOG_ERR("Error Package ID 0x%X", rx_packet->pid);
return -EINVAL;
}
cks_start_idx = sys_be16_to_cpu(rx_packet->len) - R502A_CHECKSUM_LEN;
recv_cks = sys_get_be16(&rx_packet->data[cks_start_idx]);
calc_cks += rx_packet->pid + (sys_be16_to_cpu(rx_packet->len) >> 8) +
(sys_be16_to_cpu(rx_packet->len) & 0xFF);
for (int i = 0; i < cks_start_idx; i++) {
calc_cks += rx_packet->data[i];
}
if (recv_cks == calc_cks) {
LOG_DBG("Checksum matched calculated 0x%x received 0x%x", calc_cks, recv_cks);
} else {
LOG_ERR("Checksum mismatch calculated 0x%x received 0x%x", calc_cks, recv_cks);
return -EINVAL;
}
return 0;
}
static void uart_cb_tx_handler(const struct device *dev)
{
const struct grow_r502a_config *config = dev->config;
struct grow_r502a_data *drv_data = dev->data;
int sent = 0;
if (drv_data->tx_buf.len > 0) {
sent = uart_fifo_fill(config->dev, drv_data->tx_buf.data,
drv_data->tx_buf.len);
drv_data->tx_buf.data += sent;
drv_data->tx_buf.len -= sent;
}
if (!drv_data->tx_buf.len && uart_irq_tx_complete(config->dev) > 0) {
uart_irq_tx_disable(config->dev);
k_sem_give(&drv_data->uart_tx_sem);
return;
}
}
static void uart_cb_handler(const struct device *dev, void *user_data)
{
const struct device *uart_dev = user_data;
struct grow_r502a_data *drv_data = uart_dev->data;
int len = 0;
int offset = drv_data->rx_buf.len;
if ((uart_irq_update(dev) > 0) && (uart_irq_is_pending(dev) > 0)) {
if (uart_irq_tx_ready(dev)) {
uart_cb_tx_handler(uart_dev);
}
while (uart_irq_rx_ready(dev)) {
len = uart_fifo_read(dev, &drv_data->rx_buf.data[offset],
drv_data->pkt_len);
offset += len;
drv_data->rx_buf.len = offset;
if (drv_data->pkt_len != len) {
drv_data->pkt_len -= len;
continue;
}
if (offset == R502A_HEADER_LEN) {
drv_data->pkt_len = sys_get_be16(
&drv_data->rx_buf.data[R502A_PKG_LEN_IDX]
);
continue;
}
LOG_HEXDUMP_DBG(drv_data->rx_buf.data, offset, "RX");
uart_irq_rx_disable(dev);
k_sem_give(&drv_data->uart_rx_sem);
break;
}
}
}
/**
* @brief Set sensor device's basic parameters like baud rate, security level
* and data package length.
*/
static int fps_set_sys_param(const struct device *dev, const struct sensor_value *val)
{
union r502a_packet rx_packet = {0};
int ret = 0;
char const set_sys_param_len = 3;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = { R502A_SETSYSPARAM, val->val1, val->val2}
};
ret = transceive_packet(dev, &tx_packet, &rx_packet, set_sys_param_len);
if (ret != 0) {
return ret;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
return ret;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("R502A set system parameter success");
} else {
LOG_ERR("R502A set system parameter error %d", rx_packet.buf[R502A_CC_IDX]);
return -EIO;
}
return 0;
}
int r502a_read_sys_param(const struct device *dev, struct r502a_sys_param *val)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
int offset = 0, ret = 0;
char const read_sys_param_len = 1;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_READSYSPARAM}
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, read_sys_param_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("R502A read system parameter success");
} else {
LOG_ERR("R502A read system parameter error %d", rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
goto unlock;
}
val->status_reg = sys_get_be16(
&rx_packet.data[offsetof(struct r502a_sys_param, status_reg) + 1]
);
val->system_id = sys_get_be16(
&rx_packet.data[offsetof(struct r502a_sys_param, system_id) + 1]
);
val->lib_size = sys_get_be16(
&rx_packet.data[offsetof(struct r502a_sys_param, lib_size) + 1]
);
val->sec_level = sys_get_be16(
&rx_packet.data[offsetof(struct r502a_sys_param, sec_level) + 1]
);
val->addr = sys_get_be32(
&rx_packet.data[offsetof(struct r502a_sys_param, addr) + 1]
);
offset = sys_get_be16(
&rx_packet.data[offsetof(struct r502a_sys_param, data_pkt_size) + 1]
);
val->data_pkt_size = 32 * (1 << offset);
val->baud = sys_get_be16(
&rx_packet.data[offsetof(struct r502a_sys_param, baud) + 1]
) * 9600;
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_led_control(const struct device *dev, struct r502a_led_params *led_control)
{
union r502a_packet rx_packet = {0};
char const led_ctrl_len = 5;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = { R502A_LED_CONFIG, led_control->ctrl_code,
led_control->speed, led_control->color_idx, led_control->cycle}
};
ret = transceive_packet(dev, &tx_packet, &rx_packet, led_ctrl_len);
if (ret != 0) {
return ret;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
return ret;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("R502A LED ON");
k_sleep(K_MSEC(R502A_DELAY));
} else {
LOG_ERR("R502A LED control error %d", rx_packet.buf[R502A_CC_IDX]);
return -EIO;
}
return 0;
}
static int fps_verify_password(const struct device *dev)
{
union r502a_packet rx_packet = {0};
char const verify_pwd_len = 5;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data[0] = R502A_VERIFYPASSWORD,
};
sys_put_be32(R502A_DEFAULT_PASSWORD, &tx_packet.data[1]);
ret = transceive_packet(dev, &tx_packet, &rx_packet, verify_pwd_len);
if (ret != 0) {
return ret;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
return ret;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Correct password, R502A verified");
} else {
LOG_ERR("Password verification error 0x%X", rx_packet.buf[R502A_CC_IDX]);
return -EIO;
}
return 0;
}
static int fps_get_template_count(const struct device *dev)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const get_temp_cnt_len = 1;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_TEMPLATECOUNT},
};
ret = transceive_packet(dev, &tx_packet, &rx_packet, get_temp_cnt_len);
if (ret != 0) {
return ret;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
return ret;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Read success");
drv_data->template_count = sys_get_be16(&rx_packet.data[1]);
LOG_INF("Remaining templates count : %d", drv_data->template_count);
} else {
LOG_ERR("R502A template count get error");
return -EIO;
}
return 0;
}
static int fps_read_template_table(const struct device *dev, uint32_t *free_idx)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const temp_table_len = 2;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_READTEMPLATEINDEX, 0x00}
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, temp_table_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Read success");
} else {
LOG_ERR("R502A template table get error");
ret = -EIO;
goto unlock;
}
for (int group_idx = 0; group_idx < R502A_TEMP_TABLE_BUF_SIZE; group_idx++) {
uint8_t group = rx_packet.data[group_idx + 1];
/* if group is all occupied */
if (group == 0xff) {
continue;
}
*free_idx = (group_idx * 8) + find_lsb_set(~group) - 1;
goto unlock;
}
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_get_image(const struct device *dev)
{
union r502a_packet rx_packet = {0};
char const get_img_len = 1;
int ret = 0;
struct r502a_led_params led_ctrl = {
.ctrl_code = R502A_LED_CTRL_BREATHING,
.color_idx = R502A_LED_COLOR_BLUE,
.speed = R502A_LED_SPEED_HALF,
.cycle = 0x01,
};
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_GENIMAGE},
};
ret = transceive_packet(dev, &tx_packet, &rx_packet, get_img_len);
if (ret != 0) {
return ret;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
return ret;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
fps_led_control(dev, &led_ctrl);
LOG_DBG("Image taken");
} else {
led_ctrl.ctrl_code = R502A_LED_CTRL_ON_ALWAYS;
led_ctrl.color_idx = R502A_LED_COLOR_RED;
fps_led_control(dev, &led_ctrl);
LOG_ERR("Error getting image 0x%X", rx_packet.buf[R502A_CC_IDX]);
return -EIO;
}
return 0;
}
static int fps_image_to_char(const struct device *dev, uint8_t char_buf_idx)
{
union r502a_packet rx_packet = {0};
char const img_to_char_len = 2;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_IMAGE2TZ, char_buf_idx}
};
ret = transceive_packet(dev, &tx_packet, &rx_packet, img_to_char_len);
if (ret != 0) {
return ret;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
return ret;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Image converted");
} else {
LOG_ERR("Error converting image 0x%X", rx_packet.buf[R502A_CC_IDX]);
return -EIO;
}
return 0;
}
static int fps_create_model(const struct device *dev)
{
union r502a_packet rx_packet = {0};
char const create_model_len = 1;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_REGMODEL}
};
ret = transceive_packet(dev, &tx_packet, &rx_packet, create_model_len);
if (ret != 0) {
return ret;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
return ret;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Model Created");
} else {
LOG_ERR("Error creating model 0x%X", rx_packet.buf[R502A_CC_IDX]);
return -EIO;
}
return 0;
}
static int fps_store_model(const struct device *dev, uint16_t id)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const store_model_len = 4;
int ret = 0;
struct r502a_led_params led_ctrl = {
.ctrl_code = R502A_LED_CTRL_BREATHING,
.color_idx = R502A_LED_COLOR_BLUE,
.speed = R502A_LED_SPEED_HALF,
.cycle = 0x01,
};
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_STORE, R502A_CHAR_BUF_1}
};
sys_put_be16(id, &tx_packet.data[2]);
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, store_model_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
led_ctrl.color_idx = R502A_LED_COLOR_BLUE;
led_ctrl.ctrl_code = R502A_LED_CTRL_FLASHING;
led_ctrl.cycle = 0x03;
fps_led_control(dev, &led_ctrl);
LOG_INF("Fingerprint stored! at ID #%d", id);
} else {
LOG_ERR("Error storing model 0x%X", rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
}
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_delete_model(const struct device *dev, uint16_t id, uint16_t count)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const delete_model_len = 5;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_DELETE}
};
sys_put_be16(id, &tx_packet.data[1]);
sys_put_be16(count + R502A_DELETE_COUNT_OFFSET, &tx_packet.data[3]);
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, delete_model_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_INF("Fingerprint Deleted from ID #%d to #%d", id, (id + count));
} else {
LOG_ERR("Error deleting image 0x%X", rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
}
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_empty_db(const struct device *dev)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const empty_db_len = 1;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_EMPTYLIBRARY}
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, empty_db_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_INF("Emptied Fingerprint Library");
} else {
LOG_ERR("Error emptying fingerprint library 0x%X",
rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
}
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_search(const struct device *dev, struct sensor_value *val)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const search_len = 6;
int ret = 0;
struct r502a_led_params led_ctrl = {
.ctrl_code = R502A_LED_CTRL_BREATHING,
.color_idx = R502A_LED_COLOR_BLUE,
.speed = R502A_LED_SPEED_HALF,
.cycle = 0x01,
};
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_SEARCH, R502A_CHAR_BUF_1}
};
sys_put_be16(R02A_LIBRARY_START_IDX, &tx_packet.data[2]);
sys_put_be16(R502A_DEFAULT_CAPACITY, &tx_packet.data[4]);
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, search_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
led_ctrl.ctrl_code = R502A_LED_CTRL_FLASHING;
led_ctrl.color_idx = R502A_LED_COLOR_PURPLE;
led_ctrl.cycle = 0x01;
fps_led_control(dev, &led_ctrl);
val->val1 = sys_get_be16(&rx_packet.data[1]);
val->val2 = sys_get_be16(&rx_packet.data[3]);
LOG_INF("Found a matching print! at ID #%d", val->val1);
} else if (rx_packet.buf[R502A_CC_IDX] == R502A_NOT_FOUND_CC) {
led_ctrl.ctrl_code = R502A_LED_CTRL_BREATHING;
led_ctrl.color_idx = R502A_LED_COLOR_RED;
led_ctrl.cycle = 0x02;
fps_led_control(dev, &led_ctrl);
LOG_ERR("Did not find a match");
ret = -ENOENT;
} else {
led_ctrl.ctrl_code = R502A_LED_CTRL_ON_ALWAYS;
led_ctrl.color_idx = R502A_LED_COLOR_RED;
fps_led_control(dev, &led_ctrl);
LOG_ERR("Error searching for image 0x%X", rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
}
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_load_template(const struct device *dev, uint16_t id)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const load_tmp_len = 4;
int ret = 0;
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_LOAD, R502A_CHAR_BUF_1}
};
sys_put_be16(id, &tx_packet.data[2]);
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, load_tmp_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Load template data from id #%d to Char_buffer2", id);
} else {
LOG_ERR("Error Loading template 0x%X",
rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
}
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_match_templates(const struct device *dev, struct sensor_value *val)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const match_templates_len = 1;
int ret = 0;
struct r502a_led_params led_ctrl = {
.ctrl_code = R502A_LED_CTRL_BREATHING,
.color_idx = R502A_LED_COLOR_BLUE,
.speed = R502A_LED_SPEED_HALF,
.cycle = 0x01,
};
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_MATCH}
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, match_templates_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
fps_led_control(dev, &led_ctrl);
val->val1 = R502A_FINGER_MATCH_FOUND;
val->val2 = sys_get_be16(&rx_packet.data[1]);
LOG_INF("Fingerprint matched with a score %d", val->val2);
} else if (rx_packet.buf[R502A_CC_IDX] == R502A_NOT_MATCH_CC) {
val->val1 = R502A_FINGER_MATCH_NOT_FOUND;
LOG_ERR("Fingerprint not matched");
ret = -ENOENT;
} else {
led_ctrl.ctrl_code = R502A_LED_CTRL_ON_ALWAYS;
led_ctrl.color_idx = R502A_LED_COLOR_RED;
fps_led_control(dev, &led_ctrl);
LOG_ERR("Error Matching templates 0x%X",
rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
}
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_capture(const struct device *dev)
{
struct grow_r502a_data *drv_data = dev->data;
int ret;
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = fps_get_image(dev);
if (ret != 0) {
goto unlock;
}
ret = fps_image_to_char(dev, R502A_CHAR_BUF_1);
if (ret != 0) {
goto unlock;
}
ret = fps_get_image(dev);
if (ret != 0) {
goto unlock;
}
ret = fps_image_to_char(dev, R502A_CHAR_BUF_2);
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
/**
* @brief upload template from sensor device's RAM buffer 1 to controller.
*
* @result temp->data holds the template to be uploaded to controller.
* temp->len holds the length of the template.
*/
int fps_upload_char_buf(const struct device *dev, struct r502a_template *temp)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const upload_temp_len = 2;
int ret = 0, idx = 0;
if (!temp->data || (temp->len < R502A_TEMPLATE_MAX_SIZE)) {
LOG_ERR("Invalid temp data");
return -EINVAL;
}
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_UPCHAR, R502A_CHAR_BUF_1}
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, upload_temp_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Upload to host controller");
} else {
LOG_ERR("Error uploading template 0x%X",
rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
goto unlock;
}
do {
ret = transceive_packet(dev, NULL, &rx_packet, 0);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
memcpy(&temp->data[idx], &rx_packet.data,
sys_be16_to_cpu(rx_packet.len) - R502A_CHECKSUM_LEN);
idx += sys_be16_to_cpu(rx_packet.len) - R502A_CHECKSUM_LEN;
} while (rx_packet.pid != R502A_END_DATA_PACKET);
temp->len = idx;
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
/**
* @brief download template from controller to sensor device's RAM buffer.
* @Notes char_buf_id - other than value 1 will be considered as value 2
* by R502A sensor.
*/
int fps_download_char_buf(const struct device *dev, uint8_t char_buf_id,
const struct r502a_template *temp)
{
struct grow_r502a_data *drv_data = dev->data;
union r502a_packet rx_packet = {0};
char const down_temp_len = 2;
int ret = 0, i = 0;
if (!temp->data || (temp->len < R502A_TEMPLATE_MAX_SIZE)) {
LOG_ERR("Invalid temp data");
return -EINVAL;
}
union r502a_packet tx_packet = {
.pid = R502A_COMMAND_PACKET,
.data = {R502A_DOWNCHAR, char_buf_id}
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = transceive_packet(dev, &tx_packet, &rx_packet, down_temp_len);
if (ret != 0) {
goto unlock;
}
ret = r502a_validate_rx_packet(&rx_packet);
if (ret != 0) {
goto unlock;
}
if (rx_packet.buf[R502A_CC_IDX] == R502A_OK) {
LOG_DBG("Download to R502A sensor");
} else {
LOG_ERR("Error downloading template 0x%X",
rx_packet.buf[R502A_CC_IDX]);
ret = -EIO;
goto unlock;
}
while (i < (R502A_TEMPLATE_MAX_SIZE - CONFIG_R502A_DATA_PKT_SIZE)) {
tx_packet.pid = R502A_DATA_PACKET;
memcpy(tx_packet.data, &temp->data[i], CONFIG_R502A_DATA_PKT_SIZE);
ret = transceive_packet(dev, &tx_packet, NULL, CONFIG_R502A_DATA_PKT_SIZE);
if (ret != 0) {
goto unlock;
}
i += CONFIG_R502A_DATA_PKT_SIZE;
}
memcpy(tx_packet.data, &temp->data[i], (R502A_TEMPLATE_MAX_SIZE - i));
tx_packet.pid = R502A_END_DATA_PACKET;
ret = transceive_packet(dev, &tx_packet, NULL, (R502A_TEMPLATE_MAX_SIZE - i));
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int fps_init(const struct device *dev)
{
struct grow_r502a_data *drv_data = dev->data;
struct sensor_value val;
int ret;
struct r502a_led_params led_ctrl = {
.ctrl_code = R502A_LED_CTRL_FLASHING,
.color_idx = R502A_LED_COLOR_PURPLE,
.speed = R502A_LED_SPEED_HALF,
.cycle = 0x02,
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = fps_verify_password(dev);
if (ret != 0) {
goto unlock;
}
val.val1 = R502A_DATA_PKG_LEN;
val.val2 = LOG2(CONFIG_R502A_DATA_PKT_SIZE >> 5);
ret = fps_set_sys_param(dev, &val);
if (ret != 0) {
goto unlock;
}
ret = fps_led_control(dev, &led_ctrl);
unlock:
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int grow_r502a_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct grow_r502a_data *drv_data = dev->data;
int ret;
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = fps_get_template_count(dev);
k_mutex_unlock(&drv_data->lock);
return ret;
}
static int grow_r502a_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct grow_r502a_data *drv_data = dev->data;
if ((enum sensor_channel_grow_r502a)chan == SENSOR_CHAN_FINGERPRINT) {
val->val1 = drv_data->template_count;
} else {
LOG_ERR("Invalid channel");
return -ENOTSUP;
}
return 0;
}
static int grow_r502a_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
struct grow_r502a_data *drv_data = dev->data;
if ((enum sensor_channel_grow_r502a)chan != SENSOR_CHAN_FINGERPRINT) {
LOG_ERR("Channel not supported");
return -ENOTSUP;
}
switch ((enum sensor_attribute_grow_r502a)attr) {
case SENSOR_ATTR_R502A_CAPTURE:
return fps_capture(dev);
case SENSOR_ATTR_R502A_TEMPLATE_CREATE:
return fps_create_model(dev);
case SENSOR_ATTR_R502A_RECORD_ADD:
return fps_store_model(dev, val->val1);
case SENSOR_ATTR_R502A_RECORD_DEL:
return fps_delete_model(dev, val->val1, val->val2);
case SENSOR_ATTR_R502A_RECORD_EMPTY:
return fps_empty_db(dev);
case SENSOR_ATTR_R502A_RECORD_LOAD:
return fps_load_template(dev, val->val1);
case SENSOR_ATTR_R502A_SYS_PARAM: {
int ret = 0;
if (val->val1 == R502A_DATA_PKG_LEN) {
LOG_ERR("Data package length should not be runtime configurable");
return -EINVAL;
};
k_mutex_lock(&drv_data->lock, K_FOREVER);
ret = fps_set_sys_param(dev, val);
if (ret != 0) {
k_mutex_unlock(&drv_data->lock);
return ret;
}
k_mutex_unlock(&drv_data->lock);
return 0;
}
default:
LOG_ERR("Sensor attribute not supported");
return -ENOTSUP;
}
}
static int grow_r502a_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
int ret;
if ((enum sensor_channel_grow_r502a)chan != SENSOR_CHAN_FINGERPRINT) {
LOG_ERR("Channel not supported");
return -ENOTSUP;
}
switch ((enum sensor_attribute_grow_r502a)attr) {
case SENSOR_ATTR_R502A_RECORD_FIND:
ret = fps_search(dev, val);
break;
case SENSOR_ATTR_R502A_RECORD_FREE_IDX:
ret = fps_read_template_table(dev, &val->val1);
break;
case SENSOR_ATTR_R502A_COMPARE:
ret = fps_match_templates(dev, val);
break;
default:
LOG_ERR("Sensor attribute not supported");
ret = -ENOTSUP;
break;
}
return ret;
}
static void grow_r502a_uart_flush(const struct device *dev)
{
uint8_t c;
while (uart_fifo_read(dev, &c, 1) > 0) {
continue;
}
}
static int grow_r502a_init(const struct device *dev)
{
const struct grow_r502a_config *cfg = dev->config;
struct grow_r502a_data *drv_data = dev->data;
int ret;
if (!device_is_ready(cfg->dev)) {
LOG_ERR("%s: grow_r502a device not ready", dev->name);
return -ENODEV;
}
if (IS_ENABLED(CONFIG_GROW_R502A_GPIO_POWER)) {
if (!gpio_is_ready_dt(&cfg->vin_gpios)) {
LOG_ERR("GPIO port %s not ready", cfg->vin_gpios.port->name);
return -ENODEV;
}
ret = gpio_pin_configure_dt(&cfg->vin_gpios, GPIO_OUTPUT_ACTIVE);
if (ret < 0) {
return ret;
}
k_sleep(K_MSEC(R502A_DELAY));
if (!gpio_is_ready_dt(&cfg->act_gpios)) {
LOG_ERR("GPIO port %s not ready", cfg->act_gpios.port->name);
return -ENODEV;
}
ret = gpio_pin_configure_dt(&cfg->act_gpios, GPIO_OUTPUT_ACTIVE);
if (ret < 0) {
return ret;
}
k_sleep(K_MSEC(R502A_DELAY));
}
grow_r502a_uart_flush(cfg->dev);
k_mutex_init(&drv_data->lock);
k_sem_init(&drv_data->uart_rx_sem, 0, 1);
k_sem_init(&drv_data->uart_tx_sem, 0, 1);
uart_irq_callback_user_data_set(cfg->dev, uart_cb_handler, (void *)dev);
uart_irq_rx_disable(cfg->dev);
uart_irq_tx_disable(cfg->dev);
#ifdef CONFIG_GROW_R502A_TRIGGER
ret = grow_r502a_init_interrupt(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupt!");
return ret;
}
#endif
return fps_init(dev);
}
static const struct sensor_driver_api grow_r502a_api = {
.sample_fetch = grow_r502a_sample_fetch,
.channel_get = grow_r502a_channel_get,
.attr_set = grow_r502a_attr_set,
.attr_get = grow_r502a_attr_get,
#ifdef CONFIG_GROW_R502A_TRIGGER
.trigger_set = grow_r502a_trigger_set,
#endif
};
#ifdef CONFIG_LED
static int grow_r502a_led_set_color(const struct device *dev, uint32_t led,
uint8_t num_colors, const uint8_t *color)
{
struct grow_r502a_data *drv_data = dev->data;
if (!(*color)) {
LOG_ERR("invalid color code value");
return -ENOTSUP;
}
drv_data->led_color = *color;
return 0;
}
static int grow_r502a_led_on(const struct device *dev, uint32_t led)
{
struct grow_r502a_data *drv_data = dev->data;
if (!drv_data->led_color) {
drv_data->led_color = R502A_LED_COLOR_BLUE;
}
struct r502a_led_params led_ctrl = {
.ctrl_code = R502A_LED_CTRL_ON_ALWAYS,
.color_idx = drv_data->led_color,
};
return fps_led_control(dev, &led_ctrl);
}
static int grow_r502a_led_off(const struct device *dev, uint32_t led)
{
struct r502a_led_params led_ctrl = {
.ctrl_code = R502A_LED_CTRL_OFF_ALWAYS,
};
return fps_led_control(dev, &led_ctrl);
}
static const struct led_driver_api grow_r502a_leds_api = {
.set_color = grow_r502a_led_set_color,
.on = grow_r502a_led_on,
.off = grow_r502a_led_off,
};
#endif
#define GROW_R502A_INIT(index) \
static struct grow_r502a_data grow_r502a_data_##index; \
\
static struct grow_r502a_config grow_r502a_config_##index = { \
.dev = DEVICE_DT_GET(DT_INST_BUS(index)), \
.comm_addr = DT_INST_REG_ADDR(index), \
IF_ENABLED(CONFIG_GROW_R502A_GPIO_POWER, \
(.vin_gpios = GPIO_DT_SPEC_INST_GET_OR(index, vin_gpios, {}), \
.act_gpios = GPIO_DT_SPEC_INST_GET_OR(index, act_gpios, {}),)) \
IF_ENABLED(CONFIG_GROW_R502A_TRIGGER, \
(.int_gpios = GPIO_DT_SPEC_INST_GET_OR(index, int_gpios, {}),)) \
}; \
\
DEVICE_DT_INST_DEFINE(index, &grow_r502a_init, NULL, &grow_r502a_data_##index, \
&grow_r502a_config_##index, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &grow_r502a_api); \
#define GROW_R502A_LED_INIT(index) \
DEVICE_DT_INST_DEFINE(index, NULL, NULL, &grow_r502a_data_##index, \
&grow_r502a_config_##index, POST_KERNEL, \
CONFIG_LED_INIT_PRIORITY, &grow_r502a_leds_api); \
#define DT_DRV_COMPAT hzgrow_r502a
DT_INST_FOREACH_STATUS_OKAY(GROW_R502A_INIT)
#undef DT_DRV_COMPAT
#ifdef CONFIG_LED
#define DT_DRV_COMPAT hzgrow_r502a_led
DT_INST_FOREACH_STATUS_OKAY(GROW_R502A_LED_INIT)
#undef DT_DRV_COMPAT
#endif
``` | /content/code_sandbox/drivers/sensor/grow_r502a/grow_r502a.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 9,473 |
```c
/*
*
*/
#define DT_DRV_COMPAT sensirion_sht4x
#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>
#include <zephyr/sys/crc.h>
#include <zephyr/drivers/sensor/sht4x.h>
#include "sht4x.h"
LOG_MODULE_REGISTER(SHT4X, CONFIG_SENSOR_LOG_LEVEL);
static uint8_t sht4x_compute_crc(uint16_t value)
{
uint8_t buf[2];
sys_put_be16(value, buf);
return crc8(buf, 2, SHT4X_CRC_POLY, SHT4X_CRC_INIT, false);
}
static int sht4x_write_command(const struct device *dev, uint8_t cmd)
{
const struct sht4x_config *cfg = dev->config;
uint8_t tx_buf[1] = { cmd };
return i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
}
static int sht4x_read_sample(const struct device *dev,
uint16_t *t_sample,
uint16_t *rh_sample)
{
const struct sht4x_config *cfg = dev->config;
uint8_t rx_buf[6];
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;
}
*t_sample = sys_get_be16(rx_buf);
if (sht4x_compute_crc(*t_sample) != rx_buf[2]) {
LOG_ERR("Invalid CRC for T.");
return -EIO;
}
*rh_sample = sys_get_be16(&rx_buf[3]);
if (sht4x_compute_crc(*rh_sample) != rx_buf[5]) {
LOG_ERR("Invalid CRC for RH.");
return -EIO;
}
return 0;
}
/* public API for handling the heater */
int sht4x_fetch_with_heater(const struct device *dev)
{
struct sht4x_data *data = dev->data;
int rc;
rc = sht4x_write_command(dev,
heater_cmd[data->heater_power][data->heater_duration]);
if (rc < 0) {
LOG_ERR("Failed to start measurement.");
return rc;
}
k_sleep(K_MSEC(heater_wait_ms[data->heater_duration]));
rc = sht4x_read_sample(dev, &data->t_sample, &data->rh_sample);
if (rc < 0) {
LOG_ERR("Failed to fetch data.");
return rc;
}
return 0;
}
static int sht4x_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct sht4x_config *cfg = dev->config;
struct sht4x_data *data = dev->data;
int rc;
if (chan != SENSOR_CHAN_ALL &&
chan != SENSOR_CHAN_AMBIENT_TEMP &&
chan != SENSOR_CHAN_HUMIDITY) {
return -ENOTSUP;
}
rc = sht4x_write_command(dev, measure_cmd[cfg->repeatability]);
if (rc < 0) {
LOG_ERR("Failed to start measurement.");
return rc;
}
k_sleep(K_USEC(measure_wait_us[cfg->repeatability]));
rc = sht4x_read_sample(dev, &data->t_sample, &data->rh_sample);
if (rc < 0) {
LOG_ERR("Failed to fetch data.");
return rc;
}
return 0;
}
static int sht4x_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct sht4x_data *data = dev->data;
/*
* See datasheet "Conversion of Signal Output" section
* for more details on processing sample data.
*/
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
int64_t tmp;
tmp = data->t_sample * 175;
val->val1 = (int32_t)(tmp / 0xFFFF) - 45;
val->val2 = ((tmp % 0xFFFF) * 1000000) / 0xFFFF;
} else if (chan == SENSOR_CHAN_HUMIDITY) {
uint64_t tmp;
tmp = data->rh_sample * 125U;
val->val1 = (uint32_t)(tmp / 0xFFFF) - 6U;
val->val2 = (tmp % 0xFFFF) * 15625U / 1024U;
} else {
return -ENOTSUP;
}
return 0;
}
static int sht4x_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct sht4x_data *data = dev->data;
if (val->val1 < 0) {
return -EINVAL;
}
switch ((enum sensor_attribute_sht4x)attr) {
case SENSOR_ATTR_SHT4X_HEATER_POWER:
if (val->val1 > SHT4X_HEATER_POWER_IDX_MAX) {
return -EINVAL;
}
data->heater_power = val->val1;
break;
case SENSOR_ATTR_SHT4X_HEATER_DURATION:
if (val->val1 > SHT4X_HEATER_DURATION_IDX_MAX) {
return -EINVAL;
}
data->heater_duration = val->val1;
break;
default:
return -ENOTSUP;
}
return 0;
}
static int sht4x_init(const struct device *dev)
{
const struct sht4x_config *cfg = dev->config;
int rc = 0;
if (!device_is_ready(cfg->bus.bus)) {
LOG_ERR("Device not ready.");
return -ENODEV;
}
rc = sht4x_write_command(dev, SHT4X_CMD_RESET);
if (rc < 0) {
LOG_ERR("Failed to reset the device.");
return rc;
}
k_sleep(K_MSEC(SHT4X_RESET_WAIT_MS));
return 0;
}
static const struct sensor_driver_api sht4x_api = {
.sample_fetch = sht4x_sample_fetch,
.channel_get = sht4x_channel_get,
.attr_set = sht4x_attr_set,
};
#define SHT4X_INIT(n) \
static struct sht4x_data sht4x_data_##n; \
\
static const struct sht4x_config sht4x_config_##n = { \
.bus = I2C_DT_SPEC_INST_GET(n), \
.repeatability = DT_INST_PROP(n, repeatability) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, \
sht4x_init, \
NULL, \
&sht4x_data_##n, \
&sht4x_config_##n, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&sht4x_api);
DT_INST_FOREACH_STATUS_OKAY(SHT4X_INIT)
``` | /content/code_sandbox/drivers/sensor/sensirion/sht4x/sht4x.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,599 |
```unknown
# SHT4x temperature and humidity sensor configuration options
config SHT4X
bool "SHT4x Temperature and Humidity Sensor"
default y
depends on DT_HAS_SENSIRION_SHT4X_ENABLED
select I2C
select CRC
help
Enable driver for SHT4x temperature and humidity sensors.
``` | /content/code_sandbox/drivers/sensor/sensirion/sht4x/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SHT4X_SHT4X_H_
#define ZEPHYR_DRIVERS_SENSOR_SHT4X_SHT4X_H_
#include <zephyr/device.h>
#define SHT4X_CMD_READ_SERIAL 0x89
#define SHT4X_CMD_RESET 0x94
#define SHT4X_RESET_WAIT_MS 1
#define SHT4X_HEATER_POWER_IDX_MAX 3
#define SHT4X_HEATER_DURATION_IDX_MAX 2
/*
* CRC parameters were taken from the
* "Checksum Calculation" section of the datasheet.
*/
#define SHT4X_CRC_POLY 0x31
#define SHT4X_CRC_INIT 0xFF
struct sht4x_config {
struct i2c_dt_spec bus;
uint8_t repeatability;
};
struct sht4x_data {
uint16_t t_sample;
uint16_t rh_sample;
uint8_t heater_power;
uint8_t heater_duration;
};
static const uint8_t measure_cmd[3] = {
0xE0, 0xF6, 0xFD
};
static const uint16_t measure_wait_us[3] = {
1700, 4500, 8200
};
/*
* heater specifics
*
* power:
* High power heater pulse -> ~200 mW @3.3V
* Medium power heater pulse -> ~110 mW @3.3V
* Low power heater pulse -> ~20 mW @3.3V
*
* duration:
* Long heater pulse -> 1.1s
* Short heater pulse -> 0.11s
*/
static const int8_t heater_cmd[SHT4X_HEATER_POWER_IDX_MAX][SHT4X_HEATER_DURATION_IDX_MAX] = {
{ 0x39, 0x32 },
{ 0x2F, 0x24 },
{ 0x1E, 0x15 }
};
static const uint32_t heater_wait_ms[SHT4X_HEATER_DURATION_IDX_MAX] = {
1000, 100
};
#endif /* ZEPHYR_DRIVERS_SENSOR_SHT4X_SHT4X_H_ */
``` | /content/code_sandbox/drivers/sensor/sensirion/sht4x/sht4x.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 470 |
```unknown
# SGP40 multipixel gas sensor configuration options
config SGP40
bool "SGP40 Multipixel Gas Sensor"
default y
depends on DT_HAS_SENSIRION_SGP40_ENABLED
select I2C
select CRC
help
Enable driver for SGP40 Multipixel Gas Sensor.
``` | /content/code_sandbox/drivers/sensor/sensirion/sgp40/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 65 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SGP40_SGP40_H_
#define ZEPHYR_DRIVERS_SENSOR_SGP40_SGP40_H_
#include <zephyr/device.h>
#define SGP40_CMD_MEASURE_RAW 0x260F
#define SGP40_CMD_MEASURE_TEST 0x280E
#define SGP40_CMD_HEATER_OFF 0x3615
#define SGP40_TEST_OK 0xD400
#define SGP40_TEST_FAIL 0x4B00
#define SGP40_RESET_WAIT_MS 10
#define SGP40_MEASURE_WAIT_MS 30
#define SGP40_TEST_WAIT_MS 250
/*
* CRC parameters were taken from the
* "Checksum Calculation" section of the datasheet.
*/
#define SGP40_CRC_POLY 0x31
#define SGP40_CRC_INIT 0xFF
/*
* Value range of compensation data parameters
*/
#define SGP40_COMP_MIN_RH 0
#define SGP40_COMP_MAX_RH 100
#define SGP40_COMP_MIN_T -45
#define SGP40_COMP_MAX_T 130
#define SGP40_COMP_DEFAULT_T 25
#define SGP40_COMP_DEFAULT_RH 50
struct sgp40_config {
struct i2c_dt_spec bus;
bool selftest;
};
struct sgp40_data {
uint16_t raw_sample;
int8_t rh_param[3];
int8_t t_param[3];
};
#endif /* ZEPHYR_DRIVERS_SENSOR_SGP40_SGP40_H_ */
``` | /content/code_sandbox/drivers/sensor/sensirion/sgp40/sgp40.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 328 |
```c
/*
*
*/
#define DT_DRV_COMPAT sensirion_sgp40
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/crc.h>
#include <zephyr/drivers/sensor/sgp40.h>
#include "sgp40.h"
LOG_MODULE_REGISTER(SGP40, CONFIG_SENSOR_LOG_LEVEL);
static uint8_t sgp40_compute_crc(uint16_t value)
{
uint8_t buf[2];
sys_put_be16(value, buf);
return crc8(buf, 2, SGP40_CRC_POLY, SGP40_CRC_INIT, false);
}
static int sgp40_write_command(const struct device *dev, uint16_t cmd)
{
const struct sgp40_config *cfg = dev->config;
uint8_t tx_buf[2];
sys_put_be16(cmd, tx_buf);
return i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
}
static int sgp40_start_measurement(const struct device *dev)
{
const struct sgp40_config *cfg = dev->config;
struct sgp40_data *data = dev->data;
uint8_t tx_buf[8];
sys_put_be16(SGP40_CMD_MEASURE_RAW, tx_buf);
sys_put_be24(sys_get_be24(data->rh_param), &tx_buf[2]);
sys_put_be24(sys_get_be24(data->t_param), &tx_buf[5]);
return i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
}
static int sgp40_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct sgp40_data *data = dev->data;
/*
* Temperature and RH conversion to ticks as explained in datasheet
* in section "I2C commands"
*/
switch ((enum sensor_attribute_sgp40)attr) {
case SENSOR_ATTR_SGP40_TEMPERATURE:
{
uint16_t t_ticks;
int16_t tmp;
tmp = (int16_t)CLAMP(val->val1, SGP40_COMP_MIN_T, SGP40_COMP_MAX_T);
/* adding +87 to avoid most rounding errors through truncation */
t_ticks = (uint16_t)((((tmp + 45) * 65535) + 87) / 175);
sys_put_be16(t_ticks, data->t_param);
data->t_param[2] = sgp40_compute_crc(t_ticks);
}
break;
case SENSOR_ATTR_SGP40_HUMIDITY:
{
uint16_t rh_ticks;
uint8_t tmp;
tmp = (uint8_t)CLAMP(val->val1, SGP40_COMP_MIN_RH, SGP40_COMP_MAX_RH);
/* adding +50 to eliminate rounding errors through truncation */
rh_ticks = (uint16_t)(((tmp * 65535U) + 50U) / 100U);
sys_put_be16(rh_ticks, data->rh_param);
data->rh_param[2] = sgp40_compute_crc(rh_ticks);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int sgp40_selftest(const struct device *dev)
{
const struct sgp40_config *cfg = dev->config;
uint8_t rx_buf[3];
uint16_t raw_sample;
int rc;
rc = sgp40_write_command(dev, SGP40_CMD_MEASURE_TEST);
if (rc < 0) {
LOG_ERR("Failed to start selftest!");
return rc;
}
k_sleep(K_MSEC(SGP40_TEST_WAIT_MS));
rc = i2c_read_dt(&cfg->bus, rx_buf, sizeof(rx_buf));
if (rc < 0) {
LOG_ERR("Failed to read data sample.");
return rc;
}
raw_sample = sys_get_be16(rx_buf);
if (sgp40_compute_crc(raw_sample) != rx_buf[2]) {
LOG_ERR("Received invalid CRC from selftest.");
return -EIO;
}
if (raw_sample != SGP40_TEST_OK) {
LOG_ERR("Selftest failed.");
return -EIO;
}
return 0;
}
static int sgp40_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct sgp40_data *data = dev->data;
const struct sgp40_config *cfg = dev->config;
uint8_t rx_buf[3];
uint16_t raw_sample;
int rc;
if (chan != SENSOR_CHAN_GAS_RES && chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
rc = sgp40_start_measurement(dev);
if (rc < 0) {
LOG_ERR("Failed to start measurement.");
return rc;
}
k_sleep(K_MSEC(SGP40_MEASURE_WAIT_MS));
rc = i2c_read_dt(&cfg->bus, rx_buf, sizeof(rx_buf));
if (rc < 0) {
LOG_ERR("Failed to read data sample.");
return rc;
}
raw_sample = sys_get_be16(rx_buf);
if (sgp40_compute_crc(raw_sample) != rx_buf[2]) {
LOG_ERR("Invalid CRC8 for data sample.");
return -EIO;
}
data->raw_sample = raw_sample;
return 0;
}
static int sgp40_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct sgp40_data *data = dev->data;
if (chan != SENSOR_CHAN_GAS_RES) {
return -ENOTSUP;
}
val->val1 = data->raw_sample;
val->val2 = 0;
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int sgp40_pm_action(const struct device *dev,
enum pm_device_action action)
{
uint16_t cmd;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
/* activate the hotplate by sending a measure command */
cmd = SGP40_CMD_MEASURE_RAW;
break;
case PM_DEVICE_ACTION_SUSPEND:
cmd = SGP40_CMD_HEATER_OFF;
break;
default:
return -ENOTSUP;
}
return sgp40_write_command(dev, cmd);
}
#endif /* CONFIG_PM_DEVICE */
static int sgp40_init(const struct device *dev)
{
const struct sgp40_config *cfg = dev->config;
struct sensor_value comp_data;
if (!device_is_ready(cfg->bus.bus)) {
LOG_ERR("Device not ready.");
return -ENODEV;
}
if (cfg->selftest) {
int rc = sgp40_selftest(dev);
if (rc < 0) {
LOG_ERR("Selftest failed!");
return rc;
}
LOG_DBG("Selftest succeeded!");
}
comp_data.val1 = SGP40_COMP_DEFAULT_T;
sensor_attr_set(dev,
SENSOR_CHAN_GAS_RES,
(enum sensor_attribute) SENSOR_ATTR_SGP40_TEMPERATURE,
&comp_data);
comp_data.val1 = SGP40_COMP_DEFAULT_RH;
sensor_attr_set(dev,
SENSOR_CHAN_GAS_RES,
(enum sensor_attribute) SENSOR_ATTR_SGP40_HUMIDITY,
&comp_data);
return 0;
}
static const struct sensor_driver_api sgp40_api = {
.sample_fetch = sgp40_sample_fetch,
.channel_get = sgp40_channel_get,
.attr_set = sgp40_attr_set,
};
#define SGP40_INIT(n) \
static struct sgp40_data sgp40_data_##n; \
\
static const struct sgp40_config sgp40_config_##n = { \
.bus = I2C_DT_SPEC_INST_GET(n), \
.selftest = DT_INST_PROP(n, enable_selftest), \
}; \
\
PM_DEVICE_DT_INST_DEFINE(n, sgp40_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, \
sgp40_init, \
PM_DEVICE_DT_INST_GET(n), \
&sgp40_data_##n, \
&sgp40_config_##n, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&sgp40_api);
DT_INST_FOREACH_STATUS_OKAY(SGP40_INIT)
``` | /content/code_sandbox/drivers/sensor/sensirion/sgp40/sgp40.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,838 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SHT3XD_SHT3XD_H_
#define ZEPHYR_DRIVERS_SENSOR_SHT3XD_SHT3XD_H_
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#define SHT3XD_CMD_FETCH 0xE000
#define SHT3XD_CMD_ART 0x2B32
#define SHT3XD_CMD_READ_STATUS 0xF32D
#define SHT3XD_CMD_CLEAR_STATUS 0x3041
#define SHT3XD_CMD_WRITE_TH_HIGH_SET 0x611D
#define SHT3XD_CMD_WRITE_TH_HIGH_CLEAR 0x6116
#define SHT3XD_CMD_WRITE_TH_LOW_SET 0x610B
#define SHT3XD_CMD_WRITE_TH_LOW_CLEAR 0x6100
#if CONFIG_SHT3XD_REPEATABILITY_LOW
#define SHT3XD_REPEATABILITY_IDX 0
#elif CONFIG_SHT3XD_REPEATABILITY_MEDIUM
#define SHT3XD_REPEATABILITY_IDX 1
#elif CONFIG_SHT3XD_REPEATABILITY_HIGH
#define SHT3XD_REPEATABILITY_IDX 2
#endif
#if CONFIG_SHT3XD_MPS_05
#define SHT3XD_MPS_IDX 0
#elif CONFIG_SHT3XD_MPS_1
#define SHT3XD_MPS_IDX 1
#elif CONFIG_SHT3XD_MPS_2
#define SHT3XD_MPS_IDX 2
#elif CONFIG_SHT3XD_MPS_4
#define SHT3XD_MPS_IDX 3
#elif CONFIG_SHT3XD_MPS_10
#define SHT3XD_MPS_IDX 4
#endif
#define SHT3XD_CLEAR_STATUS_WAIT_USEC 1000
struct sht3xd_config {
struct i2c_dt_spec bus;
#ifdef CONFIG_SHT3XD_TRIGGER
struct gpio_dt_spec alert_gpio;
#endif /* CONFIG_SHT3XD_TRIGGER */
};
struct sht3xd_data {
uint16_t t_sample;
uint16_t rh_sample;
#ifdef CONFIG_SHT3XD_TRIGGER
const struct device *dev;
struct gpio_callback alert_cb;
uint16_t t_low;
uint16_t t_high;
uint16_t rh_low;
uint16_t rh_high;
sensor_trigger_handler_t handler;
const struct sensor_trigger *trigger;
#if defined(CONFIG_SHT3XD_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_SHT3XD_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_SHT3XD_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_SHT3XD_TRIGGER */
};
#ifdef CONFIG_SHT3XD_TRIGGER
int sht3xd_write_command(const struct device *dev, uint16_t cmd);
int sht3xd_write_reg(const struct device *dev, uint16_t cmd, uint16_t val);
int sht3xd_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
int sht3xd_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int sht3xd_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_SHT3XD_SHT3XD_H_ */
``` | /content/code_sandbox/drivers/sensor/sensirion/sht3xd/sht3xd.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 740 |
```unknown
# SHT3xD temperature and humidity sensor configuration options
menuconfig SHT3XD
bool "SHT3xD Temperature and Humidity Sensor"
default y
depends on DT_HAS_SENSIRION_SHT3XD_ENABLED
select I2C
select CRC
help
Enable driver for SHT3xD temperature and humidity sensors.
if SHT3XD
choice SHT3XD_TRIGGER_MODE
prompt "Trigger mode"
default SHT3XD_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config SHT3XD_TRIGGER_NONE
bool "No trigger"
config SHT3XD_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select SHT3XD_TRIGGER
config SHT3XD_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select SHT3XD_TRIGGER
endchoice
config SHT3XD_TRIGGER
bool
config SHT3XD_THREAD_PRIORITY
int "Thread priority"
depends on SHT3XD_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config SHT3XD_THREAD_STACK_SIZE
int "Thread stack size"
depends on SHT3XD_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
choice SHT3XD_REPEATABILITY
prompt "Measurement repeatability"
default SHT3XD_REPEATABILITY_HIGH
help
Repeatability modes differ with respect to measurement duration,
noise level and energy consumption.
config SHT3XD_REPEATABILITY_LOW
bool "low"
config SHT3XD_REPEATABILITY_MEDIUM
bool "medium"
config SHT3XD_REPEATABILITY_HIGH
bool "high"
endchoice
choice SHT3XD_MEASUREMENT_MODE
prompt "Measurement mode"
default SHT3XD_PERIODIC_MODE
config SHT3XD_SINGLE_SHOT_MODE
bool "single shot"
config SHT3XD_PERIODIC_MODE
bool "periodic data acquisition"
endchoice
choice SHT3XD_MPS
prompt "Measurements per second"
default SHT3XD_MPS_1
depends on SHT3XD_PERIODIC_MODE
help
Number of measurements per second.
config SHT3XD_MPS_05
bool "0.5"
config SHT3XD_MPS_1
bool "1"
config SHT3XD_MPS_2
bool "2"
config SHT3XD_MPS_4
bool "4"
config SHT3XD_MPS_10
bool "10"
endchoice
endif # SHT3XD
``` | /content/code_sandbox/drivers/sensor/sensirion/sht3xd/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 561 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "sht3xd.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(SHT3XD, CONFIG_SENSOR_LOG_LEVEL);
static uint16_t sht3xd_temp_processed_to_raw(const struct sensor_value *val)
{
uint64_t uval;
/* ret = (val + 45) * (2^16 - 1) / 175 */
uval = (uint64_t)(val->val1 + 45) * 1000000U + val->val2;
return ((uval * 0xFFFF) / 175) / 1000000;
}
static int sht3xd_rh_processed_to_raw(const struct sensor_value *val)
{
uint64_t uval;
/* ret = val * (2^16 -1) / 100 */
uval = (uint64_t)val->val1 * 1000000U + val->val2;
return ((uval * 0xFFFF) / 100) / 1000000;
}
int sht3xd_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct sht3xd_data *data = dev->data;
uint16_t set_cmd, clear_cmd, reg_val, temp, rh;
if (attr == SENSOR_ATTR_LOWER_THRESH) {
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
data->t_low = sht3xd_temp_processed_to_raw(val);
} else if (chan == SENSOR_CHAN_HUMIDITY) {
data->rh_low = sht3xd_rh_processed_to_raw(val);
} else {
return -ENOTSUP;
}
set_cmd = SHT3XD_CMD_WRITE_TH_LOW_SET;
clear_cmd = SHT3XD_CMD_WRITE_TH_LOW_CLEAR;
temp = data->t_low;
rh = data->rh_low;
} else if (attr == SENSOR_ATTR_UPPER_THRESH) {
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
data->t_high = sht3xd_temp_processed_to_raw(val);
} else if (chan == SENSOR_CHAN_HUMIDITY) {
data->rh_high = sht3xd_rh_processed_to_raw(val);
} else {
return -ENOTSUP;
}
set_cmd = SHT3XD_CMD_WRITE_TH_HIGH_SET;
clear_cmd = SHT3XD_CMD_WRITE_TH_HIGH_CLEAR;
temp = data->t_high;
rh = data->rh_high;
} else {
return -ENOTSUP;
}
reg_val = (rh & 0xFE00) | ((temp & 0xFF80) >> 7);
if (sht3xd_write_reg(dev, set_cmd, reg_val) < 0 ||
sht3xd_write_reg(dev, clear_cmd, reg_val) < 0) {
LOG_DBG("Failed to write threshold value!");
return -EIO;
}
return 0;
}
static inline void setup_alert(const struct device *dev,
bool enable)
{
const struct sht3xd_config *cfg =
(const struct sht3xd_config *)dev->config;
unsigned int flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->alert_gpio, flags);
}
static inline void handle_alert(const struct device *dev)
{
setup_alert(dev, false);
#if defined(CONFIG_SHT3XD_TRIGGER_OWN_THREAD)
struct sht3xd_data *data = dev->data;
k_sem_give(&data->gpio_sem);
#elif defined(CONFIG_SHT3XD_TRIGGER_GLOBAL_THREAD)
struct sht3xd_data *data = dev->data;
k_work_submit(&data->work);
#endif
}
int sht3xd_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct sht3xd_data *data = dev->data;
const struct sht3xd_config *cfg =
(const struct sht3xd_config *)dev->config;
setup_alert(dev, false);
if (trig->type != SENSOR_TRIG_THRESHOLD) {
return -ENOTSUP;
}
data->handler = handler;
if (handler == NULL) {
return 0;
}
data->trigger = trig;
setup_alert(dev, true);
/* If ALERT is active we probably won't get the rising edge,
* so invoke the callback manually.
*/
if (gpio_pin_get_dt(&cfg->alert_gpio)) {
handle_alert(dev);
}
return 0;
}
static void sht3xd_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct sht3xd_data *data =
CONTAINER_OF(cb, struct sht3xd_data, alert_cb);
handle_alert(data->dev);
}
static void sht3xd_thread_cb(const struct device *dev)
{
struct sht3xd_data *data = dev->data;
if (data->handler != NULL) {
data->handler(dev, data->trigger);
}
setup_alert(dev, true);
}
#ifdef CONFIG_SHT3XD_TRIGGER_OWN_THREAD
static void sht3xd_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct sht3xd_data *data = p1;
while (1) {
k_sem_take(&data->gpio_sem, K_FOREVER);
sht3xd_thread_cb(data->dev);
}
}
#endif
#ifdef CONFIG_SHT3XD_TRIGGER_GLOBAL_THREAD
static void sht3xd_work_cb(struct k_work *work)
{
struct sht3xd_data *data =
CONTAINER_OF(work, struct sht3xd_data, work);
sht3xd_thread_cb(data->dev);
}
#endif
int sht3xd_init_interrupt(const struct device *dev)
{
struct sht3xd_data *data = dev->data;
const struct sht3xd_config *cfg = dev->config;
int rc;
if (!gpio_is_ready_dt(&cfg->alert_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
rc = gpio_pin_configure_dt(&cfg->alert_gpio, GPIO_INPUT);
if (rc != 0) {
LOG_DBG("Failed to configure alert pin %u!", cfg->alert_gpio.pin);
return -EIO;
}
gpio_init_callback(&data->alert_cb, sht3xd_gpio_callback,
BIT(cfg->alert_gpio.pin));
rc = gpio_add_callback(cfg->alert_gpio.port, &data->alert_cb);
if (rc < 0) {
LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
/* set alert thresholds to match measurement ranges */
data->t_low = 0U;
data->rh_low = 0U;
data->t_high = 0xFFFF;
data->rh_high = 0xFFFF;
if (sht3xd_write_reg(dev, SHT3XD_CMD_WRITE_TH_HIGH_SET, 0xFFFF)
< 0) {
LOG_DBG("Failed to write threshold high set value!");
return -EIO;
}
if (sht3xd_write_reg(dev, SHT3XD_CMD_WRITE_TH_HIGH_CLEAR,
0xFFFF) < 0) {
LOG_DBG("Failed to write threshold high clear value!");
return -EIO;
}
if (sht3xd_write_reg(dev, SHT3XD_CMD_WRITE_TH_LOW_SET, 0) < 0) {
LOG_DBG("Failed to write threshold low set value!");
return -EIO;
}
if (sht3xd_write_reg(dev, SHT3XD_CMD_WRITE_TH_LOW_SET, 0) < 0) {
LOG_DBG("Failed to write threshold low clear value!");
return -EIO;
}
#if defined(CONFIG_SHT3XD_TRIGGER_OWN_THREAD)
k_sem_init(&data->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_SHT3XD_THREAD_STACK_SIZE,
sht3xd_thread, data,
NULL, NULL, K_PRIO_COOP(CONFIG_SHT3XD_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_SHT3XD_TRIGGER_GLOBAL_THREAD)
data->work.handler = sht3xd_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/sensirion/sht3xd/sht3xd_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,846 |
```c
/*
*
*/
#define DT_DRV_COMPAT sensirion_sht3xd
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/crc.h>
#include <zephyr/logging/log.h>
#include "sht3xd.h"
LOG_MODULE_REGISTER(SHT3XD, CONFIG_SENSOR_LOG_LEVEL);
#ifdef CONFIG_SHT3XD_SINGLE_SHOT_MODE
static const uint16_t measure_cmd[3] = {
0x2416, 0x240B, 0x2400
};
#endif
#ifdef CONFIG_SHT3XD_PERIODIC_MODE
static const uint16_t measure_cmd[5][3] = {
{ 0x202F, 0x2024, 0x2032 },
{ 0x212D, 0x2126, 0x2130 },
{ 0x222B, 0x2220, 0x2236 },
{ 0x2329, 0x2322, 0x2334 },
{ 0x272A, 0x2721, 0x2737 }
};
#endif
static const int measure_wait[3] = {
4000, 6000, 15000
};
/*
* CRC algorithm parameters were taken from the
* "Checksum Calculation" section of the datasheet.
*/
static uint8_t sht3xd_compute_crc(uint16_t value)
{
uint8_t buf[2];
sys_put_be16(value, buf);
return crc8(buf, 2, 0x31, 0xFF, false);
}
int sht3xd_write_command(const struct device *dev, uint16_t cmd)
{
const struct sht3xd_config *config = dev->config;
uint8_t tx_buf[2];
sys_put_be16(cmd, tx_buf);
return i2c_write_dt(&config->bus, tx_buf, sizeof(tx_buf));
}
int sht3xd_write_reg(const struct device *dev, uint16_t cmd, uint16_t val)
{
const struct sht3xd_config *config = dev->config;
uint8_t tx_buf[5];
sys_put_be16(cmd, &tx_buf[0]);
sys_put_be16(val, &tx_buf[2]);
tx_buf[4] = sht3xd_compute_crc(val);
return i2c_write_dt(&config->bus, tx_buf, sizeof(tx_buf));
}
static int sht3xd_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct sht3xd_config *config = dev->config;
struct sht3xd_data *data = dev->data;
uint8_t rx_buf[6];
uint16_t t_sample, rh_sample;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
#ifdef CONFIG_SHT3XD_SINGLE_SHOT_MODE
/* start single shot measurement */
if (sht3xd_write_command(dev,
measure_cmd[SHT3XD_REPEATABILITY_IDX])
< 0) {
LOG_DBG("Failed to set single shot measurement mode!");
return -EIO;
}
k_sleep(K_MSEC(measure_wait[SHT3XD_REPEATABILITY_IDX] / USEC_PER_MSEC));
if (i2c_read_dt(&config->bus, rx_buf, sizeof(rx_buf)) < 0) {
LOG_DBG("Failed to read data sample!");
return -EIO;
}
#endif
#ifdef CONFIG_SHT3XD_PERIODIC_MODE
uint8_t tx_buf[2];
sys_put_be16(SHT3XD_CMD_FETCH, tx_buf);
if (i2c_write_read_dt(&config->bus, tx_buf, sizeof(tx_buf),
rx_buf, sizeof(rx_buf)) < 0) {
LOG_DBG("Failed to read data sample!");
return -EIO;
}
#endif
t_sample = sys_get_be16(&rx_buf[0]);
if (sht3xd_compute_crc(t_sample) != rx_buf[2]) {
LOG_DBG("Received invalid temperature CRC!");
return -EIO;
}
rh_sample = sys_get_be16(&rx_buf[3]);
if (sht3xd_compute_crc(rh_sample) != rx_buf[5]) {
LOG_DBG("Received invalid relative humidity CRC!");
return -EIO;
}
data->t_sample = t_sample;
data->rh_sample = rh_sample;
return 0;
}
static int sht3xd_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct sht3xd_data *data = dev->data;
uint64_t tmp;
/*
* See datasheet "Conversion of Signal Output" section
* for more details on processing sample data.
*/
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
/* val = -45 + 175 * sample / (2^16 -1) */
tmp = (uint64_t)data->t_sample * 175U;
val->val1 = (int32_t)(tmp / 0xFFFF) - 45;
val->val2 = ((tmp % 0xFFFF) * 1000000U) / 0xFFFF;
} else if (chan == SENSOR_CHAN_HUMIDITY) {
/* val = 100 * sample / (2^16 -1) */
uint32_t tmp2 = (uint32_t)data->rh_sample * 100U;
val->val1 = tmp2 / 0xFFFF;
/* x * 100000 / 65536 == x * 15625 / 1024 */
val->val2 = (tmp2 % 0xFFFF) * 15625U / 1024;
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api sht3xd_driver_api = {
#ifdef CONFIG_SHT3XD_TRIGGER
.attr_set = sht3xd_attr_set,
.trigger_set = sht3xd_trigger_set,
#endif
.sample_fetch = sht3xd_sample_fetch,
.channel_get = sht3xd_channel_get,
};
static int sht3xd_init(const struct device *dev)
{
const struct sht3xd_config *cfg = dev->config;
if (!device_is_ready(cfg->bus.bus)) {
LOG_ERR("I2C bus %s is not ready!", cfg->bus.bus->name);
return -EINVAL;
}
/* clear status register */
if (sht3xd_write_command(dev, SHT3XD_CMD_CLEAR_STATUS) < 0) {
LOG_DBG("Failed to clear status register!");
return -EIO;
}
k_busy_wait(SHT3XD_CLEAR_STATUS_WAIT_USEC);
#ifdef CONFIG_SHT3XD_PERIODIC_MODE
/* set periodic measurement mode */
if (sht3xd_write_command(dev,
measure_cmd[SHT3XD_MPS_IDX][SHT3XD_REPEATABILITY_IDX])
< 0) {
LOG_DBG("Failed to set measurement mode!");
return -EIO;
}
k_busy_wait(measure_wait[SHT3XD_REPEATABILITY_IDX]);
#endif
#ifdef CONFIG_SHT3XD_TRIGGER
struct sht3xd_data *data = dev->data;
data->dev = dev;
if (sht3xd_init_interrupt(dev) < 0) {
LOG_DBG("Failed to initialize interrupt");
return -EIO;
}
#endif
return 0;
}
#ifdef CONFIG_SHT3XD_TRIGGER
#define SHT3XD_TRIGGER_INIT(inst) \
.alert_gpio = GPIO_DT_SPEC_INST_GET(inst, alert_gpios),
#else
#define SHT3XD_TRIGGER_INIT(inst)
#endif
#define SHT3XD_DEFINE(inst) \
struct sht3xd_data sht3xd0_data_##inst; \
static const struct sht3xd_config sht3xd0_cfg_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
SHT3XD_TRIGGER_INIT(inst) \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, sht3xd_init, NULL, \
&sht3xd0_data_##inst, &sht3xd0_cfg_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&sht3xd_driver_api);
DT_INST_FOREACH_STATUS_OKAY(SHT3XD_DEFINE)
``` | /content/code_sandbox/drivers/sensor/sensirion/sht3xd/sht3xd.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,831 |
```objective-c
/* HopeRF Electronic HP206C precision barometer and altimeter header
*
*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_HP206C_HP206C_H_
#define ZEPHYR_DRIVERS_SENSOR_HP206C_HP206C_H_
#include <zephyr/sys/util.h>
#define HP206C_I2C_ADDRESS 0x76
/* HP206C configuration registers */
#define HP206C_REG_ALT_OFF_LSB 0x00
#define HP206C_REG_ALT_OFF_MSB 0x01
#define HP206C_REG_PA_H_TH_LSB 0x02
#define HP206C_REG_PA_H_TH_MSB 0x03
#define HP206C_REG_PA_M_TH_LSB 0x04
#define HP206C_REG_PA_M_TH_MSB 0x05
#define HP206C_REG_PA_L_TH_LSB 0x06
#define HP206C_REG_PA_L_TH_MSB 0x07
#define HP206C_REG_T_H_TH 0x08
#define HP206C_REG_T_M_TH 0x09
#define HP206C_REG_T_L_TH 0x0A
#define HP206C_REG_INT_EN 0x0B
#define HP206C_REG_INT_GFG 0x0C
#define HP206C_REG_INT_SRC 0x0D
#define HP206C_REG_INT_DIR 0x0E
#define HP206C_REG_PARA 0x0F
/* HP206C commands */
#define HP206C_CMD_SOFT_RST 0x06
#define HP206C_CMD_ADC_CVT 0x40
#define HP206C_CMD_READ_PT 0x10
#define HP206C_CMD_READ_AT 0x11
#define HP206C_CMD_READ_P 0x30
#define HP206C_CMD_READ_A 0x31
#define HP206C_CMD_READ_T 0x32
#define HP206C_CMD_ANA_CAL 0x28
#define HP206C_CMD_READ_REG 0x80
#define HP206C_CMD_WRITE_REG 0xC0
#define HP206C_REG_ADDR_MASK 0x3F
/* HP206C_REG_INT_SRC */
#define HP206C_T_WIN BIT(0)
#define HP206C_PA_WIN BIT(1)
#define HP206C_T_TRAV BIT(2)
#define HP206C_PA_TRAV BIT(3)
#define HP206C_T_RDY BIT(4)
#define HP206C_PA_RDY BIT(5)
#define HP206C_DEV_RDY BIT(6)
#define HP206C_TH_ERR BIT(7)
/* HP206C_REG_PARA */
#define HP206C_COMPENSATION_EN BIT(7)
/* default settings, based on menuconfig options */
#if defined(CONFIG_HP206C_OSR_RUNTIME)
# define HP206C_DEFAULT_OSR 4096
#else
# define HP206C_DEFAULT_OSR CONFIG_HP206C_OSR
#endif
#if defined(CONFIG_HP206C_ALT_OFFSET_RUNTIME)
# define HP206C_DEFAULT_ALT_OFFSET 0
#else
# define HP206C_DEFAULT_ALT_OFFSET CONFIG_HP206C_ALT_OFFSET
#endif
/* end of default settings */
struct hp206c_device_config {
struct i2c_dt_spec i2c;
};
struct hp206c_device_data {
#if CONFIG_SYS_CLOCK_TICKS_PER_SEC < 1000
#error "driver needs millisecond tick granularity"
#endif
struct k_timer tmr;
uint8_t osr;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_HP206C_HP206C_H_ */
``` | /content/code_sandbox/drivers/sensor/hp206c/hp206c.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 771 |
```c
/* HopeRF Electronic HP206C precision barometer and altimeter driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT hoperf_hp206c
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include "hp206c.h"
LOG_MODULE_REGISTER(HP206C, CONFIG_SENSOR_LOG_LEVEL);
static inline int hp206c_bus_config(const struct device *dev)
{
const struct hp206c_device_config *cfg = dev->config;
uint32_t i2c_cfg;
i2c_cfg = I2C_MODE_CONTROLLER | I2C_SPEED_SET(I2C_SPEED_STANDARD);
return i2c_configure(cfg->i2c.bus, i2c_cfg);
}
static int hp206c_read(const struct device *dev, uint8_t cmd, uint8_t *data,
uint8_t len)
{
const struct hp206c_device_config *cfg = dev->config;
hp206c_bus_config(dev);
if (i2c_burst_read_dt(&cfg->i2c, cmd, data, len) < 0) {
return -EIO;
}
return 0;
}
static int hp206c_read_reg(const struct device *dev, uint8_t reg_addr,
uint8_t *reg_val)
{
uint8_t cmd = HP206C_CMD_READ_REG | (reg_addr & HP206C_REG_ADDR_MASK);
return hp206c_read(dev, cmd, reg_val, 1);
}
static int hp206c_write(const struct device *dev, uint8_t cmd, uint8_t *data,
uint8_t len)
{
const struct hp206c_device_config *cfg = dev->config;
hp206c_bus_config(dev);
if (i2c_burst_write_dt(&cfg->i2c, cmd, data, len) < 0) {
return -EIO;
}
return 0;
}
static int hp206c_write_reg(const struct device *dev, uint8_t reg_addr,
uint8_t reg_val)
{
uint8_t cmd = HP206C_CMD_WRITE_REG | (reg_addr & HP206C_REG_ADDR_MASK);
return hp206c_write(dev, cmd, ®_val, 1);
}
static int hp206c_cmd_send(const struct device *dev, uint8_t cmd)
{
const struct hp206c_device_config *cfg = dev->config;
hp206c_bus_config(dev);
return i2c_write_dt(&cfg->i2c, &cmd, 1);
}
/*
* The conversion times in this map were rounded up. The reason for doing that
* is merely to spare 24 bytes that, otherwise, would've been taken by having
* the times converted to microseconds. The trade-off is 900us added to the
* conversion wait time which looks like a good compromise provided the highest
* precision computation takes 131.1ms.
*/
static uint8_t hp206c_adc_time_ms[] = {
/* conversion time(ms), OSR */
132, /* 4096 */
66, /* 2048 */
34, /* 1024 */
17, /* 512 */
9, /* 256 */
5, /* 128 */
};
static int hp206c_osr_set(const struct device *dev, uint16_t osr)
{
struct hp206c_device_data *hp206c = dev->data;
uint8_t i;
/* the following code translates OSR values to an index */
for (i = 0U; i < 6 && BIT(12 - i) != osr; i++) {
}
if (i == 6U) {
return -ENOTSUP;
}
hp206c->osr = i;
return 0;
}
static int hp206c_altitude_offs_set(const struct device *dev, int16_t offs)
{
uint8_t reg_val;
reg_val = offs & 0xff;
if (hp206c_write_reg(dev, HP206C_REG_ALT_OFF_LSB, reg_val) < 0) {
return -EIO;
}
reg_val = (offs & 0xff00) >> 8;
if (hp206c_write_reg(dev, HP206C_REG_ALT_OFF_MSB, reg_val) < 0) {
return -EIO;
}
return hp206c_write_reg(dev, HP206C_REG_PARA, HP206C_COMPENSATION_EN);
}
static int hp206c_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
#ifdef CONFIG_HP206C_OSR_RUNTIME
if (attr == SENSOR_ATTR_OVERSAMPLING) {
return hp206c_osr_set(dev, val->val1);
}
#endif
#ifdef CONFIG_HP206C_ALT_OFFSET_RUNTIME
if (attr == SENSOR_ATTR_OFFSET) {
if (chan != SENSOR_CHAN_ALTITUDE) {
return -ENOTSUP;
}
return hp206c_altitude_offs_set(dev, val->val1);
}
#endif
return -ENOTSUP;
}
static int hp206c_wait_dev_ready(const struct device *dev,
uint32_t timeout_ms)
{
struct hp206c_device_data *hp206c = dev->data;
uint8_t int_src;
k_timer_start(&hp206c->tmr, K_MSEC(timeout_ms), K_NO_WAIT);
k_timer_status_sync(&hp206c->tmr);
if (hp206c_read_reg(dev, HP206C_REG_INT_SRC, &int_src) < 0) {
return -EIO;
}
if (int_src & HP206C_DEV_RDY) {
return 0;
}
return -EBUSY;
}
static int hp206c_adc_acquire(const struct device *dev,
enum sensor_channel chan)
{
struct hp206c_device_data *hp206c = dev->data;
if (hp206c_cmd_send(dev, HP206C_CMD_ADC_CVT | (hp206c->osr << 2)) < 0) {
return -EIO;
}
return hp206c_wait_dev_ready(dev, hp206c_adc_time_ms[hp206c->osr]);
}
static int32_t hp206c_buf_convert(uint8_t *buf, bool signed_val)
{
int32_t tmp = 0;
if (signed_val && (buf[0] & 0x08)) {
tmp |= (0xff << 24) | (0xf0 << 16);
}
tmp |= ((buf[0] & 0x0f) << 16) | (buf[1] << 8) | buf[2];
return tmp;
}
static int hp206c_val_get(const struct device *dev,
uint8_t cmd, struct sensor_value *val)
{
uint8_t buf[3];
int32_t temp = 0;
if (hp206c_read(dev, cmd, buf, 3) < 0) {
return -EIO;
}
/*
* According to documentation, pressure and altitude are 20 bit unsigned
* values whereas temperature is a signed.
*/
if (cmd == HP206C_CMD_READ_T) {
temp = hp206c_buf_convert(buf, true);
} else {
temp = hp206c_buf_convert(buf, false);
}
if (cmd == HP206C_CMD_READ_P) {
val->val1 = temp / 1000;
val->val2 = temp % 1000 * 1000;
} else {
val->val1 = temp / 100;
val->val2 = temp % 100 * 10000;
}
return 0;
}
static inline int hp206c_pressure_get(const struct device *dev,
struct sensor_value *val)
{
return hp206c_val_get(dev, HP206C_CMD_READ_P, val);
}
static inline int hp206c_altitude_get(const struct device *dev,
struct sensor_value *val)
{
return hp206c_val_get(dev, HP206C_CMD_READ_A, val);
}
static inline int hp206c_temperature_get(const struct device *dev,
struct sensor_value *val)
{
return hp206c_val_get(dev, HP206C_CMD_READ_T, val);
}
static int hp206c_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
return hp206c_temperature_get(dev, val);
case SENSOR_CHAN_PRESS:
return hp206c_pressure_get(dev, val);
case SENSOR_CHAN_ALTITUDE:
return hp206c_altitude_get(dev, val);
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api hp206c_api = {
.attr_set = hp206c_attr_set,
.sample_fetch = hp206c_adc_acquire,
.channel_get = hp206c_channel_get,
};
static int hp206c_init(const struct device *dev)
{
struct hp206c_device_data *hp206c = dev->data;
const struct hp206c_device_config *cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -EINVAL;
}
/* reset the chip */
if (hp206c_cmd_send(dev, HP206C_CMD_SOFT_RST) < 0) {
LOG_ERR("Cannot reset chip.");
return -EIO;
}
k_timer_init(&hp206c->tmr, NULL, NULL);
k_busy_wait(500);
if (hp206c_osr_set(dev, HP206C_DEFAULT_OSR) < 0) {
LOG_ERR("OSR value is not supported.");
return -ENOTSUP;
}
if (hp206c_altitude_offs_set(dev, HP206C_DEFAULT_ALT_OFFSET) < 0) {
return -EIO;
}
return 0;
}
#define HP206C_DEFINE(inst) \
static struct hp206c_device_data hp206c_data_##inst; \
\
static const struct hp206c_device_config hp206c_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, hp206c_init, NULL, \
&hp206c_data_##inst, &hp206c_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &hp206c_api); \
DT_INST_FOREACH_STATUS_OKAY(HP206C_DEFINE)
``` | /content/code_sandbox/drivers/sensor/hp206c/hp206c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,309 |
```unknown
# HopeRF Electronic HP206C precision barometer and altimeter configuration
# options
menuconfig HP206C
bool "HopeRF HP206C precision barometer and altimeter sensor"
default y
depends on DT_HAS_HOPERF_HP206C_ENABLED
select I2C
help
Enable HopeRF HP206C barometer and altimeter support.
if HP206C
config HP206C_OSR_RUNTIME
bool "Oversampling rate set at runtime"
default y
config HP206C_OSR
int "Oversampling rate"
depends on !HP206C_OSR_RUNTIME
default 4096
help
Allowed values: 4096, 2048, 1024, 512, 256, 128
config HP206C_ALT_OFFSET_RUNTIME
bool "Altitude offset set at runtime"
default y
config HP206C_ALT_OFFSET
int "Altitude offset (in cm)"
depends on !HP206C_ALT_OFFSET_RUNTIME
default 0
help
Value, in cm, that will be used to compensate altitude calculation.
For more info on how to choose this value, consult section 6.1.1 in
the datasheet.
endif # HP206C
``` | /content/code_sandbox/drivers/sensor/hp206c/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 260 |
```unknown
# S11059 color sensor
config S11059
bool "S11059 color sensor"
default y
depends on DT_HAS_HAMAMATSU_S11059_ENABLED
select I2C
help
Enable driver for S11059 color sensor
``` | /content/code_sandbox/drivers/sensor/s11059/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 57 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/infineon/dps310/Kconfig"
source "drivers/sensor/infineon/tle9104/Kconfig"
source "drivers/sensor/infineon/xmc4xxx_temp/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/infineon/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 70 |
```c
/*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT hamamatsu_s11059
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
LOG_MODULE_REGISTER(S11059, CONFIG_SENSOR_LOG_LEVEL);
/* register address */
#define S11059_REG_ADDR_CONTROL 0x00
#define S11059_REG_ADDR_MANUAL_TIMING 0x01
#define S11059_REG_ADDR_DATA 0x03
/* control bit */
#define S11059_CONTROL_GAIN 3
#define S11059_CONTROL_STANDBY_MONITOR 5
#define S11059_CONTROL_STADBY 6
#define S11059_CONTROL_ADC_RESET 7
/* bit mask for control */
#define S11059_BIT_MASK_INTEGRATION_TIME 0x03
#define S11059_BIT_MASK_CONTROL_STANDBY_MONITOR 0x20
/* factors for converting sensor samples to Lux */
#define S11059_CONVERT_FACTOR_LOW_RED (112)
#define S11059_CONVERT_FACTOR_LOW_GREEN (83)
#define S11059_CONVERT_FACTOR_LOW_BLUE (44)
#define S11059_CONVERT_FACTOR_LOW_IR (3 * 10)
#define S11059_CONVERT_FACTOR_HIGH_RED (117 * 10)
#define S11059_CONVERT_FACTOR_HIGH_GREEN (85 * 10)
#define S11059_CONVERT_FACTOR_HIGH_BLUE (448)
#define S11059_CONVERT_FACTOR_HIGH_IR (30 * 10)
#define S11059_INTEGRATION_TIME_MODE_00 175
#define S11059_INTEGRATION_TIME_MODE_01 2800
#define S11059_INTEGRATION_TIME_MODE_10 44800
#define S11059_INTEGRATION_TIME_MODE_11 358400
#define S11059_WAIT_PER_LOOP 400
#define S11059_INITIAL_CONTROL 0x04
#define S11059_MAX_MANUAL_TIMING UINT16_MAX
#define S11059_CARRY_UP 10000
#define S11059_NUM_GAIN_MODE 2
enum s11059_channel {
RED,
GREEN,
BLUE,
IR,
NUM_OF_COLOR_CHANNELS
};
struct s11059_dev_config {
struct i2c_dt_spec bus;
uint8_t gain;
int64_t integration_time; /* integration period (unit: us) */
};
struct s11059_data {
uint16_t samples[NUM_OF_COLOR_CHANNELS];
};
static const uint16_t convert_factors[S11059_NUM_GAIN_MODE][NUM_OF_COLOR_CHANNELS] = {
{S11059_CONVERT_FACTOR_LOW_RED, S11059_CONVERT_FACTOR_LOW_GREEN,
S11059_CONVERT_FACTOR_LOW_BLUE, S11059_CONVERT_FACTOR_LOW_IR},
{S11059_CONVERT_FACTOR_HIGH_RED, S11059_CONVERT_FACTOR_HIGH_GREEN,
S11059_CONVERT_FACTOR_HIGH_BLUE, S11059_CONVERT_FACTOR_HIGH_IR}};
/* Integration timing in Manual integration mode */
static const uint32_t integ_time_factor[] = {
S11059_INTEGRATION_TIME_MODE_00, S11059_INTEGRATION_TIME_MODE_01,
S11059_INTEGRATION_TIME_MODE_10, S11059_INTEGRATION_TIME_MODE_11};
static int s11059_convert_channel_to_index(enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_RED:
return RED;
case SENSOR_CHAN_GREEN:
return GREEN;
case SENSOR_CHAN_BLUE:
return BLUE;
default:
return IR;
}
}
static int s11059_samples_read(const struct device *dev, uint8_t addr, uint16_t *val, uint32_t size)
{
const struct s11059_dev_config *cfg = dev->config;
int rc;
if (size < NUM_OF_COLOR_CHANNELS * 2) {
return -EINVAL;
}
rc = i2c_burst_read_dt(&cfg->bus, addr, (uint8_t *)val, size);
if (rc < 0) {
return rc;
}
for (size_t i = 0; i < NUM_OF_COLOR_CHANNELS; i++) {
val[i] = sys_be16_to_cpu(val[i]);
}
return 0;
}
static int s11059_control_write(const struct device *dev, uint8_t control)
{
const struct s11059_dev_config *cfg = dev->config;
const uint8_t opcode[] = {S11059_REG_ADDR_CONTROL, control};
return i2c_write_dt(&cfg->bus, opcode, sizeof(opcode));
}
static int s11059_manual_timing_write(const struct device *dev, uint16_t manual_time)
{
const struct s11059_dev_config *cfg = dev->config;
const uint8_t opcode[] = {S11059_REG_ADDR_MANUAL_TIMING, manual_time >> 8,
manual_time & 0xFF};
return i2c_write_dt(&cfg->bus, opcode, sizeof(opcode));
}
static int s11059_start_measurement(const struct device *dev)
{
const struct s11059_dev_config *cfg = dev->config;
uint8_t control;
int rc;
/* read current control */
rc = i2c_reg_read_byte_dt(&cfg->bus, S11059_REG_ADDR_CONTROL, &control);
if (rc < 0) {
LOG_ERR("%s, Failed to read current control.", dev->name);
return rc;
}
/* reset adc block */
WRITE_BIT(control, S11059_CONTROL_ADC_RESET, 1);
WRITE_BIT(control, S11059_CONTROL_STADBY, 0);
rc = s11059_control_write(dev, control);
if (rc < 0) {
LOG_ERR("%s, Failed to reset adc.", dev->name);
return rc;
}
/* start device */
WRITE_BIT(control, S11059_CONTROL_ADC_RESET, 0);
rc = s11059_control_write(dev, control);
if (rc < 0) {
LOG_ERR("%s, Failed to start device.", dev->name);
return rc;
}
return 0;
}
static int s11059_integ_time_calculate(const struct device *dev, uint16_t *manual_time,
uint8_t *mode)
{
const struct s11059_dev_config *cfg = dev->config;
int64_t tmp;
if (cfg->integration_time < integ_time_factor[0]) {
*mode = 0;
*manual_time = 1;
} else {
*manual_time = S11059_MAX_MANUAL_TIMING;
for (uint8_t i = 0; i < ARRAY_SIZE(integ_time_factor); i++) {
*mode = i;
tmp = cfg->integration_time / integ_time_factor[i];
if (tmp < S11059_MAX_MANUAL_TIMING) {
*manual_time = (uint16_t)tmp;
break;
}
}
}
return 0;
}
static int s11059_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct s11059_dev_config *cfg = dev->config;
struct s11059_data *drv_data = dev->data;
uint16_t values[NUM_OF_COLOR_CHANNELS];
uint8_t control;
int rc;
if (chan != SENSOR_CHAN_ALL) {
LOG_ERR("%s, Unsupported sensor channel", dev->name);
return -ENOTSUP;
}
rc = s11059_start_measurement(dev);
if (rc < 0) {
LOG_ERR("%s, Failed to start measurement.", dev->name);
return rc;
}
do {
rc = i2c_reg_read_byte_dt(&cfg->bus, S11059_REG_ADDR_CONTROL, &control);
if (rc < 0) {
LOG_ERR("%s, Failed to read control.", dev->name);
return rc;
}
k_usleep(S11059_WAIT_PER_LOOP);
} while (!(control & S11059_BIT_MASK_CONTROL_STANDBY_MONITOR));
rc = s11059_samples_read(dev, S11059_REG_ADDR_DATA, values, sizeof(values));
if (rc < 0) {
LOG_ERR("%s, Failed to get sample.", dev->name);
return rc;
}
for (size_t i = 0; i < NUM_OF_COLOR_CHANNELS; i++) {
drv_data->samples[i] = values[i];
}
return 0;
}
static int s11059_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct s11059_dev_config *cfg = dev->config;
struct s11059_data *drv_data = dev->data;
const uint8_t index = s11059_convert_channel_to_index(chan);
const uint16_t factor = convert_factors[cfg->gain][index];
uint32_t meas_value;
meas_value = drv_data->samples[index] * S11059_CARRY_UP / factor;
val->val1 = meas_value / (S11059_CARRY_UP / 10);
val->val2 = meas_value % (S11059_CARRY_UP / 10);
return 0;
}
static int s11059_init(const struct device *dev)
{
const struct s11059_dev_config *cfg = dev->config;
uint8_t control = S11059_INITIAL_CONTROL;
uint16_t manual_time;
uint8_t timing_mode;
int rc;
/* device set */
if (!i2c_is_ready_dt(&cfg->bus)) {
LOG_ERR("%s, device is not ready.", dev->name);
return -ENODEV;
}
rc = s11059_integ_time_calculate(dev, &manual_time, &timing_mode);
if (rc < 0) {
LOG_ERR("%s, Failed to calculate manual timing.", dev->name);
return rc;
}
rc = s11059_manual_timing_write(dev, manual_time);
if (rc < 0) {
LOG_ERR("%s, Failed to set manual timing.", dev->name);
return rc;
}
/* set integration time mode and gain*/
control |= timing_mode & S11059_BIT_MASK_INTEGRATION_TIME;
WRITE_BIT(control, S11059_CONTROL_GAIN, cfg->gain);
rc = s11059_control_write(dev, control);
if (rc < 0) {
LOG_ERR("%s, Failed to set gain and integration time.", dev->name);
return rc;
}
return 0;
}
static const struct sensor_driver_api s11059_driver_api = {
.sample_fetch = s11059_sample_fetch,
.channel_get = s11059_channel_get,
};
#define S11059_INST(inst) \
static struct s11059_data s11059_data_##inst; \
static const struct s11059_dev_config s11059_config_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
.gain = DT_INST_PROP(inst, high_gain), \
.integration_time = DT_INST_PROP(inst, integration_time)}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, s11059_init, NULL, &s11059_data_##inst, \
&s11059_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &s11059_driver_api);
DT_INST_FOREACH_STATUS_OKAY(S11059_INST)
``` | /content/code_sandbox/drivers/sensor/s11059/s11059.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,402 |
```unknown
# DPS310 temperature and pressure sensor configuration options
menuconfig DPS310
bool "DPS310 sensor"
default y
depends on DT_HAS_INFINEON_DPS310_ENABLED
select I2C
help
Enable driver for DPS310 I2C-based temperature and pressure sensor.
if DPS310
menu "Attributes"
choice
prompt "DPS310 temperature oversampling"
default DPS310_TEMP_OSR_8X
help
Select temperature oversampling for the DPS310 sensor. Higher values
lead to more accurate readings, but higher power consumption.
config DPS310_TEMP_OSR_1X
bool "x1"
config DPS310_TEMP_OSR_2X
bool "x2"
config DPS310_TEMP_OSR_4X
bool "x4"
config DPS310_TEMP_OSR_8X
bool "x8"
config DPS310_TEMP_OSR_16X
bool "x16"
config DPS310_TEMP_OSR_32X
bool "x32"
config DPS310_TEMP_OSR_64X
bool "x64"
config DPS310_TEMP_OSR_128X
bool "x128"
endchoice
choice
prompt "DPS310 pressure oversampling"
default DPS310_PRESS_OSR_8X
help
Select pressure oversampling for the DPS310 sensor. Higher values
lead to more accurate readings, but higher power consumption.
config DPS310_PRESS_OSR_1X
bool "x1"
config DPS310_PRESS_OSR_2X
bool "x2"
config DPS310_PRESS_OSR_4X
bool "x4"
config DPS310_PRESS_OSR_8X
bool "x8"
config DPS310_PRESS_OSR_16X
bool "x16"
config DPS310_PRESS_OSR_32X
bool "x32"
config DPS310_PRESS_OSR_64X
bool "x64"
config DPS310_PRESS_OSR_128X
bool "x128"
endchoice
endmenu
endif # DPS310
``` | /content/code_sandbox/drivers/sensor/infineon/dps310/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 425 |
```c
/*
*
*/
#define DT_DRV_COMPAT infineon_tle9104_diagnostics
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/tle9104.h>
#include <zephyr/logging/log.h>
#include "tle9104_diagnostics.h"
LOG_MODULE_REGISTER(TLE9104_DIAGNOSTICS, CONFIG_SENSOR_LOG_LEVEL);
static int tle9104_diagnostics_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct tle9104_diagnostics_config *config = dev->config;
struct tle9104_diagnostics_data *data = dev->data;
int result;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
result = tle9104_get_diagnostics(config->parent, data->values);
if (result != 0) {
return result;
}
result = tle9104_clear_diagnostics(config->parent);
if (result != 0) {
return result;
}
return 0;
}
static int tle9104_diagnostics_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct tle9104_diagnostics_data *data = dev->data;
val->val1 = 0;
val->val2 = 0;
switch (chan) {
case SENSOR_CHAN_TLE9104_OPEN_LOAD:
for (size_t i = 0; i < ARRAY_SIZE(data->values); ++i) {
if (data->values[i].off == TLE9104_OFFDIAG_OL) {
val->val1 |= BIT(i);
}
}
return 0;
case SENSOR_CHAN_TLE9104_OVER_CURRENT:
for (size_t i = 0; i < ARRAY_SIZE(data->values); ++i) {
if (data->values[i].on == TLE9104_ONDIAG_OCTIME ||
data->values[i].on == TLE9104_ONDIAG_OCOT) {
val->val1 |= BIT(i);
}
}
return 0;
default:
LOG_ERR("%s: requesting unsupported channel %i", dev->name, chan);
return -ENOTSUP;
}
}
static const struct sensor_driver_api tle9104_diagnostics_driver_api = {
.sample_fetch = tle9104_diagnostics_sample_fetch,
.channel_get = tle9104_diagnostics_channel_get,
};
int tle9104_diagnostics_init(const struct device *dev)
{
const struct tle9104_diagnostics_config *config = dev->config;
if (!device_is_ready(config->parent)) {
LOG_ERR("%s: parent device is not ready", dev->name);
return -ENODEV;
}
return 0;
}
#define TLE9104_DIAGNOSTICS_DEFINE(inst) \
static struct tle9104_diagnostics_data tle9104_diagnostics_data_##inst; \
\
static const struct tle9104_diagnostics_config tle9104_diagnostics_config##inst = { \
.parent = DEVICE_DT_GET(DT_PARENT(DT_DRV_INST(inst))), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE( \
inst, tle9104_diagnostics_init, NULL, &tle9104_diagnostics_data_##inst, \
&tle9104_diagnostics_config##inst, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&tle9104_diagnostics_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TLE9104_DIAGNOSTICS_DEFINE)
``` | /content/code_sandbox/drivers/sensor/infineon/tle9104/tle9104_diagnostics.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 750 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_INFINEON_TLE9104_TLE9104_DIAGNOSTICS_H_
#define ZEPHYR_DRIVERS_SENSOR_INFINEON_TLE9104_TLE9104_DIAGNOSTICS_H_
#include <stdint.h>
#include <zephyr/device.h>
#include <zephyr/drivers/mfd/tle9104.h>
struct tle9104_diagnostics_data {
struct gpio_tle9104_channel_diagnostics values[TLE9104_GPIO_COUNT];
};
struct tle9104_diagnostics_config {
const struct device *parent;
uint8_t channel;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_INFINEON_TLE9104_TLE9104_DIAGNOSTICS_H_ */
``` | /content/code_sandbox/drivers/sensor/infineon/tle9104/tle9104_diagnostics.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 156 |
```unknown
config TLE9104_DIAGNOSTICS
bool "Output diagnostics of TLE9104"
default y
depends on DT_HAS_INFINEON_TLE9104_DIAGNOSTICS_ENABLED
help
Enable driver for the output diagnostics of the power train
switch TLE9104.
``` | /content/code_sandbox/drivers/sensor/infineon/tle9104/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 64 |
```c
/*
*
*/
#define DT_DRV_COMPAT infineon_xmc4xxx_temp
#include <xmc_scu.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(xmc4xxx_temp, CONFIG_SENSOR_LOG_LEVEL);
struct xmc4xxx_temp_data {
float temp_out;
};
static int xmc4xxx_temp_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct xmc4xxx_temp_data *data = dev->data;
int32_t val;
int ret;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
ret = XMC_SCU_StartTemperatureMeasurement();
if (ret != 0) {
return -EBUSY;
}
while (XMC_SCU_IsTemperatureSensorBusy()) {
};
val = XMC_SCU_GetTemperatureMeasurement();
/* See Infineon XMC4500 Reference Manual Section 11.2.5.1 */
data->temp_out = (val - 605) / 2.05f;
return ret;
}
static int xmc4xxx_temp_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct xmc4xxx_temp_data *data = dev->data;
if (chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
return sensor_value_from_double(val, data->temp_out);
}
static const struct sensor_driver_api xmc4xxx_temp_driver_api = {
.sample_fetch = xmc4xxx_temp_sample_fetch,
.channel_get = xmc4xxx_temp_channel_get,
};
static int xmc4xxx_temp_init(const struct device *dev)
{
ARG_UNUSED(dev);
XMC_SCU_EnableTemperatureSensor();
BUILD_ASSERT(CONFIG_XMC4XXX_TEMP_CALIBRATE_OFFSET >= -64 &&
CONFIG_XMC4XXX_TEMP_CALIBRATE_OFFSET <= 63);
BUILD_ASSERT(CONFIG_XMC4XXX_TEMP_CALIBRATE_GAIN >= 0 &&
CONFIG_XMC4XXX_TEMP_CALIBRATE_OFFSET <= 63);
XMC_SCU_CalibrateTemperatureSensor(CONFIG_XMC4XXX_TEMP_CALIBRATE_OFFSET & 0x7f,
CONFIG_XMC4XXX_TEMP_CALIBRATE_GAIN);
return 0;
}
#define XMC4XXX_TEMP_DEFINE(inst) \
static struct xmc4xxx_temp_data xmc4xxx_temp_dev_data_##inst; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, xmc4xxx_temp_init, NULL, \
&xmc4xxx_temp_dev_data_##inst, NULL, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&xmc4xxx_temp_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(XMC4XXX_TEMP_DEFINE)
``` | /content/code_sandbox/drivers/sensor/infineon/xmc4xxx_temp/xmc4xxx_temp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 624 |
```unknown
config XMC4XXX_TEMP
bool "XMC4XXX Temperature Sensor"
default y
depends on DT_HAS_INFINEON_XMC4XXX_TEMP_ENABLED
help
Enable driver for temperature sensor on Infineon XMC4XXX targets.
if XMC4XXX_TEMP
config XMC4XXX_TEMP_CALIBRATE_OFFSET
int "Offset adjumstment of the temperature reading"
default 0
help
Offset adjustment is defined as a shift of the conversion result.
The value is 7 bits in the range [-64, 63] which maps to -/+ 12.5C.
config XMC4XXX_TEMP_CALIBRATE_GAIN
int "Gain adjumstment of the temperature reading"
default 32
help
Gain adjustment of the temperature reading. Range [0, 63].
endif # XMC4XXX_TEMP
``` | /content/code_sandbox/drivers/sensor/infineon/xmc4xxx_temp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 182 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/meas/ms5607/Kconfig"
source "drivers/sensor/meas/ms5837/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/meas/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 48 |
```objective-c
/*
*
*/
#ifndef __SENSOR_MS5837_H__
#define __SENSOR_MS5837_H__
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#define MS5837_CMD_RESET 0x1E
#define MS5837_CMD_CONV_P_256 0x40
#define MS5837_CMD_CONV_P_512 0x42
#define MS5837_CMD_CONV_P_1024 0x44
#define MS5837_CMD_CONV_P_2048 0x46
#define MS5837_CMD_CONV_P_4096 0x48
#define MS5837_CMD_CONV_P_8192 0x4A
#define MS5837_CMD_CONV_T_256 0x50
#define MS5837_CMD_CONV_T_512 0x52
#define MS5837_CMD_CONV_T_1024 0x54
#define MS5837_CMD_CONV_T_2048 0x56
#define MS5837_CMD_CONV_T_4096 0x58
#define MS5837_CMD_CONV_T_8192 0x5A
#define MS5837_CMD_CONV_READ_ADC 0x00
#define MS5837_CMD_CONV_READ_CRC 0xA0
#define MS5837_CMD_CONV_READ_SENS_T1 0xA2
#define MS5837_CMD_CONV_READ_OFF_T1 0xA4
#define MS5837_CMD_CONV_READ_TCS 0xA6
#define MS5837_CMD_CONV_READ_TCO 0xA8
#define MS5837_CMD_CONV_READ_T_REF 0xAA
#define MS5837_CMD_CONV_READ_TEMPSENS 0xAC
#define MS5837_ADC_READ_DELAY_256 1
#define MS5837_ADC_READ_DELAY_512 2
#define MS5837_ADC_READ_DELAY_1024 3
#define MS5837_ADC_READ_DELAY_2048 5
#define MS5837_ADC_READ_DELAY_4086 10
#define MS5837_ADC_READ_DELAY_8129 20
enum ms5837_type {
MS5837_02BA01 = 0x00,
MS5837_02BA21 = 0x15,
MS5837_30BA26 = 0x1A
};
typedef void (*ms5837_compensate_func)(const struct device *dev,
const int32_t adc_temperature,
const int32_t adc_pressure);
struct ms5837_data {
/* Calibration values */
uint16_t factory;
uint16_t sens_t1;
uint16_t off_t1;
uint16_t tcs;
uint16_t tco;
uint16_t t_ref;
uint16_t tempsens;
/* Measured values */
int32_t pressure;
int32_t temperature;
/* Conversion commands */
uint8_t presure_conv_cmd;
uint8_t temperature_conv_cmd;
/* Conversion delay in ms*/
uint8_t presure_conv_delay;
uint8_t temperature_conv_delay;
ms5837_compensate_func comp_func;
};
struct ms5837_config {
struct i2c_dt_spec i2c;
};
#endif /* __SENSOR_MS5837_H__ */
``` | /content/code_sandbox/drivers/sensor/meas/ms5837/ms5837.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 668 |
```unknown
# MS5837 pressure sensor configuration options
config MS5837
bool "MS5837 pressure and temperature sensor"
default y
depends on DT_HAS_MEAS_MS5837_ENABLED
select I2C
help
Enable driver for MS5837 pressure and temperature sensor.
``` | /content/code_sandbox/drivers/sensor/meas/ms5837/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 59 |
```c
/* Driver for Infineon DPS310 temperature and pressure sensor */
/*
*
*/
#define DT_DRV_COMPAT infineon_dps310
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(DPS310, CONFIG_SENSOR_LOG_LEVEL);
/* Register addresses as in the datasheet */
#define IFX_DPS310_REG_ADDR_PSR_B2 (0x00)
#define IFX_DPS310_REG_ADDR_TMP_B2 (0x03)
#define IFX_DPS310_REG_ADDR_PRS_CFG (0x06)
#define IFX_DPS310_REG_ADDR_TMP_CFG (0x07)
#define IFX_DPS310_REG_ADDR_MEAS_CFG (0x08)
#define IFX_DPS310_REG_ADDR_CFG_REG (0x09)
#define IFX_DPS310_REG_ADDR_INT_STS (0x0A)
#define IFX_DPS310_REG_ADDR_FIFO_STS (0x0B)
#define IFX_DPS310_REG_ADDR_RESET (0x0C)
#define IFX_DPS310_REG_ADDR_PRODUCT_ID (0x0D)
#define IFX_DPS310_REG_ADDR_COEF_0 (0x10)
#define IFX_DPS310_REG_ADDR_COEF_SRCE (0x28)
enum {
IFX_DPS310_MODE_IDLE = 0x00,
IFX_DPS310_MODE_COMMAND_PRESSURE = 0x01,
IFX_DPS310_MODE_COMMAND_TEMPERATURE = 0x02,
IFX_DPS310_MODE_BACKGROUND_PRESSURE = 0x05,
IFX_DPS310_MODE_BACKGROUND_TEMPERATURE = 0x06,
IFX_DPS310_MODE_BACKGROUND_ALL = 0x07
};
/* Bits in registers as in the datasheet */
#define IFX_DPS310_REG_ADDR_MEAS_CFG_PRS_RDY (0x10)
#define IFX_DPS310_REG_ADDR_MEAS_CFG_TMP_RDY (0x20)
/*
* If sensor is ready after self initialization
* bits 6 and 7 in register MEAS_CFG (0x08) should be "1"
*/
#define IFX_DPS310_REG_ADDR_MEAS_CFG_SELF_INIT_OK (0xC0)
#define IFX_DPS310_COEF_SRCE_MASK (0x80)
#define IFX_DPS310_PRODUCT_ID (0x10)
/* Polling time in ms*/
#define POLL_TIME_MS (K_MSEC(10))
/* Number of times to poll before timeout */
#define POLL_TRIES 3
/*
* Measurement times in ms for different oversampling rates
* From Table 16 in the datasheet, rounded up for safety margin
*/
enum {
IFX_DPS310_MEAS_TIME_OSR_1 = 4,
IFX_DPS310_MEAS_TIME_OSR_2 = 6,
IFX_DPS310_MEAS_TIME_OSR_4 = 9,
IFX_DPS310_MEAS_TIME_OSR_8 = 15,
IFX_DPS310_MEAS_TIME_OSR_16 = 28,
IFX_DPS310_MEAS_TIME_OSR_32 = 54,
IFX_DPS310_MEAS_TIME_OSR_64 = 105,
IFX_DPS310_MEAS_TIME_OSR_128 = 207
};
/* Compensation scale factors from Table 9 in the datasheet */
enum {
IFX_DPS310_SF_OSR_1 = 524288,
IFX_DPS310_SF_OSR_2 = 1572864,
IFX_DPS310_SF_OSR_4 = 3670016,
IFX_DPS310_SF_OSR_8 = 7864320,
IFX_DPS310_SF_OSR_16 = 253952,
IFX_DPS310_SF_OSR_32 = 516096,
IFX_DPS310_SF_OSR_64 = 1040384,
IFX_DPS310_SF_OSR_128 = 2088960
};
/*
* Oversampling and measurement rates configuration for pressure and temperature
* sensor According to Table 16 of the datasheet
*/
enum {
IFX_DPS310_RATE_1 = 0x00,
IFX_DPS310_RATE_2 = 0x01,
IFX_DPS310_RATE_4 = 0x02,
IFX_DPS310_RATE_8 = 0x03,
IFX_DPS310_RATE_16 = 0x04,
IFX_DPS310_RATE_32 = 0x05,
IFX_DPS310_RATE_64 = 0x06,
IFX_DPS310_RATE_128 = 0x07
};
/* Helper macro to set temperature and pressure config register */
#define CFG_REG(MEAS_RATE, OSR_RATE) \
((((MEAS_RATE)&0x07) << 4) | ((OSR_RATE)&0x07))
/* Setup constants depending on temperature oversampling factor */
#if defined CONFIG_DPS310_TEMP_OSR_1X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_1
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_1
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_1)
#define IFX_DPS310_T_SHIFT 0
#elif defined CONFIG_DPS310_TEMP_OSR_2X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_2
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_2
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_2)
#define IFX_DPS310_T_SHIFT 0
#elif defined CONFIG_DPS310_TEMP_OSR_4X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_4
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_4
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_4)
#define IFX_DPS310_T_SHIFT 0
#elif defined CONFIG_DPS310_TEMP_OSR_8X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_8
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_8
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_8)
#define IFX_DPS310_T_SHIFT 0
#elif defined CONFIG_DPS310_TEMP_OSR_16X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_16
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_16
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_16)
#define IFX_DPS310_T_SHIFT 1
#elif defined CONFIG_DPS310_TEMP_OSR_32X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_32
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_32
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_32)
#define IFX_DPS310_T_SHIFT 1
#elif defined CONFIG_DPS310_TEMP_OSR_64X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_64
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_64
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_64)
#define IFX_DPS310_T_SHIFT 1
#elif defined CONFIG_DPS310_TEMP_OSR_128X
#define IFX_DPS310_SF_TMP IFX_DPS310_SF_OSR_128
#define IFX_DPS310_TMP_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_128
#define IFX_DPS310_TMP_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_128)
#define IFX_DPS310_T_SHIFT 1
#endif
/* Setup constants depending on pressure oversampling factor */
#if defined CONFIG_DPS310_PRESS_OSR_1X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_1
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_1
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_1)
#define IFX_DPS310_P_SHIFT 0
#elif defined CONFIG_DPS310_PRESS_OSR_2X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_2
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_2
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_2)
#define IFX_DPS310_P_SHIFT 0
#elif defined CONFIG_DPS310_PRESS_OSR_4X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_4
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_4
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_4)
#define IFX_DPS310_P_SHIFT 0
#elif defined CONFIG_DPS310_PRESS_OSR_8X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_8
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_8
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_8)
#define IFX_DPS310_P_SHIFT 0
#elif defined CONFIG_DPS310_PRESS_OSR_16X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_16
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_16
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_16)
#define IFX_DPS310_P_SHIFT 1
#elif defined CONFIG_DPS310_PRESS_OSR_32X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_32
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_32
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_32)
#define IFX_DPS310_P_SHIFT 1
#elif defined CONFIG_DPS310_PRESS_OSR_64X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_64
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_64
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_64)
#define IFX_DPS310_P_SHIFT 1
#elif defined CONFIG_DPS310_PRESS_OSR_128X
#define IFX_DPS310_SF_PSR IFX_DPS310_SF_OSR_128
#define IFX_DPS310_PSR_MEAS_TIME IFX_DPS310_MEAS_TIME_OSR_128
#define IFX_DPS310_PSR_CFG CFG_REG(IFX_DPS310_RATE_1, IFX_DPS310_RATE_128)
#define IFX_DPS310_P_SHIFT 1
#endif
#define DPS310_CFG_REG \
(((IFX_DPS310_T_SHIFT & 0x01) << 3) | \
((IFX_DPS310_P_SHIFT & 0x01) << 2))
#define HW_BUG_FIX_SEQUENCE_LEN 5
#define POW_2_23_MINUS_1 BIT_MASK(23)
#define POW_2_24 BIT(24)
#define POW_2_15_MINUS_1 BIT_MASK(15)
#define POW_2_16 BIT(16)
#define POW_2_11_MINUS_1 BIT_MASK(11)
#define POW_2_12 BIT(12)
#define POW_2_20 BIT(20)
#define POW_2_19_MINUS_1 BIT_MASK(19)
/* Needed because the values are referenced by pointer. */
static const uint8_t REG_ADDR_MEAS_CFG = IFX_DPS310_REG_ADDR_MEAS_CFG;
static const uint8_t REG_ADDR_CALIB_COEFF_0 = IFX_DPS310_REG_ADDR_COEF_0;
static const uint8_t REG_ADDR_TMP_B2 = IFX_DPS310_REG_ADDR_TMP_B2;
static const uint8_t REG_ADDR_PSR_B2 = IFX_DPS310_REG_ADDR_PSR_B2;
static const uint8_t REG_ADDR_COEF_SRCE = IFX_DPS310_REG_ADDR_COEF_SRCE;
/* calibration coefficients */
struct dps310_cal_coeff {
/* Pressure Sensor Calibration Coefficients */
int32_t c00; /* 20bit */
int32_t c10; /* 20bit */
int16_t c01; /* 16bit */
int16_t c11; /* 16bit */
int16_t c20; /* 16bit */
int16_t c21; /* 16bit */
int16_t c30; /* 16bit */
/* Temperature Sensor Calibration Coefficients */
int16_t c0; /* 12bit */
int16_t c1; /* 12bit */
};
struct dps310_data {
struct dps310_cal_coeff comp;
/* Temperature Values */
int32_t tmp_val1;
int32_t tmp_val2;
/* Last raw temperature value for temperature compensation */
int32_t raw_tmp;
/* Pressure Values */
int32_t psr_val1;
int32_t psr_val2;
};
struct dps310_cfg {
struct i2c_dt_spec i2c;
};
/*
* Convert the bytes from calibration memory to calibration coefficients
* structure
*/
static void dps310_calib_coeff_creation(const uint8_t raw_coef[18],
struct dps310_cal_coeff *comp)
{
/* Temperature sensor compensation values */
comp->c0 = (((uint16_t)raw_coef[0]) << 4) + (raw_coef[1] >> 4);
/* coefficient is 2nd compliment */
if (comp->c0 > POW_2_11_MINUS_1) {
comp->c0 = comp->c0 - POW_2_12;
}
comp->c1 = (((uint16_t)(raw_coef[1] & 0x0F)) << 8) + raw_coef[2];
/* coefficient is 2nd compliment */
if (comp->c1 > POW_2_11_MINUS_1) {
comp->c1 = comp->c1 - POW_2_12;
}
/* Pressure sensor compensation values */
comp->c00 = (((uint32_t)raw_coef[3]) << 12) + (((uint16_t)raw_coef[4]) << 4) +
(raw_coef[5] >> 4);
/* coefficient is 2nd compliment */
if (comp->c00 > POW_2_19_MINUS_1) {
comp->c00 = comp->c00 - POW_2_20;
}
comp->c10 = (((uint32_t)(raw_coef[5] & 0x0F)) << 16) +
(((uint16_t)raw_coef[6]) << 8) + raw_coef[7];
/* coefficient is 2nd compliment */
if (comp->c10 > POW_2_19_MINUS_1) {
comp->c10 = comp->c10 - POW_2_20;
}
comp->c01 = (int16_t) sys_get_be16(&raw_coef[8]);
comp->c11 = (int16_t) sys_get_be16(&raw_coef[10]);
comp->c20 = (int16_t) sys_get_be16(&raw_coef[12]);
comp->c21 = (int16_t) sys_get_be16(&raw_coef[14]);
comp->c30 = (int16_t) sys_get_be16(&raw_coef[16]);
}
/* Poll one or multiple bits given by ready_mask in reg_addr */
static bool poll_rdy(const struct device *dev, uint8_t reg_addr, uint8_t ready_mask)
{
const struct dps310_cfg *config = dev->config;
/* Try only a finite number of times */
for (int i = 0; i < POLL_TRIES; i++) {
uint8_t reg = 0;
int res = i2c_reg_read_byte_dt(&config->i2c, reg_addr, ®);
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return false;
}
if ((reg & ready_mask) == ready_mask) {
/* measurement is ready */
return true;
}
/* give the sensor more time */
k_sleep(POLL_TIME_MS);
}
return false;
}
/* Trigger a temperature measurement and wait until the result is stored */
static bool dps310_trigger_temperature(const struct device *dev)
{
const struct dps310_cfg *config = dev->config;
/* command to start temperature measurement */
static const uint8_t tmp_meas_cmd[] = {
IFX_DPS310_REG_ADDR_MEAS_CFG,
IFX_DPS310_MODE_COMMAND_TEMPERATURE
};
/* trigger temperature measurement */
int res = i2c_write_dt(&config->i2c, tmp_meas_cmd, sizeof(tmp_meas_cmd));
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return false;
}
/* give the sensor time to store measured values internally */
k_msleep(IFX_DPS310_TMP_MEAS_TIME);
if (!poll_rdy(dev, IFX_DPS310_REG_ADDR_MEAS_CFG, IFX_DPS310_REG_ADDR_MEAS_CFG_TMP_RDY)) {
LOG_DBG("Poll timeout for temperature");
return false;
}
return true;
}
/* Trigger a pressure measurement and wait until the result is stored */
static bool dps310_trigger_pressure(const struct device *dev)
{
const struct dps310_cfg *config = dev->config;
/* command to start pressure measurement */
static const uint8_t psr_meas_cmd[] = {
IFX_DPS310_REG_ADDR_MEAS_CFG,
IFX_DPS310_MODE_COMMAND_PRESSURE
};
/* trigger pressure measurement */
int res = i2c_write_dt(&config->i2c, psr_meas_cmd, sizeof(psr_meas_cmd));
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return false;
}
/* give the sensor time to store measured values internally */
k_msleep(IFX_DPS310_PSR_MEAS_TIME);
if (!poll_rdy(dev, IFX_DPS310_REG_ADDR_MEAS_CFG, IFX_DPS310_REG_ADDR_MEAS_CFG_PRS_RDY)) {
LOG_DBG("Poll timeout for pressure");
return false;
}
return true;
}
/*
* function to fix a hardware problem on some devices
* you have this bug if you measure around 60C when temperature is around 20C
* call dps310_hw_bug_fix() directly in the init() function to fix this issue
*/
static void dps310_hw_bug_fix(const struct device *dev)
{
const struct dps310_cfg *config = dev->config;
/* setup the necessary 5 sequences to fix the hw bug */
static const uint8_t hw_bug_fix_sequence[HW_BUG_FIX_SEQUENCE_LEN][2] = {
/*
* First write valid signature on 0x0e and 0x0f
* to unlock address 0x62
*/
{ 0x0E, 0xA5 },
{ 0x0F, 0x96 },
/* Then update high gain value for Temperature */
{ 0x62, 0x02 },
/* Finally lock back the location 0x62 */
{ 0x0E, 0x00 },
{ 0x0F, 0x00 }
};
/* execute sequence for hw bug fix */
for (int i = 0; i < HW_BUG_FIX_SEQUENCE_LEN; i++) {
int res = i2c_write_dt(&config->i2c, hw_bug_fix_sequence[i], 2);
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return;
}
}
}
/*
* Scale and compensate the raw temperature measurement value to micro C
* The formula is based on the Chapter 4.9.2 in the datasheet and was
* modified to need only integer arithmetic.
*/
static void dps310_scale_temperature(const struct device *dev, int32_t tmp_raw)
{
struct dps310_data *data = dev->data;
const struct dps310_cal_coeff *comp = &data->comp;
/* first term, rescaled to micro C */
int32_t tmp_p0 = (1000000 / 2) * comp->c0;
/* second term, rescaled to micro C */
int32_t tmp_p1 =
(((int64_t)1000000) * comp->c1 * tmp_raw) / IFX_DPS310_SF_TMP;
/* calculate the temperature corresponding to the datasheet */
int32_t tmp_final = tmp_p0 + tmp_p1; /* value is in micro C */
/* store calculated value */
data->tmp_val1 = tmp_final / 1000000;
data->tmp_val2 = tmp_final % 1000000;
}
/*
* Scale and temperature compensate the raw pressure measurement value to
* Kilopascal. The formula is based on the Chapter 4.9.1 in the datasheet.
*/
static void dps310_scale_pressure(const struct device *dev, int32_t tmp_raw, int32_t psr_raw)
{
struct dps310_data *data = dev->data;
const struct dps310_cal_coeff *comp = &data->comp;
float psr = ((float)psr_raw) / IFX_DPS310_SF_PSR;
float tmp = ((float)tmp_raw) / IFX_DPS310_SF_TMP;
/* scale according to formula from datasheet */
float psr_final = comp->c00;
psr_final += psr * (comp->c10 + psr * (comp->c20 + psr * comp->c30));
psr_final += tmp * comp->c01;
psr_final += tmp * psr * (comp->c11 + psr * comp->c21);
/* rescale from Pascal to Kilopascal */
psr_final /= 1000;
/* store calculated value */
data->psr_val1 = psr_final;
data->psr_val2 = (psr_final - data->psr_val1) * 1000000;
}
/* Convert the raw sensor data to int32_t */
static int32_t raw_to_int24(const uint8_t raw[3])
{
/* convert from twos complement */
int32_t res = (int32_t) sys_get_be24(raw);
if (res > POW_2_23_MINUS_1) {
res -= POW_2_24;
}
return res;
}
/* perform a single measurement of temperature and pressure */
static bool dps310_measure_tmp_psr(const struct device *dev)
{
struct dps310_data *data = dev->data;
const struct dps310_cfg *config = dev->config;
if (!dps310_trigger_temperature(dev)) {
return false;
}
if (!dps310_trigger_pressure(dev)) {
return false;
}
/* memory for pressure and temperature raw values */
uint8_t value_raw[6];
/* read pressure and temperature raw values in one continuous read */
int res = i2c_write_read_dt(&config->i2c, ®_ADDR_PSR_B2, 1,
&value_raw, sizeof(value_raw));
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return false;
}
/* convert raw data to int */
int32_t psr_raw = raw_to_int24(&value_raw[0]);
data->raw_tmp = raw_to_int24(&value_raw[3]);
dps310_scale_temperature(dev, data->raw_tmp);
dps310_scale_pressure(dev, data->raw_tmp, psr_raw);
return true;
}
/*
* perform a single pressure measurement
* uses the stored temperature value for sensor temperature compensation
* temperature must be measured regularly for good temperature compensation
*/
static bool dps310_measure_psr(const struct device *dev)
{
struct dps310_data *data = dev->data;
const struct dps310_cfg *config = dev->config;
/* measure pressure */
if (!dps310_trigger_pressure(dev)) {
return false;
}
/* memory for pressure raw value */
uint8_t value_raw[3];
/* read pressure raw values in one continuous read */
int res = i2c_write_read_dt(&config->i2c, ®_ADDR_PSR_B2, 1,
&value_raw, sizeof(value_raw));
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return false;
}
/* convert raw data to int */
int32_t psr_raw = raw_to_int24(&value_raw[0]);
dps310_scale_pressure(dev, data->raw_tmp, psr_raw);
return true;
}
/* perform a single temperature measurement */
static bool dps310_measure_tmp(const struct device *dev)
{
struct dps310_data *data = dev->data;
const struct dps310_cfg *config = dev->config;
/* measure temperature */
if (!dps310_trigger_temperature(dev)) {
return false;
}
/* memory for temperature raw value */
uint8_t value_raw[3];
/* read temperature raw values in one continuous read */
int res = i2c_write_read_dt(&config->i2c, ®_ADDR_TMP_B2, 1,
&value_raw, sizeof(value_raw));
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return false;
}
/* convert raw data to int */
data->raw_tmp = raw_to_int24(&value_raw[0]);
dps310_scale_temperature(dev, data->raw_tmp);
return true;
}
/* Initialize the sensor and apply the configuration */
static int dps310_init(const struct device *dev)
{
struct dps310_data *data = dev->data;
const struct dps310_cfg *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
uint8_t product_id = 0;
int res = i2c_reg_read_byte_dt(&config->i2c, IFX_DPS310_REG_ADDR_PRODUCT_ID, &product_id);
if (res < 0) {
LOG_ERR("No device found");
return -EINVAL;
}
if (product_id != IFX_DPS310_PRODUCT_ID) {
LOG_ERR("Device is not a DPS310");
return -EINVAL;
}
LOG_DBG("Init DPS310");
/* give the sensor time to load the calibration data */
k_sleep(K_MSEC(40));
/* wait for the sensor to load the calibration data */
if (!poll_rdy(dev, REG_ADDR_MEAS_CFG, IFX_DPS310_REG_ADDR_MEAS_CFG_SELF_INIT_OK)) {
LOG_DBG("Sensor not ready");
return -EIO;
}
/* read calibration coefficients */
uint8_t raw_coef[18] = { 0 };
res = i2c_write_read_dt(&config->i2c, ®_ADDR_CALIB_COEFF_0, 1, &raw_coef, 18);
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return -EIO;
}
/* convert calibration coefficients */
dps310_calib_coeff_creation(raw_coef, &data->comp);
/*
* check which temperature sensor was used for calibration and use it
* for measurements.
*/
uint8_t tmp_coef_srce = 0;
res = i2c_write_read_dt(&config->i2c, ®_ADDR_COEF_SRCE, 1, &tmp_coef_srce,
sizeof(tmp_coef_srce));
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return -EIO;
}
/* clear all other bits */
tmp_coef_srce &= IFX_DPS310_COEF_SRCE_MASK;
/* merge with temperature measurement configuration */
tmp_coef_srce |= IFX_DPS310_TMP_CFG;
/* set complete configuration in one write */
const uint8_t config_seq[] = {
IFX_DPS310_REG_ADDR_PRS_CFG, /* start register address */
IFX_DPS310_PSR_CFG, /* PSR_CFG */
tmp_coef_srce, /* TMP_CFG */
0x00, /* MEAS_CFG */
DPS310_CFG_REG /* CFG_REG */
};
res = i2c_write_dt(&config->i2c, config_seq, sizeof(config_seq));
if (res < 0) {
LOG_WRN("I2C error: %d", res);
return -EIO;
}
dps310_hw_bug_fix(dev);
dps310_measure_tmp_psr(dev);
LOG_DBG("Init OK");
return 0;
}
/* Do a measurement and fetch the data from the sensor */
static int dps310_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
LOG_DBG("Fetching sample from DPS310");
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
if (!dps310_measure_tmp(dev)) {
LOG_ERR("Failed to measure temperature");
return -EIO;
}
break;
case SENSOR_CHAN_PRESS:
if (!dps310_measure_psr(dev)) {
LOG_ERR("Failed to measure pressure");
return -EIO;
}
break;
case SENSOR_CHAN_ALL:
if (!dps310_measure_tmp_psr(dev)) {
LOG_ERR("Failed to measure temperature and pressure");
return -EIO;
}
break;
default:
return -EINVAL;
}
return 0;
}
/* Get the measurement data */
static int dps310_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct dps310_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
val->val1 = data->tmp_val1;
val->val2 = data->tmp_val2;
break;
case SENSOR_CHAN_PRESS:
val->val1 = data->psr_val1;
val->val2 = data->psr_val2;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api dps310_api_funcs = {
.sample_fetch = dps310_sample_fetch,
.channel_get = dps310_channel_get,
};
#define DPS310_DEFINE(inst) \
static struct dps310_data dps310_data_##inst; \
\
static const struct dps310_cfg dps310_cfg_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, dps310_init, NULL, \
&dps310_data_##inst, &dps310_cfg_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &dps310_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(DPS310_DEFINE)
``` | /content/code_sandbox/drivers/sensor/infineon/dps310/dps310.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,201 |
```c
/* Driver for MS5837 pressure sensor
*
*
*/
#define DT_DRV_COMPAT meas_ms5837
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "ms5837.h"
LOG_MODULE_REGISTER(MS5837, CONFIG_SENSOR_LOG_LEVEL);
static int ms5837_get_measurement(const struct device *dev, uint32_t *val,
uint8_t cmd, const uint8_t delay)
{
const struct ms5837_config *cfg = dev->config;
uint8_t adc_read_cmd = MS5837_CMD_CONV_READ_ADC;
int err;
*val = 0U;
err = i2c_write_dt(&cfg->i2c, &cmd, 1);
if (err < 0) {
return err;
}
k_msleep(delay);
err = i2c_burst_read_dt(&cfg->i2c, adc_read_cmd, ((uint8_t *)val) + 1,
3);
if (err < 0) {
return err;
}
*val = sys_be32_to_cpu(*val);
return 0;
}
static void ms5837_compensate_30(const struct device *dev,
const int32_t adc_temperature,
const int32_t adc_pressure)
{
struct ms5837_data *data = dev->data;
int64_t dT;
int64_t OFF;
int64_t SENS;
int64_t temp_sq;
int32_t Ti;
int32_t OFFi;
int32_t SENSi;
/* first order compensation as per datasheet
* (path_to_url section
* PRESSURE AND TEMPERATURE CALCULATION
*/
dT = adc_temperature - ((int32_t)(data->t_ref) << 8);
data->temperature = 2000 + (dT * data->tempsens) / (1ll << 23);
OFF = ((int64_t)(data->off_t1) << 16) + (dT * data->tco) / (1ll << 7);
SENS = ((int64_t)(data->sens_t1) << 15) + (dT * data->tcs) / (1ll << 8);
/* Second order compensation as per datasheet
* (path_to_url section
* SECOND ORDER TEMPERATURE COMPENSATION
*/
temp_sq = (int64_t)(data->temperature - 2000) * (data->temperature - 2000);
if (data->temperature < 2000) {
Ti = (3ll * dT * dT) / (1ll << 33);
OFFi = (3ll * temp_sq) / (1ll << 1);
SENSi = (5ll * temp_sq) / (1ll << 3);
if (data->temperature < -1500) {
temp_sq = (data->temperature + 1500) *
(data->temperature + 1500);
OFFi += 7ll * temp_sq;
SENSi += 4ll * temp_sq;
}
} else {
Ti = (2ll * dT * dT) / (1ll << 37);
OFFi = temp_sq / (1ll << 4);
SENSi = 0;
}
OFF -= OFFi;
SENS -= SENSi;
data->temperature -= Ti;
data->pressure =
(((SENS * adc_pressure) / (1ll << 21)) - OFF) / (1ll << 13);
}
/*
* First and second order pressure and temperature calculations, as per the flowchart in the
* MS5837-02B datasheet. (see "Pressure and Temperature Calculation", pages 6 and 7, REV a8 12/2019)
*/
static void ms5837_compensate_02(const struct device *dev,
const int32_t adc_temperature,
const int32_t adc_pressure)
{
struct ms5837_data *data = dev->data;
int64_t dT;
int64_t OFF;
int64_t SENS;
int64_t temp_sq;
int32_t Ti;
int32_t OFFi;
int32_t SENSi;
dT = adc_temperature - ((int32_t)(data->t_ref) << 8);
data->temperature = 2000 + (dT * data->tempsens) / (1ll << 23);
OFF = ((int64_t)(data->off_t1) << 17) + (dT * data->tco) / (1ll << 6);
SENS = ((int64_t)(data->sens_t1) << 16) + (dT * data->tcs) / (1ll << 7);
temp_sq = (int64_t)(data->temperature - 2000) * (data->temperature - 2000);
if (data->temperature < 2000) {
Ti = (11ll * dT * dT) / (1ll << 35);
OFFi = (31ll * temp_sq) / (1ll << 3);
SENSi = (63ll * temp_sq) / (1ll << 5);
} else {
Ti = 0;
OFFi = 0;
SENSi = 0;
}
OFF -= OFFi;
SENS -= SENSi;
data->temperature -= Ti;
data->pressure = (((SENS * adc_pressure) / (1ll << 21)) - OFF) / (1ll << 15);
}
static int ms5837_sample_fetch(const struct device *dev,
enum sensor_channel channel)
{
struct ms5837_data *data = dev->data;
int err;
uint32_t adc_pressure;
uint32_t adc_temperature;
__ASSERT_NO_MSG(channel == SENSOR_CHAN_ALL);
err = ms5837_get_measurement(dev, &adc_pressure, data->presure_conv_cmd,
data->presure_conv_delay);
if (err < 0) {
return err;
}
err = ms5837_get_measurement(dev, &adc_temperature,
data->temperature_conv_cmd,
data->temperature_conv_delay);
if (err < 0) {
return err;
}
data->comp_func(dev, adc_temperature, adc_pressure);
return 0;
}
static int ms5837_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct ms5837_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
/* Internal temperature is in 100ths of deg C */
val->val1 = data->temperature / 100;
val->val2 = data->temperature % 100 * 10000;
break;
case SENSOR_CHAN_PRESS:
/* Internal value is (mbar * 100), so factor to kPa is 1000 */
val->val1 = data->pressure / 1000;
val->val2 = data->pressure % 1000 * 1000;
break;
default:
return -ENOTSUP;
}
return 0;
}
static int ms5837_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct ms5837_data *data = dev->data;
uint8_t p_conv_cmd;
uint8_t t_conv_cmd;
uint8_t conv_delay;
if (attr == SENSOR_ATTR_OVERSAMPLING) {
switch (val->val1) {
case 8192:
p_conv_cmd = MS5837_CMD_CONV_P_8192;
t_conv_cmd = MS5837_CMD_CONV_T_8192;
conv_delay = 19U;
break;
case 4096:
p_conv_cmd = MS5837_CMD_CONV_P_4096;
t_conv_cmd = MS5837_CMD_CONV_T_4096;
conv_delay = 10U;
break;
case 2048:
p_conv_cmd = MS5837_CMD_CONV_P_2048;
t_conv_cmd = MS5837_CMD_CONV_T_2048;
conv_delay = 5U;
break;
case 1024:
p_conv_cmd = MS5837_CMD_CONV_P_1024;
t_conv_cmd = MS5837_CMD_CONV_T_1024;
conv_delay = 3U;
break;
case 512:
p_conv_cmd = MS5837_CMD_CONV_P_512;
t_conv_cmd = MS5837_CMD_CONV_T_512;
conv_delay = 2U;
break;
case 256:
p_conv_cmd = MS5837_CMD_CONV_P_256;
t_conv_cmd = MS5837_CMD_CONV_T_256;
conv_delay = 1U;
break;
default:
LOG_ERR("invalid oversampling rate %d", val->val1);
return -EINVAL;
}
if (chan == SENSOR_CHAN_ALL) {
data->presure_conv_cmd = p_conv_cmd;
data->presure_conv_delay = conv_delay;
data->temperature_conv_cmd = t_conv_cmd;
data->temperature_conv_delay = conv_delay;
return 0;
}
if (chan == SENSOR_CHAN_PRESS) {
data->presure_conv_cmd = p_conv_cmd;
data->presure_conv_delay = conv_delay;
return 0;
}
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
data->temperature_conv_cmd = t_conv_cmd;
data->temperature_conv_delay = conv_delay;
return 0;
}
return -ENOTSUP;
}
return -ENOTSUP;
}
static const struct sensor_driver_api ms5837_api_funcs = {
.attr_set = ms5837_attr_set,
.sample_fetch = ms5837_sample_fetch,
.channel_get = ms5837_channel_get,
};
static int ms5837_read_prom(const struct device *dev, const uint8_t cmd,
uint16_t *val)
{
const struct ms5837_config *cfg = dev->config;
int err;
err = i2c_burst_read_dt(&cfg->i2c, cmd, (uint8_t *)val, 2);
if (err < 0) {
return err;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
static int ms5837_init(const struct device *dev)
{
struct ms5837_data *data = dev->data;
const struct ms5837_config *cfg = dev->config;
int err;
uint8_t cmd;
data->pressure = 0;
data->temperature = 0;
data->presure_conv_cmd = MS5837_CMD_CONV_P_256;
data->presure_conv_delay = 1U;
data->temperature_conv_cmd = MS5837_CMD_CONV_T_256;
data->temperature_conv_delay = 1U;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
cmd = MS5837_CMD_RESET;
err = i2c_write_dt(&cfg->i2c, &cmd, 1);
if (err < 0) {
return err;
}
err = ms5837_read_prom(dev, MS5837_CMD_CONV_READ_CRC, &data->factory);
if (err < 0) {
LOG_ERR("couldn't read device info");
return err;
}
err = ms5837_read_prom(dev, MS5837_CMD_CONV_READ_SENS_T1, &data->sens_t1);
if (err < 0) {
return err;
}
err = ms5837_read_prom(dev, MS5837_CMD_CONV_READ_OFF_T1, &data->off_t1);
if (err < 0) {
return err;
}
err = ms5837_read_prom(dev, MS5837_CMD_CONV_READ_TCS, &data->tcs);
if (err < 0) {
return err;
}
err = ms5837_read_prom(dev, MS5837_CMD_CONV_READ_TCO, &data->tco);
if (err < 0) {
return err;
}
err = ms5837_read_prom(dev, MS5837_CMD_CONV_READ_T_REF, &data->t_ref);
if (err < 0) {
return err;
}
err = ms5837_read_prom(dev, MS5837_CMD_CONV_READ_TEMPSENS,
&data->tempsens);
if (err < 0) {
return err;
}
const int type_id = (data->factory >> 5) & 0x7f;
switch (type_id) {
case MS5837_02BA01:
case MS5837_02BA21:
data->comp_func = ms5837_compensate_02;
break;
case MS5837_30BA26:
data->comp_func = ms5837_compensate_30;
break;
default:
LOG_WRN(" unrecognized type: '%2x', defaulting to MS5837-30", type_id);
data->comp_func = ms5837_compensate_30;
break;
}
return 0;
}
#define MS5837_DEFINE(inst) \
static struct ms5837_data ms5837_data_##inst; \
\
static const struct ms5837_config ms5837_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, ms5837_init, NULL, \
&ms5837_data_##inst, &ms5837_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &ms5837_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(MS5837_DEFINE)
``` | /content/code_sandbox/drivers/sensor/meas/ms5837/ms5837.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,016 |
```c
/*
*
*/
#define DT_DRV_COMPAT meas_ms5607
#include <string.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include "ms5607.h"
#define LOG_LEVEL CONFIG_SENSOR_LOG_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ms5607);
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
static int ms5607_spi_raw_cmd(const struct ms5607_config *config, uint8_t cmd)
{
const struct spi_buf buf = {
.buf = &cmd,
.len = 1,
};
const struct spi_buf_set buf_set = {
.buffers = &buf,
.count = 1,
};
return spi_write_dt(&config->bus_cfg.spi, &buf_set);
}
static int ms5607_spi_reset(const struct ms5607_config *config)
{
int err = ms5607_spi_raw_cmd(config, MS5607_CMD_RESET);
if (err < 0) {
return err;
}
k_sleep(K_MSEC(3));
return 0;
}
static int ms5607_spi_read_prom(const struct ms5607_config *config, uint8_t cmd,
uint16_t *val)
{
int err;
uint8_t tx[3] = { cmd, 0, 0 };
const struct spi_buf tx_buf = {
.buf = tx,
.len = 3,
};
union {
struct {
uint8_t pad;
uint16_t prom_value;
} __packed;
uint8_t rx[3];
} rx;
const struct spi_buf rx_buf = {
.buf = &rx,
.len = 3,
};
const struct spi_buf_set rx_buf_set = {
.buffers = &rx_buf,
.count = 1,
};
const struct spi_buf_set tx_buf_set = {
.buffers = &tx_buf,
.count = 1,
};
err = spi_transceive_dt(&config->bus_cfg.spi, &tx_buf_set, &rx_buf_set);
if (err < 0) {
return err;
}
*val = sys_be16_to_cpu(rx.prom_value);
return 0;
}
static int ms5607_spi_start_conversion(const struct ms5607_config *config, uint8_t cmd)
{
return ms5607_spi_raw_cmd(config, cmd);
}
static int ms5607_spi_read_adc(const struct ms5607_config *config, uint32_t *val)
{
int err;
uint8_t tx[4] = { MS5607_CMD_CONV_READ_ADC, 0, 0, 0 };
const struct spi_buf tx_buf = {
.buf = tx,
.len = 4,
};
union {
struct {
uint32_t adc_value;
} __packed;
uint8_t rx[4];
} rx;
const struct spi_buf rx_buf = {
.buf = &rx,
.len = 4,
};
const struct spi_buf_set rx_buf_set = {
.buffers = &rx_buf,
.count = 1,
};
const struct spi_buf_set tx_buf_set = {
.buffers = &tx_buf,
.count = 1,
};
err = spi_transceive_dt(&config->bus_cfg.spi, &tx_buf_set, &rx_buf_set);
if (err < 0) {
return err;
}
rx.rx[0] = 0;
*val = sys_be32_to_cpu(rx.adc_value);
return 0;
}
static int ms5607_spi_check(const struct ms5607_config *config)
{
if (!spi_is_ready_dt(&config->bus_cfg.spi)) {
LOG_DBG("SPI bus not ready");
return -ENODEV;
}
return 0;
}
const struct ms5607_transfer_function ms5607_spi_transfer_function = {
.bus_check = ms5607_spi_check,
.reset = ms5607_spi_reset,
.read_prom = ms5607_spi_read_prom,
.start_conversion = ms5607_spi_start_conversion,
.read_adc = ms5607_spi_read_adc,
};
#endif
``` | /content/code_sandbox/drivers/sensor/meas/ms5607/ms5607_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 893 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.