The average American driver spends about 17 hours a year hunting for a parking spot. A 2017 INRIX study put a price tag on that: roughly $345 per driver in wasted time, gas, and emissions, and $72.7 billion nationally.
That's annoying for drivers. For business owners it's worse. In that same study, 63 percent of drivers said they'd avoided going somewhere because parking was a headache. That's not a traffic stat. That's a customer pulling a U turn in your lot and taking their wallet to Amazon.
You've seen the fix in newer garages. The sign at the entrance that says "Level 2: 14 open." The little green and red lights over every spot. It feels like magic. It isn't. It's logic. A handful of rules. And a while back I built a small version of that logic from scratch, on a chip, with nothing but switches, buttons, and some very stubborn LEDs.
Here's how it works, what it taught me, and the bug I found when I rewatched my own demo. Spoiler: past me was a little too confident.
First Things First: What Even Is an FPGA?
Most chips in your life, like the processor in your laptop, work like a really fast employee reading a to do list one line at a time. Blazing fast, sure. Still one line at a time.
An FPGA (field programmable gate array) is a different animal. Think of it as an empty warehouse where you design the assembly line yourself. You don't write instructions for a processor to follow. You write code that describes actual circuits, and the chip physically configures itself to become those circuits.
The language I used is called Verilog. If normal code is a recipe, Verilog is the blueprint for the kitchen.
Why should a manager or recruiter care? Because everything happens at once. If my garage needs to check 16 parking spots, a regular processor checks them one after another. The FPGA builds 16 little checkers and they all look at the same time, like Naruto spamming shadow clones. That kind of speed and predictability is why FPGAs show up where timing is life or death. AMD, one of the biggest FPGA makers on the planet, builds defense grade and space grade versions for aircraft, radar, satellites, and rovers.
A parking garage is not a satellite. But the fundamentals are the same ones, and that's the whole point.
The Setup: 16 Switches Walk Into a Parking Garage
I built this on a Digilent Basys 3, a training board with an AMD Artix 7 FPGA and a bunch of built in switches, buttons, LEDs, and a small four digit display. No real sensors, no real gate, no real cars. My insurance company thanks me. Everything in a real garage got a stand in:
| In a real garage | On my board |
|---|---|
| Car sensor over each spot | 16 switches (flipped up = car parked) |
| Pay station | Payment button |
| Permit or pass reader | Permit button |
| Gate arm | Center LED that lights up when you're approved |
| "Go to Level X, Spot Y" sign | Seven segment display for the spot, LEDs for the floor |
| Bonus nerd feature | Four LEDs showing the spot number in binary |
Two floors, eight spots each. Sixteen spots, sixteen switches. Chef's kiss.
Fun fact: that seven segment display is the same kind of display on your microwave and on every movie bomb from the 90s. Thankfully, mine only counts parking spots.
Same eight spot floor plan stacked twice: blue numbers for floor one, red for floor two.
The Bouncer at the Gate
The gate logic is the simplest part of the whole system, and that's on purpose.
The rule: did you pay, or do you have a permit? If either one is yes, you're in. In chip terms that's an OR gate, one of the most basic building blocks in all of electronics.
There's one more condition. The lot can't be full. If there's no room, it doesn't matter how much cash you're waving. Full Gandalf mode. You shall not pass. Which is extra funny because the signal in my code is literally named pass.
After a car goes through, the system clears the payment and permit flags, so the next driver can't roll in on somebody else's receipt. Here's my whiteboard version of that logic:
The Valet Inside the Chip
This is the part that actually saves drivers time. Instead of letting people circle the lot like sharks, the system tells every driver exactly where to go.
The logic works like a valet running down a checklist:
- Is spot 1 open? Send them there.
- Nope? Check spot 2.
- Keep going until you hit an open one.
- Floor one full? Jump to floor two and start again at spot 1.
- Everything full? Show a 0. Nobody's getting in.
The display shows the spot number and the LEDs show the floor. When spot 8 on floor one fills up, the floor light jumps from 1 to 2. Like leveling up in a video game, except the reward is walking farther.
I mapped the whole thing out as a loop. Each circle is a spot. The system stays on a spot while it's open and moves to the next one once it's taken.
Here's the design choice I'm proudest of. It doesn't trust drivers. It trusts sensors. In the demo, I skip a recommended spot and park somewhere else, and the display keeps pointing at the one that's actually still open. It never assumes someone parked where they were told. It checks what's real, every single time.
That lesson goes way beyond parking. Systems that assume behavior break. Systems that measure reality don't.
And when everybody leaves at once? Thanos snap. Every switch drops, and the display resets to floor 1, spot 1 like nothing ever happened.
See It in Action
[EMBED: https://www.youtube.com/watch?v=nFVDIF1gLEc]
Here's what you're watching. I hit the permit button, the center light flashes, and the display sends me to the first open spot. Then I start flipping switches to fill the lot, and you can watch the recommendation climb, jump to floor two, and keep counting. Skip a spot and it still points you right back to it. Fill all 16 and it shows 0. Then everyone leaves and it snaps back to square one.
The Bug I Caught Rewatching My Own Demo
Time to roast past me a little.
To decide whether the lot is full, the gate checks exactly one thing: is the last spot, spot 16, taken? Since the valet logic fills spots in order, spot 16 being full usually means everything is full.
Usually.
Real people don't leave in order. Picture this. The lot fills up, all 16 spots. Then the car in floor 1, spot 3 heads home. Spot 16 is still taken. So the display correctly says "go to spot 3"... and the gate stays shut because it thinks the lot is full.
That's the parking version of a restaurant with empty tables telling you there's a 45 minute wait. A real garage running this logic would turn away paying customers during its busiest hours, which is exactly when that revenue matters most.
My demo didn't catch it because everybody left at the same time, like a flash mob. Real drivers don't coordinate their exits.
The fix is to stop asking "is spot 16 taken?" and start asking "is any spot open at all?" In Verilog that's basically one line, something like:
// open the gate if they paid or have a permit AND any spot is free
assign gate_open = (paid | permit) & ~&spots;
The fix is tiny. Spotting it is the skill. The most expensive bugs usually aren't in the code you tested. They're hiding in the scenario you never thought to demo.
What a Real Deployment Would Need
If a garage owner handed me a budget tomorrow, the core logic mostly stays the same. The inputs and outputs just grow up:
- Real sensors instead of switches. Ultrasonic or magnetic detectors over each spot.
- An entrance sign with counts per floor, so drivers pick a level before they even pull in.
- Actual payment and permit readers wired to a real gate arm instead of two buttons.
- Logging. Every time a spot fills or empties is a data point. Stack enough of those up and you know your peak hours, your dead hours, and where pricing or staffing should change.
That last one is where my IoT work comes in: getting sensor data off a device and into a dashboard somebody can actually make decisions with.Why This Matters (Whether You're Hiring or Running a Lot)
If you're a recruiter or hiring manager, here's what this project actually shows. I can design digital logic from scratch, write it in Verilog, map it onto real hardware, document the design with diagrams a non engineer can follow, and go back and audit my own work honestly. That last one is rarer than it should be.
If you run a business with a parking lot, here's your takeaway. The "smart" in smart parking isn't magic. It's a few clear rules, good sensors, and somebody who tests the weird edge cases before your customers find them for you.
Want to talk FPGAs, embedded systems, or smart building tech? Watch the full demo above or reach out at chrisnortonjr.com. The gate's open. And this time it checks every spot.
