Zephyr API Documentation 4.2.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
adc.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2018 Nordic Semiconductor ASA
3 * Copyright (c) 2015 Intel Corporation
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
13
14#ifndef ZEPHYR_INCLUDE_DRIVERS_ADC_H_
15#define ZEPHYR_INCLUDE_DRIVERS_ADC_H_
16
17#include <zephyr/device.h>
19#include <zephyr/kernel.h>
20#include <zephyr/rtio/rtio.h>
21#include <zephyr/dsp/types.h>
22
23#ifdef __cplusplus
24extern "C" {
25#endif
26
35
60
77int adc_gain_invert(enum adc_gain gain, int32_t *value);
78
95int adc_gain_invert_64(enum adc_gain gain, int64_t *value);
96
107
114
117
128
152
155
156#ifdef CONFIG_ADC_CONFIGURABLE_INPUTS
162 uint8_t input_positive;
163
169 uint8_t input_negative;
170#endif /* CONFIG_ADC_CONFIGURABLE_INPUTS */
171
172#ifdef CONFIG_ADC_CONFIGURABLE_EXCITATION_CURRENT_SOURCE_PIN
173 uint8_t current_source_pin_set : 1;
180 uint8_t current_source_pin[2];
181#endif /* CONFIG_ADC_CONFIGURABLE_EXCITATION_CURRENT_SOURCE_PIN */
182
183#ifdef CONFIG_ADC_CONFIGURABLE_VBIAS_PIN
192 uint32_t vbias_pins;
193#endif /* CONFIG_ADC_CONFIGURABLE_VBIAS_PIN */
194};
195
260#define ADC_CHANNEL_CFG_DT(node_id) { \
261 .gain = DT_STRING_TOKEN(node_id, zephyr_gain), \
262 .reference = DT_STRING_TOKEN(node_id, zephyr_reference), \
263 .acquisition_time = DT_PROP(node_id, zephyr_acquisition_time), \
264 .channel_id = DT_REG_ADDR(node_id), \
265COND_CODE_1(UTIL_OR(DT_PROP(node_id, zephyr_differential), \
266 UTIL_AND(CONFIG_ADC_CONFIGURABLE_INPUTS, \
267 DT_NODE_HAS_PROP(node_id, zephyr_input_negative))), \
268 (.differential = true,), \
269 (.differential = false,)) \
270IF_ENABLED(CONFIG_ADC_CONFIGURABLE_INPUTS, \
271 (.input_positive = DT_PROP_OR(node_id, zephyr_input_positive, 0), \
272 .input_negative = DT_PROP_OR(node_id, zephyr_input_negative, 0),)) \
273IF_ENABLED(CONFIG_ADC_CONFIGURABLE_EXCITATION_CURRENT_SOURCE_PIN, \
274 (.current_source_pin_set = DT_NODE_HAS_PROP(node_id, zephyr_current_source_pin), \
275 .current_source_pin = DT_PROP_OR(node_id, zephyr_current_source_pin, {0}),)) \
276IF_ENABLED(CONFIG_ADC_CONFIGURABLE_VBIAS_PIN, \
277 (.vbias_pins = DT_PROP_OR(node_id, zephyr_vbias_pins, 0),)) \
278}
279
332
334
335#define ADC_DT_SPEC_STRUCT(ctlr, input) { \
336 .dev = DEVICE_DT_GET(ctlr), \
337 .channel_id = input, \
338 ADC_CHANNEL_CFG_FROM_DT_NODE(\
339 ADC_CHANNEL_DT_NODE(ctlr, input)) \
340 }
341
342#define ADC_CHANNEL_DT_NODE(ctlr, input) \
343 DT_FOREACH_CHILD_VARGS(ctlr, ADC_FOREACH_INPUT, input)
344
345#define ADC_FOREACH_INPUT(node, input) \
346 IF_ENABLED(IS_EQ(DT_REG_ADDR_RAW(node), input), (node))
347
348#define ADC_CHANNEL_CFG_FROM_DT_NODE(node_id) \
349 IF_ENABLED(DT_NODE_EXISTS(node_id), \
350 (.channel_cfg_dt_node_exists = true, \
351 .channel_cfg = ADC_CHANNEL_CFG_DT(node_id), \
352 .vref_mv = DT_PROP_OR(node_id, zephyr_vref_mv, 0), \
353 .resolution = DT_PROP_OR(node_id, zephyr_resolution, 0), \
354 .oversampling = DT_PROP_OR(node_id, zephyr_oversampling, 0),))
355
357
426#define ADC_DT_SPEC_GET_BY_NAME(node_id, name) \
427 ADC_DT_SPEC_STRUCT(DT_IO_CHANNELS_CTLR_BY_NAME(node_id, name), \
428 DT_IO_CHANNELS_INPUT_BY_NAME(node_id, name))
429
440#define ADC_DT_SPEC_INST_GET_BY_NAME(inst, name) \
441 ADC_DT_SPEC_GET_BY_NAME(DT_DRV_INST(inst), name)
442
512#define ADC_DT_SPEC_GET_BY_IDX(node_id, idx) \
513 ADC_DT_SPEC_STRUCT(DT_IO_CHANNELS_CTLR_BY_IDX(node_id, idx), \
514 DT_IO_CHANNELS_INPUT_BY_IDX(node_id, idx))
515
526#define ADC_DT_SPEC_INST_GET_BY_IDX(inst, idx) \
527 ADC_DT_SPEC_GET_BY_IDX(DT_DRV_INST(inst), idx)
528
538#define ADC_DT_SPEC_GET(node_id) ADC_DT_SPEC_GET_BY_IDX(node_id, 0)
539
548#define ADC_DT_SPEC_INST_GET(inst) ADC_DT_SPEC_GET(DT_DRV_INST(inst))
549
550/* Forward declaration of the adc_sequence structure. */
551struct adc_sequence;
552
569
589typedef enum adc_action (*adc_sequence_callback)(const struct device *dev,
590 const struct adc_sequence *sequence,
591 uint16_t sampling_index);
592
626
694
708
722
752
764
769
781
782/*
783 * Internal data structure used to store information about the IODevice for async reading and
784 * streaming adc data.
785 */
797
812 int (*get_frame_count)(const uint8_t *buffer, uint32_t channel,
813 uint16_t *frame_count);
814
828 int (*get_size_info)(struct adc_dt_spec adc_spec, uint32_t channel, size_t *base_size,
829 size_t *frame_size);
830
846 int (*decode)(const uint8_t *buffer, uint32_t channel, uint32_t *fit,
847 uint16_t max_count, void *data_out);
848
856 bool (*has_trigger)(const uint8_t *buffer, enum adc_trigger_type trigger);
857};
858
863typedef int (*adc_api_channel_setup)(const struct device *dev,
864 const struct adc_channel_cfg *channel_cfg);
865
870typedef int (*adc_api_read)(const struct device *dev,
871 const struct adc_sequence *sequence);
872
877typedef void (*adc_api_submit)(const struct device *dev,
878 struct rtio_iodev_sqe *sqe);
879
885typedef int (*adc_api_get_decoder)(const struct device *dev,
886 const struct adc_decoder_api **api);
887
888
894typedef int (*adc_api_read_async)(const struct device *dev,
895 const struct adc_sequence *sequence,
896 struct k_poll_signal *async);
897
903__subsystem struct adc_driver_api {
906#ifdef CONFIG_ADC_ASYNC
907 adc_api_read_async read_async;
908#endif
909#ifdef CONFIG_ADC_STREAM
910 adc_api_submit submit;
911 adc_api_get_decoder get_decoder;
912#endif
914};
915
928__syscall int adc_channel_setup(const struct device *dev,
929 const struct adc_channel_cfg *channel_cfg);
930
931static inline int z_impl_adc_channel_setup(const struct device *dev,
932 const struct adc_channel_cfg *channel_cfg)
933{
934 return DEVICE_API_GET(adc, dev)->channel_setup(dev, channel_cfg);
935}
936
946static inline int adc_channel_setup_dt(const struct adc_dt_spec *spec)
947{
948 if (!spec->channel_cfg_dt_node_exists) {
949 return -ENOTSUP;
950 }
951
952 return adc_channel_setup(spec->dev, &spec->channel_cfg);
953}
954
976__syscall int adc_read(const struct device *dev,
977 const struct adc_sequence *sequence);
978
979static inline int z_impl_adc_read(const struct device *dev,
980 const struct adc_sequence *sequence)
981{
982 return DEVICE_API_GET(adc, dev)->read(dev, sequence);
983}
984
994static inline int adc_read_dt(const struct adc_dt_spec *spec,
995 const struct adc_sequence *sequence)
996{
997 return adc_read(spec->dev, sequence);
998}
999
1020__syscall int adc_read_async(const struct device *dev,
1021 const struct adc_sequence *sequence,
1022 struct k_poll_signal *async);
1023
1024#ifdef CONFIG_ADC_ASYNC
1025static inline int z_impl_adc_read_async(const struct device *dev,
1026 const struct adc_sequence *sequence,
1027 struct k_poll_signal *async)
1028{
1029 return DEVICE_API_GET(adc, dev)->read_async(dev, sequence, async);
1030}
1031#endif /* CONFIG_ADC_ASYNC */
1032
1033#ifdef CONFIG_ADC_STREAM
1047__syscall int adc_get_decoder(const struct device *dev,
1048 const struct adc_decoder_api **api);
1049/*
1050 * Generic data structure used for encoding the sample timestamp and number of channels sampled.
1051 */
1052struct __attribute__((__packed__)) adc_data_generic_header {
1053 /* The timestamp at which the data was collected from the adc */
1054 uint64_t timestamp_ns;
1055
1056 /*
1057 * The number of channels present in the frame.
1058 */
1059 uint8_t num_channels;
1060
1061 /* Shift value for all samples in the frame */
1062 int8_t shift;
1063
1064 /* This padding is needed to make sure that the 'channels' field is aligned */
1065 int16_t _padding;
1066
1067 /* Channels present in the frame */
1068 struct adc_chan_spec channels[0];
1069};
1070
1071static inline int adc_stream(struct rtio_iodev *iodev, struct rtio *ctx, void *userdata,
1072 struct rtio_sqe **handle)
1073{
1074 if (IS_ENABLED(CONFIG_USERSPACE)) {
1075 struct rtio_sqe sqe;
1076
1078 rtio_sqe_copy_in_get_handles(ctx, &sqe, handle, 1);
1079 } else {
1080 struct rtio_sqe *sqe = rtio_sqe_acquire(ctx);
1081
1082 if (sqe == NULL) {
1083 return -ENOMEM;
1084 }
1085 if (handle != NULL) {
1086 *handle = sqe;
1087 }
1089 }
1090 rtio_submit(ctx, 0);
1091 return 0;
1092}
1093
1094static inline int z_impl_adc_get_decoder(const struct device *dev,
1095 const struct adc_decoder_api **decoder)
1096{
1097 const struct adc_driver_api *api = DEVICE_API_GET(adc, dev);
1098
1099 __ASSERT_NO_MSG(api != NULL);
1100
1101 if (api->get_decoder == NULL) {
1102 *decoder = NULL;
1103 return -1;
1104 }
1105
1106 return api->get_decoder(dev, decoder);
1107}
1108#endif /* CONFIG_ADC_STREAM */
1109
1119static inline uint16_t adc_ref_internal(const struct device *dev)
1120{
1121 return DEVICE_API_GET(adc, dev)->ref_internal;
1122}
1123
1147typedef int (*adc_raw_to_x_fn)(int32_t ref_mv, enum adc_gain gain, uint8_t resolution,
1148 int32_t *valp);
1149
1155static inline int adc_raw_to_millivolts(int32_t ref_mv, enum adc_gain gain, uint8_t resolution,
1156 int32_t *valp)
1157{
1158 int32_t adc_mv = *valp * ref_mv;
1159 int ret = adc_gain_invert(gain, &adc_mv);
1160
1161 if (ret == 0) {
1162 *valp = (adc_mv >> resolution);
1163 }
1164
1165 return ret;
1166}
1167
1173static inline int adc_raw_to_microvolts(int32_t ref_mv, enum adc_gain gain, uint8_t resolution,
1174 int32_t *valp)
1175{
1176 int64_t adc_uv = (int64_t)*valp * ref_mv * 1000;
1177 int ret = adc_gain_invert_64(gain, &adc_uv);
1178
1179 if (ret == 0) {
1180 *valp = (int32_t)(adc_uv >> resolution);
1181 }
1182
1183 return ret;
1184}
1185
1202static inline int adc_raw_to_x_dt_chan(adc_raw_to_x_fn conv_func,
1203 const struct adc_dt_spec *spec,
1204 const struct adc_channel_cfg *channel_cfg,
1205 int32_t *valp)
1206{
1207 int32_t vref_mv;
1208 uint8_t resolution;
1209
1210 if (!spec->channel_cfg_dt_node_exists) {
1211 return -ENOTSUP;
1212 }
1213
1214 if (channel_cfg->reference == ADC_REF_INTERNAL) {
1215 vref_mv = (int32_t)adc_ref_internal(spec->dev);
1216 } else {
1217 vref_mv = spec->vref_mv;
1218 }
1219
1220 resolution = spec->resolution;
1221
1222 /*
1223 * For differential channels, one bit less needs to be specified
1224 * for resolution to achieve correct conversion.
1225 */
1226 if (channel_cfg->differential) {
1227 resolution -= 1U;
1228 }
1229
1230 return conv_func(vref_mv, channel_cfg->gain, resolution, valp);
1231}
1232
1233
1247static inline int adc_raw_to_millivolts_dt(const struct adc_dt_spec *spec, int32_t *valp)
1248{
1249 return adc_raw_to_x_dt_chan(adc_raw_to_millivolts, spec, &spec->channel_cfg, valp);
1250}
1251
1265static inline int adc_raw_to_microvolts_dt(const struct adc_dt_spec *spec, int32_t *valp)
1266{
1267 return adc_raw_to_x_dt_chan(adc_raw_to_microvolts, spec, &spec->channel_cfg, valp);
1268}
1269
1288static inline int adc_sequence_init_dt(const struct adc_dt_spec *spec,
1289 struct adc_sequence *seq)
1290{
1291 if (!spec->channel_cfg_dt_node_exists) {
1292 return -ENOTSUP;
1293 }
1294
1295 seq->channels = BIT(spec->channel_id);
1296 seq->resolution = spec->resolution;
1297 seq->oversampling = spec->oversampling;
1298
1299 return 0;
1300}
1301
1309static inline bool adc_is_ready_dt(const struct adc_dt_spec *spec)
1310{
1311 return device_is_ready(spec->dev);
1312}
1313
1317
1323#define ADC_DECODER_NAME() UTIL_CAT(DT_DRV_COMPAT, __adc_decoder_api)
1324
1332#define ADC_DECODER_DT_GET(node_id) \
1333 &UTIL_CAT(DT_STRING_TOKEN_BY_IDX(node_id, compatible, 0), __adc_decoder_api)
1334
1350#define ADC_DECODER_API_DT_DEFINE() \
1351 COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT), (), (static)) \
1352 const STRUCT_SECTION_ITERABLE(adc_decoder_api, ADC_DECODER_NAME())
1353
1354#define Z_MAYBE_ADC_DECODER_DECLARE_INTERNAL_IDX(node_id, prop, idx) \
1355 extern const struct adc_decoder_api UTIL_CAT( \
1356 DT_STRING_TOKEN_BY_IDX(node_id, prop, idx), __adc_decoder_api);
1357
1358#define Z_MAYBE_ADC_DECODER_DECLARE_INTERNAL(node_id) \
1359 COND_CODE_1(DT_NODE_HAS_PROP(node_id, compatible), \
1360 (DT_FOREACH_PROP_ELEM(node_id, compatible, \
1361 Z_MAYBE_ADC_DECODER_DECLARE_INTERNAL_IDX)), \
1362 ())
1363
1364DT_FOREACH_STATUS_OKAY_NODE(Z_MAYBE_ADC_DECODER_DECLARE_INTERNAL)
1365
1366/* The default adc iodev API */
1367extern const struct rtio_iodev_api __adc_iodev_api;
1368
1369#define ADC_DT_STREAM_IODEV(name, dt_node, adc_dt_spec, ...) \
1370 static struct adc_stream_trigger _CONCAT(__trigger_array_, name)[] = {__VA_ARGS__}; \
1371 static struct adc_read_config _CONCAT(__adc_read_config_, name) = { \
1372 .adc = DEVICE_DT_GET(dt_node), \
1373 .is_streaming = true, \
1374 .adc_spec = adc_dt_spec, \
1375 .triggers = _CONCAT(__trigger_array_, name), \
1376 .adc_spec_cnt = ARRAY_SIZE(adc_dt_spec), \
1377 .trigger_cnt = ARRAY_SIZE(_CONCAT(__trigger_array_, name)), \
1378 }; \
1379 RTIO_IODEV_DEFINE(name, &__adc_iodev_api, &_CONCAT(__adc_read_config_, name))
1380
1381#ifdef __cplusplus
1382}
1383#endif
1384
1385#include <zephyr/syscalls/adc.h>
1386
1387#endif /* ZEPHYR_INCLUDE_DRIVERS_ADC_H_ */
#define DEVICE_API_GET(_class, _dev)
Expands to the pointer of a device's API for a given class.
Definition device.h:1350
int adc_read_async(const struct device *dev, const struct adc_sequence *sequence, struct k_poll_signal *async)
Set an asynchronous read request.
static int adc_raw_to_millivolts_dt(const struct adc_dt_spec *spec, int32_t *valp)
Convert a raw ADC value to millivolts using information stored in a struct adc_dt_spec.
Definition adc.h:1247
int(* adc_api_get_decoder)(const struct device *dev, const struct adc_decoder_api **api)
Get the decoder associate with the given device.
Definition adc.h:885
static int adc_raw_to_x_dt_chan(adc_raw_to_x_fn conv_func, const struct adc_dt_spec *spec, const struct adc_channel_cfg *channel_cfg, int32_t *valp)
Convert a raw ADC value to an arbitrary output unit.
Definition adc.h:1202
int adc_gain_invert_64(enum adc_gain gain, int64_t *value)
Invert the application of gain to a measurement value.
static int adc_read_dt(const struct adc_dt_spec *spec, const struct adc_sequence *sequence)
Set a read request from a struct adc_dt_spec.
Definition adc.h:994
adc_gain
ADC channel gain factors.
Definition adc.h:37
static bool adc_is_ready_dt(const struct adc_dt_spec *spec)
Validate that the ADC device is ready.
Definition adc.h:1309
int(* adc_raw_to_x_fn)(int32_t ref_mv, enum adc_gain gain, uint8_t resolution, int32_t *valp)
Conversion from raw ADC units to a specific output unit.
Definition adc.h:1147
adc_stream_data_opt
Options for what to do with the associated data when a trigger is consumed.
Definition adc.h:756
static int adc_raw_to_microvolts(int32_t ref_mv, enum adc_gain gain, uint8_t resolution, int32_t *valp)
Convert a raw ADC value to microvolts.
Definition adc.h:1173
static int adc_raw_to_microvolts_dt(const struct adc_dt_spec *spec, int32_t *valp)
Convert a raw ADC value to microvolts using information stored in a struct adc_dt_spec.
Definition adc.h:1265
int(* adc_api_read)(const struct device *dev, const struct adc_sequence *sequence)
Type definition of ADC API function for setting a read request.
Definition adc.h:870
static int adc_sequence_init_dt(const struct adc_dt_spec *spec, struct adc_sequence *seq)
Initialize a struct adc_sequence from information stored in struct adc_dt_spec.
Definition adc.h:1288
int adc_gain_invert(enum adc_gain gain, int32_t *value)
Invert the application of gain to a measurement value.
void(* adc_api_submit)(const struct device *dev, struct rtio_iodev_sqe *sqe)
Type definition of ADC API function for setting an submit stream request.
Definition adc.h:877
int adc_read(const struct device *dev, const struct adc_sequence *sequence)
Set a read request.
adc_trigger_type
ADC trigger types.
Definition adc.h:726
int adc_channel_setup(const struct device *dev, const struct adc_channel_cfg *channel_cfg)
Configure an ADC channel.
int(* adc_api_channel_setup)(const struct device *dev, const struct adc_channel_cfg *channel_cfg)
Type definition of ADC API function for configuring a channel.
Definition adc.h:863
adc_action
Action to be performed after a sampling is done.
Definition adc.h:556
enum adc_action(* adc_sequence_callback)(const struct device *dev, const struct adc_sequence *sequence, uint16_t sampling_index)
Type definition of the optional callback function to be called after a requested sampling is done.
Definition adc.h:589
adc_reference
ADC references.
Definition adc.h:98
int(* adc_api_read_async)(const struct device *dev, const struct adc_sequence *sequence, struct k_poll_signal *async)
Type definition of ADC API function for setting an asynchronous read request.
Definition adc.h:894
static uint16_t adc_ref_internal(const struct device *dev)
Get the internal reference voltage.
Definition adc.h:1119
static int adc_channel_setup_dt(const struct adc_dt_spec *spec)
Configure an ADC channel from a struct adc_dt_spec.
Definition adc.h:946
static int adc_raw_to_millivolts(int32_t ref_mv, enum adc_gain gain, uint8_t resolution, int32_t *valp)
Convert a raw ADC value to millivolts.
Definition adc.h:1155
@ ADC_GAIN_64
x 64.
Definition adc.h:57
@ ADC_GAIN_3
x 3.
Definition adc.h:49
@ ADC_GAIN_4
x 4.
Definition adc.h:50
@ ADC_GAIN_1_5
x 1/5.
Definition adc.h:39
@ ADC_GAIN_128
x 128.
Definition adc.h:58
@ ADC_GAIN_1_2
x 1/2.
Definition adc.h:44
@ ADC_GAIN_2_7
x 2/7.
Definition adc.h:41
@ ADC_GAIN_12
x 12.
Definition adc.h:53
@ ADC_GAIN_2_5
x 2/5.
Definition adc.h:43
@ ADC_GAIN_16
x 16.
Definition adc.h:54
@ ADC_GAIN_24
x 24.
Definition adc.h:55
@ ADC_GAIN_1
x 1.
Definition adc.h:47
@ ADC_GAIN_6
x 6.
Definition adc.h:51
@ ADC_GAIN_1_6
x 1/6.
Definition adc.h:38
@ ADC_GAIN_32
x 32.
Definition adc.h:56
@ ADC_GAIN_2_3
x 2/3.
Definition adc.h:45
@ ADC_GAIN_4_5
x 4/5.
Definition adc.h:46
@ ADC_GAIN_8
x 8.
Definition adc.h:52
@ ADC_GAIN_1_3
x 1/3.
Definition adc.h:42
@ ADC_GAIN_1_4
x 1/4.
Definition adc.h:40
@ ADC_GAIN_2
x 2.
Definition adc.h:48
@ ADC_STREAM_DATA_NOP
Do nothing with the associated trigger data, it may be consumed later.
Definition adc.h:760
@ ADC_STREAM_DATA_DROP
Flush/clear whatever data is associated with the trigger.
Definition adc.h:762
@ ADC_STREAM_DATA_INCLUDE
Include whatever data is associated with the trigger.
Definition adc.h:758
@ ADC_TRIG_PRIV_START
This and higher values are adc specific.
Definition adc.h:745
@ ADC_TRIG_DATA_READY
Trigger fires whenever new data is ready.
Definition adc.h:728
@ ADC_TRIG_FIFO_WATERMARK
Trigger fires when the FIFO watermark has been reached.
Definition adc.h:731
@ ADC_TRIG_MAX
Maximum value describing a adc trigger type.
Definition adc.h:750
@ ADC_TRIG_FIFO_FULL
Trigger fires when the FIFO becomes full.
Definition adc.h:734
@ ADC_TRIG_COMMON_COUNT
Number of all common adc triggers.
Definition adc.h:739
@ ADC_ACTION_FINISH
The sequence should be finished immediately.
Definition adc.h:567
@ ADC_ACTION_REPEAT
The sampling should be repeated.
Definition adc.h:564
@ ADC_ACTION_CONTINUE
The sequence should be continued normally.
Definition adc.h:558
@ ADC_REF_INTERNAL
Internal.
Definition adc.h:103
@ ADC_REF_EXTERNAL1
External, input 1.
Definition adc.h:105
@ ADC_REF_VDD_1_2
VDD/2.
Definition adc.h:100
@ ADC_REF_VDD_1_3
VDD/3.
Definition adc.h:101
@ ADC_REF_VDD_1_4
VDD/4.
Definition adc.h:102
@ ADC_REF_VDD_1
VDD.
Definition adc.h:99
@ ADC_REF_EXTERNAL0
External, input 0.
Definition adc.h:104
bool device_is_ready(const struct device *dev)
Verify that a device is ready for use.
#define DT_FOREACH_STATUS_OKAY_NODE(fn)
Invokes fn for every status okay node in the tree.
Definition devicetree.h:3000
int32_t q31_t
32-bit fractional data type in 1.31 format.
Definition types.h:35
#define RTIO_PRIO_NORM
Normal priority.
Definition rtio.h:71
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 struct rtio_sqe * rtio_sqe_acquire(struct rtio *r)
Acquire a single submission queue event if available.
Definition rtio.h:1102
static void rtio_sqe_prep_read_multishot(struct rtio_sqe *sqe, const struct rtio_iodev *iodev, int8_t prio, void *userdata)
Definition rtio.h:632
int rtio_submit(struct rtio *r, uint32_t wait_count)
Submit I/O requests to the underlying executor.
#define IS_ENABLED(config_macro)
Check for macro definition in compiler-visible expressions.
Definition util_macro.h:148
#define BIT(n)
Unsigned integer with bit position n set (signed in assembly language).
Definition util_macro.h:44
#define ENOMEM
Not enough core.
Definition errno.h:50
#define ENOTSUP
Unsupported value.
Definition errno.h:114
#define NULL
Definition iar_missing_defs.h:20
Public kernel APIs.
Size of off_t must be equal or less than size of size_t
Definition retained_mem.h:29
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
__UINT64_TYPE__ uint64_t
Definition stdint.h:91
__UINT8_TYPE__ uint8_t
Definition stdint.h:88
__UINT16_TYPE__ uint16_t
Definition stdint.h:89
#define INT16_MAX
Definition stdint.h:17
__INT64_TYPE__ int64_t
Definition stdint.h:75
__INT8_TYPE__ int8_t
Definition stdint.h:72
__INT16_TYPE__ int16_t
Definition stdint.h:73
ADC Channel Specification.
Definition adc.h:777
uint8_t chan_resolution
A ADC channel resolution.
Definition adc.h:779
uint8_t chan_idx
A ADC channel index.
Definition adc.h:778
Structure for specifying the configuration of an ADC channel.
Definition adc.h:111
enum adc_gain gain
Gain selection.
Definition adc.h:113
uint8_t differential
Channel type: single-ended or differential.
Definition adc.h:154
uint16_t acquisition_time
Acquisition time.
Definition adc.h:127
enum adc_reference reference
Reference selection.
Definition adc.h:116
uint8_t channel_id
Channel identifier.
Definition adc.h:151
Definition adc.h:715
q31_t value
Definition adc.h:718
uint32_t timestamp_delta
Definition adc.h:716
Definition adc.h:695
uint64_t base_timestamp_ns
The closest timestamp for when the first frame was generated as attained by :c:func:k_uptime_ticks.
Definition adc.h:700
uint16_t reading_count
The number of elements in the 'readings' array.
Definition adc.h:706
Data for the adc channel.
Definition adc.h:712
int8_t shift
Definition adc.h:714
struct adc_data::adc_sample_data readings[1]
struct adc_data_header header
Definition adc.h:713
Decodes a single raw data buffer.
Definition adc.h:802
bool(* has_trigger)(const uint8_t *buffer, enum adc_trigger_type trigger)
Check if the given trigger type is present.
Definition adc.h:856
int(* get_frame_count)(const uint8_t *buffer, uint32_t channel, uint16_t *frame_count)
Get the number of frames in the current buffer.
Definition adc.h:812
int(* get_size_info)(struct adc_dt_spec adc_spec, uint32_t channel, size_t *base_size, size_t *frame_size)
Get the size required to decode a given channel.
Definition adc.h:828
int(* decode)(const uint8_t *buffer, uint32_t channel, uint32_t *fit, uint16_t max_count, void *data_out)
Decode up to max_count samples from the buffer.
Definition adc.h:846
ADC driver API.
Definition adc.h:903
adc_api_read read
Definition adc.h:905
uint16_t ref_internal
Definition adc.h:913
adc_api_channel_setup channel_setup
Definition adc.h:904
Container for ADC channel information specified in devicetree.
Definition adc.h:286
struct adc_channel_cfg channel_cfg
Configuration of the associated ADC channel specified in devicetree.
Definition adc.h:308
uint8_t channel_id
ADC channel identifier used by this io-channel.
Definition adc.h:294
uint16_t vref_mv
Voltage of the reference selected for the channel or 0 if this value is not provided in devicetree.
Definition adc.h:316
const struct device * dev
Pointer to the device structure for the ADC driver instance used by this io-channel.
Definition adc.h:291
uint8_t oversampling
Oversampling setting to be used for that channel.
Definition adc.h:330
bool channel_cfg_dt_node_exists
Flag indicating whether configuration of the associated ADC channel is provided as a child node of th...
Definition adc.h:301
uint8_t resolution
ADC resolution to be used for that channel.
Definition adc.h:323
Definition adc.h:786
const struct adc_dt_spec * adc_spec
Definition adc.h:789
uint16_t fifo_mode
Definition adc.h:793
uint16_t fifo_watermark_lvl
Definition adc.h:792
const struct device * adc
Definition adc.h:787
size_t trigger_cnt
Definition adc.h:795
struct adc_sequence * sequence
Definition adc.h:791
size_t adc_spec_cnt
Definition adc.h:794
const struct adc_stream_trigger * triggers
Definition adc.h:790
const bool is_streaming
Definition adc.h:788
Structure defining additional options for an ADC sampling sequence.
Definition adc.h:596
void * user_data
Pointer to user data.
Definition adc.h:618
uint16_t extra_samplings
Number of extra samplings to perform (the total number of samplings is 1 + extra_samplings).
Definition adc.h:624
adc_sequence_callback callback
Callback function to be called after each sampling is done.
Definition adc.h:612
uint32_t interval_us
Interval between consecutive samplings (in microseconds), 0 means sample as fast as possible,...
Definition adc.h:606
Structure defining an ADC sampling sequence.
Definition adc.h:630
uint8_t oversampling
Oversampling setting.
Definition adc.h:682
const struct adc_sequence_options * options
Pointer to a structure defining additional options for the sequence.
Definition adc.h:635
uint32_t channels
Bit-mask indicating the channels to be included in each sampling of this sequence.
Definition adc.h:644
void * buffer
Pointer to a buffer where the samples are to be written.
Definition adc.h:657
bool calibrate
Perform calibration before the reading is taken if requested.
Definition adc.h:692
size_t buffer_size
Specifies the actual size of the buffer pointed by the "buffer" field (in bytes).
Definition adc.h:665
uint8_t resolution
ADC resolution.
Definition adc.h:674
Definition adc.h:765
enum adc_stream_data_opt opt
Definition adc.h:767
enum adc_trigger_type trigger
Definition adc.h:766
Runtime device structure (in ROM) per driver instance.
Definition device.h:510
Definition kernel.h:6168
API that an RTIO IO device should implement.
Definition rtio.h:525
Compute the mempool block index for a given pointer.
Definition rtio.h:515
struct rtio_sqe sqe
Definition rtio.h:516
An IO device with a function table for submitting requests.
Definition rtio.h:540
A submission queue event.
Definition rtio.h:296
void * userdata
User provided data which is returned upon operation completion.
Definition rtio.h:314
const struct rtio_iodev * iodev
Device to operation on.
Definition rtio.h:305
An RTIO context containing what can be viewed as a pair of queues.
Definition rtio.h:419