We use Ohm’s Law to calculate current limiting resistor values:

Forward voltage ratings:

RED: 2.1V
GREEN: 3.3V
BLUE: 3.3V

Current:

I = 20mA

Supply voltage:

V = 5V

Ohm’s Law:

I = V/R => R = V/I

So for Red:

(5 – 2.1)/0.02 => R = 145 Ohm

For Green/Blue:

(5 – 3.3)/0.02 => R = 85 Ohm

As for the Arduino sketch, I chose to have the lamp fade between two colors, aqua (#00FFFF) and magenta (#FF00FF). For that I kept the Blue value at 255 and varied the Green and Red values between 0-255 to achieve the desired colors, as shown in the diagram:
(You can pick your favorite colors, cycle through the entire spectrum, or go psychedelic and show random colors with random delays)

// fade from aqua to magenta
for (int i = 0; i < 256; i++) {
  analogWrite(RED, i);
  analogWrite(GREEN, 255-i);
  analogWrite(BLUE, 255);
  delay(50);
}

// fade from magenta to aqua
for (int i = 0; i < 256; i++) {
  analogWrite(RED, 255-i);
  analogWrite(GREEN, i);
  analogWrite(BLUE, 255);
  delay(50);
}

You might also enjoy:

1. Arduino RGB LED Spinning Night Light
2. Arduino RGB LED Spinning Night Light: Assembly
3. Arduino Motor Control for the Spinning Night Light

The basic problem with this circuit is that the direction of the motor cannot be reversed. For our simple application in this RGB LED night light, spinning the motor in one direction is enough. In the future we will use motors in applications which require us to reverse the direction as well, and for that we will be using the type of motor control circuit called H-bridge circuit.

Note that a diode has been used in this circuit. The core of all types of motors is the inductor (or coil). When the amount of current (which can be moderate to high) passing through the inductor is changed, it produces large voltage spikes (“kickback” ) .

The diode used in motor control circuits is called a kickback diode and its purpose is to absorb the voltage that is produced when the transistor is turned on and off. When you are developing motor control applications using a bipolar transistor you should always put in the kickback diode in order to protect the other parts of your circuit.

You might also enjoy:

1. Basic Hobby Electronics Vocabulary Part 2 of 4 (D-G)
2. Arduino RGB LED Spinning Night Light: Assembly
3. Arduino RGB LED Spinning Night Light
4. Arduino RGB LED Control for the Spinning Night Light

Solder wires to motor terminals and cover with heat-shrink tubing

Check the previous post if you need to see the sketch for the Arduino RGB LED night light again.

You might also enjoy:

1. Arduino RGB LED Spinning Night Light
2. Arduino Motor Control for the Spinning Night Light
3. Arduino RGB LED Control for the Spinning Night Light

The initial idea was to recycle empty toilet paper tubes to serve as the lampshade, but it turns out the project looks much more attractive and colorful using white paper. (I haven’t given up on the idea of finding a use for the empty tubes, though. Suggestions are welcome.)

A simple DC motor is used to spin the lamp structure, and a jar lid serves as the base. There is (a lot of) room for improvement in the design of the lamp, but I’m a computer scientist and wanna-be crafter at best.

I intend to revisit these projects in the future, and make them stand alone using smaller Arduino boards and sporting a nicer finish (something worthy of showing guests). For now the purpose of these projects is solely educational (in a microcontroller programming way, not hand crafting).

In the upcoming posts we will explore the assembly of the night light, as well as the circuit and Arduino sketch that make the project work.

Parts list:

• Arduino Duemilanove
• Mini Breadboard
• DC Motor
• RGB LED
• 1N914 Diode
• 2N3904 Transistor
• 100 Ohm Resistor
• 147 Ohm Resistor
• 82 Ohm Resistor
• Soldering iron
• Solder
• Heat-shrink tubing
• Jumper Wires of assorted lengths
• White paper
• Jar lid
• Mounting tape

I have recorded a short video of the Arduino RGB LED Spinning Night Light in action.

And here is the Arduino sketch:

// www.TheElectronicsHobbyist.com/blog
// Natalia Fargasch Norman
// RGB LED night light using Arduino

// Arduino pins used for motor and LEDs
#define MOTOR 3
#define RED 9
#define GREEN 10
#define BLUE 11

// pins for motor and LEDs are outputs
void setup() {
  pinMode(MOTOR, OUTPUT);
  pinMode(RED, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(BLUE, OUTPUT);
}

void loop() {
  // set motor speed, between 0 and 255
  analogWrite(MOTOR, 69);

  // fade from aqua to magenta
  for (int i = 0; i < 256; i++) {
    analogWrite(RED, i);
    analogWrite(GREEN, 255-i);
    analogWrite(BLUE, 255);
    delay(50);
  }

  // fade from magenta to aqua
  for (int i = 0; i < 256; i++) {
    analogWrite(RED, 255-i);
    analogWrite(GREEN, i);
    analogWrite(BLUE, 255);
    delay(50);
  }

}

You might also enjoy:

1. Arduino RGB LED Control for the Spinning Night Light
2. Arduino RGB LED Spinning Night Light: Assembly
3. Controlling a Seven-Segment Display Using Arduino Part 4
4. Controlling a Seven-Segment Display Using Arduino Part 3

There are just a couple of snippets that I would like to comment on:

The first part of the loop() function checks whether either button has been pressed and increments the value of each digit.

  // check button1
  int val1 = digitalRead(BTN1);
  if (val1 == HIGH) {
    digit1++;
    digit1 %= 10;
    delay(10);
  }

  // check button2
  int val2 = digitalRead(BTN2);
  if (val2 == HIGH) {
    digit2++;
    digit2 %= 10;
    delay(10);
  }

The line

    digit1 %= 10;

which is shorthand for

    digit1 = digit1 % 10;

accomplishes the same as the line

    if (count == 10) count = 0;

that was used on the sketch for the single-digit 7-segment project a couple of months ago. It updates digit1 with the remainder of the division of itself by 10, which will be zero when digit1 is 10. The latter code looks a bit more obvious for beginner programmers.

The last part of the loop() function refreshes the display, and is very similar to the sketch for the 2-digit 7-segment display counter.

  // display number
  unsigned long startTime = millis();
  for (unsigned long elapsed=0; elapsed < 600; elapsed = millis() - startTime) {
    lightDigit1(numbers[digit1]);
    delay(5);
    lightDigit2(numbers[digit2]);
    delay(5);
  }

You might also enjoy:

1. Arduino 2-Digit 7-Segment Display with Buttons
2. Arduino 2-Digit 7-Segment Display Counter: Sketch
3. Arduino 2-Digit 7-Segment Display Counter
4. Controlling a Seven-Segment Display Using Arduino Part 4

Here’s what the setup looks like:

And here’s the complete sketch:

// www.TheElectronicsHobbyist.com/blog
// Natalia Fargasch Norman
// Dual seven-segment LED Display with buttons
// Common Anode digit 1 pin 10
// Common Anode digit 2 pin 5

//       CA1 G  F  A  B
//        |  |  |  |  |      -> pins and segments they control
//   ---------    ---------
//   |   A   |    |   A   |
//  F|       |B  F|       |B
//   |---G---|    |---G---|
//  E|       |C  E|       |C
//   |   D   |    |   D   |
//   ---------    ---------
//        |  |  |  |  |      -> pins and segments they control
//        D  DP E  C CA2         

// Segments that make each number when lit:
// 0 => -FEDCBA
// 1 => ----BC-
// 2 => G-ED-BA
// 3 => G--DCBA
// 4 => GF--CB-
// 5 => GF-DC-A
// 6 => GFEDC-A
// 7 => ----CBA
// 8 => GFEDCBA
// 9 => GF-DCBA

// Arduino digital pins used to light up
// corresponding segments on the LED display
#define A 3
#define B 2
#define C 6
#define D 8
#define E 7
#define F 4
#define G 5

// Pushbuttons connected to pins 9 and 10
#define BTN1 9
#define BTN2 10

// Pins driving common anodes
#define CA1 13
#define CA2 12

// Pins for A B C D E F G, in sequence
const int segs[7] = { 3, 2, 6, 8, 7, 4, 5 };

// Segments that make each number
const byte numbers[10] = { 0b1000000, 0b1111001, 0b0100100, 0b0110000, 0b0011001, 0b0010010,
0b0000010, 0b1111000, 0b0000000, 0b0010000 };

int digit1 = 0;
int digit2 = 0;

void setup() {
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(BTN1, INPUT);
  pinMode(BTN2, INPUT);
  pinMode(CA1, OUTPUT);
  pinMode(CA2, OUTPUT);
}

void loop() {

  // check button1
  int val1 = digitalRead(BTN1);
  if (val1 == HIGH) {
    digit1++;
    digit1 %= 10;
    delay(10);
  }

  // check button2
  int val2 = digitalRead(BTN2);
  if (val2 == HIGH) {
    digit2++;
    digit2 %= 10;
    delay(10);
  }

  // display number
  unsigned long startTime = millis();
  for (unsigned long elapsed=0; elapsed < 600; elapsed = millis() - startTime) {
    lightDigit1(numbers[digit1]);
    delay(5);
    lightDigit2(numbers[digit2]);
    delay(5);
  }
}

void lightDigit1(byte number) {
  digitalWrite(CA1, LOW);
  digitalWrite(CA2, HIGH);
  lightSegments(number);
}

void lightDigit2(byte number) {
  digitalWrite(CA1, HIGH);
  digitalWrite(CA2, LOW);
  lightSegments(number);
}

void lightSegments(byte number) {
  for (int i = 0; i < 7; i++) {
    int bit = bitRead(number, i);
    digitalWrite(segs[i], bit);
  }
}

Here’s a video of the Arduino 2-digit 7-segment display counter with buttons in action.

You might also enjoy:

1. Arduino 2-Digit 7-Segment Display Counter
2. Controlling a Seven-Segment Display Using Arduino Part 4
3. Arduino 2-Digit 7-Segment Display Counter: Sketch
4. Controlling a Seven-Segment Display Using Arduino Part 3

So now on the the meatier sections of the sketch for this project:

Common anode displays are not immediately obvious as a segment is lit when the corresponding pin is made LOW. You might be surprised, though, that common anode displays are most often used because they can be used with 74xx series logic data-selector chips and PNP bipolar transistors.

// Segments that make each number when lit:
// 0 => -FEDCBA
// 1 => ----BC-
// 2 => G-ED-BA
// 3 => G--DCBA
// 4 => GF--CB-
// 5 => GF-DC-A
// 6 => GFEDC-A
// 7 => ----CBA
// 8 => GFEDCBA
// 9 => GF-DCBA

Remember, the Arduino pins are connected to the display’s cathodes. To light a segment we make the corresponding pin LOW.

We use 0s where the segments need to be lit up. The digit ‘zero’, for instance, is not the intuitive 0b0111111, but the less obvious 0b1000000.

// Segments that make each number
const byte numbers[10] = { 0b1000000, 0b1111001, 0b0100100, 0b0110000, 0b0011001, 0b0010010,
0b0000010, 0b1111000, 0b0000000, 0b0010000 };

To give the impression that both displays are active at the same time and avoid flickering we cycle through the digits in quick succession and keep each of them lit for 5ms. This is implemented by adding a short delay after displaying each digit. Since numbers stay lit for 600 ms, the whole process is repeated 60 times for each number displayed, and thanks to Persistence of Vision (POV) we have the impressios that both digits are actually lit up at the same time. (Even though they are not).

The loop below is where the action takes place in our sketch: we cycle through both digits keeping each on for 5ms at a time for the 600ms during which we display each complete number.

void loop() {
  for (int digit1=0; digit1 < 10; digit1++) {
    for (int digit2=0; digit2 < 10; digit2++) {
      unsigned long startTime = millis();
      for (unsigned long elapsed=0; elapsed < 600; elapsed = millis() - startTime) {
        lightDigit1(numbers[digit1]);
        delay(5);
        lightDigit2(numbers[digit2]);
        delay(5);
      }
    }
  }
}

The lightDigit function for digit 1 enables only the transistor for the common anode pin of the tens digit:

void lightDigit1(byte number) {
  digitalWrite(CA1, LOW);
  digitalWrite(CA2, HIGH);
  lightSegments(number);
}

The lightDigit function for digit 2 enables only the transistor for the common anode pin of the units digit:

void lightDigit2(byte number) {
  digitalWrite(CA1, HIGH);
  digitalWrite(CA2, LOW);
  lightSegments(number);
}

Function lightSegments was reused from the single-digit 7-segment sketch:

void lightSegments(byte number) {
  for (int i = 0; i < 7; i++) {
    int bit = bitRead(number, i);
    digitalWrite(segs[i], bit);
  }
}

Next week we will modify our project to use buttons to control each digit, and as such we’ll avoid having to cycle through several numbers in order to achieve the desired number being displayed (if that number is significantly greater than the current number being displayed).

You might also enjoy:

1. Arduino 2-Digit 7-Segment Display with Buttons
2. Arduino 2-Digit 7-Segment Display Counter
3. Arduino 2-Digit 7-Segment Display with Buttons: Sketch
4. Controlling a Seven-Segment Display Using Arduino Part 4

There are a few options to control multiple displays:

• employing multiple controllers;
• using a 7-segment driver chip like the 7447;
• using a multi-display controller such as the MAXIM MAX7219;
• sequencing through the displays, which is what we have done in our example, as it requires no added hardware.

When we were using a single-digit display, we connected the common anode pin to our Vdd supply, but with two digits we have to drive them independently if we want them to display different digits!

A natural reaction would be to try to use two Arduino I/O pins, each driving a digit of the display. The problem with this scenario is that it is not possible to drive the common anode or cathode pin using Arduino I/O pins, as they cannot source or sink enough current to light all seven segments.

The solution is then to use bipolar junction transistors (NPN for common cathode and PNP for common anode displays) in order to sink or drive the required current. The controlling interface outputs the value for a specific display by enabling only its common pin transistor, and the digit driven by that common pin becomes active.

To give the impression that both displays are active at the same time and avoid flickering we cycle through the digits in quick succession and keep each of them lit for 5ms. We will see how that was implemented when we go over the sketch next week.

Here is the schematic for the circuit (click for larger image):

You might also enjoy:

1. Arduino 2-Digit 7-Segment Display Counter: Sketch
2. Controlling a Seven-Segment Display Using Arduino Part 1
3. Arduino 2-Digit 7-Segment Display Counter
4. Arduino 2-Digit 7-Segment Display with Buttons

Materials:

• Arduino Duemilanove
• 1 2-digit 7-segment display (I got a 50-piece LED display grab bag for better value; the one I used was configured as shown)
• 2 Mini push button switches
• 9 Resistors, 100 Ohm
• 2 Resistors, 10K Ohm



• 2 2N3906 transistors (PNP)
• 1 Solderless breadboard
• Jumper Wires in assorted lengths

Sketch for counting up without buttons:

// www.TheElectronicsHobbyist.com/blog
// Natalia Fargasch Norman
// Dual seven-segment LED Display
// Common Anode digit 1 pin 10
// Common Anode digit 2 pin 5

//       CA1 G  F  A  B
//        |  |  |  |  |      -> pins and segments they control
//   ---------    ---------
//   |   A   |    |   A   |
//  F|       |B  F|       |B
//   |---G---|    |---G---|
//  E|       |C  E|       |C
//   |   D   |    |   D   |
//   ---------    ---------
//        |  |  |  |  |      -> pins and segments they control
//        D  DP E  C CA2         

// Segments that make each number when lit:
// 0 => -FEDCBA
// 1 => ----BC-
// 2 => G-ED-BA
// 3 => G--DCBA
// 4 => GF--CB-
// 5 => GF-DC-A
// 6 => GFEDC-A
// 7 => ----CBA
// 8 => GFEDCBA
// 9 => GF-DCBA

// Arduino digital pins used to light up
// corresponding segments on the LED display
#define A 3
#define B 2
#define C 6
#define D 8
#define E 7
#define F 4
#define G 5

// Pins driving common anodes
#define CA1 13
#define CA2 12

// Pins for A B C D E F G, in sequence
const int segs[7] = { 3, 2, 6, 8, 7, 4, 5 };

// Segments that make each number
const byte numbers[10] = { 0b1000000, 0b1111001, 0b0100100, 0b0110000, 0b0011001, 0b0010010,
0b0000010, 0b1111000, 0b0000000, 0b0010000 };

void setup() {
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(CA1, OUTPUT);
  pinMode(CA2, OUTPUT);
}

void loop() {
  for (int digit1=0; digit1 < 10; digit1++) {
    for (int digit2=0; digit2 < 10; digit2++) {
      unsigned long startTime = millis();
      for (unsigned long elapsed=0; elapsed < 600; elapsed = millis() - startTime) {
        lightDigit1(numbers[digit1]);
        delay(5);
        lightDigit2(numbers[digit2]);
        delay(5);
      }
    }
  }
}

void lightDigit1(byte number) {
  digitalWrite(CA1, LOW);
  digitalWrite(CA2, HIGH);
  lightSegments(number);
}

void lightDigit2(byte number) {
  digitalWrite(CA1, HIGH);
  digitalWrite(CA2, LOW);
  lightSegments(number);
}

void lightSegments(byte number) {
  for (int i = 0; i < 7; i++) {
    int bit = bitRead(number, i);
    digitalWrite(segs[i], bit);
  }
}

Here’s a video of the 2-digit 7-segment display counter in action.

You might also enjoy:

1. Arduino 2-Digit 7-Segment Display with Buttons
2. Arduino 2-Digit 7-Segment Display Counter: Sketch
3. Controlling a Seven-Segment Display Using Arduino Part 4
4. Controlling a Seven-Segment Display Using Arduino Part 3

1. Pregnancy: a pregnancy belt that notifies the father every time the unborn baby kicks? Oh, and it tweets it: http://www.nydailynews.com/lifestyle/2008/12/17/2008-12-17_twittering_from_the_womb_how_soon_is_too.html
2. UAV: Sean Reynolds achieves autonomous flight control with this Arduino-based unmanned aerial vehicle: http://seanreynoldscs.com/WashUAV.aspx
3. Bluetooth: can’t afford a Bluetooth Arduino project? Check out this inexpensive Bluetooth module for the Arduino Mini: http://interactive.usc.edu/members/jbleecker/archives/007361.html
4. Stribe: have you heard of stribes? A stribe is a lighted touch strip music controller: http://stribe-org.blogspot.com/2008/01/description.html

Buy the Arduino Stamp Mini

The Mini at the official Arduino website: http://www.arduino.cc/en/Main/ArduinoBoardMini

You might also enjoy:

1. Arduino Lilypad: an Account of Coolness in 4 Links
2. Arduino Mega: an Account of Coolness in 4 Links
3. Arduino Nano: an Account of Coolness in 4 Links
4. An Arduino for Any Project

1. Light: how do you feel today? Find out with the interactive, multi-function mood light: http://www.instructables.com/id/Interactive-Open-Source-Mood-Light/
2. Sound: have you ever played with water filled crystal glasses to make sound? How about using an Arduino Nano to control the music? Check out this cool video: http://www.vimeo.com/1261369
3. Game: it’s no Wii, but this simple version of Super Mario Bros using an 8×8 LED matrix rocks: http://vimeo.com/9928343
4. iPod: an Arduino-based iPod remote with a single button that toggles between Play and Pause on the iPod: http://davidfindlay.org/weblog/files/2009_09_07_ipod_remote.php

Buy the Arduino Nano Ver 3.0

The Nano at the official Arduino website: http://www.arduino.cc/en/Main/ArduinoBoardNano

You might also enjoy:

1. Arduino Lilypad: an Account of Coolness in 4 Links
2. Arduino Mini: an Account of Coolness in 4 Links
3. Arduino Mega: an Account of Coolness in 4 Links
4. An Arduino for Any Project

1. Jacket 1: a jacket with turn signals that lets people know where you’re headed when you’re on your bike: http://web.media.mit.edu/~leah/LilyPad/build/turn_signal_jacket.html
2. Jacket 2: a jacket that both heats and cools based on one’s body temperature: http://www.instructables.com/id/How-to-make-a-Heating-and-Cooling-Jacket/
3. Shirt: this cool shirt features an RGB LED that changes color in response to motion and tilt: http://web.media.mit.edu/~leah/LilyPad/build/accelero_shirt.html
4. Scarf: this is no ordinary scarf! The interactive passion sensing scarf detects the presence of another scarf wearer nearby and sets the color of an RGB LED to either blue (lonely) or red (passion): http://www.instructables.com/id/Arduino-Lilypad-Interactive-Passion-Sensing-Scarf/

Buy the LilyPad Arduino

The Lilypad at the Official Arduino website: http://www.arduino.cc/en/Main/ArduinoBoardLilyPad

You might also enjoy:

1. Arduino Mini: an Account of Coolness in 4 Links
2. Arduino Mega: an Account of Coolness in 4 Links
3. Arduino Nano: an Account of Coolness in 4 Links
4. Check Out the Arduino Contest Winners