Antique cameras: how to build a shutter-speed meter with Arduino

The splendid camera in the photo is a folding one that shoots on glass plates in 82 × 107 mm format — also called “quarter-plate” — handmade in 1900 by the famous chemist and camera maker Dr. Rudolf Krugener of Frankfurt, on behalf of London-based manufacturer George Houghton, owner of the registered trademark Klito, and sold by an optician in Manchester, named A. Franks, to an unknown buyer who probably never used it.

Although the origin of this device is easily identifiable from some construction details typical of Krugener and from the labels affixed on the chassis, we know nothing of its history until the moment it arrived at our Spazio Chirale following an auction won by our researchers, always hunting for significant material for our studies.

The almost-perfect condition of the body, the bellows and the related accessories reveal that the camera has never been used.

It is certainly a very rare object, since it mounts an optic consisting of a simple meniscus lens and a rotating shutter with only two options: the classic “T” and the “I”, which identifies the Instantaneous shot — for which the value of the related speed is not indicated. The apertures consist of a series of circular holes placed on a disc mounted in front of the lens.

We know that Krugener built cameras that would be branded Klito by Houghton until 1912, and in almost all the models known and classified by collector sites there is a more complex lens and a more complex central shutter.

The model in our possession is therefore one of the very first series.

The absence of a shutter with adjustable speeds may seem a limitation, but at the time it was not really a problem, since the typical sensitivity of glass photographic plates was about 2–3 ISO, and only at the end of the 19th century did plates with 25 ISO emulsion begin to appear. This fact, together with the “f” numbers shown on the aperture selector — varying from f12 to f34 — suggests that the shutter speed in the I position could be between 1/20 and 1/30 of a second, sufficient to shoot outdoors on days with normal sunlight, with some adaptability of exposure.

Needless to say, our aim is to use the camera, making it shoot for the first time in its life — doing justice to this jewel. For this reason we immediately ordered two boxes of glass photographic plates at 2 ISO and 25 ISO.

Yes! In 2019 it is possible to buy virgin photographic plates with the same characteristics as those of the first or second half of the 1800s, depending on preferences. All thanks to the Internet and Anderson’s long tail, and if you don’t know what we are talking about it doesn’t really matter — just go to the e-commerce site Etsy at this link and complete the purchase of the plates you like, thanks to the work of Jason Jane, optical engineer and photographer based in Michigan (USA), who decided to start an artisanal production to bring this ancient technology back to life.

With 2 ISO plates the exposure times will necessarily be of several seconds, so we will use the T mode with manual timing.

The use of the I mode would also be interesting — but how long will the actual exposure time be, and how reliable?

A shutter meter would be needed. A device of this kind would also be useful to verify the accuracy of shutters in all cases where we have to assess the reliability of vintage cameras.

Building a shutter meter is not difficult. It involves emitting a light beam that crosses the lens and placing on the open back of the camera a sensor that records the time during which the passage of light is perceived.

With Arduino it’s something that can be implemented quickly.

If you are thinking of using as a sensor a photoresistor like the one present in all Arduino starter kits, get rid of the idea immediately.

The variation in resistance during luminous transitions of a component of this kind takes between 20 and 30 milliseconds — a time of the same order of magnitude as the interval we want to measure. On fast times, we simply wouldn’t have time to notice that the shutter has been opened.

We therefore need a sensor that reacts quickly in order to be able to detect times at least up to 1/1000 of a second, which is the limit for a mechanical shutter.

Photodiodes and phototransistors are suitable components; however, looking at the rich panorama of low-cost Chinese sensors and components that proliferate on the maker market, a fast and very low-cost solution consists in the use of two components easily purchasable on sites such as Ebay, Amazon or Aliexpress at the price of a few euros.

The first is a laser source, normally used as a pointer: it has three terminals, but it is enough to connect two of them to GND and +5V to activate the light beam. On e-commerce sites you often find it indicated as a laser sensor, but obviously this naming is incorrect, since it is a simple actuator.

The laser sensor, in fact, is the second component. It is a simple digital sensor. On the PCB the classic three terminals are present: +Vcc, GND and Signal (S). Once powered, the sensor provides on the S terminal a value that, depending on the model, can be HIGH (+Vcc) or LOW (GND). If the sensor is illuminated by a laser beam, after a latency time of a few microseconds, the value on the S terminal is inverted.

Once both components have been purchased, you can test their operation with a simple Arduino sketch and determine the type of transition the sensor performs. For example, those in our possession show a HIGH value in the absence of laser illumination that becomes LOW if the sensor is hit by the beam.

