Health Monitor - WIP

Author: rob-robinson-14

soc/nordic/nrf54l/CMakeLists.txt

@@ -7,6 +7,8 @@ zephyr_library_sources(
   )
 zephyr_include_directories(.)
 
+add_subdirectory_ifdef(CONFIG_SOC_HEALTH_MONITORING health_monitoring_nrfx)
+
 dt_nodelabel(kmu_push_area_node NODELABEL nrf_kmu_reserved_push_area)
 
 # We need a buffer in memory in a static location which can be used by

soc/nordic/nrf54l/Kconfig

@@ -107,4 +107,12 @@ config SOC_NRF54L_ANOMALY_56_WORKAROUND
 	help
 	   This option enables configuration workaround 56 for nRF54L Series SoCs.
 
+config VBAT_MONITOR_ENABLE
+	bool "Enable VBAT monitoring"
+	select  SOC_HEALTH_MONITORING
+
+config VINTERNAL_MONITOR_ENABLE
+	bool "Enable VInternal monitoring"
+	select  SOC_HEALTH_MONITORING
+
 endif # SOC_SERIES_NRF54L

soc/nordic/nrf54l/Kconfig.defconfig

@@ -6,6 +6,7 @@
 if SOC_SERIES_NRF54L
 
 rsource "Kconfig.defconfig.nrf54l*"
+rsource "health_monitoring_nrfx/Kconfig"
 
 if ARM
 

soc/nordic/nrf54l/health_monitoring/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright (c) 2026 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+zephyr_library_sources(health_monitoring.c)
+zephyr_include_directories(.)
+
+# if(CONFIG_VBAT_MONITOR_ENABLE)
+set(EXTRA_DTC_OVERLAY_FILE "vbatt_monitor.overlay")
+# endif()
+
+if(CONFIG_VINTERNAL_MONITOR_ENABLE)
+  set(EXTRA_DTC_OVERLAY_FILE "v_internal_monitor.overlay")
+endif()
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})

soc/nordic/nrf54l/health_monitoring/Kconfig

@@ -0,0 +1,62 @@
+# Nordic Semiconductor nRF71 MCU line
+
+# Copyright (c) 2025 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+config VBAT_MONITOR_ENABLE
+	bool "Enable VBAT monitoring"
+	select  SOC_HEALTH_MONITORING
+
+config VINTERNAL_MONITOR_ENABLE
+	bool "Enable VInternal monitoring"
+	select  SOC_HEALTH_MONITORING
+
+config SOC_HEALTH_MONITORING
+    bool "Enable health monitoring system"
+	default n
+    select ADC
+	select SOC_LATE_INIT_HOOK
+	# Debug
+	select SHELL
+	select KERNEL_SHELL
+    help
+      Enable periodic VBAT voltage monitoring using SAADC.
+      When enabled, the application will periodically measure
+      the battery voltage and trigger a callback if it falls
+      below the configured threshold.
+
+
+if SOC_HEALTH_MONITORING
+
+config VBAT_MONITOR_INTERVAL_MS
+	int "VBAT measurement interval (milliseconds)"
+	default 2000
+	range 100 3600000
+	help
+	  Interval between VBAT measurements in milliseconds.
+	  Minimum: 100 ms
+	  Maximum: 3600000 ms (1 hour)
+
+config VBAT_MONITOR_LOWER_THRESHOLD_MV
+	int "VBAT low threshold (millivolts)"
+	default 250
+	range 200 5000
+	help
+	  Battery voltage threshold in millivolts. When the measured
+	  voltage falls below this value, the low battery callback
+	  will be triggered.
+	  Typical range: 2000-5000 mV
+
+config HEALTH_MONITOR_LOG_LEVEL
+	int "Health monitor log level"
+	default 3
+	range 0 4
+	help
+	  Log level for health monitor module:
+	  0 = OFF
+	  1 = ERROR
+	  2 = WARN
+	  3 = INFO
+	  4 = DEBUG
+
+endif # VBAT_MONITOR_ENABLE

soc/nordic/nrf54l/health_monitoring/health_monitoring.c

