-
-
User facing display of parking spots (no actual inference or computation, to fit with N+1 track requirements)
-
Display of inner workings of the application running on the Arduino Uno Q (no actual inference/computation for N+1 track reqs)
-
Display of the g_sessions table, for all licese plate entries and exits (no actual inference/computation for N+1 track reqs)
-
Display of the garage_visit_history table, for visit times and lengths (no actual inference/computation for N+1 track reqs)
-
The actual Arduino Uno Q, along with both the attached camera (via USB hub), and the Modulino distance sensor
-
Display of the parking_spots table, for status on each parking spot (no actual inference/computation for N+1 track reqs)
Inspiration
If you've ever tried to park at the Mall of America on a busy weekend, you know the feeling: circling ramp after ramp, guessing which level might have a spot, and squinting down rows only to find another car already there. The garage has thousands of spaces and almost no idea which of them are empty, or who is supposed to be in them.
We kept coming back to one question: What would it take for the garage to know you were expected?
The driver has usually already decided to come, and often already paid or booked. And every car carries the one identifier a garage needs to recognize it: its license plate. The information exists. It just isn't connected.
ParkSight is our attempt to connect it, cheaply and reliably, with hardware small enough to put at every entrance and above every stall.
What it does
Recognizes arriving and departing cars: A camera at the lane, driven by an Arduino UNO Q, detects motion, captures a burst of frames, and reads the plate with an on-device detector and OCR model.
Knows entry from exit: An operator captures a reference photo from the installed camera and draws an entry zone and an exit zone on it. Where the plate appears decides what happens: a confirmed read in the entry zone starts the visit for a booked car, and a read in the exit zone closes and archives it.
Tracks every stall: A small Modulino Distance sensor in each space reports whether a car is there, and the board only marks the space occupied once the reading has settled.
Updates drivers instantly: Spot occupancy and garage sessions live in Databricks Lakebase, and a driver-facing app shows live availability, floor by floor, as cars arrive and leave.
Keeps working offline: The camera, sensors and local dashboard all keep running without internet. Garage updates are queued on the board and retried later with their original event IDs, so nothing is applied twice.
How we built it
On the edge (Arduino UNO Q). The UNO Q pairs a Linux MPU with a real-time microcontroller, so we split the work:
The MCU sketch polls the Modulino Distance sensor and applies the stall thresholds.
The Python app on the Linux side runs the camera loop, motion detection, plate recognition, the local dashboard, and syncing to Lakebase.
The two sides talk over the App Lab bridge.
Plate recognition: We trained our own two-stage pipeline:
A YOLO11-nano plate detector.
A compact CTC-based OCR model for the plate text.
Both were trained on a synthetic dataset we generated ourselves: 10,000 full scenes and 30,000 OCR crops of Wisconsin-, Illinois- and Minnesota-style plates, with plate strings kept disjoint across the train, validation and test splits. Both models were exported to ONNX and verified to match PyTorch within $10^{-3}$ before deploying to the board. On held-out synthetic data: | Metric | Result |
| --- | --- |
| End-to-end exact plate text | 92.8% |
| Character error rate | 1.3% |
| Detector [email protected] | 99.5% |
| False detections on plate-free scenes | 0 / 94 |
Trusting a read. Single frames lie: motion blur, glare, and an I that looks like a 1. So the board captures a burst of six frames and only confirms a plate when at least four of them agree. If each frame is read correctly with probability $p$, and frames are treated as independent, the chance of getting a confirmed correct read is
$$P(\text{confirm}) = \sum_{k=4}^{6} \binom{6}{k}\, p^{k} (1-p)^{6-k}$$
For $p = 0.928$ this is about $0.994$, and even for harder frames at $p = 0.81$ it stays above $0.91$. A wrong confirmation is far rarer still, because four frames would have to agree on the same wrong string. Real frames aren't fully independent, so treat these numbers as an optimistic bound. That gap between theory and reality is part of what we learned.
Settling the stall reading. Each stall is calibrated with two samples: the distance to the floor when the stall is empty ($d_{\text{clear}}$), and the distance when a car is parked ($d_{\text{occ}}$). With the gap $g = d_{\text{clear}} - d_{\text{occ}}$ (at least 20 mm), we set two thresholds:
$$ \text{occupied if } d < d_{\text{occ}} + \tfrac{g}{3}, \qquad \text{clear if } d > d_{\text{clear}} - \tfrac{g}{3}. $$
This leaves a hysteresis band in the middle third, so a car creeping into the space or a person walking past doesn't make the state flicker.
In the cloud (Databricks).
- Lakebase (Postgres) stores parking spots, garage sessions and visit history.
- A FastAPI app handles camera calibration, the operator debug feed, garage events and stall calibration.
- A Flask operator front end handles camera calibration and live debugging. It forwards each signed-in operator's Databricks token server-side, so the browser never holds database credentials.
- A Streamlit driver app shows live availability by floor and zone.
- Everything runs as serverless Databricks Apps, deployed straight from our GitHub branches. ## Challenges we ran into
- Synthetic data doesn't equal the real world. Our models scored well on synthetic plates, but real webcam frames, with real lighting, angles, glare and blur, were much harder. That forced us to add multi-frame consensus, crop straightening, and a calibrated detection zone so the model only looks where plates actually appear. It also forced us to build a debug view that shows exactly which frame, crop and OCR input produced each decision.
- Embedded constraints. Running a detector and an OCR model on a small board alongside a live camera loop meant being careful about CPU, memory and frame rate:
- motion-triggered bursts instead of continuous inference,
- fixed-size ONNX models,
- keeping the camera loop alive even when recognition fails.
- Two worlds on one board. Coordinating the MCU sketch and the Linux app over the bridge, with timeouts and fallbacks when either side is busy, took more care than we expected.
- Networks fail at the worst time. A garage can't stop working because Wi-Fi dropped. We built a local outbox that persists pending updates and retries them with their original event IDs, so a reconnect never applies the same visit twice.
Security across the boundary. The board, the API and the front ends each needed their own credentials:
- device keys for camera uploads,
- an operator allow-list behind the Databricks Apps proxy,
- tokens kept server-side,
- snapshot requests that expire after 30 seconds. ## Accomplishments that we're proud of
Getting the project done, with all deliverables correctly achieved, in a timely manner!
Ensuring the whole applicaiton is compact enough to run on the Uno Q itself
Ensuring high speed access to accurate data!
What we learned
- The Databricks platform end to end: Lakebase, serverless Databricks Apps, Git-based deployment, and app-to-app authentication.
- Embedded programming on a hybrid MPU + MCU board, and how different "it works on my laptop" is from "it works on the device".
- Computer vision and ML engineering: generating synthetic data, training detection and OCR models, exporting to ONNX with parity checks, and why held-out and real-world accuracy are two different numbers.
- Cameras in practice: exposure, glare, motion blur, and how much placement matters.
Building for failure: offline-first design, idempotent retries, and security boundaries between devices, services and users.
What's next for ParkSight
Collect and label real garage footage to close the gap between synthetic and real-world accuracy.
Scale the per-stall sensor array to a full floor, with guidance lights that point drivers to open spaces.
Let drivers book and pay in the same app that shows live availability.
Built With
- arduino
- arduinounoq
- databricks
- html
- javascript
- modulino
- postgresql
- python
- pytorch
- streamlit
- ultralytics
- yolo