Rotation and Flashes

How Lighthouses Work

Chapter 5 · Rotation and Flashes

How Lighthouses Work 4 ended with a lens that squeezes the light of a small flame into a narrow beam. A narrow beam solves one problem and creates another: a ship sees it only when it points at the ship. The answer is to turn the lens, so that the beam sweeps the sea like the hand of a clock. Turning also solves a second problem for free. If every lighthouse showed a steady glow, a sailor could not tell one from the next. A rotating beam, and a lamp that is shuttered or switched, can give each light its own rhythm. This chapter covers the machinery that turns the lens and the shorthand that names the rhythm.

What was run, and what to trust

Every Python snippet in this chapter and in the three exercise solutions was run, and the output in the comments is what Python printed. The facts about clockwork, mercury, panel counts and flash rates were taken from the Wikipedia pages on lighthouses, on Fresnel lenses and on light characteristics, as fetched; where the pages disagree, the chapter says so. The assumptions are mine and are labelled where they appear: 5 W to turn a mercury-floated lens, four times that for a dry bearing, the example timings of each characteristic (for instance 1 s of light and 7 s of dark), and the beam widths carried over from How Lighthouses Work 4. The characteristics shown are illustrative patterns, not the timings of any named lighthouse. The 480 second turn in the first snippet is my arithmetic from the source's flash rates, not a figure the source states.

Turning the Lens

The lighthouse article says William Hutchinson developed the first practical optical system in 1777, which made the first revolving beams possible, and that Robert Stevenson's Bell Rock Lighthouse (1810) used rotating lights alternating between red and white. The Fresnel lens article describes Fresnel's next lens, a rotating apparatus with eight bull's-eye panels that gave eight rotating beams, and an 1825 plan for one flash per minute from a rotating lens with eight panels and two per minute from one with 16. A first-order catadioptric lens in Paris is described as giving four revolving beams, seen as four flashes per revolution; another lens gives three double flashes per rotation.

The sums are simple. With N panels equally spaced, the lens makes N flashes per turn, so the interval between flashes is the turn time divided by N. Run the plan backwards: eight panels and one flash per minute need 8 minutes per turn, and 16 panels and two flashes per minute need the same 8 minutes. That is my reading of the source's numbers, not something it states. How long does an observer see each flash? The beam crosses the observer in the time it takes to turn through its own width.

# Flash interval, revolution period and how long one beam sweeps past an observer.
PLANS = (("8 panels, 1 flash per minute", 8, 1.0), ("16 panels, 2 flashes per minute", 16, 2.0))

def revolution_s(panels, flashes_per_min):
    return panels * 60.0 / flashes_per_min

def dwell_s(beam_deg, period_s):
    return beam_deg / 360.0 * period_s

for name, panels, rate in PLANS:
    t = revolution_s(panels, rate)
    print(name, "->", t, "s per turn,", round(360 / t, 2), "deg per second")
for beam in (0.86, 1.25, 7.63):
    print(beam, "deg beam:", round(dwell_s(beam, 480), 2), "s at 480 s per turn,", round(dwell_s(beam, 10), 3), "s at 10 s per turn")
print("beam width for a 1 s flash at 10 s per turn:", 1.0 / 10 * 360, "deg")
# 8 panels, 1 flash per minute -> 480.0 s per turn, 0.75 deg per second
# 16 panels, 2 flashes per minute -> 480.0 s per turn, 0.75 deg per second
# 0.86 deg beam: 1.15 s at 480 s per turn, 0.024 s at 10 s per turn
# 1.25 deg beam: 1.67 s at 480 s per turn, 0.035 s at 10 s per turn
# 7.63 deg beam: 10.17 s at 480 s per turn, 0.212 s at 10 s per turn
# beam width for a 1 s flash at 10 s per turn: 36.0 deg
    

