Zephyr Project API 4.2.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
sensor.h
Go to the documentation of this file.
1
7/*
8 * Copyright (c) 2016 Intel Corporation
9 *
10 * SPDX-License-Identifier: Apache-2.0
11 */
12#ifndef ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_
13#define ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_
14
28#include <errno.h>
29#include <stdlib.h>
30
31#include <zephyr/device.h>
33#include <zephyr/dsp/types.h>
34#include <zephyr/rtio/rtio.h>
36#include <zephyr/types.h>
37
38#ifdef __cplusplus
39extern "C" {
40#endif
41
61
115
124
133
136
139
144
147
150
159
162
165
208
211
216
222
227};
228
299
309
383
391typedef void (*sensor_trigger_handler_t)(const struct device *dev,
392 const struct sensor_trigger *trigger);
393
400typedef int (*sensor_attr_set_t)(const struct device *dev,
401 enum sensor_channel chan,
402 enum sensor_attribute attr,
403 const struct sensor_value *val);
404
411typedef int (*sensor_attr_get_t)(const struct device *dev,
412 enum sensor_channel chan,
413 enum sensor_attribute attr,
414 struct sensor_value *val);
415
422typedef int (*sensor_trigger_set_t)(const struct device *dev,
423 const struct sensor_trigger *trig,
431typedef int (*sensor_sample_fetch_t)(const struct device *dev,
432 enum sensor_channel chan);
439typedef int (*sensor_channel_get_t)(const struct device *dev,
440 enum sensor_channel chan,
441 struct sensor_value *val);
442
455
457/* Ensure sensor_chan_spec is sensibly sized to pass by value */
458BUILD_ASSERT(sizeof(struct sensor_chan_spec) <= sizeof(uintptr_t),
459 "sensor_chan_spec size should be equal or less than the size of a machine word");
470static inline bool sensor_chan_spec_eq(struct sensor_chan_spec chan_spec0,
471 struct sensor_chan_spec chan_spec1)
472{
473 return chan_spec0.chan_type == chan_spec1.chan_type &&
474 chan_spec0.chan_idx == chan_spec1.chan_idx;
475}
476
493 int (*get_frame_count)(const uint8_t *buffer, struct sensor_chan_spec channel,
494 uint16_t *frame_count);
495
508 int (*get_size_info)(struct sensor_chan_spec channel, size_t *base_size,
509 size_t *frame_size);
510
536 int (*decode)(const uint8_t *buffer, struct sensor_chan_spec channel, uint32_t *fit,
537 uint16_t max_count, void *data_out);
538
546 bool (*has_trigger)(const uint8_t *buffer, enum sensor_trigger_type trigger);
547};
548
579
583#define SENSOR_DECODE_CONTEXT_INIT(decoder_, buffer_, channel_type_, channel_index_) \
584 { \
585 .decoder = (decoder_), \
586 .buffer = (buffer_), \
587 .channel = {.chan_type = (channel_type_), .chan_idx = (channel_index_)}, \
588 .fit = 0, \
589 }
590
599static inline int sensor_decode(struct sensor_decode_context *ctx, void *out, uint16_t max_count)
600{
601 return ctx->decoder->decode(ctx->buffer, ctx->channel, &ctx->fit, max_count, out);
602}
603
605 size_t *frame_size);
606
613typedef int (*sensor_get_decoder_t)(const struct device *dev,
614 const struct sensor_decoder_api **api);
615
627
632
633#define SENSOR_STREAM_TRIGGER_PREP(_trigger, _opt) \
634 { \
635 .trigger = (_trigger), .opt = (_opt), \
636 }
637
638/*
639 * Internal data structure used to store information about the IODevice for async reading and
640 * streaming sensor data.
641 */
643 const struct device *sensor;
644 const bool is_streaming;
645 union {
648 };
649 size_t count;
650 const size_t max;
651};
652
668#define SENSOR_DT_READ_IODEV(name, dt_node, ...) \
669 static struct sensor_chan_spec _CONCAT(__channel_array_, name)[] = {__VA_ARGS__}; \
670 static struct sensor_read_config _CONCAT(__sensor_read_config_, name) = { \
671 .sensor = DEVICE_DT_GET(dt_node), \
672 .is_streaming = false, \
673 .channels = _CONCAT(__channel_array_, name), \
674 .count = ARRAY_SIZE(_CONCAT(__channel_array_, name)), \
675 .max = ARRAY_SIZE(_CONCAT(__channel_array_, name)), \
676 }; \
677 RTIO_IODEV_DEFINE(name, &__sensor_iodev_api, _CONCAT(&__sensor_read_config_, name))
678
698#define SENSOR_DT_STREAM_IODEV(name, dt_node, ...) \
699 static struct sensor_stream_trigger _CONCAT(__trigger_array_, name)[] = {__VA_ARGS__}; \
700 static struct sensor_read_config _CONCAT(__sensor_read_config_, name) = { \
701 .sensor = DEVICE_DT_GET(dt_node), \
702 .is_streaming = true, \
703 .triggers = _CONCAT(__trigger_array_, name), \
704 .count = ARRAY_SIZE(_CONCAT(__trigger_array_, name)), \
705 .max = ARRAY_SIZE(_CONCAT(__trigger_array_, name)), \
706 }; \
707 RTIO_IODEV_DEFINE(name, &__sensor_iodev_api, &_CONCAT(__sensor_read_config_, name))
708
709/* Used to submit an RTIO sqe to the sensor's iodev */
710typedef void (*sensor_submit_t)(const struct device *sensor, struct rtio_iodev_sqe *sqe);
711
712/* The default decoder API */
713extern const struct sensor_decoder_api __sensor_default_decoder;
714
715/* The default sensor iodev API */
716extern const struct rtio_iodev_api __sensor_iodev_api;
717
727
740__syscall int sensor_attr_set(const struct device *dev,
741 enum sensor_channel chan,
742 enum sensor_attribute attr,
743 const struct sensor_value *val);
744
745static inline int z_impl_sensor_attr_set(const struct device *dev,
746 enum sensor_channel chan,
747 enum sensor_attribute attr,
748 const struct sensor_value *val)
749{
750 const struct sensor_driver_api *api =
751 (const struct sensor_driver_api *)dev->api;
752
753 if (api->attr_set == NULL) {
754 return -ENOSYS;
755 }
756
757 return api->attr_set(dev, chan, attr, val);
758}
759
772__syscall int sensor_attr_get(const struct device *dev,
773 enum sensor_channel chan,
774 enum sensor_attribute attr,
775 struct sensor_value *val);
776
777static inline int z_impl_sensor_attr_get(const struct device *dev,
778 enum sensor_channel chan,
779 enum sensor_attribute attr,
780 struct sensor_value *val)
781{
782 const struct sensor_driver_api *api =
783 (const struct sensor_driver_api *)dev->api;
784
785 if (api->attr_get == NULL) {
786 return -ENOSYS;
787 }
788
789 return api->attr_get(dev, chan, attr, val);
790}
791
814static inline int sensor_trigger_set(const struct device *dev,
815 const struct sensor_trigger *trig,
817{
818 const struct sensor_driver_api *api =
819 (const struct sensor_driver_api *)dev->api;
820
821 if (api->trigger_set == NULL) {
822 return -ENOSYS;
823 }
824
825 return api->trigger_set(dev, trig, handler);
826}
827
846__syscall int sensor_sample_fetch(const struct device *dev);
847
848static inline int z_impl_sensor_sample_fetch(const struct device *dev)
849{
850 const struct sensor_driver_api *api =
851 (const struct sensor_driver_api *)dev->api;
852
853 return api->sample_fetch(dev, SENSOR_CHAN_ALL);
854}
855
877__syscall int sensor_sample_fetch_chan(const struct device *dev,
878 enum sensor_channel type);
879
880static inline int z_impl_sensor_sample_fetch_chan(const struct device *dev,
881 enum sensor_channel type)
882{
883 const struct sensor_driver_api *api =
884 (const struct sensor_driver_api *)dev->api;
885
886 return api->sample_fetch(dev, type);
887}
888
910__syscall int sensor_channel_get(const struct device *dev,
911 enum sensor_channel chan,
912 struct sensor_value *val);
913
914static inline int z_impl_sensor_channel_get(const struct device *dev,
915 enum sensor_channel chan,
916 struct sensor_value *val)
917{
918 const struct sensor_driver_api *api =
919 (const struct sensor_driver_api *)dev->api;
920
921 return api->channel_get(dev, chan, val);
922}
923
924#if defined(CONFIG_SENSOR_ASYNC_API) || defined(__DOXYGEN__)
925
926/*
927 * Generic data structure used for encoding the sample timestamp and number of channels sampled.
928 */
929struct __attribute__((__packed__)) sensor_data_generic_header {
930 /* The timestamp at which the data was collected from the sensor */
932
933 /*
934 * The number of channels present in the frame. This will be the true number of elements in
935 * channel_info and in the q31 values that follow the header.
936 */
938
939 /* Shift value for all samples in the frame */
941
942 /* This padding is needed to make sure that the 'channels' field is aligned */
943 int8_t _padding[sizeof(struct sensor_chan_spec) - 1];
944
945 /* Channels present in the frame */
946 struct sensor_chan_spec channels[0];
947};
948
957#define SENSOR_CHANNEL_3_AXIS(chan) \
958 ((chan) == SENSOR_CHAN_ACCEL_XYZ || (chan) == SENSOR_CHAN_GYRO_XYZ || \
959 (chan) == SENSOR_CHAN_MAGN_XYZ || (chan) == SENSOR_CHAN_POS_DXYZ)
960
969#define SENSOR_CHANNEL_IS_ACCEL(chan) \
970 ((chan) == SENSOR_CHAN_ACCEL_XYZ || (chan) == SENSOR_CHAN_ACCEL_X || \
971 (chan) == SENSOR_CHAN_ACCEL_Y || (chan) == SENSOR_CHAN_ACCEL_Z)
972
981#define SENSOR_CHANNEL_IS_GYRO(chan) \
982 ((chan) == SENSOR_CHAN_GYRO_XYZ || (chan) == SENSOR_CHAN_GYRO_X || \
983 (chan) == SENSOR_CHAN_GYRO_Y || (chan) == SENSOR_CHAN_GYRO_Z)
984
993__syscall int sensor_get_decoder(const struct device *dev,
994 const struct sensor_decoder_api **decoder);
995
996static inline int z_impl_sensor_get_decoder(const struct device *dev,
997 const struct sensor_decoder_api **decoder)
998{
999 const struct sensor_driver_api *api = (const struct sensor_driver_api *)dev->api;
1000
1001 __ASSERT_NO_MSG(api != NULL);
1002
1003 if (api->get_decoder == NULL) {
1004 *decoder = &__sensor_default_decoder;
1005 return 0;
1006 }
1007
1008 return api->get_decoder(dev, decoder);
1009}
1010
1029__syscall int sensor_reconfigure_read_iodev(struct rtio_iodev *iodev, const struct device *sensor,
1030 const struct sensor_chan_spec *channels,
1031 size_t num_channels);
1032
1033static inline int z_impl_sensor_reconfigure_read_iodev(struct rtio_iodev *iodev,
1034 const struct device *sensor,
1035 const struct sensor_chan_spec *channels,
1036 size_t num_channels)
1037{
1038 struct sensor_read_config *cfg = (struct sensor_read_config *)iodev->data;
1039
1040 if (cfg->max < num_channels || cfg->is_streaming) {
1041 return -ENOMEM;
1042 }
1043
1044 cfg->sensor = sensor;
1045 memcpy(cfg->channels, channels, num_channels * sizeof(struct sensor_chan_spec));
1046 cfg->count = num_channels;
1047 return 0;
1048}
1049
1050static inline int sensor_stream(struct rtio_iodev *iodev, struct rtio *ctx, void *userdata,
1051 struct rtio_sqe **handle)
1052{
1053 if (IS_ENABLED(CONFIG_USERSPACE)) {
1054 struct rtio_sqe sqe;
1055
1057 rtio_sqe_copy_in_get_handles(ctx, &sqe, handle, 1);
1058 } else {
1059 struct rtio_sqe *sqe = rtio_sqe_acquire(ctx);
1060
1061 if (sqe == NULL) {
1062 return -ENOMEM;
1063 }
1064 if (handle != NULL) {
1065 *handle = sqe;
1066 }
1068 }
1069 rtio_submit(ctx, 0);
1070 return 0;
1071}
1072
1087static inline int sensor_read(struct rtio_iodev *iodev, struct rtio *ctx, uint8_t *buf,
1088 size_t buf_len)
1089{
1090 if (IS_ENABLED(CONFIG_USERSPACE)) {
1091 struct rtio_sqe sqe;
1092
1094 rtio_sqe_copy_in(ctx, &sqe, 1);
1095 } else {
1096 struct rtio_sqe *sqe = rtio_sqe_acquire(ctx);
1097
1098 if (sqe == NULL) {
1099 return -ENOMEM;
1100 }
1102 }
1103 rtio_submit(ctx, 0);
1104
1105 struct rtio_cqe *cqe = rtio_cqe_consume_block(ctx);
1106 int res = cqe->result;
1107
1108 __ASSERT(cqe->userdata == buf,
1109 "consumed non-matching completion for sensor read into buffer %p\n", buf);
1110
1111 rtio_cqe_release(ctx, cqe);
1112
1113 return res;
1114}
1115
1129static inline int sensor_read_async_mempool(struct rtio_iodev *iodev, struct rtio *ctx,
1130 void *userdata)
1131{
1132 if (IS_ENABLED(CONFIG_USERSPACE)) {
1133 struct rtio_sqe sqe;
1134
1136 rtio_sqe_copy_in(ctx, &sqe, 1);
1137 } else {
1138 struct rtio_sqe *sqe = rtio_sqe_acquire(ctx);
1139
1140 if (sqe == NULL) {
1141 return -ENOMEM;
1142 }
1144 }
1145 rtio_submit(ctx, 0);
1146 return 0;
1147}
1148
1161 void *userdata);
1162
1175
1176#endif /* defined(CONFIG_SENSOR_ASYNC_API) || defined(__DOXYGEN__) */
1177
1181#define SENSOR_G 9806650LL
1182
1186#define SENSOR_PI 3141592LL
1187
1196static inline int32_t sensor_ms2_to_g(const struct sensor_value *ms2)
1197{
1198 int64_t micro_ms2 = ms2->val1 * 1000000LL + ms2->val2;
1199
1200 if (micro_ms2 > 0) {
1201 return (micro_ms2 + SENSOR_G / 2) / SENSOR_G;
1202 } else {
1203 return (micro_ms2 - SENSOR_G / 2) / SENSOR_G;
1204 }
1205}
1206
1213static inline void sensor_g_to_ms2(int32_t g, struct sensor_value *ms2)
1214{
1215 ms2->val1 = ((int64_t)g * SENSOR_G) / 1000000LL;
1216 ms2->val2 = ((int64_t)g * SENSOR_G) % 1000000LL;
1217}
1218
1227static inline int32_t sensor_ms2_to_mg(const struct sensor_value *ms2)
1228{
1229 int64_t nano_ms2 = (ms2->val1 * 1000000LL + ms2->val2) * 1000LL;
1230
1231 if (nano_ms2 > 0) {
1232 return (nano_ms2 + SENSOR_G / 2) / SENSOR_G;
1233 } else {
1234 return (nano_ms2 - SENSOR_G / 2) / SENSOR_G;
1235 }
1236}
1237
1246static inline int32_t sensor_ms2_to_ug(const struct sensor_value *ms2)
1247{
1248 int64_t micro_ms2 = (ms2->val1 * INT64_C(1000000)) + ms2->val2;
1249
1250 return (micro_ms2 * 1000000LL) / SENSOR_G;
1251}
1252
1259static inline void sensor_ug_to_ms2(int32_t ug, struct sensor_value *ms2)
1260{
1261 ms2->val1 = ((int64_t)ug * SENSOR_G / 1000000LL) / 1000000LL;
1262 ms2->val2 = ((int64_t)ug * SENSOR_G / 1000000LL) % 1000000LL;
1263}
1264
1272static inline int32_t sensor_rad_to_degrees(const struct sensor_value *rad)
1273{
1274 int64_t micro_rad_s = rad->val1 * 1000000LL + rad->val2;
1275
1276 if (micro_rad_s > 0) {
1277 return (micro_rad_s * 180LL + SENSOR_PI / 2) / SENSOR_PI;
1278 } else {
1279 return (micro_rad_s * 180LL - SENSOR_PI / 2) / SENSOR_PI;
1280 }
1281}
1282
1289static inline void sensor_degrees_to_rad(int32_t d, struct sensor_value *rad)
1290{
1291 rad->val1 = ((int64_t)d * SENSOR_PI / 180LL) / 1000000LL;
1292 rad->val2 = ((int64_t)d * SENSOR_PI / 180LL) % 1000000LL;
1293}
1294
1306static inline int32_t sensor_rad_to_10udegrees(const struct sensor_value *rad)
1307{
1308 int64_t micro_rad_s = rad->val1 * 1000000LL + rad->val2;
1309
1310 return (micro_rad_s * 180LL * 100000LL) / SENSOR_PI;
1311}
1312
1319static inline void sensor_10udegrees_to_rad(int32_t d, struct sensor_value *rad)
1320{
1321 rad->val1 = ((int64_t)d * SENSOR_PI / 180LL / 100000LL) / 1000000LL;
1322 rad->val2 = ((int64_t)d * SENSOR_PI / 180LL / 100000LL) % 1000000LL;
1323}
1324
1331static inline double sensor_value_to_double(const struct sensor_value *val)
1332{
1333 return (double)val->val1 + (double)val->val2 / 1000000;
1334}
1335
1342static inline float sensor_value_to_float(const struct sensor_value *val)
1343{
1344 return (float)val->val1 + (float)val->val2 / 1000000;
1345}
1346
1354static inline int sensor_value_from_double(struct sensor_value *val, double inp)
1355{
1356 if (inp < (double)INT32_MIN || inp > (double)INT32_MAX) {
1357 return -ERANGE;
1358 }
1359
1360 int32_t val1 = (int32_t)inp;
1361 int32_t val2 = (int32_t)((inp - (double)val1) * 1000000.0);
1362
1363 val->val1 = val1;
1364 val->val2 = val2;
1365
1366 return 0;
1367}
1368
1376static inline int sensor_value_from_float(struct sensor_value *val, float inp)
1377{
1378 if (inp < (float)INT32_MIN || inp >= (float)INT32_MAX) {
1379 return -ERANGE;
1380 }
1381
1382 int32_t val1 = (int32_t)inp;
1383 int32_t val2 = (int32_t)((inp - (float)val1) * 1000000.0f);
1384
1385 val->val1 = val1;
1386 val->val2 = val2;
1387
1388 return 0;
1389}
1390
1391#ifdef CONFIG_SENSOR_INFO
1392
1393struct sensor_info {
1394 const struct device *dev;
1395 const char *vendor;
1396 const char *model;
1397 const char *friendly_name;
1398};
1399
1400#define SENSOR_INFO_INITIALIZER(_dev, _vendor, _model, _friendly_name) \
1401 { \
1402 .dev = _dev, \
1403 .vendor = _vendor, \
1404 .model = _model, \
1405 .friendly_name = _friendly_name, \
1406 }
1407
1408#define SENSOR_INFO_DEFINE(name, ...) \
1409 static const STRUCT_SECTION_ITERABLE(sensor_info, name) = \
1410 SENSOR_INFO_INITIALIZER(__VA_ARGS__)
1411
1412#define SENSOR_INFO_DT_NAME(node_id) \
1413 _CONCAT(__sensor_info, DEVICE_DT_NAME_GET(node_id))
1414
1415#define SENSOR_INFO_DT_DEFINE(node_id) \
1416 SENSOR_INFO_DEFINE(SENSOR_INFO_DT_NAME(node_id), \
1417 DEVICE_DT_GET(node_id), \
1418 DT_NODE_VENDOR_OR(node_id, NULL), \
1419 DT_NODE_MODEL_OR(node_id, NULL), \
1420 DT_PROP_OR(node_id, friendly_name, NULL)) \
1421
1422#else
1423
1424#define SENSOR_INFO_DEFINE(name, ...)
1425#define SENSOR_INFO_DT_DEFINE(node_id)
1426
1427#endif /* CONFIG_SENSOR_INFO */
1428
1456#define SENSOR_DEVICE_DT_DEFINE(node_id, init_fn, pm_device, \
1457 data_ptr, cfg_ptr, level, prio, \
1458 api_ptr, ...) \
1459 DEVICE_DT_DEFINE(node_id, init_fn, pm_device, \
1460 data_ptr, cfg_ptr, level, prio, \
1461 api_ptr, __VA_ARGS__); \
1462 \
1463 SENSOR_INFO_DT_DEFINE(node_id);
1464
1474#define SENSOR_DEVICE_DT_INST_DEFINE(inst, ...) \
1475 SENSOR_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
1476
1483static inline int64_t sensor_value_to_deci(const struct sensor_value *val)
1484{
1485 return ((int64_t)val->val1 * 10) + val->val2 / 100000;
1486}
1487
1494static inline int64_t sensor_value_to_centi(const struct sensor_value *val)
1495{
1496 return ((int64_t)val->val1 * 100) + val->val2 / 10000;
1497}
1498
1505static inline int64_t sensor_value_to_milli(const struct sensor_value *val)
1506{
1507 return ((int64_t)val->val1 * 1000) + val->val2 / 1000;
1508}
1509
1516static inline int64_t sensor_value_to_micro(const struct sensor_value *val)
1517{
1518 return ((int64_t)val->val1 * 1000000) + val->val2;
1519}
1520
1528static inline int sensor_value_from_milli(struct sensor_value *val, int64_t milli)
1529{
1530 if (milli < ((int64_t)INT32_MIN - 1) * 1000LL ||
1531 milli > ((int64_t)INT32_MAX + 1) * 1000LL) {
1532 return -ERANGE;
1533 }
1534
1535 val->val1 = (int32_t)(milli / 1000);
1536 val->val2 = (int32_t)(milli % 1000) * 1000;
1537
1538 return 0;
1539}
1540
1548static inline int sensor_value_from_micro(struct sensor_value *val, int64_t micro)
1549{
1550 if (micro < ((int64_t)INT32_MIN - 1) * 1000000LL ||
1551 micro > ((int64_t)INT32_MAX + 1) * 1000000LL) {
1552 return -ERANGE;
1553 }
1554
1555 val->val1 = (int32_t)(micro / 1000000LL);
1556 val->val2 = (int32_t)(micro % 1000000LL);
1557
1558 return 0;
1559}
1560
1570#define SENSOR_DECODER_NAME() UTIL_CAT(DT_DRV_COMPAT, __decoder_api)
1571
1579#define SENSOR_DECODER_DT_GET(node_id) \
1580 &UTIL_CAT(DT_STRING_TOKEN_BY_IDX(node_id, compatible, 0), __decoder_api)
1581
1597#define SENSOR_DECODER_API_DT_DEFINE() \
1598 COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT), (), (static)) \
1599 const STRUCT_SECTION_ITERABLE(sensor_decoder_api, SENSOR_DECODER_NAME())
1600
1601#define Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL_IDX(node_id, prop, idx) \
1602 extern const struct sensor_decoder_api UTIL_CAT( \
1603 DT_STRING_TOKEN_BY_IDX(node_id, prop, idx), __decoder_api);
1604
1605#define Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL(node_id) \
1606 COND_CODE_1(DT_NODE_HAS_PROP(node_id, compatible), \
1607 (DT_FOREACH_PROP_ELEM(node_id, compatible, \
1608 Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL_IDX)), \
1609 ())
1610
1611DT_FOREACH_STATUS_OKAY_NODE(Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL)
1612
1613#ifdef __cplusplus
1614}
1615#endif
1616
1617#include <zephyr/syscalls/sensor.h>
1618
1619#endif /* ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_ */
irp nz macro MOVR cc d
Definition asm-macro-32-bit-gnu.h:11
System error numbers.
#define DT_FOREACH_STATUS_OKAY_NODE(fn)
Invokes fn for every status okay node in the tree.
Definition devicetree.h:3000
#define RTIO_PRIO_NORM
Normal priority.
Definition rtio.h:71
static void rtio_sqe_prep_read_with_pool(struct rtio_sqe *sqe, const struct rtio_iodev *iodev, int8_t prio, void *userdata)
Prepare a read op submission with context's mempool.
Definition rtio.h:623
static int rtio_sqe_copy_in(struct rtio *r, const struct rtio_sqe *sqes, size_t sqe_count)
Copy an array of SQEs into the queue.
Definition rtio.h:1586
int rtio_sqe_copy_in_get_handles(struct rtio *r, const struct rtio_sqe *sqes, struct rtio_sqe **handle, size_t sqe_count)
Copy an array of SQEs into the queue and get resulting handles back.
static void rtio_sqe_prep_read(struct rtio_sqe *sqe, const struct rtio_iodev *iodev, int8_t prio, uint8_t *buf, uint32_t len, void *userdata)
Prepare a read op submission.
Definition rtio.h:602
static struct rtio_sqe * rtio_sqe_acquire(struct rtio *r)
Acquire a single submission queue event if available.
Definition rtio.h:1054
static void rtio_sqe_prep_read_multishot(struct rtio_sqe *sqe, const struct rtio_iodev *iodev, int8_t prio, void *userdata)
Definition rtio.h:631
static void rtio_cqe_release(struct rtio *r, struct rtio_cqe *cqe)
Release consumed completion queue event.
Definition rtio.h:1173
static struct rtio_cqe * rtio_cqe_consume_block(struct rtio *r)
Wait for and consume a single completion queue event.
Definition rtio.h:1149
int rtio_submit(struct rtio *r, uint32_t wait_count)
Submit I/O requests to the underlying executor.
#define SENSOR_G
The value of gravitational constant in micro m/s^2.
Definition sensor.h:1181
static int sensor_decode(struct sensor_decode_context *ctx, void *out, uint16_t max_count)
Decode N frames using a sensor_decode_context.
Definition sensor.h:599
static int32_t sensor_rad_to_degrees(const struct sensor_value *rad)
Helper function for converting radians to degrees.
Definition sensor.h:1272
sensor_trigger_type
Sensor trigger types.
Definition sensor.h:232
sensor_attribute
Sensor attribute types.
Definition sensor.h:313
int(* sensor_attr_set_t)(const struct device *dev, enum sensor_channel chan, enum sensor_attribute attr, const struct sensor_value *val)
Callback API upon setting a sensor's attributes.
Definition sensor.h:400
int sensor_get_decoder(const struct device *dev, const struct sensor_decoder_api **decoder)
Get the sensor's decoder API.
static int sensor_read(struct rtio_iodev *iodev, struct rtio *ctx, uint8_t *buf, size_t buf_len)
Blocking one shot read of samples from a sensor into a buffer.
Definition sensor.h:1087
int(* sensor_sample_fetch_t)(const struct device *dev, enum sensor_channel chan)
Callback API for fetching data from a sensor.
Definition sensor.h:431
static void sensor_ug_to_ms2(int32_t ug, struct sensor_value *ms2)
Helper function to convert acceleration from micro Gs to m/s^2.
Definition sensor.h:1259
static double sensor_value_to_double(const struct sensor_value *val)
Helper function for converting struct sensor_value to double.
Definition sensor.h:1331
static float sensor_value_to_float(const struct sensor_value *val)
Helper function for converting struct sensor_value to float.
Definition sensor.h:1342
int sensor_natively_supported_channel_size_info(struct sensor_chan_spec channel, size_t *base_size, size_t *frame_size)
static void sensor_degrees_to_rad(int32_t d, struct sensor_value *rad)
Helper function for converting degrees to radians.
Definition sensor.h:1289
static int32_t sensor_ms2_to_ug(const struct sensor_value *ms2)
Helper function to convert acceleration from m/s^2 to micro Gs.
Definition sensor.h:1246
int(* sensor_attr_get_t)(const struct device *dev, enum sensor_channel chan, enum sensor_attribute attr, struct sensor_value *val)
Callback API upon getting a sensor's attributes.
Definition sensor.h:411
static int sensor_value_from_float(struct sensor_value *val, float inp)
Helper function for converting float to struct sensor_value.
Definition sensor.h:1376
void(* sensor_trigger_handler_t)(const struct device *dev, const struct sensor_trigger *trigger)
Callback API upon firing of a trigger.
Definition sensor.h:391
static void sensor_g_to_ms2(int32_t g, struct sensor_value *ms2)
Helper function to convert acceleration from Gs to m/s^2.
Definition sensor.h:1213
static int64_t sensor_value_to_milli(const struct sensor_value *val)
Helper function for converting struct sensor_value to integer milli units.
Definition sensor.h:1505
#define SENSOR_PI
The value of constant PI in micros.
Definition sensor.h:1186
static int sensor_trigger_set(const struct device *dev, const struct sensor_trigger *trig, sensor_trigger_handler_t handler)
Activate a sensor's trigger and set the trigger handler.
Definition sensor.h:814
sensor_stream_data_opt
Options for what to do with the associated data when a trigger is consumed.
Definition sensor.h:619
static int sensor_value_from_milli(struct sensor_value *val, int64_t milli)
Helper function for converting integer milli units to struct sensor_value.
Definition sensor.h:1528
void(* sensor_processing_callback_t)(int result, uint8_t *buf, uint32_t buf_len, void *userdata)
Callback function used with the helper processing function.
Definition sensor.h:1160
static int64_t sensor_value_to_micro(const struct sensor_value *val)
Helper function for converting struct sensor_value to integer micro units.
Definition sensor.h:1516
int sensor_channel_get(const struct device *dev, enum sensor_channel chan, struct sensor_value *val)
Get a reading from a sensor device.
static int32_t sensor_ms2_to_mg(const struct sensor_value *ms2)
Helper function to convert acceleration from m/s^2 to milli Gs.
Definition sensor.h:1227
int sensor_sample_fetch(const struct device *dev)
Fetch a sample from the sensor and store it in an internal driver buffer.
sensor_channel
Sensor channels.
Definition sensor.h:65
int(* sensor_get_decoder_t)(const struct device *dev, const struct sensor_decoder_api **api)
Get the decoder associate with the given device.
Definition sensor.h:613
static void sensor_10udegrees_to_rad(int32_t d, struct sensor_value *rad)
Helper function for converting 10 micro degrees to radians.
Definition sensor.h:1319
int(* sensor_channel_get_t)(const struct device *dev, enum sensor_channel chan, struct sensor_value *val)
Callback API for getting a reading from a sensor.
Definition sensor.h:439
static int32_t sensor_ms2_to_g(const struct sensor_value *ms2)
Helper function to convert acceleration from m/s^2 to Gs.
Definition sensor.h:1196
int sensor_reconfigure_read_iodev(struct rtio_iodev *iodev, const struct device *sensor, const struct sensor_chan_spec *channels, size_t num_channels)
Reconfigure a reading iodev.
static int sensor_read_async_mempool(struct rtio_iodev *iodev, struct rtio *ctx, void *userdata)
One shot non-blocking read with pool allocated buffer.
Definition sensor.h:1129
void sensor_processing_with_callback(struct rtio *ctx, sensor_processing_callback_t cb)
Helper function for common processing of sensor data.
static int64_t sensor_value_to_deci(const struct sensor_value *val)
Helper function for converting struct sensor_value to integer deci units.
Definition sensor.h:1483
int(* sensor_trigger_set_t)(const struct device *dev, const struct sensor_trigger *trig, sensor_trigger_handler_t handler)
Callback API for setting a sensor's trigger and handler.
Definition sensor.h:422
static int sensor_value_from_micro(struct sensor_value *val, int64_t micro)
Helper function for converting integer micro units to struct sensor_value.
Definition sensor.h:1548
int sensor_sample_fetch_chan(const struct device *dev, enum sensor_channel type)
Fetch a sample from the sensor and store it in an internal driver buffer.
static int sensor_stream(struct rtio_iodev *iodev, struct rtio *ctx, void *userdata, struct rtio_sqe **handle)
Definition sensor.h:1050
void(* sensor_submit_t)(const struct device *sensor, struct rtio_iodev_sqe *sqe)
Definition sensor.h:710
static int32_t sensor_rad_to_10udegrees(const struct sensor_value *rad)
Helper function for converting radians to 10 micro degrees.
Definition sensor.h:1306
static int64_t sensor_value_to_centi(const struct sensor_value *val)
Helper function for converting struct sensor_value to integer centi units.
Definition sensor.h:1494
static bool sensor_chan_spec_eq(struct sensor_chan_spec chan_spec0, struct sensor_chan_spec chan_spec1)
Check if channel specs are equivalent.
Definition sensor.h:470
int sensor_attr_get(const struct device *dev, enum sensor_channel chan, enum sensor_attribute attr, struct sensor_value *val)
Get an attribute for a sensor.
static int sensor_value_from_double(struct sensor_value *val, double inp)
Helper function for converting double to struct sensor_value.
Definition sensor.h:1354
int sensor_attr_set(const struct device *dev, enum sensor_channel chan, enum sensor_attribute attr, const struct sensor_value *val)
Set an attribute for a sensor.
@ SENSOR_TRIG_DELTA
Trigger fires when the selected channel varies significantly.
Definition sensor.h:248
@ SENSOR_TRIG_NEAR_FAR
Trigger fires when a near/far event is detected.
Definition sensor.h:250
@ SENSOR_TRIG_FREEFALL
Trigger fires when a free fall is detected.
Definition sensor.h:266
@ SENSOR_TRIG_PRIV_START
This and higher values are sensor specific.
Definition sensor.h:292
@ SENSOR_TRIG_FIFO_FULL
Trigger fires when the FIFO becomes full.
Definition sensor.h:278
@ SENSOR_TRIG_MOTION
Trigger fires when motion is detected.
Definition sensor.h:269
@ SENSOR_TRIG_STATIONARY
Trigger fires when no motion has been detected for a while.
Definition sensor.h:272
@ SENSOR_TRIG_COMMON_COUNT
Number of all common sensor triggers.
Definition sensor.h:286
@ SENSOR_TRIG_THRESHOLD
Trigger fires when channel reading transitions configured thresholds.
Definition sensor.h:257
@ SENSOR_TRIG_MAX
Maximum value describing a sensor trigger type.
Definition sensor.h:297
@ SENSOR_TRIG_DOUBLE_TAP
Trigger fires when a double tap is detected.
Definition sensor.h:263
@ SENSOR_TRIG_TILT
Trigger fires when a tilt is detected.
Definition sensor.h:281
@ SENSOR_TRIG_TIMER
Timer-based trigger, useful when the sensor does not have an interrupt line.
Definition sensor.h:237
@ SENSOR_TRIG_FIFO_WATERMARK
Trigger fires when the FIFO watermark has been reached.
Definition sensor.h:275
@ SENSOR_TRIG_TAP
Trigger fires when a single tap is detected.
Definition sensor.h:260
@ SENSOR_TRIG_DATA_READY
Trigger fires whenever new data is ready.
Definition sensor.h:239
@ SENSOR_ATTR_HYSTERESIS
Definition sensor.h:331
@ SENSOR_ATTR_FEATURE_MASK
Enable/disable sensor features.
Definition sensor.h:351
@ SENSOR_ATTR_CALIB_TARGET
Calibration target.
Definition sensor.h:345
@ SENSOR_ATTR_OFFSET
The sensor value returned will be altered by the amount indicated by offset: final_value = sensor_val...
Definition sensor.h:340
@ SENSOR_ATTR_BATCH_DURATION
Hardware batch duration in ticks.
Definition sensor.h:362
@ SENSOR_ATTR_OVERSAMPLING
Oversampling factor.
Definition sensor.h:333
@ SENSOR_ATTR_FF_DUR
Free-fall duration represented in milliseconds.
Definition sensor.h:359
@ SENSOR_ATTR_UPPER_THRESH
Upper threshold for trigger.
Definition sensor.h:322
@ SENSOR_ATTR_CONFIGURATION
Configure the operating modes of a sensor.
Definition sensor.h:347
@ SENSOR_ATTR_RESOLUTION
Definition sensor.h:366
@ SENSOR_ATTR_CALIBRATION
Set a calibration value needed by a sensor.
Definition sensor.h:349
@ SENSOR_ATTR_COMMON_COUNT
Number of all common sensor attributes.
Definition sensor.h:370
@ SENSOR_ATTR_ALERT
Alert threshold or alert enable/disable.
Definition sensor.h:353
@ SENSOR_ATTR_SLOPE_TH
Threshold for any-motion (slope) trigger.
Definition sensor.h:324
@ SENSOR_ATTR_GAIN
Definition sensor.h:364
@ SENSOR_ATTR_SAMPLING_FREQUENCY
Sensor sampling frequency, i.e.
Definition sensor.h:318
@ SENSOR_ATTR_FULL_SCALE
Sensor range, in SI units.
Definition sensor.h:335
@ SENSOR_ATTR_LOWER_THRESH
Lower threshold for trigger.
Definition sensor.h:320
@ SENSOR_ATTR_SLOPE_DUR
Duration for which the slope values needs to be outside the threshold for the trigger to fire.
Definition sensor.h:329
@ SENSOR_ATTR_MAX
Maximum value describing a sensor attribute type.
Definition sensor.h:381
@ SENSOR_ATTR_PRIV_START
This and higher values are sensor specific.
Definition sensor.h:376
@ SENSOR_STREAM_DATA_INCLUDE
Include whatever data is associated with the trigger.
Definition sensor.h:621
@ SENSOR_STREAM_DATA_NOP
Do nothing with the associated trigger data, it may be consumed later.
Definition sensor.h:623
@ SENSOR_STREAM_DATA_DROP
Flush/clear whatever data is associated with the trigger.
Definition sensor.h:625
@ SENSOR_CHAN_GAUGE_STATE_OF_HEALTH
State of health measurement in %.
Definition sensor.h:189
@ SENSOR_CHAN_PM_1_0
1.0 micro-meters Particulate Matter, in ug/m^3
Definition sensor.h:117
@ SENSOR_CHAN_DIE_TEMP
Device die temperature in degrees Celsius.
Definition sensor.h:91
@ SENSOR_CHAN_PRESS
Pressure in kilopascal.
Definition sensor.h:95
@ SENSOR_CHAN_GAUGE_TIME_TO_FULL
Time to full in minutes.
Definition sensor.h:193
@ SENSOR_CHAN_ACCEL_XYZ
Acceleration on the X, Y and Z axes.
Definition sensor.h:73
@ SENSOR_CHAN_MAGN_X
Magnetic field on the X axis, in Gauss.
Definition sensor.h:83
@ SENSOR_CHAN_O2
O2 level, in parts per million (ppm)
Definition sensor.h:128
@ SENSOR_CHAN_CURRENT
Current, in amps.
Definition sensor.h:141
@ SENSOR_CHAN_GYRO_XYZ
Angular velocity around the X, Y and Z axes.
Definition sensor.h:81
@ SENSOR_CHAN_VSHUNT
Current Shunt Voltage in milli-volts.
Definition sensor.h:138
@ SENSOR_CHAN_GREEN
Illuminance in green spectrum, in lux.
Definition sensor.h:110
@ SENSOR_CHAN_GRAVITY_VECTOR
Gravity Vector (X/Y/Z components in m/s^2)
Definition sensor.h:205
@ SENSOR_CHAN_MAGN_Z
Magnetic field on the Z axis, in Gauss.
Definition sensor.h:87
@ SENSOR_CHAN_MAGN_Y
Magnetic field on the Y axis, in Gauss.
Definition sensor.h:85
@ SENSOR_CHAN_GAUGE_DESIRED_VOLTAGE
Desired voltage of cell in V (nominal voltage)
Definition sensor.h:199
@ SENSOR_CHAN_POWER
Power in watts.
Definition sensor.h:143
@ SENSOR_CHAN_PM_2_5
2.5 micro-meters Particulate Matter, in ug/m^3
Definition sensor.h:119
@ SENSOR_CHAN_RESISTANCE
Resistance , in Ohm.
Definition sensor.h:146
@ SENSOR_CHAN_GAME_ROTATION_VECTOR
Game Rotation Vector (unit quaternion components X/Y/Z/W)
Definition sensor.h:203
@ SENSOR_CHAN_GAUGE_AVG_CURRENT
Average current, in amps (negative=discharging)
Definition sensor.h:169
@ SENSOR_CHAN_GYRO_Y
Angular velocity around the Y axis, in radians/s.
Definition sensor.h:77
@ SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT
Desired charging current in mA.
Definition sensor.h:201
@ SENSOR_CHAN_FREQUENCY
Frequency, in Hz.
Definition sensor.h:164
@ SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY
Full Charge Capacity in mAh.
Definition sensor.h:179
@ SENSOR_CHAN_ROTATION
Angular rotation, in degrees.
Definition sensor.h:149
@ SENSOR_CHAN_AMBIENT_TEMP
Ambient temperature in degrees Celsius.
Definition sensor.h:93
@ SENSOR_CHAN_MAGN_XYZ
Magnetic field on the X, Y and Z axes.
Definition sensor.h:89
@ SENSOR_CHAN_GAUGE_STDBY_CURRENT
Standby current, in amps (negative=discharging)
Definition sensor.h:171
@ SENSOR_CHAN_GAUGE_MAX_LOAD_CURRENT
Max load current, in amps (negative=discharging)
Definition sensor.h:173
@ SENSOR_CHAN_ACCEL_Y
Acceleration on the Y axis, in m/s^2.
Definition sensor.h:69
@ SENSOR_CHAN_RPM
Revolutions per minute, in RPM.
Definition sensor.h:161
@ SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY
Full Available Capacity in mAh.
Definition sensor.h:185
@ SENSOR_CHAN_VOLTAGE
Voltage, in volts.
Definition sensor.h:135
@ SENSOR_CHAN_BLUE
Illuminance in blue spectrum, in lux.
Definition sensor.h:112
@ SENSOR_CHAN_LIGHT
Illuminance in visible spectrum, in lux.
Definition sensor.h:104
@ SENSOR_CHAN_GAUGE_DESIGN_VOLTAGE
Design voltage of cell in V (max voltage)
Definition sensor.h:197
@ SENSOR_CHAN_ACCEL_Z
Acceleration on the Z axis, in m/s^2.
Definition sensor.h:71
@ SENSOR_CHAN_CO2
CO2 level, in parts per million (ppm)
Definition sensor.h:126
@ SENSOR_CHAN_GAUGE_STATE_OF_CHARGE
State of charge measurement in %.
Definition sensor.h:177
@ SENSOR_CHAN_POS_DXYZ
Position change on the X, Y and Z axis, in points.
Definition sensor.h:158
@ SENSOR_CHAN_GBIAS_XYZ
Gyroscope bias (X/Y/Z components in radians/s)
Definition sensor.h:207
@ SENSOR_CHAN_GAUGE_CYCLE_COUNT
Cycle count (total number of charge/discharge cycles)
Definition sensor.h:195
@ SENSOR_CHAN_GAUGE_TEMP
Gauge temperature
Definition sensor.h:175
@ SENSOR_CHAN_POS_DY
Position change on the Y axis, in points.
Definition sensor.h:154
@ SENSOR_CHAN_GYRO_Z
Angular velocity around the Z axis, in radians/s.
Definition sensor.h:79
@ SENSOR_CHAN_POS_DX
Position change on the X axis, in points.
Definition sensor.h:152
@ SENSOR_CHAN_GAUGE_AVG_POWER
Average power in mW.
Definition sensor.h:187
@ SENSOR_CHAN_GAUGE_TIME_TO_EMPTY
Time to empty in minutes.
Definition sensor.h:191
@ SENSOR_CHAN_PM_10
10 micro-meters Particulate Matter, in ug/m^3
Definition sensor.h:121
@ SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY
Remaining Charge Capacity in mAh.
Definition sensor.h:181
@ SENSOR_CHAN_ALL
All channels.
Definition sensor.h:210
@ SENSOR_CHAN_GAUGE_VOLTAGE
Voltage, in volts.
Definition sensor.h:167
@ SENSOR_CHAN_PROX
Proximity.
Definition sensor.h:100
@ SENSOR_CHAN_COMMON_COUNT
Number of all common sensor channels.
Definition sensor.h:215
@ SENSOR_CHAN_PRIV_START
This and higher values are sensor specific.
Definition sensor.h:221
@ SENSOR_CHAN_GYRO_X
Angular velocity around the X axis, in radians/s.
Definition sensor.h:75
@ SENSOR_CHAN_GAS_RES
Gas sensor resistance in ohms.
Definition sensor.h:132
@ SENSOR_CHAN_HUMIDITY
Humidity, in percent.
Definition sensor.h:102
@ SENSOR_CHAN_DISTANCE
Distance.
Definition sensor.h:123
@ SENSOR_CHAN_IR
Illuminance in infra-red spectrum, in lux.
Definition sensor.h:106
@ SENSOR_CHAN_MAX
Maximum value describing a sensor channel type.
Definition sensor.h:226
@ SENSOR_CHAN_POS_DZ
Position change on the Z axis, in points.
Definition sensor.h:156
@ SENSOR_CHAN_RED
Illuminance in red spectrum, in lux.
Definition sensor.h:108
@ SENSOR_CHAN_ALTITUDE
Altitude, in meters.
Definition sensor.h:114
@ SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY
Nominal Available Capacity in mAh.
Definition sensor.h:183
@ SENSOR_CHAN_ACCEL_X
Acceleration on the X axis, in m/s^2.
Definition sensor.h:67
@ SENSOR_CHAN_VOC
VOC level, in parts per billion (ppb)
Definition sensor.h:130
#define IS_ENABLED(config_macro)
Check for macro definition in compiler-visible expressions.
Definition util_macro.h:148
#define ENOSYS
Function not implemented.
Definition errno.h:82
#define ENOMEM
Not enough core.
Definition errno.h:50
#define ERANGE
Result too large.
Definition errno.h:72
#define NULL
Definition iar_missing_defs.h:20
Size of off_t must be equal or less than size of size_t
Definition retained_mem.h:28
Real-Time IO device API for moving bytes with low effort.
#define bool
Definition stdbool.h:13
__UINT32_TYPE__ uint32_t
Definition stdint.h:90
__INT32_TYPE__ int32_t
Definition stdint.h:74
#define INT32_MAX
Definition stdint.h:18
__UINT64_TYPE__ uint64_t
Definition stdint.h:91
__UINT8_TYPE__ uint8_t
Definition stdint.h:88
__UINTPTR_TYPE__ uintptr_t
Definition stdint.h:105
__UINT16_TYPE__ uint16_t
Definition stdint.h:89
#define INT32_MIN
Definition stdint.h:24
#define INT16_MAX
Definition stdint.h:17
__INT64_TYPE__ int64_t
Definition stdint.h:75
__INT8_TYPE__ int8_t
Definition stdint.h:72
void * memcpy(void *ZRESTRICT d, const void *ZRESTRICT s, size_t n)
Runtime device structure (in ROM) per driver instance.
Definition device.h:510
const void * api
Address of the API structure exposed by the device instance.
Definition device.h:516
A completion queue event.
Definition rtio.h:385
void * userdata
Associated userdata with operation.
Definition rtio.h:389
int32_t result
Result from operation.
Definition rtio.h:388
API that an RTIO IO device should implement.
Definition rtio.h:524
Compute the mempool block index for a given pointer.
Definition rtio.h:514
struct rtio_sqe sqe
Definition rtio.h:515
An IO device with a function table for submitting requests.
Definition rtio.h:539
void * data
Definition rtio.h:544
A submission queue event.
Definition rtio.h:295
void * userdata
User provided data which is returned upon operation completion.
Definition rtio.h:313
uint32_t buf_len
Length of buffer.
Definition rtio.h:319
const struct rtio_iodev * iodev
Device to operation on.
Definition rtio.h:304
const uint8_t * buf
Buffer to write from.
Definition rtio.h:320
An RTIO context containing what can be viewed as a pair of queues.
Definition rtio.h:418
Sensor Channel Specification.
Definition sensor.h:451
uint16_t chan_idx
A sensor channel index.
Definition sensor.h:453
uint16_t chan_type
A sensor channel type.
Definition sensor.h:452
Definition sensor.h:929
uint64_t timestamp_ns
Definition sensor.h:931
int8_t shift
Definition sensor.h:940
uint32_t num_channels
Definition sensor.h:937
Used for iterating over the data frames via the sensor_decoder_api.
Definition sensor.h:573
const struct sensor_decoder_api * decoder
Definition sensor.h:574
struct sensor_chan_spec channel
Definition sensor.h:576
const uint8_t * buffer
Definition sensor.h:575
uint32_t fit
Definition sensor.h:577
Decodes a single raw data buffer.
Definition sensor.h:483
int(* get_size_info)(struct sensor_chan_spec channel, size_t *base_size, size_t *frame_size)
Get the size required to decode a given channel.
Definition sensor.h:508
int(* get_frame_count)(const uint8_t *buffer, struct sensor_chan_spec channel, uint16_t *frame_count)
Get the number of frames in the current buffer.
Definition sensor.h:493
int(* decode)(const uint8_t *buffer, struct sensor_chan_spec channel, uint32_t *fit, uint16_t max_count, void *data_out)
Decode up to max_count samples from the buffer.
Definition sensor.h:536
bool(* has_trigger)(const uint8_t *buffer, enum sensor_trigger_type trigger)
Check if the given trigger type is present.
Definition sensor.h:546
Definition sensor.h:718
sensor_get_decoder_t get_decoder
Definition sensor.h:724
sensor_attr_set_t attr_set
Definition sensor.h:719
sensor_attr_get_t attr_get
Definition sensor.h:720
sensor_trigger_set_t trigger_set
Definition sensor.h:721
sensor_sample_fetch_t sample_fetch
Definition sensor.h:722
sensor_channel_get_t channel_get
Definition sensor.h:723
sensor_submit_t submit
Definition sensor.h:725
Definition sensor.h:642
struct sensor_chan_spec *const channels
Definition sensor.h:646
size_t count
Definition sensor.h:649
struct sensor_stream_trigger *const triggers
Definition sensor.h:647
const bool is_streaming
Definition sensor.h:644
const struct device * sensor
Definition sensor.h:643
const size_t max
Definition sensor.h:650
Definition sensor.h:628
enum sensor_stream_data_opt opt
Definition sensor.h:630
enum sensor_trigger_type trigger
Definition sensor.h:629
Sensor trigger spec.
Definition sensor.h:303
enum sensor_trigger_type type
Trigger type.
Definition sensor.h:305
enum sensor_channel chan
Channel the trigger is set on.
Definition sensor.h:307
Representation of a sensor readout value.
Definition sensor.h:55
int32_t val2
Fractional part of the value (in one-millionth parts).
Definition sensor.h:59
int32_t val1
Integer part of the value.
Definition sensor.h:57
#define INT64_C(x)
Definition xcc.h:119