Summary: PoC to run/infer a simple mode on raspberry pi pico2

Test Plan:
1. Cross compile executorch libs for rp_pi pico2 board
cmake -B cmake-out
-DCMAKE_TOOLCHAIN_FILE=examples/arm/ethos-u-setup/arm-none-eabi-gcc.cmake
-DTARGET_CPU=cortex-m0plus
-DEXECUTORCH_BUILD_ARM_BAREMETAL=ON
-DEXECUTORCH_PAL_DEFAULT=minimal -DEXECUTORCH_DTYPE_SELECTIVE_BUILD=ON
-DCMAKE_BUILD_TYPE=MinSizeRel
-DEXECUTORCH_ENABLE_LOGGING=OFF
-DEXECUTORCH_SELECT_ALL_OPS=OFF
-DEXECUTORCH_BUILD_EXECUTOR_RUNNER=OFF
-DCMAKE_INSTALL_PREFIX=cmake-out .;
cmake --build cmake-out --target install -j$(nproc)1. Cross compile
executorch libs for rp_pi pico2 board
cmake -B cmake-out
-DCMAKE_TOOLCHAIN_FILE=examples/arm/ethos-u-setup/arm-none-eabi-gcc.cmake
-DTARGET_CPU=cortex-m0plus
-DEXECUTORCH_BUILD_ARM_BAREMETAL=ON
-DEXECUTORCH_PAL_DEFAULT=minimal -DEXECUTORCH_DTYPE_SELECTIVE_BUILD=ON
-DCMAKE_BUILD_TYPE=MinSizeRel
-DEXECUTORCH_ENABLE_LOGGING=OFF
-DEXECUTORCH_SELECT_ALL_OPS=OFF
-DEXECUTORCH_BUILD_EXECUTOR_RUNNER=OFF
-DCMAKE_INSTALL_PREFIX=cmake-out .;
cmake --build cmake-out --target install -j$(npro1. Cross compile
executorch libs for rp_pi pico2 board
cmake -B cmake-out
-DCMAKE_TOOLCHAIN_FILE=examples/arm/ethos-u-setup/arm-none-eabi-gcc.cmake
-DTARGET_CPU=cortex-m0plus
-DEXECUTORCH_BUILD_ARM_BAREMETAL=ON
-DEXECUTORCH_PAL_DEFAULT=minimal -DEXECUTORCH_DTYPE_SELECTIVE_BUILD=ON
-DCMAKE_BUILD_TYPE=MinSizeRel
-DEXECUTORCH_ENABLE_LOGGING=OFF
-DEXECUTORCH_SELECT_ALL_OPS=OFF
-DEXECUTORCH_BUILD_EXECUTOR_RUNNER=OFF
-DCMAKE_INSTALL_PREFIX=cmake-out .;
cmake --build cmake-out --target install -j$(nproc);

2.
Setup the pico SDK path : export PICO_SDK_PATH=...

3. Build pico2 firmware

cd executorch/examples/arm/raspberry_pi/pico2;rm -rf build; mkdir build; cd build; cmake .. -DPICO_BOARD=pico2 -DCMAKE_BUILD_TYPE=Release; cmake --build . -j$(nproc)

4. Flash the firmware : 'executorch_pico.uf2'

5. Verify that it successfully runs / infers the simple add module

Reviewers:

Subscribers:

Tasks:

Tags:

Author: sidart

examples/arm/raspberry_pi/pico2/CMakeLists.txt

@@ -0,0 +1,58 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+# Copyright 2023-2025 Arm Limited and/or its affiliates.
+
+# This source code is licensed under the BSD-style license found in the LICENSE
+# file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+include($ENV{PICO_SDK_PATH}/external/pico_sdk_import.cmake)
+project(executorch_pico C CXX ASM)
+pico_sdk_init()
+
+set(EXECUTORCH_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../../../..)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Note: Replace simple_model_pte.c with your model's pte files
+add_executable(executorch_pico main.cpp simple_model_pte.c)
+pico_enable_stdio_usb(executorch_pico 1)
+pico_enable_stdio_uart(executorch_pico 0)
+
+# Set correct flags for Pico (Cortex-M0+)
+target_compile_options(executorch_pico PRIVATE
+    -mcpu=cortex-m0plus -mfloat-abi=soft -mthumb
+)
+
+target_include_directories(
+    executorch_pico
+    PRIVATE ${EXECUTORCH_ROOT} ${EXECUTORCH_ROOT}/executorch/third-party/
+    ${EXECUTORCH_ROOT}/executorch/runtime/core/portable_type/c10
+)
+add_compile_definitions(C10_USING_CUSTOM_GENERATED_MACROS)
+
+# Add these optimization flags to your CMakeLists.txt
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Os -ffunction-sections -fdata-sections")
+set(CMAKE_CXX_FLAGS
+"${CMAKE_CXX_FLAGS} -Os -ffunction-sections -fdata-sections")
+
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
+# Also add these size optimization definitions
+add_compile_definitions(
+    EXECUTORCH_ENABLE_LOGGING=OFF EXECUTORCH_PAL_DEFAULT=minimal
+)
+
+set(BAREMETAL_BUILD_DIR ${EXECUTORCH_ROOT}/executorch/cmake-out/)
+# Link Executorch and Pico libraries
+target_link_libraries(
+    executorch_pico
+    PRIVATE ${BAREMETAL_BUILD_DIR}/lib/libexecutorch.a
+    ${BAREMETAL_BUILD_DIR}/lib/libexecutorch_core.a
+    -Wl,--whole-archive
+    ${BAREMETAL_BUILD_DIR}/lib/libportable_ops_lib.a
+    -Wl,--no-whole-archive
+    ${BAREMETAL_BUILD_DIR}/lib/libportable_kernels.a
+    pico_stdlib
+    pico_stdio_usb
+)
+
+pico_add_extra_outputs(executorch_pico)

examples/arm/raspberry_pi/pico2/README.md

@@ -0,0 +1,86 @@
+## Overview
+This document outlines the steps required to run a simple Add Module on the Pico2 microcontroller using executorch.
+## Steps
+
+### (Pre-requisistes) Prepare the Environment for Arm
+1. See <a href="https://docs.pytorch.org/executorch/main/tutorial-arm.html#set-up-the-developer-environment"/> for instructions on setting up the environment for Arm.
+2. Make sure you have the toolchain configured correctly.
+```bash
+which arm-none-eabi-gcc
+``` should return something like 'executorch/examples/arm/ethos-u-scratch/arm-gnu-toolchain-13.3.rel1-x86_64-arm-none-eabi/bin/arm-none-eabi-gcc'
+
+### 1. Cross Compile Executorch for Arm Cortex M Target
+To begin, navigate to the executorch root directory and execute the following commands:
+```bash
+cmake -B cmake-out \
+  -DCMAKE_TOOLCHAIN_FILE=examples/arm/ethos-u-setup/arm-none-eabi-gcc.cmake \
+  -DTARGET_CPU=cortex-m0plus \
+  -DEXECUTORCH_BUILD_ARM_BAREMETAL=ON \
+  -DEXECUTORCH_PAL_DEFAULT=minimal \
+  -DEXECUTORCH_DTYPE_SELECTIVE_BUILD=ON \
+  -DCMAKE_BUILD_TYPE=MinSizeRel \
+  -DEXECUTORCH_ENABLE_LOGGING=OFF \
+  -DEXECUTORCH_SELECT_ALL_OPS=OFF \
+  -DEXECUTORCH_BUILD_EXECUTOR_RUNNER=OFF \
+  -DCMAKE_INSTALL_PREFIX=cmake-out .; \
+cmake --build cmake-out --target install -j$(nproc);
+```
+
+### 2. Export PICO_SDK_PATH
+Download the Pico SDK from GitHub: https://github.com/raspberrypi/pico-sdk and set the PICO_SDK_PATH environment variable:
+```bash
+export PICO_SDK_PATH=<path_to_local_pico_sdk_folder>
+```
+
+### 3. Build the example for Pico2
+Go to the example directory and initiate the build process:
+```bash
+cd examples/arm/raspberry_pi/pico2/
+rm -rf build
+mkdir build
+cd build
+cmake .. -DPICO_BOARD=pico2 -DCMAKE_BUILD_TYPE=Release
+cmake --build . -j$(nproc)
+```
+This step will generate the firmware file executorch_pico.uf2
+
+### 4. Flash the Firmware
+Press and hold the BOOTSEL button on the Pico2.
+Connect the Pico2 to your computer; it should mount as RPI-RP2.
+Copy the executorch_pico.uf2 file to the mounted drive.
+
+### 5. Verify the Firmware
+Check that the Pico2's LED blinks 10 times at 500 ms interval to confirm successful firmware execution.
+You should see the output (if the serial port is connected, see below for details) :
+````bash
+Method loaded [forward]
+Output: 13.000000, 136.000000, 24.000000, 131.000000
+```
+
+### 6. Steps to debug / triage using a serial terminal
+
+On macOS or Linux, run the following command to open a serial terminal for the Pico2:
+```bash
+screen /dev/tty.usbmodem1101 115200
+```
+
+Make sure to replace /dev/tty.usbmodem1101 with the actual device path for your Pico if different.
+This will open a serial terminal at 115200 baud rate, where you should see the printf output from your program, including any logs or error messages printed during execution.
+If you see the LED blink 10 times at 100 ms interval, that indicates your program reached the error indicator code, so you should also see the corresponding logs in this terminal.
+
+These steps complete the process required to run the simple Add Module on the Pico2 microcontroller using executorch.
+
+### 6. Other Tips
+
+a. The pte_to_header.py script converts binary PTE files into C++ header files containing byte arrays.
+```bash
+python ./examples/arm/executor_runner/pte_to_header.py -p model.pte
+```
+
+b. The following command will generate a simple_ops.txt file with the list of operators used in any given model. This can be used to verify all the operators that should be included in the build.
+From the root executor dir,
+```bash
+python -m executorch.codegen.tools.gen_oplist   --output_path simple_ops.txt   --model_file_path ./model.pte
+```
+
+c.

examples/arm/raspberry_pi/pico2/main.cpp

@@ -0,0 +1,171 @@
+/* Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ * Copyright 2023-2025 Arm Limited and/or its affiliates.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Model data
+#include "simple_model_pte.h"
+
+// Pico includes
+#include "pico/stdio_usb.h"
+#include "pico/stdlib.h"
+
+// Executorch includes
+#include <executorch/extension/data_loader/buffer_data_loader.h>
+#include <executorch/runtime/core/portable_type/scalar_type.h>
+#include <executorch/runtime/executor/memory_manager.h>
+#include <executorch/runtime/executor/method.h>
+#include <executorch/runtime/executor/program.h>
+#include <executorch/runtime/platform/runtime.h>
+
+// Std c++ includes
+#include <memory>
+
+using namespace executorch::runtime;
+using executorch::aten::Tensor;
+using executorch::aten::TensorImpl;
+using ScalarType = executorch::runtime::etensor::ScalarType;
+using executorch::runtime::runtime_init;
+
+// Define GPIO pins for indicators
+const uint INDICATOR_PIN_1 = 25; // Onboard LED
+const uint INDICATOR_PIN_2 = 22; // External LED
+const uint INDICATOR_PIN_3 = 23; // Onboard LED
+
+void init_gpio_pins() {
+  gpio_init(INDICATOR_PIN_1);
+  gpio_set_dir(INDICATOR_PIN_1, GPIO_OUT);
+  gpio_init(INDICATOR_PIN_2);
+  gpio_set_dir(INDICATOR_PIN_2, GPIO_OUT);
+  gpio_init(INDICATOR_PIN_3);
+  gpio_set_dir(INDICATOR_PIN_3, GPIO_OUT);
+}
+
+void wait_for_usb() {
+  const int kMaxRetryCount = 10;
+  int retry_usb_count = 0;
+  while (!stdio_usb_connected() && retry_usb_count++ < kMaxRetryCount) {
+    printf("Retry again! USB not connected \n");
+    sleep_ms(1000);
+  }
+}
+
+// Helper function to blink an indicator pin on the pico board a given number of
+// times
+void blink_indicator(uint pin, int times, int delay_ms = 100) {
+  for (int i = 0; i < times; ++i) {
+    gpio_put(pin, 1);
+    sleep_ms(delay_ms);
+    gpio_put(pin, 0);
+    sleep_ms(delay_ms);
+  }
+}
+
+bool load_and_prepare_model(
+    std::unique_ptr<Program>& program_ptr,
+    std::unique_ptr<Method>& method_ptr,
+    MemoryManager& memory_manager) {
+  executorch::extension::BufferDataLoader loader(model_pte, model_pte_len);
+  auto program_result = Program::load(&loader);
+  if (!program_result.ok()) {
+    printf("Failed to load model: %d\n", (int)program_result.error());
+    blink_indicator(INDICATOR_PIN_1, 10);
+    return false;
+  }
+  program_ptr = std::make_unique<Program>(std::move(*program_result));
+  auto method_name_result = program_ptr->get_method_name(0);
+  if (!method_name_result.ok()) {
+    printf("Failed to get method name: %d\n", (int)method_name_result.error());
+    blink_indicator(INDICATOR_PIN_1, 10);
+    return false;
+  }
+  auto method_result =
+      program_ptr->load_method(*method_name_result, &memory_manager);
+  if (!method_result.ok()) {
+    printf("Failed to load method: %d\n", (int)method_result.error());
+    blink_indicator(INDICATOR_PIN_1, 10);
+    return false;
+  }
+  method_ptr = std::make_unique<Method>(std::move(*method_result));
+  printf("Method loaded [%s]\n", *method_name_result);
+  return true;
+}
+
+bool run_inference(Method& method) {
+  float input_data_0[4] = {4.0, 109.0, 13.0, 123.0};
+  float input_data_1[4] = {9.0, 27.0, 11.0, 8.0};
+  TensorImpl::SizesType sizes[1] = {4};
+  TensorImpl::DimOrderType dim_order[] = {0};
+  TensorImpl impl0(ScalarType::Float, 1, sizes, input_data_0, dim_order);
+  TensorImpl impl1(ScalarType::Float, 1, sizes, input_data_1, dim_order);
+  Tensor input0(&impl0);
+  Tensor input1(&impl1);
+
+  if (method.set_input(input0, 0) != Error::Ok ||
+      method.set_input(input1, 1) != Error::Ok) {
+    printf("Failed to set input(s)\n");
+    blink_indicator(INDICATOR_PIN_1, 10);
+    return false;
+  }
+  if (method.execute() != Error::Ok) {
+    printf("Failed to execute\n");
+    blink_indicator(INDICATOR_PIN_1, 10);
+    return false;
+  }
+  const EValue& output = method.get_output(0);
+  if (output.isTensor()) {
+    const float* out_data = output.toTensor().const_data_ptr<float>();
+    printf(
+        "Output: %f, %f, %f, %f\n",
+        out_data[0],
+        out_data[1],
+        out_data[2],
+        out_data[3]);
+  } else {
+    printf("Output is not a tensor!\n");
+    blink_indicator(INDICATOR_PIN_1, 10);
+    return false;
+  }
+  return true;
+}
+
+int executor_runner() {
+  init_gpio_pins();
+  stdio_init_all();
+  sleep_ms(1000);
+
+  wait_for_usb();
+  runtime_init();
+
+  static uint8_t method_allocator_pool[32 * 1024]; // 32KB
+  static uint8_t activation_pool[64 * 1024]; // 64KB
+  MemoryAllocator method_allocator(
+      sizeof(method_allocator_pool), method_allocator_pool);
+  method_allocator.enable_profiling("method allocator");
+  Span<uint8_t> memory_planned_buffers[1]{
+      {activation_pool, sizeof(activation_pool)}};
+  HierarchicalAllocator planned_memory({memory_planned_buffers, 1});
+  MemoryManager memory_manager(&method_allocator, &planned_memory);
+
+  std::unique_ptr<Program> program_ptr;
+  std::unique_ptr<Method> method_ptr;
+  if (!load_and_prepare_model(program_ptr, method_ptr, memory_manager)) {
+    printf("Failed to load and prepare model\n");
+    return 1;
+  }
+  if (!run_inference(*method_ptr)) {
+    printf("Failed to run inference\n");
+    return 1;
+  }
+
+  // If everything went well, it will blink the indicator pin
+  blink_indicator(INDICATOR_PIN_1, 10, 500);
+  return 0;
+}
+
+int main() {
+  return executor_runner();
+}