samples/boards/sensortile_box_pro/sensors-on-board/src/main.c

/*
 * Copyright (c) 2023 STMicroelectronics
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>

#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/led.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/sensor.h>

#include <stdio.h>

#ifdef CONFIG_LPS2XDF_TRIGGER
static int lps22df_trig_cnt;

static void lps22df_trigger_handler(const struct device *dev,
				    const struct sensor_trigger *trig)
{
	sensor_sample_fetch_chan(dev, SENSOR_CHAN_PRESS);
	lps22df_trig_cnt++;
}
#endif

#ifdef CONFIG_LSM6DSV16X_TRIGGER
static int lsm6dsv16x_acc_trig_cnt;
static int lsm6dsv16x_gyr_trig_cnt;
static int lsm6dsv16x_temp_trig_cnt;

static void lsm6dsv16x_acc_trig_handler(const struct device *dev,
				     const struct sensor_trigger *trig)
{
	sensor_sample_fetch_chan(dev, SENSOR_CHAN_ACCEL_XYZ);
	lsm6dsv16x_acc_trig_cnt++;
}

static void lsm6dsv16x_gyr_trig_handler(const struct device *dev,
				     const struct sensor_trigger *trig)
{
	sensor_sample_fetch_chan(dev, SENSOR_CHAN_GYRO_XYZ);
	lsm6dsv16x_gyr_trig_cnt++;
}

static void lsm6dsv16x_temp_trig_handler(const struct device *dev,
				      const struct sensor_trigger *trig)
{
	sensor_sample_fetch_chan(dev, SENSOR_CHAN_DIE_TEMP);
	lsm6dsv16x_temp_trig_cnt++;
}
#endif

#ifdef CONFIG_LIS2MDL_TRIGGER
static int lis2mdl_trig_cnt;

static void lis2mdl_trigger_handler(const struct device *dev,
				    const struct sensor_trigger *trig)
{
	sensor_sample_fetch_chan(dev, SENSOR_CHAN_ALL);
	lis2mdl_trig_cnt++;
}
#endif

#ifdef CONFIG_LIS2DU12_TRIGGER
static int lis2du12_trig_cnt;

static void lis2du12_trigger_handler(const struct device *dev,
				    const struct sensor_trigger *trig)
{
	sensor_sample_fetch_chan(dev, SENSOR_CHAN_ALL);
	lis2du12_trig_cnt++;
}
#endif

#ifdef CONFIG_STTS22H_TRIGGER
static int stts22h_trig_cnt;

static void stts22h_trigger_handler(const struct device *dev,
				    const struct sensor_trigger *trig)
{
	stts22h_trig_cnt++;
}
#endif

static void lps22df_config(const struct device *lps22df)
{
	struct sensor_value odr_attr;

	/* set LPS22DF sampling frequency to 50 Hz */
	odr_attr.val1 = 50;
	odr_attr.val2 = 0;

	if (sensor_attr_set(lps22df, SENSOR_CHAN_ALL,
			    SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
		printk("Cannot set sampling frequency for LPS22DF\n");
		return;
	}

#ifdef CONFIG_LPS2XDF_TRIGGER
	struct sensor_trigger trig;

	trig.type = SENSOR_TRIG_DATA_READY;
	trig.chan = SENSOR_CHAN_ALL;
	sensor_trigger_set(lps22df, &trig, lps22df_trigger_handler);
#endif
}

static void lsm6dsv16x_config(const struct device *lsm6dsv16x)
{
	struct sensor_value odr_attr, fs_attr;

	/* set LSM6DSV16X accel sampling frequency to 208 Hz */
	odr_attr.val1 = 208;
	odr_attr.val2 = 0;

	if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_ACCEL_XYZ,
			    SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
		printk("Cannot set sampling frequency for LSM6DSV16X accel\n");
		return;
	}

	sensor_g_to_ms2(16, &fs_attr);

	if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_ACCEL_XYZ,
			    SENSOR_ATTR_FULL_SCALE, &fs_attr) < 0) {
		printk("Cannot set fs for LSM6DSV16X accel\n");
		return;
	}

	/* set LSM6DSV16X gyro sampling frequency to 208 Hz */
	odr_attr.val1 = 208;
	odr_attr.val2 = 0;

	if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_GYRO_XYZ,
			    SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
		printk("Cannot set sampling frequency for LSM6DSV16X gyro\n");
		return;
	}

	sensor_degrees_to_rad(250, &fs_attr);

	if (sensor_attr_set(lsm6dsv16x, SENSOR_CHAN_GYRO_XYZ,
			    SENSOR_ATTR_FULL_SCALE, &fs_attr) < 0) {
		printk("Cannot set fs for LSM6DSV16X gyro\n");
		return;
	}

