The Gimbal-less Joystick - Redefining Control With a Solid-State IMU Core.

A New Horizon in Controller Design

For a while now, I've been looking for a flight stick that is simple, easy to take with me, but still versatile enough for different sims. Commercial sticks often have complex and bulky gimbals, and I wanted to see if I could build something with very simple mechanics that still felt great to use. This project is the result: a 3D-printed, IMU-based flight stick that does away with the traditional gimbal entirely.

The real clue to this design is how it moves. The entire stick simply balances on a 3D-printed half-dome at its base. This allows for fluid and intuitive control over the pitch and roll axes, which are read by an IMU mounted at the pivot point. The feeling is very close to a standard joystick without a bulky controller base and works best on a fabric surface like a mousepad, which gives it just the right amount of grip and slide. If you dare you don't even need a surface - just hold the controller up in air. The movements will be measured by the IMU.

To keep the design compact and versatile, I've used a single rotational dial for both throttle and rudder control. The challenge here is that you can't use one potentiometer for two different settings without getting a "jump" in the values. So a solution was to build a "pickup" logic into the firmware. When you press and hold one of the modifier buttons (I've put one on each side for both left- and right-handed use), the code waits for you to move the physical dial to match the rudders's last known value before the control engages. This gives you a smooth and predictable transition between the two modes.

Vital settings such as sensitivity, responsiveness, handedness can be modified in a serial menu mode if activated at startup. Set values are saved in EEPROM and reused with every startup of the controller.

So ultimately my project resulted in a portable hands on single stick, throttle and rudder (HOSSTAR?).

The controller is built from a mix of common electronics and a custom-designed PCB and 3D-printed parts.

From the shelf

The Brains: An Arduino Pro Micro runs the whole show. It was the perfect choice because its ATmega32U4 chip can act as a native USB HID device, so any PC will recognize it as a game controller without any special drivers.

The Senses: An MPU-6050 IMU is the core sensor. It's connected to the Arduino via I2C and reads the orientation of the stick to control the pitch and roll axes. Furthermore the design caters for up to four switch buttons for the activation, modifier function and multi purpose buttons. A dial potentiometer is responsible to measure thrust lever inputs, respectively rudder inputs if modifier is pressed.

DIY electronics

The Interface: For all the buttons and the main potentiometer, I designed a simple PCB in KiCad to act as a "shield" for the Pro Micro. This keeps the wiring much cleaner and more organized inside the grip.

The related gerber files can be downloaded from github.

3D printable parts

I designed all the parts to be easily printable and functional.

Grip and Handrest: The main grip is printed in two halves. It's designed to be ambidextrous, with four pushbuttons placed for easy access from either side. A separate handrest is fixed around the bottom of the grip for better ergonomics.

The "Gimbal": The IMU is mounted inside a half-dome that is fixed to the bottom of the stick. This is the part that allows the controller to tilt in any direction for X and Y control.

Top Controls: On top of the stick, there's a mount for a 5-way coolie hat and two additional multi-purpose buttons. Right below this is the rotational dial which is connected to the potentiometer for throttle and rudder inputs.

The printable parts can be downloaded from tinkercad as version 4.9 or 5.9

The electronics are the heart of our controller, translating every physical movement and button press into a digital signal. The design is straightforward, centered around a powerful Arduino Pro Micro and an IMU, all brought together on a custom-designed circuit board to keep the wiring clean and simple.

Core Components

Arduino Pro Micro (ATmega32U4): This is the brain of our controller. It was chosen specifically for its native USB capabilities, which allow it to be recognized as a plug-and-play joystick by any modern PC without needing special drivers.

IMU ( MPU-6050): This is the primary sensor, acting as the gyroscopic core of the balancing stick. It measures pitch and roll orientation. It communicates with the Pro Micro using the I2C protocol, which only requires two signal wires.

Inputs: The controller uses a standard potentiometer for the thrust/rudder dial and simple tactile pushbuttons for all the other functions, including the 5-way coolie hat. All the inputs are wired directly to the Arduino Pro Micro according to the following layout. The buttons are all connected using the INPUT_PULLUP mode, so you only need to wire them between their assigned pin and Ground (GND).

Taking it to the Next Level: A Custom PCB with KiCad

For this project, I designed a simple "shield" that the Pro Micro plugs into. This shield has dedicated connection points for the potentiometer, all the buttons, and the IMU, which keeps the internal wiring incredibly tidy.

The best part is that powerful PCB design software is completely free. I used KiCad, an open-source and incredibly capable tool for schematic capture and PCB layout. The basic idea is:

Draw the Schematic: First, you draw a logical diagram of your circuit in KiCad's schematic editor, showing how all the components (the Pro Micro, buttons, etc.) are connected.

Lay out the Board: Next, you switch to the PCB editor. Here, you arrange the physical footprints of your components on a virtual board and then draw the copper "traces" that connect them, just like you drew the wires in the schematic.

From Design to Your Doorstep with printed circuit boards

In the past, getting a custom PCB made was expensive and difficult. Today, smart services make it incredibly easy and affordable.

Once you finish your design in KiCad, you export a set of manufacturing files called "Gerber files." You then upload these files to the respective PCB website, choose your desired color for the board (I went with blue), and place your order. Some time later, a stack of your professionally-made, high-quality circuit boards arrives at your door, ready for you to solder your components onto. It's a game-changing process for any electronics hobbyist and takes your project from a prototype to a polished, final product.

You can find the gerber production zip file on github.

The hardware is only half the story; the real magic happens in the firmware. The code is what turns a collection of sensors and buttons into a responsive, highly configurable game controller. This section breaks down how the software works, from its core features to the powerful setup menu that makes it so versatile.

Core Features

To get the performance and features we want, the firmware accomplishes several key tasks:

Advanced IMU Filtering: Raw data from an IMU is noisy and prone to drift. To fix this, the code uses a Kalman filter, a sophisticated sensor fusion algorithm. It intelligently blends the accelerometer's long-term stability with the gyroscope's instantaneous motion tracking. The result is incredibly smooth and responsive pitch and roll control that feels like a high-end joystick.

Ambidextrous Rudder/Thrust Control: A single potentiometer seamlessly controls two different axes. By default, it manages the Thrust axis. But hold down one of the modifier buttons (Button 2 or 3), and it instantly switches to controlling the Rudder axis.

"No-Jump" Pickup Logic: To prevent the axis value from jumping wildly when switching between thrust and rudder, the firmware uses "pickup" logic. When you switch modes, the code waits for the physical lever's position to match the last known value of the target axis before re-engaging control. It's a clever trick that makes the dual-mode system feel smooth and intuitive.

Plug-and-Play USB Joystick: Thanks to the Arduino Joystick library, the firmware handles all the low-level communication. To your PC, it appears as a standard, plug-and-play USB game controller, requiring no special drivers or software.

The On-Board Setup Menu: No More Re-Uploading!

Instead of changing settings by editing and re-uploading code, you can configure the controller on the fly through its built-in Setup Menu.

How to Access:

Unplug the controller.

Press and hold the activation button.

While holding it, plug the controller into your PC.

Open the Serial Monitor in the Arduino IDE (at 115200 baud). The menu will appear.

From this menu, you can customize and save the following settings directly to the controller's memory:

Max Lean Angle: Adjust the physical tilt sensitivity. Set how far you need to lean the controller to get 100% joystick output in-game.

Handedness: Choose between Right-Handed (Inverted) and Left-Handed (Normal) modes. This inverts the potentiometer's output so you can choose whether pulling the lever towards you increases or decreases the thrust/rudder value.

IMU Responsiveness: Fine-tune the feel of the stick by cycling through three Kalman filter presets: Smooth, Quick, and Fastest.

Pickup_threshold: Can now be adjusted via menue.

Once you save, the settings are stored permanently on the device. Your custom configuration goes with you, no matter what computer you plug into.

The boards.txt: Giving Your Controller a Unique Identity

A very useful tweak in the Arduino IDE is customizing the boards.txt file. When you build multiple USB devices using the same board (like the Pro Micro), they all report the same Vendor ID (VID) and Product ID (PID). This means your computer sees them as identical copies.

By creating custom board definitions in this file, we can assign a unique Product ID and USB Product Name to each of your controllers.

This is how we get the "My Custom Flight Yoke" and "My Custom Flightstick" to show up with their own names in the Windows Game Controllers panel. It's a powerful feature that makes your DIY projects feel like professional, distinct pieces of hardware.

The Future: Ideas for Firmware Updates

A great advantage of a custom controller is that it can evolve. As soon as the hardware is solid, we can add new features and capabilities just by updating the firmware. Here are some of my ideas for the future:

Custom Curves and Deadzones: Add functions to create custom response curves for the axes, making them less sensitive in the center for fine control, or more sensitive at the edges for aggressive maneuvers.

On-the-Fly Sensitivity Control: Use the coolie hat, combined with a modifier button, to adjust the sensitivity of the pitch and roll axes in real-time while you're flying.

Macro Functionality: Program one of the buttons to send a sequence of keyboard presses, allowing you to create complex macros for in-game commands.

A lot of work went into the 3D body for the joystick. Tinkercad does not provide the most advanced complex body development tools and I did not yet prioritize hobby-time to gather experience with Autodesk Fusion which seems pretty sophisticated. So the body of my HOSSTAR looks more like a kids building block work - but is does the job.

I created two versions - the first was a bit less ergonomic, so I worked on a more suitable form. Both forms worked very well in my flight sim testing.

The assembly is a bit ricky:

Solder required wiring to push buttons, poti and coolie hat. Best way is to use pin headers and connect using jumper wires. However you may run out of space. In the protoype I soldered the wires to the pins directly. Only for the connectors to the board I used socket headers.

You wil need to glue the bushbuttons into position with a small glue bubble - otherwise the assembly will cause real headache.

Fix the IMU to the bottom half dome as indicated in the Tinkercad model with two M3 screws. In version 2.8. the IMU is mounted facing down and the software is adjusted to this orientation. Needs to be considered when mounting in another orientation.

Fix the coolie hat with the cover to the top cap using 4 M3 screws and insert the wire through the opening so that it can be connected inside the grip to the PCB shield.

Put the thrust lever onto the potentiometer dial. The poti needs to be adjusted to 50% so that is can be dialed into both directions.

When all buttons and connectors are fixed make a test run! I had some bad experience having to diassemble a tediously assembled grip just because there were some connections nonfunctional.

put the handrest over the grip and the cover on the grip and use the screws to tighten.

Initial Version

Second Version

It's nice to look at this finished flightstick and remember it started with an idea around low-to-no-mechanics controller.

What I ended up with isn't just a generic DIY joystick, but a controller that's really my own. I like that it's set up for my preferences and feels comfortable to use.

This was a good reminder that you can make something surprisingly capable and satisfying by combining simple hardware with some smart software and a bit of collaboration.

I would like to give a big credit to my Microelectronics Buddy (Gemini Gem) with whom I could greatly brainstorm my ideas and complement them with its inputs (knowing it is 'just' an LLM - but the brainstorming dynamic really blew me away). The concept, design and features are originated from my own ideas. Software coding, and some writeup of the documentation are from my buddy.

Isn't it mindblowing what we can do in today's time - imagine trying this 15 years ago...