LEDFace

The face is controlled by a SMD (surface mount) PIC16f684 microcontroller. I wanted to try my hand at surface mount chips and I thought this would be a good introduction. The LEDs follow various patterns (ie. chasing each other, flashing in unison, checkeboard flashing, etc.) It is also very easy to add your own patterns. Overall, this is a very easy project, and a good one if you want to try your hand at SMD microcontrollers.

Here is the PCB. As you can see, it is very straightforward, and a schematic is not really necessary. Keep in mind the PIC is on the underside of the PCB so it appears backwards in this picture.
The plus side of each LED is connected to an I/O pin of the microcontroller. The PIC16F684 has 12 I/O pins and they're are 10 LEDs total, leaving 2 I/O pins left over. The negative side of each pin is connected together and then connected to ground.

The LED Face uses a 3v "button cell" battery. It is a "CR2032," which is a very common battery. The +3V and Gnd on the PCB connect to the power and ground on a button cell holder. Here is a picture of the battery and holder (I got mine from Digi-key) and the underside of the LED face:

    In the picture of the back of the face, you can see the SMD microcontroller (I covered it with glue when I was done so there would be no problems with static electricity) and you can also see that I added an on/off switch. I simply put a switch between the +3v of the button cell holder and the +3v on the circuit board.

    Now, on to the code. I used MPLAB v8 and PICC Lite (The "c" plugin for MPLAB.) Both of these programs are free.

    Here is the beginning:

#include <pic.h>

__CONFIG(INTIO & WDTDIS & PWRTEN & MCLRDIS & UNPROTECT \
& UNPROTECT & BORDIS & IESODIS & FCMDIS);

//                RA0        -        LED1
//                RA1        -        LED2
//                RA2        -        LED3
//                RC0        -        LED4
//                RC1        -        LED5
//                RC3        -        LED6
//                RC4        -        LED7
//                RC5        -        LED8
//                RA4        -        LED9
//                RA5        -        LED10

const char PORTAValue[10] = {        0b000001,        //RA0
                                        0b000010,        //RA1
                                        0b000100,        //RA2
                                        0b000000,
                                        0b000000,
                                        0b000000,
                                        0b000000,
                                        0b000000,
                                        0b010000,        //RA4
                                        0b100000 };        //RA5

const char PORTCValue[10] = {        0b000000
                                        0b000000,
                                        0b000000,
                                        0b000001,        //RC0
                                        0b000010,        //RC1
                                        0b001000,        //RC3
                                        0b010000,        //RC4
                                        0b100000,        //RC5
                                        0b000000,
                                        0b000000 };

int i, j;

void Delay(void);                        //Declare a prototype for the delay function

This section of code #includes the pic header file, sets up the config bits and then sets up 2 arrays for PORTA and PORTC to make cycling easy. I could have made the code shorter, but for the sake of simplicity, I coded it this way.

We then move on to the main function:

main()
{
        PORTA = 0;                //Turn off PORTA LEDs
        PORTC = 0;                //Turn off PORTC LEDs
        TRISA = 0;                //All ouputs
        TRISC = 0;
        CMCON0 = 7;        //Turn off comparators
        ANSEL = 0;                //Turn off ADCs

This sets PORTA and PORTC to all outputs, turns them off (sets them to 0), and turns off the ADC and comparators.

We then move into the guts of the program. These four routines cycle through the patterns in different ways:

       while(1)
        {
                // CHASER
                for(j=0;j<6;j++)
                {
                        for(i=0;i<10;i++)
                        {
                                PORTA = PORTAValue[i];
                                PORTC = PORTCValue[i];
                                Delay();
                        }
                }

                // FLASHER
                for(j=0;j<3;j++)
                {
                        for(i=0;i<10;i++)
                        {
                                PORTA = 0b000000;
                                PORTC = 0b000000;
                                Delay();
                                PORTA = 0b111111;
                                PORTC = 0b111111;
                                Delay();

                        }
                }

                // CHECKERBOARD
                for(j=0;j<6;j++)
                {
                        for(i=0;i<10;i++)
                        {
                                PORTA = 0b100010;
                                PORTC = 0b101001;
                                Delay();
                                PORTA = 0b011101;
                                PORTC = 0b010110;
                                Delay();

                        }
                }

                // DUAL CHASER
                for(j=0;j<6;j++)
                {
                        for(i=0;i<9;i++)
                        {
                                PORTA = PORTAValue[i] | PORTAValue[9-i];
                                PORTC = PORTCValue[i] | PORTCValue[9-i];
                                Delay();
                        }
                }


        }//Forever loop
}//End

And lastly, we setup a delay routine:

void Delay(void)
{
        T1CON = 0b00010001;                //TMR1 On/Internal Clock/8x prescalar
        TMR1H = 70;                                        //Initialize a 300ms delay
        TMR1L = 60;
        PEIE = 1;                                        //Enable peripheral interrupts
        TMR1IF = 0;                                        //Turn off pending interrupt requests
        TMR1IE = 1;                                        //Enable Timer1 overflow

        while(!TMR1IF);                        //Wait for Tmr1 to overflow
}

    Basically,the operation of the program is simple: we simply turn on a specific set of lights, wait for a delay, turn on a different set, wait for a delay, and continue.

    Some may wonder how I got around using any resistors. I tested the LEDs for quite a while on a breadboard and discovered that they worked perfectly fine with the 3 volt button cell. I guess t he current in the button cell is OK as well. I also did not put on a capacitor between power and ground as it is a very stable battery and in the testing one was not needed.

    Lastly, I added the eyes and mouth from a batch of stickers I bought at Thinkgeek.com. They were $5.95 for 2 sheets. Very fun! You can order them here.

    If anyone is interested in making this project themselves, you can download the source file, ExpressPCB file and PCB artwork here.

main() { PORTA = 0; //Turn off PORTA LEDs PORTC = 0; //Turn off PORTC LEDs TRISA = 0; //All ouputs TRISC = 0; CMCON0 = 7; //Turn off comparators ANSEL = 0; //Turn off ADCs

main()
{
PORTA = 0; //Turn off PORTA LEDs
PORTC = 0; //Turn off PORTC LEDs
TRISA = 0; //All ouputs
TRISC = 0;
CMCON0 = 7; //Turn off comparators
ANSEL = 0; //Turn off ADCs