#ifdef CONFIG_LSM6DSV16X_TRIGGER
	struct sensor_trigger trig;

	trig.type = SENSOR_TRIG_DATA_READY;
	trig.chan = SENSOR_CHAN_ACCEL_XYZ;
	sensor_trigger_set(lsm6dsv16x, &trig, lsm6dsv16x_acc_trig_handler);

	trig.type = SENSOR_TRIG_DATA_READY;
	trig.chan = SENSOR_CHAN_GYRO_XYZ;
	sensor_trigger_set(lsm6dsv16x, &trig, lsm6dsv16x_gyr_trig_handler);

	trig.type = SENSOR_TRIG_DATA_READY;
	trig.chan = SENSOR_CHAN_DIE_TEMP;
	sensor_trigger_set(lsm6dsv16x, &trig, lsm6dsv16x_temp_trig_handler);
#endif
}

static void lis2mdl_config(const struct device *lis2mdl)
{
	struct sensor_value odr_attr;

	/* set LIS2MDL sampling frequency to 100 Hz */
	odr_attr.val1 = 100;
	odr_attr.val2 = 0;

	if (sensor_attr_set(lis2mdl, SENSOR_CHAN_ALL,
			    SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
		printk("Cannot set sampling frequency for LIS2MDL\n");
		return;
	}

#ifdef CONFIG_LIS2MDL_TRIGGER
	struct sensor_trigger trig;

	trig.type = SENSOR_TRIG_DATA_READY;
	trig.chan = SENSOR_CHAN_MAGN_XYZ;
	sensor_trigger_set(lis2mdl, &trig, lis2mdl_trigger_handler);
#endif
}

static void lis2du12_config(const struct device *lis2du12)
{
	struct sensor_value odr_attr;

	/* set LIS2DU12 sampling frequency to 400 Hz */
	odr_attr.val1 = 400;
	odr_attr.val2 = 0;

	if (sensor_attr_set(lis2du12, SENSOR_CHAN_ACCEL_XYZ,
			    SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
		printk("Cannot set sampling frequency for LIS2DU12\n");
		return;
	}

#ifdef CONFIG_LIS2DU12_TRIGGER
	struct sensor_trigger trig;

	trig.type = SENSOR_TRIG_DATA_READY;
	trig.chan = SENSOR_CHAN_ACCEL_XYZ;
	sensor_trigger_set(lis2du12, &trig, lis2du12_trigger_handler);
#endif
}

static void stts22h_config(const struct device *stts22h)
{
	struct sensor_value odr_attr;

	/* set STTS22H sampling frequency to 100 Hz */
	odr_attr.val1 = 100;
	odr_attr.val2 = 0;

	if (sensor_attr_set(stts22h, SENSOR_CHAN_AMBIENT_TEMP,
			    SENSOR_ATTR_SAMPLING_FREQUENCY, &odr_attr) < 0) {
		printk("Cannot set sampling frequency for STTS22H\n");
		return;
	}

#ifdef CONFIG_STTS22H_TRIGGER
	struct sensor_trigger trig;

	trig.type = SENSOR_TRIG_DATA_READY;
	trig.chan = SENSOR_CHAN_AMBIENT_TEMP;
	sensor_trigger_set(stts22h, &trig, stts22h_trigger_handler);
#endif
}

static int led_pattern_out(void)
{
	const struct gpio_dt_spec led0_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios);
	const struct gpio_dt_spec led1_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led1), gpios);
	const struct gpio_dt_spec led2_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led2), gpios);
	const struct gpio_dt_spec led3_gpio = GPIO_DT_SPEC_GET(DT_ALIAS(led3), gpios);
	int i;

	/* led 0 */
	if (!gpio_is_ready_dt(&led0_gpio)) {
		printk("%s: device not ready.\n", led0_gpio.port->name);
		return -1;
	}
	gpio_pin_configure_dt(&led0_gpio, GPIO_OUTPUT_INACTIVE);

	/* led 1 */
	if (!gpio_is_ready_dt(&led1_gpio)) {
		printk("%s: device not ready.\n", led1_gpio.port->name);
		return -1;
	}
	gpio_pin_configure_dt(&led1_gpio, GPIO_OUTPUT_INACTIVE);

	/* led 2 */
	if (!gpio_is_ready_dt(&led2_gpio)) {
		printk("%s: device not ready.\n", led2_gpio.port->name);
		return -1;
	}
	gpio_pin_configure_dt(&led2_gpio, GPIO_OUTPUT_INACTIVE);

	/* led 3 */
	if (!gpio_is_ready_dt(&led3_gpio)) {
		printk("%s: device not ready.\n", led3_gpio.port->name);
		return -1;
	}
	gpio_pin_configure_dt(&led3_gpio, GPIO_OUTPUT_INACTIVE);

	/* output led pattern */
	for (i = 0; i < 12; i++) {
		gpio_pin_set_dt(&led0_gpio, ((i % 4) == 0) ? 1 : 0);
		gpio_pin_set_dt(&led1_gpio, ((i % 4) == 1) ? 1 : 0);
		gpio_pin_set_dt(&led2_gpio, ((i % 4) == 2) ? 1 : 0);
		gpio_pin_set_dt(&led3_gpio, ((i % 4) == 3) ? 1 : 0);
		k_sleep(K_MSEC(100));
	}

	/* turn all leds off */
	gpio_pin_set_dt(&led0_gpio, 0);
	gpio_pin_set_dt(&led1_gpio, 0);
	gpio_pin_set_dt(&led2_gpio, 0);
	gpio_pin_set_dt(&led3_gpio, 0);

	return 0;
}

