I went to the University of Lincoln, where I did a course called Media Production. One of the things I made while I was there was a short film called Night Drive. The film follows a father who, after losing custody of his daughter, has a strop. He kidnaps her and sets both himself, his car, and his own kid alight. It’s pretty dark, and looking back at the film a few years later, the message certainly isn’t clear enough. Night Drive showed at the Aesthetica Short Film Festival, which was really flattering.
This article isn’t about the film though. Well, I guess it kind of is, it’s about one specific sequence from the film. We worked with Lincoln Fire & Rescue to set fire to the car, and part of the safety procedure involved taking out the engine. That meant that we couldn’t drive the car. We had to film a moving car scene, without the car moving.
At the time of filming, I was going through a phase where I thought green screen was shit. I’m still in that phase, now that I think about it. I was eager to find a way of creating a visual, wherein the actor (the wonderful Julian Feria) drove his car through the night, without driving, and without relying on a green screen. My solution was to take concepts from bigger budget filmmaking, and make them low budget.
Actually, before we go any further, spoiler alert. Here’s the shot I ended up building. It’s pretty dark because we were very #edgy, but you get the point.
Creating a Moving Film Set Around a Car
The year before, I had visited the BFI and attended an RTS lecture by Tim Palmer, cinematographer of Critical (2015). Palmer discussed the idea of using a projector instead of a green screen. He approached Critical by building a moving scenery around the car. Lighting set-ups surrounded the actors that imitated street lights moving overhead, while crew operated shadow puppets to replicate trees and signs passing by.
I was in awe. This was movie magic at it’s absolute best. Luckily enough, Palmer supplied the attendees with some behind the scenes photos of the light rig that was designed for Critical. The set ups were crazy impressive to me.
I checked through the clips again and again and again. In every shot, there was a lot to learn. Palmer used inventive techniques, large wooden wheels affixed with leaves. He had mirror rigs, where a crew member slowly rotated a series of mirrors around an axis, casting light over the actor’s face.
I built a budget version of the mirror rig by attaching three mirrors perpendicular to a cake spinner. They were held on with metal shelf brackets, gorilla glue, and a large amount of tape. The brackets were loose enough to allow the mirrors to be removed for transport purposes.
Using an Arduino to DIY Automated Lighting for Filmmaking
The final effect was the biggest, and the most technically impressive in my opinion. Palmer had access to a DMX console, a technical piece of equipment that allows the user to dim a series of lights. He had this set up to turn lights on and off one by one, simulating street lights overhead. We didn’t have access to a DMX console, and with our low budget, I wanted to find the cheapest possibility.
I found my answer in the Arduino platform.
If you’re not interested in computing and code, just click this handy little link and I’ll skip over this section.
Still with me? Nice! For those unfamiliar, Arduino is a small programmable microcontroller. It’s open-source, and the community has done a ton of interesting projects. Arduino has it’s own programming language, which compared to some other coding languages, is fairly simple. If you do want to buy one and complete a similar project, I suggest getting this Arduino Beginner’s Kit.
The code I wrote for my budget lighting rig has two sections. The first establishes all of the values and components. The second plays a loop that will repeat itself over and over forever. It’ll loop until either the sun burns out, or until the user turns it off, whichever comes first.
As grabbed myself an Arduino board, and did tests with smaller LEDs before I attempted anything connected to the mains. I plugged a few LED bulbs in, and programmed them to turn on one after the other. If you haven’t coded before, there’s a special kind of magic you feel when your code works for the first time. I managed to turn 3 on and off with more wiring than should have been necessary.
int yellowLED=9;
int redLED=8;
int greenLED=7;
int offTime=500;
void setup() {
pinMode(yellowLED, OUTPUT);
}
void loop() {
digitalWrite(redLED, LOW);
digitalWrite(greenLED, HIGH);
delay (offTime);
digitalWrite(greenLED, LOW);
digitalWrite(yellowLED, HIGH);
delay (offTime);
digitalWrite(yellowLED, LOW);
digitalWrite(redLED, HIGH);
delay(offTime);
}
Don’t worry, I’ll walk through the code side of things a bit further down. Now, working with LEDs is fine to test code and wiring. But tiny little LEDs are in no way strong enough to light a movie scene. I needed to connect my Arduino to a set of stronger lights. Unfortunately, I had no safe way of doing this. An Arduino is a weak little microcontroller attached to a laptop, while the lights I wanted to use are big, powerful and power intensive. Luckily enough, I found this tutorial (in Spanish) by Luis Llamas, who described the use of a relay.
A relay system acts as a programmable switch. Kind of an vague definition, so just read that sentence again. It’s like being able to programme a light switch on the wall to turn itself off or on. The relay allows the user to power electricity travelling on another circuit. In this case, I used an optocoupler-based relay. The magic behind this is based on a small LED emitter and a photodetector, that activates a switch dependent on whether the photodetector is receiving light.
The relay modules I looked at are self-contained optocouplers that allow the user to plug their 5 volt circuit in on one side, and their mains on the other. They are usually contained in a small blue box. The prongs on the right side each connect to a different pin on the Arduino. One receives power, from a 5v pin, another grounds this power, creating a functional circuit. The final one sends an analogue signal, 0 or 1, that describes whether the mains circuit should be open or closed.
On the left side are three sockets, each one allowing the user to screw a single wire in. This is where the user connects a live wire that will complete a full circuit while turned on. The important thing here is the conductive separation between the two circuits (that little LED emitter of course, does not conduct electricity).
What does that mean?
Well, the two separate circuits (one which is a minor 5 volts, safe for a computer or Arduino module to contain, while the other, the mains, has 230 volts running through) never actually touch. The relay creates a safe environment and you never risking overpowering expensive equipment.
After a little experimenting, I managed to correctly write a piece of code that would turn the relay on and off, and was pleased to hear a loud clicking noise, signifying that the switch inside was turning on and off. I connected this to an LED light circuit and amazingly got it working!
const int light1 = 12;
cont int onTime =500;
const int waitTime=3000;
void setup() {
Serial.begin(9600);
pinMode(light1, OUTPUT);
}
void loop(){
// Light 1
digitalWrite(light1, HIGH);
delay(onTime);
digitalWrite(light1, LOW);
delay(waitTime);
This meant that I was ready to attempt it with the mains power.
I managed to blow the electric at home three times.
This was due to a lack of proper understanding of how the UK power worked, mainly the earth wire. A quick note – if any of the wires, mainly the earth, touch the live wire then the plug will blow. I like to think that “oops” is the sound we make when we learn a lesson. It took me a few goes for me to learn that particular lesson. Additionally, let me make it clear. I’m not advocating that you go and stick loose wires in the wall if you don’t know what you’re doing. Please be careful here.
I bought 3 m of wire and 6 female and male plug housings from Wilkos. I wired them up, leaving 50 cm of wire for each set. My plan was to create my own Frankenstein’s extension cables, that would allow me to do all the wiring I needed without opening up and destroying the wiring in the university’s lighting equipment.
I connected the wires up and finally managed to get a desk lamp to flash on and off. I could control the pauses and rhythm of the light turning on and off in any detail up to 1ms, faster than most cameras can catch, and even the human eye in some cases.
This meant that I could start wiring up multiple lights. I bought an optocoupler with a 8 modules. This formidable looking piece of electronics would allow me to control up to 8 lights (or other electronic devices) from a single Arduino board. I tested it with two desk lamps, and my code worked! Look at the joy and this young whippersnapper’s face:
Want to see the ecstasy when something finally works for the first time and your friend (whose muffin’s were ruined because your blew the power to the oven) is very tired but it also vibing?
Coding Film Lights to Turn On and Off Independently Using Arduino
The code is fairly self-explanatory, but I’m going to run through it anyway. I’m way out of my depth here. I’m not a coder, and I certainly shouldn’t be teaching you how to code. What I’ll do is put the full code right below, then I’ll break down each section and explain what it’s doing. I’ll also link some of Arduino’s own literature, so you can peruse at your leisure.
const int light1 = 12;
const int light2 = 13;
const int light3 = 8;
const int light4 = 7;
const int light5 = 4;
const int light6 = 2;
const int timeOn = 500;
const int speedPast = 0;
const int timeBetween = 500;
void setup() {
Serial.begin(9600);
pinMode(light1, OUTPUT);
pinMode(light2, OUTPUT);
pinMode(light3, OUTPUT);
pinMode(light4, OUTPUT);
pinMode(light5, OUTPUT);
pinMode(light6, OUTPUT);
}
void loop() {
digitalWrite(light1, HIGH);
delay(timeOn);
digitalWrite(light2, HIGH);
delay(timeOn);
digitalWrite(light1, LOW);
delay(speedPast);
digitalWrite(light3, HIGH);
delay(timeOn);
digitalWrite(light2, LOW);
delay(speedPast);
digitalWrite(light4, HIGH);
delay(timeOn);
digitalWrite(light3, LOW);
delay(speedPast);
digitalWrite(light5, HIGH);
delay(timeOn);
digitalWrite(light4, LOW);
delay(speedPast);
digitalWrite(light6, HIGH);
delay(timeOn);
digitalWrite(light5, LOW);
delay(speedPast);
digitalWrite(light6, LOW);
delay(speedPast);
delay(timeBetween);
}
Now, if you code for a living and you look at the code above and think to yourself “Hey this is dogshit code! He should have used loops!”. I need you to understand that you’re entirely correct and I want to screenshot a point I made earlier:
I was doing a media production degree, don’t expect too much.
The setup void introduces consistent data into the Arduino, values and commands that will always stay the same. In this case Serial.begin(9600) sets a standard bitrate of 9600 bit/s that will allow the Arduino to communicate with the laptop it is connected to. This is necessary in every code.
Next, pinMode(n,OUTPUT); tells the Arduino what certain pins are going to be doing, inputting data, or outputting. Since we are setting 0s or 1s, we’ll be outputting. in the loop void, the part of the code that repeats itself indefinitely, we have a piece of code called digitalWrite(n,HIGH/LOW); which will send a 1 for HIGH or 0 for LOW out of a specified (n) pin. Finally, we have delay(500); measured in milliseconds, meaning that there is a half a second pause in between the light turning on and off.
You may notice that there’s this odd back and forth between lights in each loop. Originally the code just turned the light on and off, then moved to the next light. The lights flashing one after the other only seemed like strobe lights in a music video or club – not what I was looking for. I reordered the digitalwrite(n,LOW); commands to allow a light to stay on until the next light had already turned itself on. This created a slightly slower but much more fluid transition between the different lights.
I also applied names to all the constant integrals, all of the pin numbers, the time they would be HIGH (timeOn), the delay in between each light (speedPast) for debugging purposes, and the time in between each light animation, (timeBetween), each of which I could adjust to suit how fast I wanted the light source to travel overhead.
After that, I had the wiring, which I found a pain to do. I had clumsy sausage hands. I grabbed 6 Sachtler film lights and hid away in a room for a few hours with a small nest of cables. I’d connected 5 out of 6 lights up, and tested them a few times, being fairly happy with the result. My wiring plan can be seen in the following drawing:
Want to see what that looks like, but instead of a drawing it’s a fire hazard?
Filming The Driving Scene In a “Studio” Environment (a garage)
So, on the day of filming we got everybody set up and moved to Lincoln Fire & Rescue’s training ground. I cannot speak highly enough of the team and of how helpful they were. They ensured that the entire burning process was safe, and were on hand for any problems we had. If you do plan to set fire to anything for your film, please do approach the right people to help you out.
We set the “studio” up, which was a large garage that the fire engines usually live in.
First, a large white sheet acted as a backdrop. You know my feelings on green screen, we were going to do this the old-fashioned way. I don’t need to go into detail here, it was held up with C-stands, your sparky or grip will be able to sort this.
And hey, if you’re curious as to what video we actually projected on the screen, it was literally filmed out of the back of a car. I stuck a GoPro up to the window, we had a drive around the outskirts of the city centre. The footage didn’t look good, but it was such a small and minor feature that it didn’t matter too much.
Next, I hooked up all the wiring. By this point I was pretty confident that it would work, but lemme tell you, I felt so damn relieved when it worked on the day.
We also had that little mirror contraption I mentioned earlier, and a few more lights to get the right look. I can’t properly remember the full set up, as this was 5 years ago. I believe we had a Satchler light behind the car to act as headlights behind the actor. We additionally had a small cheap fill light on the left side of the shot to fill his face in with some warm orange colour.
Finally, we got the projector set up, plugged into my laptop running the footage. It rested just on top of the car. Admittedly the projector was a little too dim. It wasn’t an expensive one, I don’t even recall the model, and I’m sure there’s better alternatives on the market at the moment. We gave it a quick test and were pretty chuffed with how it was looking.
And we were nearly ready to shoot! We had a few problems with the lights where we needed to reveal a pink blanket in the back seats. The simple fix was staggering the lights out and spreading them apart a little. Nothing groundbreaking!
Also, check out these brooding sexy shots of yours truly, back when he didn’t have a beard or a dress sense.
I’m pretty happy with the end result. There’s definitely a lot more that could have been done to improve this, but on such a tiny budget, the result were extremely well-received. There’s new technology out there, Virtual Sets, that are absolutely incredible. Plenty of different versions of this, but in 2017, and certainly now in 2022, these aren’t accessible to the low budget film market.
Oh and hey, I mentioned that we set a car on fire. Wanna see how it looked? Of course, you do. You love fire.
Darn rootin’ tootin’ cool is how it looked. It was like a bonfire, but more exciting. Despite having the fire brigade at hand, we felt like we were breaking the rules. Hell, I even got a new profile picture taken while I was there.
And of course, the next day, the state of the car meant that reshoots were out of the question.
Just before wrapping up, I’d like to say thanks to Mikey Murray, and Jack Shelbourn, both who were a tremendous help during the process of this film. Nice work, gents.
If you’ve got absolutely any questions about this process, or need advice, please get in touch. My details are in the footer. I’ve helped a few people out with similar shoots since then, and they never stop feeling rewarding. I also welcome those from the Arduino community to find a more efficient solution to the code. I’ll add any comments you make to the end of this article. You can also take a look at some of my other film work. love you xoxoxo