We’ve lost our fuel tank sender. It doesn’t report anything below about ½ tank. It simply drops from ½ to “not working at all” mode. I looked at it with my trusty multimeter. It is dead.

It’s a standard Teleflex sender. Nothing special; easy to replace.

But.

Until we replace it, do we have a fallback?

Duh. It’s a sailboat.

The first fallback is to sail and stop using fuel. Tank level doesn’t matter anymore, right?

But sailing isn’t always the best choice. After making two long motor-sailing passages along the US East Coast, we’ve found that we like motor-sailing a lot. A real lot.

I’ve just finished working on a book about computer programming. During the long night watches, my brain continued to spin in “author mode”. This blog post will involve code. I apologize in advance.

**Additional Workarounds**

One workaround is never enough. Not for something as important as the distance we can cruise.

The second fallback to no working gauge is our “magic fuel consumption number” and a log. Based on data from Epic Northbound Voyage, Part I, combined with Epic Northbound Voyage, Part II, we appear to burn about 6×10^{-4} gallons per RPM-hour. Multiply hours at a given RPM to figure out what fuel was burned.

Previously, I had computed for leg 1. The leg 2 data, including an estimate for failing to fill the tank to the top the second time, gives a slightly lower burn rate of . We use a weighted average because leg 1 was 83,600 RPM-hours, and leg 2 was 88,700 RPM-hours. This is , which is so close to 6 that I’m going to use that value.

The third fallback is to open the inspection port and use a stick. This is annoying because we don’t really have a suitable inspection port. I have to remove the fuel level sender to “stick the tank.” The sender is held on with five screws, and an awkward shape to remove.

The design for the Whitby has 3 tanks: port and starboard are 75 gallon tanks. There’s a keel tank that holds something like 100 gallons. *Red Ranger* has no port tank and bilgewater leaks into the center tank. We’re focused on the starboard tank. 250 gallons. At 2000 RPM, you could go, well… How far could you go?

**Sticking the Whitby Fuel Tank**

The saddle tanks have a profile something like the following. This is the view from aft looking forward on the starboard tank. It seems to be about 32″ fore-to-aft; but it’s deeply buried inside the cabinetry, so it’s hard to be sure.

I figure that this shape is just a hair over 75 gallons. I get 17,472 in^{3}; 75 gallons is exactly 17,325 in^{3}. Lacking better information, I’m using this as the size and shape.

The vertical 21″ line shows the depth when I drop a stick straight in. The sloping 31″ line shows the depth when I slide the stick down to the deepest part of the tank.

I did these two measurements yesterday by sticking a dowel in the tank and marking it with sharpie at the top. I then divided the space into quarters to help gauge depth. Since the existing sender is in the way, using a stick on regular basis to gauge fuel depth isn’t really practical.

Since the stick is at an angle, the marks on the stick aren’t **directly** indicative of gallons. You have to use two bits of math to get some meaningful accuracy. First, the correction for the offset stick:

This converts stick inches, *s*, to vertical inches, *d*, down the front of the tank. Here’s some Python programming to confirm this formula.

>>> cos(asin(12/28))*31

28.00874499006279

>>> cos(asin(12/28))*15.5

14.004372495031395

31″ on the stick is 28″ vertical inches. 15″ on the stick is 14″ vertical inches down the front of the tank. Not a huge difference, but it could mean three gallons of error.

The “cos(arcsin…)” expression reduces to the value of 0.9035. I prefer to show the whole formula rather than replace it with a mystical constant.

**Depth To Gallons**

The irregularity of the tank, however, leads to an important question. How to we convert stick or binnacle gauge readings to actual gallons? When the gauge reads ½ or the stick reads ½, how much fuel is that really?

We have a rather complex, two part formula to compute volume given depth. The bottom 14″ and the top 14″ play by different rules: the bottom is a triangular prism, the top is a simple rectangular box. Here’s the version in cubic inches, to show in detail how the triangle bottom and rectangle top work.

Ugh. Not really very useful in that form.

Here’s a simplified version that also includes the conversion from cubic inches to gallons; 231 in^{3}/gal.

We can use this to create a handy stick-to-gallons table.

Here’s some Python programming to create the table. We’ll break this down into three separate very simple functions: stick_to_depth, depth_to_in3 and in3_to_gal. We can build a single stick_to_gal function that combines these into a single answer.

>>> def stick_to_depth(s):

... return cos(asin(12/28))*s

...

>>> stick_to_depth(15.5)

14.004372495031395

>>> def depth_to_in3(d):

... if d <= 14: return 5600*d/14

... else: return 5600+(d-14)*832

...

>>> def in3_to_gal(d):

... return d/231

...

>>> def stick_to_gal(s):

... return in3_to_gal( depth_to_in3( stick_to_depth(s) ) )

...

>>> stick_to_gal(15.5)

24.258172795957233

Given our stick_to_gal function, we can produce a table with 9 steps, from 0/8 (empty) to 8/8 (full), showing the stick inches and the gallons actually in the tank.

>>> for i in range(9):

... print( i/8, 31*i/8, stick_to_gal(31*i/8) )

...

0.0 0.0 0.0

0.125 3.875 6.062498915598007

0.25 7.75 12.124997831196014

0.375 11.625 18.187496746794018

0.5 15.5 24.258172795957233

0.625 19.375 36.86817054040109

0.75 23.25 49.47816828484494

0.875 27.125 62.088166029288786

1.0 31.0 74.69816377373266

The unformatted output is really hard to work with. We can clean that up like this.

