This little project aims to give the Logitech G27 gaming steering wheel a quick-release mechanism that still allows all of the on-wheel buttons to operate. I’ve become a bit of a racing fan lately, and have built up a little formula-style simulator rig for home. As part of the rig, I’ve also 3D printed myself a couple of different steering wheels, and wanted the ability to swap wheels out, but maintain working buttons on all wheels.

This has been achieved using off-the-shelf RJ45 plugs/sockets and some 4-pin JST connectors, and has been working great.

The project design

## UPDATE: Fusion360 project file

You can download the original project F3D file for this at https://drive.google.com/file/d/1sIe2yy43A-gLZU5LipdCCJJ3xd8svUNW/view?usp=sharing

Be kind, this was my first 3D modelling / Fusion360 project, so it’s probably a bit of a shambles 🙂

There’s 2 main parts to the design.

The first is the “base-side hub” – the part on the lift in the above image, which obviously attaches to the G27 base, and has the RJ45 socket.

The second is the “wheel-side hub” – the part on the right. The idea that one of these is printed and attached to each wheel that you have. The wheel-side hub has a number of 3D printed parts, including the main hub, a couple of locking bars to stop the wheel from popping off, and a spring-loaded release-ring to lock the locking bars in place.

Pros:

• Relatively small 3D print requirements, even at the 100% infill that I have printed
• Relatively cheap off-the-shelf components
• Fits the Logitech G27 and G25 mount pattern
• Easy to replace/re-print if a part gets damaged

Cons:

• While it will stand up to abuse from people who are used to racing games, if there are people using it who might not be familiar with racing, they can put stress on the 3D printed mount. Often these people, usually kids, push the wheel forwards more than actually rotating the wheel. For me, this led to one case where the base-side hub had snapped, although this just meant I had to printing a new piece and swap it over.
• This model adds around 35mm of distance between the steering wheel and the shifter paddles. Whilst you can still reach the paddles OK, I opted to 3D print some paddle extensions – The STL file for the extension is available here – this doesn’t include the little back piece as I lost the original project file and I need to re-design it again
  

The Parts

• Obviously you’ll need a 3D printer and filament. I’m rocking an old Makerbot Replicator 2 with bog-standard PLA filament from BilbyCNC
• 1 x RJ45 Plate insert. I bought mine from Bunnings for around $11 and modelled the mount around it’s dimensions, so if you have a different one then you may need to tweak the model
• 1 x RJ45 cable, or an RJ45 plug and some cable that you can crimp yourself. I got lazy and just cut up an old network lead that I had lying2  around
• 2 x 3/8″ x 3/4″ x 0.32 compression springs. Honestly I think I actually used some 3/8″ x 1-1/3″ x 0.41 springs and cut them to size, but it’s been a while since I actually built this, so I’m going from memory. I got mine at Bunnings for around $3 and just cut them to size, but if you’re keen and have the tools then you may want to wind your own for a better fit
• 2 x 3/16″ x 1 3/8″ x 0.16 compression springs. You’ll get away with one easily, but again they’re about $3 at Bunnings and we’ll be cutting them to size
• 4 x 4pin Mini Micro 2.0mm PH connectors (male and female connections). These are the connectors that connect the stock G27 steering wheel to the wheel base. I grabbed mine for around $3 on ebay but do take care to make sure you get the right ones. Note that the G27 uses a different plug, so if you’re doing this for a G25 then you’ll need to try to confirm which ones to order (honestly, trial an error is probably your friend here, because documentation online is non-existent)
• 6 x M4 lock-nuts
• 6 x M4 bolts (per steering wheel). The exact length you’ll need will depend on the wheel you are attaching, and you’ll probably end up cutting them to fit exactly anyway.
• You’ll also need some screws to attach the mounting hub to the G27 base. Now, I built this project so long ago that I can’t recall exactly what type these were, but I took the original hex-bolts from the G27 to Bunnings and bought some that had the same thread pattern. I think I ended up with sheeting screws, but I recommend you go to your local hardware store with an original bolt and get them to find a matching thread
• 3D printed parts – STL Files available here. You’ll need:
  • 2 x locking bars (per steering wheel)
  • 1 x release ring (per steering wheel)
  • 1 x Wheel-side hub (per steering wheel)
  • 1 x Base-side hub

