Automotive – Page 3 – Chamber of Understanding

RX8 Project – Part 7, Introduction to flywheels

Having decided what engine I was going to use and deciding to keep the existing gearbox so I could retain the factory carbon prop shaft the next logical step was to work out how exactly to achieve that…

First off the engine I had bought was from an automatic and so had a flex plate rather than a flywheel. This is a comparatively thin piece of steel which gives the starter ring gear, which would be on the outside of the flywheel on a manual, a fixing point and also mates the torque converter to the crank. In automatics the torque converter provides the rotating mass to smooth the engine pulses. So the first step was to get a flywheel that would work. My first idea was to take the factory RX8 flywheel which has quite a deep offset (i.e. it is quite dished) which would help correct for gearbox adapters which would space the gearbox off the engine. So I looked into simply machining off the back of the RX8 flywheel flat and drilling the bolt pattern from the V6 crank into it. While technically this would work there are a few problems.

(Taken from here : http://www.locostbuilders.co.uk/viewthread.php?tid=185939&page=2)

The image above shows exactly what I’m talking about, this is a factory RX8 flywheel modded onto a V6 crank. I believe the engine used in this case is the Mazda KLDE. While this all looks good there are a couple of issues. First is that the RX8 flywheel isn’t balanced as it stands, it forms a balanced arrangement with the rest of the engine and so needs modifying. I don’t have a picture of this but the weighted lip on the rear ranges from thin on one side to very thick the other. Aftermarket flywheels get round this by using balanced flywheel and a separate counterweight. Problem two is that the factory flywheel is cast iron, this has an irregular structure and can have flaws and other weaknesses from new but parts are generally made with a factor of safety to account for this but modification in this way will remove some of this additional strength and change areas of stress. I actually 3D modelled this change to see if it would work:

Original:

Modified:

Having modelled this I performed a stress analysis of this based on the force created by the flywheel spinning at 8000 RPM. This is more than redline as it stands but it seemed prudent to plan ahead! It turns out the stock flywheel is only about 20% stronger than required based on the nominal ‘standard’ properties of cast iron. The new version would be below strength at this speed, dropping to 7500 RPM gave something around 102% strength. Not a number I felt confident in at all! Just to make a point here as people argue the safety of modded flywheels a lot (mostly from “I’ve done it and it’s fine”). I’m not saying it will fail modded like this, in fact the numbers suggest it is (just) strong enough here but there is no margin for error even on the ‘ideal’ material and cast iron does vary significantly. A given flywheel might be fine like this for years, but get a weaker one or one with a flaw or even give it a hard jolt when it’s at full revs and it may just shatter. If it does, be somewhere else!

So after deciding the mod wasn’t really the best idea I realised that all I needed was a flywheel that would bolt up and work. A fairly easy task at face value since it turned out the the standard Ford clutch splines (1″ dia, 23 spline) match the gearbox the solution suddenly seemed simple and I just needed a stock Ford flywheel and clutch for that engine. It turns out there were a few variations of the Ford flywheel depending if you went for an ST200, ST220 or just a vanilla V6 Mondeo but the difference between them seems to be some are ‘lighter’ versions to make the more special cars rev a little more freely. This is achieved by leaving out sections of the outer lip on the flywheel. In my case I had no idea if this project would ever work so I bought the cheapest! This is when another problem emerged:

Note the starter ring gear on each. The top is the S-Type flex plate, the bottom is the Mondeo one. It seems the Ford and Jag use a different starter motor as well. Add to this that the Mondeo flywheel puts the clutch far too far forward to mate to the gearbox and because the starter is on the engine side on the Jag but on the top of the gearbox on the Mondeo (because it’s transverse) – something we can’t do on the RX8 as the gearbox is wrong and there isn’t the room in the tunnel the whole idea falls apart! Modifying the cast one seems to be the only sensible option.

Around this time I happened to have a chat with a colleague at work who is a professional mechanical engineer and 3D designer I know through the job I had at the time and explained the problem and he directed me towards a machinist who did a lot of work for him and was well into cars. By chance a few days later this machinist came into the office and as soon as I explained the problem he just said “ah, we’ll just make you a custom one if you do a design”…. So I found myself with the challenge of designing a custom flywheel which as per the machinists recommendation would be made out of EN24 steel. As a comparison changing the models above to EN24 changes the safety factor to something around 300% from memory meaning we can lighten it significantly later if required and not risk weakening it dangerously.

More to come…

RX8 Project – Part 6, Canbus #2

So now we have a powered up RX8 cluster and some Canbus hardware that we can talk to we can start doing a few interesting things with our new setup.

Fire up the Arduino IDE and we can start writing our basic controller code. Canbus devices have a device address and a memory location for all the required data so we need to work all of these out. This is a lot easier for digital IO than the more complicated analog values because digital IO are just either set bit on or off whereas analog values can have funny scaling and things going on. I initially used a canbus demo program which worked because I basically cloned the Arduino Canbus shield. Plenty of starter guides and information can be found here : https://learn.sparkfun.com/tutorials/can-bus-shield-hookup-guide

My initial approach involved setting the target address for the Canbus transmission and sending patterns of bits high and low and see what happens. Google told me that the cluster Canbus interface operates on 500 kHz clock so with that information we should get a connection.

#include <Arduino.h>
#include <mcp_can.h>
#include <mcp_can_dfs.h>

#define CANint 2
#define LED2 8
#define LED3 7

MCP_CAN CAN0(10); // Set CS to pin 10

void setup() {
 // put your setup code here, to run once:
 Serial.begin(115200);
 Serial.println("Init…");

Serial.println("Setup pins");
 pinMode(LED2, OUTPUT);
 pinMode(LED3, OUTPUT);
 pinMode(CANint, INPUT);

Serial.println("Enable pullups");
 digitalWrite(LED2, LOW);
 Serial.println("CAN init:");
 
 if (CAN0.begin(CAN_500KBPS) == CAN_OK) 
 {
 Serial.println("OK!");
 } 
 else 
 {
 Serial.println("fail :-(");
 while (1) 
 {
 Serial.print("Zzz… ");
 delay(1000);
 }
 }

Serial.println("Good to go!");
}

unsigned char offarray[8] = {0, 0, 0, 0, 0, 0, 0, 0}; // Always Off Array
unsigned char onarray[8] = {255,255,255,255,255,255,255,255}; // Always On Array

void loop() {
 // put your main code here, to run repeatedly:

for (int i=0; i <= 512; i++){ 
  for (int l=0; l <= 10; l++){  
    for (int j=0; j <= 100; j++){
       CAN0.sendMsgBuf(i, 0, 8,offarray);
       delay(10);
     }

     for (int k=0; k <= 100; k++){
     CAN0.sendMsgBuf(i, 0, 8,onarray);
     delay(10);
     }
   }
  }
}

So this loop will iterate through 512 addresses strobing all 8 bytes high and low on 1 second intervals. The trick here is that canbus needs regular packets to stay active, so we can’t just send a value once. In this case each value (high or low) is send 100 times at 10ms intervals so the cluster should stay active long enough to see if anything is happening. Each address will get 10 cycles of high and low before moving onto the next address. In concept this would work and provided ‘i’ is set to increment high enough you would cover all the addresses. Bear in mind at this rate you’d have to watch it for about 90 mins…

Thankfully around the time I started running though this trying to find any useful addresses I came across this :

https://www.cantanko.com/rx-8/reverse-engineering-the-rx-8s-instrument-cluster-part-one/

This nicely tied in with the hardware I was working on and so the code and information is all exceedingly useful and saved me a lot of time. Specifically it gives the address locations for most of the indicators on the cluster which is what we really need.

After lots of trial and error I managed to come up with a block of code that can control the cluster but easily allow me to set any warning light I need on the dash, or more accurately also to turn off all the warning lights. Something that will be essential come MOT time as a warning light that stays on is an MOT fail and since most of the systems that control them will no longer be in the car (primarily the original ECU).

#include <Arduino.h>
#include <mcp_can.h>
#include <mcp_can_dfs.h>


#define COMMAND 0xFE
#define CLEAR 0x01
#define LINE0 0x80
#define LINE1 0xC0

#define CANint 2
#define LED2 8
#define LED3 7

#define NOP __asm__ ("nop\n\t")

// Variables for StatusMIL
bool checkEngineMIL;
bool checkEngineBL;
byte engTemp;
byte odo;
bool oilPressure;
bool lowWaterMIL;
bool batChargeMIL;
bool oilPressureMIL;

// Variables for PCM
byte engRPM;
byte vehicleSpeed;

// Variables for DSC
bool dscOff;
bool absMIL;
bool brakeFailMIL;
bool etcActiveBL;
bool etcDisabled;


MCP_CAN CAN0(10); // Set CS to pin 10

void setup() 
{
    
    //Serial.begin(115200);
    //Serial.println("Init…");
    //Serial.println("Setup pins");
    
    pinMode(LED2, OUTPUT);
    pinMode(LED3, OUTPUT);
    pinMode(CANint, INPUT);

    //Serial.println("Enable pullups");
    digitalWrite(LED2, LOW);
    //Serial.println("CAN init:");
    
    if (CAN0.begin(CAN_500KBPS) == CAN_OK) 
    {
        //Serial.println("OK!");
    } 
    else 
    {
        //Serial.println("fail :-(");
        while (1) 
        {
            //Serial.print("Zzz… ");
            delay(1000);
        }
     }

Serial.println("Good to go!");
}

unsigned char stmp[8]       = {0, 0, 0, 0, 0, 0, 0, 0};                         // Always Off Array
unsigned char otmp[8]       = {255,255,255,255,255,255,255,255};                // Always On Array

unsigned char statusPCM[8]  = {125,0,0,0,156,0,0,0};                            // Write to 201
unsigned char statusMIL[8]  = {140,0,0,0,0,0,0,0};                              // Write to 420
unsigned char statusDSC[8]  = {0,0,0,0,0,0,0,0};                                // Write to 212

unsigned char statusEPS1[8] = {0x00,0x00,0xFF,0xFF,0x00,0x32,0x06,0x81};        // Write to 200 0x00 00 FF FF 00 32 06 81
unsigned char statusEPS2[8] = {0x89,0x89,0x89,0x19,0x34,0x1F,0xC8,0xFF};        // Write to 202 0x89 89 89 19 34 1F C8 FF

unsigned char statusECU1[8] = {0x02,0x2D,0x02,0x2D,0x02,0x2A,0x06,0x81};        // Write to 215 - Unknown
unsigned char statusECU2[8] = {0x0F,0x00,0xFF,0xFF,0x02,0x2D,0x06,0x81};        // Write to 231 - Unknown
unsigned char statusECU3[8] = {0x04,0x00,0x28,0x00,0x02,0x37,0x06,0x81};        // Write to 240 - Unknown
unsigned char statusECU4[8] = {0x00,0x00,0xCF,0x87,0x7F,0x83,0x00,0x00};        // Write to 250 - Unknown


/*

215 02 2D 02 2D 02 2A 06 81 // Some ECU status

231 0F 00 FF FF 02 2D 06 81 // Some ECU status

240 04 00 28 00 02 37 06 81 // Some ECU status

250 00 00 CF 87 7F 83 00 00 // Some ECU status

*/


void updateMIL()
{
    statusMIL[0] = engTemp;
    statusMIL[1] = odo;
    statusMIL[4] = oilPressure;
    
  if (checkEngineMIL == 1)
  {
    statusMIL[5] = statusMIL[5] | 0b01000000;
  }
  else
  {
    statusMIL[5] = statusMIL[5] & 0b10111111;
  }
   
    if (checkEngineBL == 1)
  {
    statusMIL[5] = statusMIL[5] | 0b10000000;
  }
  else
  {
    statusMIL[5] = statusMIL[5] & 0b01111111;
  }

   if (lowWaterMIL == 1)
  {
    statusMIL[6] = statusMIL[6] | 0b00000010;
  }
  else
  {
    statusMIL[6] = statusMIL[6] & 0b11111101;
  }

     if (batChargeMIL == 1)
  {
    statusMIL[6] = statusMIL[6] | 0b01000000;
  }
  else
  {
    statusMIL[6] = statusMIL[6] & 0b10111111;
  }

       if (oilPressureMIL == 1)
  {
    statusMIL[6] = statusMIL[6] | 0b10000000;
  }
  else
  {
    statusMIL[6] = statusMIL[6] & 0b01111111;
  }
}

void updatePCM()
{
    statusPCM[0] = engRPM;
    statusPCM[4] = vehicleSpeed;
}

void updateDSC()
{       
  if (dscOff == 1)
  {
    statusDSC[3] = statusDSC[3] | 0b00000100;
  }
  else
  {
    statusDSC[3] = statusDSC[3] & 0b01111011;
  }

    if (absMIL == 1)
  {
    statusDSC[4] = statusDSC[4] | 0b00001000;
  }
  else
  {
    statusDSC[4] = statusDSC[4] & 0b11110111;
  }

      if (brakeFailMIL == 1)
  {
    statusDSC[4] = statusDSC[4] | 0b01000000;
  }
  else
  {
    statusDSC[4] = statusDSC[4] & 0b10111111;
  }

     if (etcActiveBL == 1)
  {
     statusDSC[5] = statusDSC[5] | 0b00100000;
  }
  else
  {
    statusDSC[5] = statusDSC[5] & 0b11011111;
  }

    if (etcDisabled == 1)
  {
    statusDSC[5] = statusDSC[5] | 0b00010000;
  }
  else
  {
    statusDSC[5] = statusDSC[5] & 0b11101111;
  }
 

}

void loop() 
{
    // StatusMIL
    engTemp         = 145;
    odo             = 0;
    oilPressure     = 1;    // Either 0 (fault) or >=1 (Ok)
    checkEngineMIL  = 0;
    checkEngineBL   = 0;
    lowWaterMIL     = 0;
    batChargeMIL    = 0;
    oilPressureMIL  = 0;

    updateMIL();
    CAN0.sendMsgBuf(0x420, 0, 8, statusMIL);
    delay(10);


    // StatusPCM
    engRPM          = 60;    // RPM  Value*67 gives 8500 RPM Reading Redline is 127
    vehicleSpeed    = 93;    // Speed  Value=0.63*(Speed)+38.5

    updatePCM();
    CAN0.sendMsgBuf(0x201, 0, 8, statusPCM);          //CAN0.sendMsgBuf(CAN_ID, Data Type (normally 0), length of data, Data
    delay(10);

    // StatusDSC
    dscOff          = 0;
    absMIL          = 0;
    brakeFailMIL    = 0;
    etcActiveBL     = 0;    // Only works with dscOff set
    etcDisabled     = 0;    // Only works with dscOff set

    updateDSC();
    CAN0.sendMsgBuf(0x212, 0, 8, statusDSC);
    delay(10);

/*
    CAN0.sendMsgBuf(0x200, 0, 8, statusEPS1);
    delay(10);            

    CAN0.sendMsgBuf(0x202, 0, 8, statusEPS2);
    delay(10);    
           
    
    CAN0.sendMsgBuf(0x215, 0, 8, statusECU1);
    delay(10);  

    CAN0.sendMsgBuf(0x231, 0, 8, statusECU2);
    delay(10);  

    CAN0.sendMsgBuf(0x240, 0, 8, statusECU3);
    delay(10);  
    CAN0.sendMsgBuf(0x250, 0, 8, statusECU4);
    delay(10);  

*/
            
 }

This is the current latest version of the code I have, the serial comms section at the start is handy for checking you have a working connection but if you don’t have the serial monitor open it will cause the Arduino to hang at the transmit instruction and not get as far as updating the canbus so I recommend enabling these initially but once you get a working connection comment them back out as above. There are also sections above taken directly from the Cantanko page to deal with the power steering controller and some other bits, I haven’t tried these yes as the cluster isn’t in a car but I plan do so at some stage.

This code has some limitations in this form, basically the warning lights etc are set in the code as static values so this code will just set everything normal and all the lights I have addresses for to off. One particular curiosity is the way the cluster treats the oil pressure value. The data space actually has a whole byte for a value here but the cluster only only has two values despite having an actual gauge, a value of 0 drops the needle to the bottom, a value of 1 or more sets the gauge to normal. My feeling on this is the car was originally intended to have a proper oil pressure transmitter but someone decided it was too expensive and a normal pressure switch was used instead and rather than redesign the cluster they just changed the scaling in the on board microcontroller to behave as described. long term I’d love to mod the cluster to add the analog functionality back in but without the code for the controller this would probably involve disconnecting the original drive to that gauge and adding another Arduino inside the cluster just for driving that gauge. It seems like a lot of work to know oil pressure on a scale of low to high!

The code also sets a speed and RPM however the ODO and trip meters will not increment as it stands – I purposefully left this bit of code out because it’s only really applicable if you’re on an actual car otherwise your cluster will just keep clocking up. The ODO and trips seemed to be the one bit no-one else had managed to do or identify but after quite a few hours of testing random blocks will various combinations of high and low as well as sending incrementing / decrementing values I noticed my trip meter had actually moved up by 0.1 miles which meant something was working. I eventually managed to trace it to the address listed above. The trick to actually making it work is that the value in the byte is irrelevant to what the cluster displays, so no this doesn’t let you clock it back! What it appears to do is counts the changes to the value so I made it work by setting up a loop of code that keeps changing this value up to a certain number to give a specific distance. Turns out the cluster needs to see 4140 changes per mile. Eventually I plan to tie this in to the speedometer value so only one value needs to be set, by knowing the pulses per mile and the speed we can work out the time delay between each change. As an example at 100mph we need to send 115 changes per second, this is one every 8.7ms which is obviously faster than the loops above and so for speed and accuracy would have to be hardware timed with an interrupt to do the update at the right speed. I’ll probably do an updated version at a later date.

There’s a couple other things I need to sort out, the airbag warning light being the prime one because this is an outright MOT fail. Now in theory when it’s back on the car it should work just fine as the airbag wiring is all there but I figured it was worth working out anyway. So after working through all of the RX8 cluster wiring diagrams (1)(2)(3)(4) I pieced this together :

This covers the majority of everything someone might need to use the cluster on a simulator apart from the fuel gauge. The RX8 fuel gauge is a bit of an oddity because the car uses a saddle shaped fuel tank to allow it to clear the driveshaft and so it has two senders denoted as ‘main’ and ‘sub’.

Each of these apparently has a resistance value of between about 325Ω at the bottom and 10Ω at the top. There seems to be some questions about how this system works out what to display based on the two sender values and whether it expects to see one remain full while the other empties or something similar. Unfortunately I’ve not played with it much because I’ve don’t actually need to make this work off the car (since the car will have the senders but I can say putting 100Ω a resistor between both 2R-2P and 2R-2T gives a value of about 1/3 of a tank and 9Ω (because I just added a 10Ω on along side the existing 100Ω) across these connections gives a full tank reading (actually a little above full) so as long as you move both together it works fine, this is ok if all you want to do is get the fuel warning light off for a driving simulator but not that helpful for a single fuel sender conversion which is why most people are interested. If I get chance I’ll investigate further. Also for some reason it takes an absolute age to move up the scale which is a bit unfortunate but I suspect is as intended. At least it should be stable!

All of that leaved us with just one light I can’t get to turn of, the warning light for the electronic power steering. This is controlled via canbus by the look of the circuit diagram but as yet I’ve not found the address for it. If anyone knows the address please leave a comment! Else I will have to go back to either trial and error or the really dodgy backup plan which involves cutting the tracks in the cluster and doubling up on another warning light which isn’t used much! Maybe I should just add another controller in the cluster!

So hopefully that gives you (almost) everything you need to know about making the cluster work! We might get back to mechanical things in the next update…

RX8 Project – Part 5, Canbus

Following the decision to go for the complete engine swap I had the sudden realisation that nothing was going to work on the car because I wouldn’t have the factory engine and so also wouldn’t have the factory ECU and so no engine data and nothing on the instrument cluster. So I needed to come up with a better plan!

Initially I intended to open up the stock instrument cluster and replace the normal controller circuits inside the cluster with a microcontroller (probably an Arduino) with suitable supporting electronics such as motor driver IC’s to control the gauges and small MOSFET’s to switch the warning lights and anything else I needed to get it working. Done in that way I could interface almost anything to the Arduino and make the cluster behave however I wanted.

I started looking into what wiring the cluster had normally to see if I could hack into anything directly and not have to fake signals, say a nice direct tachometer connection I could use, but found that virtually everything on the cluster was controlled via a canbus communications connection and this gave me other ideas.For anyone who doesn’t know canbus is a differential communications interface used in the majority of common cars to connect all the separate devices together. It is what’s called multi drop and as such all the devices are basically just daisychained on a single pair of wires. Complexity is the data is sent to a specific target device based on a device ID which we don’t know and the format the device needs the data in is to give a particular result is entirely up the manufacturer. So for example even if you found the memory location that controls RPM it might be using a single byte (256 possible values) to represent RPM in the range of 0-7500 rpm. This means that each increment would be a step of approximately 30 rpm which would likely not be noticeable. Or they might use two bytes at different addresses which combine to give the value, or something more complicated! Figure it all out and you can directly control the cluster!

The Arduino can be made to communicate with a canbus system with appropriate components added on. These are available as an off the shelf canbus shield and if you’ve not build circuits like this before I recommend that approach but since I have an electronics background I decided to DIY my own and save the money and so I started down the route of designing a canbus interface. I then had another interesting thought, if I had an engine ECU for the new engine it would be transmitting all sorts of data about what it was doing which would normally go to the cluster of the car it was from. I could work out what address it was sending that data too I could read it all. So suddenly one canbus interface grew to a pair of them so I could connect one to the engine ECU and one to the cluster and eventually use the pair of interfaces to bridge the two canbus connections and convert and reformat all the engine data in real time to control the cluster. Sounds simple right!

Based on information found via Google the chips to use seemed to be the MCP2515 transceiver and MCP2551 canbus line driver. Part of the reason behind this was there are well documented libraries available for the Arduino to work with these, plus they are available in DIP packages to make prototyping on stripboard easier!

Sadly I can’t seem to find the original circuit diagram I drew for this but it was closely based on this one (click to enlarge):

I tend to use Arduino nanos in my projects, they are very small but have a good clock speed and all the handy features you’re likely to need for fairly small IO count projects. Plus you can buy the knock off version on eBay for very little, my last ones were 5 for £12 delivered next day but can be had for less if bought from a Chinese seller but obviously with a much longer delivery. The down side of these is they make them cheaper by not using the proper FTDI branded USB to serial converter chip, instead they use the CH340G which means the driver isn’t included with the normal Arduino IDE and must be downloaded and installed manually. The appropriate driver can be found from a number of sources via Google.

After quite a bit of work I ended up with something that looked a bit like this (ok, exactly this!)

The red and black coloured solder lines are to distinguish the 5V power from the Arduino from everything else to make sure I hadn’t accidentally shorted it out. Needless to say there’s quite a bit going on on the bottom of this board! The converter board has options for either screw terminal connectors or the 9 way DSUB used for certain applications. I’ve also included options for connecting power into the DSUB if required. On particularly important feature is the termination resistor, this is situated next to the blue jumper, moving the jumper turns this on or off. Canbus must have this termination resistor connected between the two bus wires (called CANL(-) and CANH(+)) at each end of the bus, so if this is an end node on the bus it needs enabling. If it’s being added to the middle of an existing bus it should be disabled. Other keen people will notice there’s only one Arduino slot occupied, this is because by the time I took the photo it had been commandeered for another project but since I was still working with identifying signals in a single bus at a time it didn’t really matter. I did initial test with two Arduinos connected via canbus with one transmitting and one receiving just to prove the hardware out.

Next up we need to connect the new hardware up to the RX8 cluster. This assumed it is disconnected from the car, if it isn’t you won’t need to tie in power to the cluster but I have no idea how the but will behave in this situation. If you experimenting as I am it’s advisable to disconnect the canbus pins to avoid problems or just disconnect the whole cluster. to make this work we need to use the smaller connector on the back only. In the diagram above you can see the pinout for this, the simple version is :

Upper Row going left to right
Spare
Spare
B/Y – Ignition Switched +12V
B – 0V (PSU Minus)
L/R – Permanent +12V
Spare

Lower Row
G/B – CANL
L/W – CANH
Spare
G/Y – Unknown
BR/B – Unknown
R/Y – Unknown

For testing purposes both +12V can be connected together and any normal 12VDC PSU (cheapo wall wart or anything else you have) can be used. Congratulations, you now have a powered up cluster you can work with!

Things will get technical in the next section Canbus #2

RX8 Project – Part 4, The New Engine

Following part 3 where the original rotary engine proved to be a lost cause I decided to research possible engines that could be swapped in but there were a few criteria and limitations I had:

Size – The RX8 has a reasonable size engine bay overall but due to the size and position of the standard engine there are some limiting factors to consider. I’m aware others have swapped V8’s (among others) into RX8 shells but this generally involves extensive modification of the engine bay, steering rack and even front cross member due to the length of the engine.

Weight – The RX8 is famous for being very balanced largely due to the compact size and resulting low mounting position of the standard engine. No standard piston engine will quite match up but I wanted to get as close as reasonably possible.

Power – The standard RX8 was available with either 192 or 231 bhp and so I wanted to get to ideally the upper figure (even though mine actually started as the lower 192 model) or even exceed it if possible.

Cost & availibility – I wanted and engine that was cheap to buy and for which spares were cheap and readily available. This was always intended to be a budget project to swap the engine more cheaply than replacing it.

After considering a huge number of options from things people have done before (VW 1.8t engine) to completely off the wall ideas that would probably upset all the RX8 purists (1.9 turbo diesel?) I eventually came across a couple really promising candidates – the Mazda KLDE and Ford AJ series engines. These are both very compact aluminium construction V6’s which should be short enough that no modification to the front cross member should be needed. It became apparent pretty quickly that the KLDE was hard to find and attracted a comparatively high price so I ruled this out.

The AJ V6 is related to the older KLDE and is available in a few flavours. It was produced as the AJ25 and AJ30 (2.5 and 3.0 litre respectively) and were used in a a range of cars in slightly different configurations including the Ford Mondeo ST220 (along with US Contour and Taurus), Jaguar S-type and X-Type along with several others. Some (including the S-type version) have VVT.

So after an eBay search and a hard earned £165 (including delivery) later I had this prime example of an AJ25 from an S type Jag sat on my driveway. At this stage I went for the 2.5L because the 3.0L version attracts a more premium price and since I had no real idea if it I would ever get it all together I bought the cheap version. Since the block is identical for both the logic was if I made one fit and decided I just didn’t have enough power I could swap all the custom parts over to a 3.0. Clearly there’s a lot of extraneous parts on here I won’t be using and once much of this is stripped the true compact size of the engine is a bit clearer.

There are a few reasons I picked this version of this engine. One was that the Mondeo version, which is more common, has the water pump driven from and extended camshaft on the rear of the engine because in the Mondeo the engine is in a transverse orientation. To fit the engine to the RX8 the engine will need to be installed longitudinally and the rear will have to be very close to the firewall so this is a non-starter. The Jag version has the water pump front mounted so avoids this problem. The Jag version also includes direct acting mechanical bucket cam followers and VVT. Sadly the 2.5L generally only offers 200bhp in this configuration so it’s a little down on where I really wanted to be but the torque is 240 Nm compared to the 211 Nm peak of the 231 bhp RX8 and a considerably wider torque band so it should still go well.

Around this time I found out that the Noble M12 uses this same 2.5L engine running as a twin turbo at 325 bhp. The later M400 uses the 3.0L version of the engine but they again two turbos to it and get something in the order of 425 bhp out of it with minimal additional modifications. Reports from Noble suggest it is capable of even more but was limited because they were planning on upping the power later selling this as another model but due due to the change of direction and ford taking the engine out of production this never happened. More info can be found here : Noble M12 History

I also made the decision to keep the RX8 gearbox so I could retain the standard carbon prop shaft in the RX8 so next up is the challenge of making an engine made by Ford, which was salvaged from a Jag, fit the gearbox from a Mazda!

RX8 Project – Part 3, Engine Autopsy!

Rather long delay since the last post on this project mostly due to a server problem it took a while to resolve.

So here it is, the autopsy of a failed RX8 engine. First here’s how the engine looks freshly removed from the car.

The 13B rotary engine really is rather small and while it is true to say it is a comparatively light engine (I’ve heard figures around 130kg though I’ve not checked this) it is a solid lump with very little space inside. It’s also worth noting the four spark plugs at this point – this engine has leading and trailing plugs and actually fire the chamber twice during combustion phase which is a little unusual for an engine.

Here’s the next stage, strip all the supporting components from the engine. So the alternator, aux drive belt, manifolds, ignition coils, clutch and anything else bolted onto the main block.

13B Stripped Components — All the bits removed

So when you get to this point you will (if you haven’t already) realised the flywheel must be removed to break down the engine any further as the engine is built as a series of layers with long through bolts. These through bolts are all located under the flywheel hence why that needs removing.

The bad news here is that the flywheel is held on by a single very large nut, this nut is 54mm across flats. I have no idea what torque it is tightened to, but it’s very tight, very fine pitch and is installed with thread locker adhesive.

The first problem is locking the engine solid. I actually used a section of steel between two of the the clutch bolts and then another bolt through one of the bell housing bolt holes. Obviously the steel must be installed across two bolts so it doesn’t cross the nut you’re trying to remove. Alternatively proper locking tools can be bought but the ones I could find were quite pricey. As for the actual nut I ended up buying a 54mm impact socket which on its own was about £30.

For the actual removal I tried a long 1/2″ breaker with a big cheater bar and ended up shearing the end off the bar! The bolt didn’t budge! I ended up convincing a mechanical fitter where I worked who was well into cars to stay a little late one night, borrowed the company van to get the engine up to the workshop and borrowed his largest 1/2″ drive air impact gun to remove it. After a bit of an argument the nut eventually moved!

Next I took off the sump, while I could have done this earlier I was largely resting the engine on the sump so it made sense to leave it in place. This moment was a huge warning of what was to come!

So, apparently this was once oil! Judging from what came out it was something like 90% or more water at this stage suggesting a serious internal failure of a water seal. This is a known problem in these engines and if caught early is repairable. In this case unfortunately the engine had still been used for some time after the warning signs started appearing with the previous owner running the car until it wouldn’t idle at all or restart when warm. Expectations for the engine were not high at this point!

It’s worth pointing out at this stage you need to find a way to prop up the engine vertically to disassemble from the flywheel end. Again a guy at work helped me out here by building me a custom engine stand from offcuts in a quiet moment but other solutions could be used. the positions I used were the rear pair of air con mounts.

Seriously rusty rotor — Well that doesn’t look good!

On opening it I was met with this sight. Again this confirms very large amounts of water getting inside the engine. Several parts of the engine are cast iron and so will rust for a pass-time when exposed to water. Add to that the total lack of lubrication offered by the water and engines will basically overheat and the bearing surfaces will eat themselves alive.

Notice the scoring on the internal bearing surface on this rotor.

Here is the lobe on the eccentric shaft that the rotor locates on. This photo clearly shows the the lobe has experienced excessively high temperatures to such an extent the shaft has discoloured.

And the final shot shows the amount of scoring on the shaft. Clearly everything is not well.

So this is what actually caused the damage. These o-rings seal both the water from the combustion chamber (red) and from the outside world (black). As can clearly be seen in the photo the outer seal has degraded to the point of failure. The really unfortunate aspect here is is this seal failed at any point over most of its length the engine would leak coolant but this wouldn’t actively damage the engine. What happened here is the point of failure was above the sump so as the water leaked out it filled the sump with more water than oil progressively ruining the engine. The inner seal in this engine had also failed and this means that once the coolant is hot and under pressure it leaks into the combustion side. This is a common cause of the warm idle and restart problems.

More signs of running without oil - chatter marks in the housing — 13B Housing damage

So this was the final nail in the coffin for this 13B engine, both rotor housings were ruined with significant chatter marks, scoring and chipping of the hard chrome surface and these cannot be restored because the only people that have a specialist surface grinder to finish the hard chrome surface in the correct profile is Mazda. So at this point virtually everything needs replacing, effectively this is buying a new engine and costs a huge amount of money. for a £300 car it just isn’t worth it.

So now project moved onto what reasonably priced alternative engines could be fitted for less than the cost of replacing the proper engine….

RX8 Project – Part 2

In part two we look at finally getting the engine clear. In reality due to the time I had available this process actually took something like three months. A qualified professional mechanic can remove the engine in an RX8 in as little as three HOURS! Clearly I’m not a professional mechanic!

I didn’t fully document the process as there are any number of people who have already done excellent write ups of this but hopefully I can offer a couple of pointers to anyone trying to do this. Officially the engine should be removed by dropping out the front sub-frame and not being able to do this easily on a driveway has led me to removing the engine upwards. This adds a few minor problems along the way but nothing insurmountable

One thing I found is that you really need to remove the crank pulley to clear the front crossmember. While you probably could yank it past regardless it makes the process notably easier.

With somewhat awkward visibility it can be hard to tell whats going on but it looks like this. You do not need to remove the main bolt – the pulley is just held on by the four small bolts around it (already removed in the photo).

The next major problem is removing the engine mounts. I found it virtually impossible to get at in any conventional way. You can get a ratchet on but they’re quite tight and there’s little room, and a breaker bar doesn’t have room to move. My solution to this was to undo the bolts from the top of the engine bay with a selection of extensions. These need to be 1/2″ drive as my 3/8″ drive ones were starting to flex a bit plus you will probably need a breaker bar. Due to the angle restriction a UJ is also required. While the whole assembly looks a bit bodged it works fine.

Also the oil line connectors, these are really awkward and are usually corroded solid. Hose them liberally with WD40 and let it stew overnight if they are a problem. If you plan to use them again don’t lose the small retaining wire ring, these can be hard to replace (though can probably be replaced by a snap ring from an engineering supplier).

After another brief pause for another project we started watching some car based youtube videos (Roadkill and Mighty car mods for anyone interested) and after feeling inspired to do car-ish things and pull the engine out.

My best advice on this one is – don’t try to remove an engine when it’s dark and drizzling!

Next up, rotary engine autopsy! Coming soon!

RX8 Engine Swap Project Intro

So the RX8 project involves making what is effectively a worthless vehicle useful again. For anyone not familiar with the Mazda RX8 they are a fairly high spec 4 seater car which is most widely known because it uses a Wankle rotary engine. This type of engine does not use pistons and so is incredibly smooth in operation and in the higher power (231) version of the car revs to 10,000 RPM as standard.

Sadly for all its good points the engine has a number of down sides. In terms of behavior the engine shares a number of similarities to a two stroke piston engine, one aspect is that it is designed to burn oil in normal operation to such an extent it actually has mechanical components to inject oil into the combustion chamber. This means the oil needs to be topped up frequently and it is recommended to check it every time the fuel is filled, though this isn’t as easy it probably should be and very few people do so. As a result many engines fail rapidly due to lack of lubrication once the oil gets low.

The other common failure is with the o-rings which seal the sections of the engine to each other if these fail water gets into the combustion chamber when the cooling system is under pressure (i.e. once the engine is hot). This is one common cause of the warm start/idle problems and where water gets into the oil you get lack of lubrication failure eventually as well.

The engines are expensive to get repaired assuming the fault is detected early enough and no major damage has occurred. If major damage has occurred then sections or even the whole engine may need replacement. Either way the repair is likely to cost more than the car is actually worth and this seems to happen at something around 60-80,000 miles. The combination of all of this is that these cars are abundantly available for very little money with engines in varying degrees of failure but with relatively few miles on the clock. This leads us nicely to exhibit A:

This is a 55 plate RX8 I bought from ebay for grand total of £300 taken on the day I bought it in July 2015. While technically still road legal at this stage the car wouldn’t idle when warm so was not drive-able for any real distance without serious difficulty. In order to collect it I had to impose on a friend who has a van and car trailer for moving his racing car.

My plan for the car was to remove the engine and dismantle it to see how far gone the internals were and if possible repair the engine and reinstall it. Failing that the backup plan was to try to swap in an engine from something else simply because buying a working replacement rotary engine would cost approximately £3500!

So having got the car home the next day we started taking things out:

This may look a little unconventional but in the UK the RX8 was Thatcham security rated. Part of this involved preventing the ECU from being removed because otherwise any wannabe car thief could just swap the ECU for one from a scrap yard for which they have the matching immobiliser chip, then either hotwire it or force the ignition lock like older pre-immobiliser cars. RX8’s from other countries do not have the steel retaining plates as they do not have this rating. Since the retaining bars (gold in the picture) were several mm thick and held in place with any number of rivets the only option (well the only one we could come up with at short notice) was to drill the rivets outs. I recommend centre punching (creating a divot in the centre) the rivets before drilling because they are domed and the drill will skid off. Now technically you could probably remove all the plugs on the engine and leave the ECU in place but we wanted to allow as much room as possible to take the engine out.

Unfortunately in the RX8 the engine is mounted very low and well back with a lot of ancillaries on top of it making removal a little more time consuming:

RX8 Engine Bay — There’s an engine in there somewhere!

Incredibly the back end of the engine is nearly level with the visible firewall and the front is indicated by the alternator! Yes is really is a very small engine and this particular one is the lower power RX8 – so the output of this engine is *only* 192 bhp!

And this was basically where we got to by the end of our first day removing parts. In truth this is only about three hours in as we’d had something of a heavy night and bright sunlight wasn’t helping the situation!

More to follow shortly…

Finished Pipe Vice

So I finally finished the pipe vice seen in a previous post after getting distracted by other projects. I actually needed to use it for its intended purpose which is something I never fully expected when I started restoring it. I needed to tap a thread into a section of bar as part of another long term project (involving a Mazda RX8 – soon to be added to this blog).

Somewhat appropriately the first time I used it again after putting it back together would have actually been my granddads birthday. Asking around the family by best estimations this vise was purchased for installing pipework when my granddad built his house some 55 years ago. With any luck it will last another few decades!

Anyway, here it is :