1 /*
2 * Copyright (c) 2023 STMicroelectronics
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <zephyr/kernel.h>
8 #include <zephyr/sys/printk.h>
9
10 #include <zephyr/drivers/gpio.h>
11 #include <zephyr/drivers/led.h>
12 #include <zephyr/drivers/i2c.h>
13 #include <zephyr/drivers/spi.h>
14 #include <zephyr/drivers/sensor.h>
15
16 #include <stdio.h>
17
18 #ifdef CONFIG_LPS2XDF_TRIGGER
19 static int lps22df_trig_cnt;
20
lps22df_trigger_handler(const struct device * dev,const struct sensor_trigger * trig)21 static void lps22df_trigger_handler(const struct device *dev,
22 const struct sensor_trigger *trig)
23 {
24 sensor_sample_fetch_chan(dev, SENSOR_CHAN_PRESS);
25 lps22df_trig_cnt++;
26 }
27 #endif
28
29 #ifdef CONFIG_LSM6DSV16X_TRIGGER
30 static int lsm6dsv16x_acc_trig_cnt;
31 static int lsm6dsv16x_gyr_trig_cnt;
32 static int lsm6dsv16x_temp_trig_cnt;
33
lsm6dsv16x_acc_trig_handler(const struct device * dev,const struct sensor_trigger * trig)34 static void lsm6dsv16x_acc_trig_handler(const struct device *dev,
35 const struct sensor_trigger *trig)
36 {
37 sensor_sample_fetch_chan(dev, SENSOR_CHAN_ACCEL_XYZ);
38 lsm6dsv16x_acc_trig_cnt++;
39 }
40
lsm6dsv16x_gyr_trig_handler(const struct device * dev,const struct sensor_trigger * trig)41 static void lsm6dsv16x_gyr_trig_handler(const struct device *dev,
42 const struct sensor_trigger *trig)
43 {
44 sensor_sample_fetch_chan(dev, SENSOR_CHAN_GYRO_XYZ);
45 lsm6dsv16x_gyr_trig_cnt++;
46 }
47
lsm6dsv16x_temp_trig_handler(const struct device * dev,const struct sensor_trigger * trig)48 static void lsm6dsv16x_temp_trig_handler(const struct device *dev,
49 const struct sensor_trigger *trig)
50 {
51 sensor_sample_fetch_chan(dev, SENSOR_CHAN_DIE_TEMP);
52 lsm6dsv16x_temp_trig_cnt++;
53 }
54 #endif
55
56 #ifdef CONFIG_LIS2MDL_TRIGGER
57 static int lis2mdl_trig_cnt;
58
lis2mdl_trigger_handler(const struct device * dev,const struct sensor_trigger * trig)59 static void lis2mdl_trigger_handler(const struct device *dev,
60 const struct sensor_trigger *trig)
61 {
62 sensor_sample_fetch_chan(dev, SENSOR_CHAN_ALL);
63 lis2mdl_trig_cnt++;
64 }
65 #endif
66
67 #ifdef CONFIG_LIS2DU12_TRIGGER
68 static int lis2du12_trig_cnt;
69
lis2du12_trigger_handler(const struct device * dev,const struct sensor_trigger * trig)70 static void lis2du12_trigger_handler(const struct device *dev,
71 const struct sensor_trigger *trig)
72 {
73 sensor_sample_fetch_chan(dev, SENSOR_CHAN_ALL);
74 lis2du12_trig_cnt++;
75 }
76 #endif
77
78 #ifdef CONFIG_STTS22H_TRIGGER
79 static int stts22h_trig_cnt;
80
stts22h_trigger_handler(const struct device * dev,const struct sensor_trigger * trig)81 static void stts22h_trigger_handler(const struct device *dev,
82 const struct sensor_trigger *trig)
83 {
84 stts22h_trig_cnt++;
85 }
86 #endif
87
lps22df_config(const struct device * lps22df)88 static void lps22df_config(const struct device *lps22df)
89 {
90 struct sensor_value odr_attr;
91
92 /* set LPS22DF sampling frequency to 50 Hz */
93 odr_attr.val1 = 50;
94 odr_attr.val2 = 0;
95
96 if (sensor_attr_set(lps22df, SENSOR_CHAN_ALL,
97 SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
98 printk("Cannot set sampling frequency for LPS22DF\n");
99 return;
100 }
101
102 #ifdef CONFIG_LPS2XDF_TRIGGER
103 struct sensor_trigger trig;
104
105 trig.type = SENSOR_TRIG_DATA_READY;
106 trig.chan = SENSOR_CHAN_ALL;
107 sensor_trigger_set(lps22df, &trig, lps22df_trigger_handler);
108 #endif
109 }
110
lsm6dsv16x_config(const struct device * lsm6dsv16x)111 static void lsm6dsv16x_config(const struct device *lsm6dsv16x)
112 {
113 struct sensor_value odr_attr, fs_attr;
114
115 /* set LSM6DSV16X accel sampling frequency to 208 Hz */
116 odr_attr.val1 = 208;
117 odr_attr.val2 = 0;
118
119 if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_ACCEL_XYZ,
120 SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
121 printk("Cannot set sampling frequency for LSM6DSV16X accel\n");
122 return;
123 }
124
125 sensor_g_to_ms2(16, &fs_attr);
126
127 if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_ACCEL_XYZ,
128 SENSOR_ATTR_FULL_SCALE, &fs_attr) < 0) {
129 printk("Cannot set fs for LSM6DSV16X accel\n");
130 return;
131 }
132
133 /* set LSM6DSV16X gyro sampling frequency to 208 Hz */
134 odr_attr.val1 = 208;
135 odr_attr.val2 = 0;
136
137 if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_GYRO_XYZ,
138 SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
139 printk("Cannot set sampling frequency for LSM6DSV16X gyro\n");
140 return;
141 }
142
143 sensor_degrees_to_rad(250, &fs_attr);
144
145 if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_GYRO_XYZ,
146 SENSOR_ATTR_FULL_SCALE, &fs_attr) < 0) {
147 printk("Cannot set fs for LSM6DSV16X gyro\n");
148 return;
149 }
150
151 #ifdef CONFIG_LSM6DSV16X_TRIGGER
152 struct sensor_trigger trig;
153
154 trig.type = SENSOR_TRIG_DATA_READY;
155 trig.chan = SENSOR_CHAN_ACCEL_XYZ;
156 sensor_trigger_set(lsm6dsv16x, &trig, lsm6dsv16x_acc_trig_handler);
157
158 trig.type = SENSOR_TRIG_DATA_READY;
159 trig.chan = SENSOR_CHAN_GYRO_XYZ;
160 sensor_trigger_set(lsm6dsv16x, &trig, lsm6dsv16x_gyr_trig_handler);
161
162 trig.type = SENSOR_TRIG_DATA_READY;
163 trig.chan = SENSOR_CHAN_DIE_TEMP;
164 sensor_trigger_set(lsm6dsv16x, &trig, lsm6dsv16x_temp_trig_handler);
165 #endif
166 }
167
lis2mdl_config(const struct device * lis2mdl)168 static void lis2mdl_config(const struct device *lis2mdl)
169 {
170 struct sensor_value odr_attr;
171
172 /* set LIS2MDL sampling frequency to 100 Hz */
173 odr_attr.val1 = 100;
174 odr_attr.val2 = 0;
175
176 if (sensor_attr_set(lis2mdl, SENSOR_CHAN_ALL,
177 SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
178 printk("Cannot set sampling frequency for LIS2MDL\n");
179 return;
180 }
181
182 #ifdef CONFIG_LIS2MDL_TRIGGER
183 struct sensor_trigger trig;
184
185 trig.type = SENSOR_TRIG_DATA_READY;
186 trig.chan = SENSOR_CHAN_MAGN_XYZ;
187 sensor_trigger_set(lis2mdl, &trig, lis2mdl_trigger_handler);
188 #endif
189 }
190
lis2du12_config(const struct device * lis2du12)191 static void lis2du12_config(const struct device *lis2du12)
192 {
193 struct sensor_value odr_attr;
194
195 /* set LIS2DU12 sampling frequency to 400 Hz */
196 odr_attr.val1 = 400;
197 odr_attr.val2 = 0;
198
199 if (sensor_attr_set(lis2du12, SENSOR_CHAN_ACCEL_XYZ,
200 SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
201 printk("Cannot set sampling frequency for LIS2DU12\n");
202 return;
203 }
204
205 #ifdef CONFIG_LIS2DU12_TRIGGER
206 struct sensor_trigger trig;
207
208 trig.type = SENSOR_TRIG_DATA_READY;
209 trig.chan = SENSOR_CHAN_ACCEL_XYZ;
210 sensor_trigger_set(lis2du12, &trig, lis2du12_trigger_handler);
211 #endif
212 }
213
stts22h_config(const struct device * stts22h)214 static void stts22h_config(const struct device *stts22h)
215 {
216 struct sensor_value odr_attr;
217
218 /* set STTS22H sampling frequency to 100 Hz */
219 odr_attr.val1 = 100;
220 odr_attr.val2 = 0;
221
222 if (sensor_attr_set(stts22h, SENSOR_CHAN_AMBIENT_TEMP,
223 SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
224 printk("Cannot set sampling frequency for STTS22H\n");
225 return;
226 }
227
228 #ifdef CONFIG_STTS22H_TRIGGER
229 struct sensor_trigger trig;
230
231 trig.type = SENSOR_TRIG_DATA_READY;
232 trig.chan = SENSOR_CHAN_AMBIENT_TEMP;
233 sensor_trigger_set(stts22h, &trig, stts22h_trigger_handler);
234 #endif
235 }
236
led_pattern_out(void)237 static int led_pattern_out(void)
238 {
239 const struct gpio_dt_spec led0_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios);
240 const struct gpio_dt_spec led1_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led1), gpios);
241 const struct gpio_dt_spec led2_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led2), gpios);
242 const struct gpio_dt_spec led3_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led3), gpios);
243 int i;
244
245 /* led 0 */
246 if (!gpio_is_ready_dt(&led0_gpio)) {
247 printk("%s: device not ready.\n", led0_gpio.port->name);
248 return -1;
249 }
250 gpio_pin_configure_dt(&led0_gpio, GPIO_OUTPUT_INACTIVE);
251
252 /* led 1 */
253 if (!gpio_is_ready_dt(&led1_gpio)) {
254 printk("%s: device not ready.\n", led1_gpio.port->name);
255 return -1;
256 }
257 gpio_pin_configure_dt(&led1_gpio, GPIO_OUTPUT_INACTIVE);
258
259 /* led 2 */
260 if (!gpio_is_ready_dt(&led2_gpio)) {
261 printk("%s: device not ready.\n", led2_gpio.port->name);
262 return -1;
263 }
264 gpio_pin_configure_dt(&led2_gpio, GPIO_OUTPUT_INACTIVE);
265
266 /* led 3 */
267 if (!gpio_is_ready_dt(&led3_gpio)) {
268 printk("%s: device not ready.\n", led3_gpio.port->name);
269 return -1;
270 }
271 gpio_pin_configure_dt(&led3_gpio, GPIO_OUTPUT_INACTIVE);
272
273 /* output led pattern */
274 for (i = 0; i < 12; i++) {
275 gpio_pin_set_dt(&led0_gpio, ((i % 4) == 0) ? 1 : 0);
276 gpio_pin_set_dt(&led1_gpio, ((i % 4) == 1) ? 1 : 0);
277 gpio_pin_set_dt(&led2_gpio, ((i % 4) == 2) ? 1 : 0);
278 gpio_pin_set_dt(&led3_gpio, ((i % 4) == 3) ? 1 : 0);
279 k_sleep(K_MSEC(100));
280 }
281
282 /* turn all leds off */
283 gpio_pin_set_dt(&led0_gpio, 0);
284 gpio_pin_set_dt(&led1_gpio, 0);
285 gpio_pin_set_dt(&led2_gpio, 0);
286 gpio_pin_set_dt(&led3_gpio, 0);
287
288 return 0;
289 }
290
main(void)291 int main(void)
292 {
293 int cnt = 1;
294
295 /* signal that sample is started */
296 if (led_pattern_out() < 0) {
297 return -1;
298 }
299
300 printk("SensorTile.box Pro sensor test\n");
301
302 const struct device *const lps22df = DEVICE_DT_GET_ONE(st_lps22df);
303 const struct device *const lsm6dsv16x = DEVICE_DT_GET_ONE(st_lsm6dsv16x);
304 const struct device *const lis2mdl = DEVICE_DT_GET_ONE(st_lis2mdl);
305 const struct device *const lis2du12 = DEVICE_DT_GET_ONE(st_lis2du12);
306 const struct device *const stts22h = DEVICE_DT_GET_ONE(st_stts22h);
307
308 if (!device_is_ready(lps22df)) {
309 printk("%s: device not ready.\n", lps22df->name);
310 return 0;
311 }
312 if (!device_is_ready(lsm6dsv16x)) {
313 printk("%s: device not ready.\n", lsm6dsv16x->name);
314 return 0;
315 }
316 if (!device_is_ready(lis2mdl)) {
317 printk("%s: device not ready.\n", lis2mdl->name);
318 return 0;
319 }
320 if (!device_is_ready(lis2du12)) {
321 printk("%s: device not ready.\n", lis2du12->name);
322 return 0;
323 }
324 if (!device_is_ready(stts22h)) {
325 printk("%s: device not ready.\n", stts22h->name);
326 return 0;
327 }
328
329 stts22h_config(stts22h);
330 lis2du12_config(lis2du12);
331 lis2mdl_config(lis2mdl);
332 lps22df_config(lps22df);
333 lsm6dsv16x_config(lsm6dsv16x);
334
335 while (1) {
336 struct sensor_value lps22df_press, lps22df_temp;
337 struct sensor_value lsm6dsv16x_accel[3], lsm6dsv16x_gyro[3];
338 struct sensor_value lis2mdl_magn[3];
339 struct sensor_value lis2mdl_temp;
340 struct sensor_value lis2du12_accel[3];
341 struct sensor_value stts22h_temp;
342
343 #ifndef CONFIG_LSM6DSV16X_TRIGGER
344 if (sensor_sample_fetch(lsm6dsv16x) < 0) {
345 printf("LSM6DSV16X Sensor sample update error\n");
346 return 0;
347 }
348 #endif
349
350 #ifndef CONFIG_LPS2XDF_TRIGGER
351 if (sensor_sample_fetch(lps22df) < 0) {
352 printf("LPS22DF Sensor sample update error\n");
353 return 0;
354 }
355 #endif
356
357 #ifndef CONFIG_LIS2MDL_TRIGGER
358 if (sensor_sample_fetch(lis2mdl) < 0) {
359 printf("LIS2MDL Magn Sensor sample update error\n");
360 return 0;
361 }
362 #endif
363
364 #ifndef CONFIG_LIS2DU12_TRIGGER
365 if (sensor_sample_fetch(lis2du12) < 0) {
366 printf("LIS2DU12 xl Sensor sample update error\n");
367 return 0;
368 }
369 #endif
370
371 #ifndef CONFIG_STTS22H_TRIGGER
372 if (sensor_sample_fetch(stts22h) < 0) {
373 printf("STTS22H Sensor sample update error\n");
374 return 0;
375 }
376 #endif
377
378 sensor_channel_get(lps22df, SENSOR_CHAN_AMBIENT_TEMP, &lps22df_temp);
379 sensor_channel_get(lps22df, SENSOR_CHAN_PRESS, &lps22df_press);
380 sensor_channel_get(lsm6dsv16x, SENSOR_CHAN_ACCEL_XYZ, lsm6dsv16x_accel);
381 sensor_channel_get(lsm6dsv16x, SENSOR_CHAN_GYRO_XYZ, lsm6dsv16x_gyro);
382 sensor_channel_get(lis2mdl, SENSOR_CHAN_MAGN_XYZ, lis2mdl_magn);
383 sensor_channel_get(lis2mdl, SENSOR_CHAN_DIE_TEMP, &lis2mdl_temp);
384 sensor_channel_get(lis2du12, SENSOR_CHAN_ACCEL_XYZ, lis2du12_accel);
385 sensor_channel_get(stts22h, SENSOR_CHAN_AMBIENT_TEMP, &stts22h_temp);
386
387 /* Display sensor data */
388
389 /* Clear terminal (ANSI ESC-C) */
390 printf("\0033\014");
391
392 printf("SensorTile.box dashboard\n\n");
393
394 /* temperature */
395 printf("LPS22DF: Temperature: %.1f C\n",
396 sensor_value_to_double(&lps22df_temp));
397
398 /* pressure */
399 printf("LPS22DF: Pressure: %.3f kpa\n",
400 sensor_value_to_double(&lps22df_press));
401
402 printf("LSM6DSV16X: Accel (m.s-2): x: %.3f, y: %.3f, z: %.3f\n",
403 sensor_value_to_double(&lsm6dsv16x_accel[0]),
404 sensor_value_to_double(&lsm6dsv16x_accel[1]),
405 sensor_value_to_double(&lsm6dsv16x_accel[2]));
406
407 printf("LSM6DSV16X: GYro (dps): x: %.3f, y: %.3f, z: %.3f\n",
408 sensor_value_to_double(&lsm6dsv16x_gyro[0]),
409 sensor_value_to_double(&lsm6dsv16x_gyro[1]),
410 sensor_value_to_double(&lsm6dsv16x_gyro[2]));
411
412 /* lis2mdl */
413 printf("LIS2MDL: Magn (gauss): x: %.3f, y: %.3f, z: %.3f\n",
414 sensor_value_to_double(&lis2mdl_magn[0]),
415 sensor_value_to_double(&lis2mdl_magn[1]),
416 sensor_value_to_double(&lis2mdl_magn[2]));
417
418 printf("LIS2MDL: Temperature: %.1f C\n",
419 sensor_value_to_double(&lis2mdl_temp));
420
421 printf("LIS2DU12: Accel (m.s-2): x: %.3f, y: %.3f, z: %.3f\n",
422 sensor_value_to_double(&lis2du12_accel[0]),
423 sensor_value_to_double(&lis2du12_accel[1]),
424 sensor_value_to_double(&lis2du12_accel[2]));
425
426 /* STTS22H temperature */
427 printf("STTS22H: Temperature: %.1f C\n",
428 sensor_value_to_double(&stts22h_temp));
429
430 #ifdef CONFIG_LPS2XDF_TRIGGER
431 printk("%d:: lps22df trig %d\n", cnt, lps22df_trig_cnt);
432 #endif
433
434 #ifdef CONFIG_LSM6DSV16X_TRIGGER
435 printk("%d:: lsm6dsv16x acc trig %d\n", cnt, lsm6dsv16x_acc_trig_cnt);
436 printk("%d:: lsm6dsv16x gyr trig %d\n", cnt, lsm6dsv16x_gyr_trig_cnt);
437 #endif
438
439 #ifdef CONFIG_LIS2MDL_TRIGGER
440 printk("%d:: lis2mdl trig %d\n", cnt, lis2mdl_trig_cnt);
441 #endif
442
443 #ifdef CONFIG_LIS2DU12_TRIGGER
444 printk("%d:: lis2du12 trig %d\n", cnt, lis2du12_trig_cnt);
445 #endif
446
447 #ifdef CONFIG_STTS22H_TRIGGER
448 printk("%d:: stts22h trig %d\n", cnt, stts22h_trig_cnt);
449 #endif
450
451 k_sleep(K_MSEC(2000));
452 }
453 }
454