The Build

1. Print and prepare the parts

Download each of the STL files and print them. I printed all of mine with 100% infill – you may be able to get away, but as they’re relatively small parts and will potentially see a fair bit of load, I just did 100% fill. You will need to print the parts with supports enabled unless you’re a 3D printing ninja – but for us mere mortals, use supports and just remove them later.

After printing each part, you’ll need to sand down each of the contacting surfaces. They will be the out-side face of the base-side hub (A), the inside and outside edges of the wheel-side hub (B & C), and the inside of the release ring (D). You’ll also likely need to do a little sanding on the locking bars to make them slide freely in the channel of the wheel-side hub:

After you’ve printed and sanded all of the parts down, make sure that they slide Ok over each other. I’ve used a Crème brûlée torch and gone over the sanded faces lightly to bring back the shine on them, and the fit and finish is really quite nice

2. Assemble the Wheel-side hub

At this stage, I’d recommend placing the M4 lock-nuts in their hexagonal homes now before you do the next step. I’ve made the tolerances quite tight for the model, so you may need some pliers to get them to slide home, so may as well do it now before other parts get in the way.

Once all of the parts fit together nicely, you need to cut some of the thinner springs down to act as a pre-load for the locking bars. They need only be fairly short, between 5-10mm in length – just enough to push the locking bar back out of the channel.

This is the part there you need 3 hands, but take it one side at a time.

• Place the shortened spring into the little circular indent in the wheel-side hub channel
• Then carefully place one of the locking bars over the spring and push it in so that the locking bar sits flush in the channel
• Hold it carefully in place with your thumb, and repeat with the spring and locking bar on the other side
  
• When you have both springs and locking bars in place, take the release ring and line up the notches with the side channels on the hub. You need to carefully slide the release ring down the channel, over the locking bars, and then rotate the ring to lock it in place on the hub

The final part for the Wheel-side hub is the electronics, but let’s leave that for now and come back to it shortly. We need to quickly cover off some things about the wiring..

3. The wiring design

So there are 8 wires that we need to deal with between the G27 base and the steering wheel – they are:

1. Left buttons - Common Ground
2. Left Top Button +
3. Left Middle Button +
4. Left Bottom Button +

5. Right buttons - Common Ground
6. Right Top Button +
7. Right Middle Button +
8. Right Bottom Button +

Luckily, an RJ45 connector has 8 connections that we can use, we just need to be consistent from here on in with what pins we’ll assign to what wires in our quick-release system. It can get confusing, especially as the RJ45 sockets usually have the pins colour-coded instead of numbered. This is another reason that I used an old network cable for part of this project, as the network cable wires are colour coded to match already.

Cable Length: I generally have around 50-75mm of cable between the JST and RJ45 connectors on each of the parts. This can be slightly too much in some cases, but I find it better to have the length to play with and then adjust later if needed.

My approach to the wiring was to set up the base-side hub that has the RJ45 socket connector in it according to the following wiring schematic. Here, we are wiring up the male 4pin JST 2.0mm PH connectors to the back of the female RJ45 connector. At this point, it should be as easy as pushing the wires into their corresponding slots with something like a jeweller’s flathead screwdriver.

NOTE: When connecting the wires to the RJ45 socket, follow the colours indicated in the diagram, not necessarily the physical location on the diagram. My connector has laid out the location of the pins slightly different to the diagram, but by following the colours, I get the same result.

The reason I’ve wired up the base-side hub like this is that it neatly lines up one plug with the first 4 pins on the male RJ45 lead, and the other plug with the next 4 pins. This can be helpful if you’re crimping your own connectors, but preference was just to take an old network lead and cut it in half to save time.