The source code we present is therefore developed to handle this behaviour, but is easily modifiable to handle sensors that have the inverse behaviour.

The principle on which the shutter meter prototype is based is very simple and can be logically summarised in the following steps:

• The laser source is always powered and is positioned in front of the camera lens.
• The laser-beam detection sensor is connected to a digital PIN of Arduino configurable as interrupt (e.g. PIN 2 on Arduino UNO) and is positioned on the back of the camera, whose back must be open or removed, so that when the shutter opens, the sensor is hit by the light beam. Keeping the shutter open using the T or B position makes it easy to align sensor and source.
• Once sensor and source are aligned, the shutter can be closed and the measurement test can be performed by setting the speed dial and taking the shot.
• When the shutter opens following the shot, the sensor changes state and the time marker at that instant is recorded.
• When the shutter closes at the end of the shot, the sensor changes state again and the current time marker is recorded at this instant.
• The shutter speed is then calculated by taking the difference between the time markers detected at the opening and closing of the shutter.

In our prototype we connected the laser-sensor signal to PIN 2 of Arduino UNO and used the management of the related interrupt to detect the time measurements.

The source code can be found at this link: https://github.com/spaziochirale/ArduinoShutterMeter

Those who have followed our basic Arduino courses and all those who know the programming of Interrupt Service Routines will have no difficulty in interpreting the algorithm.

In any case, we report some details on the structure of the code.

• To detect the current time marker we used the Arduino library function micros(), which provides the number of microseconds elapsed since the board was powered on. The data returned are potentially very large integers and therefore of type unsigned long.
• Since on a single PIN only one ISR can be installed, our routine — which we named shutterEvent() and installed on PIN 2 — is invoked for any state transition of the sensor (mode CHANGE), and inside it determines which transition has occurred (from HIGH to LOW or from LOW to HIGH) by reading the current value on PIN 2.
• As a first thing, our ISR records the current time value, invoking micros() and updating the global variable now. As is known, inside the ISR the micros() function is not incremented — i.e. it always provides the same value — since interrupts, and therefore also the management of the internal microcontroller timer, are disabled; but in our case we need exactly the time marker at the instant of the event that invoked the interrupt.
• As a second action, our ISR determines whether the event that caused its invocation was the opening or the closing of the shutter. Recall that our sensor varies from HIGH to LOW when illuminated and from LOW to HIGH when the laser beam is interrupted.
• The ISR function shutterEvent() records the type of event by setting to 1 the global variables shutterOpen or shutterClose used as flags, and then terminates. It receives no parameters, returns no values and performs fast and essential actions, as is correct for a well-designed ISR.

The loop() function of our sketch constantly cycles testing the value of the two flags shutterOpen and shutterClose.

If the shutterOpen flag is active, it means that the opening of the shutter has been detected, with the consequent call to the ISR shutterEvent(), which has therefore updated the time marker in the variable now. This value is then copied into the variable tOpen.

The shutterOpen flag is reset to zero and the loop continues in its cycle of testing the two flags. If the shutterClose flag is active, it means that the closure of the shutter has been detected, with the consequent call to the ISR shutterEvent(), which has again updated the time marker in the variable now. This value is then copied into the variable tClose and the calculation of the time elapsed since the opening event — whose time marker is contained in tOpen — is performed.

The shutterClose flag is reset and the results are printed in the typical format used in photography. In particular, the difference between tClose and tOpen provides the number of microseconds during which the shutter has remained open. If this time is greater than 1,000,000 microseconds — i.e. 1 second — this time is indicated in seconds and decimals are also printed due to the float conversion of the data. For times less than a second the value is printed as a fraction without the use of decimals.

The execution time of one cycle of loop() is a few microseconds, so the logic of this program works in the desired range of times — which provides a maximum shutter speed close to 1/1000 of a second.

In this case, the detected time will be about 1,000 microseconds, greater than the execution time of the single cycle by at least three orders of magnitude.

In the case of our camera, the times detected by our shutter meter — by triggering the shutter several times in the I position — turned out to be quite variable, with readings ranging from 1/19 of a second up to 1/40 of a second, with most measurements at about 1/30 of a second.

This is not surprising, since we are talking about a simple spring mechanism probably unused for almost 120 years!

In the end, the variability of the exposure is contained within an interval of plus or minus 2/3 of a stop — consistent with the coarse resolution of the possible aperture choice, which shows only the values f12, f17, f24 and f34.

It should not be a problem to obtain reasonably exposed glass-plate negatives, considering that they will be developed in a tray under red light — the emulsion being orthochromatic — with the possibility of visually controlling the contrast index.