ThrustMaster® Mark II FCS: The Resurrection

The Story

It all started when I was visiting my parents over the holidays. I was going through my closet, and that's when I stumbled upon her, the ThrustMaster® Mark II Flight Control System... What an amazing piece of hardware! This was state-of-the-art technology when I bought it and it still has a cult-following today*.

*probably not, unless I start a cult.

The Snag

Just by looking at the DB-15 serial connector, it is immediately obvious it is a product of the 1990's. As such, it is completely incompatible with modern machines. A quick web-search revealed the DB-15 hurdle could be overcome with the Rockfire RM-203 gameport adapter.

However, I discovered the last known driver for the ThrustMaster® Mark II FCS was written for Windows 95 OSR 2. It's posted on a driver website, so please be extremely cautious/suspicious.

Uploader's notes:

This is the complete WCS loader program and driver set. The last one we made before ThrustMaster was sold to a French company. I was formerly the Direct Order/Customer Service Manager for ThrustMaster, Hillsboro, Oregon, USA. Remember to restart in DOS MODE when installing under OSR 2 or Win 98. Will NOT function under NT.

As you can see, it is clearly stated the drivers will "NOT function under NT", which means they also won't work for anything else of this century.

The Dissection

The good thing about working with older electronics, is the primary focus was to make them resilient to uncertain hardware/software environments. With that aim, they were built durable, easy to pull apart and to fix.

On initial inspection, the only visible screws are the hex-heads on the handle. I wasn't mentally prepared to jump into the handle, so I looked a little harder for the body screws. I was able to use a flat-head screwdriver to pry out the rubberized boots on the bottom of the control to reveal the phillips-head screws hidden beneath them.

The Base

I selected the PH2 phillips-head from my handy iFixit 54-bit driver kit; a perfect fit. The bottom half of the base was able to be pulled away without issue. Now the internals of the joystick mechanism are exposed. Two potentiometers, one for each axis, are revealed. Together, they will generate analog signals to represent their relative position on each axis. They are both powered by the same brown wire on their center pins. A white wire runs off the X-axis and a black wire from the Y-axis, while the remaining cables run into the handle. Before I closed it up, I ran a quick continuity test using my Extech DM110 Pocket MultiMeter.

• DB15::pin 1 -> wire::brown
  
• DB15::pin 3 -> wire::white
• DB15::pin 6 -> wire::black

NOTE: Apparently, I had the affordable model which has a rectangular plastic plate, to cover the body cut-away that would normally house the serial connection from the ThrustMaster® Mark II WCS.

The Control Stick

Now it was time to bite the bullet and open up the control stick. I used the H2.0 hex-head, and again, a perfect fit. I removed two screws, one at the top and one at the bottom of the joystick. When I started pulling it apart, it was caught but I couldn't see on what, so I kept wiggling and it eventually came apart; DO NOT DO THIS!!!

WARNING: There are two hidden screws beneath the grip pad along the joystick.

When the control stick is apart, there are three pieces you need to keep track of, the trigger, the tactile switch (pressed by the trigger), and the hat switch. As long as you keep it on it's side (depicted below), gravity will do all the work and it is easy to put back together. The first thing you notice, is the bare wire extending the green wire and providing current to all the digital buttons. The trigger is connected to a red wire, the red button at the top (button 1) uses a purple wire, the red button at mid-stick (button 2) uses a pink wire, and the red button on the bottom (button 3) uses a green wire with black stripe.

The hat switch is the subject of U.S. Patent #5,389,950. It is different in that it has its own power supply (orange with black stripe) and analog signal wire (green with black stripe). Basically, the hat switch is constructed of four tactile switches connected to a common power supply. Each tactile switch has a different resistor associated with it, and the output from each switch is merged together on single output wire creating an analog signal. As before, I ran continuity testing on each line and the results are listed below.

• DB15::pin 1 -> wire::orange/black
• DB15::pin 2 -> wire::red
• DB15::pin 4 -> wire::green
  
• DB15::pin 7 -> wire::purple
  
• DB15::pin 10 -> wire::pink
  
• DB15::pin 13 -> wire::white/black
  
• DB15::pin 14 -> wire::green/black
  

DB-15 serial connector pin map

1. Vdd analog
2. Trigger (digital)
3. X-axis (analog)
4. Vdd digital
5. [not used]
6. Y-axis (analog)
7. Button 1 (digital)
8. [not used]
9. [not used]
10. Button 2 (digital)
11. [not used]
12. [not used]
13. Hat (analog)
14. Button 3 (digital)
15. [not used]

The Resurrection

The breakdown showed us how the hardware works, now all we need is a platform to "normalize" it and make it consumable. The requirements are simple. We need two lines providing direct current, three lines reading analog input and four lines reading digital input. Nearly every MCU on the market can meet these requirements, so we can look to other considerations to make our decision; namely price, form-factor and ease-of-use. With these considerations in mind, I decided to use the Spark Core. The Spark Core is nice, because it is small enough to sit inside the void space in the base of the controller. The Core also has onboard wifi, so it will be simple to send the signal out to whichever target we need to control.

Now, I said the Spark Core can fit in the void space. However, while I'm still prototyping I'm not ready to cut the cord; so to speak. Without looking too hard, I was able to find a DB-15 breakout board on eBay (pictured below), and here is the mapping I used to wire it up.

Wiring Details

• DB15::pin 1 -> Core::3V3
  
• DB15::pin 2 -> Core::D7
  
• DB15::pin 3 -> Core::A0 -> 47K Ω resistor -> Core::GND
• DB15::pin 4 -> Core::3V3
• DB15::pin 6 -> Core::A1 -> 47K Ω resistor -> Core::GND
• DB15::pin 7 -> Core::D4
• DB15::pin 10 -> Core::D5
• DB15::pin 13 -> Core::A6 -> 47K Ω resistor -> Core::GND
• DB15::pin 14 -> Core::D6