int main(void)
{
	int cnt = 1;

	/* signal that sample is started */
	if (led_pattern_out() < 0) {
		return -1;
	}

	printk("SensorTile.box Pro sensor test\n");

	const struct device *const hts221 = DEVICE_DT_GET_ONE(st_hts221);
	const struct device *const lps22df = DEVICE_DT_GET_ONE(st_lps22df);
	const struct device *const lsm6dsv16x = DEVICE_DT_GET_ONE(st_lsm6dsv16x);
	const struct device *const lis2mdl = DEVICE_DT_GET_ONE(st_lis2mdl);
	const struct device *const lis2du12 = DEVICE_DT_GET_ONE(st_lis2du12);
	const struct device *const stts22h = DEVICE_DT_GET_ONE(st_stts22h);

	if (!device_is_ready(hts221)) {
		printk("%s: device not ready.\n", hts221->name);
		return 0;
	}
	if (!device_is_ready(lps22df)) {
		printk("%s: device not ready.\n", lps22df->name);
		return 0;
	}
	if (!device_is_ready(lsm6dsv16x)) {
		printk("%s: device not ready.\n", lsm6dsv16x->name);
		return 0;
	}
	if (!device_is_ready(lis2mdl)) {
		printk("%s: device not ready.\n", lis2mdl->name);
		return 0;
	}
	if (!device_is_ready(lis2du12)) {
		printk("%s: device not ready.\n", lis2du12->name);
		return 0;
	}
	if (!device_is_ready(stts22h)) {
		printk("%s: device not ready.\n", stts22h->name);
		return 0;
	}

	stts22h_config(stts22h);
	lis2du12_config(lis2du12);
	lis2mdl_config(lis2mdl);
	lps22df_config(lps22df);
	lsm6dsv16x_config(lsm6dsv16x);

	while (1) {
		struct sensor_value hts221_hum, hts221_temp;
		struct sensor_value lps22df_press, lps22df_temp;
		struct sensor_value lsm6dsv16x_accel[3], lsm6dsv16x_gyro[3];
		struct sensor_value lis2mdl_magn[3];
		struct sensor_value lis2mdl_temp;
		struct sensor_value lis2du12_accel[3];
		struct sensor_value stts22h_temp;

		/* handle HTS221 sensor */
		if (sensor_sample_fetch(hts221) < 0) {
			printf("HTS221 Sensor sample update error\n");
			return 0;
		}

#ifndef CONFIG_LSM6DSV16X_TRIGGER
		if (sensor_sample_fetch(lsm6dsv16x) < 0) {
			printf("LSM6DSV16X Sensor sample update error\n");
			return 0;
		}
#endif

#ifndef CONFIG_LPS2XDF_TRIGGER
		if (sensor_sample_fetch(lps22df) < 0) {
			printf("LPS22DF Sensor sample update error\n");
			return 0;
		}
#endif

#ifndef CONFIG_LIS2MDL_TRIGGER
		if (sensor_sample_fetch(lis2mdl) < 0) {
			printf("LIS2MDL Magn Sensor sample update error\n");
			return 0;
		}
#endif

#ifndef CONFIG_LIS2DU12_TRIGGER
		if (sensor_sample_fetch(lis2du12) < 0) {
			printf("LIS2DU12 xl Sensor sample update error\n");
			return 0;
		}
#endif

#ifndef CONFIG_STTS22H_TRIGGER
		if (sensor_sample_fetch(stts22h) < 0) {
			printf("STTS22H Sensor sample update error\n");
			return 0;
		}
#endif

		sensor_channel_get(hts221, SENSOR_CHAN_HUMIDITY, &hts221_hum);
		sensor_channel_get(hts221, SENSOR_CHAN_AMBIENT_TEMP, &hts221_temp);
		sensor_channel_get(lps22df, SENSOR_CHAN_AMBIENT_TEMP, &lps22df_temp);
		sensor_channel_get(lps22df, SENSOR_CHAN_PRESS, &lps22df_press);
		sensor_channel_get(lsm6dsv16x, SENSOR_CHAN_ACCEL_XYZ, lsm6dsv16x_accel);
		sensor_channel_get(lsm6dsv16x, SENSOR_CHAN_GYRO_XYZ, lsm6dsv16x_gyro);
		sensor_channel_get(lis2mdl, SENSOR_CHAN_MAGN_XYZ, lis2mdl_magn);
		sensor_channel_get(lis2mdl, SENSOR_CHAN_DIE_TEMP, &lis2mdl_temp);
		sensor_channel_get(lis2du12, SENSOR_CHAN_ACCEL_XYZ, lis2du12_accel);
		sensor_channel_get(stts22h, SENSOR_CHAN_AMBIENT_TEMP, &stts22h_temp);

		/* Display sensor data */

		/*  Clear terminal (ANSI ESC-C) */
		printf("\0033\014");

		printf("SensorTile.box dashboard\n\n");

		/* HTS221 temperature */
		printf("HTS221: Temperature: %.1f C\n",
		       sensor_value_to_double(&hts221_temp));

		/* HTS221 humidity */
		printf("HTS221: Relative Humidity: %.1f%%\n",
		       sensor_value_to_double(&hts221_hum));

		/* temperature */
		printf("LPS22DF: Temperature: %.1f C\n",
		       sensor_value_to_double(&lps22df_temp));

		/* pressure */
		printf("LPS22DF: Pressure: %.3f kpa\n",
		       sensor_value_to_double(&lps22df_press));

		printf("LSM6DSV16X: Accel (m.s-2): x: %.3f, y: %.3f, z: %.3f\n",
			sensor_value_to_double(&lsm6dsv16x_accel[0]),
			sensor_value_to_double(&lsm6dsv16x_accel[1]),
			sensor_value_to_double(&lsm6dsv16x_accel[2]));

		printf("LSM6DSV16X: GYro (dps): x: %.3f, y: %.3f, z: %.3f\n",
			sensor_value_to_double(&lsm6dsv16x_gyro[0]),
			sensor_value_to_double(&lsm6dsv16x_gyro[1]),
			sensor_value_to_double(&lsm6dsv16x_gyro[2]));

		/* lis2mdl */
		printf("LIS2MDL: Magn (gauss): x: %.3f, y: %.3f, z: %.3f\n",
		       sensor_value_to_double(&lis2mdl_magn[0]),
		       sensor_value_to_double(&lis2mdl_magn[1]),
		       sensor_value_to_double(&lis2mdl_magn[2]));

		printf("LIS2MDL: Temperature: %.1f C\n",
		       sensor_value_to_double(&lis2mdl_temp));

		printf("LIS2DU12: Accel (m.s-2): x: %.3f, y: %.3f, z: %.3f\n",
			sensor_value_to_double(&lis2du12_accel[0]),
			sensor_value_to_double(&lis2du12_accel[1]),
			sensor_value_to_double(&lis2du12_accel[2]));

		/* STTS22H temperature */
		printf("STTS22H: Temperature: %.1f C\n",
		       sensor_value_to_double(&stts22h_temp));

#ifdef CONFIG_LPS2XDF_TRIGGER
		printk("%d:: lps22df trig %d\n", cnt, lps22df_trig_cnt);
#endif

#ifdef CONFIG_LSM6DSV16X_TRIGGER
		printk("%d:: lsm6dsv16x acc trig %d\n", cnt, lsm6dsv16x_acc_trig_cnt);
		printk("%d:: lsm6dsv16x gyr trig %d\n", cnt, lsm6dsv16x_gyr_trig_cnt);
#endif

#ifdef CONFIG_LIS2MDL_TRIGGER
		printk("%d:: lis2mdl trig %d\n", cnt, lis2mdl_trig_cnt);
#endif

#ifdef CONFIG_LIS2DU12_TRIGGER
		printk("%d:: lis2du12 trig %d\n", cnt, lis2du12_trig_cnt);
#endif

#ifdef CONFIG_STTS22H_TRIGGER
		printk("%d:: stts22h trig %d\n", cnt, stts22h_trig_cnt);
#endif

		k_sleep(K_MSEC(2000));
	}
}