The result is that you can connect the RJ45 plug to the female JST connectors according to the following diagram.

4. Insert the network connectors, and mount it all up

BEFORE you insert the RJ45 plug, tear/but off the retaining clip so you can remove the wheel from the hub!!

Once you’ve soldered the the connections in place, you can simply insert the network connectors into the corresponding spots in the 3D printed parts as in the picture below.

Be careful to orient the plug and socket up the same way. The 3D printed parts are keyed to only slot in one way, so you need to make sure the plug and socket are in the same orientation or they won’t go in fully.

Then connect the JST connectors of the base-side hub to the G27 base and screw the hub in place with the relevant screws. Bolt the wheel-side hub to your steering wheel, making sure that the bolts don’t protrude past the nuts that are held in the hub. If the bolts are too long, you may not be able to slide the release ring down enough to unlock the locking bars, and you won’t get the wheel on or off the quick-change hub.

And that’s it! A little time-consuming to build, but works a treat, and should fit to any wheel with the G27 mounting pattern. I’ve already got the original wheel and a few different 3D printed wheels that I swap between.

This is a project based on the ETC #lighthack Box-1 project that can be purchased as a full kit to build yourself at https://shop.etcconnect.eu/lighthack-box-1-kit/. This project is a bit of an extension/modification to the original project to suit my needs better.

I currently use an ETC Element lighting desk which is great, but having just purchased some moving head lights, the desk isn’t as great at programming these lights due to it’s lack of encoder wheels.

One quick caveat – the original code worked with multiple ETC console families. The code listed here has been cobbled together from the original source, my own head, and some various posts in the #lighthack forum. As a result, this code only currently supports the EOS family of consoles, although it should be easy enough to add support for other console families back in – honestly I just haven’t been bothered at this stage to go through it all..

The code for this has been moved to github and is available at https://github.com/ntbutler87/lighthack/blob/master/sketch_sep30a.ino

Operation

Connecting the encoder wing to an ETC EOS device should take a few seconds, and then the screen will display the first “page” of parameters – Pan, Tilt and Edge.

When you have a compatible fixture selected in the EOS software, you can turn the leftmost encoder to change the first value – in the above photo, this is Pan. Turning the second encoder will control the second parameter, and the right-most encoder will control the third parameter.

Each “tick” of the encoder has been set to send four “ticks” to the EOS software. By holding down the momentary “Fine” switch, the encoder wing will change to send one “tick”.

You can push in the left and centre encoders to use the Next and Last functions of the EOS software (to easily move between individual fixtures in a group for example).

By pushing in the right-most encoder, you will change the “page” of parameters that the wing is controlling. The code has been set initially to change to control Red, Green and Blue, but could be adapted to control others such as zoom, Gobo shake, etc.

The Parts List

Rather than spending $100+ on the full kit, most of which I had various bits and bobs of anyway, I’ve taken and adapted the original Arduino project to work with what I already had.

The parts list for this project are:

• 1 x Arduino Nano (or nano clone – see the info regarding the driver for clones below). I had a clone from ebay for a couple of dollars.
• 1 x XC4629 TFT 128×128 Colour LCD display – I bought mine from Jaycar for around $20AU a fair while before this project and had it lying around –
• 3 x SR1230 rotary encoder’s with push-button – again, I purchased mine from Jaycar for around $10AU each
• 3 x knobs for the rotary encoder. I would have preferred a nicer one similar to the knob on other ETC desks, but I just grabbed some quickly from Jaycar for about $5AU each
• 1 x 12mm x 12mm Tactile momentary switch. I bought mine in a pack complete with various coloured caps from ebay for another project
• Either:
  • a perfboard to build the project on (something like this one from Jaycar) OR
  • A custom printed PCB. I have created a custom PCB layout that can be ordered from JLCPCB for around $16AU + shipping for 5 units. Gerber files will be linked here which you can upload and order your own.