@@ -0,0 +1,177 @@
+/*
+ * ADC measurement sample with work queue.
+ *
+ * - Performs an ADC measurement in a work queue item scheduled every 5 seconds.
+ * - Updates a global variable with the latest ADC value (raw and millivolts).
+ * - If the ADC value (mV) is below a configured threshold, triggers a
+ *   low-threshold callback (e.g. for alert/interrupt handling).
+ * - After each measurement, schedules the same work again to repeat.
+ */
+
+#include <zephyr/device.h>
+#include <zephyr/kernel.h>
+#include <zephyr/devicetree.h>
+#include <zephyr/drivers/adc.h>
+#include <zephyr/sys/printk.h>
+
+#if !DT_NODE_EXISTS(DT_PATH(zephyr_user)) || \
+	!DT_NODE_HAS_PROP(DT_PATH(zephyr_user), io_channels)
+#error "No suitable devicetree overlay specified"
+#endif
+
+#define DT_SPEC_AND_COMMA(node_id, prop, idx) \
+	ADC_DT_SPEC_GET_BY_IDX(node_id, idx),
+
+/* Data of ADC io-channels specified in devicetree. */
+static const struct adc_dt_spec adc_channels[] = {
+	DT_FOREACH_PROP_ELEM(DT_PATH(zephyr_user), io_channels,
+			     DT_SPEC_AND_COMMA)
+};
+
+/* Delay between measurements */
+#define MEASUREMENT_INTERVAL_SEC 5
+
+/* Threshold in millivolts: trigger callback when ADC (mV) is below this */
+#define ADC_LOW_THRESHOLD_MV 1500
+
+/** Global variable: latest ADC value in millivolts (updated by work item). */
+volatile int32_t g_adc_value_mv;
+
+/** Global variable: latest raw ADC value (updated by work item). */
+volatile int32_t g_adc_value_raw;
+
+/** Set when ADC value is below threshold (can be used like an interrupt flag). */
+volatile bool g_adc_below_threshold;
+
+/** Optional: count how many times low threshold was triggered. */
+volatile uint32_t g_adc_low_trigger_count;
+
+static int32_t adc_buffer;
+static struct adc_sequence sequence = {
+	.buffer = &adc_buffer,
+	.buffer_size = sizeof(adc_buffer),
+#if CONFIG_SAMPLE_ADC_CALIBRATE_REQUIRED
+    .calibrate = true,
+#endif
+};
+
+static void adc_work_handler(struct k_work *work);
+
+K_WORK_DELAYABLE_DEFINE(adc_work, adc_work_handler);
+
+/**
+ * Called when ADC value is below threshold (treat as software "interrupt" handler).
+ * Can be extended to set a GPIO, wake a thread, or raise a poll signal.
+ */
+static void adc_low_threshold_trigger(void)
+{
+	g_adc_below_threshold = true;
+	g_adc_low_trigger_count++;
+	printk("ADC below threshold: %d mV (raw %d)\n",
+	       (int)g_adc_value_mv, (int)g_adc_value_raw);
+}
+
+static int adc_setup()
+{
+    int err = 0;
+    /* Configure channels individually prior to sampling. */
+	for (size_t i = 0U; i < ARRAY_SIZE(adc_channels); i++) {
+		printk("Is ready %s \n", adc_channels[i].dev->name);
+		if (!adc_is_ready_dt(&adc_channels[i])) {
+			printk("ADC controller device %s not ready\n", adc_channels[i].dev->name);
+			return 0;
+		}
+		printk("Configure %s \n", adc_channels[i].dev->name);
+		err = adc_channel_setup_dt(&adc_channels[i]);
+		if (err < 0) {
+			printk("Could not setup channel #%d (%d)\n", i, err);
+			return 0;
+		}
+	}
+    return 0;
+}
+
+static void adc_work_handler(struct k_work *work)
+{
+	int err;
+
+	(void)work;
+
+    for (size_t i = 0U; i < ARRAY_SIZE(adc_channels); i++) {
+        int32_t val_mv;
+
+        printk("- %s, channel %d: ",
+                adc_channels[i].dev->name,
+                adc_channels[i].channel_id);
+
+        (void)adc_sequence_init_dt(&adc_channels[i], &sequence);
+
+        err = adc_read_dt(&adc_channels[i], &sequence);
+        if (err < 0) {
+            printk("Could not read (%d)\n", err);
+            continue;
+        }
+
+        val_mv = adc_buffer;
+
+        printk("%"PRId32, val_mv);
+        err = adc_raw_to_millivolts_dt(&adc_channels[i],
+                            &val_mv);
+        /* conversion to mV may not be supported, skip if not */
+        if (err < 0) {
+            printk(" (value in mV not available)\n");
+        } else {
+            printk(" = %"PRId32" mV\n", val_mv);
+        }
+    }
+    k_work_schedule(&adc_work, K_MSEC(CONFIG_VBAT_MONITOR_INTERVAL_MS));
+
+// 	/* Update global variable (raw) */
+// 	g_adc_value_raw = adc_buffer;
+
+// 	/* Convert to millivolts and update global */
+// 	ret = adc_raw_to_millivolts_dt(&adc_channel, &adc_buffer);
+// 	if (ret == 0) {
+// 		g_adc_value_mv = adc_buffer;
+// 	} else {
+// 		g_adc_value_mv = 0;
+// 	}
+
+// 	/* If below threshold, trigger "interrupt" (callback) */
+// 	if (g_adc_value_mv < ADC_LOW_THRESHOLD_MV) {
+// 		adc_low_threshold_trigger();
+// 	} else {
+// 		g_adc_below_threshold = false;
+// 	}
+
+// 	printk("ADC: %d mV (raw %d)%s\n",
+// 	       (int)g_adc_value_mv, (int)g_adc_value_raw,
+// 	       g_adc_below_threshold ? " [LOW]" : "");
+
+// reschedule:
+// 	/* Schedule this work again in 5 seconds to repeat the process */
+// 	k_work_schedule(&adc_work, K_SECONDS(MEASUREMENT_INTERVAL_SEC));
+}
+
+
+
+int health_monitoring_setup(void)
+{
+
+	printk("ADC work queue sample: measure every %d s, low threshold %d mV\n",
+	       MEASUREMENT_INTERVAL_SEC, ADC_LOW_THRESHOLD_MV);
+
+	adc_setup();
+
+	/* Start the cycle: first run in 5 seconds */
+	k_work_schedule(&adc_work, K_MSEC(CONFIG_VBAT_MONITOR_INTERVAL_MS));
+
+	// for (;;) {
+	// 	k_sleep(K_SECONDS(10));
+	// 	/* Optional: print global state from main loop */
+	// 	printk("Global ADC: %d mV, low_trigger_count %u\n",
+	// 	       (int)g_adc_value_mv, (unsigned)g_adc_low_trigger_count);
+	// }
+
+	return 0;
+}

