Hi all! As you may have seen previously, I posted a teaser for the latest project some time ago. It is an 8mm film scanner which is run by an Arduino robot, and with the images captured by a recycled Canon IXUS55  pocket camera running an open source (and hacked ) operating system. I’ll show you a video first, then I’ll take you through the parts. A full building instruction will appear at some point on this blog.

The whole project started when I wanted to try capturing the 8mm films I shoot every year onto video. So far, I have used a commercial service, which delivers nice quality, and is easy for me. But I have wanted to learn to use the Arduino robot for some time now, and this seemed like a perfect project to try that with.

The relevant parts of the system are thus:

• 3D printed parts, including the camera mount, the film gate mount, lamp mount, spool mounts, and the film transport switch
• Arduino robot for getting information from switches and running two servo motors and the camera
• Canon IXUS55 camera, with the Canon Hack Development Kit, and that allows me to not only shoot the images by command from the Arduino, but also to manage focus, exposure and every other feature of the camera
• A macro lens attachment
• A genuine film gate from 1962 Bolex C8, which was available on eBay, and needed for reasons of accuracy in film transport
• Sundries, such as a Clas Ohlson 7-LED flashlight, which I gutted and mounted anew, and some eyewear cleaning cloth for film transport parts
• And of course Blender 3D for modeling the parts, exporting to printable STL, and to edit the movie from the single images

So how does it work?

The main part of the entire system is the film gate. When you think of how small 8mm film is, you’ll soon see it has a frame size of 4.5mm x 3.3 mm, and that is tiny. You can fit quite a few on a dime.

Therefore, if you want to grab a picture of each and every frame on its own, you have to move the film in extremely exact movements. I decided very early on that I won’t even attempt to build the film transport on my own, as that sort of precision is well beyond the engineering skills of an English major. But since even Bolex cameras are plentiful on eBay, I bought one for 12 euros, with postage from Britain, 23 euros. It is an earlier version of the camera I use myself, and had no lens. I was very keen to grab a camera that I can use later for spares, if my own should fail.

The film gate is the part attached to the rectangular piece in the center of the image. I kept on shedding parts until I had the bare minimum, a spike-like attachment to an eccentric so as to translate the rotation of the spring engine into a pushing movement. When I had the film gate in its essential part, I printed a mount for it, and attached a servo to simulate the spring-loaded motor it used to have. Worked like a charm.

With the film gate done, I focused (pun intended) on the camera. It focuses to 30mm on its own in a digital macro setting, but a macro lens attachment brings the focus down to 10mm.

I was amazed when I was able to focus the camera so close that it would capture frames at 2592 x 1544 pixels, yielding a lot more than I aimed for. This meant that I could scan the film and have material to spare, and then in Blender just crop out the parts I don’t need. Of course, if I used a real SLR for this, with a macro reversing ring for the lens, I could get even better resolution, but this is quite sufficient for now.

After this I set about designing the printable parts. I will publish a full set of them later, so if someone wants to print them too, they can easily do so I have around 20 printed parts in this project, and it was nice to be able to set up the system in Blender first before printing, so I had only small adjustments to make when I actually printed them out.

After assembling the system and taking pictures of frames manually, it was time to grab the bull by the horns… Arduino. I hadn’t used it before, and my experience with C was from 1989 (Arduino’s programming bears a close resemblance to C and C++).

I needed the Arduino to do this in a cycle:

1. Rotate the film gate at a constant speed
2. When the image is in place, send a command to the camera to grab a picture
3. Rotate the film takeup spool
4. When the film is too tight, stop rotating the takeup spool

Of course it had to be done in parts – first learn how to run the film gate, then consider how to trip the camera remotely, and at a very late stage, how to control the film takeup spool. The code that runs the servo at a constant speed is actually rather interesting: you send the Arduino a pulse of a certain length in microseconds, and the servo responds by rotating. A value of 1300 microseconds rotates clockwise quite fast, and 1700 runs counterclockwise. By trial and error I found that I need to send 1565 microseconds to get the servo to turn at a leisurely pace of one rotation every 2 seconds.

To actually grab an image, I needed the Arduino to send 5 volts to the camera via a USB cable I soldered together. This was a major feat of engineering for someone like me, who hasn’t soldered since  the 5th grade. After some trial and error I had a cable I could attach to the camera, and hook the other end into the Arduino, and then use this little piece of code:

void takePicture(){
 digitalWrite(cameraPin, HIGH);
 delay(400);
 digitalWrite(cameraPin, LOW);
 delay(300);
}

digitalWrite instructs the Arduino to send +5 volts to the pin named cameraPin, and hold it high for 400 milliseconds (not microseconds, note). After that it is asked to send 0 volts for 300 milliseconds, then return from the function. This worked straight out, which had me whooping with joy. Of course, this was only half of the actual action: I had to find a way to send the pulse when and only when the image is in the film gate, and it is still. With the speed I had set for the servo motor, I had about one second to shoot the picture. To do this, I bought a few microswitches, and added an appendage to the film gate.

The appendage manually presses the switch, when the film is in place. This switch then tells Arduino to take a picture, as before:

boolean frameOnGate(){
 filmgateButtonDown=digitalRead(filmgatePin);
 if(HIGH==filmgateButtonDown){
 return true;
 }
 else {
 return false;
}
}

This piece of code tells whether the film gate button is down by checking with digitalRead if the switch is closed. If it is, current flows through, and the function returns true. When the main loop hears that the film gate is ready, it shoots the pic.

All good so far, eh? In the next part, I’ll tell you about the Canon Hack Development Kit and how it features so prominently in this process.