NOTE: The DB-15 breakout board has a GND line that needs to be connected to the Core's GND pin. It does not do anything to ground the controller activity, but it does ensure static does not build up between the plug and the Core.

I chose this mapping deliberately, because it provides a number of benefits. It does not use any pins associated with Serial1, I2C or SPI. Also, pins D2 and D3 are left open, which is significant because they are capable of receiving hardware interrupts. Finally, supplying input into the D7 pin flashes an built-in LED on the Spark Core, which allows you to visually debug a trigger press.

Code

With all the wiring complete, all that was left was to write a little test code. Below, I have supplied code that samples the controller's state at four time per second, then reports it over the USB serial connection (Serial) of the Spark Core.

The goal of the code is to address the most basic use case and to provide a base for you to build upon. The `button_state_t` data structure stores the entire state of the controller in a 32-bit package, which should enable the efficient passing of those values on to another program. If you were to use this for actual control you will want to increase the sampling rate to 60Hz (60 times per second). It is currently set to 4Hz, so it is easier to read on on the serial monitor of the Spark Dev app. 

// Filename:thrustmaster-mark-ii-fcs.ino
// Author: Zachary J. Fields
// Created: 2015 JAN 27
// License: Beerware

#include <cstdint>

const uint32_t SAMPLING_RATE_HZ = 4;
const uint32_t SAMPLING_DELAY_MS = (1000 / SAMPLING_RATE_HZ);

union button_state_t {
    struct button_t {
        uint32_t hat_up : 1;
        uint32_t hat_right : 1;
        uint32_t hat_down : 1;
        uint32_t hat_left : 1;
        uint32_t button_1 : 1;
        uint32_t button_2 : 1;
        uint32_t button_3 : 1;
        uint32_t trigger : 1;
        uint32_t joystick_x : 12;
        uint32_t joystick_y : 12;
    } button;
    uint32_t data;
} button_state;

void setup() {
    Serial.begin(9600);
    
    // Setup digital pins
    pinMode(D5, INPUT_PULLDOWN);    // button 1
    pinMode(D4, INPUT_PULLDOWN);    // button 2
    pinMode(D6, INPUT_PULLDOWN);    // button 3
    pinMode(D7, INPUT_PULLDOWN);    // trigger
    
    // Setup analog pins (ALL REQUIRE EXTERNAL PULLDOWN - 47K)
    pinMode(A0, INPUT);    // joystick-x
    pinMode(A1, INPUT);    // joystick-y
    pinMode(A6, INPUT);    // hat
    
    return;
}

void loop() {
    delay(SAMPLING_DELAY_MS);
    sampleState();
    reportValues();
}

void reportValues() {
    // Report hat value
    Serial.print("Hat Position: ");
    if ( button_state.button.hat_up ) {
        Serial.println("UP");
    } else if ( button_state.button.hat_right ) {
        Serial.println("RIGHT");
    } else if ( button_state.button.hat_down ) {
        Serial.println("DOWN");
    } else if ( button_state.button.hat_left ) {
        Serial.println("LEFT");
    } else {
        Serial.println("CENTER");
    }
    Serial.println();
    
    // Report digital values
    Serial.print("Button 1: ");
    Serial.println(button_state.button.button_1 ? "DOWN" : "UP");
    
    Serial.print("Trigger: ");
    Serial.println(button_state.button.trigger ? "DOWN" : "UP");
    
    Serial.print("Button 2: ");
    Serial.println(button_state.button.button_2 ? "DOWN" : "UP");
    
    Serial.print("Button 3: ");
    Serial.println(button_state.button.button_3 ? "DOWN" : "UP");
    Serial.println();
    
    // Report analog values
    Serial.print("Joystick X: ");
    Serial.println(button_state.button.joystick_x);
    
    Serial.print("Joystick Y: ");
    Serial.println(button_state.button.joystick_y);
    Serial.println("\n==================\n");
    
    return;
}

void sampleState() {
    // Sample/convert hat state
    const uint32_t hat_raw = analogRead(A6);
    button_state.button.hat_up = (hat_raw >= 4000);
    button_state.button.hat_right = (hat_raw < 3500 && hat_raw >= 2500);
    button_state.button.hat_down = (hat_raw < 2500 && hat_raw >= 2000);
    button_state.button.hat_left = (hat_raw < 2000 && hat_raw >= 1750);
    
    // Sample digital state
    button_state.button.button_1 = digitalRead(D4);
    button_state.button.button_2 = digitalRead(D5);
    button_state.button.button_3 = digitalRead(D6);
    button_state.button.trigger = digitalRead(D7);
    
    // Sample analog state
    button_state.button.joystick_x = analogRead(A0);
    button_state.button.joystick_y = analogRead(A1);
    
    return;
}

Summary

I hope you've enjoyed this walk down memory lane, and hopefully you will also be able to get some use out of your old controller.

In other news, I have purchased the ThrustMaster® Mark II Weapon Control System, and I intend to submit a similar breakdown. Ultimately, I plan to show how to connect the two together to send a unified control signal. Also, I plan to add a Fritzing wiring schematic as soon as I, or hopefully someone else, creates the schematic for the DB-15 connector.

Required Tools

• PH2 phillips-head screwdriver
  
• H2.0 hex-head screwdriver
  
• Extech DM110 Pocket MultiMeter

Interesting Links

• ThrustMaster - Technical Support
• Forum post describing how to use the controller on a tower PC
• Forum post about using the Rockfire adapter with the Thrustmaster Mark II FCS / WCS
• MigMan's review of the ThrustMaster Mark II FCS/WCS

Files