Skip to content

Arducam IMX500 AI Camera for MCU/SoC

Introduction

Arducam’s latest innovation transforms the Sony IMX500 into a truly universal AI camera series. Breaking free from the limitations of previous experimental modules, this new platform is engineered to bridge the ecological gap between microcontrollers (MCUs) and high-end SoCs, offering a standardized, scalable vision solution.

Redefining the boundaries of embedded vision. Unlike traditional solutions that rely on heavy operating systems, this module enables MCU-grade AI. It delivers instantaneous on-device processing, ultra-low power consumption, and industrial-grade stability—perfect for scenarios where privacy, latency, and energy efficiency are paramount.

The heart of the module is Sony's IMX500 Intelligent Vision Sensor, integrating pixel sensing and logic computation on a single chip. We have unlocked its full potential for the embedded world, allowing developers to deploy sophisticated AI models on platforms like ESP32 P4, Arduino, and Raspberry Pi without the complexity of a full Linux stack.

Product

Product Image SKU Supported Platform Product Type Max Resolution Resolution@fps Camera Interface Power Supply Lens Mount FOV(DxHxV) Features
B0642-1 MCU 12.3MP Camera Module 12.3MP / SPI/MIPI CSI M12 82°(D)×72°(H)×56°(V) AI Camera
B0642-2 ESP32 P4 12.3MP Camera Bundle Kit 12.3MP with AI: 1024x600@20fps SPI/MIPI CSI M12 82°(D)×72°(H)×56°(V) ESP32 P4 AI Camera Bundle Kit

User Guide for Raspberry Pi Pico

Hardware Device List

Item Quantity(PCS)
Arducam IMX500 AI Camera for MCU/SoC 1
Raspberry Pi Pico 2 Dev Board 1
8-pin Dupont Cable 1
Micro-USB Cable 1

Wiring Tutorial

All Pico 2 examples in this directory use the same hardware interface to the IMX500 camera module:

  • I2C0 for control
  • SPI0 for data

The same pin mapping is used by:

  • integration_test
  • camera_serial_stream_multitask
  • production_test

1. Read the Camera Header First

b0642-connect-pico

Based on the hardware image, the camera board exposes an 8-pin header. In the image orientation, the pins appear in this order from left to right:

Camera pad Signal on camera board
8 I2C SDA
7 +3v3
6 DGND
5 SPI_SCK_3v3
4 SPI_RX_3v3
3 SPI_TX_3v3
2 SPI_CS_3v3
1 I2C SCL

Important

  • This left-to-right order is only valid for the same viewing direction as the image.
  • If you flip the board or view it from the opposite side, the physical order will appear reversed.
  • When wiring by hand, always confirm both the pad number and the signal name on the PCB silk.

Use the following mapping between the camera board and Pico 2:

Camera pad Camera signal Pico 2 connection Pico 2 function
8 I2C SDA GPIO20 I2C0 SDA
1 I2C SCL GPIO21 I2C0 SCL
5 SPI_SCK_3v3 GPIO18 SPI0 SCK
4 SPI_RX_3v3 GPIO19 SPI0 TX
3 SPI_TX_3v3 GPIO16 SPI0 RX
2 SPI_CS_3v3 GPIO17 SPI chip select
7 +3v3 3V3(OUT) 3.3 V power
6 DGND GND Ground

3. Why SPI_TX and SPI_RX Can Be Confusing

This is the part that usually causes mistakes.

The camera board silk uses SPI_TX and SPI_RX from the camera side. Pico 2 uses SPI0 TX and SPI0 RX from the MCU side. Because of that:

  • Pico TX must connect to camera RX
  • Pico RX must connect to camera TX

So the correct SPI cross-connection is:

  • GPIO19 (Pico SPI0 TX) -> camera pad 4 (SPI_RX_3v3)
  • GPIO16 (Pico SPI0 RX) -> camera pad 3 (SPI_TX_3v3)

If you instead connect TX -> TX and RX -> RX, SPI communication will not work.

4. Wiring Diagram

Pico 2                         IMX500 camera board
-----------------------------------------------------------
GPIO20  (I2C0 SDA)        ->   Pad 8  (I2C SDA)
GPIO21  (I2C0 SCL)        ->   Pad 1  (I2C SCL)
GPIO18  (SPI0 SCK)        ->   Pad 5  (SPI_SCK_3v3)
GPIO19  (SPI0 TX / MOSI)  ->   Pad 4  (SPI_RX_3v3)
GPIO16  (SPI0 RX / MISO)  <-   Pad 3  (SPI_TX_3v3)
GPIO17  (SPI CS)          ->   Pad 2  (SPI_CS_3v3)
3V3(OUT)                  ->   Pad 7  (+3v3)
GND                       ->   Pad 6  (DGND)

5. Wiring Checklist

