Click here to get this special deal

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.

---

Why Use an Electric Car Seat?

Car seats, especially electric ones, offer:

• Adjustable Positioning: Perfect for dialing in your driving position.
• Durability: Designed to withstand years of use.
• Cost-Effectiveness: Many great options are available for under $100.

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.

---

What You’ll Need

Here’s what I used to repurpose my seat:

1. Electric Car Seat – Find one that suits your comfort and style.
2. PC Power Supply – A repurposed desktop power supply can deliver the 12V needed for the seat’s motors.
3. Breakout Board – Simplifies the wiring and allows for easy connections.
4. Basic Tools: Screwdrivers, wire strippers, and a multimeter.
5. Safety Supplies: Heat shrink tubing and electrical tape for safe wiring.

---

Step 1: Test the 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.

---

Step 2: Set Up the Power Supply

A PC power supply is ideal for this project because it delivers the necessary voltage and amperage. Follow these steps:

1. Modify the Power Supply: Remove it from the computer and identify the 12V lines (yellow wires) and ground (black wires).
2. Use a Breakout Board: While optional, a breakout board makes connections cleaner and safer.
3. Test the Output: Use a multimeter to ensure the correct voltage is delivered before connecting the seat.

---

Step 3: Wire the Seat

1. Connect the seat’s power input to the 12V output of the power supply.
2. Ground the seat to the power supply’s black wire.
3. Test each motor function to confirm the connections are correct.

---

Step 4: Mount the Seat

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.

---

Safety Tips

• Avoid Overloading the Power Supply: Ensure your seat doesn’t exceed the supply’s amperage.
• Insulate Exposed Wires: Use heat shrink tubing or electrical tape to cover all connections.
• Skip Airbag Wiring: Leave out unnecessary systems to avoid complications.

---

Final Thoughts

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!

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.

Design Overview:

• Structure: Based on my earlier pedal design, with modifications to replace the pedal mechanism with a handbrake lever.
• Material: 3D-printed components, including a reinforced hollow shaft to accommodate an 8mm threaded rod for added strength.
• Controller Integration: A compact enclosure for the controller ensures easy connection and independent functionality.

Challenges and Improvements:

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.

Assembly and Testing:

• After painting and assembling the parts, I connected the controller and sensor. Initial adjustments ensured proper alignment and sensitivity of the hall-effect sensor.
• Once calibrated, the handbrake worked seamlessly with the PC, offering precise input recognition.

Key Takeaways:

• Strength Optimization: Using 100% infill on critical parts ensures durability without compromising functionality.
• Customization: Designed to be user-friendly and adaptable, making it a great DIY project for sim racing enthusiasts.

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.

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.

Why Hall Effect Sensors?

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.

The Design

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:

1. Structure
   • The pedal frame consists of PLA 3D-printed sides reinforced with six aluminum tubes and bolts, providing excellent strength and minimal twist.
   • To ensure clean and precise cuts, I recommend using a good pipe cutter.
2. Magnet Holder and Spring
   • A magnet holder keeps the magnet parallel to the Hall effect sensor.
   • A spring, sourced from a disassembled hardware clamp, provides resistance to the pedal’s movement. The spring was sturdy enough to withstand heavy use, making it ideal for this setup.
3. Sensor Mounting
   • The Hall effect sensor is securely housed in a dedicated slot beneath the pedal. Its orientation ensures accurate detection of the magnet’s position.
4. Final Assembly
   • Once the frame, magnet, spring, and sensor were in place, I attached a custom pedal face. All components were wired to the controller for seamless communication.

Calibration and Testing

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:

• Steering Wheel: Translates movements onto the screen as expected.
• Pedals: Display accurate input changes when pressed, with real-time feedback visible on the calibration tool.

This ensured that the pedals worked flawlessly alongside the steering wheel in my sim setup.

Make Your Own

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?

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!

The Inspiration

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.

The Concept: NeoPixel Frisbee

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.

Initial Setup and Challenges

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:

1. Advertise time: The tags only transmit every three seconds, which is too slow for a real-time game.
2. Processing Power: The ESP32-C3 struggled to handle the NeoPixel lighting and Bluetooth scanning simultaneously, which affected the frisbee’s performance.

Switching to the Raspberry Pi Pico

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.

Building the NeoPixel Frisbee

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:

• NeoPixel Ring: This goes inside the frisbee to create the light effects.
• Accelerometer: Used to measure the frisbee’s speed and intensity in motion.
• Bluetooth (for future use): While the Bluetooth tags didn’t work as planned, there’s still potential for future enhancements with Bluetooth-enabled devices.

A voltage booster was added to ensure the power requirements were met for the NeoPixel ring.

Coding the NeoPixel Effects

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!

Join the DIY Community!

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.

---

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.

Materials and Tools

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:

• Laser-cut MDF panels
• 3D-printed corner supports
• Old-school arcade buttons and joystick
• Affordable Nintendo Switch controller (for repurposing the internals)
• Quick connectors for easy wiring
• Inkjet printer for artwork
• Adhesive spray for artwork application
• Black vinyl for a polished finish
• Clear acrylic sheet for artwork protection

Step 1: Building the Frame

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.

Step 2: Setting Up the Classic Arcade Layout

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.

Step 3: Repurposing a Nintendo Switch Controller

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.

Step 4: Adding Artwork for that Arcade Vibe

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.

Final Thoughts: Bringing Retro Arcade Gaming to the Switch

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!

Step 1: Understanding the Setup and Goals

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.

Step 2: Creating the Gauge Faces

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.

Step 3: Backlighting with NeoPixels

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.

