https://community.element14.com/products/raspberry-pi/Join the Raspberry Pi Community, learn about the Pi 5 and the family of the single board computeren-USTelligent Community 12https://community.element14.com/products/raspberry-pi/b/blog/posts/detecting-objects-with-the-raspberry-pi-ai-camera-and-a-raspberry-pi-5----version-1Sat, 07 Nov 2026 11:26:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:33b7e721-8d43-412d-9f27-2538f8b975efRobinB13As an intern for the element14 community, I carried out this project as part of the tasks I had during my internship. The idea is simple: use a Raspberry Pi 5 and a Raspberry Pi AI Camera to recognize everyday objects, and build the project in four steps so that each one adds a single new feature to the previous one. Here is the progression. First, version 1: I set up the camera and print the objects it detects in the terminal. Second, version 2: I take a picture and save it, together with a copy annotated with the detected objects. Third, version 3: I run detection on a live video stream. Fourth, version 4: I'll try to make the video stream reachable from another PC. What Hardware and Software I used To get this project going, I used a Raspberry Pi 5 8GB (RAM is optional but try to get one >= 8GB, even with nowadays RAM price inflation >:(...) with its dedicated Active Cooler , and a Raspberry Pi AI Camera , with its sensor called IMX500. What makes this camera special is that it runs its neural network (the model that recognize objects) on the camera itself, not on the Pi's processor, it receives only the images and the results. You'll also need some storage, like a microSD card not less than 32GB, to carry out the OS and potential pictures and videos taken (if you get to this step ). To power up all this, the official PSU from Raspberry Pi works perfectly, and to avoid using your beloved monitor and unplug it from your beautiful PC setup, a Touch Display 2 7" will do the job wonderfully. The model used in every version is the file /usr/share/imx500-models/imx500_network_ssd_mobilenetv2_fpnlite_320x320_pp.rpk . From its name, it is an SSD MobileNetV2 FPNLite model with a 320x320 input. The .rpk extension is the packaged format loaded onto the camera ==> I didn’t just pull that out of the hat; you'll see how I did it in a minute! From the import lines of my files, the Python libraries involved are picamera2 (camera control), libcamera, numpy, Pillow (image saving and drawing, step2) and openCV (cv2, live display, step3). The live window of step3 also needs a desktop session on the Pi. Version 1 - Setup the environment and the camera Goal: Check that the camera works and that it can detect objects, printed as text in the terminal **You can read through that link on how to configure your Raspberry Pi** First of all: it is needed to ask the Pi if any updates are available, and install everything we'll need onto it: the different python packages mentioned earlier, as well as the imx500 resources. Once those have been installed, a well deserved REBOOT is needed for our Pi. Then to keep it in the momentum and not let it cool down, lets see how we can get the model quoted higher: First, to see if the AI Camera is detected, the command rpicam-hello --list-camera is perfectly well designed, and we search through the imx500 directory(tab key will be your best friend): And we can see at the end of the list our model! Lovely! Then we need to load the model into the camera, start the video stream and decode the results. A python source file is in charge of that, which I named... Detector.py. Not very original I reckon... :P It has a function named read(), that returns one video frame and a list of detections: A detection is a small Detection object holding a label, a confidence conf and a bounding box . The confidence is the model's certainty, from 0 to 1. Detections with a score at or below the threshold are ignored. The test script hello_detect.py then simply calls read() from Detector.py in a loop and prints in the terminal what it finds using the Objects.txt file (labels list): The defaults are a threshold of 0.55 and a duration of 15 seconds, both adjustable with --threshold and --duration in the main python file named hello_detect.py Now, lets try to launch the main python file to see if anything works: And... it works! As you can see at the end of the output, the camera detected a person standing in front of it. Was it me? Maybe... :P As mentioned earlier, I showcase the arguments I created in hello_detect.py by using --duration, setting the time capture for this demo at 3 seconds. Difficulty encountered / that may happen Those are basics but really time wasting and frustrating: Camera not detected? Take a look at your connections to the Pi (: One that really got me on my nerves is microSD card being on read-only after a re-write. I started on a different Pi, first OS write has been successful on the first try. Once I got the one Pi that I ordered, I told myself that I'll start from the beginning again! Well... I don't know how, but when I wanted to re-write on the SAME microSD card, I couldn't, which took me fairly one hour to understand why... Conclusion And that's it for the version 1 of this project! I've set up the AI Camera, loaded an object-detection model, and confirmed that detections appear in the terminal. It's a simple first step, but it lays the foundations for the version 2: Taking a picture and saving an annotated copy with the detected objects marked on it .raspberry piai camerahttps://community.element14.com/products/raspberry-pi/f/forum/57410/rpi5---pcn-65-revision-7-pcb/238904Thu, 05 Nov 2026 14:33:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:5a86fbbe-5d12-4768-b8b1-cba11ccadc09spindenwonder if this would allow for getting lower density ram times two to allow for lower overall costhttps://community.element14.com/products/raspberry-pi/m/files/151979Wed, 04 Nov 2026 16:26:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:79d2fd5c-3dff-4a8f-8077-90decf9bc555cstantonMirror of https://pip-assets.raspberrypi.com/categories/1129-pcn/documents/RP-010685-PC-2-PCN%2065_%20Change%20of%20Raspberry%20Pi%205%20PCB%20to%20Revision%207.pdfraspberry pi 5revision 7 pcbpcn 65https://community.element14.com/products/raspberry-pi/f/forum/57410/rpi5---pcn-65-revision-7-pcbWed, 04 Nov 2026 15:27:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:ea1c6b25-38ee-4422-99c4-32dd4a04e801geraldsHi all, its just an info: the RPi 5 PCB comes in revision 7: Raspberry Pi 5 PCN 65 - Revision 7 PCB best regards Geraldraspberry pihttps://community.element14.com/products/raspberry-pi/m/managed-videos/151956Mon, 26 Oct 2026 19:14:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:15ddd3f0-97f3-4787-8733-d4e2a20bc7f6Jan CumpsTemplated PID controller, where you can select the underlying data type (and precision, and CPU burden) for element14 blog: https://community.element14.com/products/raspberry-pi/b/blog/posts/pico-low-jitter-pid-controllerraspberrypicopidarmc++https://community.element14.com/products/raspberry-pi/b/blog/posts/pico-low-jitter-pid-controllerSat, 24 Oct 2026 11:35:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:36643f32-3cec-4e14-b156-2c94a2368691Jan CumpsIn my blog Pico PID controller without floating point using DSP C++ fixed point API , I created a low footprint Pico PID example. In this post, I reduce jitter by making sample clock steady, and let that drive the PID loop execution. I used Google AI in this blog post to help explain jitter aspects, and help to set up ADC timer and trigger code. All narrative is written by me, except where explicitly stated. In a PID control loop, an inconsistent sample time can introduce jitter in the regulation. By letting a clock drive the exact ADC timing, the sample cadence becomes deterministic. This content is AI generated by Google Gemini: PID loop scheduling vs ADC sample scheduling: impact on firmware In the code of the previous post, a Pico timer generated an interrupt. That interrupt was the driver of executing a full PID loop: sample the output let PID calculate ideal PWM duty cycle, to have output match desired output set the PWM In the deterministic sample design, there is no longer a clock that makes the PID tick. The ADC clock ticks the sample time, ADC ready interrupt pushes the regulation ADC clock initiates sample ADC raises interrupt when sample done When the interrupt happens: let PID calculate ideal PWM duty cycle, to have output match desired output set the PWM (see end of this post: I replaced the PWM API call by a CPU-less DMA approach). Real time startup behaviour, set to regulate output to 50%: slomo 4X: https://youtu.be/zgpOERTVS_A Source Code #include "fixed_point.hpp" #include "hardware/adc.h" #include "hardware/gpio.h" #include "hardware/pwm.h" #include "hardware/irq.h" #include "hardware/clocks.h" import pid; using namespace arm_cmsis_dsp; using fp_t = Q15; constexpr Q15 operator""_fp(long double val) { return operator""_q15(val); } using pid_controller_t = pid::pid ; // ADC and PWM declarations // Pico SDK types are used here: const uint ADC_PIN = 26; const uint PWM_PIN = 0; const uint PWM_CHANNEL = 0; // frequency of PWM will be 125 MHz (on Pico1, 150 on Pico2) / (PWM_MAX * CKDIV) // i.e. about 30.5 kHz for PWM_MAX = 4095 const uint PWM_MAX = 4095; const float CKDIV = 1; // set CKDIV to 1 for approx 30.5 / 36.62 kHz PWM frequency if PWM_MAX is 4095 const uint32_t pwm_frequency = clock_get_hz(clk_sys) / (PWM_MAX * CKDIV); const uint32_t adc_frequency = pwm_frequency / 10; // 3.663 kHze PID loop rate, 1/10 of PWM frequency const float adc_clock_div = clock_get_hz(clk_adc) / adc_frequency; // PID variables and objects fp_t feedback; constinit fp_t target_command = 0.66_fp; // Example target command in fixed point per-unit (0.0 to 1.0) constinit fp_t output_pid = 0.0_fp; // Initialize output_pid to 0.0 in fixed point per-unit pid_controller_t controller(0.1_fp, 0.01_fp, 0.05_fp); // Example PID gains for voltage control // GPIO pin, to measure duration of a PID loop const uint GPIO_PIN = 22; // happens to be the Pico Eurocard LED void __not_in_flash_func(adc_pid_handler)() { gpio_xor_mask(1u ((adc_fifo_get()) (output_pid.v >> 3)); // set PWM value gpio_xor_mask(1u ((adc_fifo_get()) (controller.compute(target_command, feedback).v >> 3); // set PWM value dma_channel_set_trans_count(dma_chan, 1, true); The samples happen clock steady every 276 µs. Measurements done on a Pico 2 / RP2350 ARM, at the default 150 MHz. I used a GPIO pin to measure both times, toggled in the ADC interrupt handler. It's not an exact representation of when the sample happens, and when the PID is finished. But I think this is a reasonable way to validate timings. references: Development kit: Pi Pico Eurocard Development Board Previous Pico PID blog: Pico PID controller without floating point using DSP C++ fixed point API PID class GitHub repository VS Code project - with DMA. Configured for Pico 2 / RP3250 ARM . Check the CMake section above to configure for an RP2040. The non-dma source is available as main.cpp.pidtimer : community.element14.com/.../pico_5F00_pid_5F00_template_5F00_dma_5F00_20261024-_2800_2_2900_.zip VS Code project - with DMA. Configured for Pico 2 / RP3250 RISC community.element14.com/.../pico_5F00_pid_5F00_template_5F00_20261025_5F00_riscv.zip . Thank you for readingpico2picoc++26pico_eurocardpico c sdkpid_controllerc++