The first two lines give the turn time (480 s) and the beam's angular speed (0.75 degrees per second). The next three give the time a ship sees a beam of 0.86, 1.25 and 7.63 degrees (the hyper-radial, first-order and sixth-order beams of the model in How Lighthouses Work 4) at 480 s and at 10 s per turn. The last line gives the beam width a 1 second flash would need at 10 s per turn: 36 degrees. This exposes a tension that I could not resolve from my sources. A fast-turning, narrow-beam lens gives a very brief flash (0.035 s for a 1.25 degree beam at 10 s per turn), yet the characteristics in the next section are described with flashes of a second or more. Either those lights have wide beams, or turn very slowly, or the figure is the effective duration of a flash as the eye sees it rather than the geometric one. I do not know which, so treat the flash length as the stated characteristic and the 0.035 s as the model's geometry.

Clockwork, weights and mercury

The lighthouse article says the lenses were rotated by a weight-driven clockwork assembly wound by keepers, sometimes as often as every two hours, and that the lens assembly sometimes floated in liquid mercury to reduce friction. It gives no date for the mercury. Later lighthouses used electric motors, generally powered by diesel generators, again with no date. How heavy would the weight have to be? It stores energy as mass times gravity times drop, and the lens uses power continuously, so the weight needed for a given winding interval depends on the drop. Here is the sum for the 2 hour winding, with an assumed 5 W for a floated lens and four times that for a dry bearing (both assumed):

# Weight-driven clockwork: how heavy a weight, how far it drops.
G = 9.81

def weight_kg(power_w, hours, drop_m):
    energy_j = power_w * hours * 3600
    return energy_j / (G * drop_m)

POWER_W = 5.0        # assumed: power to turn a mercury-floated lens
DRY_FACTOR = 4.0     # assumed: a dry bearing needs four times the power
WIND_H = 2.0         # the lighthouse article: sometimes as often as every two hours
for drop in (4, 8, 12):
    print(drop, "m drop:", round(weight_kg(POWER_W, WIND_H, drop)), "kg floated,", round(weight_kg(POWER_W * DRY_FACTOR, WIND_H, drop)), "kg dry")
print("energy per 2 h at 5 W:", POWER_W * WIND_H * 3600, "J")
print("hours from a 300 kg weight falling 8 m:", round(300 * G * 8 / (POWER_W * 3600), 1))
# 4 m drop: 917 kg floated, 3670 kg dry
# 8 m drop: 459 kg floated, 1835 kg dry
# 12 m drop: 306 kg floated, 1223 kg dry
# energy per 2 h at 5 W: 36000.0 J
# hours from a 300 kg weight falling 8 m: 1.3
    

The first three lines give the weight for 4, 8 and 12 m drops. A floated lens needs 459 kg at 8 m and a dry one 1,835 kg: four times the power means four times the weight for the same winding interval. The 36,000 J is the energy used in 2 hours at 5 W. The last line shows that a 300 kg weight falling 8 m would run only 1.3 hours at 5 W. The mercury therefore cuts the weight, or lengthens the winding interval, by a large factor in this model. The lens itself weighs tonnes (How Lighthouses Work 4 gives about 1.5 tonnes for a first-order assembly), so floating it is a sensible way to make it turn at all. Mercury is also toxic, which is general knowledge and not something I read in the sources; it is a reason to prefer motors today, but that is my inference, not a quoted one.

Drive	What the source says	What it needs
Weight-driven clockwork	wound by keepers, sometimes every two hours	a keeper awake and winding through the night
Mercury float bearing	lens sometimes floated in liquid mercury to reduce friction	far less force to turn the lens (model: one quarter, assumed)
Electric motor	used in more modern lighthouses, often with a diesel generator	a power supply, not a keeper's arm

Flash Characters

A light characteristic is the pattern of light and dark that identifies a light. The Wikipedia article on light characteristics gives these abbreviations (colour letters W, G, R, Y and Bu follow, and white is implied if none is given):

Abbreviation	Name	Definition (from the article)
F	Fixed	a continuous and steady light
Fl	Flashing	a flash of light repeated, with a longer period of darkness
LFl	Long flashing	the flash lasts 2 to 5 seconds
Q, VQ, UQ	Quick, very quick, ultra quick	a flashing light of high frequency (see the conflict below)
Iso	Isophase	dark and light periods of equal length
Oc	Occulting	the light in each period lasts longer than the total darkness
Mo	Morse code	two clearly different durations of light, dots and dashes
Al	Alternating	a light showing alternating colours