Step 4: Assembly

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.

Step 5: Connecting to SimHub

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.

Final Thoughts

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.

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.

The Turbo Button Issue

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.

A Simple but Effective Solution

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.

A $15 Win

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.

Building the Fight Stick

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.

Personalizing the Design

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.

What’s Next?

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!

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.

The Challenge: Finding the Right Solution

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.

A Breakthrough: Discovering Handheld Legend

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.

Hurdles Along the Way

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.

A New Hope: OpenController-ESP32

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.

Fumbling My Way to Success

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.

Final Thoughts: It Works (Almost) Perfectly!

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!

Next Steps: Building the Arcade Cabinet

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.

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.

Components Needed

• Raspberry Pi Pico
• x27.168 stepper motor
• L298N motor driver
• Jumper wires
• Breadboard (optional)

Wiring the Components

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.

1. Connect L298N to Raspberry Pi Pico:
   • Connect the IN1, IN2, IN3, and IN4 pins of the L298N to GPIO pins on the Pico (for example, GPIO 0, 1, 2, and 3).
   • Connect the GND and VCC pins of the L298N to the GND and VBUS pins of the Pico.
2. Connect the motor (see diagram)

Here is a simplified wiring diagram:

Test Code to Move the Motor

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:

• Cadillac Escalade GMT800 (models from 2003 to 2006);
• Chevrolet Avalanche GMT800 (models from 2003 to 2006);
• Chevrolet Frontera (models from 1998 to 2004);
• Chevrolet Silverado GMT800 (models from 2003 to 2007);
• Chevrolet Suburban GMT800 (models from 2003 to 2006);
• Chevrolet Tahoe GMT800 (models from 2003 to 2006);
• Fendt 206 (models from 2003 to 2009)
  all models including 206S, 206V, 206F;
• Fendt 207 (models 2003 from 2009)
  all models including 207S, 207V, 207F;
• Fendt 208 (models from 2003 to 2009)
  all models including 208S, 208V, 208F, 208P;
• Fendt 209 (models from 2003 to 2009)
  all models including 209S, 209V, 209F, 209P;
• Fendt Farmer 307Ci (models from 2003 to 2008);
• Fendt Farmer 308Ci (models from 2003 to 2008);
• Fendt Farmer 309Ci (models from 2003 to 2008);
• GMC Sierra GMT800 (models from 2003 to 2007);
• GMC Suburban GMT800 (models from 2003 to 2006);
• GMC Yukon GMT800 (models from 2003 to 2006);
• GMC Yukon XL GMT800 (models from 2003 to 2006);
• GMC Yukon XL Denali GMT800 (models from 2003 to 2006);
• Holden Frontera (models from 1999 to 2004);
• Honda Passport (models from 1998 to 2002);
• Hummer H2 (models from 2003 to 2007);
• Hürlimann H-1200 SX (models from 1998 to 2004);
• Hürlimann H-1350 SX (models from 1998 to 2004);
• Hürlimann H-1500 SX (models from 1998 to 2004);
• Hürlimann H-1600 SX (models from 2000 to 2004);
• Hürlimann H-1800 SX (models from 2000 to 2004);
• Hürlimann H-2000 SX (models from 2000 to 2004);
• Isuzu Amigo (models from 1998 to 2001);
• Isuzu Frontier (models from 1998 to 2004);
• Isuzu MU / Wizard (models from 1998 to 2004);
• Isuzu Rodeo (models from 1998 to 2002);
• KTM 690 Enduro (models from 2009 to 2017)
  all versions including 690 Enduro R, 690 Enduro Rally Replica;
• KTM 690 Duke (models from 2007 to 2016);
  all versions including 690 Duke R;
• KTM 690 SMC (models from 2008 to 2011);
• KTM 690 SMC R (models from 2012 to 2017);
• KTM 690 Supermoto (models from 2006 to 2012);
• KTM 990 Adventure (models from 2009 to 2014)
  all versions including 990 Adventure ABS, 990 Adventure Dakar ABS and 990 Adventure R;
• KTM 990 Super Duke (models from 2007 to 2013)
  all versions including 990 Super Duke R;
• KTM 990 Supermoto (models from 2007 to 2013)
  all versions including 990 Supermoto R, Supermoto T and Supermoto T ABS;
• Lamborghini Champion 120 (models from 1998 to 2004);
• Lamborghini Champion 135 (models from 1998 to 2004);
• Lamborghini Champion 150 (models from 1998 to 2004);
• Lamborghini Champion 160 (models from 2000 to 2004);
• Lamborghini Champion 180 (models from 2000 to 2004);
• Lamborghini Champion 200 (models from 2000 to 2004);
• Lombardini Marine speedometers
  some versions;
• Opel Frontera (models from 1998 to 2005);
• Peugeot Geopolis 125 (modeli from 2006 to 2013);
• Peugeot Geopolis 250 (models from 2005 to 2012);
• Peugeot Geopolis 300 (models from 2010 to 2015);
• Peugeot Geopolis 400 (models from 2007 to 2013);
• Peugeot Geopolis 500 (models from 2008 to 2012);
• Same Rubin 120 (models from 1998 to 2004);
• Same Rubin 135 (models from 1998 to 2004);
• Same Rubin 150 (models from 1998 to 2004);
• Same Rubin 160 (models from 2000 to 2004);
• Same Rubin 180 (models from 2000 to 2004);
• Same Rubin 200 (models from 2000 to 2004);
• Vauxhall Frontera (models from 1998 to 2004);
• Volkswagen Passat B3 / B4 (models from 1988 to 1997)
  some versions.