Back to all projects
Sipeed MaixCAM Pro edge AI vision board on a stand, connected to a display showing detection analytics

Advanced

Build an Advanced Edge Vision Station

SensorsIoT

A genuine step up from microcontroller-class edge AI: a full Linux-class RISC-V board with its own onboard NPU, built to run serious, demanding vision models locally, no cloud, no compromise on capability.

1 real parts included

Total for this kit: 4,462.00 ฿

Doesn't include any order discount you may get at checkout.

What you'll need

Project Goal

This project uses a genuinely higher tier of edge AI hardware than the rest of this catalog's vision boards: a full Linux-class RISC-V system with its own onboard NPU, camera, screen support, and audio, all on one board. Where a microcontroller-class board is limited to small, simple models, this board is built to run real, demanding vision workloads entirely on-device.

What the Board Does

It runs a full embedded Linux environment on real RISC-V silicon, with a dedicated NPU handling model inference separately from the main processor. Camera capture, model inference, and screen output can all happen on the same board simultaneously, without the careful resource budgeting a small microcontroller project requires.

What Makes This Different From a Microcontroller Board

Our entry-level edge AI boards (the XIAO ESP32S3 Sense, the Grove Vision AI Module) are genuinely capable, but they run small, purpose-built models within tight memory limits. This board runs a real operating system, supports more demanding models, and gives you a proper development environment on the device itself, a meaningfully different class of hardware for builders who have outgrown a microcontroller.

Software and Library Concepts

Start with one of the board's own official example applications running end to end before writing anything custom, this confirms the camera, NPU, and display are all working together correctly and gives a known-good baseline to modify from.

Testing and Troubleshooting

  • Firmware or software feels behind the hardware's capability, this is a genuinely newer board with an actively developing software ecosystem, check for the latest official firmware release before assuming a hardware fault.
  • Display shows nothing or the wrong content, confirm your code's configured screen resolution actually matches the physical display you have connected, a real and specifically documented gotcha on this board family.
  • Model inference is slower than expected, confirm the model is actually compiled to run on the onboard NPU rather than falling back to the general-purpose CPU.

Optional Upgrade

Once a working vision model is running, connect it to the buzzer or an LED from the parts bin as a simple physical output, closing the loop from what the camera sees to a real action in the physical world.

Wiring

  • Sipeed MaixCAM Pro USB-C → PC/USB power supply — this is a standalone Linux-based SBC-style board with an onboard camera and NPU; there is no breadboarding required for a starter setup

Important framing: the MaixCAM Pro is not an Arduino-sketch target. It's a RISC-V edge-AI vision board with an onboard NPU that boots its own Linux-based OS and runs Sipeed's own software stack (MaixPy/MaixCPY, a Python-based SDK, or Linux userspace applications) — not C++ Arduino firmware flashed the way the other boards in this batch are.

The exact current MaixPy/Sipeed API function names, module paths, and camera/display object methods for this board can differ by SDK version, so rather than assert specific function names as verified fact, the code below is illustrative pseudocode showing the general shape of a MaixPy camera-open-and-display loop (a real, common pattern for this class of board), clearly labeled as illustrative — not copy-paste-verified against Sipeed's current SDK. For the real, correct API calls, model-loading syntax, and NPU inference calls, defer to Sipeed's own official MaixCAM Pro / MaixPy documentation and example repository, which is the authoritative and current source.

Starter Code

# ILLUSTRATIVE ONLY — shows the general shape of a MaixPy-style camera/display
# loop on Sipeed's MaixCAM Pro. Exact module names, object methods, and NPU
# model-loading calls are NOT verified against the current official SDK —
# confirm all API names/usage against Sipeed's official MaixCAM Pro / MaixPy
# documentation and example code before relying on this.

from maix import camera, display, image  # illustrative import shape — confirm real module paths in Sipeed's docs

def main():
    cam = camera.Camera()      # illustrative — open the onboard camera
    disp = display.Display()   # illustrative — open the onboard/attached display output

    while True:
        img = cam.read()       # illustrative — capture a frame

        # Real object/person detection on this board's NPU requires loading
        # a model via Sipeed's own model-loading + inference API (e.g. their
        # documented NPU/model runner calls) — see Sipeed's official MaixCAM
        # Pro examples for the real, current syntax rather than fabricated
        # calls here.

        disp.show(img)          # illustrative — push the frame to the display

if __name__ == "__main__":
    main()

Not sure about a step? Ask us

Try this next

Small plastic project enclosure with AHT20 sensor and ESP32-C3 breadboard, on a windowsill Build a Room Temperature & Humidity Monitor WS2812B LED strip glowing warm on a desk edge, wired to PIR sensor and ESP32-C3 on a breadboard Build a Motion-Activated Desk Light Small enclosure and breadboard with ESP32-C3, AHT20, SD card module and DS3231 RTC, laptop showing logged data graph Build a Wireless Environmental Data Logger