doc: Update Edge Impulse documentation with Axon deployment

Jira: NCSDK-37145

Signed-off-by: Bartosz Meus <bartosz.meus@nordicsemi.no>

Author: mbarchie

doc/integrations/edge_impulse.rst

@@ -72,21 +72,39 @@ Preparing the machine learning model
 
       .. group-tab:: Using |EIS| web interface
 
-         a. Go to the :guilabel:`Deployment` tab and select :guilabel:`Zephyr library`.
-            This will generate a :file:`zip` file that contains source files defining the |EI| ML model.
+         .. tabs::
 
-         .. figure:: ./images/ei_deploy.png
-            :scale: 50 %
-            :alt: Model deployment in |EIS| dashboard
+            .. group-tab:: Model executed on CPU
 
-            Model deployment in |EIS| dashboard
+               a. Go to the :guilabel:`Deployment` tab and select :guilabel:`Zephyr library`.
+                  This will generate a :file:`zip` file that contains source files defining the |EI| ML model for execution on CPU.
 
-         .. note::
-            Edge Impulse supports multiple deployment formats, some of which are compatible with |NCS| applications.
-            However, this instruction focuses on the Zephyr library deployment format.
+               .. figure:: ./images/ei_deploy_cpu.png
+                  :scale: 50 %
+                  :alt: CPU model deployment in |EIS| dashboard
+
+                  CPU model deployment in |EIS| dashboard
+
+            .. group-tab:: Model executed on Axon NPU
+
+               a. Go to the :guilabel:`Deployment` tab and select :guilabel:`Nordic Axon NPU Library`.
+                  This will generate a :file:`zip` file that contains source files defining the |EI| ML model for Axon NPU.
+
+               .. figure:: ./images/ei_deploy_axon.png
+                  :scale: 50 %
+                  :alt: Axon NPU model deployment in |EIS| dashboard
+
+                  Axon NPU model deployment in |EIS| dashboard
+
+            .. note::
+               |EI| supports multiple deployment formats, some of which are compatible with |NCS| applications.
+               However, this instruction focuses on the `Zephyr library` and `Nordic Axon NPU Library` deployment formats.
 
       .. group-tab:: Using |EI| west extensions
 
+         .. note::
+            This method currently does not allow deploying Axon NPU models.
+
          |EI| provides west command extensions that let you build and deploy the machine learning model from |EIS| using the command line instead of the web interface.
          The commands are already configured in the |EAI| west manifest and are ready to use.
 
@@ -126,57 +144,158 @@ Preparing the machine learning model
 
 .. _ug_edge_impulse_adding_building:
 
-.. rst-class:: numbered-step
-
 Building an application with machine learning model
 ===================================================
 
 You have to complete the following configuration steps to be able to build your application including the deployed |EI| machine learning model:
 