Before powering the board:

  1. Connect GND first.
  2. Connect 3V3(OUT) to the camera +3v3 pin.
  3. Connect the two I2C lines: GPIO20 -> SDA and GPIO21 -> SCL.
  4. Connect the four SPI lines: SCK, TX -> RX, RX -> TX, and CS.
  5. Double-check that 3.3 V is used. Do not feed 5 V into the camera signal pins.
  6. Power Pico 2 through USB only after the wiring is complete.

6. Troubleshooting

Troubleshooting

  • If the camera is not detected, first check GND, 3V3, SDA, SCL, and CS.
  • If the module powers up but data transfer fails, check whether SPI_TX and SPI_RX were crossed correctly.
  • If you changed the wiring, update the corresponding g_config.h file in the example you are building.
  • The examples expect both I2C and SPI to be connected. I2C alone is not enough.

7. Pin Definitions Used by the Current Code

The current Pico 2 examples all use:

#define I2C_SDA_PIN 20
#define I2C_SCL_PIN 21
#define SPI_SCK_PIN 18
#define SPI_TX_PIN 19
#define SPI_RX_PIN 16
#define SPI_CSN_PIN 17

These definitions are consistent across:

  • examples/platform/rpi/pico2/integration_test/g_config.h
  • examples/platform/rpi/pico2/camera_serial_stream_multitask/g_config.h
  • examples/platform/rpi/pico2/production_test/g_config.h

Pico2-IMX500 Camera Serial Stream (Multitask)

This example consolidates the four task-oriented camera_serial_stream_* demos into a single Pico2 serial-forwarding firmware project with one host-side Python receiver script.

The Pico2 firmware is task-agnostic. It forwards read_metadata(...) frames over USB serial, while the host script uses --task to select the matching parser and renderer for the model already programmed on the IMX500 camera module.

Supported tasks

  • classification -> tools/assets/models/mobilenet_v2
  • object_detection -> tools/assets/models/ssd_mobilenetv2_fpnlite
  • pose_estimation -> tools/assets/models/higherhrnet
  • segmentation -> tools/assets/models/deeplabv3plus

1. Build and flash the Pico2 firmware

cd examples/platform/rpi/pico2/camera_serial_stream_multitask
mkdir build
cd build
cmake ..
cmake --build .

Flash imx500_camera_serial_stream_multitask.uf2 to Pico2.

2. Install host dependencies

pip install pyserial numpy opencv-python flatbuffers

For pose estimation, install one additional dependency:

pip install munkres

3. Run the host receiver

List the supported task names:

python host_receiver.py --list-tasks

Run classification and save annotated JPEGs:

python host_receiver.py --task classification --save-img --save-metadata-json --save-tensors

Run object detection:

python host_receiver.py --task object_detection

Run pose estimation with realtime preview:

python host_receiver.py --task pose_estimation --show-img --show-fps

Run segmentation:

python host_receiver.py --task segmentation

Useful options:

Useful Options

  • --port: explicitly select a serial port instead of auto-detecting one
  • --list-ports: print all currently available serial ports and exit
  • --output: override the task-specific default output directory
  • --max-payload: override the task-specific payload safety limit
  • --save-img: save annotated JPEGs (disabled by default)
  • --save-raw: save the original framed metadata payload as .bin
  • --save-metadata-json: save parsed metadata summaries as .json
  • --save-tensors: save parsed tensor arrays as .npz
  • --save-original: save the decoded JPEG before annotation
  • --show-img: show the annotated OpenCV preview window for any supported task
  • --show-fps: print host-side render/postprocess FPS for any supported task

4. Notes

Application Note

  • --task must match the network currently loaded on the IMX500 camera module.
  • If --port is omitted, the host script tries to auto-detect the Pico2 USB CDC port.
  • If multiple likely serial ports are present, use --list-ports to inspect them and then pass --port.
  • The host receiver now prints device-side text logs, including firmware startup messages and runtime status lines, while still parsing binary frame packets.
  • Annotated JPEGs are not written unless --save-img is provided.
  • The serial packet format is unchanged from the existing camera_serial_stream_jpeg and task-specific demos.
  • The multitask host script keeps its reusable Python helpers under camera_serial_stream_multitask/common for packet extraction, metadata parsing, and rendering.
  • open(nullptr, 0, nullptr, 0, ...) intentionally does not pass model data from Pico2. Pico flash is too small to store both the forwarding firmware and an IMX500 .fpk package, so the model must be programmed onto the camera module separately.

To program a model onto the IMX500 camera module:

  1. Hold the Mode button on the camera module, then connect it to the host PC over USB Type-C.
  2. Run command python tools/imx500_usb_flash.py --model <selected_network.fpk> --network-info <selected_network_info.txt>

The programmed model must also match the host-side --task selection.