ghu sensing upstream pr3

dts/bindings/sensor/zephyr,sensing-hinge-angle.yaml

@@ -0,0 +1,10 @@
+# Copyright (c) 2023, Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+description: Sensing subsystem hinge angle sensor bindings.
+
+compatible: "zephyr,sensing-hinge-angle"
+
+# Common sensor subsystem sensor properties.
+include: ["zephyr,sensing-sensor.yaml"]

include/zephyr/sensing/sensing.h

@@ -72,6 +72,11 @@ struct sensing_sensor_version {
  */
 #define SENSING_SENSOR_FLAG_REPORT_ON_CHANGE			BIT(1)
 
+/**
+ * @brief SENSING_SENSITIVITY_INDEX_ALL indicating sensitivity of each data field should be set
+ *
+ */
+#define SENSING_SENSITIVITY_INDEX_ALL -1
 
 /**
  * @brief Sensing subsystem sensor state.
@@ -151,8 +156,12 @@ struct sensing_callback_list {
  *
  */
 struct sensing_sensor_config {
+
 	enum sensing_sensor_attribute attri;
+
+	/** \ref SENSING_SENSITIVITY_INDEX_ALL */
 	int8_t data_field;
+
 	union {
 		uint32_t interval;
 		uint32_t sensitivity;

include/zephyr/sensing/sensing_datatypes.h

@@ -99,8 +99,8 @@ struct sensing_sensor_value_uint32 {
  * q31 version
  */
 struct sensing_sensor_value_q31 {
-	int8_t shift;
 	struct sensing_sensor_value_header header;
+	int8_t shift;
 	struct {
 		uint32_t timestamp_delta;
 		q31_t v;

include/zephyr/sensing/sensing_sensor.h

@@ -313,7 +313,7 @@ typedef int (*sensing_sensor_read_sample_t)(
  *
  * @param dev The sensor instance device structure.
  *
- * @param reporter The reporter handle who delivered this sensor data
+ * @param reporter_handle The reporter handle who delivered this sensor data
  *
  * @param buf The buffer stored the reporter's sensor data.
  *
@@ -324,7 +324,7 @@ typedef int (*sensing_sensor_read_sample_t)(
  */
 typedef int (*sensing_sensor_process_t)(
 		const struct device *dev,
-		int reporter,
+		const sensing_sensor_handle_t reporter_handle,
 		void *buf, int size);
 
 /**

samples/subsys/sensing/simple/boards/native_posix.overlay

@@ -41,5 +41,14 @@
 			minimal-interval = <625>;
 			underlying-device = <&bmi160_spi>;
 		};
+
+		hinge_angle: hinge-angle {
+			compatible = "zephyr,sensing-hinge-angle";
+			status = "okay";
+			sensor-type = <0x20B>;
+			friendly-name = "Hinge Angle Sensor";
+			reporters = <&base_accel &lid_accel>;
+			minimal-interval = <100000>;
+		};
 	};
 };

samples/subsys/sensing/simple/src/main.c

@@ -5,6 +5,7 @@
  */
 
 #include <zephyr/device.h>
+#include <zephyr/kernel.h>
 #include <zephyr/devicetree.h>
 #include <zephyr/logging/log.h>
 #include <zephyr/sys_clock.h>
@@ -24,6 +25,15 @@ static void acc_data_event_callback(sensing_sensor_handle_t handle, const void *
 		sample->readings[0].z);
 }
 
+
+static void hinge_angle_data_event_callback(sensing_sensor_handle_t handle, const void *buf)
+{
+	const struct sensing_sensor_info *info = sensing_get_sensor_info(handle);
+	struct sensing_sensor_value_q31 *sample = (struct sensing_sensor_value_q31 *)buf;
+
+	LOG_INF("handle:%p, Sensor:%s data:(v:%d)", handle, info->name, sample->readings[0].v);
+}
+
 void main(void)
 {
 	const struct sensing_callback_list base_acc_cb_list = {
@@ -32,9 +42,17 @@ void main(void)
 	const struct sensing_callback_list lid_acc_cb_list = {
 		.on_data_event = &acc_data_event_callback,
 	};
+	const struct sensing_callback_list hinge_angle_cb_list = {
+		.on_data_event = &hinge_angle_data_event_callback,
+	};
 	const struct sensing_sensor_info *info;
 	sensing_sensor_handle_t base_acc;
 	sensing_sensor_handle_t lid_acc;
+	sensing_sensor_handle_t hinge_angle;
+	struct sensing_sensor_config base_acc_config;
+	struct sensing_sensor_config lid_acc_config;
+	struct sensing_sensor_config hinge_angle_config;
+	const struct sensing_sensor_info *tmp_sensor_info;
 	int ret, i, num = 0;
 
 	ret = sensing_get_sensors(&num, &info);
@@ -44,7 +62,7 @@ void main(void)
 	}
 
 	for (i = 0; i < num; ++i) {
-		LOG_INF("Sensor %d: name: %s friendly_name: %s type: %d",
+		LOG_INF("Sensor %d: name: %s friendly_name: %s, type: %d",
 			 i,
 			 info[i].name,
 			 info[i].friendly_name,
@@ -63,17 +81,113 @@ void main(void)
 					&lid_acc_cb_list,
 					&lid_acc);
 	if (ret) {
-		LOG_ERR("sensing_open_sensor, type:0x%x index:1 error:%d",
+		LOG_ERR("sensing_open_sensor_by_dt, type:0x%x index:1 error:%d",
 			SENSING_SENSOR_TYPE_MOTION_ACCELEROMETER_3D, ret);
 	}
+	ret = sensing_open_sensor_by_dt(DEVICE_DT_GET(DT_NODELABEL(hinge_angle)),
+					&hinge_angle_cb_list,
+					&hinge_angle);
+	if (ret) {
+		LOG_ERR("sensing_open_sensor_by_type, type:0x%x index:0 error:%d",
+			SENSING_SENSOR_TYPE_MOTION_HINGE_ANGLE, ret);
+	}
+
+	/* set base acc, lid acc, hinge sensor interval */
+	base_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_INTERVAL;
+	base_acc_config.interval = 100 * USEC_PER_MSEC;
+	ret = sensing_set_config(base_acc, &base_acc_config, 1);
+	if (ret) {
+		LOG_ERR("base_acc sensing_set_interval error:%d\n", ret);
+	}
+
+	lid_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_INTERVAL;
+	lid_acc_config.interval = 100 * USEC_PER_MSEC;
+	ret = sensing_set_config(lid_acc, &lid_acc_config, 1);
+	if (ret) {
+		LOG_ERR("lid_acc sensing_set_interval error:%d\n", ret);
+	}
+
+	tmp_sensor_info = sensing_get_sensor_info(hinge_angle);
+	hinge_angle_config.attri = SENSING_SENSOR_ATTRIBUTE_INTERVAL;
+	hinge_angle_config.interval = tmp_sensor_info->minimal_interval;
+	ret = sensing_set_config(hinge_angle, &hinge_angle_config, 1);
+	if (ret) {
+		LOG_ERR("hinge_angle sensing_set_interval error:%d\n", ret);
+	}
+
+	memset(&base_acc_config, 0x00, sizeof(struct sensing_sensor_config));
+	memset(&lid_acc_config, 0x00, sizeof(struct sensing_sensor_config));
+	memset(&hinge_angle_config, 0x00, sizeof(struct sensing_sensor_config));
+
+	/* get base acc, lid acc, hinge sensor interval */
+	base_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_INTERVAL;
+	ret = sensing_get_config(base_acc, &base_acc_config, 1);
+	if (ret) {
+		LOG_ERR("base_acc sensing_get_interval error:%d\n", ret);
+	}
+
+	lid_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_INTERVAL;
+	ret = sensing_get_config(lid_acc, &lid_acc_config, 1);
+	if (ret) {
+		LOG_ERR("lid_acc sensing_get_interval error:%d\n", ret);
+	}
 
-	ret = sensing_close_sensor(&base_acc);
+	hinge_angle_config.attri = SENSING_SENSOR_ATTRIBUTE_INTERVAL;
+	ret = sensing_get_config(hinge_angle, &hinge_angle_config, 1);
 	if (ret) {
-		LOG_ERR("sensing_close_sensor:%p error:%d", base_acc, ret);
+		LOG_ERR("hinge_angle sensing_get_interval error:%d\n", ret);
 	}
 
-	ret = sensing_close_sensor(&lid_acc);
+	/* set base acc, lid acc, hinge sensor sensitivity */
+	base_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_SENSITIVITY;
+	base_acc_config.data_field = SENSING_SENSITIVITY_INDEX_ALL;
+	base_acc_config.sensitivity = 0;
+	ret = sensing_set_config(base_acc, &base_acc_config, 1);
 	if (ret) {
-		LOG_ERR("sensing_close_sensor:%p error:%d", lid_acc, ret);
+		LOG_ERR("base_acc sensing_set_sensitivity error:%d\n", ret);
 	}
+
+	lid_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_SENSITIVITY;
+	lid_acc_config.data_field = SENSING_SENSITIVITY_INDEX_ALL;
+	lid_acc_config.sensitivity = 0;
+	ret = sensing_set_config(lid_acc, &lid_acc_config, 1);
+	if (ret) {
+		LOG_ERR("lid_acc sensing_set_sensitivity error:%d\n", ret);
+	}
+
+	hinge_angle_config.attri = SENSING_SENSOR_ATTRIBUTE_SENSITIVITY;
+	hinge_angle_config.data_field = SENSING_SENSITIVITY_INDEX_ALL;
+	hinge_angle_config.sensitivity = 1;
+	ret = sensing_set_config(hinge_angle, &hinge_angle_config, 1);
+	if (ret) {
+		LOG_ERR("hinge_angle sensing_set_sensitivity error:%d\n", ret);
+	}
+
+	memset(&base_acc_config, 0x00, sizeof(struct sensing_sensor_config));
+	memset(&lid_acc_config, 0x00, sizeof(struct sensing_sensor_config));
+	memset(&hinge_angle_config, 0x00, sizeof(struct sensing_sensor_config));
+
+	/* get base acc, lid acc, hinge sensor sensitivity */
+	base_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_SENSITIVITY;
+	base_acc_config.data_field = SENSING_SENSITIVITY_INDEX_ALL;
+	ret = sensing_get_config(base_acc, &base_acc_config, 1);
+	if (ret) {
+		LOG_ERR("base_acc sensing_get_sensitivity error:%d\n", ret);
+	}
+
+	lid_acc_config.attri = SENSING_SENSOR_ATTRIBUTE_SENSITIVITY;
+	lid_acc_config.data_field = SENSING_SENSITIVITY_INDEX_ALL;
+	ret = sensing_get_config(lid_acc, &lid_acc_config, 1);
+	if (ret) {
+		LOG_ERR("lid_acc sensing_get_sensitivity error:%d\n", ret);
+	}
+
+	hinge_angle_config.attri = SENSING_SENSOR_ATTRIBUTE_SENSITIVITY;
+	hinge_angle_config.data_field = SENSING_SENSITIVITY_INDEX_ALL;
+	ret = sensing_get_config(hinge_angle, &hinge_angle_config, 1);
+	if (ret) {
+		LOG_ERR("hinge_angle sensing_get_sensitivity error:%d\n", ret);
+	}
+
+	k_sleep(K_MSEC(10));
 }

subsys/sensing/CMakeLists.txt

@@ -5,8 +5,10 @@ zephyr_library_include_directories(include)
 
 zephyr_library_sources(
 	sensor_mgmt.c
+	runtime.c
 	sensing.c
 	sensing_sensor.c
 )
 
 add_subdirectory_ifdef(CONFIG_SENSING_SENSOR_PHY_3D_SENSOR sensor/phy_3d_sensor)
+add_subdirectory_ifdef(CONFIG_SENSING_SENSOR_HINGE_ANGLE sensor/hinge_angle)

subsys/sensing/Kconfig

@@ -5,6 +5,7 @@ config SENSING
 	bool "Sensing Subsystem"
 	default y
 	depends on DT_HAS_ZEPHYR_SENSING_ENABLED
+	select RING_BUFFER
 	help
 	  Enable Sensing Subsystem.
 
@@ -24,6 +25,67 @@ config SENSING_MAX_SENSITIVITY_COUNT
 	  So, maximum sensitivity count is needed for sensors
 	  Typical values are 6
 
+config SENSING_RING_BUF_SIZE
+	int "ring buf size to store sensor data"
+	depends on SENSING
+	default 16384
+	help
+	  This is the ring buffer to store sensor data that
+	  will be posted to application
+	  Typical values are 16 * 1024
+
+config SENSING_MAX_SENSOR_DATA_SIZE
+	int "maximum sensor data size"
+	depends on SENSING
+	default 64
+	help
+	  This is the maximum sensor data size sensing subsystem could support
+	  when sensor is posting data to client, sensing subsystem would
+	  get no more than SENSING_MAX_SENSOR_DATA_SIZE sensor count from ring buffer
+	  Typical values are 64
+
+config SENSING_RUNTIME_THREAD_STACK_SIZE
+	int "stack size for sensing subsystem runtime thread"
+	depends on SENSING
+	default 4096
+	help
+	  This is the stack size for sensing subsystem runtime thread
+	  Typical values are 4096
+
+config SENSING_DISPATCH_THREAD_STACK_SIZE
+	int "stack size for sensor dispatch thread"
+	depends on SENSING
+	default 1024
+	help
+	  This is the stack size for sensor dispatch thread
+	  Typical values are 1024
+
+config SENSING_RUNTIME_THREAD_PRIORITY
+	int "priority for sensing subsystem runtime thread"
+	depends on SENSING
+	default 9
+	help
+	  This is the thread priority for sensor subsystem runtime thread
+	  Ring buffer data is stored by runtime thread, and then give semaphore
+	  to notify dispatch thread, runtime thread priority should lower than
+	  dispatch thread priority to ensure dispatch thread could fetch data as
+	  soon as runtime thread give semaphore. Take for example, if runtime
+	  priority is higher than dispatch thread, and runtime running in full
+	  loading with no sleep, then dispatch thread has no change to fetch
+	  data, then ring buf will always be put into data until overflow.
+	  Typical values are 9
+
+config SENSING_DISPATCH_THREAD_PRIORITY
+	  int "priority for sensor dispatch thread"
+	  depends on SENSING
+	  default 8
+	  help
+	    This is the thread priority for sensing subsystem dispatch thread
+	    Ring buffer data should be fetched ASAP, so Dispatch
+	    thread priority should be higher than runtime thread
+	    Typical values are 8
+
 source "subsys/sensing/sensor/phy_3d_sensor/Kconfig"
+source "subsys/sensing/sensor/hinge_angle/Kconfig"
 
 endif # SENSING