• You will also want some sort of case that will fit the project. Seeing as I have access to a 3D printer, I have designed and printed my own custom base to fit. The face plate STL file is available here – the back plate STL file needs a bit of re-design, so I’ll upload it at some point..

The Process

1. Gather together all of the electronic parts. Last time I ran the numbers, it was around $90 of parts.
2. If you are 3D printing a case, I printed mine with fairly coarse and fast settings. I printed mine with PLA using an 0.4mm nozzle, with 0.24mm layer height, 8% infill with fairly high speeds. I printed mine on a Makerbot Replicator 2 with painters tape on the base.
3. If you’ve gone with the custom PCB design attached above and ordered some for yourself, it should be as easy as inserting and soldering all of the components in place, then move on to step 5. If you’ve decided to build your project on a perf board, you’ll need to decide on a layout for your components, and solder them according to the schematic in step 4.
4. If you’re laying out the design on a perf-board or breadboard, here’s the pinout map:

   Arduino Pin  |  Connected to
   ____________________________________
      A0        |  Encoder 1 - B pin
      A1        |  Encoder 1 - A pin
      A2        |  Encoder 2 - B pin
      A3        |  Encoder 2 - A pin
      A4        |  Encoder 3 - B pin
      A5        |  Encoder 3 - A pin
      D4        |  Momentary switch +
      D5        |  Encoder 3 switch +
      D6        |  Encoder 2 switch +
      D7        |  Encoder 1 switch +
      D8        |  LCD - RST pin
      D9        |  LCD - DC/RS pin
      D10       |  LCD - CS pin
      D11       |  LCD - SDI pin (not necessarily required)
      D13       |  LCD - CLK pin (not necessarily required)
      3.3V      |  LCD - LED pin
      VCC       |  LCD - VCC pin
      GND       |  C pin for all encoders, negative for all switches, and LCD GND pin

   Here is a quick mockup of the wiring in EasyEDA
   

   My original build was done on a perf board, so here’s a couple of shots of what it looked like top and bottom (ignore the lines marked on top – they’re mostly wrong..):

   This slideshow requires JavaScript.
5. Program the Arduino:
   1. If you haven’t already, download and install the Arduino IDE
   2. If you are using a non-genuine Arduino, you will likely need to install the driver for your clone device. Check out the chipset of your device, and find and install the driver that you need. If you can’t see your board as a COM or usb connection in Arduino when you go to Tools -> Port, then you may be missing the driver
   3. In the Arduino IDE, go to Sketch -> Include Library, and look for the OSC (Open Sound Control) Library. Select it in the list and click Install
   4. In the Arduino IDE, go to Sketch -> Include Library, and look for the TFT Library. Select it in the list and click Install
   5. Download the Arduino code at the bottom of this post. Paste it into a new Arduino sketch
   6. Click the Verify (compile) button in the Arduino IDE. If there are any errors, make sure you have the above listed libraries installed, and/or work through the errors.
   7. When the code verifies of, connect your Arduino to your computer via the USB cable
   8. In Arduino, go to Tools -> Board, and select “Arduino Nano”
   9. In Arduino, go to Tools -> Port, and select the COM or device port for your Arduino
   10. For older Arduino nano’s and clones, you may need to select a different bootloader, so in Arduino, go to Tools -> Bootloader, and select “ATMega 328P (old bootloader)”
   11. Click the Upload (arrow) button to compile and upload the code to the board

If all goes well after that, the device should be ready to go. As a quick test, you can download the ETC Nomad software from their site. Download and run the software and make sure your encoder wing is connected via USB, and if all is well, the screen should show the Pan, Tilt and Edge parameters. (If it’s not connecting, the encoder wing will just display “waiting…”).

Troubleshooting

1. Can’t compile/upload the code to the Arduino

If you’re having issues uploading the code to the Arduino, there’s a couple of things you can check. First, see if the code will compile (click just the Compile button in the Arduino IDE). If it fails to compile, it is likely that some required libraries haven’t loaded in.