-1. Make sure that the following Kconfig options are enabled:
+.. tabs::
+
+   .. group-tab:: Model executed on CPU
+
+      1. Make sure that the following Kconfig options are enabled:
+
+         * ``CONFIG_CPP``
+         * ``CONFIG_STD_CPP11``
+         * ``CONFIG_REQUIRES_FULL_LIBCPP``
+         * ``CONFIG_EDGE_IMPULSE_SDK``
+
+         .. note::
+            The ``CONFIG_FPU`` Kconfig option is implied by default if floating point unit (FPU) is supported by the hardware.
+            Using FPU speeds up calculations.
+
+      #. Make sure that the ``CONFIG_FP16`` Kconfig option is disabled.
+          The |EI| library is not compatible with half-precision floating point support introduced in Zephyr.
+
+      #. If you want to call |EI| API directly from C code, you must define the following macros in your application's :file:`CMakeLists.txt` file:
+
+          .. code-block:: cmake
+
+             zephyr_compile_definitions(
+                EI_C_LINKAGE=1
+                EIDSP_SIGNAL_C_FN_POINTER=1
+             )
+
+          Check `Using the library from C`_ for more information.
+
+      #. Unpack the :file:`zip` archive with the deployed machine learning model and add the following to your application's :file:`CMakeLists.txt` file:
+
+         .. code-block:: cmake
+
+            add_subdirectory(ei_model)
+
+         Alternatively, you can automate the unpacking as part of the build process using CMake's ``FetchContent`` module.
+         This approach automatically extracts the archive during configuration:
+
+         .. code-block:: cmake
+
+            include(FetchContent)
+
+            FetchContent_Declare(
+               ei_model
+               URL ${CMAKE_CURRENT_SOURCE_DIR}/ei_model.zip
+            )
+
+            FetchContent_MakeAvailable(ei_model)
+
+   .. group-tab:: Model executed on Axon NPU
+
+       1. Make sure that the following Kconfig options are enabled:
+
+         * ``CONFIG_CPP``
+         * ``CONFIG_STD_CPP11``
+         * ``CONFIG_REQUIRES_FULL_LIBCPP``
+         * ``CONFIG_EDGE_IMPULSE_SDK``
+         * ``CONFIG_NRF_AXON``
+
+      #. Make sure that the ``CONFIG_FP16`` Kconfig option is disabled.
+         The |EI| library is not compatible with half-precision floating point support introduced in Zephyr.
+
+      #. If you want to call |EI| API directly from C code, you must define the following macros in your application's :file:`CMakeLists.txt` file:
+
+          .. code-block:: cmake
+
+             zephyr_compile_definitions(
+                EI_C_LINKAGE=1
+                EIDSP_SIGNAL_C_FN_POINTER=1
+             )
+
+          Check `Using the library from C`_ for more information.
+
+      #. Unpack the :file:`zip` archive with the deployed machine learning model and add the following to your application's :file:`CMakeLists.txt` file:
+
+         .. code-block:: cmake
+
+            add_subdirectory(ei_model)
+
+         Alternatively, you can automate the unpacking as part of the build process using CMake's ``FetchContent`` module.
+         This approach automatically extracts the archive during configuration:
+
+         .. code-block:: cmake
+
+            include(FetchContent)
+
+            FetchContent_Declare(
+               ei_model
+               URL ${CMAKE_CURRENT_SOURCE_DIR}/ei_model.zip
+            )
+
+            FetchContent_MakeAvailable(ei_model)
+
+      #. Set ``CONFIG_NRF_AXON_MODEL_NAME`` Kconfig option to the name of your model.
+         You can find it for example in:
+
+         * :file:`conf_overlay.conf` file included in the :file:`zip` archive with the deployed model, for example:
+
+           .. code-block:: console
+
+              cat ei_model/conf_overlay.conf
+              CONFIG_NRF_AXON_MODEL_NAME="ei_model_nrf_accel_sim_54"
+
+         * the names of the Axon model header files included in the archive.
+           For example:
 
-   * ``CONFIG_CPP``
-   * ``CONFIG_STD_CPP11``
-   * ``CONFIG_REQUIRES_FULL_LIBCPP``
-   * ``CONFIG_EDGE_IMPULSE_SDK``
+           .. code-block:: console
 
-   .. note::
-      The ``CONFIG_FPU`` Kconfig option is implied by default if floating point unit (FPU) is supported by the hardware.
-      Using FPU speeds up calculations.
+              ls nordic-axon-model/nrf_axon_model_*.h
+              nordic-axon-model/nrf_axon_model_ei_model_nrf_accel_sim_54_.h
+              nordic-axon-model/nrf_axon_model_ei_model_nrf_accel_sim_54_layers_.h
+              nordic-axon-model/nrf_axon_model_ei_model_nrf_accel_sim_54_test_vectors_.h
 
-#. Make sure that the ``CONFIG_FP16`` Kconfig option is disabled.
-   The |EI| library is not compatible with half-precision floating point support introduced in Zephyr.
+           means that the model name is ``ei_model_nrf_accel_sim_54``.
 
-#. If you want to call |EI| API directly from C code, you must define the following macros in your application's :file:`CMakeLists.txt` file:
+      #. Set ``CONFIG_NRF_AXON_INTERLAYER_BUFFER_SIZE`` and ``CONFIG_NRF_AXON_PSUM_BUFFER_SIZE`` appropriately, to fit your model's requirements.
+         If the buffers are too small, the inference will fail with an error indicating insufficient buffer size and the required size, for example:
 
-   .. code-block:: cmake
+         .. code-block:: console
 
