> ## Documentation Index
> Fetch the complete documentation index at: https://docs.edgeimpulse.com/llms.txt
> Use this file to discover all available pages before exploring further.
# YOLO-Pro Smart Parking Meter - Rubik Pi 3
Created By: Jallson Suryo
Public Project Link: [https://studio.edgeimpulse.com/public/624749/live](https://studio.edgeimpulse.com/public/624749/live)
Demo Video link: [https://youtu.be/x9OswYAFIKg](https://youtu.be/x9OswYAFIKg)
GitHub Repo: [https://github.com/Jallson/YOLO\_based\_Parking\_Meter](https://github.com/Jallson/YOLO_based_Parking_Meter)
For the same project built using a Raspberry Pi, check this link:
[https://docs.edgeimpulse.com/projects/expert-network/smart-parking-meter-raspberry-pi](https://docs.edgeimpulse.com/projects/expert-network/smart-parking-meter-raspberry-pi)
## Problem Statement
Traditional on-street parking enforcement, which relies on static signage, time-limited meters, and periodic monitoring by human attendants, is prone to inefficiencies, non-compliance, and enforcement gaps. These limitations often result in parking misuse, particularly in areas with time-restricted or paid zones, undermining both urban regulation and revenue. In the context of smart cities, there is a need for automated, intelligent systems that can monitor parking behavior in real time.
## Solution
To address this challenge and as part of a learning process in deploying vision-based Edge AI, we developed this project powered by Edge Impulse's YOLO Pro object detection. The model is trained and optimized using Edge Impulse Studio, then deployed on a [Thundercomm Rubik Pi 3](https://rubikpi.ai) for real-time inference. Leveraging transfer learning and pre-trained weights from YOLO Pro, we significantly reduced the amount of data required for model training while maintaining high accuracy for our targeted use case. This system integrates seamlessly with Python-based tracking logic, enabling enforcement of zone-specific parking rules (e.g., no-parking zones, paid durations, violation thresholds) with visual feedback and temporal tracking. The result is a low-cost, energy-efficient, and scalable solution suitable for modern urban parking management — a Smart Parking Meter.
### Hardware Components
* [Rubik Pi 3](https://rubikpi.ai)
* USB-C Power Adaptor (eg. 27W Pi 5 Power adapter)
* Raspberry Pi 5 Active Cooler (optional)
* 3D print case (optional)
* PC/laptop (for ssh and EDL mode firmware flash)
* Keyboard, mouse
* USB-C/A to USB-C
* USB-C/A to micro-USB
* USB Camera/webcam (eg. Logitech C920/C922)
* LCD/monitor with HDMI cable
* Mini tripod
* Car Miniatures with Street Parking setup
### Software & Online Services
* Edge Impulse Studio
* Edge Impulse Linux & Python SDK
* Ubuntu OS (24.04)
* OpenCV
## Steps
### 1. Preparing the Rubik Pi
When we receive the Rubik Pi 3, we will find it pre-installed with either Qualcomm Linux (based on Yocto), or a minimal Ubuntu OS version. If yours comes with QC Linux, you need to switch to Ubuntu OS, because it lacks `apt` and `dpkg` package managers, has limited OpenCV, GStreamer support, and runs in a restricted environment.
Prepare a USB-C and a micro-USB cable, then follow this link — [https://softwarecenter.qualcomm.com/catalog/item/Qualcomm\_Launcher](https://softwarecenter.qualcomm.com/catalog/item/Qualcomm_Launcher) — to download Qualcomm Launcher. Next, follow the instructions here: [https://www.thundercomm.com/rubik-pi-3/en/docs/rubik-pi-3-user-manual/1.0.0-u/Update-Software/3.2.Flash-using-Qualcomm-Launcher](https://www.thundercomm.com/rubik-pi-3/en/docs/rubik-pi-3-user-manual/1.0.0-u/Update-Software/3.2.Flash-using-Qualcomm-Launcher) to perform the flashing and switch the Rubik Pi to Ubuntu OS.
Once successfully flashed, connect to the network, reboot and login (ubuntu/ubuntu for user/password), open up the terminal/ssh then you can proceed to install the Edge Impulse CLI:
```
sudo apt update
curl -sL https://deb.nodesource.com/setup_20.x | sudo bash -
sudo apt install -y gcc g++ make build-essential nodejs sox gstreamer1.0-tools gstreamer1.0-plugins-good gstreamer1.0-plugins-base gstreamer1.0-plugins-base-apps
sudo npm install edge-impulse-linux -g —unsafe-perm
```
> Note: For the Python SDK and other dependencies, follow the instruction as described in Step 5 below.
**Desktop / display problems and troubleshooting**
By default, the Rubik Pi Ubuntu flashing process will only install the command-line (Server) version of Ubuntu. To add a Desktop, you can try the following solutions:
**Option 1: Install LXDE / Light desktop**
Run the following commands:
```
sudo apt update
sudo apt install lxde
sudo reboot
```
**Option 2: Install Ubuntu Desktop version (recommended)**
Run the following commands:
```
sudo apt install qcom-adreno1- libgbm-msm1- libegl-mesa0 libegl1 libgles2 libglvnd0 libvulkan1 weston-
sudo apt install ubuntu-desktop
sudo reboot
```
### 2. Collecting Data
In the initial stage of building a model in Edge Impulse Studio, we need to prepare the data. You can collect your own data to better suit the purposes of your project; in this case we capture from smartphone/camera and save them in a folder. For those who are not familiar with Edge Impulse Studio, please follow these steps —> Open [studio.edgeimpulse.com](https://studio.edgeimpulse.com), login or create an account then create a new project. Choose Images project option, then Object detection. In Dashboard > Project Info, choose **Bounding Boxes** for labeling method and \**Rubik Pi 3* for target device. Then in Data acquisition, click on Upload Data tab. Choose your saved folder then upload.
You also can connect a USB camera to the Rubik Pi and connect to Edge Impulse Studio to collect images. With the Edge Impulse Linux CLI setup on the Rubik Pi, run: `edge-impulse-linux --clean`
This will start a wizard which asks you to login and choose your project, then connects your Rubik Pi with USB camera to your Studio project to collect photos.
### 3. Labeling
The next step is labeling, now click on Data Acquisition, click on Labeling queue tab, then drag a box around an object and label it, then click Save. Repeat this until all images are labelled. Alternatively, you can try Edge Impulse's new feature [AI auto labeling](/studio/projects/data-acquisition/ai-labeling) to help speed things up.
After labeling, it's recommended to split the data into Training and Testing sets, around an 80/20 ratio. If you haven't done this yet, click on Train / Test Split to automate this process.
### 4. Train and build Yolo-Pro model
Once your labelled dataset is ready, go to Impulse Design > Create Impulse, and set the image width and height to **320x320**. Choose Fit shortest axis, then select Image and Object Detection as the learning blocks, and click Save Impulse. Next, navigate to the Image Parameters section, select RGB as the color depth, and press Save parameters. After that, click on Generate, where you'll be able to see a graphical distribution of the feature data.
Now, move to the Object Detection section and configure the training settings. Select GPU and set the training cycles to around 200, learning rate to 0.001 and medium for model size. Choose **YOLO-Pro** as the NN architecture. Once done, start training by pressing Start, and monitor the progress.
If everything goes well and the precision result is around 90%, proceed to the next step. Go to the Model Testing section, click Classify all, and if the result is around 90%, you can move on to the final step — Deployment.
### 5. Deploy Model on Rubik Pi
Simply ensure that the model has been built in Edge Impulse Studio. Now, you can test, download the model, and run everything directly from the Rubik Pi (Ubuntu 24.04).
On the Rubik, there are several things that need to be done. Install a recent version of Python 3 (>= 3.7). Ubuntu 24.04 should comes with with Python 3.12 installed. You can verify this by running this command: `python3 —version`.
Ensure you have the latest Edge Impulse Linux CLI installed (in Step 1). Then install the Linux Python SDK, OpenCV, ffmpeg, Gstreamer, numpy and other dependencies:
```
sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-pip python3-opencv ffmpeg gstreamer1.0-tools gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav libportaudio2
pip3 install numpy
pip3 install edge_impulse_linux
```
You can clone this repository to get the examples: `git clone https://github.com/edgeimpulse/linux-sdk-python`
Then install other dependencies: `pip install -r requirements.txt`
Next, build/download/run the model via the Edge Impulse runner. Open a terminal on the Rubik Pi or ssh from your PC/laptop then simply type `edge-impulse-linux-runner` (you can add `--clean` to allow you to select your project if you've tried a different project in the past). Log in to your account then choose your project. Then choose your specific Impulse (if any) and be sure to select **quantized model**. This process will download the `model.eim`, which is specifically built for aarch64 QNN (Qualcomm Hexagon) architecture. During this process, the console will display the path where the `model.eim` has been downloaded. For example, in the image below, it shows the file located at `/home/ubuntu/.ei-linux-runner/models/624749/v10-quantized…../model.eim`
Once this file is downloaded, you can stop the inference process with Ctrl-C on the keyboard.
For convenience, you can use the following command to copy it to the home directory for easier access: `cp -v model.eim /home/ubuntu`
Now the model is ready to run in a high-level language such as Python. To ensure this model works, we can re-run the EI Runner with a camera attached to the Rubik Pi. You can see the camera feed and inference in a browser, at the local IP address of the Rubik on port 4912. Run this command once again: `edge-impulse-linux-runner`
The inferencing time is around 1-3ms on the Rubik Pi 3, which is very fast for object detection speed (around 40ms on a Raspberry Pi 3 as a reference).
### 6. Build a Smart Parking Application (Python)
With the impressive accuracy of live inferencing using the Edge Impulse Runner, we can now create a Python-based Parking Meter program. This code performs object tracking and parking duration analysis using bounding boxes detected by our YOLO-Pro model. For every frame, it identifies the location and size of detected cars, then attempts to match them with previously tracked objects using Intersection over Union (IoU), distance between centers, and size similarity. If a match is found, it checks whether the object has moved; if not, it updates the tracked object's "stopped" duration. If the object has moved or reappeared after more than 3 seconds, it resets the timer. The system only starts displaying bounding boxes if a car has remained stationary for 5 seconds or more, ensuring it is actually parked.
Each car is also assigned to one of four parking zones (A, B, C, or D) based on its location. Zone A and B allow parking but turn the bounding box red if the duration exceeds 30 or 100 seconds. Zone C is a no-parking zone and triggers a red box after just 5 seconds. Zone D is a paid parking area where the display shows a dollar amount instead of time, charging \$5 every 10 seconds. This zone-based logic allows for flexible rules depending on where the car is parked, and visual feedback is given via color-coded bounding boxes and overlaid text.
> Note: Minutes are converted to seconds. So that we don't have to wait for the actual parking time :-)
All code, images and videos can be accessed at: [https://github.com/Jallson/YOLO\_based\_Parking\_Meter](https://github.com/Jallson/YOLO_based_Parking_Meter)
With a USB camera connected to the Rubik Pi, run the program (`parkingmeter.py`) with the following command:
`python3 parkingmeter.py /model.eim`
Check out our demo video:
## Conclusion
We have successfully implemented a YOLO-Pro ML model into our Python-based visual parking meter system. Despite using a minimal dataset for training, the model achieved reliable accuracy in our use case. The integration of object detection and tracking allows the system to recognize parked vehicles, monitor their duration, and maintain consistent tracking even in challenging conditions like short disappearances or slight changes in bounding box size.
The system also supports multiple parking zones, each with its own enforcement rules, such as no-parking alerts, time-based violations, and dynamic fee calculation. This level of flexibility demonstrates the system's ability to adapt to real-world constraints while keeping resource usage low. With its real-time performance, simple setup, and cost-effective hardware, the project has successfully met our objectives. The result is also scalable, well-suited for broader deployment in smart city infrastructure.
## Problem Statement
Traditional on-street parking enforcement, which relies on static signage, time-limited meters, and periodic monitoring by human attendants, is prone to inefficiencies, non-compliance, and enforcement gaps. These limitations often result in parking misuse, particularly in areas with time-restricted or paid zones, undermining both urban regulation and revenue. In the context of smart cities, there is a need for automated, intelligent systems that can monitor parking behavior in real time.
## Solution
To address this challenge and as part of a learning process in deploying vision-based Edge AI, we developed this project powered by Edge Impulse's YOLO Pro object detection. The model is trained and optimized using Edge Impulse Studio, then deployed on a [Thundercomm Rubik Pi 3](https://rubikpi.ai) for real-time inference. Leveraging transfer learning and pre-trained weights from YOLO Pro, we significantly reduced the amount of data required for model training while maintaining high accuracy for our targeted use case. This system integrates seamlessly with Python-based tracking logic, enabling enforcement of zone-specific parking rules (e.g., no-parking zones, paid durations, violation thresholds) with visual feedback and temporal tracking. The result is a low-cost, energy-efficient, and scalable solution suitable for modern urban parking management — a Smart Parking Meter.
### Hardware Components
* [Rubik Pi 3](https://rubikpi.ai)
* USB-C Power Adaptor (eg. 27W Pi 5 Power adapter)
* Raspberry Pi 5 Active Cooler (optional)
* 3D print case (optional)
* PC/laptop (for ssh and EDL mode firmware flash)
* Keyboard, mouse
* USB-C/A to USB-C
* USB-C/A to micro-USB
* USB Camera/webcam (eg. Logitech C920/C922)
* LCD/monitor with HDMI cable
* Mini tripod
* Car Miniatures with Street Parking setup
### Software & Online Services
* Edge Impulse Studio
* Edge Impulse Linux & Python SDK
* Ubuntu OS (24.04)
* OpenCV
## Steps
### 1. Preparing the Rubik Pi
When we receive the Rubik Pi 3, we will find it pre-installed with either Qualcomm Linux (based on Yocto), or a minimal Ubuntu OS version. If yours comes with QC Linux, you need to switch to Ubuntu OS, because it lacks `apt` and `dpkg` package managers, has limited OpenCV, GStreamer support, and runs in a restricted environment.
Prepare a USB-C and a micro-USB cable, then follow this link — [https://softwarecenter.qualcomm.com/catalog/item/Qualcomm\_Launcher](https://softwarecenter.qualcomm.com/catalog/item/Qualcomm_Launcher) — to download Qualcomm Launcher. Next, follow the instructions here: [https://www.thundercomm.com/rubik-pi-3/en/docs/rubik-pi-3-user-manual/1.0.0-u/Update-Software/3.2.Flash-using-Qualcomm-Launcher](https://www.thundercomm.com/rubik-pi-3/en/docs/rubik-pi-3-user-manual/1.0.0-u/Update-Software/3.2.Flash-using-Qualcomm-Launcher) to perform the flashing and switch the Rubik Pi to Ubuntu OS.
Once successfully flashed, connect to the network, reboot and login (ubuntu/ubuntu for user/password), open up the terminal/ssh then you can proceed to install the Edge Impulse CLI:
```
sudo apt update
curl -sL https://deb.nodesource.com/setup_20.x | sudo bash -
sudo apt install -y gcc g++ make build-essential nodejs sox gstreamer1.0-tools gstreamer1.0-plugins-good gstreamer1.0-plugins-base gstreamer1.0-plugins-base-apps
sudo npm install edge-impulse-linux -g —unsafe-perm
```
> Note: For the Python SDK and other dependencies, follow the instruction as described in Step 5 below.
**Desktop / display problems and troubleshooting**
By default, the Rubik Pi Ubuntu flashing process will only install the command-line (Server) version of Ubuntu. To add a Desktop, you can try the following solutions:
**Option 1: Install LXDE / Light desktop**
Run the following commands:
```
sudo apt update
sudo apt install lxde
sudo reboot
```
**Option 2: Install Ubuntu Desktop version (recommended)**
Run the following commands:
```
sudo apt install qcom-adreno1- libgbm-msm1- libegl-mesa0 libegl1 libgles2 libglvnd0 libvulkan1 weston-
sudo apt install ubuntu-desktop
sudo reboot
```
### 2. Collecting Data
In the initial stage of building a model in Edge Impulse Studio, we need to prepare the data. You can collect your own data to better suit the purposes of your project; in this case we capture from smartphone/camera and save them in a folder. For those who are not familiar with Edge Impulse Studio, please follow these steps —> Open [studio.edgeimpulse.com](https://studio.edgeimpulse.com), login or create an account then create a new project. Choose Images project option, then Object detection. In Dashboard > Project Info, choose **Bounding Boxes** for labeling method and \**Rubik Pi 3* for target device. Then in Data acquisition, click on Upload Data tab. Choose your saved folder then upload.
You also can connect a USB camera to the Rubik Pi and connect to Edge Impulse Studio to collect images. With the Edge Impulse Linux CLI setup on the Rubik Pi, run: `edge-impulse-linux --clean`
This will start a wizard which asks you to login and choose your project, then connects your Rubik Pi with USB camera to your Studio project to collect photos.
### 3. Labeling
The next step is labeling, now click on Data Acquisition, click on Labeling queue tab, then drag a box around an object and label it, then click Save. Repeat this until all images are labelled. Alternatively, you can try Edge Impulse's new feature [AI auto labeling](/studio/projects/data-acquisition/ai-labeling) to help speed things up.
After labeling, it's recommended to split the data into Training and Testing sets, around an 80/20 ratio. If you haven't done this yet, click on Train / Test Split to automate this process.
### 4. Train and build Yolo-Pro model
Once your labelled dataset is ready, go to Impulse Design > Create Impulse, and set the image width and height to **320x320**. Choose Fit shortest axis, then select Image and Object Detection as the learning blocks, and click Save Impulse. Next, navigate to the Image Parameters section, select RGB as the color depth, and press Save parameters. After that, click on Generate, where you'll be able to see a graphical distribution of the feature data.
Now, move to the Object Detection section and configure the training settings. Select GPU and set the training cycles to around 200, learning rate to 0.001 and medium for model size. Choose **YOLO-Pro** as the NN architecture. Once done, start training by pressing Start, and monitor the progress.
If everything goes well and the precision result is around 90%, proceed to the next step. Go to the Model Testing section, click Classify all, and if the result is around 90%, you can move on to the final step — Deployment.
### 5. Deploy Model on Rubik Pi
Simply ensure that the model has been built in Edge Impulse Studio. Now, you can test, download the model, and run everything directly from the Rubik Pi (Ubuntu 24.04).
On the Rubik, there are several things that need to be done. Install a recent version of Python 3 (>= 3.7). Ubuntu 24.04 should comes with with Python 3.12 installed. You can verify this by running this command: `python3 —version`.
Ensure you have the latest Edge Impulse Linux CLI installed (in Step 1). Then install the Linux Python SDK, OpenCV, ffmpeg, Gstreamer, numpy and other dependencies:
```
sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-pip python3-opencv ffmpeg gstreamer1.0-tools gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav libportaudio2
pip3 install numpy
pip3 install edge_impulse_linux
```
You can clone this repository to get the examples: `git clone https://github.com/edgeimpulse/linux-sdk-python`
Then install other dependencies: `pip install -r requirements.txt`
Next, build/download/run the model via the Edge Impulse runner. Open a terminal on the Rubik Pi or ssh from your PC/laptop then simply type `edge-impulse-linux-runner` (you can add `--clean` to allow you to select your project if you've tried a different project in the past). Log in to your account then choose your project. Then choose your specific Impulse (if any) and be sure to select **quantized model**. This process will download the `model.eim`, which is specifically built for aarch64 QNN (Qualcomm Hexagon) architecture. During this process, the console will display the path where the `model.eim` has been downloaded. For example, in the image below, it shows the file located at `/home/ubuntu/.ei-linux-runner/models/624749/v10-quantized…../model.eim`
Once this file is downloaded, you can stop the inference process with Ctrl-C on the keyboard.
For convenience, you can use the following command to copy it to the home directory for easier access: `cp -v model.eim /home/ubuntu`
Now the model is ready to run in a high-level language such as Python. To ensure this model works, we can re-run the EI Runner with a camera attached to the Rubik Pi. You can see the camera feed and inference in a browser, at the local IP address of the Rubik on port 4912. Run this command once again: `edge-impulse-linux-runner`
The inferencing time is around 1-3ms on the Rubik Pi 3, which is very fast for object detection speed (around 40ms on a Raspberry Pi 3 as a reference).
### 6. Build a Smart Parking Application (Python)
With the impressive accuracy of live inferencing using the Edge Impulse Runner, we can now create a Python-based Parking Meter program. This code performs object tracking and parking duration analysis using bounding boxes detected by our YOLO-Pro model. For every frame, it identifies the location and size of detected cars, then attempts to match them with previously tracked objects using Intersection over Union (IoU), distance between centers, and size similarity. If a match is found, it checks whether the object has moved; if not, it updates the tracked object's "stopped" duration. If the object has moved or reappeared after more than 3 seconds, it resets the timer. The system only starts displaying bounding boxes if a car has remained stationary for 5 seconds or more, ensuring it is actually parked.
Each car is also assigned to one of four parking zones (A, B, C, or D) based on its location. Zone A and B allow parking but turn the bounding box red if the duration exceeds 30 or 100 seconds. Zone C is a no-parking zone and triggers a red box after just 5 seconds. Zone D is a paid parking area where the display shows a dollar amount instead of time, charging \$5 every 10 seconds. This zone-based logic allows for flexible rules depending on where the car is parked, and visual feedback is given via color-coded bounding boxes and overlaid text.
> Note: Minutes are converted to seconds. So that we don't have to wait for the actual parking time :-)
All code, images and videos can be accessed at: [https://github.com/Jallson/YOLO\_based\_Parking\_Meter](https://github.com/Jallson/YOLO_based_Parking_Meter)
With a USB camera connected to the Rubik Pi, run the program (`parkingmeter.py`) with the following command:
`python3 parkingmeter.py