
If you’ve ever dreamed of a sim racing rig that’s both budget-friendly and high-quality, repurposing an electric car seat might just be the ultimate hack. Not only do these seats provide comfort and adjustability, but they’re also readily available and can add a touch of authenticity to your setup.
In this blog, I’ll guide you through how I turned a $50 electric car seat into the perfect addition to my sim rig using an old PC power supply.
Car seats, especially electric ones, offer:
I picked up a 2007 Subaru Legacy seat from Facebook Marketplace for just $50. It was in great condition and had all the features I needed for my sim rig.
Here’s what I used to repurpose my seat:
Before diving into the wiring, test the seat’s motors. Using a 12V battery or similar power source, identify which wires control the seat’s movements. This step helps you isolate unnecessary systems like airbags or seatbelt sensors.
A PC power supply is ideal for this project because it delivers the necessary voltage and amperage. Follow these steps:
Once the seat is functional, mount it securely to your sim rig base. Use sturdy brackets or a custom-made frame to ensure stability during use.
Repurposing an electric car seat is a fantastic way to elevate your sim racing experience without breaking the bank. With a bit of patience and some basic DIY skills, you’ll have a comfortable, adjustable seat that rivals high-end rigs.
Have you tried this project, or do you have questions? Drop a comment below—I’d love to hear about your experiences or help you troubleshoot!
No related posts.
In this video, I complete my DIY sim racing setup by building a custom handbrake to complement the pedals and steering wheel I previously designed. Inspired by outrageously priced commercial handbrakes—often little more than glorified switches—I set out to create an affordable, high-quality alternative.
The handbrake integrates seamlessly with my existing pedal controller, allowing for standalone operation independent of other peripherals. For those using pre-built solutions like Logitech steering wheels and pedals, this handbrake can still enhance your sim setup.
During initial testing, the handbrake snapped under pressure due to insufficient infill in the 3D-printed parts. I reprinted the components at 100% infill, significantly enhancing their strength. The threaded rod was extended fully through the shaft, providing additional durability.
Watch the video for a step-by-step guide on creating your own DIY handbrake, and take your sim racing experience to the next level!
If you would like files to make this handbrake and pedals, you can get them by clicking on the image below.
No related posts.
In my previous project, I crafted a force feedback steering wheel for sim racing, but this time, I tackled a different challenge—designing and building racing pedals. These pedals not only complement the steering wheel but also introduce a more efficient and accurate approach to measuring pedal inputs.
Traditional racing pedals often use potentiometers to measure input. These devices rely on variable resistors to adjust voltage based on pedal position. While effective, they require complex mechanical linkages and are prone to wear over time.
Instead, I opted for Hall effect sensors. These sensors measure the proximity of a magnet, translating magnetic force into voltage changes. By simply moving a magnet closer or further from the sensor, the pedals can send precise input data to a controller or computer. This approach eliminates the need for intricate linkages, reducing complexity and improving durability.
For this project, I designed sturdy yet straightforward pedals using a combination of 3D-printed parts, aluminum tubing, and bolts. Here’s how it came together:
After assembly, I mounted the pedals onto a plywood base for testing. To integrate them with my sim setup, I used a calibration tool provided by the developer of the steering wheel firmware.
The calibration process involved setting the minimum and maximum pedal positions, allowing the software to accurately interpret the pedal’s range of motion. Using the tool, I confirmed the following:
This ensured that the pedals worked flawlessly alongside the steering wheel in my sim setup.
If you’re inspired to build your own Hall effect racing pedals, the STL files and assembly guide are available in the show notes of my video. This DIY approach not only saves money but also gives you the satisfaction of creating custom, high-quality sim racing equipment.
Whether you’re a casual gamer or a dedicated sim racer, these pedals are a robust and precise addition to any setup. Ready to race?
No related posts.
If you’re into DIY electronics, you know there’s always room to level up with new gadgets, especially when it involves NeoPixel lighting. This project combines a Raspberry Pi Pico, accelerometers, NeoPixels, and Bluetooth to create a custom “NeoPixel Frisbee” that lights up in response to motion, perfect for fun outdoor games on warm nights!
Summer is ideal for getting outside and experimenting with light-based projects. I wanted a project that would be exciting in the dark, so I thought about making a game that could be both fun and interactive with some added tech. I grabbed a soft cloth frisbee—lightweight and safe, even if thrown hard. This type of frisbee is durable, flies straight, and doesn’t risk anyone getting hurt (no black eyes here). The idea was to add LEDs to it, so it glows while spinning in the air, making it visually spectacular.
My plan was to embed NeoPixel lights inside the frisbee, controlled by a microcontroller that could detect movement. The NeoPixels would respond to the speed and intensity of the throw by changing colors—starting red and becoming “white hot” as the frisbee spins faster. To make it even cooler, I envisioned using Bluetooth to track the proximity of the frisbee to the player, changing colors when it got close to them.
At first, I tried using a compact ESP32-C3 board for this project. It’s tiny, has built-in Bluetooth, and seemed ideal. I also planned to incorporate inexpensive Bluetooth tags (similar to luggage trackers) to identify and locate the players. The idea was that each player would carry a tag, and the frisbee would detect who it was close to and change color based on that tag.
However, two issues popped up:
Given these limitations, I swapped the ESP32-C3 for a Raspberry Pi Pico. The Pico is slightly larger but still lightweight enough for the frisbee. Despite being bulkier, it has enough processing power to manage both the lighting effects and accelerometer data, making it a better fit.
With the Pico, I assembled the components carefully, balancing the batteries and distributing the weight to keep the frisbee’s flight stable. Here’s what went into the build:
A voltage booster was added to ensure the power requirements were met for the NeoPixel ring.
The Pico runs a simple script that changes the LED colors based on movement. When the frisbee is thrown, the lights start red, transitioning to a bright white as the frisbee reaches higher speeds, creating a “white hot” effect. This adds a dynamic visual cue to the speed and power of each throw, making the frisbee look like it’s on fire as it spins through the air!
If you’re excited to dive into similar projects, check out my free Patreon page. There, you can access free 3D printing files, STL files for custom parts, and ready-to-go code. Join the community and let’s create some amazing stuff together.
No related posts.
If you love the look and feel of classic arcade machines and you’re a Nintendo Switch gamer, this DIY project might be right up your alley. Today, we’re building a wireless Nintendo Switch controller inspired by the classic Mortal Kombat arcade machine. With its authentic button and joystick layout, this controller brings an old-school arcade experience to your modern gaming setup. Let’s dive into how we put it all together.
To build this controller, I used a combination of laser-cut MDF for the main body, 3D-printed corner supports, and classic arcade components like buttons and a joystick. Here’s the basic list of materials:
The frame for this controller combines laser-cut MDF with 3D-printed corner supports. The laser-cut MDF ensures precision, giving the controller the look and feel of a sturdy arcade machine. The 3D-printed corners snap everything together, making the structure both modular and secure.
The frame I created is designed specifically for the control panel, though you could easily expand it to build a complete arcade cabinet if you wanted. The modular design allows you to customize or modify it later.
I went with a button and joystick layout that matches the original Mortal Kombat arcade machine. Using classic-style arcade buttons and a joystick not only gives it that authentic look, but it also makes the gaming experience feel genuinely retro.
These arcade buttons are quick and easy to install. They snap right into the pre-cut holes in the MDF, and with quick connectors, wiring them up is hassle-free. This setup makes it easy to replace or reconfigure buttons if you want to experiment with different layouts later on.
For the electronics, I repurposed the internals from an affordable Nintendo Switch controller. The button contacts on this controller are easily accessible, which made it simple to wire the arcade buttons and joystick without losing any functionality.
The wireless functionality remains intact, so you don’t have to worry about messy cables cluttering up your setup. I also added select, start, left, and right buttons to the front of the controller for full compatibility with the Switch.
To give the controller a true Mortal Kombat feel, I printed some custom artwork. Using an inkjet printer, I created a design that would add a touch of nostalgia. I applied the artwork to the MDF using adhesive spray, which not only looks great but also protects the wood surface.
To finish things off, I applied black vinyl around the edges, which hides the screws, enhances the appearance, and adds durability. For further protection, especially during intense gaming sessions, I placed a 3mm clear acrylic sheet over the artwork. This layer guards against wear and tear while preserving the vivid look of the print.
The finished product is a fun blend of retro arcade design and modern gaming tech. This project is perfect for Mortal Kombat fans and those who enjoy custom gaming builds. The authentic feel of the arcade joystick and buttons combined with the wireless functionality makes this controller ideal for playing on the Nintendo Switch.
If you’re interested in building this project yourself, you can find all the dimensions and design files on my Patreon page. There, I provide step-by-step guidance on this and other DIY gaming projects, all designed to make gaming more affordable and fun. Happy gaming, and let’s keep that retro arcade spirit alive!
No related posts.
In this guide, I’ll walk you through the process of building an analog gauge cluster for sim racing, inspired by the iconic Ferrari F40. The end goal? A set of analog gauges that syncs with your sim racing game, providing a realistic dashboard experience. I’ll share the steps to assemble this gauge cluster, plus tips and tricks to get the best results.
The purpose of this project is to create an analog gauge cluster that can be used with sim racing software, like SimHub. By connecting to SimHub, we can extract real-time data such as speed, RPM, and other telemetry from the game and feed it into our gauge cluster. This integration brings the experience closer to what you’d see in a real car, with physical dials that respond to in-game performance.
For this project, we have two main gauges – a speedometer and a tachometer. They look similar but have different markings to reflect speed and RPM. The faceplates of these gauges are protected by a layer of clear acrylic, adding durability and a clean look while preventing dust from entering.
To achieve the look and feel of an authentic gauge, I experimented with several materials and methods for creating the faces. Initially, I considered printing on paper, but the backlighting caused paper fibers to become visible. Instead, I spray-painted clear acrylic and used a diode laser cutter to precisely etch out the numbers and markings. The laser burns off the paint without damaging the acrylic, resulting in a clear display area that lets light pass through perfectly.
Traditional dashboard lighting uses individual bulbs to illuminate the cluster. However, I opted to use NeoPixels, which are RGB LEDs that can display any color independently. This flexibility allows us to customize the lighting for each gauge, adding a modern, dynamic touch to the cluster.
Each gauge has a set of NeoPixels installed behind it, which we can control through SimHub or custom code. With this setup, we can match the gauge lighting to in-game conditions or set them to specific colors, adding a professional and immersive feel to the gauges.
After preparing the faces and lighting, it’s time to assemble the gauge components. The faceplate fits into a cone-shaped housing, which reflects the look of the Ferrari F40’s dashboard. Inside, I placed the gauge, securing it with a gasket. The housing also has specific cutouts to allow light from the NeoPixels to shine through effectively.
Each part of this assembly has been precisely cut using a laser cutter. The laser ensures that every piece fits perfectly, eliminating the need for extensive manual adjustments. This precision saves time and results in a clean, professional-looking build.
Once everything is assembled, it’s time to connect the gauge cluster to SimHub. SimHub is a powerful tool that pulls telemetry data from your game and translates it into real-time motor movements, which drive our gauges. In a previous video, I detailed the setup of SimHub, so check that out for a comprehensive tutorial. Additionally, my website includes code examples and instructions for using SimHub with this project.
This project adds a new level of realism to sim racing setups. Not only does it look impressive, but it also creates a more immersive experience by bringing real-time data out of the screen and into physical gauges. If you’re looking for an affordable, DIY way to enhance your sim racing setup, building an analog gauge cluster like this is a rewarding challenge. Whether you’re a seasoned DIYer or a beginner, I hope this guide inspires you to give it a try. For more tips, tricks, and project updates, follow my blog and YouTube channel.
No related posts.
In my last video, I introduced a project where I set out to build a Nintendo Switch fight stick using an ESP32 controller. My goal was to replace the standard controls with arcade-style buttons and a joystick. If you haven’t seen the video, check it out.
The original plan was to use software called “HOJA” to flash the ESP32 controller, allowing it to interface with the Nintendo Switch. This setup seemed promising during my initial tests on a breadboard, with all the buttons working. However, when I moved to actual use, I encountered a major issue—the dreaded “turbo” mode.
For those unfamiliar, a turbo button causes the button to act as if it’s repeatedly being pressed and released, even when you’re just holding it down. This obviously wasn’t ideal for a fight stick, where precise, deliberate inputs are key. With this problem in mind, I decided to change my approach.
I thought about sourcing a regular controller locally and soldering onto its internal buttons instead of continuing to troubleshoot the ESP32 setup. Luckily, I found a great solution at a local store called Mighty Ape. They were selling a basic controller for just $15. I figured at worst, I’d have a decent controller to play with, and at best, I could use it for my fight stick project.
Once I got the controller and disassembled it, I was pleasantly surprised. The circuit board had test points for each button, making it incredibly easy to solder wires directly to them and connect them to my arcade controls.
For just $15, I got a full controller that had everything I needed—buttons, analog sticks, a capture button, audio output, and even a battery. The controller also had LEDs to indicate player number, which was a nice touch. Compared to the ESP32 controller (which cost $19), this solution was not only cheaper but much simpler to implement.
The only downside was that I didn’t buy more than one, and now they’re sold out. It’s a white-label controller, so I’ll likely need to hunt for more on eBay or AliExpress, where they go for around $23. Despite the slight price increase, this is still an incredible deal for the functionality it offers.
To make the project more modular, I built a breakout box. This box houses the entire controller and provides screw terminals for easy connection to the arcade buttons. It’s a bit bulky, so it wouldn’t be suitable for a handheld controller, but for a fight stick with plenty of space, it works perfectly.
I broke out all the necessary buttons: the joystick, left and right triggers, select and start, and the basic face buttons. Since this setup is meant for games like Mortal Kombat, where you don’t need analog sticks, I focused on mapping out the most important digital inputs.
The board fits neatly in the back, and I left room for USB-C charging. I’ve also designed the layout so that the USB port is easily accessible for recharging the battery.
To give the fight stick a more authentic arcade feel, I downloaded some artwork from the internet and had it printed at a local stationery shop. I plan to apply this artwork to the top panel and protect it with a layer of acrylic. This will help the fight stick resemble a classic arcade machine while keeping the artwork safe from wear and tear.
The only things left are the final assembly steps: securing the artwork, adding acrylic for protection, and cutting a hole for the USB charging cable. I haven’t decided whether to complete a full build video for this project, as the initial response to my last one wasn’t great. But I’ll see how things go—maybe I’ll release a shorter video highlighting the key aspects.
Thank you for watching and following along with this project. Stay tuned for updates, and I hope this inspires your own DIY Nintendo Switch controller builds!
No related posts.
I recently embarked on an exciting new project—building a wireless Nintendo Switch controller. The inspiration came from my love of Mortal Kombat, a game that’s hugely popular in my household. Playing it with the tiny Joy-Con controllers that come with the Switch? Well, let’s just say it doesn’t feel quite right, especially for an old-school gamer like me. I wanted something more authentic, reminiscent of the classic arcade cabinets with buttons and joysticks. And here’s the kicker: I wanted it to be wireless.
Building a wireless controller for the Switch seemed simple in theory, but when I started searching online for guides or libraries to help, I hit a wall. There are tons of resources for wired controllers, but I couldn’t find much for wireless setups. One library I found, GP2040-CE, works on a variety of devices like PlayStations, Xbox, and the Switch, but it requires a cable connection. That wasn’t going to cut it—I was determined to go wireless.
The GP2040-CE runs on the Raspberry Pi Pico, which is great since I’ve used it in previous projects. However, even though the Pico has a wireless version, I couldn’t find any proper wireless implementation for GP2040-CE. That was a dead end.
After some deep digging online, I came across something called the Handheld Legend. This controller looked fantastic, modeled after the classic Nintendo design, and ran on an ESP32 chip, which offers wireless capabilities. Better yet, it wasn’t just limited to the Switch—you could use it on a computer, GameCube, and other devices.
The Handheld Legend project even had a software installer. You just plug your ESP32 into your computer, head to their website, and install the firmware. It sounded straightforward enough, so I gave it a shot.
But of course, no project ever goes off without a hitch. The wiring setup was a nightmare. The Handheld Legend uses a diode keyboard, which meant I had to breadboard the diodes and get everything wired correctly. I finally managed to get the buttons working, but when I checked the terminal, the software was constantly crashing. The issue? It kept trying to communicate with an I2C controller that I didn’t have—some sort of extra controller included in their kit, which I wasn’t using. Without this, the setup would fail, reboot, and crash again. So, another dead end.
Not one to give up easily, I kept researching and found something called OpenController-ESP32. This software doesn’t explicitly mention Nintendo Switch compatibility, which is why it’s so hard to find. But buried deep in the project is a component called HOJA, an ESP-IDF library with very limited documentation. The library is designed to interface with a wide variety of controllers, including the Switch, without relying on I2C communication. Perfect!
It even had a basic wired gamepad example, which seemed promising. However, I was venturing into unfamiliar territory. I’m comfortable with Arduino and Python, but this was a whole different level of complexity for me.
To get the project working, I downloaded ESP-IDF, the development environment for ESP32 devices, installed it, and followed the basic compilation instructions. I had no idea what I was doing, but to my surprise, it worked! I compiled the software, flashed my ESP32, and it actually ran without a hitch.
Before I committed further, I wired up all the buttons—12 in total—and connected everything. To my delight, it worked on the Switch! The D-pad, triggers, home, and select buttons all functioned perfectly. Now, I had a wireless Nintendo Switch controller. The only thing left was to hook up a battery.
With the controller working, I tested it out on the Switch, and it performed great! I could easily pull off all the moves I needed in Mortal Kombat. One minor issue: one of the buttons wasn’t pressing down properly. But since I got these switches from China for a couple of dollars, I wasn’t too surprised. I’ll replace them with proper arcade buttons soon.
If you’ve seen my previous project—a Defender cocktail table—you’ll recognize the style of this build. For those interested, I’ve included links to the libraries I used in the show notes, so you can try it yourself. You could even buy the Handheld Legend hardware and just add an ESP32 for a wireless controller that works with Switch, PlayStation, and Windows!
Now that the controller is up and running, I’m planning to build a mini arcade cabinet to house the setup. I’ll make the controller part removable so it can be used separately, too. That way, you won’t be stuck with the entire unit in your lap while playing.
So, stay tuned for the next phase of the project! If you love DIY and gaming, this build is definitely worth trying out.
No related posts.
The x27.168 stepper motor is a precise and reliable motor commonly used in automotive applications, particularly for gauge instrumentation such as speedometers and tachometers. Its compact size and accuracy make it an excellent choice for DIY projects that require precise movement and control. In this blog post, we will cover how to use the x27.168 stepper motor with a Raspberry Pi Pico using the Arduino IDE and an L298N motor driver.
To control the x27.168 stepper motor with the Raspberry Pi Pico, you need to connect it to the L298N motor driver. The L298N allows you to drive the stepper motor with adequate power and control signals from the Pico.
GND
and VCC
pins of the L298N to the GND and VBUS pins of the Pico.Here is a simplified wiring diagram:
Here is a basic test code to move the x27.168 stepper motor using the Raspberry Pi Pico. Ensure you have the SwitecX25 library installed in the Arduino IDE.
#include <SwitecX25.h>
// Pin definitions for the motor
#define MOTOR_PIN1 0
#define MOTOR_PIN2 1
#define MOTOR_PIN3 2
#define MOTOR_PIN4 3
// Number of steps for 315 degrees (full range)
#define STEPS_PER_REV 945
#define MAX_DEGREES 315
#define TARGET_DEGREES 200
#define STEPS_PER_DEGREE (STEPS_PER_REV / MAX_DEGREES)
// Create an instance of the SwitecX25 motor
SwitecX25 motor(STEPS_PER_REV, MOTOR_PIN1, MOTOR_PIN2, MOTOR_PIN3, MOTOR_PIN4);
void setup() {
motor.zero(); // Move the motor to its zero position
delay(1000); // Wait for 1 second to allow motor to zero
}
void loop() {
// Move to 200 degrees
int steps = TARGET_DEGREES * STEPS_PER_DEGREE;
motor.setPosition(steps);
while (motor.stopped == 0) {
motor.update();
}
delay(1000); // Wait for 1 second
// Move back to 0 degrees
motor.setPosition(0);
while (motor.stopped == 0) {
motor.update();
}
delay(1000); // Wait for 1 second
}
If you have wired your controller, H-Bridge and motor correctly this code should see the motor move 200 degrees and back to 0 repeatedly like a window wiper,
What cars use this motor? Quite a few:
No related posts.
No related posts.