# How to measure engine friction using flywheel deceleration

This article describes the method used to determine the engine component friction in the 3D printed Stirling engine. This technique can be used on rotating machines of any size.

The ordinary purpose for a flywheel is to store kinetic energy to smooth the rotation of an engine or machine tool. For our purposes we will use the flywheel to store energy (we spin it up manually or with a motor) and then measure the rate at which the flywheel slows down. A flywheel only slows down because its kinetic energy is being transferred to a load.

If we know the rotational inertia of the rotating parts of the engine, which is mostly just the flywheel, we can compute the energy stored by the flywheel versus rotational speed. For the 3D printed Stirling engine PE 2, the plotted values are shown in figure 1.

Figure 1. Flywheel energy vs speed for the PE 2 engine.

The flywheel inertia (and any other rotating engine parts) is the first piece of information you need. I’ll take you through the steps to compute that in a minute.

The second piece of information you need are measurements of the flywheel deceleration in the form of speed versus time. Two measurements taken from my article on engine friction measurement using flywheel deceleration are shown in figure 2.

Figure 2. Flywheel deceleration vs time for two PE 2 engine configurations.

To make the plots in figure 2 I’m computing the rotational speed by using the reciprocal of the time between two consecutive revolutions.

Rotational speed (Hz) = 1/(Tn+1 – Tn)

The plots in figure 2 show two different configurations. The upper line of red data points is for the flywheel and crankshaft alone. The blue plot shows the results for the engine with the displacer attached. You can see that the flywheel alone is still spinning at 3 Hz (180 rpm) after 20 seconds. With the displacer attached the flywheel decelerates to 3 Hz in just 5 seconds.

You can clearly see the flywheel slows down much faster when the displacer is attached than it does with just the flywheel alone. That’s because there is a lot more friction when driving the displacer and flywheel than just the flywheel alone. To transform this qualitative observation into a quantitative measurement of power, we need to perform some computations.

Here are the steps we need to perform:

1. Compute the rotational inertial of the flywheel and any other significant rotating parts of the engine.
2. Measure the time between revolutions of the engine in various configurations.
3. Compute the rotational velocity of the flywheel versus time from the test measurements.
4. Compute the kinetic energy stored in the flywheel versus time.
5. Compute the power loss versus rotational speed.

Most of these steps are simple computations you can perform on the data in a spreadsheet.

You’ll still need to compute the inertia of the flywheel for your particular engine. If you are testing a stock 3D printed Stirling engine PE 2 design, you can probably use my inertia value. Different 3D printers may result in slightly different ABS flywheel densities.

#### Compute the rotational inertia of the flywheel

There are a number of equations for computing rotational inertia for various shapes. I’m only going to use two of them.

For a round disk of uniform thickness where:
total mass = m
rotational inertia = Idisk = (mR2)/2

For a concentrated mass where:
center of mass radius from the rotational axis = Rave
mass = m
rotational inertia = Iconcentrated mass = mR2ave<\sub>

All rotational inertia computed around the same axis may be added or subtracted. For the flywheel on my engine (see figure 3), there is a round disk and also four holes. To compute the total rotational inertia I will compute the disk inertia as though it were solid and subtract the inertia of the four holes which will be treated as concentrated masses.

Itotal = Idisk – 4Iholes

Use meters for all length measurements and kg for all mass measurements to end up with Joules for energy and Watts for power.

Figure 3. Flywheel dimensions.

For this computation I’ll compute the rotational inertia of one hole, multiply it by four and then subtract the inertia of the holes that have been removed from the flywheel. If the flywheel disk did not have holes, I could just weigh it and use the mass with the disk inertia equation. Because the flywheel does have holes, it’s necessary to determine the density and then multiply the density by the total volume of the flywheel disk as if it were solid to obtain the total mass. Using the same density we can compute the mass for the material subtracted by one hole. Using the mass subtracted by the hole with the inertia equation for a concentrated mass, we can compute the inertia to be subtracted for the holes.

Flywheel mass, grams = 38.0 (measured)
Actual flywheel material volume = 43.2 cm3 (computed)
ABS material density for this flywheel = 38.0 g/ 43.2 cm3 = 0.88 g/cm2
Disk cutout mass computed, grams (one hole) = 7.92 cm2 x .318 cm x 0.88 g/cm3 = 2.22 g
Flywheel mass computed with no holes, grams = 38.0 + 4 x 2.22 = 46.9 g

Although I’ve used cm and grams above because they are convenient to use on such small, light objects, these should be converted to meters and kilograms.

Idisk = 0.0469 x .0732/2 = 0.000125 kg-m2
Iholes = 0.00222 x 0.03812 = 3.22 x 10-6 kg-m2
Itotal = Idisk – 4Iholes = 0.000125 − 4 x 3.22 x 10-6 = 0.000112 kg-m2

To be accurate I also computed the inertia due to the displacer crank disk, the four screws that connect the flywheel to the crank disk, and the some of the other rotating masses on the power piston crank disk. The crankshaft itself has such a small radius that it can be ignored. My total result for the inertia with all the other items added is slightly larger:

Itotal = 0.000115 kg-m2

#### Measuring the time between flywheel rotations

To measure the time between flywheel rotations you can make use of the test system detailed in my article on automated testing. For this test you will need to load a different program into the Arduino to record the accurate timing data we need. You’ll find the listing for the program at the end of this article. Note that for this test you don’t need any of the temperature sensors, just the Hall-effect sensor.