-      zephyr_compile_definitions(
-         EI_C_LINKAGE=1
-         EIDSP_SIGNAL_C_FN_POINTER=1
-      )
+            init model ei_model_nrf_accel_sim_54 failed! interlayer buffer too small! Allocated 0, need 36
+            ERR: nrf_axon_nn_model_validate failed!
+            E: Classification failed with error code: -36
 
-   Check `Using the library from C`_ for more information.
+         You can also find the required buffer sizes:
 
-#. Unpack the :file:`zip` archive with the deployed machine learning model and add the following to your application's :file:`CMakeLists.txt` file:
+         * in the console output from testing model in |EIS|, when deploying the model:
 
-   .. code-block:: cmake
+           .. code-block:: console
 
-      add_subdirectory(ei_model)
+               -------------------------------------------------------------------------------
+               Model EI_MODEL_NRF_ACCEL_SIM_54 results (variant : ei_model_nrf_accel_sim_54)
+               -------------------------------------------------------------------------------
 
-   Alternatively, you can automate the unpacking as part of the build process using CMake's ``FetchContent`` module.
-   This approach automatically extracts the archive during configuration:
+                     Memory Usage (in bytes)
 
-   .. code-block:: cmake
+                              model_const_buffer_size:        1024
+                              interlayer_buffer_size: 36
+                              psum_buffer_size:       0
+                              cmd_buffer_size:        736
 
-      include(FetchContent)
+         * in the :file:`zip` archive with the deployed model, in the :file:`nrf_axon_model_<model_name>_.h` file, for example:
 
-      FetchContent_Declare(
-         ei_model
-         URL ${CMAKE_CURRENT_SOURCE_DIR}/ei_model.zip
-      )
+           .. code-block:: c
 
-      FetchContent_MakeAvailable(ei_model)
+              #define NRF_AXON_MODEL_EI_MODEL_NRF_ACCEL_SIM_54_MAX_IL_BUFFER_USED 36
+              #define NRF_AXON_MODEL_EI_MODEL_NRF_ACCEL_SIM_54_MAX_PSUM_BUFFER_USED 0
 
 .. _ug_edge_impulse_building:
 

doc/integrations/images/ei_deploy.png

@@ -27,6 +27,7 @@ These workflows rely on integrated toolchains and APIs to reduce setup effort:
   Use it for easy setup, standardized workflow, and the best Nordic Semiconductor device compatibility.
 * :ref:`quick_start_edge_impulse` - Use the Edge Impulse platform for an end-to-end machine learning solution.
   It includes visual development tools, extensive documentation, and community support.
+  Models run on CPU or on the Axon NPU depending on the target device you select.
   Use this option if you already work with Edge Impulse or require its tooling ecosystem.
 
 .. toctree::
@@ -45,13 +46,9 @@ These workflows require more manual configuration but allow finer control over p
 * :ref:`quick_start_axon_driver` - Work directly with the Axon NPU driver API for maximum control, performance and low energy consumption.
   Compile TensorFlow Lite models and implement custom inference pipelines.
   Use this option for advanced optimization and direct NPU control.
-* :ref:`quick_start_axon_edge_impulse` - Combine Edge Impulse's user-friendly platform with Axon NPU hardware acceleration.
-  Use Edge Impulse SDK while benefiting from NPU performance on compatible devices.
-  Use this option if you want to keep the Edge Impulse workflow while targeting Axon hardware.
 
 .. toctree::
    :maxdepth: 1
    :hidden:
 
-   quick_start/axon_driver
-   quick_start/axon_edge_impulse
+   quick_start/axon_driver

doc/integrations/images/ei_deploy_axon.png

@@ -15,6 +15,8 @@ Compared to higher‑level frameworks such as |EAILib|, using the driver API req
 
 After completing this guide, you will have compiled a TensorFlow Lite model for the Axon NPU and deployed a custom application that performs inference using the Axon driver API.
 
+.. _quick_start_axon_driver_model_compilation:
+
 Model compilation
 *****************
 
@@ -49,6 +51,8 @@ Test your compiled model to ensure it works correctly before integrating it into
 Run :ref:`test_nn_inference` to confirm your compiled model produces correct results.
 This validation step checks for compilation issues early in the development process.
 
