How to drive an rgb led using three microcontroller pins.
The RGB LED contains three LEDs encased in one
shell: Red, Green and Blue (some contain an extra blue led - as blue LEDs
generate less output intensity (candela) per mA). It looks like a single white
led except that it has four leads - one for the common ground connection and
one for each led.
This project shows you how to produce PWM output without using the internal
PWM hardware modules i.e. a software PWM method.
The average current through each of the LEDs determines it's
light output i.e. its contribution to the total output color. So by controlling
the average current through each LED you can create almost any other color.
RGB LED Output colors
RGB LED driver project details.
RGB LED Project
Mikroelectronika MikroC Compiler Free!
(retargetable to other PICs that have an 3 output pins!).
driven 3 output PWM.
Enter your details to get the Download Link
and get the microcontroller newsletter:
(Your email is safe it will never
be sold or rented).
You will get All the C source code and
Note: Check your email for the project code download link.
You can program the PIC in circuit through the ICSP
By varying the current through each led you can create almost
any other color but at close range you only see the individual colors of each
To see the 'merged' color view it from a distance or put a
diffuser over it. I used a small piece of baking paper - which is transparent
enough to let the light through and opaque enough to diffuse the light from the
three LEDs. In a proper design you would use a diffused LED (roughened surface!).
all depends on what you want to do as the light output is reduced when
using a diffused LED so you may want to put the RGB LED in a housing
that does the diffusing e.g. a semi-transparent plastic housing, in
which case you would use a non-diffused LED.
Note: Other projects in the web
show the output without a diffuser I think the camera settings merge the light
acting as a diffuser (they do - using a digital camera gives the same results
i.e. It's not what your eye sees on the bench).
If you make a sign board using these LEDs you won't need a
diffuser as your eye will not be able to distinguish the individual LEDs (if
it's far enough away - it's exactly the same as a TV pixel).
How it works.
This project uses pulse width modulation to drive each of the
leds in the RGB led. By changing the duty cycle of each PWM signal you can
control the average current flowing through each led creating any color you
want. The limit is set by the resolution of the PWM (set at 256 steps per
The project relies on persistence of vision to make it appear
that the led is continuously driven (the PWM signals must be repeated quickly
enough so that you do not see any flicker) at a rate greater than 50Hz
(approx). Too slow and you begin to see the led flickering.
PIC micros only have one built in PWM module so you need to
create three pulse width modulators in software.
This is fairly easy to do using one of the timers in the PIC
micro and all that's needed is an 8 bit timer for an output resolution of
Note: It's fairly difficult to make it work at 4MHz (it
probably can be done in assembler or with more effort in 'C'). So I chose to
use a 20MHz crystal just to make it easier.
Heart beat timer
This project uses timer 0 to create a heart beat timer that
generates a regular interrupt. The pwm timer tick routine called here controls
the PWM operation.
Note: You can use any timer to generate the
Non PWM use
The other way to use a tri-color LED is without using PWM and
treat each led line as fully on or off.
Using it in this way you get six color outputs: Red, Green,
Blue, Magenta, Cyan and Yellow - without complex PWM control.
The hardware is simple with only three wires needed to drive
the rgb led.
RGB LED circuit
(Click diagram to open a pdf).
RGB LED: Software operation
The source code consists of the following files:
RGB LED: 'C' Files
RGB LED: Header files
RGB LED: pwm.c, pwm.h, types.h
pwm.h defines the prototypes for use in other files.
pwm.c defines a simple pulse width modulator - simplified in
that each output uses the same time base. Two user access functions let you
initialize the port and set the duty cycle:
_pwm_Init( U8 *usePORT, U8 _p1, U8 _p2, U8 _p3 )
_pwm_Duty( U8 chan, U8 d )
Note that U8 is defined in types.h as a typedef so and is a
short hand for an unsigned short (usually of 8 bits) hence Unsigned
Channels are selected in _pwm_Duty from 0 to 2.
RGB LED: PWM interrupt
The main control for the PWM is _pwm_timer_tick(void) which
must be called regularly from a timer interrupt. This calls the local file
scope function action which then calls chan_action that does the PWM output.
Note that a shadow register is used here to ensure the outputs are set
You would need to integrate the shadow register with other code
if other code accesses the same port.
The resolution of the PWM is 256 bits and at each call to
_pwm_timer_tick(void) each pwm channel is updated.
RGB LED : 16F877A_rgb-led.c
This function contains main which initializes the PWM on port C
and enters an infinite loop.
The random number generator qrn seems more random than the
built in one and it uses less memory. It is used in random_start to set a
random duty cycle value for each channel and a random sweep direction.
In the infinite loop each channel is swept up and down using
the current values from the arrays duty and dir. This produces a random
color pulsating light output.
So that a new random sequence is started after a count of 300
cycles a new random sequence is started so you don't see the same thing over