applications: gesture_recognition: Add Axon configuration

Add Axon configuration for gesture recognition application.
Add new model compatible with axon NPU architecture.

JIRA: NCSDK-36993

Signed-off-by: Jan Zyczkowski <jan.zyczkowski@nordicsemi.no>

Author: zycz

applications/gesture_recognition/CMakeLists.txt

@@ -12,17 +12,26 @@ set(APPLICATION_CONFIG_DIR "${CMAKE_CURRENT_SOURCE_DIR}/configuration/\${NORMALI
 find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
 project(gesture_recognition)
 
-# Check if platform-specific neural network model file exists
-set(NN_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/src/nrf_edgeai_generated/${BOARD}")
-set(NN_PATH "${NN_SOURCE}/nrf_edgeai_user_model.c")
-if(EXISTS "${NN_PATH}")
-    message(STATUS "Using Edge AI model for board: ${BOARD}")
+set(NN_BASE "${CMAKE_CURRENT_SOURCE_DIR}/src/nrf_edgeai_generated/${BOARD}")
+
+if(CONFIG_NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_AXON)
+  set(NN_SOURCE "${NN_BASE}/Axon")
 else()
-    message(FATAL_ERROR "Edge AI model file not found for board '${BOARD}'.\n"
-        "Expected file: ${NN_PATH}\n"
-        "Please create ${NN_PATH} or use one of the supported boards."
-    )
+  # Neuton: use Neuton subdir only for nrf54lm20dk (has both Axon and Neuton)
+  if(BOARD STREQUAL "nrf54lm20dk")
+    set(NN_SOURCE "${NN_BASE}/Neuton")
+  else()
+    set(NN_SOURCE "${NN_BASE}")
+  endif()
+endif()
+
+set(NN_PATH "${NN_SOURCE}/nrf_edgeai_user_model.c")
+if(NOT EXISTS "${NN_PATH}")
+  message(FATAL_ERROR "Edge AI model file not found for board '${BOARD}' (model dir: ${BOARD_BASE}).\n"
+    "Expected: ${NN_PATH}\n"
+    "Create the model at that path or use a supported board.")
 endif()
+message(STATUS "Using Edge AI model: ${NN_SOURCE}")
 
 target_include_directories(app PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/src/hw_modules

applications/gesture_recognition/Kconfig

@@ -9,6 +9,28 @@ source "Kconfig.zephyr"
 config DATA_COLLECTION_MODE
 	bool "Enable Data Collection Mode (no inference run)"
 
+choice NRF_EDGEAI_GESTURE_RECOGNITION_MODEL
+	prompt "Edge AI model backend"
+	default NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_AXON if SOC_NRF54LM20B
+	default NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_NEUTON
+	help
+	  Select which model implementation to use. Axon (NPU) is only available
+	  on nRF54L20 (nrf54lm20b). Other boards use Neuton (CPU).
+
+config NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_NEUTON
+	bool "Neuton (CPU)"
+	help
+	  Use the Neuton model. Works on all supported boards.
+
+config NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_AXON
+	bool "Axon (NPU)"
+	depends on SOC_NRF54LM20B
+	select NRF_AXON
+	help
+	  Use the Axon model. Only available on Axon-enabled devices.
+
+endchoice
+
 choice BLE_MODE
 	prompt "BLE mode"
 	default BLE_MODE_HID if !DATA_COLLECTION_MODE

applications/gesture_recognition/README.rst

@@ -12,11 +12,12 @@ This application demonstrates a gesture-based remote control device using Nordic
 Application overview
 ********************
 
-.. note::
+The gesture recognition application demonstrates how to use an nRF Edge AI model to recognize hand gestures from motion sensor data and expose them as standard HID inputs over Bluetooth® Low Energy.
+There are two variants of the application that differ in where the model is executed:
 
-   Currently, the gesture recognition application supports only Neuton CPU-based neural network models.
+* The Neuton variant, which uses a CPU-based model, also called the Neuton model.
+* The Axon variant, which uses an NPU-based model, also called the Axon model.
 
-The gesture recognition application demonstrates how to use an nRF Edge AI model to recognize hand gestures from motion sensor data and expose them as standard HID inputs over Bluetooth® Low Energy.
 When connected to a PC, the device appears as a Bluetooth LE HID device, allowing recognized gestures to control media playback or presentation slides.
 Based on accelerometer and gyroscope data, the nRF Edge AI model recognizes eight gesture classes:
 
@@ -179,6 +180,17 @@ Configuration
 
 |config|
 
+Choosing the model backend
+==========================
+
+The application supports two execution backends:
+
+* `Neuton models`_ - Highly optimized models that run on the CPU.
+* `Axon NPU`_ - Models that run on the Axon NPU (AI accelerator core).
+
+The Neuton model is used by default on all boards that do not have the Axon NPU.
+You can use the Axon model by enabling the ``CONFIG_NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_AXON`` Kconfig option.
+
 Choosing Bluetooth LE mode
 ==========================
 

applications/gesture_recognition/configuration/nrf54lm20dk_nrf54lm20b_cpuapp/app.overlay

@@ -126,3 +126,7 @@
 		spi-max-frequency = <DT_FREQ_M(8)>;
 	};
 };
+
+&axon {
+	status = "okay";
+};

applications/gesture_recognition/configuration/nrf54lm20dk_nrf54lm20b_cpuapp/prj.conf

@@ -47,3 +47,6 @@ CONFIG_FLASH_PAGE_LAYOUT=y
 CONFIG_FLASH_MAP=y
 CONFIG_NVS=y
 CONFIG_SETTINGS=y
+
+# nRF Axon
+CONFIG_NRF_AXON_INTERLAYER_BUFFER_SIZE=512

applications/gesture_recognition/src/main.c

@@ -72,8 +72,12 @@ typedef enum app_remotectrl_mode_e {
 
 typedef int (*led_set_func_t)(float brightness);
 
-static void send_imu_data(int16_t *input_data);
+#if IS_ENABLED(CONFIG_NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_AXON)
+static void execute_inference(flt32_t *input_data);
+#else
 static void execute_inference(int16_t *input_data);
+#endif
+static void send_imu_data(int16_t *input_data);
 static void hw_modules_init(void);
 static void led_glowing_timer_handler(struct k_timer *timer);
 static void handle_inference_result(nrf_edgeai_t *model);
@@ -111,7 +115,10 @@ int main(void)
 		nrf_edgeai_solution_id_str(p_model));
 
 	imu_data_t imu_data = {0};
-	int16_t input_data[NRF_EDGEAI_INPUT_DATA_LEN];
+
+	flt32_t input_data_f32[NRF_EDGEAI_INPUT_DATA_LEN];
+	int16_t input_data_i16[NRF_EDGEAI_INPUT_DATA_LEN];
+
 
 	for (;;) {
 		/* Wait for the semaphore to be released by IMU data ready interrupt */
@@ -121,17 +128,28 @@ int main(void)
 			continue;
 		}
 
-		input_data[0] = imu_data.accel[0].raw;
-		input_data[1] = imu_data.accel[1].raw;
-		input_data[2] = imu_data.accel[2].raw;
-		input_data[3] = imu_data.gyro[0].raw;
-		input_data[4] = imu_data.gyro[1].raw;
-		input_data[5] = imu_data.gyro[2].raw;
+		input_data_f32[0] = (flt32_t)(imu_data.accel[0].phys * 1000);
+		input_data_f32[1] = (flt32_t)(imu_data.accel[1].phys * 1000);
+		input_data_f32[2] = (flt32_t)(imu_data.accel[2].phys * 1000);
+		input_data_f32[3] = (flt32_t)(imu_data.gyro[0].phys * 1000);
+		input_data_f32[4] = (flt32_t)(imu_data.gyro[1].phys * 1000);
+		input_data_f32[5] = (flt32_t)(imu_data.gyro[2].phys * 1000);
+
+		input_data_i16[0] = imu_data.accel[0].raw;
+		input_data_i16[1] = imu_data.accel[1].raw;
+		input_data_i16[2] = imu_data.accel[2].raw;
+		input_data_i16[3] = imu_data.gyro[0].raw;
+		input_data_i16[4] = imu_data.gyro[1].raw;
+		input_data_i16[5] = imu_data.gyro[2].raw;
 
 		if (IS_ENABLED(CONFIG_DATA_COLLECTION_MODE)) {
-			send_imu_data(input_data);
+			send_imu_data(input_data_i16);
 		} else {
-			execute_inference(input_data);
+#if IS_ENABLED(CONFIG_NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_AXON)
+			execute_inference(input_data_f32);
+#else
+			execute_inference(input_data_i16);
+#endif
 		}
 	}
 
@@ -300,11 +318,15 @@ static void ble_send_recognized_class(const class_label_t class_label, size_t pr
 }
 #endif
 
+#if IS_ENABLED(CONFIG_NRF_EDGEAI_GESTURE_RECOGNITION_MODEL_AXON)
+static void execute_inference(flt32_t *input_data)
+#else
 static void execute_inference(int16_t *input_data)
+#endif
 {
 	nrf_edgeai_err_t res;
 
-	res = nrf_edgeai_feed_inputs(p_model, input_data, NRF_EDGEAI_INPUT_DATA_LEN);
+	res = nrf_edgeai_feed_inputs(p_model, (void *)input_data, NRF_EDGEAI_INPUT_DATA_LEN);
 
 	if (res == NRF_EDGEAI_ERR_SUCCESS) {
 		res = nrf_edgeai_run_inference(p_model);