Parts List

Whether you are using a Raspberry Pi or Arduino (or both), you are going to need the following parts to build this project:

Over time, you will probably find yourself collecting resistors of many different values. In this case, I have suggested a compromise value of 150Ω resistors for the LEDs for both Arduino and Raspberry Pi and for all three colors of LED. If you wanted to fine-tune this for maximum brightness, you could use Table 6-1 to pick the optimum resistor values. 

Design

The three LEDs are each connected to a separate output pin of either the Arduino or Raspberry Pi. 

Arduino Connections

Figure 6-5 shows the breadboard layout and connection to the Arduino.

Figure 6-5. Breadboard layout for the Arduino traffic signal

Remember that the long LED lead is the positive lead and these go to the left of the breadboard and one end of the LED’s resistor. The shorter negative lead of the LEDs all go to the negative supply column that runs down the righthand side of the breadboard.

Arduino Software

The Arduino sketch for this project can be found in arduino/projects/traffic_signals, which you’ll find in the place where you downloaded the book’s code (see “The Book Code” in Chapter 2). Let’s take a look at it:

const int redPin = 11;           // 
const int orangePin = 10;
const int greenPin = 9;

void setup() {                    // 
  pinMode(redPin, OUTPUT);
  pinMode(orangePin, OUTPUT);  
  pinMode(greenPin, OUTPUT);  
}

void loop() {                 // 
  setLEDs(1, 0, 0);
  delay(3000);
  setLEDs(1, 1, 0);
  delay(500);
  setLEDs(0, 0, 1);
  delay(5000);
  setLEDs(0, 1, 0);
  delay(500);
}
  
void setLEDs(int red, int orange, int green) {   // 
 digitalWrite(redPin, red);
 digitalWrite(orangePin, orange);
 digitalWrite(greenPin, green);
}

The sketch has much in common with the original blink sketch, except that instead of controlling a single LED, three LEDs are being controlled.  

Constants are defined for each of the Arduino pins connected to an LED.

In the setup() function, the pins are set to be outputs.

The loop() function calls a setLEDs() function to set the three LEDs on or off (1 or 0). The delay between each call to setLEDs() determines how long the lights stay in that phase.

The setLEDs() function really just makes the loop function shorter and easier to read, allowing all three digitalWrites() to be condensed into one line. 

Raspberry Pi Connections

For the Raspberry Pi version of this project, the male-to-male jumpers are swapped for female-to-male jumpers and the same breadboard layout is connected to GPIO pins 18, 23, and 24, as shown in Figure 6-6.

Figure 6-6. Breadboard layout for the Raspberry Pi traffic signal

Raspberry Pi Software

The Python program for this project can be found in the traffic.py file in the python/projects/ directory (for information on installing the Python programs for the book, see “The Book Code” in Chapter 3):

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

red_pin = 18
orange_pin = 23
green_pin = 24

GPIO.setup(red_pin, GPIO.OUT)
GPIO.setup(orange_pin, GPIO.OUT)
GPIO.setup(green_pin, GPIO.OUT)

def set_leds(red, orange, green):    # 
    GPIO.output(red_pin, red)
    GPIO.output(orange_pin, orange)
    GPIO.output(green_pin, green)

try:         
    while True:
        set_leds(1, 0, 0)
        time.sleep(3)
        set_leds(1, 1, 0)
        time.sleep(0.5)
        set_leds(0, 0, 1)
        time.sleep(5)
        set_leds(0, 1, 0)
        time.sleep(0.5)
          
finally:  
    print("Cleaning up")
    GPIO.cleanup()

Just like the Arduino version, a function (set_leds) is used to keep the main loop uncluttered by too many GPIO.output functions.

Hardware

Figure 6-10 shows the schematic diagram for the experiment. 

Figure 6-9. Mixing colors with a Raspberry Pi

Figure 6-10. The schematic diagram for the RGB LED experiment

For optimum brightness and best color balance, you should choose your resistor values carefully. However, it’s easier to buy your components if you use the same value resistor for all three channels. In this case, I suggest 470Ω resistors as a “universal” option that will work with Raspberry Pi or Arduino.

The brightness and efficiency of an RGB LED is such that even with only 3mA (6mA on an Arduino), the LED will still look pretty bright.

Parts List

Whether you are using a Raspberry Pi or Arduino (or both), you are going to need the following parts to carry out this experiment:

If you are planning to try this experiment with a Raspberry Pi, you will need female-to-male jumper wires to connect the Raspberry Pi GPIO pins to the breadboard.

All the components in the list are included in the MonkMakes Electronic Starter Kit for Raspberry Pi (see Appendix A).

Arduino Connections

The Arduino version of this experiment uses the Serial Monitor to set the proportion of red, green, and blue.

Figure 6-11 shows the breadboard layout and connections to the Arduino.

Figure 6-11. Arduino breadboard layout for RGB color mixing