Source conflict on the quick lights: the article says the threshold for "quick" is given as either 30 or 50 flashes per minute depending on the source, and elsewhere it gives bands of 50 to 80 flashes per minute for quick, 80 to 159 (in another place "more than 80 and less than 160") for very quick, and 160 or more for ultra quick. I have not resolved which threshold is used where. The article also gives rules for a single flash: a period of 2 to 15 seconds (2.5 to 15 in countries that use quick lights) and a darkness of at least three times the flash. A group of flashes is written with the count in brackets, so Fl(2) is two flashes per group, with a period of no more than 20 seconds for two flashes and no more than 30 for three or more. The article's example, Fl(3) R 15s, is three red flashes of 1.0 s separated by 1.0 s of darkness, then 10.0 s of darkness, a 15 second cycle. What do these look like? The code draws each one as a row of characters, a hash for light and a dot for dark, in half-second steps:

# Light characteristics as timelines, drawn at half-second steps.
CHARS = {
    "Fl W 5s":     [("L", 1), ("D", 4)],
    "LFl W 12s":   [("L", 3), ("D", 9)],
    "Fl(2) W 10s": [("L", 1), ("D", 1), ("L", 1), ("D", 7)],
    "Fl(3) R 15s": [("L", 1), ("D", 1), ("L", 1), ("D", 1), ("L", 1), ("D", 10)],
    "Iso W 4s":    [("L", 2), ("D", 2)],
    "Oc W 5s":     [("L", 4), ("D", 1)],
    "Mo(A) W 12s": [("L", 1), ("D", 1), ("L", 3), ("D", 7)],
}

def period(segs):
    return sum(d for _, d in segs)

def light_share(segs):
    return sum(d for s, d in segs if s == "L") / period(segs)

def draw(segs, window_s=30, step=0.5):
    out = ""
    for i in range(int(window_s / step)):
        t = (i * step) % period(segs)
        acc = 0.0
        for s, d in segs:
            acc += d
            if t < acc:
                out += "#" if s == "L" else "."
                break
    return out

def check_single_flash(segs):
    lights = [d for s, d in segs if s == "L"]
    darks = [d for s, d in segs if s == "D"]
    return period(segs) >= 2 and period(segs) <= 15 and darks[0] >= 3 * lights[0]

for name, segs in CHARS.items():
    print(name.ljust(12), draw(segs), round(light_share(segs), 2))
print("Fl W 5s passes the single-flash rules:", check_single_flash(CHARS["Fl W 5s"]))
print("Fl(3) R 15s period:", period(CHARS["Fl(3) R 15s"]), "s")
# Fl W 5s      ##........##........##........##........##........##........ 0.2
# LFl W 12s    ######..................######..................######...... 0.25
# Fl(2) W 10s  ##..##..............##..##..............##..##.............. 0.2
# Fl(3) R 15s  ##..##..##....................##..##..##.................... 0.2
# Iso W 4s     ####....####....####....####....####....####....####....#### 0.5
# Oc W 5s      ########..########..########..########..########..########.. 0.8
# Mo(A) W 12s  ##..######..............##..######..............##..######.. 0.33
# Fl W 5s passes the single-flash rules: True
# Fl(3) R 15s period: 15 s
    

Each row shows the characteristic, 30 seconds of its pattern, and the share of the time the light is on. The Fl(3) R 15s row follows the article's example exactly (three flashes, gaps of 1 s and a 10 s pause, so 3 + 2 + 10 = 15). The other timings are my illustrative choices: Fl 5s with a 1 s flash passes the "at least three times" darkness rule (4 s against 1 s), LFl has a 3 s flash (within the 2 to 5 s range), and Mo(A) is a 1 s dot and a 3 s dash (a short and a long signal, the letter A; the 12 s period is my choice). The isophase light is on half the time and the occulting one 80 per cent of the time, while the flashing lights are on for a fifth to a third. A sailor can look away, time the pattern with a watch and compare it with the chart, as How Lighthouses Work 9 does when it reads one.

From Pattern to Panel

How does a lens that only turns make Fl(2) or Fl(3)? The panels are placed in pairs or threes, and the angle at which each flash starts is its start time divided by the period, times 360 degrees. The code works out where each flash starts and how wide it must be, from the same illustrative timelines:

# Where the flash panels must sit on a rotating lens.
CHARS = {
    "Fl(2) W 10s": [("L", 1), ("D", 1), ("L", 1), ("D", 7)],
    "Fl(3) R 15s": [("L", 1), ("D", 1), ("L", 1), ("D", 1), ("L", 1), ("D", 10)],
}

def panel_layout(segs):
    total = sum(d for _, d in segs)
    t = 0.0
    out = []
    for s, d in segs:
        if s == "L":
            out.append((round(t / total * 360, 1), round(d / total * 360, 1)))
        t += d
    return out

for name, segs in CHARS.items():
    print(name, "(start deg, width deg):", panel_layout(segs))
# Fl(2) W 10s (start deg, width deg): [(0.0, 36.0), (72.0, 36.0)]
# Fl(3) R 15s (start deg, width deg): [(0.0, 24.0), (48.0, 24.0), (96.0, 24.0)]
    

For Fl(2) W 10s the two flashes start at 0 and 72 degrees and each is 36 degrees wide (a 1 s flash on a 10 s turn). For Fl(3) R 15s the three start at 0, 48 and 96 degrees and are 24 degrees wide. The widths are large because the flashes last a whole second, which is the tension described in the first section: the model implies beams of tens of degrees for second-long flashes. I could not check this against a real lens, and the Fresnel article's own examples (three double flashes per rotation) describe how many flashes there are, not their angular size. The method (angles from times) is plain arithmetic; the numbers are the model's.

Common mistakes

Reading "one flash per minute from eight panels" as one turn per minute (it is eight minutes per turn, by my arithmetic); treating the mercury as a source of light rather than a bearing; counting an occulting light (long light, brief dark) as a flashing one; applying the "darkness three times the flash" rule to every characteristic (the article states it for single flashes, and I applied it only there); forgetting that the quick-light threshold is quoted as both 30 and 50 flashes per minute; and quoting the example timings in this chapter as those of a real light.

Exercise 1

Write a function that classifies a light from timed observations of one repeat of its pattern (a list of light and dark durations in seconds) as Fl, LFl, Oc, Iso, Mo or Fl(n), and returns the period. Run it on six observed patterns, print the share of the time the light is on, and check the plain flash against the rule that darkness must be at least three times the flash.

📄 View solution

Exercise 2

A lens has 4 equally spaced panels and turns once in 20 s. Find the flash interval and the rate per minute, the time a 1.25 degree beam is seen, the turn time that would give a 5 s interval with 4 panels, the angle between the two flashes of an Fl(2) 10s pair, and the beam width needed for a 1 s flash at 20 s and 5 s per turn. Finally find how fast the beam sweeps at a ship 10 nm away.

📄 View solution

Exercise 3

With 5 W to turn a floated lens and four times that dry, find the weight needed for an 8 m drop at winding intervals of 2 and 4 hours, then how long a 300 kg weight with a 10 m drop runs floated and dry, and how many windings a 12 hour night needs at each interval.

📄 View solution

Quick Reference

Rotation: N equally spaced panels give N flashes per turn; flash interval is turn time divided by N; the source's 1825 plan (8 panels, one flash per minute) works out to 8 minutes per turn
Drive: weight-driven clockwork wound by keepers, sometimes every two hours; lens sometimes floated in liquid mercury to reduce friction; later electric motors
Characteristics: F fixed, Fl flashing, LFl 2 to 5 s flash, Iso equal light and dark, Oc light longer than dark, Mo Morse, Al alternating colours
Rules: single flash period 2 to 15 s with darkness at least three times the flash; groups written Fl(n); example Fl(3) R 15s = 3 flashes of 1 s, 1 s gaps, 10 s dark
Conflict: the quick threshold is 30 or 50 flashes per minute depending on the source
Model: flash start angle = start time divided by period times 360; beam width for a flash = flash time divided by period times 360

Coming next

How Lighthouses Work 6 is about building on rock: Bell Rock (1810), Skerryvore (1844), Muckle Flugga, tide-limited working, interlocking stones, and wave forces.