- Use an Arduino Nano
- Control 5 LEDs
- Each LED should be controllable using just one switch on a remote control
- Flipping the switch X times will toggle LED X
So after a bit of programming and testing this is what I came up with:
Here's the breadboard layout (doesn't match the one from the movie exactly, but you get the idea)
And the schematics:
And of course, the code!
Let's cover the reading of the switch on the remote first. By connecting the signal wire (usually the white one) from the receiver to pin 9 on the Arduino we can read the state of the switch. There will be a pulse coming from the receiver about 50 times per second. This pulse will be between 1000 and 2000 microseconds in length depending on the position of the switch. We can assume that anything above 1500 is the up position, and below 1500 the down position. So it's simply a matter of detecting the pulse and measuring its length. Normally I'd use interrupts to handle this, but I wanted to keep this one simple so I used the pulseIn() function instead.
Let's define a few variables first:
1: uint8_t cfg_inputPin;
2: bool loop_lastSwitchPosition;
3: uint8_t loop_switchCount;
4: unsigned long loop_lastSwitchTime;
Now for the setup:
1: void setup()
2: {
3: cfg_inputPin = 9;
4:
5: loop_lastSwitchPosition = pulseIn(cfg_inputPin, HIGH) > 1500;
6: }
First we set the input pin. Pins are already in INPUT mode initially so no need to set that here. Furthermore we initialize the loop variable here with some default value.
1: void loop()
2: {
3: unsigned long duration = pulseIn(cfg_inputPin, HIGH);
4: while ( duration == 0 )
5: {
6: duration = pulseIn(cfg_inputPin, HIGH);
7: }
8:
9: bool newSwitchPosition = duration > 1500;
10: if ( newSwitchPosition != loop_lastSwitchPosition )
11: {
12: loop_lastSwitchPosition = newSwitchPosition;
13: if ( newSwitchPosition )
14: {
15: ++loop_switchCount;
16: loop_lastSwitchTime = millis();
17: }
18: }
19: else
20: {
21: if ( loop_lastSwitchTime != 0 && millis() - loop_lastSwitchTime > 1000 )
22: {
23: uint8_t channel = loop_switchCount - 1;
24: if ( channel < CHANNELS )
25: {
26: // do something
27: }
28: loop_switchCount = 0;
29: loop_lastSwitchTime = 0;
30: }
31: }
32: }
In lines 3-7 we wait for a valid pulse.
Line 9 converts the pulse duration to a switch position.
Line 10 checks if there's a change in switch position since the last loop. If so, we update the stored switch position on line 12.
Lines 13-17 handle the transition of the switch from down to up. If that happens we increment the switch counter and update the "last switch" timestamp.
The rest of the lines handle the situation where the switch did not change.
Line 21 checks if there was a switch change in one of the previous loops (loop_lastSwitchTime != 0) and if more than a second has passed since. So this expression will evaluate to true when you've flipped the switch up a second ago. That basically means you've stopped flipping the switch.
Lines 23 to 29 convert the switch counter to a channel index, check if that's not out of bounds (flipped the switch more than there are channels to control) and line 26 is where you put your actual code. The remaining two lines reset the loop variables.
Let's add some LEDs!
1: #define CHANNELS 5
2: uint8_t cfg_pins[CHANNELS];
3: bool state_switch[CHANNELS];
4:
5: void setChannelPin(uint8_t p_channel, uint8_t p_pin)
6: {
7: digitalWrite(p_pin, LOW);
8: pinMode(p_pin, OUTPUT);
9: cfg_pins[p_channel] = p_pin;
10: }
11:
12: void setChannelSwitch(uint8_t p_channel, bool p_on)
13: {
14: state_switch[p_channel] = p_on;
15: if ( p_on == false )
16: {
17: digitalWrite(cfg_pins[p_channel], LOW);
18: }
19: else
20: {
21: digitalWrite(cfg_pins[p_channel], HIGH);
22: }
23: }
24:
25:
26: void toggleChannelSwitch(uint8_t p_channel)
27: {
28: setChannelSwitch(p_channel, !state_switch[p_channel]);
29: }
30:
Now we need to update our setup function and add a few lines:
1: setChannelPin(0, 4);
2: setChannelPin(1, 5);
3: setChannelPin(2, 6);
4: setChannelPin(3, 7);
5: setChannelPin(4, 8);
In our loop function we need to replace the "// do something " comment with
1: toggleChannelSwitch( channel );
Tadaaah! We can now turn channels on and off with the switch on the remote.
Hmm, that's a bit boring though... Let's add some blinking and flashing! For this we need some sort of update function that updates all the "animations". We need to keep track of time as well. The easiest way to handle this is by giving the update function a parameter that holds the number of milliseconds passed since the last update.
1: unsigned long loop_lastMillis;
2:
3: void setup()
4: {
5: // previous code here
6: loop_lastMillis = millis();
7: }
8:
9: void loop()
10: {
11: // previous code here
12:
13: unsigned long now = millis();
14: uint16_t deltaMillis = now - loop_lastMillis);
15: loop_lastMillis = now;
16:
17: if ( deltaMillis > 0 )
18: {
19: update( deltaMillis );
20: }
21: }
22:
23: void update(uint16_t p_delta)
24: {
25: // animation code here
26: }
For the animations I want to be able to specify how often an LED should blink, how long it should blink, how much time should be between blinks and how much time should be between the last blink in a sequence and the first one of the next sequence. I want to be able to create a strobe that flashes two times rapidly and then waits for a second or so, but I also want to be able to have a LED that blinks at a constant rate. And of course, I want some LEDs to be on all of the time.
We'll need a few more variables...
1: uint8_t cfg_blinks[CHANNELS];
2: uint16_t cfg_onDuration[CHANNELS];
3: uint16_t cfg_offDuration[CHANNELS];
4: uint16_t cfg_pauseDuration[CHANNELS];
5:
6: bool state_onOff[CHANNELS];
7: uint8_t state_currentBlink[CHANNELS];
8: uint16_t state_nextChange[CHANNELS];
Then we have our variable to hold the state of the channels while the animation is running. We need to know whether it's currently on or off, which blink we're at and how many milliseconds remain until the next state change.
We'll want some convenience functions to configure the channels:
1: void configureChannelBlink(uint8_t p_channel, uint8_t p_blinks, uint16_t p_onDuration, uint16_t p_offDuration, uint16_t p_pauseDuration)
2: {
3: cfg_blinks[p_channel] = p_blinks;
4: cfg_onDuration[p_channel] = p_onDuration;
5: cfg_offDuration[p_channel] = p_offDuration;
6: cfg_pauseDuration[p_channel] = p_pauseDuration;
7: setChannelSwitch(p_channel, true);
8: }
9:
10:
11: void configureChannelConstant(uint8_t p_channel)
12: {
13: cfg_blinks[p_channel] = 0;
14: setChannelSwitch(p_channel, true);
15: }
1: configureChannelConstant(0);
2: configureChannelConstant(1);
3: configureChannelConstant(2);
4:
5: configureChannelBlink(3, 1, 50, 0, 950);
6: configureChannelBlink(4, 2, 50, 50, 1850);
We need to update our setChannelSwitch function so it will reset the animation when the channel is turned on:
1: void setChannelSwitch(uint8_t p_channel, bool p_on)
2: {
3: state_switch[p_channel] = p_on;
4: if ( p_on == false )
5: {
6: digitalWrite(cfg_pins[p_channel], LOW);
7: }
8: else
9: {
10: state_onOff[p_channel] = true;
11: state_currentBlink[p_channel] = 0;
12: state_nextChange[p_channel] = cfg_onDuration[p_channel];
13: digitalWrite(cfg_pins[p_channel], HIGH);
14: }
15: }
And lastly, our blinky code:
1: void update(uint16_t p_delta)
2: {
3: for ( uint8_t channel = 0; channel < CHANNELS; ++channel )
4: {
5: if ( cfg_blinks[channel] == 0 )
6: {
7: continue;
8: }
9: if ( state_switch[channel] == false )
10: {
11: continue;
12: }
13:
14: if ( p_delta >= state_nextChange[channel] )
15: {
16: state_onOff[channel] = ! state_onOff[channel];
17:
18: if ( state_onOff[channel] )
19: {
20: state_nextChange[channel] = cfg_onDuration[channel];
21: digitalWrite(cfg_pins[channel], HIGH);
22: }
23: else
24: {
25: state_currentBlink[channel]++;
26: if ( state_currentBlink[channel] == cfg_blinks[channel] )
27: {
28: state_nextChange[channel] = cfg_pauseDuration[channel];
29: state_currentBlink[channel] = 0;
30: }
31: else
32: {
33: state_nextChange[channel] = cfg_offDuration[channel];
34: }
35: digitalWrite(cfg_pins[channel], LOW);
36: }
37: }
38: else
39: {
40: state_nextChange[channel] = state_nextChange[channel] - p_delta;
41: }
42: }
43: }
Lines 9-12 test if the channel is switched off, if so we can again skip this channel.
Line 14 checks whether it's time to toggle the channel.
Line 15 toggles the state of the channel; from on to off and vice versa.
Lines 18-22 turn the LED on and update the "next change" counter.
Lines 23-37 turn the LED off, increment the blink counter and check if this was the last blink. If so then we use the pauseDuration, else we use the offDuration. Don't forget to reset the blink counter ( line 29).
Lines 38-41 handle the situation where a channel does not need to change state yet, all we need to do is decrement the amount of time remaining until the next state change.
That's all there's to it.
Here's the final complete code for your convenience:
1: // NavLights.ino
2: // Arduino based remote controlled navigation lights
3: //
4: // By Daniel van den Ouden, 2014
5: //
6:
7: // configuration for input
8: uint8_t cfg_inputPin;
9:
10: // 5 output channels
11: #define CHANNELS 5
12:
13: uint8_t cfg_blinks[CHANNELS]; // how often a channel will blink in a sequence, 8 bit, so value is 0 - 255, 0 means no blinking
14: uint16_t cfg_onDuration[CHANNELS]; // how long the channel will be on in milliseconds, 16 bit, so value is 0 - 65535
15: uint16_t cfg_offDuration[CHANNELS]; // how long the channel will be off between blinks in milliseconds, 16 bit
16: uint16_t cfg_pauseDuration[CHANNELS]; // how long the channel will be off between the last and first blink of a sequence, 16 bit
17: uint8_t cfg_pins[CHANNELS]; // which pin to use for which channel
18:
19: bool state_switch[CHANNELS]; // state of the channel's "switch" (true = on, false = off)
20: bool state_onOff[CHANNELS]; // the output state of the channel (true = high, false = low)
21: uint8_t state_currentBlink[CHANNELS]; // how often this channel has blinked in the current sequence
22: uint16_t state_nextChange[CHANNELS]; // number of milliseconds until next change
23:
24: unsigned long loop_lastMillis; // time of last update
25: bool loop_lastSwitchPosition; // last measured switch position
26: uint8_t loop_switchCount; // number of switches in current sequence
27: unsigned long loop_lastSwitchTime; // time at which the switch was flipped last
28:
29: void setChannelPin(uint8_t p_channel, uint8_t p_pin)
30: {
31: digitalWrite(p_pin, LOW);
32: pinMode(p_pin, OUTPUT);
33: cfg_pins[p_channel] = p_pin;
34: }
35:
36:
37: void configureChannelBlink(uint8_t p_channel, uint8_t p_blinks, uint16_t p_onDuration, uint16_t p_offDuration, uint16_t p_pauseDuration)
38: {
39: cfg_blinks[p_channel] = p_blinks;
40: cfg_onDuration[p_channel] = p_onDuration;
41: cfg_offDuration[p_channel] = p_offDuration;
42: cfg_pauseDuration[p_channel] = p_pauseDuration;
43: setChannelSwitch(p_channel, true);
44: }
45:
46:
47: void configureChannelConstant(uint8_t p_channel)
48: {
49: cfg_blinks[p_channel] = 0;
50: setChannelSwitch(p_channel, true);
51: }
52:
53:
54: void setup()
55: {
56: cfg_inputPin = 9;
57:
58: setChannelPin(0, 4);
59: setChannelPin(1, 5);
60: setChannelPin(2, 6);
61: setChannelPin(3, 7);
62: setChannelPin(4, 8);
63:
64: configureChannelConstant(0);
65: configureChannelConstant(1);
66: configureChannelConstant(2);
67:
68: configureChannelBlink(3, 1, 50, 0, 950);
69: configureChannelBlink(4, 2, 50, 50, 1850);
70:
71: loop_lastMillis = millis();
72: loop_lastSwitchPosition = pulseIn(cfg_inputPin, HIGH) > 1500;
73: }
74:
75:
76: void loop()
77: {
78: unsigned long duration = pulseIn(cfg_inputPin, HIGH);
79: while ( duration == 0 )
80: {
81: duration = pulseIn(cfg_inputPin, HIGH);
82: }
83:
84: bool newSwitchPosition = duration > 1500;
85: if ( newSwitchPosition != loop_lastSwitchPosition )
86: {
87: loop_lastSwitchPosition = newSwitchPosition;
88: if ( newSwitchPosition )
89: {
90: ++loop_switchCount;
91: loop_lastSwitchTime = millis();
92: }
93: }
94: else
95: {
96: if ( loop_lastSwitchTime != 0 && millis() - loop_lastSwitchTime > 1000 )
97: {
98: uint8_t channel = loop_switchCount - 1;
99: if ( channel < CHANNELS )
100: {
101: toggleChannelSwitch( channel );
102: }
103: loop_switchCount = 0;
104: loop_lastSwitchTime = 0;
105: }
106: }
107:
108: unsigned long now = millis();
109: uint16_t deltaMillis = now - loop_lastMillis;
110: loop_lastMillis = now;
111:
112: if ( deltaMillis > 0 )
113: {
114: update( deltaMillis );
115: }
116: }
117:
118:
119: void update(uint16_t p_delta)
120: {
121: for ( uint8_t channel = 0; channel < CHANNELS; ++channel )
122: {
123: if ( cfg_blinks[channel] == 0 )
124: {
125: continue;
126: }
127: if ( state_switch[channel] == false )
128: {
129: continue;
130: }
131:
132: if ( p_delta >= state_nextChange[channel] )
133: {
134: state_onOff[channel] = ! state_onOff[channel];
135:
136: if ( state_onOff[channel] )
137: {
138: state_nextChange[channel] = cfg_onDuration[channel];
139: digitalWrite(cfg_pins[channel], HIGH);
140: }
141: else
142: {
143: state_currentBlink[channel]++;
144: if ( state_currentBlink[channel] == cfg_blinks[channel] )
145: {
146: state_nextChange[channel] = cfg_pauseDuration[channel];
147: state_currentBlink[channel] = 0;
148: }
149: else
150: {
151: state_nextChange[channel] = cfg_offDuration[channel];
152: }
153: digitalWrite(cfg_pins[channel], LOW);
154: }
155: }
156: else
157: {
158: state_nextChange[channel] = state_nextChange[channel] - p_delta;
159: }
160: }
161: }
162:
163:
164: void setChannelSwitch(uint8_t p_channel, bool p_on)
165: {
166: state_switch[p_channel] = p_on;
167: if ( p_on == false )
168: {
169: digitalWrite(cfg_pins[p_channel], LOW);
170: }
171: else
172: {
173: state_onOff[p_channel] = true;
174: state_currentBlink[p_channel] = 0;
175: state_nextChange[p_channel] = cfg_onDuration[p_channel];
176: digitalWrite(cfg_pins[p_channel], HIGH);
177: }
178: }
179:
180:
181: void toggleChannelSwitch(uint8_t p_channel)
182: {
183: setChannelSwitch(p_channel, !state_switch[p_channel]);
184: }
185:
186:
