After months of wrenching, troubleshooting, and more late nights than I can count, the Mustang finally roared back to life.
This project has been equal parts obsession, education, and exercise in patience. From building the harness to relocating the battery, setting up the Microsquirt ECU, and chasing down electrical gremlins, every system has demanded attention. But hearing it fire up—especially knowing every wire and connection was laid out by hand—made it all worth it.
The Startup I’ll be sharing a video of the first successful start. Even though it’s just idling in the driveway, this moment marks a huge milestone. The Microsquirt is online, sensors are reading correctly, and the ignition finally behaving after sorting out the voltage drop and verifying the coil wiring. It’s not perfectly tuned yet, but the fundamentals are there.
Battery Relocation One of the big changes was moving the battery to the trunk. That meant upgrading to 1/0 gauge cable to handle cranking amps, integrating a cutoff switch, battery charger and re-routing grounds to avoid the voltage drop issues I ran into early on. Even with careful planning, I ended up chasing low voltage at the starter and ECU, if you’re considering a similar setup, be prepared to measure everything twice and still have to improvise.
Electrical Debugging If you’ve been following along, you know the turn signals and hazards decided to quit altogether. After pulling modules apart and checking power feeds, I confirmed the flasher wasn’t the culprit, just a lot of old wiring and tired switches. Replacing the multifunction stalk resolved the high beams refusing to stay on, and I’m still tidying up the last of the loose ends.
Tuning Learning Curve Moving to a standalone ECU has been a serious learning experience. From setting up the base fuel tables to configuring the trigger wheel and spark output, it’s a process that demands patience and constant iteration. Even now, I’m still refining idle control and enrichment settings. But compared to the old carb setup, the control and data visibility are on another level.
Next Steps Now that it’s running, the next phase is fine-tuning the fuel and ignition maps, tracking down any remaining wiring gremlins, and starting some road tests. There’s still a lot to do before it’s ready for consistent driving, but this was the biggest hurdle.
I’ll post updates as the tuning progresses. For anyone considering a Microsquirt conversion on an old Foxbody, don’t underestimate the learning curve but also don’t underestimate how satisfying it is when everything finally comes together.
Raspberry Pi-Based Digital Dash & ECU Tuning Interface for a Race Car
This project transforms a Raspberry Pi into a powerful, multifunctional infotainment and tuning system for my 1989 Foxbody Mustang race car. It replicates the functionality of expensive standalone systems using open-source tools and custom hardware integration, all on a budget.
Overview
I adapted an open-source Android Auto emulator called OpenAuto to work seamlessly in my custom race car environment. It provides a full graphical interface for music, navigation, and rear camera integration, while also acting as a direct tuning interface with TunerStudio, enabling real-time ECU adjustments without needing a laptop.
Audio is routed through a compact amp module connected to the car’s factory speaker system, offering both clarity and volume control. This setup mimics the experience of high-end race car data systems but at a fraction of the cost.
Key Features
TunerStudio Integration: The Raspberry Pi connects to my Microsquirt ECU over USB, letting me monitor, log, and tune the engine directly through TunerStudio on the Pi.
OpenAuto Interface: I customized OpenAuto to act as a driver-friendly infotainment system, with clean visuals and touch support.
Rear Camera Support: A libcamera-compatible rear camera streams to the dash. A GPIO-controlled trigger (via reverse signal or button) activates the view using libcamera-vid and ffplay.
Graceful Shutdown Logic: A pair of relays (12V and 5V) with a delay module safely shuts down the Pi when ignition is turned off. This replicates OEM-style system behavior and protects the SD card from corruption.
Audio Integration: A compact 12V-powered audio amplifier module routes the Pi’s sound output through the car’s speaker system.
Bill of Materials (BOM)
Item
Description
Notes
Raspberry Pi 4 (2GB or higher)
Main system board
Running OpenAuto & TunerStudio
MicroSD Card (32GB+)
Storage for OS and software
High-endurance card preferred
12V to 5V Buck Converter
Powers the Pi
Connected through 5V delay relay
12V Relay
Monitors ignition and triggers shutdown logic
ACC line goes to pin 85
5V Time Delay Relay Module
Maintains power to Pi for safe shutdown
Receives trigger from Pi GPIO
Compact Audio Amplifier
Routes Pi audio to car speakers
Powered by 12V supply
Rear Camera (IMX219 or similar)
High-quality CSI camera
Streamed using libcamera-vid
Display (HDMI or DSI)
Dash-mounted screen
Non-touch or touch-capable options available
USB GPS (optional)
For accurate navigation/tuning logs
Integrates into OpenAuto or TunerStudio logging
Misc Wiring, Fuses, Connectors
For all power, GPIO, and AV routing
Include fuse on VREF and Pi power lines
How It Works
Startup Sequence: When the ignition (ACC) is turned on, the 12V relay powers up and sends power to the Pi via a 5V converter and delayed relay. The Pi boots into OpenAuto and launches TunerStudio in the background.
Rear Camera Activation: A GPIO pin is monitored for a high signal. When activated (e.g., reverse gear engaged), a script launches libcamera-vid to stream live video to the display.
Tuning: TunerStudio runs full-featured on the Pi, letting me log data, tune fuel/spark maps, and test outputs. It connects via USB to the Microsquirt V3 ECU running MS2/Extra firmware.
Shutdown Sequence: When ignition is turned off, the relay loses its signal. The Pi senses this via GPIO and begins a graceful shutdown after a 5-minute delay. The 5V relay holds power until shutdown is complete.
Why This Matters
High-end ECU dashboards and data logging systems often cost thousands. This project replicates a huge amount of their functionality using a <$150 stack, proving that DIY and open-source solutions can rival commercial-grade gear with the right design and implementation.
It’s also modular — future upgrades could include:
How I Built My Own Server Ecosystem (and Why I Think Everyone Should Try)
If there’s one project that ties all my passions together—networking, security, automation, coding, design—it’s my homelab.
What started as a simple goal to self-host a personal website quickly evolved into a fully-fledged multi-service server environment. Running 24/7 on my own hardware, my homelab now supports websites, dashboards, automation tools, media streaming, IoT monitoring, cloud storage, and more—all built, configured, and secured by me.
This project has been one of the most challenging and rewarding things I’ve done—and it continues to grow every day.
My homelab runs primarily on repurposed Lenovo ThinkCentre machines I’ve affectionately named thefrogpit and thebrain. They’re compact, energy-efficient, and powerful enough to handle multiple services via containers and reverse proxies.
🌍 My Personal Website
I self-host averyizatt.com, built on WordPress and served through Nginx with Let’s Encrypt SSL, custom themes, and DNS managed through Cloudflare. Everything from the domain name to uptime monitoring is configured and maintained by me.
📊 Sensor Dashboards & Flask APIs
I designed and deployed a live Frog Tank Monitoring System using ESP32 microcontrollers, Flask APIs, and custom dashboards. It logs real-time temperature, humidity, lux, and TDS values across multiple enclosures and displays them visually at averyizatt.com/terrariums. Each sensor has individual logging, alerts, and uptime status via Ntfy push notifications.
📦 Plex, qBittorrent, Jackett & Media Automation
My media server setup includes:
Plex for local streaming
qBittorrent bound to a VPN for safety
Jackett + RSS Feeds for automated content delivery
All secured behind a reverse proxy with Fail2Ban and AppArmor configured for intrusion prevention
🧭 Homer Dashboard
I use a Homer dashboard to monitor all my services in real time. It shows current sensor data, server uptime, and links to tools like Plex, Nextcloud, Cockpit, and more.
☁️ Nextcloud Personal Cloud
I run my own instance of Nextcloud for secure file storage and syncing between devices. No third-party cloud dependency—just private, encrypted access hosted right in my home.
🛠️ Guacamole, Kasm, and Admin Tools
For remote access, I’ve integrated:
Apache Guacamole for browser-based VNC/SSH
Kasm Workspaces for containerized desktops
Cockpit and Logwatch for system monitoring and log parsing
🔒 Security First
Running internet-facing services comes with real responsibility. I’ve hardened my servers using:
Fail2Ban to block brute-force attempts
SSH key-only login
Firewalls and UFW rules
AIDE and Auditd for integrity checks
Regular backups to a dedicated 3TB drive, with a viewer integrated into the dashboard
🔄 Automation & Scripting
I created my own setup script that installs and configures:
Nginx + Certbot
WordPress
Plex
qBittorrent
Fail2Ban
All with auto-start services and secure permissions
I’ve also written automation scripts to:
Prune logs
Auto-delete old sensor data
Check backup health
Generate service status banners for the Homer dashboard
🧠 What I’ve Learned
This project taught me real-world applications of:
Linux server administration
Reverse proxies and port forwarding
Systemd services and autostart
Bash scripting and Python APIs
Docker, virtualization, and container security
Troubleshooting live systems under real user load (me 😅)
🔗 Why It Matters
Self-hosting has made me a better engineer. It’s taught me to think about:
Scalability and modular design
Fault tolerance and uptime
Security by design, not by patch
Building things for myself and for others
My homelab isn’t just a server—it’s a playground, a test bench, a workspace, and a digital home I built from the ground up.
A Self-Made Command Center with NFC, Screen Display, and Raspberry Pi Integration
To bring order (and a little flair) to my growing homelab, I went beyond software—I designed and 3D printed my own modular enclosure to house the key components of my server setup.
What started as a project to mount a screen and a Raspberry Pi turned into a full-blown custom-built command station with support for:
💻 Multiple Lenovo ThinkCentre units
🧠 Raspberry Pi with built-in touchscreen support
🏷️ NFC card reader/writer integration
🔌 Clean cable management and modular power routing
🌡️ Vents for airflow and cooling under server load
🛠️ Design & CAD
I modeled the enclosure using Fusion 360, carefully planning space for:
Horizontal mounting slots for multiple ThinkCentre M-series SFF units
A secured Pi tray with access to GPIO headers
Cutouts for HDMI, USB, and Ethernet pass-through
Snap-in mounts for a 3.5″ TFT screen and camera module
I included custom vents and fan brackets, using overlapping grill patterns to both diffuse airflow and add visual style.
All parts were printed on my Ender 3 V2 using Pro Nylon for heat resistance near the Pi and ThinkCentre vents.
📟 Integrated Screen Display
On the front panel, I mounted a 3.5″ TFT Raspberry Pi display, which now runs a custom status screen showing:
CPU usage
Temperature
IP address
QR code for server access
NFC scan status when active
This screen is powered by a lightweight Python app that refreshes live stats and supports soft shutdown/reboot buttons via GPIO.
📶 NFC Access Control
One of the most exciting additions is the NFC card reader/writer, mounted inside a flush front slot with LED feedback. I’ve programmed it to:
Read custom NFC tags for login or access triggers
Log tag scans to a local SQLite database
Eventually trigger services like user-specific dashboards or log retrieval
(I’m exploring future use for secure local unlock of encrypted drives or launching custom user shells.)
🔌 Multi-System Power & Clean Routing
Cable routing is fully internal, using:
A fused DC power bus
Toggle switch for global shutdown
Mounting channels for SATA power routing and USB hub access
🧩 Why I Built It
This project was about blending hardware, CAD, software, and self-hosting into one physical artifact. It gave me full control over:
Beats, Loops, and Late Nights — How I Found Rhythm in Music Production
Before I ever touched an oscilloscope or wrote a line of C++, I was layering samples and chopping snares. Under the alias httpsavery, I spent years producing original beats, mixes, and experimental loops—blending hip hop, lofi, and ambient influences into soundtracks for chill nights and creative flow.
Music was my third creative pillar, alongside visual design and motion work. I composed everything from full beat tapes to curated playlists and SoundCloud radio-style mixes, teaching myself DAWs like FL Studio and Ableton Live along the way.
🎚️ Skills That Carried Over
Producing music gave me a deep respect for rhythm, iteration, and detail—skills I now use constantly in my engineering work:
Audio signal flow → wiring and circuits
DAW layering → multithreaded workflows
Loop-building → modular, testable design
Creative discipline → showing up and iterating daily
What I Made:
Instrumental Beats
I crafted original instrumentals—some sampled, some completely from scratch—focusing on lofi textures, warm melodies, and hip-hop drum patterns.
Tools used: FL Studio, Edison, RC-20, Gross Beat
Jazzy lofi tracks built on vinyl samples
Trap-inspired beats with custom 808s
Ambient pads and textured synth layering
📻 httpsavery Radio
I curated and blended my own tracks with others into chill mix tapes, complete with smooth transitions.
Posted to SoundCloud as long-form listening experiences
Motion, Music, and Meaning — Learning Cinematics Through After Effects & Cinema 4D
While my early graphic design work taught me visual composition, it was video editing that taught me motion and timing. Alongside my identity as Raven Arts, I created cinematic edits for gaming montages, channel intros, and community projects—mostly for the same online spaces I designed artwork for.
Using Adobe After Effects and Cinema 4D, I taught myself how to sync motion with music, add kinetic typography, build custom 3D transitions, and render dramatic effects that elevated basic footage into stylized edits. These projects taught me not just software—but storytelling through movement.
From Logos to 3D Rendering: How Design Sparked My Creative Engineering Path
Before I was wiring ECUs or designing robots, I was creating digital art under the name Raven Arts. As a teenager, I began freelancing online, designing custom artwork for a wide range of niche gaming communities—from fantasy MMOs to competitive FPS clans. I created everything from logos and social media banners to ad graphics and stream overlays, often working with content creators and guild leaders to bring their visions to life.
Learning design early helped me get comfortable with complex creative software like Photoshop, Maya, Cinema 4D, Octane Renderer, and Fusion 360—tools I now use in much more technical contexts for engineering, animation, and 3D modeling.
When people ask where my love for cars and engineering started, I always come back to one thing—my first car: a 1989 Foxbody Mustang LX 2.3L. It wasn’t just a vehicle—it was my blank canvas, my first real hands-on project, and the machine that jumpstarted my obsession with building, tuning, and truly understanding cars from the inside out.
I got the car when I was still early in my automotive journey. Stock, slow, and in need of serious work—but something about that boxy, raw chassis spoke to me. It wasn’t about how fast it was out of the gate—it was about what it could become. This Mustang became the foundation where I built not just a car, but a deep passion for performance vehicles and electronics integration.
Over the years, this Foxbody has gone through major transformations:
I rebuilt the 2.3L Lima engine from the bottom up.
Swapped it to a manual transmission.
Designed and wired a custom engine harness.
Installed a Microsquirt standalone ECU.
Converted to coil-on-plug and distributorless ignition.
Each of these steps taught me more than any textbook could. I dove deep into electrical engineering, engine tuning, diagnostics, fabrication, and the trial-and-error process of building something real.
This Mustang didn’t just teach me how to work on cars—it showed me how to push through setbacks, learn new systems fast, and take pride in every part of the process. It also gave me the confidence to take on bigger challenges—like designing embedded systems, building robotics, and leading engineering projects.
This is the first post in a series where I’ll be breaking down the entire journey—from the engine rebuild to the custom ECU and everything in between. If you’re into hands-on learning, standalone ECUs, tuning, or just love a good DIY story, you’ll feel right at home here.
Welcome to one of my favorite ongoing builds—an environmental monitoring system made specifically for my frog terrariums and exotic pets. This project started as a way to keep an eye on temperature and humidity in my Whites Tree Frog and Green Tree Frog enclosures, but it quickly grew into something bigger: a full-stack, scalable home automation system with live dashboards, push notifications, and species-specific care profiles.
The Goal: Peace of Mind for My Frogs
Reptiles and amphibians are highly sensitive to their environments. Too cold, and their metabolism slows. Too dry, and they risk dehydration or stress. This system ensures that each tank stays within ideal parameters 24/7, even when I’m not around to check manually.
With this setup, I can instantly see:
Current temperature and humidity in each tank
Graphical trends over time
Alerts when anything goes out of range
Uptime status for each sensor (so I know if a device goes offline)
The system currently monitors the following zones:
Whites Tree Frog Terrarium
Green Tree Frog Terrarium
Office Environment
Other/Experimental Sensors
(Soon to include Living Room, Bedroom, and 3D Printer)
Each zone has its own DHT11 sensor feeding data into a centralized API every few minutes.
Push Notifications with Ntfy
If any sensor detects a value outside the safe range—for example, a drop below 65°F for the frogs—I get an instant push notification via ntfy.sh. This means I don’t have to constantly check the dashboard—I’ll know right away if something’s wrong.
Example:
“ALERT: Green Tree Frog Terrarium temperature is 59.8°F — below safe threshold!”
Notifications are:
Lightweight and fast (sent via HTTP)
Platform-agnostic (can hit my phone, desktop, or browser)
Easy to configure per sensor profile
Each species has its own care range. For instance:
White Tree Frogs: 70–85°F and 50–80% humidity
Red Knee Tarantulas: 70–80°F and 50–60% humidity
Office sensors: monitored, but do not trigger alerts
Full Tech Stack Breakdown
This is a mix of hardware and software designed to be flexible, scalable, and DIY-friendly.
Power via USB (plugged into a powered USB hub on the server rack)
Software:
Firmware: Custom C++ sketch using Arduino libraries, sending JSON via HTTP POST
Flask API (Python):
Accepts and logs incoming sensor data
Serves real-time values and CSV logs via REST endpoints
Mounted at /terrariums and served securely with Nginx
Data Logging:
Sensor logs saved in /home/thefrogpit/frog-api/logs/ as CSV files
Timestamps included for graph generation and device health checks
Dashboard UI:
Built from scratch using HTML/CSS + Chart.js for rendering graphs
Hosted at /var/www/dashboard on thefrogpit
Reverse Proxy + HTTPS:
Nginx routes traffic and handles SSL (Let’s Encrypt via Certbot)
Push Notifications:
Ntfy topics configured per sensor using Python requests and if statements in the app
Why It Matters
This project isn’t just about cool graphs or smart home bragging rights—it’s about preventing harm and improving care. I’ve caught real issues early because of this system:
A heater failure that dropped temps dangerously low
A sensor cable that came loose and triggered a “sensor offline” status
Unexpected humidity spikes due to a malfunctioning fogger
Plus, it’s totally expandable. I can easily add:
More tanks and terrariums
Outdoor sensors for gardening or weather
Air quality, light, or motion sensors
If you’re into DIY electronics, exotic animal care, or just like building things that actually help in the real world—this system is for you.
Want to Build Your Own?
If you want a copy of the code, wiring diagrams, or help setting up your own system, feel free to reach out. I’m planning to release a GitHub repo and setup guide soon.
This year’s Colorado Space Grant Consortium (COSGC) Robotics Challenge was nothing short of incredible—and I’m proud to share that our team won Best in Class in the under 1.5kg category!
We competed against ten other university teams, each bringing their A-game, with robots built to tackle a simulated planetary terrain. As the president of our IEEE club and the team’s lead presenter, it was an honor to represent Colorado Mesa University on a stage filled with such innovative minds. Our presentation highlighted not only our design and build process, but also our problem-solving, teamwork, and iterative improvements that we pushed right up until the finish line.
And when I say “finish line,” I mean it—our team stayed up in the hotel until 2AM the night before the event, huddled over the robot, soldering, coding, 3D printing last-minute tweaks, and perfecting the bot’s navigation logic. It was a grind, but it reminded me what engineering is really about: rapid learning, adaptation, and collaboration under pressure. That effort paid off.
Winning Best in Class was a proud moment, but the biggest takeaway wasn’t the trophy—it was everything we learned about how to grow and improve from here. As we reflect on the experience, a few key lessons stand out:
What We Learned
Testing early and often matters. Some of our challenges could’ve been caught sooner if we had done more iterative field testing.
Team communication is everything. Staying in sync, especially across sub-teams (hardware, software, design), is what helped us rally when it counted most.
Every failure is a chance to improve. We hit a lot of walls—both figurative and literal—and each one taught us something new about our bot and ourselves.
What’s Next
We’re already thinking ahead. There’s so much potential to evolve our robot beyond this first prototype. Ideas on the table:
Upgraded sensor array for more precise terrain detection
Swappable modules to test different locomotion strategies
Better cable management and power efficiency
Autonomous pathfinding logic using computer vision
This experience has energized our whole club. We’re looking to channel that momentum into future competitions, community outreach, and expanding opportunities for all students interested in robotics and engineering.
If you’ve been following our journey, thank you. This win is shared with everyone who supported us—professors, peers, family, and friends. And if you’re just tuning in, we’ve got a lot more coming. Stick around.