>>> for i in range(9):

... print( "{:d}/8 {:5.1f} {:5.1f}".format(i, 31*i/8, stick_to_gal(31*i/8)) )

...

0/8 0.0 0.0

1/8 3.9 6.1

2/8 7.8 12.1

3/8 11.6 18.2

4/8 15.5 24.3

5/8 19.4 36.9

6/8 23.2 49.5

7/8 27.1 62.1

8/8 31.0 74.7

That’s much nicer. As a fall-back measurement, this works out nicely.

It would work out even **more** nicely if the fractions were properly reduced. We should use the fractions module to clean this up a bit.

>>> from fractions import *

>>> for i in range(9):

... d= Fraction( i, 8 ) ... print( '{:3s} {:5.1f}" {:5.1f}'.format(d, float(31*d), stick_to_gal(31*d)))

...

0 0.0" 0.0

1/8 3.9" 6.1

1/4 7.8" 12.1

3/8 11.6" 18.2

1/2 15.5" 24.3

5/8 19.4" 36.9

3/4 23.2" 49.5

7/8 27.1" 62.1

1 31.0" 74.7

That’s really nice. When we’re forced to stick the tank, we can not only see how much fuel we have, but we can convert it to a precise number of gallons. Exact gallons translates to engine run time. From there, based on wind and sea, the distance that can be safely covered.

**Teleflex Gauge to Gallons**

Because sticking the tank is messy and awkward, we will replace the Teleflex sender with one that works. This leads us to a conversion from the Teleflex 24″ depth gauge to actual gallons. We want to know how much fuel we have; we also know how much we’re going to buy when we fill the tank for the next leg of a long voyage.

Gauge | Inches | Available | To Fill |
---|---|---|---|

E | 4 | 7 | 68 |

1/8 | 7 | 12 | 63 |

1/4 | 10 | 18 | 57 |

3/8 | 13 | 23 | 52 |

1/2 | 16 | 32 | 43 |

5/8 | 19 | 43 | 32 |

3/4 | 22 | 54 | 21 |

7/8 | 25 | 64 | 11 |

F | 28 | 75 | 0 |

Note that the Teleflex sender only measures the top 24″ of the tank. Therefore, there’s a kind of reserve of 7 gallons even when the gauge reads empty.

The conversion from Teleflex gauge reading to inches is relatively simple.

>>> def gauge_to_depth(g):

... return 4+g*24

...

>>> gauge_to_depth(0)

4

>>> gauge_to_depth(.5)

16.0

>>> gauge_to_depth(1)

28

What’s important is that the ½ line on the gauge means there’s closer to 31½ — not 37½ — gallons in the tank.

Here’s the programming.

>>> in3_to_gal( depth_to_in3( gauge_to_depth(.5) ) )

31.445887445887447

Creating a gauge_to_gal function and using it to produce the table shown above is left as an exercise for the reader. If you don’t have Python3 on your computer, you can download it from www.python.org.

**Gallons Burned Per RPM-Hour**

Here is the more useful calculation: Gallons per RPM-hour. The table shown below is used to convert gauge readings to available running time at a given RPM level.

The table is based on this process.

1. Convert gauge reading to gallons.

2. Use 6×10^{-4} gallons per RPM-hour to determine how far we can go at various RPM levels.

**Fuel level to Hours of run-time at a given RPM**

Hours at RPM | ||||||
---|---|---|---|---|---|---|

Gauge | Gallons | 1200 | 1400 | 1600 | 1800 | 2000 |

E | 7 | 9.7 | 8.3 | 7.3 | 6.5 | 5.8 |

1/8 | 12 | 16.7 | 14.3 | 12.5 | 11.1 | 10.0 |

1/4 | 18 | 25.0 | 21.4 | 18.8 | 16.7 | 15.0 |

3/8 | 23 | 31.9 | 27.4 | 24.0 | 21.3 | 19.2 |

1/2 | 32 | 44.4 | 38.1 | 33.3 | 29.6 | 26.7 |

5/8 | 43 | 59.7 | 51.2 | 44.8 | 39.8 | 35.8 |

3/4 | 54 | 75.0 | 64.3 | 56.3 | 50.0 | 45.0 |

7/8 | 64 | 88.9 | 76.2 | 66.7 | 59.3 | 53.3 |

F | 75 | 104.2 | 89.3 | 78.1 | 69.4 | 62.5 |

(For other boats, 7×10^{-4} gallons per RPM-hour might is a more useful number because it doesn’t involve Red Ranger’s peculiar alternator setup. Our RPM numbers are higher than the engine is actually turning.)

Here’s how we use this table.

1. Given a level of fuel in our tank. Say it’s ⁵⁄₈.

2. Given an RPM. Say 1600.

We have 44.8 hours of motoring until the tank is **empty**. Bone-dry empty. Figure in safety margins and one should probably figure on 30 hours motoring keeping 15 hours of reserve fuel.

15 hours of fuel (at 1600 RPM) will read below ¼, close to ¹⁄₈.

Generally, we make about 7 knots at this RPM, so we might be able to go 210 nm. Speed and distance vary with wind, current and wave conditions. Fuel consumption doesn’t.

**Exercises**

We can apply this to the theoretical Whitby design.

a) 250 gallons of fuel, at 1600 RPM at 7×10^{-4} gallons per RPM-hour means what cruising time?

b) If 1600 RPM leads to cruising at 7 knots, what’s the cruising range?

c) How far from Norfolk, VA, can you get with that much fuel?