+.. _quick_start_axon_driver_app_development:
+
 Application development
 ***********************
 

doc/integrations/images/ei_deploy_cpu.png

@@ -10,6 +10,10 @@ Edge Impulse
 The following guide explains how to develop and deploy machine learning applications on Nordic Semiconductor devices using |EI|.
 It is ideal if you want an end‑to‑end workflow for data collection, model training, and deployment on embedded targets.
 
+|EI| models can run on CPU or on the `Axon NPU`_, depending on the target device you select during the deployment process.
+On devices equipped with the Axon NPU, |EI| automatically leverages hardware acceleration for supported operations, resulting in faster inference and lower power consumption.
+On devices without the NPU, the same model runs in software on the CPU.
+
 To follow this guide, you should be familiar with basic embedded systems development.
 The guide covers the steps required to collect data, train a model using Edge Impulse tools, and deploy the resulting model to a Nordic device.
 
@@ -55,7 +59,7 @@ Choose the method that works best for your project:
    * For image data, aim for 50-100 images per class as a starting point, with good variety in lighting, angles, and backgrounds.
    * For all data types, prioritize dataset diversity and balance the number of samples across classes to improve model performance.
 
-For more details on data collection strategies, follow the `Edge Impulse data acquisition` guide.
+For more details on data collection strategies, follow the `Edge Impulse data acquisition`_ guide.
 
 .. rst-class:: numbered-step
 
@@ -72,6 +76,11 @@ Train and deploy your model using `Edge Impulse studio`_:
 
 Your model is now trained and ready for deployment on Nordic devices.
 
+Next steps
+==========
+
+* If you use Axon and need lower‑level access to the NPU beyond what |EI| provides, see :ref:`quick_start_axon_driver_model_compilation` to learn how to compile custom TensorFlow Lite models for Axon.
+
 Application development
 ***********************
 
@@ -109,7 +118,7 @@ The |EI| SDK makes it easy to load your model, feed it sensor data, and get pred
    * Read the `Edge Impulse C++ SDK`_ documentation for comprehensive API reference and advanced features.
 
 .. tip::
-   Start with one of the sample applications and modify it incrementally. 
+   Start with one of the sample applications and modify it incrementally.
    This will help you understand the API structure before building your custom application from scratch.
 
 .. rst-class:: numbered-step
@@ -128,5 +137,5 @@ Next steps
 
 To work on advanced solutions, see further documentation:
 
-* Accelerate with Axon NPU - If you have a device with `Axon NPU`_, see :ref:`quick_start_axon_edge_impulse` to learn how to combine |EI| with Axon hardware acceleration for significantly faster inference times.
 * Explore advanced features - Dive deeper into the `Edge Impulse C++ SDK`_ documentation to discover advanced capabilities like anomaly detection, continuous learning, and custom processing blocks.
+* Direct Axon NPU control - If you use Axon and need lower‑level access to the NPU beyond what |EI| provides, see :ref:`quick_start_axon_driver_app_development` to learn how to implement custom inference pipelines with the Axon driver API.

doc/quick_start.rst

@@ -20,8 +20,8 @@ This release is based on the |NCS| release v3.2.0.
 * Added:
 
   * :ref:`Hello Axon sample application <sample_hello_axon>`, along with documentation, demonstrating how to run neural model inference on the Axon NPU using the Axon NPU driver.
-  * :ref:`Hello Edge Impulse sample application <hello_ei_sample>` demonstrating neural network inference using an |EI| machine learning model on the CPU.
+  * :ref:`Hello Edge Impulse sample application <hello_ei_sample>` demonstrating neural network inference using an |EI| machine learning model on the CPU and the Axon NPU.
   * :ref:`Data forwarder sample application <ei_data_forwarder_sample>` demonstrating how to forward sensor data to |EIS|.
   * :ref:`Documentation for the Edge Impulse integration <edge_impulse_integration>`, with instructions for preparing and deploying |EI| machine learning models and using them in |EAI| applications.
-  * Edge Impulse SDK v1.82.3 integrated into the |EAI| west manifest.
+  * Edge Impulse SDK v1.88.1 integrated into the |EAI| west manifest.
   * :ref:`Documentation for setting up the environment <setting_up_environment>`, depending on |EAI| use case.