Try going to Tools -> Library Manager in the Arduino IDE. Look for and install the OSC and the TFT libraries

This slideshow requires JavaScript.

If you can compile the code OK, but can’t get it to upload, make sure you have the Arduino drivers installed for the device you are using. If you’re using genuine Arduino parts, this should be as easy as installing the Arduino IDE and making sure you do install the drivers as part of that process. If you, like me, have used an arduino clone, then you’ll also need to install the correct driver for the clone device. I think mine was a CH340/CH341 driver that was needed, but check the specifics for the device you have.

Once you know you have the correct drivers installed, you should be able to set the board type to Arduino Nano in the IDE and find the COM port to connect to the device. A quick note that, as my nano was purchased a while ago, I did have to change the Processor to the “ATmega328P (Old Bootloader)” in order to upload sketches.

2. The encoder wing won’t connect to the ETC console – just stays “waiting”

Check to see that OSC USB device support/operation is enabled in our ETC Software (nomad or console). Go to Settings -> System Settings, then go to “Show Control” -> “OSC” and ensure the “USC USB” option is enabled.

3. OSC USB is enabled but it still won’t connect to the ETC console

If you’ve uploaded the code correctly and ensured that OSC USB is enabled in the ETC EOS console, then you may need to ensure that the arduino driver (or arduino clone driver) is installed on your console.

Whilst I’m not sure if this is common knowledge, it’s wasn’t difficult to get local admin access on the ETC console to install the drivers. The console I have runs Windows 7 embedded. If you exit out of the EOS software and go to the Settings menu, and head into the Maintenance section, there should be a log out button. This will take you to a Windows 7 login screen, that shows an Admin user that you can log in as. After a couple of guesses, it was easy to get access to my Element console using the password “element”.

Once you have local admin access to the console, you can simply put the drivers/installers onto a USB stick and access it on the console to install them there.

4. The Encoder Wing is connected, but none of the parameters are updating/changing

Whilst I’m sure anyone reading this post would already know this, it’s worth pointing out that you need to have a fixture/channel/group/etc selected in the EOS software that supports the parameters that you are trying to control. For example, I have some moving head lights that are a simple white LED with colour and gobo wheels. Obviously, if I have these fixtures selected on the console, then I can control the Pan, Tilt and Edge parameters, but Red, Green and Blue do nothing, and it’s the other way around for my LED RGBU PARs which do not move. Double-check to see what fixtures you have selected in your console and what parameters they support.

Also, hopefully you read the sentence at the start of this post that noted that my code is rather hacky and is missing the code from the initial project that supports consoles other than the EOS ones. Whilst I do plan to fix my code at some point, I haven’t yet (apologies), so if you’re not running an EOS family console, then you’ll need to fix my code to work with your console.

The Code

The arduino code has been adapted from the original box_1 source code available here

The main changes to the code are as follows:

• The display code has been changed for the XC4629 colour TFT LCD screen that I had on hand
• The code is a bit messy/hacky, but has been built so that there is minimal updates made to the LCD screen, and when those updates are made, they are done to as fewer pixels as possible, as the display refresh for large areas can cause a big performance hit and makes it much less user-friendly
• There are more encoder wheels than the original project, and I use the encoder button functions for the NEXT, LAST and page toggle functions
• The unit can now do multiple “pages” of controls. That is, initially the 3 encoders will control Pan, Tilt and Edge, but by pushing the 3rd encoder button, it will toggle to a new “page” to control Red, Green and Blue. This code was taken/adapted from someone else’s on the #lighthack forum. I have left it at just these 2 pages as it serves my needs, but this could be adapted to control even more if needed.
• The single momentary switch is designed to be the “fine” control as-it-were. In effect, all I’ve done now is made the encoders “tick” at a faster rate, and when the momentary switch is held down, it just reverts the scale of the “ticks” back to 1 unit.

The code is available at https://github.com/ntbutler87/lighthack/blob/master/sketch_sep30a.ino