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 "tsl2591.h"
LOG_MODULE_DECLARE(TSL2591, CONFIG_SENSOR_LOG_LEVEL);
static inline void tsl2591_setup_int(const struct device *dev, bool enable)
{
const struct tsl2591_config *config = dev->config;
gpio_flags_t flags = enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
}
static void tsl2591_gpio_callback(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
ARG_UNUSED(dev);
ARG_UNUSED(pins);
struct tsl2591_data *data = CONTAINER_OF(cb, struct tsl2591_data, gpio_cb);
tsl2591_setup_int(data->dev, false);
#if defined(CONFIG_TSL2591_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_TSL2591_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void tsl2591_handle_int(const struct device *dev)
{
struct tsl2591_data *data = dev->data;
const struct tsl2591_config *config = dev->config;
uint8_t clear_cmd;
int ret;
/* Interrupt must be cleared manually */
clear_cmd = TSL2591_CLEAR_INT_CMD;
ret = i2c_write_dt(&config->i2c, &clear_cmd, 1U);
if (ret < 0) {
LOG_ERR("Failed to clear interrupt");
return;
}
if (data->th_handler != NULL) {
data->th_handler(dev, data->th_trigger);
}
tsl2591_setup_int(dev, true);
}
#ifdef CONFIG_TSL2591_TRIGGER_OWN_THREAD
static void tsl2591_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct tsl2591_data *data = p1;
while (1) {
k_sem_take(&data->trig_sem, K_FOREVER);
tsl2591_handle_int(data->dev);
}
}
#endif
#ifdef CONFIG_TSL2591_TRIGGER_GLOBAL_THREAD
static void tsl2591_work_handler(struct k_work *work)
{
struct tsl2591_data *data = CONTAINER_OF(work, struct tsl2591_data, work);
tsl2591_handle_int(data->dev);
}
#endif
int tsl2591_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct tsl2591_data *data = dev->data;
const struct tsl2591_config *config = dev->config;
int ret;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (trig->chan != SENSOR_CHAN_LIGHT) {
LOG_ERR("Unsupported sensor trigger channel");
return -ENOTSUP;
}
if (trig->type != SENSOR_TRIG_THRESHOLD) {
LOG_ERR("Unsupported sensor trigger type");
return -ENOTSUP;
}
data->th_handler = handler;
data->th_trigger = trig;
tsl2591_setup_int(dev, true);
ret = tsl2591_reg_update(dev, TSL2591_REG_ENABLE, TSL2591_AIEN_MASK, TSL2591_AIEN_ON);
if (ret < 0) {
LOG_ERR("Failed to enable interrupt on sensor");
}
return ret;
}
int tsl2591_initialize_int(const struct device *dev)
{
struct tsl2591_data *data = dev->data;
const struct tsl2591_config *config = dev->config;
int ret;
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("%s: gpio controller %s not ready", dev->name, config->int_gpio.port->name);
return -ENODEV;
}
ret = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT | config->int_gpio.dt_flags);
if (ret < 0) {
LOG_ERR("Failed to configure gpio pin for input");
return ret;
}
gpio_init_callback(&data->gpio_cb, tsl2591_gpio_callback, BIT(config->int_gpio.pin));
ret = gpio_add_callback(config->int_gpio.port, &data->gpio_cb);
if (ret < 0) {
LOG_DBG("Failed to set gpio callback");
return ret;
}
data->dev = dev;
#if defined(CONFIG_TSL2591_TRIGGER_OWN_THREAD)
ret = k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
if (ret < 0) {
LOG_ERR("Failed to initialize trigger semaphore");
return ret;
}
k_thread_create(&data->thread, data->thread_stack, CONFIG_TSL2591_THREAD_STACK_SIZE,
tsl2591_thread, data, NULL, NULL,
K_PRIO_COOP(CONFIG_TSL2591_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_TSL2591_TRIGGER_GLOBAL_THREAD)
data->work.handler = tsl2591_work_handler;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/ams/tsl2591/tsl2591_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,061 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_tsl2591
#include <zephyr/device.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/byteorder.h>
#include "tsl2591.h"
LOG_MODULE_REGISTER(TSL2591, CONFIG_SENSOR_LOG_LEVEL);
static int tsl2591_reg_read(const struct device *dev, uint8_t reg, uint8_t *buf, uint8_t size)
{
const struct tsl2591_config *config = dev->config;
uint8_t cmd = TSL2591_NORMAL_CMD | reg;
return i2c_write_read_dt(&config->i2c, &cmd, 1U, buf, size);
}
static int tsl2591_reg_write(const struct device *dev, uint8_t reg, uint8_t val)
{
const struct tsl2591_config *config = dev->config;
uint8_t cmd[2] = {TSL2591_NORMAL_CMD | reg, val};
return i2c_write_dt(&config->i2c, cmd, 2U);
}
int tsl2591_reg_update(const struct device *dev, uint8_t reg, uint8_t mask, uint8_t val)
{
uint8_t old_value, new_value;
int ret;
ret = tsl2591_reg_read(dev, reg, &old_value, 1U);
if (ret < 0) {
return ret;
}
new_value = (old_value & ~mask) | (val & mask);
if (new_value == old_value) {
return 0;
}
return tsl2591_reg_write(dev, reg, new_value);
}
static int tsl2591_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct tsl2591_data *data = dev->data;
uint8_t als_data[4];
int ret;
#ifdef CONFIG_TSL2591_FETCH_WAIT
uint8_t status;
ret = tsl2591_reg_read(dev, TSL2591_REG_STATUS, &status, 1U);
if (ret < 0) {
LOG_ERR("Failed to read status register");
return ret;
}
/* Check if ALS has completed an integration cycle since AEN asserted.
* If not, sleep for the duration of an integration cycle to ensure valid reading.
*/
if (!(status & TSL2591_AVALID_MASK)) {
k_msleep((data->atime / 100) * TSL2591_MAX_TIME_STEP);
}
/* Reassert AEN to determine if next reading is valid */
ret = tsl2591_reg_update(dev, TSL2591_REG_ENABLE, TSL2591_AEN_MASK, TSL2591_AEN_OFF);
if (ret < 0) {
LOG_ERR("Failed to disable ALS");
return ret;
}
ret = tsl2591_reg_update(dev, TSL2591_REG_ENABLE, TSL2591_AEN_MASK, TSL2591_AEN_ON);
if (ret < 0) {
LOG_ERR("Failed to re-enable ALS");
return ret;
}
#endif
switch (chan) {
case SENSOR_CHAN_ALL:
ret = tsl2591_reg_read(dev, TSL2591_REG_C0DATAL, als_data, 4U);
if (ret < 0) {
LOG_ERR("Failed to read ALS data");
return ret;
}
data->vis_count = sys_get_le16(als_data);
data->ir_count = sys_get_le16(als_data + 2);
break;
case SENSOR_CHAN_LIGHT:
ret = tsl2591_reg_read(dev, TSL2591_REG_C0DATAL, als_data, 2U);
if (ret < 0) {
LOG_ERR("Failed to read ALS visible light data");
return ret;
}
data->vis_count = sys_get_le16(als_data);
break;
case SENSOR_CHAN_IR:
ret = tsl2591_reg_read(dev, TSL2591_REG_C1DATAL, als_data, 2U);
if (ret < 0) {
LOG_ERR("Failed to read ALS infrared data");
return ret;
}
data->ir_count = sys_get_le16(als_data);
break;
default:
LOG_ERR("Unsupported sensor channel");
return -ENOTSUP;
}
#ifdef CONFIG_TSL2591_WARN_SATURATED
uint16_t max_count = data->atime == 100 ? TSL2591_MAX_ADC_100 : TSL2591_MAX_ADC;
bool vis_saturated = (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_LIGHT) &&
(data->vis_count >= max_count);
bool ir_saturated = (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_IR) &&
(data->ir_count >= max_count);
if (vis_saturated || ir_saturated) {
LOG_WRN("Sensor ADC potentially saturated, reading may be invalid");
return -EOVERFLOW;
}
#endif
return 0;
}
static int tsl2591_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct tsl2591_data *data = dev->data;
int64_t cpl = data->atime * data->again;
int64_t strength;
/* Unfortunately, datasheet does not provide a lux conversion formula for this particular
* device. There is still ongoing discussion about the proper formula, though this
* implementation uses a slightly modified version of the Adafruit library formula:
* path_to_url
*
* Since the device relies on both visible and IR readings to calculate lux,
* read SENSOR_CHAN_ALL to get a closer approximation of lux. Reading SENSOR_CHAN_LIGHT or
* SENSOR_CHAN_IR individually can be more closely thought of as relative strength
* as opposed to true lux.
*/
switch (chan) {
case SENSOR_CHAN_ALL:
if (data->vis_count > 0) {
cpl *= 1000000;
strength =
(data->vis_count - data->ir_count) *
(1000000 - (((int64_t)data->ir_count * 1000000) / data->vis_count));
} else {
strength = 0;
}
break;
case SENSOR_CHAN_LIGHT:
strength = data->vis_count;
break;
case SENSOR_CHAN_IR:
strength = data->ir_count;
break;
default:
LOG_ERR("Unsupported sensor channel");
return -ENOTSUP;
}
strength *= TSL2591_LUX_DF;
val->val1 = strength / cpl;
val->val2 = ((strength % cpl) * 1000000) / cpl;
return 0;
}
#ifdef CONFIG_TSL2591_TRIGGER
static int tsl2591_set_threshold(const struct device *dev, enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct tsl2591_data *data = dev->data;
const struct tsl2591_config *config = dev->config;
uint64_t cpl;
uint32_t raw;
uint16_t thld;
uint8_t thld_reg;
uint8_t cmd[3];
int ret;
/* Convert from relative strength of visible light to raw value */
cpl = data->atime * data->again;
raw = ((val->val1 * cpl) / TSL2591_LUX_DF) +
((val->val2 * cpl) / (1000000U * TSL2591_LUX_DF));
if (raw > TSL2591_MAX_ADC) {
LOG_ERR("Given value would overflow threshold register");
return -EOVERFLOW;
}
thld = sys_cpu_to_le16(raw);
thld_reg = attr == SENSOR_ATTR_LOWER_THRESH ? TSL2591_REG_AILTL : TSL2591_REG_AIHTL;
cmd[0] = TSL2591_NORMAL_CMD | thld_reg;
bytecpy(cmd + 1, &thld, 2U);
ret = i2c_write_dt(&config->i2c, cmd, 3U);
if (ret < 0) {
LOG_ERR("Failed to set interrupt threshold");
}
return ret;
}
static int tsl2591_set_persist(const struct device *dev, int32_t persist_filter)
{
uint8_t persist_mode;
int ret;
switch (persist_filter) {
case 0:
persist_mode = TSL2591_PERSIST_EVERY;
break;
case 1:
persist_mode = TSL2591_PERSIST_1;
break;
case 2:
persist_mode = TSL2591_PERSIST_2;
break;
case 3:
persist_mode = TSL2591_PERSIST_3;
break;
case 5:
persist_mode = TSL2591_PERSIST_5;
break;
case 10:
persist_mode = TSL2591_PERSIST_10;
break;
case 15:
persist_mode = TSL2591_PERSIST_15;
break;
case 20:
persist_mode = TSL2591_PERSIST_20;
break;
case 25:
persist_mode = TSL2591_PERSIST_25;
break;
case 30:
persist_mode = TSL2591_PERSIST_30;
break;
case 35:
persist_mode = TSL2591_PERSIST_35;
break;
case 40:
persist_mode = TSL2591_PERSIST_40;
break;
case 45:
persist_mode = TSL2591_PERSIST_45;
break;
case 50:
persist_mode = TSL2591_PERSIST_50;
break;
case 55:
persist_mode = TSL2591_PERSIST_55;
break;
case 60:
persist_mode = TSL2591_PERSIST_60;
break;
default:
LOG_ERR("Invalid persist filter");
return -EINVAL;
}
ret = tsl2591_reg_write(dev, TSL2591_REG_PERSIST, persist_mode);
if (ret < 0) {
LOG_ERR("Failed to set persist filter");
}
return ret;
}
#endif
static int tsl2591_set_gain(const struct device *dev, enum sensor_gain_tsl2591 gain)
{
struct tsl2591_data *data = dev->data;
uint8_t gain_mode;
int ret;
switch (gain) {
case TSL2591_SENSOR_GAIN_LOW:
data->again = TSL2591_GAIN_SCALE_LOW;
gain_mode = TSL2591_GAIN_MODE_LOW;
break;
case TSL2591_SENSOR_GAIN_MED:
data->again = TSL2591_GAIN_SCALE_MED;
gain_mode = TSL2591_GAIN_MODE_MED;
break;
case TSL2591_SENSOR_GAIN_HIGH:
data->again = TSL2591_GAIN_SCALE_HIGH;
gain_mode = TSL2591_GAIN_MODE_HIGH;
break;
case TSL2591_SENSOR_GAIN_MAX:
data->again = TSL2591_GAIN_SCALE_MAX;
gain_mode = TSL2591_GAIN_MODE_MAX;
break;
default:
LOG_ERR("Invalid gain mode");
return -EINVAL;
}
ret = tsl2591_reg_update(dev, TSL2591_REG_CONFIG, TSL2591_AGAIN_MASK, gain_mode);
if (ret < 0) {
LOG_ERR("Failed to set gain mode");
}
return ret;
}
static int tsl2591_set_integration(const struct device *dev, int32_t integration_time)
{
struct tsl2591_data *data = dev->data;
uint8_t atime_mode;
int ret;
switch (integration_time) {
case 100:
atime_mode = TSL2591_INTEGRATION_100MS;
break;
case 200:
atime_mode = TSL2591_INTEGRATION_200MS;
break;
case 300:
atime_mode = TSL2591_INTEGRATION_300MS;
break;
case 400:
atime_mode = TSL2591_INTEGRATION_400MS;
break;
case 500:
atime_mode = TSL2591_INTEGRATION_500MS;
break;
case 600:
atime_mode = TSL2591_INTEGRATION_600MS;
break;
default:
LOG_ERR("Invalid integration time");
return -EINVAL;
}
ret = tsl2591_reg_update(dev, TSL2591_REG_CONFIG, TSL2591_ATIME_MASK, atime_mode);
if (ret < 0) {
LOG_ERR("Failed to set integration time");
return ret;
}
data->atime = integration_time;
return 0;
}
static int tsl2591_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct tsl2591_data *data = dev->data;
int ret;
ret = tsl2591_reg_update(dev, TSL2591_REG_ENABLE, TSL2591_POWER_MASK, TSL2591_POWER_OFF);
if (ret < 0) {
LOG_ERR("Unable to power down device");
return ret;
}
#ifdef CONFIG_TSL2591_TRIGGER
if (attr == SENSOR_ATTR_UPPER_THRESH || attr == SENSOR_ATTR_LOWER_THRESH) {
if (chan == SENSOR_CHAN_LIGHT) {
ret = tsl2591_set_threshold(dev, attr, val);
} else {
LOG_ERR("Attribute not supported for channel");
ret = -ENOTSUP;
}
goto exit;
}
#endif
switch ((enum sensor_attribute_tsl2591)attr) {
case SENSOR_ATTR_GAIN_MODE:
ret = tsl2591_set_gain(dev, (enum sensor_gain_tsl2591)val->val1);
break;
case SENSOR_ATTR_INTEGRATION_TIME:
ret = tsl2591_set_integration(dev, val->val1);
break;
#ifdef CONFIG_TSL2591_TRIGGER
case SENSOR_ATTR_INT_PERSIST:
ret = tsl2591_set_persist(dev, val->val1);
break;
#endif
default:
LOG_ERR("Invalid sensor attribute");
ret = -EINVAL;
goto exit; /* So the compiler doesn't warn if triggers not enabled */
}
exit:
if (data->powered_on) {
ret = tsl2591_reg_update(dev, TSL2591_REG_ENABLE, TSL2591_POWER_MASK,
TSL2591_POWER_ON);
}
return ret;
}
static int tsl2591_setup(const struct device *dev)
{
struct tsl2591_data *data = dev->data;
uint8_t device_id;
int ret;
ret = tsl2591_reg_write(dev, TSL2591_REG_CONFIG, TSL2591_SRESET);
if (ret < 0) {
LOG_ERR("Failed to reset device");
return ret;
}
ret = tsl2591_reg_read(dev, TSL2591_REG_ID, &device_id, 1U);
if (ret < 0) {
LOG_ERR("Failed to read device ID");
return ret;
}
if (device_id != TSL2591_DEV_ID) {
LOG_ERR("Device with ID 0x%02x is not supported", device_id);
return -ENOTSUP;
}
/* Set initial values to match sensor values on reset */
data->again = TSL2591_GAIN_SCALE_LOW;
data->atime = 100U;
ret = tsl2591_reg_write(dev, TSL2591_REG_ENABLE, TSL2591_POWER_ON);
if (ret < 0) {
LOG_ERR("Failed to perform initial power up of device");
return ret;
}
data->powered_on = true;
return 0;
}
static int tsl2591_init(const struct device *dev)
{
const struct tsl2591_config *config = dev->config;
int ret;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_ERR("I2C dev %s not ready", config->i2c.bus->name);
return -ENODEV;
}
ret = tsl2591_setup(dev);
if (ret < 0) {
LOG_ERR("Failed to setup device");
return ret;
}
#ifdef CONFIG_TSL2591_TRIGGER
ret = tsl2591_initialize_int(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupt!");
return ret;
}
#endif
return 0;
}
static const struct sensor_driver_api tsl2591_driver_api = {
#ifdef CONFIG_TSL2591_TRIGGER
.trigger_set = tsl2591_trigger_set,
#endif
.attr_set = tsl2591_attr_set,
.sample_fetch = tsl2591_sample_fetch,
.channel_get = tsl2591_channel_get};
#ifdef CONFIG_PM_DEVICE
static int tsl2591_pm_action(const struct device *dev, enum pm_device_action action)
{
struct tsl2591_data *data = dev->data;
int ret;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
ret = tsl2591_reg_update(dev, TSL2591_REG_ENABLE, TSL2591_POWER_MASK,
TSL2591_POWER_ON);
if (ret < 0) {
LOG_ERR("Failed to power on device");
return ret;
}
data->powered_on = true;
break;
case PM_DEVICE_ACTION_SUSPEND:
ret = tsl2591_reg_update(dev, TSL2591_REG_ENABLE, TSL2591_POWER_MASK,
TSL2591_POWER_OFF);
if (ret < 0) {
LOG_ERR("Failed to power off device");
return ret;
}
data->powered_on = false;
break;
default:
LOG_ERR("Unsupported PM action");
return -ENOTSUP;
}
return 0;
}
#endif
#define TSL2591_INIT_INST(n) \
static struct tsl2591_data tsl2591_data_##n; \
static const struct tsl2591_config tsl2591_config_##n = { \
.i2c = I2C_DT_SPEC_INST_GET(n), \
IF_ENABLED(CONFIG_TSL2591_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(n, int_gpios, {0}),))}; \
PM_DEVICE_DT_INST_DEFINE(n, tsl2591_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(n, tsl2591_init, PM_DEVICE_DT_INST_GET(n), &tsl2591_data_##n, \
&tsl2591_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tsl2591_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TSL2591_INIT_INST)
``` | /content/code_sandbox/drivers/sensor/ams/tsl2591/tsl2591.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,975 |
```unknown
menuconfig TSL2591
bool "OSRAM-AMS TSL2591 light sensor"
default y
depends on DT_HAS_AMS_TSL2591_ENABLED
select I2C
help
Enable driver for TSL2591 sensor.
if TSL2591
config TSL2591_FETCH_WAIT
bool "Wait for valid sensor reading before fetch"
help
If set, the driver will automatically wait for the duration of an integration cycle
during a fetch call if necessary.
config TSL2591_WARN_SATURATED
bool "Warn if sensor is potentially saturated"
help
If set, the driver will warn if the sensor ADC is
potentially saturated after a data fetch.
config TSL2591_TRIGGER
bool
choice
prompt "Trigger mode"
default TSL2591_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config TSL2591_TRIGGER_NONE
bool "No trigger"
config TSL2591_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select TSL2591_TRIGGER
config TSL2591_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select TSL2591_TRIGGER
endchoice
config TSL2591_THREAD_PRIORITY
int "Thread priority"
depends on TSL2591_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config TSL2591_THREAD_STACK_SIZE
int "Thread stack size"
depends on TSL2591_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # TSL2591
``` | /content/code_sandbox/drivers/sensor/ams/tsl2591/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 358 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TSL2591_TSL2591_H_
#define ZEPHYR_DRIVERS_SENSOR_TSL2591_TSL2591_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor/tsl2591.h>
/* Device Identification */
#define TSL2591_DEV_ID 0x50
/* Command: CMD:7 | TRANSACTION:6:5 | ADDR/SF:4:0 */
#define TSL2591_NORMAL_CMD (BIT(7) | BIT(5))
#define TSL2591_SPECIAL_CMD (BIT(7) | BIT(6) | BIT(5))
#define TSL2591_CLEAR_INT_CMD (TSL2591_SPECIAL_CMD | 0x7)
/* Enable: (0x00): NPIEN:7 | SAI:6 | Reserved:5 | AIEN:4 | Reserved:3:2 | AEN:1 | PON:0 */
#define TSL2591_POWER_MASK (BIT(1) | BIT(0))
#define TSL2591_POWER_ON (BIT(1) | BIT(0))
#define TSL2591_POWER_OFF (0)
#define TSL2591_AEN_MASK (BIT(1))
#define TSL2591_AEN_ON (BIT(1))
#define TSL2591_AEN_OFF (0)
#define TSL2591_AIEN_MASK (BIT(4))
#define TSL2591_AIEN_ON (BIT(4))
#define TSL2591_AIEN_OFF (0)
/* Config/Control: (0x01): SRESET:7 | Reserved:6 | AGAIN:5:4 | Reserved:3 | ATIME:2:0 */
#define TSL2591_SRESET (BIT(7))
#define TSL2591_AGAIN_MASK (BIT(5) | BIT(4))
#define TSL2591_ATIME_MASK (BIT(2) | BIT(1) | BIT(0))
/* Status: (0x13): Reserved:7:6 | NPINTR:5 | AINT:4 | Reserved:3:1 | AVALID:0 */
#define TSL2591_AVALID_MASK (BIT(0))
/* Register Addresses */
#define TSL2591_REG_ENABLE 0x00
#define TSL2591_REG_CONFIG 0x01
#define TSL2591_REG_AILTL 0x04
#define TSL2591_REG_AILTH 0x05
#define TSL2591_REG_AIHTL 0x06
#define TSL2591_REG_AIHTH 0x07
#define TSL2591_REG_NPAILTL 0x08
#define TSL2591_REG_NPAILTH 0x09
#define TSL2591_REG_NPAIHTL 0x0A
#define TSL2591_REG_NPAIHTH 0x0B
#define TSL2591_REG_PERSIST 0x0C
#define TSL2591_REG_PID 0x11
#define TSL2591_REG_ID 0x12
#define TSL2591_REG_STATUS 0x13
#define TSL2591_REG_C0DATAL 0x14
#define TSL2591_REG_C0DATAH 0x15
#define TSL2591_REG_C1DATAL 0x16
#define TSL2591_REG_C1DATAH 0x17
/* Integration Time Modes */
#define TSL2591_INTEGRATION_100MS 0x00
#define TSL2591_INTEGRATION_200MS 0x01
#define TSL2591_INTEGRATION_300MS 0x02
#define TSL2591_INTEGRATION_400MS 0x03
#define TSL2591_INTEGRATION_500MS 0x04
#define TSL2591_INTEGRATION_600MS 0x05
/* Gain Modes */
#define TSL2591_GAIN_MODE_LOW 0x00
#define TSL2591_GAIN_MODE_MED 0x10
#define TSL2591_GAIN_MODE_HIGH 0x20
#define TSL2591_GAIN_MODE_MAX 0x30
/* Gain Scales (Typical Values)
* See datasheet, used only for lux calculation.
*/
#define TSL2591_GAIN_SCALE_LOW 1U
#define TSL2591_GAIN_SCALE_MED 25U
#define TSL2591_GAIN_SCALE_HIGH 400U
#define TSL2591_GAIN_SCALE_MAX 9200U
/* Persistence Filters */
#define TSL2591_PERSIST_EVERY 0x00
#define TSL2591_PERSIST_1 0x01
#define TSL2591_PERSIST_2 0x02
#define TSL2591_PERSIST_3 0x03
#define TSL2591_PERSIST_5 0x04
#define TSL2591_PERSIST_10 0x05
#define TSL2591_PERSIST_15 0x06
#define TSL2591_PERSIST_20 0x07
#define TSL2591_PERSIST_25 0x08
#define TSL2591_PERSIST_30 0x09
#define TSL2591_PERSIST_35 0x0A
#define TSL2591_PERSIST_40 0x0B
#define TSL2591_PERSIST_45 0x0C
#define TSL2591_PERSIST_50 0x0D
#define TSL2591_PERSIST_55 0x0E
#define TSL2591_PERSIST_60 0x0F
/* Device factor coefficient for lux calculations */
#define TSL2591_LUX_DF 408
/* Max integration time (in ms) for single step */
#define TSL2591_MAX_TIME_STEP 105
/* Max ADC Counts */
#define TSL2591_MAX_ADC 65535
#define TSL2591_MAX_ADC_100 36863
struct tsl2591_config {
const struct i2c_dt_spec i2c;
#ifdef CONFIG_TSL2591_TRIGGER
const struct gpio_dt_spec int_gpio;
#endif
};
struct tsl2591_data {
uint16_t vis_count;
uint16_t ir_count;
uint16_t again;
uint16_t atime;
bool powered_on;
#ifdef CONFIG_TSL2591_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t th_handler;
const struct sensor_trigger *th_trigger;
#if defined(CONFIG_TSL2591_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_TSL2591_THREAD_STACK_SIZE);
struct k_sem trig_sem;
struct k_thread thread;
#elif defined(CONFIG_TSL2591_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif
};
int tsl2591_reg_update(const struct device *dev, uint8_t reg, uint8_t mask, uint8_t val);
#ifdef CONFIG_TSL2591_TRIGGER
int tsl2591_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int tsl2591_initialize_int(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_TSL2591_TSL2591_H_ */
``` | /content/code_sandbox/drivers/sensor/ams/tsl2591/tsl2591.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,573 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TSL2540_TSL2540_H_
#define ZEPHYR_DRIVERS_SENSOR_TSL2540_TSL2540_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/tsl2540.h>
#define TSL2540_REG_ATIME 0x81
#define TSL2540_REG_WTIME 0x83
#define TSL2540_REG_AILT_LOW 0x84
#define TSL2540_REG_AILT_HI 0x85
#define TSL2540_REG_AIHT_LOW 0x86
#define TSL2540_REG_AIHT_HI 0x87
#define TSL2540_REG_PERS 0x8c
#define TSL2540_REG_CFG_0 0x8d
#define TSL2540_REG_CFG_1 0x90
#define TSL2540_REG_REVID 0x91
#define TSL2540_REG_ID 0x92
#define TSL2540_REG_STATUS 0x93
#define TSL2540_REG_VIS_LOW 0x94
#define TSL2540_REG_VIS_HI 0x95
#define TSL2540_REG_IR_LOW 0x96
#define TSL2540_REG_IR_HI 0x97
#define TSL2540_REG_REVID2 0x9E
#define TSL2540_REG_CFG_2 0x9f
#define TSL2540_AGAIN_S1_2 0.5
#define TSL2540_AGAIN_S1 1
#define TSL2540_AGAIN_S4 4
#define TSL2540_AGAIN_S16 16
#define TSL2540_AGAIN_S64 67
#define TSL2540_AGAIN_S128 140
#define TSL2540_CFG1_G1_2 0x00
#define TSL2540_CFG1_G1 0x00
#define TSL2540_CFG1_G4 0x01
#define TSL2540_CFG1_G16 0x02
#define TSL2540_CFG1_G64 0x03
#define TSL2540_CFG1_G128 0x03
#define TSL2540_CFG2_G1_2 0x00
#define TSL2540_CFG2_G1 0x04
#define TSL2540_CFG2_G4 0x04
#define TSL2540_CFG2_G16 0x04
#define TSL2540_CFG2_G64 0x04
#define TSL2540_CFG2_G128 0x14
/* ENABLE(0x80: 0x00): Reserved:7:4 | WEN:3 | Reserved:2 | AEN:1 | PON:0 */
#define TSL2540_ENABLE_ADDR 0x80
#define TSL2540_ENABLE_MASK (BIT(3) | BIT(1) | BIT(0))
#define TSL2540_ENABLE_CONF (BIT(3) | BIT(1) | BIT(0))
#define TSL2540_ENABLE_AEN_PON (BIT(1) | BIT(0))
#define TSL2540_ENABLE_DISABLE (0)
/* CRG3(0xAB: 0x0C): INT_READ_CLEAR:7 | Reserved:6:5 | SAI:4 | Reserved:3:0 */
#define TSL2540_CFG3_ADDR 0xAB
#define TSL2540_CFG3_MASK (BIT(7) | BIT(4))
#define TSL2540_CFG3_CONF (BIT(7) | BIT(4))
#define TSL2540_CFG3_DFLT (0)
/* INTENAB(0xDD: 0x00): ASIEN:7 | Reserved:6:5 | AIEN:4 | Reserved:3:0 */
#define TSL2540_INTENAB_ADDR 0xDD
#define TSL2540_INTENAB_MASK (BIT(7) | BIT(4))
#define TSL2540_INTENAB_CONF (BIT(4))
#define TSL2540_INT_EN_AEN 0x90
struct tsl2540_config {
const struct i2c_dt_spec i2c_spec;
#ifdef CONFIG_TSL2540_TRIGGER
const struct gpio_dt_spec int_gpio;
#endif
const uint32_t glass_attenuation;
const uint32_t glass_ir_attenuation;
};
struct tsl2540_data {
const struct device *i2c;
struct k_sem sem;
#ifdef CONFIG_TSL2540_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *als_trigger;
sensor_trigger_handler_t als_handler;
#endif
#ifdef CONFIG_TSL2540_TRIGGER_OWN_THREAD
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_TSL2540_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#endif
#ifdef CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD
struct k_work work;
#endif
uint8_t enable_mode;
uint16_t count_vis;
uint16_t count_ir;
uint8_t integration_time;
double again;
};
#ifdef CONFIG_TSL2540_TRIGGER
int tsl2540_trigger_init(const struct device *dev);
int tsl2540_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif
#endif
``` | /content/code_sandbox/drivers/sensor/ams/tsl2540/tsl2540.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,171 |
```c
/*
*
*/
#include "tsl2540.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(tsl2540, CONFIG_SENSOR_LOG_LEVEL);
static void tsl2540_setup_int(const struct device *dev, bool enable)
{
const struct tsl2540_config *config = dev->config;
gpio_flags_t flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
}
static void tsl2540_handle_int(const struct device *dev)
{
struct tsl2540_data *drv_data = dev->data;
tsl2540_setup_int(dev, false);
#if defined(CONFIG_TSL2540_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->trig_sem);
#elif defined(CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void tsl2540_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pin_mask)
{
struct tsl2540_data *data = CONTAINER_OF(cb, struct tsl2540_data, gpio_cb);
tsl2540_handle_int(data->dev);
}
static void tsl2540_process_int(const struct device *dev)
{
const struct tsl2540_config *config = dev->config;
struct tsl2540_data *data = dev->data;
uint8_t status;
/* Read the status, cleared automatically in CFG3 */
int ret = i2c_reg_read_byte_dt(&config->i2c_spec, TSL2540_REG_STATUS, &status);
if (ret) {
LOG_ERR("Could not read status register (%#x), errno: %d", TSL2540_REG_STATUS,
ret);
return;
}
if (BIT(7) & status) { /* ASAT */
LOG_ERR("Interrupt status(%#x): %#x: ASAT", TSL2540_REG_STATUS, status);
}
if (BIT(3) & status) { /* CINT */
LOG_DBG("Interrupt status(%#x): %#x: CINT", TSL2540_REG_STATUS, status);
}
if (BIT(4) & status) { /* AINT */
LOG_DBG("Interrupt status(%#x): %#x: AINT", TSL2540_REG_STATUS, status);
if (data->als_handler != NULL) {
data->als_handler(dev, data->als_trigger);
}
}
tsl2540_setup_int(dev, true);
/* Check for pin that may be asserted while we were busy */
int pv = gpio_pin_get_dt(&config->int_gpio);
if (pv > 0) {
tsl2540_handle_int(dev);
}
}
#ifdef CONFIG_TSL2540_TRIGGER_OWN_THREAD
static void tsl2540_thread_main(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct tsl2540_data *data = p1;
while (true) {
k_sem_take(&data->trig_sem, K_FOREVER);
tsl2540_process_int(data->dev);
}
}
#endif
#ifdef CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD
static void tsl2540_work_handler(struct k_work *work)
{
struct tsl2540_data *data = CONTAINER_OF(work, struct tsl2540_data, work);
tsl2540_process_int(data->dev);
}
#endif
int tsl2540_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct tsl2540_config *config = dev->config;
struct tsl2540_data *data = dev->data;
int ret;
if (trig->type != SENSOR_TRIG_THRESHOLD) {
LOG_ERR("Unsupported sensor trigger type: %d", trig->type);
return -ENOTSUP;
}
if (trig->chan != SENSOR_CHAN_LIGHT) {
LOG_ERR("Unsupported sensor trigger channel: %d", trig->chan);
return -ENOTSUP;
}
const struct i2c_dt_spec *i2c_spec = &config->i2c_spec;
ret = i2c_reg_update_byte_dt(i2c_spec, TSL2540_INTENAB_ADDR,
TSL2540_INTENAB_MASK, TSL2540_INTENAB_CONF);
if (ret) {
LOG_ERR("%#x: I/O error: %d", TSL2540_INTENAB_ADDR, ret);
return -EIO;
}
ret = i2c_reg_update_byte_dt(i2c_spec, TSL2540_CFG3_ADDR,
TSL2540_CFG3_MASK, TSL2540_CFG3_CONF);
if (ret) {
LOG_ERR("%#x: I/O error: %d", TSL2540_CFG3_ADDR, ret);
return -EIO;
}
k_sem_take(&data->sem, K_FOREVER);
data->als_handler = handler;
data->als_trigger = trig;
if (handler != NULL) {
tsl2540_setup_int(dev, true);
/* Check whether already asserted */
int pv = gpio_pin_get_dt(&config->int_gpio);
if (pv > 0) {
tsl2540_handle_int(dev);
}
}
k_sem_give(&data->sem);
return ret;
}
int tsl2540_trigger_init(const struct device *dev)
{
const struct tsl2540_config *config = dev->config;
struct tsl2540_data *data = dev->data;
int rc;
/* Check device is defined */
if (config->int_gpio.port == NULL) {
LOG_ERR("int-gpios is not defined in the device tree.");
return -EINVAL;
}
/* Get the GPIO device */
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("%s: gpio controller %s not ready", dev->name, config->int_gpio.port->name);
return -ENODEV;
}
rc = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
if (rc < 0) {
return rc;
}
gpio_init_callback(&data->gpio_cb, tsl2540_gpio_callback, BIT(config->int_gpio.pin));
if (gpio_add_callback(config->int_gpio.port, &data->gpio_cb) < 0) {
LOG_ERR("Failed to set gpio callback!");
return -EIO;
}
data->dev = dev;
#if defined(CONFIG_TSL2540_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_TSL2540_THREAD_STACK_SIZE,
tsl2540_thread_main, data, NULL, NULL,
K_PRIO_COOP(CONFIG_TSL2540_THREAD_PRIORITY), 0, K_NO_WAIT);
k_thread_name_set(&data->thread, "TSL2540 trigger");
#elif defined(CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD)
data->work.handler = tsl2540_work_handler;
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/ams/tsl2540/tsl2540_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,499 |
```unknown
# TSL2540 Ambient Light Sensor configuration options
menuconfig TSL2540
bool "TSL2540 Ambient Light Sensor"
default y
depends on DT_HAS_AMS_TSL2540_ENABLED
select I2C
help
Enable driver for TSL2540 sensors.
if TSL2540
config TSL2540_TRIGGER
bool
choice
prompt "Trigger mode"
default TSL2540_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config TSL2540_TRIGGER_NONE
bool "No trigger"
config TSL2540_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select TSL2540_TRIGGER
config TSL2540_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select TSL2540_TRIGGER
endchoice
config TSL2540_THREAD_PRIORITY
int "Thread priority"
depends on TSL2540_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config TSL2540_THREAD_STACK_SIZE
int "Thread stack size"
depends on TSL2540_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # TSL2540
``` | /content/code_sandbox/drivers/sensor/ams/tsl2540/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 276 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_tsl2540
#include "tsl2540.h"
#include <stdlib.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#define TSL2540_INTEGRATION_TIME_MS (2.81)
#define TSL2540_DEVICE_FACTOR (53.0)
#define FIXED_ATTENUATION_TO_DBL(x) (x * 0.00001)
LOG_MODULE_REGISTER(tsl2540, CONFIG_SENSOR_LOG_LEVEL);
static int tsl2540_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct tsl2540_config *cfg = dev->config;
struct tsl2540_data *data = dev->data;
int ret = 0;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_LIGHT ||
chan == SENSOR_CHAN_IR);
k_sem_take(&data->sem, K_FOREVER);
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_LIGHT) {
uint16_t le16_buffer;
ret = i2c_burst_read_dt(&cfg->i2c_spec, TSL2540_REG_VIS_LOW,
(uint8_t *)&le16_buffer, sizeof(le16_buffer));
if (ret) {
LOG_ERR("Could not fetch ambient light (visible)");
k_sem_give(&data->sem);
return -EIO;
}
data->count_vis = sys_le16_to_cpu(le16_buffer);
}
if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_IR) {
uint16_t le16_buffer;
ret = i2c_burst_read_dt(&cfg->i2c_spec, TSL2540_REG_IR_LOW, (uint8_t *)&le16_buffer,
sizeof(le16_buffer));
if (ret) {
LOG_ERR("Could not fetch ambient light (IR)");
k_sem_give(&data->sem);
return -EIO;
}
data->count_ir = sys_le16_to_cpu(le16_buffer);
}
k_sem_give(&data->sem);
return ret;
}
static int tsl2540_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
const struct tsl2540_config *cfg = dev->config;
struct tsl2540_data *data = dev->data;
int ret = 0;
double cpl;
double glass_attenuation = FIXED_ATTENUATION_TO_DBL(cfg->glass_attenuation);
double glass_ir_attenuation = FIXED_ATTENUATION_TO_DBL(cfg->glass_ir_attenuation);
k_sem_take(&data->sem, K_FOREVER);
cpl = (data->integration_time + 1) * TSL2540_INTEGRATION_TIME_MS;
cpl *= data->again;
switch (chan) {
case SENSOR_CHAN_LIGHT:
sensor_value_from_double(val, data->count_vis / cpl *
TSL2540_DEVICE_FACTOR * glass_attenuation);
break;
case SENSOR_CHAN_IR:
sensor_value_from_double(val, data->count_ir / cpl *
TSL2540_DEVICE_FACTOR * glass_ir_attenuation);
break;
default:
ret = -ENOTSUP;
}
k_sem_give(&data->sem);
return ret;
}
static int tsl2540_attr_set_gain(const struct device *dev, enum sensor_gain_tsl2540 gain)
{
const struct tsl2540_config *cfg = dev->config;
struct tsl2540_data *data = dev->data;
uint8_t value = 0;
double again = 0.0;
switch (gain) {
case TSL2540_SENSOR_GAIN_1_2:
value = TSL2540_CFG1_G1_2;
again = TSL2540_AGAIN_S1_2;
break;
case TSL2540_SENSOR_GAIN_1:
value = TSL2540_CFG1_G1;
again = TSL2540_AGAIN_S1;
break;
case TSL2540_SENSOR_GAIN_4:
value = TSL2540_CFG1_G4;
again = TSL2540_AGAIN_S4;
break;
case TSL2540_SENSOR_GAIN_16:
value = TSL2540_CFG1_G16;
again = TSL2540_AGAIN_S16;
break;
case TSL2540_SENSOR_GAIN_64:
value = TSL2540_CFG1_G64;
again = TSL2540_AGAIN_S64;
break;
case TSL2540_SENSOR_GAIN_128:
value = TSL2540_CFG1_G128;
again = TSL2540_CFG2_G128;
break;
}
if (i2c_reg_write_byte_dt(&cfg->i2c_spec, TSL2540_REG_CFG_1, value) < 0) {
return -EIO;
}
if (i2c_reg_write_byte_dt(&cfg->i2c_spec, TSL2540_REG_CFG_2, value) < 0) {
return -EIO;
}
data->again = again;
return 0;
}
static int tsl2540_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct tsl2540_config *cfg = dev->config;
struct tsl2540_data *data = dev->data;
int ret = 0;
uint8_t temp;
double it;
if ((chan != SENSOR_CHAN_IR) & (chan != SENSOR_CHAN_LIGHT)) {
return -ENOTSUP;
}
k_sem_take(&data->sem, K_FOREVER);
ret = i2c_reg_write_byte_dt(&cfg->i2c_spec, TSL2540_ENABLE_ADDR, TSL2540_ENABLE_MASK &
~TSL2540_ENABLE_CONF);
if (ret) {
k_sem_give(&data->sem);
return ret;
}
#if CONFIG_TSL2540_TRIGGER
if (chan == SENSOR_CHAN_LIGHT) {
if (attr == SENSOR_ATTR_UPPER_THRESH) {
double cpl;
uint16_t thld, le16_buffer;
double glass_attenuation = FIXED_ATTENUATION_TO_DBL(cfg->glass_attenuation);
cpl = ((data->integration_time + 1) * TSL2540_INTEGRATION_TIME_MS);
cpl *= data->again;
cpl /= (TSL2540_DEVICE_FACTOR * glass_attenuation);
thld = sensor_value_to_double(val) * cpl;
LOG_DBG("attr: %d, cpl: %g, thld: %x\n", attr, cpl, thld);
le16_buffer = sys_cpu_to_le16(thld);
ret = i2c_burst_write_dt(
&((const struct tsl2540_config *)dev->config)->i2c_spec,
TSL2540_REG_AIHT_LOW, (uint8_t *)&le16_buffer, sizeof(le16_buffer));
goto exit;
}
if (attr == SENSOR_ATTR_LOWER_THRESH) {
double cpl;
uint16_t thld, le16_buffer;
double glass_attenuation = FIXED_ATTENUATION_TO_DBL(cfg->glass_attenuation);
cpl = ((data->integration_time + 1) * TSL2540_INTEGRATION_TIME_MS);
cpl *= data->again;
cpl /= (TSL2540_DEVICE_FACTOR * glass_attenuation);
thld = sensor_value_to_double(val) * cpl;
LOG_DBG("attr: %d, cpl: %g, thld: %x\n", attr, cpl, thld);
le16_buffer = sys_cpu_to_le16(sys_cpu_to_le16(thld));
ret = i2c_burst_write_dt(
&((const struct tsl2540_config *)dev->config)->i2c_spec,
TSL2540_REG_AILT_LOW, (uint8_t *)&le16_buffer, sizeof(le16_buffer));
goto exit;
}
}
#endif /* CONFIG_TSL2540_TRIGGER */
if (attr == SENSOR_ATTR_GAIN) {
tsl2540_attr_set_gain(dev, (enum sensor_gain_tsl2540)val->val1);
goto exit;
}
switch ((enum sensor_attribute_tsl2540)attr) {
case SENSOR_ATTR_INT_APERS:
temp = (uint8_t)val->val1;
if (temp > 15) {
ret = -EINVAL;
goto exit;
}
if (i2c_reg_write_byte_dt(&cfg->i2c_spec, TSL2540_REG_PERS, temp)) {
ret = -EIO;
goto exit;
}
break;
case SENSOR_ATTR_INTEGRATION_TIME:
it = sensor_value_to_double(val);
it /= TSL2540_INTEGRATION_TIME_MS;
if (it < 1 || it > 256) {
ret = -EINVAL;
goto exit;
}
it -= 1;
temp = (uint8_t)it;
if (i2c_reg_write_byte_dt(&cfg->i2c_spec, TSL2540_REG_ATIME, temp)) {
ret = -EIO;
goto exit;
}
data->integration_time = temp;
ret = 0;
break;
case SENSOR_ATTR_TSL2540_SHUTDOWN_MODE:
data->enable_mode = TSL2540_ENABLE_DISABLE;
ret = i2c_reg_update_byte_dt(&cfg->i2c_spec, TSL2540_CFG3_ADDR, TSL2540_CFG3_MASK,
TSL2540_CFG3_CONF);
break;
case SENSOR_ATTR_TSL2540_CONTINUOUS_MODE:
data->enable_mode = TSL2540_ENABLE_CONF;
ret = i2c_reg_update_byte_dt(&cfg->i2c_spec, TSL2540_CFG3_ADDR, TSL2540_CFG3_MASK,
TSL2540_CFG3_CONF);
break;
case SENSOR_ATTR_TSL2540_CONTINUOUS_NO_WAIT_MODE:
data->enable_mode = TSL2540_ENABLE_AEN_PON;
ret = i2c_reg_update_byte_dt(&cfg->i2c_spec, TSL2540_CFG3_ADDR, TSL2540_CFG3_MASK,
TSL2540_CFG3_DFLT);
break;
}
exit:
i2c_reg_update_byte_dt(&cfg->i2c_spec, TSL2540_ENABLE_ADDR, TSL2540_ENABLE_MASK,
data->enable_mode);
k_sem_give(&data->sem);
return ret;
}
static int tsl2540_setup(const struct device *dev)
{
struct sensor_value integration_time;
/* Set ALS integration time */
tsl2540_attr_set(dev, (enum sensor_channel)SENSOR_CHAN_LIGHT,
(enum sensor_attribute)SENSOR_ATTR_GAIN,
&(struct sensor_value){.val1 = TSL2540_SENSOR_GAIN_1_2, .val2 = 0});
sensor_value_from_double(&integration_time, 500.0);
tsl2540_attr_set(dev, (enum sensor_channel)SENSOR_CHAN_LIGHT,
(enum sensor_attribute)SENSOR_ATTR_INTEGRATION_TIME, &integration_time);
return 0;
}
static int tsl2540_init(const struct device *dev)
{
const struct tsl2540_config *cfg = dev->config;
struct tsl2540_data *data = dev->data;
int ret;
data->enable_mode = TSL2540_ENABLE_DISABLE;
k_sem_init(&data->sem, 1, K_SEM_MAX_LIMIT);
if (!i2c_is_ready_dt(&cfg->i2c_spec)) {
LOG_ERR("I2C dev %s not ready", cfg->i2c_spec.bus->name);
return -ENODEV;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c_spec, TSL2540_REG_PERS, 1);
if (ret) {
LOG_ERR("Failed to setup interrupt persistence filter");
return ret;
}
ret = i2c_reg_update_byte_dt(&cfg->i2c_spec, TSL2540_CFG3_ADDR, TSL2540_CFG3_MASK,
TSL2540_CFG3_DFLT);
if (ret) {
LOG_ERR("Failed to set configuration");
return ret;
}
if (tsl2540_setup(dev)) {
LOG_ERR("Failed to setup ambient light functionality");
return -EIO;
}
#if CONFIG_TSL2540_TRIGGER
if (tsl2540_trigger_init(dev)) {
LOG_ERR("Could not initialize interrupts");
return -EIO;
}
#endif
LOG_DBG("Init complete");
return 0;
}
static const struct sensor_driver_api tsl2540_driver_api = {
.sample_fetch = tsl2540_sample_fetch,
.channel_get = tsl2540_channel_get,
.attr_set = tsl2540_attr_set,
#ifdef CONFIG_TSL2540_TRIGGER
.trigger_set = tsl2540_trigger_set,
#endif
};
#ifdef CONFIG_PM_DEVICE
static int tsl2540_pm_action(const struct device *dev, enum pm_device_action action)
{
const struct tsl2540_config *cfg = dev->config;
struct tsl2540_data *data = dev->data;
int ret = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
ret = i2c_reg_update_byte_dt(&cfg->i2c_spec, TSL2540_ENABLE_ADDR,
TSL2540_ENABLE_MASK, data->enable_mode);
break;
case PM_DEVICE_ACTION_SUSPEND:
ret = i2c_reg_update_byte_dt(&cfg->i2c_spec, TSL2540_ENABLE_ADDR,
TSL2540_ENABLE_MASK, TSL2540_ENABLE_DISABLE);
break;
default:
return -ENOTSUP;
}
return ret;
}
#endif
#define TSL2540_GLASS_ATTEN(inst) \
.glass_attenuation = DT_INST_PROP(inst, glass_attenuation), \
.glass_ir_attenuation = DT_INST_PROP(inst, glass_ir_attenuation), \
#define TSL2540_DEFINE(inst) \
static struct tsl2540_data tsl2540_prv_data_##inst; \
static const struct tsl2540_config tsl2540_config_##inst = { \
.i2c_spec = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_TSL2540_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET(inst, int_gpios),)) \
TSL2540_GLASS_ATTEN(inst) \
}; \
PM_DEVICE_DT_INST_DEFINE(inst, tsl2540_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, &tsl2540_init, PM_DEVICE_DT_INST_GET(inst), \
&tsl2540_prv_data_##inst, &tsl2540_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tsl2540_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TSL2540_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ams/tsl2540/tsl2540.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,268 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_ccs811
#include <zephyr/drivers/sensor.h>
#include "ccs811.h"
#define LOG_LEVEL CONFIG_SENSOR_LOG_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(CCS811);
int ccs811_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *thr)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
int rc;
if (!config->irq_gpio.port) {
return -ENOTSUP;
}
if (chan != SENSOR_CHAN_CO2) {
rc = -ENOTSUP;
} else if (attr == SENSOR_ATTR_LOWER_THRESH) {
rc = -EINVAL;
if ((thr->val1 >= CCS811_CO2_MIN_PPM)
&& (thr->val1 <= CCS811_CO2_MAX_PPM)) {
drv_data->co2_l2m = thr->val1;
rc = 0;
}
} else if (attr == SENSOR_ATTR_UPPER_THRESH) {
rc = -EINVAL;
if ((thr->val1 >= CCS811_CO2_MIN_PPM)
&& (thr->val1 <= CCS811_CO2_MAX_PPM)) {
drv_data->co2_m2h = thr->val1;
rc = 0;
}
} else {
rc = -ENOTSUP;
}
return rc;
}
static inline void setup_irq(const struct device *dev,
bool enable)
{
const struct ccs811_config *config = dev->config;
unsigned int flags = enable
? GPIO_INT_LEVEL_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&config->irq_gpio, flags);
}
static inline void handle_irq(const struct device *dev)
{
struct ccs811_data *data = dev->data;
setup_irq(dev, false);
#if defined(CONFIG_CCS811_TRIGGER_OWN_THREAD)
k_sem_give(&data->gpio_sem);
#elif defined(CONFIG_CCS811_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void process_irq(const struct device *dev)
{
struct ccs811_data *data = dev->data;
if (data->handler != NULL) {
data->handler(dev, data->trigger);
}
if (data->handler != NULL) {
setup_irq(dev, true);
}
}
static void gpio_callback(const struct device *dev,
struct gpio_callback *cb,
uint32_t pins)
{
struct ccs811_data *data =
CONTAINER_OF(cb, struct ccs811_data, gpio_cb);
ARG_UNUSED(pins);
handle_irq(data->dev);
}
#ifdef CONFIG_CCS811_TRIGGER_OWN_THREAD
static void irq_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct ccs811_data *drv_data = p1;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
process_irq(drv_data->dev);
}
}
#elif defined(CONFIG_CCS811_TRIGGER_GLOBAL_THREAD)
static void work_cb(struct k_work *work)
{
struct ccs811_data *data = CONTAINER_OF(work, struct ccs811_data, work);
process_irq(data->dev);
}
#else
#error Unhandled trigger configuration
#endif
int ccs811_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
uint8_t drdy_thresh = CCS811_MODE_THRESH | CCS811_MODE_DATARDY;
int rc;
if (!config->irq_gpio.port) {
return -ENOTSUP;
}
LOG_DBG("CCS811 trigger set");
setup_irq(dev, false);
drv_data->handler = handler;
if (handler == NULL) {
return 0;
}
if (trig->type == SENSOR_TRIG_DATA_READY) {
rc = ccs811_mutate_meas_mode(dev, CCS811_MODE_DATARDY,
CCS811_MODE_THRESH);
} else if (trig->type == SENSOR_TRIG_THRESHOLD) {
rc = -EINVAL;
if ((drv_data->co2_l2m >= CCS811_CO2_MIN_PPM)
&& (drv_data->co2_l2m <= CCS811_CO2_MAX_PPM)
&& (drv_data->co2_m2h >= CCS811_CO2_MIN_PPM)
&& (drv_data->co2_m2h <= CCS811_CO2_MAX_PPM)
&& (drv_data->co2_l2m <= drv_data->co2_m2h)) {
rc = ccs811_set_thresholds(dev);
}
if (rc == 0) {
rc = ccs811_mutate_meas_mode(dev, drdy_thresh, 0);
}
} else {
rc = -ENOTSUP;
}
if (rc == 0) {
drv_data->trigger = trig;
setup_irq(dev, true);
if (gpio_pin_get_dt(&config->irq_gpio) > 0) {
handle_irq(dev);
}
} else {
drv_data->handler = NULL;
(void)ccs811_mutate_meas_mode(dev, 0, drdy_thresh);
}
return rc;
}
int ccs811_init_interrupt(const struct device *dev)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
drv_data->dev = dev;
gpio_pin_configure_dt(&config->irq_gpio, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb, gpio_callback, BIT(config->irq_gpio.pin));
if (gpio_add_callback(config->irq_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
#if defined(CONFIG_CCS811_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_CCS811_THREAD_STACK_SIZE,
irq_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_CCS811_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_CCS811_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = work_cb;
#else
#error Unhandled trigger configuration
#endif
return 0;
}
``` | /content/code_sandbox/drivers/sensor/ams/ccs811/ccs811_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,415 |
```unknown
# CCS811 Digital Gas sensor configuration options
#
menuconfig CCS811
bool "CCS811 Digital Gas Sensor"
default y
depends on DT_HAS_AMS_CCS811_ENABLED
select I2C
help
Enable driver for CCS811 Gas sensors.
if CCS811
choice CCS811_DRIVE_MODE
prompt "Measurement drive mode"
default CCS811_DRIVE_MODE_1
help
Specifies the measurement rate used by the driver.
config CCS811_DRIVE_MODE_0
bool "Measurements disabled"
config CCS811_DRIVE_MODE_1
bool "Measurement every second"
config CCS811_DRIVE_MODE_2
bool "Measurement every ten seconds"
config CCS811_DRIVE_MODE_3
bool "Measurement every sixty seconds"
config CCS811_DRIVE_MODE_4
bool "Measurement every 250 milliseconds"
endchoice
config CCS811_TRIGGER
bool
choice
prompt "Trigger mode"
default CCS811_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config CCS811_TRIGGER_NONE
bool "No trigger"
config CCS811_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select CCS811_TRIGGER
config CCS811_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select CCS811_TRIGGER
endchoice
config CCS811_THREAD_PRIORITY
int "Thread priority"
depends on CCS811_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config CCS811_THREAD_STACK_SIZE
int "Thread stack size"
depends on CCS811_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # CCS811
``` | /content/code_sandbox/drivers/sensor/ams/ccs811/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 354 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_CCS811_CCS811_H_
#define ZEPHYR_DRIVERS_SENSOR_CCS811_CCS811_H_
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor/ccs811.h>
/* Registers */
#define CCS811_REG_STATUS 0x00
#define CCS811_REG_MEAS_MODE 0x01
#define CCS811_REG_ALG_RESULT_DATA 0x02
#define CCS811_REG_RAW_DATA 0x03
#define CCS811_REG_ENV_DATA 0x05
#define CCS811_REG_THRESHOLDS 0x10
#define CCS811_REG_BASELINE 0x11
#define CCS811_REG_HW_ID 0x20
#define CCS811_REG_HW_VERSION 0x21
#define CCS811_REG_FW_BOOT_VERSION 0x23
#define CCS811_REG_FW_APP_VERSION 0x24
#define CCS811_REG_ERROR_ID 0xE0
#define CCS811_REG_APP_START 0xF4
#define CCS881_HW_ID 0x81
#define CCS811_HW_VERSION_MSK 0xF0
/* Measurement modes */
#define CCS811_MODE_RAW_DATA 0x40
#define CCS811_MODE_DATARDY 0x08
#define CCS811_MODE_THRESH 0x04
#define CCS811_RAW_VOLTAGE_POS 0
#define CCS811_RAW_VOLTAGE_MSK (0x3FF << CCS811_RAW_VOLTAGE_POS)
#define CCS811_RAW_VOLTAGE_SCALE (1650000U / (CCS811_RAW_VOLTAGE_MSK \
>> CCS811_RAW_VOLTAGE_POS))
#define CCS811_RAW_CURRENT_POS 10
#define CCS811_RAW_CURRENT_MSK (0x3F << CCS811_RAW_CURRENT_POS)
#define CCS811_RAW_CURRENT_SCALE 1
#define CCS811_CO2_MIN_PPM 400
#define CCS811_CO2_MAX_PPM 32767
struct ccs811_data {
#ifdef CONFIG_CCS811_TRIGGER
const struct device *dev;
/*
* DATARDY is configured through SENSOR_CHAN_ALL.
* THRESH would be configured through SENSOR_CHAN_CO2.
*/
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler;
const struct sensor_trigger *trigger;
#if defined(CONFIG_CCS811_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_CCS811_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_CCS811_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
uint16_t co2_l2m;
uint16_t co2_m2h;
#endif /* CONFIG_CCS811_TRIGGER */
struct ccs811_result_type result;
uint8_t mode;
uint8_t app_fw_ver;
};
struct ccs811_config {
struct i2c_dt_spec i2c;
struct gpio_dt_spec irq_gpio;
struct gpio_dt_spec reset_gpio;
struct gpio_dt_spec wake_gpio;
};
#ifdef CONFIG_CCS811_TRIGGER
int ccs811_mutate_meas_mode(const struct device *dev,
uint8_t set,
uint8_t clear);
int ccs811_set_thresholds(const struct device *dev);
int ccs811_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
int ccs811_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int ccs811_init_interrupt(const struct device *dev);
#endif /* CONFIG_CCS811_TRIGGER */
#endif /* _SENSOR_CCS811_ */
``` | /content/code_sandbox/drivers/sensor/ams/ccs811/ccs811.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 785 |
```unknown
# AS5600 Angular position sensor configuration option
config AMS_AS5600
bool "AS5600 Angular position sensor"
default y
depends on DT_HAS_AMS_AS5600_ENABLED
select I2C
help
Enable driver for AS5600 Angular position sensor.
``` | /content/code_sandbox/drivers/sensor/ams/ams_as5600/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 59 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_ccs811
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "ccs811.h"
LOG_MODULE_REGISTER(CCS811, CONFIG_SENSOR_LOG_LEVEL);
static void set_wake(const struct device *dev, bool enable)
{
const struct ccs811_config *config = dev->config;
gpio_pin_set_dt(&config->wake_gpio, enable);
if (enable) {
k_busy_wait(50); /* t_WAKE = 50 us */
} else {
k_busy_wait(20); /* t_DWAKE = 20 us */
}
}
/* Get STATUS register in low 8 bits, and if ERROR is set put ERROR_ID
* in bits 8..15. These registers are available in both boot and
* application mode.
*/
static int fetch_status(const struct device *dev)
{
const struct ccs811_config *config = dev->config;
uint8_t status;
int rv;
if (i2c_reg_read_byte_dt(&config->i2c, CCS811_REG_STATUS, &status) < 0) {
LOG_ERR("Failed to read Status register");
return -EIO;
}
rv = status;
if (status & CCS811_STATUS_ERROR) {
uint8_t error_id;
if (i2c_reg_read_byte_dt(&config->i2c, CCS811_REG_ERROR_ID, &error_id) < 0) {
LOG_ERR("Failed to read ERROR_ID register");
return -EIO;
}
rv |= (error_id << 8);
}
return rv;
}
static inline uint8_t error_from_status(int status)
{
return status >> 8;
}
const struct ccs811_result_type *ccs811_result(const struct device *dev)
{
struct ccs811_data *drv_data = dev->data;
return &drv_data->result;
}
int ccs811_configver_fetch(const struct device *dev,
struct ccs811_configver_type *ptr)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
uint8_t cmd;
int rc;
if (!ptr) {
return -EINVAL;
}
set_wake(dev, true);
cmd = CCS811_REG_HW_VERSION;
rc = i2c_write_read_dt(&config->i2c, &cmd, sizeof(cmd), &ptr->hw_version,
sizeof(ptr->hw_version));
if (rc == 0) {
cmd = CCS811_REG_FW_BOOT_VERSION;
rc = i2c_write_read_dt(&config->i2c, &cmd, sizeof(cmd),
(uint8_t *)&ptr->fw_boot_version,
sizeof(ptr->fw_boot_version));
ptr->fw_boot_version = sys_be16_to_cpu(ptr->fw_boot_version);
}
if (rc == 0) {
cmd = CCS811_REG_FW_APP_VERSION;
rc = i2c_write_read_dt(&config->i2c, &cmd, sizeof(cmd),
(uint8_t *)&ptr->fw_app_version,
sizeof(ptr->fw_app_version));
ptr->fw_app_version = sys_be16_to_cpu(ptr->fw_app_version);
}
if (rc == 0) {
LOG_INF("HW %x FW %x APP %x",
ptr->hw_version, ptr->fw_boot_version,
ptr->fw_app_version);
}
set_wake(dev, false);
ptr->mode = drv_data->mode & CCS811_MODE_MSK;
return rc;
}
int ccs811_baseline_fetch(const struct device *dev)
{
const uint8_t cmd = CCS811_REG_BASELINE;
const struct ccs811_config *config = dev->config;
int rc;
uint16_t baseline;
set_wake(dev, true);
rc = i2c_write_read_dt(&config->i2c, &cmd, sizeof(cmd), (uint8_t *)&baseline,
sizeof(baseline));
set_wake(dev, false);
if (rc <= 0) {
rc = baseline;
}
return rc;
}
int ccs811_baseline_update(const struct device *dev,
uint16_t baseline)
{
const struct ccs811_config *config = dev->config;
uint8_t buf[1 + sizeof(baseline)];
int rc;
buf[0] = CCS811_REG_BASELINE;
memcpy(buf + 1, &baseline, sizeof(baseline));
set_wake(dev, true);
rc = i2c_write_dt(&config->i2c, buf, sizeof(buf));
set_wake(dev, false);
return rc;
}
int ccs811_envdata_update(const struct device *dev,
const struct sensor_value *temperature,
const struct sensor_value *humidity)
{
const struct ccs811_config *config = dev->config;
int rc;
uint8_t buf[5] = { CCS811_REG_ENV_DATA };
/*
* Environment data are represented in a broken whole/fraction
* system that specified a 9-bit fractional part to represent
* milli-units. Since 1000 is greater than 512, the device
* actually only pays attention to the top bit, treating it as
* indicating 0.5. So we only write the first octet (7-bit
* while plus 1-bit half).
*
* Humidity is simple: scale it by two and round to the
* nearest half. Assume the fractional part is not
* negative.
*/
if (humidity) {
int value = 2 * humidity->val1;
value += (250000 + humidity->val2) / 500000;
if (value < 0) {
value = 0;
} else if (value > (2 * 100)) {
value = 2 * 100;
}
LOG_DBG("HUM %d.%06d becomes %d",
humidity->val1, humidity->val2, value);
buf[1] = value;
} else {
buf[1] = 2 * 50;
}
/*
* Temperature is offset from -25 Cel. Values below minimum
* store as zero. Default is 25 Cel. Again we round to the
* nearest half, complicated by Zephyr's signed representation
* of the fractional part.
*/
if (temperature) {
int value = 2 * temperature->val1;
if (temperature->val2 < 0) {
value += (250000 + temperature->val2) / 500000;
} else {
value += (-250000 + temperature->val2) / 500000;
}
if (value < (2 * -25)) {
value = 0;
} else {
value += 2 * 25;
}
LOG_DBG("TEMP %d.%06d becomes %d",
temperature->val1, temperature->val2, value);
buf[3] = value;
} else {
buf[3] = 2 * (25 + 25);
}
set_wake(dev, true);
rc = i2c_write_dt(&config->i2c, buf, sizeof(buf));
set_wake(dev, false);
return rc;
}
static int ccs811_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
struct ccs811_result_type *rp = &drv_data->result;
const uint8_t cmd = CCS811_REG_ALG_RESULT_DATA;
int rc;
uint16_t buf[4] = { 0 };
unsigned int status;
set_wake(dev, true);
rc = i2c_write_read_dt(&config->i2c, &cmd, sizeof(cmd), (uint8_t *)buf, sizeof(buf));
set_wake(dev, false);
if (rc < 0) {
return -EIO;
}
rp->co2 = sys_be16_to_cpu(buf[0]);
rp->voc = sys_be16_to_cpu(buf[1]);
status = sys_le16_to_cpu(buf[2]); /* sic */
rp->status = status;
rp->error = error_from_status(status);
rp->raw = sys_be16_to_cpu(buf[3]);
/* APP FW 1.1 does not set DATA_READY, but it does set CO2 to
* zero while it's starting up. Assume a non-zero CO2 with
* old firmware is valid for the purposes of claiming the
* fetch was fresh.
*/
if ((drv_data->app_fw_ver <= 0x11)
&& (rp->co2 != 0)) {
status |= CCS811_STATUS_DATA_READY;
}
return (status & CCS811_STATUS_DATA_READY) ? 0 : -EAGAIN;
}
static int ccs811_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_result_type *rp = &drv_data->result;
uint32_t uval;
switch (chan) {
case SENSOR_CHAN_CO2:
val->val1 = rp->co2;
val->val2 = 0;
break;
case SENSOR_CHAN_VOC:
val->val1 = rp->voc;
val->val2 = 0;
break;
case SENSOR_CHAN_VOLTAGE:
/*
* Raw ADC readings are contained in least significant 10 bits
*/
uval = ((rp->raw & CCS811_RAW_VOLTAGE_MSK)
>> CCS811_RAW_VOLTAGE_POS) * CCS811_RAW_VOLTAGE_SCALE;
val->val1 = uval / 1000000U;
val->val2 = uval % 1000000;
break;
case SENSOR_CHAN_CURRENT:
/*
* Current readings are contained in most
* significant 6 bits in microAmps
*/
uval = ((rp->raw & CCS811_RAW_CURRENT_MSK)
>> CCS811_RAW_CURRENT_POS) * CCS811_RAW_CURRENT_SCALE;
val->val1 = uval / 1000000U;
val->val2 = uval % 1000000;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api ccs811_driver_api = {
#ifdef CONFIG_CCS811_TRIGGER
.attr_set = ccs811_attr_set,
.trigger_set = ccs811_trigger_set,
#endif
.sample_fetch = ccs811_sample_fetch,
.channel_get = ccs811_channel_get,
};
static int switch_to_app_mode(const struct device *dev)
{
const struct ccs811_config *config = dev->config;
uint8_t buf;
int status;
LOG_DBG("Switching to Application mode...");
status = fetch_status(dev);
if (status < 0) {
return -EIO;
}
/* Check for the application firmware */
if (!(status & CCS811_STATUS_APP_VALID)) {
LOG_ERR("No Application firmware loaded");
return -EINVAL;
}
/* Check if already in application mode */
if (status & CCS811_STATUS_FW_MODE) {
LOG_DBG("CCS811 Already in application mode");
return 0;
}
buf = CCS811_REG_APP_START;
/* Set the device to application mode */
if (i2c_write_dt(&config->i2c, &buf, 1) < 0) {
LOG_ERR("Failed to set Application mode");
return -EIO;
}
k_msleep(1); /* t_APP_START */
status = fetch_status(dev);
if (status < 0) {
return -EIO;
}
/* Check for application mode */
if (!(status & CCS811_STATUS_FW_MODE)) {
LOG_ERR("Failed to start Application firmware");
return -EINVAL;
}
LOG_DBG("CCS811 Application firmware started!");
return 0;
}
#ifdef CONFIG_CCS811_TRIGGER
int ccs811_mutate_meas_mode(const struct device *dev,
uint8_t set,
uint8_t clear)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
int rc = 0;
uint8_t mode = set | (drv_data->mode & ~clear);
/*
* Changing drive mode of a running system has preconditions.
* Only allow changing the interrupt generation.
*/
if ((set | clear) & ~(CCS811_MODE_DATARDY | CCS811_MODE_THRESH)) {
return -EINVAL;
}
if (mode != drv_data->mode) {
set_wake(dev, true);
rc = i2c_reg_write_byte_dt(&config->i2c, CCS811_REG_MEAS_MODE, mode);
LOG_DBG("CCS811 meas mode change %02x to %02x got %d",
drv_data->mode, mode, rc);
if (rc < 0) {
LOG_ERR("Failed to set mode");
rc = -EIO;
} else {
drv_data->mode = mode;
rc = 0;
}
set_wake(dev, false);
}
return rc;
}
int ccs811_set_thresholds(const struct device *dev)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
const uint8_t buf[5] = {
CCS811_REG_THRESHOLDS,
drv_data->co2_l2m >> 8,
drv_data->co2_l2m,
drv_data->co2_m2h >> 8,
drv_data->co2_m2h,
};
int rc;
set_wake(dev, true);
rc = i2c_write_dt(&config->i2c, buf, sizeof(buf));
set_wake(dev, false);
return rc;
}
#endif /* CONFIG_CCS811_TRIGGER */
static int ccs811_init(const struct device *dev)
{
struct ccs811_data *drv_data = dev->data;
const struct ccs811_config *config = dev->config;
int ret = 0;
int status;
uint16_t fw_ver;
uint8_t cmd;
uint8_t hw_id;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
if (config->wake_gpio.port) {
if (!gpio_is_ready_dt(&config->wake_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
/*
* Wakeup pin should be pulled low before initiating
* any I2C transfer. If it has been tied to GND by
* default, skip this part.
*/
gpio_pin_configure_dt(&config->wake_gpio, GPIO_OUTPUT_INACTIVE);
set_wake(dev, true);
k_msleep(1);
}
if (config->reset_gpio.port) {
if (!gpio_is_ready_dt(&config->reset_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
gpio_pin_configure_dt(&config->reset_gpio, GPIO_OUTPUT_ACTIVE);
k_msleep(1);
}
if (config->irq_gpio.port) {
if (!gpio_is_ready_dt(&config->irq_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
}
k_msleep(20); /* t_START assuming recent power-on */
/* Reset the device. This saves having to deal with detecting
* and validating any errors or configuration inconsistencies
* after a reset that left the device running.
*/
if (config->reset_gpio.port) {
gpio_pin_set_dt(&config->reset_gpio, 1);
k_busy_wait(15); /* t_RESET */
gpio_pin_set_dt(&config->reset_gpio, 0);
} else {
static uint8_t const reset_seq[] = {
0xFF, 0x11, 0xE5, 0x72, 0x8A,
};
if (i2c_write_dt(&config->i2c, reset_seq, sizeof(reset_seq)) < 0) {
LOG_ERR("Failed to issue SW reset");
ret = -EIO;
goto out;
}
}
k_msleep(2); /* t_START after reset */
/* Switch device to application mode */
ret = switch_to_app_mode(dev);
if (ret) {
goto out;
}
/* Check Hardware ID */
if (i2c_reg_read_byte_dt(&config->i2c, CCS811_REG_HW_ID, &hw_id) < 0) {
LOG_ERR("Failed to read Hardware ID register");
ret = -EIO;
goto out;
}
if (hw_id != CCS881_HW_ID) {
LOG_ERR("Hardware ID mismatch!");
ret = -EINVAL;
goto out;
}
/* Check application firmware version (first byte) */
cmd = CCS811_REG_FW_APP_VERSION;
if (i2c_write_read_dt(&config->i2c, &cmd, sizeof(cmd), &fw_ver, sizeof(fw_ver)) < 0) {
LOG_ERR("Failed to read App Firmware Version register");
ret = -EIO;
goto out;
}
fw_ver = sys_be16_to_cpu(fw_ver);
LOG_INF("App FW %04x", fw_ver);
drv_data->app_fw_ver = fw_ver >> 8U;
/* Configure measurement mode */
uint8_t meas_mode = CCS811_MODE_IDLE;
#ifdef CONFIG_CCS811_DRIVE_MODE_1
meas_mode = CCS811_MODE_IAQ_1SEC;
#elif defined(CONFIG_CCS811_DRIVE_MODE_2)
meas_mode = CCS811_MODE_IAQ_10SEC;
#elif defined(CONFIG_CCS811_DRIVE_MODE_3)
meas_mode = CCS811_MODE_IAQ_60SEC;
#elif defined(CONFIG_CCS811_DRIVE_MODE_4)
meas_mode = CCS811_MODE_IAQ_250MSEC;
#endif
if (i2c_reg_write_byte_dt(&config->i2c, CCS811_REG_MEAS_MODE, meas_mode) < 0) {
LOG_ERR("Failed to set Measurement mode");
ret = -EIO;
goto out;
}
drv_data->mode = meas_mode;
/* Check for error */
status = fetch_status(dev);
if (status < 0) {
ret = -EIO;
goto out;
}
if (status & CCS811_STATUS_ERROR) {
LOG_ERR("CCS811 Error %02x during sensor configuration",
error_from_status(status));
ret = -EINVAL;
goto out;
}
#ifdef CONFIG_CCS811_TRIGGER
if (config->irq_gpio.port) {
ret = ccs811_init_interrupt(dev);
LOG_DBG("CCS811 interrupt init got %d", ret);
}
#endif
out:
set_wake(dev, false);
return ret;
}
#define CCS811_DEFINE(inst) \
static struct ccs811_data ccs811_data_##inst; \
\
static const struct ccs811_config ccs811_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_CCS811_TRIGGER, \
(.irq_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, irq_gpios, { 0 }),)) \
.reset_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, reset_gpios, { 0 }), \
.wake_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, wake_gpios, { 0 }), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(0, ccs811_init, NULL, \
&ccs811_data_##inst, &ccs811_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&ccs811_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(CCS811_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ams/ccs811/ccs811.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,395 |
```unknown
config TCS3400
bool "TCS3400 Sensor"
default y
depends on DT_HAS_AMS_TCS3400_ENABLED
select I2C
help
Enable driver for TCS3400 sensors.
``` | /content/code_sandbox/drivers/sensor/ams/tcs3400/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 49 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_as5600
#include <errno.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ams_as5600, CONFIG_SENSOR_LOG_LEVEL);
#define AS5600_ANGLE_REGISTER_H 0x0E
#define AS5600_FULL_ANGLE 360
#define AS5600_PULSES_PER_REV 4096
#define AS5600_MILLION_UNIT 1000000
struct as5600_dev_cfg {
struct i2c_dt_spec i2c_port;
};
/* Device run time data */
struct as5600_dev_data {
uint16_t position;
};
static int as5600_fetch(const struct device *dev, enum sensor_channel chan)
{
struct as5600_dev_data *dev_data = dev->data;
const struct as5600_dev_cfg *dev_cfg = dev->config;
uint8_t read_data[2] = {0, 0};
uint8_t angle_reg = AS5600_ANGLE_REGISTER_H;
int err = i2c_write_read_dt(&dev_cfg->i2c_port,
&angle_reg,
1,
&read_data,
sizeof(read_data));
/* invalid readings preserves the last good value */
if (!err) {
dev_data->position = ((uint16_t)read_data[0] << 8) | read_data[1];
}
return err;
}
static int as5600_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct as5600_dev_data *dev_data = dev->data;
if (chan == SENSOR_CHAN_ROTATION) {
val->val1 = ((int32_t)dev_data->position * AS5600_FULL_ANGLE) /
AS5600_PULSES_PER_REV;
val->val2 = (((int32_t)dev_data->position * AS5600_FULL_ANGLE) %
AS5600_PULSES_PER_REV) * (AS5600_MILLION_UNIT / AS5600_PULSES_PER_REV);
} else {
return -ENOTSUP;
}
return 0;
}
static int as5600_initialize(const struct device *dev)
{
struct as5600_dev_data *const dev_data = dev->data;
dev_data->position = 0;
LOG_INF("Device %s initialized", dev->name);
return 0;
}
static const struct sensor_driver_api as5600_driver_api = {
.sample_fetch = as5600_fetch,
.channel_get = as5600_get,
};
#define AS5600_INIT(n) \
static struct as5600_dev_data as5600_data##n; \
static const struct as5600_dev_cfg as5600_cfg##n = {\
.i2c_port = I2C_DT_SPEC_INST_GET(n) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, as5600_initialize, NULL, \
&as5600_data##n, &as5600_cfg##n, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&as5600_driver_api);
DT_INST_FOREACH_STATUS_OKAY(AS5600_INIT)
``` | /content/code_sandbox/drivers/sensor/ams/ams_as5600/ams_as5600.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 718 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_tcs3400
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/tcs3400.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(tcs3400, CONFIG_SENSOR_LOG_LEVEL);
#define TCS3400_ENABLE_REG 0x80
#define TCS3400_ENABLE_AIEN BIT(4)
#define TCS3400_ENABLE_AEN BIT(1)
#define TCS3400_ENABLE_PON BIT(0)
#define TCS3400_ATIME_REG 0x81
#define TCS3400_PERS_REG 0x8c
#define TCS3400_CONFIG_REG 0x8d
#define TCS3400_CONTROL_REG 0x8f
#define TCS3400_ID_REG 0x92
#define TCS3400_ID_1 0x90
#define TCS3400_ID_2 0x93
#define TCS3400_STATUS_REG 0x93
#define TCS3400_STATUS_AVALID BIT(0)
#define TCS3400_CDATAL_REG 0x94
#define TCS3400_CDATAH_REG 0x95
#define TCS3400_RDATAL_REG 0x96
#define TCS3400_RDATAH_REG 0x97
#define TCS3400_GDATAL_REG 0x98
#define TCS3400_GDATAH_REG 0x99
#define TCS3400_BDATAL_REG 0x9A
#define TCS3400_BDATAH_REG 0x9B
#define TCS3400_AICLEAR_REG 0xe7
/* Default values */
#define TCS3400_DEFAULT_ENABLE 0x00
#define TCS3400_DEFAULT_ATIME 0xff
#define TCS3400_DEFAULT_PERS 0x00
#define TCS3400_DEFAULT_CONFIG 0x00
#define TCS3400_DEFAULT_CONTROL 0x00
#define TCS3400_AICLEAR_RESET 0x00
struct tcs3400_config {
struct i2c_dt_spec i2c;
struct gpio_dt_spec int_gpio;
};
struct tcs3400_data {
struct gpio_callback gpio_cb;
const struct device *dev;
uint16_t sample_crgb[4];
struct k_sem data_sem;
};
static void tcs3400_setup_int(const struct tcs3400_config *config, bool enable)
{
unsigned int flags = enable ? GPIO_INT_EDGE_TO_ACTIVE : GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
}
static void tcs3400_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct tcs3400_data *data = CONTAINER_OF(cb, struct tcs3400_data,
gpio_cb);
tcs3400_setup_int(data->dev->config, false);
k_sem_give(&data->data_sem);
}
static int tcs3400_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct tcs3400_config *cfg = dev->config;
struct tcs3400_data *data = dev->data;
int ret;
uint8_t status;
if (chan != SENSOR_CHAN_ALL) {
LOG_ERR("Unsupported sensor channel");
return -ENOTSUP;
}
tcs3400_setup_int(cfg, true);
ret = i2c_reg_write_byte_dt(&cfg->i2c, TCS3400_ENABLE_REG,
TCS3400_ENABLE_AIEN | TCS3400_ENABLE_AEN |
TCS3400_ENABLE_PON);
if (ret) {
return ret;
}
k_sem_take(&data->data_sem, K_FOREVER);
ret = i2c_reg_read_byte_dt(&cfg->i2c, TCS3400_STATUS_REG, &status);
if (ret) {
return ret;
}
if (status & TCS3400_STATUS_AVALID) {
ret = i2c_burst_read_dt(&cfg->i2c, TCS3400_CDATAL_REG,
(uint8_t *)&data->sample_crgb,
sizeof(data->sample_crgb));
if (ret) {
return ret;
}
} else {
LOG_ERR("Unexpected status: %02x", status);
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, TCS3400_ENABLE_REG, 0);
if (ret) {
return ret;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, TCS3400_AICLEAR_REG, 0);
if (ret) {
return ret;
}
return 0;
}
static int tcs3400_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct tcs3400_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_LIGHT:
val->val1 = sys_le16_to_cpu(data->sample_crgb[0]);
val->val2 = 0;
break;
case SENSOR_CHAN_RED:
val->val1 = sys_le16_to_cpu(data->sample_crgb[1]);
val->val2 = 0;
break;
case SENSOR_CHAN_GREEN:
val->val1 = sys_le16_to_cpu(data->sample_crgb[2]);
val->val2 = 0;
break;
case SENSOR_CHAN_BLUE:
val->val1 = sys_le16_to_cpu(data->sample_crgb[3]);
val->val2 = 0;
break;
default:
return -ENOTSUP;
}
return 0;
}
static int tcs3400_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct tcs3400_config *cfg = dev->config;
int ret;
uint8_t reg_val;
switch (attr) {
case SENSOR_ATTR_TCS3400_INTEGRATION_CYCLES:
if (!IN_RANGE(val->val1, 1, 256)) {
return -EINVAL;
}
reg_val = UINT8_MAX - val->val1 + 1;
ret = i2c_reg_write_byte_dt(&cfg->i2c,
TCS3400_ATIME_REG, reg_val);
if (ret) {
return ret;
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int tcs3400_sensor_setup(const struct device *dev)
{
const struct tcs3400_config *cfg = dev->config;
uint8_t chip_id;
int ret;
struct {
uint8_t reg_addr;
uint8_t value;
} reset_regs[] = {
{TCS3400_ENABLE_REG, TCS3400_DEFAULT_ENABLE},
{TCS3400_AICLEAR_REG, TCS3400_AICLEAR_RESET},
{TCS3400_ATIME_REG, TCS3400_DEFAULT_ATIME},
{TCS3400_PERS_REG, TCS3400_DEFAULT_PERS},
{TCS3400_CONFIG_REG, TCS3400_DEFAULT_CONFIG},
{TCS3400_CONTROL_REG, TCS3400_DEFAULT_CONTROL},
};
ret = i2c_reg_read_byte_dt(&cfg->i2c, TCS3400_ID_REG, &chip_id);
if (ret) {
LOG_DBG("Failed to read chip id: %d", ret);
return ret;
}
if (!((chip_id == TCS3400_ID_1) || (chip_id == TCS3400_ID_2))) {
LOG_DBG("Invalid chip id: %02x", chip_id);
return -EIO;
}
LOG_INF("chip id: 0x%x", chip_id);
for (size_t i = 0; i < ARRAY_SIZE(reset_regs); i++) {
ret = i2c_reg_write_byte_dt(&cfg->i2c, reset_regs[i].reg_addr,
reset_regs[i].value);
if (ret) {
LOG_ERR("Failed to set default register: %02x",
reset_regs[i].reg_addr);
return ret;
}
}
return 0;
}
static const struct sensor_driver_api tcs3400_api = {
.sample_fetch = tcs3400_sample_fetch,
.channel_get = tcs3400_channel_get,
.attr_set = tcs3400_attr_set,
};
static int tcs3400_init(const struct device *dev)
{
const struct tcs3400_config *cfg = dev->config;
struct tcs3400_data *data = dev->data;
int ret;
k_sem_init(&data->data_sem, 0, K_SEM_MAX_LIMIT);
data->dev = dev;
if (!i2c_is_ready_dt(&cfg->i2c)) {
LOG_ERR("I2C bus is not ready");
return -ENODEV;
}
ret = tcs3400_sensor_setup(dev);
if (ret < 0) {
LOG_ERR("Failed to setup device");
return ret;
}
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("Interrupt GPIO device not ready");
return -ENODEV;
}
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Failed to configure interrupt pin");
return ret;
}
gpio_init_callback(&data->gpio_cb, tcs3400_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 GPIO callback");
return ret;
}
return 0;
}
#define TCS3400_INIT(n) \
static struct tcs3400_data tcs3400_data_##n; \
static const struct tcs3400_config tcs3400_config_##n = { \
.i2c = I2C_DT_SPEC_INST_GET(n), \
.int_gpio = GPIO_DT_SPEC_INST_GET(n, int_gpios), \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(n, &tcs3400_init, NULL, \
&tcs3400_data_##n, &tcs3400_config_##n, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&tcs3400_api);
DT_INST_FOREACH_STATUS_OKAY(TCS3400_INIT)
``` | /content/code_sandbox/drivers/sensor/ams/tcs3400/tcs3400.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,263 |
```unknown
config TSL2561
bool "OSRAM-AMS TSL2561 light sensor"
default y
depends on DT_HAS_AMS_TSL2561_ENABLED
select I2C
help
Enable driver for TSL2561 sensor.
``` | /content/code_sandbox/drivers/sensor/ams/tsl2561/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 54 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_iaqcore
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "iAQcore.h"
LOG_MODULE_REGISTER(IAQ_CORE, CONFIG_SENSOR_LOG_LEVEL);
static int iaqcore_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct iaq_core_data *drv_data = dev->data;
const struct iaq_core_config *config = dev->config;
struct iaq_registers buf;
struct i2c_msg msg;
int ret, tries;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
msg.buf = (uint8_t *)&buf;
msg.len = sizeof(struct iaq_registers);
msg.flags = I2C_MSG_READ | I2C_MSG_STOP;
for (tries = 0; tries < CONFIG_IAQ_CORE_MAX_READ_RETRIES; tries++) {
ret = i2c_transfer_dt(&config->i2c, &msg, 1);
if (ret < 0) {
LOG_ERR("Failed to read registers data [%d].", ret);
return -EIO;
}
drv_data->status = buf.status;
if (buf.status == 0x00) {
drv_data->co2 = sys_be16_to_cpu(buf.co2_pred);
drv_data->voc = sys_be16_to_cpu(buf.voc);
drv_data->status = buf.status;
drv_data->resistance = sys_be32_to_cpu(buf.resistance);
return 0;
}
k_sleep(K_MSEC(100));
}
if (drv_data->status == 0x01) {
LOG_INF("Sensor data not available");
}
if (drv_data->status == 0x80) {
LOG_ERR("Sensor Error");
}
return -EIO;
}
static int iaqcore_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct iaq_core_data *drv_data = dev->data;
switch (chan) {
case SENSOR_CHAN_CO2:
val->val1 = drv_data->co2;
val->val2 = 0;
break;
case SENSOR_CHAN_VOC:
val->val1 = drv_data->voc;
val->val2 = 0;
break;
case SENSOR_CHAN_RESISTANCE:
val->val1 = drv_data->resistance;
val->val2 = 0;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api iaq_core_driver_api = {
.sample_fetch = iaqcore_sample_fetch,
.channel_get = iaqcore_channel_get,
};
static int iaq_core_init(const struct device *dev)
{
const struct iaq_core_config *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
return 0;
}
#define IAQ_CORE_DEFINE(inst) \
static struct iaq_core_data iaq_core_data_##inst; \
\
static const struct iaq_core_config iaq_core_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, iaq_core_init, NULL, &iaq_core_data_##inst, \
&iaq_core_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &iaq_core_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(IAQ_CORE_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ams/ams_iAQcore/iAQcore.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 839 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_AMS_IAQCORE_IAQCORE_H_
#define ZEPHYR_DRIVERS_SENSOR_AMS_IAQCORE_IAQCORE_H_
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
struct iaq_registers {
uint16_t co2_pred;
uint8_t status;
int32_t resistance;
uint16_t voc;
} __packed;
struct iaq_core_config {
struct i2c_dt_spec i2c;
};
struct iaq_core_data {
uint16_t co2;
uint16_t voc;
uint8_t status;
int32_t resistance;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_AMS_IAQCORE_IAQCORE_H_ */
``` | /content/code_sandbox/drivers/sensor/ams/ams_iAQcore/iAQcore.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 154 |
```c
/*
*
*/
#define DT_DRV_COMPAT ams_tsl2561
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <zephyr/devicetree.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
LOG_MODULE_REGISTER(TSL2561, CONFIG_SENSOR_LOG_LEVEL);
#define TSL2561_CHIP_ID 0x05
#define TSL2561_GAIN_1X 0x00
#define TSL2561_GAIN_16X 0x01
#define TSL2561_INTEGRATION_13MS 0x00
#define TSL2561_INTEGRATION_101MS 0x01
#define TSL2561_INTEGRATION_402MS 0x02
/* Register set */
#define TSL2561_REG_CONTROL 0x00
#define TSL2561_REG_TIMING 0x01
#define TSL2561_REG_THRESHLOWLOW 0x02
#define TSL2561_REG_THRESHLOWHIGH 0x03
#define TSL2561_REG_THRESHHIGHLOW 0x04
#define TSL2561_REG_THRESHHIGHHIGH 0x05
#define TSL2561_REG_INTERRUPT 0x06
#define TSL2561_REG_ID 0x0A
#define TSL2561_REG_DATA0LOW 0x0C
#define TSL2561_REG_DATA0HIGH 0x0D
#define TSL2561_REG_DATA1LOW 0x0E
#define TSL2561_REG_DATA1HIGH 0x0F
/* Command register fields */
#define TSL2561_COMMAND_CMD BIT(7)
#define TSL2561_COMMAND_WORD BIT(5)
/* Control register fields */
#define TSL2561_CONTROL_POWER_UP 0x03
#define TSL2561_CONTROL_POWER_DOWN 0x00
/* Timing register fields */
#define TSL2561_TIMING_GAIN BIT(4)
#define TSL2561_TIMING_INTEG GENMASK(1, 0)
/* ID register part number mask */
#define TSL2561_ID_PARTNO GENMASK(7, 4)
/* Lux calculation constants */
#define TSL2561_LUX_SCALE 14U
#define TSL2561_RATIO_SCALE 9U
#define TSL2561_CH_SCALE 10U
#define TSL2561_CHSCALE_TINT0 0x7517
#define TSL2561_CHSCALE_TINT1 0x0FE7
#define TSL2561_LUX_K1T 0X0040 /* 0.125 * 2^RATIO_SCALE */
#define TSL2561_LUX_B1T 0X01F2 /* 0.0304 * 2^LUX_SCALE */
#define TSL2561_LUX_M1T 0X01BE /* 0.0272 * 2^LUX_SCALE */
#define TSL2561_LUX_K2T 0X0080 /* 0.250 * 2^RATIO_SCALE */
#define TSL2561_LUX_B2T 0X0214 /* 0.0325 * 2^LUX_SCALE */
#define TSL2561_LUX_M2T 0X02D1 /* 0.0440 * 2^LUX_SCALE */
#define TSL2561_LUX_K3T 0X00C0 /* 0.375 * 2^RATIO_SCALE */
#define TSL2561_LUX_B3T 0X023F /* 0.0351 * 2^LUX_SCALE */
#define TSL2561_LUX_M3T 0X037B /* 0.0544 * 2^LUX_SCALE */
#define TSL2561_LUX_K4T 0X0100 /* 0.50 * 2^RATIO_SCALE */
#define TSL2561_LUX_B4T 0X0270 /* 0.0381 * 2^LUX_SCALE */
#define TSL2561_LUX_M4T 0X03FE /* 0.0624 * 2^LUX_SCALE */
#define TSL2561_LUX_K5T 0X0138 /* 0.61 * 2^RATIO_SCALE */
#define TSL2561_LUX_B5T 0X016F /* 0.0224 * 2^LUX_SCALE */
#define TSL2561_LUX_M5T 0X01FC /* 0.0310 * 2^LUX_SCALE */
#define TSL2561_LUX_K6T 0X019A /* 0.80 * 2^RATIO_SCALE */
#define TSL2561_LUX_B6T 0X00D2 /* 0.0128 * 2^LUX_SCALE */
#define TSL2561_LUX_M6T 0X00FB /* 0.0153 * 2^LUX_SCALE */
#define TSL2561_LUX_K7T 0X029A /* 1.3 * 2^RATIO_SCALE */
#define TSL2561_LUX_B7T 0X0018 /* 0.00146 * 2^LUX_SCALE */
#define TSL2561_LUX_M7T 0X0012 /* 0.00112 * 2^LUX_SCALE */
#define TSL2561_LUX_K8T 0X029A /* 1.3 * 2^RATIO_SCALE */
#define TSL2561_LUX_B8T 0X0000 /* 0.000 * 2^LUX_SCALE */
#define TSL2561_LUX_M8T 0X0000 /* 0.000 * 2^LUX_SCALE */
struct tsl2561_config {
struct i2c_dt_spec i2c;
uint16_t integration_time;
uint8_t gain;
};
struct tsl2561_data {
uint16_t ch0;
uint16_t ch1;
uint32_t ch_scale;
};
static int tsl2561_reg_read(const struct device *dev, uint8_t reg, uint8_t *buf, uint8_t size)
{
int ret;
const struct tsl2561_config *config = dev->config;
uint8_t cmd = (TSL2561_COMMAND_CMD | TSL2561_COMMAND_WORD | reg);
ret = i2c_write_read_dt(&config->i2c, &cmd, 1U, buf, size);
if (ret < 0) {
LOG_ERR("Failed reading register 0x%02x", reg);
return ret;
}
return 0;
}
static int tsl2561_reg_write(const struct device *dev, uint8_t reg, uint8_t val)
{
int ret;
const struct tsl2561_config *config = dev->config;
uint8_t buf[2];
buf[0] = (TSL2561_COMMAND_CMD | TSL2561_COMMAND_WORD | reg);
buf[1] = val;
ret = i2c_write_dt(&config->i2c, buf, 2U);
if (ret < 0) {
LOG_ERR("Failed writing register 0x%02x", reg);
return ret;
}
return 0;
}
static int tsl2561_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct tsl2561_config *config = dev->config;
struct tsl2561_data *data = dev->data;
uint8_t bytes[2];
int ret;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_LIGHT) {
LOG_ERR("Unsupported sensor channel");
return -ENOTSUP;
}
ret = tsl2561_reg_write(dev, TSL2561_REG_CONTROL, TSL2561_CONTROL_POWER_UP);
if (ret < 0) {
LOG_ERR("Failed to power up device");
return ret;
}
/* Short sleep after power up. Not in the datasheet, but found by trial and error */
k_msleep(5);
k_msleep(config->integration_time);
/* Read data register's lower and upper bytes consecutively */
ret = tsl2561_reg_read(dev, TSL2561_REG_DATA0LOW, bytes, 2U);
if (ret < 0) {
LOG_ERR("Failed reading channel0 data");
return ret;
}
data->ch0 = bytes[1] << 8 | bytes[0];
ret = tsl2561_reg_read(dev, TSL2561_REG_DATA1LOW, bytes, 2U);
if (ret < 0) {
LOG_ERR("Failed reading channel1 data");
return ret;
}
data->ch1 = bytes[1] << 8 | bytes[0];
ret = tsl2561_reg_write(dev, TSL2561_REG_CONTROL, TSL2561_CONTROL_POWER_DOWN);
if (ret < 0) {
LOG_ERR("Failed to power down device");
return ret;
}
LOG_DBG("channel0: 0x%x; channel1: 0x%x", data->ch0, data->ch1);
return 0;
}
static int tsl2561_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct tsl2561_data *data = dev->data;
uint32_t channel0;
uint32_t channel1;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_LIGHT) {
return -ENOTSUP;
}
channel0 = (data->ch0 * data->ch_scale) >> TSL2561_CH_SCALE;
channel1 = (data->ch1 * data->ch_scale) >> TSL2561_CH_SCALE;
uint32_t ratio1 = 0;
if (channel0 != 0) {
ratio1 = (channel1 << (TSL2561_RATIO_SCALE + 1)) / channel0;
}
/* Round the ratio value */
uint32_t ratio = (ratio1 + 1) >> 1;
uint32_t b = 0;
uint32_t m = 0;
if (ratio <= TSL2561_LUX_K1T) {
b = TSL2561_LUX_B1T;
m = TSL2561_LUX_M1T;
} else if (ratio <= TSL2561_LUX_K2T) {
b = TSL2561_LUX_B2T;
m = TSL2561_LUX_M2T;
} else if (ratio <= TSL2561_LUX_K3T) {
b = TSL2561_LUX_B3T;
m = TSL2561_LUX_M3T;
} else if (ratio <= TSL2561_LUX_K4T) {
b = TSL2561_LUX_B4T;
m = TSL2561_LUX_M4T;
} else if (ratio <= TSL2561_LUX_K5T) {
b = TSL2561_LUX_B5T;
m = TSL2561_LUX_M5T;
} else if (ratio <= TSL2561_LUX_K6T) {
b = TSL2561_LUX_B6T;
m = TSL2561_LUX_M6T;
} else if (ratio <= TSL2561_LUX_K7T) {
b = TSL2561_LUX_B7T;
m = TSL2561_LUX_M7T;
} else if (ratio > TSL2561_LUX_K8T) {
b = TSL2561_LUX_B8T;
m = TSL2561_LUX_M8T;
}
int32_t tmp = ((channel0 * b) - (channel1 * m));
/* Round LSB (2^(LUX_SCALE1)) */
tmp += (1 << (TSL2561_LUX_SCALE - 1));
/* Strip off fractional portion */
val->val1 = tmp >> TSL2561_LUX_SCALE;
val->val2 = 0;
return 0;
}
static const struct sensor_driver_api tsl2561_driver_api = {
.sample_fetch = tsl2561_sample_fetch,
.channel_get = tsl2561_channel_get
};
static int tsl2561_sensor_setup(const struct device *dev)
{
const struct tsl2561_config *config = dev->config;
struct tsl2561_data *data = dev->data;
uint8_t timing_reg;
uint8_t chip_id;
uint8_t tmp;
int ret;
ret = tsl2561_reg_read(dev, TSL2561_REG_ID, &chip_id, 1U);
if (ret < 0) {
LOG_ERR("Failed reading chip ID");
return ret;
}
if (FIELD_GET(TSL2561_ID_PARTNO, chip_id) != TSL2561_CHIP_ID) {
LOG_ERR("Chip ID is invalid! Device @%02x is not TSL2561!", config->i2c.addr);
return -EIO;
}
switch (config->integration_time) {
case 13:
tmp = TSL2561_INTEGRATION_13MS;
data->ch_scale = TSL2561_CHSCALE_TINT0;
break;
case 101:
tmp = TSL2561_INTEGRATION_101MS;
data->ch_scale = TSL2561_CHSCALE_TINT1;
break;
case 402:
tmp = TSL2561_INTEGRATION_402MS;
data->ch_scale = (1 << TSL2561_CH_SCALE);
break;
default:
LOG_ERR("Invalid integration time");
return -EINVAL;
}
timing_reg = TSL2561_TIMING_INTEG & tmp;
switch (config->gain) {
case 1:
tmp = TSL2561_GAIN_1X;
data->ch_scale = data->ch_scale << 4;
break;
case 16:
tmp = TSL2561_GAIN_16X;
break;
default:
LOG_ERR("Invalid ADC gain");
return -EINVAL;
}
timing_reg |= FIELD_PREP(TSL2561_TIMING_GAIN, tmp);
ret = tsl2561_reg_write(dev, TSL2561_REG_TIMING, timing_reg);
if (ret < 0) {
LOG_ERR("Failed setting timing register");
return ret;
}
return 0;
}
static int tsl2561_init(const struct device *dev)
{
const struct tsl2561_config *config = dev->config;
int ret;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_ERR("I2C dev %s not ready", config->i2c.bus->name);
return -ENODEV;
}
ret = tsl2561_sensor_setup(dev);
if (ret < 0) {
LOG_ERR("Failed to configure device");
return ret;
}
return 0;
}
#define TSL2561_INIT_INST(n) \
static struct tsl2561_data tsl2561_data_##n; \
static const struct tsl2561_config tsl2561_config_##n = { \
.i2c = I2C_DT_SPEC_INST_GET(n), \
.integration_time = DT_INST_PROP(n, integration_time), \
.gain = DT_INST_PROP(n, gain)}; \
SENSOR_DEVICE_DT_INST_DEFINE(n, tsl2561_init, NULL, &tsl2561_data_##n, \
&tsl2561_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tsl2561_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TSL2561_INIT_INST)
``` | /content/code_sandbox/drivers/sensor/ams/tsl2561/tsl2561.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,397 |
```unknown
# iAQ-core Digital VOC sensor configuration options
menuconfig AMS_IAQ_CORE
bool "iAQ-core Digital VOC sensor"
default y
depends on DT_HAS_AMS_IAQCORE_ENABLED
select I2C
help
Enable driver for iAQ-core Digital VOC sensor.
config IAQ_CORE_MAX_READ_RETRIES
int "Number of read retries"
default 4
depends on AMS_IAQ_CORE
help
Number of retries when reading failed or device not ready.
``` | /content/code_sandbox/drivers/sensor/ams/ams_iAQcore/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 102 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_SBS_GAUGE_H_
#define ZEPHYR_DRIVERS_SENSOR_SBS_GAUGE_H_
#include <stdint.h>
#include <zephyr/drivers/i2c.h>
/*** Standard Commands ***/
#define SBS_GAUGE_CMD_MANUFACTURER_ACCESS 0x00 /* ManufacturerAccess */
#define SBS_GAUGE_CMD_REM_CAPACITY_ALARM 0x01 /* LowCapacityAlarmThreshold */
#define SBS_GAUGE_CMD_REM_TIME_ALARM 0x02 /* RemainingTimeToEmptyThreshold */
#define SBS_GAUGE_CMD_BATTERY_MODE 0x03 /* BatteryOperatingMode */
#define SBS_GAUGE_CMD_AR 0x04 /* AtRate */
#define SBS_GAUGE_CMD_ARTTF 0x05 /* AtRateTimeToFull */
#define SBS_GAUGE_CMD_ARTTE 0x06 /* AtRateTimeToEmpty */
#define SBS_GAUGE_CMD_AROK 0x07 /* AtRateOK */
#define SBS_GAUGE_CMD_TEMP 0x08 /* Temperature */
#define SBS_GAUGE_CMD_VOLTAGE 0x09 /* Voltage */
#define SBS_GAUGE_CMD_CURRENT 0x0A /* Current */
#define SBS_GAUGE_CMD_AVG_CURRENT 0x0B /* AverageCurrent */
#define SBS_GAUGE_CMD_MAX_ERROR 0x0C /* MaxError */
#define SBS_GAUGE_CMD_RSOC 0x0D /* RelativeStateOfCharge */
#define SBS_GAUGE_CMD_ASOC 0x0E /* AbsoluteStateOfCharge */
#define SBS_GAUGE_CMD_REM_CAPACITY 0x0F /* RemainingCapacity */
#define SBS_GAUGE_CMD_FULL_CAPACITY 0x10 /* FullChargeCapacity */
#define SBS_GAUGE_CMD_RUNTIME2EMPTY 0x11 /* RunTimeToEmpty */
#define SBS_GAUGE_CMD_AVG_TIME2EMPTY 0x12 /* AverageTimeToEmpty */
#define SBS_GAUGE_CMD_AVG_TIME2FULL 0x13 /* AverageTimeToFull */
#define SBS_GAUGE_CMD_CHG_CURRENT 0x14 /* ChargeCurrent */
#define SBS_GAUGE_CMD_CHG_VOLTAGE 0x15 /* ChargeVoltage */
#define SBS_GAUGE_CMD_FLAGS 0x16 /* BatteryStatus */
#define SBS_GAUGE_CMD_CYCLE_COUNT 0x17 /* CycleCount */
#define SBS_GAUGE_CMD_NOM_CAPACITY 0x18 /* DesignCapacity */
#define SBS_GAUGE_CMD_DESIGN_VOLTAGE 0x19 /* DesignVoltage */
#define SBS_GAUGE_CMD_SPECS_INFO 0x1A /* SpecificationInfo */
#define SBS_GAUGE_CMD_MANUFACTURER_DATE 0x1B /* ManufacturerDate */
#define SBS_GAUGE_CMD_SN 0x1C /* SerialNumber */
#define SBS_GAUGE_CMD_MANUFACTURER_NAME 0x20 /* ManufacturerName */
#define SBS_GAUGE_CMD_DEVICE_NAME 0x21 /* DeviceName */
#define SBS_GAUGE_CMD_DEVICE_CHEM 0x22 /* DeviceChemistry */
#define SBS_GAUGE_CMD_MANUFACTURER_DATA 0x23 /* ManufacturerData */
#define SBS_GAUGE_CMD_DESIGN_MAX_POWER 0x24 /* DesignMaxPower */
#define SBS_GAUGE_CMD_START_TIME 0x25 /* StartTime */
#define SBS_GAUGE_CMD_TOTAL_RUNTIME 0x26 /* TotalRuntime */
#define SBS_GAUGE_CMD_FC_TEMP 0x27 /* FCTemp */
#define SBS_GAUGE_CMD_FC_STATUS 0x28 /* FCStatus */
#define SBS_GAUGE_CMD_FC_MODE 0x29 /* FCMode */
#define SBS_GAUGE_CMD_AUTO_SOFT_OFF 0x2A /* AutoSoftOff */
#define SBS_GAUGE_CMD_AUTHENTICATE 0x2F /* Authenticate */
#define SBS_GAUGE_CMD_CELL_V4 0x3C /* CellVoltage4 */
#define SBS_GAUGE_CMD_CELL_V3 0x3D /* CellVoltage3 */
#define SBS_GAUGE_CMD_CELL_V2 0x3E /* CellVoltage2 */
#define SBS_GAUGE_CMD_CELL_V1 0x3F /* CellVoltage1 */
#define SBS_GAUGE_DELAY 1000
struct sbs_gauge_data {
uint16_t voltage;
int16_t avg_current;
uint16_t state_of_charge;
uint16_t internal_temperature;
uint16_t full_charge_capacity;
uint16_t remaining_charge_capacity;
uint16_t nom_avail_capacity;
uint16_t full_avail_capacity;
uint16_t time_to_empty;
uint16_t time_to_full;
uint16_t cycle_count;
};
struct sbs_gauge_config {
struct i2c_dt_spec i2c;
};
#endif
``` | /content/code_sandbox/drivers/sensor/sbs_gauge/sbs_gauge.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,056 |
```unknown
config SBS_GAUGE
bool "Smart Battery Fuel Gauge"
default y
depends on DT_HAS_SBS_SBS_GAUGE_ENABLED
select I2C
help
Enable I2C-based/SMBus-based driver for a Smart Battery Fuel Gauge.
# Maintain access to emul_sbs_gauge.
source "drivers/fuel_gauge/sbs_gauge/Kconfig.emul_sbs_gauge"
``` | /content/code_sandbox/drivers/sensor/sbs_gauge/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 89 |
```c
/*
*
*/
#define DT_DRV_COMPAT sbs_sbs_gauge
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include "sbs_gauge.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(sbs_gauge, CONFIG_SENSOR_LOG_LEVEL);
static int sbs_cmd_reg_read(const struct device *dev,
uint8_t reg_addr,
uint16_t *val)
{
const struct sbs_gauge_config *cfg;
uint8_t i2c_data[2];
int status;
cfg = dev->config;
status = i2c_burst_read_dt(&cfg->i2c, reg_addr, i2c_data,
ARRAY_SIZE(i2c_data));
if (status < 0) {
LOG_ERR("Unable to read register");
return status;
}
*val = sys_get_le16(i2c_data);
return 0;
}
/**
* @brief sensor value get
*
* @return -ENOTSUP for unsupported channels
*/
static int sbs_gauge_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct sbs_gauge_data *data;
int32_t int_temp;
data = dev->data;
val->val2 = 0;
switch (chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
val->val1 = data->voltage / 1000;
val->val2 = (data->voltage % 1000) * 1000;
break;
case SENSOR_CHAN_GAUGE_AVG_CURRENT:
val->val1 = data->avg_current / 1000;
val->val2 = (data->avg_current % 1000) * 1000;
break;
case SENSOR_CHAN_GAUGE_TEMP:
int_temp = (data->internal_temperature * 10);
int_temp = int_temp - 27315;
val->val1 = int_temp / 100;
val->val2 = (int_temp % 100) * 1000000;
break;
case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
val->val1 = data->state_of_charge;
break;
case SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY:
val->val1 = data->full_charge_capacity;
break;
case SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY:
val->val1 = data->remaining_charge_capacity;
break;
case SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY:
val->val1 = data->nom_avail_capacity;
break;
case SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY:
val->val1 = data->full_avail_capacity;
break;
case SENSOR_CHAN_GAUGE_TIME_TO_EMPTY:
val->val1 = data->time_to_empty;
break;
case SENSOR_CHAN_GAUGE_TIME_TO_FULL:
val->val1 = data->time_to_full;
break;
case SENSOR_CHAN_GAUGE_CYCLE_COUNT:
val->val1 = data->cycle_count;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const uint16_t all_channels[] = {
SENSOR_CHAN_GAUGE_VOLTAGE,
SENSOR_CHAN_GAUGE_AVG_CURRENT,
SENSOR_CHAN_GAUGE_TEMP,
SENSOR_CHAN_GAUGE_STATE_OF_CHARGE,
SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY,
SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY,
SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY,
SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY,
SENSOR_CHAN_GAUGE_TIME_TO_EMPTY,
SENSOR_CHAN_GAUGE_TIME_TO_FULL,
SENSOR_CHAN_GAUGE_CYCLE_COUNT
};
static int sbs_gauge_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct sbs_gauge_data *data;
int status = 0;
data = dev->data;
switch (chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_VOLTAGE,
&data->voltage);
if (status < 0) {
LOG_ERR("Failed to read voltage");
}
break;
case SENSOR_CHAN_GAUGE_AVG_CURRENT:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_AVG_CURRENT,
&data->avg_current);
if (status < 0) {
LOG_ERR("Failed to read average current ");
}
break;
case SENSOR_CHAN_GAUGE_TEMP:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_TEMP,
&data->internal_temperature);
if (status < 0) {
LOG_ERR("Failed to read internal temperature");
}
break;
case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_ASOC,
&data->state_of_charge);
if (status < 0) {
LOG_ERR("Failed to read state of charge");
}
break;
case SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_FULL_CAPACITY,
&data->full_charge_capacity);
if (status < 0) {
LOG_ERR("Failed to read full charge capacity");
}
break;
case SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_REM_CAPACITY,
&data->remaining_charge_capacity);
if (status < 0) {
LOG_ERR("Failed to read remaining charge capacity");
}
break;
case SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_NOM_CAPACITY,
&data->nom_avail_capacity);
if (status < 0) {
LOG_ERR("Failed to read nominal available capacity");
}
break;
case SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_FULL_CAPACITY,
&data->full_avail_capacity);
if (status < 0) {
LOG_ERR("Failed to read full available capacity");
}
break;
case SENSOR_CHAN_GAUGE_TIME_TO_EMPTY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_AVG_TIME2EMPTY,
&data->time_to_empty);
data->time_to_empty = (data->time_to_empty) & 0x00FF;
if (status < 0) {
LOG_ERR("Failed to read time to empty");
}
break;
case SENSOR_CHAN_GAUGE_TIME_TO_FULL:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_AVG_TIME2FULL,
&data->time_to_full);
data->time_to_full = (data->time_to_full) & 0x00FF;
if (status < 0) {
LOG_ERR("Failed to read time to full");
}
break;
case SENSOR_CHAN_GAUGE_CYCLE_COUNT:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_CYCLE_COUNT,
&data->cycle_count);
data->cycle_count = (data->cycle_count) & 0x00FF;
if (status < 0) {
LOG_ERR("Failed to read cycle count");
}
break;
case SENSOR_CHAN_ALL:
for (int i = 0; i < ARRAY_SIZE(all_channels); i++) {
status = sbs_gauge_sample_fetch(dev, all_channels[i]);
if (status != 0) {
break;
}
}
break;
default:
return -ENOTSUP;
}
return status;
}
/**
* @brief initialize the fuel gauge
*
* @return 0 for success
*/
static int sbs_gauge_init(const struct device *dev)
{
const struct sbs_gauge_config *cfg;
cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
return 0;
}
static const struct sensor_driver_api sbs_gauge_driver_api = {
.sample_fetch = sbs_gauge_sample_fetch,
.channel_get = sbs_gauge_channel_get,
};
#define SBS_GAUGE_INIT(index) \
static struct sbs_gauge_data sbs_gauge_driver_##index; \
\
static const struct sbs_gauge_config sbs_gauge_config_##index = { \
.i2c = I2C_DT_SPEC_INST_GET(index), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(index, \
&sbs_gauge_init, \
NULL, \
&sbs_gauge_driver_##index, \
&sbs_gauge_config_##index, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&sbs_gauge_driver_api);
DT_INST_FOREACH_STATUS_OKAY(SBS_GAUGE_INIT)
``` | /content/code_sandbox/drivers/sensor/sbs_gauge/sbs_gauge.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,953 |
```unknown
# PMS7003 particulate matter sensor configuration options
config PMS7003
bool "PMS7003 particulate matter sensor"
default y
depends on DT_HAS_PLANTOWER_PMS7003_ENABLED
depends on SERIAL
help
Enable driver for pms7003 particulate matter sensor.
``` | /content/code_sandbox/drivers/sensor/pms7003/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 67 |
```c
/*
*
*/
#define DT_DRV_COMPAT plantower_pms7003
/* sensor pms7003.c - Driver for plantower PMS7003 sensor
* PMS7003 product: path_to_url
* PMS7003 spec: path_to_url
*/
#include <errno.h>
#include <zephyr/arch/cpu.h>
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <stdlib.h>
#include <string.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(PMS7003, CONFIG_SENSOR_LOG_LEVEL);
/* wait serial output with 1000ms timeout */
#define CFG_PMS7003_SERIAL_TIMEOUT 1000
struct pms7003_config {
const struct device *uart_dev;
};
struct pms7003_data {
uint16_t pm_1_0;
uint16_t pm_2_5;
uint16_t pm_10;
};
/**
* @brief wait for an array data from uart device with a timeout
*
* @param dev the uart device
* @param data the data array to be matched
* @param len the data array len
* @param timeout the timeout in milliseconds
* @return 0 if success; -ETIME if timeout
*/
static int uart_wait_for(const struct device *dev, uint8_t *data, int len,
int timeout)
{
int matched_size = 0;
int64_t timeout_time = k_uptime_get() + timeout;
while (1) {
uint8_t c;
if (k_uptime_get() > timeout_time) {
return -ETIME;
}
if (uart_poll_in(dev, &c) == 0) {
if (c == data[matched_size]) {
matched_size++;
if (matched_size == len) {
break;
}
} else if (c == data[0]) {
matched_size = 1;
} else {
matched_size = 0;
}
}
}
return 0;
}
/**
* @brief read bytes from uart
*
* @param data the data buffer
* @param len the data len
* @param timeout the timeout in milliseconds
* @return 0 if success; -ETIME if timeout
*/
static int uart_read_bytes(const struct device *dev, uint8_t *data, int len,
int timeout)
{
int read_size = 0;
int64_t timeout_time = k_uptime_get() + timeout;
while (1) {
uint8_t c;
if (k_uptime_get() > timeout_time) {
return -ETIME;
}
if (uart_poll_in(dev, &c) == 0) {
data[read_size++] = c;
if (read_size == len) {
break;
}
}
}
return 0;
}
static int pms7003_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct pms7003_data *drv_data = dev->data;
const struct pms7003_config *cfg = dev->config;
/* sample output */
/* 42 4D 00 1C 00 01 00 01 00 01 00 01 00 01 00 01 01 92
* 00 4E 00 03 00 00 00 00 00 00 71 00 02 06
*/
uint8_t pms7003_start_bytes[] = {0x42, 0x4d};
uint8_t pms7003_receive_buffer[30];
if (uart_wait_for(cfg->uart_dev, pms7003_start_bytes,
sizeof(pms7003_start_bytes),
CFG_PMS7003_SERIAL_TIMEOUT) < 0) {
LOG_WRN("waiting for start bytes is timeout");
return -ETIME;
}
if (uart_read_bytes(cfg->uart_dev, pms7003_receive_buffer, 30,
CFG_PMS7003_SERIAL_TIMEOUT) < 0) {
return -ETIME;
}
drv_data->pm_1_0 =
(pms7003_receive_buffer[8] << 8) + pms7003_receive_buffer[9];
drv_data->pm_2_5 =
(pms7003_receive_buffer[10] << 8) + pms7003_receive_buffer[11];
drv_data->pm_10 =
(pms7003_receive_buffer[12] << 8) + pms7003_receive_buffer[13];
LOG_DBG("pm1.0 = %d", drv_data->pm_1_0);
LOG_DBG("pm2.5 = %d", drv_data->pm_2_5);
LOG_DBG("pm10 = %d", drv_data->pm_10);
return 0;
}
static int pms7003_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct pms7003_data *drv_data = dev->data;
if (chan == SENSOR_CHAN_PM_1_0) {
val->val1 = drv_data->pm_1_0;
val->val2 = 0;
} else if (chan == SENSOR_CHAN_PM_2_5) {
val->val1 = drv_data->pm_2_5;
val->val2 = 0;
} else if (chan == SENSOR_CHAN_PM_10) {
val->val1 = drv_data->pm_10;
val->val2 = 0;
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api pms7003_api = {
.sample_fetch = &pms7003_sample_fetch,
.channel_get = &pms7003_channel_get,
};
static int pms7003_init(const struct device *dev)
{
const struct pms7003_config *cfg = dev->config;
if (!device_is_ready(cfg->uart_dev)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
return 0;
}
#define PMS7003_DEFINE(inst) \
static struct pms7003_data pms7003_data_##inst; \
\
static const struct pms7003_config pms7003_config_##inst = { \
.uart_dev = DEVICE_DT_GET(DT_INST_BUS(inst)), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, &pms7003_init, NULL, \
&pms7003_data_##inst, &pms7003_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &pms7003_api); \
DT_INST_FOREACH_STATUS_OKAY(PMS7003_DEFINE)
``` | /content/code_sandbox/drivers/sensor/pms7003/pms7003.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,477 |
```unknown
# LM75 temperature sensor config
config LM75
bool "LM75 Temperature Sensor"
default y
depends on DT_HAS_LM75_ENABLED
select I2C
help
Enable the driver for the LM75 digital temperature Sensor with 2-wire
interface.
if LM75
choice
prompt "Trigger mode"
default LM75_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config LM75_TRIGGER_NONE
bool "No trigger"
config LM75_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on $(dt_compat_any_has_prop,$(DT_COMPAT_LM75),int-gpios)
depends on GPIO
select LM75_TRIGGER
endchoice
config LM75_TRIGGER
bool
if LM75_TRIGGER
config LM75_TRIGGER_THREAD_STACK_SIZE
int "Stack size for the trigger workqueue thread"
default 512
help
Size of the stack used for the internal trigger workqueue thread.
config LM75_TRIGGER_THREAD_PRIO
int "Priority for the trigger workqueue thread"
default 0
help
Priority level for the internal trigger workqueue thread.
endif # LM75_TRIGGER
endif # LM75
``` | /content/code_sandbox/drivers/sensor/lm75/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 247 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include "apds9960.h"
extern struct apds9960_data apds9960_driver;
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(APDS9960, CONFIG_SENSOR_LOG_LEVEL);
void apds9960_work_cb(struct k_work *work)
{
struct apds9960_data *data = CONTAINER_OF(work,
struct apds9960_data,
work);
const struct device *dev = data->dev;
if (data->p_th_handler != NULL) {
data->p_th_handler(dev, data->p_th_trigger);
}
apds9960_setup_int(dev->config, true);
}
int apds9960_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct apds9960_config *config = dev->config;
if (chan == SENSOR_CHAN_PROX) {
if (attr == SENSOR_ATTR_UPPER_THRESH) {
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_PIHT_REG,
(uint8_t)val->val1)) {
return -EIO;
}
return 0;
}
if (attr == SENSOR_ATTR_LOWER_THRESH) {
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_PILT_REG,
(uint8_t)val->val1)) {
return -EIO;
}
return 0;
}
}
return -ENOTSUP;
}
int apds9960_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct apds9960_config *config = dev->config;
struct apds9960_data *data = dev->data;
apds9960_setup_int(dev->config, false);
switch (trig->type) {
case SENSOR_TRIG_THRESHOLD:
if (trig->chan == SENSOR_CHAN_PROX) {
data->p_th_handler = handler;
data->p_th_trigger = trig;
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PIEN,
APDS9960_ENABLE_PIEN)) {
return -EIO;
}
} else {
return -ENOTSUP;
}
break;
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
apds9960_setup_int(config, true);
if (gpio_pin_get_dt(&config->int_gpio) > 0) {
k_work_submit(&data->work);
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/apds9960/apds9960_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 638 |
```c
/*
*
*/
#define DT_DRV_COMPAT lm75
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/pm/device_runtime.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
LOG_MODULE_REGISTER(LM75, CONFIG_SENSOR_LOG_LEVEL);
/*
* Only compile in trigger support if enabled in Kconfig and at least one
* enabled lm75 devicetree node has the int-gpios property.
*/
#define LM75_TRIGGER_SUPPORT \
(CONFIG_LM75_TRIGGER && DT_ANY_INST_HAS_PROP_STATUS_OKAY(int_gpios))
/* LM75 registers */
#define LM75_REG_TEMP 0x00
#define LM75_REG_CONFIG 0x01
#define LM75_REG_T_HYST 0x02
#define LM75_REG_T_OS 0x03
struct lm75_data {
int16_t temp;
#if LM75_TRIGGER_SUPPORT
const struct device *dev;
struct k_work_q workq;
struct k_work work;
struct gpio_callback int_gpio_cb;
const struct sensor_trigger *trigger;
sensor_trigger_handler_t trigger_handler;
K_KERNEL_STACK_MEMBER(stack, CONFIG_LM75_TRIGGER_THREAD_STACK_SIZE);
#endif /* LM75_TRIGGER_SUPPORT */
};
/* LM75 configuration register bits */
union lm75_reg_config {
uint8_t reg;
struct {
uint8_t shutdown: 1;
uint8_t int_mode: 1;
uint8_t int_pol: 1;
uint8_t fault_queue: 2;
uint8_t reserved: 3;
} __packed;
};
struct lm75_config {
struct i2c_dt_spec i2c;
union lm75_reg_config config_dt;
#if LM75_TRIGGER_SUPPORT
struct gpio_dt_spec int_gpio;
#endif /* LM75_TRIGGER_SUPPORT */
};
static inline int lm75_reg_read(const struct device *dev, uint8_t reg, uint8_t *buf, uint32_t size)
{
const struct lm75_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->i2c, reg, buf, size);
}
static inline int lm75_reg_write(const struct device *dev, uint8_t reg, const uint8_t *buf,
uint32_t size)
{
const struct lm75_config *cfg = dev->config;
return i2c_burst_write_dt(&cfg->i2c, reg, buf, size);
}
static inline int lm75_temp_read(const struct device *dev, uint8_t reg, int16_t *value)
{
uint8_t buf[2];
int ret;
ret = lm75_reg_read(dev, reg, buf, sizeof(buf));
if (ret) {
LOG_ERR("Could not fetch temperature [%d]", ret);
return -EIO;
}
*value = sys_get_be16(buf);
return 0;
}
static int lm75_temp_write(const struct device *dev, uint8_t reg, int16_t value)
{
uint8_t buf[2];
sys_put_be16(value, buf);
return lm75_reg_write(dev, reg, buf, sizeof(buf));
}
static void lm75_sensor_value_to_temp(const struct sensor_value *val, int16_t *temp)
{
*temp = val->val1 * 10;
*temp += val->val2 / 100000U;
*temp = (*temp * 256) / 10;
}
static void lm75_temp_to_sensor_value(int16_t temp, struct sensor_value *val)
{
/* shift right by 7, multiply by 10 to get 0.1 and divide by 2 to get C */
temp = (temp / 128) * 10 / 2;
/* Integer part in degrees Celsius */
val->val1 = temp / 10;
/* Fractional part in micro degrees Celsius */
val->val2 = (temp - val->val1 * 10) * 100000U;
}
static int lm75_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
int16_t temp = 0;
uint8_t reg;
int err;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_ALERT:
reg = LM75_REG_T_OS;
break;
case SENSOR_ATTR_HYSTERESIS:
reg = LM75_REG_T_HYST;
break;
default:
return -ENOTSUP;
}
lm75_sensor_value_to_temp(val, &temp);
err = lm75_temp_write(dev, reg, temp);
if (err < 0) {
LOG_ERR("failed to write register 0x%02x (err %d)", reg, err);
return err;
}
return 0;
}
static int lm75_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
int16_t temp;
uint8_t reg;
int err;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_ALERT:
reg = LM75_REG_T_OS;
break;
case SENSOR_ATTR_HYSTERESIS:
reg = LM75_REG_T_HYST;
break;
default:
return -ENOTSUP;
}
err = lm75_temp_read(dev, reg, &temp);
if (err < 0) {
LOG_ERR("failed to read register 0x%02x (err %d)", reg, err);
return err;
}
lm75_temp_to_sensor_value(temp, val);
return 0;
}
#if LM75_TRIGGER_SUPPORT
static int lm75_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lm75_config *config = dev->config;
struct lm75_data *data = dev->data;
gpio_flags_t flags;
int err;
__ASSERT_NO_MSG(trig != NULL);
if (trig->type != SENSOR_TRIG_THRESHOLD || trig->chan != SENSOR_CHAN_AMBIENT_TEMP ||
config->int_gpio.port == NULL) {
return -ENOTSUP;
}
if (handler != NULL) {
flags = GPIO_INT_EDGE_TO_ACTIVE;
} else {
flags = GPIO_INT_DISABLE;
}
err = gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
if (err < 0) {
LOG_ERR("failed to configure INT GPIO IRQ (err %d)", err);
return err;
}
data->trigger = trig;
data->trigger_handler = handler;
return 0;
}
static void lm75_trigger_work_handler(struct k_work *item)
{
struct lm75_data *data = CONTAINER_OF(item, struct lm75_data, work);
sensor_trigger_handler_t handler = data->trigger_handler;
if (handler != NULL) {
handler(data->dev, (struct sensor_trigger *)data->trigger);
}
}
static void lm75_int_gpio_callback_handler(const struct device *port, struct gpio_callback *cb,
gpio_port_pins_t pins)
{
struct lm75_data *data = CONTAINER_OF(cb, struct lm75_data, int_gpio_cb);
ARG_UNUSED(port);
ARG_UNUSED(pins);
k_work_submit_to_queue(&data->workq, &data->work);
}
#endif /* LM75_TRIGGER_SUPPORT */
static inline int lm75_fetch_temp(const struct device *dev)
{
struct lm75_data *data = dev->data;
int16_t temp;
int ret;
ret = lm75_temp_read(dev, LM75_REG_TEMP, &temp);
if (ret) {
LOG_ERR("Could not fetch temperature [%d]", ret);
return -EIO;
}
data->temp = temp;
return 0;
}
static int lm75_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
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 (chan) {
case SENSOR_CHAN_ALL:
case SENSOR_CHAN_AMBIENT_TEMP:
ret = lm75_fetch_temp(dev);
break;
default:
ret = -ENOTSUP;
break;
}
return ret;
}
static int lm75_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct lm75_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_AMBIENT_TEMP:
lm75_temp_to_sensor_value(data->temp, val);
return 0;
default:
return -ENOTSUP;
}
}
static const struct sensor_driver_api lm75_driver_api = {
.attr_set = lm75_attr_set,
.attr_get = lm75_attr_get,
#if LM75_TRIGGER_SUPPORT
.trigger_set = lm75_trigger_set,
#endif /* LM75_TRIGGER_SUPPORT */
.sample_fetch = lm75_sample_fetch,
.channel_get = lm75_channel_get,
};
int lm75_init(const struct device *dev)
{
const struct lm75_config *cfg = dev->config;
int ret = 0;
#if LM75_TRIGGER_SUPPORT
struct lm75_data *data = dev->data;
#endif /* LM75_TRIGGER_SUPPORT */
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("I2C dev not ready");
return -ENODEV;
}
#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
ret = lm75_reg_write(dev, LM75_REG_CONFIG, &cfg->config_dt.reg, sizeof(cfg->config_dt.reg));
if (ret < 0) {
LOG_ERR("failed to write configuration (ret %d)", ret);
return ret;
}
#if LM75_TRIGGER_SUPPORT
/** Even if Trigger support is enabled, there may be multiple
* instances. This handles those who may not have Trigger support.
*/
if (cfg->int_gpio.port != NULL) {
data->dev = dev;
k_work_queue_start(&data->workq, data->stack, K_THREAD_STACK_SIZEOF(data->stack),
CONFIG_LM75_TRIGGER_THREAD_PRIO, NULL);
k_thread_name_set(&data->workq.thread, "lm75_trigger");
k_work_init(&data->work, lm75_trigger_work_handler);
if (!device_is_ready(cfg->int_gpio.port)) {
LOG_ERR("INT GPIO not ready");
return -EINVAL;
}
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("failed to configure INT GPIO (ret %d)", ret);
return ret;
}
gpio_init_callback(&data->int_gpio_cb, lm75_int_gpio_callback_handler,
BIT(cfg->int_gpio.pin));
ret = gpio_add_callback(cfg->int_gpio.port, &data->int_gpio_cb);
if (ret < 0) {
LOG_ERR("failed to add INT GPIO callback (ret %d)", ret);
return ret;
}
}
#endif /* LM75_TRIGGER_SUPPORT */
return ret;
}
#ifdef CONFIG_PM_DEVICE
static int lm75_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
#if LM75_TRIGGER_SUPPORT
#define LM75_INT_GPIO_INIT(n) .int_gpio = GPIO_DT_SPEC_INST_GET_OR(n, int_gpios, { 0 })
#else /* LM75_TRIGGER_SUPPORT */
#define LM75_INT_GPIO_INIT(n)
#endif /* ! LM75_TRIGGER_SUPPORT */
#define LM75_INST(inst) \
static struct lm75_data lm75_data_##inst; \
static const struct lm75_config lm75_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.config_dt = { \
.shutdown = 0, \
.int_mode = DT_INST_NODE_HAS_PROP(inst, int_gpios), \
.int_pol = DT_INST_PROP(inst, int_inverted), \
.fault_queue = 0, \
.reserved = 0, \
}, \
LM75_INT_GPIO_INIT(inst) \
}; \
PM_DEVICE_DT_INST_DEFINE(inst, lm75_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, lm75_init, PM_DEVICE_DT_INST_GET(inst), &lm75_data_##inst, \
&lm75_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &lm75_driver_api);
DT_INST_FOREACH_STATUS_OKAY(LM75_INST)
``` | /content/code_sandbox/drivers/sensor/lm75/lm75.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,814 |
```unknown
menuconfig APDS9960
bool "APDS9960 Sensor"
default y
depends on DT_HAS_AVAGO_APDS9960_ENABLED
select I2C
help
Enable driver for APDS9960 sensors.
if APDS9960
choice
prompt "Trigger mode"
default APDS9960_TRIGGER_NONE
help
Specify the type of triggering used by the driver.
config APDS9960_TRIGGER_NONE
bool "No trigger"
config APDS9960_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select APDS9960_TRIGGER
endchoice
config APDS9960_TRIGGER
bool
config APDS9960_ENABLE_ALS
bool "Ambient Light Sense"
default y
help
Enable Ambient Light Sense (ALS).
choice
prompt "Proximity Gain"
default APDS9960_PGAIN_4X
config APDS9960_PGAIN_1X
bool "1x"
config APDS9960_PGAIN_2X
bool "2x"
config APDS9960_PGAIN_4X
bool "4x"
config APDS9960_PGAIN_8X
bool "8x"
endchoice
choice
prompt "ALS and Color Gain"
default APDS9960_AGAIN_4X
config APDS9960_AGAIN_1X
bool "1x"
config APDS9960_AGAIN_4X
bool "4x"
config APDS9960_AGAIN_16X
bool "16x"
config APDS9960_AGAIN_64X
bool "64x"
endchoice
choice
prompt "Proximity Pulse Length"
default APDS9960_PPULSE_LENGTH_8US
config APDS9960_PPULSE_LENGTH_4US
bool "4us"
config APDS9960_PPULSE_LENGTH_8US
bool "8us"
config APDS9960_PPULSE_LENGTH_16US
bool "16us"
config APDS9960_PPULSE_LENGTH_32US
bool "32us"
endchoice
choice
prompt "Proximity LED boost current"
default APDS9960_PLED_BOOST_100PCT
config APDS9960_PLED_BOOST_300PCT
bool "300%"
config APDS9960_PLED_BOOST_200PCT
bool "200%"
config APDS9960_PLED_BOOST_150PCT
bool "150%"
config APDS9960_PLED_BOOST_100PCT
bool "100%"
endchoice
config APDS9960_PPULSE_COUNT
int "Proximity Pulse Count"
range 1 64
default 8
endif # APDS9960
``` | /content/code_sandbox/drivers/sensor/apds9960/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 571 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_APDS9960_APDS9960_H_
#define ZEPHYR_DRIVERS_SENSOR_APDS9960_APDS9960_H_
#include <zephyr/drivers/gpio.h>
#define APDS9960_ENABLE_REG 0x80
#define APDS9960_ENABLE_GEN BIT(6)
#define APDS9960_ENABLE_PIEN BIT(5)
#define APDS9960_ENABLE_AIEN BIT(4)
#define APDS9960_ENABLE_WEN BIT(3)
#define APDS9960_ENABLE_PEN BIT(2)
#define APDS9960_ENABLE_AEN BIT(1)
#define APDS9960_ENABLE_PON BIT(0)
#define APDS9960_ATIME_REG 0x81
#define APDS9960_WTIME_REG 0x83
#define APDS9960_INT_AILTL_REG 0x84
#define APDS9960_INT_AILTH_REG 0x85
#define APDS9960_INT_AIHTL_REG 0x86
#define APDS9960_INT_AIHTH_REG 0x87
#define APDS9960_PILT_REG 0x89
#define APDS9960_PIHT_REG 0x8B
#define APDS9960_PERS_REG 0x8C
#define APDS9960_PERS_PPERS (BIT(4) | BIT(5) | BIT(6) | BIT(7))
#define APDS9960_APERS_MASK (BIT(0) | BIT(1) | BIT(2) | BIT(3))
#define APDS9960_CONFIG1_REG 0x8D
#define APDS9960_CONFIG1_WLONG BIT(1)
#define APDS9960_PPULSE_REG 0x8E
#define APDS9960_PPULSE_LENGTH_4US 0
#define APDS9960_PPULSE_LENGTH_8US BIT(6)
#define APDS9960_PPULSE_LENGTH_16US BIT(7)
#define APDS9960_PPULSE_LENGTH_32US (BIT(7) | BIT(6))
#define APDS9960_CONTROL_REG 0x8F
#define APDS9960_CONTROL_LDRIVE (BIT(6) | BIT(7))
#define APDS9960_CONTROL_PGAIN (BIT(3) | BIT(2))
#define APDS9960_CONTROL_AGAIN (BIT(0) | BIT(1))
/* LED Drive values */
#define APDS9960_LED_DRIVE_100MA 0
#define APDS9960_LED_DRIVE_50MA BIT(6)
#define APDS9960_LED_DRIVE_25MA BIT(7)
#define APDS9960_LED_DRIVE_12_5MA (BIT(6) | BIT(7))
/* Proximity Gain (PGAIN) values */
#define APDS9960_PGAIN_1X 0
#define APDS9960_PGAIN_2X BIT(2)
#define APDS9960_PGAIN_4X BIT(3)
#define APDS9960_PGAIN_8X (BIT(2) | BIT(3))
/* ALS Gain (AGAIN) values */
#define APDS9960_AGAIN_1X 0
#define APDS9960_AGAIN_4X BIT(0)
#define APDS9960_AGAIN_16X BIT(1)
#define APDS9960_AGAIN_64X (BIT(0) | BIT(1))
#define APDS9960_CONFIG2_REG 0x90
#define APDS9960_CONFIG2_CPSIEN BIT(6)
#define APDS9960_CONFIG2_PSIEN BIT(7)
/* LED Boost values */
#define APDS9960_PLED_BOOST_100 0
#define APDS9960_PLED_BOOST_150 BIT(4)
#define APDS9960_PLED_BOOST_200 BIT(5)
#define APDS9960_PLED_BOOST_300 (BIT(5) | BIT(4))
#define APDS9960_ID_REG 0x92
/* Acceptable device IDs */
#define APDS9960_ID_1 0xAB
#define APDS9960_ID_2 0x9C
#define APDS9960_STATUS_REG 0x93
#define APDS9960_STATUS_CPSAT BIT(7)
#define APDS9960_STATUS_PGSAT BIT(6)
#define APDS9960_STATUS_PINT BIT(5)
#define APDS9960_STATUS_AINT BIT(4)
#define APDS9960_STATUS_GINT BIT(2)
#define APDS9960_STATUS_PVALID BIT(1)
#define APDS9960_STATUS_AVALID BIT(0)
#define APDS9960_CDATAL_REG 0x94
#define APDS9960_CDATAH_REG 0x95
#define APDS9960_RDATAL_REG 0x96
#define APDS9960_RDATAH_REG 0x97
#define APDS9960_GDATAL_REG 0x98
#define APDS9960_GDATAH_REG 0x99
#define APDS9960_BDATAL_REG 0x9A
#define APDS9960_BDATAH_REG 0x9B
#define APDS9960_PDATA_REG 0x9C
#define APDS9960_POFFSET_UR_REG 0x9D
#define APDS9960_POFFSET_DL_REG 0x9E
#define APDS9960_CONFIG3_REG 0x9F
#define APDS9960_CONFIG3_PCMP BIT(5)
#define APDS9960_CONFIG3_SAI BIT(4)
#define APDS9960_CONFIG3_PMSK_U BIT(3)
#define APDS9960_CONFIG3_PMSK_D BIT(2)
#define APDS9960_CONFIG3_PMSK_L BIT(1)
#define APDS9960_CONFIG3_PMSK_R BIT(0)
#define APDS9960_GPENTH_REG 0xA0
#define APDS9960_GEXTH_REG 0xA1
#define APDS9960_GCONFIG1_REG 0xA2
#define APDS9960_GCONFIG1_GFIFOTH (BIT(7) | BIT(6))
#define APDS9960_GCONFIG1_GEXMSK (BIT(5) | BIT(4) | BIT(3) | BIT(2))
#define APDS9960_GCONFIG1_GEXPERS (BIT(1) | BIT(0))
#define APDS9960_GCONFIG2_REG 0xA3
#define APDS9960_GCONFIG2_GGAIN (BIT(6) | BIT(5))
#define APDS9960_GCONFIG2_GLDRIVE (BIT(4) | BIT(3))
#define APDS9960_GCONFIG2_WTIME (BIT(2) | BIT(1) | BIT(0))
/* Gesture Gain (GGAIN) values */
#define APDS9960_GGAIN_1X 0
#define APDS9960_GGAIN_2X BIT(5)
#define APDS9960_GGAIN_4X BIT(6)
#define APDS9960_GGAIN_8X (BIT(6) | BIT(5))
/* Gesture LED Drive Strength values */
#define APDS9960_LED_GDRIVE_100MA 0
#define APDS9960_LED_GDRIVE_50MA BIT(3)
#define APDS9960_LED_GDRIVE_25MA BIT(4)
#define APDS9960_LED_GDRIVE_12_5MA (BIT(4) | BIT(3))
/* Gesture wait time values */
#define APDS9960_GWTIME_0MS 0
#define APDS9960_GWTIME_2_8MS 1
#define APDS9960_GWTIME_5_6MS 2
#define APDS9960_GWTIME_8_4MS 3
#define APDS9960_GWTIME_14_0MS 4
#define APDS9960_GWTIME_22_4MS 5
#define APDS9960_GWTIME_30_8MS 6
#define APDS9960_GWTIME_39_2MS 7
#define APDS9960_GOFFSET_U_REG 0xA4
#define APDS9960_GOFFSET_D_REG 0xA5
#define APDS9960_GOFFSET_L_REG 0xA7
#define APDS9960_GOFFSET_R_REG 0xA9
#define APDS9960_GPULSE_REG 0xA6
#define APDS9960_GPULSE_GPLEN (BIT(7) | BIT(6))
#define APDS9960_GPULSE_GPULSE (BIT(5) | BIT(4) | BIT(3) |\
BIT(2) | BIT(1) | BIT(0))
/* Gesture Pulse Length values */
#define APDS9960_GPLEN_0US 0
#define APDS9960_GPLEN_8US BIT(6)
#define APDS9960_GPLEN_16US BIT(7)
#define APDS9960_GPLEN_32US (BIT(7) | BIT(6))
#define APDS9960_GCONFIG3_REG 0xAA
#define APDS9960_GCONFIG3_GDIMS (BIT(1) | BIT(0))
/* Gesture Registers */
#define APDS9960_GCONFIG4_REG 0xAB
#define APDS9960_GCONFIG4_GFIFO_CLR BIT(2)
#define APDS9960_GCONFIG4_GIEN BIT(1)
#define APDS9960_GCONFIG4_GMODE BIT(0)
#define APDS9960_GFLVL_REG 0xAE
#define APDS9960_GSTATUS_REG 0xAF
#define APDS9960_GSTATUS_GFOV BIT(1)
#define APDS9960_GSTATUS_GVALID BIT(0)
#define APDS9960_IFORCE_REG 0xE4
#define APDS9960_PICLEAR_REG 0xE5
#define APDS9960_CICLEAR_REG 0xE6
#define APDS9960_AICLEAR_REG 0xE7
#define APDS9960_GFIFO_U_REG 0xFC
#define APDS9960_GFIFO_D_REG 0xFD
#define APDS9960_GFIFO_L_REG 0xFE
#define APDS9960_GFIFO_R_REG 0xFF
/* Default values */
#define APDS9960_DEFAULT_ATIME 219
#define APDS9960_DEFAULT_WTIME 255
#define APDS9960_DEFAULT_CONFIG1 0x60
#define APDS9960_DEFAULT_PERS BIT(4)
#define APDS9960_DEFAULT_CONFIG2 (BIT(6) | BIT(0))
#define APDS9960_DEFAULT_GESTURE_PPULSE 0x89
#define APDS9960_DEFAULT_POFFSET_UR 0
#define APDS9960_DEFAULT_POFFSET_DL 0
#define APDS9960_DEFAULT_LDRIVE APDS9960_LED_DRIVE_100MA
#ifdef CONFIG_APDS9960_TRIGGER
#define APDS9960_DEFAULT_PILT 0
#define APDS9960_DEFAULT_PIHT 50
#define APDS9960_DEFAULT_AILT 10
#define APDS9960_DEFAULT_AIHT 1000
#define APDS9960_DEFAULT_CONFIG3 0
#else
#define APDS9960_DEFAULT_PILT 0
#define APDS9960_DEFAULT_PIHT 1
#define APDS9960_DEFAULT_AILT 0xFFFF
#define APDS9960_DEFAULT_AIHT 0
#define APDS9960_DEFAULT_CONFIG3 APDS9960_CONFIG3_SAI
#endif
#define APDS9960_DEFAULT_GPENTH 40
#define APDS9960_DEFAULT_GEXTH 30
#define APDS9960_DEFAULT_GCONF1 0x40
#define APDS9960_DEFAULT_GGAIN APDS9960_GGAIN_4X
#define APDS9960_DEFAULT_GLDRIVE APDS9960_LED_DRIVE_100MA
#define APDS9960_DEFAULT_GWTIME APDS9960_GWTIME_2_8MS
#define APDS9960_DEFAULT_GOFFSET 0
#define APDS9960_DEFAULT_GPULSE 0xC9
#define APDS9960_DEFAULT_GCONF3 0
struct apds9960_config {
struct i2c_dt_spec i2c;
struct gpio_dt_spec int_gpio;
uint8_t pgain;
uint8_t again;
uint8_t ppcount;
uint8_t pled_boost;
};
struct apds9960_data {
struct gpio_callback gpio_cb;
struct k_work work;
const struct device *dev;
uint16_t sample_crgb[4];
uint8_t pdata;
#ifdef CONFIG_APDS9960_TRIGGER
sensor_trigger_handler_t p_th_handler;
const struct sensor_trigger *p_th_trigger;
#else
struct k_sem data_sem;
#endif
};
static inline void apds9960_setup_int(const struct apds9960_config *cfg,
bool enable)
{
unsigned int flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, flags);
}
#ifdef CONFIG_APDS9960_TRIGGER
void apds9960_work_cb(struct k_work *work);
int apds9960_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
int apds9960_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* CONFIG_APDS9960_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_APDS9960_APDS9960_H_*/
``` | /content/code_sandbox/drivers/sensor/apds9960/apds9960.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,016 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/ite/ite_tach_it8xxx2/Kconfig"
source "drivers/sensor/ite/ite_vcmp_it8xxx2/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/ite/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 58 |
```c
/*
*
*/
#define DT_DRV_COMPAT avago_apds9960
/* @file
* @brief driver for APDS9960 ALS/RGB/gesture/proximity sensor
*/
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <string.h>
#include <zephyr/logging/log.h>
#include "apds9960.h"
LOG_MODULE_REGISTER(APDS9960, CONFIG_SENSOR_LOG_LEVEL);
static void apds9960_handle_cb(struct apds9960_data *drv_data)
{
apds9960_setup_int(drv_data->dev->config, false);
#ifdef CONFIG_APDS9960_TRIGGER
k_work_submit(&drv_data->work);
#else
k_sem_give(&drv_data->data_sem);
#endif
}
static void apds9960_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct apds9960_data *drv_data =
CONTAINER_OF(cb, struct apds9960_data, gpio_cb);
apds9960_handle_cb(drv_data);
}
static int apds9960_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct apds9960_config *config = dev->config;
struct apds9960_data *data = dev->data;
uint8_t tmp;
if (chan != SENSOR_CHAN_ALL) {
LOG_ERR("Unsupported sensor channel");
return -ENOTSUP;
}
#ifndef CONFIG_APDS9960_TRIGGER
apds9960_setup_int(config, true);
#ifdef CONFIG_APDS9960_ENABLE_ALS
tmp = APDS9960_ENABLE_PON | APDS9960_ENABLE_AIEN;
#else
tmp = APDS9960_ENABLE_PON | APDS9960_ENABLE_PIEN;
#endif
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG, tmp, tmp)) {
LOG_ERR("Power on bit not set.");
return -EIO;
}
k_sem_take(&data->data_sem, K_FOREVER);
#endif
if (i2c_reg_read_byte_dt(&config->i2c,
APDS9960_STATUS_REG, &tmp)) {
return -EIO;
}
LOG_DBG("status: 0x%x", tmp);
if (tmp & APDS9960_STATUS_PINT) {
if (i2c_reg_read_byte_dt(&config->i2c,
APDS9960_PDATA_REG, &data->pdata)) {
return -EIO;
}
}
if (tmp & APDS9960_STATUS_AINT) {
if (i2c_burst_read_dt(&config->i2c,
APDS9960_CDATAL_REG,
(uint8_t *)&data->sample_crgb,
sizeof(data->sample_crgb))) {
return -EIO;
}
}
#ifndef CONFIG_APDS9960_TRIGGER
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON,
0)) {
return -EIO;
}
#endif
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_AICLEAR_REG, 0)) {
return -EIO;
}
return 0;
}
static int apds9960_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct apds9960_data *data = dev->data;
switch (chan) {
#ifdef CONFIG_APDS9960_ENABLE_ALS
case SENSOR_CHAN_LIGHT:
val->val1 = sys_le16_to_cpu(data->sample_crgb[0]);
val->val2 = 0;
break;
case SENSOR_CHAN_RED:
val->val1 = sys_le16_to_cpu(data->sample_crgb[1]);
val->val2 = 0;
break;
case SENSOR_CHAN_GREEN:
val->val1 = sys_le16_to_cpu(data->sample_crgb[2]);
val->val2 = 0;
break;
case SENSOR_CHAN_BLUE:
val->val1 = sys_le16_to_cpu(data->sample_crgb[3]);
val->val2 = 0;
break;
#endif
case SENSOR_CHAN_PROX:
val->val1 = data->pdata;
val->val2 = 0;
break;
default:
return -ENOTSUP;
}
return 0;
}
static int apds9960_proxy_setup(const struct device *dev)
{
const struct apds9960_config *config = dev->config;
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_POFFSET_UR_REG,
APDS9960_DEFAULT_POFFSET_UR)) {
LOG_ERR("Default offset UR not set ");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_POFFSET_DL_REG,
APDS9960_DEFAULT_POFFSET_DL)) {
LOG_ERR("Default offset DL not set ");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_PPULSE_REG,
config->ppcount)) {
LOG_ERR("Default pulse count not set ");
return -EIO;
}
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_CONTROL_REG,
APDS9960_CONTROL_LDRIVE,
APDS9960_DEFAULT_LDRIVE)) {
LOG_ERR("LED Drive Strength not set");
return -EIO;
}
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_CONFIG2_REG,
APDS9960_PLED_BOOST_300,
config->pled_boost)) {
LOG_ERR("LED Drive Strength not set");
return -EIO;
}
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_CONTROL_REG, APDS9960_CONTROL_PGAIN,
(config->pgain & APDS9960_PGAIN_8X))) {
LOG_ERR("Gain is not set");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_PILT_REG, APDS9960_DEFAULT_PILT)) {
LOG_ERR("Low threshold not set");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_PIHT_REG, APDS9960_DEFAULT_PIHT)) {
LOG_ERR("High threshold not set");
return -EIO;
}
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG, APDS9960_ENABLE_PEN,
APDS9960_ENABLE_PEN)) {
LOG_ERR("Proximity mode is not enabled");
return -EIO;
}
return 0;
}
#ifdef CONFIG_APDS9960_ENABLE_ALS
static int apds9960_ambient_setup(const struct device *dev)
{
const struct apds9960_config *config = dev->config;
uint16_t th;
/* ADC value */
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_ATIME_REG, APDS9960_DEFAULT_ATIME)) {
LOG_ERR("Default integration time not set for ADC");
return -EIO;
}
/* ALS Gain */
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_CONTROL_REG,
APDS9960_CONTROL_AGAIN,
(config->again & APDS9960_AGAIN_64X))) {
LOG_ERR("Ambient Gain is not set");
return -EIO;
}
th = sys_cpu_to_le16(APDS9960_DEFAULT_AILT);
if (i2c_burst_write_dt(&config->i2c,
APDS9960_INT_AILTL_REG,
(uint8_t *)&th, sizeof(th))) {
LOG_ERR("ALS low threshold not set");
return -EIO;
}
th = sys_cpu_to_le16(APDS9960_DEFAULT_AIHT);
if (i2c_burst_write_dt(&config->i2c,
APDS9960_INT_AIHTL_REG,
(uint8_t *)&th, sizeof(th))) {
LOG_ERR("ALS low threshold not set");
return -EIO;
}
/* Enable ALS */
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG, APDS9960_ENABLE_AEN,
APDS9960_ENABLE_AEN)) {
LOG_ERR("ALS is not enabled");
return -EIO;
}
return 0;
}
#endif
static int apds9960_sensor_setup(const struct device *dev)
{
const struct apds9960_config *config = dev->config;
uint8_t chip_id;
if (i2c_reg_read_byte_dt(&config->i2c,
APDS9960_ID_REG, &chip_id)) {
LOG_ERR("Failed reading chip id");
return -EIO;
}
if (!((chip_id == APDS9960_ID_1) || (chip_id == APDS9960_ID_2))) {
LOG_ERR("Invalid chip id 0x%x", chip_id);
return -EIO;
}
/* Disable all functions and interrupts */
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_ENABLE_REG, 0)) {
LOG_ERR("ENABLE register is not cleared");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_AICLEAR_REG, 0)) {
return -EIO;
}
/* Disable gesture interrupt */
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_GCONFIG4_REG, 0)) {
LOG_ERR("GCONFIG4 register is not cleared");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_WTIME_REG, APDS9960_DEFAULT_WTIME)) {
LOG_ERR("Default wait time not set");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_CONFIG1_REG,
APDS9960_DEFAULT_CONFIG1)) {
LOG_ERR("Default WLONG not set");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_CONFIG2_REG,
APDS9960_DEFAULT_CONFIG2)) {
LOG_ERR("Configuration Register Two not set");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_CONFIG3_REG,
APDS9960_DEFAULT_CONFIG3)) {
LOG_ERR("Configuration Register Three not set");
return -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_PERS_REG,
APDS9960_DEFAULT_PERS)) {
LOG_ERR("Interrupt persistence not set");
return -EIO;
}
if (apds9960_proxy_setup(dev)) {
LOG_ERR("Failed to setup proximity functionality");
return -EIO;
}
#ifdef CONFIG_APDS9960_ENABLE_ALS
if (apds9960_ambient_setup(dev)) {
LOG_ERR("Failed to setup ambient light functionality");
return -EIO;
}
#endif
return 0;
}
static int apds9960_init_interrupt(const struct device *dev)
{
const struct apds9960_config *config = dev->config;
struct apds9960_data *drv_data = dev->data;
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name,
config->int_gpio.port->name);
return -ENODEV;
}
gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT | config->int_gpio.dt_flags);
gpio_init_callback(&drv_data->gpio_cb,
apds9960_gpio_callback,
BIT(config->int_gpio.pin));
if (gpio_add_callback(config->int_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
drv_data->dev = dev;
#ifdef CONFIG_APDS9960_TRIGGER
drv_data->work.handler = apds9960_work_cb;
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON,
APDS9960_ENABLE_PON)) {
LOG_ERR("Power on bit not set.");
return -EIO;
}
#else
k_sem_init(&drv_data->data_sem, 0, K_SEM_MAX_LIMIT);
#endif
apds9960_setup_int(config, true);
if (gpio_pin_get_dt(&config->int_gpio) > 0) {
apds9960_handle_cb(drv_data);
}
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int apds9960_pm_action(const struct device *dev,
enum pm_device_action action)
{
const struct apds9960_config *config = dev->config;
int ret = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON,
APDS9960_ENABLE_PON)) {
ret = -EIO;
}
break;
case PM_DEVICE_ACTION_SUSPEND:
if (i2c_reg_update_byte_dt(&config->i2c,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON, 0)) {
ret = -EIO;
}
if (i2c_reg_write_byte_dt(&config->i2c,
APDS9960_AICLEAR_REG, 0)) {
ret = -EIO;
}
break;
default:
return -ENOTSUP;
}
return ret;
}
#endif
static int apds9960_init(const struct device *dev)
{
const struct apds9960_config *config = dev->config;
struct apds9960_data *data = dev->data;
/* Initialize time 5.7ms */
k_sleep(K_MSEC(6));
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -EINVAL;
}
(void)memset(data->sample_crgb, 0, sizeof(data->sample_crgb));
data->pdata = 0U;
if (apds9960_sensor_setup(dev) < 0) {
LOG_ERR("Failed to setup device!");
return -EIO;
}
if (apds9960_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt!");
return -EIO;
}
return 0;
}
static const struct sensor_driver_api apds9960_driver_api = {
.sample_fetch = &apds9960_sample_fetch,
.channel_get = &apds9960_channel_get,
#ifdef CONFIG_APDS9960_TRIGGER
.attr_set = apds9960_attr_set,
.trigger_set = apds9960_trigger_set,
#endif
};
static const struct apds9960_config apds9960_config = {
.i2c = I2C_DT_SPEC_INST_GET(0),
.int_gpio = GPIO_DT_SPEC_INST_GET(0, int_gpios),
#if CONFIG_APDS9960_PGAIN_8X
.pgain = APDS9960_PGAIN_8X,
#elif CONFIG_APDS9960_PGAIN_4X
.pgain = APDS9960_PGAIN_4X,
#elif CONFIG_APDS9960_PGAIN_2X
.pgain = APDS9960_PGAIN_2X,
#else
.pgain = APDS9960_PGAIN_1X,
#endif
#if CONFIG_APDS9960_AGAIN_64X
.again = APDS9960_AGAIN_64X,
#elif CONFIG_APDS9960_AGAIN_16X
.again = APDS9960_AGAIN_16X,
#elif CONFIG_APDS9960_AGAIN_4X
.again = APDS9960_AGAIN_4X,
#else
.again = APDS9960_AGAIN_1X,
#endif
#if CONFIG_APDS9960_PPULSE_LENGTH_32US
.ppcount = APDS9960_PPULSE_LENGTH_32US |
(CONFIG_APDS9960_PPULSE_COUNT - 1),
#elif CONFIG_APDS9960_PPULSE_LENGTH_16US
.ppcount = APDS9960_PPULSE_LENGTH_16US |
(CONFIG_APDS9960_PPULSE_COUNT - 1),
#elif CONFIG_APDS9960_PPULSE_LENGTH_8US
.ppcount = APDS9960_PPULSE_LENGTH_8US |
(CONFIG_APDS9960_PPULSE_COUNT - 1),
#else
.ppcount = APDS9960_PPULSE_LENGTH_4US |
(CONFIG_APDS9960_PPULSE_COUNT - 1),
#endif
#if CONFIG_APDS9960_PLED_BOOST_300PCT
.pled_boost = APDS9960_PLED_BOOST_300,
#elif CONFIG_APDS9960_PLED_BOOST_200PCT
.pled_boost = APDS9960_PLED_BOOST_200,
#elif CONFIG_APDS9960_PLED_BOOST_150PCT
.pled_boost = APDS9960_PLED_BOOST_150,
#else
.pled_boost = APDS9960_PLED_BOOST_100,
#endif
};
static struct apds9960_data apds9960_data;
PM_DEVICE_DT_INST_DEFINE(0, apds9960_pm_action);
SENSOR_DEVICE_DT_INST_DEFINE(0, apds9960_init,
PM_DEVICE_DT_INST_GET(0), &apds9960_data, &apds9960_config,
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &apds9960_driver_api);
``` | /content/code_sandbox/drivers/sensor/apds9960/apds9960.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,018 |
```unknown
# ITE tachometer sensor configuration options
config TACH_IT8XXX2
bool "ITE it8xxx2 Tachometer sensor"
default y
depends on DT_HAS_ITE_IT8XXX2_TACH_ENABLED
depends on SOC_IT8XXX2
help
Enable the ITE it8xxx2 tachometer sensor,
it8xxx2 supports two 16-bit tachometer sensor, each sensor has two
input channel and we can select one input from two channel.
``` | /content/code_sandbox/drivers/sensor/ite/ite_tach_it8xxx2/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 105 |
```unknown
# ITE Voltage Comparator driver configuration options
config VCMP_IT8XXX2
bool "ITE it8xxx2 Voltage Comparator"
default y
depends on DT_HAS_ITE_IT8XXX2_VCMP_ENABLED
depends on SOC_IT8XXX2 && ADC_ITE_IT8XXX2
help
This option enables the ITE it8xxx2 voltage comparator,
it8xxx2 supports six 10-bit resolution voltage comparator
channels, and the input of each comparator comes from ADC pin.
if VCMP_IT8XXX2
config VCMP_IT8XXX2_INIT_PRIORITY
int "ITE it8xxx2 voltage comparator device instance init priority"
default SENSOR_INIT_PRIORITY
help
This option sets ITE voltage comparator device instance init priority.
config VCMP_IT8XXX2_WORKQUEUE
bool "ITE it8xxx2 voltage comparator threshold detection uses internal work queue"
help
Threshold detection ISR utilizes system work queue for calling
trigger handlers; set this option to use dedicated work queue instead.
if VCMP_IT8XXX2_WORKQUEUE
config VCMP_IT8XXX2_WORKQUEUE_PRIORITY
int "ITE it8xxx2 voltage comparator threshold detection work queue priority"
default SYSTEM_WORKQUEUE_PRIORITY
help
This option sets internal ITE voltage comparator threshold detection
workqueue priority.
config VCMP_IT8XXX2_WORKQUEUE_STACK_SIZE
int "ITE it8xxx2 voltage comparator threshold detection work queue stack size"
default 768
help
This option sets internal ITE voltage comparator threshold detection
workqueue stack size.
endif # VCMP_IT8XXX2_WORKQUEUE
endif # VCMP_IT8XXX2
``` | /content/code_sandbox/drivers/sensor/ite/ite_vcmp_it8xxx2/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 340 |
```c
/*
*
*/
#define DT_DRV_COMPAT ite_it8xxx2_tach
/**
* @file
* @brief ITE it8xxx2 tachometer sensor module driver
*
* This file contains a driver for the tachometer sensor module which contains
* two independent counters (F1TL/MRR and F2TL/MRR). The content of the
* Tachometer Reading Register is still update based on the sampling counter
* that samples the tachometer input (T0A, T0B, T1A or T1B pins).
* The following is block diagram of this module:
*
* Sample Rate = TACH_FREQ / 128
* |
* | Tachometer 0 | T0A (GPD6)
* | | | +-----------+ |
* | +-----+-----+ | | _ _ |<--+
* |------>| F1TL/MRR |<-+-| | |_| |_ |<--+
* | +-----------+ +-----------+ |
* | capture pulses T0B (GPJ2)
* | in sample rate
* | period
* +-----------+ |
* Crystal-->| Prescaler |--->| Tachometer 1 T1A (GPD7)
* 32.768k +-----------+ | | +-----------+ |
* | +-----+-----+ | _ _ |<--+
* |------>| F2TL/MRR |<-+-| | |_| |_ |<--+
* | +-----------+ +-----------+ |
* | capture pulses T1B (GPJ3)
* | in one second
* | period
* |
*
* Based on the counter value, we can compute the current RPM of external signal
* from encoders.
*/
#include <zephyr/device.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/dt-bindings/sensor/it8xxx2_tach.h>
#include <errno.h>
#include <soc.h>
#include <soc_dt.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(tach_ite_it8xxx2, CONFIG_SENSOR_LOG_LEVEL);
/*
* NOTE: The PWM output maximum is 324Hz in EC LPM, so if we need fan to work
* then don't let EC enter LPM.
*/
#define TACH_FREQ EC_FREQ
struct tach_it8xxx2_config {
/* Fan x tachometer LSB reading register */
uintptr_t reg_fxtlrr;
/* Fan x tachometer MSB reading register */
uintptr_t reg_fxtmrr;
/* Tachometer switch control register */
uintptr_t reg_tswctlr;
/* Tachometer data valid bit of tswctlr register */
int dvs_bit;
/* Tachometer data valid status bit of tswctlr register */
int chsel_bit;
/* Tachometer alternate configuration */
const struct pinctrl_dev_config *pcfg;
/* Select channel of tachometer */
int channel;
/* Number of pulses per round of tachometer's input */
int pulses_per_round;
};
/* Driver data */
struct tach_it8xxx2_data {
/* Captured counts of tachometer */
uint32_t capture;
};
static bool tach_ch_is_valid(const struct device *dev, int tach_ch)
{
const struct tach_it8xxx2_config *const config = dev->config;
volatile uint8_t *reg_tswctlr = (uint8_t *)config->reg_tswctlr;
int dvs_bit = config->dvs_bit;
int chsel_bit = config->chsel_bit;
int mask = (dvs_bit | chsel_bit);
bool valid = false;
switch (tach_ch) {
case IT8XXX2_TACH_CHANNEL_A:
if ((*reg_tswctlr & mask) == dvs_bit) {
valid = true;
}
break;
case IT8XXX2_TACH_CHANNEL_B:
if ((*reg_tswctlr & mask) == mask) {
valid = true;
}
break;
default:
break;
}
return valid;
}
static int tach_it8xxx2_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
const struct tach_it8xxx2_config *const config = dev->config;
volatile uint8_t *reg_fxtlrr = (uint8_t *)config->reg_fxtlrr;
volatile uint8_t *reg_fxtmrr = (uint8_t *)config->reg_fxtmrr;
volatile uint8_t *reg_tswctlr = (uint8_t *)config->reg_tswctlr;
int tach_ch = config->channel;
struct tach_it8xxx2_data *const data = dev->data;
if ((chan != SENSOR_CHAN_RPM) && (chan != SENSOR_CHAN_ALL)) {
return -ENOTSUP;
}
if (tach_ch_is_valid(dev, tach_ch)) {
/* If channel data of tachometer is valid, then save it */
data->capture = ((*reg_fxtmrr) << 8) | (*reg_fxtlrr);
/* Clear tachometer data valid status */
*reg_tswctlr |= config->dvs_bit;
} else {
/* If channel data of tachometer isn't valid, then clear it */
data->capture = 0;
}
return 0;
}
static int tach_it8xxx2_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct tach_it8xxx2_config *const config = dev->config;
int tachx = ((config->dvs_bit) == IT8XXX2_PWM_T0DVS) ? 0 : 1;
int p = config->pulses_per_round;
struct tach_it8xxx2_data *const data = dev->data;
if (chan != SENSOR_CHAN_RPM) {
LOG_ERR("Sensor chan %d, only support SENSOR_CHAN_RPM", chan);
return -ENOTSUP;
}
/* Transform count unit to RPM */
if (data->capture > 0) {
if (tachx == 0) {
/*
* Fan Speed (RPM) = 60 / (1/fs * {F1TMRR, F1TLRR} * P)
* - P denotes the numbers of pulses per round
* - {F1TMRR, F1TLRR} = 0000h denotes Fan Speed is zero
* - The sampling rate (fs) is TACH_FREQ / 128
*/
val->val1 = (60 * TACH_FREQ / 128 / p / (data->capture));
} else {
/*
* Fan Speed (RPM) = {F2TMRR, F2TLRR} * 60 / P
* - P denotes the numbers of pulses per round
* - {F2TMRR, F2TLRR} = 0000h denotes Fan Speed is zero
*/
val->val1 = ((data->capture) * 120 / (p * 2));
}
} else {
val->val1 = 0U;
}
val->val2 = 0U;
return 0;
}
static int tach_it8xxx2_init(const struct device *dev)
{
const struct tach_it8xxx2_config *const config = dev->config;
volatile uint8_t *reg_tswctlr = (uint8_t *)config->reg_tswctlr;
int tach_ch = config->channel;
int status;
if (tach_ch > IT8XXX2_TACH_CHANNEL_B) {
LOG_ERR("Tach channel %d, only support 0 or 1", tach_ch);
return -EINVAL;
}
/* Select pin to alternate mode for tachometer */
status = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
if (status < 0) {
LOG_ERR("Failed to configure TACH pins");
return status;
}
if (tach_ch == IT8XXX2_TACH_CHANNEL_A) {
/* Select IT8XXX2_TACH_CHANNEL_A output to tachometer */
*reg_tswctlr &= ~(config->chsel_bit);
/* Clear tachometer data valid status */
*reg_tswctlr |= config->dvs_bit;
} else {
/* Select IT8XXX2_TACH_CHANNEL_B output to tachometer */
*reg_tswctlr |= config->chsel_bit;
/* Clear tachometer data valid status */
*reg_tswctlr |= config->dvs_bit;
}
/* Tachometer sensor already start */
return 0;
}
static const struct sensor_driver_api tach_it8xxx2_driver_api = {
.sample_fetch = tach_it8xxx2_sample_fetch,
.channel_get = tach_it8xxx2_channel_get,
};
#define TACH_IT8XXX2_INIT(inst) \
PINCTRL_DT_INST_DEFINE(inst); \
\
static const struct tach_it8xxx2_config tach_it8xxx2_cfg_##inst = { \
.reg_fxtlrr = DT_INST_REG_ADDR_BY_IDX(inst, 0), \
.reg_fxtmrr = DT_INST_REG_ADDR_BY_IDX(inst, 1), \
.reg_tswctlr = DT_INST_REG_ADDR_BY_IDX(inst, 2), \
.dvs_bit = DT_INST_PROP(inst, dvs_bit), \
.chsel_bit = DT_INST_PROP(inst, chsel_bit), \
.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \
.channel = DT_INST_PROP(inst, channel), \
.pulses_per_round = DT_INST_PROP(inst, pulses_per_round), \
}; \
\
static struct tach_it8xxx2_data tach_it8xxx2_data_##inst; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
tach_it8xxx2_init, \
NULL, \
&tach_it8xxx2_data_##inst, \
&tach_it8xxx2_cfg_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&tach_it8xxx2_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TACH_IT8XXX2_INIT)
``` | /content/code_sandbox/drivers/sensor/ite/ite_tach_it8xxx2/tach_ite_it8xxx2.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,304 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_TH02_TH02_H_
#define ZEPHYR_DRIVERS_SENSOR_TH02_TH02_H_
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
#define TH02_REG_STATUS 0x00
#define TH02_REG_DATA_H 0x01
#define TH02_REG_DATA_L 0x02
#define TH02_REG_CONFIG 0x03
#define TH02_REG_ID 0x11
#define TH02_STATUS_RDY_MASK 0x01
#define TH02_CMD_MEASURE_HUMI 0x01
#define TH02_CMD_MEASURE_TEMP 0x11
#define TH02_WR_REG_MODE 0xC0
#define TH02_RD_REG_MODE 0x80
struct th02_config {
struct i2c_dt_spec i2c;
};
struct th02_data {
uint16_t t_sample;
uint16_t rh_sample;
};
#endif /* _SENSOR_TH02_ */
``` | /content/code_sandbox/drivers/sensor/th02/th02.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 213 |
```c
/*
*
*/
#define DT_DRV_COMPAT hoperf_th02
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "th02.h"
LOG_MODULE_REGISTER(TH02, CONFIG_SENSOR_LOG_LEVEL);
static uint8_t read8(const struct i2c_dt_spec *i2c, uint8_t d)
{
uint8_t buf;
if (i2c_reg_read_byte_dt(i2c, d, &buf) < 0) {
LOG_ERR("Error reading register.");
}
return buf;
}
static int is_ready(const struct i2c_dt_spec *i2c)
{
uint8_t status;
if (i2c_reg_read_byte_dt(i2c, TH02_REG_STATUS, &status) < 0) {
LOG_ERR("error reading status register");
}
if (status & TH02_STATUS_RDY_MASK) {
return 0;
} else {
return 1;
}
}
static uint16_t get_humi(const struct i2c_dt_spec *i2c)
{
uint16_t humidity = 0U;
if (i2c_reg_write_byte_dt(i2c, TH02_REG_CONFIG, TH02_CMD_MEASURE_HUMI) < 0) {
LOG_ERR("Error writing register");
return 0;
}
while (!is_ready(i2c)) {
}
humidity = read8(i2c, TH02_REG_DATA_H) << 8;
humidity |= read8(i2c, TH02_REG_DATA_L);
humidity >>= 4;
return humidity;
}
uint16_t get_temp(const struct i2c_dt_spec *i2c)
{
uint16_t temperature = 0U;
if (i2c_reg_write_byte_dt(i2c, TH02_REG_CONFIG, TH02_CMD_MEASURE_TEMP) < 0) {
LOG_ERR("Error writing register");
return 0;
}
while (!is_ready(i2c)) {
}
temperature = read8(i2c, TH02_REG_DATA_H) << 8;
temperature |= read8(i2c, TH02_REG_DATA_L);
temperature >>= 2;
return temperature;
}
static int th02_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct th02_data *drv_data = dev->data;
const struct th02_config *cfg = dev->config;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_AMBIENT_TEMP);
drv_data->t_sample = get_temp(&cfg->i2c);
LOG_INF("temp: %u", drv_data->t_sample);
drv_data->rh_sample = get_humi(&cfg->i2c);
LOG_INF("rh: %u", drv_data->rh_sample);
return 0;
}
static int th02_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct th02_data *drv_data = dev->data;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_AMBIENT_TEMP ||
chan == SENSOR_CHAN_HUMIDITY);
if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
/* val = sample / 32 - 50 */
val->val1 = drv_data->t_sample / 32U - 50;
val->val2 = (drv_data->t_sample % 32) * (1000000 / 32);
} else if (chan == SENSOR_CHAN_HUMIDITY) {
/* val = sample / 16 -24 */
val->val1 = drv_data->rh_sample / 16U - 24;
val->val2 = (drv_data->rh_sample % 16) * (1000000 / 16);
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api th02_driver_api = {
.sample_fetch = th02_sample_fetch,
.channel_get = th02_channel_get,
};
static int th02_init(const struct device *dev)
{
const struct th02_config *cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
return 0;
}
#define TH02_DEFINE(inst) \
static struct th02_data th02_data_##inst; \
\
static const struct th02_config th02_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, th02_init, NULL, \
&th02_data_##inst, &th02_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &th02_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(TH02_DEFINE)
``` | /content/code_sandbox/drivers/sensor/th02/th02.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,093 |
```unknown
config TH02
bool "TH02 Temperature Sensor"
default y
depends on DT_HAS_HOPERF_TH02_ENABLED
select I2C
help
Enable driver for the TH02 temperature sensor.
``` | /content/code_sandbox/drivers/sensor/th02/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 45 |
```unknown
# Current sense amplifier driver
#
#
config CURRENT_AMP
bool "Current sense amplifier driver"
default y
depends on DT_HAS_CURRENT_SENSE_AMPLIFIER_ENABLED
select ADC
help
Enable current sense amplifier driver.
``` | /content/code_sandbox/drivers/sensor/current_amp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 49 |
```c
/*
*
*/
#define DT_DRV_COMPAT ite_it8xxx2_vcmp
#include <zephyr/device.h>
#include <zephyr/devicetree/io-channels.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/it8xxx2_vcmp.h>
#include <zephyr/dt-bindings/dt-util.h>
#include <zephyr/dt-bindings/sensor/it8xxx2_vcmp.h>
#include <errno.h>
#include <soc.h>
#include <soc_dt.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(vcmp_ite_it8xxx2, CONFIG_SENSOR_LOG_LEVEL);
#define VCMP_REG_MASK 0x7
#define VCMP_RESOLUTION BIT(10)
#ifdef CONFIG_ADC_IT8XXX2_VOL_FULL_SCALE
#define VCMP_MAX_MVOLT 3300
#else
#define VCMP_MAX_MVOLT 3000
#endif
/* Device config */
struct vcmp_it8xxx2_config {
/* Voltage comparator x control register */
volatile uint8_t *reg_vcmpxctl;
/* Voltage comparator x channel select MSB register */
volatile uint8_t *reg_vcmpxcselm;
/* Voltage comparator scan period register */
volatile uint8_t *reg_vcmpscp;
/* Voltage comparator x threshold data buffer MSB register */
volatile uint8_t *reg_vcmpxthrdatm;
/* Voltage comparator x threshold data buffer LSB register */
volatile uint8_t *reg_vcmpxthrdatl;
/* Voltage comparator status register */
volatile uint8_t *reg_vcmpsts;
/* Voltage comparator status 2 register */
volatile uint8_t *reg_vcmpsts2;
/* Voltage comparator module irq */
int irq;
/* Voltage comparator channel */
int vcmp_ch;
/* Scan period for "all voltage comparator channel" */
int scan_period;
/*
* Determines the condition between ADC data and threshold_mv
* that will trigger voltage comparator interrupt.
*/
int comparison;
/* Threshold assert value in mv */
int threshold_mv;
/* Pointer of ADC device that will be performing measurement */
const struct device *adc;
};
/* Driver data */
struct vcmp_it8xxx2_data {
/* ADC channel config */
struct adc_channel_cfg adc_ch_cfg;
/* Work queue to be notified when threshold assertion happens */
struct k_work work;
/* Sensor trigger hanlder to notify user of assetion */
sensor_trigger_handler_t handler;
const struct sensor_trigger *trig;
/* Pointer of voltage comparator device */
const struct device *vcmp;
};
/* Voltage comparator work queue address */
static uint32_t vcmp_work_addr[VCMP_CHANNEL_CNT];
#ifdef CONFIG_VCMP_IT8XXX2_WORKQUEUE
/*
* Pointer of work queue thread to be notified when threshold assertion
* occurs.
*/
struct k_work_q *work_q;
#endif
static void clear_vcmp_status(const struct device *dev, int vcmp_ch)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
volatile uint8_t *reg_vcmpsts = config->reg_vcmpsts;
volatile uint8_t *reg_vcmpsts2 = config->reg_vcmpsts2;
/* W/C voltage comparator specific channel interrupt status */
if (vcmp_ch <= VCMP_CHANNEL_2) {
*reg_vcmpsts = BIT(vcmp_ch);
} else {
*reg_vcmpsts2 = BIT(vcmp_ch - VCMP_CHANNEL_3);
}
}
static void vcmp_enable(const struct device *dev, int enable)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
volatile uint8_t *reg_vcmpxctl = config->reg_vcmpxctl;
if (enable) {
/* Enable voltage comparator specific channel interrupt */
*reg_vcmpxctl |= IT8XXX2_VCMP_CMPINTEN;
/* Start voltage comparator specific channel */
*reg_vcmpxctl |= IT8XXX2_VCMP_CMPEN;
} else {
/* Stop voltage comparator specific channel */
*reg_vcmpxctl &= ~IT8XXX2_VCMP_CMPEN;
/* Disable voltage comparator specific channel interrupt */
*reg_vcmpxctl &= ~IT8XXX2_VCMP_CMPINTEN;
}
}
static int vcmp_set_threshold(const struct device *dev,
enum sensor_attribute attr,
int32_t reg_val)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
volatile uint8_t *reg_vcmpxthrdatm = config->reg_vcmpxthrdatm;
volatile uint8_t *reg_vcmpxthrdatl = config->reg_vcmpxthrdatl;
volatile uint8_t *reg_vcmpxctl = config->reg_vcmpxctl;
if (reg_val >= VCMP_RESOLUTION) {
LOG_ERR("Vcmp%d threshold only support 10-bits", config->vcmp_ch);
return -ENOTSUP;
}
/* Set threshold raw value */
*reg_vcmpxthrdatl = (uint8_t)(reg_val & 0xff);
*reg_vcmpxthrdatm = (uint8_t)((reg_val >> 8) & 0xff);
/* Set lower or higher threshold */
if ((attr == SENSOR_ATTR_UPPER_THRESH) ||
(attr == (uint16_t) SENSOR_ATTR_UPPER_VOLTAGE_THRESH)) {
*reg_vcmpxctl |= IT8XXX2_VCMP_GREATER_THRESHOLD;
} else {
*reg_vcmpxctl &= ~IT8XXX2_VCMP_GREATER_THRESHOLD;
}
return 0;
}
static void it8xxx2_vcmp_trigger_work_handler(struct k_work *item)
{
struct vcmp_it8xxx2_data *data =
CONTAINER_OF(item, struct vcmp_it8xxx2_data, work);
if (data->handler) {
data->handler(data->vcmp, data->trig);
}
}
static int vcmp_ite_it8xxx2_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
int32_t reg_val, ret = 0;
if (chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
switch ((uint16_t)attr) {
case SENSOR_ATTR_LOWER_THRESH:
case SENSOR_ATTR_UPPER_THRESH:
ret = vcmp_set_threshold(dev, attr, val->val1);
break;
case SENSOR_ATTR_LOWER_VOLTAGE_THRESH:
case SENSOR_ATTR_UPPER_VOLTAGE_THRESH:
/*
* Tranfrom threshold from mv to raw
* NOTE: CMPXTHRDAT[9:0] = threshold(mv) * 1024 / 3000(mv)
*/
reg_val = (val->val1 * VCMP_RESOLUTION / VCMP_MAX_MVOLT);
ret = vcmp_set_threshold(dev, attr, reg_val);
break;
case SENSOR_ATTR_ALERT:
if (!!val->val1) {
clear_vcmp_status(dev, config->vcmp_ch);
vcmp_enable(dev, 1);
} else {
vcmp_enable(dev, 0);
clear_vcmp_status(dev, config->vcmp_ch);
}
break;
default:
ret = -ENOTSUP;
}
return ret;
}
static int vcmp_ite_it8xxx2_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
struct vcmp_it8xxx2_data *const data = dev->data;
if (trig->type != SENSOR_TRIG_THRESHOLD ||
trig->chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
data->handler = handler;
data->trig = trig;
vcmp_work_addr[config->vcmp_ch] = (uint32_t) &data->work;
return 0;
}
static int vcmp_it8xxx2_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
if (chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
/*
* It8xxx2 adc and comparator module read automatically, according to
* {ADCCTS1, ADCCTS2} and VCMPSCP register setting.
*/
val->val1 = config->vcmp_ch;
return 0;
}
/*
* All voltage comparator channels share one irq interrupt, so we
* need to handle all channels, when the interrupt fired.
*/
static void vcmp_it8xxx2_isr(const struct device *dev)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
volatile uint8_t *reg_vcmpsts = config->reg_vcmpsts;
volatile uint8_t *reg_vcmpsts2 = config->reg_vcmpsts2;
int idx, status;
/* Find out which voltage comparator triggered */
status = *reg_vcmpsts & VCMP_REG_MASK;
status |= (*reg_vcmpsts2 & VCMP_REG_MASK) << 3;
for (idx = VCMP_CHANNEL_0; idx < VCMP_CHANNEL_CNT; idx++) {
if (status & BIT(idx)) {
/* Call triggered channel callback function in work queue */
if (vcmp_work_addr[idx]) {
#ifdef CONFIG_VCMP_IT8XXX2_WORKQUEUE
k_work_submit_to_queue(work_q,
(struct k_work *) vcmp_work_addr[idx]);
#else
k_work_submit((struct k_work *) vcmp_work_addr[idx]);
#endif
}
/* W/C voltage comparator specific channel interrupt status */
clear_vcmp_status(dev, idx);
}
}
/* W/C voltage comparator irq interrupt status */
ite_intc_isr_clear(config->irq);
}
static int vcmp_it8xxx2_init(const struct device *dev)
{
const struct vcmp_it8xxx2_config *const config = dev->config;
struct vcmp_it8xxx2_data *const data = dev->data;
volatile uint8_t *reg_vcmpxctl = config->reg_vcmpxctl;
volatile uint8_t *reg_vcmpxcselm = config->reg_vcmpxcselm;
volatile uint8_t *reg_vcmpscp = config->reg_vcmpscp;
/* Disable voltage comparator specific channel before init */
vcmp_enable(dev, 0);
/*
* ADC channel signal output to voltage comparator,
* so we need to set ADC channel to alternate mode first.
*/
if (!device_is_ready(config->adc)) {
LOG_ERR("ADC device not ready");
return -ENODEV;
}
adc_channel_setup(config->adc, &data->adc_ch_cfg);
/* Select which ADC channel output voltage into comparator */
if (data->adc_ch_cfg.channel_id <= 7) {
/* ADC channel 0~7 map to value 0x0~0x7 */
*reg_vcmpxctl |= data->adc_ch_cfg.channel_id & VCMP_REG_MASK;
*reg_vcmpxcselm &= ~IT8XXX2_VCMP_VCMPXCSELM;
} else {
/* ADC channel 13~16 map to value 0x8~0xb */
*reg_vcmpxctl |= (data->adc_ch_cfg.channel_id - 5) & VCMP_REG_MASK;
*reg_vcmpxcselm |= IT8XXX2_VCMP_VCMPXCSELM;
}
/* Set minimum scan period for "all voltage comparator channel" */
if (*reg_vcmpscp > config->scan_period) {
*reg_vcmpscp = config->scan_period;
}
/* Data must keep device reference for worker handler */
data->vcmp = dev;
/* Init and set work item to enable notifications */
k_work_init(&data->work, it8xxx2_vcmp_trigger_work_handler);
vcmp_work_addr[config->vcmp_ch] = (uint32_t) &data->work;
/* Set threshold and comparison if set on device tree */
if ((config->threshold_mv != IT8XXX2_VCMP_UNDEFINED) &&
(config->comparison != IT8XXX2_VCMP_UNDEFINED)) {
enum sensor_attribute attr;
struct sensor_value val;
if (config->comparison == IT8XXX2_VCMP_LESS_OR_EQUAL) {
attr = SENSOR_ATTR_LOWER_VOLTAGE_THRESH;
} else {
attr = SENSOR_ATTR_UPPER_VOLTAGE_THRESH;
}
val.val1 = config->threshold_mv;
val.val2 = 0;
vcmp_ite_it8xxx2_attr_set(dev, SENSOR_CHAN_VOLTAGE, attr, &val);
}
/*
* All voltage comparator channels share one irq interrupt,
* so if the irq is enabled before, we needn't to enable again.
* And we will figure out the triggered channel in vcmp_it8xxx2_isr().
*/
if (!irq_is_enabled(config->irq)) {
ite_intc_isr_clear(config->irq);
irq_connect_dynamic(config->irq, 0,
(void (*)(const void *))vcmp_it8xxx2_isr,
(const void *)dev, 0);
irq_enable(config->irq);
}
return 0;
}
static const struct sensor_driver_api vcmp_ite_it8xxx2_api = {
.attr_set = vcmp_ite_it8xxx2_attr_set,
.trigger_set = vcmp_ite_it8xxx2_trigger_set,
.channel_get = vcmp_it8xxx2_channel_get,
};
#ifdef CONFIG_VCMP_IT8XXX2_WORKQUEUE
struct k_work_q vcmp_it8xxx2_work_q;
static K_KERNEL_STACK_DEFINE(vcmp_it8xxx2_work_q_stack,
CONFIG_VCMP_IT8XXX2_WORKQUEUE_STACK_SIZE);
static int vcmp_it8xxx2_init_work_q(void)
{
struct k_work_queue_config cfg = {
.name = "vcmp_work",
.no_yield = false,
};
k_work_queue_start(&vcmp_it8xxx2_work_q,
vcmp_it8xxx2_work_q_stack,
K_KERNEL_STACK_SIZEOF(vcmp_it8xxx2_work_q_stack),
CONFIG_VCMP_IT8XXX2_WORKQUEUE_PRIORITY, &cfg);
work_q = &vcmp_it8xxx2_work_q;
return 0;
}
SYS_INIT(vcmp_it8xxx2_init_work_q, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY);
#endif
#define VCMP_IT8XXX2_INIT(inst) \
static const struct vcmp_it8xxx2_config vcmp_it8xxx2_cfg_##inst = { \
.reg_vcmpxctl = (uint8_t *)DT_INST_REG_ADDR_BY_IDX(inst, 0), \
.reg_vcmpxcselm = (uint8_t *)DT_INST_REG_ADDR_BY_IDX(inst, 1), \
.reg_vcmpscp = (uint8_t *)DT_INST_REG_ADDR_BY_IDX(inst, 2), \
.reg_vcmpxthrdatm = (uint8_t *)DT_INST_REG_ADDR_BY_IDX(inst, 3), \
.reg_vcmpxthrdatl = (uint8_t *)DT_INST_REG_ADDR_BY_IDX(inst, 4), \
.reg_vcmpsts = (uint8_t *)DT_INST_REG_ADDR_BY_IDX(inst, 5), \
.reg_vcmpsts2 = (uint8_t *)DT_INST_REG_ADDR_BY_IDX(inst, 6), \
.irq = DT_INST_IRQN(inst), \
.vcmp_ch = DT_INST_PROP(inst, vcmp_ch), \
.scan_period = DT_INST_PROP(inst, scan_period), \
.comparison = DT_INST_PROP(inst, comparison), \
.threshold_mv = DT_INST_PROP(inst, threshold_mv), \
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(inst)), \
}; \
\
static struct vcmp_it8xxx2_data vcmp_it8xxx2_data_##inst = { \
.adc_ch_cfg.gain = ADC_GAIN_1, \
.adc_ch_cfg.reference = ADC_REF_INTERNAL, \
.adc_ch_cfg.acquisition_time = ADC_ACQ_TIME_DEFAULT, \
.adc_ch_cfg.channel_id = (uint8_t)DT_INST_IO_CHANNELS_INPUT(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
vcmp_it8xxx2_init, \
NULL, \
&vcmp_it8xxx2_data_##inst, \
&vcmp_it8xxx2_cfg_##inst, \
POST_KERNEL, \
CONFIG_VCMP_IT8XXX2_INIT_PRIORITY, \
&vcmp_ite_it8xxx2_api);
DT_INST_FOREACH_STATUS_OKAY(VCMP_IT8XXX2_INIT)
#ifdef CONFIG_VCMP_IT8XXX2_WORKQUEUE
BUILD_ASSERT(CONFIG_SENSOR_INIT_PRIORITY < CONFIG_VCMP_IT8XXX2_INIT_PRIORITY,
"CONFIG_SENSOR_INIT_PRIORITY must be less than CONFIG_VCMP_IT8XXX2_INIT_PRIORITY");
#endif
``` | /content/code_sandbox/drivers/sensor/ite/ite_vcmp_it8xxx2/vcmp_ite_it8xxx2.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,735 |
```c
/*
*
*/
#define DT_DRV_COMPAT current_sense_amplifier
#include <zephyr/drivers/adc.h>
#include <zephyr/drivers/adc/current_sense_amplifier.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(current_amp, CONFIG_SENSOR_LOG_LEVEL);
struct current_sense_amplifier_data {
struct adc_sequence sequence;
int16_t raw;
};
static int fetch(const struct device *dev, enum sensor_channel chan)
{
const struct current_sense_amplifier_dt_spec *config = dev->config;
struct current_sense_amplifier_data *data = dev->data;
int ret;
if ((chan != SENSOR_CHAN_CURRENT) && (chan != SENSOR_CHAN_ALL)) {
return -ENOTSUP;
}
ret = adc_read_dt(&config->port, &data->sequence);
if (ret != 0) {
LOG_ERR("adc_read: %d", ret);
}
return ret;
}
static int get(const struct device *dev, enum sensor_channel chan, struct sensor_value *val)
{
const struct current_sense_amplifier_dt_spec *config = dev->config;
struct current_sense_amplifier_data *data = dev->data;
int32_t raw_val = data->raw;
int32_t i_ma;
int ret;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_CURRENT) {
return -ENOTSUP;
}
ret = adc_raw_to_millivolts_dt(&config->port, &raw_val);
if (ret != 0) {
LOG_ERR("raw_to_mv: %d", ret);
return ret;
}
i_ma = raw_val;
current_sense_amplifier_scale_dt(config, &i_ma);
LOG_DBG("%d/%d, %dmV, current:%dmA", data->raw,
(1 << data->sequence.resolution) - 1, raw_val, i_ma);
val->val1 = i_ma / 1000;
val->val2 = (i_ma % 1000) * 1000;
return 0;
}
static const struct sensor_driver_api current_api = {
.sample_fetch = fetch,
.channel_get = get,
};
#ifdef CONFIG_PM_DEVICE
static int pm_action(const struct device *dev, enum pm_device_action action)
{
const struct current_sense_amplifier_dt_spec *config = dev->config;
int ret;
if (config->power_gpio.port == NULL) {
LOG_ERR("PM not supported");
return -ENOTSUP;
}
switch (action) {
case PM_DEVICE_ACTION_RESUME:
ret = gpio_pin_set_dt(&config->power_gpio, 1);
if (ret != 0) {
LOG_ERR("failed to set GPIO for PM resume");
return ret;
}
break;
case PM_DEVICE_ACTION_SUSPEND:
ret = gpio_pin_set_dt(&config->power_gpio, 0);
if (ret != 0) {
LOG_ERR("failed to set GPIO for PM suspend");
return ret;
}
break;
default:
return -ENOTSUP;
}
return 0;
}
#endif
static int current_init(const struct device *dev)
{
const struct current_sense_amplifier_dt_spec *config = dev->config;
struct current_sense_amplifier_data *data = dev->data;
int ret;
if (!adc_is_ready_dt(&config->port)) {
LOG_ERR("ADC is not ready");
return -ENODEV;
}
#ifdef CONFIG_PM_DEVICE
if (config->power_gpio.port != NULL) {
if (!gpio_is_ready_dt(&config->power_gpio)) {
LOG_ERR("Power GPIO is not ready");
return -ENODEV;
}
ret = gpio_pin_configure_dt(&config->power_gpio, GPIO_OUTPUT_ACTIVE);
if (ret != 0) {
LOG_ERR("failed to config GPIO: %d", ret);
return ret;
}
}
#endif
ret = adc_channel_setup_dt(&config->port);
if (ret != 0) {
LOG_ERR("setup: %d", ret);
return ret;
}
ret = adc_sequence_init_dt(&config->port, &data->sequence);
if (ret != 0) {
LOG_ERR("sequence init: %d", ret);
return ret;
}
data->sequence.buffer = &data->raw;
data->sequence.buffer_size = sizeof(data->raw);
return 0;
}
#define CURRENT_SENSE_AMPLIFIER_INIT(inst) \
static struct current_sense_amplifier_data current_amp_##inst##_data; \
\
static const struct current_sense_amplifier_dt_spec current_amp_##inst##_config = \
CURRENT_SENSE_AMPLIFIER_DT_SPEC_GET(DT_DRV_INST(inst)); \
\
PM_DEVICE_DT_INST_DEFINE(inst, pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, ¤t_init, PM_DEVICE_DT_INST_GET(inst), \
¤t_amp_##inst##_data, ¤t_amp_##inst##_config, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, ¤t_api);
DT_INST_FOREACH_STATUS_OKAY(CURRENT_SENSE_AMPLIFIER_INIT)
``` | /content/code_sandbox/drivers/sensor/current_amp/current_amp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,128 |
```unknown
config TSIC_XX6
bool "TSic xx6 driver"
default y
depends on DT_HAS_IST_TSIC_XX6_ENABLED
select PWM
select PWM_CAPTURE
help
Enable driver for TSic 206/306/316/506F/516/716.
``` | /content/code_sandbox/drivers/sensor/tsic_xx6/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 63 |
```c
/*
*
*/
#define DT_DRV_COMPAT ist_tsic_xx6
#include <zephyr/device.h>
#include <zephyr/drivers/pwm.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/atomic.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/util_macro.h>
LOG_MODULE_REGISTER(TSIC_XX6, CONFIG_SENSOR_LOG_LEVEL);
#define FRAME_BIT_PERIOD_US 125
enum {
FRAME_PARITIY_BIT_LSB,
FRAME_DATA_BIT_0,
FRAME_DATA_BIT_1,
FRAME_DATA_BIT_2,
FRAME_DATA_BIT_3,
FRAME_DATA_BIT_4,
FRAME_DATA_BIT_5,
FRAME_DATA_BIT_6,
FRAME_DATA_BIT_7,
FRAME_START_BIT_LSB,
/* Theres a single bit period between the two packets that is constant high. This bit will
* be part of the 2nd packet's start bit thus frame length is not affected.
*/
FRAME_PARITIY_BIT_MSB,
FRAME_DATA_BIT_8,
FRAME_DATA_BIT_9,
FRAME_DATA_BIT_10,
FRAME_DATA_BIT_11,
FRAME_DATA_BIT_12,
FRAME_DATA_BIT_13,
FRAME_ZERO_BIT_0,
FRAME_ZERO_BIT_1,
FRAME_START_BIT_MSB,
FRAME_READY_BIT,
FRAME_FLAGS,
};
struct tsic_xx6_config {
const struct pwm_dt_spec pwm;
const int8_t lower_temperature_limit;
const uint8_t higher_temperature_limit;
const uint8_t data_bits;
};
struct tsic_xx6_data {
uint64_t frame_cycles;
struct sensor_value val;
ATOMIC_DEFINE(frame, FRAME_FLAGS);
uint32_t buf;
uint8_t buf_index;
};
static inline void tsic_xx6_buf_reset(struct tsic_xx6_data *data)
{
data->buf_index = FRAME_START_BIT_MSB;
}
static inline bool tsic_xx6_is_buf_reset(struct tsic_xx6_data *data)
{
return data->buf_index == FRAME_START_BIT_MSB;
}
static inline bool tsic_xx6_is_data_line_idle(struct tsic_xx6_data *data, uint64_t period_cycles)
{
/* If the period is larger than two frames assume the data line has been idle */
return period_cycles > data->frame_cycles * 2;
}
static void tsic_xx6_pwm_callback(const struct device *dev, uint32_t channel,
uint32_t period_cycles, uint32_t pulse_cycles, int status,
void *user_data)
{
const struct device *tsic_xx6_dev = user_data;
const struct tsic_xx6_config *config = tsic_xx6_dev->config;
struct tsic_xx6_data *data = tsic_xx6_dev->data;
uint32_t low_cycles;
bool val;
if (dev != config->pwm.dev || channel != config->pwm.channel) {
return;
}
if (status != 0) {
LOG_ERR("callback failed: %d", status);
return;
}
if (!tsic_xx6_is_buf_reset(data) && tsic_xx6_is_data_line_idle(data, period_cycles)) {
LOG_ERR("unexpected data idle");
tsic_xx6_buf_reset(data);
}
/*
* Calculate low cycles: The sensor sends the pulse in the last part of the period. The PWM
* capture driver triggers on rising edge with normal polarity. Therefore only the low part
* of the frame bit is present.
*/
low_cycles = period_cycles - pulse_cycles;
/* 25 % duty cycle is 0, 75 % duty cycle is 1 */
val = low_cycles * 2 < data->frame_cycles;
WRITE_BIT(data->buf, data->buf_index, val);
if (data->buf_index > 0) {
--data->buf_index;
} else {
WRITE_BIT(data->buf, FRAME_READY_BIT, 1);
(void)atomic_set(data->frame, data->buf);
tsic_xx6_buf_reset(data);
}
}
static inline bool tsic_xx6_parity_check(uint8_t data, bool parity)
{
bool data_parity = false;
size_t i;
for (i = 0; i < 8; ++i) {
data_parity ^= FIELD_GET(BIT(i), data);
}
return (parity ^ data_parity) == 0;
}
static int tsic_xx6_get_data_bits(const struct tsic_xx6_config *config, uint16_t *data_bits,
uint32_t frame)
{
uint8_t frame_data_bit_high =
config->data_bits == 14 ? FRAME_DATA_BIT_13 : FRAME_DATA_BIT_10;
uint8_t data_msb = FIELD_GET(GENMASK(frame_data_bit_high, FRAME_DATA_BIT_8), frame);
uint8_t data_lsb = FIELD_GET(GENMASK(FRAME_DATA_BIT_7, FRAME_DATA_BIT_0), frame);
bool parity_msb = FIELD_GET(BIT(FRAME_PARITIY_BIT_MSB), frame);
bool parity_lsb = BIT(FRAME_PARITIY_BIT_LSB) & frame;
if (!tsic_xx6_parity_check(data_msb, parity_msb) ||
!tsic_xx6_parity_check(data_lsb, parity_lsb)) {
return -EIO;
}
*data_bits = data_msb << 8 | data_lsb;
return 0;
}
static void tsic_xx6_get_value(const struct tsic_xx6_config *config, struct tsic_xx6_data *data,
uint16_t data_bits)
{
int64_t tmp;
/* Apply the datasheet formula scaled to micro celcius */
tmp = data_bits * (config->higher_temperature_limit - config->lower_temperature_limit);
tmp = tmp * 1000000 / (BIT(config->data_bits) - 1);
tmp += (int64_t)config->lower_temperature_limit * 1000000;
data->val.val1 = tmp / 1000000;
data->val.val2 = tmp % 1000000;
}
static int tsic_xx6_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct tsic_xx6_config *config = dev->config;
struct tsic_xx6_data *data = dev->data;
uint32_t frame;
uint16_t data_bits;
int rc;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
frame = atomic_and(data->frame, ~BIT(FRAME_READY_BIT));
if (FIELD_GET(BIT(FRAME_READY_BIT), frame) == 0) {
return -EBUSY;
}
rc = tsic_xx6_get_data_bits(config, &data_bits, frame);
if (rc != 0) {
return rc;
}
tsic_xx6_get_value(config, data, data_bits);
return 0;
}
static int tsic_xx6_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct tsic_xx6_data *data = dev->data;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
return -ENOTSUP;
}
*val = data->val;
return 0;
}
static const struct sensor_driver_api tsic_xx6_driver_api = {.sample_fetch = tsic_xx6_sample_fetch,
.channel_get = tsic_xx6_channel_get};
static int tsic_xx6_get_frame_cycles(const struct tsic_xx6_config *config, uint64_t *frame_cycles)
{
uint64_t tmp;
int rc;
rc = pwm_get_cycles_per_sec(config->pwm.dev, config->pwm.channel, &tmp);
if (rc != 0) {
return rc;
}
if (u64_mul_overflow(tmp, FRAME_BIT_PERIOD_US, &tmp)) {
return -ERANGE;
}
*frame_cycles = tmp / USEC_PER_SEC;
return 0;
}
static int tsic_xx6_init(const struct device *dev)
{
const struct tsic_xx6_config *config = dev->config;
struct tsic_xx6_data *data = dev->data;
int rc;
if (!pwm_is_ready_dt(&config->pwm)) {
return -ENODEV;
}
rc = tsic_xx6_get_frame_cycles(config, &data->frame_cycles);
if (rc != 0) {
return rc;
}
rc = pwm_configure_capture(config->pwm.dev, config->pwm.channel,
config->pwm.flags | PWM_CAPTURE_TYPE_BOTH |
PWM_CAPTURE_MODE_CONTINUOUS,
tsic_xx6_pwm_callback, (void *)dev);
if (rc != 0) {
return rc;
}
tsic_xx6_buf_reset(data);
rc = pwm_enable_capture(config->pwm.dev, config->pwm.channel);
if (rc != 0) {
return rc;
}
return 0;
}
#define TSIC_XX6_DEVICE(n) \
\
static struct tsic_xx6_data tsic_xx6_data_##n; \
\
static const struct tsic_xx6_config tsic_xx6_config_##n = { \
.pwm = PWM_DT_SPEC_INST_GET(n), \
.lower_temperature_limit = (int8_t)DT_INST_PROP(n, lower_temperature_limit), \
.higher_temperature_limit = DT_INST_PROP(n, higher_temperature_limit), \
.data_bits = DT_INST_PROP(n, data_bits), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, &tsic_xx6_init, NULL, &tsic_xx6_data_##n, \
&tsic_xx6_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &tsic_xx6_driver_api);
DT_INST_FOREACH_STATUS_OKAY(TSIC_XX6_DEVICE)
``` | /content/code_sandbox/drivers/sensor/tsic_xx6/tsic_xx6.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,113 |
```unknown
# Voltage sensor driver
#
#
config VOLTAGE_DIVIDER
bool "Voltage sensor driver"
default y
depends on DT_HAS_VOLTAGE_DIVIDER_ENABLED
select ADC
help
Enable voltage sensor driver.
``` | /content/code_sandbox/drivers/sensor/voltage_divider/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 46 |
```c
/*
*
*/
#define DT_DRV_COMPAT voltage_divider
#include <zephyr/drivers/adc.h>
#include <zephyr/drivers/adc/voltage_divider.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(voltage, CONFIG_SENSOR_LOG_LEVEL);
struct voltage_config {
struct voltage_divider_dt_spec voltage;
struct gpio_dt_spec gpio_power;
};
struct voltage_data {
struct adc_sequence sequence;
uint16_t raw;
};
static int fetch(const struct device *dev, enum sensor_channel chan)
{
const struct voltage_config *config = dev->config;
struct voltage_data *data = dev->data;
int ret;
if ((chan != SENSOR_CHAN_VOLTAGE) && (chan != SENSOR_CHAN_ALL)) {
return -ENOTSUP;
}
ret = adc_read(config->voltage.port.dev, &data->sequence);
if (ret != 0) {
LOG_ERR("adc_read: %d", ret);
}
return ret;
}
static int get(const struct device *dev, enum sensor_channel chan, struct sensor_value *val)
{
const struct voltage_config *config = dev->config;
struct voltage_data *data = dev->data;
int32_t raw_val;
int32_t v_mv;
int ret;
__ASSERT_NO_MSG(val != NULL);
if (chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
if (config->voltage.port.channel_cfg.differential) {
raw_val = (int16_t)data->raw;
} else {
raw_val = data->raw;
}
ret = adc_raw_to_millivolts_dt(&config->voltage.port, &raw_val);
if (ret != 0) {
LOG_ERR("raw_to_mv: %d", ret);
return ret;
}
v_mv = raw_val;
/* Note if full_ohms is not specified then unscaled voltage is returned */
(void)voltage_divider_scale_dt(&config->voltage, &v_mv);
LOG_DBG("%d of %d, %dmV, voltage:%dmV", data->raw,
(1 << data->sequence.resolution) - 1, raw_val, v_mv);
val->val1 = v_mv / 1000;
val->val2 = (v_mv * 1000) % 1000000;
return ret;
}
static const struct sensor_driver_api voltage_api = {
.sample_fetch = fetch,
.channel_get = get,
};
static int pm_action(const struct device *dev, enum pm_device_action action)
{
const struct voltage_config *config = dev->config;
int ret = 0;
if (config->gpio_power.port == NULL) {
/* No work to do */
return 0;
}
switch (action) {
case PM_DEVICE_ACTION_TURN_ON:
ret = gpio_pin_configure_dt(&config->gpio_power, GPIO_OUTPUT_INACTIVE);
if (ret != 0) {
LOG_ERR("failed to configure GPIO for PM on");
}
break;
case PM_DEVICE_ACTION_RESUME:
ret = gpio_pin_set_dt(&config->gpio_power, 1);
if (ret != 0) {
LOG_ERR("failed to set GPIO for PM resume");
}
break;
#ifdef CONFIG_PM_DEVICE
case PM_DEVICE_ACTION_SUSPEND:
ret = gpio_pin_set_dt(&config->gpio_power, 0);
if (ret != 0) {
LOG_ERR("failed to set GPIO for PM suspend");
}
break;
case PM_DEVICE_ACTION_TURN_OFF:
break;
#endif /* CONFIG_PM_DEVICE */
default:
return -ENOTSUP;
}
return ret;
}
static int voltage_init(const struct device *dev)
{
const struct voltage_config *config = dev->config;
struct voltage_data *data = dev->data;
int ret;
if (!adc_is_ready_dt(&config->voltage.port)) {
LOG_ERR("ADC is not ready");
return -ENODEV;
}
if (config->gpio_power.port != NULL) {
if (!gpio_is_ready_dt(&config->gpio_power)) {
LOG_ERR("Power GPIO is not ready");
return -ENODEV;
}
}
ret = adc_channel_setup_dt(&config->voltage.port);
if (ret != 0) {
LOG_ERR("setup: %d", ret);
return ret;
}
ret = adc_sequence_init_dt(&config->voltage.port, &data->sequence);
if (ret != 0) {
LOG_ERR("sequence init: %d", ret);
return ret;
}
data->sequence.buffer = &data->raw;
data->sequence.buffer_size = sizeof(data->raw);
return pm_device_driver_init(dev, pm_action);
}
#define VOLTAGE_INIT(inst) \
static struct voltage_data voltage_##inst##_data; \
\
static const struct voltage_config voltage_##inst##_config = { \
.voltage = VOLTAGE_DIVIDER_DT_SPEC_GET(DT_DRV_INST(inst)), \
.gpio_power = GPIO_DT_SPEC_INST_GET_OR(inst, power_gpios, {0}), \
}; \
\
PM_DEVICE_DT_INST_DEFINE(inst, pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, &voltage_init, PM_DEVICE_DT_INST_GET(inst), \
&voltage_##inst##_data, &voltage_##inst##_config, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &voltage_api);
DT_INST_FOREACH_STATUS_OKAY(VOLTAGE_INIT)
``` | /content/code_sandbox/drivers/sensor/voltage_divider/voltage.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,191 |
```unknown
# IST8310 Geomagnetic sensor configuration options
config IST8310
bool "IST8310 I2C Geomagnetic Chip"
default y
depends on DT_HAS_ISENTEK_IST8310_ENABLED
select I2C
help
Enable driver for IST8310 I2C-based Geomagnetic sensor.
``` | /content/code_sandbox/drivers/sensor/ist8310/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```c
/*
*
*/
/*
* Bus-specific functionality for IST8310 accessed via I2C.
*/
#include "ist8310.h"
static int ist8310_bus_check_i2c(const union ist8310_bus *bus)
{
return i2c_is_ready_dt(&bus->i2c) ? 0 : -ENODEV;
}
static int ist8310_reg_read_i2c(const union ist8310_bus *bus, uint8_t start, uint8_t *buf, int size)
{
return i2c_burst_read_dt(&bus->i2c, start, buf, size);
}
static int ist8310_reg_write_i2c(const union ist8310_bus *bus, uint8_t reg, uint8_t val)
{
return i2c_reg_write_byte_dt(&bus->i2c, reg, val);
}
const struct ist8310_bus_io ist8310_bus_io_i2c = {
.check = ist8310_bus_check_i2c,
.read = ist8310_reg_read_i2c,
.write = ist8310_reg_write_i2c,
};
``` | /content/code_sandbox/drivers/sensor/ist8310/ist8310_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 230 |
```objective-c
/* ist8310.h - header file for IST8310 Geomagnetic sensor driver */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_IST8310_IST8310_H_
#define ZEPHYR_DRIVERS_SENSOR_IST8310_IST8310_H_
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/drivers/gpio.h>
#include <stdint.h>
#define DT_DRV_COMPAT isentek_ist8310
#define IST8310_BUS_I2C DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
union ist8310_bus {
struct i2c_dt_spec i2c;
};
typedef int (*ist8310_bus_check_fn)(const union ist8310_bus *bus);
typedef int (*ist8310_reg_read_fn)(const union ist8310_bus *bus,
uint8_t start, uint8_t *buf, int size);
typedef int (*ist8310_reg_write_fn)(const union ist8310_bus *bus,
uint8_t reg, uint8_t val);
struct ist8310_bus_io {
ist8310_bus_check_fn check;
ist8310_reg_read_fn read;
ist8310_reg_write_fn write;
};
extern const struct ist8310_bus_io ist8310_bus_io_i2c;
#define IST8310_WHO_AM_I 0x00
#define IST8310_WHO_AM_I_VALUE 0x10
#define IST8310_STATUS_REGISTER1 0x02
#define STAT1_DRDY 0x01
#define STAT1_DRO 0x02
#define IST8310_OUTPUT_VALUE_X_L 0x03
#define IST8310_OUTPUT_VALUE_X_H 0x04
#define IST8310_OUTPUT_VALUE_Y_L 0x05
#define IST8310_OUTPUT_VALUE_Y_H 0x06
#define IST8310_OUTPUT_VALUE_Z_L 0x07
#define IST8310_OUTPUT_VALUE_Z_H 0x08
#define IST8310_CONTROL_REGISTER1 0x0A
#define CTRL1_MODE_SINGLE 0x1
#define IST8310_CONTROL_REGISTER2 0x0B
#define CTRL2_SRST 0x01
#define IST8310_OUTPUT_VALUE_T_L 0x1C
#define IST8310_OUTPUT_VALUE_T_H 0x1D
#define IST8310_CONTROL_REGISTER3 0x0d
#define Z_16BIT 0x40
#define Y_16BIT 0x20
#define X_16BIT 0x10
#define IST8310_AVG_REGISTER 0x41
#define Y_16TIMES_SET 0x20
#define Y_16TIMES_CLEAR 0x18
#define XZ_16TIMES_SET 0x04
#define XZ_16TIMES_CLEAR 0x03
#define IST8310_PDCNTL_REGISTER 0x42
#define PULSE_NORMAL 0xC0
struct ist8310_config {
union ist8310_bus bus;
const struct ist8310_bus_io *bus_io;
};
struct ist8310_data {
struct k_sem sem;
int16_t sample_x, sample_y, sample_z;
};
int ist8310_reg_update_byte(const struct device *dev, uint8_t reg,
uint8_t mask, uint8_t value);
#endif /* __SENSOR_IST8310_H__ */
``` | /content/code_sandbox/drivers/sensor/ist8310/ist8310.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 805 |
```unknown
# zephyr-keep-sorted-start
source "drivers/sensor/nuvoton/nuvoton_adc_cmp_npcx/Kconfig"
source "drivers/sensor/nuvoton/nuvoton_tach_npcx/Kconfig"
# zephyr-keep-sorted-stop
``` | /content/code_sandbox/drivers/sensor/nuvoton/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 62 |
```c
/* ist8310.c - Driver for Isentek IST8310 Geomagnetic Sensor */
/*
*
*/
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include "ist8310.h"
LOG_MODULE_REGISTER(IST8310, CONFIG_SENSOR_LOG_LEVEL);
static inline int ist8310_bus_check(const struct device *dev)
{
const struct ist8310_config *cfg = dev->config;
return cfg->bus_io->check(&cfg->bus);
}
static inline int ist8310_reg_read(const struct device *dev, uint8_t start, uint8_t *buf, int size)
{
const struct ist8310_config *cfg = dev->config;
return cfg->bus_io->read(&cfg->bus, start, buf, size);
}
static inline int ist8310_reg_write(const struct device *dev, uint8_t reg, uint8_t val)
{
const struct ist8310_config *cfg = dev->config;
return cfg->bus_io->write(&cfg->bus, reg, val);
}
static int ist8310_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct ist8310_data *drv_data = dev->data;
uint8_t buff[6];
if (ist8310_reg_read(dev, IST8310_STATUS_REGISTER1, (uint8_t *)buff, 1) < 0) {
LOG_ERR("failed to read status register 1");
return -EIO;
}
if ((buff[0] & STAT1_DRDY) == 0) {
LOG_ERR("Data not ready");
if (ist8310_reg_write(dev, IST8310_CONTROL_REGISTER1, CTRL1_MODE_SINGLE) < 0) {
LOG_ERR("failed to set single");
return -EIO;
}
return -EIO;
}
if (ist8310_reg_read(dev, IST8310_OUTPUT_VALUE_X_L, (uint8_t *)buff, 6) < 0) {
LOG_ERR("failed to read mag values");
return -EIO;
}
drv_data->sample_x = (sys_le16_to_cpu(*(uint16_t *)&buff[0]));
drv_data->sample_y = (sys_le16_to_cpu(*(uint16_t *)&buff[2]));
drv_data->sample_z = (sys_le16_to_cpu(*(uint16_t *)&buff[4]));
if (ist8310_reg_write(dev, IST8310_CONTROL_REGISTER1, CTRL1_MODE_SINGLE) < 0) {
LOG_ERR("failed to set single");
return -EIO;
}
return 0;
}
static int ist8310_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct ist8310_data *drv_data = dev->data;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
sensor_value_from_float(val, drv_data->sample_x * (1.0f / 1320));
break;
case SENSOR_CHAN_MAGN_Y:
sensor_value_from_float(val, drv_data->sample_y * (1.0f / 1320));
break;
case SENSOR_CHAN_MAGN_Z:
sensor_value_from_float(val, drv_data->sample_z * (1.0f / 1320));
break;
case SENSOR_CHAN_MAGN_XYZ:
sensor_value_from_float(val, drv_data->sample_x * (1.0f / 1320));
sensor_value_from_float(val + 1, drv_data->sample_y * (1.0f / 1320));
sensor_value_from_float(val + 2, drv_data->sample_z * (1.0f / 1320));
break;
default:
return -EINVAL;
}
return 0;
}
static const struct sensor_driver_api ist8310_api_funcs = {
.sample_fetch = ist8310_sample_fetch,
.channel_get = ist8310_channel_get,
};
static int ist8310_init_chip(const struct device *dev)
{
uint8_t reg;
/* Read chip ID (can only be read in sleep mode)*/
if (ist8310_reg_read(dev, IST8310_WHO_AM_I, ®, 1) < 0) {
LOG_ERR("failed reading chip id");
return -EIO;
}
if (ist8310_reg_read(dev, IST8310_WHO_AM_I, ®, 1) < 0) {
LOG_ERR("failed reading chip id");
return -EIO;
}
if (ist8310_reg_read(dev, IST8310_WHO_AM_I, ®, 1) < 0) {
LOG_ERR("failed reading chip id");
return -EIO;
}
if (reg != IST8310_WHO_AM_I_VALUE) {
LOG_ERR("invalid chip id 0x%x", reg);
return -EIO;
}
if (ist8310_reg_read(dev, IST8310_CONTROL_REGISTER2, ®, 1) < 0) {
LOG_ERR("failed reading chip reg2");
return -EIO;
}
reg &= ~CTRL2_SRST;
if (ist8310_reg_write(dev, IST8310_CONTROL_REGISTER2, reg) < 0) {
LOG_ERR("failed to set REG2 to %d", reg);
return -EIO;
}
k_sleep(K_MSEC(3));
if (ist8310_reg_read(dev, IST8310_CONTROL_REGISTER3, ®, 1) < 0) {
LOG_ERR("failed reading chip reg3");
return -EIO;
}
reg |= X_16BIT | Y_16BIT | Z_16BIT;
if (ist8310_reg_write(dev, IST8310_CONTROL_REGISTER3, reg) < 0) {
LOG_ERR("failed to set REG3 to %d", reg);
return -EIO;
}
if (ist8310_reg_write(dev, IST8310_AVG_REGISTER, XZ_16TIMES_CLEAR | Y_16TIMES_CLEAR) < 0) {
LOG_ERR("failed to set AVG");
return -EIO;
}
if (ist8310_reg_write(dev, IST8310_AVG_REGISTER, XZ_16TIMES_SET | Y_16TIMES_SET) < 0) {
LOG_ERR("failed to set AVG");
return -EIO;
}
if (ist8310_reg_write(dev, IST8310_PDCNTL_REGISTER, PULSE_NORMAL) < 0) {
LOG_ERR("failed to set AVG");
return -EIO;
}
k_sleep(K_MSEC(3));
if (ist8310_reg_write(dev, IST8310_CONTROL_REGISTER1, CTRL1_MODE_SINGLE) < 0) {
LOG_ERR("failed to set single");
return -EIO;
}
return 0;
}
static int ist8310_init(const struct device *dev)
{
int err = 0;
err = ist8310_bus_check(dev);
if (err < 0) {
LOG_DBG("bus check failed: %d", err);
return err;
}
if (ist8310_init_chip(dev) < 0) {
LOG_ERR("failed to initialize chip");
return -EIO;
}
return 0;
}
/* Initializes a struct ist8310_config for an instance on an I2C bus. */
#define IST8310_CONFIG_I2C(inst) \
.bus.i2c = I2C_DT_SPEC_INST_GET(inst), .bus_io = &ist8310_bus_io_i2c,
#define IST8310_BUS_CFG(inst) \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), (IST8310_CONFIG_I2C(inst)), \
(IST8310_CONFIG_SPI(inst)))
/*
* Main instantiation macro, which selects the correct bus-specific
* instantiation macros for the instance.
*/
#define IST8310_DEFINE(inst) \
static struct ist8310_data ist8310_data_##inst; \
static const struct ist8310_config ist8310_config_##inst = {IST8310_BUS_CFG(inst)}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, ist8310_init, NULL, &ist8310_data_##inst, \
&ist8310_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &ist8310_api_funcs);
/* Create the struct device for every status "okay" node in the devicetree. */
DT_INST_FOREACH_STATUS_OKAY(IST8310_DEFINE)
``` | /content/code_sandbox/drivers/sensor/ist8310/ist8310.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,815 |
```unknown
# ADC CMP NPCX driver configuration options
if ADC_NPCX
config ADC_CMP_NPCX
bool "Nuvoton NPCX ADC threshold detection interruption"
default y
depends on DT_HAS_NUVOTON_ADC_CMP_ENABLED
help
This option enables threshold interruption using sensor
trigger API.
if ADC_CMP_NPCX
config ADC_CMP_NPCX_WORKQUEUE
bool "NPCX ADC threshold detection uses internal work queue"
help
Threshold detection ISR utilizes system work queue for calling
trigger handlers; set this option to use dedicated work queue instead.
if ADC_CMP_NPCX_WORKQUEUE
config ADC_CMP_NPCX_WORKQUEUE_PRIORITY
int "Nuvoton NPCX ADC trheshold detection work queue priority"
default SYSTEM_WORKQUEUE_PRIORITY
help
This option sets internal ADC NPCX threshold detection workqueue
priority.
config ADC_CMP_NPCX_WORKQUEUE_STACK_SIZE
int "Nuvoton NPCX ADC trheshold detection work queue stack size"
default 768
help
This option sets internal ADC NPCX threshold detection workqueue
stack size.
endif # ADC_CMP_NPCX_WORKQUEUE
endif # ADC_CMP_NPCX
endif # ADC_NPCX
``` | /content/code_sandbox/drivers/sensor/nuvoton/nuvoton_adc_cmp_npcx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 247 |
```c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/adc/adc_npcx_threshold.h>
#include <zephyr/drivers/sensor/adc_cmp_npcx.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(adc_cmp_npcx, CONFIG_SENSOR_LOG_LEVEL);
struct adc_cmp_npcx_data {
/* Work queue to be notified when threshold assertion happens */
struct k_work work;
/* Sensor trigger hanlder to notify user of assetion */
sensor_trigger_handler_t handler;
/* ADC NPCX driver reference */
const struct device *dev;
/* Driver user sensor trigger reference */
const struct sensor_trigger *trigger;
};
struct adc_cmp_npcx_config {
/*
* Pointer of ADC device that will be performing measurement, this
* must be provied by device tree.
*/
const struct device *adc;
/*
* ADC channel that will be used to measure signal, this must be
* provided by device tree.
*/
uint8_t chnsel;
/* Threshold selection number assigned during initialization */
uint8_t th_sel;
/* Threshold assert value in millivolts */
uint32_t thr_mv;
/*
* Condition to be met between measured signal and threshold assert
* value that will trigger event
*/
enum adc_cmp_npcx_comparison comparison;
};
#define DT_DRV_COMPAT nuvoton_adc_cmp
#define ADC_CMP_NPCX_UNDEFINED (-1)
static void adc_cmp_npcx_trigger_work_handler(struct k_work *item)
{
struct adc_cmp_npcx_data *data =
CONTAINER_OF(item, struct adc_cmp_npcx_data, work);
if (data->handler) {
data->handler(data->dev, data->trigger);
}
}
static int adc_cmp_npcx_init(const struct device *dev)
{
const struct adc_cmp_npcx_config *const config = dev->config;
struct adc_cmp_npcx_data *data = dev->data;
struct adc_npcx_threshold_param param;
int ret;
LOG_DBG("Initialize ADC CMP threshold selection (%d)", config->th_sel);
/* Data must keep device reference for worker handler*/
data->dev = dev;
/* Set ADC channel selection */
param.type = ADC_NPCX_THRESHOLD_PARAM_CHNSEL;
param.val = (uint32_t)config->chnsel;
ret = adc_npcx_threshold_ctrl_set_param(config->adc, config->th_sel,
¶m);
if (ret) {
goto init_error;
}
/* Init and set Worker queue to enable notifications */
k_work_init(&data->work, adc_cmp_npcx_trigger_work_handler);
param.type = ADC_NPCX_THRESHOLD_PARAM_WORK;
param.val = (uint32_t)&data->work;
ret = adc_npcx_threshold_ctrl_set_param(config->adc, config->th_sel,
¶m);
if (ret) {
goto init_error;
}
/* Set threshold value if set on device tree */
if (config->thr_mv != ADC_CMP_NPCX_UNDEFINED) {
param.type = ADC_NPCX_THRESHOLD_PARAM_THVAL;
/* Convert from millivolts to ADC raw register value */
ret = adc_npcx_threshold_mv_to_thrval(config->adc, config->thr_mv,
¶m.val);
if (ret) {
goto init_error;
}
ret = adc_npcx_threshold_ctrl_set_param(config->adc,
config->th_sel, ¶m);
if (ret) {
goto init_error;
}
}
/* Set threshold comparison if set on device tree */
if (config->comparison == ADC_CMP_NPCX_GREATER ||
config->comparison == ADC_CMP_NPCX_LESS_OR_EQUAL) {
param.type = ADC_NPCX_THRESHOLD_PARAM_L_H;
param.val =
config->comparison == ADC_CMP_NPCX_GREATER ?
ADC_NPCX_THRESHOLD_PARAM_L_H_HIGHER :
ADC_NPCX_THRESHOLD_PARAM_L_H_LOWER;
ret = adc_npcx_threshold_ctrl_set_param(config->adc,
config->th_sel, ¶m);
}
init_error:
if (ret) {
LOG_ERR("Error setting parameter %d - value %d",
(uint32_t)param.type, param.val);
}
return ret;
}
static int adc_cmp_npcx_set_threshold(const struct device *dev, bool is_upper,
bool is_mv, uint32_t value)
{
const struct adc_cmp_npcx_config *const config = dev->config;
struct adc_npcx_threshold_param param;
int ret;
param.type = ADC_NPCX_THRESHOLD_PARAM_THVAL;
if (is_mv) {
ret = adc_npcx_threshold_mv_to_thrval(config->adc, value, ¶m.val);
if (ret) {
return ret;
}
}
ret = adc_npcx_threshold_ctrl_set_param(config->adc,
config->th_sel, ¶m);
if (ret) {
return ret;
}
param.type = ADC_NPCX_THRESHOLD_PARAM_L_H;
param.val = is_upper ? ADC_NPCX_THRESHOLD_PARAM_L_H_HIGHER :
ADC_NPCX_THRESHOLD_PARAM_L_H_LOWER;
ret = adc_npcx_threshold_ctrl_set_param(config->adc,
config->th_sel, ¶m);
return ret;
}
static int adc_cmp_npcx_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct adc_cmp_npcx_config *const config = dev->config;
int ret;
if (chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
switch ((uint16_t)attr) {
case SENSOR_ATTR_LOWER_THRESH:
__fallthrough;
case SENSOR_ATTR_UPPER_THRESH:
__fallthrough;
case SENSOR_ATTR_LOWER_VOLTAGE_THRESH:
__fallthrough;
case SENSOR_ATTR_UPPER_VOLTAGE_THRESH:
ret = adc_cmp_npcx_set_threshold(dev,
/* Is upper? */
attr == SENSOR_ATTR_UPPER_THRESH ||
(uint16_t)attr == SENSOR_ATTR_UPPER_VOLTAGE_THRESH,
/* Is mV? */
(uint16_t)attr == SENSOR_ATTR_LOWER_VOLTAGE_THRESH ||
(uint16_t)attr == SENSOR_ATTR_UPPER_VOLTAGE_THRESH,
val->val1);
break;
case SENSOR_ATTR_ALERT:
ret = adc_npcx_threshold_ctrl_enable(config->adc,
config->th_sel, !!val->val1);
break;
default:
ret = -ENOTSUP;
}
return ret;
}
static int adc_cmp_npcx_attr_get(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
struct sensor_value *val)
{
return -ENOTSUP;
}
static int adc_cmp_npcx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct adc_cmp_npcx_config *const config = dev->config;
struct adc_cmp_npcx_data *data = dev->data;
struct adc_npcx_threshold_param param;
if (trig == NULL || handler == NULL) {
return -EINVAL;
}
if (trig->type != SENSOR_TRIG_THRESHOLD ||
trig->chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
data->handler = handler;
data->trigger = trig;
param.type = ADC_NPCX_THRESHOLD_PARAM_WORK;
param.val = (uint32_t)&data->work;
return adc_npcx_threshold_ctrl_set_param(config->adc, config->th_sel,
¶m);
}
static int adc_cmp_npcx_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
return -ENOTSUP;
}
static int adc_cmp_npcx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
return -ENOTSUP;
}
static const struct sensor_driver_api adc_cmp_npcx_api = {
.attr_set = adc_cmp_npcx_attr_set,
.attr_get = adc_cmp_npcx_attr_get,
.trigger_set = adc_cmp_npcx_trigger_set,
.sample_fetch = adc_cmp_npcx_sample_fetch,
.channel_get = adc_cmp_npcx_channel_get,
};
#define NPCX_ADC_CMP_INIT(inst) \
static struct adc_cmp_npcx_data adc_cmp_npcx_data_##inst; \
static const struct adc_cmp_npcx_config adc_cmp_npcx_config_##inst = { \
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(inst)), \
.chnsel = DT_INST_IO_CHANNELS_INPUT(inst), \
.th_sel = DT_INST_STRING_TOKEN_OR(inst, thr_sel, inst), \
.thr_mv = DT_INST_PROP_OR(inst, threshold_mv, \
ADC_CMP_NPCX_UNDEFINED), \
.comparison = DT_INST_STRING_TOKEN_OR(inst, \
comparison, ADC_CMP_NPCX_UNDEFINED) \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, adc_cmp_npcx_init, NULL, \
&adc_cmp_npcx_data_##inst, \
&adc_cmp_npcx_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&adc_cmp_npcx_api); \
BUILD_ASSERT(DT_INST_STRING_TOKEN_OR(inst, thr_sel, inst) < \
DT_PROP(DT_INST_IO_CHANNELS_CTLR(inst), threshold_count), \
"Exceed the number of threshold detectors adc supports");
DT_INST_FOREACH_STATUS_OKAY(NPCX_ADC_CMP_INIT)
``` | /content/code_sandbox/drivers/sensor/nuvoton/nuvoton_adc_cmp_npcx/adc_cmp_npcx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,011 |
```unknown
# NPCX tachometer sensor configuration options
config TACH_NPCX
bool "Nuvoton NPCX Tachometer sensor"
default y
depends on DT_HAS_NUVOTON_NPCX_TACH_ENABLED
depends on SOC_FAMILY_NPCX
help
Enable the "Nuvoton NPCX tachometer sensor.
``` | /content/code_sandbox/drivers/sensor/nuvoton/nuvoton_tach_npcx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 71 |
```unknown
config NCT75
bool "NCT75 temperature sensor"
default y
depends on DT_HAS_ONNN_NCT75_ENABLED
select I2C
help
Enable driver for the NCT75 temperature sensor.
``` | /content/code_sandbox/drivers/sensor/nct75/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 48 |
```c
/*
*
*/
#define DT_DRV_COMPAT onnn_nct75
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
LOG_MODULE_REGISTER(NCT75, CONFIG_SENSOR_LOG_LEVEL);
#define NCT75REGISTER_STOREDTEMPERATUREVALUE 0x00
#define NCT75REGISTER_CONFIGURATION 0x01
#define NCT75REGISTER_ONESHOT 0x04
#define NCT75_CONFIGURATION_ONESHOTMODE_POS 5
#define NCT75_TEMPERATURE_CONVERSION_TIME_US 48500
#define NCT75_TEMPERATURE_CONVERSION_WAIT_TIME_US (NCT75_TEMPERATURE_CONVERSION_TIME_US + 1000)
struct nct75_config {
struct i2c_dt_spec i2c;
};
struct nct75_data {
/* temperature in 1e-6 C */
int64_t value;
};
static int nct75_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct nct75_config *config = dev->config;
struct nct75_data *data = dev->data;
int result;
uint8_t write_buffer = 0;
uint16_t read_buffer;
int16_t raw_value;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
result = i2c_reg_write_byte_dt(&config->i2c, NCT75REGISTER_ONESHOT, 0);
if (result != 0) {
LOG_ERR("%s: unable to trigger temperature one shot measurement", dev->name);
return result;
}
k_sleep(K_USEC(NCT75_TEMPERATURE_CONVERSION_WAIT_TIME_US));
write_buffer = NCT75REGISTER_STOREDTEMPERATUREVALUE;
result = i2c_write_read_dt(&config->i2c, &write_buffer, sizeof(write_buffer), &read_buffer,
sizeof(read_buffer));
if (result != 0) {
LOG_ERR("%s: unable to read temperature", dev->name);
return result;
}
raw_value = arithmetic_shift_right(sys_be16_to_cpu(read_buffer), 4);
data->value = (raw_value * 1000 * 1000) * 100 / 0x640;
return 0;
}
static int nct75_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct nct75_data *data = dev->data;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
LOG_ERR("%s: requesting unsupported channel %i", dev->name, chan);
return -ENOTSUP;
}
val->val1 = data->value / (1000 * 1000);
val->val2 = data->value - val->val1 * 1000 * 1000;
return 0;
}
static const struct sensor_driver_api nct75_api = {
.sample_fetch = nct75_sample_fetch,
.channel_get = nct75_channel_get,
};
static int nct75_init(const struct device *dev)
{
const struct nct75_config *config = dev->config;
uint8_t configuration_register_value = BIT(NCT75_CONFIGURATION_ONESHOTMODE_POS);
int result;
if (!i2c_is_ready_dt(&config->i2c)) {
LOG_ERR("I2C device not ready");
return -ENODEV;
}
result = i2c_reg_write_byte_dt(&config->i2c, NCT75REGISTER_CONFIGURATION,
configuration_register_value);
if (result != 0) {
LOG_ERR("%s: unable to configure temperature sensor", dev->name);
return result;
}
return 0;
}
#define NCT75_INIT(inst) \
static const struct nct75_config nct75_##inst##_config = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
static struct nct75_data nct75_##inst##_data; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, nct75_init, NULL, &nct75_##inst##_data, \
&nct75_##inst##_config, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &nct75_api);
DT_INST_FOREACH_STATUS_OKAY(NCT75_INIT);
``` | /content/code_sandbox/drivers/sensor/nct75/nct75.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 921 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_MPU9250_AK8963_H_
#define ZEPHYR_DRIVERS_SENSOR_MPU9250_AK8963_H_
#include <stdint.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
int ak8963_convert_magn(struct sensor_value *val, int16_t raw_val,
int16_t scale, uint8_t st2);
int ak8963_init(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_MPU9250_AK8963_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/mpu9250/ak8963.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 125 |
```c
/*
*
*/
#define DT_DRV_COMPAT nuvoton_npcx_tach
/**
* @file
* @brief Nuvoton NPCX tachometer sensor module driver
*
* This file contains a driver for the tachometer sensor module which contains
* two independent timers (counter 1 and 2). They are used to capture a counter
* value when the signals via external pins match the condition. The following
* is block diagram of this module when it set to mode 5.
*
* | Capture A
* | | +-----------+ TA Pin
* +-----------+ | +-----+-----+ | _ _ | |
* APB_CLK-->| Prescaler |--->|---+--->| Counter 1 |<--| _| |_| |_ |<--+
* +-----------+ | | +-----------+ +-----------+
* | CLK_SEL Edge Detection
* | Capture B
* LFCLK--------------------->| | +-----------+ TB Pin
* | +-----+-----+ | _ _ | |
* |---+--->| Counter 2 |<--| _| |_| |_ |<--+
* | | +-----------+ +-----------+
* | CLK_SEL Edge Detection
* |
* | TACH_CLK
* +----------
* (NPCX Tachometer Mode 5, Dual-Independent Input Capture)
*
* This mode is used to measure either the frequency of two external clocks
* (via TA or TB pins) that are slower than TACH_CLK. A transition event (rising
* or falling edge) received on TAn/TBn pin causes a transfer of timer 1/2
* contents to Capture register and reload counter. Based on this value, we can
* compute the current RPM of external signal from encoders.
*/
#include <errno.h>
#include <zephyr/device.h>
#include <zephyr/drivers/clock_control.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/dt-bindings/sensor/npcx_tach.h>
#include <soc.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(tach_npcx, CONFIG_SENSOR_LOG_LEVEL);
/* Device config */
struct tach_npcx_config {
/* tachometer controller base address */
uintptr_t base;
/* clock configuration */
struct npcx_clk_cfg clk_cfg;
/* sampling clock frequency of tachometer */
uint32_t sample_clk;
/* selected port of tachometer */
int port;
/* number of pulses (holes) per round of tachometer's input (encoder) */
int pulses_per_round;
/* pinmux configuration */
const struct pinctrl_dev_config *pcfg;
};
/* Driver data */
struct tach_npcx_data {
/* Input clock for tachometers */
uint32_t input_clk;
/* Captured counts of tachometer */
uint32_t capture;
};
/* Driver convenience defines */
#define HAL_INSTANCE(dev) \
((struct tach_reg *)((const struct tach_npcx_config *)(dev)->config)->base)
/* Maximum count of prescaler */
#define NPCX_TACHO_PRSC_MAX 0xff
/* Maximum count of counter */
#define NPCX_TACHO_CNT_MAX 0xffff
/* Operation mode used for tachometer */
#define NPCX_TACH_MDSEL 4
/* Clock selection for tachometer */
#define NPCX_CLKSEL_APBCLK 1
#define NPCX_CLKSEL_LFCLK 4
/* TACH inline local functions */
static inline void tach_npcx_start_port_a(const struct device *dev)
{
struct tach_npcx_data *const data = dev->data;
struct tach_reg *const inst = HAL_INSTANCE(dev);
/* Set the default value of counter and capture register of timer 1. */
inst->TCNT1 = NPCX_TACHO_CNT_MAX;
inst->TCRA = NPCX_TACHO_CNT_MAX;
/*
* Set the edge detection polarity of port A to falling (high-to-low
* transition) and enable the functionality to capture TCNT1 into TCRA
* and preset TCNT1 when event is triggered.
*/
inst->TMCTRL |= BIT(NPCX_TMCTRL_TAEN);
/* Enable input debounce logic into TA pin. */
inst->TCFG |= BIT(NPCX_TCFG_TADBEN);
/* Select clock source of timer 1 from no clock and start to count. */
SET_FIELD(inst->TCKC, NPCX_TCKC_C1CSEL_FIELD, data->input_clk == LFCLK
? NPCX_CLKSEL_LFCLK : NPCX_CLKSEL_APBCLK);
}
static inline void tach_npcx_start_port_b(const struct device *dev)
{
struct tach_reg *const inst = HAL_INSTANCE(dev);
struct tach_npcx_data *const data = dev->data;
/* Set the default value of counter and capture register of timer 2. */
inst->TCNT2 = NPCX_TACHO_CNT_MAX;
inst->TCRB = NPCX_TACHO_CNT_MAX;
/*
* Set the edge detection polarity of port B to falling (high-to-low
* transition) and enable the functionality to capture TCNT2 into TCRB
* and preset TCNT2 when event is triggered.
*/
inst->TMCTRL |= BIT(NPCX_TMCTRL_TBEN);
/* Enable input debounce logic into TB pin. */
inst->TCFG |= BIT(NPCX_TCFG_TBDBEN);
/* Select clock source of timer 2 from no clock and start to count. */
SET_FIELD(inst->TCKC, NPCX_TCKC_C2CSEL_FIELD, data->input_clk == LFCLK
? NPCX_CLKSEL_LFCLK : NPCX_CLKSEL_APBCLK);
}
static inline bool tach_npcx_is_underflow(const struct device *dev)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_reg *const inst = HAL_INSTANCE(dev);
LOG_DBG("port A is underflow %d, port b is underflow %d",
IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TCPND),
IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TDPND));
/*
* In mode 5, the flag TCPND or TDPND indicates the TCNT1 or TCNT2
* is under underflow situation. (No edges are detected.)
*/
if (config->port == NPCX_TACH_PORT_A) {
return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TCPND);
} else {
return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TDPND);
}
}
static inline void tach_npcx_clear_underflow_flag(const struct device *dev)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_reg *const inst = HAL_INSTANCE(dev);
if (config->port == NPCX_TACH_PORT_A) {
inst->TECLR = BIT(NPCX_TECLR_TCCLR);
} else {
inst->TECLR = BIT(NPCX_TECLR_TDCLR);
}
}
static inline bool tach_npcx_is_captured(const struct device *dev)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_reg *const inst = HAL_INSTANCE(dev);
LOG_DBG("port A is captured %d, port b is captured %d",
IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND),
IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TBPND));
/*
* In mode 5, the flag TAPND or TBPND indicates a input captured on
* TAn or TBn transition.
*/
if (config->port == NPCX_TACH_PORT_A) {
return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND);
} else {
return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TBPND);
}
}
static inline void tach_npcx_clear_captured_flag(const struct device *dev)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_reg *const inst = HAL_INSTANCE(dev);
if (config->port == NPCX_TACH_PORT_A) {
inst->TECLR = BIT(NPCX_TECLR_TACLR);
} else {
inst->TECLR = BIT(NPCX_TECLR_TBCLR);
}
}
static inline uint16_t tach_npcx_get_captured_count(const struct device *dev)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_reg *const inst = HAL_INSTANCE(dev);
if (config->port == NPCX_TACH_PORT_A) {
return inst->TCRA;
} else {
return inst->TCRB;
}
}
/* TACH local functions */
static int tach_npcx_configure(const struct device *dev)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_npcx_data *const data = dev->data;
struct tach_reg *const inst = HAL_INSTANCE(dev);
/* Set mode 5 to tachometer module */
SET_FIELD(inst->TMCTRL, NPCX_TMCTRL_MDSEL_FIELD, NPCX_TACH_MDSEL);
/* Configure clock module and its frequency of tachometer */
if (config->sample_clk == 0) {
return -EINVAL;
} else if (data->input_clk == LFCLK) {
/* Enable low power mode */
inst->TCKC |= BIT(NPCX_TCKC_LOW_PWR);
if (config->sample_clk != data->input_clk) {
LOG_ERR("%s operate freq is %d not fixed to 32kHz",
dev->name, data->input_clk);
return -EINVAL;
}
} else {
/* Configure sampling freq by setting prescaler of APB1 */
uint16_t prescaler = data->input_clk / config->sample_clk;
if (data->input_clk > config->sample_clk) {
LOG_ERR("%s operate freq exceeds APB1 clock",
dev->name);
return -EINVAL;
}
inst->TPRSC = MIN(NPCX_TACHO_PRSC_MAX, MAX(prescaler, 1));
}
return 0;
}
/* TACH api functions */
int tach_npcx_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
ARG_UNUSED(chan);
struct tach_npcx_data *const data = dev->data;
/* Check whether underflow flag of tachometer is occurred */
if (tach_npcx_is_underflow(dev)) {
/* Clear pending flags */
tach_npcx_clear_underflow_flag(dev);
/* Clear stale captured data */
tach_npcx_clear_captured_flag(dev);
data->capture = 0;
return 0;
}
/* Check whether capture flag of tachometer is set */
if (tach_npcx_is_captured(dev)) {
/* Clear pending flags */
tach_npcx_clear_captured_flag(dev);
/* Save captured count */
data->capture = NPCX_TACHO_CNT_MAX -
tach_npcx_get_captured_count(dev);
}
return 0;
}
static int tach_npcx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_npcx_data *const data = dev->data;
if (chan != SENSOR_CHAN_RPM) {
return -ENOTSUP;
}
if (data->capture > 0) {
/*
* RPM = (f * 60) / (n * TACH)
* n = Pulses per round
* f = Tachometer operation frequency (Hz)
* TACH = Captured counts of tachometer
*/
val->val1 = (config->sample_clk * 60) /
(config->pulses_per_round * data->capture);
} else {
val->val1 = 0U;
}
val->val2 = 0U;
return 0;
}
/* TACH driver registration */
static int tach_npcx_init(const struct device *dev)
{
const struct tach_npcx_config *const config = dev->config;
struct tach_npcx_data *const data = dev->data;
const struct device *const clk_dev = DEVICE_DT_GET(NPCX_CLK_CTRL_NODE);
int ret;
if (!device_is_ready(clk_dev)) {
LOG_ERR("clock control device not ready");
return -ENODEV;
}
/* Turn on device clock first and get source clock freq. */
ret = clock_control_on(clk_dev, (clock_control_subsys_t)
&config->clk_cfg);
if (ret < 0) {
LOG_ERR("Turn on tachometer clock fail %d", ret);
return ret;
}
ret = clock_control_get_rate(clk_dev, (clock_control_subsys_t)
&config->clk_cfg, &data->input_clk);
if (ret < 0) {
LOG_ERR("Get tachometer clock rate error %d", ret);
return ret;
}
/* Configure pin-mux for tachometer device */
ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
if (ret < 0) {
LOG_ERR("Tacho pinctrl setup failed (%d)", ret);
return ret;
}
/* Configure tachometer and its operate freq. */
ret = tach_npcx_configure(dev);
if (ret < 0) {
LOG_ERR("Config tachometer port %d failed", config->port);
return ret;
}
/* Start tachometer sensor */
if (config->port == NPCX_TACH_PORT_A) {
tach_npcx_start_port_a(dev);
} else if (config->port == NPCX_TACH_PORT_B) {
tach_npcx_start_port_b(dev);
} else {
return -EINVAL;
}
return 0;
}
static const struct sensor_driver_api tach_npcx_driver_api = {
.sample_fetch = tach_npcx_sample_fetch,
.channel_get = tach_npcx_channel_get,
};
#define NPCX_TACH_INIT(inst) \
PINCTRL_DT_INST_DEFINE(inst); \
\
static const struct tach_npcx_config tach_cfg_##inst = { \
.base = DT_INST_REG_ADDR(inst), \
.clk_cfg = NPCX_DT_CLK_CFG_ITEM(inst), \
.sample_clk = DT_INST_PROP(inst, sample_clk), \
.port = DT_INST_PROP(inst, port), \
.pulses_per_round = DT_INST_PROP(inst, pulses_per_round), \
.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \
}; \
\
static struct tach_npcx_data tach_data_##inst; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
tach_npcx_init, \
NULL, \
&tach_data_##inst, \
&tach_cfg_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&tach_npcx_driver_api);
DT_INST_FOREACH_STATUS_OKAY(NPCX_TACH_INIT)
``` | /content/code_sandbox/drivers/sensor/nuvoton/nuvoton_tach_npcx/tach_nuvoton_npcx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,338 |
```c
/*
*
*/
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "mpu9250.h"
#include "ak8963.h"
LOG_MODULE_DECLARE(MPU9250, CONFIG_SENSOR_LOG_LEVEL);
#define I2C_READ_FLAG BIT(7)
#define AK8963_I2C_ADDR 0x0C
#define AK8963_REG_ID 0x00
#define AK8963_REG_ID_VAL 0x48
#define AK8963_REG_DATA 0x03
#define AK8963_ST2_OVRFL_BIT BIT(3)
#define AK8963_REG_CNTL1 0x0A
#define AK8963_REG_CNTL1_POWERDOWN_VAL 0x00
#define AK8963_REG_CNTL1_FUSE_ROM_VAL 0x0F
#define AK8963_REG_CNTL1_16BIT_100HZ_VAL 0x16
#define AK8963_SET_MODE_DELAY_MS 1
#define AK8963_REG_CNTL2 0x0B
#define AK8963_REG_CNTL2_RESET_VAL 0x01
#define AK8963_RESET_DELAY_MS 1
#define AK8963_REG_ADJ_DATA_X 0x10
#define AK8963_REG_ADJ_DATA_Y 0x11
#define AK8963_REG_ADJ_DATA_Z 0x12
#define AK9863_SCALE_TO_UG 1499
#define MPU9250_REG_I2C_MST_CTRL 0x24
#define MPU9250_REG_I2C_MST_CTRL_WAIT_MAG_400KHZ_VAL 0x4D
#define MPU9250_REG_I2C_SLV0_ADDR 0x25
#define MPU9250_REG_I2C_SLV0_REG 0x26
#define MPU9250_REG_I2C_SLV0_CTRL 0x27
#define MPU9250_REG_I2C_SLV0_DATA0 0x63
#define MPU9250_REG_READOUT_CTRL_VAL (BIT(7) | 0x07)
#define MPU9250_REG_USER_CTRL 0x6A
#define MPU9250_REG_USER_CTRL_I2C_MASTERMODE_VAL 0x20
#define MPU9250_REG_EXT_DATA00 0x49
#define MPU9250_REG_I2C_SLV4_ADDR 0x31
#define MPU9250_REG_I2C_SLV4_REG 0x32
#define MPU9250_REG_I2C_SLV4_DO 0x33
#define MPU9250_REG_I2C_SLV4_CTRL 0x34
#define MPU9250_REG_I2C_SLV4_CTRL_VAL 0x80
#define MPU9250_REG_I2C_SLV4_DI 0x35
#define MPU9250_I2C_MST_STS 0x36
#define MPU9250_I2C_MST_STS_SLV4_DONE BIT(6)
int ak8963_convert_magn(struct sensor_value *val, int16_t raw_val,
int16_t scale, uint8_t st2)
{
/* The sensor device returns 10^-9 Teslas after scaling.
* Scale adjusts for calibration data and units
* So sensor instance returns Gauss units
*/
/* If overflow happens then value is invalid */
if ((st2 & AK8963_ST2_OVRFL_BIT) != 0) {
LOG_INF("Magnetometer value overflow.");
return -EOVERFLOW;
}
int32_t scaled_val = (int32_t)raw_val * (int32_t)scale;
val->val1 = scaled_val / 1000000;
val->val2 = scaled_val % 1000000;
return 0;
}
static int ak8963_execute_rw(const struct device *dev, uint8_t reg, bool write)
{
/* Instruct the MPU9250 to access over its external i2c bus
* given device register with given details
*/
const struct mpu9250_config *cfg = dev->config;
uint8_t mode_bit = 0x00;
uint8_t status;
int ret;
if (!write) {
mode_bit = I2C_READ_FLAG;
}
/* Set target i2c address */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV4_ADDR,
AK8963_I2C_ADDR | mode_bit);
if (ret < 0) {
LOG_ERR("Failed to write i2c target slave address.");
return ret;
}
/* Set target i2c register */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV4_REG,
reg);
if (ret < 0) {
LOG_ERR("Failed to write i2c target slave register.");
return ret;
}
/* Initiate transfer */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV4_CTRL,
MPU9250_REG_I2C_SLV4_CTRL_VAL);
if (ret < 0) {
LOG_ERR("Failed to initiate i2c slave transfer.");
return ret;
}
/* Wait for a transfer to be ready */
do {
ret = i2c_reg_read_byte_dt(&cfg->i2c,
MPU9250_I2C_MST_STS, &status);
if (ret < 0) {
LOG_ERR("Waiting for slave failed.");
return ret;
}
} while (!(status & MPU9250_I2C_MST_STS_SLV4_DONE));
return 0;
}
static int ak8963_read_reg(const struct device *dev, uint8_t reg, uint8_t *data)
{
const struct mpu9250_config *cfg = dev->config;
int ret;
/* Execute transfer */
ret = ak8963_execute_rw(dev, reg, false);
if (ret < 0) {
LOG_ERR("Failed to prepare transfer.");
return ret;
}
/* Read the result */
ret = i2c_reg_read_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV4_DI, data);
if (ret < 0) {
LOG_ERR("Failed to read data from slave.");
return ret;
}
return 0;
}
static int ak8963_write_reg(const struct device *dev, uint8_t reg, uint8_t data)
{
const struct mpu9250_config *cfg = dev->config;
int ret;
/* Set the data to write */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV4_DO, data);
if (ret < 0) {
LOG_ERR("Failed to write data to slave.");
return ret;
}
/* Execute transfer */
ret = ak8963_execute_rw(dev, reg, true);
if (ret < 0) {
LOG_ERR("Failed to transfer write to slave.");
return ret;
}
return 0;
}
static int ak8963_set_mode(const struct device *dev, uint8_t mode)
{
int ret;
ret = ak8963_write_reg(dev, AK8963_REG_CNTL1, mode);
if (ret < 0) {
LOG_ERR("Failed to set AK8963 mode.");
return ret;
}
/* Wait for mode to change */
k_msleep(AK8963_SET_MODE_DELAY_MS);
return 0;
}
static int16_t ak8963_calc_adj(int16_t val)
{
/** Datasheet says the actual register value is in 16bit output max
* value of 32760 that corresponds to 4912 uT flux, yielding factor
* of 0.149938.
*
* Now Zephyr unit is Gauss, and conversion is 1T = 10^4G
* -> 0.1499 * 10^4 = 1499
* So if we multiply with scaling with 1499 the unit is uG.
*
* Calculation from MPU-9250 Register Map and Descriptions
* adj = (((val-128)*0.5)/128)+1
*/
return ((AK9863_SCALE_TO_UG * (val - 128)) / 256) + AK9863_SCALE_TO_UG;
}
static int ak8963_fetch_adj(const struct device *dev)
{
/* Read magnetometer adjustment data from the AK8963 chip */
struct mpu9250_data *drv_data = dev->data;
uint8_t buf;
int ret;
/* Change to FUSE access mode to access adjustment registers */
ret = ak8963_set_mode(dev, AK8963_REG_CNTL1_FUSE_ROM_VAL);
if (ret < 0) {
LOG_ERR("Failed to set chip in fuse access mode.");
return ret;
}
ret = ak8963_read_reg(dev, AK8963_REG_ADJ_DATA_X, &buf);
if (ret < 0) {
LOG_ERR("Failed to read adjustment data.");
return ret;
}
drv_data->magn_scale_x = ak8963_calc_adj(buf);
ret = ak8963_read_reg(dev, AK8963_REG_ADJ_DATA_Y, &buf);
if (ret < 0) {
LOG_ERR("Failed to read adjustment data.");
return ret;
}
drv_data->magn_scale_y = ak8963_calc_adj(buf);
ret = ak8963_read_reg(dev, AK8963_REG_ADJ_DATA_Z, &buf);
if (ret < 0) {
LOG_ERR("Failed to read adjustment data.");
return ret;
}
drv_data->magn_scale_z = ak8963_calc_adj(buf);
/* Change back to the powerdown mode */
ret = ak8963_set_mode(dev, AK8963_REG_CNTL1_POWERDOWN_VAL);
if (ret < 0) {
LOG_ERR("Failed to set chip in power down mode.");
return ret;
}
LOG_DBG("Adjustment values %d %d %d", drv_data->magn_scale_x,
drv_data->magn_scale_y, drv_data->magn_scale_z);
return 0;
}
static int ak8963_reset(const struct device *dev)
{
int ret;
/* Reset the chip -> reset all settings. */
ret = ak8963_write_reg(dev, AK8963_REG_CNTL2,
AK8963_REG_CNTL2_RESET_VAL);
if (ret < 0) {
LOG_ERR("Failed to reset AK8963.");
return ret;
}
/* Wait for reset */
k_msleep(AK8963_RESET_DELAY_MS);
return 0;
}
static int ak8963_init_master(const struct device *dev)
{
const struct mpu9250_config *cfg = dev->config;
int ret;
/* Instruct MPU9250 to use its external I2C bus as master */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_USER_CTRL,
MPU9250_REG_USER_CTRL_I2C_MASTERMODE_VAL);
if (ret < 0) {
LOG_ERR("Failed to set MPU9250 master i2c mode.");
return ret;
}
/* Set MPU9250 I2C bus as 400kHz and issue interrupt at data ready. */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_MST_CTRL,
MPU9250_REG_I2C_MST_CTRL_WAIT_MAG_400KHZ_VAL);
if (ret < 0) {
LOG_ERR("Failed to set MPU9250 master i2c speed.");
return ret;
}
return 0;
}
static int ak8963_init_readout(const struct device *dev)
{
const struct mpu9250_config *cfg = dev->config;
int ret;
/* Set target i2c address */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV0_ADDR,
AK8963_I2C_ADDR | I2C_READ_FLAG);
if (ret < 0) {
LOG_ERR("Failed to set AK8963 slave address.");
return ret;
}
/* Set target as data registers */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV0_REG, AK8963_REG_DATA);
if (ret < 0) {
LOG_ERR("Failed to set AK8963 register address.");
return ret;
}
/* Initiate readout at sample rate */
ret = i2c_reg_write_byte_dt(&cfg->i2c,
MPU9250_REG_I2C_SLV0_CTRL,
MPU9250_REG_READOUT_CTRL_VAL);
if (ret < 0) {
LOG_ERR("Failed to init AK8963 value readout.");
return ret;
}
return 0;
}
int ak8963_init(const struct device *dev)
{
uint8_t buf;
int ret;
ret = ak8963_init_master(dev);
if (ret < 0) {
LOG_ERR("Initializing MPU9250 master mode failed.");
return ret;
}
ret = ak8963_reset(dev);
if (ret < 0) {
LOG_ERR("Resetting AK8963 failed.");
return ret;
}
/* First check that the chip says hello */
ret = ak8963_read_reg(dev, AK8963_REG_ID, &buf);
if (ret < 0) {
LOG_ERR("Failed to read AK8963 chip id.");
return ret;
}
if (buf != AK8963_REG_ID_VAL) {
LOG_ERR("Invalid AK8963 chip id (0x%X).", buf);
return -ENOTSUP;
}
/* Fetch calibration data */
ret = ak8963_fetch_adj(dev);
if (ret < 0) {
LOG_ERR("Calibrating AK8963 failed.");
return ret;
}
/* Set AK sample rate and resolution */
ret = ak8963_set_mode(dev, AK8963_REG_CNTL1_16BIT_100HZ_VAL);
if (ret < 0) {
LOG_ERR("Failed set sample rate for AK8963.");
return ret;
}
/* Init constant readouts at sample rate */
ret = ak8963_init_readout(dev);
if (ret < 0) {
LOG_ERR("Initializing AK8963 readout failed.");
return ret;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/tdk/mpu9250/ak8963.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,130 |
```unknown
# MPU9250 Nine-Axis Motion Tracking device configuration options
menuconfig MPU9250
bool "MPU9250 Nine-Axis Motion Tracking Device"
default y
depends on DT_HAS_INVENSENSE_MPU9250_ENABLED
select I2C
help
Enable driver for MPU9250 I2C-based nine-axis motion tracking device.
if MPU9250
choice
prompt "Trigger mode"
default MPU9250_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config MPU9250_TRIGGER_NONE
bool "No trigger"
config MPU9250_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select MPU9250_TRIGGER
config MPU9250_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select MPU9250_TRIGGER
endchoice
config MPU9250_TRIGGER
bool
config MPU9250_THREAD_PRIORITY
int "Thread priority"
depends on MPU9250_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config MPU9250_THREAD_STACK_SIZE
int "Thread stack size"
depends on MPU9250_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config MPU9250_MAGN_EN
bool "Magnetometer enable"
default y
help
Enable AK8963 builtin magnetometer.
endif # MPU9250
``` | /content/code_sandbox/drivers/sensor/tdk/mpu9250/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 305 |
```c
/*
*
*/
#define DT_DRV_COMPAT invensense_mpu9250
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include <zephyr/devicetree.h>
#include "mpu9250.h"
#ifdef CONFIG_MPU9250_MAGN_EN
#include "ak8963.h"
#endif
LOG_MODULE_REGISTER(MPU9250, CONFIG_SENSOR_LOG_LEVEL);
#define MPU9250_REG_CHIP_ID 0x75
#define MPU9250_CHIP_ID 0x71
#define MPU9250_REG_SR_DIV 0x19
#define MPU9250_REG_CONFIG 0x1A
#define MPU9250_GYRO_DLPF_MAX 7
#define MPU9250_REG_GYRO_CFG 0x1B
#define MPU9250_GYRO_FS_SHIFT 3
#define MPU9250_GYRO_FS_MAX 3
#define MPU9250_REG_ACCEL_CFG 0x1C
#define MPU9250_ACCEL_FS_SHIFT 3
#define MPU9250_ACCEL_FS_MAX 3
#define MPU9250_REG_ACCEL_CFG2 0x1D
#define MPU9250_ACCEL_DLPF_MAX 7
#define MPU9250_REG_DATA_START 0x3B
#define MPU0259_TEMP_SENSITIVITY 334
#define MPU9250_TEMP_OFFSET 21
#define MPU9250_REG_PWR_MGMT1 0x6B
#define MPU9250_SLEEP_EN BIT(6)
#ifdef CONFIG_MPU9250_MAGN_EN
#define MPU9250_READ_BUF_SIZE 11
#else
#define MPU9250_READ_BUF_SIZE 7
#endif
/* see "Accelerometer Measurements" section from register map description */
static void mpu9250_convert_accel(struct sensor_value *val, int16_t raw_val,
uint16_t sensitivity_shift)
{
int64_t conv_val;
conv_val = ((int64_t)raw_val * SENSOR_G) >> sensitivity_shift;
val->val1 = conv_val / 1000000;
val->val2 = conv_val % 1000000;
}
/* see "Gyroscope Measurements" section from register map description */
static void mpu9250_convert_gyro(struct sensor_value *val, int16_t raw_val,
uint16_t sensitivity_x10)
{
int64_t conv_val;
conv_val = ((int64_t)raw_val * SENSOR_PI * 10) /
(sensitivity_x10 * 180U);
val->val1 = conv_val / 1000000;
val->val2 = conv_val % 1000000;
}
/* see "Temperature Measurement" section from register map description */
static inline void mpu9250_convert_temp(struct sensor_value *val,
int16_t raw_val)
{
/* Temp[*C] = (raw / sensitivity) + offset */
val->val1 = (raw_val / MPU0259_TEMP_SENSITIVITY) + MPU9250_TEMP_OFFSET;
val->val2 = (((int64_t)(raw_val % MPU0259_TEMP_SENSITIVITY) * 1000000)
/ MPU0259_TEMP_SENSITIVITY);
if (val->val2 < 0) {
val->val1--;
val->val2 += 1000000;
} else if (val->val2 >= 1000000) {
val->val1++;
val->val2 -= 1000000;
}
}
static int mpu9250_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct mpu9250_data *drv_data = dev->data;
#ifdef CONFIG_MPU9250_MAGN_EN
int ret;
#endif
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
mpu9250_convert_accel(val, drv_data->accel_x,
drv_data->accel_sensitivity_shift);
mpu9250_convert_accel(val + 1, drv_data->accel_y,
drv_data->accel_sensitivity_shift);
mpu9250_convert_accel(val + 2, drv_data->accel_z,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_X:
mpu9250_convert_accel(val, drv_data->accel_x,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Y:
mpu9250_convert_accel(val, drv_data->accel_y,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Z:
mpu9250_convert_accel(val, drv_data->accel_z,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_GYRO_XYZ:
mpu9250_convert_gyro(val, drv_data->gyro_x,
drv_data->gyro_sensitivity_x10);
mpu9250_convert_gyro(val + 1, drv_data->gyro_y,
drv_data->gyro_sensitivity_x10);
mpu9250_convert_gyro(val + 2, drv_data->gyro_z,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_X:
mpu9250_convert_gyro(val, drv_data->gyro_x,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Y:
mpu9250_convert_gyro(val, drv_data->gyro_y,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Z:
mpu9250_convert_gyro(val, drv_data->gyro_z,
drv_data->gyro_sensitivity_x10);
break;
#ifdef CONFIG_MPU9250_MAGN_EN
case SENSOR_CHAN_MAGN_XYZ:
ret = ak8963_convert_magn(val, drv_data->magn_x,
drv_data->magn_scale_x,
drv_data->magn_st2);
if (ret < 0) {
return ret;
}
ret = ak8963_convert_magn(val + 1, drv_data->magn_y,
drv_data->magn_scale_y,
drv_data->magn_st2);
if (ret < 0) {
return ret;
}
ret = ak8963_convert_magn(val + 2, drv_data->magn_z,
drv_data->magn_scale_z,
drv_data->magn_st2);
return ret;
case SENSOR_CHAN_MAGN_X:
return ak8963_convert_magn(val, drv_data->magn_x,
drv_data->magn_scale_x,
drv_data->magn_st2);
case SENSOR_CHAN_MAGN_Y:
return ak8963_convert_magn(val, drv_data->magn_y,
drv_data->magn_scale_y,
drv_data->magn_st2);
case SENSOR_CHAN_MAGN_Z:
return ak8963_convert_magn(val, drv_data->magn_z,
drv_data->magn_scale_z,
drv_data->magn_st2);
case SENSOR_CHAN_DIE_TEMP:
mpu9250_convert_temp(val, drv_data->temp);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static int mpu9250_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct mpu9250_data *drv_data = dev->data;
const struct mpu9250_config *cfg = dev->config;
int16_t buf[MPU9250_READ_BUF_SIZE];
int ret;
ret = i2c_burst_read_dt(&cfg->i2c,
MPU9250_REG_DATA_START, (uint8_t *)buf,
sizeof(buf));
if (ret < 0) {
LOG_ERR("Failed to read data sample.");
return ret;
}
drv_data->accel_x = sys_be16_to_cpu(buf[0]);
drv_data->accel_y = sys_be16_to_cpu(buf[1]);
drv_data->accel_z = sys_be16_to_cpu(buf[2]);
drv_data->temp = sys_be16_to_cpu(buf[3]);
drv_data->gyro_x = sys_be16_to_cpu(buf[4]);
drv_data->gyro_y = sys_be16_to_cpu(buf[5]);
drv_data->gyro_z = sys_be16_to_cpu(buf[6]);
#ifdef CONFIG_MPU9250_MAGN_EN
drv_data->magn_x = sys_le16_to_cpu(buf[7]);
drv_data->magn_y = sys_le16_to_cpu(buf[8]);
drv_data->magn_z = sys_le16_to_cpu(buf[9]);
drv_data->magn_st2 = ((uint8_t *)buf)[20];
LOG_DBG("magn_st2: %u", drv_data->magn_st2);
#endif
return 0;
}
static const struct sensor_driver_api mpu9250_driver_api = {
#if CONFIG_MPU9250_TRIGGER
.trigger_set = mpu9250_trigger_set,
#endif
.sample_fetch = mpu9250_sample_fetch,
.channel_get = mpu9250_channel_get,
};
/* measured in degrees/sec x10 to avoid floating point */
static const uint16_t mpu9250_gyro_sensitivity_x10[] = {
1310, 655, 328, 164
};
static int mpu9250_init(const struct device *dev)
{
struct mpu9250_data *drv_data = dev->data;
const struct mpu9250_config *cfg = dev->config;
uint8_t id;
int ret;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("I2C dev %s not ready", cfg->i2c.bus->name);
return -ENODEV;
}
/* check chip ID */
ret = i2c_reg_read_byte_dt(&cfg->i2c, MPU9250_REG_CHIP_ID, &id);
if (ret < 0) {
LOG_ERR("Failed to read chip ID.");
return ret;
}
if (id != MPU9250_CHIP_ID) {
LOG_ERR("Invalid chip ID.");
return -ENOTSUP;
}
/* wake up chip */
ret = i2c_reg_update_byte_dt(&cfg->i2c,
MPU9250_REG_PWR_MGMT1,
MPU9250_SLEEP_EN, 0);
if (ret < 0) {
LOG_ERR("Failed to wake up chip.");
return ret;
}
if (cfg->accel_fs > MPU9250_ACCEL_FS_MAX) {
LOG_ERR("Accel FS is too big: %d", cfg->accel_fs);
return -EINVAL;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, MPU9250_REG_ACCEL_CFG,
cfg->accel_fs << MPU9250_ACCEL_FS_SHIFT);
if (ret < 0) {
LOG_ERR("Failed to write accel full-scale range.");
return ret;
}
drv_data->accel_sensitivity_shift = 14 - cfg->accel_fs;
if (cfg->gyro_fs > MPU9250_GYRO_FS_MAX) {
LOG_ERR("Gyro FS is too big: %d", cfg->accel_fs);
return -EINVAL;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, MPU9250_REG_GYRO_CFG,
cfg->gyro_fs << MPU9250_GYRO_FS_SHIFT);
if (ret < 0) {
LOG_ERR("Failed to write gyro full-scale range.");
return ret;
}
if (cfg->gyro_dlpf > MPU9250_GYRO_DLPF_MAX) {
LOG_ERR("Gyro DLPF is too big: %d", cfg->gyro_dlpf);
return -EINVAL;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, MPU9250_REG_CONFIG,
cfg->gyro_dlpf);
if (ret < 0) {
LOG_ERR("Failed to write gyro digital LPF settings.");
return ret;
}
if (cfg->accel_dlpf > MPU9250_ACCEL_DLPF_MAX) {
LOG_ERR("Accel DLPF is too big: %d", cfg->accel_dlpf);
return -EINVAL;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, MPU9250_REG_ACCEL_CFG2,
cfg->accel_dlpf);
if (ret < 0) {
LOG_ERR("Failed to write accel digital LPF settings.");
return ret;
}
ret = i2c_reg_write_byte_dt(&cfg->i2c, MPU9250_REG_SR_DIV,
cfg->gyro_sr_div);
if (ret < 0) {
LOG_ERR("Failed to write gyro ODR divider.");
return ret;
}
drv_data->gyro_sensitivity_x10 =
mpu9250_gyro_sensitivity_x10[cfg->gyro_fs];
#ifdef CONFIG_MPU9250_MAGN_EN
ret = ak8963_init(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize AK8963.");
return ret;
}
#endif
#ifdef CONFIG_MPU9250_TRIGGER
ret = mpu9250_init_interrupt(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupts.");
return ret;
}
#endif
return 0;
}
#define INIT_MPU9250_INST(inst) \
static struct mpu9250_data mpu9250_data_##inst; \
static const struct mpu9250_config mpu9250_cfg_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.gyro_sr_div = DT_INST_PROP(inst, gyro_sr_div), \
.gyro_dlpf = DT_INST_ENUM_IDX(inst, gyro_dlpf), \
.gyro_fs = DT_INST_ENUM_IDX(inst, gyro_fs), \
.accel_fs = DT_INST_ENUM_IDX(inst, accel_fs), \
.accel_dlpf = DT_INST_ENUM_IDX(inst, accel_dlpf), \
IF_ENABLED(CONFIG_MPU9250_TRIGGER, \
(.int_pin = GPIO_DT_SPEC_INST_GET(inst, irq_gpios))) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, mpu9250_init, NULL, \
&mpu9250_data_##inst, &mpu9250_cfg_##inst,\
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&mpu9250_driver_api);
DT_INST_FOREACH_STATUS_OKAY(INIT_MPU9250_INST)
``` | /content/code_sandbox/drivers/sensor/tdk/mpu9250/mpu9250.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,125 |
```c
/*
*
*/
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
#include "mpu9250.h"
LOG_MODULE_DECLARE(MPU9250, CONFIG_SENSOR_LOG_LEVEL);
#define MPU9250_REG_INT_EN 0x38
#define MPU9250_DRDY_EN BIT(0)
int mpu9250_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct mpu9250_data *drv_data = dev->data;
const struct mpu9250_config *cfg = dev->config;
int ret;
if (trig->type != SENSOR_TRIG_DATA_READY) {
return -ENOTSUP;
}
ret = gpio_pin_interrupt_configure_dt(&cfg->int_pin, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("Failed to disable gpio interrupt.");
return ret;
}
drv_data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
drv_data->data_ready_trigger = trig;
ret = gpio_pin_interrupt_configure_dt(&cfg->int_pin,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
LOG_ERR("Failed to enable gpio interrupt.");
return ret;
}
return 0;
}
static void mpu9250_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct mpu9250_data *drv_data =
CONTAINER_OF(cb, struct mpu9250_data, gpio_cb);
const struct mpu9250_config *cfg = drv_data->dev->config;
int ret;
ARG_UNUSED(pins);
ret = gpio_pin_interrupt_configure_dt(&cfg->int_pin, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("Disabling gpio interrupt failed with err: %d", ret);
return;
}
#if defined(CONFIG_MPU9250_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_MPU9250_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void mpu9250_thread_cb(const struct device *dev)
{
struct mpu9250_data *drv_data = dev->data;
const struct mpu9250_config *cfg = dev->config;
int ret;
if (drv_data->data_ready_handler != NULL) {
drv_data->data_ready_handler(dev,
drv_data->data_ready_trigger);
}
ret = gpio_pin_interrupt_configure_dt(&cfg->int_pin,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
LOG_ERR("Enabling gpio interrupt failed with err: %d", ret);
}
}
#ifdef CONFIG_MPU9250_TRIGGER_OWN_THREAD
static void mpu9250_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct mpu9250_data *drv_data = p1;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
mpu9250_thread_cb(drv_data->dev);
}
}
#endif
#ifdef CONFIG_MPU9250_TRIGGER_GLOBAL_THREAD
static void mpu9250_work_cb(struct k_work *work)
{
struct mpu9250_data *drv_data =
CONTAINER_OF(work, struct mpu9250_data, work);
mpu9250_thread_cb(drv_data->dev);
}
#endif
int mpu9250_init_interrupt(const struct device *dev)
{
struct mpu9250_data *drv_data = dev->data;
const struct mpu9250_config *cfg = dev->config;
int ret;
/* setup data ready gpio interrupt */
if (!gpio_is_ready_dt(&cfg->int_pin)) {
LOG_ERR("Interrupt pin is not ready.");
return -EIO;
}
drv_data->dev = dev;
ret = gpio_pin_configure_dt(&cfg->int_pin, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Failed to configure interrupt pin.");
return ret;
}
gpio_init_callback(&drv_data->gpio_cb,
mpu9250_gpio_callback,
BIT(cfg->int_pin.pin));
ret = gpio_add_callback(cfg->int_pin.port, &drv_data->gpio_cb);
if (ret < 0) {
LOG_ERR("Failed to set gpio callback.");
return ret;
}
/* enable data ready interrupt */
ret = i2c_reg_write_byte_dt(&cfg->i2c, MPU9250_REG_INT_EN,
MPU9250_DRDY_EN);
if (ret < 0) {
LOG_ERR("Failed to enable data ready interrupt.");
return ret;
}
#if defined(CONFIG_MPU9250_TRIGGER_OWN_THREAD)
ret = k_sem_init(&drv_data->gpio_sem, 0, K_SEM_MAX_LIMIT);
if (ret < 0) {
LOG_ERR("Failed to enable semaphore");
return ret;
}
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_MPU9250_THREAD_STACK_SIZE,
mpu9250_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_MPU9250_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_MPU9250_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = mpu9250_work_cb;
#endif
ret = gpio_pin_interrupt_configure_dt(&cfg->int_pin,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
LOG_ERR("Failed to enable interrupt");
return ret;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/tdk/mpu9250/mpu9250_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,193 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_MPU9250_MPU9250_H_
#define ZEPHYR_DRIVERS_SENSOR_MPU9250_MPU9250_H_
#include <stdint.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
struct mpu9250_data {
int16_t accel_x;
int16_t accel_y;
int16_t accel_z;
uint16_t accel_sensitivity_shift;
int16_t temp;
int16_t gyro_x;
int16_t gyro_y;
int16_t gyro_z;
uint16_t gyro_sensitivity_x10;
#ifdef CONFIG_MPU9250_MAGN_EN
int16_t magn_x;
int16_t magn_scale_x;
int16_t magn_y;
int16_t magn_scale_y;
int16_t magn_z;
int16_t magn_scale_z;
uint8_t magn_st2;
#endif
#ifdef CONFIG_MPU9250_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_MPU9250_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_MPU9250_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_MPU9250_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_MPU9250_TRIGGER */
};
struct mpu9250_config {
const struct i2c_dt_spec i2c;
uint8_t gyro_sr_div;
uint8_t gyro_dlpf;
uint8_t gyro_fs;
uint8_t accel_fs;
uint8_t accel_dlpf;
#ifdef CONFIG_MPU9250_TRIGGER
const struct gpio_dt_spec int_pin;
#endif /* CONFIG_MPU9250_TRIGGER */
};
#ifdef CONFIG_MPU9250_TRIGGER
int mpu9250_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int mpu9250_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_MPU9250_MPU9250_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/mpu9250/mpu9250.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 471 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "icm42605.h"
#include "icm42605_setup.h"
LOG_MODULE_DECLARE(ICM42605, CONFIG_SENSOR_LOG_LEVEL);
int icm42605_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
if (trig->type != SENSOR_TRIG_DATA_READY
&& trig->type != SENSOR_TRIG_TAP
&& trig->type != SENSOR_TRIG_DOUBLE_TAP) {
return -ENOTSUP;
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
if (handler == NULL) {
icm42605_turn_off_sensor(dev);
return 0;
}
if (trig->type == SENSOR_TRIG_DATA_READY) {
drv_data->data_ready_handler = handler;
drv_data->data_ready_trigger = trig;
} else if (trig->type == SENSOR_TRIG_TAP) {
drv_data->tap_handler = handler;
drv_data->tap_trigger = trig;
drv_data->tap_en = true;
} else if (trig->type == SENSOR_TRIG_DOUBLE_TAP) {
drv_data->double_tap_handler = handler;
drv_data->double_tap_trigger = trig;
drv_data->tap_en = true;
} else {
return -ENOTSUP;
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_EDGE_TO_ACTIVE);
icm42605_turn_on_sensor(dev);
return 0;
}
static void icm42605_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct icm42605_data *drv_data =
CONTAINER_OF(cb, struct icm42605_data, gpio_cb);
const struct icm42605_config *cfg = drv_data->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
k_sem_give(&drv_data->gpio_sem);
}
static void icm42605_thread_cb(const struct device *dev)
{
struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
if (drv_data->data_ready_handler != NULL) {
drv_data->data_ready_handler(dev,
drv_data->data_ready_trigger);
}
if (drv_data->tap_handler != NULL ||
drv_data->double_tap_handler != NULL) {
icm42605_tap_fetch(dev);
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_EDGE_TO_ACTIVE);
}
static void icm42605_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct icm42605_data *drv_data = p1;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
icm42605_thread_cb(drv_data->dev);
}
}
int icm42605_init_interrupt(const struct device *dev)
{
struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
int result = 0;
if (!gpio_is_ready_dt(&cfg->gpio_int)) {
LOG_ERR("gpio_int gpio not ready");
return -ENODEV;
}
drv_data->dev = dev;
gpio_pin_configure_dt(&cfg->gpio_int, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb, icm42605_gpio_callback, BIT(cfg->gpio_int.pin));
result = gpio_add_callback(cfg->gpio_int.port, &drv_data->gpio_cb);
if (result < 0) {
LOG_ERR("Failed to set gpio callback");
return result;
}
k_sem_init(&drv_data->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_ICM42605_THREAD_STACK_SIZE, icm42605_thread, drv_data, NULL, NULL,
K_PRIO_COOP(CONFIG_ICM42605_THREAD_PRIORITY), 0, K_NO_WAIT);
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_EDGE_TO_INACTIVE);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,000 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_SETUP_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_SETUP_H_
#include <zephyr/device.h>
int icm42605_sensor_init(const struct device *dev);
int icm42605_turn_on_fifo(const struct device *dev);
int icm42605_turn_off_fifo(const struct device *dev);
int icm42605_turn_off_sensor(const struct device *dev);
int icm42605_turn_on_sensor(const struct device *dev);
int icm42605_set_odr(const struct device *dev, int a_rate, int g_rate);
#endif /* __SENSOR_ICM42605_ICM42605_SETUP__ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605_setup.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 156 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_H_
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#include <zephyr/types.h>
#include "icm42605_reg.h"
typedef void (*tap_fetch_t)(const struct device *dev);
int icm42605_tap_fetch(const struct device *dev);
struct icm42605_data {
uint8_t fifo_data[HARDWARE_FIFO_SIZE];
int16_t accel_x;
int16_t accel_y;
int16_t accel_z;
uint16_t accel_sensitivity_shift;
uint16_t accel_hz;
uint16_t accel_sf;
int16_t temp;
int16_t gyro_x;
int16_t gyro_y;
int16_t gyro_z;
uint16_t gyro_sensitivity_x10;
uint16_t gyro_hz;
uint16_t gyro_sf;
bool accel_en;
bool gyro_en;
bool tap_en;
bool sensor_started;
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
const struct sensor_trigger *tap_trigger;
sensor_trigger_handler_t tap_handler;
const struct sensor_trigger *double_tap_trigger;
sensor_trigger_handler_t double_tap_handler;
#ifdef CONFIG_ICM42605_TRIGGER
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ICM42605_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#endif
};
struct icm42605_config {
struct spi_dt_spec spi;
struct gpio_dt_spec gpio_int;
uint16_t accel_hz;
uint16_t gyro_hz;
uint16_t accel_fs;
uint16_t gyro_fs;
};
int icm42605_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int icm42605_init_interrupt(const struct device *dev);
#endif /* __SENSOR_ICM42605__ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 445 |
```c
/*
*
*/
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "icm42605.h"
#include "icm42605_reg.h"
#include "icm42605_spi.h"
LOG_MODULE_DECLARE(ICM42605, CONFIG_SENSOR_LOG_LEVEL);
int icm42605_set_fs(const struct device *dev, uint16_t a_sf, uint16_t g_sf)
{
const struct icm42605_config *cfg = dev->config;
uint8_t databuf;
int result;
result = inv_spi_read(&cfg->spi, REG_ACCEL_CONFIG0, &databuf, 1);
if (result) {
return result;
}
databuf &= ~BIT_ACCEL_FSR;
databuf |= a_sf;
result = inv_spi_single_write(&cfg->spi, REG_ACCEL_CONFIG0, &databuf);
result = inv_spi_read(&cfg->spi, REG_GYRO_CONFIG0, &databuf, 1);
if (result) {
return result;
}
databuf &= ~BIT_GYRO_FSR;
databuf |= g_sf;
result = inv_spi_single_write(&cfg->spi, REG_GYRO_CONFIG0, &databuf);
if (result) {
return result;
}
return 0;
}
int icm42605_set_odr(const struct device *dev, uint16_t a_rate, uint16_t g_rate)
{
const struct icm42605_config *cfg = dev->config;
uint8_t databuf;
int result;
if (a_rate > 8000 || g_rate > 8000 ||
a_rate < 1 || g_rate < 12) {
LOG_ERR("Not supported frequency");
return -ENOTSUP;
}
result = inv_spi_read(&cfg->spi, REG_ACCEL_CONFIG0, &databuf, 1);
if (result) {
return result;
}
databuf &= ~BIT_ACCEL_ODR;
if (a_rate > 4000) {
databuf |= BIT_ACCEL_ODR_8000;
} else if (a_rate > 2000) {
databuf |= BIT_ACCEL_ODR_4000;
} else if (a_rate > 1000) {
databuf |= BIT_ACCEL_ODR_2000;
} else if (a_rate > 500) {
databuf |= BIT_ACCEL_ODR_1000;
} else if (a_rate > 200) {
databuf |= BIT_ACCEL_ODR_500;
} else if (a_rate > 100) {
databuf |= BIT_ACCEL_ODR_200;
} else if (a_rate > 50) {
databuf |= BIT_ACCEL_ODR_100;
} else if (a_rate > 25) {
databuf |= BIT_ACCEL_ODR_50;
} else if (a_rate > 12) {
databuf |= BIT_ACCEL_ODR_25;
} else if (a_rate > 6) {
databuf |= BIT_ACCEL_ODR_12;
} else if (a_rate > 3) {
databuf |= BIT_ACCEL_ODR_6;
} else if (a_rate > 1) {
databuf |= BIT_ACCEL_ODR_3;
} else {
databuf |= BIT_ACCEL_ODR_1;
}
result = inv_spi_single_write(&cfg->spi, REG_ACCEL_CONFIG0, &databuf);
if (result) {
return result;
}
LOG_DBG("Write Accel ODR 0x%X", databuf);
result = inv_spi_read(&cfg->spi, REG_GYRO_CONFIG0, &databuf, 1);
if (result) {
return result;
}
databuf &= ~BIT_GYRO_ODR;
if (g_rate > 4000) {
databuf |= BIT_GYRO_ODR_8000;
} else if (g_rate > 2000) {
databuf |= BIT_GYRO_ODR_4000;
} else if (g_rate > 1000) {
databuf |= BIT_GYRO_ODR_2000;
} else if (g_rate > 500) {
databuf |= BIT_GYRO_ODR_1000;
} else if (g_rate > 200) {
databuf |= BIT_GYRO_ODR_500;
} else if (g_rate > 100) {
databuf |= BIT_GYRO_ODR_200;
} else if (g_rate > 50) {
databuf |= BIT_GYRO_ODR_100;
} else if (g_rate > 25) {
databuf |= BIT_GYRO_ODR_50;
} else if (g_rate > 12) {
databuf |= BIT_GYRO_ODR_25;
} else {
databuf |= BIT_GYRO_ODR_12;
}
LOG_DBG("Write GYRO ODR 0x%X", databuf);
result = inv_spi_single_write(&cfg->spi, REG_GYRO_CONFIG0, &databuf);
if (result) {
return result;
}
return result;
}
int icm42605_sensor_init(const struct device *dev)
{
const struct icm42605_config *cfg = dev->config;
int result = 0;
uint8_t v;
result = inv_spi_read(&cfg->spi, REG_WHO_AM_I, &v, 1);
if (result) {
return result;
}
LOG_DBG("WHO AM I : 0x%X", v);
result = inv_spi_read(&cfg->spi, REG_DEVICE_CONFIG, &v, 1);
if (result) {
LOG_DBG("read REG_DEVICE_CONFIG_REG failed");
return result;
}
v |= BIT_SOFT_RESET;
result = inv_spi_single_write(&cfg->spi, REG_DEVICE_CONFIG, &v);
if (result) {
LOG_ERR("write REG_DEVICE_CONFIG failed");
return result;
}
/* Need at least 10ms after soft reset */
k_msleep(10);
v = BIT_GYRO_AFSR_MODE_HFS | BIT_ACCEL_AFSR_MODE_HFS | BIT_CLK_SEL_PLL;
result = inv_spi_single_write(&cfg->spi, REG_INTF_CONFIG1, &v);
if (result) {
LOG_ERR("write REG_INTF_CONFIG1 failed");
return result;
}
v = BIT_EN_DREG_FIFO_D2A |
BIT_TMST_TO_REGS_EN |
BIT_TMST_EN;
result = inv_spi_single_write(&cfg->spi, REG_TMST_CONFIG, &v);
if (result) {
LOG_ERR("Write REG_TMST_CONFIG failed");
return result;
}
result = inv_spi_read(&cfg->spi, REG_INTF_CONFIG0, &v, 1);
if (result) {
LOG_ERR("Read REG_INTF_CONFIG0 failed");
return result;
}
LOG_DBG("Read REG_INTF_CONFIG0 0x%X", v);
v |= BIT_UI_SIFS_DISABLE_I2C;
result = inv_spi_single_write(&cfg->spi, REG_INTF_CONFIG0, &v);
if (result) {
LOG_ERR("Write REG_INTF_CONFIG failed");
return result;
}
v = 0;
result = inv_spi_single_write(&cfg->spi, REG_INT_CONFIG1, &v);
if (result) {
return result;
}
result = inv_spi_single_write(&cfg->spi, REG_PWR_MGMT0, &v);
if (result) {
return result;
}
return 0;
}
int icm42605_turn_on_fifo(const struct device *dev)
{
const struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
uint8_t int0_en = BIT_INT_UI_DRDY_INT1_EN;
uint8_t fifo_en = BIT_FIFO_ACCEL_EN | BIT_FIFO_GYRO_EN | BIT_FIFO_WM_TH;
uint8_t burst_read[3];
int result;
uint8_t v = 0;
v = BIT_FIFO_MODE_BYPASS;
result = inv_spi_single_write(&cfg->spi, REG_FIFO_CONFIG, &v);
if (result) {
return result;
}
v = 0;
result = inv_spi_single_write(&cfg->spi, REG_FIFO_CONFIG1, &v);
if (result) {
return result;
}
result = inv_spi_read(&cfg->spi, REG_FIFO_COUNTH, burst_read, 2);
if (result) {
return result;
}
result = inv_spi_read(&cfg->spi, REG_FIFO_DATA, burst_read, 3);
if (result) {
return result;
}
v = BIT_FIFO_MODE_STREAM;
result = inv_spi_single_write(&cfg->spi, REG_FIFO_CONFIG, &v);
if (result) {
return result;
}
result = inv_spi_single_write(&cfg->spi, REG_FIFO_CONFIG1, &fifo_en);
if (result) {
return result;
}
result = inv_spi_single_write(&cfg->spi, REG_INT_SOURCE0, &int0_en);
if (result) {
return result;
}
if (drv_data->tap_en) {
v = BIT_TAP_ENABLE;
result = inv_spi_single_write(&cfg->spi, REG_APEX_CONFIG0, &v);
if (result) {
return result;
}
v = BIT_DMP_INIT_EN;
result = inv_spi_single_write(&cfg->spi, REG_SIGNAL_PATH_RESET, &v);
if (result) {
return result;
}
v = BIT_BANK_SEL_4;
result = inv_spi_single_write(&cfg->spi, REG_BANK_SEL, &v);
if (result) {
return result;
}
v = BIT_INT_STATUS_TAP_DET;
result = inv_spi_single_write(&cfg->spi, REG_INT_SOURCE6, &v);
if (result) {
return result;
}
v = BIT_BANK_SEL_0;
result = inv_spi_single_write(&cfg->spi, REG_BANK_SEL, &v);
if (result) {
return result;
}
}
LOG_DBG("turn on fifo done");
return 0;
}
int icm42605_turn_off_fifo(const struct device *dev)
{
const struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
uint8_t int0_en = 0;
uint8_t burst_read[3];
int result;
uint8_t v = 0;
v = BIT_FIFO_MODE_BYPASS;
result = inv_spi_single_write(&cfg->spi, REG_FIFO_CONFIG, &v);
if (result) {
return result;
}
v = 0;
result = inv_spi_single_write(&cfg->spi, REG_FIFO_CONFIG1, &v);
if (result) {
return result;
}
result = inv_spi_read(&cfg->spi, REG_FIFO_COUNTH, burst_read, 2);
if (result) {
return result;
}
result = inv_spi_read(&cfg->spi, REG_FIFO_DATA, burst_read, 3);
if (result) {
return result;
}
result = inv_spi_single_write(&cfg->spi, REG_INT_SOURCE0, &int0_en);
if (result) {
return result;
}
if (drv_data->tap_en) {
v = 0;
result = inv_spi_single_write(&cfg->spi, REG_APEX_CONFIG0, &v);
if (result) {
return result;
}
result = inv_spi_single_write(&cfg->spi, REG_SIGNAL_PATH_RESET, &v);
if (result) {
return result;
}
v = BIT_BANK_SEL_4;
result = inv_spi_single_write(&cfg->spi, REG_BANK_SEL, &v);
if (result) {
return result;
}
v = 0;
result = inv_spi_single_write(&cfg->spi, REG_INT_SOURCE6, &v);
if (result) {
return result;
}
v = BIT_BANK_SEL_0;
result = inv_spi_single_write(&cfg->spi, REG_BANK_SEL, &v);
if (result) {
return result;
}
}
return 0;
}
int icm42605_turn_on_sensor(const struct device *dev)
{
struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
uint8_t v = 0;
int result = 0;
if (drv_data->sensor_started) {
LOG_ERR("Sensor already started");
return -EALREADY;
}
icm42605_set_fs(dev, drv_data->accel_sf, drv_data->gyro_sf);
icm42605_set_odr(dev, drv_data->accel_hz, drv_data->gyro_hz);
v |= BIT_ACCEL_MODE_LNM;
v |= BIT_GYRO_MODE_LNM;
result = inv_spi_single_write(&cfg->spi, REG_PWR_MGMT0, &v);
if (result) {
return result;
}
/* Accelerometer sensor need at least 10ms startup time
* Gyroscope sensor need at least 30ms startup time
*/
k_msleep(100);
icm42605_turn_on_fifo(dev);
drv_data->sensor_started = true;
return 0;
}
int icm42605_turn_off_sensor(const struct device *dev)
{
const struct icm42605_config *cfg = dev->config;
uint8_t v = 0;
int result = 0;
result = inv_spi_read(&cfg->spi, REG_PWR_MGMT0, &v, 1);
v ^= BIT_ACCEL_MODE_LNM;
v ^= BIT_GYRO_MODE_LNM;
result = inv_spi_single_write(&cfg->spi, REG_PWR_MGMT0, &v);
if (result) {
return result;
}
/* Accelerometer sensor need at least 10ms startup time
* Gyroscope sensor need at least 30ms startup time
*/
k_msleep(100);
icm42605_turn_off_fifo(dev);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605_setup.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,089 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_REG_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_REG_H_
/* BANK 0 */
#define REG_DEVICE_CONFIG 0x11
#define REG_DRIVE_CONFIG 0x13
#define REG_INT_CONFIG 0x14
#define REG_FIFO_CONFIG 0x16
#define REG_TEMP_DATA1 0x1D
#define REG_TEMP_DATA0 0x1E
#define REG_ACCEL_DATA_X1 0x1F
#define REG_ACCEL_DATA_X0 0x20
#define REG_ACCEL_DATA_Y1 0x21
#define REG_ACCEL_DATA_Y0 0x22
#define REG_ACCEL_DATA_Z1 0x23
#define REG_ACCEL_DATA_Z0 0x24
#define REG_GYRO_DATA_X1 0x25
#define REG_GYRO_DATA_X0 0x26
#define REG_GYRO_DATA_Y1 0x27
#define REG_GYRO_DATA_Y0 0x28
#define REG_GYRO_DATA_Z1 0x29
#define REG_GYRO_DATA_Z0 0x2A
#define REG_TMST_FSYNCH 0x2B
#define REG_TMST_FSYNCL 0x2C
#define REG_INT_STATUS 0x2D
#define REG_FIFO_COUNTH 0x2E
#define REG_FIFO_COUNTL 0x2F
#define REG_FIFO_DATA 0x30
#define REG_APEX_DATA0 0x31
#define REG_APEX_DATA1 0x32
#define REG_APEX_DATA2 0x33
#define REG_APEX_DATA3 0x34
#define REG_APEX_DATA4 0x35
#define REG_APEX_DATA5 0x36
#define REG_INT_STATUS2 0x37
#define REG_INT_STATUS3 0x38
#define REG_SIGNAL_PATH_RESET 0x4B
#define REG_INTF_CONFIG0 0x4C
#define REG_INTF_CONFIG1 0x4D
#define REG_PWR_MGMT0 0x4E
#define REG_GYRO_CONFIG0 0x4F
#define REG_ACCEL_CONFIG0 0x50
#define REG_GYRO_CONFIG1 0x51
#define REG_GYRO_ACCEL_CONFIG0 0x52
#define REG_ACCEL_CONFIG1 0x53
#define REG_TMST_CONFIG 0x54
#define REG_APEX_CONFIG0 0x56
#define REG_SMD_CONFIG 0x57
#define REG_FIFO_CONFIG1 0x5F
#define REG_FIFO_CONFIG2 0x60
#define REG_FIFO_CONFIG4 0x61
#define REG_FIFO_FSYNC_CONFIG 0x62
#define REG_INT_CONFIG0 0x63
#define REG_INT_CONFIG1 0x64
#define REG_INT_SOURCE0 0x65
#define REG_INT_SOURCE1 0x66
#define REG_INT_SOURCE3 0x68
#define REG_INT_SOURCE4 0x69
#define REG_FIFO_LOST_PKT0 0x6C
#define REG_FIFO_LOST_PKT1 0x6D
#define REG_SELF_TEST_CONFIG 0x70
#define REG_WHO_AM_I 0x75
#define REG_BANK_SEL 0x76
/* BANK 1 */
#define REG_SENSOR_CONFIG0 0x03
#define REG_GYRO_CONFIG_STATIC2 0x0B
#define REG_GYRO_CONFIG_STATIC3 0x0C
#define REG_GYRO_CONFIG_STATIC4 0x0D
#define REG_GYRO_CONFIG_STATIC5 0x0E
#define REG_GYRO_CONFIG_STATIC6 0x0F
#define REG_GYRO_CONFIG_STATIC7 0x10
#define REG_GYRO_CONFIG_STATIC8 0x11
#define REG_GYRO_CONFIG_STATIC9 0x12
#define REG_GYRO_CONFIG_STATIC10 0x13
#define REG_XG_ST_DATA 0x5F
#define REG_YG_ST_DATA 0x60
#define REG_ZG_ST_DATA 0x61
#define REG_TMSTVAL0 0x62
#define REG_TMSTVAL1 0x63
#define REG_TMSTVAL2 0x64
#define REG_INTF_CONFIG4 0x7A
#define REG_INTF_CONFIG5 0x7B
#define REG_INTF_CONFIG6 0x7C
/* BANK 2 */
#define REG_ACCEL_CONFIG_STATIC2 0x03
#define REG_ACCEL_CONFIG_STATIC3 0x04
#define REG_ACCEL_CONFIG_STATIC4 0x05
#define REG_XA_ST_DATA 0x3B
#define REG_YA_ST_DATA 0x3C
#define REG_ZA_ST_DATA 0x3D
/* BANK 4 */
#define REG_GYRO_ON_OFF_CONFIG 0x0E
#define REG_APEX_CONFIG1 0x40
#define REG_APEX_CONFIG2 0x41
#define REG_APEX_CONFIG3 0x42
#define REG_APEX_CONFIG4 0x43
#define REG_APEX_CONFIG5 0x44
#define REG_APEX_CONFIG6 0x45
#define REG_APEX_CONFIG7 0x46
#define REG_APEX_CONFIG8 0x47
#define REG_APEX_CONFIG9 0x48
#define REG_ACCEL_WOM_X_THR 0x4A
#define REG_ACCEL_WOM_Y_THR 0x4B
#define REG_ACCEL_WOM_Z_THR 0x4C
#define REG_INT_SOURCE6 0x4D
#define REG_INT_SOURCE7 0x4E
#define REG_INT_SOURCE8 0x4F
#define REG_INT_SOURCE9 0x50
#define REG_INT_SOURCE10 0x51
#define REG_OFFSET_USER0 0x77
#define REG_OFFSET_USER1 0x78
#define REG_OFFSET_USER2 0x79
#define REG_OFFSET_USER3 0x7A
#define REG_OFFSET_USER4 0x7B
#define REG_OFFSET_USER5 0x7C
#define REG_OFFSET_USER6 0x7D
#define REG_OFFSET_USER7 0x7E
#define REG_OFFSET_USER8 0x7F
/* #define REG_#define REG_BANK_SEL */
#define BIT_BANK_SEL_0 0x00
#define BIT_BANK_SEL_1 0x01
#define BIT_BANK_SEL_2 0x02
#define BIT_BANK_SEL_3 0x03
#define BIT_BANK_SEL_4 0x04
#define WHO_AM_I_ICM42605 0x42
/* Bank0 #define REG_DEVICE_CONFIG_REG */
#define BIT_SOFT_RESET 0x01
/* Bank0 #define REG_GYRO_CONFIG0, REG_ACCEL_CONFIG0 */
#define SHIFT_GYRO_FS_SEL 5
#define SHIFT_ACCEL_FS_SEL 5
#define SHIFT_ODR_CONF 0
/* Bank0 #define REG_GYRO_CONFIG1 */
#define BIT_TEMP_FILT_BW_BYPASS 0x00
#define BIT_TEMP_FILT_BW_170 0x20
#define BIT_TEMP_FILT_BW_82 0x40
#define BIT_TEMP_FILT_BW_40 0x60
#define BIT_TEMP_FILT_BW_20 0x80
#define BIT_TEMP_FILT_BW_10 0x90
#define BIT_TEMP_FILT_BW_5 0xC0
#define BIT_GYR_AVG_FLT_RATE_8KHZ 0x10
#define BIT_GYR_AVG_FLT_RATE_1KHZ 0x00
#define BIT_GYR_UI_FILT_ORD_IND_1 0x00
#define BIT_GYR_UI_FILT_ORD_IND_2 0x04
#define BIT_GYR_UI_FILT_ORD_IND_3 0x08
#define BIT_GYR_DEC2_M2_ORD_1 0x00
#define BIT_GYR_DEC2_M2_ORD_2 0x01
#define BIT_GYR_DEC2_M2_ORD_3 0x02
/* Bank0 REG_ACCEL_CONFIG1 */
#define BIT_ACC_UI_FILT_ODR_IND_1 0x00
#define BIT_ACC_UI_FILT_ODR_IND_2 0x08
#define BIT_ACC_UI_FILT_ODR_IND_3 0x10
#define BIT_ACC_DEC2_M2_ORD_1 0x00
#define BIT_ACC_DEC2_M2_ORD_2 0x02
#define BIT_ACC_DEC2_M2_ORD_3 0x04
#define BIT_ACC_AVG_FLT_RATE_8KHZ 0x01
#define BIT_ACC_AVG_FLT_RATE_1KHZ 0x00
/* Bank0 REG_INT_CONFIG_REG */
#define SHIFT_INT1_POLARITY 0
#define SHIFT_INT1_DRIVE_CIRCUIT 1
#define SHIFT_INT1_MODE 2
/* Bank0 REG_PWR_MGMT_0 */
#define BIT_TEMP_DIS 0x20
#define BIT_IDLE 0x10
#define BIT_GYRO_MODE_OFF 0x00
#define BIT_GYRO_MODE_STBY 0x04
#define BIT_GYRO_MODE_LPM 0x08
#define BIT_GYRO_MODE_LNM 0x0C
#define BIT_ACCEL_MODE_OFF 0x00
#define BIT_ACCEL_MODE_LPM 0x02
#define BIT_ACCEL_MODE_LNM 0x03
/* Bank0 REG_SIGNAL_PATH_RESET */
#define BIT_TEMP_RST 0x01
#define BIT_FIFO_FLUSH 0x02
#define BIT_TMST_STROBE 0x04
#define BIT_ABORT_AND_RESET 0x08
#define BIT_S4S_RESTART 0x10
#define BIT_DMP_MEM_RESET_EN 0x20
#define BIT_DMP_INIT_EN 0x40
/* Bank0 REG_INTF_CONFIG0 */
#define BIT_FIFO_COUNT_REC 0x40
#define BIT_COUNT_BIG_ENDIAN 0x20
#define BIT_SENS_DATA_BIG_ENDIAN 0x10
#define BIT_UI_SIFS_DISABLE_SPI 0x02
#define BIT_UI_SIFS_DISABLE_I2C 0x03
/* Bank0 REG_INTF_CONFIG1 */
#define BIT_GYRO_AFSR_MODE_LFS 0x00
#define BIT_GYRO_AFSR_MODE_HFS 0x40
#define BIT_GYRO_AFSR_MODE_DYN 0xC0
#define BIT_ACCEL_AFSR_MODE_LFS 0x00
#define BIT_ACCEL_AFSR_MODE_HFS 0x10
#define BIT_ACCEL_AFSR_MODE_DYN 0x30
#define BIT_ACCEL_LP_CLK_SEL 0x08
#define BIT_RTC_MODE 0x04
#define BIT_CLK_SEL_RC 0x00
#define BIT_CLK_SEL_PLL 0x01
#define BIT_CLK_SEL_DIS 0x03
/* Bank0 REG_FIFO_CONFIG1 */
#define BIT_FIFO_ACCEL_EN 0x01
#define BIT_FIFO_GYRO_EN 0x02
#define BIT_FIFO_TEMP_EN 0x04
#define BIT_FIFO_TMST_FSYNC_EN 0x08
#define BIT_FIFO_HIRES_EN 0x10
#define BIT_FIFO_WM_TH 0x20
#define BIT_FIFO_RESUME_PART_RD 0x40
/* Bank0 REG_INT_CONFIG1 */
#define BIT_INT_ASY_RST_DISABLE 0x10
/* Bank0 REG_INT_SOURCE0 */
#define BIT_INT_UI_AGC_RDY_INT1_EN 0x01
#define BIT_INT_FIFO_FULL_INT1_EN 0x02
#define BIT_INT_FIFO_THS_INT1_EN 0x04
#define BIT_INT_UI_DRDY_INT1_EN 0x08
#define BIT_INT_RESET_DONE_INT1_EN 0x10
#define BIT_INT_PLL_RDY_INT1_EN 0x20
#define BIT_INT_UI_FSYNC_INT1_EN 0x40
/* Bank0 REG_INT_SOURCE1 */
#define BIT_INT_WOM_X_INT1_EN 0x01
#define BIT_INT_WOM_Y_INT1_EN 0x02
#define BIT_INT_WOM_Z_INT1_EN 0x04
#define BIT_INT_SMD_INT1_EN 0x08
#define BIT_INT_WOM_XYZ_INT1_EN \
(BIT_INT_WOM_X_INT1_EN | BIT_INT_WOM_Y_INT1_EN | BIT_INT_WOM_Z_INT1_EN)
/* Bank0 REG_SENSOR_SELFTEST_REG1 */
#define BIT_ACCEL_SELF_TEST_PASS 0x08
#define BIT_GYRO_SELF_TEST_PASS 0x04
#define BIT_ACCEL_SELF_TEST_DONE 0x02
#define BIT_GYRO_SELF_TEST_DONE 0x01
/* Bank0 REG_SELF_TEST_CONFIG */
#define BIT_SELF_TEST_REGULATOR_EN 0x40
#define BIT_TEST_AZ_EN 0x20
#define BIT_TEST_AY_EN 0x10
#define BIT_TEST_AX_EN 0x08
#define BIT_TEST_GZ_EN 0x04
#define BIT_TEST_GY_EN 0x02
#define BIT_TEST_GX_EN 0x01
/* Bank0 REG_INT_STATUS */
#define BIT_INT_STATUS_AGC_RDY 0x01
#define BIT_INT_STATUS_FIFO_FULL 0x02
#define BIT_INT_STATUS_FIFO_THS 0x04
#define BIT_INT_STATUS_DRDY 0x08
#define BIT_INT_STATUS_RESET_DONE 0x10
#define BIT_INT_STATUS_PLL_DRY 0x20
#define BIT_INT_STATUS_UI_FSYNC 0x40
/* Bank0 REG_INT_STATUS2 */
#define BIT_INT_STATUS_WOM_X 0x01
#define BIT_INT_STATUS_WOM_Y 0x02
#define BIT_INT_STATUS_WOM_Z 0x04
#define BIT_INT_STATUS_SMD 0x08
#define BIT_INT_STATUS_WOM_XYZ \
(BIT_INT_STATUS_WOM_X | BIT_INT_STATUS_WOM_Y | BIT_INT_STATUS_WOM_Z)
/* Bank0 REG_INT_STATUS3 */
#define BIT_INT_STATUS_TAP_DET 0x01
#define BIT_INT_STATUS_SLEEP_DET 0x02
#define BIT_INT_STATUS_RAISE_DET 0x04
#define BIT_INT_STATUS_TILT_DET 0x08
#define BIT_INT_STATUS_STEP_CNT_OVFL 0x10
#define BIT_INT_STATUS_STEP_DET 0x20
#define BIT_INT_STATUS_DMP_POWER_SAVE 0x40
/* Bank0 REG_FIFO_CONFIG_REG */
#define BIT_FIFO_MODE_BYPASS 0x00
#define BIT_FIFO_MODE_STREAM 0x40
#define BIT_FIFO_MODE_STOP_FULL 0x80
/* Bank0 REG_GYRO_ACCEL_CONFIG0 */
#define BIT_ACCEL_UI_LNM_BW_2_FIR 0x00
#define BIT_ACCEL_UI_LNM_BW_4_IIR 0x10
#define BIT_ACCEL_UI_LNM_BW_5_IIR 0x20
#define BIT_ACCEL_UI_LNM_BW_8_IIR 0x30
#define BIT_ACCEL_UI_LNM_BW_10_IIR 0x40
#define BIT_ACCEL_UI_LNM_BW_16_IIR 0x50
#define BIT_ACCEL_UI_LNM_BW_20_IIR 0x60
#define BIT_ACCEL_UI_LNM_BW_40_IIR 0x70
#define BIT_ACCEL_UI_LNM_AVG_1 0xF0
#define BIT_ACCEL_UI_LPM_BW_2_FIR 0x00
#define BIT_ACCEL_UI_LPM_AVG_1 0x10
#define BIT_ACCEL_UI_LPM_AVG_2 0x20
#define BIT_ACCEL_UI_LPM_AVG_3 0x30
#define BIT_ACCEL_UI_LPM_AVG_4 0x40
#define BIT_ACCEL_UI_LPM_AVG_8 0x50
#define BIT_ACCEL_UI_LPM_AVG_16 0x60
#define BIT_ACCEL_UI_LPM_AVG_32 0x70
#define BIT_ACCEL_UI_LPM_AVG_64 0x80
#define BIT_ACCEL_UI_LPM_AVG_128 0x90
#define BIT_GYRO_UI_LNM_BW_2_FIR 0x00
#define BIT_GYRO_UI_LNM_BW_4_IIR 0x01
#define BIT_GYRO_UI_LNM_BW_5_IIR 0x02
#define BIT_GYRO_UI_LNM_BW_8_IIR 0x03
#define BIT_GYRO_UI_LNM_BW_10_IIR 0x04
#define BIT_GYRO_UI_LNM_BW_16_IIR 0x05
#define BIT_GYRO_UI_LNM_BW_20_IIR 0x06
#define BIT_GYRO_UI_LNM_BW_40_IIR 0x07
#define BIT_GYRO_UI_LNM_AVG_1 0xF0
#define BIT_GYRO_UI_LPM_BW_2_FIR 0x00
#define BIT_GYRO_UI_LPM_AVG_1 0x01
#define BIT_GYRO_UI_LPM_AVG_2 0x02
#define BIT_GYRO_UI_LPM_AVG_3 0x03
#define BIT_GYRO_UI_LPM_AVG_4 0x04
#define BIT_GYRO_UI_LPM_AVG_8 0x05
#define BIT_GYRO_UI_LPM_AVG_16 0x06
#define BIT_GYRO_UI_LPM_AVG_32 0x07
#define BIT_GYRO_UI_LPM_AVG_64 0x08
#define BIT_GYRO_UI_LPM_AVG_128 0x09
/* Bank0 REG_SMD_CONFIG */
#define BIT_WOM_INT_MODE_OR 0x00
#define BIT_WOM_INT_MODE_AND 0x08
#define BIT_WOM_MODE_INITIAL 0x00
#define BIT_WOM_MODE_PREV 0x04
#define BIT_SMD_MODE_OFF 0x00
#define BIT_SMD_MODE_OLD 0x01
#define BIT_SMD_MODE_SHORT 0x02
#define BIT_SMD_MODE_LONG 0x03
/* Bank0 REG_TMST_CONFIG */
#define BIT_FIFO_RAM_ISO_ENA 0x40
#define BIT_EN_DREG_FIFO_D2A 0x20
#define BIT_TMST_TO_REGS_EN 0x10
#define BIT_TMST_RESOL 0x08
#define BIT_TMST_DELTA_EN 0x04
#define BIT_TMST_FSYNC_EN 0x02
#define BIT_TMST_EN 0x01
/* Bank0 REG_APEX_CONFIG0 */
#define BIT_DMP_ODR_25HZ 0x00
#define BIT_DMP_ODR_50HZ 0x02
#define BIT_DMP_ODR_100HZ 0x03
#define BIT_RAISE_ENABLE 0x08
#define BIT_TILT_ENABLE 0x10
#define BIT_PEDO_ENABLE 0x20
#define BIT_TAP_ENABLE 0x40
#define BIT_DMP_POWER_SAVE_EN 0x80
/* Bank0 REG_ACCEL_CONFIG0 */
#define BIT_ACCEL_FSR 0xE0
#define BIT_ACCEL_ODR 0x0F
#define BIT_ACCEL_ODR_8000 0x03
#define BIT_ACCEL_ODR_4000 0x04
#define BIT_ACCEL_ODR_2000 0x05
#define BIT_ACCEL_ODR_1000 0x06
#define BIT_ACCEL_ODR_500 0x0F
#define BIT_ACCEL_ODR_200 0x07
#define BIT_ACCEL_ODR_100 0x08
#define BIT_ACCEL_ODR_50 0x09
#define BIT_ACCEL_ODR_25 0x0A
#define BIT_ACCEL_ODR_12 0x0B
#define BIT_ACCEL_ODR_6 0x0C
#define BIT_ACCEL_ODR_3 0x0D
#define BIT_ACCEL_ODR_1 0x0E
/* Bank0 REG_GYRO_CONFIG0 */
#define BIT_GYRO_FSR 0xE0
#define BIT_GYRO_ODR 0x0F
#define BIT_GYRO_ODR_8000 0x03
#define BIT_GYRO_ODR_4000 0x04
#define BIT_GYRO_ODR_2000 0x05
#define BIT_GYRO_ODR_1000 0x06
#define BIT_GYRO_ODR_500 0x0F
#define BIT_GYRO_ODR_200 0x07
#define BIT_GYRO_ODR_100 0x08
#define BIT_GYRO_ODR_50 0x09
#define BIT_GYRO_ODR_25 0x0A
#define BIT_GYRO_ODR_12 0x0B
/* Bank1 REG_INTF_CONFIG5 */
#define BIT_PIN9_FUNC_INT2 0x00
#define BIT_PIN9_FUNC_FSYNC 0x02
#define BIT_PIN9_FUNC_CLKIN 0x04
#define BIT_PIN9_FUNC_RSV 0x06
/* Bank4 REG_DRV_GYR_CFG0_REG */
#define GYRO_DRV_TEST_FSMFORCE_D2A_LINEAR_START_MODE 0x0D
#define GYRO_DRV_TEST_FSMFORCE_D2A_STEADY_STATE_AGC_REG_MODE 0x2A
/* Bank4 REG_DRV_GYR_CFG2_REG */
#define GYRO_DRV_SPARE2_D2A_EN 0x01
/* Bank4 REG_INT_SOURCE6 */
#define BIT_INT_TAP_DET_INT1_EN 0x01
#define BIT_INT_SLEEP_DET_INT1_EN 0x02
#define BIT_INT_RAISE_DET_INT1_EN 0x04
#define BIT_INT_TILT_DET_INT1_EN 0x08
#define BIT_INT_STEP_CNT_OVFL_INT1_EN 0x10
#define BIT_INT_STEP_DET_INT1_EN 0x20
#define BIT_INT_DMP_POWER_SAVE_INT1_EN 0x40
/* Bank4 REG_INT_SOURCE7 */
#define BIT_INT_TAP_DET_INT2_EN 0x01
#define BIT_INT_HIGHG_DET_INT2_EN 0x02
#define BIT_INT_LOWG_DET_INT2_EN 0x04
#define BIT_INT_TILT_DET_INT2_EN 0x80
#define BIT_INT_STEP_CNT_OVFL_INT2_EN 0x10
#define BIT_INT_STEP_DET_INT2_EN 0x20
#define BIT_INT_DMP_POWER_SAVE_INT2_EN 0x40
/* Bank4 REG_INT_SOURCE8 */
#define BIT_INT_AGC_RDY_IBI_EN 0x01
#define BIT_INT_FIFO_FULL_IBI_EN 0x02
#define BIT_INT_FIFO_THS_IBI_EN 0x04
#define BIT_INT_UI_DRDY_IBI_EN 0x08
#define BIT_INT_PLL_RDY_IBI_EN 0x10
#define BIT_INT_FSYNC_IBI_EN 0x20
#define BIT_INT_OIS1_DRDY_IBI_EN 0x40
/* Bank4 REG_INT_SOURCE9 */
#define BIT_INT_DMP_POWER_SAVE_IBI_EN 0x01
#define BIT_INT_WOM_X_IBI_EN 0x02
#define BIT_INT_WOM_Y_IBI_EN 0x04
#define BIT_INT_WOM_Z_IBI_EN 0x08
#define BIT_INT_SMD_IBI_EN 0x10
/* Bank4 REG_INT_SOURCE10 */
#define BIT_INT_TAP_DET_IBI_EN 0x01
#define BIT_INT_HIGHG_DET_IBI_EN 0x02
#define BIT_INT_LOWG_DET_IBI_EN 0x04
#define BIT_INT_TILT_DET_IBI_EN 0x08
#define BIT_INT_STEP_CNT_OVFL_IBI_EN 0x10
#define BIT_INT_STEP_DET_IBI_EN 0x20
/* fifo data packet header */
#define BIT_FIFO_HEAD_MSG 0x80
#define BIT_FIFO_HEAD_ACCEL 0x40
#define BIT_FIFO_HEAD_GYRO 0x20
#define BIT_FIFO_HEAD_20 0x10
#define BIT_FIFO_HEAD_TMSP_ODR 0x08
#define BIT_FIFO_HEAD_TMSP_NO_ODR 0x04
#define BIT_FIFO_HEAD_TMSP_FSYNC 0x0C
#define BIT_FIFO_HEAD_ODR_ACCEL 0x02
#define BIT_FIFO_HEAD_ODR_GYRO 0x01
/* data definitions */
#define FIFO_PACKET_BYTE_SINGLE 8
#define FIFO_PACKET_BYTE_6X 16
#define FIFO_PACKET_BYTE_HIRES 20
#define FIFO_COUNT_BYTE 2
/* sensor startup time */
#define INV_ICM42600_GYRO_START_TIME 100
#define INV_ICM42600_ACCEL_START_TIME 50
/* temperature sensor */
/* scale by 100, 1LSB=1degC, 9447 */
#define TEMP_SCALE 100
/* 25 degC */
#define TEMP_OFFSET (25 * TEMP_SCALE)
#ifdef SUPPORT_RTC_MODE
#define BASE_SAMPLE_RATE (RTC_FREQ_HZ / 32)
#else
#define BASE_SAMPLE_RATE 1000
#endif
#define GESTURE_ACCEL_RATE 50
#define ESI_GYRO_RATE 1000
#define MPU_INIT_SENSOR_RATE_LNM 12 /* min Hz in LNM */
#define MPU_INIT_SENSOR_RATE_LPM 3 /* min Hz in LPM */
#define MAX_FIFO_PACKET_READ 16
#define HARDWARE_FIFO_SIZE 2048
#define FIFO_SIZE (HARDWARE_FIFO_SIZE * 7 / 8)
#define LEFT_OVER_BYTES 128
#define POWER_UP_TIME 100
#define REG_UP_TIME_USEC 100
#define IIO_BUFFER_BYTES 8
#define BYTES_PER_SENSOR 6
#define BYTES_FOR_TEMP 1
#define MAX_BATCH_FIFO_SIZE FIFO_SIZE
#define FIRST_DROP_SAMPLES_ACC_500HZ 20
#define FIRST_DROP_SAMPLES_ACC_200HZ 10
#define FIRST_DROP_SAMPLES_GYR_500HZ 20
#define FIRST_DROP_SAMPLES_GYR_200HZ 10
#define WOM_THRESHOLD 13 /* 1000 / 256 * 13 = 50.7mg */
#define BIT_GYRO_FSR 0xE0
#define BIT_GYRO_ODR 0x0F
#define BIT_ACCEL_FSR 0xE0
#define BIT_ACCEL_ODR 0x0F
#define FIFO_ACCEL0_RESET_VALUE 0x80
#define FIFO_ACCEL1_RESET_VALUE 0x00
#define FIFO_GYRO0_RESET_VALUE 0x80
#define FIFO_GYRO1_RESET_VALUE 0x00
#define APEX_TAP 0x08
#define APEX_DOUBLE_TAP 0x10
/*
* INT configurations
* Polarity: 0 -> Active Low, 1 -> Active High
* Drive circuit: 0 -> Open Drain, 1 -> Push-Pull
* Mode: 0 -> Pulse, 1 -> Latch
*/
#define INT_POLARITY 1
#define INT_DRIVE_CIRCUIT 1
#define INT_MODE 0
#define ACC_LPM_MAX_RATE 500
#define GYR_LPM_MAX_RATE 200
enum {
GYRO_FS_2000DPS = 0,
GYRO_FS_1000DPS,
GYRO_FS_500DPS,
GYRO_FS_250DPS,
GYRO_FS_125DPS,
GYRO_FS_62DPS,
GYRO_FS_32DPS,
GYRO_FS_15DPS,
};
enum {
ACCEL_FS_16G = 0,
ACCEL_FS_8G,
ACCEL_FS_4G,
ACCEL_FS_2G,
};
#endif /* __SENSOR_ICM42605_ICM42605_REG__ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605_reg.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,158 |
```c
/*
*
*/
#include <zephyr/logging/log.h>
#include <zephyr/sys/__assert.h>
#include "icm42605_spi.h"
LOG_MODULE_DECLARE(ICM42605, CONFIG_SENSOR_LOG_LEVEL);
int inv_spi_single_write(const struct spi_dt_spec *bus, uint8_t reg, uint8_t *data)
{
int result;
const struct spi_buf buf[2] = {
{
.buf = ®,
.len = 1,
},
{
.buf = data,
.len = 1,
}
};
const struct spi_buf_set tx = {
.buffers = buf,
.count = 2,
};
result = spi_write_dt(bus, &tx);
if (result) {
return result;
}
return 0;
}
int inv_spi_read(const struct spi_dt_spec *bus, uint8_t reg, uint8_t *data, size_t len)
{
int result;
unsigned char tx_buffer[2] = { 0, };
tx_buffer[0] = 0x80 | reg;
const struct spi_buf tx_buf = {
.buf = tx_buffer,
.len = 1,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1,
};
struct spi_buf rx_buf[2] = {
{
.buf = tx_buffer,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2,
};
result = spi_transceive_dt(bus, &tx, &rx);
if (result) {
return result;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 386 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_SPI_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42605_ICM42605_SPI_H_
#include <zephyr/device.h>
#include <zephyr/drivers/spi.h>
int inv_spi_single_write(const struct spi_dt_spec *bus, uint8_t reg, uint8_t *data);
int inv_spi_read(const struct spi_dt_spec *bus, uint8_t reg, uint8_t *data, size_t len);
#endif /* __SENSOR_ICM42605_ICM42605_SPI__ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605_spi.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 126 |
```unknown
# ICM42605 Six-Axis Motion Tracking device configuration options
menuconfig ICM42605
bool "ICM42605 Six-Axis Motion Tracking Device"
default y
depends on DT_HAS_INVENSENSE_ICM42605_ENABLED
select SPI
help
Enable driver for ICM42605 SPI-based six-axis motion tracking device.
if ICM42605
choice ICM42605_TRIGGER_MODE
prompt "Trigger mode"
default ICM42605_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config ICM42605_TRIGGER_NONE
bool "No trigger"
config ICM42605_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ICM42605_TRIGGER
endchoice
config ICM42605_TRIGGER
bool
config ICM42605_THREAD_PRIORITY
int "Thread priority"
depends on ICM42605_TRIGGER_GLOBAL_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config ICM42605_THREAD_STACK_SIZE
int "Thread stack size"
depends on ICM42605_TRIGGER_GLOBAL_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # ICM42605
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 264 |
```c
/*
*
*/
#define DT_DRV_COMPAT invensense_mpu6050
#include <zephyr/drivers/i2c.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "mpu6050.h"
LOG_MODULE_REGISTER(MPU6050, CONFIG_SENSOR_LOG_LEVEL);
/* see "Accelerometer Measurements" section from register map description */
static void mpu6050_convert_accel(struct sensor_value *val, int16_t raw_val,
uint16_t sensitivity_shift)
{
int64_t conv_val;
conv_val = ((int64_t)raw_val * SENSOR_G) >> sensitivity_shift;
val->val1 = conv_val / 1000000;
val->val2 = conv_val % 1000000;
}
/* see "Gyroscope Measurements" section from register map description */
static void mpu6050_convert_gyro(struct sensor_value *val, int16_t raw_val,
uint16_t sensitivity_x10)
{
int64_t conv_val;
conv_val = ((int64_t)raw_val * SENSOR_PI * 10) /
(sensitivity_x10 * 180U);
val->val1 = conv_val / 1000000;
val->val2 = conv_val % 1000000;
}
/* see "Temperature Measurement" section from register map description */
static inline void mpu6050_convert_temp(enum mpu6050_device_type device_type,
struct sensor_value *val,
int16_t raw_val)
{
int64_t tmp_val = (int64_t)raw_val * 1000000;
switch (device_type) {
case DEVICE_TYPE_MPU6500:
tmp_val = (tmp_val * 1000 / 333870) + 21000000;
break;
case DEVICE_TYPE_MPU6050:
default:
tmp_val = (tmp_val / 340) + 36000000;
};
val->val1 = tmp_val / 1000000;
val->val2 = tmp_val % 1000000;
}
static int mpu6050_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct mpu6050_data *drv_data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
mpu6050_convert_accel(val, drv_data->accel_x,
drv_data->accel_sensitivity_shift);
mpu6050_convert_accel(val + 1, drv_data->accel_y,
drv_data->accel_sensitivity_shift);
mpu6050_convert_accel(val + 2, drv_data->accel_z,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_X:
mpu6050_convert_accel(val, drv_data->accel_x,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Y:
mpu6050_convert_accel(val, drv_data->accel_y,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Z:
mpu6050_convert_accel(val, drv_data->accel_z,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_GYRO_XYZ:
mpu6050_convert_gyro(val, drv_data->gyro_x,
drv_data->gyro_sensitivity_x10);
mpu6050_convert_gyro(val + 1, drv_data->gyro_y,
drv_data->gyro_sensitivity_x10);
mpu6050_convert_gyro(val + 2, drv_data->gyro_z,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_X:
mpu6050_convert_gyro(val, drv_data->gyro_x,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Y:
mpu6050_convert_gyro(val, drv_data->gyro_y,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Z:
mpu6050_convert_gyro(val, drv_data->gyro_z,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_DIE_TEMP:
mpu6050_convert_temp(drv_data->device_type, val, drv_data->temp);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int mpu6050_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct mpu6050_data *drv_data = dev->data;
const struct mpu6050_config *cfg = dev->config;
int16_t buf[7];
if (i2c_burst_read_dt(&cfg->i2c, MPU6050_REG_DATA_START, (uint8_t *)buf,
14) < 0) {
LOG_ERR("Failed to read data sample.");
return -EIO;
}
drv_data->accel_x = sys_be16_to_cpu(buf[0]);
drv_data->accel_y = sys_be16_to_cpu(buf[1]);
drv_data->accel_z = sys_be16_to_cpu(buf[2]);
drv_data->temp = sys_be16_to_cpu(buf[3]);
drv_data->gyro_x = sys_be16_to_cpu(buf[4]);
drv_data->gyro_y = sys_be16_to_cpu(buf[5]);
drv_data->gyro_z = sys_be16_to_cpu(buf[6]);
return 0;
}
static const struct sensor_driver_api mpu6050_driver_api = {
#if CONFIG_MPU6050_TRIGGER
.trigger_set = mpu6050_trigger_set,
#endif
.sample_fetch = mpu6050_sample_fetch,
.channel_get = mpu6050_channel_get,
};
int mpu6050_init(const struct device *dev)
{
struct mpu6050_data *drv_data = dev->data;
const struct mpu6050_config *cfg = dev->config;
uint8_t id, i;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
/* check chip ID */
if (i2c_reg_read_byte_dt(&cfg->i2c, MPU6050_REG_CHIP_ID, &id) < 0) {
LOG_ERR("Failed to read chip ID.");
return -EIO;
}
if (id == MPU6050_CHIP_ID || id == MPU9250_CHIP_ID || id == MPU6880_CHIP_ID) {
LOG_DBG("MPU6050/MPU9250/MPU6880 detected");
drv_data->device_type = DEVICE_TYPE_MPU6050;
} else if (id == MPU6500_CHIP_ID) {
LOG_DBG("MPU6500 detected");
drv_data->device_type = DEVICE_TYPE_MPU6500;
} else {
LOG_ERR("Invalid chip ID.");
return -EINVAL;
}
/* wake up chip */
if (i2c_reg_update_byte_dt(&cfg->i2c, MPU6050_REG_PWR_MGMT1,
MPU6050_SLEEP_EN, 0) < 0) {
LOG_ERR("Failed to wake up chip.");
return -EIO;
}
/* set accelerometer full-scale range */
for (i = 0U; i < 4; i++) {
if (BIT(i+1) == CONFIG_MPU6050_ACCEL_FS) {
break;
}
}
if (i == 4U) {
LOG_ERR("Invalid value for accel full-scale range.");
return -EINVAL;
}
if (i2c_reg_write_byte_dt(&cfg->i2c, MPU6050_REG_ACCEL_CFG,
i << MPU6050_ACCEL_FS_SHIFT) < 0) {
LOG_ERR("Failed to write accel full-scale range.");
return -EIO;
}
drv_data->accel_sensitivity_shift = 14 - i;
/* set gyroscope full-scale range */
for (i = 0U; i < 4; i++) {
if (BIT(i) * 250 == CONFIG_MPU6050_GYRO_FS) {
break;
}
}
if (i == 4U) {
LOG_ERR("Invalid value for gyro full-scale range.");
return -EINVAL;
}
if (i2c_reg_write_byte_dt(&cfg->i2c, MPU6050_REG_GYRO_CFG,
i << MPU6050_GYRO_FS_SHIFT) < 0) {
LOG_ERR("Failed to write gyro full-scale range.");
return -EIO;
}
drv_data->gyro_sensitivity_x10 = mpu6050_gyro_sensitivity_x10[i];
#ifdef CONFIG_MPU6050_TRIGGER
if (cfg->int_gpio.port) {
if (mpu6050_init_interrupt(dev) < 0) {
LOG_DBG("Failed to initialize interrupts.");
return -EIO;
}
}
#endif
return 0;
}
#define MPU6050_DEFINE(inst) \
static struct mpu6050_data mpu6050_data_##inst; \
\
static const struct mpu6050_config mpu6050_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
IF_ENABLED(CONFIG_MPU6050_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, mpu6050_init, NULL, \
&mpu6050_data_##inst, &mpu6050_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&mpu6050_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(MPU6050_DEFINE)
``` | /content/code_sandbox/drivers/sensor/tdk/mpu6050/mpu6050.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,124 |
```c
/*
*
*/
#define DT_DRV_COMPAT invensense_icm42605
#include <zephyr/drivers/spi.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "icm42605.h"
#include "icm42605_reg.h"
#include "icm42605_setup.h"
#include "icm42605_spi.h"
LOG_MODULE_REGISTER(ICM42605, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t icm42605_gyro_sensitivity_x10[] = {
1310, 655, 328, 164
};
/* see "Accelerometer Measurements" section from register map description */
static void icm42605_convert_accel(struct sensor_value *val,
int16_t raw_val,
uint16_t sensitivity_shift)
{
int64_t conv_val;
conv_val = ((int64_t)raw_val * SENSOR_G) >> sensitivity_shift;
val->val1 = conv_val / 1000000;
val->val2 = conv_val % 1000000;
}
/* see "Gyroscope Measurements" section from register map description */
static void icm42605_convert_gyro(struct sensor_value *val,
int16_t raw_val,
uint16_t sensitivity_x10)
{
int64_t conv_val;
conv_val = ((int64_t)raw_val * SENSOR_PI * 10) /
(sensitivity_x10 * 180U);
val->val1 = conv_val / 1000000;
val->val2 = conv_val % 1000000;
}
/* see "Temperature Measurement" section from register map description */
static inline void icm42605_convert_temp(struct sensor_value *val,
int16_t raw_val)
{
val->val1 = (((int64_t)raw_val * 100) / 207) + 25;
val->val2 = ((((int64_t)raw_val * 100) % 207) * 1000000) / 207;
if (val->val2 < 0) {
val->val1--;
val->val2 += 1000000;
} else if (val->val2 >= 1000000) {
val->val1++;
val->val2 -= 1000000;
}
}
static int icm42605_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
const struct icm42605_data *drv_data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
icm42605_convert_accel(val, drv_data->accel_x,
drv_data->accel_sensitivity_shift);
icm42605_convert_accel(val + 1, drv_data->accel_y,
drv_data->accel_sensitivity_shift);
icm42605_convert_accel(val + 2, drv_data->accel_z,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_X:
icm42605_convert_accel(val, drv_data->accel_x,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Y:
icm42605_convert_accel(val, drv_data->accel_y,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Z:
icm42605_convert_accel(val, drv_data->accel_z,
drv_data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_GYRO_XYZ:
icm42605_convert_gyro(val, drv_data->gyro_x,
drv_data->gyro_sensitivity_x10);
icm42605_convert_gyro(val + 1, drv_data->gyro_y,
drv_data->gyro_sensitivity_x10);
icm42605_convert_gyro(val + 2, drv_data->gyro_z,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_X:
icm42605_convert_gyro(val, drv_data->gyro_x,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Y:
icm42605_convert_gyro(val, drv_data->gyro_y,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Z:
icm42605_convert_gyro(val, drv_data->gyro_z,
drv_data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_DIE_TEMP:
icm42605_convert_temp(val, drv_data->temp);
break;
default:
return -ENOTSUP;
}
return 0;
}
int icm42605_tap_fetch(const struct device *dev)
{
int result = 0;
struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
if (drv_data->tap_en &&
(drv_data->tap_handler || drv_data->double_tap_handler)) {
result = inv_spi_read(&cfg->spi, REG_INT_STATUS3, drv_data->fifo_data, 1);
if (drv_data->fifo_data[0] & BIT_INT_STATUS_TAP_DET) {
result = inv_spi_read(&cfg->spi, REG_APEX_DATA4,
drv_data->fifo_data, 1);
if (drv_data->fifo_data[0] & APEX_TAP) {
if (drv_data->tap_trigger->type ==
SENSOR_TRIG_TAP) {
if (drv_data->tap_handler) {
LOG_DBG("Single Tap detected");
drv_data->tap_handler(dev
, drv_data->tap_trigger);
}
} else {
LOG_ERR("Trigger type is mismatched");
}
} else if (drv_data->fifo_data[0] & APEX_DOUBLE_TAP) {
if (drv_data->double_tap_trigger->type ==
SENSOR_TRIG_DOUBLE_TAP) {
if (drv_data->double_tap_handler) {
LOG_DBG("Double Tap detected");
drv_data->double_tap_handler(dev
, drv_data->tap_trigger);
}
} else {
LOG_ERR("Trigger type is mismatched");
}
} else {
LOG_DBG("Not supported tap event");
}
}
}
return 0;
}
static int icm42605_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
int result = 0;
uint16_t fifo_count = 0;
struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
/* Read INT_STATUS (0x45) and FIFO_COUNTH(0x46), FIFO_COUNTL(0x47) */
result = inv_spi_read(&cfg->spi, REG_INT_STATUS, drv_data->fifo_data, 3);
if (drv_data->fifo_data[0] & BIT_INT_STATUS_DRDY) {
fifo_count = (drv_data->fifo_data[1] << 8)
+ (drv_data->fifo_data[2]);
result = inv_spi_read(&cfg->spi, REG_FIFO_DATA, drv_data->fifo_data,
fifo_count);
/* FIFO Data structure
* Packet 1 : FIFO Header(1), AccelX(2), AccelY(2),
* AccelZ(2), Temperature(1)
* Packet 2 : FIFO Header(1), GyroX(2), GyroY(2),
* GyroZ(2), Temperature(1)
* Packet 3 : FIFO Header(1), AccelX(2), AccelY(2), AccelZ(2),
* GyroX(2), GyroY(2), GyroZ(2), Temperature(1)
*/
if (drv_data->fifo_data[0] & BIT_FIFO_HEAD_ACCEL) {
/* Check empty values */
if (!(drv_data->fifo_data[1] == FIFO_ACCEL0_RESET_VALUE
&& drv_data->fifo_data[2] ==
FIFO_ACCEL1_RESET_VALUE)) {
drv_data->accel_x =
(drv_data->fifo_data[1] << 8)
+ (drv_data->fifo_data[2]);
drv_data->accel_y =
(drv_data->fifo_data[3] << 8)
+ (drv_data->fifo_data[4]);
drv_data->accel_z =
(drv_data->fifo_data[5] << 8)
+ (drv_data->fifo_data[6]);
}
if (!(drv_data->fifo_data[0] & BIT_FIFO_HEAD_GYRO)) {
drv_data->temp =
(int16_t)(drv_data->fifo_data[7]);
} else {
if (!(drv_data->fifo_data[7] ==
FIFO_GYRO0_RESET_VALUE &&
drv_data->fifo_data[8] ==
FIFO_GYRO1_RESET_VALUE)) {
drv_data->gyro_x =
(drv_data->fifo_data[7] << 8)
+ (drv_data->fifo_data[8]);
drv_data->gyro_y =
(drv_data->fifo_data[9] << 8)
+ (drv_data->fifo_data[10]);
drv_data->gyro_z =
(drv_data->fifo_data[11] << 8)
+ (drv_data->fifo_data[12]);
}
drv_data->temp =
(int16_t)(drv_data->fifo_data[13]);
}
} else {
if (drv_data->fifo_data[0] & BIT_FIFO_HEAD_GYRO) {
if (!(drv_data->fifo_data[1] ==
FIFO_GYRO0_RESET_VALUE &&
drv_data->fifo_data[2] ==
FIFO_GYRO1_RESET_VALUE)) {
drv_data->gyro_x =
(drv_data->fifo_data[1] << 8)
+ (drv_data->fifo_data[2]);
drv_data->gyro_y =
(drv_data->fifo_data[3] << 8)
+ (drv_data->fifo_data[4]);
drv_data->gyro_z =
(drv_data->fifo_data[5] << 8)
+ (drv_data->fifo_data[6]);
}
drv_data->temp =
(int16_t)(drv_data->fifo_data[7]);
}
}
}
return 0;
}
static int icm42605_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct icm42605_data *drv_data = dev->data;
__ASSERT_NO_MSG(val != NULL);
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
if (val->val1 > 8000 || val->val1 < 1) {
LOG_ERR("Incorrect sampling value");
return -EINVAL;
} else {
drv_data->accel_hz = val->val1;
}
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
if (val->val1 < ACCEL_FS_16G ||
val->val1 > ACCEL_FS_2G) {
LOG_ERR("Incorrect fullscale value");
return -EINVAL;
} else {
drv_data->accel_sf = val->val1;
}
} else {
LOG_ERR("Not supported ATTR");
return -ENOTSUP;
}
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
if (val->val1 > 8000 || val->val1 < 12) {
LOG_ERR("Incorrect sampling value");
return -EINVAL;
} else {
drv_data->gyro_hz = val->val1;
}
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
if (val->val1 < GYRO_FS_2000DPS ||
val->val1 > GYRO_FS_15DPS) {
LOG_ERR("Incorrect fullscale value");
return -EINVAL;
} else {
drv_data->gyro_sf = val->val1;
}
} else {
LOG_ERR("Not supported ATTR");
return -EINVAL;
}
break;
default:
LOG_ERR("Not support");
return -EINVAL;
}
return 0;
}
static int icm42605_attr_get(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
struct sensor_value *val)
{
const struct icm42605_data *drv_data = dev->data;
__ASSERT_NO_MSG(val != NULL);
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
val->val1 = drv_data->accel_hz;
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
val->val1 = drv_data->accel_sf;
} else {
LOG_ERR("Not supported ATTR");
return -EINVAL;
}
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
val->val1 = drv_data->gyro_hz;
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
val->val1 = drv_data->gyro_sf;
} else {
LOG_ERR("Not supported ATTR");
return -EINVAL;
}
break;
default:
LOG_ERR("Not support");
return -EINVAL;
}
return 0;
}
static int icm42605_data_init(struct icm42605_data *data,
const struct icm42605_config *cfg)
{
data->accel_x = 0;
data->accel_y = 0;
data->accel_z = 0;
data->temp = 0;
data->gyro_x = 0;
data->gyro_y = 0;
data->gyro_z = 0;
data->accel_hz = cfg->accel_hz;
data->gyro_hz = cfg->gyro_hz;
data->accel_sf = cfg->accel_fs;
data->gyro_sf = cfg->gyro_fs;
data->tap_en = false;
data->sensor_started = false;
return 0;
}
static int icm42605_init(const struct device *dev)
{
struct icm42605_data *drv_data = dev->data;
const struct icm42605_config *cfg = dev->config;
if (!spi_is_ready_dt(&cfg->spi)) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
}
icm42605_data_init(drv_data, cfg);
icm42605_sensor_init(dev);
drv_data->accel_sensitivity_shift = 14 - 3;
drv_data->gyro_sensitivity_x10 = icm42605_gyro_sensitivity_x10[3];
#ifdef CONFIG_ICM42605_TRIGGER
if (icm42605_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupts.");
return -EIO;
}
#endif
LOG_DBG("Initialize interrupt done");
return 0;
}
static const struct sensor_driver_api icm42605_driver_api = {
#ifdef CONFIG_ICM42605_TRIGGER
.trigger_set = icm42605_trigger_set,
#endif
.sample_fetch = icm42605_sample_fetch,
.channel_get = icm42605_channel_get,
.attr_set = icm42605_attr_set,
.attr_get = icm42605_attr_get,
};
#define ICM42605_DEFINE_CONFIG(index) \
static const struct icm42605_config icm42605_cfg_##index = { \
.spi = SPI_DT_SPEC_INST_GET(index, \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA | \
SPI_WORD_SET(8) | \
SPI_TRANSFER_MSB, \
0U), \
.gpio_int = GPIO_DT_SPEC_INST_GET(index, int_gpios), \
.accel_hz = DT_INST_PROP(index, accel_hz), \
.gyro_hz = DT_INST_PROP(index, gyro_hz), \
.accel_fs = DT_INST_ENUM_IDX(index, accel_fs), \
.gyro_fs = DT_INST_ENUM_IDX(index, gyro_fs), \
}
#define ICM42605_INIT(index) \
ICM42605_DEFINE_CONFIG(index); \
static struct icm42605_data icm42605_driver_##index; \
SENSOR_DEVICE_DT_INST_DEFINE(index, icm42605_init, \
NULL, \
&icm42605_driver_##index, \
&icm42605_cfg_##index, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&icm42605_driver_api);
DT_INST_FOREACH_STATUS_OKAY(ICM42605_INIT)
``` | /content/code_sandbox/drivers/sensor/tdk/icm42605/icm42605.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,810 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_MPU6050_MPU6050_H_
#define ZEPHYR_DRIVERS_SENSOR_MPU6050_MPU6050_H_
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#include <zephyr/types.h>
#define MPU6050_REG_CHIP_ID 0x75
#define MPU6050_CHIP_ID 0x68
#define MPU6500_CHIP_ID 0x70
#define MPU9250_CHIP_ID 0x71
#define MPU6880_CHIP_ID 0x19
#define MPU6050_REG_GYRO_CFG 0x1B
#define MPU6050_GYRO_FS_SHIFT 3
#define MPU6050_REG_ACCEL_CFG 0x1C
#define MPU6050_ACCEL_FS_SHIFT 3
#define MPU6050_REG_INT_EN 0x38
#define MPU6050_DRDY_EN BIT(0)
#define MPU6050_REG_DATA_START 0x3B
#define MPU6050_REG_PWR_MGMT1 0x6B
#define MPU6050_SLEEP_EN BIT(6)
/* measured in degrees/sec x10 to avoid floating point */
static const uint16_t mpu6050_gyro_sensitivity_x10[] = {
1310, 655, 328, 164
};
/* Device type, uses the correct offets for a particular device */
enum mpu6050_device_type {
DEVICE_TYPE_MPU6050 = 0,
DEVICE_TYPE_MPU6500,
};
struct mpu6050_data {
int16_t accel_x;
int16_t accel_y;
int16_t accel_z;
uint16_t accel_sensitivity_shift;
int16_t temp;
int16_t gyro_x;
int16_t gyro_y;
int16_t gyro_z;
uint16_t gyro_sensitivity_x10;
enum mpu6050_device_type device_type;
#ifdef CONFIG_MPU6050_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_MPU6050_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_MPU6050_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_MPU6050_TRIGGER */
};
struct mpu6050_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_MPU6050_TRIGGER
struct gpio_dt_spec int_gpio;
#endif /* CONFIG_MPU6050_TRIGGER */
};
#ifdef CONFIG_MPU6050_TRIGGER
int mpu6050_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int mpu6050_init_interrupt(const struct device *dev);
#endif
#endif /* __SENSOR_MPU6050__ */
``` | /content/code_sandbox/drivers/sensor/tdk/mpu6050/mpu6050.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 645 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "mpu6050.h"
LOG_MODULE_DECLARE(MPU6050, CONFIG_SENSOR_LOG_LEVEL);
int mpu6050_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct mpu6050_data *drv_data = dev->data;
const struct mpu6050_config *cfg = dev->config;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
if (trig->type != SENSOR_TRIG_DATA_READY) {
return -ENOTSUP;
}
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_DISABLE);
drv_data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
drv_data->data_ready_trigger = trig;
gpio_pin_interrupt_configure_dt(&cfg->int_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
return 0;
}
static void mpu6050_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct mpu6050_data *drv_data =
CONTAINER_OF(cb, struct mpu6050_data, gpio_cb);
const struct mpu6050_config *cfg = drv_data->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_MPU6050_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void mpu6050_thread_cb(const struct device *dev)
{
struct mpu6050_data *drv_data = dev->data;
const struct mpu6050_config *cfg = dev->config;
if (drv_data->data_ready_handler != NULL) {
drv_data->data_ready_handler(dev,
drv_data->data_ready_trigger);
}
gpio_pin_interrupt_configure_dt(&cfg->int_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
#ifdef CONFIG_MPU6050_TRIGGER_OWN_THREAD
static void mpu6050_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct mpu6050_data *drv_data = p1;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
mpu6050_thread_cb(drv_data->dev);
}
}
#endif
#ifdef CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD
static void mpu6050_work_cb(struct k_work *work)
{
struct mpu6050_data *drv_data =
CONTAINER_OF(work, struct mpu6050_data, work);
mpu6050_thread_cb(drv_data->dev);
}
#endif
int mpu6050_init_interrupt(const struct device *dev)
{
struct mpu6050_data *drv_data = dev->data;
const struct mpu6050_config *cfg = dev->config;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
drv_data->dev = dev;
gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb,
mpu6050_gpio_callback,
BIT(cfg->int_gpio.pin));
if (gpio_add_callback(cfg->int_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_ERR("Failed to set gpio callback");
return -EIO;
}
/* enable data ready interrupt */
if (i2c_reg_write_byte_dt(&cfg->i2c, MPU6050_REG_INT_EN,
MPU6050_DRDY_EN) < 0) {
LOG_ERR("Failed to enable data ready interrupt.");
return -EIO;
}
#if defined(CONFIG_MPU6050_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_MPU6050_THREAD_STACK_SIZE,
mpu6050_thread, drv_data,
NULL, NULL, K_PRIO_COOP(CONFIG_MPU6050_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = mpu6050_work_cb;
#endif
gpio_pin_interrupt_configure_dt(&cfg->int_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/tdk/mpu6050/mpu6050_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,012 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42688_SPI_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42688_SPI_H_
#include <zephyr/device.h>
#include <zephyr/drivers/spi.h>
/**
* @brief perform a single SPI write to a ICM42688 register
*
* this functions wraps all logic necessary to write to any of the ICM42688 registers, regardless
* of which memory bank the register belongs to.
*
* @param bus SPI bus pointer
* @param reg address of ICM42688 register to write to
* @param data data byte to write to register
* @return int 0 on success, negative error code otherwise
*/
int icm42688_spi_single_write(const struct spi_dt_spec *bus, uint16_t reg, uint8_t data);
/**
* @brief update a single ICM42688 register value
*
* this functions wraps all logic necessary to update any of the ICM42688 registers, regardless
* of which memory bank the register belongs to.
*
* @param bus SPI bus pointer
* @param reg address of ICM42688 register to update
* @param mask bitmask defining which bits of the register to update
* @param data new value to update register with, respecting the bitmask
* @return int 0 on success, negative error code otherwise
*/
int icm42688_spi_update_register(const struct spi_dt_spec *bus, uint16_t reg, uint8_t mask,
uint8_t data);
/**
* @brief read from one or more ICM42688 registers
*
* this functions wraps all logic necessary to read from any of the ICM42688 registers, regardless
* of which memory bank the register belongs to.
*
* @param bus SPI bus pointer
* @param reg start address of ICM42688 register(s) to read from
* @param data pointer to byte array to read register values to
* @param len number of bytes to read from the device
* @return int 0 on success, negative error code otherwise
*/
int icm42688_spi_read(const struct spi_dt_spec *bus, uint16_t reg, uint8_t *data, size_t len);
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42688_SPI_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_spi.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 484 |
```unknown
# MPU6050 Six-Axis Motion Tracking device configuration options
menuconfig MPU6050
bool "MPU6050 Six-Axis Motion Tracking Device"
default y
depends on DT_HAS_INVENSENSE_MPU6050_ENABLED
select I2C
help
Enable driver for MPU6050 I2C-based six-axis motion tracking device.
if MPU6050
choice
prompt "Trigger mode"
default MPU6050_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config MPU6050_TRIGGER_NONE
bool "No trigger"
config MPU6050_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select MPU6050_TRIGGER
config MPU6050_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select MPU6050_TRIGGER
endchoice
config MPU6050_TRIGGER
bool
config MPU6050_THREAD_PRIORITY
int "Thread priority"
depends on MPU6050_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config MPU6050_THREAD_STACK_SIZE
int "Thread stack size"
depends on MPU6050_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config MPU6050_ACCEL_FS
int "Accelerometer full-scale range"
default 2
help
Magnetometer full-scale range.
An X value for the config represents a range of +/- X g. Valid
values are 2, 4, 8 and 16.
config MPU6050_GYRO_FS
int "Gyroscope full-scale range"
default 250
help
Gyroscope full-scale range.
An X value for the config represents a range of +/- X degrees/second.
Valid values are 250, 500, 1000, 2000.
endif # MPU6050
``` | /content/code_sandbox/drivers/sensor/tdk/mpu6050/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 402 |
```c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#include <zephyr/rtio/work.h>
#include "icm42688.h"
#include "icm42688_decoder.h"
#include "icm42688_reg.h"
#include "icm42688_rtio.h"
#include "icm42688_spi.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ICM42688_RTIO, CONFIG_SENSOR_LOG_LEVEL);
static int icm42688_rtio_sample_fetch(const struct device *dev, int16_t readings[7])
{
uint8_t status;
const struct icm42688_dev_cfg *cfg = dev->config;
uint8_t *buffer = (uint8_t *)readings;
int res = icm42688_spi_read(&cfg->spi, REG_INT_STATUS, &status, 1);
if (res) {
return res;
}
if (!FIELD_GET(BIT_INT_STATUS_DATA_RDY, status)) {
return -EBUSY;
}
res = icm42688_read_all(dev, buffer);
if (res) {
return res;
}
for (int i = 0; i < 7; i++) {
readings[i] = sys_le16_to_cpu((buffer[i * 2] << 8) | buffer[i * 2 + 1]);
}
return 0;
}
static void icm42688_submit_one_shot(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe)
{
const struct sensor_read_config *cfg = iodev_sqe->sqe.iodev->data;
const struct sensor_chan_spec *const channels = cfg->channels;
const size_t num_channels = cfg->count;
uint32_t min_buf_len = sizeof(struct icm42688_encoded_data);
int rc;
uint8_t *buf;
uint32_t buf_len;
struct icm42688_encoded_data *edata;
/* Get the buffer for the frame, it may be allocated dynamically by the rtio context */
rc = rtio_sqe_rx_buf(iodev_sqe, min_buf_len, min_buf_len, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get a read buffer of size %u bytes", min_buf_len);
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
edata = (struct icm42688_encoded_data *)buf;
icm42688_encode(dev, channels, num_channels, buf);
rc = icm42688_rtio_sample_fetch(dev, edata->readings);
/* Check that the fetch succeeded */
if (rc != 0) {
LOG_ERR("Failed to fetch samples");
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
rtio_iodev_sqe_ok(iodev_sqe, 0);
}
void icm42688_submit_sync(struct rtio_iodev_sqe *iodev_sqe)
{
const struct sensor_read_config *cfg = iodev_sqe->sqe.iodev->data;
const struct device *dev = cfg->sensor;
if (!cfg->is_streaming) {
icm42688_submit_one_shot(dev, iodev_sqe);
} else if (IS_ENABLED(CONFIG_ICM42688_STREAM)) {
icm42688_submit_stream(dev, iodev_sqe);
} else {
rtio_iodev_sqe_err(iodev_sqe, -ENOTSUP);
}
}
void icm42688_submit(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe)
{
struct rtio_work_req *req = rtio_work_req_alloc();
__ASSERT_NO_MSG(req);
rtio_work_req_submit(req, iodev_sqe, icm42688_submit_sync);
}
BUILD_ASSERT(sizeof(struct icm42688_decoder_header) == 9);
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_rtio.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 838 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42688_REG_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42688_REG_H_
#include <zephyr/sys/util.h>
/* Address value has a read bit */
#define REG_SPI_READ_BIT BIT(7)
/* Common bank select register and values */
#define REG_BANK_SEL 0x76
#define MASK_BANK_SEL GENMASK(2, 0)
#define BIT_BANK0 0x000
#define BIT_BANK1 0x001
#define BIT_BANK2 0x010
#define BIT_BANK3 0x011
#define BIT_BANK4 0x100
/* Helper macros for addressing registers in the 4 register banks
* registers are defined as 16 bit values with the bank in the high
* byte and the register address in the low byte
*/
#define REG_ADDRESS_MASK GENMASK(7, 0)
#define REG_BANK_MASK GENMASK(15, 8)
#define REG_BANK_OFFSET(bank) (bank << 8)
#define REG_BANK0_OFFSET REG_BANK_OFFSET(BIT_BANK0)
#define REG_BANK1_OFFSET REG_BANK_OFFSET(BIT_BANK1)
#define REG_BANK2_OFFSET REG_BANK_OFFSET(BIT_BANK2)
#define REG_BANK3_OFFSET REG_BANK_OFFSET(BIT_BANK3)
#define REG_BANK4_OFFSET REG_BANK_OFFSET(BIT_BANK4)
/* Bank 0 */
#define REG_DEVICE_CONFIG (REG_BANK0_OFFSET | 0x11)
#define REG_DRIVE_CONFIG (REG_BANK0_OFFSET | 0x13)
#define REG_INT_CONFIG (REG_BANK0_OFFSET | 0x14)
#define REG_FIFO_CONFIG (REG_BANK0_OFFSET | 0x16)
#define REG_TEMP_DATA1 (REG_BANK0_OFFSET | 0x1D)
#define REG_TEMP_DATA0 (REG_BANK0_OFFSET | 0x1E)
#define REG_ACCEL_DATA_X1 (REG_BANK0_OFFSET | 0x1F)
#define REG_ACCEL_DATA_X0 (REG_BANK0_OFFSET | 0x20)
#define REG_ACCEL_DATA_Y1 (REG_BANK0_OFFSET | 0x21)
#define REG_ACCEL_DATA_Y0 (REG_BANK0_OFFSET | 0x22)
#define REG_ACCEL_DATA_Z1 (REG_BANK0_OFFSET | 0x23)
#define REG_ACCEL_DATA_Z0 (REG_BANK0_OFFSET | 0x24)
#define REG_GYRO_DATA_X1 (REG_BANK0_OFFSET | 0x25)
#define REG_GYRO_DATA_X0 (REG_BANK0_OFFSET | 0x26)
#define REG_GYRO_DATA_Y1 (REG_BANK0_OFFSET | 0x27)
#define REG_GYRO_DATA_Y0 (REG_BANK0_OFFSET | 0x28)
#define REG_GYRO_DATA_Z1 (REG_BANK0_OFFSET | 0x29)
#define REG_GYRO_DATA_Z0 (REG_BANK0_OFFSET | 0x2A)
#define REG_TMST_FSYNCH (REG_BANK0_OFFSET | 0x2B)
#define REG_TMST_FSYNCL (REG_BANK0_OFFSET | 0x2C)
#define REG_INT_STATUS (REG_BANK0_OFFSET | 0x2D)
#define REG_FIFO_COUNTH (REG_BANK0_OFFSET | 0x2E)
#define REG_FIFO_COUNTL (REG_BANK0_OFFSET | 0x2F)
#define REG_FIFO_DATA (REG_BANK0_OFFSET | 0x30)
#define REG_APEX_DATA0 (REG_BANK0_OFFSET | 0x31)
#define REG_APEX_DATA1 (REG_BANK0_OFFSET | 0x32)
#define REG_APEX_DATA2 (REG_BANK0_OFFSET | 0x33)
#define REG_APEX_DATA3 (REG_BANK0_OFFSET | 0x34)
#define REG_APEX_DATA4 (REG_BANK0_OFFSET | 0x35)
#define REG_APEX_DATA5 (REG_BANK0_OFFSET | 0x36)
#define REG_INT_STATUS2 (REG_BANK0_OFFSET | 0x37)
#define REG_INT_STATUS3 (REG_BANK0_OFFSET | 0x38)
#define REG_SIGNAL_PATH_RESET (REG_BANK0_OFFSET | 0x4B)
#define REG_INTF_CONFIG0 (REG_BANK0_OFFSET | 0x4C)
#define REG_INTF_CONFIG1 (REG_BANK0_OFFSET | 0x4D)
#define REG_PWR_MGMT0 (REG_BANK0_OFFSET | 0x4E)
#define REG_GYRO_CONFIG0 (REG_BANK0_OFFSET | 0x4F)
#define REG_ACCEL_CONFIG0 (REG_BANK0_OFFSET | 0x50)
#define REG_GYRO_CONFIG1 (REG_BANK0_OFFSET | 0x51)
#define REG_GYRO_ACCEL_CONFIG0 (REG_BANK0_OFFSET | 0x52)
#define REG_ACCEL_CONFIG1 (REG_BANK0_OFFSET | 0x53)
#define REG_TMST_CONFIG (REG_BANK0_OFFSET | 0x54)
#define REG_APEX_CONFIG0 (REG_BANK0_OFFSET | 0x56)
#define REG_SMD_CONFIG (REG_BANK0_OFFSET | 0x57)
#define REG_FIFO_CONFIG1 (REG_BANK0_OFFSET | 0x5F)
#define REG_FIFO_CONFIG2 (REG_BANK0_OFFSET | 0x60)
#define REG_FIFO_CONFIG3 (REG_BANK0_OFFSET | 0x61)
#define REG_FSYNC_CONFIG (REG_BANK0_OFFSET | 0x62)
#define REG_INT_CONFIG0 (REG_BANK0_OFFSET | 0x63)
#define REG_INT_CONFIG1 (REG_BANK0_OFFSET | 0x64)
#define REG_INT_SOURCE0 (REG_BANK0_OFFSET | 0x65)
#define REG_INT_SOURCE1 (REG_BANK0_OFFSET | 0x66)
#define REG_INT_SOURCE3 (REG_BANK0_OFFSET | 0x68)
#define REG_INT_SOURCE4 (REG_BANK0_OFFSET | 0x69)
#define REG_FIFO_LOST_PKT0 (REG_BANK0_OFFSET | 0x6C)
#define REG_FIFO_LOST_PKT1 (REG_BANK0_OFFSET | 0x6D)
#define REG_SELF_TEST_CONFIG (REG_BANK0_OFFSET | 0x70)
#define REG_WHO_AM_I (REG_BANK0_OFFSET | 0x75)
/* Bank 1 */
#define SENSOR_CONFIG0 (REG_BANK1_OFFSET | 0x03)
#define GYRO_CONFIG_STATIC2 (REG_BANK1_OFFSET | 0x0B)
#define GYRO_CONFIG_STATIC3 (REG_BANK1_OFFSET | 0x0C)
#define GYRO_CONFIG_STATIC4 (REG_BANK1_OFFSET | 0x0D)
#define GYRO_CONFIG_STATIC5 (REG_BANK1_OFFSET | 0x0E)
#define GYRO_CONFIG_STATIC6 (REG_BANK1_OFFSET | 0x0F)
#define GYRO_CONFIG_STATIC7 (REG_BANK1_OFFSET | 0x10)
#define GYRO_CONFIG_STATIC8 (REG_BANK1_OFFSET | 0x11)
#define GYRO_CONFIG_STATIC9 (REG_BANK1_OFFSET | 0x12)
#define GYRO_CONFIG_STATIC10 (REG_BANK1_OFFSET | 0x13)
#define REG_XG_ST_DATA (REG_BANK1_OFFSET | 0x5F)
#define REG_YG_ST_DATA (REG_BANK1_OFFSET | 0x60)
#define REG_ZG_ST_DATA (REG_BANK1_OFFSET | 0x61)
#define REG_TMSTVAL0 (REG_BANK1_OFFSET | 0x62)
#define REG_TMSTVAL1 (REG_BANK1_OFFSET | 0x63)
#define REG_TMSTVAL2 (REG_BANK1_OFFSET | 0x64)
#define REG_INTF_CONFIG4 (REG_BANK1_OFFSET | 0x7A)
#define REG_INTF_CONFIG5 (REG_BANK1_OFFSET | 0x7B)
#define REG_INTF_CONFIG6 (REG_BANK1_OFFSET | 0x7C)
/* Bank 2 */
/* Bank 4 */
#define REG_INT_SOURCE6 (REG_BANK4_OFFSET | 0x77)
#define REG_INT_SOURCE7 (REG_BANK4_OFFSET | 0x78)
#define REG_INT_SOURCE8 (REG_BANK4_OFFSET | 0x79)
#define REG_INT_SOURCE9 (REG_BANK4_OFFSET | 0x80)
/* Bank0 REG_DEVICE_CONFIG */
#define BIT_SOFT_RESET BIT(0)
#define BIT_SPI_MODE BIT(4)
/* Bank0 REG_DRIVE_CONFIG */
/* Not used! */
/* Bank0 REG_INT_CONFIG */
#define BIT_INT1_POLARITY BIT(0)
#define BIT_INT1_DRIVE_CIRCUIT BIT(1)
#define BIT_INT1_MODE BIT(2)
#define BIT_INT2_POLARITY BIT(3)
#define BIT_INT2_DRIVE_CIRCUIT BIT(4)
#define BIT_INT2_MODE BIT(5)
/* Bank0 REG_FIFO_CONFIG */
#define MASK_FIFO_MODE GENMASK(7, 6)
#define BIT_FIFO_MODE_BYPASS 0x00
#define BIT_FIFO_MODE_STREAM 0x01
#define BIT_FIFO_MODE_STOP_ON_FULL 0x10
/* Bank0 REG_INT_STATUS */
#define BIT_INT_STATUS_AGC_RDY BIT(0)
#define BIT_INT_STATUS_FIFO_FULL BIT(1)
#define BIT_INT_STATUS_FIFO_THS BIT(2)
#define BIT_INT_STATUS_DATA_RDY BIT(3)
#define BIT_INT_STATUS_RESET_DONE BIT(4)
#define BIT_INT_STATUS_PLL_RDY BIT(5)
#define BIT_INT_STATUS_FSYNC BIT(6)
/* Bank0 REG_INT_STATUS2 */
#define BIT_INT_STATUS_WOM_Z BIT(0)
#define BIT_INT_STATUS_WOM_Y BIT(1)
#define BIT_INT_STATUS_WOM_X BIT(2)
#define BIT_INT_STATUS_SMD BIT(3)
/* Bank0 REG_INT_STATUS3 */
#define BIT_INT_STATUS_LOWG_DET BIT(1)
#define BIT_INT_STATUS_FF_DET BIT(2)
#define BIT_INT_STATUS_TILT_DET BIT(3)
#define BIT_INT_STATUS_STEP_CNT_OVFL BIT(4)
#define BIT_INT_STATUS_STEP_DET BIT(5)
/* Bank0 REG_SIGNAL_PATH_RESET */
#define BIT_FIFO_FLUSH BIT(1)
#define BIT_TMST_STROBE BIT(2)
#define BIT_ABORT_AND_RESET BIT(3)
#define BIT_DMP_MEM_RESET_EN BIT(5)
#define BIT_DMP_INIT_EN BIT(6)
/* Bank0 REG_INTF_CONFIG0 */
#define MASK_UI_SIFS_CFG GENMASK(1, 0)
#define BIT_UI_SIFS_CFG_DISABLE_SPI 0x10
#define BIT_UI_SIFS_CFG_DISABLE_I2C 0x11
#define BIT_SENSOR_DATA_ENDIAN BIT(4)
#define BIT_FIFO_COUNT_ENDIAN BIT(5)
#define BIT_FIFO_COUNT_REC BIT(6)
#define BIT_FIFO_HOLD_LAST_DATA_EN BIT(7)
/* Bank0 REG_INTF_CONFIG1 */
#define MASK_CLKSEL GENMASK(1, 0)
#define BIT_CLKSEL_INT_RC 0x00
#define BIT_CLKSEL_PLL_OR_RC 0x01
#define BIT_CLKSEL_DISABLE 0x11
#define BIT_RTC_MODE BIT(2)
#define BIT_ACCEL_LP_CLK_SEL BIT(3)
/* Bank0 REG_PWR_MGMT_0 */
#define MASK_ACCEL_MODE GENMASK(1, 0)
#define BIT_ACCEL_MODE_OFF 0x00
#define BIT_ACCEL_MODE_LPM 0x02
#define BIT_ACCEL_MODE_LNM 0x03
#define MASK_GYRO_MODE GENMASK(3, 2)
#define BIT_GYRO_MODE_OFF 0x00
#define BIT_GYRO_MODE_STBY 0x01
#define BIT_GYRO_MODE_LNM 0x03
#define BIT_IDLE BIT(4)
#define BIT_TEMP_DIS BIT(5)
/* Bank0 REG_GYRO_CONFIG0 */
#define MASK_GYRO_UI_FS_SEL GENMASK(7, 5)
#define BIT_GYRO_UI_FS_2000 0x00
#define BIT_GYRO_UI_FS_1000 0x01
#define BIT_GYRO_UI_FS_500 0x02
#define BIT_GYRO_UI_FS_250 0x03
#define BIT_GYRO_UI_FS_125 0x04
#define BIT_GYRO_UI_FS_62_5 0x05
#define BIT_GYRO_UI_FS_31_25 0x06
#define BIT_GYRO_UI_FS_15_625 0x07
#define MASK_GYRO_ODR GENMASK(3, 0)
#define BIT_GYRO_ODR_32000 0x01
#define BIT_GYRO_ODR_16000 0x02
#define BIT_GYRO_ODR_8000 0x03
#define BIT_GYRO_ODR_4000 0x04
#define BIT_GYRO_ODR_2000 0x05
#define BIT_GYRO_ODR_1000 0x06
#define BIT_GYRO_ODR_200 0x07
#define BIT_GYRO_ODR_100 0x08
#define BIT_GYRO_ODR_50 0x09
#define BIT_GYRO_ODR_25 0x0A
#define BIT_GYRO_ODR_12_5 0x0B
#define BIT_GYRO_ODR_500 0x0F
/* Bank0 REG_ACCEL_CONFIG0 */
#define MASK_ACCEL_UI_FS_SEL GENMASK(7, 5)
#define BIT_ACCEL_UI_FS_16 0x00
#define BIT_ACCEL_UI_FS_8 0x01
#define BIT_ACCEL_UI_FS_4 0x02
#define BIT_ACCEL_UI_FS_2 0x03
#define MASK_ACCEL_ODR GENMASK(3, 0)
#define BIT_ACCEL_ODR_32000 0x01
#define BIT_ACCEL_ODR_16000 0x02
#define BIT_ACCEL_ODR_8000 0x03
#define BIT_ACCEL_ODR_4000 0x04
#define BIT_ACCEL_ODR_2000 0x05
#define BIT_ACCEL_ODR_1000 0x06
#define BIT_ACCEL_ODR_200 0x07
#define BIT_ACCEL_ODR_100 0x08
#define BIT_ACCEL_ODR_50 0x09
#define BIT_ACCEL_ODR_25 0x0A
#define BIT_ACCEL_ODR_12_5 0x0B
#define BIT_ACCEL_ODR_6_25 0x0C
#define BIT_ACCEL_ODR_3_12 0x0D
#define BIT_ACCEL_ODR_1_5625 0x0E
#define BIT_ACCEL_ODR_500 0x0F
/* Bank0 FIFO_CONFIG1 */
#define BIT_FIFO_WM_GT_TH BIT(5)
#define BIT_FIFO_HIRES_EN BIT(4)
#define BIT_FIFO_TMST_FSYNC_EN BIT(3)
#define BIT_FIFO_GYRO_EN BIT(2)
#define BIT_FIFO_ACCEL_EN BIT(1)
#define BIT_FIFO_TEMP_EN BIT(0)
/* Bank0 INT_SOURCE0 */
#define BIT_UI_FSYNC_INT1_EN BIT(6)
#define BIT_PLL_RDY_INT1_EN BIT(5)
#define BIT_RESET_DONE_INT1_EN BIT(4)
#define BIT_UI_DRDY_INT1_EN BIT(3)
#define BIT_FIFO_THS_INT1_EN BIT(2)
#define BIT_FIFO_FULL_INT1_EN BIT(1)
#define BIT_FIFO_UI_AGC_RDY_INT1_EN BIT(0)
/* Bank0 REG_FSYNC_CONFIG */
#define MASK_FSYNC_UI_SEL GENMASK(6, 4)
#define BIT_FSYNC_UI
/* Bank0 REG_INT_CONFIG1 */
#define BIT_INT_TPULSE_DURATION BIT(6)
#define BIT_INT_TDEASSERT_DISABLE BIT(5)
#define BIT_INT_ASYNC_RESET BIT(4)
/* misc. defines */
#define WHO_AM_I_ICM42688 0x47
#define MIN_ACCEL_SENS_SHIFT 11
#define ACCEL_DATA_SIZE 6
#define GYRO_DATA_SIZE 6
#define TEMP_DATA_SIZE 2
#define MCLK_POLL_INTERVAL_US 250
#define MCLK_POLL_ATTEMPTS 100
#define SOFT_RESET_TIME_MS 2 /* 1ms + elbow room */
/* FIFO header */
#define FIFO_HEADER_ACCEL BIT(6)
#define FIFO_HEADER_GYRO BIT(5)
#define FIFO_HEADER_20 BIT(4)
#define FIFO_HEADER_TIMESTAMP_FSYNC GENMASK(3, 2)
#define FIFO_HEADER_ODR_ACCEL BIT(1)
#define FIFO_HEADER_ODR_GYRO BIT(0)
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42688_REG_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_reg.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,591 |
```c
/*
*
*/
#include "icm42688_decoder.h"
#include "icm42688_reg.h"
#include "icm42688.h"
#include <errno.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ICM42688_DECODER, CONFIG_SENSOR_LOG_LEVEL);
#define DT_DRV_COMPAT invensense_icm42688
static int icm42688_get_shift(enum sensor_channel channel, int accel_fs, int gyro_fs, int8_t *shift)
{
switch (channel) {
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
switch (accel_fs) {
case ICM42688_DT_ACCEL_FS_2:
*shift = 5;
return 0;
case ICM42688_DT_ACCEL_FS_4:
*shift = 6;
return 0;
case ICM42688_DT_ACCEL_FS_8:
*shift = 7;
return 0;
case ICM42688_DT_ACCEL_FS_16:
*shift = 8;
return 0;
default:
return -EINVAL;
}
case SENSOR_CHAN_GYRO_XYZ:
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
switch (gyro_fs) {
case ICM42688_DT_GYRO_FS_15_625:
*shift = -1;
return 0;
case ICM42688_DT_GYRO_FS_31_25:
*shift = 0;
return 0;
case ICM42688_DT_GYRO_FS_62_5:
*shift = 1;
return 0;
case ICM42688_DT_GYRO_FS_125:
*shift = 2;
return 0;
case ICM42688_DT_GYRO_FS_250:
*shift = 3;
return 0;
case ICM42688_DT_GYRO_FS_500:
*shift = 4;
return 0;
case ICM42688_DT_GYRO_FS_1000:
*shift = 5;
return 0;
case ICM42688_DT_GYRO_FS_2000:
*shift = 6;
return 0;
default:
return -EINVAL;
}
case SENSOR_CHAN_DIE_TEMP:
*shift = 9;
return 0;
default:
return -EINVAL;
}
}
int icm42688_convert_raw_to_q31(struct icm42688_cfg *cfg, enum sensor_channel chan, int32_t reading,
q31_t *out)
{
int32_t whole;
int32_t fraction;
int64_t intermediate;
int8_t shift;
int rc;
rc = icm42688_get_shift(chan, cfg->accel_fs, cfg->gyro_fs, &shift);
if (rc != 0) {
return rc;
}
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
icm42688_accel_ms(cfg, reading, &whole, &fraction);
break;
case SENSOR_CHAN_GYRO_XYZ:
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
icm42688_gyro_rads(cfg, reading, &whole, &fraction);
break;
case SENSOR_CHAN_DIE_TEMP:
icm42688_temp_c(reading, &whole, &fraction);
break;
default:
return -ENOTSUP;
}
intermediate = ((int64_t)whole * INT64_C(1000000) + fraction);
if (shift < 0) {
intermediate =
intermediate * ((int64_t)INT32_MAX + 1) * (1 << -shift) / INT64_C(1000000);
} else if (shift > 0) {
intermediate =
intermediate * ((int64_t)INT32_MAX + 1) / ((1 << shift) * INT64_C(1000000));
}
*out = CLAMP(intermediate, INT32_MIN, INT32_MAX);
return 0;
}
static int icm42688_get_channel_position(enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_DIE_TEMP:
return 0;
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_ACCEL_X:
return 1;
case SENSOR_CHAN_ACCEL_Y:
return 2;
case SENSOR_CHAN_ACCEL_Z:
return 3;
case SENSOR_CHAN_GYRO_XYZ:
case SENSOR_CHAN_GYRO_X:
return 4;
case SENSOR_CHAN_GYRO_Y:
return 5;
case SENSOR_CHAN_GYRO_Z:
return 6;
default:
return 0;
}
}
static uint8_t icm42688_encode_channel(enum sensor_channel chan)
{
uint8_t encode_bmask = 0;
switch (chan) {
case SENSOR_CHAN_DIE_TEMP:
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
encode_bmask = BIT(icm42688_get_channel_position(chan));
break;
case SENSOR_CHAN_ACCEL_XYZ:
encode_bmask = BIT(icm42688_get_channel_position(SENSOR_CHAN_ACCEL_X)) |
BIT(icm42688_get_channel_position(SENSOR_CHAN_ACCEL_Y)) |
BIT(icm42688_get_channel_position(SENSOR_CHAN_ACCEL_Z));
break;
case SENSOR_CHAN_GYRO_XYZ:
encode_bmask = BIT(icm42688_get_channel_position(SENSOR_CHAN_GYRO_X)) |
BIT(icm42688_get_channel_position(SENSOR_CHAN_GYRO_Y)) |
BIT(icm42688_get_channel_position(SENSOR_CHAN_GYRO_Z));
break;
default:
break;
}
return encode_bmask;
}
int icm42688_encode(const struct device *dev, const struct sensor_chan_spec *const channels,
const size_t num_channels, uint8_t *buf)
{
struct icm42688_dev_data *data = dev->data;
struct icm42688_encoded_data *edata = (struct icm42688_encoded_data *)buf;
edata->channels = 0;
for (int i = 0; i < num_channels; i++) {
edata->channels |= icm42688_encode_channel(channels[i].chan_type);
}
edata->header.is_fifo = false;
edata->header.accel_fs = data->cfg.accel_fs;
edata->header.gyro_fs = data->cfg.gyro_fs;
edata->header.timestamp = k_ticks_to_ns_floor64(k_uptime_ticks());
return 0;
}
#define IS_ACCEL(chan) ((chan) >= SENSOR_CHAN_ACCEL_X && (chan) <= SENSOR_CHAN_ACCEL_XYZ)
#define IS_GYRO(chan) ((chan) >= SENSOR_CHAN_GYRO_X && (chan) <= SENSOR_CHAN_GYRO_XYZ)
static inline q31_t icm42688_read_temperature_from_packet(const uint8_t *pkt)
{
int32_t temperature;
int32_t whole;
int32_t fraction;
/* Temperature always assumes a shift of 9 for a range of (-273,273) C */
if (FIELD_GET(FIFO_HEADER_20, pkt[0]) == 1) {
temperature = (pkt[0xd] << 8) | pkt[0xe];
icm42688_temp_c(temperature, &whole, &fraction);
} else {
if (FIELD_GET(FIFO_HEADER_ACCEL, pkt[0]) == 1 &&
FIELD_GET(FIFO_HEADER_GYRO, pkt[0]) == 1) {
temperature = pkt[0xd];
} else {
temperature = pkt[0x7];
}
int64_t sensitivity = 207;
int64_t temperature100 = (temperature * 100) + (25 * sensitivity);
whole = temperature100 / sensitivity;
fraction =
((temperature100 - whole * sensitivity) * INT64_C(1000000)) / sensitivity;
}
__ASSERT_NO_MSG(whole >= -512 && whole <= 511);
return FIELD_PREP(GENMASK(31, 22), whole) | (fraction * GENMASK64(21, 0) / 1000000);
}
static int icm42688_read_imu_from_packet(const uint8_t *pkt, bool is_accel, int fs,
uint8_t axis_offset, q31_t *out)
{
int32_t value;
int64_t scale = 0;
int32_t max = BIT(15);
int offset = 1 + (axis_offset * 2);
if (is_accel) {
switch (fs) {
case ICM42688_DT_ACCEL_FS_2:
scale = INT64_C(2) * BIT(31 - 5) * 9.80665;
break;
case ICM42688_DT_ACCEL_FS_4:
scale = INT64_C(4) * BIT(31 - 6) * 9.80665;
break;
case ICM42688_DT_ACCEL_FS_8:
scale = INT64_C(8) * BIT(31 - 7) * 9.80665;
break;
case ICM42688_DT_ACCEL_FS_16:
scale = INT64_C(16) * BIT(31 - 8) * 9.80665;
break;
}
} else {
switch (fs) {
case ICM42688_DT_GYRO_FS_2000:
scale = 164;
break;
case ICM42688_DT_GYRO_FS_1000:
scale = 328;
break;
case ICM42688_DT_GYRO_FS_500:
scale = 655;
break;
case ICM42688_DT_GYRO_FS_250:
scale = 1310;
break;
case ICM42688_DT_GYRO_FS_125:
scale = 2620;
break;
case ICM42688_DT_GYRO_FS_62_5:
scale = 5243;
break;
case ICM42688_DT_GYRO_FS_31_25:
scale = 10486;
break;
case ICM42688_DT_GYRO_FS_15_625:
scale = 20972;
break;
}
}
if (!is_accel && FIELD_GET(FIFO_HEADER_ACCEL, pkt[0]) == 1) {
offset += 7;
}
value = (int16_t)sys_le16_to_cpu((pkt[offset] << 8) | pkt[offset + 1]);
if (FIELD_GET(FIFO_HEADER_20, pkt[0]) == 1) {
uint32_t mask = is_accel ? GENMASK(7, 4) : GENMASK(3, 0);
offset = 0x11 + axis_offset;
value = (value << 4) | FIELD_GET(mask, pkt[offset]);
/* In 20 bit mode, FS can only be +/-16g and +/-2000dps */
scale = is_accel ? (INT64_C(16) * BIT(8) * 9.80665) : 131;
max = is_accel ? BIT(18) : BIT(19);
if (value == -524288) {
/* Invalid 20 bit value */
return -ENODATA;
}
} else {
if (value <= -32767) {
/* Invalid 16 bit value */
return -ENODATA;
}
}
*out = (q31_t)(value * scale / max);
return 0;
}
static uint32_t accel_period_ns[] = {
[ICM42688_DT_ACCEL_ODR_1_5625] = UINT32_C(10000000000000) / 15625,
[ICM42688_DT_ACCEL_ODR_3_125] = UINT32_C(10000000000000) / 31250,
[ICM42688_DT_ACCEL_ODR_6_25] = UINT32_C(10000000000000) / 62500,
[ICM42688_DT_ACCEL_ODR_12_5] = UINT32_C(10000000000000) / 12500,
[ICM42688_DT_ACCEL_ODR_25] = UINT32_C(1000000000) / 25,
[ICM42688_DT_ACCEL_ODR_50] = UINT32_C(1000000000) / 50,
[ICM42688_DT_ACCEL_ODR_100] = UINT32_C(1000000000) / 100,
[ICM42688_DT_ACCEL_ODR_200] = UINT32_C(1000000000) / 200,
[ICM42688_DT_ACCEL_ODR_500] = UINT32_C(1000000000) / 500,
[ICM42688_DT_ACCEL_ODR_1000] = UINT32_C(1000000),
[ICM42688_DT_ACCEL_ODR_2000] = UINT32_C(1000000) / 2,
[ICM42688_DT_ACCEL_ODR_4000] = UINT32_C(1000000) / 4,
[ICM42688_DT_ACCEL_ODR_8000] = UINT32_C(1000000) / 8,
[ICM42688_DT_ACCEL_ODR_16000] = UINT32_C(1000000) / 16,
[ICM42688_DT_ACCEL_ODR_32000] = UINT32_C(1000000) / 32,
};
static uint32_t gyro_period_ns[] = {
[ICM42688_DT_GYRO_ODR_12_5] = UINT32_C(10000000000000) / 12500,
[ICM42688_DT_GYRO_ODR_25] = UINT32_C(1000000000) / 25,
[ICM42688_DT_GYRO_ODR_50] = UINT32_C(1000000000) / 50,
[ICM42688_DT_GYRO_ODR_100] = UINT32_C(1000000000) / 100,
[ICM42688_DT_GYRO_ODR_200] = UINT32_C(1000000000) / 200,
[ICM42688_DT_GYRO_ODR_500] = UINT32_C(1000000000) / 500,
[ICM42688_DT_GYRO_ODR_1000] = UINT32_C(1000000),
[ICM42688_DT_GYRO_ODR_2000] = UINT32_C(1000000) / 2,
[ICM42688_DT_GYRO_ODR_4000] = UINT32_C(1000000) / 4,
[ICM42688_DT_GYRO_ODR_8000] = UINT32_C(1000000) / 8,
[ICM42688_DT_GYRO_ODR_16000] = UINT32_C(1000000) / 16,
[ICM42688_DT_GYRO_ODR_32000] = UINT32_C(1000000) / 32,
};
static int icm42688_fifo_decode(const uint8_t *buffer, struct sensor_chan_spec chan_spec,
uint32_t *fit, uint16_t max_count, void *data_out)
{
const struct icm42688_fifo_data *edata = (const struct icm42688_fifo_data *)buffer;
const uint8_t *buffer_end = buffer + sizeof(struct icm42688_fifo_data) + edata->fifo_count;
int accel_frame_count = 0;
int gyro_frame_count = 0;
int count = 0;
int rc;
if ((uintptr_t)buffer_end <= *fit || chan_spec.chan_idx != 0) {
return 0;
}
((struct sensor_data_header *)data_out)->base_timestamp_ns = edata->header.timestamp;
buffer += sizeof(struct icm42688_fifo_data);
while (count < max_count && buffer < buffer_end) {
const bool is_20b = FIELD_GET(FIFO_HEADER_20, buffer[0]) == 1;
const bool has_accel = FIELD_GET(FIFO_HEADER_ACCEL, buffer[0]) == 1;
const bool has_gyro = FIELD_GET(FIFO_HEADER_GYRO, buffer[0]) == 1;
const uint8_t *frame_end = buffer;
if (is_20b) {
frame_end += 20;
} else if (has_accel && has_gyro) {
frame_end += 16;
} else {
frame_end += 8;
}
if (has_accel) {
accel_frame_count++;
}
if (has_gyro) {
gyro_frame_count++;
}
if ((uintptr_t)buffer < *fit) {
/* This frame was already decoded, move on to the next frame */
buffer = frame_end;
continue;
}
if (chan_spec.chan_type == SENSOR_CHAN_DIE_TEMP) {
struct sensor_q31_data *data = (struct sensor_q31_data *)data_out;
data->shift = 9;
if (has_accel) {
data->readings[count].timestamp_delta =
accel_period_ns[edata->accel_odr] * (accel_frame_count - 1);
} else {
data->readings[count].timestamp_delta =
gyro_period_ns[edata->gyro_odr] * (gyro_frame_count - 1);
}
data->readings[count].temperature =
icm42688_read_temperature_from_packet(buffer);
} else if (IS_ACCEL(chan_spec.chan_type) && has_accel) {
/* Decode accel */
struct sensor_three_axis_data *data =
(struct sensor_three_axis_data *)data_out;
uint64_t period_ns = accel_period_ns[edata->accel_odr];
icm42688_get_shift(SENSOR_CHAN_ACCEL_XYZ, edata->header.accel_fs,
edata->header.gyro_fs, &data->shift);
data->readings[count].timestamp_delta = (accel_frame_count - 1) * period_ns;
rc = icm42688_read_imu_from_packet(buffer, true, edata->header.accel_fs, 0,
&data->readings[count].x);
rc |= icm42688_read_imu_from_packet(buffer, true, edata->header.accel_fs, 1,
&data->readings[count].y);
rc |= icm42688_read_imu_from_packet(buffer, true, edata->header.accel_fs, 2,
&data->readings[count].z);
if (rc != 0) {
accel_frame_count--;
buffer = frame_end;
continue;
}
} else if (IS_GYRO(chan_spec.chan_type) && has_gyro) {
/* Decode gyro */
struct sensor_three_axis_data *data =
(struct sensor_three_axis_data *)data_out;
uint64_t period_ns = accel_period_ns[edata->gyro_odr];
icm42688_get_shift(SENSOR_CHAN_GYRO_XYZ, edata->header.accel_fs,
edata->header.gyro_fs, &data->shift);
data->readings[count].timestamp_delta = (gyro_frame_count - 1) * period_ns;
rc = icm42688_read_imu_from_packet(buffer, false, edata->header.gyro_fs, 0,
&data->readings[count].x);
rc |= icm42688_read_imu_from_packet(buffer, false, edata->header.gyro_fs, 1,
&data->readings[count].y);
rc |= icm42688_read_imu_from_packet(buffer, false, edata->header.gyro_fs, 2,
&data->readings[count].z);
if (rc != 0) {
gyro_frame_count--;
buffer = frame_end;
continue;
}
}
buffer = frame_end;
*fit = (uintptr_t)frame_end;
count++;
}
return count;
}
static int icm42688_one_shot_decode(const uint8_t *buffer, struct sensor_chan_spec chan_spec,
uint32_t *fit, uint16_t max_count, void *data_out)
{
const struct icm42688_encoded_data *edata = (const struct icm42688_encoded_data *)buffer;
const struct icm42688_decoder_header *header = &edata->header;
struct icm42688_cfg cfg = {
.accel_fs = edata->header.accel_fs,
.gyro_fs = edata->header.gyro_fs,
};
uint8_t channel_request;
int rc;
if (*fit != 0) {
return 0;
}
if (max_count == 0 || chan_spec.chan_idx != 0) {
return -EINVAL;
}
switch (chan_spec.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ: {
channel_request = icm42688_encode_channel(SENSOR_CHAN_ACCEL_XYZ);
if ((channel_request & edata->channels) != channel_request) {
return -ENODATA;
}
struct sensor_three_axis_data *out = data_out;
out->header.base_timestamp_ns = edata->header.timestamp;
out->header.reading_count = 1;
rc = icm42688_get_shift(SENSOR_CHAN_ACCEL_XYZ, header->accel_fs, header->gyro_fs,
&out->shift);
if (rc != 0) {
return -EINVAL;
}
icm42688_convert_raw_to_q31(
&cfg, SENSOR_CHAN_ACCEL_X,
edata->readings[icm42688_get_channel_position(SENSOR_CHAN_ACCEL_X)],
&out->readings[0].x);
icm42688_convert_raw_to_q31(
&cfg, SENSOR_CHAN_ACCEL_Y,
edata->readings[icm42688_get_channel_position(SENSOR_CHAN_ACCEL_Y)],
&out->readings[0].y);
icm42688_convert_raw_to_q31(
&cfg, SENSOR_CHAN_ACCEL_Z,
edata->readings[icm42688_get_channel_position(SENSOR_CHAN_ACCEL_Z)],
&out->readings[0].z);
*fit = 1;
return 1;
}
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ: {
channel_request = icm42688_encode_channel(SENSOR_CHAN_GYRO_XYZ);
if ((channel_request & edata->channels) != channel_request) {
return -ENODATA;
}
struct sensor_three_axis_data *out = data_out;
out->header.base_timestamp_ns = edata->header.timestamp;
out->header.reading_count = 1;
rc = icm42688_get_shift(SENSOR_CHAN_GYRO_XYZ, header->accel_fs, header->gyro_fs,
&out->shift);
if (rc != 0) {
return -EINVAL;
}
out->readings[0].timestamp_delta = 0;
icm42688_convert_raw_to_q31(
&cfg, SENSOR_CHAN_GYRO_X,
edata->readings[icm42688_get_channel_position(SENSOR_CHAN_GYRO_X)],
&out->readings[0].x);
icm42688_convert_raw_to_q31(
&cfg, SENSOR_CHAN_GYRO_Y,
edata->readings[icm42688_get_channel_position(SENSOR_CHAN_GYRO_Y)],
&out->readings[0].y);
icm42688_convert_raw_to_q31(
&cfg, SENSOR_CHAN_GYRO_Z,
edata->readings[icm42688_get_channel_position(SENSOR_CHAN_GYRO_Z)],
&out->readings[0].z);
*fit = 1;
return 1;
}
case SENSOR_CHAN_DIE_TEMP: {
channel_request = icm42688_encode_channel(SENSOR_CHAN_DIE_TEMP);
if ((channel_request & edata->channels) != channel_request) {
return -ENODATA;
}
struct sensor_q31_data *out = data_out;
out->header.base_timestamp_ns = edata->header.timestamp;
out->header.reading_count = 1;
rc = icm42688_get_shift(SENSOR_CHAN_DIE_TEMP, header->accel_fs, header->gyro_fs,
&out->shift);
if (rc != 0) {
return -EINVAL;
}
out->readings[0].timestamp_delta = 0;
icm42688_convert_raw_to_q31(
&cfg, SENSOR_CHAN_DIE_TEMP,
edata->readings[icm42688_get_channel_position(SENSOR_CHAN_DIE_TEMP)],
&out->readings[0].temperature);
*fit = 1;
return 1;
}
default:
return -EINVAL;
}
}
static int icm42688_decoder_decode(const uint8_t *buffer, struct sensor_chan_spec chan_spec,
uint32_t *fit, uint16_t max_count, void *data_out)
{
const struct icm42688_decoder_header *header =
(const struct icm42688_decoder_header *)buffer;
if (header->is_fifo) {
return icm42688_fifo_decode(buffer, chan_spec, fit, max_count, data_out);
}
return icm42688_one_shot_decode(buffer, chan_spec, fit, max_count, data_out);
}
static int icm42688_decoder_get_frame_count(const uint8_t *buffer,
struct sensor_chan_spec chan_spec,
uint16_t *frame_count)
{
const struct icm42688_fifo_data *data = (const struct icm42688_fifo_data *)buffer;
const struct icm42688_decoder_header *header = &data->header;
if (chan_spec.chan_idx != 0) {
return -ENOTSUP;
}
if (!header->is_fifo) {
switch (chan_spec.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
case SENSOR_CHAN_DIE_TEMP:
*frame_count = 1;
return 0;
default:
return -ENOTSUP;
}
return 0;
}
/* Skip the header */
buffer += sizeof(struct icm42688_fifo_data);
uint16_t count = 0;
const uint8_t *end = buffer + data->fifo_count;
while (buffer < end) {
bool is_20b = FIELD_GET(FIFO_HEADER_20, buffer[0]);
int size = is_20b ? 3 : 2;
if (FIELD_GET(FIFO_HEADER_ACCEL, buffer[0])) {
size += 6;
}
if (FIELD_GET(FIFO_HEADER_GYRO, buffer[0])) {
size += 6;
}
if (FIELD_GET(FIFO_HEADER_TIMESTAMP_FSYNC, buffer[0])) {
size += 2;
}
if (is_20b) {
size += 3;
}
buffer += size;
++count;
}
*frame_count = count;
return 0;
}
static int icm42688_decoder_get_size_info(struct sensor_chan_spec chan_spec, size_t *base_size,
size_t *frame_size)
{
switch (chan_spec.chan_type) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
*base_size = sizeof(struct sensor_three_axis_data);
*frame_size = sizeof(struct sensor_three_axis_sample_data);
return 0;
case SENSOR_CHAN_DIE_TEMP:
*base_size = sizeof(struct sensor_q31_data);
*frame_size = sizeof(struct sensor_q31_sample_data);
return 0;
default:
return -ENOTSUP;
}
}
static bool icm24688_decoder_has_trigger(const uint8_t *buffer, enum sensor_trigger_type trigger)
{
const struct icm42688_fifo_data *edata = (const struct icm42688_fifo_data *)buffer;
if (!edata->header.is_fifo) {
return false;
}
switch (trigger) {
case SENSOR_TRIG_DATA_READY:
return FIELD_GET(BIT_INT_STATUS_DATA_RDY, edata->int_status);
case SENSOR_TRIG_FIFO_WATERMARK:
return FIELD_GET(BIT_INT_STATUS_FIFO_THS, edata->int_status);
case SENSOR_TRIG_FIFO_FULL:
return FIELD_GET(BIT_INT_STATUS_FIFO_FULL, edata->int_status);
default:
return false;
}
}
SENSOR_DECODER_API_DT_DEFINE() = {
.get_frame_count = icm42688_decoder_get_frame_count,
.get_size_info = icm42688_decoder_get_size_info,
.decode = icm42688_decoder_decode,
.has_trigger = icm24688_decoder_has_trigger,
};
int icm42688_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder)
{
ARG_UNUSED(dev);
*decoder = &SENSOR_DECODER_NAME();
return 0;
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_decoder.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 6,543 |
```c
/*
*
*/
#include <zephyr/sys/util.h>
#include "icm42688_spi.h"
#include "icm42688_reg.h"
static inline int spi_write_register(const struct spi_dt_spec *bus, uint8_t reg, uint8_t data)
{
const struct spi_buf buf[2] = {
{
.buf = ®,
.len = 1,
},
{
.buf = &data,
.len = 1,
}
};
const struct spi_buf_set tx = {
.buffers = buf,
.count = 2,
};
return spi_write_dt(bus, &tx);
}
static inline int spi_read_register(const struct spi_dt_spec *bus, uint8_t reg, uint8_t *data,
size_t len)
{
uint8_t tx_buffer = REG_SPI_READ_BIT | reg;
const struct spi_buf tx_buf = {
.buf = &tx_buffer,
.len = 1,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1,
};
struct spi_buf rx_buf[2] = {
{
.buf = NULL,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2,
};
return spi_transceive_dt(bus, &tx, &rx);
}
int icm42688_spi_read(const struct spi_dt_spec *bus, uint16_t reg, uint8_t *data, size_t len)
{
int res = 0;
uint8_t address = FIELD_GET(REG_ADDRESS_MASK, reg);
res = spi_read_register(bus, address, data, len);
return res;
}
int icm42688_spi_update_register(const struct spi_dt_spec *bus, uint16_t reg, uint8_t mask,
uint8_t data)
{
uint8_t temp = 0;
int res = icm42688_spi_read(bus, reg, &temp, 1);
if (res) {
return res;
}
temp &= ~mask;
temp |= FIELD_PREP(mask, data);
return icm42688_spi_single_write(bus, reg, temp);
}
int icm42688_spi_single_write(const struct spi_dt_spec *bus, uint16_t reg, uint8_t data)
{
int res = 0;
uint8_t address = FIELD_GET(REG_ADDRESS_MASK, reg);
res = spi_write_register(bus, address, data);
return res;
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 553 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42688_RTIO_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42688_RTIO_H_
#include <zephyr/device.h>
#include <zephyr/rtio/rtio.h>
void icm42688_submit(const struct device *sensor, struct rtio_iodev_sqe *iodev_sqe);
void icm42688_submit_stream(const struct device *sensor, struct rtio_iodev_sqe *iodev_sqe);
void icm42688_fifo_event(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42688_RTIO_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_rtio.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 141 |
```objective-c
/*
*/
#ifndef DRIVERS_SENSOR_ICM42688_ICM42688_EMUL_H
#define DRIVERS_SENSOR_ICM42688_ICM42688_EMUL_H
#include <zephyr/drivers/emul.h>
/**
* @brief Set one or more register values
*
* @param target The target emulator to modify
* @param reg_addr The starting address of the register to modify
* @param in One or more bytes to write to the registers
* @param count The number of bytes to write
*/
void icm42688_emul_set_reg(const struct emul *target, uint8_t reg_addr, const uint8_t *in,
size_t count);
/**
* @brief Get the values of one or more register values
*
* @param target The target emulator to read
* @param reg_addr The starting address of the register to read
* @param out Buffer to write the register values into
* @param count The number of bytes to read
*/
void icm42688_emul_get_reg(const struct emul *target, uint8_t reg_addr, uint8_t *out, size_t count);
#endif /* DRIVERS_SENSOR_ICM42688_ICM42688_EMUL_H */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_emul.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 253 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42688_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42688_H_
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/dt-bindings/sensor/icm42688.h>
#include <stdlib.h>
static inline uint8_t icm42688_accel_fs_to_reg(uint8_t g)
{
if (g >= 16) {
return ICM42688_DT_ACCEL_FS_16;
} else if (g >= 8) {
return ICM42688_DT_ACCEL_FS_8;
} else if (g >= 4) {
return ICM42688_DT_ACCEL_FS_4;
} else {
return ICM42688_DT_ACCEL_FS_2;
}
}
static inline void icm42688_accel_reg_to_fs(uint8_t fs, struct sensor_value *out)
{
switch (fs) {
case ICM42688_DT_ACCEL_FS_16:
sensor_g_to_ms2(16, out);
return;
case ICM42688_DT_ACCEL_FS_8:
sensor_g_to_ms2(8, out);
return;
case ICM42688_DT_ACCEL_FS_4:
sensor_g_to_ms2(4, out);
return;
case ICM42688_DT_ACCEL_FS_2:
sensor_g_to_ms2(2, out);
return;
}
}
static inline uint8_t icm42688_gyro_fs_to_reg(uint16_t dps)
{
if (dps >= 2000) {
return ICM42688_DT_GYRO_FS_2000;
} else if (dps >= 1000) {
return ICM42688_DT_GYRO_FS_1000;
} else if (dps >= 500) {
return ICM42688_DT_GYRO_FS_500;
} else if (dps >= 250) {
return ICM42688_DT_GYRO_FS_250;
} else if (dps >= 125) {
return ICM42688_DT_GYRO_FS_125;
} else if (dps >= 62) {
return ICM42688_DT_GYRO_FS_62_5;
} else if (dps >= 31) {
return ICM42688_DT_GYRO_FS_31_25;
} else {
return ICM42688_DT_GYRO_FS_15_625;
}
}
static inline void icm42688_gyro_reg_to_fs(uint8_t fs, struct sensor_value *out)
{
switch (fs) {
case ICM42688_DT_GYRO_FS_2000:
sensor_degrees_to_rad(2000, out);
return;
case ICM42688_DT_GYRO_FS_1000:
sensor_degrees_to_rad(1000, out);
return;
case ICM42688_DT_GYRO_FS_500:
sensor_degrees_to_rad(500, out);
return;
case ICM42688_DT_GYRO_FS_250:
sensor_degrees_to_rad(250, out);
return;
case ICM42688_DT_GYRO_FS_125:
sensor_degrees_to_rad(125, out);
return;
case ICM42688_DT_GYRO_FS_62_5:
sensor_10udegrees_to_rad(6250000, out);
return;
case ICM42688_DT_GYRO_FS_31_25:
sensor_10udegrees_to_rad(3125000, out);
return;
case ICM42688_DT_GYRO_FS_15_625:
sensor_10udegrees_to_rad(1562500, out);
return;
}
}
static inline uint8_t icm42688_accel_hz_to_reg(uint16_t hz)
{
if (hz >= 32000) {
return ICM42688_DT_ACCEL_ODR_32000;
} else if (hz >= 16000) {
return ICM42688_DT_ACCEL_ODR_16000;
} else if (hz >= 8000) {
return ICM42688_DT_ACCEL_ODR_8000;
} else if (hz >= 4000) {
return ICM42688_DT_ACCEL_ODR_4000;
} else if (hz >= 2000) {
return ICM42688_DT_ACCEL_ODR_2000;
} else if (hz >= 1000) {
return ICM42688_DT_ACCEL_ODR_1000;
} else if (hz >= 500) {
return ICM42688_DT_ACCEL_ODR_500;
} else if (hz >= 200) {
return ICM42688_DT_ACCEL_ODR_200;
} else if (hz >= 100) {
return ICM42688_DT_ACCEL_ODR_100;
} else if (hz >= 50) {
return ICM42688_DT_ACCEL_ODR_50;
} else if (hz >= 25) {
return ICM42688_DT_ACCEL_ODR_25;
} else if (hz >= 12) {
return ICM42688_DT_ACCEL_ODR_12_5;
} else if (hz >= 6) {
return ICM42688_DT_ACCEL_ODR_6_25;
} else if (hz >= 3) {
return ICM42688_DT_ACCEL_ODR_3_125;
} else {
return ICM42688_DT_ACCEL_ODR_1_5625;
}
}
static inline void icm42688_accel_reg_to_hz(uint8_t odr, struct sensor_value *out)
{
switch (odr) {
case ICM42688_DT_ACCEL_ODR_32000:
out->val1 = 32000;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_16000:
out->val1 = 1600;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_8000:
out->val1 = 8000;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_4000:
out->val1 = 4000;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_2000:
out->val1 = 2000;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_1000:
out->val1 = 1000;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_500:
out->val1 = 500;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_200:
out->val1 = 200;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_100:
out->val1 = 100;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_50:
out->val1 = 50;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_25:
out->val1 = 25;
out->val2 = 0;
return;
case ICM42688_DT_ACCEL_ODR_12_5:
out->val1 = 12;
out->val2 = 500000;
return;
case ICM42688_DT_ACCEL_ODR_6_25:
out->val1 = 6;
out->val2 = 250000;
return;
case ICM42688_DT_ACCEL_ODR_3_125:
out->val1 = 3;
out->val2 = 125000;
return;
case ICM42688_DT_ACCEL_ODR_1_5625:
out->val1 = 1;
out->val2 = 562500;
return;
}
}
static inline uint8_t icm42688_gyro_odr_to_reg(uint16_t hz)
{
if (hz >= 32000) {
return ICM42688_DT_GYRO_ODR_32000;
} else if (hz >= 16000) {
return ICM42688_DT_GYRO_ODR_16000;
} else if (hz >= 8000) {
return ICM42688_DT_GYRO_ODR_8000;
} else if (hz >= 4000) {
return ICM42688_DT_GYRO_ODR_4000;
} else if (hz >= 2000) {
return ICM42688_DT_GYRO_ODR_2000;
} else if (hz >= 1000) {
return ICM42688_DT_GYRO_ODR_1000;
} else if (hz >= 500) {
return ICM42688_DT_GYRO_ODR_500;
} else if (hz >= 200) {
return ICM42688_DT_GYRO_ODR_200;
} else if (hz >= 100) {
return ICM42688_DT_GYRO_ODR_100;
} else if (hz >= 50) {
return ICM42688_DT_GYRO_ODR_50;
} else if (hz >= 25) {
return ICM42688_DT_GYRO_ODR_25;
} else {
return ICM42688_DT_GYRO_ODR_12_5;
}
}
static inline void icm42688_gyro_reg_to_odr(uint8_t odr, struct sensor_value *out)
{
switch (odr) {
case ICM42688_DT_GYRO_ODR_32000:
out->val1 = 32000;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_16000:
out->val1 = 16000;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_8000:
out->val1 = 8000;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_4000:
out->val1 = 4000;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_2000:
out->val1 = 2000;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_1000:
out->val1 = 1000;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_500:
out->val1 = 500;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_200:
out->val1 = 200;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_100:
out->val1 = 100;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_50:
out->val1 = 50;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_25:
out->val1 = 25;
out->val2 = 0;
return;
case ICM42688_DT_GYRO_ODR_12_5:
out->val1 = 12;
out->val2 = 500000;
return;
}
}
/**
* @brief All sensor configuration options
*/
struct icm42688_cfg {
uint8_t accel_pwr_mode;
uint8_t accel_fs;
uint8_t accel_odr;
/* TODO accel signal processing options */
uint8_t gyro_pwr_mode;
uint8_t gyro_fs;
uint8_t gyro_odr;
/* TODO gyro signal processing options */
bool temp_dis;
/* TODO temp signal processing options */
/* TODO timestamp options */
bool fifo_en;
int32_t batch_ticks;
bool fifo_hires;
/* TODO additional FIFO options */
/* TODO interrupt options */
bool interrupt1_drdy;
bool interrupt1_fifo_ths;
bool interrupt1_fifo_full;
};
struct icm42688_trigger_entry {
struct sensor_trigger trigger;
sensor_trigger_handler_t handler;
};
/**
* @brief Device data (struct device)
*/
struct icm42688_dev_data {
struct icm42688_cfg cfg;
#ifdef CONFIG_ICM42688_TRIGGER
#if defined(CONFIG_ICM42688_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ICM42688_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_ICM42688_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#ifdef CONFIG_ICM42688_STREAM
struct rtio_iodev_sqe *streaming_sqe;
struct rtio *r;
struct rtio_iodev *spi_iodev;
uint8_t int_status;
uint16_t fifo_count;
uint64_t timestamp;
atomic_t reading_fifo;
#endif /* CONFIG_ICM42688_STREAM */
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t data_ready_handler;
const struct sensor_trigger *data_ready_trigger;
struct k_mutex mutex;
#endif /* CONFIG_ICM42688_TRIGGER */
int16_t readings[7];
};
/**
* @brief Device config (struct device)
*/
struct icm42688_dev_cfg {
struct spi_dt_spec spi;
struct gpio_dt_spec gpio_int1;
struct gpio_dt_spec gpio_int2;
};
/**
* @brief Reset the sensor
*
* @param dev icm42688 device pointer
*
* @retval 0 success
* @retval -EINVAL Reset status or whoami register returned unexpected value.
*/
int icm42688_reset(const struct device *dev);
/**
* @brief (Re)Configure the sensor with the given configuration
*
* @param dev icm42688 device pointer
* @param cfg icm42688_cfg pointer
*
* @retval 0 success
* @retval -errno Error
*/
int icm42688_configure(const struct device *dev, struct icm42688_cfg *cfg);
/**
* @brief Safely (re)Configure the sensor with the given configuration
*
* Will rollback to prior configuration if new configuration is invalid
*
* @param dev icm42688 device pointer
* @param cfg icm42688_cfg pointer
*
* @retval 0 success
* @retval -errno Error
*/
int icm42688_safely_configure(const struct device *dev, struct icm42688_cfg *cfg);
/**
* @brief Reads all channels
*
* Regardless of what is enabled/disabled this reads all data registers
* as the time to read the 14 bytes at 1MHz is going to be 112 us which
* is less time than a SPI transaction takes to setup typically.
*
* @param dev icm42688 device pointer
* @param buf 14 byte buffer to store data values (7 channels, 2 bytes each)
*
* @retval 0 success
* @retval -errno Error
*/
int icm42688_read_all(const struct device *dev, uint8_t data[14]);
/**
* @brief Convert icm42688 accelerometer value to useful g values
*
* @param cfg icm42688_cfg current device configuration
* @param in raw data value in int32_t format
* @param out_g whole G's output in int32_t
* @param out_ug micro (1/1000000) of a G output as uint32_t
*/
static inline void icm42688_accel_g(struct icm42688_cfg *cfg, int32_t in, int32_t *out_g,
uint32_t *out_ug)
{
int32_t sensitivity;
switch (cfg->accel_fs) {
case ICM42688_DT_ACCEL_FS_2:
sensitivity = 16384;
break;
case ICM42688_DT_ACCEL_FS_4:
sensitivity = 8192;
break;
case ICM42688_DT_ACCEL_FS_8:
sensitivity = 4096;
break;
case ICM42688_DT_ACCEL_FS_16:
sensitivity = 2048;
break;
default:
CODE_UNREACHABLE;
}
/* Whole g's */
*out_g = in / sensitivity;
/* Micro g's */
*out_ug = ((abs(in) - (abs((*out_g)) * sensitivity)) * 1000000) / sensitivity;
}
/**
* @brief Convert icm42688 gyroscope value to useful deg/s values
*
* @param cfg icm42688_cfg current device configuration
* @param in raw data value in int32_t format
* @param out_dps whole deg/s output in int32_t
* @param out_udps micro (1/1000000) deg/s as uint32_t
*/
static inline void icm42688_gyro_dps(const struct icm42688_cfg *cfg, int32_t in, int32_t *out_dps,
uint32_t *out_udps)
{
int64_t sensitivity;
switch (cfg->gyro_fs) {
case ICM42688_DT_GYRO_FS_2000:
sensitivity = 164;
break;
case ICM42688_DT_GYRO_FS_1000:
sensitivity = 328;
break;
case ICM42688_DT_GYRO_FS_500:
sensitivity = 655;
break;
case ICM42688_DT_GYRO_FS_250:
sensitivity = 1310;
break;
case ICM42688_DT_GYRO_FS_125:
sensitivity = 2620;
break;
case ICM42688_DT_GYRO_FS_62_5:
sensitivity = 5243;
break;
case ICM42688_DT_GYRO_FS_31_25:
sensitivity = 10486;
break;
case ICM42688_DT_GYRO_FS_15_625:
sensitivity = 20972;
break;
default:
CODE_UNREACHABLE;
}
int32_t in10 = in * 10;
/* Whole deg/s */
*out_dps = in10 / sensitivity;
/* Micro deg/s */
*out_udps = ((int64_t)(llabs(in10) - (llabs((*out_dps)) * sensitivity)) * 1000000LL) /
sensitivity;
}
/**
* @brief Convert icm42688 accelerometer value to useful m/s^2 values
*
* @param cfg icm42688_cfg current device configuration
* @param in raw data value in int32_t format
* @param out_ms meters/s^2 (whole) output in int32_t
* @param out_ums micrometers/s^2 output as uint32_t
*/
static inline void icm42688_accel_ms(const struct icm42688_cfg *cfg, int32_t in, int32_t *out_ms,
int32_t *out_ums)
{
int64_t sensitivity = 0; /* value equivalent for 1g */
switch (cfg->accel_fs) {
case ICM42688_DT_ACCEL_FS_2:
sensitivity = 16384;
break;
case ICM42688_DT_ACCEL_FS_4:
sensitivity = 8192;
break;
case ICM42688_DT_ACCEL_FS_8:
sensitivity = 4096;
break;
case ICM42688_DT_ACCEL_FS_16:
sensitivity = 2048;
break;
}
/* Convert to micrometers/s^2 */
int64_t in_ms = in * SENSOR_G;
/* meters/s^2 whole values */
*out_ms = in_ms / (sensitivity * 1000000LL);
/* micrometers/s^2 */
*out_ums = (in_ms - (*out_ms * sensitivity * 1000000LL)) / sensitivity;
}
/**
* @brief Convert icm42688 gyroscope value to useful rad/s values
*
* @param cfg icm42688_cfg current device configuration
* @param in raw data value in int32_t format
* @param out_rads whole rad/s output in int32_t
* @param out_urads microrad/s as uint32_t
*/
static inline void icm42688_gyro_rads(const struct icm42688_cfg *cfg, int32_t in, int32_t *out_rads,
int32_t *out_urads)
{
int64_t sensitivity = 0; /* value equivalent for 10x gyro reading deg/s */
switch (cfg->gyro_fs) {
case ICM42688_DT_GYRO_FS_2000:
sensitivity = 164;
break;
case ICM42688_DT_GYRO_FS_1000:
sensitivity = 328;
break;
case ICM42688_DT_GYRO_FS_500:
sensitivity = 655;
break;
case ICM42688_DT_GYRO_FS_250:
sensitivity = 1310;
break;
case ICM42688_DT_GYRO_FS_125:
sensitivity = 2620;
break;
case ICM42688_DT_GYRO_FS_62_5:
sensitivity = 5243;
break;
case ICM42688_DT_GYRO_FS_31_25:
sensitivity = 10486;
break;
case ICM42688_DT_GYRO_FS_15_625:
sensitivity = 20972;
break;
}
int64_t in10_rads = (int64_t)in * SENSOR_PI * 10LL;
/* Whole rad/s */
*out_rads = in10_rads / (sensitivity * 180LL * 1000000LL);
/* microrad/s */
*out_urads =
(in10_rads - (*out_rads * sensitivity * 180LL * 1000000LL)) / (sensitivity * 180LL);
}
/**
* @brief Convert icm42688 temp value to useful celsius values
*
* @param cfg icm42688_cfg current device configuration
* @param in raw data value in int32_t format
* @param out_c whole celsius output in int32_t
* @param out_uc micro (1/1000000) celsius as uint32_t
*/
static inline void icm42688_temp_c(int32_t in, int32_t *out_c, uint32_t *out_uc)
{
int64_t sensitivity = 13248; /* value equivalent for x100 1c */
/* Offset by 25 degrees Celsius */
int64_t in100 = (in * 100) + (25 * sensitivity);
/* Whole celsius */
*out_c = in100 / sensitivity;
/* Micro celsius */
*out_uc = ((in100 - (*out_c) * sensitivity) * INT64_C(1000000)) / sensitivity;
}
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42688_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,053 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42688_DECODER_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42688_DECODER_H_
#include <stdint.h>
#include <zephyr/drivers/sensor.h>
struct icm42688_decoder_header {
uint64_t timestamp;
uint8_t is_fifo: 1;
uint8_t gyro_fs: 3;
uint8_t accel_fs: 2;
uint8_t reserved: 2;
} __attribute__((__packed__));
struct icm42688_fifo_data {
struct icm42688_decoder_header header;
uint8_t int_status;
uint16_t gyro_odr: 4;
uint16_t accel_odr: 4;
uint16_t fifo_count: 11;
uint16_t reserved: 5;
} __attribute__((__packed__));
struct icm42688_encoded_data {
struct icm42688_decoder_header header;
struct {
uint8_t channels: 7;
uint8_t reserved: 1;
} __attribute__((__packed__));
int16_t readings[7];
};
int icm42688_encode(const struct device *dev, const struct sensor_chan_spec *const channels,
const size_t num_channels, uint8_t *buf);
int icm42688_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder);
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42688_DECODER_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_decoder.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 305 |
```c
/*
*
*/
#define DT_DRV_COMPAT invensense_icm42688
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/sys/byteorder.h>
#include "icm42688.h"
#include "icm42688_decoder.h"
#include "icm42688_reg.h"
#include "icm42688_rtio.h"
#include "icm42688_spi.h"
#include "icm42688_trigger.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ICM42688, CONFIG_SENSOR_LOG_LEVEL);
static void icm42688_convert_accel(struct sensor_value *val, int16_t raw_val,
struct icm42688_cfg *cfg)
{
icm42688_accel_ms(cfg, (int32_t)raw_val, &val->val1, &val->val2);
}
static void icm42688_convert_gyro(struct sensor_value *val, int16_t raw_val,
struct icm42688_cfg *cfg)
{
icm42688_gyro_rads(cfg, (int32_t)raw_val, &val->val1, &val->val2);
}
static inline void icm42688_convert_temp(struct sensor_value *val, int16_t raw_val)
{
icm42688_temp_c((int32_t)raw_val, &val->val1, &val->val2);
}
int icm42688_channel_parse_readings(enum sensor_channel chan, int16_t readings[7],
struct icm42688_cfg *cfg, struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
icm42688_convert_accel(&val[0], readings[1], cfg);
icm42688_convert_accel(&val[1], readings[2], cfg);
icm42688_convert_accel(&val[2], readings[3], cfg);
break;
case SENSOR_CHAN_ACCEL_X:
icm42688_convert_accel(val, readings[1], cfg);
break;
case SENSOR_CHAN_ACCEL_Y:
icm42688_convert_accel(val, readings[2], cfg);
break;
case SENSOR_CHAN_ACCEL_Z:
icm42688_convert_accel(val, readings[3], cfg);
break;
case SENSOR_CHAN_GYRO_XYZ:
icm42688_convert_gyro(&val[0], readings[4], cfg);
icm42688_convert_gyro(&val[1], readings[5], cfg);
icm42688_convert_gyro(&val[2], readings[6], cfg);
break;
case SENSOR_CHAN_GYRO_X:
icm42688_convert_gyro(val, readings[4], cfg);
break;
case SENSOR_CHAN_GYRO_Y:
icm42688_convert_gyro(val, readings[5], cfg);
break;
case SENSOR_CHAN_GYRO_Z:
icm42688_convert_gyro(val, readings[6], cfg);
break;
case SENSOR_CHAN_DIE_TEMP:
icm42688_convert_temp(val, readings[0]);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int icm42688_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct icm42688_dev_data *data = dev->data;
return icm42688_channel_parse_readings(chan, data->readings, &data->cfg, val);
}
static int icm42688_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
uint8_t status;
struct icm42688_dev_data *data = dev->data;
const struct icm42688_dev_cfg *cfg = dev->config;
int res = icm42688_spi_read(&cfg->spi, REG_INT_STATUS, &status, 1);
if (res) {
return res;
}
if (!FIELD_GET(BIT_INT_STATUS_DATA_RDY, status)) {
return -EBUSY;
}
uint8_t readings[14];
res = icm42688_read_all(dev, readings);
if (res) {
return res;
}
for (int i = 0; i < 7; i++) {
data->readings[i] = sys_le16_to_cpu((readings[i * 2] << 8) | readings[i * 2 + 1]);
}
return 0;
}
static int icm42688_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct icm42688_dev_data *data = dev->data;
struct icm42688_cfg new_config = data->cfg;
int res = 0;
__ASSERT_NO_MSG(val != NULL);
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
new_config.accel_odr = icm42688_accel_hz_to_reg(val->val1);
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
new_config.accel_fs = icm42688_accel_fs_to_reg(sensor_ms2_to_g(val));
} else {
LOG_ERR("Unsupported attribute");
res = -ENOTSUP;
}
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
new_config.gyro_odr = icm42688_gyro_odr_to_reg(val->val1);
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
new_config.gyro_fs = icm42688_gyro_fs_to_reg(sensor_rad_to_degrees(val));
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
case SENSOR_CHAN_ALL:
if (attr == SENSOR_ATTR_BATCH_DURATION) {
if (val->val1 < 0) {
return -EINVAL;
}
new_config.batch_ticks = val->val1;
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
default:
LOG_ERR("Unsupported channel");
res = -EINVAL;
break;
}
if (res) {
return res;
}
return icm42688_safely_configure(dev, &new_config);
}
static int icm42688_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct icm42688_dev_data *data = dev->data;
const struct icm42688_cfg *cfg = &data->cfg;
int res = 0;
__ASSERT_NO_MSG(val != NULL);
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
icm42688_accel_reg_to_hz(cfg->accel_odr, val);
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
icm42688_accel_reg_to_fs(cfg->accel_fs, val);
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
icm42688_gyro_reg_to_odr(cfg->gyro_odr, val);
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
icm42688_gyro_reg_to_fs(cfg->gyro_fs, val);
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
case SENSOR_CHAN_ALL:
if (attr == SENSOR_ATTR_BATCH_DURATION) {
val->val1 = cfg->batch_ticks;
val->val2 = 0;
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
default:
LOG_ERR("Unsupported channel");
res = -EINVAL;
break;
}
return res;
}
static const struct sensor_driver_api icm42688_driver_api = {
.sample_fetch = icm42688_sample_fetch,
.channel_get = icm42688_channel_get,
.attr_set = icm42688_attr_set,
.attr_get = icm42688_attr_get,
#ifdef CONFIG_ICM42688_TRIGGER
.trigger_set = icm42688_trigger_set,
#endif
.get_decoder = icm42688_get_decoder,
#ifdef CONFIG_SENSOR_ASYNC_API
.submit = icm42688_submit,
#endif
};
int icm42688_init(const struct device *dev)
{
struct icm42688_dev_data *data = dev->data;
const struct icm42688_dev_cfg *cfg = dev->config;
int res;
if (!spi_is_ready_dt(&cfg->spi)) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
}
if (icm42688_reset(dev)) {
LOG_ERR("could not initialize sensor");
return -EIO;
}
#ifdef CONFIG_ICM42688_TRIGGER
res = icm42688_trigger_init(dev);
if (res != 0) {
LOG_ERR("Failed to initialize triggers");
return res;
}
#endif
res = icm42688_configure(dev, &data->cfg);
if (res != 0) {
LOG_ERR("Failed to configure");
return res;
}
return 0;
}
#ifndef CONFIG_ICM42688_TRIGGER
void icm42688_lock(const struct device *dev)
{
ARG_UNUSED(dev);
}
void icm42688_unlock(const struct device *dev)
{
ARG_UNUSED(dev);
}
#endif
/* device defaults to spi mode 0/3 support */
#define ICM42688_SPI_CFG \
SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_WORD_SET(8) | SPI_TRANSFER_MSB
#define ICM42688_RTIO_DEFINE(inst) \
SPI_DT_IODEV_DEFINE(icm42688_spi_iodev_##inst, DT_DRV_INST(inst), ICM42688_SPI_CFG, 0U); \
RTIO_DEFINE(icm42688_rtio_##inst, 8, 4);
#define ICM42688_DT_CONFIG_INIT(inst) \
{ \
.accel_pwr_mode = DT_INST_PROP(inst, accel_pwr_mode), \
.accel_fs = DT_INST_PROP(inst, accel_fs), \
.accel_odr = DT_INST_PROP(inst, accel_odr), \
.gyro_pwr_mode = DT_INST_PROP(inst, gyro_pwr_mode), \
.gyro_fs = DT_INST_PROP(inst, gyro_fs), \
.gyro_odr = DT_INST_PROP(inst, gyro_odr), \
.temp_dis = false, \
.fifo_en = IS_ENABLED(CONFIG_ICM42688_STREAM), \
.batch_ticks = 0, \
.fifo_hires = false, \
.interrupt1_drdy = false, \
.interrupt1_fifo_ths = false, \
.interrupt1_fifo_full = false \
}
#define ICM42688_DEFINE_DATA(inst) \
IF_ENABLED(CONFIG_ICM42688_STREAM, (ICM42688_RTIO_DEFINE(inst))); \
static struct icm42688_dev_data icm42688_driver_##inst = { \
.cfg = ICM42688_DT_CONFIG_INIT(inst), \
IF_ENABLED(CONFIG_ICM42688_STREAM, (.r = &icm42688_rtio_##inst, \
.spi_iodev = &icm42688_spi_iodev_##inst,)) \
};
#define ICM42688_INIT(inst) \
ICM42688_DEFINE_DATA(inst); \
\
static const struct icm42688_dev_cfg icm42688_cfg_##inst = { \
.spi = SPI_DT_SPEC_INST_GET(inst, ICM42688_SPI_CFG, 0U), \
.gpio_int1 = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, {0}), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, icm42688_init, NULL, &icm42688_driver_##inst, \
&icm42688_cfg_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &icm42688_driver_api);
DT_INST_FOREACH_STATUS_OKAY(ICM42688_INIT)
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,750 |
```c
/*
*
*/
#include <zephyr/logging/log.h>
#include "icm42688.h"
#include "icm42688_decoder.h"
#include "icm42688_reg.h"
#include "icm42688_rtio.h"
LOG_MODULE_DECLARE(ICM42688_RTIO);
void icm42688_submit_stream(const struct device *sensor, struct rtio_iodev_sqe *iodev_sqe)
{
const struct sensor_read_config *cfg = iodev_sqe->sqe.iodev->data;
struct icm42688_dev_data *data = sensor->data;
struct icm42688_cfg new_config = data->cfg;
new_config.interrupt1_drdy = false;
new_config.interrupt1_fifo_ths = false;
new_config.interrupt1_fifo_full = false;
for (int i = 0; i < cfg->count; ++i) {
switch (cfg->triggers[i].trigger) {
case SENSOR_TRIG_DATA_READY:
new_config.interrupt1_drdy = true;
break;
case SENSOR_TRIG_FIFO_WATERMARK:
new_config.interrupt1_fifo_ths = true;
break;
case SENSOR_TRIG_FIFO_FULL:
new_config.interrupt1_fifo_full = true;
break;
default:
LOG_DBG("Trigger (%d) not supported", cfg->triggers[i].trigger);
rtio_iodev_sqe_err(iodev_sqe, -ENOTSUP);
return;
}
}
if (new_config.interrupt1_drdy != data->cfg.interrupt1_drdy ||
new_config.interrupt1_fifo_ths != data->cfg.interrupt1_fifo_ths ||
new_config.interrupt1_fifo_full != data->cfg.interrupt1_fifo_full) {
int rc = icm42688_safely_configure(sensor, &new_config);
if (rc != 0) {
LOG_ERR("Failed to configure sensor");
rtio_iodev_sqe_err(iodev_sqe, rc);
return;
}
}
data->streaming_sqe = iodev_sqe;
}
static void icm42688_complete_cb(struct rtio *r, const struct rtio_sqe *sqe, void *arg)
{
const struct device *dev = arg;
struct icm42688_dev_data *drv_data = dev->data;
const struct icm42688_dev_cfg *drv_cfg = dev->config;
struct rtio_iodev_sqe *iodev_sqe = sqe->userdata;
rtio_iodev_sqe_ok(iodev_sqe, drv_data->fifo_count);
gpio_pin_interrupt_configure_dt(&drv_cfg->gpio_int1, GPIO_INT_EDGE_TO_ACTIVE);
}
static void icm42688_fifo_count_cb(struct rtio *r, const struct rtio_sqe *sqe, void *arg)
{
const struct device *dev = arg;
struct icm42688_dev_data *drv_data = dev->data;
const struct icm42688_dev_cfg *drv_cfg = dev->config;
struct rtio_iodev *spi_iodev = drv_data->spi_iodev;
uint8_t *fifo_count_buf = (uint8_t *)&drv_data->fifo_count;
uint16_t fifo_count = ((fifo_count_buf[0] << 8) | fifo_count_buf[1]);
drv_data->fifo_count = fifo_count;
/* Pull a operation from our device iodev queue, validated to only be reads */
struct rtio_iodev_sqe *iodev_sqe = drv_data->streaming_sqe;
drv_data->streaming_sqe = NULL;
/* Not inherently an underrun/overrun as we may have a buffer to fill next time */
if (iodev_sqe == NULL) {
LOG_DBG("No pending SQE");
gpio_pin_interrupt_configure_dt(&drv_cfg->gpio_int1, GPIO_INT_EDGE_TO_ACTIVE);
return;
}
const size_t packet_size = drv_data->cfg.fifo_hires ? 20 : 16;
const size_t min_read_size = sizeof(struct icm42688_fifo_data) + packet_size;
const size_t ideal_read_size = sizeof(struct icm42688_fifo_data) + fifo_count;
uint8_t *buf;
uint32_t buf_len;
if (rtio_sqe_rx_buf(iodev_sqe, min_read_size, ideal_read_size, &buf, &buf_len) != 0) {
LOG_ERR("Failed to get buffer");
rtio_iodev_sqe_err(iodev_sqe, -ENOMEM);
return;
}
LOG_DBG("Requesting buffer [%u, %u] got %u", (unsigned int)min_read_size,
(unsigned int)ideal_read_size, buf_len);
/* Read FIFO and call back to rtio with rtio_sqe completion */
/* TODO is packet format even needed? the fifo has a header per packet
* already
*/
struct icm42688_fifo_data hdr = {
.header = {
.is_fifo = true,
.gyro_fs = drv_data->cfg.gyro_fs,
.accel_fs = drv_data->cfg.accel_fs,
.timestamp = drv_data->timestamp,
},
.int_status = drv_data->int_status,
.gyro_odr = drv_data->cfg.gyro_odr,
.accel_odr = drv_data->cfg.accel_odr,
};
uint32_t buf_avail = buf_len;
memcpy(buf, &hdr, sizeof(hdr));
buf_avail -= sizeof(hdr);
uint32_t read_len = MIN(fifo_count, buf_avail);
uint32_t pkts = read_len / packet_size;
read_len = pkts * packet_size;
((struct icm42688_fifo_data *)buf)->fifo_count = read_len;
__ASSERT_NO_MSG(read_len % pkt_size == 0);
uint8_t *read_buf = buf + sizeof(hdr);
/* Flush out completions */
struct rtio_cqe *cqe;
do {
cqe = rtio_cqe_consume(r);
if (cqe != NULL) {
rtio_cqe_release(r, cqe);
}
} while (cqe != NULL);
/* Setup new rtio chain to read the fifo data and report then check the
* result
*/
struct rtio_sqe *write_fifo_addr = rtio_sqe_acquire(r);
struct rtio_sqe *read_fifo_data = rtio_sqe_acquire(r);
struct rtio_sqe *complete_op = rtio_sqe_acquire(r);
const uint8_t reg_addr = REG_SPI_READ_BIT | FIELD_GET(REG_ADDRESS_MASK, REG_FIFO_DATA);
rtio_sqe_prep_tiny_write(write_fifo_addr, spi_iodev, RTIO_PRIO_NORM, ®_addr, 1, NULL);
write_fifo_addr->flags = RTIO_SQE_TRANSACTION;
rtio_sqe_prep_read(read_fifo_data, spi_iodev, RTIO_PRIO_NORM, read_buf, read_len,
iodev_sqe);
read_fifo_data->flags = RTIO_SQE_CHAINED;
rtio_sqe_prep_callback(complete_op, icm42688_complete_cb, (void *)dev, iodev_sqe);
rtio_submit(r, 0);
}
static struct sensor_stream_trigger *
icm42688_get_read_config_trigger(const struct sensor_read_config *cfg,
enum sensor_trigger_type trig)
{
for (int i = 0; i < cfg->count; ++i) {
if (cfg->triggers[i].trigger == trig) {
return &cfg->triggers[i];
}
}
LOG_DBG("Unsupported trigger (%d)", trig);
return NULL;
}
static void icm42688_int_status_cb(struct rtio *r, const struct rtio_sqe *sqr, void *arg)
{
const struct device *dev = arg;
struct icm42688_dev_data *drv_data = dev->data;
const struct icm42688_dev_cfg *drv_cfg = dev->config;
struct rtio_iodev *spi_iodev = drv_data->spi_iodev;
struct rtio_iodev_sqe *streaming_sqe = drv_data->streaming_sqe;
struct sensor_read_config *read_config;
if (streaming_sqe == NULL) {
return;
}
read_config = (struct sensor_read_config *)streaming_sqe->sqe.iodev->data;
__ASSERT_NO_MSG(read_config != NULL);
if (!read_config->is_streaming) {
/* Oops, not really configured for streaming data */
return;
}
struct sensor_stream_trigger *fifo_ths_cfg =
icm42688_get_read_config_trigger(read_config, SENSOR_TRIG_FIFO_WATERMARK);
bool has_fifo_ths_trig = fifo_ths_cfg != NULL &&
FIELD_GET(BIT_INT_STATUS_FIFO_THS, drv_data->int_status) != 0;
struct sensor_stream_trigger *fifo_full_cfg =
icm42688_get_read_config_trigger(read_config, SENSOR_TRIG_FIFO_FULL);
bool has_fifo_full_trig = fifo_full_cfg != NULL &&
FIELD_GET(BIT_INT_STATUS_FIFO_FULL, drv_data->int_status) != 0;
if (!has_fifo_ths_trig && !has_fifo_full_trig) {
gpio_pin_interrupt_configure_dt(&drv_cfg->gpio_int1, GPIO_INT_EDGE_TO_ACTIVE);
return;
}
/* Flush completions */
struct rtio_cqe *cqe;
do {
cqe = rtio_cqe_consume(r);
if (cqe != NULL) {
rtio_cqe_release(r, cqe);
}
} while (cqe != NULL);
enum sensor_stream_data_opt data_opt;
if (has_fifo_ths_trig && !has_fifo_full_trig) {
/* Only care about fifo threshold */
data_opt = fifo_ths_cfg->opt;
} else if (!has_fifo_ths_trig && has_fifo_full_trig) {
/* Only care about fifo full */
data_opt = fifo_full_cfg->opt;
} else {
/* Both fifo threshold and full */
data_opt = MIN(fifo_ths_cfg->opt, fifo_full_cfg->opt);
}
if (data_opt == SENSOR_STREAM_DATA_NOP || data_opt == SENSOR_STREAM_DATA_DROP) {
uint8_t *buf;
uint32_t buf_len;
/* Clear streaming_sqe since we're done with the call */
drv_data->streaming_sqe = NULL;
if (rtio_sqe_rx_buf(streaming_sqe, sizeof(struct icm42688_fifo_data),
sizeof(struct icm42688_fifo_data), &buf, &buf_len) != 0) {
rtio_iodev_sqe_err(streaming_sqe, -ENOMEM);
return;
}
struct icm42688_fifo_data *data = (struct icm42688_fifo_data *)buf;
memset(buf, 0, buf_len);
data->header.timestamp = drv_data->timestamp;
data->int_status = drv_data->int_status;
data->fifo_count = 0;
rtio_iodev_sqe_ok(streaming_sqe, 0);
gpio_pin_interrupt_configure_dt(&drv_cfg->gpio_int1, GPIO_INT_EDGE_TO_ACTIVE);
if (data_opt == SENSOR_STREAM_DATA_DROP) {
/* Flush the FIFO */
struct rtio_sqe *write_signal_path_reset = rtio_sqe_acquire(r);
uint8_t write_buffer[] = {
FIELD_GET(REG_ADDRESS_MASK, REG_SIGNAL_PATH_RESET),
BIT_FIFO_FLUSH,
};
rtio_sqe_prep_tiny_write(write_signal_path_reset, spi_iodev, RTIO_PRIO_NORM,
write_buffer, ARRAY_SIZE(write_buffer), NULL);
/* TODO Add a new flag for fire-and-forget so we don't have to block here */
rtio_submit(r, 1);
ARG_UNUSED(rtio_cqe_consume(r));
}
return;
}
/* We need the data, read the fifo length */
struct rtio_sqe *write_fifo_count_reg = rtio_sqe_acquire(r);
struct rtio_sqe *read_fifo_count = rtio_sqe_acquire(r);
struct rtio_sqe *check_fifo_count = rtio_sqe_acquire(r);
uint8_t reg = REG_SPI_READ_BIT | FIELD_GET(REG_ADDRESS_MASK, REG_FIFO_COUNTH);
uint8_t *read_buf = (uint8_t *)&drv_data->fifo_count;
rtio_sqe_prep_tiny_write(write_fifo_count_reg, spi_iodev, RTIO_PRIO_NORM, ®, 1, NULL);
write_fifo_count_reg->flags = RTIO_SQE_TRANSACTION;
rtio_sqe_prep_read(read_fifo_count, spi_iodev, RTIO_PRIO_NORM, read_buf, 2, NULL);
read_fifo_count->flags = RTIO_SQE_CHAINED;
rtio_sqe_prep_callback(check_fifo_count, icm42688_fifo_count_cb, arg, NULL);
rtio_submit(r, 0);
}
void icm42688_fifo_event(const struct device *dev)
{
struct icm42688_dev_data *drv_data = dev->data;
struct rtio_iodev *spi_iodev = drv_data->spi_iodev;
struct rtio *r = drv_data->r;
if (drv_data->streaming_sqe == NULL) {
return;
}
drv_data->timestamp = k_ticks_to_ns_floor64(k_uptime_ticks());
/*
* Setup rtio chain of ops with inline calls to make decisions
* 1. read int status
* 2. call to check int status and get pending RX operation
* 4. read fifo len
* 5. call to determine read len
* 6. read fifo
* 7. call to report completion
*/
struct rtio_sqe *write_int_reg = rtio_sqe_acquire(r);
struct rtio_sqe *read_int_reg = rtio_sqe_acquire(r);
struct rtio_sqe *check_int_status = rtio_sqe_acquire(r);
uint8_t reg = REG_SPI_READ_BIT | FIELD_GET(REG_ADDRESS_MASK, REG_INT_STATUS);
rtio_sqe_prep_tiny_write(write_int_reg, spi_iodev, RTIO_PRIO_NORM, ®, 1, NULL);
write_int_reg->flags = RTIO_SQE_TRANSACTION;
rtio_sqe_prep_read(read_int_reg, spi_iodev, RTIO_PRIO_NORM, &drv_data->int_status, 1, NULL);
read_int_reg->flags = RTIO_SQE_CHAINED;
rtio_sqe_prep_callback(check_int_status, icm42688_int_status_cb, (void *)dev, NULL);
rtio_submit(r, 0);
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_rtio_stream.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,161 |
```c
/*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/util.h>
#include "icm42688.h"
#include "icm42688_reg.h"
#include "icm42688_rtio.h"
#include "icm42688_spi.h"
#include "icm42688_trigger.h"
LOG_MODULE_DECLARE(ICM42688, CONFIG_SENSOR_LOG_LEVEL);
static void icm42688_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins)
{
struct icm42688_dev_data *data = CONTAINER_OF(cb, struct icm42688_dev_data, gpio_cb);
ARG_UNUSED(dev);
ARG_UNUSED(pins);
#if defined(CONFIG_ICM42688_TRIGGER_OWN_THREAD)
k_sem_give(&data->gpio_sem);
#elif defined(CONFIG_ICM42688_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
if (IS_ENABLED(CONFIG_ICM42688_STREAM)) {
icm42688_fifo_event(data->dev);
}
}
#if defined(CONFIG_ICM42688_TRIGGER_OWN_THREAD) || defined(CONFIG_ICM42688_TRIGGER_GLOBAL_THREAD)
static void icm42688_thread_cb(const struct device *dev)
{
struct icm42688_dev_data *data = dev->data;
icm42688_lock(dev);
if (data->data_ready_handler != NULL) {
data->data_ready_handler(dev, data->data_ready_trigger);
}
icm42688_unlock(dev);
}
#endif
#ifdef CONFIG_ICM42688_TRIGGER_OWN_THREAD
static void icm42688_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct icm42688_dev_data *data = p1;
while (1) {
k_sem_take(&data->gpio_sem, K_FOREVER);
icm42688_thread_cb(data->dev);
}
}
#elif defined(CONFIG_ICM42688_TRIGGER_GLOBAL_THREAD)
static void icm42688_work_handler(struct k_work *work)
{
struct icm42688_dev_data *data = CONTAINER_OF(work, struct icm42688_dev_data, work);
icm42688_thread_cb(data->dev);
}
#endif
int icm42688_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct icm42688_dev_data *data = dev->data;
const struct icm42688_dev_cfg *cfg = dev->config;
uint8_t status;
int res = 0;
if (trig == NULL || handler == NULL) {
return -EINVAL;
}
icm42688_lock(dev);
gpio_pin_interrupt_configure_dt(&cfg->gpio_int1, GPIO_INT_DISABLE);
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
case SENSOR_TRIG_FIFO_WATERMARK:
case SENSOR_TRIG_FIFO_FULL:
data->data_ready_handler = handler;
data->data_ready_trigger = trig;
res = icm42688_spi_read(&cfg->spi, REG_INT_STATUS, &status, 1);
break;
default:
res = -ENOTSUP;
break;
}
icm42688_unlock(dev);
gpio_pin_interrupt_configure_dt(&cfg->gpio_int1, GPIO_INT_EDGE_TO_ACTIVE);
return res;
}
int icm42688_trigger_init(const struct device *dev)
{
struct icm42688_dev_data *data = dev->data;
const struct icm42688_dev_cfg *cfg = dev->config;
int res = 0;
if (!cfg->gpio_int1.port) {
LOG_ERR("trigger enabled but no interrupt gpio supplied");
return -ENODEV;
}
if (!gpio_is_ready_dt(&cfg->gpio_int1)) {
LOG_ERR("gpio_int1 not ready");
return -ENODEV;
}
data->dev = dev;
gpio_pin_configure_dt(&cfg->gpio_int1, GPIO_INPUT);
gpio_init_callback(&data->gpio_cb, icm42688_gpio_callback, BIT(cfg->gpio_int1.pin));
res = gpio_add_callback(cfg->gpio_int1.port, &data->gpio_cb);
if (res < 0) {
LOG_ERR("Failed to set gpio callback");
return res;
}
k_mutex_init(&data->mutex);
#if defined(CONFIG_ICM42688_TRIGGER_OWN_THREAD)
k_sem_init(&data->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_ICM42688_THREAD_STACK_SIZE,
icm42688_thread, data, NULL, NULL,
K_PRIO_COOP(CONFIG_ICM42688_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_ICM42688_TRIGGER_GLOBAL_THREAD)
data->work.handler = icm42688_work_handler;
#endif
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int1, GPIO_INT_EDGE_TO_ACTIVE);
}
int icm42688_trigger_enable_interrupt(const struct device *dev, struct icm42688_cfg *new_cfg)
{
int res;
const struct icm42688_dev_cfg *cfg = dev->config;
/* pulse-mode (auto clearing), push-pull and active-high */
res = icm42688_spi_single_write(&cfg->spi, REG_INT_CONFIG,
BIT_INT1_DRIVE_CIRCUIT | BIT_INT1_POLARITY);
if (res != 0) {
return res;
}
/* Deassert async reset for proper INT pin operation, see datasheet 14.50 */
res = icm42688_spi_single_write(&cfg->spi, REG_INT_CONFIG1, 0);
if (res != 0) {
return res;
}
/* enable interrupts on INT1 pin */
uint8_t value = 0;
if (new_cfg->interrupt1_drdy) {
value |= FIELD_PREP(BIT_UI_DRDY_INT1_EN, 1);
}
if (new_cfg->interrupt1_fifo_ths) {
value |= FIELD_PREP(BIT_FIFO_THS_INT1_EN, 1);
}
if (new_cfg->interrupt1_fifo_full) {
value |= FIELD_PREP(BIT_FIFO_FULL_INT1_EN, 1);
}
return icm42688_spi_single_write(&cfg->spi, REG_INT_SOURCE0, value);
}
void icm42688_lock(const struct device *dev)
{
struct icm42688_dev_data *data = dev->data;
k_mutex_lock(&data->mutex, K_FOREVER);
}
void icm42688_unlock(const struct device *dev)
{
struct icm42688_dev_data *data = dev->data;
k_mutex_unlock(&data->mutex);
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,436 |
```unknown
# ICM42688-P Six-Axis Motion Tracking device configuration options
#
#
menuconfig ICM42688
bool "ICM42688 Six-Axis Motion Tracking Device"
default y
depends on DT_HAS_INVENSENSE_ICM42688_ENABLED
select SPI
select RTIO_WORKQ if SENSOR_ASYNC_API
help
Enable driver for ICM42688 SPI-based six-axis motion tracking device.
if ICM42688
config EMUL_ICM42688
bool "Emulator for the ICM42688"
default y
depends on EMUL
help
Enable the hardware emulator for the ICM42688. Doing so allows exercising
sensor APIs for this IMU in native_sim and qemu.
config ICM42688_DECODER
bool "ICM42688 decoder logic"
default y
select SENSOR_ASYNC_API
help
Compile the ICM42688 decoder API which allows decoding raw data returned
from the sensor.
choice
prompt "Trigger mode"
default ICM42688_TRIGGER_NONE if ICM42688_STREAM
default ICM42688_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver
config ICM42688_TRIGGER_NONE
bool "No trigger"
config ICM42688_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
select ICM42688_TRIGGER
config ICM42688_TRIGGER_OWN_THREAD
bool "Use own thread"
select ICM42688_TRIGGER
endchoice
config ICM42688_STREAM
bool "Use hardware FIFO to stream data"
select ICM42688_TRIGGER
default y
depends on SPI_RTIO
depends on SENSOR_ASYNC_API
help
Use this config option to enable streaming sensor data via RTIO subsystem.
config ICM42688_TRIGGER
bool
config ICM42688_THREAD_PRIORITY
int "Own thread priority"
depends on ICM42688_TRIGGER_OWN_THREAD
default 10
help
The priority of the thread used for handling interrupts.
config ICM42688_THREAD_STACK_SIZE
int "Own thread stack size"
depends on ICM42688_TRIGGER_OWN_THREAD
default 1024
help
The thread stack size.
endif # ICM42688
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 465 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42688_TRIGGER_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42688_TRIGGER_H_
#include <zephyr/device.h>
/** implement the trigger_set sensor api function */
int icm42688_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
/**
* @brief initialize the icm42688 trigger system
*
* @param dev icm42688 device pointer
* @return int 0 on success, negative error code otherwise
*/
int icm42688_trigger_init(const struct device *dev);
/**
* @brief enable the trigger gpio interrupt
*
* @param dev icm42688 device pointer
* @param new_cfg New configuration to use for the device
* @return int 0 on success, negative error code otherwise
*/
int icm42688_trigger_enable_interrupt(const struct device *dev, struct icm42688_cfg *new_cfg);
/**
* @brief lock access to the icm42688 device driver
*
* @param dev icm42688 device pointer
*/
void icm42688_lock(const struct device *dev);
/**
* @brief lock access to the icm42688 device driver
*
* @param dev icm42688 device pointer
*/
void icm42688_unlock(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42688_TRIGGER_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_trigger.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 303 |
```c
/*
*/
#define DT_DRV_COMPAT invensense_icm42688
#include <zephyr/device.h>
#include <zephyr/drivers/emul.h>
#include <zephyr/drivers/emul_sensor.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/spi_emul.h>
#include <zephyr/logging/log.h>
#include <icm42688_reg.h>
LOG_MODULE_DECLARE(ICM42688, CONFIG_SENSOR_LOG_LEVEL);
#define NUM_REGS (UINT8_MAX >> 1)
struct icm42688_emul_data {
uint8_t reg[NUM_REGS];
};
struct icm42688_emul_cfg {
};
void icm42688_emul_set_reg(const struct emul *target, uint8_t reg_addr, const uint8_t *val,
size_t count)
{
struct icm42688_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr + count < NUM_REGS);
memcpy(data->reg + reg_addr, val, count);
}
void icm42688_emul_get_reg(const struct emul *target, uint8_t reg_addr, uint8_t *val, size_t count)
{
struct icm42688_emul_data *data = target->data;
__ASSERT_NO_MSG(reg_addr + count < NUM_REGS);
memcpy(val, data->reg + reg_addr, count);
}
static void icm42688_emul_handle_write(const struct emul *target, uint8_t regn, uint8_t value)
{
struct icm42688_emul_data *data = target->data;
switch (regn) {
case REG_DEVICE_CONFIG:
if (FIELD_GET(BIT_SOFT_RESET, value) == 1) {
/* Perform a soft reset */
memset(data->reg, 0, NUM_REGS);
/* Initialized the who-am-i register */
data->reg[REG_WHO_AM_I] = WHO_AM_I_ICM42688;
/* Set the bit for the reset being done */
data->reg[REG_INT_STATUS] |= BIT_INT_STATUS_RESET_DONE;
}
break;
}
}
static int icm42688_emul_io_spi(const struct emul *target, const struct spi_config *config,
const struct spi_buf_set *tx_bufs,
const struct spi_buf_set *rx_bufs)
{
struct icm42688_emul_data *data = target->data;
const struct spi_buf *tx, *rx;
uint8_t regn;
bool is_read;
ARG_UNUSED(config);
__ASSERT_NO_MSG(tx_bufs != NULL);
tx = tx_bufs->buffers;
__ASSERT_NO_MSG(tx != NULL);
__ASSERT_NO_MSG(tx->len > 0);
regn = *(uint8_t *)tx->buf;
is_read = FIELD_GET(REG_SPI_READ_BIT, regn);
regn &= GENMASK(6, 0);
if (is_read) {
__ASSERT_NO_MSG(rx_bufs != NULL);
__ASSERT_NO_MSG(rx_bufs->count > 1);
rx = &rx_bufs->buffers[1];
__ASSERT_NO_MSG(rx->buf != NULL);
__ASSERT_NO_MSG(rx->len > 0);
for (uint16_t i = 0; i < rx->len; ++i) {
((uint8_t *)rx->buf)[i] = data->reg[regn + i];
}
} else {
/* Writing to regn */
uint8_t value;
__ASSERT_NO_MSG(tx_bufs->count > 1);
tx = &tx_bufs->buffers[1];
__ASSERT_NO_MSG(tx->len > 0);
value = ((uint8_t *)tx->buf)[0];
icm42688_emul_handle_write(target, regn, value);
}
return 0;
}
static int icm42688_emul_init(const struct emul *target, const struct device *parent)
{
struct icm42688_emul_data *data = target->data;
/* Initialized the who-am-i register */
data->reg[REG_WHO_AM_I] = WHO_AM_I_ICM42688;
return 0;
}
static const struct spi_emul_api icm42688_emul_spi_api = {
.io = icm42688_emul_io_spi,
};
#define Q31_SCALE ((int64_t)INT32_MAX + 1)
/**
* @brief Get current full-scale range in g's based on register config, along with corresponding
* sensitivity and shift. See datasheet section 3.2, table 2.
*/
static void icm42688_emul_get_accel_settings(const struct emul *target, int *fs_g, int *sensitivity,
int8_t *shift)
{
uint8_t reg;
int sensitivity_out, fs_g_out;
int8_t shift_out;
icm42688_emul_get_reg(target, REG_ACCEL_CONFIG0, ®, 1);
switch ((reg & MASK_ACCEL_UI_FS_SEL) >> 5) {
case BIT_ACCEL_UI_FS_16:
fs_g_out = 16;
sensitivity_out = 2048;
/* shift is based on `fs_g * 9.8` since the final numbers will be in SI units of
* m/s^2, not g's
*/
shift_out = 8;
break;
case BIT_ACCEL_UI_FS_8:
fs_g_out = 8;
sensitivity_out = 4096;
shift_out = 7;
break;
case BIT_ACCEL_UI_FS_4:
fs_g_out = 4;
sensitivity_out = 8192;
shift_out = 6;
break;
case BIT_ACCEL_UI_FS_2:
fs_g_out = 2;
sensitivity_out = 16384;
shift_out = 5;
break;
default:
__ASSERT_UNREACHABLE;
}
if (fs_g) {
*fs_g = fs_g_out;
}
if (sensitivity) {
*sensitivity = sensitivity_out;
}
if (shift) {
*shift = shift_out;
}
}
/**
* @brief Helper function for calculating accelerometer ranges. Considers the current full-scale
* register config (i.e. +/-2g, +/-4g, etc...)
*/
static void icm42688_emul_get_accel_ranges(const struct emul *target, q31_t *lower, q31_t *upper,
q31_t *epsilon, int8_t *shift)
{
int fs_g;
int sensitivity;
icm42688_emul_get_accel_settings(target, &fs_g, &sensitivity, shift);
/* Epsilon is equal to 1.5 bit-counts worth of error. */
*epsilon = (3 * SENSOR_G * Q31_SCALE / sensitivity / 1000000LL / 2) >> *shift;
*upper = (fs_g * SENSOR_G * Q31_SCALE / 1000000LL) >> *shift;
*lower = -*upper;
}
/**
* @brief Get current full-scale gyro range in milli-degrees per second based on register config,
* along with corresponding sensitivity and shift. See datasheet section 3.1, table 1.
*/
static void icm42688_emul_get_gyro_settings(const struct emul *target, int *fs_mdps,
int *sensitivity, int8_t *shift)
{
uint8_t reg;
int sensitivity_out, fs_mdps_out;
int8_t shift_out;
icm42688_emul_get_reg(target, REG_GYRO_CONFIG0, ®, 1);
switch ((reg & MASK_GYRO_UI_FS_SEL) >> 5) {
case BIT_GYRO_UI_FS_2000:
/* Milli-degrees per second */
fs_mdps_out = 2000000;
/* 10x LSBs/deg/s */
sensitivity_out = 164;
/* Shifts are based on rad/s: `(fs_mdps * pi / 180 / 1000)` */
shift_out = 6; /* +/- 34.90659 */
break;
case BIT_GYRO_UI_FS_1000:
fs_mdps_out = 1000000;
sensitivity_out = 328;
shift_out = 5; /* +/- 17.44444 */
break;
case BIT_GYRO_UI_FS_500:
fs_mdps_out = 500000;
sensitivity_out = 655;
shift_out = 4; /* +/- 8.72222 */
break;
case BIT_GYRO_UI_FS_250:
fs_mdps_out = 250000;
sensitivity_out = 1310;
shift_out = 3; /* +/- 4.36111 */
break;
case BIT_GYRO_UI_FS_125:
fs_mdps_out = 125000;
sensitivity_out = 2620;
shift_out = 2; /* +/- 2.18055 */
break;
case BIT_GYRO_UI_FS_62_5:
fs_mdps_out = 62500;
sensitivity_out = 5243;
shift_out = 1; /* +/- 1.09027 */
break;
case BIT_GYRO_UI_FS_31_25:
fs_mdps_out = 31250;
sensitivity_out = 10486;
shift_out = 0; /* +/- 0.54513 */
break;
case BIT_GYRO_UI_FS_15_625:
fs_mdps_out = 15625;
sensitivity_out = 20972;
shift_out = -1; /* +/- 0.27256 */
break;
default:
__ASSERT_UNREACHABLE;
}
if (fs_mdps) {
*fs_mdps = fs_mdps_out;
}
if (sensitivity) {
*sensitivity = sensitivity_out;
}
if (shift) {
*shift = shift_out;
}
}
/**
* @brief Helper function for calculating gyroscope ranges. Considers the current full-scale
* register config
*/
static void icm42688_emul_get_gyro_ranges(const struct emul *target, q31_t *lower, q31_t *upper,
q31_t *epsilon, int8_t *shift)
{
/* millidegrees/second */
int fs_mdps;
/* 10x LSBs per degrees/second*/
int sensitivity;
icm42688_emul_get_gyro_settings(target, &fs_mdps, &sensitivity, shift);
/* Reduce the actual range of gyroscope values. Some full-scale ranges actually exceed the
* size of an int16 by a small margin. For example, FS_SEL=0 has a +/-2000 deg/s range with
* 16.4 bits/deg/s sensitivity (Section 3.1, Table 1). This works out to register values of
* +/-2000 * 16.4 = +/-32800. This will cause the expected value to get clipped when
* setting the register and throw off the actual reading. Therefore, scale down the range
* to 99% to avoid the top and bottom edges.
*/
fs_mdps *= 0.99;
/* Epsilon is equal to 1.5 bit-counts worth of error. */
*epsilon = (3 * SENSOR_PI * Q31_SCALE * 10LL / 1000000LL / 180LL / sensitivity / 2LL) >>
*shift;
*upper = (((fs_mdps * SENSOR_PI / 1000000LL) * Q31_SCALE) / 1000LL / 180LL) >> *shift;
*lower = -*upper;
}
static int icm42688_emul_backend_get_sample_range(const struct emul *target,
struct sensor_chan_spec ch, q31_t *lower,
q31_t *upper, q31_t *epsilon, int8_t *shift)
{
if (!lower || !upper || !epsilon || !shift) {
return -EINVAL;
}
switch (ch.chan_type) {
case SENSOR_CHAN_DIE_TEMP:
/* degrees C = ([16-bit signed temp_data register] / 132.48) + 25 */
*shift = 9;
*lower = (int64_t)(-222.342995169 * Q31_SCALE) >> *shift;
*upper = (int64_t)(272.33544686 * Q31_SCALE) >> *shift;
*epsilon = (int64_t)(0.0076 * Q31_SCALE) >> *shift;
break;
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
icm42688_emul_get_accel_ranges(target, lower, upper, epsilon, shift);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
icm42688_emul_get_gyro_ranges(target, lower, upper, epsilon, shift);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int icm42688_emul_backend_set_channel(const struct emul *target, struct sensor_chan_spec ch,
const q31_t *value, int8_t shift)
{
if (!target || !target->data) {
return -EINVAL;
}
struct icm42688_emul_data *data = target->data;
int sensitivity;
uint8_t reg_addr;
int32_t reg_val;
int64_t value_unshifted =
shift < 0 ? ((int64_t)*value >> -shift) : ((int64_t)*value << shift);
switch (ch.chan_type) {
case SENSOR_CHAN_DIE_TEMP:
reg_addr = REG_TEMP_DATA1;
reg_val = ((value_unshifted - (25 * Q31_SCALE)) * 13248) / (100 * Q31_SCALE);
break;
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
switch (ch.chan_type) {
case SENSOR_CHAN_ACCEL_X:
reg_addr = REG_ACCEL_DATA_X1;
break;
case SENSOR_CHAN_ACCEL_Y:
reg_addr = REG_ACCEL_DATA_Y1;
break;
case SENSOR_CHAN_ACCEL_Z:
reg_addr = REG_ACCEL_DATA_Z1;
break;
default:
__ASSERT_UNREACHABLE;
}
icm42688_emul_get_accel_settings(target, NULL, &sensitivity, NULL);
reg_val = ((value_unshifted * sensitivity / Q31_SCALE) * 1000000LL) / SENSOR_G;
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
switch (ch.chan_type) {
case SENSOR_CHAN_GYRO_X:
reg_addr = REG_GYRO_DATA_X1;
break;
case SENSOR_CHAN_GYRO_Y:
reg_addr = REG_GYRO_DATA_Y1;
break;
case SENSOR_CHAN_GYRO_Z:
reg_addr = REG_GYRO_DATA_Z1;
break;
default:
__ASSERT_UNREACHABLE;
}
icm42688_emul_get_gyro_settings(target, NULL, &sensitivity, NULL);
reg_val =
CLAMP((((value_unshifted * sensitivity * 180LL) / Q31_SCALE) * 1000000LL) /
SENSOR_PI / 10LL,
INT16_MIN, INT16_MAX);
break;
default:
return -ENOTSUP;
}
data->reg[reg_addr] = (reg_val >> 8) & 0xFF;
data->reg[reg_addr + 1] = reg_val & 0xFF;
/* Set data ready flag */
data->reg[REG_INT_STATUS] |= BIT_INT_STATUS_DATA_RDY;
return 0;
}
static const struct emul_sensor_driver_api icm42688_emul_sensor_driver_api = {
.set_channel = icm42688_emul_backend_set_channel,
.get_sample_range = icm42688_emul_backend_get_sample_range,
};
#define ICM42688_EMUL_DEFINE(n, api) \
EMUL_DT_INST_DEFINE(n, icm42688_emul_init, &icm42688_emul_data_##n, \
&icm42688_emul_cfg_##n, &api, &icm42688_emul_sensor_driver_api)
#define ICM42688_EMUL_SPI(n) \
static struct icm42688_emul_data icm42688_emul_data_##n; \
static const struct icm42688_emul_cfg icm42688_emul_cfg_##n; \
ICM42688_EMUL_DEFINE(n, icm42688_emul_spi_api)
DT_INST_FOREACH_STATUS_OKAY(ICM42688_EMUL_SPI)
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_emul.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,638 |
```c
/*
*
*/
/*
* Bus-specific functionality for ICM42670 accessed via I2C.
*/
#include "icm42670.h"
#include "icm42670_reg.h"
#if ICM42670_BUS_I2C
static int icm42670_bus_check_i2c(const union icm42670_bus *bus)
{
return i2c_is_ready_dt(&bus->i2c) ? 0 : -ENODEV;
}
static int i2c_read_mreg(const union icm42670_bus *bus, uint8_t reg, uint8_t bank,
uint8_t *buf, size_t len)
{
int res = i2c_reg_write_byte_dt(&bus->i2c, REG_BLK_SEL_R, bank);
if (res) {
return res;
}
/* reads from MREG registers must be done byte-by-byte */
for (size_t i = 0; i < len; i++) {
uint8_t addr = reg + i;
res = i2c_reg_write_byte_dt(&bus->i2c, REG_MADDR_R, addr);
if (res) {
return res;
}
k_usleep(MREG_R_W_WAIT_US);
res = i2c_reg_read_byte_dt(&bus->i2c, REG_M_R, &buf[i]);
if (res) {
return res;
}
k_usleep(MREG_R_W_WAIT_US);
}
return 0;
}
static int icm42670_reg_read_i2c(const union icm42670_bus *bus, uint16_t reg, uint8_t *data,
size_t len)
{
int res = 0;
uint8_t bank = FIELD_GET(REG_BANK_MASK, reg);
uint8_t address = FIELD_GET(REG_ADDRESS_MASK, reg);
if (bank) {
res = i2c_read_mreg(bus, address, bank, data, len);
} else {
res = i2c_burst_read_dt(&bus->i2c, address, data, len);
}
return res;
}
static int i2c_write_mreg(const union icm42670_bus *bus, uint16_t reg, uint8_t bank,
uint8_t buf)
{
int res = i2c_reg_write_byte_dt(&bus->i2c, REG_BLK_SEL_W, bank);
if (res) {
return res;
}
res = i2c_reg_write_byte_dt(&bus->i2c, REG_MADDR_W, reg);
if (res) {
return res;
}
res = i2c_reg_write_byte_dt(&bus->i2c, REG_M_W, buf);
if (res) {
return res;
}
k_usleep(MREG_R_W_WAIT_US);
return 0;
}
static int icm42670_reg_write_i2c(const union icm42670_bus *bus,
uint16_t reg, uint8_t data)
{
int res = 0;
uint8_t bank = FIELD_GET(REG_BANK_MASK, reg);
uint8_t address = FIELD_GET(REG_ADDRESS_MASK, reg);
if (bank) {
res = i2c_write_mreg(bus, address, bank, data);
} else {
res = i2c_reg_write_byte_dt(&bus->i2c, address, data);
}
return res;
}
static int icm42670_reg_update_i2c(const union icm42670_bus *bus, uint16_t reg, uint8_t mask,
uint8_t val)
{
return i2c_reg_update_byte_dt(&bus->i2c, reg, mask, val);
}
const struct icm42670_bus_io icm42670_bus_io_i2c = {
.check = icm42670_bus_check_i2c,
.read = icm42670_reg_read_i2c,
.write = icm42670_reg_write_i2c,
.update = icm42670_reg_update_i2c,
};
#endif /* ICM42670_BUS_I2C */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/icm42670_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 852 |
```c
/*
*
*/
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/sys/byteorder.h>
#include "icm42688.h"
#include "icm42688_reg.h"
#include "icm42688_spi.h"
#include "icm42688_trigger.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ICM42688_LL, CONFIG_SENSOR_LOG_LEVEL);
int icm42688_reset(const struct device *dev)
{
int res;
uint8_t value;
const struct icm42688_dev_cfg *dev_cfg = dev->config;
/* start up time for register read/write after POR is 1ms and supply ramp time is 3ms */
k_msleep(3);
/* perform a soft reset to ensure a clean slate, reset bit will auto-clear */
res = icm42688_spi_single_write(&dev_cfg->spi, REG_DEVICE_CONFIG, BIT_SOFT_RESET);
if (res) {
LOG_ERR("write REG_SIGNAL_PATH_RESET failed");
return res;
}
/* wait for soft reset to take effect */
k_msleep(SOFT_RESET_TIME_MS);
/* clear reset done int flag */
res = icm42688_spi_read(&dev_cfg->spi, REG_INT_STATUS, &value, 1);
if (res) {
return res;
}
if (FIELD_GET(BIT_INT_STATUS_RESET_DONE, value) != 1) {
LOG_ERR("unexpected RESET_DONE value, %i", value);
return -EINVAL;
}
res = icm42688_spi_read(&dev_cfg->spi, REG_WHO_AM_I, &value, 1);
if (res) {
return res;
}
if (value != WHO_AM_I_ICM42688) {
LOG_ERR("invalid WHO_AM_I value, was %i but expected %i", value, WHO_AM_I_ICM42688);
return -EINVAL;
}
return 0;
}
static uint16_t icm42688_compute_fifo_wm(const struct icm42688_cfg *cfg)
{
const bool accel_enabled = cfg->accel_pwr_mode != ICM42688_DT_ACCEL_OFF;
const bool gyro_enabled = cfg->gyro_pwr_mode != ICM42688_DT_GYRO_OFF;
const int pkt_size = cfg->fifo_hires ? 20 : (accel_enabled && gyro_enabled ? 16 : 8);
int accel_modr = 0;
int gyro_modr = 0;
int64_t modr;
if (cfg->batch_ticks == 0 || (!accel_enabled && !gyro_enabled)) {
return 0;
}
if (accel_enabled) {
struct sensor_value val = {0};
icm42688_accel_reg_to_hz(cfg->accel_odr, &val);
accel_modr = sensor_value_to_micro(&val) / 1000;
}
if (gyro_enabled) {
struct sensor_value val = {0};
icm42688_gyro_reg_to_odr(cfg->gyro_odr, &val);
gyro_modr = sensor_value_to_micro(&val) / 1000;
}
if (accel_modr == 0) {
modr = gyro_modr;
} else if (gyro_modr == 0) {
modr = accel_modr;
} else {
/* Need to find the least common multiplier (LCM) */
int n1 = accel_modr;
int n2 = gyro_modr;
while (n1 != n2) {
if (n1 > n2) {
n1 -= n2;
} else {
n2 -= n1;
}
}
LOG_DBG("GCD=%d", n1);
modr = ((int64_t)accel_modr * (int64_t)gyro_modr) / n1;
}
/* At this point we have 'modr' as mHz which is 1 / msec. */
/* Convert 'modr' to bytes * batch_ticks / msec */
modr *= (int64_t)cfg->batch_ticks * pkt_size;
/* 'modr' = byte_ticks_per_msec / kticks_per_sec */
modr = DIV_ROUND_UP(modr, CONFIG_SYS_CLOCK_TICKS_PER_SEC * INT64_C(1000));
return (uint16_t)MIN(modr, 0x7ff);
}
int icm42688_configure(const struct device *dev, struct icm42688_cfg *cfg)
{
struct icm42688_dev_data *dev_data = dev->data;
const struct icm42688_dev_cfg *dev_cfg = dev->config;
int res;
/* Disable interrupts, reconfigured at end */
res = icm42688_spi_single_write(&dev_cfg->spi, REG_INT_SOURCE0, 0);
/* if fifo is enabled right now, disable and flush */
if (dev_data->cfg.fifo_en) {
res = icm42688_spi_single_write(&dev_cfg->spi, REG_FIFO_CONFIG,
FIELD_PREP(MASK_FIFO_MODE, BIT_FIFO_MODE_BYPASS));
if (res != 0) {
LOG_ERR("Error writing FIFO_CONFIG");
return -EINVAL;
}
res = icm42688_spi_single_write(&dev_cfg->spi, REG_SIGNAL_PATH_RESET,
FIELD_PREP(BIT_FIFO_FLUSH, 1));
if (res != 0) {
LOG_ERR("Error flushing fifo");
return -EINVAL;
}
}
/* TODO maybe do the next few steps intelligently by checking current config */
/* Power management to set gyro/accel modes */
uint8_t pwr_mgmt0 = FIELD_PREP(MASK_GYRO_MODE, cfg->gyro_pwr_mode) |
FIELD_PREP(MASK_ACCEL_MODE, cfg->accel_pwr_mode) |
FIELD_PREP(BIT_TEMP_DIS, cfg->temp_dis);
LOG_DBG("PWR_MGMT0 (0x%x) 0x%x", REG_PWR_MGMT0, pwr_mgmt0);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_PWR_MGMT0, pwr_mgmt0);
if (res != 0) {
LOG_ERR("Error writing PWR_MGMT0");
return -EINVAL;
}
/* Need to wait at least 200us before updating more registers
* see datasheet 14.36
*/
k_busy_wait(250);
uint8_t accel_config0 = FIELD_PREP(MASK_ACCEL_ODR, cfg->accel_odr) |
FIELD_PREP(MASK_ACCEL_UI_FS_SEL, cfg->accel_fs);
LOG_DBG("ACCEL_CONFIG0 (0x%x) 0x%x", REG_ACCEL_CONFIG0, accel_config0);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_ACCEL_CONFIG0, accel_config0);
if (res != 0) {
LOG_ERR("Error writing ACCEL_CONFIG0");
return -EINVAL;
}
uint8_t gyro_config0 = FIELD_PREP(MASK_GYRO_ODR, cfg->gyro_odr) |
FIELD_PREP(MASK_GYRO_UI_FS_SEL, cfg->gyro_fs);
LOG_DBG("GYRO_CONFIG0 (0x%x) 0x%x", REG_GYRO_CONFIG0, gyro_config0);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_GYRO_CONFIG0, gyro_config0);
if (res != 0) {
LOG_ERR("Error writing GYRO_CONFIG0");
return -EINVAL;
}
/*
* Accelerometer sensor need at least 10ms startup time
* Gyroscope sensor need at least 30ms startup time
*/
k_msleep(50);
/* Ensure FIFO is in bypass mode */
uint8_t fifo_config_bypass = FIELD_PREP(MASK_FIFO_MODE, BIT_FIFO_MODE_BYPASS);
LOG_DBG("FIFO_CONFIG (0x%x) 0x%x", REG_FIFO_CONFIG, fifo_config_bypass);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_FIFO_CONFIG, fifo_config_bypass);
if (res != 0) {
LOG_ERR("Error writing FIFO_CONFIG");
return -EINVAL;
}
/* Disable FSYNC */
uint8_t tmst_config;
res = icm42688_spi_single_write(&dev_cfg->spi, REG_FSYNC_CONFIG, 0);
if (res != 0) {
LOG_ERR("Error writing FSYNC_CONFIG");
return -EINVAL;
}
res = icm42688_spi_read(&dev_cfg->spi, REG_TMST_CONFIG, &tmst_config, 1);
if (res != 0) {
LOG_ERR("Error reading TMST_CONFIG");
return -EINVAL;
}
res = icm42688_spi_single_write(&dev_cfg->spi, REG_TMST_CONFIG, tmst_config & ~BIT(1));
if (res != 0) {
LOG_ERR("Error writing TMST_CONFIG");
return -EINVAL;
}
/* Pulse mode with async reset (resets interrupt line on int status read) */
if (IS_ENABLED(CONFIG_ICM42688_TRIGGER)) {
res = icm42688_trigger_enable_interrupt(dev, cfg);
} else {
res = icm42688_spi_single_write(&dev_cfg->spi, REG_INT_CONFIG,
BIT_INT1_DRIVE_CIRCUIT | BIT_INT1_POLARITY);
}
if (res) {
LOG_ERR("Error writing to INT_CONFIG");
return res;
}
uint8_t int_config1 = 0;
if ((cfg->accel_odr <= ICM42688_DT_ACCEL_ODR_4000 ||
cfg->gyro_odr <= ICM42688_DT_GYRO_ODR_4000)) {
int_config1 = FIELD_PREP(BIT_INT_TPULSE_DURATION, 1) |
FIELD_PREP(BIT_INT_TDEASSERT_DISABLE, 1);
}
res = icm42688_spi_single_write(&dev_cfg->spi, REG_INT_CONFIG1, int_config1);
if (res) {
LOG_ERR("Error writing to INT_CONFIG1");
return res;
}
/* fifo configuration steps if desired */
if (cfg->fifo_en) {
LOG_INF("FIFO ENABLED");
/* Setup desired FIFO packet fields, maybe should base this on the other
* temp/accel/gyro en fields in cfg
*/
uint8_t fifo_cfg1 =
FIELD_PREP(BIT_FIFO_TEMP_EN, 1) | FIELD_PREP(BIT_FIFO_GYRO_EN, 1) |
FIELD_PREP(BIT_FIFO_ACCEL_EN, 1) | FIELD_PREP(BIT_FIFO_TMST_FSYNC_EN, 1);
LOG_DBG("FIFO_CONFIG1 (0x%x) 0x%x", REG_FIFO_CONFIG1, fifo_cfg1);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_FIFO_CONFIG1, fifo_cfg1);
if (res != 0) {
LOG_ERR("Error writing FIFO_CONFIG1");
return -EINVAL;
}
/* Set watermark and interrupt handling first */
uint16_t fifo_wm = icm42688_compute_fifo_wm(cfg);
uint8_t fifo_wml = fifo_wm & 0xFF;
LOG_DBG("FIFO_CONFIG2( (0x%x)) (WM Low) 0x%x", REG_FIFO_CONFIG2, fifo_wml);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_FIFO_CONFIG2, fifo_wml);
if (res != 0) {
LOG_ERR("Error writing FIFO_CONFIG2");
return -EINVAL;
}
uint8_t fifo_wmh = (fifo_wm >> 8) & 0x0F;
LOG_DBG("FIFO_CONFIG3 (0x%x) (WM High) 0x%x", REG_FIFO_CONFIG3, fifo_wmh);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_FIFO_CONFIG3, fifo_wmh);
if (res != 0) {
LOG_ERR("Error writing FIFO_CONFIG3");
return -EINVAL;
}
/* Begin streaming */
uint8_t fifo_config = FIELD_PREP(MASK_FIFO_MODE, BIT_FIFO_MODE_STREAM);
LOG_DBG("FIFO_CONFIG (0x%x) 0x%x", REG_FIFO_CONFIG, 1 << 6);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_FIFO_CONFIG, fifo_config);
/* Config interrupt source to only be fifo wm/full */
uint8_t int_source0 = BIT_FIFO_FULL_INT1_EN | BIT_FIFO_THS_INT1_EN;
LOG_DBG("INT_SOURCE0 (0x%x) 0x%x", REG_INT_SOURCE0, int_source0);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_INT_SOURCE0, int_source0);
if (res) {
return res;
}
} else {
LOG_INF("FIFO DISABLED");
/* No fifo mode so set data ready as interrupt source */
uint8_t int_source0 = BIT_UI_DRDY_INT1_EN;
LOG_DBG("INT_SOURCE0 (0x%x) 0x%x", REG_INT_SOURCE0, int_source0);
res = icm42688_spi_single_write(&dev_cfg->spi, REG_INT_SOURCE0, int_source0);
if (res) {
return res;
}
}
return res;
}
int icm42688_safely_configure(const struct device *dev, struct icm42688_cfg *cfg)
{
struct icm42688_dev_data *drv_data = dev->data;
int ret = icm42688_configure(dev, cfg);
if (ret == 0) {
drv_data->cfg = *cfg;
} else {
ret = icm42688_configure(dev, &drv_data->cfg);
}
return ret;
}
int icm42688_read_all(const struct device *dev, uint8_t data[14])
{
const struct icm42688_dev_cfg *dev_cfg = dev->config;
int res;
res = icm42688_spi_read(&dev_cfg->spi, REG_TEMP_DATA1, data, 14);
return res;
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42688/icm42688_common.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,066 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42670_TRIGGER_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42670_TRIGGER_H_
#include <zephyr/device.h>
/** implement the trigger_set sensor api function */
int icm42670_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
/**
* @brief initialize the icm42670 trigger system
*
* @param dev icm42670 device pointer
* @return int 0 on success, negative error code otherwise
*/
int icm42670_trigger_init(const struct device *dev);
/**
* @brief enable the trigger gpio interrupt
*
* @param dev icm42670 device pointer
* @return int 0 on success, negative error code otherwise
*/
int icm42670_trigger_enable_interrupt(const struct device *dev);
/**
* @brief lock access to the icm42670 device driver
*
* @param dev icm42670 device pointer
*/
void icm42670_lock(const struct device *dev);
/**
* @brief lock access to the icm42670 device driver
*
* @param dev icm42670 device pointer
*/
void icm42670_unlock(const struct device *dev);
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42670_TRIGGER_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/icm42670_trigger.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 280 |
```c
/*
*
*/
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#include "icm42670.h"
#include "icm42670_reg.h"
#if ICM42670_BUS_SPI
static inline int spi_write_register(const union icm42670_bus *bus, uint8_t reg, uint8_t data)
{
const struct spi_buf buf[2] = {
{
.buf = ®,
.len = 1,
},
{
.buf = &data,
.len = 1,
}
};
const struct spi_buf_set tx = {
.buffers = buf,
.count = 2,
};
return spi_write_dt(&bus->spi, &tx);
}
static inline int spi_read_register(const union icm42670_bus *bus, uint8_t reg, uint8_t *data,
size_t len)
{
uint8_t tx_buffer = REG_SPI_READ_BIT | reg;
const struct spi_buf tx_buf = {
.buf = &tx_buffer,
.len = 1,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1,
};
struct spi_buf rx_buf[2] = {
{
.buf = NULL,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2,
};
return spi_transceive_dt(&bus->spi, &tx, &rx);
}
static inline int spi_read_mreg(const union icm42670_bus *bus, uint8_t reg, uint8_t bank,
uint8_t *buf, size_t len)
{
int res = spi_write_register(bus, REG_BLK_SEL_R, bank);
if (res) {
return res;
}
/* reads from MREG registers must be done byte-by-byte */
for (size_t i = 0; i < len; i++) {
uint8_t addr = reg + i;
res = spi_write_register(bus, REG_MADDR_R, addr);
if (res) {
return res;
}
k_usleep(MREG_R_W_WAIT_US);
res = spi_read_register(bus, REG_M_R, &buf[i], 1);
if (res) {
return res;
}
k_usleep(MREG_R_W_WAIT_US);
}
return 0;
}
static inline int spi_write_mreg(const union icm42670_bus *bus, uint8_t reg, uint8_t bank,
uint8_t buf)
{
int res = spi_write_register(bus, REG_BLK_SEL_W, bank);
if (res) {
return res;
}
res = spi_write_register(bus, REG_MADDR_W, reg);
if (res) {
return res;
}
res = spi_write_register(bus, REG_M_W, buf);
if (res) {
return res;
}
k_usleep(MREG_R_W_WAIT_US);
return 0;
}
int icm42670_spi_read(const union icm42670_bus *bus, uint16_t reg, uint8_t *data, size_t len)
{
int res = 0;
uint8_t bank = FIELD_GET(REG_BANK_MASK, reg);
uint8_t address = FIELD_GET(REG_ADDRESS_MASK, reg);
if (bank) {
res = spi_read_mreg(bus, address, bank, data, len);
} else {
res = spi_read_register(bus, address, data, len);
}
return res;
}
int icm42670_spi_single_write(const union icm42670_bus *bus, uint16_t reg, uint8_t data)
{
int res = 0;
uint8_t bank = FIELD_GET(REG_BANK_MASK, reg);
uint8_t address = FIELD_GET(REG_ADDRESS_MASK, reg);
if (bank) {
res = spi_write_mreg(bus, address, bank, data);
} else {
res = spi_write_register(bus, address, data);
}
return res;
}
int icm42670_spi_update_register(const union icm42670_bus *bus, uint16_t reg, uint8_t mask,
uint8_t data)
{
uint8_t temp = 0;
int res = icm42670_spi_read(bus, reg, &temp, 1);
if (res) {
return res;
}
temp &= ~mask;
temp |= FIELD_PREP(mask, data);
return icm42670_spi_single_write(bus, reg, temp);
}
static int icm42670_bus_check_spi(const union icm42670_bus *bus)
{
return spi_is_ready_dt(&bus->spi) ? 0 : -ENODEV;
}
const struct icm42670_bus_io icm42670_bus_io_spi = {
.check = icm42670_bus_check_spi,
.read = icm42670_spi_read,
.write = icm42670_spi_single_write,
.update = icm42670_spi_update_register,
};
#endif /* ICM42670_BUS_SPI */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/icm42670_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,093 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_ICM42670_REG_H_
#define ZEPHYR_DRIVERS_SENSOR_ICM42670_REG_H_
#include <zephyr/sys/util.h>
/* Helper macros for addressing registers in MREG1-3, see datasheet section 13 */
#define REG_MADDR_BASE 0x0028
#define REG_MREG1_SHIFT 8
#define REG_MREG2_SHIFT 9
#define REG_MREG3_SHIFT 10
#define REG_BANK0_OFFSET 0x0000
#define REG_MREG1_OFFSET (REG_MADDR_BASE << REG_MREG1_SHIFT)
#define REG_MREG2_OFFSET (REG_MADDR_BASE << REG_MREG2_SHIFT)
#define REG_MREG3_OFFSET (REG_MADDR_BASE << REG_MREG3_SHIFT)
#define REG_ADDRESS_MASK GENMASK(7, 0)
#define REG_BANK_MASK GENMASK(15, 8)
#define REG_SPI_READ_BIT BIT(7)
#define MREG_R_W_WAIT_US 20 /* 10us, but use 20us to be on the safe side */
/* BANK 0 */
#define REG_MCLK_RDY (REG_BANK0_OFFSET | 0x00)
#define REG_DEVICE_CONFIG (REG_BANK0_OFFSET | 0x01)
#define REG_SIGNAL_PATH_RESET (REG_BANK0_OFFSET | 0x02)
#define REG_DRIVE_CONFIG1 (REG_BANK0_OFFSET | 0x03)
#define REG_DRIVE_CONFIG2 (REG_BANK0_OFFSET | 0x04)
#define REG_DRIVE_CONFIG3 (REG_BANK0_OFFSET | 0x05)
#define REG_INT_CONFIG (REG_BANK0_OFFSET | 0x06)
#define REG_TEMP_DATA1 (REG_BANK0_OFFSET | 0x09)
#define REG_TEMP_DATA0 (REG_BANK0_OFFSET | 0x0a)
#define REG_ACCEL_DATA_X1 (REG_BANK0_OFFSET | 0x0b)
#define REG_ACCEL_DATA_X0 (REG_BANK0_OFFSET | 0x0c)
#define REG_ACCEL_DATA_Y1 (REG_BANK0_OFFSET | 0x0d)
#define REG_ACCEL_DATA_Y0 (REG_BANK0_OFFSET | 0x0e)
#define REG_ACCEL_DATA_Z1 (REG_BANK0_OFFSET | 0x0f)
#define REG_ACCEL_DATA_Z0 (REG_BANK0_OFFSET | 0x10)
#define REG_GYRO_DATA_X1 (REG_BANK0_OFFSET | 0x11)
#define REG_GYRO_DATA_X0 (REG_BANK0_OFFSET | 0x12)
#define REG_GYRO_DATA_Y1 (REG_BANK0_OFFSET | 0x13)
#define REG_GYRO_DATA_Y0 (REG_BANK0_OFFSET | 0x14)
#define REG_GYRO_DATA_Z1 (REG_BANK0_OFFSET | 0x15)
#define REG_GYRO_DATA_Z0 (REG_BANK0_OFFSET | 0x16)
#define REG_TMST_FSYNCH (REG_BANK0_OFFSET | 0x17)
#define REG_TMST_FSYNCL (REG_BANK0_OFFSET | 0x18)
#define REG_APEX_DATA4 (REG_BANK0_OFFSET | 0x1d)
#define REG_APEX_DATA5 (REG_BANK0_OFFSET | 0x1e)
#define REG_PWR_MGMT0 (REG_BANK0_OFFSET | 0x1f)
#define REG_GYRO_CONFIG0 (REG_BANK0_OFFSET | 0x20)
#define REG_ACCEL_CONFIG0 (REG_BANK0_OFFSET | 0x21)
#define REG_TEMP_CONFIG0 (REG_BANK0_OFFSET | 0x22)
#define REG_GYRO_CONFIG1 (REG_BANK0_OFFSET | 0x23)
#define REG_ACCEL_CONFIG1 (REG_BANK0_OFFSET | 0x24)
#define REG_APEX_CONFIG0 (REG_BANK0_OFFSET | 0x25)
#define REG_APEX_CONFIG1 (REG_BANK0_OFFSET | 0x26)
#define REG_WOM_CONFIG (REG_BANK0_OFFSET | 0x27)
#define REG_FIFO_CONFIG1 (REG_BANK0_OFFSET | 0x28)
#define REG_FIFO_CONFIG2 (REG_BANK0_OFFSET | 0x29)
#define REG_FIFO_CONFIG3 (REG_BANK0_OFFSET | 0x2a)
#define REG_INT_SOURCE0 (REG_BANK0_OFFSET | 0x2b)
#define REG_INT_SOURCE1 (REG_BANK0_OFFSET | 0x2c)
#define REG_INT_SOURCE3 (REG_BANK0_OFFSET | 0x2d)
#define REG_INT_SOURCE4 (REG_BANK0_OFFSET | 0x2e)
#define REG_FIFO_LOST_PKT0 (REG_BANK0_OFFSET | 0x2f)
#define REG_FIFO_LOST_PKT1 (REG_BANK0_OFFSET | 0x30)
#define REG_APEX_DATA0 (REG_BANK0_OFFSET | 0x31)
#define REG_APEX_DATA1 (REG_BANK0_OFFSET | 0x32)
#define REG_APEX_DATA2 (REG_BANK0_OFFSET | 0x33)
#define REG_APEX_DATA3 (REG_BANK0_OFFSET | 0x34)
#define REG_INTF_CONFIG0 (REG_BANK0_OFFSET | 0x35)
#define REG_INTF_CONFIG1 (REG_BANK0_OFFSET | 0x36)
#define REG_INT_STATUS_DRDY (REG_BANK0_OFFSET | 0x39)
#define REG_INT_STATUS (REG_BANK0_OFFSET | 0x3a)
#define REG_INT_STATUS2 (REG_BANK0_OFFSET | 0x3b)
#define REG_INT_STATUS3 (REG_BANK0_OFFSET | 0x3c)
#define REG_FIFO_COUNTH (REG_BANK0_OFFSET | 0x3d)
#define REG_FIFO_COUNTL (REG_BANK0_OFFSET | 0x3e)
#define REG_FIFO_DATA (REG_BANK0_OFFSET | 0x3f)
#define REG_WHO_AM_I (REG_BANK0_OFFSET | 0x75)
#define REG_BLK_SEL_W (REG_BANK0_OFFSET | 0x79)
#define REG_MADDR_W (REG_BANK0_OFFSET | 0x7a)
#define REG_M_W (REG_BANK0_OFFSET | 0x7b)
#define REG_BLK_SEL_R (REG_BANK0_OFFSET | 0x7c)
#define REG_MADDR_R (REG_BANK0_OFFSET | 0x7d)
#define REG_M_R (REG_BANK0_OFFSET | 0x7e)
/* MREG1 */
#define REG_TMST_CONFIG1 (REG_MREG1_OFFSET | 0x00)
#define REG_FIFO_CONFIG5 (REG_MREG1_OFFSET | 0x01)
#define REG_FIFO_CONFIG6 (REG_MREG1_OFFSET | 0x02)
#define REG_FSYNC_CONFIG (REG_MREG1_OFFSET | 0x03)
#define REG_INT_CONFIG0 (REG_MREG1_OFFSET | 0x04)
#define REG_INT_CONFIG1 (REG_MREG1_OFFSET | 0x05)
#define REG_SENSOR_CONFIG3 (REG_MREG1_OFFSET | 0x06)
#define REG_ST_CONFIG (REG_MREG1_OFFSET | 0x13)
#define REG_SELFTEST (REG_MREG1_OFFSET | 0x14)
#define REG_INTF_CONFIG6 (REG_MREG1_OFFSET | 0x23)
#define REG_INTF_CONFIG10 (REG_MREG1_OFFSET | 0x25)
#define REG_INTF_CONFIG7 (REG_MREG1_OFFSET | 0x28)
#define REG_OTP_CONFIG (REG_MREG1_OFFSET | 0x2b)
#define REG_INT_SOURCE6 (REG_MREG1_OFFSET | 0x2f)
#define REG_INT_SOURCE7 (REG_MREG1_OFFSET | 0x30)
#define REG_INT_SOURCE8 (REG_MREG1_OFFSET | 0x31)
#define REG_INT_SOURCE9 (REG_MREG1_OFFSET | 0x32)
#define REG_INT_SOURCE10 (REG_MREG1_OFFSET | 0x33)
#define REG_APEX_CONFIG2 (REG_MREG1_OFFSET | 0x44)
#define REG_APEX_CONFIG3 (REG_MREG1_OFFSET | 0x45)
#define REG_APEX_CONFIG4 (REG_MREG1_OFFSET | 0x46)
#define REG_APEX_CONFIG5 (REG_MREG1_OFFSET | 0x47)
#define REG_APEX_CONFIG9 (REG_MREG1_OFFSET | 0x48)
#define REG_APEX_CONFIG10 (REG_MREG1_OFFSET | 0x49)
#define REG_APEX_CONFIG11 (REG_MREG1_OFFSET | 0x4a)
#define REG_ACCEL_WOM_X_THR (REG_MREG1_OFFSET | 0x4b)
#define REG_ACCEL_WOM_Y_THR (REG_MREG1_OFFSET | 0x4c)
#define REG_ACCEL_WOM_Z_THR (REG_MREG1_OFFSET | 0x4d)
#define REG_OFFSET_USER0 (REG_MREG1_OFFSET | 0x4e)
#define REG_OFFSET_USER1 (REG_MREG1_OFFSET | 0x4f)
#define REG_OFFSET_USER2 (REG_MREG1_OFFSET | 0x50)
#define REG_OFFSET_USER3 (REG_MREG1_OFFSET | 0x51)
#define REG_OFFSET_USER4 (REG_MREG1_OFFSET | 0x52)
#define REG_OFFSET_USER5 (REG_MREG1_OFFSET | 0x53)
#define REG_OFFSET_USER6 (REG_MREG1_OFFSET | 0x54)
#define REG_OFFSET_USER7 (REG_MREG1_OFFSET | 0x55)
#define REG_OFFSET_USER8 (REG_MREG1_OFFSET | 0x56)
#define REG_ST_STATUS1 (REG_MREG1_OFFSET | 0x63)
#define REG_ST_STATUS2 (REG_MREG1_OFFSET | 0x64)
#define REG_FDR_CONFIG (REG_MREG1_OFFSET | 0x66)
#define REG_APEX_CONFIG12 (REG_MREG1_OFFSET | 0x67)
/* MREG2 */
#define REG_OTP_CTRL7 (REG_MREG2_OFFSET | 0x06)
/* MREG3 */
#define REG_XA_ST_DATA3 (REG_MREG3_OFFSET | 0x00)
#define REG_YA_ST_DATA3 (REG_MREG3_OFFSET | 0x01)
#define REG_ZA_ST_DATA3 (REG_MREG3_OFFSET | 0x02)
#define REG_XG_ST_DATA3 (REG_MREG3_OFFSET | 0x03)
#define REG_YG_ST_DATA3 (REG_MREG3_OFFSET | 0x04)
#define REG_ZG_ST_DATA3 (REG_MREG3_OFFSET | 0x05)
/* Bank0 REG_MCLK_RDY */
#define BIT_MCLK_RDY BIT(3)
/* Bank0 REG_DEVICE_CONFIG */
#define BIT_SPI_AP_4WIRE BIT(2)
#define BIT_SPI_MODE BIT(0)
/* Bank0 REG_SIGNAL_PATH_RESET */
#define BIT_FIFO_FLUSH BIT(2)
#define BIT_SOFT_RESET BIT(4)
/* Bank0 REG_INST_STATUS */
#define BIT_STATUS_RESET_DONE_INT BIT(4)
/* Bank0 REG_INT_CONFIG */
#define BIT_INT1_POLARITY BIT(0)
#define BIT_INT1_DRIVE_CIRCUIT BIT(1)
#define BIT_INT1_MODE BIT(2)
#define BIT_INT2_POLARITY BIT(3)
#define BIT_INT2_DRIVE_CIRCUIT BIT(4)
#define BIT_INT2_MODE BIT(5)
/* Bank0 REG_PWR_MGMT_0 */
#define MASK_ACCEL_MODE GENMASK(1, 0)
#define BIT_ACCEL_MODE_OFF 0x00
#define BIT_ACCEL_MODE_LPM 0x02
#define BIT_ACCEL_MODE_LNM 0x03
#define MASK_GYRO_MODE GENMASK(3, 2)
#define BIT_GYRO_MODE_OFF 0x00
#define BIT_GYRO_MODE_STBY 0x01
#define BIT_GYRO_MODE_LNM 0x03
#define BIT_IDLE BIT(4)
#define BIT_ACCEL_LP_CLK_SEL BIT(7)
/* Bank0 REG_INT_SOURCE0 */
#define BIT_INT_AGC_RDY_INT1_EN BIT(0)
#define BIT_INT_FIFO_FULL_INT1_EN BIT(1)
#define BIT_INT_FIFO_THS_INT1_EN BIT(2)
#define BIT_INT_DRDY_INT1_EN BIT(3)
#define BIT_INT_RESET_DONE_INT1_EN BIT(4)
#define BIT_INT_PLL_RDY_INT1_EN BIT(5)
#define BIT_INT_FSYNC_INT1_EN BIT(6)
#define BIT_INT_ST_INT1_EN BIT(7)
/* Bank0 REG_INT_STATUS_DRDY */
#define BIT_INT_STATUS_DATA_DRDY BIT(0)
/* Bank9 REG_INTF_CONFIG1 */
#define BIT_I3C_SDR_EN BIT(3)
#define BIT_I3C_DDR_EN BIT(2)
#define MASK_CLKSEL GENMASK(1, 0)
#define BIT_CLKSEL_INT_RC 0x00
#define BIT_CLKSEL_PLL_OR_RC 0x01
#define BIT_CLKSEL_DISABLE 0x11
/* Bank0 REG_INT_STATUS */
#define BIT_INT_STATUS_AGC_RDY BIT(0)
#define BIT_INT_STATUS_FIFO_FULL BIT(1)
#define BIT_INT_STATUS_FIFO_THS BIT(2)
#define BIT_INT_STATUS_RESET_DONE BIT(4)
#define BIT_INT_STATUS_PLL_RDY BIT(5)
#define BIT_INT_STATUS_FSYNC BIT(6)
#define BIT_INT_STATUS_ST BIT(7)
/* Bank0 REG_INT_STATUS2 */
#define BIT_INT_STATUS_WOM_Z BIT(0)
#define BIT_INT_STATUS_WOM_Y BIT(1)
#define BIT_INT_STATUS_WOM_X BIT(2)
#define BIT_INT_STATUS_SMD BIT(3)
/* Bank0 REG_INT_STATUS3 */
#define BIT_INT_STATUS_LOWG_DET BIT(1)
#define BIT_INT_STATUS_FF_DET BIT(2)
#define BIT_INT_STATUS_TILT_DET BIT(3)
#define BIT_INT_STATUS_STEP_CNT_OVFL BIT(4)
#define BIT_INT_STATUS_STEP_DET BIT(5)
/* Bank0 REG_ACCEL_CONFIG0 */
#define MASK_ACCEL_UI_FS_SEL GENMASK(6, 5)
#define BIT_ACCEL_UI_FS_16 0x00
#define BIT_ACCEL_UI_FS_8 0x01
#define BIT_ACCEL_UI_FS_4 0x02
#define BIT_ACCEL_UI_FS_2 0x03
#define MASK_ACCEL_ODR GENMASK(3, 0)
#define BIT_ACCEL_ODR_1600 0x05
#define BIT_ACCEL_ODR_800 0x06
#define BIT_ACCEL_ODR_400 0x07
#define BIT_ACCEL_ODR_200 0x08
#define BIT_ACCEL_ODR_100 0x09
#define BIT_ACCEL_ODR_50 0x0A
#define BIT_ACCEL_ODR_25 0x0B
#define BIT_ACCEL_ODR_12 0x0C
#define BIT_ACCEL_ODR_6 0x0D
#define BIT_ACCEL_ODR_3 0x0E
#define BIT_ACCEL_ODR_1 0x0F
/* Bank0 REG_GYRO_CONFIG0 */
#define MASK_GYRO_UI_FS_SEL GENMASK(6, 5)
#define BIT_GYRO_UI_FS_2000 0x00
#define BIT_GYRO_UI_FS_1000 0x01
#define BIT_GYRO_UI_FS_500 0x02
#define BIT_GYRO_UI_FS_250 0x03
#define MASK_GYRO_ODR GENMASK(3, 0)
#define BIT_GYRO_ODR_1600 0x05
#define BIT_GYRO_ODR_800 0x06
#define BIT_GYRO_ODR_400 0x07
#define BIT_GYRO_ODR_200 0x08
#define BIT_GYRO_ODR_100 0x09
#define BIT_GYRO_ODR_50 0x0A
#define BIT_GYRO_ODR_25 0x0B
#define BIT_GYRO_ODR_12 0x0C
/* misc. defines */
#define WHO_AM_I_ICM42670 0x67
#define MIN_ACCEL_SENS_SHIFT 11
#define ACCEL_DATA_SIZE 6
#define GYRO_DATA_SIZE 6
#define TEMP_DATA_SIZE 2
#define MCLK_POLL_INTERVAL_US 250
#define MCLK_POLL_ATTEMPTS 100
#define SOFT_RESET_TIME_MS 2 /* 1ms + elbow room */
#endif /* ZEPHYR_DRIVERS_SENSOR_ICM42670_REG_H_ */
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/icm42670_reg.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,641 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/util.h>
#include "icm42670.h"
#include "icm42670_reg.h"
#include "icm42670_trigger.h"
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(ICM42670, CONFIG_SENSOR_LOG_LEVEL);
static void icm42670_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins)
{
ARG_UNUSED(dev);
ARG_UNUSED(pins);
struct icm42670_data *data = CONTAINER_OF(cb, struct icm42670_data, gpio_cb);
#if defined(CONFIG_ICM42670_TRIGGER_OWN_THREAD)
k_sem_give(&data->gpio_sem);
#elif defined(CONFIG_ICM42670_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void icm42670_thread_cb(const struct device *dev)
{
struct icm42670_data *data = dev->data;
const struct icm42670_config *cfg = dev->config;
icm42670_lock(dev);
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
if (data->data_ready_handler) {
data->data_ready_handler(dev, data->data_ready_trigger);
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_EDGE_TO_ACTIVE);
icm42670_unlock(dev);
}
#if defined(CONFIG_ICM42670_TRIGGER_OWN_THREAD)
static void icm42670_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct icm42670_data *data = p1;
while (1) {
k_sem_take(&data->gpio_sem, K_FOREVER);
icm42670_thread_cb(data->dev);
}
}
#elif defined(CONFIG_ICM42670_TRIGGER_GLOBAL_THREAD)
static void icm42670_work_handler(struct k_work *work)
{
struct icm42670_data *data = CONTAINER_OF(work, struct icm42670_data, work);
icm42670_thread_cb(data->dev);
}
#endif
int icm42670_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
int res = 0;
struct icm42670_data *data = dev->data;
const struct icm42670_config *cfg = dev->config;
if (!handler) {
return -EINVAL;
}
icm42670_lock(dev);
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
data->data_ready_handler = handler;
data->data_ready_trigger = trig;
break;
default:
res = -ENOTSUP;
break;
}
icm42670_unlock(dev);
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_EDGE_TO_ACTIVE);
return res;
}
int icm42670_trigger_init(const struct device *dev)
{
struct icm42670_data *data = dev->data;
const struct icm42670_config *cfg = dev->config;
int res = 0;
if (!cfg->gpio_int.port) {
LOG_ERR("trigger enabled but no interrupt gpio supplied");
return -ENODEV;
}
if (!gpio_is_ready_dt(&cfg->gpio_int)) {
LOG_ERR("gpio_int gpio not ready");
return -ENODEV;
}
data->dev = dev;
gpio_pin_configure_dt(&cfg->gpio_int, GPIO_INPUT);
gpio_init_callback(&data->gpio_cb, icm42670_gpio_callback, BIT(cfg->gpio_int.pin));
res = gpio_add_callback(cfg->gpio_int.port, &data->gpio_cb);
if (res < 0) {
LOG_ERR("Failed to set gpio callback");
return res;
}
k_mutex_init(&data->mutex);
#if defined(CONFIG_ICM42670_TRIGGER_OWN_THREAD)
k_sem_init(&data->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_ICM42670_THREAD_STACK_SIZE,
icm42670_thread, data, NULL, NULL,
K_PRIO_COOP(CONFIG_ICM42670_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_ICM42670_TRIGGER_GLOBAL_THREAD)
data->work.handler = icm42670_work_handler;
#endif
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_EDGE_TO_ACTIVE);
}
int icm42670_trigger_enable_interrupt(const struct device *dev)
{
int res;
const struct icm42670_config *cfg = dev->config;
/* pulse-mode (auto clearing), push-pull and active-high */
res = cfg->bus_io->write(&cfg->bus, REG_INT_CONFIG,
BIT_INT1_DRIVE_CIRCUIT | BIT_INT1_POLARITY);
if (res) {
return res;
}
/* enable data ready interrupt on INT1 pin */
return cfg->bus_io->write(&cfg->bus, REG_INT_SOURCE0, BIT_INT_DRDY_INT1_EN);
}
void icm42670_lock(const struct device *dev)
{
struct icm42670_data *data = dev->data;
k_mutex_lock(&data->mutex, K_FOREVER);
}
void icm42670_unlock(const struct device *dev)
{
struct icm42670_data *data = dev->data;
k_mutex_unlock(&data->mutex);
}
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/icm42670_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,166 |
```c
/*
*
*/
#define DT_DRV_COMPAT invensense_icm42670
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/sys/byteorder.h>
#include "icm42670.h"
#include "icm42670_reg.h"
#include "icm42670_trigger.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ICM42670, CONFIG_SENSOR_LOG_LEVEL);
/*
* Gyro FS to scaling factor mapping.
* See datasheet section 3.1 for details
*/
static const uint16_t icm42670_gyro_sensitivity_x10[] = {
164, /* BIT_GYRO_UI_FS_2000 */
328, /* BIT_GYRO_UI_FS_1000 */
655, /* BIT_GYRO_UI_FS_500 */
1310, /* BIT_GYRO_UI_FS_250 */
};
static int icm42670_set_accel_fs(const struct device *dev, uint16_t fs)
{
const struct icm42670_config *cfg = dev->config;
struct icm42670_data *data = dev->data;
uint8_t temp;
if ((fs > 16) || (fs < 2)) {
LOG_ERR("Unsupported range");
return -ENOTSUP;
}
if (fs > 8) {
temp = BIT_ACCEL_UI_FS_16;
} else if (fs > 4) {
temp = BIT_ACCEL_UI_FS_8;
} else if (fs > 2) {
temp = BIT_ACCEL_UI_FS_4;
} else {
temp = BIT_ACCEL_UI_FS_2;
}
data->accel_sensitivity_shift = MIN_ACCEL_SENS_SHIFT + temp;
return cfg->bus_io->update(&cfg->bus, REG_ACCEL_CONFIG0,
(uint8_t)MASK_ACCEL_UI_FS_SEL, temp);
}
static int icm42670_set_gyro_fs(const struct device *dev, uint16_t fs)
{
const struct icm42670_config *cfg = dev->config;
struct icm42670_data *data = dev->data;
uint8_t temp;
if ((fs > 2000) || (fs < 250)) {
LOG_ERR("Unsupported range");
return -ENOTSUP;
}
if (fs > 1000) {
temp = BIT_GYRO_UI_FS_2000;
} else if (fs > 500) {
temp = BIT_GYRO_UI_FS_1000;
} else if (fs > 250) {
temp = BIT_GYRO_UI_FS_500;
} else {
temp = BIT_GYRO_UI_FS_250;
}
data->gyro_sensitivity_x10 = icm42670_gyro_sensitivity_x10[temp];
return cfg->bus_io->update(&cfg->bus, REG_GYRO_CONFIG0,
(uint8_t)MASK_GYRO_UI_FS_SEL, temp);
}
static int icm42670_set_accel_odr(const struct device *dev, uint16_t rate)
{
const struct icm42670_config *cfg = dev->config;
uint8_t temp;
if ((rate > 1600) || (rate < 1)) {
LOG_ERR("Unsupported frequency");
return -ENOTSUP;
}
if (rate > 800) {
temp = BIT_ACCEL_ODR_1600;
} else if (rate > 400) {
temp = BIT_ACCEL_ODR_800;
} else if (rate > 200) {
temp = BIT_ACCEL_ODR_400;
} else if (rate > 100) {
temp = BIT_ACCEL_ODR_200;
} else if (rate > 50) {
temp = BIT_ACCEL_ODR_100;
} else if (rate > 25) {
temp = BIT_ACCEL_ODR_50;
} else if (rate > 12) {
temp = BIT_ACCEL_ODR_25;
} else if (rate > 6) {
temp = BIT_ACCEL_ODR_12;
} else if (rate > 3) {
temp = BIT_ACCEL_ODR_6;
} else if (rate > 1) {
temp = BIT_ACCEL_ODR_3;
} else {
temp = BIT_ACCEL_ODR_1;
}
return cfg->bus_io->update(&cfg->bus, REG_ACCEL_CONFIG0, (uint8_t)MASK_ACCEL_ODR,
temp);
}
static int icm42670_set_gyro_odr(const struct device *dev, uint16_t rate)
{
const struct icm42670_config *cfg = dev->config;
uint8_t temp;
if ((rate > 1600) || (rate < 12)) {
LOG_ERR("Unsupported frequency");
return -ENOTSUP;
}
if (rate > 800) {
temp = BIT_GYRO_ODR_1600;
} else if (rate > 400) {
temp = BIT_GYRO_ODR_800;
} else if (rate > 200) {
temp = BIT_GYRO_ODR_400;
} else if (rate > 100) {
temp = BIT_GYRO_ODR_200;
} else if (rate > 50) {
temp = BIT_GYRO_ODR_100;
} else if (rate > 25) {
temp = BIT_GYRO_ODR_50;
} else if (rate > 12) {
temp = BIT_GYRO_ODR_25;
} else {
temp = BIT_GYRO_ODR_12;
}
return cfg->bus_io->update(&cfg->bus, REG_GYRO_CONFIG0, (uint8_t)MASK_GYRO_ODR,
temp);
}
static int icm42670_enable_mclk(const struct device *dev)
{
const struct icm42670_config *cfg = dev->config;
/* switch on MCLK by setting the IDLE bit */
int res = cfg->bus_io->write(&cfg->bus, REG_PWR_MGMT0, BIT_IDLE);
if (res) {
return res;
}
/* wait for the MCLK to stabilize by polling MCLK_RDY register */
for (int i = 0; i < MCLK_POLL_ATTEMPTS; i++) {
uint8_t value = 0;
k_usleep(MCLK_POLL_INTERVAL_US);
res = cfg->bus_io->read(&cfg->bus, REG_MCLK_RDY, &value, 1);
if (res) {
return res;
}
if (FIELD_GET(BIT_MCLK_RDY, value)) {
return 0;
}
}
return -EIO;
}
static int icm42670_sensor_init(const struct device *dev)
{
int res;
uint8_t value;
const struct icm42670_config *cfg = dev->config;
/* start up time for register read/write after POR is 1ms and supply ramp time is 3ms */
k_msleep(3);
/* perform a soft reset to ensure a clean slate, reset bit will auto-clear */
res = cfg->bus_io->write(&cfg->bus, REG_SIGNAL_PATH_RESET, BIT_SOFT_RESET);
if (res) {
LOG_ERR("write REG_SIGNAL_PATH_RESET failed");
return res;
}
/* wait for soft reset to take effect */
k_msleep(SOFT_RESET_TIME_MS);
/* force SPI-4w hardware configuration (so that next read is correct) */
res = cfg->bus_io->write(&cfg->bus, REG_DEVICE_CONFIG, BIT_SPI_AP_4WIRE);
if (res) {
return res;
}
/* always use internal RC oscillator */
res = cfg->bus_io->write(&cfg->bus, REG_INTF_CONFIG1,
(uint8_t)FIELD_PREP(MASK_CLKSEL, BIT_CLKSEL_INT_RC));
if (res) {
return res;
}
/* clear reset done int flag */
res = cfg->bus_io->read(&cfg->bus, REG_INT_STATUS, &value, 1);
if (res) {
return res;
}
if (FIELD_GET(BIT_STATUS_RESET_DONE_INT, value) != 1) {
LOG_ERR("unexpected RESET_DONE_INT value, %i", value);
return -EINVAL;
}
/* enable the master clock to ensure proper operation */
res = icm42670_enable_mclk(dev);
if (res) {
return res;
}
res = cfg->bus_io->read(&cfg->bus, REG_WHO_AM_I, &value, 1);
if (res) {
return res;
}
if (value != WHO_AM_I_ICM42670) {
LOG_ERR("invalid WHO_AM_I value, was %i but expected %i", value, WHO_AM_I_ICM42670);
return -EINVAL;
}
LOG_DBG("device id: 0x%02X", value);
return 0;
}
static int icm42670_turn_on_sensor(const struct device *dev)
{
struct icm42670_data *data = dev->data;
const struct icm42670_config *cfg = dev->config;
uint8_t value;
int res;
value = FIELD_PREP(MASK_ACCEL_MODE, BIT_ACCEL_MODE_LNM) |
FIELD_PREP(MASK_GYRO_MODE, BIT_GYRO_MODE_LNM);
res = cfg->bus_io->update(&cfg->bus, REG_PWR_MGMT0,
(uint8_t)(MASK_ACCEL_MODE | MASK_GYRO_MODE), value);
if (res) {
return res;
}
res = icm42670_set_accel_fs(dev, data->accel_fs);
if (res) {
return res;
}
res = icm42670_set_accel_odr(dev, data->accel_hz);
if (res) {
return res;
}
res = icm42670_set_gyro_fs(dev, data->gyro_fs);
if (res) {
return res;
}
res = icm42670_set_gyro_odr(dev, data->gyro_hz);
if (res) {
return res;
}
/*
* Accelerometer sensor need at least 10ms startup time
* Gyroscope sensor need at least 30ms startup time
*/
k_msleep(100);
return 0;
}
static void icm42670_convert_accel(struct sensor_value *val, int16_t raw_val,
uint16_t sensitivity_shift)
{
/* see datasheet section 3.2 for details */
int64_t conv_val = ((int64_t)raw_val * SENSOR_G) >> sensitivity_shift;
val->val1 = conv_val / 1000000LL;
val->val2 = conv_val % 1000000LL;
}
static void icm42670_convert_gyro(struct sensor_value *val, int16_t raw_val,
uint16_t sensitivity_x10)
{
/* see datasheet section 3.1 for details */
int64_t conv_val = ((int64_t)raw_val * SENSOR_PI * 10) / (sensitivity_x10 * 180LL);
val->val1 = conv_val / 1000000LL;
val->val2 = conv_val % 1000000LL;
}
static inline void icm42670_convert_temp(struct sensor_value *val, int16_t raw_val)
{
/* see datasheet section 15.9 for details */
val->val1 = (((int64_t)raw_val * 100) / 12800) + 25;
val->val2 = ((((int64_t)raw_val * 100) % 12800) * 1000000) / 12800;
if (val->val2 < 0) {
val->val1--;
val->val2 += 1000000;
} else if (val->val2 >= 1000000) {
val->val1++;
val->val2 -= 1000000;
}
}
static int icm42670_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
int res = 0;
const struct icm42670_data *data = dev->data;
icm42670_lock(dev);
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
icm42670_convert_accel(&val[0], data->accel_x, data->accel_sensitivity_shift);
icm42670_convert_accel(&val[1], data->accel_y, data->accel_sensitivity_shift);
icm42670_convert_accel(&val[2], data->accel_z, data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_X:
icm42670_convert_accel(val, data->accel_x, data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Y:
icm42670_convert_accel(val, data->accel_y, data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_ACCEL_Z:
icm42670_convert_accel(val, data->accel_z, data->accel_sensitivity_shift);
break;
case SENSOR_CHAN_GYRO_XYZ:
icm42670_convert_gyro(&val[0], data->gyro_x, data->gyro_sensitivity_x10);
icm42670_convert_gyro(&val[1], data->gyro_y, data->gyro_sensitivity_x10);
icm42670_convert_gyro(&val[2], data->gyro_z, data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_X:
icm42670_convert_gyro(val, data->gyro_x, data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Y:
icm42670_convert_gyro(val, data->gyro_y, data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_GYRO_Z:
icm42670_convert_gyro(val, data->gyro_z, data->gyro_sensitivity_x10);
break;
case SENSOR_CHAN_DIE_TEMP:
icm42670_convert_temp(val, data->temp);
break;
default:
res = -ENOTSUP;
break;
}
icm42670_unlock(dev);
return res;
}
static int icm42670_sample_fetch_accel(const struct device *dev)
{
const struct icm42670_config *cfg = dev->config;
struct icm42670_data *data = dev->data;
uint8_t buffer[ACCEL_DATA_SIZE];
int res = cfg->bus_io->read(&cfg->bus, REG_ACCEL_DATA_X1, buffer, ACCEL_DATA_SIZE);
if (res) {
return res;
}
data->accel_x = (int16_t)sys_get_be16(&buffer[0]);
data->accel_y = (int16_t)sys_get_be16(&buffer[2]);
data->accel_z = (int16_t)sys_get_be16(&buffer[4]);
return 0;
}
static int icm42670_sample_fetch_gyro(const struct device *dev)
{
const struct icm42670_config *cfg = dev->config;
struct icm42670_data *data = dev->data;
uint8_t buffer[GYRO_DATA_SIZE];
int res = cfg->bus_io->read(&cfg->bus, REG_GYRO_DATA_X1, buffer, GYRO_DATA_SIZE);
if (res) {
return res;
}
data->gyro_x = (int16_t)sys_get_be16(&buffer[0]);
data->gyro_y = (int16_t)sys_get_be16(&buffer[2]);
data->gyro_z = (int16_t)sys_get_be16(&buffer[4]);
return 0;
}
static int icm42670_sample_fetch_temp(const struct device *dev)
{
const struct icm42670_config *cfg = dev->config;
struct icm42670_data *data = dev->data;
uint8_t buffer[TEMP_DATA_SIZE];
int res = cfg->bus_io->read(&cfg->bus, REG_TEMP_DATA1, buffer, TEMP_DATA_SIZE);
if (res) {
return res;
}
data->temp = (int16_t)sys_get_be16(&buffer[0]);
return 0;
}
static int icm42670_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
uint8_t status;
const struct icm42670_config *cfg = dev->config;
icm42670_lock(dev);
int res = cfg->bus_io->read(&cfg->bus, REG_INT_STATUS_DRDY, &status, 1);
if (res) {
goto cleanup;
}
if (!FIELD_GET(BIT_INT_STATUS_DATA_DRDY, status)) {
res = -EBUSY;
goto cleanup;
}
switch (chan) {
case SENSOR_CHAN_ALL:
res |= icm42670_sample_fetch_accel(dev);
res |= icm42670_sample_fetch_gyro(dev);
res |= icm42670_sample_fetch_temp(dev);
break;
case SENSOR_CHAN_ACCEL_XYZ:
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
res = icm42670_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_GYRO_XYZ:
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
res = icm42670_sample_fetch_gyro(dev);
break;
case SENSOR_CHAN_DIE_TEMP:
res = icm42670_sample_fetch_temp(dev);
break;
default:
res = -ENOTSUP;
break;
}
cleanup:
icm42670_unlock(dev);
return res;
}
static int icm42670_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
int res = 0;
struct icm42670_data *data = dev->data;
__ASSERT_NO_MSG(val != NULL);
icm42670_lock(dev);
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
res = icm42670_set_accel_odr(dev, data->accel_hz);
if (res) {
LOG_ERR("Incorrect sampling value");
} else {
data->accel_hz = val->val1;
}
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
res = icm42670_set_accel_fs(dev, data->accel_fs);
if (res) {
LOG_ERR("Incorrect fullscale value");
} else {
data->accel_fs = val->val1;
}
} else {
LOG_ERR("Unsupported attribute");
res = -ENOTSUP;
}
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
res = icm42670_set_gyro_odr(dev, data->gyro_hz);
if (res) {
LOG_ERR("Incorrect sampling value");
} else {
data->gyro_hz = val->val1;
}
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
res = icm42670_set_gyro_fs(dev, data->gyro_fs);
if (res) {
LOG_ERR("Incorrect fullscale value");
} else {
data->gyro_fs = val->val1;
}
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
default:
LOG_ERR("Unsupported channel");
res = -EINVAL;
break;
}
icm42670_unlock(dev);
return res;
}
static int icm42670_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct icm42670_data *data = dev->data;
int res = 0;
__ASSERT_NO_MSG(val != NULL);
icm42670_lock(dev);
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
val->val1 = data->accel_hz;
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
val->val1 = data->accel_fs;
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
val->val1 = data->gyro_hz;
} else if (attr == SENSOR_ATTR_FULL_SCALE) {
val->val1 = data->gyro_fs;
} else {
LOG_ERR("Unsupported attribute");
res = -EINVAL;
}
break;
default:
LOG_ERR("Unsupported channel");
res = -EINVAL;
break;
}
icm42670_unlock(dev);
return res;
}
static inline int icm42670_bus_check(const struct device *dev)
{
const struct icm42670_config *cfg = dev->config;
return cfg->bus_io->check(&cfg->bus);
}
static int icm42670_init(const struct device *dev)
{
struct icm42670_data *data = dev->data;
if (icm42670_bus_check(dev) < 0) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
}
data->accel_x = 0;
data->accel_y = 0;
data->accel_z = 0;
data->gyro_x = 0;
data->gyro_y = 0;
data->gyro_z = 0;
data->temp = 0;
if (icm42670_sensor_init(dev)) {
LOG_ERR("could not initialize sensor");
return -EIO;
}
#ifdef CONFIG_ICM42670_TRIGGER
if (icm42670_trigger_init(dev)) {
LOG_ERR("Failed to initialize interrupts.");
return -EIO;
}
#endif
int res = icm42670_turn_on_sensor(dev);
#ifdef CONFIG_ICM42670_TRIGGER
if (icm42670_trigger_enable_interrupt(dev)) {
LOG_ERR("Failed to enable interrupts");
return -EIO;
}
#endif
return res;
}
#ifndef CONFIG_ICM42670_TRIGGER
void icm42670_lock(const struct device *dev)
{
ARG_UNUSED(dev);
}
void icm42670_unlock(const struct device *dev)
{
ARG_UNUSED(dev);
}
#endif
static const struct sensor_driver_api icm42670_driver_api = {
#ifdef CONFIG_ICM42670_TRIGGER
.trigger_set = icm42670_trigger_set,
#endif
.sample_fetch = icm42670_sample_fetch,
.channel_get = icm42670_channel_get,
.attr_set = icm42670_attr_set,
.attr_get = icm42670_attr_get,
};
/* device defaults to spi mode 0/3 support */
#define ICM42670_SPI_CFG \
SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_WORD_SET(8) | SPI_TRANSFER_MSB
/* Initializes the bus members for an instance on a SPI bus. */
#define ICM42670_CONFIG_SPI(inst) \
.bus.spi = SPI_DT_SPEC_INST_GET(inst, ICM42670_SPI_CFG, 0), \
.bus_io = &icm42670_bus_io_spi,
/* Initializes the bus members for an instance on an I2C bus. */
#define ICM42670_CONFIG_I2C(inst) \
.bus.i2c = I2C_DT_SPEC_INST_GET(inst), \
.bus_io = &icm42670_bus_io_i2c,
#define ICM42670_INIT(inst) \
static struct icm42670_data icm42670_driver_##inst = { \
.accel_hz = DT_INST_PROP(inst, accel_hz), \
.accel_fs = DT_INST_PROP(inst, accel_fs), \
.gyro_hz = DT_INST_PROP(inst, gyro_hz), \
.gyro_fs = DT_INST_PROP(inst, gyro_fs), \
}; \
\
static const struct icm42670_config icm42670_cfg_##inst = { \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(ICM42670_CONFIG_SPI(inst)), \
(ICM42670_CONFIG_I2C(inst))) \
.gpio_int = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, {0}), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, icm42670_init, NULL, &icm42670_driver_##inst, \
&icm42670_cfg_##inst, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&icm42670_driver_api);
DT_INST_FOREACH_STATUS_OKAY(ICM42670_INIT)
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/icm42670.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,418 |
```unknown
# ICM42670 Six-Axis Motion Tracking device configuration options
#
#
menuconfig ICM42670
bool "ICM42670 Six-Axis Motion Tracking Device"
default y
depends on DT_HAS_INVENSENSE_ICM42670_ENABLED
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_INVENSENSE_ICM42670),spi)
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_INVENSENSE_ICM42670),i2c)
help
Enable driver for ICM42670 SPI-based six-axis motion tracking device.
if ICM42670
choice ICM42670_TRIGGER_MODE
prompt "Trigger mode"
default ICM42670_TRIGGER_NONE
help
Specify the type of triggering to be used by the driver.
config ICM42670_TRIGGER_NONE
bool "No trigger"
config ICM42670_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select ICM42670_TRIGGER
config ICM42670_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select ICM42670_TRIGGER
endchoice
config ICM42670_TRIGGER
bool
config ICM42670_THREAD_PRIORITY
int "Thread priority"
depends on ICM42670_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config ICM42670_THREAD_STACK_SIZE
int "Thread stack size"
depends on ICM42670_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # ICM42670
``` | /content/code_sandbox/drivers/sensor/tdk/icm42670/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 340 |
```unknown
# ICP10125 barometric pressure/temperature sensor configuration options
menuconfig ICP10125
bool "ICP10125 Barometric Pressure & Temperature Sensor"
default y
depends on DT_HAS_INVENSENSE_ICP10125_ENABLED
select I2C
help
Enable driver for ICP10125 barometric pressure/temperature sensor.
if ICP10125
config ICP10125_CHECK_CRC
bool "Check the CRC of measument data"
imply CRC
default y
help
Verify the CRC checksum that appended to the measurement data.
endif # ICP10125
``` | /content/code_sandbox/drivers/sensor/tdk/icp10125/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 126 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.