I’m not going to go through the steps of using the Arduino and obtaining the output from the serial monitor. Everything you need to learn to use the Arduino is available on Adafruit’s site. Once you know how to connect up the Arduino and receive output on the serial monitor, you should know everything you need to run the tests.

Make an Arduino sketch (that’s a program) using the listing at the end of this article. This assumes you’ve wired up the sensors to the Arduino as described in the automated testing article. Load the program into the Arduino and open the serial monitor. Spin the flywheel by hand. You’ll want to locate the magnet that actuates the Hall-effect sensor so that it doesn’t pass in front of the Hall-effect sensor until you’ve released the flywheel. The data recording is actuated by the first pass of the magnet. The Arduino sketch will have the microcontroller record the first 100 times the magnet passes the Hall-effect sensor. After 100 measurements or 2 seconds without a revolution, the system outputs the data and resets for the next data set.

Copy and paste the timing data into a spreadsheet to complete the computations. Measurements are recorded in microseconds. You’ll need to convert them to seconds to use them in the spreadsheet.

#### Kinetic energy

Rotational kinetic energy is:

KE = Itotalω2/2 joules

Engineers and physicists usually measure rotational speed in radians/second and call it ω.
ω = (speed in Hz)2π

(The symbol π represents pi but sometimes doesn’t look correct in every browser).

Using the units I’ve suggested, the kinetic energy of the flywheel will be in kg-m2/sec2 also called a Joule.

The kinetic energy equation will let you generate the plot shown in figure 1 except that I’ve changed the kinetic energy scale from Joules to milliJoules.

## Flywheel power loss computation

data sampleClock time when magnet passes sensorSpeed (frequency), Hzω radians/seckinetic energy of flywheelFlywheel power lossSpeed (frequency) corresponding to power loss measurement.
1T1
2T2F1 = 1/(T2 - T1)ω1 = 2πF1
KE1 = ω12Itotal/2
3T3F2=1/(T3 - T2)ω2 = 2πF2KE2 = ω22Itotal/2Power1 = 2(KE1 - KE2)/(T3 - T1) F = 2/(T3 - T1)

The above table shows that you need 3 data points to get a power measurement, after that you can compute one power measurement for each data point. Three time measurements let you determine the flywheel speed over two periods. The two speeds let you compute the kinetic energies represented by the two speeds. Finally, the difference in kinetic energy of the two measurements divided by the time between the two measurements results in the average power supplied by the flywheel during that period.

The above table shows the computations that need to go into the first three rows of your spreadsheet. After that just keep repeating the third row computations for each additional row.

Although there are more rigorous methods for determining the power loss that would use curve fitting and computing the derivative, this method should be sufficiently accurate for most applications. We assume the computed speed F1 represents the actual speed at the time half way between T1 and T2. Similarly, F2 represents the speed at the time half way between T2 and T3. Using the same logic, we assume the power change occurs over one half the period from T1 to T3.

If you compute the kinetic energy in Joules then the power computation in the above table will result in Watts. You can see the results of using this technique on the 3D printed engine in my article on engine friction measurements using flywheel deceleration.

This method isn’t limited to Stirling engines, it can be used to test the loads on all kinds of rotating machinery, large or small. The beauty of it is that it only requires data from a single sensor and some computations to determine the flywheel inertia.

#### Arduino program listing

```/*
Instrumentation conttroller for PE2 engine tests 2/4/13
Features:
This version is for capturing and outputting the system time when the
speed magnet is sensed by the hall-effect sensor. The data collected
provides flywheel speed data.

*/

//Hardware Pin assignments ************************************

//Keep the temperature sensor pin assignments because they are still
//elecrically connectred even though not being used.
int Tc_pin = 1;
int Th_pin = 2;

int speedPin = 2; // Digital pin for Hall Effect sensor

//Variable declarations ***************************************

#define aref_voltage 5.0
unsigned long time[100]; // storage for 100 time values
int N = 0; // count for time array
boolean done = false; // Done indicates the time memory has been filled
unsigned long oldTime = 0; // oldtime holds the last recorded time
int i;

//Function definitions *********************************************

//The function is called for engine speed by interrupt on hall sensor
void hertz(){ //Interrupt routine to track Hz or RPM
time[N] = (micros());
oldTime = time[N];
if(N>=100){
done = true;
}else{
N++;
}
}

// begin setup function *********************************

void setup() {
Serial.begin(9600); //Start the serial connection
for(i=0; i<100; i++){
time[i]=0; //set all time memory to zero
}

// Hardware intitialization
pinMode(speedPin, INPUT); // Hall effect sensor
attachInterrupt(0, hertz, FALLING); // function call for the interrupt

Serial.print("Test name: ");
Serial.println("PE 2 spindown test");
Serial.println("micro sec");

}

// Begin loop function ***************************************

void loop(){

/*
If the sensor has triggered and nothing has happened for 2 sec
then the flywheel must have stopped. If done is true then memory
has been used up. In either case print results to serial monitor.
*/
if((oldTime > 0 && (micros()) > oldTime + 2000000) || done == true){
for(i=0; i<100; i++){
Serial.println(time[i]);
if(time[i] == 0){ // just print out one zero, not all 100.
i = 100;
}
}
// Reset for another run
// There will be a gap of missed data if data has been continuous

for(i=0; i<100; i++){
time[i]=0; // zero time memory
}
done = false;
N=0;
oldTime=0;
}
}
```