The longest lead of the LED is the common cathode lead that is connected to GND in Figure 6-11. The order of the other leads may not be the same as I have shown, so you might have to do some lead swapping if you find your colors mixed up.

Arduino Software

The Arduino sketch for this experiment uses three PWM channels to control the brightness of each of the three colors. The sketch is in the ex_12_mixing_colors file, which you’ll find in the place where you downloaded the book’s code):

const int redPin = 11;
const int greenPin = 10;
const int bluePin = 9;

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);  
  Serial.begin(9600);
  Serial.println("Enter R G B (E.g. 255 100 200)");
}

void loop() {
  if (Serial.available()) {
    int red = Serial.parseInt();   // 
    int green = Serial.parseInt();
    int blue = Serial.parseInt();
    analogWrite(redPin, red);     // 
    analogWrite(greenPin, green);
    analogWrite(bluePin, blue);
  }
}

Each of the three PWM values that should be between 0 and 255 are read into variables.

The PWM output is then set for each channel.

Arduino Experimentation

After uploading the sketch, open the Serial Monitor on the Arduino IDE. Then type three numbers, each between 0 and 255 and separated by a space, and click the Send button.

The LED should then change color to match the red, green, and blue numbers that you just entered. 

You can check each channel separately by entering 255 0 0 (red), then 0 255 0 (green), and finally, 0 0 255 (blue).

Raspberry Pi Connections

Rather than just use commands to change color, the Raspberry Pi version of this project creates a small user interface window on the Raspberry Pi that has three sliders, one for each color channel.

As you change the position of the sliders, the LED color will change. This software uses a graphical user interface, so you will need to have a keyboard, mouse, and monitor attached to your Raspberry Pi, as SSH does not have a graphical interface.

The breadboard layout for the Raspberry Pi (Figure 6-12) is just the same as for the Arduino, except that for the Raspberry Pi you need to use female-to-male jumper wires. The GPIO pins 18, 23, and 24 are used as PWM outputs.

Figure 6-12. Raspberry Pi breadboard layout for RGB color mixing

Raspberry Pi Software

The Python program for this experiment uses a framework called Tkinter that allows you to make applications that run in a window and have user interface controls, rather than the simple command line that you have used so far. This makes the program a bit longer than normal. It also makes use of some more advanced programming.

Let’s take a look at the program code (which you can find in the file mixing_colors.py):

from Tkinter import *       
import RPi.GPIO as GPIO
import time


GPIO.setmode(GPIO.BCM)  # 
GPIO.setup(18, GPIO.OUT)
GPIO.setup(23, GPIO.OUT)
GPIO.setup(24, GPIO.OUT)


pwmRed = GPIO.PWM(18, 500) # 
pwmRed.start(100)

pwmGreen = GPIO.PWM(23, 500)
pwmGreen.start(100)

pwmBlue = GPIO.PWM(24, 500)
pwmBlue.start(100)

class App:
    
    def __init__(self, master): # 
        frame = Frame(master)  # 
        frame.pack()
        
        Label(frame, text='Red').grid(row=0, column=0) # 
        Label(frame, text='Green').grid(row=1, column=0)
        Label(frame, text='Blue').grid(row=2, column=0)
        
        scaleRed = Scale(frame, from_=0, to=100,     # 
              orient=HORIZONTAL, command=self.updateRed)
        scaleRed.grid(row=0, column=1)
        scaleGreen = Scale(frame, from_=0, to=100,
              orient=HORIZONTAL, command=self.updateGreen)
        scaleGreen.grid(row=1, column=1)
        scaleBlue = Scale(frame, from_=0, to=100,
              orient=HORIZONTAL, command=self.updateBlue)
        scaleBlue.grid(row=2, column=1)

    def updateRed(self, duty):     # 
        # change the led brightness to match the slider
        pwmRed.ChangeDutyCycle(float(duty))

    def updateGreen(self, duty):
        pwmGreen.ChangeDutyCycle(float(duty))
    
    def updateBlue(self, duty):
        pwmBlue.ChangeDutyCycle(float(duty))


root = Tk()  # 
root.wm_title('RGB LED Control')
app = App(root)
root.geometry("200x150+0+0")
try:
    root.mainloop()
finally:  
    print("Cleaning up")
    GPIO.cleanup()

Configure the Pi to use the Broadcom (BCM) pin names, rather than the pin positions.

Start pulse-width modulation (PWM) on the red, green, and blue channels to control the brightness of the LEDs.

This function gets called when the app is created.

A frame holds the various GUI controls.

Create the labels and position them in a grid layout.

Create the sliders and position them in a grid layout. The command attribute specifies a method to call when a slider is moved.

This method and the similar methods for the other colors are called when their slider moves.

Set the GUI running, and give the window a title, size, and position.

Raspberry Pi Experimentation

Run the program as superuser using the following command:

$ sudo python mixing_colors.py

After a moment or two, the window shown in Figure 6-13 will appear.

Figure 6-13. Move the sliders to change the LED color

When you move the sliders around, the color of the LED will change.