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 |
|---|---|---|---|---|---|---|---|---|
```c
/*
*
*/
#include <stdlib.h>
#include <string.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include "sensor_shell.h"
/* Create a single common config for streaming */
static struct sensor_stream_trigger iodev_sensor_shell_trigger;
static struct sensor_read_config iodev_sensor_shell_stream_config = {
.sensor = NULL,
.is_streaming = true,
.triggers = &iodev_sensor_shell_trigger,
.count = 0,
.max = 1,
};
RTIO_IODEV_DEFINE(iodev_sensor_shell_stream, &__sensor_iodev_api,
&iodev_sensor_shell_stream_config);
static void sensor_shell_processing_entry_point(void *a, void *b, void *c)
{
ARG_UNUSED(a);
ARG_UNUSED(b);
ARG_UNUSED(c);
while (true) {
sensor_processing_with_callback(&sensor_read_rtio,
sensor_shell_processing_callback);
}
}
K_THREAD_DEFINE(sensor_shell_processing_tid, CONFIG_SENSOR_SHELL_THREAD_STACK_SIZE,
sensor_shell_processing_entry_point, NULL, NULL, NULL, 0, 0, 0);
int cmd_sensor_stream(const struct shell *shell_ptr, size_t argc, char *argv[])
{
static struct rtio_sqe *current_streaming_handle;
static struct sensor_shell_processing_context ctx;
const struct device *dev = device_get_binding(argv[1]);
if (argc != 5 && argc != 3) {
shell_error(shell_ptr, "Wrong number of arguments (%zu)", argc);
return -EINVAL;
}
if (dev == NULL) {
shell_error(shell_ptr, "Device unknown (%s)", argv[1]);
return -ENODEV;
}
if (current_streaming_handle != NULL) {
shell_info(shell_ptr, "Disabling existing stream");
rtio_sqe_cancel(current_streaming_handle);
}
if (strcmp("off", argv[2]) == 0) {
return 0;
}
if (strcmp("on", argv[2]) != 0) {
shell_error(shell_ptr, "Unknown streaming operation (%s)", argv[2]);
return -EINVAL;
}
if (strcmp("double_tap", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_DOUBLE_TAP;
} else if (strcmp("data_ready", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_DATA_READY;
} else if (strcmp("delta", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_DELTA;
} else if (strcmp("freefall", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_FREEFALL;
} else if (strcmp("motion", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_MOTION;
} else if (strcmp("near_far", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_NEAR_FAR;
} else if (strcmp("stationary", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_STATIONARY;
} else if (strcmp("threshold", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_THRESHOLD;
} else if (strcmp("fifo_wm", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_FIFO_WATERMARK;
} else if (strcmp("fifo_full", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_FIFO_FULL;
} else if (strcmp("tap", argv[3]) == 0) {
iodev_sensor_shell_trigger.trigger = SENSOR_TRIG_TAP;
} else {
shell_error(shell_ptr, "Invalid trigger (%s)", argv[3]);
return -EINVAL;
}
if (strcmp("incl", argv[4]) == 0) {
iodev_sensor_shell_trigger.opt = SENSOR_STREAM_DATA_INCLUDE;
} else if (strcmp("drop", argv[4]) == 0) {
iodev_sensor_shell_trigger.opt = SENSOR_STREAM_DATA_DROP;
} else if (strcmp("nop", argv[4]) == 0) {
iodev_sensor_shell_trigger.opt = SENSOR_STREAM_DATA_NOP;
} else {
shell_error(shell_ptr, "Unknown trigger op (%s)", argv[4]);
return -EINVAL;
}
shell_print(shell_ptr, "Enabling stream...");
iodev_sensor_shell_stream_config.sensor = dev;
iodev_sensor_shell_stream_config.count = 1;
ctx.dev = dev;
ctx.sh = shell_ptr;
int rc = sensor_stream(&iodev_sensor_shell_stream, &sensor_read_rtio, &ctx,
¤t_streaming_handle);
if (rc != 0) {
shell_error(shell_ptr, "Failed to start stream");
}
return rc;
}
``` | /content/code_sandbox/drivers/sensor/sensor_shell_stream.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,080 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SENSOR_SHELL_H
#define ZEPHYR_DRIVERS_SENSOR_SENSOR_SHELL_H
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/rtio/rtio.h>
#include <zephyr/shell/shell.h>
struct sensor_shell_processing_context {
const struct device *dev;
const struct shell *sh;
};
extern struct rtio sensor_read_rtio;
int cmd_sensor_stream(const struct shell *shell_ptr, size_t argc, char *argv[]);
void sensor_shell_processing_callback(int result, uint8_t *buf, uint32_t buf_len, void *userdata);
#endif /* ZEPHYR_DRIVERS_SENSOR_SENSOR_SHELL_H */
``` | /content/code_sandbox/drivers/sensor/sensor_shell.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 158 |
```c
/*
*
*/
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
static int sensor_decoders_init(void)
{
STRUCT_SECTION_FOREACH(sensor_decoder_api, api) {
k_object_access_all_grant(api);
}
return 0;
}
SYS_INIT(sensor_decoders_init, POST_KERNEL, 99);
``` | /content/code_sandbox/drivers/sensor/sensor_decoders_init.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#include <zephyr/internal/syscall_handler.h>
static inline int z_vrfy_sensor_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
K_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, attr_set));
K_OOPS(K_SYSCALL_MEMORY_READ(val, sizeof(struct sensor_value)));
return z_impl_sensor_attr_set((const struct device *)dev, chan, attr,
(const struct sensor_value *)val);
}
#include <zephyr/syscalls/sensor_attr_set_mrsh.c>
static inline int z_vrfy_sensor_attr_get(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
struct sensor_value *val)
{
K_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, attr_get));
K_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value)));
return z_impl_sensor_attr_get((const struct device *)dev, chan, attr,
(struct sensor_value *)val);
}
#include <zephyr/syscalls/sensor_attr_get_mrsh.c>
static inline int z_vrfy_sensor_sample_fetch(const struct device *dev)
{
K_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, sample_fetch));
return z_impl_sensor_sample_fetch((const struct device *)dev);
}
#include <zephyr/syscalls/sensor_sample_fetch_mrsh.c>
static inline int z_vrfy_sensor_sample_fetch_chan(const struct device *dev,
enum sensor_channel type)
{
K_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, sample_fetch));
return z_impl_sensor_sample_fetch_chan((const struct device *)dev,
type);
}
#include <zephyr/syscalls/sensor_sample_fetch_chan_mrsh.c>
static inline int z_vrfy_sensor_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
K_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, channel_get));
K_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value)));
return z_impl_sensor_channel_get((const struct device *)dev, chan,
(struct sensor_value *)val);
}
#include <zephyr/syscalls/sensor_channel_get_mrsh.c>
#ifdef CONFIG_SENSOR_ASYNC_API
static inline int z_vrfy_sensor_get_decoder(const struct device *dev,
const struct sensor_decoder_api **decoder)
{
K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_SENSOR));
K_OOPS(K_SYSCALL_MEMORY_READ(decoder, sizeof(struct sensor_decoder_api)));
return z_impl_sensor_get_decoder(dev, decoder);
}
#include <zephyr/syscalls/sensor_get_decoder_mrsh.c>
static inline int z_vrfy_sensor_reconfigure_read_iodev(struct rtio_iodev *iodev,
const struct device *sensor,
const enum sensor_channel *channels,
size_t num_channels)
{
K_OOPS(K_SYSCALL_OBJ(iodev, K_OBJ_RTIO_IODEV));
K_OOPS(K_SYSCALL_OBJ(sensor, K_OBJ_DRIVER_SENSOR));
K_OOPS(K_SYSCALL_MEMORY_READ(channels, sizeof(enum sensor_channel) * num_channels));
return z_impl_sensor_reconfigure_read_iodev(iodev, sensor, channels, num_channels);
}
#include <zephyr/syscalls/sensor_reconfigure_read_iodev_mrsh.c>
#endif
``` | /content/code_sandbox/drivers/sensor/sensor_handlers.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 697 |
```unknown
# Common Kconfig template for all sensors
choice "$(module)_TRIGGER_MODE"
prompt "Trigger mode"
help
Specify the type of triggering to be used by the sensor module.
config $(module)_TRIGGER_NONE
bool "No trigger"
config $(module)_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select $(module)_TRIGGER
config $(module)_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select $(module)_TRIGGER
endchoice
config $(module)_TRIGGER
bool
if $(module)_TRIGGER
config $(module)_THREAD_PRIORITY
int "Thread priority"
depends on $(module)_TRIGGER_OWN_THREAD
default $(thread_priority)
help
Priority of thread used by the driver to handle interrupts.
config $(module)_THREAD_STACK_SIZE
int "Thread stack size"
depends on $(module)_TRIGGER_OWN_THREAD
default $(thread_stack_size)
help
Stack size of thread used by the driver to handle interrupts.
endif # $(module)_TRIGGER
``` | /content/code_sandbox/drivers/sensor/Kconfig.trigger_template | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 225 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_MC3419_H_
#define ZEPHYR_DRIVERS_SENSOR_MC3419_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>
/* Registers */
#define MC3419_REG_INT_CTRL 0x06
#define MC3419_REG_OP_MODE 0x07
#define MC3419_REG_SAMPLE_RATE 0x08
#define MC3419_REG_MOTION_CTRL 0x09
#define MC3419_REG_XOUT_L 0x0D
#define MC3419_REG_YOUT_L 0x0F
#define MC3419_REG_ZOUT_L 0x11
#define MC3419_REG_STATUS 0x13
#define MC3419_REG_INT_STATUS 0x14
#define MC3419_REG_RANGE_SELECT_CTRL 0x20
#define MC3419_REG_SAMPLE_RATE_2 0x30
#define MC3419_REG_COMM_CTRL 0x31
#define MC3419_REG_ANY_MOTION_THRES 0x43
#define MC3419_RANGE_MASK GENMASK(6, 4)
#define MC3419_DATA_READY_MASK BIT(7)
#define MC3419_ANY_MOTION_MASK BIT(2)
#define MC3419_INT_CLEAR 0x00
#define MC3419_INT_ROUTE 0x10
#define MC3419_ANY_MOTION_THRESH_MAX 0x7FFF
#define MC3419_SAMPLE_SIZE 3
#define MC3419_SAMPLE_READ_SIZE (MC3419_SAMPLE_SIZE * (sizeof(int16_t)))
#define SENSOR_GRAIN_VALUE (61LL / 1000.0)
#define SENSOR_GRAVITY_DOUBLE (SENSOR_G / 1000000.0)
#define MC3419_BASE_ODR_VAL 0x10
#define MC3419_TRIG_DATA_READY 0
#define MC3419_TRIG_ANY_MOTION 1
#define MC3419_TRIG_SIZE 2
enum mc3419_op_mode {
MC3419_MODE_STANDBY = 0x00,
MC3419_MODE_WAKE = 0x01
};
struct mc3419_odr_map {
int16_t freq;
int16_t mfreq;
};
enum mc3419_accl_range {
MC3419_ACCl_RANGE_2G,
MC3419_ACCl_RANGE_4G,
MC3419_ACCl_RANGE_8G,
MC3419_ACCl_RANGE_16G,
MC3419_ACCl_RANGE_12G,
MC3419_ACCL_RANGE_END
};
struct mc3419_config {
struct i2c_dt_spec i2c;
#if defined(CONFIG_MC3419_TRIGGER)
struct gpio_dt_spec int_gpio;
bool int_cfg;
#endif
};
struct mc3419_driver_data {
double sensitivity;
struct k_sem sem;
int16_t samples[MC3419_SAMPLE_SIZE];
#if defined(CONFIG_MC3419_TRIGGER)
const struct device *gpio_dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler[MC3419_TRIG_SIZE];
const struct sensor_trigger *trigger[MC3419_TRIG_SIZE];
#if defined(CONFIG_MC3419_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_MC3419_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#else
struct k_work work;
#endif
#endif
};
#if defined(CONFIG_MC3419_TRIGGER)
int mc3419_trigger_init(const struct device *dev);
int mc3419_configure_trigger(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif
#endif
``` | /content/code_sandbox/drivers/sensor/mc3419/mc3419.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 795 |
```unknown
# Sensor configuration options
menuconfig SENSOR
bool "Sensor drivers"
help
Include sensor drivers in system config
if SENSOR
module = SENSOR
module-str = sensor
source "subsys/logging/Kconfig.template.log_config"
config SENSOR_INIT_PRIORITY
int "Sensor init priority"
default 90
help
Sensor initialization priority.
config SENSOR_ASYNC_API
bool "Async Sensor API"
select RTIO
select RTIO_SYS_MEM_BLOCKS
select RTIO_CONSUME_SEM
select RTIO_WORKQ
help
Enables the asynchronous sensor API by leveraging the RTIO subsystem.
config SENSOR_SHELL
bool "Sensor shell"
depends on SHELL
select CBPRINTF_FP_SUPPORT
select SENSOR_ASYNC_API
help
This shell provides access to basic sensor data.
config SENSOR_SHELL_STREAM
bool "Sensor shell 'stream' command"
depends on SENSOR_SHELL
help
Add the 'stream' subcommand to the sensor shell. When run on drivers that
support streaming (usually hardware FIFO backed), the shell will continue
to print new values as they come until the stream is closed.
config SENSOR_SHELL_THREAD_STACK_SIZE
int "Stack size for the sensor shell data processing thread"
depends on SENSOR_SHELL_STREAM
default 1024
help
The sensor shell uses a dedicated thread to process data coming from the
sensors in either one-shot or streaming mode. Use this config to control
the size of that thread's stack.
config SENSOR_SHELL_BATTERY
bool "Sensor shell 'battery' command"
depends on SHELL
help
This enables the 'battery' command which reports charging information
in a convenient format. It makes use of a fuel gauge to read its
information.
config SENSOR_SHELL_TRIG_PRINT_TIMEOUT_MS
int "Timeout for printing the average sensor sample value"
default 5000
depends on SENSOR_SHELL
help
Control the frequency of the sampling window over which the sensor
interrupt handler will collect data.
config SENSOR_SHELL_MAX_TRIGGER_DEVICES
int "Maximum number of sensor devices that can have enabled triggers in shell"
default 1
depends on SENSOR_SHELL
help
Maximum number of sensor devices that the shell cmd can have
enabled triggers for.
config SENSOR_INFO
bool "Sensor Info iterable section"
comment "Device Drivers"
# zephyr-keep-sorted-start
source "drivers/sensor/adi/Kconfig"
source "drivers/sensor/ams/Kconfig"
source "drivers/sensor/aosong/Kconfig"
source "drivers/sensor/asahi_kasei/Kconfig"
source "drivers/sensor/bosch/Kconfig"
source "drivers/sensor/espressif/Kconfig"
source "drivers/sensor/honeywell/Kconfig"
source "drivers/sensor/infineon/Kconfig"
source "drivers/sensor/ite/Kconfig"
source "drivers/sensor/maxim/Kconfig"
source "drivers/sensor/meas/Kconfig"
source "drivers/sensor/microchip/Kconfig"
source "drivers/sensor/nordic/Kconfig"
source "drivers/sensor/nuvoton/Kconfig"
source "drivers/sensor/nxp/Kconfig"
source "drivers/sensor/rohm/Kconfig"
source "drivers/sensor/seeed/Kconfig"
source "drivers/sensor/sensirion/Kconfig"
source "drivers/sensor/silabs/Kconfig"
source "drivers/sensor/st/Kconfig"
source "drivers/sensor/ti/Kconfig"
source "drivers/sensor/vishay/Kconfig"
source "drivers/sensor/wsen/Kconfig"
# zephyr-keep-sorted-stop
source "drivers/sensor/a01nyub/Kconfig"
source "drivers/sensor/amd_sb_tsi/Kconfig"
source "drivers/sensor/amg88xx/Kconfig"
source "drivers/sensor/apds9960/Kconfig"
source "drivers/sensor/current_amp/Kconfig"
source "drivers/sensor/ens160/Kconfig"
source "drivers/sensor/explorir_m/Kconfig"
source "drivers/sensor/f75303/Kconfig"
source "drivers/sensor/fcx_mldx5/Kconfig"
source "drivers/sensor/grow_r502a/Kconfig"
source "drivers/sensor/hp206c/Kconfig"
source "drivers/sensor/hs300x/Kconfig"
source "drivers/sensor/tdk/icm42605/Kconfig"
source "drivers/sensor/tdk/icm42670/Kconfig"
source "drivers/sensor/tdk/icm42688/Kconfig"
source "drivers/sensor/tdk/icp10125/Kconfig"
source "drivers/sensor/isl29035/Kconfig"
source "drivers/sensor/ist8310/Kconfig"
source "drivers/sensor/lm35/Kconfig"
source "drivers/sensor/lm75/Kconfig"
source "drivers/sensor/lm77/Kconfig"
source "drivers/sensor/ltrf216a/Kconfig"
source "drivers/sensor/mc3419/Kconfig"
source "drivers/sensor/mhz19b/Kconfig"
source "drivers/sensor/tdk/mpu6050/Kconfig"
source "drivers/sensor/tdk/mpu9250/Kconfig"
source "drivers/sensor/nct75/Kconfig"
source "drivers/sensor/ntc_thermistor/Kconfig"
source "drivers/sensor/pms7003/Kconfig"
source "drivers/sensor/qdec_sam/Kconfig"
source "drivers/sensor/rpi_pico_temp/Kconfig"
source "drivers/sensor/s11059/Kconfig"
source "drivers/sensor/sbs_gauge/Kconfig"
source "drivers/sensor/sx9500/Kconfig"
source "drivers/sensor/th02/Kconfig"
source "drivers/sensor/tsic_xx6/Kconfig"
source "drivers/sensor/veaa_x_3/Kconfig"
source "drivers/sensor/voltage_divider/Kconfig"
source "drivers/sensor/ene_tach_kb1200/Kconfig"
endif # SENSOR
``` | /content/code_sandbox/drivers/sensor/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,250 |
```unknown
#
menuconfig MC3419
bool "MC3419 acclerometer driver"
default y
depends on DT_HAS_MEMSIC_MC3419_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_MEMSIC_MC3419),i2c)
help
Enable driver for MC3419 acclerometer.
if MC3419
config MC3419_TRIGGER
bool "Trigger mode"
if MC3419_TRIGGER
config MC3419_TRIGGER_OWN_THREAD
bool "Use own thread"
help
Enable trigger to run in own thread. By
default it is global thread mode.
config MC3419_THREAD_PRIORITY
int "Own thread priority"
depends on MC3419_TRIGGER_OWN_THREAD
default 10
config MC3419_THREAD_STACK_SIZE
int "Own thread stask size"
depends on MC3419_TRIGGER_OWN_THREAD
default 1024
endif # MC3419_TRIGGER
config MC3419_DECIMATION_RATE
int "Enable decimation rate"
range 0 15
default 15
help
This helps in producing slower interrupt. Internal Data
Rate is divide by this decimation rate. If decimation rate
is 0 then internal data rate is equal to output data rate,
then it produce interrupt floods.
endif # MC3419
``` | /content/code_sandbox/drivers/sensor/mc3419/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 280 |
```c
/*
*
*/
#include "mc3419.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(MC3419, CONFIG_SENSOR_LOG_LEVEL);
static void mc3419_gpio_callback(const struct device *dev,
struct gpio_callback *cb,
uint32_t pin_mask)
{
struct mc3419_driver_data *data = CONTAINER_OF(cb,
struct mc3419_driver_data, gpio_cb);
const struct mc3419_config *cfg = data->gpio_dev->config;
if ((pin_mask & BIT(cfg->int_gpio.pin)) == 0U) {
return;
}
#if defined(CONFIG_MC3419_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#else
k_work_submit(&data->work);
#endif
}
static void mc3419_process_int(const struct device *dev)
{
int ret = 0;
const struct mc3419_config *cfg = dev->config;
const struct mc3419_driver_data *data = dev->data;
uint8_t int_source = 0;
ret = i2c_reg_read_byte_dt(&cfg->i2c, MC3419_REG_INT_STATUS, &int_source);
if (ret < 0) {
goto exit;
}
if (int_source & MC3419_DATA_READY_MASK) {
if (data->handler[MC3419_TRIG_DATA_READY]) {
data->handler[MC3419_TRIG_DATA_READY](dev,
data->trigger[MC3419_TRIG_DATA_READY]);
}
}
if (int_source & MC3419_ANY_MOTION_MASK) {
if (data->handler[MC3419_TRIG_ANY_MOTION]) {
data->handler[MC3419_TRIG_ANY_MOTION](dev,
data->trigger[MC3419_TRIG_ANY_MOTION]);
}
}
exit:
ret = i2c_reg_write_byte_dt(&cfg->i2c, MC3419_REG_INT_STATUS,
MC3419_INT_CLEAR);
if (ret < 0) {
LOG_ERR("Failed to clear interrupt (%d)", ret);
}
}
#if defined(CONFIG_MC3419_TRIGGER_OWN_THREAD)
static void mc3419_thread(struct mc3419_driver_data *data)
{
while (1) {
k_sem_take(&data->trig_sem, K_FOREVER);
mc3419_process_int(data->gpio_dev);
}
}
#else
static void mc3419_work_cb(struct k_work *work)
{
struct mc3419_driver_data *data = CONTAINER_OF(work,
struct mc3419_driver_data, work);
mc3419_process_int(data->gpio_dev);
}
#endif
int mc3419_configure_trigger(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
int ret = 0;
uint8_t buf = 0;
const struct mc3419_config *cfg = dev->config;
struct mc3419_driver_data *data = dev->data;
if (!(trig->type & SENSOR_TRIG_DATA_READY) &&
!(trig->type & SENSOR_TRIG_MOTION)) {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
if (trig->type & SENSOR_TRIG_DATA_READY) {
data->handler[MC3419_TRIG_DATA_READY] = handler;
data->trigger[MC3419_TRIG_DATA_READY] = trig;
buf |= MC3419_DATA_READY_MASK;
}
if (trig->type & SENSOR_TRIG_MOTION) {
uint8_t int_mask = MC3419_ANY_MOTION_MASK;
buf |= MC3419_ANY_MOTION_MASK;
data->handler[MC3419_TRIG_ANY_MOTION] = handler;
data->trigger[MC3419_TRIG_ANY_MOTION] = trig;
ret = i2c_reg_update_byte_dt(&cfg->i2c, MC3419_REG_MOTION_CTRL,
int_mask, handler ? int_mask : 0);
if (ret < 0) {
LOG_ERR("Failed to configure motion interrupt (%d)", ret);
return ret;
}
}
ret = i2c_reg_update_byte_dt(&cfg->i2c, MC3419_REG_INT_CTRL,
buf, buf);
if (ret < 0) {
LOG_ERR("Failed to configure interrupt (%d)", ret);
return ret;
}
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_FALLING);
return ret;
}
int mc3419_trigger_init(const struct device *dev)
{
int ret = 0;
struct mc3419_driver_data *data = dev->data;
const struct mc3419_config *cfg = dev->config;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("GPIO port %s not ready", cfg->int_gpio.port->name);
return -ENODEV;
}
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Failed to configure interrupt gpio");
return ret;
}
data->gpio_dev = dev;
#if defined(CONFIG_MC3419_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, 1);
k_thread_create(&data->thread, data->thread_stack,
CONFIG_MC3419_THREAD_STACK_SIZE,
(k_thread_entry_t)mc3419_thread, data, NULL,
NULL, K_PRIO_COOP(CONFIG_MC3419_THREAD_PRIORITY), 0,
K_NO_WAIT);
#else
k_work_init(&data->work, mc3419_work_cb);
#endif
gpio_init_callback(&data->gpio_cb, mc3419_gpio_callback,
BIT(cfg->int_gpio.pin));
ret = gpio_add_callback(cfg->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
LOG_ERR("Failed to set int callback");
return ret;
}
if (cfg->int_cfg) {
ret = i2c_reg_write_byte_dt(&cfg->i2c, MC3419_REG_COMM_CTRL,
MC3419_INT_ROUTE);
if (ret < 0) {
LOG_ERR("Failed to route the interrupt to INT2 pin (%d)", ret);
return ret;
}
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/mc3419/mc3419_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,328 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/espressif/esp32_temp/Kconfig"
source "drivers/sensor/espressif/pcnt_esp32/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/espressif/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 54 |
```unknown
config ESP32_TEMP
bool "ESP32 Temperature Sensor"
default y
depends on DT_HAS_ESPRESSIF_ESP32_TEMP_ENABLED
depends on !SOC_SERIES_ESP32
help
Enable driver for temperature sensor on certain ESP targets.
``` | /content/code_sandbox/drivers/sensor/espressif/esp32_temp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 55 |
```c
/*
*
*/
#define DT_DRV_COMPAT memsic_mc3419
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include "mc3419.h"
LOG_MODULE_REGISTER(MC3419, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t mc3419_accel_sense_map[] = {1, 2, 4, 8, 6};
static struct mc3419_odr_map odr_map_table[] = {
{25}, {50}, {62, 500}, {100},
{125}, {250}, {500}, {1000}
};
static int mc3419_get_odr_value(uint16_t freq, uint16_t m_freq)
{
for (int i = 0; i < ARRAY_SIZE(odr_map_table); i++) {
if (odr_map_table[i].freq == freq &&
odr_map_table[i].mfreq == m_freq) {
return i;
}
}
return -EINVAL;
}
static inline int mc3419_set_op_mode(const struct mc3419_config *cfg,
enum mc3419_op_mode mode)
{
return i2c_reg_write_byte_dt(&cfg->i2c, MC3419_REG_OP_MODE, mode);
}
static int mc3419_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
int ret = 0;
const struct mc3419_config *cfg = dev->config;
struct mc3419_driver_data *data = dev->data;
k_sem_take(&data->sem, K_FOREVER);
ret = i2c_burst_read_dt(&cfg->i2c, MC3419_REG_XOUT_L,
(uint8_t *)data->samples,
MC3419_SAMPLE_READ_SIZE);
k_sem_give(&data->sem);
return ret;
}
static int mc3419_to_sensor_value(double sensitivity, int16_t *raw_data,
struct sensor_value *val)
{
double value = sys_le16_to_cpu(*raw_data);
value *= sensitivity * SENSOR_GRAVITY_DOUBLE / 1000;
return sensor_value_from_double(val, value);
}
static int mc3419_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
int ret = 0;
struct mc3419_driver_data *data = dev->data;
k_sem_take(&data->sem, K_FOREVER);
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ret = mc3419_to_sensor_value(data->sensitivity, &data->samples[0], val);
break;
case SENSOR_CHAN_ACCEL_Y:
ret = mc3419_to_sensor_value(data->sensitivity, &data->samples[1], val);
break;
case SENSOR_CHAN_ACCEL_Z:
ret = mc3419_to_sensor_value(data->sensitivity, &data->samples[2], val);
break;
case SENSOR_CHAN_ACCEL_XYZ:
ret = mc3419_to_sensor_value(data->sensitivity, &data->samples[0], &val[0]);
ret |= mc3419_to_sensor_value(data->sensitivity, &data->samples[1], &val[1]);
ret |= mc3419_to_sensor_value(data->sensitivity, &data->samples[2], &val[2]);
break;
default:
LOG_ERR("Unsupported channel");
ret = -ENOTSUP;
}
k_sem_give(&data->sem);
return ret;
}
static int mc3419_set_accel_range(const struct device *dev, uint8_t range)
{
int ret = 0;
const struct mc3419_config *cfg = dev->config;
struct mc3419_driver_data *data = dev->data;
if (range >= MC3419_ACCL_RANGE_END) {
LOG_ERR("Accel resolution is out of range");
return -EINVAL;
}
ret = i2c_reg_update_byte_dt(&cfg->i2c, MC3419_REG_RANGE_SELECT_CTRL,
MC3419_RANGE_MASK, range << 4);
if (ret < 0) {
LOG_ERR("Failed to set resolution (%d)", ret);
return ret;
}
data->sensitivity = (double)(mc3419_accel_sense_map[range] *
SENSOR_GRAIN_VALUE);
return 0;
}
static int mc3419_set_odr(const struct device *dev,
const struct sensor_value *val)
{
int ret = 0;
int data_rate = 0;
const struct mc3419_config *cfg = dev->config;
ret = mc3419_get_odr_value(val->val1, val->val2);
if (ret < 0) {
LOG_ERR("Failed to get odr value from odr map (%d)", ret);
return ret;
}
data_rate = MC3419_BASE_ODR_VAL + ret;
ret = i2c_reg_write_byte_dt(&cfg->i2c, MC3419_REG_SAMPLE_RATE,
data_rate);
if (ret < 0) {
LOG_ERR("Failed to set ODR (%d)", ret);
return ret;
}
LOG_DBG("Set ODR Rate to 0x%x", data_rate);
ret = i2c_reg_write_byte_dt(&cfg->i2c, MC3419_REG_SAMPLE_RATE_2,
CONFIG_MC3419_DECIMATION_RATE);
if (ret < 0) {
LOG_ERR("Failed to set decimation rate (%d)", ret);
return ret;
}
return 0;
}
#if defined(CONFIG_MC3419_TRIGGER)
static int mc3419_set_anymotion_threshold(const struct device *dev,
const struct sensor_value *val)
{
int ret = 0;
const struct mc3419_config *cfg = dev->config;
uint8_t buf[3] = {0};
if (val->val1 > MC3419_ANY_MOTION_THRESH_MAX) {
return -EINVAL;
}
buf[0] = MC3419_REG_ANY_MOTION_THRES;
sys_put_le16((uint16_t)val->val1, &buf[1]);
ret = i2c_write_dt(&cfg->i2c, buf, sizeof(buf));
if (ret < 0) {
LOG_ERR("Failed to set anymotion threshold (%d)", ret);
return ret;
}
return 0;
}
static int mc3419_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
int ret = 0;
const struct mc3419_config *cfg = dev->config;
struct mc3419_driver_data *data = dev->data;
k_sem_take(&data->sem, K_FOREVER);
ret = mc3419_set_op_mode(cfg, MC3419_MODE_STANDBY);
if (ret < 0) {
goto exit;
}
ret = mc3419_configure_trigger(dev, trig, handler);
if (ret < 0) {
LOG_ERR("Failed to set trigger (%d)", ret);
}
exit:
mc3419_set_op_mode(cfg, MC3419_MODE_WAKE);
k_sem_give(&data->sem);
return ret;
}
#endif
static int mc3419_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
int ret = 0;
struct mc3419_driver_data *data = dev->data;
if (chan != SENSOR_CHAN_ACCEL_X &&
chan != SENSOR_CHAN_ACCEL_Y &&
chan != SENSOR_CHAN_ACCEL_Z &&
chan != SENSOR_CHAN_ACCEL_XYZ) {
LOG_ERR("Not supported on this channel.");
return -ENOTSUP;
}
k_sem_take(&data->sem, K_FOREVER);
ret = mc3419_set_op_mode(dev->config, MC3419_MODE_STANDBY);
if (ret < 0) {
goto exit;
}
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
ret = mc3419_set_accel_range(dev, val->val1);
break;
case SENSOR_ATTR_SAMPLING_FREQUENCY:
ret = mc3419_set_odr(dev, val);
break;
#if defined(CONFIG_MC3419_TRIGGER)
case SENSOR_ATTR_SLOPE_TH:
ret = mc3419_set_anymotion_threshold(dev, val);
break;
#endif
default:
LOG_ERR("ACCEL attribute is not supported");
ret = -EINVAL;
}
exit:
mc3419_set_op_mode(dev->config, MC3419_MODE_WAKE);
k_sem_give(&data->sem);
return ret;
}
static int mc3419_init(const struct device *dev)
{
int ret = 0;
struct mc3419_driver_data *data = dev->data;
const struct mc3419_config *cfg = dev->config;
if (!(i2c_is_ready_dt(&cfg->i2c))) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
k_sem_init(&data->sem, 1, 1);
#if defined(CONFIG_MC3419_TRIGGER)
ret = mc3419_trigger_init(dev);
if (ret < 0) {
LOG_ERR("Could not initialize interrupts");
return ret;
}
#endif
/* Leave the sensor in default power on state, will be
* enabled by configure attr or setting trigger.
*/
LOG_INF("MC3419 Initialized");
return ret;
}
static const struct sensor_driver_api mc3419_api = {
.attr_set = mc3419_attr_set,
#if defined(CONFIG_MC3419_TRIGGER)
.trigger_set = mc3419_trigger_set,
#endif
.sample_fetch = mc3419_sample_fetch,
.channel_get = mc3419_channel_get,
};
#if defined(CONFIG_MC3419_TRIGGER)
#define MC3419_CFG_IRQ(idx) \
.int_gpio = GPIO_DT_SPEC_INST_GET_OR(idx, int_gpios, { 0 }), \
.int_cfg = DT_INST_PROP(idx, int_pin2),
#else
#define MC3419_CFG_IRQ(idx)
#endif
#define MC3419_DEFINE(idx) \
static const struct mc3419_config mc3419_config_##idx = { \
.i2c = I2C_DT_SPEC_INST_GET(idx), \
MC3419_CFG_IRQ(idx) \
}; \
static struct mc3419_driver_data mc3419_data_##idx; \
SENSOR_DEVICE_DT_INST_DEFINE(idx, \
mc3419_init, NULL, \
&mc3419_data_##idx, \
&mc3419_config_##idx, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&mc3419_api);
DT_INST_FOREACH_STATUS_OKAY(MC3419_DEFINE)
``` | /content/code_sandbox/drivers/sensor/mc3419/mc3419.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,300 |
```c
/*
*
*/
#define DT_DRV_COMPAT espressif_esp32_temp
#include <driver/temp_sensor.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(esp32_temp, CONFIG_SENSOR_LOG_LEVEL);
#if CONFIG_SOC_SERIES_ESP32
#error "Temperature sensor not supported on ESP32"
#endif /* CONFIG_SOC_SERIES_ESP32 */
struct esp32_temp_data {
struct k_mutex mutex;
temp_sensor_config_t temp_sensor;
float temp_out;
};
struct esp32_temp_config {
temp_sensor_dac_offset_t range;
};
static int esp32_temp_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct esp32_temp_data *data = dev->data;
int rc = 0;
k_mutex_lock(&data->mutex, K_FOREVER);
if (temp_sensor_read_celsius(&data->temp_out) != ESP_OK) {
LOG_ERR("Temperature read error!");
rc = -EFAULT;
goto unlock;
}
unlock:
k_mutex_unlock(&data->mutex);
return rc;
}
static int esp32_temp_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct esp32_temp_data *data = dev->data;
const struct esp32_temp_config *cfg = dev->config;
if (chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
return sensor_value_from_double(val, data->temp_out);
}
static const struct sensor_driver_api esp32_temp_driver_api = {
.sample_fetch = esp32_temp_sample_fetch,
.channel_get = esp32_temp_channel_get,
};
static int esp32_temp_init(const struct device *dev)
{
struct esp32_temp_data *data = dev->data;
const struct esp32_temp_config *conf = dev->config;
k_mutex_init(&data->mutex);
temp_sensor_get_config(&data->temp_sensor);
data->temp_sensor.dac_offset = conf->range;
temp_sensor_set_config(data->temp_sensor);
temp_sensor_start();
LOG_DBG("Temperature sensor started. Offset %d, clk_div %d",
data->temp_sensor.dac_offset, data->temp_sensor.clk_div);
return 0;
}
#define ESP32_TEMP_DEFINE(inst) \
static struct esp32_temp_data esp32_temp_dev_data_##inst = { \
.temp_sensor = TSENS_CONFIG_DEFAULT(), \
}; \
\
static const struct esp32_temp_config esp32_temp_dev_config_##inst = { \
.range = (temp_sensor_dac_offset_t) DT_INST_PROP(inst, range), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, esp32_temp_init, NULL, \
&esp32_temp_dev_data_##inst, &esp32_temp_dev_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&esp32_temp_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(ESP32_TEMP_DEFINE)
``` | /content/code_sandbox/drivers/sensor/espressif/esp32_temp/esp32_temp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 660 |
```unknown
# ESP32 Pulse Counter configuration
config PCNT_ESP32
bool "ESP32 Pulse Counter driver"
default y
depends on DT_HAS_ESPRESSIF_ESP32_PCNT_ENABLED
help
This option enables the PCNT driver for ESP32 family of
processors.
config PCNT_ESP32_TRIGGER
bool "Trigger support"
depends on PCNT_ESP32
default y
help
Enable trigger support for the PCNT.
``` | /content/code_sandbox/drivers/sensor/espressif/pcnt_esp32/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 96 |
```c
/*
*
*/
#define DT_DRV_COMPAT ene_kb1200_tach
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/sensor.h>
#include <reg/tacho.h>
/* Device config */
struct tach_kb1200_config {
/* tachometer controller base address */
struct tacho_regs *tacho;
/* number of pulses (holes) per round of tachometer's input (encoder) */
int pulses_per_round;
/* sampling clock timing of tachometer (us) */
int sample_time_us;
const struct pinctrl_dev_config *pcfg;
};
/* Driver data */
struct tach_kb1200_data {
/* Captured counts of tachometer */
uint32_t capture;
};
/* TACH local functions */
static int tach_kb1200_configure(const struct device *dev)
{
const struct tach_kb1200_config *const config = dev->config;
uint8_t sample_us = 0;
/* Configure clock module and its frequency of tachometer */
switch (config->sample_time_us) {
case 2:
sample_us = TACHO_MONITOR_CLK_2US;
break;
case 8:
sample_us = TACHO_MONITOR_CLK_8US;
break;
case 16:
sample_us = TACHO_MONITOR_CLK_16US;
break;
case 64:
sample_us = TACHO_MONITOR_CLK_64US;
break;
default:
return -ENOTSUP;
}
config->tacho->TACHOCFG = (sample_us << 4) | TACHO_FUNCTION_ENABLE;
return 0;
}
/* TACH api functions */
int tach_kb1200_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
ARG_UNUSED(chan);
struct tach_kb1200_data *const data = dev->data;
const struct tach_kb1200_config *const config = dev->config;
/* Check tachometer timeout flag*/
if (config->tacho->TACHOPF & TACHO_TIMEOUT_EVENT) {
/* Clear timeout flags and update flag */
config->tacho->TACHOPF = (TACHO_TIMEOUT_EVENT | TACHO_UPDATE_EVENT);
data->capture = 0;
return 0;
}
/* Check tachometer update flag is set */
if (config->tacho->TACHOPF & TACHO_UPDATE_EVENT) {
/* Clear pending flags */
config->tacho->TACHOPF = TACHO_UPDATE_EVENT;
/* Save captured count */
data->capture = config->tacho->TACHOCV & TACHO_CNT_MAX_VALUE;
}
return 0;
}
static int tach_kb1200_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct tach_kb1200_data *const data = dev->data;
const struct tach_kb1200_config *const config = dev->config;
if (chan != SENSOR_CHAN_RPM) {
return -ENOTSUP;
}
if (data->capture > 0) {
/*
* RPM = (60000000/t) / n
* t: One Pulses length(us) = sample_time_us * cnt
* n: One Round pulses Number
*/
val->val1 = (60000000 / (config->sample_time_us * data->capture)) /
config->pulses_per_round;
} else {
val->val1 = 0U;
}
val->val2 = 0U;
return 0;
}
/* TACH driver registration */
static int tach_kb1200_init(const struct device *dev)
{
int ret;
const struct tach_kb1200_config *config = dev->config;
ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
if (ret != 0) {
return ret;
}
tach_kb1200_configure(dev);
return 0;
}
static const struct sensor_driver_api tach_kb1200_driver_api = {
.sample_fetch = tach_kb1200_sample_fetch,
.channel_get = tach_kb1200_channel_get,
};
#define KB1200_TACH_INIT(inst) \
PINCTRL_DT_INST_DEFINE(inst); \
static const struct tach_kb1200_config tach_cfg_##inst = { \
.tacho = (struct tacho_regs *)DT_INST_REG_ADDR(inst), \
.pulses_per_round = DT_INST_PROP(inst, pulses_per_round), \
.sample_time_us = DT_INST_PROP(inst, sample_time_us), \
.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \
}; \
static struct tach_kb1200_data tach_data_##inst; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, tach_kb1200_init, NULL, &tach_data_##inst, \
&tach_cfg_##inst, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&tach_kb1200_driver_api);
DT_INST_FOREACH_STATUS_OKAY(KB1200_TACH_INIT)
``` | /content/code_sandbox/drivers/sensor/ene_tach_kb1200/tach_ene_kb1200.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,097 |
```unknown
# KB1200 tachometer sensor configuration options
config TACH_ENE_KB1200
bool "ENE KB1200 tachometer sensor"
default y
depends on DT_HAS_ENE_KB1200_TACH_ENABLED
select PINCTRL
help
Enable tachometer sensor for ENE KB1200.
``` | /content/code_sandbox/drivers/sensor/ene_tach_kb1200/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 70 |
```c
/*
*
*/
#define DT_DRV_COMPAT espressif_esp32_pcnt
/* Include esp-idf headers first to avoid redefining BIT() macro */
#include <hal/pcnt_hal.h>
#include <hal/pcnt_ll.h>
#include <hal/pcnt_types.h>
#include <soc.h>
#include <errno.h>
#include <string.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/clock_control.h>
#ifdef CONFIG_PCNT_ESP32_TRIGGER
#include <zephyr/drivers/interrupt_controller/intc_esp32.h>
#endif /* CONFIG_PCNT_ESP32_TRIGGER */
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(pcnt_esp32, CONFIG_SENSOR_LOG_LEVEL);
#define PCNT_INTR_UNIT_0 BIT(0)
#define PCNT_INTR_UNIT_1 BIT(1)
#define PCNT_INTR_UNIT_2 BIT(2)
#define PCNT_INTR_UNIT_3 BIT(3)
#ifdef CONFIG_SOC_SERIES_ESP32
#define PCNT_INTR_UNIT_4 BIT(4)
#define PCNT_INTR_UNIT_5 BIT(5)
#define PCNT_INTR_UNIT_6 BIT(6)
#define PCNT_INTR_UNIT_7 BIT(7)
#endif /* CONFIG_SOC_SERIES_ESP32 */
#ifdef CONFIG_PCNT_ESP32_TRIGGER
#define PCNT_INTR_THRES_1 BIT(2)
#define PCNT_INTR_THRES_0 BIT(3)
#endif /* CONFIG_PCNT_ESP32_TRIGGER */
struct pcnt_esp32_data {
pcnt_hal_context_t hal;
struct k_mutex cmd_mux;
#ifdef CONFIG_PCNT_ESP32_TRIGGER
sensor_trigger_handler_t trigger_handler;
const struct sensor_trigger *trigger;
#endif /* CONFIG_PCNT_ESP32_TRIGGER */
};
struct pcnt_esp32_channel_config {
uint8_t sig_pos_mode;
uint8_t sig_neg_mode;
uint8_t ctrl_h_mode;
uint8_t ctrl_l_mode;
};
struct pcnt_esp32_unit_config {
const uint8_t idx;
int16_t filter;
int16_t count_val_acc;
struct pcnt_esp32_channel_config channel_config[2];
int32_t h_thr;
int32_t l_thr;
int32_t offset;
};
struct pcnt_esp32_config {
const struct pinctrl_dev_config *pincfg;
const struct device *clock_dev;
const clock_control_subsys_t clock_subsys;
const int irq_src;
struct pcnt_esp32_unit_config *unit_config;
const int unit_len;
};
static int pcnt_esp32_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct pcnt_esp32_config *config = dev->config;
struct pcnt_esp32_data *data = (struct pcnt_esp32_data *const)(dev)->data;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_ROTATION) {
return -ENOTSUP;
}
k_mutex_lock(&data->cmd_mux, K_FOREVER);
for (uint8_t i = 0; i < config->unit_len; i++) {
struct pcnt_esp32_unit_config *unit_config = &config->unit_config[i];
unit_config->count_val_acc = pcnt_ll_get_count(data->hal.dev, i);
}
k_mutex_unlock(&data->cmd_mux);
return 0;
}
static int pcnt_esp32_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
int ret = 0;
const struct pcnt_esp32_config *config = dev->config;
struct pcnt_esp32_data *data = (struct pcnt_esp32_data *const)(dev)->data;
k_mutex_lock(&data->cmd_mux, K_FOREVER);
if (chan == SENSOR_CHAN_ROTATION) {
val->val1 = config->unit_config[0].count_val_acc + config->unit_config[0].offset;
val->val2 = 0;
} else {
ret = -ENOTSUP;
}
k_mutex_unlock(&data->cmd_mux);
return ret;
}
static int pcnt_esp32_configure_pinctrl(const struct device *dev)
{
int ret;
struct pcnt_esp32_config *config = (struct pcnt_esp32_config *)dev->config;
return pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT);
}
int pcnt_esp32_init(const struct device *dev)
{
int ret;
const struct pcnt_esp32_config *config = dev->config;
struct pcnt_esp32_data *data = (struct pcnt_esp32_data *const)(dev)->data;
ret = clock_control_on(config->clock_dev, config->clock_subsys);
if (ret < 0) {
LOG_ERR("Could not initialize clock (%d)", ret);
return ret;
}
ret = pcnt_esp32_configure_pinctrl(dev);
if (ret < 0) {
LOG_ERR("PWM pinctrl setup failed (%d)", ret);
return ret;
}
pcnt_hal_init(&data->hal, 0);
for (uint8_t i = 0; i < config->unit_len; i++) {
struct pcnt_esp32_unit_config *unit_config = &config->unit_config[i];
unit_config->h_thr = 0;
unit_config->l_thr = 0;
unit_config->offset = 0;
pcnt_ll_enable_thres_event(data->hal.dev, i, 0, false);
pcnt_ll_enable_thres_event(data->hal.dev, i, 1, false);
pcnt_ll_enable_low_limit_event(data->hal.dev, i, false);
pcnt_ll_enable_high_limit_event(data->hal.dev, i, false);
pcnt_ll_enable_zero_cross_event(data->hal.dev, i, false);
pcnt_ll_set_edge_action(data->hal.dev, i, 0,
unit_config->channel_config[0].sig_pos_mode,
unit_config->channel_config[0].sig_neg_mode);
pcnt_ll_set_edge_action(data->hal.dev, i, 1,
unit_config->channel_config[1].sig_pos_mode,
unit_config->channel_config[1].sig_neg_mode);
pcnt_ll_set_level_action(data->hal.dev, i, 0,
unit_config->channel_config[0].ctrl_h_mode,
unit_config->channel_config[0].ctrl_l_mode);
pcnt_ll_set_level_action(data->hal.dev, i, 1,
unit_config->channel_config[1].ctrl_h_mode,
unit_config->channel_config[1].ctrl_l_mode);
pcnt_ll_clear_count(data->hal.dev, i);
pcnt_ll_set_glitch_filter_thres(data->hal.dev, i, unit_config->filter);
pcnt_ll_enable_glitch_filter(data->hal.dev, i, (bool)unit_config->filter);
pcnt_ll_start_count(data->hal.dev, i);
}
return 0;
}
static int pcnt_esp32_attr_set_thresh(const struct device *dev, enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct pcnt_esp32_config *config = dev->config;
struct pcnt_esp32_data *data = (struct pcnt_esp32_data *const)(dev)->data;
for (uint8_t i = 0; i < config->unit_len; i++) {
struct pcnt_esp32_unit_config *unit_config = &config->unit_config[i];
switch (attr) {
case SENSOR_ATTR_LOWER_THRESH:
unit_config->l_thr = val->val1;
pcnt_ll_set_thres_value(data->hal.dev, i, 0, unit_config->l_thr);
pcnt_ll_enable_thres_event(data->hal.dev, i, 0, true);
break;
case SENSOR_ATTR_UPPER_THRESH:
unit_config->h_thr = val->val1;
pcnt_ll_set_thres_value(data->hal.dev, i, 1, unit_config->h_thr);
pcnt_ll_enable_thres_event(data->hal.dev, i, 1, true);
break;
default:
return -ENOTSUP;
}
pcnt_ll_stop_count(data->hal.dev, i);
pcnt_ll_clear_count(data->hal.dev, i);
pcnt_ll_start_count(data->hal.dev, i);
}
return 0;
}
static int pcnt_esp32_attr_set_offset(const struct device *dev, const struct sensor_value *val)
{
const struct pcnt_esp32_config *config = dev->config;
for (uint8_t i = 0; i < config->unit_len; i++) {
struct pcnt_esp32_unit_config *unit_config = &config->unit_config[i];
unit_config->offset = val->val1;
}
return 0;
}
static int pcnt_esp32_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_ROTATION) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_LOWER_THRESH:
case SENSOR_ATTR_UPPER_THRESH:
return pcnt_esp32_attr_set_thresh(dev, attr, val);
case SENSOR_ATTR_OFFSET:
return pcnt_esp32_attr_set_offset(dev, val);
default:
return -ENOTSUP;
}
return 0;
}
static int pcnt_esp32_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct pcnt_esp32_config *config = dev->config;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_ROTATION) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_LOWER_THRESH:
val->val1 = config->unit_config[0].l_thr;
break;
case SENSOR_ATTR_UPPER_THRESH:
val->val1 = config->unit_config[0].h_thr;
break;
case SENSOR_ATTR_OFFSET:
val->val1 = config->unit_config[0].offset;
break;
default:
return -ENOTSUP;
}
val->val2 = 0;
return 0;
}
#ifdef CONFIG_PCNT_ESP32_TRIGGER
static void IRAM_ATTR pcnt_esp32_isr(const struct device *dev)
{
struct pcnt_esp32_data *data = (struct pcnt_esp32_data *const)(dev)->data;
uint32_t pcnt_intr_status;
uint32_t pcnt_unit_status;
pcnt_intr_status = pcnt_ll_get_intr_status(data->hal.dev);
pcnt_ll_clear_intr_status(data->hal.dev, pcnt_intr_status);
if (pcnt_intr_status & PCNT_INTR_UNIT_0) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 0);
} else if (pcnt_intr_status & PCNT_INTR_UNIT_1) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 1);
} else if (pcnt_intr_status & PCNT_INTR_UNIT_2) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 2);
} else if (pcnt_intr_status & PCNT_INTR_UNIT_3) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 3);
#ifdef CONFIG_SOC_SERIES_ESP32
} else if (pcnt_intr_status & PCNT_INTR_UNIT_4) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 4);
} else if (pcnt_intr_status & PCNT_INTR_UNIT_5) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 5);
} else if (pcnt_intr_status & PCNT_INTR_UNIT_6) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 6);
} else if (pcnt_intr_status & PCNT_INTR_UNIT_7) {
pcnt_unit_status = pcnt_ll_get_unit_status(data->hal.dev, 7);
#endif /* CONFIG_SOC_SERIES_ESP32 */
} else {
return;
}
if (!(pcnt_unit_status & PCNT_INTR_THRES_0) && !(pcnt_unit_status & PCNT_INTR_THRES_1)) {
return;
}
if (!data->trigger_handler) {
return;
}
data->trigger_handler(dev, data->trigger);
}
static int pcnt_esp32_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
int ret;
const struct pcnt_esp32_config *config = dev->config;
struct pcnt_esp32_data *data = (struct pcnt_esp32_data *const)(dev)->data;
if (trig->type != SENSOR_TRIG_THRESHOLD) {
return -ENOTSUP;
}
if ((trig->chan != SENSOR_CHAN_ALL) && (trig->chan != SENSOR_CHAN_ROTATION)) {
return -ENOTSUP;
}
if (!handler) {
return -EINVAL;
}
data->trigger_handler = handler;
data->trigger = trig;
ret = esp_intr_alloc(config->irq_src, 0, (intr_handler_t)pcnt_esp32_isr, (void *)dev, NULL);
if (ret != 0) {
LOG_ERR("pcnt isr registration failed (%d)", ret);
return ret;
}
pcnt_ll_enable_intr(data->hal.dev, 1, true);
return 0;
}
#endif /* CONFIG_PCNT_ESP32_TRIGGER */
static const struct sensor_driver_api pcnt_esp32_api = {
.sample_fetch = pcnt_esp32_sample_fetch,
.channel_get = pcnt_esp32_channel_get,
.attr_set = pcnt_esp32_attr_set,
.attr_get = pcnt_esp32_attr_get,
#ifdef CONFIG_PCNT_ESP32_TRIGGER
.trigger_set = pcnt_esp32_trigger_set,
#endif /* CONFIG_PCNT_ESP32_TRIGGER */
};
PINCTRL_DT_INST_DEFINE(0);
#define UNIT_CONFIG(node_id) \
{ \
.idx = DT_REG_ADDR(node_id), \
.filter = DT_PROP_OR(node_id, filter, 0) > 1024 ? 1024 \
: DT_PROP_OR(node_id, filter, 0), \
.channel_config[0] = \
{ \
.sig_pos_mode = DT_PROP_OR(DT_CHILD(node_id, channela_0), \
sig_pos_mode, 0), \
.sig_neg_mode = DT_PROP_OR(DT_CHILD(node_id, channela_0), \
sig_neg_mode, 0), \
.ctrl_l_mode = \
DT_PROP_OR(DT_CHILD(node_id, channela_0), ctrl_l_mode, 0), \
.ctrl_h_mode = \
DT_PROP_OR(DT_CHILD(node_id, channela_0), ctrl_h_mode, 0), \
}, \
.channel_config[1] = \
{ \
.sig_pos_mode = DT_PROP_OR(DT_CHILD(node_id, channelb_0), \
sig_pos_mode, 0), \
.sig_neg_mode = DT_PROP_OR(DT_CHILD(node_id, channelb_0), \
sig_neg_mode, 0), \
.ctrl_l_mode = \
DT_PROP_OR(DT_CHILD(node_id, channelb_0), ctrl_l_mode, 0), \
.ctrl_h_mode = \
DT_PROP_OR(DT_CHILD(node_id, channelb_0), ctrl_h_mode, 0), \
}, \
},
static struct pcnt_esp32_unit_config unit_config[] = {DT_INST_FOREACH_CHILD(0, UNIT_CONFIG)};
static struct pcnt_esp32_config pcnt_esp32_config = {
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(0),
.clock_dev = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR(0)),
.clock_subsys = (clock_control_subsys_t)DT_INST_CLOCKS_CELL(0, offset),
.irq_src = DT_INST_IRQN(0),
.unit_config = unit_config,
.unit_len = ARRAY_SIZE(unit_config),
};
static struct pcnt_esp32_data pcnt_esp32_data = {
.hal = {
.dev = (pcnt_dev_t *)DT_INST_REG_ADDR(0),
},
.cmd_mux = Z_MUTEX_INITIALIZER(pcnt_esp32_data.cmd_mux),
#ifdef CONFIG_PCNT_ESP32_TRIGGER
.trigger_handler = NULL,
#endif /* CONFIG_PCNT_ESP32_TRIGGER */
};
SENSOR_DEVICE_DT_INST_DEFINE(0, &pcnt_esp32_init, NULL,
&pcnt_esp32_data,
&pcnt_esp32_config,
POST_KERNEL,
CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
&pcnt_esp32_api);
``` | /content/code_sandbox/drivers/sensor/espressif/pcnt_esp32/pcnt_esp32.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,675 |
```unknown
# FCX-MLDx5 O2 sensor configuration options
config FCX_MLDX5
bool "FCX-MLDx5 O2 Sensor"
default y
depends on DT_HAS_AP_FCX_MLDX5_ENABLED
depends on UART_INTERRUPT_DRIVEN
select UART
help
Enable driver for FCX-MLD25 or FCX-MLD95 O2 Sensor.
``` | /content/code_sandbox/drivers/sensor/fcx_mldx5/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 87 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/ti/bq274xx/Kconfig"
source "drivers/sensor/ti/fdc2x1x/Kconfig"
source "drivers/sensor/ti/ina219/Kconfig"
source "drivers/sensor/ti/ina226/Kconfig"
source "drivers/sensor/ti/ina23x/Kconfig"
source "drivers/sensor/ti/ina3221/Kconfig"
source "drivers/sensor/ti/lm95234/Kconfig"
source "drivers/sensor/ti/opt3001/Kconfig"
source "drivers/sensor/ti/ti_hdc/Kconfig"
source "drivers/sensor/ti/ti_hdc20xx/Kconfig"
source "drivers/sensor/ti/tmag5170/Kconfig"
source "drivers/sensor/ti/tmag5273/Kconfig"
source "drivers/sensor/ti/tmp007/Kconfig"
source "drivers/sensor/ti/tmp108/Kconfig"
source "drivers/sensor/ti/tmp112/Kconfig"
source "drivers/sensor/ti/tmp114/Kconfig"
source "drivers/sensor/ti/tmp116/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/ti/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 251 |
```c
/*
*
*
* Datasheet:
* path_to_url
*
*/
#define DT_DRV_COMPAT ap_fcx_mldx5
#include <ctype.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/fcx_mldx5.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/util.h>
LOG_MODULE_REGISTER(fcx_mldx5_sensor, CONFIG_SENSOR_LOG_LEVEL);
#define FCX_MLDX5_STX 0x2
#define FCX_MLDX5_ETX 0x3
#define FCX_MLDX5_STX_LEN 1
#define FCX_MLDX5_CMD_LEN 2
/* Data length depends on command type thus defined in array */
#define FCX_MLDX5_CHECKSUM_LEN 2
#define FCX_MLDX5_ETX_LEN 1
#define FCX_MLDX5_HEADER_LEN \
(FCX_MLDX5_STX_LEN + FCX_MLDX5_CMD_LEN + FCX_MLDX5_CHECKSUM_LEN + FCX_MLDX5_ETX_LEN)
#define FCX_MLDX5_STX_INDEX 0
#define FCX_MLDX5_CMD_INDEX (FCX_MLDX5_STX_INDEX + FCX_MLDX5_STX_LEN)
#define FCX_MLDX5_DATA_INDEX (FCX_MLDX5_CMD_INDEX + FCX_MLDX5_CMD_LEN)
#define FCX_MLDX5_CHECKSUM_INDEX(frame_len) ((frame_len)-FCX_MLDX5_CHECKSUM_LEN - FCX_MLDX5_ETX_LEN)
#define FCX_MLDX5_ETX_INDEX(frame_len) ((frame_len)-FCX_MLDX5_ETX_LEN)
#define FCX_MLDX5_MAX_FRAME_LEN 11
#define FCX_MLDX5_MAX_RESPONSE_DELAY 200 /* Not specified in datasheet */
#define FCX_MLDX5_MAX_HEAT_UP_TIME 180000
struct fcx_mldx5_data {
struct k_mutex uart_mutex;
struct k_sem uart_rx_sem;
uint32_t o2_ppm;
uint8_t status;
uint8_t frame[FCX_MLDX5_MAX_FRAME_LEN];
uint8_t frame_len;
};
struct fcx_mldx5_cfg {
const struct device *uart_dev;
uart_irq_callback_user_data_t cb;
};
enum fcx_mldx5_cmd {
FCX_MLDX5_CMD_READ_STATUS,
FCX_MLDX5_CMD_READ_O2_VALUE,
FCX_MLDX5_CMD_SWITCH_SENSOR_ON_OFF,
FCX_MLDX5_CMD_RESET,
FCX_MLDX5_CMD_ERROR,
};
enum fcx_mldx5_errors {
FCX_MLDX5_ERROR_CHECKSUM,
FCX_MLDX5_ERROR_UNKNOWN_COMMAND,
FCX_MLDX5_ERROR_PARAMETER,
FCX_MLDX5_ERROR_EEPROM,
};
static const char *const fcx_mldx5_cmds[] = {
[FCX_MLDX5_CMD_READ_STATUS] = "01",
[FCX_MLDX5_CMD_READ_O2_VALUE] = "02",
[FCX_MLDX5_CMD_SWITCH_SENSOR_ON_OFF] = "04",
[FCX_MLDX5_CMD_RESET] = "11",
[FCX_MLDX5_CMD_ERROR] = "EE",
};
static const uint8_t fcx_mldx5_cmds_data_len[] = {
[FCX_MLDX5_CMD_READ_STATUS] = 2,
[FCX_MLDX5_CMD_READ_O2_VALUE] = 5,
[FCX_MLDX5_CMD_SWITCH_SENSOR_ON_OFF] = 1,
[FCX_MLDX5_CMD_RESET] = 0,
[FCX_MLDX5_CMD_ERROR] = 2,
};
static const char *const fcx_mldx5_errors[] = {
[FCX_MLDX5_ERROR_CHECKSUM] = "checksum",
[FCX_MLDX5_ERROR_UNKNOWN_COMMAND] = "command",
[FCX_MLDX5_ERROR_PARAMETER] = "parameter",
[FCX_MLDX5_ERROR_EEPROM] = "eeprom",
};
static void fcx_mldx5_uart_flush(const struct device *uart_dev)
{
uint8_t tmp;
while (uart_fifo_read(uart_dev, &tmp, 1) > 0) {
continue;
}
}
static uint8_t fcx_mldx5_calculate_checksum(const uint8_t *buf, size_t len)
{
uint8_t checksum;
size_t i;
if (buf == NULL || len == 0) {
return 0;
}
checksum = buf[0];
for (i = 1; i < len; ++i) {
checksum ^= buf[i];
}
return checksum;
}
static int fcx_mldx5_frame_check_error(const struct fcx_mldx5_data *data, const char *command_sent)
{
const uint8_t len = FCX_MLDX5_HEADER_LEN + fcx_mldx5_cmds_data_len[FCX_MLDX5_CMD_ERROR];
const char *command_error = fcx_mldx5_cmds[FCX_MLDX5_CMD_ERROR];
const char *command_received = &data->frame[FCX_MLDX5_CMD_INDEX];
const char *data_received = &data->frame[FCX_MLDX5_DATA_INDEX];
uint8_t error;
if (data->frame_len != len ||
strncmp(command_error, command_received, FCX_MLDX5_CMD_LEN) != 0) {
return 0;
}
if (data_received[0] != 'E' || char2hex(data_received[1], &error) != 0 ||
error >= ARRAY_SIZE(fcx_mldx5_errors)) {
LOG_ERR("Could not parse error value %.*s",
fcx_mldx5_cmds_data_len[FCX_MLDX5_CMD_ERROR], data_received);
} else {
LOG_ERR("Command '%s' received error '%s'", command_sent, fcx_mldx5_errors[error]);
}
return -EIO;
}
static int fcx_mldx5_frame_verify(const struct fcx_mldx5_data *data, enum fcx_mldx5_cmd cmd)
{
const uint8_t frame_len = FCX_MLDX5_HEADER_LEN + fcx_mldx5_cmds_data_len[cmd];
const char *command = fcx_mldx5_cmds[cmd];
const char *command_received = &data->frame[FCX_MLDX5_CMD_INDEX];
uint8_t checksum;
uint8_t checksum_received;
if (fcx_mldx5_frame_check_error(data, command) != 0) {
return -EIO;
} else if (data->frame_len != frame_len) {
LOG_ERR("Expected command %s frame length %u not %u", command, frame_len,
data->frame_len);
return -EIO;
} else if (data->frame[FCX_MLDX5_STX_INDEX] != FCX_MLDX5_STX) {
LOG_ERR("No STX");
return -EIO;
} else if (strncmp(command, command_received, FCX_MLDX5_CMD_LEN) != 0) {
LOG_ERR("Expected command %s not %.*s", command, FCX_MLDX5_CMD_LEN,
command_received);
return -EIO;
} else if (data->frame[FCX_MLDX5_ETX_INDEX(data->frame_len)] != FCX_MLDX5_ETX) {
LOG_ERR("No ETX");
return -EIO;
}
/* cmd and data bytes are used to calculate checksum */
checksum = fcx_mldx5_calculate_checksum(command_received,
FCX_MLDX5_CMD_LEN + fcx_mldx5_cmds_data_len[cmd]);
checksum_received =
strtol(&data->frame[FCX_MLDX5_CHECKSUM_INDEX(data->frame_len)], NULL, 16);
if (checksum != checksum_received) {
LOG_ERR("Expected checksum 0x%02x not 0x%02x", checksum, checksum_received);
return -EIO;
}
return 0;
}
static void fcx_mldx5_uart_isr(const struct device *uart_dev, void *user_data)
{
const struct device *dev = user_data;
struct fcx_mldx5_data *data = dev->data;
int rc, read_len;
if (!device_is_ready(uart_dev)) {
LOG_DBG("UART device is not ready");
return;
}
if (!uart_irq_update(uart_dev)) {
LOG_DBG("Unable to process interrupts");
return;
}
if (!uart_irq_rx_ready(uart_dev)) {
LOG_DBG("No RX data");
return;
}
read_len = FCX_MLDX5_MAX_FRAME_LEN - data->frame_len;
rc = read_len > 0 ? uart_fifo_read(uart_dev, &data->frame[data->frame_len], read_len)
: -ENOMEM;
if (rc < 0) {
LOG_ERR("UART read failed: %d", rc < 0 ? rc : -ERANGE);
fcx_mldx5_uart_flush(uart_dev);
LOG_HEXDUMP_ERR(data->frame, data->frame_len, "Discarding");
} else {
data->frame_len += rc;
if (data->frame[FCX_MLDX5_ETX_INDEX(data->frame_len)] != FCX_MLDX5_ETX) {
return;
}
LOG_HEXDUMP_DBG(data->frame, data->frame_len, "Frame received");
}
k_sem_give(&data->uart_rx_sem);
}
static void fcx_mldx5_uart_send(const struct device *dev, enum fcx_mldx5_cmd cmd,
const char *cmd_data)
{
const struct fcx_mldx5_cfg *cfg = dev->config;
size_t cmd_data_len = cmd_data != NULL ? strlen(cmd_data) : 0;
size_t frame_len = FCX_MLDX5_HEADER_LEN + cmd_data_len;
char buf[FCX_MLDX5_MAX_FRAME_LEN];
uint8_t checksum;
size_t i;
buf[FCX_MLDX5_STX_INDEX] = FCX_MLDX5_STX;
memcpy(&buf[FCX_MLDX5_CMD_INDEX], fcx_mldx5_cmds[cmd], FCX_MLDX5_CMD_LEN);
if (cmd_data_len != 0) {
memcpy(&buf[FCX_MLDX5_DATA_INDEX], cmd_data, strlen(cmd_data));
}
checksum = fcx_mldx5_calculate_checksum(&buf[FCX_MLDX5_CMD_INDEX],
FCX_MLDX5_CMD_LEN + cmd_data_len);
bin2hex(&checksum, 1, &buf[FCX_MLDX5_CHECKSUM_INDEX(frame_len)],
FCX_MLDX5_MAX_FRAME_LEN - FCX_MLDX5_CHECKSUM_INDEX(frame_len));
buf[FCX_MLDX5_ETX_INDEX(frame_len)] = FCX_MLDX5_ETX;
for (i = 0; i < frame_len; ++i) {
uart_poll_out(cfg->uart_dev, buf[i]);
}
LOG_HEXDUMP_DBG(buf, frame_len, "Frame sent");
}
static int fcx_mldx5_await_receive(const struct device *dev)
{
int rc;
const struct fcx_mldx5_cfg *cfg = dev->config;
struct fcx_mldx5_data *data = dev->data;
uart_irq_rx_enable(cfg->uart_dev);
rc = k_sem_take(&data->uart_rx_sem, K_MSEC(FCX_MLDX5_MAX_RESPONSE_DELAY));
/* Reset semaphore if sensor did not respond within maximum specified response time
*/
if (rc == -EAGAIN) {
k_sem_reset(&data->uart_rx_sem);
}
uart_irq_rx_disable(cfg->uart_dev);
return rc;
}
static int fcx_mldx5_read_status_value(struct fcx_mldx5_data *data, uint8_t data_len)
{
char *cmd_data_received = &data->frame[FCX_MLDX5_DATA_INDEX];
uint8_t value;
if (cmd_data_received[0] != '0' || char2hex(cmd_data_received[1], &value)) {
LOG_ERR("Could not parse status value %.*s", data_len, cmd_data_received);
return -EIO;
}
switch (value) {
case FCX_MLDX5_STATUS_STANDBY:
break;
case FCX_MLDX5_STATUS_RAMP_UP:
break;
case FCX_MLDX5_STATUS_RUN:
break;
case FCX_MLDX5_STATUS_ERROR:
break;
default:
LOG_ERR("Status value %u invalid", value);
return -EIO;
}
data->status = value;
return 0;
}
static int fcx_mldx5_read_o2_value(struct fcx_mldx5_data *data)
{
const char *o2_data = &data->frame[FCX_MLDX5_DATA_INDEX];
uint8_t o2_data_len = fcx_mldx5_cmds_data_len[FCX_MLDX5_CMD_READ_O2_VALUE];
uint32_t value = 0;
size_t i;
for (i = 0; i < o2_data_len; ++i) {
if (i == 2) {
if (o2_data[i] != '.') {
goto invalid_data;
}
} else if (isdigit((int)o2_data[i]) == 0) {
goto invalid_data;
} else {
value = value * 10 + (o2_data[i] - '0');
}
}
data->o2_ppm = value * 100;
return 0;
invalid_data:
LOG_HEXDUMP_ERR(o2_data, o2_data_len, "Invalid O2 data");
return -EIO;
}
static int fcx_mldx5_buffer_process(struct fcx_mldx5_data *data, enum fcx_mldx5_cmd cmd,
const char *cmd_data)
{
if (fcx_mldx5_frame_verify(data, cmd) != 0) {
return -EIO;
}
switch (cmd) {
case FCX_MLDX5_CMD_READ_STATUS:
return fcx_mldx5_read_status_value(data, fcx_mldx5_cmds_data_len[cmd]);
case FCX_MLDX5_CMD_READ_O2_VALUE:
return fcx_mldx5_read_o2_value(data);
case FCX_MLDX5_CMD_SWITCH_SENSOR_ON_OFF:
return cmd_data != NULL && data->frame[FCX_MLDX5_DATA_INDEX] == cmd_data[0];
case FCX_MLDX5_CMD_RESET:
return 0;
default:
LOG_ERR("Unknown command 0x%02x", cmd);
return -EIO;
}
}
static int fcx_mldx5_uart_transceive(const struct device *dev, enum fcx_mldx5_cmd cmd,
const char *cmd_data)
{
struct fcx_mldx5_data *data = dev->data;
int rc;
k_mutex_lock(&data->uart_mutex, K_FOREVER);
data->frame_len = 0;
fcx_mldx5_uart_send(dev, cmd, cmd_data);
rc = fcx_mldx5_await_receive(dev);
if (rc != 0) {
LOG_ERR("%s did not receive a response: %d", fcx_mldx5_cmds[cmd], rc);
} else {
rc = fcx_mldx5_buffer_process(data, cmd, cmd_data);
}
k_mutex_unlock(&data->uart_mutex);
return rc;
}
static int fcx_mldx5_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
struct fcx_mldx5_data *data = dev->data;
int rc;
if (chan != SENSOR_CHAN_O2) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_FCX_MLDX5_STATUS:
rc = fcx_mldx5_uart_transceive(dev, FCX_MLDX5_CMD_READ_STATUS, NULL);
val->val1 = data->status;
return rc;
default:
return -ENOTSUP;
}
}
static int fcx_mldx5_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
if (chan != SENSOR_CHAN_O2 && chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
return fcx_mldx5_uart_transceive(dev, FCX_MLDX5_CMD_READ_O2_VALUE, NULL);
}
static int fcx_mldx5_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct fcx_mldx5_data *data = dev->data;
if (chan != SENSOR_CHAN_O2) {
return -ENOTSUP;
}
val->val1 = data->o2_ppm;
val->val2 = 0;
return 0;
}
static const struct sensor_driver_api fcx_mldx5_api_funcs = {
.attr_get = fcx_mldx5_attr_get,
.sample_fetch = fcx_mldx5_sample_fetch,
.channel_get = fcx_mldx5_channel_get,
};
#ifdef CONFIG_PM_DEVICE
static int pm_action(const struct device *dev, enum pm_device_action action)
{
switch (action) {
case PM_DEVICE_ACTION_RESUME:
return fcx_mldx5_uart_transceive(dev, FCX_MLDX5_CMD_SWITCH_SENSOR_ON_OFF, "1");
case PM_DEVICE_ACTION_SUSPEND:
/* Standby with 20 % heating output */
return fcx_mldx5_uart_transceive(dev, FCX_MLDX5_CMD_SWITCH_SENSOR_ON_OFF, "0");
default:
return -ENOTSUP;
}
}
#endif
static int fcx_mldx5_init(const struct device *dev)
{
int rc;
const struct fcx_mldx5_cfg *cfg = dev->config;
struct fcx_mldx5_data *data = dev->data;
LOG_DBG("Initializing %s", dev->name);
if (!device_is_ready(cfg->uart_dev)) {
return -ENODEV;
}
k_mutex_init(&data->uart_mutex);
k_sem_init(&data->uart_rx_sem, 0, 1);
uart_irq_rx_disable(cfg->uart_dev);
uart_irq_tx_disable(cfg->uart_dev);
rc = uart_irq_callback_user_data_set(cfg->uart_dev, cfg->cb, (void *)dev);
if (rc != 0) {
LOG_ERR("UART IRQ setup failed: %d", rc);
return rc;
}
/* Retry in case of garbled tx due to GPIO setup, crash during unfinished send or sensor
* start up time
*/
if (!WAIT_FOR(fcx_mldx5_uart_transceive(dev, FCX_MLDX5_CMD_READ_STATUS, NULL) == 0,
1000 * USEC_PER_MSEC, k_msleep(10))) {
LOG_ERR("Read status failed");
return -EIO;
}
LOG_INF("%s status 0x%x", dev->name, data->status);
return 0;
}
#define FCX_MLDX5_INIT(n) \
\
static struct fcx_mldx5_data fcx_mldx5_data_##n = { \
.status = FCX_MLDX5_STATUS_UNKNOWN, \
}; \
\
static const struct fcx_mldx5_cfg fcx_mldx5_cfg_##n = { \
.uart_dev = DEVICE_DT_GET(DT_INST_BUS(n)), \
.cb = fcx_mldx5_uart_isr, \
}; \
\
PM_DEVICE_DT_INST_DEFINE(n, pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, fcx_mldx5_init, PM_DEVICE_DT_INST_GET(n), \
&fcx_mldx5_data_##n, &fcx_mldx5_cfg_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &fcx_mldx5_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(FCX_MLDX5_INIT)
``` | /content/code_sandbox/drivers/sensor/fcx_mldx5/fcx_mldx5.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,457 |
```unknown
# LM95234 temperature sensor config
config LM95234
bool "LM95234 Temperature Sensor"
default y
depends on DT_HAS_NATIONAL_LM95234_ENABLED
select I2C
help
Enable the driver for the LM95234 Quad Remote Diode and Local
Temperature Sensor with SMBus Interface.
``` | /content/code_sandbox/drivers/sensor/ti/lm95234/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 69 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TMAG5170_TMAG5170_H_
#define ZEPHYR_DRIVERS_SENSOR_TMAG5170_TMAG5170_H_
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/sys/util.h>
struct tmag5170_dev_config {
struct spi_dt_spec bus;
uint8_t magnetic_channels;
uint8_t x_range;
uint8_t y_range;
uint8_t z_range;
uint8_t oversampling;
bool tempeature_measurement;
uint8_t magnet_type;
uint8_t angle_measurement;
bool disable_temperature_oversampling;
uint8_t sleep_time;
uint8_t operating_mode;
#if defined(CONFIG_TMAG5170_TRIGGER)
struct gpio_dt_spec int_gpio;
#endif
};
struct tmag5170_data {
uint8_t chip_revision;
uint16_t x;
uint16_t y;
uint16_t z;
uint16_t temperature;
uint16_t angle;
#if defined(CONFIG_TMAG5170_TRIGGER)
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy;
const struct sensor_trigger *trigger_drdy;
const struct device *dev;
#endif
#if defined(CONFIG_TMAG5170_TRIGGER_OWN_THREAD)
struct k_sem sem;
struct k_thread thread;
K_KERNEL_STACK_MEMBER(thread_stack,
CONFIG_TMAG5170_THREAD_STACK_SIZE);
#elif defined(CONFIG_TMAG5170_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
};
#if defined(CONFIG_TMAG5170_TRIGGER)
int tmag5170_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int tmag5170_trigger_init(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_TMAG5170_TMAG5170_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/tmag5170/tmag5170.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 388 |
```c
/*
*
*/
#define DT_DRV_COMPAT national_lm95234
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/lm95234.h>
#include <zephyr/pm/device.h>
#include <zephyr/pm/device_runtime.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(LM95234, CONFIG_SENSOR_LOG_LEVEL);
#define LM95234_REG_LOCAL_TEMP_SIGNED_MSB 0x10
#define LM95234_REG_LOCAL_TEMP_SIGNED_LSB 0x20
#define LM95234_REG_REMOTE_TEMP_1_SIGNED_MSB 0x11
#define LM95234_REG_REMOTE_TEMP_1_SIGNED_LSB 0x21
#define LM95234_REG_REMOTE_TEMP_2_SIGNED_MSB 0x12
#define LM95234_REG_REMOTE_TEMP_2_SIGNED_LSB 0x22
#define LM95234_REG_REMOTE_TEMP_3_SIGNED_MSB 0x13
#define LM95234_REG_REMOTE_TEMP_3_SIGNED_LSB 0x23
#define LM95234_REG_REMOTE_TEMP_4_SIGNED_MSB 0x14
#define LM95234_REG_REMOTE_TEMP_4_SIGNED_LSB 0x24
#define LM95234_REG_REMOTE_TEMP_1_UNSIGNED_MSB 0x19
#define LM95234_REG_REMOTE_TEMP_1_UNSIGNED_LSB 0x29
#define LM95234_REG_REMOTE_TEMP_2_UNSIGNED_MSB 0x1a
#define LM95234_REG_REMOTE_TEMP_2_UNSIGNED_LSB 0x2a
#define LM95234_REG_REMOTE_TEMP_3_UNSIGNED_MSB 0x1b
#define LM95234_REG_REMOTE_TEMP_3_UNSIGNED_LSB 0x2b
#define LM95234_REG_REMOTE_TEMP_4_UNSIGNED_MSB 0x1c
#define LM95234_REG_REMOTE_TEMP_4_UNSIGNED_LSB 0x2c
#define LM95234_REG_DIODE_MODEL_SELECT 0x30
#define LM95234_REG_REMOTE_1_OFFSET 0x31
#define LM95234_REG_REMOTE_2_OFFSET 0x32
#define LM95234_REG_REMOTE_3_OFFSET 0x33
#define LM95234_REG_REMOTE_4_OFFSET 0x34
#define LM95234_REG_CONFIG 0x03
#define LM95234_REG_CONV_RATE 0x04
#define LM95234_REG_CHANNEL_CONV_ENABLE 0x05
#define LM95234_REG_FILTER_SETTING 0x06
#define LM95234_REG_ONESHOT 0x0f
#define LM95234_REG_COMMON_STATUS 0x02
#define LM95234_REG_STATUS_1 0x07
#define LM95234_REG_STATUS_2 0x08
#define LM95234_REG_STATUS_3 0x09
#define LM95234_REG_STATUS_4 0x0a
#define LM95234_REG_DIODE_MODEL_STATUS 0x38
#define LM95234_REG_TCRIT1_MASK 0x0c
#define LM95234_REG_TCRIT2_MASK 0x0d
#define LM95234_REG_TCRIT3_MASK 0x0e
#define LM95234_REG_LOCAL_TCRIT_LIMIT 0x40
#define LM95234_REG_REMOTE1_TCRIT1_LIMIT 0x41
#define LM95234_REG_REMOTE2_TCRIT1_LIMIT 0x42
#define LM95234_REG_REMOTE3_TCRIT_LIMIT 0x43
#define LM95234_REG_REMOTE4_TCRIT_LIMIT 0x44
#define LM95234_REG_REMOTE1_TCRIT23_LIMIT 0x49
#define LM95234_REG_REMOTE2_TCRIT23_LIMIT 0x4a
#define LM95234_REG_COMMON_TCRIT_HYSTERESIS 0x5a
#define LM95234_REG_MANUF_ID 0xfe
#define LM95234_REG_REV_ID 0xff
#define LM95234_MAN_ID 0x01
#define LM95234_CHIP_ID 0x79
#define LM95234_CONFIG_STANDBY BIT(6)
struct lm95234_data {
/** Temperatures in raw format read from sensor */
int32_t local;
int32_t remote[4];
};
struct lm95234_config {
struct i2c_dt_spec i2c;
};
static inline int lm95234_fetch_temp(const struct lm95234_config *cfg, struct lm95234_data *data,
enum sensor_channel chan, int32_t *output)
{
int ret;
uint8_t val;
int32_t result = 0;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
uint16_t temp;
int offset = (chan - SENSOR_CHAN_LM95234_REMOTE_TEMP_1);
ret = i2c_reg_read_byte_dt(&cfg->i2c,
LM95234_REG_REMOTE_TEMP_1_UNSIGNED_MSB + offset, &val);
if (ret) {
return ret;
}
temp = val << 8;
ret = i2c_reg_read_byte_dt(&cfg->i2c,
LM95234_REG_REMOTE_TEMP_1_UNSIGNED_LSB + offset, &val);
if (ret) {
return ret;
}
temp |= val;
result = temp;
}
/* Read signed temperature if unsigned temperature is 0, or for local sensor */
if (chan == SENSOR_CHAN_AMBIENT_TEMP || result == 0) {
int offset = chan == SENSOR_CHAN_AMBIENT_TEMP ? 0 :
(chan - SENSOR_CHAN_LM95234_REMOTE_TEMP_1 + 1);
int16_t temp;
ret = i2c_reg_read_byte_dt(&cfg->i2c,
LM95234_REG_LOCAL_TEMP_SIGNED_MSB + offset, &val);
if (ret) {
return ret;
}
temp = val << 8;
ret = i2c_reg_read_byte_dt(&cfg->i2c,
LM95234_REG_LOCAL_TEMP_SIGNED_LSB + offset, &val);
if (ret) {
return ret;
}
temp |= val;
result = temp;
}
*output = result;
return 0;
}
static int lm95234_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct lm95234_data *data = dev->data;
const struct lm95234_config *cfg = dev->config;
enum pm_device_state pm_state;
int ret;
(void)pm_device_state_get(dev, &pm_state);
if (pm_state != PM_DEVICE_STATE_ACTIVE) {
ret = -EIO;
return ret;
}
switch ((uint32_t)chan) {
case SENSOR_CHAN_ALL:
ret = lm95234_fetch_temp(cfg, data, SENSOR_CHAN_AMBIENT_TEMP, &data->local);
if (ret) {
return ret;
}
for (int i = 0; i < ARRAY_SIZE(data->remote); i++) {
ret = lm95234_fetch_temp(cfg, data,
SENSOR_CHAN_LM95234_REMOTE_TEMP_1 + i,
&data->remote[i]);
if (ret) {
return ret;
}
}
break;
case SENSOR_CHAN_AMBIENT_TEMP:
ret = lm95234_fetch_temp(cfg, data, chan, &data->local);
break;
case SENSOR_CHAN_LM95234_REMOTE_TEMP_1:
case SENSOR_CHAN_LM95234_REMOTE_TEMP_2:
case SENSOR_CHAN_LM95234_REMOTE_TEMP_3:
case SENSOR_CHAN_LM95234_REMOTE_TEMP_4:
ret = lm95234_fetch_temp(cfg, data, chan,
&data->remote[chan - SENSOR_CHAN_LM95234_REMOTE_TEMP_1]);
break;
default:
ret = -ENOTSUP;
break;
}
return ret;
}
static int lm95234_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lm95234_data *data = dev->data;
int32_t raw_temp;
switch ((uint32_t)chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
raw_temp = data->local;
break;
case SENSOR_CHAN_LM95234_REMOTE_TEMP_1:
case SENSOR_CHAN_LM95234_REMOTE_TEMP_2:
case SENSOR_CHAN_LM95234_REMOTE_TEMP_3:
case SENSOR_CHAN_LM95234_REMOTE_TEMP_4:
raw_temp = data->remote[chan - SENSOR_CHAN_LM95234_REMOTE_TEMP_1];
break;
default:
return -ENOTSUP;
}
/* Raw data format is 8 bits integer, 5 bits fractional, 3 bits zero */
val->val1 = raw_temp / 256;
val->val2 = (raw_temp % 256) * 1000000 / 256;
return 0;
}
static const struct sensor_driver_api lm95234_driver_api = {
.sample_fetch = lm95234_sample_fetch,
.channel_get = lm95234_channel_get,
};
static int lm95234_init(const struct device *dev)
{
const struct lm95234_config *cfg = dev->config;
int ret = 0;
uint8_t value, model_select, model_status;
if (!i2c_is_ready_dt(&cfg->i2c)) {
LOG_ERR("I2C dev not ready");
return -ENODEV;
}
ret = i2c_reg_read_byte_dt(&cfg->i2c, LM95234_REG_MANUF_ID, &value);
if (ret) {
LOG_ERR("Could not read manufacturer ID: %d", ret);
return ret;
}
if (value != LM95234_MAN_ID) {
LOG_ERR("Invalid manufacturer ID: %02x", value);
return -ENODEV;
}
ret = i2c_reg_read_byte_dt(&cfg->i2c, LM95234_REG_REV_ID, &value);
if (ret) {
LOG_ERR("Could not read revision ID: %d", ret);
return ret;
}
if (value != LM95234_CHIP_ID) {
LOG_ERR("Invalid chip ID: %02x", value);
return -ENODEV;
}
ret = i2c_reg_read_byte_dt(&cfg->i2c, LM95234_REG_CONFIG, &value);
if (ret) {
LOG_ERR("Could not read config: %d", ret);
return ret;
}
if (value & LM95234_CONFIG_STANDBY) {
value &= ~LM95234_CONFIG_STANDBY;
ret = i2c_reg_write_byte_dt(&cfg->i2c, LM95234_REG_CONFIG, value);
if (ret) {
LOG_ERR("Could not write config: %d", ret);
return ret;
}
}
ret = i2c_reg_read_byte_dt(&cfg->i2c, LM95234_REG_DIODE_MODEL_SELECT, &model_select);
if (ret) {
LOG_ERR("Could not read diode model select: %d", ret);
return ret;
}
ret = i2c_reg_read_byte_dt(&cfg->i2c, LM95234_REG_DIODE_MODEL_STATUS, &model_status);
if (ret) {
LOG_ERR("Could not read diode model status: %d", ret);
return ret;
}
/**
* Check if any remote inputs have a 3904 transistor detected but are not configured
* as such. If so, configure them as 3904 transistors.
*/
if (model_select & model_status) {
model_select &= ~model_status;
ret = i2c_reg_write_byte_dt(&cfg->i2c, LM95234_REG_DIODE_MODEL_SELECT,
model_select);
if (ret) {
LOG_ERR("Could not write diode model select: %d", ret);
return ret;
}
}
#ifdef CONFIG_PM_DEVICE_RUNTIME
pm_device_init_suspended(dev);
ret = pm_device_runtime_enable(dev);
if (ret < 0 && ret != -ENOTSUP) {
LOG_ERR("Failed to enable runtime power management");
return ret;
}
#endif
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int lm95234_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:
break;
default:
return -ENOTSUP;
}
return 0;
}
#endif
#define LM95234_INST(inst) \
static struct lm95234_data lm95234_data_##inst; \
static const struct lm95234_config lm95234_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
PM_DEVICE_DT_INST_DEFINE(inst, lm95234_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, lm95234_init, \
PM_DEVICE_DT_INST_GET(inst), \
&lm95234_data_##inst, \
&lm95234_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lm95234_driver_api);
DT_INST_FOREACH_STATUS_OKAY(LM95234_INST)
``` | /content/code_sandbox/drivers/sensor/ti/lm95234/lm95234.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,862 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmag5170
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/pm/device.h>
#include <zephyr/logging/log.h>
#include "tmag5170.h"
LOG_MODULE_DECLARE(TMAG5170, CONFIG_SENSOR_LOG_LEVEL);
static void tmag5170_handle_interrupts(const void *arg)
{
const struct device *dev = (const struct device *)arg;
struct tmag5170_data *data = dev->data;
if (data->handler_drdy) {
data->handler_drdy(dev, data->trigger_drdy);
}
}
#if defined(CONFIG_TMAG5170_TRIGGER_OWN_THREAD)
static void tmag5170_thread_main(void *arg1, void *unused1, void *unused2)
{
ARG_UNUSED(unused1);
ARG_UNUSED(unused2);
const struct device *dev = (const struct device *)arg1;
struct tmag5170_data *data = dev->data;
while (1) {
k_sem_take(&data->sem, K_FOREVER);
tmag5170_handle_interrupts(dev);
}
}
#endif
#if defined(CONFIG_TMAG5170_TRIGGER_GLOBAL_THREAD)
static void tmag5170_work_handler(struct k_work *work)
{
struct tmag5170_data *data = CONTAINER_OF(work,
struct tmag5170_data,
work);
tmag5170_handle_interrupts(data->dev);
}
#endif
static void tmag5170_gpio_callback(const struct device *port,
struct gpio_callback *cb,
uint32_t pin)
{
struct tmag5170_data *data = CONTAINER_OF(cb,
struct tmag5170_data,
gpio_cb);
ARG_UNUSED(port);
ARG_UNUSED(pin);
#if defined(CONFIG_TMAG5170_TRIGGER_OWN_THREAD)
k_sem_give(&data->sem);
#elif defined(CONFIG_TMAG5170_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#elif defined(CONFIG_TMAG5170_TRIGGER_DIRECT)
tmag5170_handle_interrupts(data->dev);
#endif
}
int tmag5170_trigger_set(
const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct tmag5170_data *data = dev->data;
#if defined(CONFIG_PM_DEVICE)
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return -EBUSY;
}
#endif
if (trig->type != SENSOR_TRIG_DATA_READY) {
return -ENOTSUP;
}
data->trigger_drdy = trig;
data->handler_drdy = handler;
return 0;
}
int tmag5170_trigger_init(const struct device *dev)
{
struct tmag5170_data *data = dev->data;
const struct tmag5170_dev_config *cfg = dev->config;
int ret;
if (!device_is_ready(cfg->int_gpio.port)) {
LOG_ERR("%s: device %s is not ready", dev->name, cfg->int_gpio.port->name);
return -ENODEV;
}
data->dev = dev;
#if defined(CONFIG_TMAG5170_TRIGGER_OWN_THREAD)
k_sem_init(&data->sem, 0, 1);
k_thread_create(
&data->thread,
data->thread_stack,
CONFIG_TMAG5170_THREAD_STACK_SIZE,
tmag5170_thread_main,
(void *)dev,
NULL,
NULL,
K_PRIO_COOP(CONFIG_TMAG5170_THREAD_PRIORITY),
0,
K_NO_WAIT);
#elif defined(CONFIG_TMAG5170_TRIGGER_GLOBAL_THREAD)
data->work.handler = tmag5170_work_handler;
#endif
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
return ret;
}
gpio_init_callback(&data->gpio_cb, tmag5170_gpio_callback, BIT(cfg->int_gpio.pin));
ret = gpio_add_callback(cfg->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_FALLING);
if (ret < 0) {
return ret;
}
return ret;
}
``` | /content/code_sandbox/drivers/sensor/ti/tmag5170/tmag5170_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 925 |
```unknown
# Texas Instruments TMAG5170 high-precision, linear 3D Hall-effect sensor with SPI bus interface
menuconfig TMAG5170
bool "TMAG5170 SPI Hall-effect sensor driver"
default y
depends on DT_HAS_TI_TMAG5170_ENABLED
select SPI
help
Enable driver for TMAG5170 Hall-effect sensor driver
if TMAG5170
choice TMAG5170_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config TMAG5170_TRIGGER_NONE
bool "No trigger"
config TMAG5170_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select TMAG5170_TRIGGER
config TMAG5170_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select TMAG5170_TRIGGER
config TMAG5170_TRIGGER_DIRECT
bool "Process trigger within interrupt context"
depends on GPIO
select TMAG5170_TRIGGER
endchoice
config TMAG5170_CRC
bool "Use CRC error detection"
default y
select CRC
help
Verify CRC of RX data and append CRC to TX data
config TMAG5170_TRIGGER
bool
if TMAG5170_TRIGGER
config TMAG5170_THREAD_PRIORITY
int "Thread priority"
depends on TMAG5170_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config TMAG5170_THREAD_STACK_SIZE
int "Thread stack size"
depends on TMAG5170_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # TMAG5170_TRIGGER
endif # TMAG5170
``` | /content/code_sandbox/drivers/sensor/ti/tmag5170/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 366 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TMP007_TMP007_H_
#define ZEPHYR_DRIVERS_SENSOR_TMP007_TMP007_H_
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#define TMP007_REG_CONFIG 0x02
#define TMP007_ALERT_EN_BIT BIT(8)
#define TMP007_REG_TOBJ 0x03
#define TMP007_DATA_INVALID_BIT BIT(0)
#define TMP007_REG_STATUS 0x04
#define TMP007_DATA_READY_INT_BIT BIT(14)
#define TMP007_TOBJ_TH_HIGH_INT_BIT BIT(13)
#define TMP007_TOBJ_TH_LOW_INT_BIT BIT(12)
#define TMP007_TOBJ_TH_INT_BITS \
(TMP007_TOBJ_TH_HIGH_INT_BIT | TMP007_TOBJ_TH_LOW_INT_BIT)
#define TMP007_REG_TOBJ_TH_HIGH 0x06
#define TMP007_REG_TOBJ_TH_LOW 0x07
/* scale in micro degrees Celsius */
#define TMP007_TEMP_SCALE 31250
#define TMP007_TEMP_TH_SCALE 500000
struct tmp007_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_TMP007_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
struct tmp007_data {
int16_t sample;
#ifdef CONFIG_TMP007_TRIGGER
struct gpio_callback gpio_cb;
const struct device *dev;
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_TMP007_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_TMP007_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_TMP007_TRIGGER */
};
#ifdef CONFIG_TMP007_TRIGGER
int tmp007_reg_read(const struct i2c_dt_spec *i2c, uint8_t reg, uint16_t *val);
int tmp007_reg_write(const struct i2c_dt_spec *i2c, uint8_t reg, uint16_t val);
int tmp007_reg_update(const struct i2c_dt_spec *i2c, uint8_t reg,
uint16_t mask, uint16_t val);
int tmp007_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
int tmp007_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int tmp007_init_interrupt(const struct device *dev);
#endif
#endif /* _SENSOR_TMP007_ */
``` | /content/code_sandbox/drivers/sensor/ti/tmp007/tmp007.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 574 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmp007
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "tmp007.h"
extern struct tmp007_data tmp007_driver;
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(TMP007, CONFIG_SENSOR_LOG_LEVEL);
static inline void setup_int(const struct device *dev,
bool enable)
{
const struct tmp007_config *cfg = dev->config;
gpio_pin_interrupt_configure_dt(&cfg->int_gpio,
enable
? GPIO_INT_LEVEL_ACTIVE
: GPIO_INT_DISABLE);
}
int tmp007_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct tmp007_config *cfg = dev->config;
int64_t value;
uint8_t reg;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
if (attr == SENSOR_ATTR_UPPER_THRESH) {
reg = TMP007_REG_TOBJ_TH_HIGH;
} else if (attr == SENSOR_ATTR_LOWER_THRESH) {
reg = TMP007_REG_TOBJ_TH_LOW;
} else {
return -ENOTSUP;
}
value = (int64_t)val->val1 * 1000000 + val->val2;
value = (value / TMP007_TEMP_TH_SCALE) << 6;
if (tmp007_reg_write(&cfg->i2c, reg, value) < 0) {
LOG_DBG("Failed to set attribute!");
return -EIO;
}
return 0;
}
static void tmp007_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct tmp007_data *drv_data =
CONTAINER_OF(cb, struct tmp007_data, gpio_cb);
setup_int(drv_data->dev, false);
#if defined(CONFIG_TMP007_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void tmp007_thread_cb(const struct device *dev)
{
struct tmp007_data *drv_data = dev->data;
const struct tmp007_config *cfg = dev->config;
uint16_t status;
if (tmp007_reg_read(&cfg->i2c, TMP007_REG_STATUS, &status) < 0) {
return;
}
if (status & TMP007_DATA_READY_INT_BIT &&
drv_data->drdy_handler != NULL) {
drv_data->drdy_handler(dev, drv_data->drdy_trigger);
}
if (status & TMP007_TOBJ_TH_INT_BITS &&
drv_data->th_handler != NULL) {
drv_data->th_handler(dev, drv_data->th_trigger);
}
setup_int(dev, true);
}
#ifdef CONFIG_TMP007_TRIGGER_OWN_THREAD
static void tmp007_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct tmp007_data *drv_data = p1;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
tmp007_thread_cb(drv_data->dev);
}
}
#endif
#ifdef CONFIG_TMP007_TRIGGER_GLOBAL_THREAD
static void tmp007_work_cb(struct k_work *work)
{
struct tmp007_data *drv_data =
CONTAINER_OF(work, struct tmp007_data, work);
tmp007_thread_cb(drv_data->dev);
}
#endif
int tmp007_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct tmp007_data *drv_data = dev->data;
const struct tmp007_config *cfg = dev->config;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
setup_int(dev, false);
if (trig->type == SENSOR_TRIG_DATA_READY) {
drv_data->drdy_handler = handler;
drv_data->drdy_trigger = trig;
} else if (trig->type == SENSOR_TRIG_THRESHOLD) {
drv_data->th_handler = handler;
drv_data->th_trigger = trig;
}
setup_int(dev, true);
return 0;
}
int tmp007_init_interrupt(const struct device *dev)
{
struct tmp007_data *drv_data = dev->data;
const struct tmp007_config *cfg = dev->config;
if (tmp007_reg_update(&cfg->i2c, TMP007_REG_CONFIG,
TMP007_ALERT_EN_BIT, TMP007_ALERT_EN_BIT) < 0) {
LOG_DBG("Failed to enable interrupt pin!");
return -EIO;
}
drv_data->dev = dev;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name,
cfg->int_gpio.port->name);
return -ENODEV;
}
gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INT_LEVEL_ACTIVE);
gpio_init_callback(&drv_data->gpio_cb,
tmp007_gpio_callback,
BIT(cfg->int_gpio.pin));
if (gpio_add_callback(cfg->int_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
#if defined(CONFIG_TMP007_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_TMP007_THREAD_STACK_SIZE,
tmp007_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_TMP007_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = tmp007_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/ti/tmp007/tmp007_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,284 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmp007
#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 "tmp007.h"
LOG_MODULE_REGISTER(TMP007, CONFIG_SENSOR_LOG_LEVEL);
int tmp007_reg_read(const struct i2c_dt_spec *i2c, uint8_t reg, uint16_t *val)
{
if (i2c_burst_read_dt(i2c, reg, (uint8_t *) val, 2) < 0) {
LOG_ERR("I2C read failed");
return -EIO;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
int tmp007_reg_write(const struct i2c_dt_spec *i2c, uint8_t reg, uint16_t val)
{
uint8_t tx_buf[3] = {reg, val >> 8, val & 0xFF};
return i2c_write_dt(i2c, tx_buf, sizeof(tx_buf));
}
int tmp007_reg_update(const struct i2c_dt_spec *i2c, uint8_t reg,
uint16_t mask, uint16_t val)
{
uint16_t old_val = 0U;
uint16_t new_val;
if (tmp007_reg_read(i2c, reg, &old_val) < 0) {
return -EIO;
}
new_val = old_val & ~mask;
new_val |= val & mask;
return tmp007_reg_write(i2c, reg, new_val);
}
static int tmp007_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct tmp007_data *drv_data = dev->data;
const struct tmp007_config *cfg = dev->config;
uint16_t val;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_AMBIENT_TEMP);
if (tmp007_reg_read(&cfg->i2c, TMP007_REG_TOBJ, &val) < 0) {
return -EIO;
}
if (val & TMP007_DATA_INVALID_BIT) {
return -EIO;
}
drv_data->sample = arithmetic_shift_right((int16_t)val, 2);
return 0;
}
static int tmp007_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct tmp007_data *drv_data = dev->data;
int32_t uval;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
uval = (int32_t)drv_data->sample * TMP007_TEMP_SCALE;
val->val1 = uval / 1000000;
val->val2 = uval % 1000000;
return 0;
}
static const struct sensor_driver_api tmp007_driver_api = {
#ifdef CONFIG_TMP007_TRIGGER
.attr_set = tmp007_attr_set,
.trigger_set = tmp007_trigger_set,
#endif
.sample_fetch = tmp007_sample_fetch,
.channel_get = tmp007_channel_get,
};
int tmp007_init(const struct device *dev)
{
const struct tmp007_config *cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
#ifdef CONFIG_TMP007_TRIGGER
if (cfg->int_gpio.port) {
if (tmp007_init_interrupt(dev) < 0) {
LOG_DBG("Failed to initialize interrupt!");
return -EIO;
}
}
#endif
return 0;
}
#define TMP007_DEFINE(inst) \
static struct tmp007_data tmp007_data_##inst; \
\
static const struct tmp007_config tmp007_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_TMP007_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, tmp007_init, NULL, \
&tmp007_data_##inst, &tmp007_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tmp007_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(TMP007_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ti/tmp007/tmp007.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 984 |
```unknown
# TMP007 infrared thermopile sensor configuration options
menuconfig TMP007
bool "TMP007 Infrared Thermopile Sensor"
default y
depends on DT_HAS_TI_TMP007_ENABLED
select I2C
help
Enable driver for TMP007 infrared thermopile sensors.
if TMP007
choice
prompt "Trigger mode"
default TMP007_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config TMP007_TRIGGER_NONE
bool "No trigger"
config TMP007_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select TMP007_TRIGGER
config TMP007_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select TMP007_TRIGGER
endchoice
config TMP007_TRIGGER
bool
config TMP007_THREAD_PRIORITY
int "Thread priority"
depends on TMP007_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config TMP007_THREAD_STACK_SIZE
int "Thread stack size"
depends on TMP007_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # TMP007
``` | /content/code_sandbox/drivers/sensor/ti/tmp007/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 248 |
```unknown
# INA226 Bidirectional Current/Power Monitor
config INA226
bool "INA226 Current/Power Monitor"
default y
depends on DT_HAS_TI_INA226_ENABLED
select I2C
help
Enable driver for INA226 Bidirectional Current/Power Monitor.
config INA226_VSHUNT
bool "INA226 VShunt Measurement Enable"
depends on DT_HAS_TI_INA226_ENABLED
help
Enable shunt voltage measurement for INA226.
This is the actual shunt voltage measured which is scaled within the
INA226 based upon the SHUNT_CAL register. This value is useful for
determining the measurement noise or debugging the SHUNT_CAL value.
Note that enabling this option requires an extra I2C read when the
SENSOR_CHAN_ALL is selected. Hence, only enable this option if the
shunt voltage measurement is required.
``` | /content/code_sandbox/drivers/sensor/ti/ina226/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 183 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmag5170
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <zephyr/devicetree.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#if defined(CONFIG_TMAG5170_CRC)
#include <zephyr/sys/crc.h>
#endif
#include "tmag5170.h"
#define TMAG5170_REG_DEVICE_CONFIG 0x0U
#define TMAG5170_REG_SENSOR_CONFIG 0x1U
#define TMAG5170_REG_SYSTEM_CONFIG 0x2U
#define TMAG5170_REG_ALERT_CONFIG 0x3U
#define TMAG5170_REG_X_THRX_CONFIG 0x4U
#define TMAG5170_REG_Y_THRX_CONFIG 0x5U
#define TMAG5170_REG_Z_THRX_CONFIG 0x6U
#define TMAG5170_REG_T_THRX_CONFIG 0x7U
#define TMAG5170_REG_CONV_STATUS 0x8U
#define TMAG5170_REG_X_CH_RESULT 0x9U
#define TMAG5170_REG_Y_CH_RESULT 0xAU
#define TMAG5170_REG_Z_CH_RESULT 0xBU
#define TMAG5170_REG_TEMP_RESULT 0xCU
#define TMAG5170_REG_AFE_STATUS 0xDU
#define TMAG5170_REG_SYS_STATUS 0xEU
#define TMAG5170_REG_TEST_CONFIG 0xFU
#define TMAG5170_REG_OSC_MONITOR 0x10U
#define TMAG5170_REG_MAG_GAIN_CONFIG 0x11U
#define TMAG5170_REG_MAG_OFFSET_CONFIG 0x12U
#define TMAG5170_REG_ANGLE_RESULT 0x13U
#define TMAG5170_REG_MAGNITUDE_RESULT 0x14U
#define TMAG5170_CONV_AVG_POS 12U
#define TMAG5170_CONV_AVG_MASK (BIT_MASK(3U) << TMAG5170_CONV_AVG_POS)
#define TMAG5170_CONV_AVG_SET(value) (((value) << TMAG5170_CONV_AVG_POS) &\
TMAG5170_CONV_AVG_MASK)
#define TMAG5170_MAG_TEMPCO_POS 8U
#define TMAG5170_MAG_TEMPCO_MASK (BIT_MASK(2U) << TMAG5170_MAG_TEMPCO_POS)
#define TMAG5170_MAG_TEMPCO_SET(value) (((value) << TMAG5170_MAG_TEMPCO_POS) &\
TMAG5170_MAG_TEMPCO_MASK)
#define TMAG5170_OPERATING_MODE_POS 4U
#define TMAG5170_OPERATING_MODE_MASK (BIT_MASK(3U) << TMAG5170_OPERATING_MODE_POS)
#define TMAG5170_OPERATING_MODE_SET(value) (((value) << TMAG5170_OPERATING_MODE_POS) &\
TMAG5170_OPERATING_MODE_MASK)
#define TMAG5170_T_CH_EN_POS 3U
#define TMAG5170_T_CH_EN_MASK (BIT_MASK(1U) << TMAG5170_T_CH_EN_POS)
#define TMAG5170_T_CH_EN_SET(value) (((value) << TMAG5170_T_CH_EN_POS) &\
TMAG5170_T_CH_EN_MASK)
#define TMAG5170_T_RATE_POS 2U
#define TMAG5170_T_RATE_MASK (BIT_MASK(1U) << TMAG5170_T_RATE_POS)
#define TMAG5170_T_RATE_SET(value) (((value) << TMAG5170_T_RATE_POS) &\
TMAG5170_T_RATE_MASK)
#define TMAG5170_ANGLE_EN_POS 14U
#define TMAG5170_ANGLE_EN_MASK (BIT_MASK(2U) << TMAG5170_ANGLE_EN_POS)
#define TMAG5170_ANGLE_EN_SET(value) (((value) << TMAG5170_ANGLE_EN_POS) &\
TMAG5170_ANGLE_EN_MASK)
#define TMAG5170_SLEEPTIME_POS 10U
#define TMAG5170_SLEEPTIME_MASK (BIT_MASK(4U) << TMAG5170_SLEEPTIME_POS)
#define TMAG5170_SLEEPTIME_SET(value) (((value) << TMAG5170_SLEEPTIME_POS) &\
TMAG5170_SLEEPTIME_MASK)
#define TMAG5170_MAG_CH_EN_POS 6U
#define TMAG5170_MAG_CH_EN_MASK (BIT_MASK(4U) << TMAG5170_MAG_CH_EN_POS)
#define TMAG5170_MAG_CH_EN_SET(value) (((value) << TMAG5170_MAG_CH_EN_POS) &\
TMAG5170_MAG_CH_EN_MASK)
#define TMAG5170_Z_RANGE_POS 4U
#define TMAG5170_Z_RANGE_MASK (BIT_MASK(2U) << TMAG5170_Z_RANGE_POS)
#define TMAG5170_Z_RANGE_SET(value) (((value) << TMAG5170_Z_RANGE_POS) &\
TMAG5170_Z_RANGE_MASK)
#define TMAG5170_Y_RANGE_POS 2U
#define TMAG5170_Y_RANGE_MASK (BIT_MASK(2U) << TMAG5170_Y_RANGE_POS)
#define TMAG5170_Y_RANGE_SET(value) (((value) << TMAG5170_Y_RANGE_POS) &\
TMAG5170_Y_RANGE_MASK)
#define TMAG5170_X_RANGE_POS 0U
#define TMAG5170_X_RANGE_MASK (BIT_MASK(2U) << TMAG5170_X_RANGE_POS)
#define TMAG5170_X_RANGE_SET(value) (((value) << TMAG5170_X_RANGE_POS) &\
TMAG5170_X_RANGE_MASK)
#define TMAG5170_RSLT_ALRT_POS 8U
#define TMAG5170_RSLT_ALRT_MASK (BIT_MASK(1U) << TMAG5170_RSLT_ALRT_POS)
#define TMAG5170_RSLT_ALRT_SET(value) (((value) << TMAG5170_RSLT_ALRT_POS) &\
TMAG5170_RSLT_ALRT_MASK)
#define TMAG5170_VER_POS 4U
#define TMAG5170_VER_MASK (BIT_MASK(2U) << TMAG5170_VER_POS)
#define TMAG5170_VER_GET(value) (((value) & TMAG5170_VER_MASK) >> TMAG5170_VER_POS)
#define TMAG5170_A1_REV 0x0U
#define TMAG5170_A2_REV 0x1U
#define TMAG5170_MAX_RANGE_50MT_IDX 0x0U
#define TMAG5170_MAX_RANGE_25MT_IDX 0x1U
#define TMAG5170_MAX_RANGE_100MT_IDX 0x2U
#define TMAG5170_MAX_RANGE_EXTEND_FACTOR 0x3U
#define TMAG5170_CONFIGURATION_MODE 0x0U
#define TMAG5170_STAND_BY_MODE 0x1U
#define TMAG5170_ACTIVE_TRIGGER_MODE 0x3U
#define TMAG5170_SLEEP_MODE 0x5U
#define TMAG5170_DEEP_SLEEP_MODE 0x6U
#define TMAG5170_MT_TO_GAUSS_RATIO 10U
#define TMAG5170_T_SENS_T0 25U
#define TMAG5170_T_ADC_T0 17522U
#define TMAG5170_T_ADC_RES 60U
#define TMAG5170_CMD_TRIGGER_CONVERSION BIT(0U)
#define TMAG5170_CRC_SEED 0xFU
#define TMAG5170_CRC_POLY 0x3U
#define TMAG5170_SPI_BUFFER_LEN 4U
#define TMAG5170_SET_CRC(buf, crc) ((uint8_t *)(buf))[3] |= (crc & 0x0F)
#define TMAG5170_ZERO_CRC(buf) ((uint8_t *)(buf))[3] &= 0xF0
#define TMAG5170_GET_CRC(buf) ((uint8_t *)(buf))[3] & 0x0F
LOG_MODULE_REGISTER(TMAG5170, CONFIG_SENSOR_LOG_LEVEL);
static int tmag5170_transmit_raw(const struct tmag5170_dev_config *config,
uint8_t *buffer_tx,
uint8_t *buffer_rx)
{
const struct spi_buf tx_buf = {
.buf = buffer_tx,
.len = TMAG5170_SPI_BUFFER_LEN,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
const struct spi_buf rx_buf = {
.buf = buffer_rx,
.len = TMAG5170_SPI_BUFFER_LEN,
};
const struct spi_buf_set rx = {
.buffers = &rx_buf,
.count = 1
};
int ret = spi_transceive_dt(&config->bus, &tx, &rx);
return ret;
}
static int tmag5170_transmit(const struct device *dev, uint8_t *buffer_tx, uint8_t *buffer_rx)
{
#if defined(CONFIG_TMAG5170_CRC)
TMAG5170_ZERO_CRC(buffer_tx);
uint8_t crc = crc4_ti(TMAG5170_CRC_SEED, buffer_tx, TMAG5170_SPI_BUFFER_LEN);
TMAG5170_SET_CRC(buffer_tx, crc);
#endif
int ret = tmag5170_transmit_raw(dev->config, buffer_tx, buffer_rx);
#if defined(CONFIG_TMAG5170_CRC)
if (buffer_rx != NULL && ret == 0) {
uint8_t read_crc = TMAG5170_GET_CRC(buffer_rx);
TMAG5170_ZERO_CRC(buffer_rx);
crc = crc4_ti(TMAG5170_CRC_SEED, buffer_rx, TMAG5170_SPI_BUFFER_LEN);
if (read_crc != crc) {
return -EIO;
}
}
#endif
return ret;
}
static int tmag5170_write_register(const struct device *dev, uint32_t reg, uint16_t data)
{
uint8_t buffer_tx[4] = { reg, (data >> 8) & 0xFF, data & 0xFF, 0x00U };
return tmag5170_transmit(dev, buffer_tx, NULL);
}
static int tmag5170_read_register(const struct device *dev,
uint32_t reg,
uint16_t *output,
uint8_t cmd)
{
uint8_t buffer_tx[4] = { BIT(7) | reg, 0x00U, 0x00U, (cmd & BIT_MASK(4U)) << 4U };
uint8_t buffer_rx[4] = { 0x00U };
int ret = tmag5170_transmit(dev, buffer_tx, buffer_rx);
*output = (buffer_rx[1] << 8) | buffer_rx[2];
return ret;
}
static int tmag5170_convert_magn_reading_to_gauss(struct sensor_value *output,
uint16_t chan_reading,
uint8_t chan_range,
uint8_t chip_revision)
{
uint16_t max_range_mt = 0U;
if (chan_range == TMAG5170_MAX_RANGE_50MT_IDX) {
max_range_mt = 50U;
} else if (chan_range == TMAG5170_MAX_RANGE_25MT_IDX) {
max_range_mt = 25U;
} else if (chan_range == TMAG5170_MAX_RANGE_100MT_IDX) {
max_range_mt = 100U;
} else {
return -ENOTSUP;
}
if (chip_revision == TMAG5170_A2_REV) {
max_range_mt *= TMAG5170_MAX_RANGE_EXTEND_FACTOR;
}
max_range_mt *= 2U;
/* The sensor returns data in mT, we need to convert it to Gauss */
uint32_t max_range_gauss = max_range_mt * TMAG5170_MT_TO_GAUSS_RATIO;
/* Convert from 2's complementary system */
int64_t result = chan_reading - ((chan_reading & 0x8000) << 1);
result *= max_range_gauss;
/* Scale to increase accuracy */
result *= 100000;
/* Divide as it is shown in datasheet */
result /= 65536;
/* Remove scale from the final result */
output->val1 = result / 100000;
output->val2 = result % 100000;
return 0;
}
static void tmag5170_convert_temp_reading_to_celsius(struct sensor_value *output,
uint16_t chan_reading)
{
int32_t result = chan_reading - TMAG5170_T_ADC_T0;
result = (TMAG5170_T_SENS_T0 * 100000) + (100000 * result / (int32_t)TMAG5170_T_ADC_RES);
output->val1 = result / 100000;
output->val2 = (result % 100000) * 10;
}
static void tmag5170_covert_angle_reading_to_degrees(struct sensor_value *output,
uint16_t chan_reading)
{
/* 12 MSBs store the integer part of the result,
* 4 LSBs store the fractional part of the result
*/
output->val1 = chan_reading >> 4;
output->val2 = ((chan_reading & 0xF) * 1000000) / 16;
}
static int tmag5170_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct tmag5170_dev_config *cfg = dev->config;
struct tmag5170_data *drv_data = dev->data;
int ret = 0;
if (cfg->operating_mode == TMAG5170_STAND_BY_MODE ||
cfg->operating_mode == TMAG5170_ACTIVE_TRIGGER_MODE) {
uint16_t read_status;
tmag5170_read_register(dev,
TMAG5170_REG_SYS_STATUS,
&read_status,
TMAG5170_CMD_TRIGGER_CONVERSION);
/* Wait for the measurement to be ready.
* The waiting time will vary depending on the configuration
*/
k_sleep(K_MSEC(5U));
}
switch (chan) {
case SENSOR_CHAN_MAGN_X:
ret = tmag5170_read_register(dev, TMAG5170_REG_X_CH_RESULT, &drv_data->x, 0U);
break;
case SENSOR_CHAN_MAGN_Y:
ret = tmag5170_read_register(dev, TMAG5170_REG_Y_CH_RESULT, &drv_data->y, 0U);
break;
case SENSOR_CHAN_MAGN_Z:
ret = tmag5170_read_register(dev, TMAG5170_REG_Z_CH_RESULT, &drv_data->z, 0U);
break;
case SENSOR_CHAN_MAGN_XYZ:
ret = tmag5170_read_register(dev, TMAG5170_REG_X_CH_RESULT, &drv_data->x, 0U);
if (ret == 0) {
ret = tmag5170_read_register(dev,
TMAG5170_REG_Y_CH_RESULT,
&drv_data->y,
0U);
}
if (ret == 0) {
ret = tmag5170_read_register(dev,
TMAG5170_REG_Z_CH_RESULT,
&drv_data->z,
0U);
}
break;
case SENSOR_CHAN_ROTATION:
ret = tmag5170_read_register(dev,
TMAG5170_REG_ANGLE_RESULT,
&drv_data->angle,
0U);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
ret = tmag5170_read_register(dev,
TMAG5170_REG_TEMP_RESULT,
&drv_data->temperature,
0U);
break;
case SENSOR_CHAN_ALL:
ret = tmag5170_read_register(dev,
TMAG5170_REG_TEMP_RESULT,
&drv_data->temperature,
0U);
if (ret == 0) {
ret = tmag5170_read_register(dev,
TMAG5170_REG_ANGLE_RESULT,
&drv_data->angle,
0U);
}
if (ret == 0) {
ret = tmag5170_read_register(dev,
TMAG5170_REG_X_CH_RESULT,
&drv_data->x,
0U);
}
if (ret == 0) {
ret = tmag5170_read_register(dev,
TMAG5170_REG_Y_CH_RESULT,
&drv_data->y,
0U);
}
if (ret == 0) {
ret = tmag5170_read_register(dev,
TMAG5170_REG_Z_CH_RESULT,
&drv_data->z,
0U);
}
break;
default:
ret = -ENOTSUP;
break;
}
return ret;
}
static int tmag5170_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct tmag5170_dev_config *cfg = dev->config;
struct tmag5170_data *drv_data = dev->data;
int ret = 0;
switch (chan) {
case SENSOR_CHAN_MAGN_XYZ:
ret = tmag5170_convert_magn_reading_to_gauss(val,
drv_data->x,
cfg->x_range,
drv_data->chip_revision);
if (ret == 0) {
ret = tmag5170_convert_magn_reading_to_gauss(val + 1,
drv_data->y,
cfg->y_range,
drv_data->chip_revision);
}
if (ret == 0) {
ret = tmag5170_convert_magn_reading_to_gauss(val + 2,
drv_data->z,
cfg->z_range,
drv_data->chip_revision);
}
break;
case SENSOR_CHAN_MAGN_X:
ret = tmag5170_convert_magn_reading_to_gauss(val,
drv_data->x,
cfg->x_range,
drv_data->chip_revision);
break;
case SENSOR_CHAN_MAGN_Y:
ret = tmag5170_convert_magn_reading_to_gauss(val,
drv_data->y,
cfg->y_range,
drv_data->chip_revision);
break;
case SENSOR_CHAN_MAGN_Z:
ret = tmag5170_convert_magn_reading_to_gauss(val,
drv_data->z,
cfg->z_range,
drv_data->chip_revision);
break;
case SENSOR_CHAN_ROTATION:
tmag5170_covert_angle_reading_to_degrees(val, drv_data->angle);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
tmag5170_convert_temp_reading_to_celsius(val, drv_data->temperature);
break;
default:
ret = -ENOTSUP;
break;
}
return ret;
}
static int tmag5170_init_registers(const struct device *dev)
{
const struct tmag5170_dev_config *cfg = dev->config;
struct tmag5170_data *drv_data = dev->data;
uint16_t test_cfg_reg = 0U;
int ret = 0;
#if !defined(CONFIG_TMAG5170_CRC)
const uint8_t disable_crc_packet[4] = { 0x0FU, 0x0U, 0x04U, 0x07U };
ret = tmag5170_transmit_raw(cfg, disable_crc_packet, NULL);
#endif
if (ret == 0) {
ret = tmag5170_read_register(dev, TMAG5170_REG_TEST_CONFIG, &test_cfg_reg, 0U);
}
if (ret == 0) {
drv_data->chip_revision = TMAG5170_VER_GET(test_cfg_reg);
ret = tmag5170_write_register(dev,
TMAG5170_REG_SENSOR_CONFIG,
TMAG5170_ANGLE_EN_SET(cfg->angle_measurement) |
TMAG5170_SLEEPTIME_SET(cfg->sleep_time) |
TMAG5170_MAG_CH_EN_SET(cfg->magnetic_channels) |
TMAG5170_Z_RANGE_SET(cfg->z_range) |
TMAG5170_Y_RANGE_SET(cfg->y_range) |
TMAG5170_X_RANGE_SET(cfg->x_range));
}
#if defined(CONFIG_TMAG5170_TRIGGER)
if (ret == 0) {
ret = tmag5170_write_register(dev,
TMAG5170_REG_ALERT_CONFIG,
TMAG5170_RSLT_ALRT_SET(1U));
}
#endif
if (ret == 0) {
ret = tmag5170_write_register(dev,
TMAG5170_REG_DEVICE_CONFIG,
TMAG5170_OPERATING_MODE_SET(cfg->operating_mode) |
TMAG5170_CONV_AVG_SET(cfg->oversampling) |
TMAG5170_MAG_TEMPCO_SET(cfg->magnet_type) |
TMAG5170_T_CH_EN_SET(cfg->tempeature_measurement) |
TMAG5170_T_RATE_SET(cfg->disable_temperature_oversampling));
}
return ret;
}
#ifdef CONFIG_PM_DEVICE
static int tmag5170_pm_action(const struct device *dev,
enum pm_device_action action)
{
int ret_val = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
tmag5170_write_register(dev,
TMAG5170_REG_DEVICE_CONFIG,
TMAG5170_OPERATING_MODE_SET(TMAG5170_CONFIGURATION_MODE));
/* As per datasheet, waking up from deep-sleep can take up to 500us */
k_sleep(K_USEC(500));
ret_val = tmag5170_init_registers(dev);
break;
case PM_DEVICE_ACTION_SUSPEND:
ret_val = tmag5170_write_register(dev,
TMAG5170_REG_DEVICE_CONFIG,
TMAG5170_OPERATING_MODE_SET(TMAG5170_DEEP_SLEEP_MODE));
break;
default:
ret_val = -ENOTSUP;
}
return ret_val;
}
#endif /* CONFIG_PM_DEVICE */
static const struct sensor_driver_api tmag5170_driver_api = {
.sample_fetch = tmag5170_sample_fetch,
.channel_get = tmag5170_channel_get,
#if defined(CONFIG_TMAG5170_TRIGGER)
.trigger_set = tmag5170_trigger_set
#endif
};
static int tmag5170_init(const struct device *dev)
{
const struct tmag5170_dev_config *cfg = dev->config;
int ret = 0;
if (!spi_is_ready_dt(&cfg->bus)) {
LOG_ERR("SPI dev %s not ready", cfg->bus.bus->name);
return -ENODEV;
}
ret = tmag5170_init_registers(dev);
if (ret != 0) {
return ret;
}
#if defined(CONFIG_TMAG5170_TRIGGER)
if (cfg->int_gpio.port) {
ret = tmag5170_trigger_init(dev);
}
#endif
return ret;
}
#define DEFINE_TMAG5170(_num) \
static struct tmag5170_data tmag5170_data_##_num; \
static const struct tmag5170_dev_config tmag5170_config_##_num = { \
.bus = SPI_DT_SPEC_INST_GET(_num, \
SPI_OP_MODE_MASTER | \
SPI_TRANSFER_MSB | \
SPI_WORD_SET(32), \
0), \
.magnetic_channels = DT_INST_ENUM_IDX(_num, magnetic_channels), \
.x_range = DT_INST_ENUM_IDX(_num, x_range), \
.y_range = DT_INST_ENUM_IDX(_num, y_range), \
.z_range = DT_INST_ENUM_IDX(_num, z_range), \
.operating_mode = DT_INST_PROP(_num, operating_mode), \
.oversampling = DT_INST_ENUM_IDX(_num, oversampling), \
.tempeature_measurement = DT_INST_PROP(_num, enable_temperature_channel), \
.magnet_type = DT_INST_ENUM_IDX(_num, magnet_type), \
.angle_measurement = DT_INST_ENUM_IDX(_num, angle_measurement), \
.disable_temperature_oversampling = DT_INST_PROP(_num, \
disable_temperature_oversampling), \
.sleep_time = DT_INST_ENUM_IDX(_num, sleep_time), \
IF_ENABLED(CONFIG_TMAG5170_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(_num, int_gpios, { 0 }),)) \
}; \
PM_DEVICE_DT_INST_DEFINE(_num, tmag5170_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(_num, \
tmag5170_init, \
PM_DEVICE_DT_INST_GET(_num), \
&tmag5170_data_##_num, \
&tmag5170_config_##_num, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&tmag5170_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_TMAG5170)
``` | /content/code_sandbox/drivers/sensor/ti/tmag5170/tmag5170.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,469 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmp114
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
LOG_MODULE_REGISTER(TMP114, CONFIG_SENSOR_LOG_LEVEL);
#define TMP114_REG_TEMP 0x0
#define TMP114_REG_ALERT 0x2
#define TMP114_REG_CFGR 0x3
#define TMP114_REG_DEVICE_ID 0xb
#define TMP114_RESOLUTION 78125 /* in tens of uCelsius*/
#define TMP114_RESOLUTION_DIV 10000000
#define TMP114_DEVICE_ID 0x1114
#define TMP114_ALERT_DATA_READY BIT(0)
#define TMP114_AVG_MASK BIT(7)
struct tmp114_data {
uint16_t sample;
uint16_t id;
};
struct tmp114_dev_config {
struct i2c_dt_spec bus;
};
static int tmp114_reg_read(const struct device *dev, uint8_t reg,
uint16_t *val)
{
const struct tmp114_dev_config *cfg = dev->config;
if (i2c_burst_read_dt(&cfg->bus, reg, (uint8_t *)val, 2)
< 0) {
return -EIO;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
static int tmp114_reg_write(const struct device *dev, uint8_t reg,
uint16_t val)
{
const struct tmp114_dev_config *cfg = dev->config;
uint8_t tx_buf[3] = {reg, val >> 8, val & 0xFF};
return i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
}
static inline int tmp114_device_id_check(const struct device *dev, uint16_t *id)
{
if (tmp114_reg_read(dev, TMP114_REG_DEVICE_ID, id) != 0) {
LOG_ERR("%s: Failed to get Device ID register!", dev->name);
return -EIO;
}
if (*id != TMP114_DEVICE_ID) {
LOG_ERR("%s: Failed to match the device ID!", dev->name);
return -EINVAL;
}
return 0;
}
static int tmp114_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct tmp114_data *drv_data = dev->data;
uint16_t value;
uint16_t cfg_reg = 0;
int rc;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_AMBIENT_TEMP);
/* clear sensor values */
drv_data->sample = 0U;
/* Check alert register to make sure that a data is available */
rc = tmp114_reg_read(dev, TMP114_REG_ALERT, &cfg_reg);
if (rc < 0) {
LOG_ERR("%s, Failed to read from CFGR register", dev->name);
return rc;
}
if ((cfg_reg & TMP114_ALERT_DATA_READY) == 0) {
LOG_DBG("%s: no data ready", dev->name);
return -EBUSY;
}
/* Get the most recent temperature measurement */
rc = tmp114_reg_read(dev, TMP114_REG_TEMP, &value);
if (rc < 0) {
LOG_ERR("%s: Failed to read from TEMP register!", dev->name);
return rc;
}
/* store measurements to the driver */
drv_data->sample = (int16_t)value;
return 0;
}
static int tmp114_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct tmp114_data *drv_data = dev->data;
int32_t tmp;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
/*
* See datasheet for tmp114, section 'Temp_Result Register' section
* for more details on processing sample data.
*/
tmp = ((int16_t)drv_data->sample * (int32_t)TMP114_RESOLUTION) / 10;
val->val1 = tmp / 1000000; /* uCelsius */
val->val2 = tmp % 1000000;
return 0;
}
static int tmp114_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
uint16_t data;
int rc;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
rc = tmp114_reg_read(dev, TMP114_REG_CFGR, &data);
if (rc < 0) {
return rc;
}
break;
default:
return -ENOTSUP;
}
val->val1 = data;
val->val2 = 0;
return 0;
}
static int tmp114_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
int16_t value;
int rc;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_OVERSAMPLING:
/* Enable the AVG in tmp114. The chip will do 8 avg of 8 samples
* to get a more accurate value.
*/
rc = tmp114_reg_read(dev, TMP114_REG_CFGR, &value);
if (rc < 0) {
return rc;
}
value = value & ~TMP114_AVG_MASK;
if (val->val1) {
value |= TMP114_AVG_MASK;
}
return tmp114_reg_write(dev, TMP114_REG_CFGR, value);
default:
return -ENOTSUP;
}
}
static const struct sensor_driver_api tmp114_driver_api = {
.attr_get = tmp114_attr_get,
.attr_set = tmp114_attr_set,
.sample_fetch = tmp114_sample_fetch,
.channel_get = tmp114_channel_get
};
static int tmp114_init(const struct device *dev)
{
struct tmp114_data *drv_data = dev->data;
const struct tmp114_dev_config *cfg = dev->config;
int rc;
uint16_t id;
if (!i2c_is_ready_dt(&cfg->bus)) {
LOG_ERR("I2C dev %s not ready", cfg->bus.bus->name);
return -EINVAL;
}
/* Check the Device ID */
rc = tmp114_device_id_check(dev, &id);
if (rc < 0) {
return rc;
}
LOG_INF("Got device ID: %x", id);
drv_data->id = id;
return 0;
}
#define DEFINE_TMP114(_num) \
static struct tmp114_data tmp114_data_##_num; \
static const struct tmp114_dev_config tmp114_config_##_num = { \
.bus = I2C_DT_SPEC_INST_GET(_num) \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(_num, tmp114_init, NULL, \
&tmp114_data_##_num, &tmp114_config_##_num, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tmp114_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_TMP114)
``` | /content/code_sandbox/drivers/sensor/ti/tmp114/tmp114.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,577 |
```unknown
# TMP114 temperature sensor configuration options
config TMP114
bool "TMP114 Temperature Sensor"
default y
depends on DT_HAS_TI_TMP114_ENABLED
select I2C
help
Enable driver for TMP114 temperature sensors.
``` | /content/code_sandbox/drivers/sensor/ti/tmp114/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 49 |
```c
/*
*
*/
/* TODO: Add functionality for Trigger. */
#define DT_DRV_COMPAT ti_ina226
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/dt-bindings/sensor/ina226.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util_macro.h>
#include <stdint.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
/* Device register addresses. */
#define INA226_REG_CONFIG 0x00
#define INA226_REG_SHUNT_VOLT 0x01
#define INA226_REG_BUS_VOLT 0x02
#define INA226_REG_POWER 0x03
#define INA226_REG_CURRENT 0x04
#define INA226_REG_CALIB 0x05
#define INA226_REG_MASK 0x06
#define INA226_REG_ALERT 0x07
#define INA226_REG_MANUFACTURER_ID 0xFE
#define INA226_REG_DEVICE_ID 0xFF
/* Device register values. */
#define INA226_MANUFACTURER_ID 0x5449
#define INA226_DEVICE_ID 0x2260
struct ina226_data {
const struct device *dev;
int16_t current;
uint16_t bus_voltage;
uint16_t power;
#ifdef CONFIG_INA226_VSHUNT
int16_t shunt_voltage;
#endif
enum sensor_channel chan;
};
struct ina226_config {
const struct i2c_dt_spec bus;
uint16_t config;
uint32_t current_lsb;
uint16_t cal;
};
LOG_MODULE_REGISTER(INA226, CONFIG_SENSOR_LOG_LEVEL);
/** @brief Calibration scaling value (scaled by 10^-5) */
#define INA226_CAL_SCALING 512ULL
/** @brief The LSB value for the bus voltage register, in microvolts/LSB. */
#define INA226_BUS_VOLTAGE_TO_uV(x) ((x) * 1250U)
/** @brief The LSB value for the shunt voltage register, in microvolts/LSB. */
#define INA226_SHUNT_VOLTAGE_TO_uV(x) ((x) * 2500U / 1000U)
/** @brief Power scaling (need factor of 0.2) */
#define INA226_POWER_TO_uW(x) ((x) * 25ULL)
int ina226_reg_read_16(const struct i2c_dt_spec *bus, uint8_t reg, uint16_t *val)
{
uint8_t data[2];
int ret;
ret = i2c_burst_read_dt(bus, reg, data, sizeof(data));
if (ret < 0) {
return ret;
}
*val = sys_get_be16(data);
return ret;
}
int ina226_reg_write(const struct i2c_dt_spec *bus, uint8_t reg, uint16_t val)
{
uint8_t tx_buf[3];
tx_buf[0] = reg;
sys_put_be16(val, &tx_buf[1]);
return i2c_write_dt(bus, tx_buf, sizeof(tx_buf));
}
static void micro_s32_to_sensor_value(struct sensor_value *val, int32_t value_microX)
{
val->val1 = value_microX / 1000000L;
val->val2 = value_microX % 1000000L;
}
static int ina226_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct ina226_data *data = dev->data;
const struct ina226_config *config = dev->config;
switch (chan) {
case SENSOR_CHAN_VOLTAGE:
micro_s32_to_sensor_value(val, INA226_BUS_VOLTAGE_TO_uV(data->bus_voltage));
break;
case SENSOR_CHAN_CURRENT:
/* see datasheet "Current and Power calculations" section */
micro_s32_to_sensor_value(val, data->current * config->current_lsb);
break;
case SENSOR_CHAN_POWER:
/* power in uW is power_reg * current_lsb * 0.2 */
micro_s32_to_sensor_value(val,
INA226_POWER_TO_uW((uint32_t)data->power * config->current_lsb));
break;
#ifdef CONFIG_INA226_VSHUNT
case SENSOR_CHAN_VSHUNT:
micro_s32_to_sensor_value(val, INA226_SHUNT_VOLTAGE_TO_uV(data->shunt_voltage));
break;
#endif /* CONFIG_INA226_VSHUNT */
default:
return -ENOTSUP;
}
return 0;
}
static int ina226_read_data(const struct device *dev)
{
struct ina226_data *data = dev->data;
const struct ina226_config *config = dev->config;
int ret;
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_VOLTAGE)) {
ret = ina226_reg_read_16(&config->bus, INA226_REG_BUS_VOLT, &data->bus_voltage);
if (ret < 0) {
LOG_ERR("Failed to read bus voltage");
return ret;
}
}
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_CURRENT)) {
ret = ina226_reg_read_16(&config->bus, INA226_REG_CURRENT, &data->current);
if (ret < 0) {
LOG_ERR("Failed to read current");
return ret;
}
}
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_POWER)) {
ret = ina226_reg_read_16(&config->bus, INA226_REG_POWER, &data->power);
if (ret < 0) {
LOG_ERR("Failed to read power");
return ret;
}
}
#ifdef CONFIG_INA226_VSHUNT
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_VSHUNT)) {
ret = ina226_reg_read_16(&config->bus, INA226_REG_SHUNT_VOLT, &data->shunt_voltage);
if (ret < 0) {
LOG_ERR("Failed to read shunt voltage");
return ret;
}
}
#endif /* CONFIG_INA226_VSHUNT */
return 0;
}
static int ina226_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ina226_data *data = dev->data;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_VOLTAGE
&& chan != SENSOR_CHAN_CURRENT && chan != SENSOR_CHAN_POWER
#ifdef CONFIG_INA226_VSHUNT
&& chan != SENSOR_CHAN_VSHUNT
#endif /* CONFIG_INA226_VSHUNT */
) {
return -ENOTSUP;
}
data->chan = chan;
return ina226_read_data(dev);
}
static int ina226_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct ina226_config *config = dev->config;
uint16_t data = val->val1;
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
return ina226_reg_write(&config->bus, INA226_REG_CONFIG, data);
case SENSOR_ATTR_CALIBRATION:
return ina226_reg_write(&config->bus, INA226_REG_CALIB, data);
default:
LOG_ERR("INA226 attribute not supported.");
return -ENOTSUP;
}
}
static int ina226_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct ina226_config *config = dev->config;
uint16_t data;
int ret;
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
ret = ina226_reg_read_16(&config->bus, INA226_REG_CONFIG, &data);
if (ret < 0) {
return ret;
}
break;
case SENSOR_ATTR_CALIBRATION:
ret = ina226_reg_read_16(&config->bus, INA226_REG_CALIB, &data);
if (ret < 0) {
return ret;
}
break;
default:
LOG_ERR("INA226 attribute not supported.");
return -ENOTSUP;
}
val->val1 = data;
val->val2 = 0;
return 0;
}
static int ina226_calibrate(const struct device *dev)
{
const struct ina226_config *config = dev->config;
int ret;
ret = ina226_reg_write(&config->bus, INA226_REG_CALIB, config->cal);
if (ret < 0) {
return ret;
}
return 0;
}
static int ina226_init(const struct device *dev)
{
struct ina226_data *data = dev->data;
const struct ina226_config *config = dev->config;
uint16_t id;
int ret;
if (!i2c_is_ready_dt(&config->bus)) {
LOG_ERR("I2C bus %s is not ready", config->bus.bus->name);
return -ENODEV;
}
data->dev = dev;
ret = ina226_reg_read_16(&config->bus, INA226_REG_MANUFACTURER_ID, &id);
if (ret < 0) {
LOG_ERR("Failed to read manufacturer register.");
return ret;
}
if (id != INA226_MANUFACTURER_ID) {
LOG_ERR("Manufacturer ID doesn't match.");
return -ENODEV;
}
ret = ina226_reg_read_16(&config->bus, INA226_REG_DEVICE_ID, &id);
if (ret < 0) {
LOG_ERR("Failed to read device register.");
return ret;
}
if (id != INA226_DEVICE_ID) {
LOG_ERR("Device ID doesn't match.");
return -ENODEV;
}
ret = ina226_reg_write(&config->bus, INA226_REG_CONFIG, config->config);
if (ret < 0) {
LOG_ERR("Failed to write configuration register.");
return ret;
}
ret = ina226_calibrate(dev);
if (ret < 0) {
LOG_ERR("Failed to write calibration register.");
return ret;
}
return 0;
}
static const struct sensor_driver_api ina226_driver_api = {
.attr_set = ina226_attr_set,
.attr_get = ina226_attr_get,
.sample_fetch = ina226_sample_fetch,
.channel_get = ina226_channel_get,
};
#define INA226_DRIVER_INIT(inst) \
static struct ina226_data ina226_data_##inst; \
static const struct ina226_config ina226_config_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
.current_lsb = DT_INST_PROP(inst, current_lsb_microamps), \
.cal = INA226_CAL_SCALING * 10000000ULL / \
(DT_INST_PROP(inst, current_lsb_microamps) * \
DT_INST_PROP(inst, rshunt_micro_ohms)), \
.config = (DT_INST_ENUM_IDX(inst, avg_count) << 9) | \
(DT_INST_ENUM_IDX(inst, vbus_conversion_time_us) << 6) | \
(DT_INST_ENUM_IDX(inst, vshunt_conversion_time_us) << 3) | \
DT_INST_ENUM_IDX(inst, operating_mode), \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
&ina226_init, \
NULL, \
&ina226_data_##inst, \
&ina226_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&ina226_driver_api);
DT_INST_FOREACH_STATUS_OKAY(INA226_DRIVER_INIT)
``` | /content/code_sandbox/drivers/sensor/ti/ina226/ina226.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,564 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_FDC2X1X_FDC2X1X_H_
#define ZEPHYR_DRIVERS_SENSOR_FDC2X1X_FDC2X1X_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#define PI (3.14159265)
/*
* FDC2X1X registers definition
*/
#define FDC2X1X_DATA_CH0 0x00
#define FDC2X1X_DATA_LSB_CH0 0x01
#define FDC2X1X_DATA_CH1 0x02
#define FDC2X1X_DATA_LSB_CH1 0x03
#define FDC2X1X_DATA_CH2 0x04
#define FDC2X1X_DATA_LSB_CH2 0x05
#define FDC2X1X_DATA_CH3 0x06
#define FDC2X1X_DATA_LSB_CH3 0x07
#define FDC2X1X_RCOUNT_CH0 0x08
#define FDC2X1X_RCOUNT_CH1 0x09
#define FDC2X1X_RCOUNT_CH2 0x0A
#define FDC2X1X_RCOUNT_CH3 0x0B
#define FDC2X1X_OFFSET_CH0 0x0C
#define FDC2X1X_OFFSET_CH1 0x0D
#define FDC2X1X_OFFSET_CH2 0x0E
#define FDC2X1X_OFFSET_CH3 0x0F
#define FDC2X1X_SETTLECOUNT_CH0 0x10
#define FDC2X1X_SETTLECOUNT_CH1 0x11
#define FDC2X1X_SETTLECOUNT_CH2 0x12
#define FDC2X1X_SETTLECOUNT_CH3 0x13
#define FDC2X1X_CLOCK_DIVIDERS_CH0 0x14
#define FDC2X1X_CLOCK_DIVIDERS_CH1 0x15
#define FDC2X1X_CLOCK_DIVIDERS_CH2 0x16
#define FDC2X1X_CLOCK_DIVIDERS_CH3 0x17
#define FDC2X1X_STATUS 0x18
#define FDC2X1X_ERROR_CONFIG 0x19
#define FDC2X1X_CONFIG 0x1A
#define FDC2X1X_MUX_CONFIG 0x1B
#define FDC2X1X_RESET_DEV 0x1C
#define FDC2X1X_DRIVE_CURRENT_CH0 0x1E
#define FDC2X1X_DRIVE_CURRENT_CH1 0x1F
#define FDC2X1X_DRIVE_CURRENT_CH2 0x20
#define FDC2X1X_DRIVE_CURRENT_CH3 0x21
#define FDC2X1X_MANUFACTURER_ID 0x7E
#define FDC2X1X_DEVICE_ID 0x7F
#define FDC2X1X_MANUFACTURER_ID_VAL 0x5449
#define FDC2X1X_DEVICE_ID_VAL_28BIT 0x3055
#define FDC2X1X_DEVICE_ID_VAL 0x3054
#define FDC2X1X_READ 0x01u
#define FDC2X1X_REG_READ(x) (((x & 0xFF) << 1) | FDC2X1X_READ)
#define FDC2X1X_REG_WRITE(x) ((x & 0xFF) << 1)
#define FDC2X1X_TO_I2C_REG(x) ((x) >> 1)
/* CLOCK_DIVIDERS_CHX Field Descriptions */
#define FDC2X1X_CLK_DIV_CHX_FIN_SEL_MSK GENMASK(13, 12)
#define FDC2X1X_CLK_DIV_CHX_FIN_SEL_SET(x) (((x) & 0x3) << 12)
#define FDC2X1X_CLK_DIV_CHX_FIN_SEL_GET(x) (((x) >> 12) & 0x3)
#define FDC2X1X_CLK_DIV_CHX_FREF_DIV_MSK GENMASK(9, 0)
#define FDC2X1X_CLK_DIV_CHX_FREF_DIV_SET(x) ((x) & 0x1FF)
#define FDC2X1X_CLK_DIV_CHX_FREF_DIV_GET(x) (((x) >> 0) & 0x1FF)
/* STATUS Field Descriptions */
#define FDC2X1X_STATUS_ERR_CHAN(x) (((x) >> 14) & 0x3)
#define FDC2X1X_STATUS_ERR_WD(x) (((x) >> 11) & 0x1)
#define FDC2X1X_STATUS_ERR_AHW(x) (((x) >> 10) & 0x1)
#define FDC2X1X_STATUS_ERR_ALW(x) (((x) >> 9) & 0x1)
#define FDC2X1X_STATUS_DRDY(x) (((x) >> 6) & 0x1)
#define FDC2X1X_STATUS_CH0_UNREADCONV_RDY(x) (((x) >> 3) & 0x1)
#define FDC2X1X_STATUS_CH1_UNREADCONV_RDY(x) (((x) >> 2) & 0x1)
#define FDC2X1X_STATUS_CH2_UNREADCONV_RDY(x) (((x) >> 1) & 0x1)
#define FDC2X1X_STATUS_CH3_UNREADCONV_RDY(x) (((x) >> 0) & 0x1)
/* ERROR_CONFIG */
#define FDC2X1X_ERROR_CONFIG_WD_ERR2OUT_MSK BIT(13)
#define FDC2X1X_ERROR_CONFIG_WD_ERR2OUT_SET(x) (((x) & 0x1) << 13)
#define FDC2X1X_ERROR_CONFIG_WD_ERR2OUT_GET(x) (((x) >> 13) & 0x1)
#define FDC2X1X_ERROR_CONFIG_AH_WARN2OUT_MSK BIT(12)
#define FDC2X1X_ERROR_CONFIG_AH_WARN2OUT_SET(x) (((x) & 0x1) << 12)
#define FDC2X1X_ERROR_CONFIG_AH_WARN2OUT_GET(x) (((x) >> 12) & 0x1)
#define FDC2X1X_ERROR_CONFIG_AL_WARN2OUT_MSK BIT(11)
#define FDC2X1X_ERROR_CONFIG_AL_WARN2OUT_SET(x) (((x) & 0x1) << 11)
#define FDC2X1X_ERROR_CONFIG_AL_WARN2OUT_GET(x) (((x) >> 11) & 0x1)
#define FDC2X1X_ERROR_CONFIG_WD_ERR2INT_MSK BIT(5)
#define FDC2X1X_ERROR_CONFIG_WD_ERR2INT_SET(x) (((x) & 0x1) << 5)
#define FDC2X1X_ERROR_CONFIG_WD_ERR2INT_GET(x) (((x) >> 5) & 0x1)
#define FDC2X1X_ERROR_CONFIG_DRDY_2INT_MSK BIT(0)
#define FDC2X1X_ERROR_CONFIG_DRDY_2INT_SET(x) (((x) & 0x1) << 0)
#define FDC2X1X_ERROR_CONFIG_DRDY_2INT_GET(x) (((x) >> 0) & 0x1)
/* CONFIG Field Descriptions */
#define FDC2X1X_CFG_ACTIVE_CHAN_MSK GENMASK(15, 14)
#define FDC2X1X_CFG_ACTIVE_CHAN_SET(x) (((x) & 0x3) << 14)
#define FDC2X1X_CFG_ACTIVE_CHAN_GET(x) (((x) >> 14) & 0x3)
#define FDC2X1X_CFG_SLEEP_SET_EN_MSK BIT(13)
#define FDC2X1X_CFG_SLEEP_SET_EN_SET(x) (((x) & 0x1) << 13)
#define FDC2X1X_CFG_SLEEP_SET_EN_GET(x) (((x) >> 13) & 0x1)
#define FDC2X1X_CFG_SENSOR_ACTIVATE_SEL_MSK BIT(11)
#define FDC2X1X_CFG_SENSOR_ACTIVATE_SEL_SET(x) (((x) & 0x1) << 11)
#define FDC2X1X_CFG_SENSOR_ACTIVATE_SEL_GET(x) (((x) >> 11) & 0x1)
#define FDC2X1X_CFG_REF_CLK_SRC_MSK BIT(9)
#define FDC2X1X_CFG_REF_CLK_SRC_SET(x) (((x) & 0x1) << 9)
#define FDC2X1X_CFG_REF_CLK_SRC_GET(x) (((x) >> 9) & 0x1)
#define FDC2X1X_CFG_INTB_DIS_MSK BIT(7)
#define FDC2X1X_CFG_INTB_DIS_SET(x) (((x) & 0x1) << 7)
#define FDC2X1X_CFG_INTB_DIS_GET(x) (((x) >> 7) & 0x1)
#define FDC2X1X_CFG_HIGH_CURRENT_DRV_MSK BIT(6)
#define FDC2X1X_CFG_HIGH_CURRENT_DRV_SET(x) (((x) & 0x1) << 6)
#define FDC2X1X_CFG_HIGH_CURRENT_DRV_GET(x) (((x) >> 6) & 0x1)
/* MUX_CONFIG Field Descriptions */
#define FDC2X1X_MUX_CFG_AUTOSCAN_EN_MSK BIT(15)
#define FDC2X1X_MUX_CFG_AUTOSCAN_EN_SET(x) (((x) & 0x1) << 15)
#define FDC2X1X_MUX_CFG_AUTOSCAN_EN_GET(x) (((x) >> 15) & 0x1)
#define FDC2X1X_MUX_CFG_RR_SEQUENCE_MSK GENMASK(14, 13)
#define FDC2X1X_MUX_CFG_RR_SEQUENCE_SET(x) (((x) & 0x3) << 13)
#define FDC2X1X_MUX_CFG_RR_SEQUENCE_GET(x) (((x) >> 13) & 0x3)
#define FDC2X1X_MUX_CFG_DEGLITCH_MSK GENMASK(2, 0)
#define FDC2X1X_MUX_CFG_DEGLITCH_SET(x) ((x) & 0x7)
#define FDC2X1X_MUX_CFG_DEGLITCH_GET(x) (((x) >> 0) & 0x7)
/* RESET_DEV Field Descriptions */
#define FDC2X1X_RESET_DEV_MSK BIT(15)
#define FDC2X1X_RESET_DEV_SET(x) (((x) & 0x1) << 15)
#define FDC2X1X_RESET_DEV_OUTPUT_GAIN_MSK GENMASK(10, 9)
#define FDC2X1X_RESET_DEV_OUTPUT_GAIN_SET(x) (((x) & 0x3) << 9)
#define FDC2X1X_RESET_DEV_OUTPUT_GAIN_GET(x) (((x) >> 9) & 0x3)
/* DRIVE_CURRENT_CHX Field Descriptions */
#define FDC2X1X_DRV_CURRENT_CHX_IDRIVE_MSK GENMASK(15, 11)
#define FDC2X1X_DRV_CURRENT_CHX_IDRIVE_SET(x) (((x) & 0x1F) << 11)
#define FDC2X1X_DRV_CURRENT_CHX_IDRIVE_GET(x) (((x) >> 11) & 0x1F)
enum fdc2x1x_op_mode {
FDC2X1X_ACTIVE_MODE,
FDC2X1X_SLEEP_MODE
};
struct fdc2x1x_data {
bool fdc221x;
#ifdef CONFIG_FDC2X1X_TRIGGER
struct gpio_callback gpio_cb;
uint16_t int_config;
struct k_mutex trigger_mutex;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trigger;
const struct device *dev;
#ifdef CONFIG_FDC2X1X_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_FDC2X1X_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif CONFIG_FDC2X1X_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
#endif /* CONFIG_FDC2X1X_TRIGGER */
uint32_t *channel_buf;
};
struct fdc2x1x_chx_config {
uint16_t rcount;
uint16_t offset;
uint16_t settle_count;
uint16_t fref_divider;
uint8_t idrive;
uint8_t fin_sel;
uint8_t inductance;
};
struct fdc2x1x_config {
struct i2c_dt_spec i2c;
struct gpio_dt_spec sd_gpio;
#ifdef CONFIG_FDC2X1X_TRIGGER
struct gpio_dt_spec intb_gpio;
#endif
bool fdc2x14;
uint8_t num_channels;
/* Device Settings */
bool autoscan_en;
uint8_t rr_sequence;
uint8_t active_channel;
uint8_t output_gain;
uint8_t deglitch;
uint8_t sensor_activate_sel;
uint8_t clk_src;
uint8_t current_drv;
uint16_t fref;
/* Channel Settings */
const struct fdc2x1x_chx_config *ch_cfg;
};
int fdc2x1x_set_interrupt_pin(const struct device *dev, bool enable);
int fdc2x1x_get_status(const struct device *dev, uint16_t *status);
int fdc2x1x_reg_write_mask(const struct device *dev, uint8_t reg_addr,
uint16_t mask, uint16_t data);
#ifdef CONFIG_FDC2X1X_TRIGGER
int fdc2x1x_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int fdc2x1x_init_interrupt(const struct device *dev);
#endif /* CONFIG_FDC2X1X_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_FDC2X1X_FDC2X1X_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/fdc2x1x/fdc2x1x.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,160 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_fdc2x1x
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "fdc2x1x.h"
#include <stdio.h>
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(FDC2X1X, CONFIG_SENSOR_LOG_LEVEL);
static void fdc2x1x_thread_cb(const struct device *dev)
{
struct fdc2x1x_data *drv_data = dev->data;
uint16_t status;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state state;
/* INTB asserts after exiting shutdown mode. Drop this interrupt */
(void)pm_device_state_get(dev, &state);
if (state == PM_DEVICE_STATE_OFF) {
return;
}
#endif
/* Clear the status */
if (fdc2x1x_get_status(dev, &status) < 0) {
LOG_ERR("Unable to get status.");
return;
}
k_mutex_lock(&drv_data->trigger_mutex, K_FOREVER);
if ((drv_data->drdy_handler != NULL) && FDC2X1X_STATUS_DRDY(status)) {
drv_data->drdy_handler(dev, drv_data->drdy_trigger);
}
k_mutex_unlock(&drv_data->trigger_mutex);
}
static void fdc2x1x_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct fdc2x1x_data *drv_data =
CONTAINER_OF(cb, struct fdc2x1x_data, gpio_cb);
#ifdef CONFIG_FDC2X1X_TRIGGER_OWN_THREAD
k_sem_give(&drv_data->gpio_sem);
#elif CONFIG_FDC2X1X_TRIGGER_GLOBAL_THREAD
k_work_submit(&drv_data->work);
#endif
}
#ifdef CONFIG_FDC2X1X_TRIGGER_OWN_THREAD
static void fdc2x1x_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct fdc2x1x_data *drv_data = p1;
while (true) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
fdc2x1x_thread_cb(drv_data->dev);
}
}
#elif CONFIG_FDC2X1X_TRIGGER_GLOBAL_THREAD
static void fdc2x1x_work_cb(struct k_work *work)
{
struct fdc2x1x_data *drv_data =
CONTAINER_OF(work, struct fdc2x1x_data, work);
fdc2x1x_thread_cb(drv_data->dev);
}
#endif
int fdc2x1x_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct fdc2x1x_data *drv_data = dev->data;
const struct fdc2x1x_config *cfg = dev->config;
uint16_t status, int_mask, int_en;
int ret;
gpio_pin_interrupt_configure_dt(&cfg->intb_gpio, GPIO_INT_DISABLE);
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
k_mutex_lock(&drv_data->trigger_mutex, K_FOREVER);
drv_data->drdy_handler = handler;
drv_data->drdy_trigger = trig;
k_mutex_unlock(&drv_data->trigger_mutex);
int_mask = FDC2X1X_ERROR_CONFIG_DRDY_2INT_MSK;
break;
default:
LOG_ERR("Unsupported sensor trigger");
ret = -ENOTSUP;
goto out;
}
if (handler) {
int_en = int_mask;
drv_data->int_config |= int_mask;
} else {
int_en = 0U;
}
ret = fdc2x1x_reg_write_mask(dev,
FDC2X1X_ERROR_CONFIG, int_mask, int_en);
/* Clear INTB pin by reading STATUS register */
fdc2x1x_get_status(dev, &status);
out:
gpio_pin_interrupt_configure_dt(&cfg->intb_gpio, GPIO_INT_EDGE_TO_ACTIVE);
return ret;
}
int fdc2x1x_init_interrupt(const struct device *dev)
{
struct fdc2x1x_data *drv_data = dev->data;
const struct fdc2x1x_config *cfg = dev->config;
int ret;
k_mutex_init(&drv_data->trigger_mutex);
if (!gpio_is_ready_dt(&cfg->intb_gpio)) {
LOG_ERR("%s: intb_gpio device not ready", cfg->intb_gpio.port->name);
return -ENODEV;
}
ret = fdc2x1x_set_interrupt_pin(dev, true);
if (ret) {
return ret;
}
gpio_pin_configure_dt(&cfg->intb_gpio, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb,
fdc2x1x_gpio_callback,
BIT(cfg->intb_gpio.pin));
if (gpio_add_callback(cfg->intb_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_ERR("Failed to set gpio callback!");
return -EIO;
}
drv_data->dev = dev;
#ifdef CONFIG_FDC2X1X_TRIGGER_OWN_THREAD
k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX);
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_FDC2X1X_THREAD_STACK_SIZE,
fdc2x1x_thread,
drv_data, 0, NULL,
K_PRIO_COOP(CONFIG_FDC2X1X_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif CONFIG_FDC2X1X_TRIGGER_GLOBAL_THREAD
drv_data->work.handler = fdc2x1x_work_cb;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/ti/fdc2x1x/fdc2x1x_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,261 |
```unknown
# FDC2X1X Capacitance-to-Digital Converter configuration options
menuconfig FDC2X1X
bool "FDC2X1X Capacitance-to-Digital Converter"
default y
depends on DT_HAS_TI_FDC2X1X_ENABLED
depends on FULL_LIBC_SUPPORTED || EXTERNAL_LIBC
select I2C
help
Enable driver for FDC2X1X Capacitance-to-Digital Converter.
if FDC2X1X
choice
prompt "Trigger mode"
default FDC2X1X_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config FDC2X1X_TRIGGER_NONE
bool "No trigger"
config FDC2X1X_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select FDC2X1X_TRIGGER
config FDC2X1X_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select FDC2X1X_TRIGGER
endchoice
config FDC2X1X_TRIGGER
bool
config FDC2X1X_THREAD_PRIORITY
int "Thread priority"
depends on FDC2X1X_TRIGGER_OWN_THREAD && FDC2X1X_TRIGGER
default 10
help
Priority of thread used by the driver to handle interrupts.
config FDC2X1X_THREAD_STACK_SIZE
int "Thread stack size"
depends on FDC2X1X_TRIGGER_OWN_THREAD && FDC2X1X_TRIGGER
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # FDC2X1X
``` | /content/code_sandbox/drivers/sensor/ti/fdc2x1x/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 352 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TMP116_TMP116_H_
#define ZEPHYR_DRIVERS_SENSOR_TMP116_TMP116_H_
#define TMP116_REG_TEMP 0x0
#define TMP116_REG_CFGR 0x1
#define TMP116_REG_HIGH_LIM 0x2
#define TMP116_REG_LOW_LIM 0x3
#define TMP116_REG_EEPROM_UL 0x4
#define TMP116_REG_EEPROM1 0x5
#define TMP116_REG_EEPROM2 0x6
#define TMP116_REG_EEPROM3 0x7
#define TMP117_REG_TEMP_OFFSET 0x7
#define TMP116_REG_EEPROM4 0x8
#define TMP116_REG_DEVICE_ID 0xF
#define TMP116_RESOLUTION 78125 /* in tens of uCelsius*/
#define TMP116_RESOLUTION_DIV 10000000
#define TMP116_DEVICE_ID 0x1116
#define TMP117_DEVICE_ID 0x0117
#define TMP116_CFGR_AVG (BIT(5) | BIT(6))
#define TMP116_CFGR_DATA_READY BIT(13)
#define TMP116_EEPROM_UL_UNLOCK BIT(15)
#define TMP116_EEPROM_UL_BUSY BIT(14)
#define TMP116_AVG_1_SAMPLE 0
#define TMP116_AVG_8_SAMPLES BIT(5)
#define TMP116_AVG_32_SAMPLES BIT(6)
#define TMP116_AVG_64_SAMPLES (BIT(5) | BIT(6))
struct tmp116_data {
uint16_t sample;
uint16_t id;
};
struct tmp116_dev_config {
struct i2c_dt_spec bus;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_TMP116_TMP116_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/tmp116/tmp116.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 378 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmp116
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/tmp116.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include "tmp116.h"
#define EEPROM_SIZE_REG sizeof(uint16_t)
#define EEPROM_TMP117_RESERVED (2 * sizeof(uint16_t))
#define EEPROM_MIN_BUSY_MS 7
LOG_MODULE_REGISTER(TMP116, CONFIG_SENSOR_LOG_LEVEL);
static int tmp116_reg_read(const struct device *dev, uint8_t reg,
uint16_t *val)
{
const struct tmp116_dev_config *cfg = dev->config;
if (i2c_burst_read_dt(&cfg->bus, reg, (uint8_t *)val, 2)
< 0) {
return -EIO;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
static int tmp116_reg_write(const struct device *dev, uint8_t reg,
uint16_t val)
{
const struct tmp116_dev_config *cfg = dev->config;
uint8_t tx_buf[3] = {reg, val >> 8, val & 0xFF};
return i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
}
int tmp116_write_config(const struct device *dev, uint16_t mask, uint16_t conf)
{
uint16_t config = 0;
int result;
result = tmp116_reg_read(dev, TMP116_REG_CFGR, &config);
if (result < 0) {
return result;
}
config &= ~mask;
config |= conf;
return tmp116_reg_write(dev, TMP116_REG_CFGR, config);
}
static bool check_eeprom_bounds(const struct device *dev, off_t offset,
size_t len)
{
struct tmp116_data *drv_data = dev->data;
if ((offset + len) > EEPROM_TMP116_SIZE ||
offset % EEPROM_SIZE_REG != 0 ||
len % EEPROM_SIZE_REG != 0) {
return false;
}
/* TMP117 uses EEPROM[2] as temperature offset register */
if (drv_data->id == TMP117_DEVICE_ID &&
offset <= EEPROM_TMP117_RESERVED &&
(offset + len) > EEPROM_TMP117_RESERVED) {
return false;
}
return true;
}
int tmp116_eeprom_write(const struct device *dev, off_t offset,
const void *data, size_t len)
{
uint8_t reg;
const uint16_t *src = data;
int res;
if (!check_eeprom_bounds(dev, offset, len)) {
return -EINVAL;
}
res = tmp116_reg_write(dev, TMP116_REG_EEPROM_UL, TMP116_EEPROM_UL_UNLOCK);
if (res) {
return res;
}
for (reg = (offset / 2); reg < offset / 2 + len / 2; reg++) {
uint16_t val = *src;
res = tmp116_reg_write(dev, reg + TMP116_REG_EEPROM1, val);
if (res != 0) {
break;
}
k_sleep(K_MSEC(EEPROM_MIN_BUSY_MS));
do {
res = tmp116_reg_read(dev, TMP116_REG_EEPROM_UL, &val);
if (res != 0) {
break;
}
} while (val & TMP116_EEPROM_UL_BUSY);
src++;
if (res != 0) {
break;
}
}
res = tmp116_reg_write(dev, TMP116_REG_EEPROM_UL, 0);
return res;
}
int tmp116_eeprom_read(const struct device *dev, off_t offset, void *data,
size_t len)
{
uint8_t reg;
uint16_t *dst = data;
int res = 0;
if (!check_eeprom_bounds(dev, offset, len)) {
return -EINVAL;
}
for (reg = (offset / 2); reg < offset / 2 + len / 2; reg++) {
res = tmp116_reg_read(dev, reg + TMP116_REG_EEPROM1, dst);
if (res != 0) {
break;
}
dst++;
}
return res;
}
/**
* @brief Check the Device ID
*
* @param[in] dev Pointer to the device structure
* @param[in] id Pointer to the variable for storing the device id
*
* @retval 0 on success
* @retval -EIO Otherwise
*/
static inline int tmp116_device_id_check(const struct device *dev, uint16_t *id)
{
if (tmp116_reg_read(dev, TMP116_REG_DEVICE_ID, id) != 0) {
LOG_ERR("%s: Failed to get Device ID register!",
dev->name);
return -EIO;
}
if ((*id != TMP116_DEVICE_ID) && (*id != TMP117_DEVICE_ID)) {
LOG_ERR("%s: Failed to match the device IDs!",
dev->name);
return -EINVAL;
}
return 0;
}
static int tmp116_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct tmp116_data *drv_data = dev->data;
uint16_t value;
uint16_t cfg_reg = 0;
int rc;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_AMBIENT_TEMP);
/* clear sensor values */
drv_data->sample = 0U;
/* Make sure that a data is available */
rc = tmp116_reg_read(dev, TMP116_REG_CFGR, &cfg_reg);
if (rc < 0) {
LOG_ERR("%s, Failed to read from CFGR register",
dev->name);
return rc;
}
if ((cfg_reg & TMP116_CFGR_DATA_READY) == 0) {
LOG_DBG("%s: no data ready", dev->name);
return -EBUSY;
}
/* Get the most recent temperature measurement */
rc = tmp116_reg_read(dev, TMP116_REG_TEMP, &value);
if (rc < 0) {
LOG_ERR("%s: Failed to read from TEMP register!",
dev->name);
return rc;
}
/* store measurements to the driver */
drv_data->sample = (int16_t)value;
return 0;
}
static int tmp116_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct tmp116_data *drv_data = dev->data;
int32_t tmp;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
/*
* See datasheet "Temperature Results and Limits" section for more
* details on processing sample data.
*/
tmp = ((int16_t)drv_data->sample * (int32_t)TMP116_RESOLUTION) / 10;
val->val1 = tmp / 1000000; /* uCelsius */
val->val2 = tmp % 1000000;
return 0;
}
static int tmp116_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct tmp116_data *drv_data = dev->data;
int16_t value;
uint16_t avg;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_OFFSET:
if (drv_data->id != TMP117_DEVICE_ID) {
LOG_ERR("%s: Offset is only supported by TMP117",
dev->name);
return -EINVAL;
}
/*
* The offset is encoded into the temperature register format.
*/
value = (((val->val1) * 10000000) + ((val->val2) * 10))
/ (int32_t)TMP116_RESOLUTION;
return tmp116_reg_write(dev, TMP117_REG_TEMP_OFFSET, value);
case SENSOR_ATTR_OVERSAMPLING:
/* sensor supports averaging 1, 8, 32 and 64 samples */
switch (val->val1) {
case 1:
avg = TMP116_AVG_1_SAMPLE;
break;
case 8:
avg = TMP116_AVG_8_SAMPLES;
break;
case 32:
avg = TMP116_AVG_32_SAMPLES;
break;
case 64:
avg = TMP116_AVG_64_SAMPLES;
break;
default:
return -EINVAL;
}
return tmp116_write_config(dev, TMP116_CFGR_AVG, avg);
default:
return -ENOTSUP;
}
}
static int tmp116_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
uint16_t data;
int rc;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
rc = tmp116_reg_read(dev, TMP116_REG_CFGR, &data);
if (rc < 0) {
return rc;
}
break;
default:
return -ENOTSUP;
}
val->val1 = data;
val->val2 = 0;
return 0;
}
static const struct sensor_driver_api tmp116_driver_api = {
.attr_set = tmp116_attr_set,
.attr_get = tmp116_attr_get,
.sample_fetch = tmp116_sample_fetch,
.channel_get = tmp116_channel_get
};
static int tmp116_init(const struct device *dev)
{
struct tmp116_data *drv_data = dev->data;
const struct tmp116_dev_config *cfg = dev->config;
int rc;
uint16_t id;
if (!device_is_ready(cfg->bus.bus)) {
LOG_ERR("I2C dev %s not ready", cfg->bus.bus->name);
return -EINVAL;
}
/* Check the Device ID */
rc = tmp116_device_id_check(dev, &id);
if (rc < 0) {
return rc;
}
LOG_DBG("Got device ID: %x", id);
drv_data->id = id;
return 0;
}
#define DEFINE_TMP116(_num) \
static struct tmp116_data tmp116_data_##_num; \
static const struct tmp116_dev_config tmp116_config_##_num = { \
.bus = I2C_DT_SPEC_INST_GET(_num) \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(_num, tmp116_init, NULL, \
&tmp116_data_##_num, &tmp116_config_##_num, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tmp116_driver_api);
DT_INST_FOREACH_STATUS_OKAY(DEFINE_TMP116)
``` | /content/code_sandbox/drivers/sensor/ti/tmp116/tmp116.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,343 |
```unknown
# TMP116 temperature sensor configuration options
config TMP116
bool "TMP116 and TMP117 Temperature Sensors"
default y
depends on DT_HAS_TI_TMP116_ENABLED
select I2C
help
Enable driver for TMP116 and TMP117 temperature sensors.
``` | /content/code_sandbox/drivers/sensor/ti/tmp116/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 55 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_INA219_INA219_H_
#define ZEPHYR_DRIVERS_SENSOR_INA219_INA219_H_
/* Device register addresses */
#define INA219_REG_CONF 0x00
#define INA219_REG_V_SHUNT 0x01
#define INA219_REG_V_BUS 0x02
#define INA219_REG_POWER 0x03
#define INA219_REG_CURRENT 0x04
#define INA219_REG_CALIB 0x05
/* Config register shifts and masks */
#define INA219_RST BIT(15)
#define INA219_BRNG_MASK 0x1
#define INA219_BRNG_SHIFT 13
#define INA219_PG_MASK 0x3
#define INA219_PG_SHIFT 11
#define INA219_ADC_MASK 0xF
#define INA219_BADC_SHIFT 7
#define INA219_SADC_SHIFT 3
#define INA219_MODE_MASK 0x7
/* Bus voltage register */
#define INA219_VBUS_GET(x) ((x) >> 3) & 0x3FFF
#define INA219_CNVR_RDY(x) ((x) >> 1) & 0x1
#define INA219_OVF_STATUS(x) x & 0x1
/* Mode fields */
#define INA219_MODE_NORMAL 0x3 /* shunt and bus, triggered */
#define INA219_MODE_SLEEP 0x4 /* ADC off */
#define INA219_MODE_OFF 0x0 /* Power off */
/* Others */
#define INA219_SIGN_BIT(x) ((x) >> 15) & 0x1
#define INA219_V_BUS_MUL 0.004
#define INA219_SI_MUL 0.00001
#define INA219_POWER_MUL 20
#define INA219_WAIT_STARTUP 40
#define INA219_WAIT_MSR_RETRY 100
#define INA219_SCALING_FACTOR 4096000
struct ina219_config {
struct i2c_dt_spec bus;
uint16_t current_lsb;
uint16_t r_shunt;
uint8_t brng;
uint8_t pg;
uint8_t badc;
uint8_t sadc;
uint8_t mode;
};
struct ina219_data {
uint16_t config;
uint16_t v_bus;
uint16_t power;
uint16_t current;
uint16_t calib;
uint32_t msr_delay;
};
static int ina219_init(const struct device *dev);
static inline int ina219_conv_delay(uint8_t delay_idx)
{
switch (delay_idx) {
case 0:
return 84;
case 1:
return 148;
case 2:
return 276;
case 3:
return 532;
case 9:
return 1060;
case 10:
return 2013;
case 11:
return 4260;
case 12:
return 8510;
case 13:
return 17020;
case 14:
return 34050;
case 15:
return 68100;
default:
return -EINVAL;
}
}
#endif /* ZEPHYR_DRIVERS_SENSOR_INA219_INA219_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/ina219/ina219.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 665 |
```c
/* fdc2x1x.c - Driver for the Texas Instruments FDC2X1X */
/*
*
*/
#define DT_DRV_COMPAT ti_fdc2x1x
#include <zephyr/device.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
#include <math.h>
#include "fdc2x1x.h"
#include <zephyr/drivers/sensor/fdc2x1x.h>
LOG_MODULE_REGISTER(FDC2X1X, CONFIG_SENSOR_LOG_LEVEL);
static int fdc2x1x_init_config(const struct device *dev);
/**
* Convert raw data to frequency (MHz).
* @param dev - The device structure.
* @param ch - Channel to convert the data from.
* @param freq - Calculated frequency value .
*/
static void fdc2x1x_raw_to_freq(const struct device *dev,
uint8_t ch, double *freq)
{
struct fdc2x1x_data *data = dev->data;
const struct fdc2x1x_config *cfg = dev->config;
if (data->fdc221x) {
*freq = (cfg->ch_cfg->fin_sel * (cfg->fref / 1000.0) *
data->channel_buf[ch]) / pow(2, 28);
} else {
*freq = cfg->ch_cfg->fin_sel * (cfg->fref / 1000.0) *
((data->channel_buf[ch] / pow(2, 12 + cfg->output_gain)) +
(cfg->ch_cfg[ch].offset / pow(2, 16)));
}
}
/**
* Convert raw data to capacitance in picofarad (pF).
* Requires the previous conversion from raw to frequency.
* @param dev - The device structure.
* @param ch - Channel to convert the data from .
* @param freq - Frequency value
* @param capacitance - Calculated capacitance value
*/
static void fdc2x1x_raw_to_capacitance(const struct device *dev,
uint8_t ch, double freq, double *capacitance)
{
const struct fdc2x1x_config *cfg = dev->config;
*capacitance = 1 / ((cfg->ch_cfg->inductance / 1000000.0) *
pow((2 * PI * freq), 2));
}
/**
* Read/Write from device.
* @param dev - The device structure.
* @param reg - The register address. Use FDC2X1X_REG_READ(x) or
* FDC2X1X_REG_WRITE(x).
* @param data - The register data.
* @param length - Number of bytes being read
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_bus_access(const struct device *dev, uint8_t reg,
uint8_t *data, size_t length)
{
const struct fdc2x1x_config *cfg = dev->config;
if (reg & FDC2X1X_READ) {
return i2c_burst_read_dt(&cfg->i2c, FDC2X1X_TO_I2C_REG(reg), data, length);
} else {
if (length != 2) {
return -EINVAL;
}
uint8_t buf[3];
buf[0] = FDC2X1X_TO_I2C_REG(reg);
memcpy(buf + 1, data, sizeof(uint16_t));
return i2c_write_dt(&cfg->i2c, buf, sizeof(buf));
}
}
/**
* Read (16 Bit) from device.
* @param dev - The device structure.
* @param reg_addr - The register address.
* @param reg_data - The register data.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_reg_read(const struct device *dev,
uint8_t reg_addr,
uint16_t *reg_data)
{
uint8_t buf[2];
int ret;
ret = fdc2x1x_bus_access(dev, FDC2X1X_REG_READ(reg_addr), buf, 2);
*reg_data = ((uint16_t)buf[0] << 8) | buf[1];
return ret;
}
/**
* Write (16 Bit) to device.
* @param dev - The device structure.
* @param reg_addr - The register address.
* @param reg_data - The register data.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_reg_write(const struct device *dev,
uint8_t reg_addr,
uint16_t reg_data)
{
LOG_DBG("[0x%x] = 0x%x", reg_addr, reg_data);
uint8_t buf[2];
buf[0] = (uint8_t)(reg_data >> 8);
buf[1] = (uint8_t)reg_data;
return fdc2x1x_bus_access(dev, FDC2X1X_REG_WRITE(reg_addr), buf, 2);
}
/**
* I2C write (16 Bit) to device using a mask.
* @param dev - The device structure.
* @param reg_addr - The register address.
* @param mask - The mask.
* @param data - The register data.
* @return 0 in case of success, negative error code otherwise.
*/
int fdc2x1x_reg_write_mask(const struct device *dev,
uint8_t reg_addr,
uint16_t mask,
uint16_t data)
{
int ret;
uint16_t tmp;
ret = fdc2x1x_reg_read(dev, reg_addr, &tmp);
if (ret) {
return ret;
}
LOG_DBG("read [0x%x] = 0x%x", reg_addr, tmp);
LOG_DBG("mask: 0x%x", mask);
tmp &= ~mask;
tmp |= data;
return fdc2x1x_reg_write(dev, reg_addr, tmp);
}
/**
* Set the Frequency Selection value of a specific channel.
* @param dev - The device structure.
* @param chx - Channel number.
* @param fin_sel - Frequency selection value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_fin_sel(const struct device *dev, uint8_t chx,
uint8_t fin_sel)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CLOCK_DIVIDERS_CH0 + chx,
FDC2X1X_CLK_DIV_CHX_FIN_SEL_MSK,
FDC2X1X_CLK_DIV_CHX_FIN_SEL_SET(fin_sel));
}
/**
* Set the Reference Divider value of a specific channel.
* @param dev - The device structure.
* @param chx - Channel number.
* @param fref_div - Reference divider value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_fref_divider(const struct device *dev, uint8_t chx,
uint16_t fref_div)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CLOCK_DIVIDERS_CH0 + chx,
FDC2X1X_CLK_DIV_CHX_FREF_DIV_MSK,
FDC2X1X_CLK_DIV_CHX_FREF_DIV_SET(fref_div));
}
/**
* Set the Drive Current value of a specific channel.
* @param dev - The device structure.
* @param chx - Channel number.
* @param idrv - Sensor driver current.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_idrive(const struct device *dev, uint8_t chx,
uint8_t idrv)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_DRIVE_CURRENT_CH0 + chx,
FDC2X1X_DRV_CURRENT_CHX_IDRIVE_MSK,
FDC2X1X_DRV_CURRENT_CHX_IDRIVE_SET(idrv));
}
/**
* Set the Conversion Settling value of a specific channel.
* @param dev - The device structure.
* @param chx - Channel number.
* @param settle_count - Settling time value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_settle_count(const struct device *dev, uint8_t chx,
uint16_t settle_count)
{
return fdc2x1x_reg_write(dev,
FDC2X1X_SETTLECOUNT_CH0 + chx, settle_count);
}
/**
* Set the Reference Count value of a specific channel.
* @param dev - The device structure.
* @param chx - Channel number.
* @param rcount - Reference count value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_rcount(const struct device *dev,
uint8_t chx, uint16_t rcount)
{
return fdc2x1x_reg_write(dev, FDC2X1X_RCOUNT_CH0 + chx, rcount);
}
/**
* Set the Offset value of a specific channel.
* @param dev - The device structure.
* @param chx - Channel number.
* @param offset - Offset value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_offset(const struct device *dev,
uint8_t chx, uint16_t offset)
{
return fdc2x1x_reg_write(dev, FDC2X1X_OFFSET_CH0 + chx, offset);
}
/**
* Set the Auto-Scan Mode.
* @param dev - The device structure.
* @param en - Enable/disable auto-scan mode.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_autoscan_mode(const struct device *dev, bool en)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_MUX_CONFIG,
FDC2X1X_MUX_CFG_AUTOSCAN_EN_MSK,
FDC2X1X_MUX_CFG_AUTOSCAN_EN_SET(en));
}
/**
* Set the Auto-Scan Sequence Configuration.
* @param dev - The device structure.
* @param rr_seq - Auto-Scan sequence value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_rr_sequence(const struct device *dev, uint8_t rr_seq)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_MUX_CONFIG,
FDC2X1X_MUX_CFG_RR_SEQUENCE_MSK,
FDC2X1X_MUX_CFG_RR_SEQUENCE_SET(rr_seq));
}
/**
* Set the Input deglitch filter bandwidth.
* @param dev - The device structure.
* @param deglitch - Deglitch selection.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_deglitch(const struct device *dev, uint8_t deglitch)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_MUX_CONFIG,
FDC2X1X_MUX_CFG_DEGLITCH_MSK,
FDC2X1X_MUX_CFG_DEGLITCH_SET(deglitch));
}
/**
* Set the Output gain control.
* @param dev - The device structure.
* @param gain - Output gain.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_output_gain(const struct device *dev, uint8_t gain)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_RESET_DEV,
FDC2X1X_RESET_DEV_OUTPUT_GAIN_MSK,
FDC2X1X_RESET_DEV_OUTPUT_GAIN_SET(gain));
}
/**
* Set the Active Channel for single channel
* conversion if Auto-Scan Mode is disabled.
* @param dev - The device structure.
* @param ch - Active channel.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_active_channel(const struct device *dev, uint8_t ch)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CONFIG,
FDC2X1X_CFG_ACTIVE_CHAN_MSK,
FDC2X1X_CFG_ACTIVE_CHAN_SET(ch));
}
/**
* Set the Sensor Activation Mode Selection.
* @param dev - The device structure.
* @param act_sel - Sensor Activation Mode Selection.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_sensor_activate_sel(const struct device *dev,
uint8_t act_sel)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CONFIG,
FDC2X1X_CFG_SENSOR_ACTIVATE_SEL_MSK,
FDC2X1X_CFG_SENSOR_ACTIVATE_SEL_SET(act_sel));
}
/**
* Set the Reference Frequency Source.
* @param dev - The device structure.
* @param clk_src - Clock source.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_ref_clk_src(const struct device *dev, uint8_t clk_src)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CONFIG,
FDC2X1X_CFG_REF_CLK_SRC_MSK,
FDC2X1X_CFG_REF_CLK_SRC_SET(clk_src));
}
/**
* Set the Current Sensor Drive.
* @param dev - The device structure.
* @param cur_drv - Current Sensor Drive.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_current_drv(const struct device *dev, uint8_t cur_drv)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CONFIG,
FDC2X1X_CFG_HIGH_CURRENT_DRV_MSK,
FDC2X1X_CFG_HIGH_CURRENT_DRV_SET(cur_drv));
}
/**
* Enable/disable the INTB-Pin interrupt assertion.
* @param dev - The device structure.
* @param enable - True = enable int assertion, false = disable int assertion.
* @return 0 in case of success, negative error code otherwise.
*/
int fdc2x1x_set_interrupt_pin(const struct device *dev, bool enable)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CONFIG,
FDC2X1X_CFG_INTB_DIS_MSK,
FDC2X1X_CFG_INTB_DIS_SET(!enable));
}
/**
* Set the Operation Mode
* @param dev - The device structure.
* @param op_mode - Operation mode
* @return 0 in case of success, negative error code otherwise.
*/
int fdc2x1x_set_op_mode(const struct device *dev,
enum fdc2x1x_op_mode op_mode)
{
return fdc2x1x_reg_write_mask(dev,
FDC2X1X_CONFIG,
FDC2X1X_CFG_SLEEP_SET_EN_MSK,
FDC2X1X_CFG_SLEEP_SET_EN_SET(op_mode));
}
/**
* Get the STATUS register data
* @param dev - The device structure.
* @param status - Data stored in the STATUS register
* @return 0 in case of success, negative error code otherwise.
*/
int fdc2x1x_get_status(const struct device *dev, uint16_t *status)
{
return fdc2x1x_reg_read(dev, FDC2X1X_STATUS, status);
}
/**
* Reset the device.
* @param dev - The device structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_reset(const struct device *dev)
{
int ret;
ret = fdc2x1x_reg_write_mask(dev,
FDC2X1X_RESET_DEV,
FDC2X1X_RESET_DEV_MSK,
FDC2X1X_RESET_DEV_SET(1));
return ret;
}
#ifdef CONFIG_PM_DEVICE
/**
* Reinitialize device after exiting shutdown mode
* @param dev - The device structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_restart(const struct device *dev)
{
int ret;
k_sleep(K_MSEC(100));
ret = fdc2x1x_init_config(dev);
if (ret) {
LOG_ERR("Reinitializing failed");
return ret;
}
#ifdef CONFIG_FDC2X1X_TRIGGER
struct fdc2x1x_data *data = dev->data;
ret = fdc2x1x_reg_write_mask(dev, FDC2X1X_ERROR_CONFIG,
data->int_config, data->int_config);
if (ret) {
LOG_ERR("Reinitializing trigger failed");
return ret;
}
#endif
return 0;
}
/**
* Enable/disable Shutdown Mode
* @param dev - The device structure.
* @param enable - True = enable shutdown, false = disable shutdown
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_set_shutdown(const struct device *dev, bool enable)
{
const struct fdc2x1x_config *cfg = dev->config;
int ret = 0;
gpio_pin_set_dt(&cfg->sd_gpio, enable);
if (!enable) {
ret = fdc2x1x_restart(dev);
}
return ret;
}
/**
* Set the Device Power Management State.
* @param dev - The device structure.
* @param pm_state - power management state
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_device_pm_action(const struct device *dev,
enum pm_device_action action)
{
int ret;
const struct fdc2x1x_config *cfg = dev->config;
enum pm_device_state curr_state;
(void)pm_device_state_get(dev, &curr_state);
switch (action) {
case PM_DEVICE_ACTION_RESUME:
if (curr_state == PM_DEVICE_STATE_OFF) {
ret = fdc2x1x_set_shutdown(dev, false);
if (ret) {
return ret;
}
}
ret = fdc2x1x_set_op_mode(dev, FDC2X1X_ACTIVE_MODE);
if (ret) {
return ret;
}
break;
case PM_DEVICE_ACTION_SUSPEND:
if (curr_state == PM_DEVICE_STATE_OFF) {
ret = fdc2x1x_set_shutdown(dev, false);
if (ret) {
return ret;
}
}
ret = fdc2x1x_set_op_mode(dev, FDC2X1X_SLEEP_MODE);
if (ret) {
return ret;
}
break;
case PM_DEVICE_ACTION_TURN_OFF:
if (cfg->sd_gpio.port->name) {
ret = fdc2x1x_set_shutdown(dev, true);
} else {
LOG_ERR("SD pin not defined");
ret = -ENOTSUP;
}
break;
default:
return -ENOTSUP;
}
return ret;
}
#endif
/**
* Set attributes for the device.
* @param dev - The device structure.
* @param chan - The sensor channel type.
* @param attr - The sensor attribute.
* @param value - The sensor attribute value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
return -ENOTSUP;
}
/**
* Read sensor data from the device.
* @param dev - The device structure.
* @param cap_data - The sensor value data.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_get_cap_data(const struct device *dev)
{
uint8_t increment_steps;
int i;
const struct fdc2x1x_config *cfg = dev->config;
struct fdc2x1x_data *data = dev->data;
uint8_t reg_addr = FDC2X1X_DATA_CH0;
uint8_t buf_size = cfg->num_channels;
if (data->fdc221x) {
buf_size *= 2;
increment_steps = 1;
} else {
increment_steps = 2;
}
uint16_t buf[buf_size];
#ifdef CONFIG_FDC2X1X_TRIGGER_NONE
uint16_t status;
do {
fdc2x1x_get_status(dev, &status);
} while (!(FDC2X1X_STATUS_DRDY(status)));
#endif
for (i = 0; i < buf_size; i++) {
if (fdc2x1x_reg_read(dev, reg_addr, &buf[i]) < 0) {
LOG_ERR("Failed to read reg 0x%x", reg_addr);
return -EIO;
}
reg_addr += increment_steps;
}
for (i = 0; i < cfg->num_channels; i++) {
if (data->fdc221x) {
data->channel_buf[i] = buf[i * 2] << 16 | buf[i * 2 + 1];
} else {
data->channel_buf[i] = buf[i];
}
}
return 0;
}
/**
* Fetch sensor data from the device.
* @param dev - The device structure.
* @param chan - The sensor channel type.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
#ifdef CONFIG_PM_DEVICE
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
LOG_ERR("Sample fetch failed, device is not in active mode");
return -ENXIO;
}
#endif
return fdc2x1x_get_cap_data(dev);
}
/**
* Get sensor channel value from the device.
* @param dev - The device structure.
* @param chan - The sensor channel type.
* @param val - The sensor channel value.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct fdc2x1x_config *cfg = dev->config;
double ch_data;
switch ((int16_t)chan) {
case SENSOR_CHAN_FDC2X1X_FREQ_CH0:
fdc2x1x_raw_to_freq(dev, 0, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
break;
case SENSOR_CHAN_FDC2X1X_FREQ_CH1:
if (cfg->num_channels >= 2) {
fdc2x1x_raw_to_freq(dev, 1, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
} else {
LOG_ERR("CH1 not defined.");
return -ENOTSUP;
}
break;
case SENSOR_CHAN_FDC2X1X_FREQ_CH2:
if (cfg->num_channels >= 3) {
fdc2x1x_raw_to_freq(dev, 2, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
} else {
LOG_ERR("CH2 not selected or not supported by device.");
return -ENOTSUP;
}
break;
case SENSOR_CHAN_FDC2X1X_FREQ_CH3:
if (cfg->num_channels == 4) {
fdc2x1x_raw_to_freq(dev, 3, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
} else {
LOG_ERR("CH3 not selected or not supported by device.");
return -ENOTSUP;
}
break;
case SENSOR_CHAN_FDC2X1X_CAPACITANCE_CH0:
fdc2x1x_raw_to_freq(dev, 0, &ch_data);
fdc2x1x_raw_to_capacitance(dev, 0, ch_data, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
break;
case SENSOR_CHAN_FDC2X1X_CAPACITANCE_CH1:
if (cfg->num_channels >= 2) {
fdc2x1x_raw_to_freq(dev, 1, &ch_data);
fdc2x1x_raw_to_capacitance(dev, 1, ch_data, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
} else {
LOG_ERR("CH1 not selected or not supported by device.");
return -ENOTSUP;
}
break;
case SENSOR_CHAN_FDC2X1X_CAPACITANCE_CH2:
if (cfg->num_channels >= 3) {
fdc2x1x_raw_to_freq(dev, 2, &ch_data);
fdc2x1x_raw_to_capacitance(dev, 2, ch_data, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
} else {
LOG_ERR("CH3 not selected or not supported by device.");
return -ENOTSUP;
}
break;
case SENSOR_CHAN_FDC2X1X_CAPACITANCE_CH3:
if (cfg->num_channels >= 4) {
fdc2x1x_raw_to_freq(dev, 3, &ch_data);
fdc2x1x_raw_to_capacitance(dev, 3, ch_data, &ch_data);
val->val1 = (uint32_t)ch_data;
val->val2 = ((uint32_t)(ch_data * 1000000)) % 1000000;
} else {
LOG_ERR("CH3 not selected or not supported by device.");
return -ENOTSUP;
}
break;
default:
LOG_ERR("Channel type not supported.");
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api fdc2x1x_api_funcs = {
.attr_set = fdc2x1x_attr_set,
.sample_fetch = fdc2x1x_sample_fetch,
.channel_get = fdc2x1x_channel_get,
#ifdef CONFIG_FDC2X1X_TRIGGER
.trigger_set = fdc2x1x_trigger_set,
#endif
};
static int fdc2x1x_init_config(const struct device *dev)
{
int ret;
int ch;
const struct fdc2x1x_config *cfg = dev->config;
struct fdc2x1x_data *data = dev->data;
/* Channel specific settings */
for (ch = 0; ch < cfg->num_channels; ch++) {
ret = fdc2x1x_set_fin_sel(dev, ch, cfg->ch_cfg[ch].fin_sel);
if (ret) {
return ret;
}
ret = fdc2x1x_set_fref_divider(dev, ch,
cfg->ch_cfg[ch].fref_divider);
if (ret) {
return ret;
}
ret = fdc2x1x_set_idrive(dev, ch, cfg->ch_cfg[ch].idrive);
if (ret) {
return ret;
}
ret = fdc2x1x_set_settle_count(dev, ch,
cfg->ch_cfg[ch].settle_count);
if (ret) {
return ret;
}
ret = fdc2x1x_set_rcount(dev, ch, cfg->ch_cfg[ch].rcount);
if (ret) {
return ret;
}
if (!data->fdc221x) {
ret = fdc2x1x_set_offset(dev, ch,
cfg->ch_cfg[ch].offset);
if (ret) {
return ret;
}
}
}
ret = fdc2x1x_set_autoscan_mode(dev, cfg->autoscan_en);
if (ret) {
return ret;
}
ret = fdc2x1x_set_rr_sequence(dev, cfg->rr_sequence);
if (ret) {
return ret;
}
ret = fdc2x1x_set_deglitch(dev, cfg->deglitch);
if (ret) {
return ret;
}
if (!data->fdc221x) {
ret = fdc2x1x_set_output_gain(dev, cfg->output_gain);
if (ret) {
return ret;
}
}
ret = fdc2x1x_set_active_channel(dev, cfg->active_channel);
if (ret) {
return ret;
}
ret = fdc2x1x_set_sensor_activate_sel(dev, cfg->sensor_activate_sel);
if (ret) {
return ret;
}
ret = fdc2x1x_set_ref_clk_src(dev, cfg->clk_src);
if (ret) {
return ret;
}
#ifdef CONFIG_FDC2X1X_TRIGGER_NONE
/* Enable Data Ready Flag to poll for new measurement */
ret = fdc2x1x_reg_write_mask(dev, FDC2X1X_ERROR_CONFIG,
FDC2X1X_ERROR_CONFIG_DRDY_2INT_MSK,
FDC2X1X_ERROR_CONFIG_DRDY_2INT_SET(1));
if (ret) {
return ret;
}
/* INTB asserts by default, so disable it here */
ret = fdc2x1x_set_interrupt_pin(dev, false);
if (ret) {
return ret;
}
#endif
ret = fdc2x1x_set_current_drv(dev, cfg->current_drv);
if (ret) {
return ret;
}
return 0;
}
/**
* Probe device (Check if it is the correct device).
* @param dev - The device structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_probe(const struct device *dev)
{
struct fdc2x1x_data *data = dev->data;
uint16_t dev_id, man_id;
if (fdc2x1x_reg_read(dev, FDC2X1X_DEVICE_ID, &dev_id) < 0) {
LOG_ERR("Failed to read device id");
return -EIO;
}
if (dev_id == FDC2X1X_DEVICE_ID_VAL_28BIT) {
data->fdc221x = true;
} else if (dev_id == FDC2X1X_DEVICE_ID_VAL) {
data->fdc221x = false;
} else {
LOG_ERR("Wrong device id");
return -ENODEV;
}
if (data->fdc221x) {
printk("is 28bit\n");
} else {
printk("is 12bit\n");
}
if (fdc2x1x_reg_read(dev, FDC2X1X_MANUFACTURER_ID, &man_id) < 0) {
LOG_ERR("Failed to read manufacturer id");
return -EIO;
}
if (man_id != FDC2X1X_MANUFACTURER_ID_VAL) {
LOG_ERR("Wrong manufacturer id");
return -ENODEV;
}
return 0;
}
/**
* Initialize the SD-Pin.
* @param dev - The device structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_init_sd_pin(const struct device *dev)
{
const struct fdc2x1x_config *cfg = dev->config;
if (!gpio_is_ready_dt(&cfg->sd_gpio)) {
LOG_ERR("%s: sd_gpio device not ready", cfg->sd_gpio.port->name);
return -ENODEV;
}
gpio_pin_configure_dt(&cfg->sd_gpio, GPIO_OUTPUT_INACTIVE);
return 0;
}
/**
* Initialization of the device.
* @param dev - The device structure.
* @return 0 in case of success, negative error code otherwise.
*/
static int fdc2x1x_init(const struct device *dev)
{
const struct fdc2x1x_config *cfg = dev->config;
uint8_t ch_supported;
if (cfg->fdc2x14) {
ch_supported = 4;
} else {
ch_supported = 2;
}
if (cfg->num_channels == 0) {
LOG_ERR("No channel nodes found");
return -EINVAL;
} else if (cfg->num_channels > ch_supported) {
LOG_ERR("Amount of channels not supported by this device");
return -EINVAL;
}
if (cfg->sd_gpio.port->name) {
if (fdc2x1x_init_sd_pin(dev) < 0) {
return -ENODEV;
}
}
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
if (fdc2x1x_probe(dev) < 0) {
return -ENODEV;
}
if (fdc2x1x_reset(dev) < 0) {
return -EIO;
}
if (fdc2x1x_init_config(dev) < 0) {
return -EIO;
}
if (fdc2x1x_set_op_mode(dev, FDC2X1X_ACTIVE_MODE) < 0) {
return -EIO;
}
#ifdef CONFIG_FDC2X1X_TRIGGER
if (fdc2x1x_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt!");
return -EIO;
}
#endif
return 0;
}
#define FDC2X1X_SD_PROPS(n) \
.sd_gpio = GPIO_DT_SPEC_INST_GET(n, sd_gpios), \
#define FDC2X1X_SD(n) \
IF_ENABLED(DT_INST_NODE_HAS_PROP(n, sd_gpios), \
(FDC2X1X_SD_PROPS(n)))
#define FDC2X1X_INTB_PROPS(n) \
.intb_gpio = GPIO_DT_SPEC_INST_GET(n, intb_gpios), \
#define FDC2X1X_INTB(n) \
IF_ENABLED(CONFIG_FDC2X1X_TRIGGER, \
(FDC2X1X_INTB_PROPS(n)))
#define FDC2X1X_CH_CFG_INIT(ch) \
{ \
.rcount = DT_PROP(ch, rcount), \
.offset = DT_PROP(ch, offset), \
.settle_count = DT_PROP(ch, settlecount), \
.fref_divider = DT_PROP(ch, fref_divider), \
.idrive = DT_PROP(ch, idrive), \
.fin_sel = DT_PROP(ch, fin_sel), \
.inductance = DT_PROP(ch, inductance), \
},
#define FDC2X1X_CHANNEL_BUF_INIT(ch) 0,
#define FDC2X1X_INIT(n) \
static uint32_t fdc2x1x_sample_buf_##n[] = { \
DT_INST_FOREACH_CHILD(n, FDC2X1X_CHANNEL_BUF_INIT) \
}; \
\
static struct fdc2x1x_data fdc2x1x_data_##n = { \
.channel_buf = fdc2x1x_sample_buf_##n, \
}; \
\
const struct fdc2x1x_chx_config ch_cfg_##n[] = { \
DT_INST_FOREACH_CHILD(n, FDC2X1X_CH_CFG_INIT) \
}; \
\
static const struct fdc2x1x_config fdc2x1x_config_##n = { \
.i2c = I2C_DT_SPEC_INST_GET(n), \
.fdc2x14 = DT_INST_PROP(n, fdc2x14), \
.autoscan_en = DT_INST_PROP(n, autoscan), \
.rr_sequence = DT_INST_PROP(n, rr_sequence), \
.active_channel = DT_INST_PROP(n, active_channel), \
.deglitch = DT_INST_PROP(n, deglitch), \
.sensor_activate_sel = \
DT_INST_ENUM_IDX(n, sensor_activate_sel), \
.clk_src = DT_INST_ENUM_IDX(n, ref_clk_src), \
.current_drv = DT_INST_ENUM_IDX(n, current_drive), \
.output_gain = DT_INST_PROP(n, output_gain), \
.ch_cfg = ch_cfg_##n, \
.num_channels = ARRAY_SIZE(fdc2x1x_sample_buf_##n), \
.fref = DT_INST_PROP(n, fref), \
FDC2X1X_SD(n) \
FDC2X1X_INTB(n) \
}; \
\
PM_DEVICE_DT_INST_DEFINE(n, fdc2x1x_device_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, \
fdc2x1x_init, \
PM_DEVICE_DT_INST_GET(n), \
&fdc2x1x_data_##n, \
&fdc2x1x_config_##n, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&fdc2x1x_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(FDC2X1X_INIT)
``` | /content/code_sandbox/drivers/sensor/ti/fdc2x1x/fdc2x1x.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 8,365 |
```unknown
# INA219 Bidirectional Current/Power Monitor
config INA219
bool "INA219 Current/Power Monitor"
default y
depends on DT_HAS_TI_INA219_ENABLED
select I2C
help
Enable driver for INA219 Bidirectional Current/Power Monitor.
``` | /content/code_sandbox/drivers/sensor/ti/ina219/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 58 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_ina219
#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 "ina219.h"
LOG_MODULE_REGISTER(INA219, CONFIG_SENSOR_LOG_LEVEL);
static int ina219_reg_read(const struct device *dev,
uint8_t reg_addr,
uint16_t *reg_data)
{
const struct ina219_config *cfg = dev->config;
uint8_t rx_buf[2];
int rc;
rc = i2c_write_read_dt(&cfg->bus,
®_addr, sizeof(reg_addr),
rx_buf, sizeof(rx_buf));
*reg_data = sys_get_be16(rx_buf);
return rc;
}
static int ina219_reg_write(const struct device *dev,
uint8_t addr,
uint16_t reg_data)
{
const struct ina219_config *cfg = dev->config;
uint8_t tx_buf[3];
tx_buf[0] = addr;
sys_put_be16(reg_data, &tx_buf[1]);
return i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
}
static int ina219_reg_field_update(const struct device *dev,
uint8_t addr,
uint16_t mask,
uint16_t field)
{
uint16_t reg_data;
int rc;
rc = ina219_reg_read(dev, addr, ®_data);
if (rc) {
return rc;
}
reg_data = (reg_data & ~mask) | field;
return ina219_reg_write(dev, addr, reg_data);
}
static int ina219_set_msr_delay(const struct device *dev)
{
const struct ina219_config *cfg = dev->config;
struct ina219_data *data = dev->data;
data->msr_delay = ina219_conv_delay(cfg->badc) +
ina219_conv_delay(cfg->sadc);
return 0;
}
static int ina219_set_config(const struct device *dev)
{
const struct ina219_config *cfg = dev->config;
uint16_t reg_data;
reg_data = (cfg->brng & INA219_BRNG_MASK) << INA219_BRNG_SHIFT |
(cfg->pg & INA219_PG_MASK) << INA219_PG_SHIFT |
(cfg->badc & INA219_ADC_MASK) << INA219_BADC_SHIFT |
(cfg->sadc & INA219_ADC_MASK) << INA219_SADC_SHIFT |
(cfg->mode & INA219_MODE_NORMAL);
return ina219_reg_write(dev, INA219_REG_CONF, reg_data);
}
static int ina219_set_calib(const struct device *dev)
{
const struct ina219_config *cfg = dev->config;
uint16_t cal;
cal = INA219_SCALING_FACTOR / ((cfg->r_shunt) * (cfg->current_lsb));
return ina219_reg_write(dev, INA219_REG_CALIB, cal);
}
static int ina219_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct ina219_data *data = dev->data;
uint16_t status;
uint16_t tmp;
int rc;
if (chan != SENSOR_CHAN_ALL &&
chan != SENSOR_CHAN_VOLTAGE &&
chan != SENSOR_CHAN_POWER &&
chan != SENSOR_CHAN_CURRENT) {
return -ENOTSUP;
}
/* Trigger measurement and wait for completion */
rc = ina219_reg_field_update(dev,
INA219_REG_CONF,
INA219_MODE_MASK,
INA219_MODE_NORMAL);
if (rc) {
LOG_ERR("Failed to start measurement.");
return rc;
}
k_sleep(K_USEC(data->msr_delay));
rc = ina219_reg_read(dev, INA219_REG_V_BUS, &status);
if (rc) {
LOG_ERR("Failed to read device status.");
return rc;
}
while (!(INA219_CNVR_RDY(status))) {
rc = ina219_reg_read(dev, INA219_REG_V_BUS, &status);
if (rc) {
LOG_ERR("Failed to read device status.");
return rc;
}
k_sleep(K_USEC(INA219_WAIT_MSR_RETRY));
}
/* Check for overflow */
if (INA219_OVF_STATUS(status)) {
LOG_WRN("Power and/or Current calculations are out of range.");
}
if (chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_VOLTAGE) {
rc = ina219_reg_read(dev, INA219_REG_V_BUS, &tmp);
if (rc) {
LOG_ERR("Error reading bus voltage.");
return rc;
}
data->v_bus = INA219_VBUS_GET(tmp);
}
if (chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_POWER) {
rc = ina219_reg_read(dev, INA219_REG_POWER, &tmp);
if (rc) {
LOG_ERR("Error reading power register.");
return rc;
}
data->power = tmp;
}
if (chan == SENSOR_CHAN_ALL ||
chan == SENSOR_CHAN_CURRENT) {
rc = ina219_reg_read(dev, INA219_REG_CURRENT, &tmp);
if (rc) {
LOG_ERR("Error reading current register.");
return rc;
}
data->current = tmp;
}
return rc;
}
static int ina219_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct ina219_config *cfg = dev->config;
struct ina219_data *data = dev->data;
double tmp;
int8_t sign = 1;
switch (chan) {
case SENSOR_CHAN_VOLTAGE:
tmp = data->v_bus * INA219_V_BUS_MUL;
break;
case SENSOR_CHAN_POWER:
tmp = data->power * cfg->current_lsb * INA219_POWER_MUL * INA219_SI_MUL;
break;
case SENSOR_CHAN_CURRENT:
if (INA219_SIGN_BIT(data->current)) {
data->current = ~data->current + 1;
sign = -1;
}
tmp = sign * data->current * cfg->current_lsb * INA219_SI_MUL;
break;
default:
LOG_DBG("Channel not supported by device!");
return -ENOTSUP;
}
return sensor_value_from_double(val, tmp);
}
#ifdef CONFIG_PM_DEVICE
static int ina219_pm_action(const struct device *dev,
enum pm_device_action action)
{
uint16_t reg_val;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
return ina219_init(dev);
case PM_DEVICE_ACTION_SUSPEND:
reg_val = INA219_MODE_SLEEP;
break;
case PM_DEVICE_ACTION_TURN_OFF:
reg_val = INA219_MODE_OFF;
break;
default:
return -ENOTSUP;
}
return ina219_reg_field_update(dev,
INA219_REG_CONF,
INA219_MODE_MASK,
reg_val);
}
#endif /* CONFIG_PM_DEVICE */
static int ina219_init(const struct device *dev)
{
const struct ina219_config *cfg = dev->config;
int rc;
if (!device_is_ready(cfg->bus.bus)) {
LOG_ERR("Device not ready.");
return -ENODEV;
}
rc = ina219_reg_write(dev, INA219_REG_CONF, INA219_RST);
if (rc) {
LOG_ERR("Could not reset device.");
return rc;
}
rc = ina219_set_config(dev);
if (rc) {
LOG_ERR("Could not set configuration data.");
return rc;
}
rc = ina219_set_calib(dev);
if (rc) {
LOG_DBG("Could not set calibration data.");
return rc;
}
/* Set measurement delay */
rc = ina219_set_msr_delay(dev);
if (rc) {
LOG_ERR("Could not get measurement delay.");
return rc;
}
k_sleep(K_USEC(INA219_WAIT_STARTUP));
return 0;
}
static const struct sensor_driver_api ina219_api = {
.sample_fetch = ina219_sample_fetch,
.channel_get = ina219_channel_get,
};
#define INA219_INIT(n) \
static struct ina219_data ina219_data_##n; \
\
static const struct ina219_config ina219_config_##n = { \
.bus = I2C_DT_SPEC_INST_GET(n), \
.current_lsb = DT_INST_PROP(n, lsb_microamp), \
.r_shunt = DT_INST_PROP(n, shunt_milliohm), \
.brng = DT_INST_PROP(n, brng), \
.pg = DT_INST_PROP(n, pg), \
.badc = DT_INST_PROP(n, badc), \
.sadc = DT_INST_PROP(n, sadc), \
.mode = INA219_MODE_NORMAL \
}; \
\
PM_DEVICE_DT_INST_DEFINE(n, ina219_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, \
ina219_init, \
PM_DEVICE_DT_INST_GET(n), \
&ina219_data_##n, \
&ina219_config_##n, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&ina219_api);
DT_INST_FOREACH_STATUS_OKAY(INA219_INIT)
``` | /content/code_sandbox/drivers/sensor/ti/ina219/ina219.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,053 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TMP112_TMP112_H_
#define ZEPHYR_DRIVERS_SENSOR_TMP112_TMP112_H_
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
#define TMP112_REG_TEMPERATURE 0x00
#define TMP112_DATA_INVALID_BIT (BIT(1) | BIT(2))
#define TMP112_DATA_EXTENDED (BIT(0))
#define TMP112_DATA_EXTENDED_SHIFT 3
#define TMP112_DATA_NORMAL_SHIFT 4
#define TMP112_REG_CONFIG 0x01
#define TMP112_CONFIG_EM BIT(4)
#define TMP112_ALERT_EN_BIT BIT(5)
#define TMP112_CONV_RATE_SHIFT 6
#define TMP112_CONV_RATE_MASK (BIT_MASK(2) << TMP112_CONV_RATE_SHIFT)
#define TMP112_CONV_RATE_025 0
#define TMP112_CONV_RATE_1000 1
#define TMP112_CONV_RATE_4 2
#define TMP112_CONV_RATE_8 3
#define TMP112_CONV_RATE(cr) ((cr) << TMP112_CONV_RATE_SHIFT)
#define TMP112_CONV_RES_SHIFT 13
#define TMP112_CONV_RES_MASK (BIT_MASK(2) << TMP112_CONV_RES_SHIFT)
#define TMP112_ONE_SHOT BIT(15)
#define TMP112_REG_TLOW 0x02
#define TMP112_REG_THIGH 0x03
/* scale in micro degrees Celsius */
#define TMP112_TEMP_SCALE 62500
struct tmp112_data {
int16_t sample;
uint16_t config_reg;
};
struct tmp112_config {
const struct i2c_dt_spec bus;
uint8_t cr;
bool extended_mode : 1;
};
#endif
``` | /content/code_sandbox/drivers/sensor/ti/tmp112/tmp112.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 363 |
```unknown
# TMP112 temperature sensor configuration options
config TMP112
bool "TMP112 Temperature Sensor"
default y
depends on DT_HAS_TI_TMP112_ENABLED
select I2C
help
Enable the driver for Texas Instruments TMP112 High-Accuracy Digital
Temperature Sensors.
The TMP102 is compatible with the TMP112 but is less accurate and has
been successfully tested with this driver.
if TMP112
config TMP112_FULL_SCALE_RUNTIME
bool "Allow to set extended mode at runtime"
default y
help
When set extended mode can be selected using tmp112_attr_set
with SENSOR_ATTR_FULL_SCALE and value to set either 128 or 150
config TMP112_SAMPLING_FREQUENCY_RUNTIME
bool "Allow to set conversion rate at runtime"
default y
help
When set conversion rate can be set at runtime using sensor_attr_set
with SENSOR_ATTR_SAMPLING_FREQUENCY
endif # TMP112
``` | /content/code_sandbox/drivers/sensor/ti/tmp112/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 192 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmp112
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "tmp112.h"
LOG_MODULE_REGISTER(TMP112, CONFIG_SENSOR_LOG_LEVEL);
static int tmp112_reg_read(const struct tmp112_config *cfg,
uint8_t reg, uint16_t *val)
{
if (i2c_burst_read_dt(&cfg->bus, reg, (uint8_t *)val, sizeof(*val)) < 0) {
return -EIO;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
static int tmp112_reg_write(const struct tmp112_config *cfg,
uint8_t reg, uint16_t val)
{
uint8_t buf[3];
buf[0] = reg;
sys_put_be16(val, &buf[1]);
return i2c_write_dt(&cfg->bus, buf, sizeof(buf));
}
static uint16_t set_config_flags(struct tmp112_data *data, uint16_t mask,
uint16_t value)
{
return (data->config_reg & ~mask) | (value & mask);
}
static int tmp112_update_config(const struct device *dev, uint16_t mask,
uint16_t val)
{
int rc;
struct tmp112_data *data = dev->data;
const uint16_t new_val = set_config_flags(data, mask, val);
rc = tmp112_reg_write(dev->config, TMP112_REG_CONFIG, new_val);
if (rc == 0) {
data->config_reg = new_val;
}
return rc;
}
static int tmp112_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
uint16_t value;
uint16_t cr;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
#if CONFIG_TMP112_FULL_SCALE_RUNTIME
case SENSOR_ATTR_FULL_SCALE:
/* the sensor supports two ranges -55 to 128 and -55 to 150 */
/* the value contains the upper limit */
if (val->val1 == 128) {
value = 0x0000;
} else if (val->val1 == 150) {
value = TMP112_CONFIG_EM;
} else {
return -ENOTSUP;
}
if (tmp112_update_config(dev, TMP112_CONFIG_EM, value) < 0) {
LOG_DBG("Failed to set attribute!");
return -EIO;
}
break;
#endif
case SENSOR_ATTR_SAMPLING_FREQUENCY:
#if CONFIG_TMP112_SAMPLING_FREQUENCY_RUNTIME
/* conversion rate in mHz */
cr = val->val1 * 1000 + val->val2 / 1000;
/* the sensor supports 0.25Hz, 1Hz, 4Hz and 8Hz */
/* conversion rate */
switch (cr) {
case 250:
value = TMP112_CONV_RATE(TMP112_CONV_RATE_025);
break;
case 1000:
value = TMP112_CONV_RATE(TMP112_CONV_RATE_1000);
break;
case 4000:
value = TMP112_CONV_RATE(TMP112_CONV_RATE_4);
break;
case 8000:
value = TMP112_CONV_RATE(TMP112_CONV_RATE_8);
break;
default:
return -ENOTSUP;
}
if (tmp112_update_config(dev, TMP112_CONV_RATE_MASK, value) < 0) {
LOG_DBG("Failed to set attribute!");
return -EIO;
}
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static int tmp112_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct tmp112_data *drv_data = dev->data;
const struct tmp112_config *cfg = dev->config;
uint16_t val;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_AMBIENT_TEMP);
if (tmp112_reg_read(cfg, TMP112_REG_TEMPERATURE, &val) < 0) {
return -EIO;
}
if (val & TMP112_DATA_EXTENDED) {
drv_data->sample = arithmetic_shift_right((int16_t)val,
TMP112_DATA_EXTENDED_SHIFT);
} else {
drv_data->sample = arithmetic_shift_right((int16_t)val,
TMP112_DATA_NORMAL_SHIFT);
}
return 0;
}
static int tmp112_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct tmp112_data *drv_data = dev->data;
int32_t uval;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
uval = (int32_t)drv_data->sample * TMP112_TEMP_SCALE;
val->val1 = uval / 1000000;
val->val2 = uval % 1000000;
return 0;
}
static const struct sensor_driver_api tmp112_driver_api = {
.attr_set = tmp112_attr_set,
.sample_fetch = tmp112_sample_fetch,
.channel_get = tmp112_channel_get,
};
int tmp112_init(const struct device *dev)
{
const struct tmp112_config *cfg = dev->config;
struct tmp112_data *data = dev->data;
if (!device_is_ready(cfg->bus.bus)) {
LOG_ERR("I2C dev %s not ready", cfg->bus.bus->name);
return -EINVAL;
}
data->config_reg = TMP112_CONV_RATE(cfg->cr) | TMP112_CONV_RES_MASK
| (cfg->extended_mode ? TMP112_CONFIG_EM : 0);
return tmp112_update_config(dev, 0, 0);
}
#define TMP112_INST(inst) \
static struct tmp112_data tmp112_data_##inst; \
static const struct tmp112_config tmp112_config_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
.cr = DT_INST_ENUM_IDX(inst, conversion_rate), \
.extended_mode = DT_INST_PROP(inst, extended_mode), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, tmp112_init, NULL, &tmp112_data_##inst, \
&tmp112_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tmp112_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TMP112_INST)
``` | /content/code_sandbox/drivers/sensor/ti/tmp112/tmp112.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,455 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_INA23X_INA237_H_
#define ZEPHYR_DRIVERS_SENSOR_INA23X_INA237_H_
#include "ina23x_trigger.h"
#include <stdint.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#define INA237_REG_CONFIG 0x00
#define INA237_CFG_HIGH_PRECISION BIT(4)
#define INA237_REG_ADC_CONFIG 0x01
#define INA237_REG_CALIB 0x02
#define INA237_REG_SHUNT_VOLT 0x04
#define INA237_REG_BUS_VOLT 0x05
#define INA237_REG_DIETEMP 0x06
#define INA237_REG_CURRENT 0x07
#define INA237_REG_POWER 0x08
#define INA237_REG_ALERT 0x0B
#define INA237_REG_SOVL 0x0C
#define INA237_REG_SUVL 0x0D
#define INA237_REG_BOVL 0x0E
#define INA237_REG_BUVL 0x0F
#define INA237_REG_TEMP_LIMIT 0x10
#define INA237_REG_PWR_LIMIT 0x11
#define INA237_REG_MANUFACTURER_ID 0x3E
#define INA237_MANUFACTURER_ID 0x5449
struct ina237_data {
const struct device *dev;
int16_t current;
uint16_t bus_voltage;
uint32_t power;
int16_t die_temp;
#ifdef CONFIG_INA237_VSHUNT
int16_t shunt_voltage;
#endif
enum sensor_channel chan;
struct ina23x_trigger trigger;
};
struct ina237_config {
struct i2c_dt_spec bus;
uint16_t config;
uint16_t adc_config;
uint32_t current_lsb;
uint16_t cal;
const struct gpio_dt_spec alert_gpio;
uint16_t alert_config;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_INA23X_INA237_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina237.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 448 |
```c
/*
*
*/
#include "ina230.h"
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(INA230, CONFIG_SENSOR_LOG_LEVEL);
static void ina230_gpio_callback(const struct device *port,
struct gpio_callback *cb, uint32_t pin)
{
struct ina230_data *ina230 = CONTAINER_OF(cb, struct ina230_data, gpio_cb);
const struct device *dev = (const struct device *)ina230->dev;
ARG_UNUSED(port);
ARG_UNUSED(pin);
ARG_UNUSED(cb);
if (ina230->handler_alert) {
ina230->handler_alert(dev, ina230->trig_alert);
}
}
int ina230_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct ina230_data *ina230 = dev->data;
ARG_UNUSED(trig);
ina230->handler_alert = handler;
ina230->trig_alert = trig;
return 0;
}
int ina230_trigger_mode_init(const struct device *dev)
{
struct ina230_data *ina230 = dev->data;
const struct ina230_config *config = dev->config;
int ret;
/* setup alert gpio interrupt */
if (!gpio_is_ready_dt(&config->alert_gpio)) {
LOG_ERR("Alert GPIO device not ready");
return -ENODEV;
}
ina230->dev = dev;
ret = gpio_pin_configure_dt(&config->alert_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&ina230->gpio_cb,
ina230_gpio_callback,
BIT(config->alert_gpio.pin));
ret = gpio_add_callback(config->alert_gpio.port, &ina230->gpio_cb);
if (ret < 0) {
LOG_ERR("Could not set gpio callback");
return ret;
}
return gpio_pin_interrupt_configure_dt(&config->alert_gpio,
GPIO_INT_EDGE_BOTH);
}
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina230_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 444 |
```c
/*
*
*/
#include "ina23x_trigger.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(INA23X_TRIGGER, CONFIG_SENSOR_LOG_LEVEL);
static void ina23x_gpio_callback(const struct device *port,
struct gpio_callback *cb, uint32_t pin)
{
ARG_UNUSED(pin);
struct ina23x_trigger *trigg = CONTAINER_OF(cb, struct ina23x_trigger, gpio_cb);
k_work_submit(&trigg->conversion_work);
}
int ina23x_trigger_mode_init(struct ina23x_trigger *trigg, const struct gpio_dt_spec *alert_gpio)
{
int ret;
if (!device_is_ready(alert_gpio->port)) {
LOG_ERR("Alert GPIO device not ready");
return -ENODEV;
}
ret = gpio_pin_configure_dt(alert_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&trigg->gpio_cb,
ina23x_gpio_callback,
BIT(alert_gpio->pin));
ret = gpio_add_callback(alert_gpio->port, &trigg->gpio_cb);
if (ret < 0) {
LOG_ERR("Could not set gpio callback");
return ret;
}
return gpio_pin_interrupt_configure_dt(alert_gpio,
GPIO_INT_EDGE_FALLING);
}
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina23x_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 281 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_ina230
#include "ina230.h"
#include "ina23x_common.h"
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
LOG_MODULE_REGISTER(INA230, CONFIG_SENSOR_LOG_LEVEL);
/** @brief Calibration scaling value (value scaled by 100000) */
#define INA230_CAL_SCALING 512ULL
/** @brief The LSB value for the bus voltage register, in microvolts/LSB. */
#define INA230_BUS_VOLTAGE_UV_LSB 1250U
/** @brief The scaling for the power register. */
#define INA230_POWER_SCALING 25
static int ina230_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ina230_data *data = dev->data;
const struct ina230_config *const config = dev->config;
uint32_t bus_uv, power_uw;
int32_t current_ua;
switch (chan) {
case SENSOR_CHAN_VOLTAGE:
bus_uv = data->bus_voltage * INA230_BUS_VOLTAGE_UV_LSB;
/* convert to fractional volts (units for voltage channel) */
val->val1 = bus_uv / 1000000U;
val->val2 = bus_uv % 1000000U;
break;
case SENSOR_CHAN_CURRENT:
/* see datasheet "Programming" section for reference */
current_ua = data->current * config->current_lsb;
/* convert to fractional amperes */
val->val1 = current_ua / 1000000L;
val->val2 = current_ua % 1000000L;
break;
case SENSOR_CHAN_POWER:
power_uw = data->power * INA230_POWER_SCALING * config->current_lsb;
/* convert to fractional watts */
val->val1 = (int32_t)(power_uw / 1000000U);
val->val2 = (int32_t)(power_uw % 1000000U);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int ina230_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ina230_data *data = dev->data;
const struct ina230_config *config = dev->config;
int ret;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_VOLTAGE && chan != SENSOR_CHAN_CURRENT &&
chan != SENSOR_CHAN_POWER) {
return -ENOTSUP;
}
if ((chan == SENSOR_CHAN_ALL) || (chan == SENSOR_CHAN_VOLTAGE)) {
ret = ina23x_reg_read_16(&config->bus, INA230_REG_BUS_VOLT, &data->bus_voltage);
if (ret < 0) {
LOG_ERR("Failed to read bus voltage");
return ret;
}
}
if ((chan == SENSOR_CHAN_ALL) || (chan == SENSOR_CHAN_CURRENT)) {
ret = ina23x_reg_read_16(&config->bus, INA230_REG_CURRENT, &data->current);
if (ret < 0) {
LOG_ERR("Failed to read current");
return ret;
}
}
if ((chan == SENSOR_CHAN_ALL) || (chan == SENSOR_CHAN_POWER)) {
ret = ina23x_reg_read_16(&config->bus, INA230_REG_POWER, &data->power);
if (ret < 0) {
LOG_ERR("Failed to read power");
return ret;
}
}
return 0;
}
static int ina230_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct ina230_config *config = dev->config;
uint16_t data = val->val1;
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
return ina23x_reg_write(&config->bus, INA230_REG_CONFIG, data);
case SENSOR_ATTR_CALIBRATION:
return ina23x_reg_write(&config->bus, INA230_REG_CALIB, data);
case SENSOR_ATTR_FEATURE_MASK:
return ina23x_reg_write(&config->bus, INA230_REG_MASK, data);
case SENSOR_ATTR_ALERT:
return ina23x_reg_write(&config->bus, INA230_REG_ALERT, data);
default:
LOG_ERR("INA230 attribute not supported.");
return -ENOTSUP;
}
}
static int ina230_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct ina230_config *config = dev->config;
uint16_t data;
int ret;
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
ret = ina23x_reg_read_16(&config->bus, INA230_REG_CONFIG, &data);
if (ret < 0) {
return ret;
}
break;
case SENSOR_ATTR_CALIBRATION:
ret = ina23x_reg_read_16(&config->bus, INA230_REG_CALIB, &data);
if (ret < 0) {
return ret;
}
break;
case SENSOR_ATTR_FEATURE_MASK:
ret = ina23x_reg_read_16(&config->bus, INA230_REG_MASK, &data);
if (ret < 0) {
return ret;
}
break;
case SENSOR_ATTR_ALERT:
ret = ina23x_reg_read_16(&config->bus, INA230_REG_ALERT, &data);
if (ret < 0) {
return ret;
}
break;
default:
LOG_ERR("INA230 attribute not supported.");
return -ENOTSUP;
}
val->val1 = data;
val->val2 = 0;
return 0;
}
static int ina230_calibrate(const struct device *dev)
{
const struct ina230_config *config = dev->config;
int ret;
/* See datasheet "Programming" section */
ret = ina23x_reg_write(&config->bus, INA230_REG_CALIB, config->cal);
if (ret < 0) {
return ret;
}
return 0;
}
static int ina230_init(const struct device *dev)
{
const struct ina230_config *const config = dev->config;
int ret;
if (!device_is_ready(config->bus.bus)) {
LOG_ERR("I2C bus %s is not ready", config->bus.bus->name);
return -ENODEV;
}
ret = ina23x_reg_write(&config->bus, INA230_REG_CONFIG, config->config);
if (ret < 0) {
LOG_ERR("Failed to write configuration register!");
return ret;
}
ret = ina230_calibrate(dev);
if (ret < 0) {
LOG_ERR("Failed to write calibration register!");
return ret;
}
#ifdef CONFIG_INA230_TRIGGER
if (config->trig_enabled) {
ret = ina230_trigger_mode_init(dev);
if (ret < 0) {
LOG_ERR("Failed to init trigger mode\n");
return ret;
}
ret = ina23x_reg_write(&config->bus, INA230_REG_ALERT, config->alert_limit);
if (ret < 0) {
LOG_ERR("Failed to write alert register!");
return ret;
}
ret = ina23x_reg_write(&config->bus, INA230_REG_MASK, config->mask);
if (ret < 0) {
LOG_ERR("Failed to write mask register!");
return ret;
}
}
#endif /* CONFIG_INA230_TRIGGER */
return 0;
}
static const struct sensor_driver_api ina230_driver_api = {
.attr_set = ina230_attr_set,
.attr_get = ina230_attr_get,
#ifdef CONFIG_INA230_TRIGGER
.trigger_set = ina230_trigger_set,
#endif
.sample_fetch = ina230_sample_fetch,
.channel_get = ina230_channel_get,
};
#ifdef CONFIG_INA230_TRIGGER
#define INA230_CFG_IRQ(inst) \
.trig_enabled = true, .mask = DT_INST_PROP(inst, mask), \
.alert_limit = DT_INST_PROP(inst, alert_limit), \
.alert_gpio = GPIO_DT_SPEC_INST_GET(inst, alert_gpios)
#else
#define INA230_CFG_IRQ(inst)
#endif /* CONFIG_INA230_TRIGGER */
#define INA230_DRIVER_INIT(inst) \
static struct ina230_data drv_data_##inst; \
static const struct ina230_config drv_config_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
.config = DT_INST_PROP(inst, config) | \
(DT_INST_ENUM_IDX(inst, avg_count) << 9) | \
(DT_INST_ENUM_IDX(inst, vbus_conversion_time_us) << 6) | \
(DT_INST_ENUM_IDX(inst, vshunt_conversion_time_us) << 3) | \
DT_INST_ENUM_IDX(inst, adc_mode), \
.current_lsb = DT_INST_PROP(inst, current_lsb_microamps), \
.cal = (uint16_t)((INA230_CAL_SCALING * 10000000ULL) / \
((uint64_t)DT_INST_PROP(inst, current_lsb_microamps) * \
DT_INST_PROP(inst, rshunt_micro_ohms))), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, alert_gpios), (INA230_CFG_IRQ(inst)), \
())}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, &ina230_init, NULL, &drv_data_##inst, \
&drv_config_##inst, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&ina230_driver_api);
DT_INST_FOREACH_STATUS_OKAY(INA230_DRIVER_INIT)
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina230.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,110 |
```c
/*
*
*/
#include "ina23x_common.h"
#include <zephyr/sys/byteorder.h>
int ina23x_reg_read_24(const struct i2c_dt_spec *bus, uint8_t reg, uint32_t *val)
{
uint8_t data[3];
int ret;
ret = i2c_burst_read_dt(bus, reg, data, sizeof(data));
if (ret < 0) {
return ret;
}
*val = sys_get_be24(data);
return ret;
}
int ina23x_reg_read_16(const struct i2c_dt_spec *bus, uint8_t reg, uint16_t *val)
{
uint8_t data[2];
int ret;
ret = i2c_burst_read_dt(bus, reg, data, sizeof(data));
if (ret < 0) {
return ret;
}
*val = sys_get_be16(data);
return ret;
}
int ina23x_reg_write(const struct i2c_dt_spec *bus, uint8_t reg, uint16_t val)
{
uint8_t tx_buf[3];
tx_buf[0] = reg;
sys_put_be16(val, &tx_buf[1]);
return i2c_write_dt(bus, tx_buf, sizeof(tx_buf));
}
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina23x_common.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 269 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_INA23X_TRIGGER_H_
#define ZEPHYR_DRIVERS_SENSOR_INA23X_TRIGGER_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
struct ina23x_trigger {
struct gpio_callback gpio_cb;
struct k_work conversion_work;
sensor_trigger_handler_t handler_alert;
const struct sensor_trigger *trig_alert;
};
int ina23x_trigger_mode_init(struct ina23x_trigger *trigg,
const struct gpio_dt_spec *alert_gpio);
#endif /* ZEPHYR_DRIVERS_SENSOR_INA23X_TRIGGER_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina23x_trigger.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 143 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_INA23X_INA230_H_
#define ZEPHYR_DRIVERS_SENSOR_INA23X_INA230_H_
#ifdef CONFIG_INA230_TRIGGER
#include <stdbool.h>
#endif
#include <stdint.h>
#include <zephyr/device.h>
#ifdef CONFIG_INA230_TRIGGER
#include <zephyr/drivers/gpio.h>
#endif
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#ifdef CONFIG_INA230_TRIGGER
#include <zephyr/kernel.h>
#endif
#define INA230_REG_CONFIG 0x00
#define INA230_REG_SHUNT_VOLT 0x01
#define INA230_REG_BUS_VOLT 0x02
#define INA230_REG_POWER 0x03
#define INA230_REG_CURRENT 0x04
#define INA230_REG_CALIB 0x05
#define INA230_REG_MASK 0x06
#define INA230_REG_ALERT 0x07
struct ina230_data {
const struct device *dev;
int16_t current;
uint16_t bus_voltage;
uint16_t power;
#ifdef CONFIG_INA230_TRIGGER
const struct device *gpio;
struct gpio_callback gpio_cb;
struct k_work work;
sensor_trigger_handler_t handler_alert;
const struct sensor_trigger *trig_alert;
#endif /* CONFIG_INA230_TRIGGER */
};
struct ina230_config {
struct i2c_dt_spec bus;
uint16_t config;
uint32_t current_lsb;
uint16_t cal;
#ifdef CONFIG_INA230_TRIGGER
bool trig_enabled;
uint16_t mask;
const struct gpio_dt_spec alert_gpio;
uint16_t alert_limit;
#endif /* CONFIG_INA230_TRIGGER */
};
int ina230_trigger_mode_init(const struct device *dev);
int ina230_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* ZEPHYR_DRIVERS_SENSOR_INA23X_INA230_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina230.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 422 |
```unknown
#
config INA23X
bool "INA23X Current and Power Monitor"
default y
depends on DT_HAS_TI_INA230_ENABLED || DT_HAS_TI_INA237_ENABLED
select I2C
help
Enable driver for INA23X Current and Power Monitor.
if INA23X
config INA230
bool "INA230"
default y
depends on DT_HAS_TI_INA230_ENABLED
help
Enable driver for INA230/INA231.
config INA237
bool "INA237"
default y
depends on DT_HAS_TI_INA237_ENABLED
help
Enable driver for INA237.
config INA237_VSHUNT
bool "INA237 VShunt Measurement Enable"
depends on DT_HAS_TI_INA237_ENABLED
help
Enable shunt voltage measurement for INA237.
This is the actual shunt voltage measured which is scaled within the
INA237 based upon the SHUNT_CAL register. This value is useful for
looking at measurement noise or debugging the SHUNT_CAL value.
Note that enabling this option requires an extra I2C read when
SENSOR_CHAN_ALL is selected, so only enable if the shunt voltage
measurement is required.
config INA230_TRIGGER
bool "INA230 trigger mode"
depends on INA230
help
Set to enable trigger mode using gpio interrupt, where
interrupts are configured to line ALERT PIN.
endif # INA23X
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 299 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_INA23X_COMMON_H_
#define ZEPHYR_DRIVERS_SENSOR_INA23X_COMMON_H_
#include <stdint.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util_macro.h>
/**
* @brief Macro used to check if the current's LSB is 1mA
*/
#define INA23X_CURRENT_LSB_1MA 1
int ina23x_reg_read_24(const struct i2c_dt_spec *bus, uint8_t reg, uint32_t *val);
int ina23x_reg_read_16(const struct i2c_dt_spec *bus, uint8_t reg, uint16_t *val);
int ina23x_reg_write(const struct i2c_dt_spec *bus, uint8_t reg, uint16_t val);
#endif /* ZEPHYR_DRIVERS_SENSOR_INA23X_COMMON_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina23x_common.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 196 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_ina237
#include "ina237.h"
#include "ina23x_common.h"
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/dt-bindings/sensor/ina237.h>
#include <zephyr/sys/byteorder.h>
LOG_MODULE_REGISTER(INA237, CONFIG_SENSOR_LOG_LEVEL);
/** @brief Calibration scaling value (scaled by 10^-5) */
#define INA237_CAL_SCALING 8192ULL
/** @brief The LSB value for the bus voltage register, in microvolts/LSB. */
#define INA237_BUS_VOLTAGE_TO_uV(x) ((x) * 3125U)
/** @brief Power scaling (need factor of 0.2) */
#define INA237_POWER_TO_uW(x) ((x) / 5ULL)
/**
* @brief Scale die temperture from 0.125 degC/bit to micro-degrees C
* Note that the bottom 4 bits are reserved and are always zero.
*/
#define INA237_DIETEMP_TO_uDegC(x) (((x) >> 4) * 125000)
static void micro_s32_to_sensor_value(struct sensor_value *val, int32_t value_microX)
{
val->val1 = value_microX / 1000000L;
val->val2 = value_microX % 1000000L;
}
static void micro_u64_to_sensor_value(struct sensor_value *val, uint64_t value_microX)
{
val->val1 = value_microX / 1000000U;
val->val2 = value_microX % 1000000U;
}
static int ina237_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct ina237_data *data = dev->data;
const struct ina237_config *config = dev->config;
switch (chan) {
case SENSOR_CHAN_VOLTAGE:
micro_s32_to_sensor_value(val, INA237_BUS_VOLTAGE_TO_uV(data->bus_voltage));
break;
case SENSOR_CHAN_CURRENT:
/* see datasheet "Current and Power calculations" section */
micro_s32_to_sensor_value(val, data->current * config->current_lsb);
break;
case SENSOR_CHAN_POWER:
/* power in uW is power_reg * current_lsb * 0.2 */
micro_u64_to_sensor_value(val,
INA237_POWER_TO_uW((uint64_t)data->power * config->current_lsb));
break;
#ifdef CONFIG_INA237_VSHUNT
case SENSOR_CHAN_VSHUNT:
if (config->config & INA237_CFG_HIGH_PRECISION) {
/* high-resolution mode - 1.25 uV/bit, sensor value is in mV */
micro_s32_to_sensor_value(val, data->shunt_voltage * 1250);
} else {
/* standard-resolution - 5 uV/bit -> nano-volts */
micro_s32_to_sensor_value(val, data->shunt_voltage * 5000);
}
break;
#endif /* CONFIG_INA237_VSHUNT */
case SENSOR_CHAN_DIE_TEMP:
micro_s32_to_sensor_value(val, INA237_DIETEMP_TO_uDegC(data->die_temp));
break;
default:
return -ENOTSUP;
}
return 0;
}
/**
* @brief sensor operation mode check
*
* @retval true if set or false if not set
*/
static bool ina237_is_triggered_mode_set(const struct device *dev)
{
const struct ina237_config *config = dev->config;
uint8_t mode = (config->adc_config & GENMASK(15, 12)) >> 12;
switch (mode) {
case INA237_OPER_MODE_BUS_VOLTAGE_TRIG:
case INA237_OPER_MODE_SHUNT_VOLTAGE_TRIG:
case INA237_OPER_MODE_SHUNT_BUS_VOLTAGE_TRIG:
case INA237_OPER_MODE_TEMP_TRIG:
case INA237_OPER_MODE_TEMP_BUS_VOLTAGE_TRIG:
case INA237_OPER_MODE_TEMP_SHUNT_VOLTAGE_TRIG:
case INA237_OPER_MODE_BUS_SHUNT_VOLTAGE_TEMP_TRIG:
return true;
default:
return false;
}
}
/**
* @brief request for one shot measurement
*
* @retval 0 for success
* @retval negative errno code on fail
*/
static int ina237_trigg_one_shot_request(const struct device *dev)
{
const struct ina237_config *config = dev->config;
int ret;
ret = ina23x_reg_write(&config->bus, INA237_REG_ADC_CONFIG, config->adc_config);
if (ret < 0) {
LOG_ERR("Failed to write ADC configuration register!");
return ret;
}
return 0;
}
/**
* @brief sensor data read
*
* @retval 0 for success
* @retval -EIO in case of input / output error
*/
static int ina237_read_data(const struct device *dev)
{
struct ina237_data *data = dev->data;
const struct ina237_config *config = dev->config;
int ret;
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_VOLTAGE)) {
ret = ina23x_reg_read_16(&config->bus, INA237_REG_BUS_VOLT, &data->bus_voltage);
if (ret < 0) {
LOG_ERR("Failed to read bus voltage");
return ret;
}
}
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_CURRENT)) {
ret = ina23x_reg_read_16(&config->bus, INA237_REG_CURRENT, &data->current);
if (ret < 0) {
LOG_ERR("Failed to read current");
return ret;
}
}
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_POWER)) {
ret = ina23x_reg_read_24(&config->bus, INA237_REG_POWER, &data->power);
if (ret < 0) {
LOG_ERR("Failed to read power");
return ret;
}
}
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_DIE_TEMP)) {
ret = ina23x_reg_read_16(&config->bus, INA237_REG_DIETEMP, &data->die_temp);
if (ret < 0) {
LOG_ERR("Failed to read temperature");
return ret;
}
}
#ifdef CONFIG_INA237_VSHUNT
if ((data->chan == SENSOR_CHAN_ALL) || (data->chan == SENSOR_CHAN_VSHUNT)) {
ret = ina23x_reg_read_16(&config->bus, INA237_REG_SHUNT_VOLT, &data->shunt_voltage);
if (ret < 0) {
LOG_ERR("Failed to read shunt voltage");
return ret;
}
}
#endif /* CONFIG_INA237_VSHUNT */
return 0;
}
/**
* @brief sensor sample fetch
*
* @retval 0 for success
* @retval negative errno code on fail
*/
static int ina237_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ina237_data *data = dev->data;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_VOLTAGE && chan != SENSOR_CHAN_CURRENT &&
chan != SENSOR_CHAN_POWER &&
#ifdef CONFIG_INA237_VSHUNT
chan != SENSOR_CHAN_VSHUNT &&
#endif /* CONFIG_INA237_VSHUNT */
chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
data->chan = chan;
if (ina237_is_triggered_mode_set(dev)) {
return ina237_trigg_one_shot_request(dev);
} else {
return ina237_read_data(dev);
}
}
static int ina237_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct ina237_config *config = dev->config;
uint16_t data = val->val1;
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
return ina23x_reg_write(&config->bus, INA237_REG_CONFIG, data);
case SENSOR_ATTR_CALIBRATION:
return ina23x_reg_write(&config->bus, INA237_REG_CALIB, data);
default:
LOG_ERR("INA237 attribute not supported.");
return -ENOTSUP;
}
}
static int ina237_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct ina237_config *config = dev->config;
uint16_t data;
int ret;
switch (attr) {
case SENSOR_ATTR_CONFIGURATION:
ret = ina23x_reg_read_16(&config->bus, INA237_REG_CONFIG, &data);
if (ret < 0) {
return ret;
}
break;
case SENSOR_ATTR_CALIBRATION:
ret = ina23x_reg_read_16(&config->bus, INA237_REG_CALIB, &data);
if (ret < 0) {
return ret;
}
break;
default:
LOG_ERR("INA237 attribute not supported.");
return -ENOTSUP;
}
val->val1 = data;
val->val2 = 0;
return 0;
}
static int ina237_calibrate(const struct device *dev)
{
const struct ina237_config *config = dev->config;
int ret;
/* see datasheet "Current and Power calculations" section */
ret = ina23x_reg_write(&config->bus, INA237_REG_CALIB, config->cal);
if (ret < 0) {
return ret;
}
return 0;
}
static void ina237_trigger_work_handler(struct k_work *work)
{
struct ina23x_trigger *trigg = CONTAINER_OF(work, struct ina23x_trigger, conversion_work);
struct ina237_data *data = CONTAINER_OF(trigg, struct ina237_data, trigger);
const struct ina237_config *config = data->dev->config;
int ret;
uint16_t reg_alert;
/* Read reg alert to clear alerts */
ret = ina23x_reg_read_16(&config->bus, INA237_REG_ALERT, ®_alert);
if (ret < 0) {
LOG_ERR("Failed to read alert register!");
return;
}
ret = ina237_read_data(data->dev);
if (ret < 0) {
LOG_WRN("Unable to read data, ret %d", ret);
}
if (data->trigger.handler_alert) {
data->trigger.handler_alert(data->dev, data->trigger.trig_alert);
}
}
static int ina237_init(const struct device *dev)
{
struct ina237_data *data = dev->data;
const struct ina237_config *config = dev->config;
uint16_t id;
int ret;
if (!device_is_ready(config->bus.bus)) {
LOG_ERR("I2C bus %s is not ready", config->bus.bus->name);
return -ENODEV;
}
data->dev = dev;
ret = ina23x_reg_read_16(&config->bus, INA237_REG_MANUFACTURER_ID, &id);
if (ret < 0) {
LOG_ERR("Failed to read manufacturer register!");
return ret;
}
if (id != INA237_MANUFACTURER_ID) {
LOG_ERR("Manufacturer ID doesn't match!");
return -ENODEV;
}
ret = ina23x_reg_write(&config->bus, INA237_REG_ADC_CONFIG, config->adc_config);
if (ret < 0) {
LOG_ERR("Failed to write ADC configuration register!");
return ret;
}
ret = ina23x_reg_write(&config->bus, INA237_REG_CONFIG, config->config);
if (ret < 0) {
LOG_ERR("Failed to write configuration register!");
return ret;
}
ret = ina237_calibrate(dev);
if (ret < 0) {
LOG_ERR("Failed to write calibration register!");
return ret;
}
if (ina237_is_triggered_mode_set(dev)) {
if ((config->alert_config & GENMASK(15, 14)) != GENMASK(15, 14)) {
LOG_ERR("ALATCH and CNVR bits must be enabled in triggered mode!");
return -ENODEV;
}
k_work_init(&data->trigger.conversion_work, ina237_trigger_work_handler);
ret = ina23x_trigger_mode_init(&data->trigger, &config->alert_gpio);
if (ret < 0) {
LOG_ERR("Failed to init trigger mode");
return ret;
}
ret = ina23x_reg_write(&config->bus, INA237_REG_ALERT, config->alert_config);
if (ret < 0) {
LOG_ERR("Failed to write alert configuration register!");
return ret;
}
}
return 0;
}
static int ina237_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
ARG_UNUSED(trig);
struct ina237_data *ina237 = dev->data;
if (!ina237_is_triggered_mode_set(dev)) {
return -ENOTSUP;
}
ina237->trigger.handler_alert = handler;
ina237->trigger.trig_alert = trig;
return 0;
}
static const struct sensor_driver_api ina237_driver_api = {
.attr_set = ina237_attr_set,
.attr_get = ina237_attr_get,
.trigger_set = ina237_trigger_set,
.sample_fetch = ina237_sample_fetch,
.channel_get = ina237_channel_get,
};
/* Shunt calibration must be muliplied by 4 if high-prevision mode is selected */
#define CAL_PRECISION_MULTIPLIER(config) \
(((config & INA237_CFG_HIGH_PRECISION) >> 4) * 3 + 1)
#define INA237_DRIVER_INIT(inst) \
static struct ina237_data ina237_data_##inst; \
static const struct ina237_config ina237_config_##inst = { \
.bus = I2C_DT_SPEC_INST_GET(inst), \
.config = DT_INST_PROP(inst, config), \
.adc_config = DT_INST_PROP(inst, adc_config) | \
(DT_INST_ENUM_IDX(inst, adc_mode) << 12) | \
(DT_INST_ENUM_IDX(inst, vbus_conversion_time_us) << 9) | \
(DT_INST_ENUM_IDX(inst, vshunt_conversion_time_us) << 6) | \
(DT_INST_ENUM_IDX(inst, temp_conversion_time_us) << 3) | \
DT_INST_ENUM_IDX(inst, avg_count), \
.current_lsb = DT_INST_PROP(inst, current_lsb_microamps), \
.cal = CAL_PRECISION_MULTIPLIER(DT_INST_PROP(inst, config)) * \
INA237_CAL_SCALING * DT_INST_PROP(inst, current_lsb_microamps) * \
DT_INST_PROP(inst, rshunt_micro_ohms) / 10000000ULL, \
.alert_config = DT_INST_PROP_OR(inst, alert_config, 0x01), \
.alert_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, alert_gpios, {0}), \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, &ina237_init, NULL, &ina237_data_##inst, \
&ina237_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &ina237_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(INA237_DRIVER_INIT)
``` | /content/code_sandbox/drivers/sensor/ti/ina23x/ina237.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,390 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_opt3001
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/__assert.h>
#include "opt3001.h"
LOG_MODULE_REGISTER(opt3001, CONFIG_SENSOR_LOG_LEVEL);
static int opt3001_reg_read(const struct device *dev, uint8_t reg,
uint16_t *val)
{
const struct opt3001_config *config = dev->config;
uint8_t value[2];
if (i2c_burst_read_dt(&config->i2c, reg, value, 2) != 0) {
return -EIO;
}
*val = ((uint16_t)value[0] << 8) + value[1];
return 0;
}
static int opt3001_reg_write(const struct device *dev, uint8_t reg,
uint16_t val)
{
const struct opt3001_config *config = dev->config;
uint8_t new_value[2];
new_value[0] = val >> 8;
new_value[1] = val & 0xff;
uint8_t tx_buf[3] = { reg, new_value[0], new_value[1] };
return i2c_write_dt(&config->i2c, tx_buf, sizeof(tx_buf));
}
static int opt3001_reg_update(const struct device *dev, uint8_t reg,
uint16_t mask, uint16_t val)
{
uint16_t old_val;
uint16_t new_val;
if (opt3001_reg_read(dev, reg, &old_val) != 0) {
return -EIO;
}
new_val = old_val & ~mask;
new_val |= val & mask;
return opt3001_reg_write(dev, reg, new_val);
}
static int opt3001_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct opt3001_data *drv_data = dev->data;
uint16_t value;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_LIGHT);
drv_data->sample = 0U;
if (opt3001_reg_read(dev, OPT3001_REG_RESULT, &value) != 0) {
return -EIO;
}
drv_data->sample = value;
return 0;
}
static int opt3001_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct opt3001_data *drv_data = dev->data;
int32_t uval;
if (chan != SENSOR_CHAN_LIGHT) {
return -ENOTSUP;
}
/**
* sample consists of 4 bits of exponent and 12 bits of mantissa
* bits 15 to 12 are exponent bits
* bits 11 to 0 are the mantissa bits
*
* lux is the integer obtained using the following formula:
* (2^(exponent value)) * 0.01 * mantissa value
*/
uval = (1 << (drv_data->sample >> OPT3001_SAMPLE_EXPONENT_SHIFT))
* (drv_data->sample & OPT3001_MANTISSA_MASK);
val->val1 = uval / 100;
val->val2 = (uval % 100) * 10000;
return 0;
}
static const struct sensor_driver_api opt3001_driver_api = {
.sample_fetch = opt3001_sample_fetch,
.channel_get = opt3001_channel_get,
};
static int opt3001_chip_init(const struct device *dev)
{
const struct opt3001_config *config = dev->config;
uint16_t value;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
if (opt3001_reg_read(dev, OPT3001_REG_MANUFACTURER_ID, &value) != 0) {
return -EIO;
}
if (value != OPT3001_MANUFACTURER_ID_VALUE) {
LOG_ERR("Bad manufacturer id 0x%x", value);
return -ENOTSUP;
}
if (opt3001_reg_read(dev, OPT3001_REG_DEVICE_ID, &value) != 0) {
return -EIO;
}
if (value != OPT3001_DEVICE_ID_VALUE) {
LOG_ERR("Bad device id 0x%x", value);
return -ENOTSUP;
}
if (opt3001_reg_update(dev, OPT3001_REG_CONFIG,
OPT3001_CONVERSION_MODE_MASK,
OPT3001_CONVERSION_MODE_CONTINUOUS) != 0) {
LOG_ERR("Failed to set mode to continuous conversion");
return -EIO;
}
return 0;
}
int opt3001_init(const struct device *dev)
{
if (opt3001_chip_init(dev) < 0) {
return -EINVAL;
}
return 0;
}
#define OPT3001_DEFINE(inst) \
static struct opt3001_data opt3001_data_##inst; \
\
static const struct opt3001_config opt3001_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, opt3001_init, NULL, \
&opt3001_data_##inst, &opt3001_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &opt3001_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(OPT3001_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ti/opt3001/opt3001.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,208 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_OPT3001_H_
#define ZEPHYR_DRIVERS_SENSOR_OPT3001_H_
#include <zephyr/sys/util.h>
#include <zephyr/drivers/i2c.h>
#define OPT3001_REG_RESULT 0x00
#define OPT3001_REG_CONFIG 0x01
#define OPT3001_REG_MANUFACTURER_ID 0x7E
#define OPT3001_REG_DEVICE_ID 0x7F
#define OPT3001_MANUFACTURER_ID_VALUE 0x5449
#define OPT3001_DEVICE_ID_VALUE 0x3001
#define OPT3001_CONVERSION_MODE_MASK (BIT(10) | BIT(9))
#define OPT3001_CONVERSION_MODE_CONTINUOUS (BIT(10) | BIT(9))
#define OPT3001_SAMPLE_EXPONENT_SHIFT 12
#define OPT3001_MANTISSA_MASK 0xfff
struct opt3001_data {
uint16_t sample;
};
struct opt3001_config {
struct i2c_dt_spec i2c;
};
#endif /* _SENSOR_OPT3001_ */
``` | /content/code_sandbox/drivers/sensor/ti/opt3001/opt3001.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 230 |
```unknown
# OPT3001 light sensor configuration options
config OPT3001
bool "OPT3001 Light Sensor"
default y
depends on DT_HAS_TI_OPT3001_ENABLED
select I2C
help
Enable driver for OPT3001 light sensors.
``` | /content/code_sandbox/drivers/sensor/ti/opt3001/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 54 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_bq274xx
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#ifdef CONFIG_BQ274XX_PM
#include <zephyr/pm/device.h>
#endif
#include "bq274xx.h"
LOG_MODULE_DECLARE(bq274xx, CONFIG_SENSOR_LOG_LEVEL);
static void bq274xx_handle_interrupts(const struct device *dev)
{
struct bq274xx_data *data = dev->data;
if (data->ready_handler) {
data->ready_handler(dev, data->ready_trig);
}
}
#ifdef CONFIG_BQ274XX_TRIGGER_OWN_THREAD
static K_KERNEL_STACK_DEFINE(bq274xx_thread_stack, CONFIG_BQ274XX_THREAD_STACK_SIZE);
static struct k_thread bq274xx_thread;
static void bq274xx_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct bq274xx_data *data = p1;
while (1) {
k_sem_take(&data->sem, K_FOREVER);
bq274xx_handle_interrupts(data->dev);
}
}
#endif
#ifdef CONFIG_BQ274XX_TRIGGER_GLOBAL_THREAD
static void bq274xx_work_handler(struct k_work *work)
{
struct bq274xx_data *data = CONTAINER_OF(work, struct bq274xx_data, work);
bq274xx_handle_interrupts(data->dev);
}
#endif
static void bq274xx_ready_callback_handler(const struct device *port,
struct gpio_callback *cb,
gpio_port_pins_t pins)
{
struct bq274xx_data *data = CONTAINER_OF(cb, struct bq274xx_data,
ready_callback);
ARG_UNUSED(port);
ARG_UNUSED(pins);
#if defined(CONFIG_BQ274XX_TRIGGER_OWN_THREAD)
k_sem_give(&data->sem);
#elif defined(CONFIG_BQ274XX_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
int bq274xx_trigger_mode_init(const struct device *dev)
{
const struct bq274xx_config *const config = dev->config;
struct bq274xx_data *data = dev->data;
int ret;
data->dev = dev;
#if defined(CONFIG_BQ274XX_TRIGGER_OWN_THREAD)
k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&bq274xx_thread, bq274xx_thread_stack,
CONFIG_BQ274XX_THREAD_STACK_SIZE,
bq274xx_thread_main,
data, NULL, NULL,
K_PRIO_COOP(CONFIG_BQ274XX_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_BQ274XX_TRIGGER_GLOBAL_THREAD)
k_work_init(&data->work, bq274xx_work_handler);
#endif
ret = gpio_pin_configure_dt(&config->int_gpios, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Unable to configure interrupt pin");
return ret;
}
gpio_init_callback(&data->ready_callback,
bq274xx_ready_callback_handler,
BIT(config->int_gpios.pin));
return 0;
}
int bq274xx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct bq274xx_config *config = dev->config;
struct bq274xx_data *data = dev->data;
int ret;
#ifdef CONFIG_BQ274XX_PM
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return -EBUSY;
}
#endif
if (trig->type != SENSOR_TRIG_DATA_READY) {
return -ENOTSUP;
}
if (!gpio_is_ready_dt(&config->int_gpios)) {
LOG_ERR("GPIO device is not ready");
return -ENODEV;
}
data->ready_handler = handler;
data->ready_trig = trig;
if (handler) {
ret = gpio_pin_configure_dt(&config->int_gpios, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Unable to configure interrupt pin: %d", ret);
return ret;
}
ret = gpio_add_callback(config->int_gpios.port,
&data->ready_callback);
if (ret < 0) {
LOG_ERR("Unable to add interrupt callback: %d", ret);
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&config->int_gpios,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
LOG_ERR("Unable to configure interrupt: %d", ret);
return ret;
}
} else {
ret = gpio_remove_callback(config->int_gpios.port,
&data->ready_callback);
if (ret < 0) {
LOG_ERR("Unable to remove interrupt callback: %d", ret);
return ret;
}
ret = gpio_pin_interrupt_configure_dt(&config->int_gpios, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("Unable to disable interrupt: %d", ret);
return ret;
}
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/ti/bq274xx/bq274xx_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,104 |
```unknown
#
menuconfig BQ274XX
bool "BQ274xx Fuel Gauge"
default y
depends on DT_HAS_TI_BQ274XX_ENABLED
select I2C
help
Enable I2C-based driver for BQ274xx Fuel Gauge.
if BQ274XX
config BQ274XX_PM
bool "BQ274XX Power Management"
depends on PM_DEVICE
default y
help
This option enables the device power management feature of the
BQ274XX.
Note: if the int_gpios pin is not used then this feature must be
disabled.
choice BQ274XX_TRIGGER_MODE
prompt "Trigger mode"
default BQ274XX_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config BQ274XX_TRIGGER_NONE
bool "No trigger"
config BQ274XX_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
select BQ274XX_TRIGGER
config BQ274XX_TRIGGER_OWN_THREAD
bool "Use own thread"
select BQ274XX_TRIGGER
endchoice # BQ274XX_TRIGGER_MODE
config BQ274XX_TRIGGER
bool
config BQ274XX_THREAD_PRIORITY
int "Thread priority"
depends on BQ274XX_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config BQ274XX_THREAD_STACK_SIZE
int "Thread stack size"
depends on BQ274XX_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # BQ274XX
``` | /content/code_sandbox/drivers/sensor/ti/bq274xx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 338 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BATTERY_BQ274XX_H_
#define ZEPHYR_DRIVERS_SENSOR_BATTERY_BQ274XX_H_
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/dt-bindings/sensor/bq274xx.h>
/*** General Constant ***/
#define BQ274XX_UNSEAL_KEY_A 0x8000 /* Unseal code one on BQ27441-G1A and similar */
#define BQ274XX_UNSEAL_KEY_B 0x8000 /* Unseal code two on BQ27441-G1A and similar */
#define BQ27421_DEVICE_ID 0x0421
#define BQ27427_DEVICE_ID 0x0427
/*** Standard Commands ***/
#define BQ274XX_CMD_CONTROL 0x00 /* Control() register */
#define BQ274XX_CMD_TEMP 0x02 /* Temperature() */
#define BQ274XX_CMD_VOLTAGE 0x04 /* Voltage() */
#define BQ274XX_CMD_FLAGS 0x06 /* Flags() */
#define BQ274XX_CMD_NOM_CAPACITY 0x08 /* NominalAvailableCapacity() */
#define BQ274XX_CMD_AVAIL_CAPACITY 0x0A /* FullAvailableCapacity() */
#define BQ274XX_CMD_REM_CAPACITY 0x0C /* RemainingCapacity() */
#define BQ274XX_CMD_FULL_CAPACITY 0x0E /* FullChargeCapacity() */
#define BQ274XX_CMD_AVG_CURRENT 0x10 /* AverageCurrent() */
#define BQ274XX_CMD_STDBY_CURRENT 0x12 /* StandbyCurrent() */
#define BQ274XX_CMD_MAX_CURRENT 0x14 /* MaxLoadCurrent() */
#define BQ274XX_CMD_AVG_POWER 0x18 /* AveragePower() */
#define BQ274XX_CMD_SOC 0x1C /* StateOfCharge() */
#define BQ274XX_CMD_INT_TEMP 0x1E /* InternalTemperature() */
#define BQ274XX_CMD_SOH 0x20 /* StateOfHealth() */
#define BQ274XX_CMD_REM_CAP_UNFL 0x28 /* RemainingCapacityUnfiltered() */
#define BQ274XX_CMD_REM_CAP_FIL 0x2A /* RemainingCapacityFiltered() */
#define BQ274XX_CMD_FULL_CAP_UNFL 0x2C /* FullChargeCapacityUnfiltered() */
#define BQ274XX_CMD_FULL_CAP_FIL 0x2E /* FullChargeCapacityFiltered() */
#define BQ274XX_CMD_SOC_UNFL 0x30 /* StateOfChargeUnfiltered() */
/*** Control Sub-Commands ***/
#define BQ274XX_CTRL_STATUS 0x0000
#define BQ274XX_CTRL_DEVICE_TYPE 0x0001
#define BQ274XX_CTRL_FW_VERSION 0x0002
#define BQ274XX_CTRL_DM_CODE 0x0004
#define BQ274XX_CTRL_PREV_MACWRITE 0x0007
#define BQ274XX_CTRL_CHEM_ID 0x0008
#define BQ274XX_CTRL_BAT_INSERT 0x000C
#define BQ274XX_CTRL_BAT_REMOVE 0x000D
#define BQ274XX_CTRL_SET_HIBERNATE 0x0011
#define BQ274XX_CTRL_CLEAR_HIBERNATE 0x0012
#define BQ274XX_CTRL_SET_CFGUPDATE 0x0013
#define BQ274XX_CTRL_SHUTDOWN_ENABLE 0x001B
#define BQ274XX_CTRL_SHUTDOWN 0x001C
#define BQ274XX_CTRL_SEALED 0x0020
#define BQ274XX_CTRL_PULSE_SOC_INT 0x0023
#define BQ274XX_CTRL_RESET 0x0041
#define BQ274XX_CTRL_SOFT_RESET 0x0042
#define BQ274XX_CTRL_EXIT_CFGUPDATE 0x0043
#define BQ274XX_CTRL_EXIT_RESIM 0x0044
/* BQ27427 */
#define BQ27427_CTRL_CHEM_A 0x0030
#define BQ27427_CTRL_CHEM_B 0x0031
#define BQ27427_CTRL_CHEM_C 0x0032
/*** Extended Data Commands ***/
#define BQ274XX_EXT_OPCONFIG 0x3A /* OpConfig() */
#define BQ274XX_EXT_CAPACITY 0x3C /* DesignCapacity() */
#define BQ274XX_EXT_DATA_CLASS 0x3E /* DataClass() */
#define BQ274XX_EXT_DATA_BLOCK 0x3F /* DataBlock() */
#define BQ274XX_EXT_BLKDAT_START 0x40 /* BlockData_start() */
#define BQ274XX_EXT_BLKDAT_END 0x5F /* BlockData_end() */
#define BQ274XX_EXT_CHECKSUM 0x60 /* BlockDataCheckSum() */
#define BQ274XX_EXT_DATA_CONTROL 0x61 /* BlockDataControl() */
#define BQ274XX_EXT_BLKDAT(off) (BQ274XX_EXT_BLKDAT_START + off)
/* Hold the register offset for a device variant. */
struct bq274xx_regs {
uint8_t dm_design_capacity;
uint8_t dm_design_energy;
uint8_t dm_terminate_voltage;
uint8_t dm_taper_rate;
};
struct bq274xx_data {
const struct bq274xx_regs *regs;
bool configured;
uint16_t voltage;
int16_t avg_current;
int16_t stdby_current;
int16_t max_load_current;
int16_t avg_power;
uint16_t state_of_charge;
int16_t state_of_health;
uint16_t internal_temperature;
uint16_t full_charge_capacity;
uint16_t remaining_charge_capacity;
uint16_t nom_avail_capacity;
uint16_t full_avail_capacity;
#ifdef CONFIG_BQ274XX_TRIGGER
const struct device *dev;
struct gpio_callback ready_callback;
sensor_trigger_handler_t ready_handler;
const struct sensor_trigger *ready_trig;
#ifdef CONFIG_BQ274XX_TRIGGER_OWN_THREAD
struct k_sem sem;
#endif
#ifdef CONFIG_BQ274XX_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
#endif /* CONFIG_BQ274XX_TRIGGER */
};
struct bq274xx_config {
struct i2c_dt_spec i2c;
uint16_t design_voltage;
uint16_t design_capacity;
uint16_t taper_current;
uint16_t terminate_voltage;
#if defined(CONFIG_BQ274XX_PM) || defined(CONFIG_BQ274XX_TRIGGER)
struct gpio_dt_spec int_gpios;
#endif
uint16_t chemistry_id;
bool lazy_loading;
};
int bq274xx_trigger_mode_init(const struct device *dev);
int bq274xx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif
``` | /content/code_sandbox/drivers/sensor/ti/bq274xx/bq274xx.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,465 |
```c
/*
*
*
* Relevant documents:
* - BQ27441
* Datasheet: path_to_url
* Technical reference manual: path_to_url
* - BQ27421
* Datasheet: path_to_url
* Technical reference manual: path_to_url
* - BQ27427
* Datasheet: path_to_url
* Technical reference manual: path_to_url
*/
#define DT_DRV_COMPAT ti_bq274xx
#include <zephyr/drivers/i2c.h>
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/__assert.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "bq274xx.h"
LOG_MODULE_REGISTER(bq274xx, CONFIG_SENSOR_LOG_LEVEL);
/* subclass 64 & 82 needs 5ms delay */
#define BQ274XX_SUBCLASS_DELAY K_MSEC(5)
/* Time to wait for CFGUP bit to be set, up to 1 second according to the
* technical reference manual, keep some headroom like the Linux driver.
*/
#define BQ274XX_CFGUP_DELAY K_MSEC(25)
#define BQ274XX_CFGUP_MAX_TRIES 100
/* Time to set pin in order to exit shutdown mode */
#define PIN_DELAY_TIME K_MSEC(1)
/* Delay from power up or shutdown exit to chip entering active state, this is
* defined as 250ms typical in the datasheet (Power-up communication delay).
*/
#define POWER_UP_DELAY_MS 300
/* Data memory size */
#define BQ27XXX_DM_SZ 32
/* Config update mode flag */
#define BQ27XXX_FLAG_CFGUP BIT(4)
/* BQ27427 CC Gain */
#define BQ27427_CC_GAIN BQ274XX_EXT_BLKDAT(5)
#define BQ27427_CC_GAIN_SIGN_BIT BIT(7)
/* Subclasses */
#define BQ274XX_SUBCLASS_82 82
#define BQ274XX_SUBCLASS_105 105
/* For temperature conversion */
#define KELVIN_OFFSET 273.15
static const struct bq274xx_regs bq27421_regs = {
.dm_design_capacity = 10,
.dm_design_energy = 12,
.dm_terminate_voltage = 16,
.dm_taper_rate = 27,
};
static const struct bq274xx_regs bq27427_regs = {
.dm_design_capacity = 6,
.dm_design_energy = 8,
.dm_terminate_voltage = 10,
.dm_taper_rate = 21,
};
static int bq274xx_cmd_reg_read(const struct device *dev, uint8_t reg_addr,
int16_t *val)
{
const struct bq274xx_config *config = dev->config;
uint8_t i2c_data[2];
int ret;
ret = i2c_burst_read_dt(&config->i2c, reg_addr, i2c_data, sizeof(i2c_data));
if (ret < 0) {
LOG_ERR("Unable to read register");
return -EIO;
}
*val = sys_get_le16(i2c_data);
return 0;
}
static int bq274xx_ctrl_reg_write(const struct device *dev, uint16_t subcommand)
{
const struct bq274xx_config *config = dev->config;
int ret;
uint8_t tx_buf[3];
tx_buf[0] = BQ274XX_CMD_CONTROL;
sys_put_le16(subcommand, &tx_buf[1]);
ret = i2c_write_dt(&config->i2c, tx_buf, sizeof(tx_buf));
if (ret < 0) {
LOG_ERR("Failed to write into control register");
return -EIO;
}
return 0;
}
static int bq274xx_get_device_type(const struct device *dev, uint16_t *val)
{
int ret;
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_CTRL_DEVICE_TYPE);
if (ret < 0) {
LOG_ERR("Unable to write control register");
return -EIO;
}
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_CONTROL, val);
if (ret < 0) {
LOG_ERR("Unable to read register");
return -EIO;
}
return 0;
}
static int bq274xx_read_block(const struct device *dev,
uint8_t subclass,
uint8_t *block, uint8_t num_bytes)
{
const struct bq274xx_config *const config = dev->config;
int ret;
ret = i2c_reg_write_byte_dt(&config->i2c, BQ274XX_EXT_DATA_CLASS, subclass);
if (ret < 0) {
LOG_ERR("Failed to update state subclass");
return -EIO;
}
/* DataBlock(), 0 for the first 32 bytes. */
ret = i2c_reg_write_byte_dt(&config->i2c, BQ274XX_EXT_DATA_BLOCK, 0x00);
if (ret < 0) {
LOG_ERR("Failed to update block offset");
return -EIO;
}
k_sleep(BQ274XX_SUBCLASS_DELAY);
ret = i2c_burst_read_dt(&config->i2c, BQ274XX_EXT_BLKDAT_START, block, num_bytes);
if (ret < 0) {
LOG_ERR("Unable to read block data");
return -EIO;
}
return 0;
}
static int bq274xx_write_block(const struct device *dev,
uint8_t *block, uint8_t num_bytes)
{
const struct bq274xx_config *const config = dev->config;
uint8_t checksum = 0;
int ret;
uint8_t buf[1 + BQ27XXX_DM_SZ];
__ASSERT_NO_MSG(num_bytes <= BQ27XXX_DM_SZ);
buf[0] = BQ274XX_EXT_BLKDAT_START;
memcpy(&buf[1], block, num_bytes);
ret = i2c_write_dt(&config->i2c, buf, 1 + num_bytes);
if (ret < 0) {
LOG_ERR("Unable to write block data");
return -EIO;
}
for (uint8_t i = 0; i < num_bytes; i++) {
checksum += block[i];
}
checksum = 0xff - checksum;
ret = i2c_reg_write_byte_dt(&config->i2c, BQ274XX_EXT_CHECKSUM, checksum);
if (ret < 0) {
LOG_ERR("Failed to update block checksum");
return -EIO;
}
k_sleep(BQ274XX_SUBCLASS_DELAY);
return 0;
}
static void bq274xx_update_block(uint8_t *block,
uint8_t offset, uint16_t val,
bool *block_modified)
{
uint16_t old_val;
old_val = sys_get_be16(&block[offset]);
LOG_DBG("update block: off=%d old=%d new=%d\n", offset, old_val, val);
if (val == old_val) {
return;
}
sys_put_be16(val, &block[offset]);
*block_modified = true;
}
static int bq274xx_mode_cfgupdate(const struct device *dev, bool enabled)
{
uint16_t flags;
uint8_t try;
int ret;
uint16_t val = enabled ? BQ274XX_CTRL_SET_CFGUPDATE : BQ274XX_CTRL_SOFT_RESET;
bool enabled_flag;
ret = bq274xx_ctrl_reg_write(dev, val);
if (ret < 0) {
LOG_ERR("Unable to set device mode to %02x", val);
return -EIO;
}
for (try = 0; try < BQ274XX_CFGUP_MAX_TRIES; try++) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_FLAGS, &flags);
if (ret < 0) {
LOG_ERR("Unable to read flags");
return -EIO;
}
enabled_flag = !!(flags & BQ27XXX_FLAG_CFGUP);
if (enabled_flag == enabled) {
LOG_DBG("CFGUP ready, try %u", try);
break;
}
k_sleep(BQ274XX_CFGUP_DELAY);
}
if (try >= BQ274XX_CFGUP_MAX_TRIES) {
LOG_ERR("Config mode change timeout");
return -EIO;
}
return 0;
}
/*
* BQ27427 needs the CC Gain polarity swapped from the ROM value.
* The details are currently only documented in the TI E2E support forum:
* path_to_url
*/
static int bq27427_ccgain_quirk(const struct device *dev)
{
const struct bq274xx_config *const config = dev->config;
int ret;
uint8_t val, checksum;
ret = i2c_reg_write_byte_dt(&config->i2c, BQ274XX_EXT_DATA_CLASS,
BQ274XX_SUBCLASS_105);
if (ret < 0) {
LOG_ERR("Failed to update state subclass");
return -EIO;
}
ret = i2c_reg_write_byte_dt(&config->i2c, BQ274XX_EXT_DATA_BLOCK, 0x00);
if (ret < 0) {
LOG_ERR("Failed to update block offset");
return -EIO;
}
k_sleep(BQ274XX_SUBCLASS_DELAY);
ret = i2c_reg_read_byte_dt(&config->i2c, BQ27427_CC_GAIN, &val);
if (ret < 0) {
LOG_ERR("Failed to read ccgain");
return -EIO;
}
if (!(val & BQ27427_CC_GAIN_SIGN_BIT)) {
LOG_DBG("bq27427 quirk already applied");
return 0;
}
ret = i2c_reg_read_byte_dt(&config->i2c, BQ274XX_EXT_CHECKSUM, &checksum);
if (ret < 0) {
LOG_ERR("Failed to read block checksum");
return -EIO;
}
/* Flip the sign bit on both value and checksum. */
val ^= BQ27427_CC_GAIN_SIGN_BIT;
checksum ^= BQ27427_CC_GAIN_SIGN_BIT;
LOG_DBG("bq27427: val=%02x checksum=%02x", val, checksum);
ret = i2c_reg_write_byte_dt(&config->i2c, BQ27427_CC_GAIN, val);
if (ret < 0) {
LOG_ERR("Failed to update ccgain");
return -EIO;
}
ret = i2c_reg_write_byte_dt(&config->i2c, BQ274XX_EXT_CHECKSUM, checksum);
if (ret < 0) {
LOG_ERR("Failed to update block checksum");
return -EIO;
}
k_sleep(BQ274XX_SUBCLASS_DELAY);
return 0;
}
static int bq274xx_ensure_chemistry(const struct device *dev)
{
struct bq274xx_data *data = dev->data;
const struct bq274xx_config *const config = dev->config;
uint16_t chem_id = config->chemistry_id;
if (chem_id == 0) {
/* No chemistry ID set, rely on the default of the device.*/
return 0;
}
int ret;
uint16_t val;
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_CTRL_CHEM_ID);
if (ret < 0) {
LOG_ERR("Unable to write control register");
return -EIO;
}
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_CONTROL, &val);
if (ret < 0) {
LOG_ERR("Unable to read register");
return -EIO;
}
LOG_DBG("Chem ID: %04x", val);
if (val != chem_id) {
/* Only the bq27427 has a configurable Chemistry ID. On bq27421, it depends on the
* variant of the chip, so just error out if the chemistry ID is wrong.
*/
if (data->regs != &bq27427_regs) {
LOG_ERR("Unable to confirm chemistry ID 0x%04x. Device reported 0x%04x",
chem_id, val);
return -EIO;
}
uint16_t cmd;
switch (val) {
case BQ27427_CHEM_ID_A:
cmd = BQ27427_CTRL_CHEM_A;
break;
case BQ27427_CHEM_ID_B:
cmd = BQ27427_CTRL_CHEM_B;
break;
case BQ27427_CHEM_ID_C:
cmd = BQ27427_CTRL_CHEM_C;
break;
default:
LOG_ERR("Unsupported chemistry ID 0x%04x", val);
return -EINVAL;
}
ret = bq274xx_ctrl_reg_write(dev, cmd);
if (ret < 0) {
LOG_ERR("Unable to configure chemistry");
return -EIO;
}
}
return 0;
}
static int bq274xx_gauge_configure(const struct device *dev)
{
const struct bq274xx_config *const config = dev->config;
struct bq274xx_data *data = dev->data;
const struct bq274xx_regs *regs = data->regs;
int ret;
uint16_t designenergy_mwh, taperrate;
uint8_t block[BQ27XXX_DM_SZ];
bool block_modified = false;
designenergy_mwh = (uint32_t)config->design_capacity * 37 / 10; /* x3.7 */
taperrate = config->design_capacity * 10 / config->taper_current;
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_UNSEAL_KEY_A);
if (ret < 0) {
LOG_ERR("Unable to unseal the battery");
return -EIO;
}
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_UNSEAL_KEY_B);
if (ret < 0) {
LOG_ERR("Unable to unseal the battery");
return -EIO;
}
ret = bq274xx_mode_cfgupdate(dev, true);
if (ret < 0) {
return ret;
}
ret = i2c_reg_write_byte_dt(&config->i2c, BQ274XX_EXT_DATA_CONTROL, 0x00);
if (ret < 0) {
LOG_ERR("Failed to enable block data memory");
return -EIO;
}
ret = bq274xx_read_block(dev, BQ274XX_SUBCLASS_82, block, sizeof(block));
if (ret < 0) {
return ret;
}
bq274xx_update_block(block,
regs->dm_design_capacity, config->design_capacity,
&block_modified);
bq274xx_update_block(block,
regs->dm_design_energy, designenergy_mwh,
&block_modified);
bq274xx_update_block(block,
regs->dm_terminate_voltage, config->terminate_voltage,
&block_modified);
bq274xx_update_block(block,
regs->dm_taper_rate, taperrate,
&block_modified);
if (block_modified) {
LOG_INF("bq274xx: updating fuel gauge parameters");
ret = bq274xx_write_block(dev, block, sizeof(block));
if (ret < 0) {
return ret;
}
if (data->regs == &bq27427_regs) {
ret = bq27427_ccgain_quirk(dev);
if (ret < 0) {
return ret;
}
}
ret = bq274xx_ensure_chemistry(dev);
if (ret < 0) {
return ret;
}
ret = bq274xx_mode_cfgupdate(dev, false);
if (ret < 0) {
return ret;
}
}
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_CTRL_SEALED);
if (ret < 0) {
LOG_ERR("Failed to seal the gauge");
return -EIO;
}
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_CTRL_BAT_INSERT);
if (ret < 0) {
LOG_ERR("Unable to configure BAT Detect");
return -EIO;
}
data->configured = true;
return 0;
}
static int bq274xx_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct bq274xx_data *data = dev->data;
int32_t int_temp;
switch (chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
val->val1 = ((data->voltage / 1000));
val->val2 = ((data->voltage % 1000) * 1000U);
break;
case SENSOR_CHAN_GAUGE_AVG_CURRENT:
val->val1 = ((data->avg_current / 1000));
val->val2 = ((data->avg_current % 1000) * 1000U);
break;
case SENSOR_CHAN_GAUGE_STDBY_CURRENT:
val->val1 = ((data->stdby_current / 1000));
val->val2 = ((data->stdby_current % 1000) * 1000U);
break;
case SENSOR_CHAN_GAUGE_MAX_LOAD_CURRENT:
val->val1 = ((data->max_load_current / 1000));
val->val2 = ((data->max_load_current % 1000) * 1000U);
break;
case SENSOR_CHAN_GAUGE_TEMP:
/* Convert units from 0.1K to 0.01K */
int_temp = data->internal_temperature * 10;
/* Convert to 0.01C */
int_temp -= (int32_t)(100.0 * KELVIN_OFFSET);
val->val1 = int_temp / 100;
val->val2 = (int_temp % 100) * 10000;
break;
case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
val->val1 = data->state_of_charge;
val->val2 = 0;
break;
case SENSOR_CHAN_GAUGE_STATE_OF_HEALTH:
val->val1 = data->state_of_health;
val->val2 = 0;
break;
case SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY:
val->val1 = data->full_charge_capacity;
val->val2 = 0;
break;
case SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY:
val->val1 = data->remaining_charge_capacity;
val->val2 = 0;
break;
case SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY:
val->val1 = data->nom_avail_capacity;
val->val2 = 0;
break;
case SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY:
val->val1 = data->full_avail_capacity;
val->val2 = 0;
break;
case SENSOR_CHAN_GAUGE_AVG_POWER:
val->val1 = data->avg_power;
val->val2 = 0;
break;
default:
return -ENOTSUP;
}
return 0;
}
static int bq274xx_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct bq274xx_data *data = dev->data;
int ret = -ENOTSUP;
if (!data->configured) {
ret = bq274xx_gauge_configure(dev);
if (ret < 0) {
return ret;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_VOLTAGE) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_VOLTAGE,
&data->voltage);
if (ret < 0) {
LOG_ERR("Failed to read voltage");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_AVG_CURRENT) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_AVG_CURRENT,
&data->avg_current);
if (ret < 0) {
LOG_ERR("Failed to read average current ");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_TEMP) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_INT_TEMP,
&data->internal_temperature);
if (ret < 0) {
LOG_ERR("Failed to read internal temperature");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_STDBY_CURRENT) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_STDBY_CURRENT,
&data->stdby_current);
if (ret < 0) {
LOG_ERR("Failed to read standby current");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_MAX_LOAD_CURRENT) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_MAX_CURRENT,
&data->max_load_current);
if (ret < 0) {
LOG_ERR("Failed to read maximum current");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_STATE_OF_CHARGE) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_SOC,
&data->state_of_charge);
if (ret < 0) {
LOG_ERR("Failed to read state of charge");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_FULL_CAPACITY,
&data->full_charge_capacity);
if (ret < 0) {
LOG_ERR("Failed to read full charge capacity");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_REM_CAPACITY,
&data->remaining_charge_capacity);
if (ret < 0) {
LOG_ERR("Failed to read remaining charge capacity");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_NOM_CAPACITY,
&data->nom_avail_capacity);
if (ret < 0) {
LOG_ERR("Failed to read nominal available capacity");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_AVAIL_CAPACITY,
&data->full_avail_capacity);
if (ret < 0) {
LOG_ERR("Failed to read full available capacity");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_AVG_POWER) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_AVG_POWER,
&data->avg_power);
if (ret < 0) {
LOG_ERR("Failed to read battery average power");
return -EIO;
}
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GAUGE_STATE_OF_HEALTH) {
ret = bq274xx_cmd_reg_read(dev, BQ274XX_CMD_SOH,
&data->state_of_health);
data->state_of_health = (data->state_of_health) & 0x00FF;
if (ret < 0) {
LOG_ERR("Failed to read state of health");
return -EIO;
}
}
return ret;
}
/**
* @brief initialise the fuel gauge
*
* @return 0 for success
*/
static int bq274xx_gauge_init(const struct device *dev)
{
const struct bq274xx_config *const config = dev->config;
struct bq274xx_data *data = dev->data;
int ret;
uint16_t id;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
#if defined(CONFIG_BQ274XX_PM) || defined(CONFIG_BQ274XX_TRIGGER)
if (!gpio_is_ready_dt(&config->int_gpios)) {
LOG_ERR("GPIO device pointer is not ready to be used");
return -ENODEV;
}
#endif
k_sleep(K_TIMEOUT_ABS_MS(POWER_UP_DELAY_MS));
ret = bq274xx_get_device_type(dev, &id);
if (ret < 0) {
LOG_ERR("Unable to get device ID");
return -EIO;
}
if (id == BQ27421_DEVICE_ID) {
data->regs = &bq27421_regs;
} else if (id == BQ27427_DEVICE_ID) {
data->regs = &bq27427_regs;
} else {
LOG_ERR("Unsupported device ID: 0x%04x", id);
return -ENOTSUP;
}
#ifdef CONFIG_BQ274XX_TRIGGER
ret = bq274xx_trigger_mode_init(dev);
if (ret < 0) {
LOG_ERR("Unable set up trigger mode.");
return ret;
}
#endif
if (!config->lazy_loading) {
ret = bq274xx_gauge_configure(dev);
}
return ret;
}
#ifdef CONFIG_BQ274XX_PM
static int bq274xx_enter_shutdown_mode(const struct device *dev)
{
int ret;
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_UNSEAL_KEY_A);
if (ret < 0) {
LOG_ERR("Unable to unseal the battery");
return ret;
}
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_UNSEAL_KEY_B);
if (ret < 0) {
LOG_ERR("Unable to unseal the battery");
return ret;
}
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_CTRL_SHUTDOWN_ENABLE);
if (ret < 0) {
LOG_ERR("Unable to enable shutdown mode");
return ret;
}
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_CTRL_SHUTDOWN);
if (ret < 0) {
LOG_ERR("Unable to enter shutdown mode");
return ret;
}
ret = bq274xx_ctrl_reg_write(dev, BQ274XX_CTRL_SEALED);
if (ret < 0) {
LOG_ERR("Failed to seal the gauge");
return ret;
}
return 0;
}
static int bq274xx_exit_shutdown_mode(const struct device *dev)
{
const struct bq274xx_config *const config = dev->config;
int ret;
ret = gpio_pin_configure_dt(&config->int_gpios, GPIO_OUTPUT | GPIO_OPEN_DRAIN);
if (ret < 0) {
LOG_ERR("Unable to configure interrupt pin to output and open drain");
return ret;
}
ret = gpio_pin_set_dt(&config->int_gpios, 0);
if (ret < 0) {
LOG_ERR("Unable to set interrupt pin to low");
return ret;
}
k_sleep(PIN_DELAY_TIME);
ret = gpio_pin_configure_dt(&config->int_gpios, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Unable to configure interrupt pin to input");
return ret;
}
if (!config->lazy_loading) {
k_sleep(K_MSEC(POWER_UP_DELAY_MS));
ret = bq274xx_gauge_configure(dev);
if (ret < 0) {
LOG_ERR("Unable to configure bq274xx gauge");
return ret;
}
}
return 0;
}
static int bq274xx_pm_action(const struct device *dev,
enum pm_device_action action)
{
int ret;
switch (action) {
case PM_DEVICE_ACTION_TURN_OFF:
ret = bq274xx_enter_shutdown_mode(dev);
break;
case PM_DEVICE_ACTION_RESUME:
ret = bq274xx_exit_shutdown_mode(dev);
break;
default:
ret = -ENOTSUP;
break;
}
return ret;
}
#endif /* CONFIG_BQ274XX_PM */
static const struct sensor_driver_api bq274xx_battery_driver_api = {
.sample_fetch = bq274xx_sample_fetch,
.channel_get = bq274xx_channel_get,
#ifdef CONFIG_BQ274XX_TRIGGER
.trigger_set = bq274xx_trigger_set,
#endif
};
#if defined(CONFIG_BQ274XX_PM) || defined(CONFIG_BQ274XX_TRIGGER)
#define BQ274XX_INT_CFG(index) \
.int_gpios = GPIO_DT_SPEC_INST_GET(index, int_gpios),
#define PM_BQ274XX_DT_INST_DEFINE(index, bq274xx_pm_action) \
PM_DEVICE_DT_INST_DEFINE(index, bq274xx_pm_action)
#define PM_BQ274XX_DT_INST_GET(index) PM_DEVICE_DT_INST_GET(index)
#else
#define BQ274XX_INT_CFG(index)
#define PM_BQ274XX_DT_INST_DEFINE(index, bq274xx_pm_action)
#define PM_BQ274XX_DT_INST_GET(index) NULL
#endif
#define BQ274XX_INIT(index) \
static struct bq274xx_data bq274xx_driver_##index; \
\
static const struct bq274xx_config bq274xx_config_##index = { \
.i2c = I2C_DT_SPEC_INST_GET(index), \
BQ274XX_INT_CFG(index) \
.design_voltage = DT_INST_PROP(index, design_voltage), \
.design_capacity = DT_INST_PROP(index, design_capacity), \
.taper_current = DT_INST_PROP(index, taper_current), \
.terminate_voltage = DT_INST_PROP(index, terminate_voltage), \
.chemistry_id = DT_INST_PROP_OR(index, chemistry_id, 0), \
.lazy_loading = DT_INST_PROP(index, zephyr_lazy_load), \
}; \
\
PM_BQ274XX_DT_INST_DEFINE(index, bq274xx_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(index, &bq274xx_gauge_init, \
PM_BQ274XX_DT_INST_GET(index), \
&bq274xx_driver_##index, \
&bq274xx_config_##index, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&bq274xx_battery_driver_api);
DT_INST_FOREACH_STATUS_OKAY(BQ274XX_INIT)
``` | /content/code_sandbox/drivers/sensor/ti/bq274xx/bq274xx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,612 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TMAG5273_H_
#define ZEPHYR_DRIVERS_SENSOR_TMAG5273_H_
#include <zephyr/sys/util.h>
/* --- Register definitions --- */
#define TMAG5273_REG_DEVICE_CONFIG_1 0x00
#define TMAG5273_REG_DEVICE_CONFIG_2 0x01
#define TMAG5273_REG_SENSOR_CONFIG_1 0x02
#define TMAG5273_REG_SENSOR_CONFIG_2 0x03
#define TMAG5273_REG_X_THR_CONFIG 0x04
#define TMAG5273_REG_Y_THR_CONFIG 0x05
#define TMAG5273_REG_Z_THR_CONFIG 0x06
#define TMAG5273_REG_T_CONFIG 0x07
#define TMAG5273_REG_INT_CONFIG_1 0x08
#define TMAG5273_REG_MAG_GAIN_CONFIG 0x09
#define TMAG5273_REG_MAG_OFFSET_CONFIG_1 0x0A
#define TMAG5273_REG_MAG_OFFSET_CONFIG_2 0x0B
#define TMAG5273_REG_I2C_ADDRESS 0x0C
#define TMAG5273_REG_DEVICE_ID 0x0D
#define TMAG5273_REG_MANUFACTURER_ID_LSB 0x0E
#define TMAG5273_REG_MANUFACTURER_ID_MSB 0x0F
#define TMAG5273_REG_T_MSB_RESULT 0x10
#define TMAG5273_REG_T_LSB_RESULT 0x11
#define TMAG5273_REG_X_MSB_RESULT 0x12
#define TMAG5273_REG_X_LSB_RESULT 0x13
#define TMAG5273_REG_Y_MSB_RESULT 0x14
#define TMAG5273_REG_Y_LSB_RESULT 0x15
#define TMAG5273_REG_Z_MSB_RESULT 0x16
#define TMAG5273_REG_Z_LSB_RESULT 0x17
#define TMAG5273_REG_CONV_STATUS 0x18
#define TMAG5273_REG_ANGLE_MSB_RESULT 0x19
#define TMAG5273_REG_ANGLE_LSB_RESULT 0x1A
#define TMAG5273_REG_MAGNITUDE_RESULT 0x1B
#define TMAG5273_REG_DEVICE_STATUS 0x1C
#define TMAG5273_REG_RESULT_BEGIN (TMAG5273_REG_T_MSB_RESULT)
#define TMAG5273_REG_RESULT_END (TMAG5273_REG_MAGNITUDE_RESULT)
/* Register DEVICE_CONFIG_1 */
#define TMAG5273_CRC_EN_POS 7
#define TMAG5273_MAG_TEMPCO_POS 5
#define TMAG5273_CONV_AVG_POS 2
#define TMAG5273_I2C_READ_POS 0
#define TMAG5273_CONV_AVB_MSK GENMASK(4, 2)
#define TMAG5273_CRC_DISABLE (0 << TMAG5273_CRC_EN_POS)
#define TMAG5273_CRC_ENABLE (1 << TMAG5273_CRC_EN_POS)
#define TMAG5273_MAGNET_TEMP_COEFF_NONE (0 << TMAG5273_MAG_TEMPCO_POS)
#define TMAG5273_MAGNET_TEMP_COEFF_NDBFE (1 << TMAG5273_MAG_TEMPCO_POS)
#define TMAG5273_MAGNET_TEMP_COEFF_CERAMIC (3 << TMAG5273_MAG_TEMPCO_POS)
#define TMAG5273_CONV_AVG_1 (0 << TMAG5273_CONV_AVG_POS)
#define TMAG5273_CONV_AVG_2 (1 << TMAG5273_CONV_AVG_POS)
#define TMAG5273_CONV_AVG_4 (2 << TMAG5273_CONV_AVG_POS)
#define TMAG5273_CONV_AVG_8 (3 << TMAG5273_CONV_AVG_POS)
#define TMAG5273_CONV_AVG_16 (4 << TMAG5273_CONV_AVG_POS)
#define TMAG5273_CONV_AVG_32 (5 << TMAG5273_CONV_AVG_POS)
#define TMAG5273_I2C_READ_MODE_STANDARD (0 << TMAG5273_I2C_READ_POS)
#define TMAG5273_I2C_READ_MODE_16BIT_SENSOR (1 << TMAG5273_I2C_READ_POS)
#define TMAG5273_I2C_READ_MODE_8BIT_MSB_DATA (2 << TMAG5273_I2C_READ_POS)
/* Register DEVICE_CONFIG_2 */
#define TMAG5273_THR_HYST_POS 5
#define TMAG5273_LP_LN_POS 4
#define TMAG5273_I2C_GLITCH_FILTER_POS 3
#define TMAG5273_TRIGGER_MODE_POS 2
#define TMAG5273_OPERATING_MODE_POS 0
#define TMAG5273_OPERATING_MODE_MSK GENMASK(1, 0)
#define TMAG5273_THR_HYST_COMPLEMENT (0 << TMAG5273_THR_HYST_POS)
#define TMAG5273_THR_HYST_LSB (1 << TMAG5273_THR_HYST_POS)
#define TMAG5273_LP_LOWPOWER (0 << TMAG5273_LP_LN_POS)
#define TMAG5273_LP_LOWNOISE (1 << TMAG5273_LP_LN_POS)
#define TMAG5273_I2C_GLITCH_FILTER_ON (0 << TMAG5273_I2C_GLITCH_FILTER_POS)
#define TMAG5273_I2C_GLITCH_FILTER_OFF (1 << TMAG5273_I2C_GLITCH_FILTER_POS)
#define TMAG5273_TRIGGER_MODE_I2C (0 << TMAG5273_TRIGGER_MODE_POS)
#define TMAG5273_TRIGGER_MODE_INT (1 << TMAG5273_TRIGGER_MODE_POS)
#define TMAG5273_OPERATING_MODE_STANDBY (0 << TMAG5273_OPERATING_MODE_POS)
#define TMAG5273_OPERATING_MODE_SLEEP (1 << TMAG5273_OPERATING_MODE_POS)
#define TMAG5273_OPERATING_MODE_CONTINUOUS (2 << TMAG5273_OPERATING_MODE_POS)
#define TMAG5273_OPERATING_MODE_WAKEUP_SLEEP (3 << TMAG5273_OPERATING_MODE_POS)
/* Register SENSOR_CONFIG_1 */
#define TMAG5273_MAG_CH_EN_POS 4
#define TMAG5273_SLEEPTIME_POS 0
#define TMAG5273_MAG_CH_EN_NONE (0x0 << TMAG5273_MAG_CH_EN_POS)
#define TMAG5273_MAG_CH_EN_X (0x1 << TMAG5273_MAG_CH_EN_POS)
#define TMAG5273_MAG_CH_EN_Y (0x2 << TMAG5273_MAG_CH_EN_POS)
#define TMAG5273_MAG_CH_EN_Z (0x4 << TMAG5273_MAG_CH_EN_POS)
#define TMAG5273_WS_SLEEPTIME_1MS (0x0 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_5MS (0x1 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_10MS (0x2 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_15MS (0x3 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_20MS (0x4 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_30MS (0x5 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_50MS (0x6 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_100MS (0x7 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_500MS (0x8 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_1000MS (0x9 << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_2000MS (0xA << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_5000MS (0xB << TMAG5273_SLEEPTIME_POS)
#define TMAG5273_WS_SLEEPTIME_20000MS (0xC << TMAG5273_SLEEPTIME_POS)
/* Register SENSOR_CONFIG_2 */
#define TMAG5273_INT_THRX_COUNT_POS 6
#define TMAG5273_INT_MAG_THR_DIR_POS 5
#define TMAG5273_GAIN_CORRECTION_CH_POS 4
#define TMAG5273_ANGLE_EN_POS 2
#define TMAG5273_X_Y_RANGE_POS 1
#define TMAG5273_Z_RANGE_POS 0
#define TMAG5273_ANGLE_EN_MSK GENMASK(3, 2)
#define TMAG5273_MEAS_RANGE_X_Y_MSK GENMASK(1, 1)
#define TMAG5273_MEAS_RANGE_Z_MSK GENMASK(0, 0)
#define TMAG5273_MEAS_RANGE_XYZ_MSK (TMAG5273_MEAS_RANGE_X_Y_MSK | TMAG5273_MEAS_RANGE_Z_MSK)
#define TMAG5273_INT_THRX_COUNT_1 (0 << TMAG5273_INT_THRX_COUNT_POS)
#define TMAG5273_INT_THRX_COUNT_4 (1 << TMAG5273_INT_THRX_COUNT_POS)
#define TMAG5273_MAG_THR_DIRECTION_ABOVE (0 << TMAG5273_INT_MAG_THR_DIR_POS)
#define TMAG5273_MAG_THR_DIRECTION_BELOW (1 << TMAG5273_INT_MAG_THR_DIR_POS)
#define TMAG5273_MAG_GAIN_CORRECTION_CH_1 (0 << TMAG5273_GAIN_CORRECTION_CH_POS)
#define TMAG5273_MAG_GAIN_CORRECTION_CH_2 (1 << TMAG5273_GAIN_CORRECTION_CH_POS)
#define TMAG5273_ANGLE_EN_NONE (0 << TMAG5273_ANGLE_EN_POS)
#define TMAG5273_ANGLE_EN_XY (1 << TMAG5273_ANGLE_EN_POS)
#define TMAG5273_ANGLE_EN_YZ (2 << TMAG5273_ANGLE_EN_POS)
#define TMAG5273_ANGLE_EN_XZ (3 << TMAG5273_ANGLE_EN_POS)
#define TMAG5273_X_Y_MEAS_RANGE_LOW (0 << TMAG5273_X_Y_RANGE_POS)
#define TMAG5273_X_Y_MEAS_RANGE_HIGH (1 << TMAG5273_X_Y_RANGE_POS)
#define TMAG5273_Z_MEAS_RANGE_LOW (0 << TMAG5273_Z_RANGE_POS)
#define TMAG5273_Z_MEAS_RANGE_HIGH (1 << TMAG5273_Z_RANGE_POS)
#define TMAG5273_XYZ_MEAS_RANGE_LOW (TMAG5273_X_Y_MEAS_RANGE_LOW | TMAG5273_Z_MEAS_RANGE_LOW)
#define TMAG5273_XYZ_MEAS_RANGE_HIGH (TMAG5273_X_Y_MEAS_RANGE_HIGH | TMAG5273_Z_MEAS_RANGE_HIGH)
/* Register T_CONFIG */
#define TMAG5273_T_THR_CONFIG_POS 1
#define TMAG5273_T_CH_EN_POS 0
#define TMAG5273_T_CH_EN_DISABLED (0 << TMAG5273_T_CH_EN_POS)
#define TMAG5273_T_CH_EN_ENABLED (1 << TMAG5273_T_CH_EN_POS)
/* Register INT_CONFIG_1 */
#define TMAG5273_INT_RSLT_INT_POS 7
#define TMAG5273_INT_THRSLD_INT_POS 6
#define TMAG5273_INT_STATE_POS 5
#define TMAG5273_INT_MODE_POS 2
#define TMAG5273_INT_MASK_INTB_POS 0
#define TMAG5273_INT_RSLT_INT_DISABLED (0 << TMAG5273_INT_RSLT_INT_POS)
#define TMAG5273_INT_RSLT_INT_ENABLED (1 << TMAG5273_INT_RSLT_INT_POS)
#define TMAG5273_INT_THRSLD_INT_DISABLED (0 << TMAG5273_INT_THRSLD_INT_POS)
#define TMAG5273_INT_THRSLD_INT_ENABLED (1 << TMAG5273_INT_THRSLD_INT_POS)
#define TMAG5273_INT_STATE_LATCHED (0 << TMAG5273_INT_STATE_POS)
#define TMAG5273_INT_STATE_PULSE (1 << TMAG5273_INT_STATE_POS)
#define TMAG5273_INT_MODE_NONE (0 << TMAG5273_INT_MODE_POS)
#define TMAG5273_INT_MODE_INT (1 << TMAG5273_INT_MODE_POS)
#define TMAG5273_INT_MODE_INT_EXC_I2C (2 << TMAG5273_INT_MODE_POS)
#define TMAG5273_INT_MODE_SCL (3 << TMAG5273_INT_MODE_POS)
#define TMAG5273_INT_MODE_SCL_EXC_I2C (4 << TMAG5273_INT_MODE_POS)
#define TMAG5273_INT_MASK_INTB_PIN_ENABLED (0 << TMAG5273_INT_MASK_INTB_POS)
#define TMAG5273_INT_MASK_INTB_PIN_MASKED (1 << TMAG5273_INT_MASK_INTB_POS)
/* Register I2C_ADDRESS */
#define TMAG5273_I2C_ADDRESS_POS 1
#define TMAG5273_I2C_ADDRESS_UPDATE_EN_POS 0
#define TMAG5273_I2C_ADDRESS_UPDATE_DISABLE (0 << TMAG5273_I2C_ADDRESS_UPDATE_EN_POS)
#define TMAG5273_I2C_ADDRESS_UPDATE_ENABLE (1 << TMAG5273_I2C_ADDRESS_UPDATE_EN_POS)
/* Register DEVICE_ID */
#define TMAG5273_VER_POS 0
#define TMAG3001_VER_POS 2
#define TMAG5273_VER_MSK GENMASK(3, 0)
#define TMAG5273_VER_TMAG5273X1 (1 << TMAG5273_VER_POS)
#define TMAG5273_VER_TMAG5273X2 (2 << TMAG5273_VER_POS)
#define TMAG5273_VER_TMAG3001X1 (0 << TMAG3001_VER_POS)
#define TMAG5273_VER_TMAG3001X2 (2 << TMAG3001_VER_POS)
/* Register CONV_STATUS */
#define TMAG5273_SET_COUNT_POS 5
#define TMAG5273_POR_POS 4
#define TMAG5273_DIAG_STATUS_POS 1
#define TMAG5273_RESULT_STATUS_POS 0
#define TMAG5273_DIAG_STATUS_MSK GENMASK(1, 1)
#define TMAG5273_RESULT_STATUS_MSK GENMASK(0, 0)
#define TMAG5273_POR_OCCURRED (1 << TMAG5273_POR_POS)
#define TMAG5273_DIAG_FAIL (1 << TMAG5273_DIAG_STATUS_POS)
#define TMAG5273_CONVERSION_COMPLETE (1 << TMAG5273_RESULT_STATUS_POS)
/* Register DEVICE_STATUS */
#define TMAG5273_INTB_RB_POS 4
#define TMAG5273_OSC_ER_POS 3
#define TMAG5273_INT_ER_POS 2
#define TMAG5273_OTP_CRC_ER_POS 1
#define TMAG5273_VCC_UV_ER_POS 0
#define TMAG5273_INTB_RB_MSK GENMASK(4, 4)
#define TMAG5273_OSC_ER_MSK GENMASK(3, 3)
#define TMAG5273_INT_ER_MSK GENMASK(2, 2)
#define TMAG5273_OTP_CRC_ER_MSK GENMASK(1, 1)
#define TMAG5273_VCC_UV_ER_MSK GENMASK(0, 0)
#define TMAG5273_INTB_PIN_HIGH (1 << TMAG5273_INTB_RB_POS)
#define TMAG5273_OSC_ERR (1 << TMAG5273_OSC_ER_POS)
#define TMAG5273_INT_ERR (1 << TMAG5273_INT_ER_POS)
#define TMAG5273_OTP_CRC_ERR (1 << TMAG5273_OTP_CRC_ER_POS)
#define TMAG5273_VCC_UV_ERR (1 << TMAG5273_VCC_UV_ER_POS)
#define TMAG5273_RESET_DEVICE_STATUS 0xF
/* additional values */
#define TMAG5273_MANUFACTURER_ID_MSB 0x54
#define TMAG5273_MANUFACTURER_ID_LSB 0x49
#define TMAG5273_MEAS_RANGE_LOW_MT_VER1 40
#define TMAG5273_MEAS_RANGE_HIGH_MT_VER1 80
#define TMAG5273_MEAS_RANGE_LOW_MT_VER2 133
#define TMAG5273_MEAS_RANGE_HIGH_MT_VER2 266
#define TMAG3001_MEAS_RANGE_LOW_MT_VER1 40
#define TMAG3001_MEAS_RANGE_HIGH_MT_VER1 80
#define TMAG3001_MEAS_RANGE_LOW_MT_VER2 120
#define TMAG3001_MEAS_RANGE_HIGH_MT_VER2 240
#define TMAG5273_TEMPERATURE_T_SENS_T0 25
#define TMAG5273_TEMPERATURE_T_ADC_T0 17508
#define TMAG5273_TEMPERATURE_T_ADC_RES 60.1
#define TMAG5273_T_START_SLEEP_US 50
#define TMAG5273_T_GO_SLEEP_US 20
/**
* @brief calculate conversion time as defined in the datasheet
* @param avg set averaging value
* @param nb_channels number of captured channels
*/
#define TMAG5273_T_CONVERSION_US(avg, nb_channels) (((1 << avg) * 25) * nb_channels + 25)
/** OR this bit to any register address to trigger a conversion in standby mode */
#define TMAG5273_CONVERSION_START_BIT 0x80
#endif /* ZEPHYR_DRIVERS_SENSOR_TMAG5273_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/tmag5273/tmag5273.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,867 |
```unknown
# TMAG5273 Low-Power Linear 3D Hall-Effect Sensor configuration options
config TMAG5273
bool "TMAG5273/TMAG3001 3D Hall-Effect Sensor"
default y
depends on DT_HAS_TI_TMAG5273_ENABLED
select I2C
select GPIO
imply CRC
help
Enable driver for TMAG5273 and TMAG3001 I2C-based 3d Hall-Effect sensor.
``` | /content/code_sandbox/drivers/sensor/ti/tmag5273/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 99 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmp108
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include "tmp108.h"
LOG_MODULE_REGISTER(TMP108, CONFIG_SENSOR_LOG_LEVEL);
int tmp108_reg_read(const struct device *dev, uint8_t reg, uint16_t *val)
{
const struct tmp108_config *cfg = dev->config;
int result;
result = i2c_burst_read_dt(&cfg->i2c_spec, reg, (uint8_t *) val, 2);
if (result < 0) {
return result;
}
*val = sys_be16_to_cpu(*val);
return 0;
}
int tmp108_reg_write(const struct device *dev, uint8_t reg, uint16_t val)
{
const struct tmp108_config *cfg = dev->config;
uint8_t tx_buf[3];
int result;
tx_buf[0] = reg;
sys_put_be16(val, &tx_buf[1]);
result = i2c_write_dt(&cfg->i2c_spec, tx_buf, sizeof(tx_buf));
if (result < 0) {
return result;
}
return 0;
}
int tmp108_write_config(const struct device *dev, uint16_t mask, uint16_t conf)
{
uint16_t config = 0;
int result;
result = tmp108_reg_read(dev, TI_TMP108_REG_CONF, &config);
if (result < 0) {
return result;
}
config &= mask;
config |= conf;
result = tmp108_reg_write(dev, TI_TMP108_REG_CONF, config);
if (result < 0) {
return result;
}
return 0;
}
int ti_tmp108_read_temp(const struct device *dev)
{
struct tmp108_data *drv_data = dev->data;
int result;
/* clear previous temperature readings */
drv_data->sample = 0U;
/* Get the most recent temperature measurement */
result = tmp108_reg_read(dev, TI_TMP108_REG_TEMP, &drv_data->sample);
if (result < 0) {
return result;
}
return 0;
}
static int tmp108_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct tmp108_data *drv_data = dev->data;
int result;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
/* If one shot mode is set, query chip for reading
* should be finished 30 ms later
*/
if (drv_data->one_shot_mode == true) {
result = tmp108_write_config(dev,
TI_TMP108_MODE_MASK(dev),
TI_TMP108_MODE_ONE_SHOT(dev));
if (result < 0) {
return result;
}
/* Schedule read to start in 30 ms if mode change was successful
* the typical wakeup time given in the data sheet is 27
*/
result = k_work_schedule(&drv_data->scheduled_work,
K_MSEC(TMP108_WAKEUP_TIME_IN_MS(dev)));
if (result < 0) {
return result;
}
return 0;
}
result = ti_tmp108_read_temp(dev);
if (result < 0) {
return result;
}
return 0;
}
static int tmp108_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct tmp108_data *drv_data = dev->data;
int32_t uval;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
uval = ((int32_t)drv_data->sample * TMP108_TEMP_MULTIPLIER(dev)) / TMP108_TEMP_DIVISOR(dev);
val->val1 = uval / 1000000;
val->val2 = uval % 1000000;
return 0;
}
static int tmp108_attr_get(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
struct sensor_value *val)
{
int result;
uint16_t tmp_val;
if (chan != SENSOR_CHAN_AMBIENT_TEMP && chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
switch ((int) attr) {
case SENSOR_ATTR_CONFIGURATION:
result = tmp108_reg_read(dev,
TI_TMP108_REG_CONF,
&tmp_val);
val->val1 = tmp_val;
val->val2 = 0;
break;
default:
return -ENOTSUP;
}
return result;
}
static int tmp108_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct tmp108_data *drv_data = dev->data;
uint16_t mode = 0;
uint16_t reg_value = 0;
int result = 0;
int32_t uval;
if (chan != SENSOR_CHAN_AMBIENT_TEMP && chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
switch ((int) attr) {
case SENSOR_ATTR_HYSTERESIS:
if (TI_TMP108_HYSTER_0_C(dev) == TI_TMP108_CONF_NA) {
LOG_WRN("AS621x Series lacks Hysterisis setttings");
return -ENOTSUP;
}
if (val->val1 < 1) {
mode = TI_TMP108_HYSTER_0_C(dev);
} else if (val->val1 < 2) {
mode = TI_TMP108_HYSTER_1_C(dev);
} else if (val->val1 < 4) {
mode = TI_TMP108_HYSTER_2_C(dev);
} else {
mode = TI_TMP108_HYSTER_4_C(dev);
}
result = tmp108_write_config(dev,
TI_TMP108_HYSTER_MASK(dev),
mode);
break;
case SENSOR_ATTR_ALERT:
/* Spec Sheet Errata: TM is set on reset not cleared */
if (val->val1 == 1) {
mode = TI_TMP108_CONF_TM_INT(dev);
} else {
mode = TI_TMP108_CONF_TM_CMP(dev);
}
result = tmp108_write_config(dev,
TI_TMP108_CONF_TM_MASK(dev),
mode);
break;
case SENSOR_ATTR_LOWER_THRESH:
uval = val->val1 * 1000000 + val->val2;
reg_value = (uval * TMP108_TEMP_DIVISOR(dev)) / TMP108_TEMP_MULTIPLIER(dev);
result = tmp108_reg_write(dev,
TI_TMP108_REG_LOW_LIMIT,
reg_value);
break;
case SENSOR_ATTR_UPPER_THRESH:
uval = val->val1 * 1000000 + val->val2;
reg_value = (uval * TMP108_TEMP_DIVISOR(dev)) / TMP108_TEMP_MULTIPLIER(dev);
result = tmp108_reg_write(dev,
TI_TMP108_REG_HIGH_LIMIT,
reg_value);
break;
case SENSOR_ATTR_SAMPLING_FREQUENCY:
if (val->val1 < 1) {
mode = TI_TMP108_FREQ_4_SECS(dev);
} else if (val->val1 < 4) {
mode = TI_TMP108_FREQ_1_HZ(dev);
} else if (val->val1 < 16) {
mode = TI_TMP108_FREQ_4_HZ(dev);
} else {
mode = TI_TMP108_FREQ_16_HZ(dev);
}
result = tmp108_write_config(dev,
TI_TMP108_FREQ_MASK(dev),
mode);
break;
case SENSOR_ATTR_TMP108_SHUTDOWN_MODE:
result = tmp108_write_config(dev,
TI_TMP108_MODE_MASK(dev),
TI_TMP108_MODE_SHUTDOWN(dev));
drv_data->one_shot_mode = false;
break;
case SENSOR_ATTR_TMP108_CONTINUOUS_CONVERSION_MODE:
result = tmp108_write_config(dev,
TI_TMP108_MODE_MASK(dev),
TI_TMP108_MODE_CONTINUOUS(dev));
drv_data->one_shot_mode = false;
break;
case SENSOR_ATTR_TMP108_ONE_SHOT_MODE:
result = tmp108_write_config(dev,
TI_TMP108_MODE_MASK(dev),
TI_TMP108_MODE_ONE_SHOT(dev));
drv_data->one_shot_mode = true;
break;
case SENSOR_ATTR_TMP108_ALERT_POLARITY:
if (val->val1 == 1) {
mode = TI_TMP108_CONF_POL_HIGH(dev);
} else {
mode = TI_TMP108_CONF_POL_LOW(dev);
}
result = tmp108_write_config(dev,
TI_TMP108_CONF_POL_MASK(dev),
mode);
break;
default:
return -ENOTSUP;
}
if (result < 0) {
return result;
}
return 0;
}
static const struct sensor_driver_api tmp108_driver_api = {
.attr_set = tmp108_attr_set,
.attr_get = tmp108_attr_get,
.sample_fetch = tmp108_sample_fetch,
.channel_get = tmp108_channel_get,
.trigger_set = tmp_108_trigger_set,
};
#ifdef CONFIG_TMP108_ALERT_INTERRUPTS
static int setup_interrupts(const struct device *dev)
{
struct tmp108_data *drv_data = dev->data;
const struct tmp108_config *config = dev->config;
const struct gpio_dt_spec *alert_gpio = &config->alert_gpio;
int result;
if (!device_is_ready(alert_gpio->port)) {
LOG_ERR("tmp108: gpio controller %s not ready",
alert_gpio->port->name);
return -ENODEV;
}
result = gpio_pin_configure_dt(alert_gpio, GPIO_INPUT);
if (result < 0) {
return result;
}
gpio_init_callback(&drv_data->temp_alert_gpio_cb,
tmp108_trigger_handle_alert,
BIT(alert_gpio->pin));
result = gpio_add_callback(alert_gpio->port,
&drv_data->temp_alert_gpio_cb);
if (result < 0) {
return result;
}
result = gpio_pin_interrupt_configure_dt(alert_gpio,
GPIO_INT_EDGE_BOTH);
if (result < 0) {
return result;
}
return 0;
}
#endif
static int tmp108_init(const struct device *dev)
{
const struct tmp108_config *cfg = dev->config;
struct tmp108_data *drv_data = dev->data;
int result = 0;
if (!device_is_ready(cfg->i2c_spec.bus)) {
LOG_ERR("I2C dev %s not ready", cfg->i2c_spec.bus->name);
return -ENODEV;
}
drv_data->scheduled_work.work.handler = tmp108_trigger_handle_one_shot;
/* save this driver instance for passing to other functions */
drv_data->tmp108_dev = dev;
#ifdef CONFIG_TMP108_ALERT_INTERRUPTS
result = setup_interrupts(dev);
if (result < 0) {
return result;
}
#endif
/* clear and set configuration registers back to default values */
result = tmp108_write_config(dev,
0x0000,
TMP108_CONF_RST(dev));
return result;
}
#define TMP108_DEFINE(inst, t) \
static struct tmp108_data tmp108_prv_data_##inst##t; \
static const struct tmp108_config tmp108_config_##inst##t = { \
.i2c_spec = I2C_DT_SPEC_INST_GET(inst), \
.alert_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, \
alert_gpios, { 0 }),\
.reg_def = t##_CONF \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
&tmp108_init, \
NULL, \
&tmp108_prv_data_##inst##t, \
&tmp108_config_##inst##t, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&tmp108_driver_api);
#define TMP108_INIT(n) TMP108_DEFINE(n, TI_TMP108)
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT ti_tmp108
DT_INST_FOREACH_STATUS_OKAY(TMP108_INIT)
#define AS6212_INIT(n) TMP108_DEFINE(n, AMS_AS6212)
#undef DT_DRV_COMPAT
#define DT_DRV_COMPAT ams_as6212
DT_INST_FOREACH_STATUS_OKAY(AS6212_INIT)
``` | /content/code_sandbox/drivers/sensor/ti/tmp108/tmp108.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,672 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TMP108_TMP108_H_
#define ZEPHYR_DRIVERS_SENSOR_TMP108_TMP108_H_
#include <stdint.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor/tmp108.h>
#define TI_TMP108_REG_TEMP 0x00 /** Temperature register */
#define TI_TMP108_REG_CONF 0x01 /** Configuration register */
#define TI_TMP108_REG_LOW_LIMIT 0x02 /** Low alert set register */
#define TI_TMP108_REG_HIGH_LIMIT 0x03 /** High alert set register */
#define AMS_AS6212_CONF {.CONF_HYS1 = TI_TMP108_CONF_NA,\
.CONF_HYS0 = TI_TMP108_CONF_NA,\
.CONF_CR0 = 0x0040, \
.CONF_CR1 = 0x0080, \
.CONF_M1 = 0x0000, \
.CONF_TM = 0x0200, \
.CONF_POL = 0x0400, \
.CONF_M0 = 0x8000, \
.CONF_RST = 0x0080, \
.TEMP_MULT = 15625, \
.TEMP_DIV = 2, \
.WAKEUP_TIME_IN_MS = 120 }
#define TI_TMP108_CONF {.CONF_HYS0 = 0x0010, \
.CONF_HYS1 = 0x0020, \
.CONF_POL = 0x0080, \
.CONF_M0 = 0x0100, \
.CONF_M1 = 0x0200, \
.CONF_TM = 0x0400, \
.CONF_CR0 = 0x2000, \
.CONF_CR1 = 0x4000, \
.CONF_RST = 0x0022, \
.TEMP_MULT = 15625, \
.TEMP_DIV = 4, \
.WAKEUP_TIME_IN_MS = 30 }
#define TI_TMP108_MODE_SHUTDOWN(x) 0
#define TI_TMP108_MODE_ONE_SHOT(x) TI_TMP108_CONF_M0(x)
#define TI_TMP108_MODE_CONTINUOUS(x) TI_TMP108_CONF_M1(x)
#define TI_TMP108_MODE_MASK(x) ~(TI_TMP108_CONF_M0(x) | TI_TMP108_CONF_M1(x))
#define TI_TMP108_FREQ_4_SECS(x) 0
#define TI_TMP108_FREQ_1_HZ(x) TI_TMP108_GET_CONF(x, CONF_CR0)
#define TI_TMP108_FREQ_4_HZ(x) TI_TMP108_GET_CONF(x, CONF_CR1)
#define TI_TMP108_FREQ_16_HZ(x) (TI_TMP108_GET_CONF(x, CONF_CR1) | \
TI_TMP108_GET_CONF(x, CONF_CR0))
#define TI_TMP108_FREQ_MASK(x) ~(TI_TMP108_GET_CONF(x, CONF_CR1) | \
TI_TMP108_GET_CONF(x, CONF_CR0))
#define TI_TMP108_CONF_POL_LOW(x) 0
#define TI_TMP108_CONF_POL_HIGH(x) TI_TMP108_GET_CONF(x, CONF_POL)
#define TI_TMP108_CONF_POL_MASK(x) ~(TI_TMP108_GET_CONF(x, CONF_POL))
#define TI_TMP108_CONF_TM_CMP(x) 0
#define TI_TMP108_CONF_TM_INT(x) TI_TMP108_GET_CONF(x, CONF_TM)
#define TI_TMP108_CONF_TM_MASK(x) ~(TI_TMP108_GET_CONF(x, CONF_TM))
#define TI_TMP108_HYSTER_0_C(x) 0
#define TI_TMP108_HYSTER_1_C(x) TI_TMP108_GET_CONF(x, CONF_HYS0)
#define TI_TMP108_HYSTER_2_C(x) TI_TMP108_GET_CONF(x, CONF_HYS1)
#define TI_TMP108_HYSTER_4_C(x) (TI_TMP108_GET_CONF(x, CONF_HYS1) | \
TI_TMP108_GET_CONF(x, CONF_HYS0))
#define TI_TMP108_HYSTER_MASK(x) ~(TI_TMP108_GET_CONF(x, CONF_HYS1) | \
TI_TMP108_GET_CONF(x, CONF_HYS0))
#define TI_TMP108_CONF_M1(x) TI_TMP108_GET_CONF(x, CONF_M1)
#define TI_TMP108_CONF_M0(x) TI_TMP108_GET_CONF(x, CONF_M0)
#define TMP108_TEMP_MULTIPLIER(x) TI_TMP108_GET_CONF(x, TEMP_MULT)
#define TMP108_TEMP_DIVISOR(x) TI_TMP108_GET_CONF(x, TEMP_DIV)
#define TMP108_WAKEUP_TIME_IN_MS(x) TI_TMP108_GET_CONF(x, WAKEUP_TIME_IN_MS)
#define TMP108_CONF_RST(x) TI_TMP108_GET_CONF(x, CONF_RST)
#define TI_TMP108_CONF_NA 0x0000
struct tmp_108_reg_def {
uint16_t CONF_M0; /** Mode 1 configuration bit */
uint16_t CONF_M1; /** Mode 2 configuration bit */
uint16_t CONF_CR0; /** Conversion rate 1 configuration bit */
uint16_t CONF_CR1; /** Conversion rate 2 configuration bit */
uint16_t CONF_POL; /** Alert pin Polarity configuration bit */
uint16_t CONF_TM; /** Thermostat mode setting bit */
uint16_t CONF_HYS1; /** Temperature hysteresis config 1 bit */
uint16_t CONF_HYS0; /** Temperature hysteresis config 2 bit */
int32_t TEMP_MULT; /** Temperature multiplier */
int32_t TEMP_DIV; /** Temperature divisor */
uint16_t WAKEUP_TIME_IN_MS; /** Wake up and conversion time from one shot */
uint16_t CONF_RST; /** default reset values on init */
};
#define TI_TMP108_GET_CONF(x, cfg) ((struct tmp108_config *)(x->config))->reg_def.cfg
struct tmp108_config {
const struct i2c_dt_spec i2c_spec;
const struct gpio_dt_spec alert_gpio;
struct tmp_108_reg_def reg_def;
};
struct tmp108_data {
const struct device *tmp108_dev;
int16_t sample;
bool one_shot_mode;
struct k_work_delayable scheduled_work;
const struct sensor_trigger *temp_alert_trigger;
sensor_trigger_handler_t temp_alert_handler;
sensor_trigger_handler_t data_ready_handler;
const struct sensor_trigger *data_ready_trigger;
struct gpio_callback temp_alert_gpio_cb;
};
int tmp_108_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int tmp108_reg_read(const struct device *dev, uint8_t reg, uint16_t *val);
int ti_tmp108_read_temp(const struct device *dev);
void tmp108_trigger_handle_one_shot(struct k_work *work);
void tmp108_trigger_handle_alert(const struct device *port,
struct gpio_callback *cb,
gpio_port_pins_t pins);
#endif /* ZEPHYR_DRIVERS_SENSOR_TMP108_TMP108_H_ */
``` | /content/code_sandbox/drivers/sensor/ti/tmp108/tmp108.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,536 |
```c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include "tmp108.h"
#define TMP108_ONE_SHOT_RETRY_TIME_IN_MS 10
LOG_MODULE_DECLARE(TMP108, CONFIG_SENSOR_LOG_LEVEL);
void tmp108_trigger_handle_one_shot(struct k_work *work)
{
struct k_work_delayable *delayable_work = k_work_delayable_from_work(work);
struct tmp108_data *drv_data = CONTAINER_OF(delayable_work,
struct tmp108_data,
scheduled_work);
uint16_t config = 0;
bool shutdown_mode = false;
tmp108_reg_read(drv_data->tmp108_dev, TI_TMP108_REG_CONF, &config);
/* check shutdown mode which indicates a one shot read was successful */
shutdown_mode = (config & (TI_TMP108_CONF_M1(drv_data->tmp108_dev) |
TI_TMP108_CONF_M0(drv_data->tmp108_dev))) == 0;
if (shutdown_mode == true) {
ti_tmp108_read_temp(drv_data->tmp108_dev);
} else {
LOG_ERR("Temperature one shot mode read failed, retrying");
/* Wait for typical wake up time, retry if the read fails
* assuming the chip should wake up and take a reading after the typical
* wake up time and call of this thread plus 10 ms time has passed
*/
k_work_reschedule(&drv_data->scheduled_work,
K_MSEC(TMP108_ONE_SHOT_RETRY_TIME_IN_MS));
return;
}
/* Successful read, call set callbacks */
if (drv_data->data_ready_handler) {
drv_data->data_ready_handler(drv_data->tmp108_dev,
drv_data->data_ready_trigger);
}
}
void tmp108_trigger_handle_alert(const struct device *gpio,
struct gpio_callback *cb,
gpio_port_pins_t pins)
{
struct tmp108_data *drv_data = CONTAINER_OF(cb,
struct tmp108_data,
temp_alert_gpio_cb);
/* Successful read, call set callbacks */
if (drv_data->temp_alert_handler) {
drv_data->temp_alert_handler(drv_data->tmp108_dev,
drv_data->temp_alert_trigger);
}
}
int tmp_108_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct tmp108_data *drv_data = dev->data;
if (trig->type == SENSOR_TRIG_DATA_READY) {
drv_data->data_ready_handler = handler;
drv_data->data_ready_trigger = trig;
return 0;
}
if (trig->type == SENSOR_TRIG_THRESHOLD) {
drv_data->temp_alert_handler = handler;
drv_data->temp_alert_trigger = trig;
return 0;
}
return -ENOTSUP;
}
``` | /content/code_sandbox/drivers/sensor/ti/tmp108/tmp108_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 612 |
```unknown
# TMP108 temperature sensor configuration options
menuconfig TMP108
bool "TMP108 Temperature Sensor"
default y
depends on DT_HAS_TI_TMP108_ENABLED || DT_HAS_AMS_AS6212_ENABLED
select I2C
help
Enable driver for the TMP108 temperature sensor and/or it's variant
the AMS AS621.
if TMP108
config TMP108_ALERT_INTERRUPTS
bool "Allow interrupts to service over and under temp alerts"
help
This will set up interrupts to service under and over temp alerts
see TMP108 spec sheet for more information on how these work.
endif # TMP108
``` | /content/code_sandbox/drivers/sensor/ti/tmp108/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 129 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_ina3221
#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 "ina3221.h"
LOG_MODULE_REGISTER(INA3221, CONFIG_SENSOR_LOG_LEVEL);
#define MAX_RETRIES 10
static int reg_read(const struct device *dev, uint8_t reg_addr, uint16_t *reg_data)
{
const struct ina3221_config *cfg = dev->config;
uint8_t rx_buf[2];
int rc;
rc = i2c_write_read_dt(&cfg->bus, ®_addr, sizeof(reg_addr), rx_buf, sizeof(rx_buf));
*reg_data = sys_get_be16(rx_buf);
return rc;
}
static int reg_write(const struct device *dev, uint8_t addr, uint16_t reg_data)
{
const struct ina3221_config *cfg = dev->config;
uint8_t tx_buf[3];
tx_buf[0] = addr;
sys_put_be16(reg_data, &tx_buf[1]);
return i2c_write_dt(&cfg->bus, tx_buf, sizeof(tx_buf));
}
static int ina3221_init(const struct device *dev)
{
int ret;
const struct ina3221_config *cfg = dev->config;
struct ina3221_data *data = dev->data;
uint16_t reg_data;
__ASSERT_NO_MSG(cfg->avg_mode < 8);
__ASSERT_NO_MSG(cfg->conv_time_bus < 8);
__ASSERT_NO_MSG(cfg->conv_time_shunt < 8);
/* select first enabled channel */
for (size_t i = 0; i < 3; ++i) {
if (cfg->enable_channel[i]) {
data->selected_channel = i;
break;
}
}
/* check bus */
if (!i2c_is_ready_dt(&cfg->bus)) {
LOG_ERR("Device not ready.");
return -ENODEV;
}
/* check connection */
ret = reg_read(dev, INA3221_MANUF_ID, ®_data);
if (ret) {
LOG_ERR("No answer from sensor.");
return ret;
}
if (reg_data != INA3221_MANUF_ID_VALUE) {
LOG_ERR("Unexpected manufacturer ID: 0x%04x", reg_data);
return -EFAULT;
}
ret = reg_read(dev, INA3221_CHIP_ID, ®_data);
if (ret) {
return ret;
}
if (reg_data != INA3221_CHIP_ID_VALUE) {
LOG_ERR("Unexpected chip ID: 0x%04x", reg_data);
return -EFAULT;
}
/* reset */
ret = reg_read(dev, INA3221_CONFIG, ®_data);
if (ret) {
return ret;
}
reg_data |= INA3221_CONFIG_RST;
ret = reg_write(dev, INA3221_CONFIG, reg_data);
if (ret) {
return ret;
}
/* configure */
reg_data = (cfg->conv_time_shunt << 3) | (cfg->conv_time_bus << 6) | (cfg->avg_mode << 9) |
(INA3221_CONFIG_CH1 * cfg->enable_channel[0]) |
(INA3221_CONFIG_CH2 * cfg->enable_channel[1]) |
(INA3221_CONFIG_CH3 * cfg->enable_channel[2]);
ret = reg_write(dev, INA3221_CONFIG, reg_data);
if (ret) {
return ret;
}
return 0;
}
static int start_measurement(const struct device *dev, bool bus, bool shunt)
{
int ret;
uint16_t reg_data;
ret = reg_read(dev, INA3221_CONFIG, ®_data);
if (ret) {
return ret;
}
reg_data &= ~(INA3221_CONFIG_BUS | INA3221_CONFIG_SHUNT);
reg_data |= (INA3221_CONFIG_BUS * bus) | (INA3221_CONFIG_SHUNT * shunt);
ret = reg_write(dev, INA3221_CONFIG, reg_data);
if (ret) {
return ret;
}
return 0;
}
static bool measurement_ready(const struct device *dev)
{
int ret;
uint16_t reg_data;
ret = reg_read(dev, INA3221_MASK_ENABLE, ®_data);
if (ret) {
return false;
}
return reg_data & INA3221_MASK_ENABLE_CONVERSION_READY;
}
static int ina3221_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ina3221_data *data = dev->data;
const struct ina3221_config *cfg = dev->config;
bool measurement_successful = false;
k_timeout_t measurement_time = K_NO_WAIT;
int ret;
/* Trigger measurement and wait for completion */
if (chan == SENSOR_CHAN_VOLTAGE) {
ret = start_measurement(dev, true, false);
if (ret) {
return ret;
}
measurement_time =
K_USEC(avg_mode_samples[cfg->avg_mode] *
conv_time_us[cfg->conv_time_bus]);
} else if (chan == SENSOR_CHAN_CURRENT) {
ret = start_measurement(dev, false, true);
if (ret) {
return ret;
}
measurement_time =
K_USEC(avg_mode_samples[cfg->avg_mode] *
conv_time_us[cfg->conv_time_shunt]);
} else if (chan == SENSOR_CHAN_POWER || chan == SENSOR_CHAN_ALL) {
ret = start_measurement(dev, true, true);
if (ret) {
return ret;
}
measurement_time =
K_USEC(avg_mode_samples[cfg->avg_mode] *
conv_time_us[MAX(cfg->conv_time_shunt, cfg->conv_time_bus)]);
} else {
return -ENOTSUP;
}
for (size_t i = 0; i < MAX_RETRIES; ++i) {
k_sleep(measurement_time);
if (measurement_ready(dev)) {
measurement_successful = true;
break;
}
}
if (!measurement_successful) {
LOG_ERR("Measurement timed out.");
return -EFAULT;
}
for (size_t i = 0; i < 3; ++i) {
if (!cfg->enable_channel[i]) {
continue;
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_POWER ||
chan == SENSOR_CHAN_VOLTAGE) {
ret = reg_read(dev, INA3221_BUS_V1 + 2 * i, &(data->v_bus[i]));
if (ret) {
return ret;
}
data->v_bus[i] = data->v_bus[i] >> 3;
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_POWER ||
chan == SENSOR_CHAN_CURRENT) {
ret = reg_read(dev, INA3221_SHUNT_V1 + 2 * i, &(data->v_shunt[i]));
if (ret) {
return ret;
}
data->v_shunt[i] = data->v_shunt[i] >> 3;
}
}
return ret;
}
static int ina3221_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct ina3221_config *cfg = dev->config;
struct ina3221_data *data = dev->data;
float result;
switch (chan) {
case SENSOR_CHAN_VOLTAGE:
result = data->v_bus[data->selected_channel] * INA3221_BUS_VOLTAGE_LSB;
break;
case SENSOR_CHAN_CURRENT:
result = data->v_shunt[data->selected_channel] * INA3221_SHUNT_VOLTAGE_LSB /
(cfg->shunt_r[data->selected_channel] / 1000.0f);
break;
case SENSOR_CHAN_POWER:
result = data->v_bus[data->selected_channel] * INA3221_BUS_VOLTAGE_LSB *
data->v_shunt[data->selected_channel] * INA3221_SHUNT_VOLTAGE_LSB /
(cfg->shunt_r[data->selected_channel] / 1000.0f);
break;
default:
LOG_DBG("Channel not supported by device!");
return -ENOTSUP;
}
return sensor_value_from_float(val, result);
}
static int ina3221_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
ARG_UNUSED(chan);
if (attr != SENSOR_ATTR_INA3221_SELECTED_CHANNEL) {
return -ENOTSUP;
}
struct ina3221_data *data = dev->data;
if (val->val1 < 1 || val->val1 > 3) {
return -EINVAL;
}
data->selected_channel = val->val1 - 1;
return 0;
}
static const struct sensor_driver_api ina3221_api = {
.sample_fetch = ina3221_sample_fetch,
.channel_get = ina3221_channel_get,
.attr_set = ina3221_attr_set,
};
#define INST_DT_INA3221(index) \
static const struct ina3221_config ina3221_config_##index = { \
.bus = I2C_DT_SPEC_INST_GET(index), \
.avg_mode = DT_INST_PROP(index, avg_mode), \
.conv_time_bus = DT_INST_PROP(index, conv_time_bus), \
.conv_time_shunt = DT_INST_PROP(index, conv_time_shunt), \
.enable_channel = DT_INST_PROP(index, enable_channel), \
.shunt_r = DT_INST_PROP(index, shunt_resistors), \
}; \
static struct ina3221_data ina3221_data_##index; \
\
SENSOR_DEVICE_DT_INST_DEFINE(index, ina3221_init, NULL, &ina3221_data_##index, \
&ina3221_config_##index, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&ina3221_api);
DT_INST_FOREACH_STATUS_OKAY(INST_DT_INA3221);
``` | /content/code_sandbox/drivers/sensor/ti/ina3221/ina3221.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,186 |
```objective-c
/*
*
*/
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#define INA3221_CONFIG 0x00
#define INA3221_SHUNT_V1 0x01
#define INA3221_BUS_V1 0x02
#define INA3221_SHUNT_V2 0x03
#define INA3221_BUS_V2 0x04
#define INA3221_SHUNT_V3 0x05
#define INA3221_BUS_V3 0x06
#define INA3221_MASK_ENABLE 0x0f
#define INA3221_MANUF_ID 0xfe
#define INA3221_MANUF_ID_VALUE 0x5449
#define INA3221_CHIP_ID 0xff
#define INA3221_CHIP_ID_VALUE 0x3220
#define INA3221_MASK_ENABLE_CONVERSION_READY BIT(0)
#define INA3221_CONFIG_RST BIT(15)
#define INA3221_CONFIG_CH1 BIT(14)
#define INA3221_CONFIG_CH2 BIT(13)
#define INA3221_CONFIG_CH3 BIT(12)
#define INA3221_CONFIG_AVG_Msk GENMASK(11, 9)
#define INA3221_CONFIG_CT_VBUS_Msk GENMASK(8, 6)
#define INA3221_CONFIG_CT_VSH_Msk GENMASK(5, 3)
#define INA3221_CONFIG_CONTINUOUS BIT(2)
#define INA3221_CONFIG_BUS BIT(1)
#define INA3221_CONFIG_SHUNT BIT(0)
#define INA3221_BUS_VOLTAGE_LSB 0.008f
#define INA3221_SHUNT_VOLTAGE_LSB 0.00004f
#define SENSOR_ATTR_INA3221_SELECTED_CHANNEL (SENSOR_ATTR_PRIV_START+1)
enum ina3221_avg_mode {
INA3221_AVG_MODE_1 = 0,
INA3221_AVG_MODE_4,
INA3221_AVG_MODE_16,
INA3221_AVG_MODE_64,
INA3221_AVG_MODE_128,
INA3221_AVG_MODE_256,
INA3221_AVG_MODE_512,
INA3221_AVG_MODE_1024,
};
enum ina3221_conv_time {
INA3221_CONV_TIME_0_140ms = 0,
INA3221_CONV_TIME_0_204ms,
INA3221_CONV_TIME_0_332ms,
INA3221_CONV_TIME_0_588ms,
INA3221_CONV_TIME_1_100ms,
INA3221_CONV_TIME_2_116ms,
INA3221_CONV_TIME_4_156ms,
INA3221_CONV_TIME_8_244ms,
};
static const int32_t avg_mode_samples[8] = {1, 4, 16, 64, 128, 256, 512, 1024};
static const int32_t conv_time_us[8] = {140, 204, 332, 588, 1100, 2116, 4156, 8244};
struct ina3221_config {
struct i2c_dt_spec bus;
enum ina3221_avg_mode avg_mode;
enum ina3221_conv_time conv_time_bus;
enum ina3221_conv_time conv_time_shunt;
bool enable_channel[3];
uint16_t shunt_r[3];
};
struct ina3221_data {
size_t selected_channel;
uint16_t config;
int16_t v_bus[3];
int16_t v_shunt[3];
};
``` | /content/code_sandbox/drivers/sensor/ti/ina3221/ina3221.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 749 |
```unknown
# INA3221 Bidirectional Current/Power Monitor
config INA3221
bool "INA3221 Triple-Channel Current/Power Monitor"
default y
depends on DT_HAS_TI_INA3221_ENABLED
select I2C
help
Enable driver for INA3221 Triple-Channel Current/Power Monitor.
``` | /content/code_sandbox/drivers/sensor/ti/ina3221/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 67 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_tmag5273
#include "tmag5273.h"
#include <stdint.h>
#include <stdlib.h>
#include <zephyr/drivers/sensor/tmag5273.h>
#include <zephyr/dt-bindings/sensor/tmag5273.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/check.h>
#include <zephyr/sys/crc.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(TMAG5273, CONFIG_SENSOR_LOG_LEVEL);
#define CONV_FACTOR_MT_TO_GS 10
#define TMAG5273_CRC_DATA_BYTES 4
#define TMAG5273_CRC_I2C_SIZE COND_CODE_1(CONFIG_CRC, (1), (0))
/**
* @brief size of the buffer to read out all result data from the sensor
*
* Since the register counting is zero-based, one byte needs to be added to get the correct size.
* Also takes into account if CRC is enabled, which adds an additional byte for the CRC always
* located after the last read result byte.
*/
#define TMAG5273_I2C_BUFFER_SIZE \
(TMAG5273_REG_RESULT_END - TMAG5273_REG_RESULT_BEGIN + 1 + TMAG5273_CRC_I2C_SIZE)
/** static configuration data */
struct tmag5273_config {
struct i2c_dt_spec i2c;
uint8_t mag_channel;
uint8_t axis;
bool temperature;
uint8_t meas_range;
uint8_t temperature_coefficient;
uint8_t angle_magnitude_axis;
uint8_t ch_mag_gain_correction;
uint8_t operation_mode;
uint8_t averaging;
bool trigger_conv_via_int;
bool low_noise_mode;
bool ignore_diag_fail;
struct gpio_dt_spec int_gpio;
#ifdef CONFIG_CRC
bool crc_enabled;
#endif
};
struct tmag5273_data {
uint8_t version; /** version as given by the sensor */
uint16_t conversion_time_us; /** time for one conversion */
int16_t x_sample; /** measured B-field @x-axis */
int16_t y_sample; /** measured B-field @y-axis */
int16_t z_sample; /** measured B-field @z-axis */
int16_t temperature_sample; /** measured temperature data */
uint16_t xyz_range; /** magnetic range for x/y/z-axis in mT */
int16_t angle_sample; /** measured angle in degree, if activated */
uint8_t magnitude_sample; /** Positive vector magnitude (can be >7 bit). */
};
/**
* @brief resets the DEVICE_STATUS register
*
* @param dev driver handle
* @retval see @ref i2c_reg_write_byte
*/
static int tmag5273_reset_device_status(const struct device *dev)
{
const struct tmag5273_config *drv_cfg = dev->config;
return i2c_reg_write_byte_dt(&drv_cfg->i2c, TMAG5273_REG_DEVICE_STATUS,
TMAG5273_RESET_DEVICE_STATUS);
}
/**
* @brief checks for DIAG_FAIL errors and reads out the DEVICE_STATUS register if necessary
*
* @param[in] drv_cfg driver instance configuration
* @param[out] device_status DEVICE_STATUS register if DIAG_FAIL is set
*
* @retval 0 on success
* @retval "!= 0" on error
* - \c -EIO on any set error device status bit
* - see @ref i2c_reg_read_byte for error codes
*
* @note
* If tmag5273_config.ignore_diag_fail is set
* - \a device_status will be always set to \c 0,
* - the function always returns \c 0.
*/
static int tmag5273_check_device_status(const struct tmag5273_config *drv_cfg,
uint8_t *device_status)
{
int retval;
if (drv_cfg->ignore_diag_fail) {
*device_status = 0;
return 0;
}
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_CONV_STATUS, device_status);
if (retval < 0) {
LOG_ERR("error reading CONV_STATUS %d", retval);
return retval;
}
if ((*device_status & TMAG5273_DIAG_STATUS_MSK) != TMAG5273_DIAG_FAIL) {
/* no error */
*device_status = 0;
return 0;
}
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_DEVICE_STATUS, device_status);
if (retval < 0) {
LOG_ERR("error reading DEVICE_STATUS %d", retval);
return retval;
}
if ((*device_status & TMAG5273_VCC_UV_ER_MSK) == TMAG5273_VCC_UV_ERR) {
LOG_ERR("VCC under voltage detected");
}
#ifdef CONFIG_CRC
if (drv_cfg->crc_enabled &&
((*device_status & TMAG5273_OTP_CRC_ER_MSK) == TMAG5273_OTP_CRC_ERR)) {
LOG_ERR("OTP CRC error detected");
}
#endif
if ((*device_status & TMAG5273_INT_ER_MSK) == TMAG5273_INT_ERR) {
LOG_ERR("INT pin error detected");
}
if ((*device_status & TMAG5273_OSC_ER_MSK) == TMAG5273_OSC_ERR) {
LOG_ERR("Oscillator error detected");
}
return -EIO;
}
/**
* @brief performs a trigger through the INT-pin
*
* @param drv_cfg driver instance configuration
*
* @retval 0 on success
* @retval see @ref gpio_pin_set_dt
*/
static inline int tmag5273_dev_int_trigger(const struct tmag5273_config *drv_cfg)
{
int retval;
retval = gpio_pin_configure_dt(&drv_cfg->int_gpio, GPIO_OUTPUT);
if (retval < 0) {
return retval;
}
retval = gpio_pin_set_dt(&drv_cfg->int_gpio, 1);
if (retval < 0) {
return retval;
}
retval = gpio_pin_set_dt(&drv_cfg->int_gpio, 0);
if (retval < 0) {
return retval;
}
retval = gpio_pin_configure_dt(&drv_cfg->int_gpio, GPIO_INPUT);
if (retval < 0) {
return retval;
}
return 0;
}
/** @brief returns the high measurement range based on the chip version */
static inline uint16_t tmag5273_range_high(uint8_t version)
{
switch (version) {
case TMAG5273_VER_TMAG5273X1:
return TMAG5273_MEAS_RANGE_HIGH_MT_VER1;
case TMAG5273_VER_TMAG5273X2:
return TMAG5273_MEAS_RANGE_HIGH_MT_VER2;
case TMAG5273_VER_TMAG3001X1:
return TMAG3001_MEAS_RANGE_HIGH_MT_VER1;
case TMAG5273_VER_TMAG3001X2:
return TMAG3001_MEAS_RANGE_HIGH_MT_VER2;
default:
return -ENODEV;
}
}
/** @brief returns the low measurement range based on the chip version */
static inline uint16_t tmag5273_range_low(uint8_t version)
{
switch (version) {
case TMAG5273_VER_TMAG5273X1:
return TMAG5273_MEAS_RANGE_LOW_MT_VER1;
case TMAG5273_VER_TMAG5273X2:
return TMAG5273_MEAS_RANGE_LOW_MT_VER2;
case TMAG5273_VER_TMAG3001X1:
return TMAG3001_MEAS_RANGE_LOW_MT_VER1;
case TMAG5273_VER_TMAG3001X2:
return TMAG3001_MEAS_RANGE_LOW_MT_VER2;
default:
return -ENODEV;
}
}
/**
* @brief update the measurement range of the X/Y/Z-axis
*
* @param dev handle to the sensor
* @param val value to be set
*
* @return see @ref i2c_reg_update_byte_dt
*/
static inline int tmag5273_attr_set_xyz_meas_range(const struct device *dev,
const struct sensor_value *val)
{
const struct tmag5273_config *drv_cfg = dev->config;
struct tmag5273_data *drv_data = dev->data;
const uint16_t range_high = tmag5273_range_high(drv_data->version);
const uint16_t range_low = tmag5273_range_low(drv_data->version);
int retval;
uint8_t regdata;
uint16_t range;
if (val->val1 >= range_high) {
regdata = TMAG5273_XYZ_MEAS_RANGE_HIGH;
range = range_high;
} else {
regdata = TMAG5273_XYZ_MEAS_RANGE_LOW;
range = range_low;
}
retval = i2c_reg_update_byte_dt(&drv_cfg->i2c, TMAG5273_REG_SENSOR_CONFIG_2,
TMAG5273_MEAS_RANGE_XYZ_MSK, regdata);
if (retval < 0) {
return retval;
}
drv_data->xyz_range = range;
return 0;
}
/**
* @brief returns the used measurement range of the X/Y/Z-axis
*
* @param dev handle to the sensor
* @param val return value
*
* @return \c 0 on success
* @return see @ref i2c_reg_read_byte_dt
*/
static inline int tmag5273_attr_get_xyz_meas_range(const struct device *dev,
struct sensor_value *val)
{
const struct tmag5273_config *drv_cfg = dev->config;
struct tmag5273_data *drv_data = dev->data;
uint8_t regdata;
int retval;
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_SENSOR_CONFIG_2, ®data);
if (retval < 0) {
return retval;
}
if ((regdata & TMAG5273_MEAS_RANGE_XYZ_MSK) == TMAG5273_XYZ_MEAS_RANGE_HIGH) {
val->val1 = tmag5273_range_high(drv_data->version);
} else {
val->val1 = tmag5273_range_low(drv_data->version);
}
val->val2 = 0;
return 0;
}
/**
* set the X/Y/Z angle & magnitude calculation mode
*
* @param dev handle to the sensor
* @param val value to be set
*
* @return \c -ENOTSUP if unknown value
* @return see @ref i2c_reg_update_byte_dt
*/
static inline int tmag5273_attr_set_xyz_calc(const struct device *dev,
const struct sensor_value *val)
{
const struct tmag5273_config *drv_cfg = dev->config;
uint8_t regdata;
int retval;
switch (val->val1) {
case TMAG5273_ANGLE_CALC_NONE:
regdata = TMAG5273_ANGLE_EN_NONE;
break;
case TMAG5273_ANGLE_CALC_XY:
if (!(drv_cfg->axis & TMAG5273_MAG_CH_EN_X) ||
!(drv_cfg->axis & TMAG5273_MAG_CH_EN_Y)) {
return -ENOTSUP;
}
regdata = TMAG5273_ANGLE_EN_XY;
break;
case TMAG5273_ANGLE_CALC_YZ:
if (!(drv_cfg->axis & TMAG5273_MAG_CH_EN_Y) ||
!(drv_cfg->axis & TMAG5273_MAG_CH_EN_Z)) {
return -ENOTSUP;
}
regdata = TMAG5273_ANGLE_EN_YZ;
break;
case TMAG5273_ANGLE_CALC_XZ:
if (!(drv_cfg->axis & TMAG5273_MAG_CH_EN_X) ||
!(drv_cfg->axis & TMAG5273_MAG_CH_EN_Z)) {
return -ENOTSUP;
}
regdata = TMAG5273_ANGLE_EN_XZ;
break;
default:
LOG_ERR("unknown attribute value %d", val->val1);
return -ENOTSUP;
}
retval = i2c_reg_update_byte_dt(&drv_cfg->i2c, TMAG5273_REG_SENSOR_CONFIG_2,
TMAG5273_ANGLE_EN_MSK, regdata);
if (retval < 0) {
return retval;
}
return 0;
}
/**
* returns the X/Y/Z angle & magnitude calculation mode
*
* @param dev handle to the sensor
* @param val return value
*
* @return \c 0 on success
* @return see @ref i2c_reg_read_byte_dt
*/
static inline int tmag5273_attr_get_xyz_calc(const struct device *dev, struct sensor_value *val)
{
const struct tmag5273_config *drv_cfg = dev->config;
uint8_t regdata;
int retval;
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_SENSOR_CONFIG_2, ®data);
if (retval < 0) {
return retval;
}
switch (regdata & TMAG5273_ANGLE_EN_MSK) {
case TMAG5273_ANGLE_EN_XY:
val->val1 = TMAG5273_ANGLE_CALC_XY;
break;
case TMAG5273_ANGLE_EN_YZ:
val->val1 = TMAG5273_ANGLE_CALC_YZ;
break;
case TMAG5273_ANGLE_EN_XZ:
val->val1 = TMAG5273_ANGLE_CALC_XZ;
break;
case TMAG5273_ANGLE_EN_NONE:
__fallthrough;
default:
val->val1 = TMAG5273_ANGLE_CALC_NONE;
}
val->val2 = 0;
return 0;
}
/** @brief returns the number of bytes readable per block for i2c burst reads */
static inline uint8_t tmag5273_get_fetch_block_size(const struct tmag5273_config *drv_cfg,
uint8_t remaining_bytes)
{
#ifdef CONFIG_CRC
if (drv_cfg->crc_enabled && (remaining_bytes > TMAG5273_CRC_DATA_BYTES)) {
return TMAG5273_CRC_DATA_BYTES;
}
#endif
return remaining_bytes;
}
/** @brief returns the size of the CRC field if active */
static inline uint8_t tmag5273_get_crc_size(const struct tmag5273_config *drv_cfg)
{
#ifdef CONFIG_CRC
if (drv_cfg->crc_enabled) {
return TMAG5273_CRC_I2C_SIZE;
}
#else
ARG_UNUSED(drv_cfg);
#endif
return 0;
}
static int tmag5273_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
CHECKIF(dev == NULL) {
LOG_ERR("dev: NULL");
return -EINVAL;
}
CHECKIF(val == NULL) {
LOG_ERR("val: NULL");
return -EINVAL;
}
if (chan != SENSOR_CHAN_MAGN_XYZ) {
return -ENOTSUP;
}
const struct tmag5273_config *drv_cfg = dev->config;
int retval;
switch ((uint16_t)attr) {
case SENSOR_ATTR_FULL_SCALE:
if (drv_cfg->meas_range != TMAG5273_DT_AXIS_RANGE_RUNTIME) {
return -ENOTSUP;
}
retval = tmag5273_attr_set_xyz_meas_range(dev, val);
if (retval < 0) {
return retval;
}
break;
case TMAG5273_ATTR_ANGLE_MAG_AXIS:
if (drv_cfg->angle_magnitude_axis != TMAG5273_DT_ANGLE_MAG_RUNTIME) {
return -ENOTSUP;
}
retval = tmag5273_attr_set_xyz_calc(dev, val);
if (retval < 0) {
return retval;
}
break;
default:
LOG_ERR("unknown attribute %d", attr);
return -ENOTSUP;
}
return 0;
}
static int tmag5273_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
CHECKIF(dev == NULL) {
LOG_ERR("dev: NULL");
return -EINVAL;
}
CHECKIF(val == NULL) {
LOG_ERR("val: NULL");
return -EINVAL;
}
if (chan != SENSOR_CHAN_MAGN_XYZ) {
return -ENOTSUP;
}
const struct tmag5273_config *drv_cfg = dev->config;
int retval;
switch ((uint16_t)attr) {
case SENSOR_ATTR_FULL_SCALE:
if (drv_cfg->meas_range != TMAG5273_DT_AXIS_RANGE_RUNTIME) {
return -ENOTSUP;
}
retval = tmag5273_attr_get_xyz_meas_range(dev, val);
if (retval < 0) {
return retval;
}
break;
case TMAG5273_ATTR_ANGLE_MAG_AXIS:
if (drv_cfg->angle_magnitude_axis != TMAG5273_DT_ANGLE_MAG_RUNTIME) {
return -ENOTSUP;
}
retval = tmag5273_attr_get_xyz_calc(dev, val);
if (retval < 0) {
return retval;
}
break;
default:
LOG_ERR("unknown attribute %d", attr);
return -ENOTSUP;
}
return 0;
}
static int tmag5273_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct tmag5273_config *drv_cfg = dev->config;
struct tmag5273_data *drv_data = dev->data;
int retval;
uint8_t i2c_buffer[TMAG5273_I2C_BUFFER_SIZE] = {0};
/* trigger a conversion and wait until done if in standby mode */
if (drv_cfg->operation_mode == TMAG5273_DT_OPER_MODE_STANDBY) {
if (drv_cfg->trigger_conv_via_int) {
retval = tmag5273_dev_int_trigger(drv_cfg);
if (retval < 0) {
return retval;
}
}
uint8_t conv_bit = TMAG5273_CONVERSION_START_BIT;
while ((i2c_buffer[0] & TMAG5273_RESULT_STATUS_MSK) !=
TMAG5273_CONVERSION_COMPLETE) {
retval = i2c_reg_read_byte_dt(
&drv_cfg->i2c, TMAG5273_REG_CONV_STATUS | conv_bit, &i2c_buffer[0]);
if (retval < 0) {
LOG_ERR("error reading conversion state %d", retval);
return retval;
}
conv_bit = 0;
k_usleep(drv_data->conversion_time_us);
}
}
/* read data */
uint8_t start_address, end_address;
switch ((int)chan) {
case SENSOR_CHAN_MAGN_X:
if (!(drv_cfg->axis & TMAG5273_MAG_CH_EN_X)) {
LOG_ERR("x-axis measurement deactivated");
return -ENOTSUP;
}
start_address = TMAG5273_REG_X_MSB_RESULT;
end_address = TMAG5273_REG_X_LSB_RESULT;
break;
case SENSOR_CHAN_MAGN_Y:
if (!(drv_cfg->axis & TMAG5273_MAG_CH_EN_Y)) {
LOG_ERR("y-axis measurement deactivated");
return -ENOTSUP;
}
start_address = TMAG5273_REG_Y_MSB_RESULT;
end_address = TMAG5273_REG_Y_LSB_RESULT;
break;
case SENSOR_CHAN_MAGN_Z:
if (!(drv_cfg->axis & TMAG5273_MAG_CH_EN_Z)) {
LOG_ERR("x-axis measurement deactivated");
return -ENOTSUP;
}
start_address = TMAG5273_REG_Z_MSB_RESULT;
end_address = TMAG5273_REG_Z_LSB_RESULT;
break;
case SENSOR_CHAN_MAGN_XYZ:
if (drv_cfg->axis == TMAG5273_MAG_CH_EN_NONE) {
LOG_ERR("xyz-axis measurement deactivated");
return -ENOTSUP;
}
start_address = TMAG5273_REG_X_MSB_RESULT;
end_address = TMAG5273_REG_Z_LSB_RESULT;
break;
case SENSOR_CHAN_DIE_TEMP:
if (!drv_cfg->temperature) {
LOG_ERR("temperature measurement deactivated");
return -ENOTSUP;
}
start_address = TMAG5273_REG_T_MSB_RESULT;
end_address = TMAG5273_REG_T_LSB_RESULT;
break;
case SENSOR_CHAN_ROTATION:
if (drv_cfg->angle_magnitude_axis == TMAG5273_ANGLE_CALC_NONE) {
LOG_ERR("axis measurement deactivated");
return -ENOTSUP;
}
start_address = TMAG5273_REG_ANGLE_MSB_RESULT;
end_address = TMAG5273_REG_ANGLE_LSB_RESULT;
break;
case TMAG5273_CHAN_MAGNITUDE:
case TMAG5273_CHAN_MAGNITUDE_MSB:
if (drv_cfg->angle_magnitude_axis == TMAG5273_ANGLE_CALC_NONE) {
LOG_ERR("axis measurement deactivated");
return -ENOTSUP;
}
start_address = end_address = TMAG5273_REG_MAGNITUDE_RESULT;
break;
case TMAG5273_CHAN_ANGLE_MAGNITUDE:
if (drv_cfg->angle_magnitude_axis == TMAG5273_ANGLE_CALC_NONE) {
LOG_ERR("axis measurement deactivated");
return -ENOTSUP;
}
start_address = TMAG5273_REG_ANGLE_MSB_RESULT;
end_address = TMAG5273_REG_MAGNITUDE_RESULT;
break;
case SENSOR_CHAN_ALL:
start_address = TMAG5273_REG_RESULT_BEGIN;
end_address = TMAG5273_REG_RESULT_END;
break;
default:
LOG_ERR("unknown sensor channel %d", chan);
return -EINVAL;
}
__ASSERT_NO_MSG(start_address >= TMAG5273_REG_RESULT_BEGIN);
__ASSERT_NO_MSG(end_address <= TMAG5273_REG_RESULT_END);
__ASSERT_NO_MSG(start_address <= end_address);
uint32_t nb_bytes = end_address - start_address + 1;
#ifdef CONFIG_CRC
/* if CRC is enabled multiples of TMAG5273_CRC_DATA_BYTES need to be read */
if (drv_cfg->crc_enabled && ((nb_bytes % TMAG5273_CRC_DATA_BYTES) != 0)) {
const uint8_t diff = TMAG5273_CRC_DATA_BYTES - (nb_bytes % TMAG5273_CRC_DATA_BYTES);
if ((start_address - diff) >= TMAG5273_REG_RESULT_BEGIN) {
start_address -= diff;
}
nb_bytes = (nb_bytes / TMAG5273_CRC_DATA_BYTES + 1) * TMAG5273_CRC_DATA_BYTES;
}
__ASSERT_NO_MSG((start_address + nb_bytes) <= (TMAG5273_REG_RESULT_END + 1));
#endif
uint8_t offset = start_address - TMAG5273_REG_RESULT_BEGIN;
const uint8_t crc_size = tmag5273_get_crc_size(drv_cfg);
while (nb_bytes) {
const uint8_t block_size = tmag5273_get_fetch_block_size(drv_cfg, nb_bytes);
__ASSERT((offset + block_size + crc_size) <= TMAG5273_I2C_BUFFER_SIZE,
"block_size would exceed available i2c buffer capacity");
__ASSERT(start_address <= end_address,
"start_address for reading after end address");
/* Note: crc_size needs to be read additionally, since it is appended on the end */
retval = i2c_burst_read_dt(&drv_cfg->i2c, start_address, &i2c_buffer[offset],
block_size + crc_size);
if (retval < 0) {
LOG_ERR("could not read result data %d", retval);
return -EIO;
}
#ifdef CONFIG_CRC
/* check data validity, if activated */
if (drv_cfg->crc_enabled) {
const uint8_t crc = crc8_ccitt(0xFF, &i2c_buffer[offset], block_size);
if (i2c_buffer[offset + block_size] != crc) {
LOG_ERR("invalid CRC value: 0x%X (expected: 0x%X)",
i2c_buffer[offset + block_size], crc);
return -EIO;
}
}
#endif
__ASSERT(nb_bytes >= block_size, "overflow on nb_bytes");
nb_bytes -= block_size;
offset += block_size;
start_address += block_size;
}
retval = tmag5273_check_device_status(
drv_cfg, &i2c_buffer[TMAG5273_REG_CONV_STATUS - TMAG5273_REG_RESULT_BEGIN]);
if (retval < 0) {
return retval;
}
bool all_channels = (chan == SENSOR_CHAN_ALL);
bool all_xyz = all_channels || (chan == SENSOR_CHAN_MAGN_XYZ);
bool all_angle_magnitude = all_channels || ((int)chan == TMAG5273_CHAN_ANGLE_MAGNITUDE);
if (all_xyz || (chan == SENSOR_CHAN_MAGN_X)) {
drv_data->x_sample = sys_get_be16(
&i2c_buffer[TMAG5273_REG_X_MSB_RESULT - TMAG5273_REG_RESULT_BEGIN]);
}
if (all_xyz || (chan == SENSOR_CHAN_MAGN_Y)) {
drv_data->y_sample = sys_get_be16(
&i2c_buffer[TMAG5273_REG_Y_MSB_RESULT - TMAG5273_REG_RESULT_BEGIN]);
}
if (all_xyz || (chan == SENSOR_CHAN_MAGN_Z)) {
drv_data->z_sample = sys_get_be16(
&i2c_buffer[TMAG5273_REG_Z_MSB_RESULT - TMAG5273_REG_RESULT_BEGIN]);
}
if (all_channels || (chan == SENSOR_CHAN_DIE_TEMP)) {
drv_data->temperature_sample = sys_get_be16(
&i2c_buffer[TMAG5273_REG_T_MSB_RESULT - TMAG5273_REG_RESULT_BEGIN]);
}
if (all_angle_magnitude || (chan == SENSOR_CHAN_ROTATION)) {
drv_data->angle_sample = sys_get_be16(
&i2c_buffer[TMAG5273_REG_ANGLE_MSB_RESULT - TMAG5273_REG_RESULT_BEGIN]);
}
if (all_angle_magnitude || ((int)chan == TMAG5273_CHAN_MAGNITUDE) ||
((int)chan == TMAG5273_CHAN_MAGNITUDE_MSB)) {
drv_data->magnitude_sample =
i2c_buffer[TMAG5273_REG_MAGNITUDE_RESULT - TMAG5273_REG_RESULT_BEGIN];
}
return 0;
}
/**
* @brief calculates the b-field value in G based on the sensor value
*
* The calculation follows the formula
* @f[ B=\frac{-(D_{15} \cdot 2^{15}) + \sum_{i=0}^{14} D_i \cdot 2^i}{2^{16}} \cdot 2|B_R| @f]
* where
* - \em D denotes the bit of the input data,
* - \em Br represents the magnetic range in mT
*
* After the calculation, the value is scaled to Gauss (1 G == 0.1 mT).
*
* @param[in] raw_value data read from the device
* @param[in] range magnetic range of the selected axis (in mT)
* @param[out] b_field holds the result data after the operation
*/
static inline void tmag5273_channel_b_field_convert(int64_t raw_value, const uint16_t range,
struct sensor_value *b_field)
{
raw_value *= (range << 1) * CONV_FACTOR_MT_TO_GS;
/* calc integer part in mT and scale to G */
b_field->val1 = raw_value / (1 << 16);
/* calc remaining part (first mT digit + fractal part) and scale according to Zephyr.
* Ensure that always positive.
*/
const int64_t raw_dec_part = (int64_t)b_field->val1 * (1 << 16);
b_field->val2 = ((raw_value - raw_dec_part) * 1000000) / (1 << 16);
}
/**
* @brief calculates the temperature value
*
* @param[in] raw_value data read from the device
* @param[out] temperature holds the result data after the operation
*/
static inline void tmag5273_temperature_convert(int64_t raw_value, struct sensor_value *temperature)
{
const int64_t value =
(TMAG5273_TEMPERATURE_T_SENS_T0 +
((raw_value - TMAG5273_TEMPERATURE_T_ADC_T0) / TMAG5273_TEMPERATURE_T_ADC_RES)) *
1000000;
temperature->val1 = value / 1000000;
temperature->val2 = value % 1000000;
}
/**
* @brief calculates the angle value between two axis
*
* @param[in] raw_value data read from the device
* @param[out] angle holds the result data after the operation
*/
static inline void tmag5273_angle_convert(int16_t raw_value, struct sensor_value *angle)
{
angle->val1 = (raw_value >> 4) & 0x1FF;
angle->val2 = ((raw_value & 0xF) * 1000000) >> 1;
}
/**
* @brief calculates the magnitude value in G between two axis
*
* Note that \c MAGNITUDE_RESULT represents the MSB of the calculation,
* therefore it needs to be shifted.
*
* @param[in] raw_value data read from the device
* @param[out] magnitude holds the result data after the operation
*/
static inline void tmag5273_magnitude_convert(uint8_t raw_value, const uint16_t range,
struct sensor_value *magnitude)
{
tmag5273_channel_b_field_convert(raw_value << 8, range, magnitude);
}
static int tmag5273_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
CHECKIF(val == NULL) {
LOG_ERR("val: NULL");
return -EINVAL;
}
const struct tmag5273_config *drv_cfg = dev->config;
struct tmag5273_data *drv_data = dev->data;
int8_t val_offset = 0;
const bool all_mag_axis = (chan == SENSOR_CHAN_MAGN_XYZ) || (chan == SENSOR_CHAN_ALL);
if ((drv_cfg->axis & TMAG5273_MAG_CH_EN_X) &&
(all_mag_axis || (chan == SENSOR_CHAN_MAGN_X))) {
tmag5273_channel_b_field_convert(drv_data->x_sample, drv_data->xyz_range,
val + val_offset);
val_offset++;
}
if ((drv_cfg->axis & TMAG5273_MAG_CH_EN_Y) &&
(all_mag_axis || (chan == SENSOR_CHAN_MAGN_Y))) {
tmag5273_channel_b_field_convert(drv_data->y_sample, drv_data->xyz_range,
val + val_offset);
val_offset++;
}
if ((drv_cfg->axis & TMAG5273_MAG_CH_EN_Z) &&
(all_mag_axis || (chan == SENSOR_CHAN_MAGN_Z))) {
tmag5273_channel_b_field_convert(drv_data->z_sample, drv_data->xyz_range,
val + val_offset);
val_offset++;
}
if (drv_cfg->temperature && (chan == SENSOR_CHAN_DIE_TEMP)) {
tmag5273_temperature_convert(drv_data->temperature_sample, val + val_offset);
val_offset++;
}
if (drv_cfg->angle_magnitude_axis != TMAG5273_ANGLE_CALC_NONE) {
const bool all_calc_ch = (TMAG5273_CHAN_ANGLE_MAGNITUDE == (uint16_t)chan);
if (all_calc_ch || ((uint16_t)chan == SENSOR_CHAN_ROTATION)) {
tmag5273_angle_convert(drv_data->angle_sample, val + val_offset);
val_offset++;
}
if (all_calc_ch || ((uint16_t)chan == TMAG5273_CHAN_MAGNITUDE)) {
tmag5273_magnitude_convert(drv_data->magnitude_sample, drv_data->xyz_range,
val + val_offset);
val_offset++;
}
if (all_calc_ch || (uint16_t)chan == TMAG5273_CHAN_MAGNITUDE_MSB) {
val[val_offset].val1 = drv_data->magnitude_sample;
val[val_offset].val2 = 0;
val_offset++;
}
}
if (val_offset == 0) {
return -ENOTSUP;
}
return 0;
}
/**
* @brief sets the \c DEVICE_CONFIG_1 and \c DEVICE_CONFIG_2 registers
*
* @param dev handle to the current device instance
*
* @retval 0 if everything was okay
* @retval -EIO on communication errors
*/
static inline int tmag5273_init_device_config(const struct device *dev)
{
const struct tmag5273_config *drv_cfg = dev->config;
struct tmag5273_data *drv_data = dev->data;
int retval;
uint8_t regdata;
/* REG_DEVICE_CONFIG_1 */
regdata = 0;
#ifdef CONFIG_CRC
if (drv_cfg->crc_enabled) {
regdata |= TMAG5273_CRC_ENABLE;
}
#endif
switch (drv_cfg->temperature_coefficient) {
case TMAG5273_DT_TEMP_COEFF_NDBFE:
regdata |= TMAG5273_MAGNET_TEMP_COEFF_NDBFE;
break;
case TMAG5273_DT_TEMP_COEFF_CERAMIC:
regdata |= TMAG5273_MAGNET_TEMP_COEFF_CERAMIC;
break;
case TMAG5273_DT_TEMP_COEFF_NONE:
__fallthrough;
default:
regdata |= TMAG5273_MAGNET_TEMP_COEFF_NONE;
break;
}
switch (drv_cfg->averaging) {
case TMAG5273_DT_AVERAGING_2X:
regdata |= TMAG5273_CONV_AVG_2;
break;
case TMAG5273_DT_AVERAGING_4X:
regdata |= TMAG5273_CONV_AVG_4;
break;
case TMAG5273_DT_AVERAGING_8X:
regdata |= TMAG5273_CONV_AVG_8;
break;
case TMAG5273_DT_AVERAGING_16X:
regdata |= TMAG5273_CONV_AVG_16;
break;
case TMAG5273_DT_AVERAGING_32X:
regdata |= TMAG5273_CONV_AVG_32;
break;
case TMAG5273_DT_AVERAGING_NONE:
__fallthrough;
default:
regdata |= TMAG5273_CONV_AVG_1;
break;
}
const int nb_captured_channels =
((drv_cfg->mag_channel >= TMAG5273_DT_AXIS_XYZ)
? 3
: POPCOUNT((drv_cfg->mag_channel & TMAG5273_DT_AXIS_XYZ))) +
(int)drv_cfg->temperature;
drv_data->conversion_time_us = TMAG5273_T_CONVERSION_US(
(FIELD_GET(TMAG5273_CONV_AVB_MSK, regdata)), (nb_captured_channels));
regdata |= TMAG5273_I2C_READ_MODE_STANDARD;
retval = i2c_reg_write_byte_dt(&drv_cfg->i2c, TMAG5273_REG_DEVICE_CONFIG_1, regdata);
if (retval < 0) {
LOG_ERR("error setting DEVICE_CONFIG_1 %d", retval);
return -EIO;
}
/* REG_DEVICE_CONFIG_2 */
regdata = 0;
if (drv_cfg->low_noise_mode) {
regdata |= TMAG5273_LP_LOWNOISE;
}
if (drv_cfg->trigger_conv_via_int) {
regdata |= TMAG5273_TRIGGER_MODE_INT;
}
if (drv_cfg->operation_mode == TMAG5273_DT_OPER_MODE_CONTINUOUS) {
regdata |= TMAG5273_OPERATING_MODE_CONTINUOUS;
}
/* Note: I2C glitch filter enabled by default */
retval = i2c_reg_write_byte_dt(&drv_cfg->i2c, TMAG5273_REG_DEVICE_CONFIG_2, regdata);
if (retval < 0) {
LOG_ERR("error setting DEVICE_CONFIG_2 %d", retval);
return -EIO;
}
return 0;
}
/**
* @brief sets the \c SENSOR_CONFIG_1 and \c SENSOR_CONFIG_2 registers
*
* @param drv_cfg configuration of the TMAG5273 instance
*
* @retval 0 if everything was okay
* @retval -EIO on communication errors
*/
static inline int tmag5273_init_sensor_settings(const struct tmag5273_config *drv_cfg,
uint8_t version)
{
int retval;
uint8_t regdata;
/* REG_SENSOR_CONFIG_1 */
regdata = drv_cfg->mag_channel << TMAG5273_MAG_CH_EN_POS;
retval = i2c_reg_write_byte_dt(&drv_cfg->i2c, TMAG5273_REG_SENSOR_CONFIG_1, regdata);
if (retval < 0) {
LOG_ERR("error setting SENSOR_CONFIG_1 %d", retval);
return -EIO;
}
/* REG_SENSOR_CONFIG_2 */
regdata = 0;
if (drv_cfg->ch_mag_gain_correction == TMAG5273_DT_CORRECTION_CH_2) {
regdata |= TMAG5273_MAG_GAIN_CORRECTION_CH_2;
}
switch (drv_cfg->angle_magnitude_axis) {
case TMAG5273_DT_ANGLE_MAG_XY:
regdata |= TMAG5273_ANGLE_EN_XY;
break;
case TMAG5273_DT_ANGLE_MAG_YZ:
regdata |= TMAG5273_ANGLE_EN_YZ;
break;
case TMAG5273_DT_ANGLE_MAG_XZ:
regdata |= TMAG5273_ANGLE_EN_XZ;
break;
case TMAG5273_DT_ANGLE_MAG_RUNTIME:
case TMAG5273_DT_ANGLE_MAG_NONE:
__fallthrough;
default:
regdata |= TMAG5273_ANGLE_EN_POS;
break;
}
if (drv_cfg->meas_range == TMAG5273_DT_AXIS_RANGE_LOW) {
regdata |= TMAG5273_XYZ_MEAS_RANGE_LOW;
} else {
regdata |= TMAG5273_XYZ_MEAS_RANGE_HIGH;
}
retval = i2c_reg_write_byte_dt(&drv_cfg->i2c, TMAG5273_REG_SENSOR_CONFIG_2, regdata);
if (retval < 0) {
LOG_ERR("error setting SENSOR_CONFIG_2 %d", retval);
return -EIO;
}
/* the 3001 Variant has REG_CONFIG_3 instead of REG_T_CONFIG. No need for temp enable. */
if (version == TMAG5273_VER_TMAG3001X1 || version == TMAG5273_VER_TMAG3001X2) {
return 0;
}
/* REG_T_CONFIG */
regdata = 0;
if (drv_cfg->temperature) {
regdata |= TMAG5273_T_CH_EN_ENABLED;
}
retval = i2c_reg_write_byte_dt(&drv_cfg->i2c, TMAG5273_REG_T_CONFIG, regdata);
if (retval < 0) {
LOG_ERR("error setting SENSOR_CONFIG_2 %d", retval);
return -EIO;
}
return 0;
}
/**
* @brief initialize a TMAG5273 sensor
*
* @param dev handle to the device
*
* @retval 0 on success
* @retval -EINVAL if bus label is invalid
* @retval -EIO on communication errors
*/
static int tmag5273_init(const struct device *dev)
{
const struct tmag5273_config *drv_cfg = dev->config;
struct tmag5273_data *drv_data = dev->data;
int retval;
uint8_t regdata;
if (!i2c_is_ready_dt(&drv_cfg->i2c)) {
LOG_ERR("could not get pointer to TMAG5273 I2C device");
return -ENODEV;
}
if (drv_cfg->trigger_conv_via_int) {
if (!gpio_is_ready_dt(&drv_cfg->int_gpio)) {
LOG_ERR("invalid int-gpio configuration");
return -ENODEV;
}
retval = gpio_pin_configure_dt(&drv_cfg->int_gpio, GPIO_INPUT);
if (retval < 0) {
LOG_ERR("cannot configure GPIO %d", retval);
return -EINVAL;
}
}
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_DEVICE_CONFIG_2, ®data);
if (retval < 0) {
LOG_ERR("could not read device config 2 register %d", retval);
return -EIO;
}
LOG_DBG("operation mode: %d", (int)FIELD_GET(TMAG5273_OPERATING_MODE_MSK, regdata));
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_MANUFACTURER_ID_LSB, ®data);
if (retval < 0) {
return -EIO;
}
if (regdata != TMAG5273_MANUFACTURER_ID_LSB) {
LOG_ERR("unexpected manufacturer id LSB 0x%X", regdata);
return -EINVAL;
}
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_MANUFACTURER_ID_MSB, ®data);
if (retval < 0) {
LOG_ERR("could not read MSB of manufacturer id %d", retval);
return -EIO;
}
if (regdata != TMAG5273_MANUFACTURER_ID_MSB) {
LOG_ERR("unexpected manufacturer id MSB 0x%X", regdata);
return -EINVAL;
}
(void)tmag5273_check_device_status(drv_cfg, ®data);
retval = tmag5273_reset_device_status(dev);
if (retval < 0) {
LOG_ERR("could not reset DEVICE_STATUS register %d", retval);
return -EIO;
}
retval = i2c_reg_read_byte_dt(&drv_cfg->i2c, TMAG5273_REG_DEVICE_ID, ®data);
if (retval < 0) {
LOG_ERR("could not read DEVICE_ID register %d", retval);
return -EIO;
}
drv_data->version = regdata & TMAG5273_VER_MSK;
/* magnetic measurement range based on version, apply correct one */
if (drv_cfg->meas_range == TMAG5273_DT_AXIS_RANGE_LOW) {
drv_data->xyz_range = tmag5273_range_low(drv_data->version);
} else {
drv_data->xyz_range = tmag5273_range_high(drv_data->version);
}
regdata = TMAG5273_INT_MODE_NONE;
if (!drv_cfg->trigger_conv_via_int) {
regdata |= TMAG5273_INT_MASK_INTB_PIN_MASKED;
}
retval = i2c_reg_write_byte_dt(&drv_cfg->i2c, TMAG5273_REG_INT_CONFIG_1, regdata);
if (retval < 0) {
LOG_ERR("error deactivating interrupts %d", retval);
return -EIO;
}
/* set settings */
retval = tmag5273_init_sensor_settings(drv_cfg, drv_data->version);
if (retval < 0) {
LOG_ERR("error setting sensor configuration %d", retval);
return retval;
}
retval = tmag5273_init_device_config(dev);
if (retval < 0) {
LOG_ERR("error setting device configuration %d", retval);
return retval;
}
return 0;
}
static const struct sensor_driver_api tmag5273_driver_api = {
.attr_set = tmag5273_attr_set,
.attr_get = tmag5273_attr_get,
.sample_fetch = tmag5273_sample_fetch,
.channel_get = tmag5273_channel_get,
};
#define TMAG5273_DT_X_AXIS_BIT(axis_dts) \
((((axis_dts & TMAG5273_DT_AXIS_X) == TMAG5273_DT_AXIS_X) || \
(axis_dts == TMAG5273_DT_AXIS_XYX) || (axis_dts == TMAG5273_DT_AXIS_YXY) || \
(axis_dts == TMAG5273_DT_AXIS_XZX)) \
? TMAG5273_MAG_CH_EN_X \
: 0)
#define TMAG5273_DT_Y_AXIS_BIT(axis_dts) \
((((axis_dts & TMAG5273_DT_AXIS_Y) == TMAG5273_DT_AXIS_Y) || \
(axis_dts == TMAG5273_DT_AXIS_XYX) || (axis_dts == TMAG5273_DT_AXIS_YXY) || \
(axis_dts == TMAG5273_DT_AXIS_YZY)) \
? TMAG5273_MAG_CH_EN_Y \
: 0)
#define TMAG5273_DT_Z_AXIS_BIT(axis_dts) \
((((axis_dts & TMAG5273_DT_AXIS_Z) == TMAG5273_DT_AXIS_Z) || \
(axis_dts == TMAG5273_DT_AXIS_YZY) || (axis_dts == TMAG5273_DT_AXIS_XZX)) \
? TMAG5273_MAG_CH_EN_Z \
: 0)
/** Instantiation macro */
#define TMAG5273_DEFINE(inst) \
BUILD_ASSERT(IS_ENABLED(CONFIG_CRC) || (DT_INST_PROP(inst, crc_enabled) == 0), \
"CRC support necessary"); \
BUILD_ASSERT(!DT_INST_PROP(inst, trigger_conversion_via_int) || \
DT_INST_NODE_HAS_PROP(inst, int_gpios), \
"trigger-conversion-via-int requires int-gpios to be defined"); \
static const struct tmag5273_config tmag5273_driver_cfg##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.mag_channel = DT_INST_PROP(inst, axis), \
.axis = (TMAG5273_DT_X_AXIS_BIT(DT_INST_PROP(inst, axis)) | \
TMAG5273_DT_Y_AXIS_BIT(DT_INST_PROP(inst, axis)) | \
TMAG5273_DT_Z_AXIS_BIT(DT_INST_PROP(inst, axis))), \
.temperature = DT_INST_PROP(inst, temperature), \
.meas_range = DT_INST_PROP(inst, range), \
.temperature_coefficient = DT_INST_PROP(inst, temperature_coefficient), \
.angle_magnitude_axis = DT_INST_PROP(inst, angle_magnitude_axis), \
.ch_mag_gain_correction = DT_INST_PROP(inst, ch_mag_gain_correction), \
.operation_mode = DT_INST_PROP(inst, operation_mode), \
.averaging = DT_INST_PROP(inst, average_mode), \
.trigger_conv_via_int = DT_INST_PROP(inst, trigger_conversion_via_int), \
.low_noise_mode = DT_INST_PROP(inst, low_noise), \
.ignore_diag_fail = DT_INST_PROP(inst, ignore_diag_fail), \
.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, {0}), \
IF_ENABLED(CONFIG_CRC, (.crc_enabled = DT_INST_PROP(inst, crc_enabled),))}; \
static struct tmag5273_data tmag5273_driver_data##inst; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, tmag5273_init, NULL, &tmag5273_driver_data##inst, \
&tmag5273_driver_cfg##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tmag5273_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TMAG5273_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ti/tmag5273/tmag5273.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 10,315 |
```c
/*
*
*/
#define DT_DRV_COMPAT ti_hdc
#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/util.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "ti_hdc.h"
LOG_MODULE_REGISTER(TI_HDC, CONFIG_SENSOR_LOG_LEVEL);
static void ti_hdc_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct ti_hdc_data *drv_data =
CONTAINER_OF(cb, struct ti_hdc_data, gpio_cb);
const struct ti_hdc_config *cfg = drv_data->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->drdy, GPIO_INT_DISABLE);
k_sem_give(&drv_data->data_sem);
}
static int ti_hdc_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct ti_hdc_data *drv_data = dev->data;
const struct ti_hdc_config *cfg = dev->config;
uint8_t buf[4];
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (cfg->drdy.port) {
gpio_pin_interrupt_configure_dt(&cfg->drdy, GPIO_INT_EDGE_TO_ACTIVE);
}
buf[0] = TI_HDC_REG_TEMP;
if (i2c_write_dt(&cfg->i2c, buf, 1) < 0) {
LOG_DBG("Failed to write address pointer");
return -EIO;
}
if (cfg->drdy.port) {
k_sem_take(&drv_data->data_sem, K_FOREVER);
} else {
/* wait for the conversion to finish */
k_msleep(HDC_CONVERSION_TIME);
}
if (i2c_read_dt(&cfg->i2c, buf, 4) < 0) {
LOG_DBG("Failed to read sample data");
return -EIO;
}
drv_data->t_sample = (buf[0] << 8) + buf[1];
drv_data->rh_sample = (buf[2] << 8) + buf[3];
return 0;
}
static int ti_hdc_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct ti_hdc_data *drv_data = dev->data;
uint64_t tmp;
/*
* See datasheet "Temperature Register" and "Humidity
* Register" sections for more details on processing
* sample data.
*/
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
/* val = -40 + 165 * sample / 2^16 */
tmp = (uint64_t)drv_data->t_sample * 165U;
val->val1 = (int32_t)(tmp >> 16) - 40;
val->val2 = ((tmp & 0xFFFF) * 1000000U) >> 16;
} else if (chan == SENSOR_CHAN_HUMIDITY) {
/* val = 100 * sample / 2^16 */
tmp = (uint64_t)drv_data->rh_sample * 100U;
val->val1 = tmp >> 16;
/* x * 1000000 / 65536 == x * 15625 / 1024 */
val->val2 = ((tmp & 0xFFFF) * 15625U) >> 10;
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api ti_hdc_driver_api = {
.sample_fetch = ti_hdc_sample_fetch,
.channel_get = ti_hdc_channel_get,
};
static uint16_t read16(const struct i2c_dt_spec *i2c, uint8_t d)
{
uint8_t buf[2];
if (i2c_burst_read_dt(i2c, d, (uint8_t *)buf, 2) < 0) {
LOG_ERR("Error reading register.");
}
return (buf[0] << 8 | buf[1]);
}
static int ti_hdc_init(const struct device *dev)
{
const struct ti_hdc_config *cfg = dev->config;
uint16_t tmp;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
if (read16(&cfg->i2c, TI_HDC_REG_MANUFID) != TI_HDC_MANUFID) {
LOG_ERR("Failed to get correct manufacturer ID");
return -EINVAL;
}
tmp = read16(&cfg->i2c, TI_HDC_REG_DEVICEID);
if (tmp != TI_HDC1000_DEVID && tmp != TI_HDC1050_DEVID) {
LOG_ERR("Unsupported device ID");
return -EINVAL;
}
if (cfg->drdy.port) {
struct ti_hdc_data *drv_data = dev->data;
drv_data->dev = dev;
k_sem_init(&drv_data->data_sem, 0, K_SEM_MAX_LIMIT);
/* setup data ready gpio interrupt */
if (!gpio_is_ready_dt(&cfg->drdy)) {
LOG_ERR("%s: device %s is not ready", dev->name,
cfg->drdy.port->name);
return -ENODEV;
}
gpio_pin_configure_dt(&cfg->drdy, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb,
ti_hdc_gpio_callback,
BIT(cfg->drdy.pin));
if (gpio_add_callback(cfg->drdy.port, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set GPIO callback");
return -EIO;
}
gpio_pin_interrupt_configure_dt(&cfg->drdy, GPIO_INT_EDGE_TO_ACTIVE);
}
LOG_INF("Initialized device successfully");
return 0;
}
#define TI_HDC_DEFINE(inst) \
static struct ti_hdc_data ti_hdc_data_##inst; \
\
static const struct ti_hdc_config ti_hdc_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.drdy = GPIO_DT_SPEC_INST_GET_OR(inst, drdy_gpios, { 0 }), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, ti_hdc_init, NULL, \
&ti_hdc_data_##inst, &ti_hdc_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &ti_hdc_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(TI_HDC_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ti/ti_hdc/ti_hdc.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,463 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TI_HDC_TI_HDC_H_
#define ZEPHYR_DRIVERS_SENSOR_TI_HDC_TI_HDC_H_
#include <zephyr/kernel.h>
#define TI_HDC_REG_TEMP 0x0
#define TI_HDC_REG_HUMIDITY 0x1
#define TI_HDC_REG_MANUFID 0xFE
#define TI_HDC_REG_DEVICEID 0xFF
#define TI_HDC_MANUFID 0x5449
#define TI_HDC1050_DEVID 0x1050
#define TI_HDC1000_DEVID 0x1000
/* For 14bit conversion RH needs 6.5ms and Temp 6.35ms */
#define HDC_CONVERSION_TIME 13
struct ti_hdc_config {
struct i2c_dt_spec i2c;
struct gpio_dt_spec drdy;
};
struct ti_hdc_data {
uint16_t t_sample;
uint16_t rh_sample;
struct gpio_callback gpio_cb;
struct k_sem data_sem;
const struct device *dev;
};
#endif
``` | /content/code_sandbox/drivers/sensor/ti/ti_hdc/ti_hdc.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 226 |
```unknown
# TI_HDC temperature and humidity sensor configuration options
config TI_HDC
bool "Texas Instruments Temperature and Humidity Sensor (e.g. HDC1008)"
default y
depends on DT_HAS_TI_HDC_ENABLED
select I2C
help
Enable driver for TI temperature and humidity sensors.
``` | /content/code_sandbox/drivers/sensor/ti/ti_hdc/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 64 |
```unknown
# TI_HDC20XX temperature and humidity sensor configuration options
config TI_HDC20XX
bool "Texas Instruments HDC20XX Temperature and Humidity Sensor"
default y
depends on DT_HAS_TI_HDC2010_ENABLED || DT_HAS_TI_HDC2021_ENABLED || \
DT_HAS_TI_HDC2022_ENABLED || DT_HAS_TI_HDC2080_ENABLED
select I2C
help
Enable driver for TI HDC20XX temperature and humidity sensors
(e.g. HDC2010, HDC2021, HDC2022, HDC2080).
``` | /content/code_sandbox/drivers/sensor/ti/ti_hdc20xx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 119 |
```c
/*
*
*
* Datasheet:
* path_to_url
*
*/
#define DT_DRV_COMPAT festo_veaa_x_3
#include <stdio.h>
#include <zephyr/device.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/drivers/dac.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/veaa_x_3.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/math_extras.h>
#include <zephyr/sys/util_macro.h>
LOG_MODULE_REGISTER(veaa_x_3_sensor, CONFIG_SENSOR_LOG_LEVEL);
struct veaa_x_3_data {
uint16_t adc_buf;
};
struct veaa_x_3_cfg {
const struct adc_dt_spec adc;
const struct device *dac;
const uint8_t dac_channel;
const uint8_t dac_resolution;
const uint16_t kpa_max;
const uint8_t kpa_min;
};
static uint16_t veaa_x_3_kpa_range(const struct veaa_x_3_cfg *cfg)
{
return cfg->kpa_max - cfg->kpa_min;
}
static int veaa_x_3_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct veaa_x_3_cfg *cfg = dev->config;
uint32_t tmp;
if (chan != SENSOR_CHAN_PRESS) {
return -ENOTSUP;
}
switch ((enum sensor_attribute_veaa_x_3)attr) {
case SENSOR_ATTR_VEAA_X_3_SETPOINT:
if (val->val1 > cfg->kpa_max || val->val1 < cfg->kpa_min) {
LOG_ERR("%d kPa outside range", val->val1);
return -EINVAL;
}
/* Convert from kPa to DAC value */
tmp = val->val1 - cfg->kpa_min;
if (u32_mul_overflow(tmp, BIT(cfg->dac_resolution) - 1, &tmp)) {
LOG_ERR("kPa to DAC overflow");
return -ERANGE;
}
tmp /= veaa_x_3_kpa_range(cfg);
return dac_write_value(cfg->dac, cfg->dac_channel, tmp);
default:
return -ENOTSUP;
}
}
static int veaa_x_3_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct veaa_x_3_cfg *cfg = dev->config;
if (chan != SENSOR_CHAN_PRESS) {
return -ENOTSUP;
}
switch ((enum sensor_attribute_veaa_x_3)attr) {
case SENSOR_ATTR_VEAA_X_3_RANGE:
val->val1 = cfg->kpa_min;
val->val2 = cfg->kpa_max;
return 0;
default:
return -ENOTSUP;
}
}
static int veaa_x_3_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
int rc;
const struct veaa_x_3_cfg *cfg = dev->config;
struct veaa_x_3_data *data = dev->data;
struct adc_sequence sequence = {
.buffer = &data->adc_buf,
.buffer_size = sizeof(data->adc_buf),
};
if (chan != SENSOR_CHAN_PRESS && chan != SENSOR_CHAN_ALL) {
return -ENOTSUP;
}
rc = adc_sequence_init_dt(&cfg->adc, &sequence);
if (rc != 0) {
return rc;
}
sequence.options = NULL;
sequence.buffer = &data->adc_buf;
sequence.buffer_size = sizeof(data->adc_buf);
sequence.calibrate = false;
rc = adc_read_dt(&cfg->adc, &sequence);
if (rc != 0) {
return rc;
}
return 0;
}
static int veaa_x_3_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct veaa_x_3_cfg *cfg = dev->config;
struct veaa_x_3_data *data = dev->data;
const uint32_t max_adc_val = BIT(cfg->adc.resolution) - 1;
if (chan != SENSOR_CHAN_PRESS) {
return -ENOTSUP;
}
/* Convert from ADC value to kPa */
if (u32_mul_overflow(data->adc_buf, veaa_x_3_kpa_range(cfg), &val->val1)) {
LOG_ERR("ADC to kPa overflow");
return -ERANGE;
}
val->val2 = (val->val1 % max_adc_val) * 1000000 / max_adc_val;
val->val1 = (val->val1 / max_adc_val) + cfg->kpa_min;
return 0;
}
static const struct sensor_driver_api veaa_x_3_api_funcs = {
.attr_set = veaa_x_3_attr_set,
.attr_get = veaa_x_3_attr_get,
.sample_fetch = veaa_x_3_sample_fetch,
.channel_get = veaa_x_3_channel_get,
};
static int veaa_x_3_init(const struct device *dev)
{
int rc;
const struct veaa_x_3_cfg *cfg = dev->config;
const struct dac_channel_cfg dac_cfg = {
.channel_id = cfg->dac_channel,
.resolution = cfg->dac_resolution,
.buffered = false,
};
LOG_DBG("Initializing %s with range %u-%u kPa", dev->name, cfg->kpa_min, cfg->kpa_max);
if (!adc_is_ready_dt(&cfg->adc)) {
LOG_ERR("ADC not ready");
return -ENODEV;
}
rc = adc_channel_setup_dt(&cfg->adc);
if (rc != 0) {
LOG_ERR("%s setup failed: %d", cfg->adc.dev->name, rc);
return -ENODEV;
}
if (!device_is_ready(cfg->dac)) {
LOG_ERR("DAC not ready");
return -ENODEV;
}
rc = dac_channel_setup(cfg->dac, &dac_cfg);
if (rc != 0) {
LOG_ERR("%s setup failed: %d", cfg->dac->name, rc);
return -ENODEV;
}
return 0;
}
#define VEAA_X_3_RANGE_KPA_INIT(n) \
COND_CODE_1(DT_INST_ENUM_HAS_VALUE(n, pressure_range_type, d11), ({.max = 1000, min = 5}), \
(COND_CODE_1(DT_INST_ENUM_HAS_VALUE(n, pressure_range_type, d9), \
({.max = 600, min = 3}), ({.max = 200, .min = 1}))))
#define VEAA_X_3_TYPE_INIT(n) \
COND_CODE_1(DT_INST_ENUM_HAS_VALUE(n, pressure_range_type, d11), \
(.kpa_max = 1000, .kpa_min = 5), \
(COND_CODE_1(DT_INST_ENUM_HAS_VALUE(n, pressure_range_type, d9), \
(.kpa_max = 600, kpa_min = 3), (.kpa_max = 200, .kpa_min = 1))))
#define VEAA_X_3_INIT(n) \
\
static struct veaa_x_3_data veaa_x_3_data_##n; \
\
static const struct veaa_x_3_cfg veaa_x_3_cfg_##n = { \
.adc = ADC_DT_SPEC_INST_GET(n), \
.dac = DEVICE_DT_GET(DT_INST_PHANDLE(n, dac)), \
.dac_channel = DT_INST_PROP(n, dac_channel_id), \
.dac_resolution = DT_INST_PROP(n, dac_resolution), \
VEAA_X_3_TYPE_INIT(n)}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, veaa_x_3_init, NULL, &veaa_x_3_data_##n, \
&veaa_x_3_cfg_##n, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&veaa_x_3_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(VEAA_X_3_INIT)
``` | /content/code_sandbox/drivers/sensor/veaa_x_3/veaa_x_3.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,764 |
```unknown
# VEAA-X-3 configuration options
config VEAA_X_3
bool "VEAA-X-3 pressure driver"
default y
depends on DT_HAS_FESTO_VEAA_X_3_ENABLED
depends on ADC
depends on DAC
help
Enable driver for Festo VEAA-X-3.
The driver assumes that the maximum ADC value matches the maximum
output from the device, and that the maximum DAC value matches the
maximum input value for the device. External hardware is probably
required between the ADC/DAC and the device.
``` | /content/code_sandbox/drivers/sensor/veaa_x_3/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 121 |
```c
/*
*
*/
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(TI_HDC20XX, CONFIG_SENSOR_LOG_LEVEL);
/* Register addresses */
#define TI_HDC20XX_REG_TEMP 0x00
#define TI_HDC20XX_REG_HUMIDITY 0x02
#define TI_HDC20XX_REG_INT_EN 0x07
#define TI_HDC20XX_REG_CONFIG 0x0E
#define TI_HDC20XX_REG_MEAS_CFG 0x0F
#define TI_HDC20XX_REG_MANUFACTURER_ID 0xFC
#define TI_HDC20XX_REG_DEVICE_ID 0xFE
/* Register values */
#define TI_HDC20XX_MANUFACTURER_ID 0x5449
#define TI_HDC20XX_DEVICE_ID 0x07D0
/* Register bits */
#define TI_HDC20XX_BIT_INT_EN_DRDY_EN 0x80
#define TI_HDC20XX_BIT_CONFIG_SOFT_RES 0x80
#define TI_HDC20XX_BIT_CONFIG_DRDY_INT_EN 0x04
/* Reset time: not in the datasheet, but found by trial and error */
#define TI_HDC20XX_RESET_TIME K_MSEC(1)
/* Conversion time for 14-bit resolution. Temperature needs 660us and humidity 610us */
#define TI_HDC20XX_CONVERSION_TIME K_MSEC(2)
/* Temperature and humidity scale and factors from the datasheet ("Register Maps" section) */
#define TI_HDC20XX_RH_SCALE 100U
#define TI_HDC20XX_TEMP_OFFSET -2654208 /* = -40.5 * 2^16 */
#define TI_HDC20XX_TEMP_SCALE 165U
struct ti_hdc20xx_config {
struct i2c_dt_spec bus;
struct gpio_dt_spec gpio_int;
};
struct ti_hdc20xx_data {
struct gpio_callback cb_int;
struct k_sem sem_int;
uint16_t t_sample;
uint16_t rh_sample;
};
static void ti_hdc20xx_int_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct ti_hdc20xx_data *data = CONTAINER_OF(cb, struct ti_hdc20xx_data, cb_int);
ARG_UNUSED(pins);
k_sem_give(&data->sem_int);
}
static int ti_hdc20xx_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct ti_hdc20xx_config *config = dev->config;
struct ti_hdc20xx_data *data = dev->data;
uint16_t buf[2];
int rc;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
/* start conversion of both temperature and humidity with the default accuracy (14 bits) */
rc = i2c_reg_write_byte_dt(&config->bus, TI_HDC20XX_REG_MEAS_CFG, 0x01);
if (rc < 0) {
LOG_ERR("Failed to write measurement configuration register");
return rc;
}
/* wait for the conversion to finish */
if (config->gpio_int.port) {
k_sem_take(&data->sem_int, K_FOREVER);
} else {
k_sleep(TI_HDC20XX_CONVERSION_TIME);
}
/* temperature and humidity registers are consecutive, read them in the same burst */
rc = i2c_burst_read_dt(&config->bus, TI_HDC20XX_REG_TEMP, (uint8_t *)buf, sizeof(buf));
if (rc < 0) {
LOG_ERR("Failed to read sample data");
return rc;
}
data->t_sample = sys_le16_to_cpu(buf[0]);
data->rh_sample = sys_le16_to_cpu(buf[1]);
return 0;
}
static int ti_hdc20xx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct ti_hdc20xx_data *data = dev->data;
int32_t tmp;
/* See datasheet "Register Maps" section for more details on processing sample data. */
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
/* val = -40.5 + 165 * sample / 2^16 */
tmp = data->t_sample * TI_HDC20XX_TEMP_SCALE + TI_HDC20XX_TEMP_OFFSET;
val->val1 = tmp >> 16;
/* x * 1000000 / 2^16 = x * 15625 / 2^10 */
val->val2 = ((tmp & 0xFFFF) * 15625U) >> 10;
break;
case SENSOR_CHAN_HUMIDITY:
/* val = 100 * sample / 2^16 */
tmp = data->rh_sample * TI_HDC20XX_RH_SCALE;
val->val1 = tmp >> 16;
/* x * 1000000 / 2^16 = x * 15625 / 2^10 */
val->val2 = ((tmp & 0xFFFF) * 15625U) >> 10;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api ti_hdc20xx_api_funcs = {
.sample_fetch = ti_hdc20xx_sample_fetch,
.channel_get = ti_hdc20xx_channel_get,
};
static int ti_hdc20xx_reset(const struct device *dev)
{
const struct ti_hdc20xx_config *config = dev->config;
int rc;
rc = i2c_reg_write_byte_dt(&config->bus, TI_HDC20XX_REG_CONFIG,
TI_HDC20XX_BIT_CONFIG_SOFT_RES);
if (rc < 0) {
LOG_ERR("Failed to soft-reset device");
return rc;
}
k_sleep(TI_HDC20XX_RESET_TIME);
return 0;
}
static int ti_hdc20xx_init(const struct device *dev)
{
const struct ti_hdc20xx_config *config = dev->config;
struct ti_hdc20xx_data *data = dev->data;
uint16_t buf[2];
int rc;
if (!device_is_ready(config->bus.bus)) {
LOG_ERR("I2C bus %s not ready", config->bus.bus->name);
return -ENODEV;
}
/* manufacturer and device ID registers are consecutive, read them in the same burst */
rc = i2c_burst_read_dt(&config->bus, TI_HDC20XX_REG_MANUFACTURER_ID,
(uint8_t *)buf, sizeof(buf));
if (rc < 0) {
LOG_ERR("Failed to read manufacturer and device IDs");
return rc;
}
if (sys_le16_to_cpu(buf[0]) != TI_HDC20XX_MANUFACTURER_ID) {
LOG_ERR("Failed to get correct manufacturer ID");
return -EINVAL;
}
if (sys_le16_to_cpu(buf[1]) != TI_HDC20XX_DEVICE_ID) {
LOG_ERR("Unsupported device ID");
return -EINVAL;
}
/* Soft-reset the device to bring all registers in a known and consistent state */
rc = ti_hdc20xx_reset(dev);
if (rc < 0) {
return rc;
}
/* Configure the interrupt GPIO if available */
if (config->gpio_int.port) {
if (!gpio_is_ready_dt(&config->gpio_int)) {
LOG_ERR("Cannot get pointer to gpio interrupt device");
return -ENODEV;
}
rc = gpio_pin_configure_dt(&config->gpio_int, GPIO_INPUT);
if (rc) {
LOG_ERR("Failed to configure interrupt pin");
return rc;
}
gpio_init_callback(&data->cb_int, ti_hdc20xx_int_callback,
BIT(config->gpio_int.pin));
rc = gpio_add_callback(config->gpio_int.port, &data->cb_int);
if (rc) {
LOG_ERR("Failed to set interrupt callback");
return rc;
}
rc = gpio_pin_interrupt_configure_dt(&config->gpio_int, GPIO_INT_EDGE_TO_ACTIVE);
if (rc) {
LOG_ERR("Failed to configure interrupt");
return rc;
}
/* Initialize the semaphore */
k_sem_init(&data->sem_int, 0, K_SEM_MAX_LIMIT);
/* Enable the data ready interrupt */
rc = i2c_reg_write_byte_dt(&config->bus, TI_HDC20XX_REG_INT_EN,
TI_HDC20XX_BIT_INT_EN_DRDY_EN);
if (rc) {
LOG_ERR("Failed to enable the data ready interrupt");
return rc;
}
/* Enable the interrupt pin with level sensitive active low polarity */
rc = i2c_reg_write_byte_dt(&config->bus, TI_HDC20XX_REG_CONFIG,
TI_HDC20XX_BIT_CONFIG_DRDY_INT_EN);
if (rc) {
LOG_ERR("Failed to enable the interrupt pin");
return rc;
}
}
return 0;
}
/* Main instantiation macro */
#define TI_HDC20XX_DEFINE(inst, compat) \
static struct ti_hdc20xx_data ti_hdc20xx_data_##compat##inst; \
static const struct ti_hdc20xx_config ti_hdc20xx_config_##compat##inst = { \
.bus = I2C_DT_SPEC_GET(DT_INST(inst, compat)), \
.gpio_int = GPIO_DT_SPEC_GET_OR(DT_INST(inst, compat), int_gpios, {0}), \
}; \
DEVICE_DT_DEFINE(DT_INST(inst, compat), \
ti_hdc20xx_init, \
NULL, \
&ti_hdc20xx_data_##compat##inst, \
&ti_hdc20xx_config_##compat##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&ti_hdc20xx_api_funcs);
/* Create the struct device for every status "okay" node in the devicetree. */
#define TI_HDC20XX_FOREACH_STATUS_OKAY(compat, fn) \
COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat), \
(UTIL_CAT(DT_FOREACH_OKAY_INST_, \
compat)(fn)), \
())
/*
* HDC2010 Low-Power Humidity and Temperature Digital Sensors
*/
#define TI_HDC2010_DEFINE(inst) TI_HDC20XX_DEFINE(inst, ti_hdc2010)
TI_HDC20XX_FOREACH_STATUS_OKAY(ti_hdc2010, TI_HDC2010_DEFINE)
/*
* HDC2021 High-Accuracy, Low-Power Humidity and Temperature Sensor
* With Assembly Protection Cover
*/
#define TI_HDC2021_DEFINE(inst) TI_HDC20XX_DEFINE(inst, ti_hdc2021)
TI_HDC20XX_FOREACH_STATUS_OKAY(ti_hdc2021, TI_HDC2021_DEFINE)
/*
* HDC2022 High-Accuracy, Low-Power Humidity and Temperature Sensor
* With IP67 Rated Water and Dust Protection Cover
*/
#define TI_HDC2022_DEFINE(inst) TI_HDC20XX_DEFINE(inst, ti_hdc2022)
TI_HDC20XX_FOREACH_STATUS_OKAY(ti_hdc2022, TI_HDC2022_DEFINE)
/*
* HDC2080 Low-Power Humidity and Temperature Digital Sensor
*/
#define TI_HDC2080_DEFINE(inst) TI_HDC20XX_DEFINE(inst, ti_hdc2080)
TI_HDC20XX_FOREACH_STATUS_OKAY(ti_hdc2080, TI_HDC2080_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ti/ti_hdc20xx/ti_hdc20xx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,538 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/wsen/wsen_hids/Kconfig"
source "drivers/sensor/wsen/wsen_itds/Kconfig"
source "drivers/sensor/wsen/wsen_pads/Kconfig"
source "drivers/sensor/wsen/wsen_pdus/Kconfig"
source "drivers/sensor/wsen/wsen_tids/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/wsen/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 92 |
```c
/*
*
*/
#define DT_DRV_COMPAT we_wsen_hids
#include <zephyr/logging/log.h>
#include "wsen_hids.h"
LOG_MODULE_DECLARE(WSEN_HIDS, CONFIG_SENSOR_LOG_LEVEL);
static inline void hids_setup_drdy_interrupt(const struct device *dev, bool enable)
{
const struct hids_config *cfg = dev->config;
unsigned int flags = enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, flags);
}
static inline void hids_handle_drdy_interrupt(const struct device *dev)
{
struct hids_data *data = dev->data;
hids_setup_drdy_interrupt(dev, false);
#if defined(CONFIG_WSEN_HIDS_TRIGGER_OWN_THREAD)
k_sem_give(&data->drdy_sem);
#elif defined(CONFIG_WSEN_HIDS_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void hids_process_drdy_interrupt(const struct device *dev)
{
struct hids_data *data = dev->data;
if (data->data_ready_handler != NULL) {
data->data_ready_handler(dev, data->data_ready_trigger);
}
if (data->data_ready_handler != NULL) {
hids_setup_drdy_interrupt(dev, true);
}
}
int hids_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct hids_data *data = dev->data;
const struct hids_config *cfg = dev->config;
if (trig->type != SENSOR_TRIG_DATA_READY) {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
hids_setup_drdy_interrupt(dev, false);
data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
data->data_ready_trigger = trig;
hids_setup_drdy_interrupt(dev, true);
/*
* If DRDY is active we probably won't get the rising edge, so
* invoke the callback manually.
*/
if (gpio_pin_get_dt(&cfg->gpio_drdy) > 0) {
hids_handle_drdy_interrupt(dev);
}
return 0;
}
static void hids_drdy_callback(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
struct hids_data *data = CONTAINER_OF(cb, struct hids_data, data_ready_cb);
ARG_UNUSED(pins);
hids_handle_drdy_interrupt(data->dev);
}
#ifdef CONFIG_WSEN_HIDS_TRIGGER_OWN_THREAD
static void hids_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct hids_data *data = p1;
while (true) {
k_sem_take(&data->drdy_sem, K_FOREVER);
hids_process_drdy_interrupt(data->dev);
}
}
#endif /* CONFIG_WSEN_HIDS_TRIGGER_OWN_THREAD */
#ifdef CONFIG_WSEN_HIDS_TRIGGER_GLOBAL_THREAD
static void hids_work_cb(struct k_work *work)
{
struct hids_data *data = CONTAINER_OF(work, struct hids_data, work);
hids_process_drdy_interrupt(data->dev);
}
#endif /* CONFIG_WSEN_HIDS_TRIGGER_GLOBAL_THREAD */
int hids_init_interrupt(const struct device *dev)
{
struct hids_data *data = dev->data;
const struct hids_config *cfg = dev->config;
int status;
data->dev = dev;
if (cfg->gpio_drdy.port == NULL) {
LOG_ERR("drdy-gpios is not defined in the device tree.");
return -EINVAL;
}
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
LOG_ERR("Device %s is not ready", cfg->gpio_drdy.port->name);
return -ENODEV;
}
/* Setup data-ready gpio interrupt */
status = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (status < 0) {
LOG_ERR("Could not configure %s.%02u", cfg->gpio_drdy.port->name,
cfg->gpio_drdy.pin);
return status;
}
gpio_init_callback(&data->data_ready_cb, hids_drdy_callback, BIT(cfg->gpio_drdy.pin));
status = gpio_add_callback(cfg->gpio_drdy.port, &data->data_ready_cb);
if (status < 0) {
LOG_ERR("Could not set gpio callback.");
return status;
}
/* Enable data-ready interrupt */
if (HIDS_enableDataReadyInterrupt(&data->sensor_interface, HIDS_enable) != WE_SUCCESS) {
LOG_ERR("Could not enable data-ready interrupt.");
return -EIO;
}
#if defined(CONFIG_WSEN_HIDS_TRIGGER_OWN_THREAD)
k_sem_init(&data->drdy_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_WSEN_HIDS_THREAD_STACK_SIZE,
hids_thread, data, NULL, NULL,
K_PRIO_COOP(CONFIG_WSEN_HIDS_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_WSEN_HIDS_TRIGGER_GLOBAL_THREAD)
data->work.handler = hids_work_cb;
#endif
hids_setup_drdy_interrupt(dev, true);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_hids/wsen_hids_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,139 |
```unknown
menuconfig WSEN_HIDS
bool "WSEN-HIDS humidity and temperature sensor"
default y
depends on DT_HAS_WE_WSEN_HIDS_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_WE_WSEN_HIDS),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_WE_WSEN_HIDS),spi)
select HAS_WESENSORS
help
Enable driver for the WSEN-HIDS I2C/SPI-based humidity sensor with integrated
temperature sensor.
if WSEN_HIDS
choice WSEN_HIDS_TRIGGER_MODE
prompt "Trigger mode"
default WSEN_HIDS_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config WSEN_HIDS_TRIGGER_NONE
bool "No trigger"
config WSEN_HIDS_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select WSEN_HIDS_TRIGGER
config WSEN_HIDS_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select WSEN_HIDS_TRIGGER
endchoice # WSEN_HIDS_TRIGGER_MODE
config WSEN_HIDS_TRIGGER
bool
config WSEN_HIDS_THREAD_PRIORITY
int "Thread priority"
depends on WSEN_HIDS_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config WSEN_HIDS_THREAD_STACK_SIZE
int "Thread stack size"
depends on WSEN_HIDS_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # WSEN_HIDS
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_hids/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 338 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_WSEN_HIDS_WSEN_HIDS_H_
#define ZEPHYR_DRIVERS_SENSOR_WSEN_HIDS_WSEN_HIDS_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <weplatform.h>
#include "WSEN_HIDS_2523020210001.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
struct hids_data {
/* WE sensor interface configuration */
WE_sensorInterface_t sensor_interface;
/* Last humidity sample */
uint16_t humidity;
/* Last temperature sample */
int16_t temperature;
#ifdef CONFIG_WSEN_HIDS_TRIGGER
const struct device *dev;
struct gpio_callback data_ready_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_WSEN_HIDS_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_WSEN_HIDS_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem drdy_sem;
#elif defined(CONFIG_WSEN_HIDS_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_WSEN_HIDS_TRIGGER */
};
struct hids_config {
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} bus_cfg;
/* Output data rate */
HIDS_outputDataRate_t odr;
#ifdef CONFIG_WSEN_HIDS_TRIGGER
/* Data-ready interrupt pin */
const struct gpio_dt_spec gpio_drdy;
#endif /* CONFIG_WSEN_HIDS_TRIGGER */
};
#ifdef CONFIG_WSEN_HIDS_TRIGGER
int hids_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int hids_init_interrupt(const struct device *dev);
#endif /* CONFIG_WSEN_HIDS_TRIGGER */
int hids_spi_init(const struct device *dev);
int hids_i2c_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_WSEN_HIDS_WSEN_HIDS_H_ */
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_hids/wsen_hids.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 512 |
```c
/*
*
*/
#define DT_DRV_COMPAT we_wsen_hids
#include <string.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include "wsen_hids.h"
LOG_MODULE_REGISTER(WSEN_HIDS, CONFIG_SENSOR_LOG_LEVEL);
/*
* List of supported output data rates (sensor_value struct, input to
* sensor_attr_set()). Index into this list is used as argument for
* HIDS_setOutputDataRate().
*/
static const struct sensor_value hids_odr_list[] = {
{.val1 = 0, .val2 = 0},
{.val1 = 1, .val2 = 0},
{.val1 = 7, .val2 = 0},
{.val1 = 12, .val2 = 5 * 100000},
};
static int hids_sample_fetch(const struct device *dev, enum sensor_channel channel)
{
struct hids_data *data = dev->data;
int16_t raw_humidity;
int16_t raw_temp;
__ASSERT_NO_MSG(channel == SENSOR_CHAN_ALL);
if (HIDS_getRawValues(&data->sensor_interface, &raw_humidity, &raw_temp) != WE_SUCCESS) {
LOG_ERR("Failed to %s sample.", "fetch data");
return -EIO;
}
if (HIDS_convertHumidity_uint16(&data->sensor_interface, raw_humidity, &data->humidity) !=
WE_SUCCESS) {
LOG_ERR("Failed to %s sample.", "convert humidity");
return -EIO;
}
if (HIDS_convertTemperature_int16(&data->sensor_interface, raw_temp, &data->temperature) !=
WE_SUCCESS) {
LOG_ERR("Failed to %s sample.", "convert temperature");
return -EIO;
}
return 0;
}
static int hids_channel_get(const struct device *dev, enum sensor_channel channel,
struct sensor_value *value)
{
struct hids_data *data = dev->data;
int32_t value_converted;
if (channel == SENSOR_CHAN_AMBIENT_TEMP) {
value_converted = (int32_t)data->temperature;
/* Convert temperature from 0.01 degrees Celsius to degrees Celsius */
value->val1 = value_converted / 100;
value->val2 = (value_converted % 100) * (1000000 / 100);
} else if (channel == SENSOR_CHAN_HUMIDITY) {
value_converted = (int32_t)data->humidity;
/* Convert humidity from 0.01 percent to percent */
value->val1 = value_converted / 100;
value->val2 = (value_converted % 100) * (1000000 / 100);
} else {
return -ENOTSUP;
}
return 0;
}
/* Set output data rate. See hids_odr_list for allowed values. */
static int hids_odr_set(const struct device *dev, const struct sensor_value *odr)
{
struct hids_data *data = dev->data;
int odr_index;
for (odr_index = 0; odr_index < ARRAY_SIZE(hids_odr_list); odr_index++) {
if (odr->val1 == hids_odr_list[odr_index].val1 &&
odr->val2 == hids_odr_list[odr_index].val2) {
break;
}
}
if (odr_index == ARRAY_SIZE(hids_odr_list)) {
/* ODR not allowed (was not found in hids_odr_list) */
LOG_ERR("Bad sampling frequency %d.%d", odr->val1, odr->val2);
return -EINVAL;
}
if (HIDS_setOutputDataRate(&data->sensor_interface, (HIDS_outputDataRate_t)odr_index) !=
WE_SUCCESS) {
LOG_ERR("Failed to set output data rate");
return -EIO;
}
return 0;
}
static int hids_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL) {
LOG_WRN("attr_set() is not supported on channel %d.", chan);
return -ENOTSUP;
}
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
return hids_odr_set(dev, val);
} else {
return -ENOTSUP;
}
}
static const struct sensor_driver_api hids_driver_api = {
.attr_set = hids_attr_set,
#if CONFIG_WSEN_HIDS_TRIGGER
.trigger_set = hids_trigger_set,
#endif
.sample_fetch = hids_sample_fetch,
.channel_get = hids_channel_get,
};
static int hids_init(const struct device *dev)
{
const struct hids_config *config = dev->config;
struct hids_data *data = dev->data;
uint8_t device_id;
/* Initialize WE sensor interface */
WE_sensorInterfaceType_t interface_type = data->sensor_interface.interfaceType;
HIDS_getDefaultInterface(&data->sensor_interface);
data->sensor_interface.interfaceType = interface_type;
switch (data->sensor_interface.interfaceType) {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
case WE_i2c:
data->sensor_interface.handle = (void *)&config->bus_cfg.i2c;
break;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
case WE_spi:
data->sensor_interface.handle = (void *)&config->bus_cfg.spi;
break;
#endif
default:
LOG_ERR("Invalid interface type");
return -EINVAL;
}
/* First communication test - check device ID */
if (HIDS_getDeviceID(&data->sensor_interface, &device_id) != WE_SUCCESS) {
LOG_ERR("Failed to read device ID.");
return -EIO;
}
if (device_id != HIDS_DEVICE_ID_VALUE) {
LOG_ERR("Invalid device ID 0x%x.", device_id);
return -EINVAL;
}
if (HIDS_setOutputDataRate(&data->sensor_interface, config->odr) != WE_SUCCESS) {
LOG_ERR("Failed to set output data rate.");
return -EIO;
}
if (HIDS_enableBlockDataUpdate(&data->sensor_interface, HIDS_enable) != WE_SUCCESS) {
LOG_ERR("Failed to enable block data update.");
return -EIO;
}
if (HIDS_setPowerMode(&data->sensor_interface, HIDS_activeMode) != WE_SUCCESS) {
LOG_ERR("Failed to set power mode.");
return -EIO;
}
if (HIDS_readCalibrationData(&data->sensor_interface) != WE_SUCCESS) {
LOG_ERR("Failed to read calibration data.");
return -EIO;
}
#if CONFIG_WSEN_HIDS_TRIGGER
int status = hids_init_interrupt(dev);
if (status < 0) {
LOG_ERR("Failed to initialize data-ready interrupt.");
return status;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "HIDS driver enabled without any devices"
#endif
/*
* Device creation macros
*/
#define HIDS_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
hids_init, \
NULL, \
&hids_data_##inst, \
&hids_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&hids_driver_api);
#ifdef CONFIG_WSEN_HIDS_TRIGGER
#define HIDS_CFG_IRQ(inst) .gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, drdy_gpios)
#else
#define HIDS_CFG_IRQ(inst)
#endif /* CONFIG_WSEN_HIDS_TRIGGER */
#define HIDS_CONFIG_COMMON(inst) \
.odr = (HIDS_outputDataRate_t)(DT_INST_ENUM_IDX(inst, odr) + 1), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(HIDS_CFG_IRQ(inst)), ())
/*
* Instantiation macros used when device is on SPI bus.
*/
#define HIDS_SPI_OPERATION (SPI_WORD_SET(8) | SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA)
#define HIDS_CONFIG_SPI(inst) \
{ \
.bus_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
HIDS_SPI_OPERATION, \
0), \
}, \
HIDS_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when device is on I2C bus.
*/
#define HIDS_CONFIG_I2C(inst) \
{ \
.bus_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
HIDS_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define HIDS_DEFINE(inst) \
static struct hids_data hids_data_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), \
({ .sensor_interface = { .interfaceType = WE_i2c } }), ()) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
({ .sensor_interface = { .interfaceType = WE_spi } }), ());\
static const struct hids_config hids_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), (HIDS_CONFIG_I2C(inst)), ()) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), (HIDS_CONFIG_SPI(inst)), ()); \
HIDS_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(HIDS_DEFINE)
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_hids/wsen_hids.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,129 |
```c
/*
*
*/
#define DT_DRV_COMPAT we_wsen_tids
#include <stdlib.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include "wsen_tids.h"
LOG_MODULE_REGISTER(WSEN_TIDS, CONFIG_SENSOR_LOG_LEVEL);
/*
* List of supported output data rates. Index into this list is used as
* argument for TIDS_setOutputDataRate()
*/
static const int32_t tids_odr_list[] = {
25,
50,
100,
200,
};
static int tids_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct tids_data *data = dev->data;
int16_t raw_temperature;
if ((chan != SENSOR_CHAN_ALL) && (chan != SENSOR_CHAN_AMBIENT_TEMP)) {
LOG_ERR("Fetching is not supported on channel %d.", chan);
return -EINVAL;
}
if (TIDS_getRawTemperature(&data->sensor_interface, &raw_temperature) != WE_SUCCESS) {
LOG_ERR("Failed to fetch data sample");
return -EIO;
}
data->temperature = raw_temperature;
return 0;
}
static int tids_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct tids_data *data = dev->data;
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
/* Convert temperature from 0.01 degrees Celsius to degrees Celsius */
val->val1 = data->temperature / 100;
val->val2 = ((int32_t)data->temperature % 100) * (1000000 / 100);
} else {
return -ENOTSUP;
}
return 0;
}
/* Set output data rate. See tids_odr_list for allowed values. */
static int tids_odr_set(const struct device *dev, const struct sensor_value *odr)
{
struct tids_data *data = dev->data;
int odr_index;
for (odr_index = 0; odr_index < ARRAY_SIZE(tids_odr_list); odr_index++) {
if (odr->val1 == tids_odr_list[odr_index] && odr->val2 == 0) {
break;
}
}
if (odr_index == ARRAY_SIZE(tids_odr_list)) {
/* ODR not allowed (was not found in tids_odr_list) */
LOG_ERR("Bad sampling frequency %d.%d", odr->val1, abs(odr->val2));
return -EINVAL;
}
if (TIDS_setOutputDataRate(&data->sensor_interface, (TIDS_outputDataRate_t)odr_index) !=
WE_SUCCESS) {
LOG_ERR("Failed to set output data rate");
return -EIO;
}
return 0;
}
static int tids_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL) {
LOG_WRN("attr_set() is not supported on channel %d.", chan);
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return tids_odr_set(dev, val);
#ifdef CONFIG_WSEN_TIDS_TRIGGER
case SENSOR_ATTR_LOWER_THRESH:
return tids_threshold_set(dev, val, false);
case SENSOR_ATTR_UPPER_THRESH:
return tids_threshold_set(dev, val, true);
#endif /* CONFIG_WSEN_TIDS_TRIGGER */
default:
LOG_ERR("Operation not supported.");
return -ENOTSUP;
}
}
static const struct sensor_driver_api tids_driver_api = {
.attr_set = tids_attr_set,
#if CONFIG_WSEN_TIDS_TRIGGER
.trigger_set = tids_trigger_set,
#endif
.sample_fetch = tids_sample_fetch,
.channel_get = tids_channel_get,
};
static int tids_init(const struct device *dev)
{
const struct tids_config *const config = dev->config;
struct tids_data *data = dev->data;
int status;
uint8_t device_id;
struct sensor_value odr;
/* Initialize WE sensor interface */
TIDS_getDefaultInterface(&data->sensor_interface);
data->sensor_interface.interfaceType = WE_i2c;
data->sensor_interface.handle = (void *)&config->bus_cfg.i2c;
/* First communication test - check device ID */
if (TIDS_getDeviceID(&data->sensor_interface, &device_id) != WE_SUCCESS) {
LOG_ERR("Failed to read device ID.");
return -EIO;
}
if (device_id != TIDS_DEVICE_ID_VALUE) {
LOG_ERR("Invalid device ID 0x%x.", device_id);
return -EIO;
}
/* Reset the sensor with an arbitrary off time of 5 us */
TIDS_softReset(&data->sensor_interface, TIDS_enable);
k_sleep(K_USEC(5));
TIDS_softReset(&data->sensor_interface, TIDS_disable);
odr.val1 = tids_odr_list[config->odr];
odr.val2 = 0;
status = tids_odr_set(dev, &odr);
if (status < 0) {
LOG_ERR("Failed to set output data rate.");
return status;
}
if (TIDS_enableBlockDataUpdate(&data->sensor_interface, TIDS_enable) != WE_SUCCESS) {
LOG_ERR("Failed to enable block data update.");
return -EIO;
}
if (TIDS_enableContinuousMode(&data->sensor_interface, TIDS_enable) != WE_SUCCESS) {
LOG_ERR("Failed to enable continuous mode.");
return -EIO;
}
#ifdef CONFIG_WSEN_TIDS_TRIGGER
status = tids_init_interrupt(dev);
if (status < 0) {
LOG_ERR("Failed to initialize threshold interrupt.");
return status;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "TIDS driver enabled without any devices"
#endif
/*
* Device creation macros
*/
#define TIDS_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
tids_init, \
NULL, \
&tids_data_##inst, \
&tids_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&tids_driver_api);
#ifdef CONFIG_WSEN_TIDS_TRIGGER
#define TIDS_CFG_IRQ(inst) \
.gpio_threshold = GPIO_DT_SPEC_INST_GET(inst, int_gpios), \
.high_threshold = DT_INST_PROP(inst, temp_high_threshold), \
.low_threshold = DT_INST_PROP(inst, temp_low_threshold)
#else
#define TIDS_CFG_IRQ(inst)
#endif /* CONFIG_WSEN_TIDS_TRIGGER */
/*
* Main instantiation macro.
*/
#define TIDS_DEFINE(inst) \
static struct tids_data tids_data_##inst; \
static const struct tids_config tids_config_##inst = \
{ \
.bus_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
.odr = (TIDS_outputDataRate_t)(DT_INST_ENUM_IDX(inst, odr)), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, int_gpios), \
(TIDS_CFG_IRQ(inst)), ()) \
}; \
TIDS_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(TIDS_DEFINE)
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_tids/wsen_tids.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,608 |
```unknown
menuconfig WSEN_TIDS
bool "WSEN-TIDS temperature sensor"
default y
depends on DT_HAS_WE_WSEN_TIDS_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_WE_WSEN_TIDS),i2c)
select HAS_WESENSORS
help
Enable driver for the WSEN-TIDS I2C-based temperature sensor.
if WSEN_TIDS
choice WSEN_TIDS_TRIGGER_MODE
prompt "Trigger mode"
default WSEN_TIDS_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config WSEN_TIDS_TRIGGER_NONE
bool "No trigger"
config WSEN_TIDS_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select WSEN_TIDS_TRIGGER
config WSEN_TIDS_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select WSEN_TIDS_TRIGGER
endchoice # WSEN_TIDS_TRIGGER_MODE
config WSEN_TIDS_TRIGGER
bool
config WSEN_TIDS_THREAD_PRIORITY
int "Thread priority"
depends on WSEN_TIDS_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config WSEN_TIDS_THREAD_STACK_SIZE
int "Thread stack size"
depends on WSEN_TIDS_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # WSEN_TIDS
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_tids/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 308 |
```c
/*
*
*/
#define DT_DRV_COMPAT we_wsen_tids
#include <stdlib.h>
#include <zephyr/logging/log.h>
#include "wsen_tids.h"
LOG_MODULE_DECLARE(WSEN_TIDS, CONFIG_SENSOR_LOG_LEVEL);
#define THRESHOLD_TEMPERATURE2REGISTER_OFFSET (double)63.
#define THRESHOLD_TEMPERATURE2REGISTER_STEP (double)0.64
/* Enable/disable threshold interrupt handling */
static inline void tids_setup_threshold_interrupt(const struct device *dev, bool enable)
{
const struct tids_config *cfg = dev->config;
unsigned int flags = enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->gpio_threshold, flags);
}
/*
* Is called when a "threshold exceeded" interrupt occurred. Triggers
* asynchronous processing of the interrupt in tids_process_threshold_interrupt().
*/
static void tids_handle_threshold_interrupt(const struct device *dev)
{
struct tids_data *data = dev->data;
/* Disable interrupt handling until the interrupt has been processed */
tids_setup_threshold_interrupt(dev, false);
#if defined(CONFIG_WSEN_TIDS_TRIGGER_OWN_THREAD)
k_sem_give(&data->threshold_sem);
#elif defined(CONFIG_WSEN_TIDS_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
/*
* Is called after a "threshold exceeded" interrupt occurred.
* Checks the sensor's status register for the limit exceeded flags and
* calls the trigger handler if one of the flags is set.
*/
static void tids_process_threshold_interrupt(const struct device *dev)
{
struct tids_data *data = dev->data;
TIDS_status_t status;
/*
* Read the sensor's status register - this also causes the interrupt pin
* to be de-asserted
*/
if (TIDS_getStatusRegister(&data->sensor_interface, &status) != WE_SUCCESS) {
LOG_ERR("Failed to read status register");
return;
}
if (data->threshold_handler != NULL &&
(status.upperLimitExceeded != 0 || status.lowerLimitExceeded != 0)) {
data->threshold_handler(dev, data->threshold_trigger);
}
if (data->threshold_handler != NULL) {
tids_setup_threshold_interrupt(dev, true);
}
}
/* Enables/disables processing of the "threshold exceeded" interrupt. */
int tids_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct tids_data *data = dev->data;
const struct tids_config *cfg = dev->config;
if (trig->type != SENSOR_TRIG_THRESHOLD) {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
tids_setup_threshold_interrupt(dev, false);
data->threshold_handler = handler;
if (handler == NULL) {
return 0;
}
data->threshold_trigger = trig;
tids_setup_threshold_interrupt(dev, true);
/*
* If threshold interrupt is active we probably won't get the rising edge, so
* invoke the callback manually.
*/
if (gpio_pin_get_dt(&cfg->gpio_threshold) > 0) {
tids_handle_threshold_interrupt(dev);
}
return 0;
}
static void tids_threshold_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins)
{
struct tids_data *data = CONTAINER_OF(cb, struct tids_data, threshold_cb);
ARG_UNUSED(pins);
tids_handle_threshold_interrupt(data->dev);
}
#ifdef CONFIG_WSEN_TIDS_TRIGGER_OWN_THREAD
static void tids_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct tids_data *tids = p1;
while (true) {
k_sem_take(&tids->threshold_sem, K_FOREVER);
tids_process_threshold_interrupt(tids->dev);
}
}
#endif /* CONFIG_WSEN_TIDS_TRIGGER_OWN_THREAD */
#ifdef CONFIG_WSEN_TIDS_TRIGGER_GLOBAL_THREAD
static void tids_work_cb(struct k_work *work)
{
struct tids_data *tids = CONTAINER_OF(work, struct tids_data, work);
tids_process_threshold_interrupt(tids->dev);
}
#endif /* CONFIG_WSEN_TIDS_TRIGGER_GLOBAL_THREAD */
int tids_threshold_set(const struct device *dev, const struct sensor_value *thresh_value,
bool upper)
{
struct tids_data *data = dev->data;
double thresh = (sensor_value_to_double(thresh_value) / THRESHOLD_TEMPERATURE2REGISTER_STEP)
+ THRESHOLD_TEMPERATURE2REGISTER_OFFSET;
if (thresh < 0) {
thresh = 0;
} else if (thresh > 255) {
thresh = 255;
}
if (upper) {
if (TIDS_setTempHighLimit(&data->sensor_interface, (uint8_t)thresh) != WE_SUCCESS) {
LOG_ERR("Failed to set high temperature threshold to %d.%d (%d).",
thresh_value->val1, abs(thresh_value->val2), (uint8_t)thresh);
return -EIO;
}
} else {
if (TIDS_setTempLowLimit(&data->sensor_interface, (uint8_t)thresh) != WE_SUCCESS) {
LOG_ERR("Failed to set low temperature threshold to %d.%d (%d).",
thresh_value->val1, abs(thresh_value->val2), (uint8_t)thresh);
return -EIO;
}
}
return 0;
}
int tids_init_interrupt(const struct device *dev)
{
struct tids_data *data = dev->data;
const struct tids_config *cfg = dev->config;
int status;
struct sensor_value upper_limit;
struct sensor_value lower_limit;
if (cfg->gpio_threshold.port == NULL) {
LOG_ERR("int-gpios is not defined in the device tree.");
return -EINVAL;
}
if (!gpio_is_ready_dt(&cfg->gpio_threshold)) {
LOG_ERR("Device %s is not ready", cfg->gpio_threshold.port->name);
return -ENODEV;
}
data->dev = dev;
/* Setup threshold gpio interrupt */
status = gpio_pin_configure_dt(&cfg->gpio_threshold, GPIO_INPUT);
if (status < 0) {
LOG_ERR("Failed to configure %s.%02u", cfg->gpio_threshold.port->name,
cfg->gpio_threshold.pin);
return status;
}
gpio_init_callback(&data->threshold_cb, tids_threshold_callback,
BIT(cfg->gpio_threshold.pin));
status = gpio_add_callback(cfg->gpio_threshold.port, &data->threshold_cb);
if (status < 0) {
LOG_ERR("Failed to set gpio callback.");
return status;
}
/*
* Enable interrupt on high/low temperature (interrupt generation is enabled if at
* least one threshold is non-zero)
*/
upper_limit.val1 = cfg->high_threshold;
upper_limit.val2 = 0;
lower_limit.val1 = cfg->low_threshold;
lower_limit.val2 = 0;
status = tids_threshold_set(dev, &upper_limit, true);
if (status < 0) {
return status;
}
status = tids_threshold_set(dev, &lower_limit, false);
if (status < 0) {
return status;
}
#if defined(CONFIG_WSEN_TIDS_TRIGGER_OWN_THREAD)
k_sem_init(&data->threshold_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_WSEN_TIDS_THREAD_STACK_SIZE,
tids_thread, data, NULL, NULL,
K_PRIO_COOP(CONFIG_WSEN_TIDS_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_WSEN_TIDS_TRIGGER_GLOBAL_THREAD)
data->work.handler = tids_work_cb;
#endif
tids_setup_threshold_interrupt(dev, true);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_tids/wsen_tids_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,678 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_WSEN_TIDS_WSEN_TIDS_H_
#define ZEPHYR_DRIVERS_SENSOR_WSEN_TIDS_WSEN_TIDS_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <weplatform.h>
#include "WSEN_TIDS_2521020222501.h"
#include <zephyr/drivers/i2c.h>
struct tids_data {
/* WE sensor interface configuration */
WE_sensorInterface_t sensor_interface;
/* Last temperature sample */
int16_t temperature;
#ifdef CONFIG_WSEN_TIDS_TRIGGER
const struct device *dev;
/* Callback for high/low limit interrupts */
struct gpio_callback threshold_cb;
const struct sensor_trigger *threshold_trigger;
sensor_trigger_handler_t threshold_handler;
#if defined(CONFIG_WSEN_TIDS_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_WSEN_TIDS_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem threshold_sem;
#elif defined(CONFIG_WSEN_TIDS_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_WSEN_TIDS_TRIGGER */
};
struct tids_config {
union {
const struct i2c_dt_spec i2c;
} bus_cfg;
/* Output data rate */
const TIDS_outputDataRate_t odr;
#ifdef CONFIG_WSEN_TIDS_TRIGGER
/* Interrupt pin used for high and low limit interrupt events */
const struct gpio_dt_spec gpio_threshold;
/* High temperature interrupt threshold */
const int high_threshold;
/* Low temperature interrupt threshold */
const int low_threshold;
#endif
};
#ifdef CONFIG_WSEN_TIDS_TRIGGER
int tids_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int tids_threshold_set(const struct device *dev, const struct sensor_value *thresh_value,
bool upper);
int tids_init_interrupt(const struct device *dev);
#endif
int tids_i2c_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_WSEN_TIDS_WSEN_TIDS_H_ */
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_tids/wsen_tids.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 433 |
```c
/*
*
*/
#define DT_DRV_COMPAT we_wsen_pads
#include <zephyr/logging/log.h>
#include "wsen_pads.h"
LOG_MODULE_DECLARE(WSEN_PADS, CONFIG_SENSOR_LOG_LEVEL);
/* Enable/disable data-ready interrupt handling */
static inline int pads_setup_drdy_interrupt(const struct device *dev, bool enable)
{
const struct pads_config *cfg = dev->config;
unsigned int flags = enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
return gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, flags);
}
/*
* Is called when a data-ready interrupt has occurred. Triggers
* asynchronous processing of the interrupt in pads_process_drdy_interrupt().
*/
static inline void pads_handle_drdy_interrupt(const struct device *dev)
{
struct pads_data *data = dev->data;
/* Disable interrupt handling until the interrupt has been processed */
pads_setup_drdy_interrupt(dev, false);
#if defined(CONFIG_WSEN_PADS_TRIGGER_OWN_THREAD)
k_sem_give(&data->drdy_sem);
#elif defined(CONFIG_WSEN_PADS_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
/* Calls data-ready trigger handler (if any) */
static void pads_process_drdy_interrupt(const struct device *dev)
{
struct pads_data *data = dev->data;
if (data->data_ready_handler != NULL) {
data->data_ready_handler(dev, data->data_ready_triggerP);
pads_setup_drdy_interrupt(dev, true);
}
}
int pads_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct pads_data *data = dev->data;
const struct pads_config *cfg = dev->config;
int32_t pressure_dummy;
if (trig->type != SENSOR_TRIG_DATA_READY) {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
pads_setup_drdy_interrupt(dev, false);
data->data_ready_handler = handler;
if (handler == NULL) {
/* Disable data-ready interrupt */
if (PADS_enableDataReadyInterrupt(&data->sensor_interface, PADS_disable) !=
WE_SUCCESS) {
LOG_ERR("Failed to disable data-ready interrupt.");
return -EIO;
}
return 0;
}
data->data_ready_triggerP = trig;
pads_setup_drdy_interrupt(dev, true);
/* Read pressure to retrigger interrupt */
if (PADS_getPressure_int(&data->sensor_interface, &pressure_dummy) != WE_SUCCESS) {
LOG_ERR("Failed to read sample");
return -EIO;
}
/* Enable data-ready interrupt */
if (PADS_enableDataReadyInterrupt(&data->sensor_interface, PADS_enable) != WE_SUCCESS) {
LOG_ERR("Failed to enable data-ready interrupt.");
return -EIO;
}
/*
* If data-ready is active we probably won't get the rising edge, so
* invoke the handler manually.
*/
if (gpio_pin_get_dt(&cfg->gpio_drdy) > 0) {
pads_handle_drdy_interrupt(dev);
}
return 0;
}
static void pads_drdy_callback(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
struct pads_data *data = CONTAINER_OF(cb, struct pads_data, data_ready_cb);
ARG_UNUSED(pins);
pads_handle_drdy_interrupt(data->dev);
}
#ifdef CONFIG_WSEN_PADS_TRIGGER_OWN_THREAD
static void pads_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct pads_data *data = p1;
while (true) {
k_sem_take(&data->drdy_sem, K_FOREVER);
pads_process_drdy_interrupt(data->dev);
}
}
#endif /* CONFIG_WSEN_PADS_TRIGGER_OWN_THREAD */
#ifdef CONFIG_WSEN_PADS_TRIGGER_GLOBAL_THREAD
static void pads_work_cb(struct k_work *work)
{
struct pads_data *data = CONTAINER_OF(work, struct pads_data, work);
pads_process_drdy_interrupt(data->dev);
}
#endif /* CONFIG_WSEN_PADS_TRIGGER_GLOBAL_THREAD */
int pads_init_interrupt(const struct device *dev)
{
struct pads_data *data = dev->data;
const struct pads_config *cfg = dev->config;
int status;
data->dev = dev;
if (cfg->gpio_drdy.port == NULL) {
LOG_ERR("drdy-gpios is not defined in the device tree.");
return -EINVAL;
}
if (!gpio_is_ready_dt(cfg->gpio_drdy.port)) {
LOG_ERR("Device %s is not ready", cfg->gpio_drdy.port->name);
return -ENODEV;
}
/* Setup data-ready gpio interrupt */
status = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (status < 0) {
LOG_ERR("Failed to configure %s.%02u", cfg->gpio_drdy.port->name,
cfg->gpio_drdy.pin);
return status;
}
gpio_init_callback(&data->data_ready_cb, pads_drdy_callback, BIT(cfg->gpio_drdy.pin));
status = gpio_add_callback(cfg->gpio_drdy.port, &data->data_ready_cb);
if (status < 0) {
LOG_ERR("Failed to set gpio callback.");
return status;
}
#if defined(CONFIG_WSEN_PADS_TRIGGER_OWN_THREAD)
k_sem_init(&data->drdy_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_WSEN_PADS_THREAD_STACK_SIZE,
pads_thread, data, NULL, NULL,
K_PRIO_COOP(CONFIG_WSEN_PADS_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_WSEN_PADS_TRIGGER_GLOBAL_THREAD)
data->work.handler = pads_work_cb;
#endif
return pads_setup_drdy_interrupt(dev, true);
}
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_pads/wsen_pads_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,271 |
```c
/*
*
*/
#define DT_DRV_COMPAT we_wsen_pads
#include <string.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include "wsen_pads.h"
LOG_MODULE_REGISTER(WSEN_PADS, CONFIG_SENSOR_LOG_LEVEL);
/*
* List of supported output data rates. Index into this list is used as
* argument for PADS_setOutputDataRate()
*/
static const int32_t pads_odr_list[] = {
0, 1, 10, 25, 50, 75, 100, 200,
};
static int pads_sample_fetch(const struct device *dev, enum sensor_channel channel)
{
struct pads_data *data = dev->data;
__ASSERT_NO_MSG(channel == SENSOR_CHAN_ALL);
if (PADS_getPressure_int(&data->sensor_interface, &data->pressure) != WE_SUCCESS) {
LOG_ERR("Failed to fetch %s sample.", "pressure");
return -EIO;
}
if (PADS_getTemperature_int(&data->sensor_interface, &data->temperature) != WE_SUCCESS) {
LOG_ERR("Failed to fetch %s sample.", "temperature");
return -EIO;
}
return 0;
}
static int pads_channel_get(const struct device *dev, enum sensor_channel channel,
struct sensor_value *value)
{
struct pads_data *data = dev->data;
int32_t value_converted;
if (channel == SENSOR_CHAN_AMBIENT_TEMP) {
value_converted = (int32_t)data->temperature;
/* Convert temperature from 0.01 degrees Celsius to degrees Celsius */
value->val1 = value_converted / 100;
value->val2 = (value_converted % 100) * (1000000 / 100);
} else if (channel == SENSOR_CHAN_PRESS) {
value_converted = (int32_t)data->pressure;
/* Convert pressure from Pa to kPa */
value->val1 = value_converted / 1000;
value->val2 = (value_converted % 1000) * (1000000 / 1000);
} else {
return -ENOTSUP;
}
return 0;
}
/* Set output data rate. See pads_odr_list for allowed values. */
static int pads_odr_set(const struct device *dev, const struct sensor_value *odr)
{
struct pads_data *data = dev->data;
int odr_index;
for (odr_index = 0; odr_index < ARRAY_SIZE(pads_odr_list); odr_index++) {
if (odr->val1 == pads_odr_list[odr_index] && odr->val2 == 0) {
break;
}
}
if (odr_index == ARRAY_SIZE(pads_odr_list)) {
/* ODR not allowed (was not found in pads_odr_list) */
LOG_ERR("Bad sampling frequency %d.%d", odr->val1, odr->val2);
return -EINVAL;
}
if (PADS_setOutputDataRate(&data->sensor_interface, (PADS_outputDataRate_t)odr_index) !=
WE_SUCCESS) {
LOG_ERR("Failed to set output data rate");
return -EIO;
}
return 0;
}
static int pads_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL) {
LOG_WRN("attr_set() is not supported on channel %d.", chan);
return -ENOTSUP;
}
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
return pads_odr_set(dev, val);
} else {
return -ENOTSUP;
}
}
static const struct sensor_driver_api pads_driver_api = {
.attr_set = pads_attr_set,
#if CONFIG_WSEN_PADS_TRIGGER
.trigger_set = pads_trigger_set,
#endif
.sample_fetch = pads_sample_fetch,
.channel_get = pads_channel_get,
};
static int pads_init(const struct device *dev)
{
const struct pads_config *config = dev->config;
struct pads_data *data = dev->data;
struct sensor_value odr;
int status;
uint8_t device_id;
/* Initialize WE sensor interface */
WE_sensorInterfaceType_t interface_type = data->sensor_interface.interfaceType;
PADS_getDefaultInterface(&data->sensor_interface);
data->sensor_interface.interfaceType = interface_type;
switch (data->sensor_interface.interfaceType) {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
case WE_i2c:
data->sensor_interface.handle = (void *)&config->bus_cfg.i2c;
break;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
case WE_spi:
data->sensor_interface.handle = (void *)&config->bus_cfg.spi;
break;
#endif
default:
LOG_ERR("Invalid interface type");
return -EINVAL;
}
/* First communication test - check device ID */
if (PADS_getDeviceID(&data->sensor_interface, &device_id) != WE_SUCCESS) {
LOG_ERR("Failed to read device ID.");
return -EIO;
}
if (device_id != PADS_DEVICE_ID_VALUE) {
LOG_ERR("Invalid device ID 0x%x.", device_id);
return -EINVAL;
}
/* Reset sensor */
PADS_softReset(&data->sensor_interface, PADS_enable);
k_sleep(K_USEC(50));
PADS_state_t swReset;
do {
if (PADS_getSoftResetState(&data->sensor_interface, &swReset) != WE_SUCCESS) {
LOG_ERR("Failed to get sensor reset state.");
return -EIO;
}
} while (PADS_enable == swReset);
if (PADS_enableBlockDataUpdate(&data->sensor_interface, PADS_enable) != WE_SUCCESS) {
LOG_ERR("Failed to enable block data update.");
return -EIO;
}
#if CONFIG_WSEN_PADS_TRIGGER
status = pads_init_interrupt(dev);
if (status < 0) {
LOG_ERR("Failed to initialize data-ready interrupt.");
return status;
}
#endif
odr.val1 = pads_odr_list[config->odr];
odr.val2 = 0;
status = pads_odr_set(dev, &odr);
if (status < 0) {
LOG_ERR("Failed to set output data rate.");
return status;
}
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "PADS driver enabled without any devices"
#endif
/*
* Device creation macros
*/
#define PADS_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
pads_init, \
NULL, \
&pads_data_##inst, \
&pads_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&pads_driver_api);
#ifdef CONFIG_WSEN_PADS_TRIGGER
#define PADS_CFG_IRQ(inst) .gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, drdy_gpios)
#else
#define PADS_CFG_IRQ(inst)
#endif /* CONFIG_WSEN_PADS_TRIGGER */
#define PADS_CONFIG_COMMON(inst) \
.odr = (PADS_outputDataRate_t)(DT_INST_ENUM_IDX(inst, odr)), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(PADS_CFG_IRQ(inst)), ())
/*
* Instantiation macros used when device is on SPI bus.
*/
#define PADS_SPI_OPERATION (SPI_WORD_SET(8) | SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA)
#define PADS_CONFIG_SPI(inst) \
{ \
.bus_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
PADS_SPI_OPERATION, \
0), \
}, \
PADS_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when device is on I2C bus.
*/
#define PADS_CONFIG_I2C(inst) \
{ \
.bus_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
PADS_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define PADS_DEFINE(inst) \
static struct pads_data pads_data_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), \
({ .sensor_interface = { .interfaceType = WE_i2c } }), ()) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
({ .sensor_interface = { .interfaceType = WE_spi } }), ()); \
static const struct pads_config pads_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), (PADS_CONFIG_I2C(inst)), ()) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), (PADS_CONFIG_SPI(inst)), ()); \
PADS_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(PADS_DEFINE)
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_pads/wsen_pads.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,994 |
```unknown
menuconfig WSEN_PADS
bool "WSEN-PADS absolute pressure and temperature sensor"
default y
depends on DT_HAS_WE_WSEN_PADS_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_WE_WSEN_PADS),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_WE_WSEN_PADS),spi)
select HAS_WESENSORS
help
Enable driver for the WSEN-PADS I2C/SPI-based absolute pressure sensor with integrated
temperature sensor.
if WSEN_PADS
choice WSEN_PADS_TRIGGER_MODE
prompt "Trigger mode"
default WSEN_PADS_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config WSEN_PADS_TRIGGER_NONE
bool "No trigger"
config WSEN_PADS_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select WSEN_PADS_TRIGGER
config WSEN_PADS_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select WSEN_PADS_TRIGGER
endchoice # WSEN_PADS_TRIGGER_MODE
config WSEN_PADS_TRIGGER
bool
config WSEN_PADS_THREAD_PRIORITY
int "Thread priority"
depends on WSEN_PADS_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config WSEN_PADS_THREAD_STACK_SIZE
int "Thread stack size"
depends on WSEN_PADS_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # WSEN_PADS
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_pads/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 340 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_WSEN_PADS_WSEN_PADS_H_
#define ZEPHYR_DRIVERS_SENSOR_WSEN_PADS_WSEN_PADS_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <weplatform.h>
#include "WSEN_PADS_2511020213301.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
struct pads_data {
/* WE sensor interface configuration */
WE_sensorInterface_t sensor_interface;
/* Last pressure sample */
int32_t pressure;
/* Last temperature sample */
int16_t temperature;
#ifdef CONFIG_WSEN_PADS_TRIGGER
const struct device *dev;
struct gpio_callback data_ready_cb;
struct sensor_trigger *data_ready_triggerP;
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_WSEN_PADS_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_WSEN_PADS_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem drdy_sem;
#elif defined(CONFIG_WSEN_PADS_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_WSEN_PADS_TRIGGER */
};
struct pads_config {
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} bus_cfg;
/* Output data rate */
const PADS_outputDataRate_t odr;
#ifdef CONFIG_WSEN_PADS_TRIGGER
/* Interrupt pin used for data-ready */
const struct gpio_dt_spec gpio_drdy;
#endif /* CONFIG_WSEN_PADS_TRIGGER */
};
#ifdef CONFIG_WSEN_PADS_TRIGGER
int pads_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int pads_init_interrupt(const struct device *dev);
#endif /* CONFIG_WSEN_PADS_TRIGGER */
int pads_spi_init(const struct device *dev);
int pads_i2c_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_WSEN_PADS_WSEN_PADS_H_ */
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_pads/wsen_pads.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 509 |
```objective-c
/* Wrth Elektronic WSEN-ITDS 3-axis Accel sensor driver
*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ITDS_H_
#define ZEPHYR_DRIVERS_SENSOR_ITDS_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
/* registers */
#define ITDS_REG_TEMP_L 0x0d
#define ITDS_REG_DEV_ID 0x0f
#define ITDS_REG_CTRL1 0x20
#define ITDS_REG_CTRL2 0x21
#define ITDS_REG_CTRL3 0x22
#define ITDS_REG_CTRL4 0x23
#define ITDS_REG_CTRL5 0x24
#define ITDS_REG_CTRL6 0x25
#define ITDS_REG_STATUS 0x27
#define ITDS_REG_X_OUT_L 0x28
#define ITDS_REG_Y_OUT_L 0x2a
#define ITDS_REG_Z_OUT_L 0x2c
#define ITDS_REG_FIFO_CTRL 0x2e
#define ITDS_REG_FIFO_SAMPLES 0x2f
#define ITDS_REG_STATUS_DETECT 0x37
#define ITDS_REG_WAKEUP_EVENT 0x38
#define ITDS_REG_CTRL7 0x3f
/* bitfields */
#define ITDS_MASK_SCALE GENMASK(5, 4)
#define ITDS_MASK_BDU_INC_ADD GENMASK(3, 2)
#define ITDS_MASK_FIFOTH GENMASK(4, 0)
#define ITDS_MASK_FIFOMODE GENMASK(7, 5)
#define ITDS_MASK_MODE GENMASK(3, 0)
#define ITDS_MASK_SAMPLES_COUNT GENMASK(5, 0)
#define ITDS_MASK_ODR GENMASK(7, 4)
#define ITDS_MASK_INT_DRDY BIT(0)
#define ITDS_MASK_INT_FIFOTH BIT(1)
#define ITDS_MASK_INT_EN BIT(5)
#define ITDS_EVENT_DRDY BIT(0)
#define ITDS_EVENT_DRDY_T BIT(6)
#define ITDS_EVENT_FIFO_TH BIT(7)
#define ITDS_FIFO_MODE_BYPASS 0
#define ITDS_FIFO_MODE_FIFO BIT(5)
#define ITDS_DEVICE_ID 0x44
#define ITDS_ACCL_FIFO_SIZE 32
#define ITDS_TEMP_OFFSET 25
enum operation_mode {
ITDS_OP_MODE_LOW_POWER = BIT(0),
ITDS_OP_MODE_NORMAL = BIT(1),
ITDS_OP_MODE_HIGH_PERF = BIT(2),
};
enum itds_accel_range_const {
ITDS_ACCL_RANGE_2G,
ITDS_ACCL_RANGE_4G,
ITDS_ACCL_RANGE_8G,
ITDS_ACCL_RANGE_16G,
ITDS_ACCL_RANGE_END
};
enum itds_odr_const {
ITDS_ODR_0,
ITDS_ODR_1_6,
ITDS_ODR_12_5,
ITDS_ODR_25,
ITDS_ODR_50,
ITDS_ODR_100,
ITDS_ODR_200,
ITDS_ODR_400,
ITDS_ODR_800,
ITDS_ODR_1600,
ITDS_ODR_MAX
};
struct itds_odr {
uint16_t freq;
uint16_t mfreq;
};
struct itds_accel_range {
uint16_t range;
uint8_t reg_val;
};
struct itds_device_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_ITDS_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
int def_odr;
int def_op_mode;
};
#define ITDS_SAMPLE_SIZE 3
struct itds_device_data {
#ifdef CONFIG_ITDS_TRIGGER
struct gpio_callback gpio_cb;
struct k_work work;
#endif
int16_t samples[ITDS_SAMPLE_SIZE];
int16_t temperature;
int16_t scale;
enum operation_mode op_mode;
const struct device *dev;
#ifdef CONFIG_ITDS_TRIGGER
sensor_trigger_handler_t handler_drdy;
const struct sensor_trigger *trigger_drdy;
#endif /* CONFIG_ITDS_TRIGGER */
};
int itds_trigger_mode_init(const struct device *dev);
int itds_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* ZEPHYR_DRIVERS_SENSOR_ITDS_H_*/
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_itds/itds.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 969 |
```c
/*
*
* Wrth Elektronic WSEN-ITDS 3-axis accel sensor driver
*
* Author: Saravanan Sekar <saravanan@linumiz.com>
*/
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "itds.h"
LOG_MODULE_DECLARE(ITDS, CONFIG_SENSOR_LOG_LEVEL);
static int itds_trigger_drdy_set(const struct device *dev,
enum sensor_channel chan,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct itds_device_data *ddata = dev->data;
const struct itds_device_config *cfg = dev->config;
uint8_t drdy_en = 0U;
int ret;
ddata->handler_drdy = handler;
ddata->trigger_drdy = trig;
if (ddata->handler_drdy) {
drdy_en = ITDS_MASK_INT_DRDY;
}
ret = i2c_reg_update_byte_dt(&cfg->i2c, ITDS_REG_CTRL4,
ITDS_MASK_INT_DRDY, drdy_en);
if (ret) {
return ret;
}
return 0;
}
int itds_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct itds_device_config *cfg = dev->config;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
if (trig->chan != SENSOR_CHAN_ACCEL_XYZ) {
return -ENOTSUP;
}
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
return itds_trigger_drdy_set(dev, trig->chan, trig, handler);
default:
return -ENOTSUP;
}
}
static void itds_work_handler(struct k_work *work)
{
struct itds_device_data *ddata =
CONTAINER_OF(work, struct itds_device_data, work);
const struct device *dev = (const struct device *)ddata->dev;
const struct itds_device_config *cfg = dev->config;
uint8_t status;
if (i2c_reg_read_byte_dt(&cfg->i2c, ITDS_REG_STATUS,
&status) < 0) {
return;
}
if (status & ITDS_EVENT_DRDY) {
if (ddata->handler_drdy) {
ddata->handler_drdy(dev, ddata->trigger_drdy);
}
}
}
static void itds_gpio_callback(const struct device *port,
struct gpio_callback *cb, uint32_t pin)
{
struct itds_device_data *ddata =
CONTAINER_OF(cb, struct itds_device_data, gpio_cb);
ARG_UNUSED(port);
ARG_UNUSED(pin);
k_work_submit(&ddata->work);
}
int itds_trigger_mode_init(const struct device *dev)
{
struct itds_device_data *ddata = dev->data;
const struct itds_device_config *cfg = dev->config;
/* dts doesn't have GPIO int pin set, so we dont support
* trigger mode for this instance
*/
if (!cfg->int_gpio.port) {
return 0;
}
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name,
cfg->int_gpio.port->name);
return -ENODEV;
}
ddata->work.handler = itds_work_handler;
ddata->dev = dev;
gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
gpio_init_callback(&ddata->gpio_cb, itds_gpio_callback,
BIT(cfg->int_gpio.pin));
gpio_add_callback(cfg->int_gpio.port, &ddata->gpio_cb);
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
/* enable global interrupt */
return i2c_reg_update_byte_dt(&cfg->i2c, ITDS_REG_CTRL7,
ITDS_MASK_INT_EN, ITDS_MASK_INT_EN);
}
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_itds/itds_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 878 |
```unknown
#
config ITDS
bool "WSEN-ITDS 3-axis accel sensor"
default y
depends on DT_HAS_WE_WSEN_ITDS_ENABLED
select I2C
help
Enable Wurth Elektronik WSEN-ITDS 3-axis acceleration sensor
provides acceleration and die temperature measurement.
if ITDS
config ITDS_TRIGGER
bool "Trigger mode"
help
Set to enable trigger mode using gpio interrupt, interrupts are
configured to line INT0.
endif # ITDS
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_itds/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 110 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_WSEN_PDUS_WSEN_PDUS_H_
#define ZEPHYR_DRIVERS_SENSOR_WSEN_PDUS_WSEN_PDUS_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <weplatform.h>
#include "WSEN_PDUS_25131308XXX01.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
struct pdus_data {
/* WE sensor interface configuration */
WE_sensorInterface_t sensor_interface;
/* Last pressure sample */
float pressure_k_pa;
/* Last temperature sample */
float temperature_deg_c;
};
struct pdus_config {
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
} bus_cfg;
PDUS_SensorType_t sensor_type;
};
int pdus_i2c_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_WSEN_PDUS_WSEN_PDUS_H_ */
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_pdus/wsen_pdus.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 244 |
```c
/*
*
* Wrth Elektronic WSEN-ITDS 3-axis accel sensor driver
*
* Author: Saravanan Sekar <saravanan@linumiz.com>
*/
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "itds.h"
#define DT_DRV_COMPAT we_wsen_itds
#define ITDS_TEMP_CONST 62500
LOG_MODULE_REGISTER(ITDS, CONFIG_SENSOR_LOG_LEVEL);
static const struct itds_odr itds_odr_map[ITDS_ODR_MAX] = {
{0}, {1, 600}, {12, 500}, {25}, {50}, {100}, {200},
{400}, {800}, {1600}
};
static const int16_t itds_sensitivity_scale[][ITDS_ACCL_RANGE_END] = {
{976, 1952, 3904, 7808},
/* high performance mode */
{244, 488, 976, 1952}
};
static int itds_get_odr_for_index(const struct device *dev,
enum itds_odr_const idx,
uint16_t *freq, uint16_t *mfreq)
{
struct itds_device_data *ddata = dev->data;
int start, end;
bool hp_mode;
hp_mode = !!(ddata->op_mode & ITDS_OP_MODE_HIGH_PERF);
if (hp_mode) {
start = ITDS_ODR_12_5;
end = ITDS_ODR_1600;
} else {
start = ITDS_ODR_1_6;
end = ITDS_ODR_200;
}
if (idx < start || idx > end) {
LOG_ERR("invalid odr for the operating mode");
return -EINVAL;
}
*freq = itds_odr_map[idx].freq;
*mfreq = itds_odr_map[idx].mfreq;
return 0;
}
static int itds_accl_odr_set(const struct device *dev, uint16_t freq,
uint16_t mfreq)
{
struct itds_device_data *ddata = dev->data;
const struct itds_device_config *cfg = dev->config;
int start, end, i;
bool hp_mode;
hp_mode = !!(ddata->op_mode & ITDS_OP_MODE_HIGH_PERF);
if (hp_mode) {
start = ITDS_ODR_12_5;
end = ITDS_ODR_1600;
} else {
start = ITDS_ODR_1_6;
end = ITDS_ODR_200;
}
for (i = start; i <= end; i++) {
if ((freq == itds_odr_map[i].freq) &&
(mfreq == itds_odr_map[i].mfreq)) {
return i2c_reg_update_byte_dt(&cfg->i2c,
ITDS_REG_CTRL1, ITDS_MASK_ODR, i << 4);
}
}
LOG_ERR("invalid odr, not in range");
return -EINVAL;
}
static int itds_accl_range_set(const struct device *dev, int32_t range)
{
struct itds_device_data *ddata = dev->data;
const struct itds_device_config *cfg = dev->config;
int i, ret;
bool hp_mode;
for (i = 0; i < ITDS_ACCL_RANGE_END; i++) {
if (range <= (2 << i)) {
break;
}
}
if (i == ITDS_ACCL_RANGE_END) {
LOG_ERR("Accl out of range");
return -EINVAL;
}
ret = i2c_reg_update_byte_dt(&cfg->i2c, ITDS_REG_CTRL6,
ITDS_MASK_SCALE, i << 4);
if (ret) {
LOG_ERR("Accl set full scale failed %d", ret);
return ret;
}
hp_mode = !!(ddata->op_mode & ITDS_OP_MODE_HIGH_PERF);
ddata->scale = itds_sensitivity_scale[hp_mode][i];
return 0;
}
static int itds_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ACCEL_X &&
chan != SENSOR_CHAN_ACCEL_Y &&
chan != SENSOR_CHAN_ACCEL_Z &&
chan != SENSOR_CHAN_ACCEL_XYZ) {
LOG_ERR("attr_set() not supported on this channel.");
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return itds_accl_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return itds_accl_odr_set(dev, val->val1, val->val2 / 1000);
default:
LOG_ERR("Accel attribute not supported.");
return -ENOTSUP;
}
}
static int itds_fetch_temperature(struct itds_device_data *ddata,
const struct itds_device_config *cfg)
{
uint8_t rval;
int16_t temp_raw = 0;
int ret;
ret = i2c_reg_read_byte_dt(&cfg->i2c,
ITDS_REG_STATUS_DETECT, &rval);
if (ret) {
return ret;
}
if (!(rval & ITDS_EVENT_DRDY_T)) {
return -EAGAIN;
}
ret = i2c_burst_read_dt(&cfg->i2c, ITDS_REG_TEMP_L,
(uint8_t *)&temp_raw, sizeof(uint16_t));
if (ret) {
return ret;
}
ddata->temperature = sys_le16_to_cpu(temp_raw);
return 0;
}
static int itds_fetch_accel(struct itds_device_data *ddata,
const struct itds_device_config *cfg)
{
size_t i, ret;
uint8_t rval;
ret = i2c_reg_read_byte_dt(&cfg->i2c,
ITDS_REG_STATUS, &rval);
if (ret) {
return ret;
}
if (!(rval & ITDS_EVENT_DRDY)) {
return -EAGAIN;
}
ret = i2c_burst_read_dt(&cfg->i2c, ITDS_REG_X_OUT_L,
(uint8_t *)ddata->samples,
sizeof(uint16_t) * ITDS_SAMPLE_SIZE);
if (ret) {
return ret;
}
/* convert samples to cpu endianness */
for (i = 0; i < ITDS_SAMPLE_SIZE; i += 2) {
int16_t *sample = (int16_t *) &ddata->samples[i];
*sample = sys_le16_to_cpu(*sample);
if (ddata->op_mode & ITDS_OP_MODE_NORMAL ||
ddata->op_mode & ITDS_OP_MODE_HIGH_PERF) {
*sample = *sample >> 2;
} else {
*sample = *sample >> 4;
}
LOG_DBG("itds sample %d %X\n", i, *sample);
}
return 0;
}
static int itds_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct itds_device_data *ddata = dev->data;
const struct itds_device_config *cfg = dev->config;
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
return itds_fetch_accel(ddata, cfg);
case SENSOR_CHAN_DIE_TEMP:
return itds_fetch_temperature(ddata, cfg);
case SENSOR_CHAN_ALL:
return itds_fetch_accel(ddata, cfg) ||
itds_fetch_temperature(ddata, cfg);
default:
return -EINVAL;
}
}
static inline void itds_accl_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
int i;
struct itds_device_data *ddata = dev->data;
uint8_t ofs_start, ofs_stop;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_ACCEL_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_ACCEL_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U; ofs_stop = 2U;
break;
}
for (i = ofs_start; i <= ofs_stop ; i++, val++) {
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)((ddata->samples[i] * ddata->scale * SENSOR_G) /
1000000LL);
val->val1 = (int32_t)(dval / 1000000);
val->val2 = (int32_t)(dval % 1000000);
}
}
static int itds_temp_channel_get(const struct device *dev,
struct sensor_value *val)
{
int32_t temp_processed;
struct itds_device_data *ddata = dev->data;
temp_processed = (ddata->temperature >> 4) * ITDS_TEMP_CONST;
val->val1 = ITDS_TEMP_OFFSET;
val->val2 = temp_processed;
return 0;
}
static int itds_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
itds_accl_channel_get(dev, chan, val);
return 0;
case SENSOR_CHAN_DIE_TEMP:
return itds_temp_channel_get(dev, val);
default:
LOG_ERR("Channel not supported.");
return -ENOTSUP;
}
return 0;
}
static int itds_init(const struct device *dev)
{
struct itds_device_data *ddata = dev->data;
const struct itds_device_config *cfg = dev->config;
int ret;
uint16_t freq, mfreq;
uint8_t rval;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
ret = i2c_reg_read_byte_dt(&cfg->i2c,
ITDS_REG_DEV_ID, &rval);
if (ret) {
LOG_ERR("device init fail: %d", ret);
return ret;
}
if (rval != ITDS_DEVICE_ID) {
LOG_ERR("device ID mismatch: %x", rval);
return -EIO;
}
ret = i2c_reg_update_byte_dt(&cfg->i2c, ITDS_REG_CTRL2,
ITDS_MASK_BDU_INC_ADD, ITDS_MASK_BDU_INC_ADD);
if (ret) {
LOG_ERR("unable to set block data update %d", ret);
return ret;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, ITDS_REG_WAKEUP_EVENT, 0);
if (ret) {
LOG_ERR("disable wakeup event fail %d", ret);
return ret;
}
ret = i2c_reg_update_byte_dt(&cfg->i2c, ITDS_REG_CTRL1,
ITDS_MASK_MODE, 1 << cfg->def_op_mode);
if (ret) {
LOG_ERR("set operating mode fail %d", ret);
return ret;
}
ddata->op_mode = 1 << cfg->def_op_mode;
ret = itds_get_odr_for_index(dev, cfg->def_odr, &freq, &mfreq);
if (ret) {
LOG_ERR("odr not in range for operating mode %d", ret);
return ret;
}
ret = itds_accl_odr_set(dev, freq, mfreq);
if (ret) {
LOG_ERR("odr not in range for operating mode %d", ret);
return ret;
}
#ifdef CONFIG_ITDS_TRIGGER
ret = itds_trigger_mode_init(dev);
if (ret) {
LOG_ERR("trigger mode init failed %d", ret);
return ret;
}
#endif
return 0;
}
static const struct sensor_driver_api itds_api = {
.attr_set = itds_attr_set,
#ifdef CONFIG_ITDS_TRIGGER
.trigger_set = itds_trigger_set,
#endif
.sample_fetch = itds_sample_fetch,
.channel_get = itds_channel_get,
};
#ifdef CONFIG_ITDS_TRIGGER
#define WSEN_ITDS_CFG_IRQ(inst) \
.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),
#else
#define WSEN_ITDS_CFG_IRQ(inst)
#endif
#define WSEN_ITDS_INIT(idx) \
\
static struct itds_device_data itds_data_##idx; \
\
static const struct itds_device_config itds_config_##idx = { \
.i2c = I2C_DT_SPEC_INST_GET(idx), \
.def_odr = DT_INST_ENUM_IDX(idx, odr), \
.def_op_mode = DT_INST_ENUM_IDX(idx, op_mode), \
WSEN_ITDS_CFG_IRQ(idx) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(idx, itds_init, NULL, \
&itds_data_##idx, &itds_config_##idx, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&itds_api); \
DT_INST_FOREACH_STATUS_OKAY(WSEN_ITDS_INIT)
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_itds/itds.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,968 |
```unknown
config WSEN_PDUS
bool "WSEN-PDUS differential pressure sensor"
default y
depends on DT_HAS_WE_WSEN_PDUS_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_WE_WSEN_PDUS),i2c)
select HAS_WESENSORS
help
Enable driver for the WSEN-PDUS I2C-based differential pressure sensor.
``` | /content/code_sandbox/drivers/sensor/wsen/wsen_pdus/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 84 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.