soc/nordic/nrf54l/health_monitoring/health_monitoring.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2024 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _HEALTH_MONITORING_H_
+#define _HEALTH_MONITORING_H_
+
+int health_monitoring_setup(void);
+
+#endif /* _HEALTH_MONITORING_H_ */

soc/nordic/nrf54l/health_monitoring/v_internal_monitor.overlay

@@ -0,0 +1,20 @@
+/ {
+	zephyr,user {
+		io-channels = <&adc 2>;
+	};
+};
+
+&adc {
+	#address-cells = <1>;
+	#size-cells = <0>;
+
+	channel@2 {
+		reg = <2>;
+		zephyr,gain = "ADC_GAIN_1";
+		zephyr,reference = "ADC_REF_INTERNAL";
+		zephyr,acquisition-time = <ADC_ACQ_TIME_DEFAULT>;
+		zephyr,input-positive = <NRF_SAADC_VDD>;
+		zephyr,resolution = <12>;
+		zephyr,oversampling = <8>;
+	};
+};

soc/nordic/nrf54l/health_monitoring/vbatt_monitor.overlay

@@ -0,0 +1,21 @@
+/ {
+	zephyr,user {
+		io-channels = <&adc 1>;
+	};
+};
+
+&adc {
+	#address-cells = <1>;
+	#size-cells = <0>;
+
+	channel@1 {
+		reg = <1>;
+		zephyr,gain = "ADC_GAIN_1"; //NRF_SAADC_GAIN1_4
+		zephyr,reference = "ADC_REF_INTERNAL";
+		zephyr,acquisition-time = <ADC_ACQ_TIME_DEFAULT>;
+		zephyr,input-positive = <NRF_SAADC_AIN2>; /* P1.06 */
+		zephyr,input-negative = <NRF_SAADC_GND>;
+		zephyr,resolution = <12>;
+		zephyr,oversampling = <8>;
+	};
+};

soc/nordic/nrf54l/health_monitoring_nrfx/CMakeLists.txt

@@ -0,0 +1,16 @@
+# Copyright (c) 2026 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+zephyr_library_sources(health_monitoring.c
+                      battery_monitor.c)
+
+zephyr_include_directories(.)
+
+if (CONFIG_ADC) # TODO Currently this does not cause an error when enabled from Kconfig
+  message(FATAL_ERROR 
+          "Health Monitoring feautre can not be used in conjunction with other ADC measurements,
+          see sample XXXX to implement an alternative, disabling this feature may have
+          adverse effects on performance over temperature")
+endif()