Microcontrollers

Program to convert ASCII to hex in 8051

2011-07-15T10:11:00.003-07:00

ASCII codes 30 to 39 represent 0 to 9 in binary and 41 to 46 represent A to F. Therefore

if the ASCII code is between 30-39h then 30h is subtracted from the code. If the number

lies between A to F then 37h is subtracted from the code to get its binary equivalent

mov dptr, #9000h ;load dptr with address 9000h

movx a,@dptr ; move data from external memory location to a

clr c ;clear carry bit

mov r1,a ;move data from a to r1

subb a,#40h ;subtract 40h from a

jc l2 ;jump to location l2, if carry

mov a,r1 ;move data from r1 to a

subb a,#37h ;subtract with borrow, 37h from a

sjmp here ;jump to location here

l2:mov a,r1 ;move data from r1 to a

clr c ;clear carry bit

subb a,#30h ;subtract with borrow, 30h from a

here:inc dptr ;increment dptr

movx @dptr,a ;move data from a to external memory location

rep:sjmp rep

end

Program to add two BCD numbers in 8051

2011-07-15T10:11:00.001-07:00

mov dptr,#9000h ;move dptr with 9000h

movx a,@dptr ; move data from external memory location to a

mov b,a ;move data from a to b

inc dptr ;increment dptr

movx a,@dptr ; move data from external memory location to a

add a,b ;add a and b

da a ;decimal adjust accumulator after addition

jc down ;if carry, jump to label down

inc dptr ;increment dptr

movx @dptr,a ;move data from a to external memory location

sjmp last ;jump to label last

down:mov r2,a ;move data from a to r2

mov a,#01h ;move data 01h to a

movx @dptr,a ;move data from a to external memory location

inc dptr ;increment dptr

mov a,r2 ;move data from r2 to a

movx @dptr,a ;move data from external memory location to a

last:sjmp last

end

Program to find the square of an 8 bit number in 8051

2011-07-15T10:10:00.005-07:00

mov dptr,#9000h ;load dptr with 9000h

movx a,@dptr ;move data from external memory location to a

mov b,a ;move data from a to b

mul ab ;multiply and b

inc dptr ;increment dptr

mov r0,a ;move data from a to r0

mov a,b ;move data from b to a

movx @dptr,a ;move data from a to external memory location

inc dptr ;increment dptr

mov a,r0 ;move data from r0 to a

movx @dptr,a ;move data from a to external memory location

here:sjmp here

end

Program to count from 0-9 in 8051

2011-07-15T10:10:00.003-07:00

here:mov a,#0h ;move 0 to a

up:mov p0,a ;move data from a to port0

acall delay ;call delay routine

add a,#01 ;increment a

cjne a,#010,up ;compare a with 10, if not equal, jump to location up

sjmp here ;jump to location here

;delay routine

delay:mov r1,#0ffh ;move 0ffh to r1

l3:mov r2,#0ffh ;move 0ffh to r2

l2:mov r3,#0ffh ;move 0ffh to r3

l1:djnz r1,l1 ;decrement r1, repeat till r1=0

djnz r3,l2 ;decrement r3,repeat l2 till r3=0

djnz r2,l3 ;decrement r2, repeat l3 till r2=0

ret ;return

end

Program to implement BCD counter to count from 0-99 in 8051

2011-07-15T10:10:00.001-07:00

here:mov a,#0h ;move 0 to a

up:mov p0,a ;move data fr

acall delay ;call delay program

inc a ;increment a

da a ;decimal adjust accumulator after addition

cjne a,#100,up ;compare a with 100, if not equal, jump to location up

sjmp here ;jump to location here

delay routine

delay:mov r1,#0ffh ;move 0ffh to r1

l3:mov r2,#0ffh ;move 0ffh to r2

l2:mov r3,#0ffh ;move 0ffh to r3

l1:djnz r1,l1 ;decrement r1, repeat till r1=0

djnz r3,l2 ;decrement r3,repeat l2 till r3=0

djnz r2,l3 ;decrement r2, repeat l3 till r2=0

ret ;return

end

Automatic Room Light Controller

2011-07-15T10:09:00.001-07:00

Project title is “AUTOMATIC ROOM LIGHT CONTROLLER WITH BIDIRECTIONAL VISITOR COUNTER “.

The objective of this project is to make a controller based model to count number of persons visiting particular room and accordingly light up the room. Here we can use sensor and can know present number of persons.

In today’s world, there is a continuous need for automatic appliances with the increase in standard of living, there is a sense of urgency for developing circuits that would ease the complexity of life.

Also if at all one wants to know the number of people present in room so as not to have congestion. This circuit proves to be helpful.

Circuit Diagram:1

Circuit Diagram: 2

Download Project

Click on above links to Download

Microcontroller Based Access Control system

2011-07-15T10:08:00.003-07:00

Now a days, a problem of security is very much important everywhere in the world. So, in large firms or companies, to make protect of entering of unauthorized person or to secure their important section, they generally use this type of security.

vThis project, AN ACCESS CONTROL SYSTEM provides a facility of security. This type of security lock is generally attached at the main entrance door of the firms. By using this type of security, only authorized fellow can enter.

It is quite easy in installation and use. Through this, one can allocate more number of passwords to many fellows. It is easy to use as the fellow don’t need to carry any type of id card or chip etc.

Circuit Diagram:

Download Project

Schematic Diagram:1

Programm

Presentation

Click on above links to download

CELLPHONE OPERATED LANDROVER

2011-07-15T10:08:00.001-07:00

Project Overview

Conventionally, wireless-controlled robots use RF circuits,which have the drawbacks of limited working range, limited frequency range and limited control. Use of a mobile phone for robotic control can overcome these limitations.

It provides the advantages of robust control, working range as large as the coverage area of the service provider,no interference with other controllers and up to twelve controls.Although the appearance and capabilities of robots vary vastly, all robots share the features of a mechanical, movable structure under some form of control.

The control of robot involves three distinct phases: reception, processing and action. Generally, the preceptors are sensors mounted on the robot, processing is done by the on-board microcontroller or processor, and the task (action) is performed using motors or with some other actuators.

Schematic Diagram

Block Diagram

Download Project

Remotely Programmable RTC-Interfaced Microcontroller for Multiple Device Control

2011-07-15T10:07:00.003-07:00

Since the circuit makes use of Philips TV remote for device-switching time parameters, you need to know the fundamentals of the coding format used in these IR remotes.

The Philips IR format makes use of RC5 code, which is also known as ‘bi-phase coding.’ In RC5-coded signals (Fig. 2), each bit has a uniform duration. A transition in the middle of the time interval assigned to each bit encodes its logical value (‘0’ or ‘1’). A high-to-low transition assigns the bit a logic value of ‘0,’ and a low-to-high transition assigns the bit a logic value of ‘1.’ We need additional transitions at the beginning of each bit if a stream of equal bits is sent. However, there is no need of additional transitions if the next bit has a different logic value.Table II shows how all the commands of an RC5 remote control are encoded.

The first two bits are ‘start’ bits, which are used to adjust and synchronise the receiver. These bits are used to calculate and analyse the bit length of the other bits. The third bit is a ‘toggle’ bit, which is toggled every time a button ispressed at the remote control. This bit is used to identify whether the button is really pressed or whether an obstacle came in between the IR path of the remote and the IR receiver.

The five bits (A4 through A0) immediately following the toggle bit are used to identify the device (see Table III). So, a maximum of 32 devices can be identified to and respond individually to the same type of coding without any disturbance, i.e., one among the 64 devices can be identified uniquely. Addresses of some of the remotes are shown in Table III. The six bits (C5 through C0) immediately following the five address bits are the control/command bits. Therefore a maximum of 64 commands can be equipped in an RC5-type remote. Some of the command codes (decimal equivalents), as used in this project, are shown in Table IV. When any of the command/control buttons on the remote is pressed, the coded signal is received by the IR receiver-demodulator TSOP1738.The output of the IR demodulator circuit is normally high, but when any of the buttons in the remote is pressed, a stream of low-going demodulated pulses will appear at its output. These pulses are fed to the external active-low interrupt input pin (INT/0) of 89C52. On receipt of the first low-going pulse, the monitor program of 89C52 will get interrupted and jump to the location ‘0003H,’ where the execution is redirected to ‘receive’ sub-routine of the

program.

The outputs from the subroutineare:

1. Toggle bit, which toggles (either ‘0’ or ‘1’) each time the button in a remote is pressed.

2. Address byte, whose value is zero for a normal Philips-type TV remote control.

3. Control byte, which has a unique value for each button in the remote control.

Download Project

Schematic Diagram

PCB Layout

Click on above links to download

Program to generate 50msec delay in 8051

2011-07-15T10:07:00.001-07:00

mov tmod,#01 ;select timer 0

here:mov tl0,#0fdh ;load tl0 with 0fdh

mov th0,#4bh ;load th0 with 4bh

cpl p1.5 ;compliment p1.5

acall delay ;call delay routine

sjmp here ;jump to here

delay:mov r1,#0c8h ;load r1 with data 0c8h

l1:setb tr0 ;set bit tr0

again:jnb tf0,again ;repeat till tf0=0

clr tr0 ;clear tr0

clr tf0 ;clear tf0

djnz r1,l1 ;decrement r1, jump to l1, if not equal to 0

ret

end

Write a C program to display the code of the key pressed in 8051

2011-07-15T10:06:00.003-07:00

#include <REG51xD2.H>

#include "lcd.h"

unsigned char getkey();

void delay(unsigned int);

main()

{

unsigned char key;

InitLcd(); /* Initialise LCD */

WriteString("Key Pressed="); /* Display msg on LCD */

while(1)

{

GotoXY(12,0); /* Set Cursor Position */

key = getkey(); /* Call Getkey method */

}

unsigned char getkey()

{

unsigned char i,j,k,indx,t;

P0=0x0ff;

P1=0x0ff;

P2 = 0x00; /* P2 as Output port */

indx = 0x00; /* Index for storing the first value of

scanline */

for(i=0x00E;i>=0x00B;i<<=1) /* for 4 scanlines */

{

P2 = i; /* write data to scanline */

t = P0; /* Read readlines connected to P0*/

t = ~t;

if(t>0) /* If key press is true */

{

delay(6000); /* Delay for bouncing */

for(j=0;j<=7;j++) /* Check for 8 lines */

{

t >>=1;

if(t==0) /* if get pressed key*/

{

k = indx+j; /* Display that by converting to Ascii */

t = k>>4;

t +=0x30;

WriteChar(t); /* Write upper nibble */

t = k & 0x0f;

if(t > 9)

t+=0x37;

else

t+=0x30;

WriteChar(t); /* write lower nibble */

return(indx+j); /* Return index of the key pressed */

}

indx += 8; /* If no key pressed increment index */

}

void delay(unsigned int x) /* Delay routine */

{

for(;x>0;x--);

}

program for Elevator Interface in 8051

2011-07-15T10:06:00.001-07:00

#include <REG51F.H>

void delay(unsigned int);

main()

{

unsigned char Flr[9] = {0xff,0x00,0x03,0xff,0x06,0xff,0xff,0xff,0x09};

unsigned char FClr[9] = {0xff,0x0E0,0x0D3,0xff,0x0B6,0xff,0xff,0xff,0x79};

unsigned char ReqFlr,CurFlr = 0x01,i,j;

P0 = 0x00;

P0 = 0x0f0;

while(1)

{

P1 = 0x0f;

ReqFlr = P1 | 0x0f0;

while(ReqFlr == 0x0ff)

ReqFlr = P1 | 0x0f0; /* Read Request Floor from P1 */

ReqFlr = ~ReqFlr;

if(CurFlr == ReqFlr) /* If Request floor is equal to Current Floor */

{

P0 = FClr[CurFlr]; /* Clear Floor Indicator */

continue; /* Go up to read again */

}

else if(CurFlr > ReqFlr) /* If Current floor is > request floor */

{

i = Flr[CurFlr] - Flr[ReqFlr]; /* Get the no of floors to travel */

j = Flr[CurFlr];

for(;i>0;i--) /* Move the indicator down */

{

P0 = 0x0f0|j;

j--;

delay(25000);

}

else /* If Current floor is < request floor */

{

i = Flr[ReqFlr] - Flr[CurFlr]; /* Get the no of floors to travel */

j = Flr[CurFlr];

for(;i>0;i--) /* Move the indicator Up */

{

P0 = 0x0f0 | j;

j++;

delay(25000);

}

CurFlr = ReqFlr; /* Update Current floor */

P0 = FClr[CurFlr]; /* Clear the indicator */

}

void delay(unsigned int x)

{

for(;x>0;x--);

}

program for Stepper motor interface in 8051

2011-07-15T10:05:00.002-07:00

#include <REG51xD2.H>

static bit Dir=0;

void delay(unsigned int x) /* Delay Routine */

{

for(;x>0;x--);

}

void ChangeDir(void) interrupt 0 /* Int Vector at 000BH, Reg Bank 1 */

{

Dir = ~Dir; /* Complement the Direction flag */

ClrLcd();

if(Dir)

delay(32000);

else

delay(32000);

}

main()

{

unsigned char Val,i;

EA=0x1; /* Enable Interrupt flag and Interrupt 0 & Serial Interrupt */

EX0=0x1;

ES=0x1;

P0=0x00; /*since the monitor is using the serial interrupt it has to be enabled*/

while(1)

{

if(Dir) /* If Dir Clockwise */

{

Val = 0x88;

for(i=0;i<4;i++)

{

P0 = Val; /* Write data for clock wise direction*/

Val = Val>>1;

delay(575);

}

else /* AntiClockwise Direction */

{

Val = 0x11;

for(i=0;i<4;i++)

{

P0 = Val; /* Write data for anticlock wise direction*/

Val = Val<<1;

delay(575);

}

Home Security System Using AT89C52

2011-07-15T10:05:00.000-07:00

The project works on 5V DC derived from 230V. It will display the condition of home like temperature, door or window status, smoke detection, obstacle detection etc on 2×16 display and here we can use any mechanical device by the use of relay so we can overcome the problem generated at home. The project is also use for controlling the temperature

The project is use for security purpose at night for security purpose alarm is generated so that we should know something is wrong going on and it will display the problem generated on 2×16 display.

Block Diagram

Description Of Block Diagram

POWER SUPPLY

Power supply block gives us 5V DC from 230V AC to drive microcontroller and other devices.

MICROCONTROLLER

Here we use AT89C52. The AT89C52 is a low-power, high-performance CMOS 8-bit microcontroller with 8K bytes of Flash programmable and erasable ROM

Here we use 2×16 LCD. It display the condition of home, it display temperature.

SOUND DETECTION

Sound signal is received from microphone in sound detection block and compared with threshold value if it is above threshold alarm is generated and display SND1 on LCD otherwise it display SND0.

SMOKE DETECTION

If the smoke is present smoke detection block will sense it and compared it with threshold value if the value is below threshold alarm is generated and display SM1 otherwise it display SM0.

Download Project

Click on below links to download

RFID Based Door Access Control System using Microcontroller

2011-07-15T10:04:00.001-07:00

Automation today has increased the speed of living. This project in which radio frequency is used to automatically control the door locks and grants access to the persons who are allowed to access that particular door.

The technology used is termed as RFID meaning ‘Radio Frequency Identification’. Here tags are provided in the form of identity cards which contain a coil and a transmitter.

When the coil is placed in a high frequency electromagnetic waves, it is energized and provides supply to the transmitter which transmits a code unique to the tag. This code is received and identify and hence the person is identified.

After identifying the person the access permission to the person are verified and if he is trying to access a door, which he is allowed access to, the door is opened and a log is created with the person’s name and time accessing the door.

Circuit Diagram:1

Download Project

Click on above links to download

Frequency Counter Circuit

2011-07-15T10:03:00.001-07:00

This frequency counter may seem simple but it is capable of measuring frequencies in range between 10Hz – 60MHz with 10Hz resolution. Frequency counter circuit is based on PIC16F282A microcontroller clocked by 4MHz crystal.

Frequency counter has a transistor based TTL level converter where small signal is increased to level acceptable to PIC microcontroller logics. So it is capable of measuring signals from crystal oscillators. There is also no problem to use additional pre-scaller circuit and rise frequency range even to GHz level. I bet this frequency counter would find a place on any hobbyists workbench.
Full Project

How To Program PIC(18F) Microcontroller In C Using MPLAB IDE

2011-07-15T10:02:00.000-07:00

MPLAB IDE is a powerful tool used to program PIC Microcontroller. This software makes several output files of which hex file is used to burn PIC Microcontroller. You can download this software from Microchip site. You can Program any Microcontroller(18F) in C language in this software.

Open MPLAB IDE and from Project tab choose “Project Wizard” and from Project Wizard choose “Next“
Select the device you want to use for programming and then choose “Next”
From Active Toolsuite choose Microchip C18 Toolsuite and from Toolsuite contents choose MPLAB C18 C Compiler then choose “Next”
Now Browse and choose a New Project File and its Directory and choose “Next”
In Step Four the software will demand you to add any file to project. Since this is the first project so simply choose Next and then in next Step choose “Finish”.
Now click on New file button and and create a empty file and don’t forget to choose it’s extension as .C
From the view tab choose “Project” then on the left side you can see the following type of Tool bar. Now Right Click on “Source Files” and choose “Add Files” and Add the file you have saved(see 6th point)
Similarly you need to add Header files, Library files, Linker files from your installed Program directory
Now you can write your code in the source file in C language. After writing the project from the Project Tab choose “build” and you will have the hex file on the same directory where your source file is…

program for Seven segment display in 8051

2011-07-15T10:01:00.001-07:00

#include<stdio.h>

#include <REG51.H>

void delay(int g);

int port[20] = {0xff,0xff,0xff,0xff,

0xc6,0x86,0xc7,0x86,

0xbf,0xc0,0xde,0x87,

0xbf,0x92,0x91,0x92,

0x92,0xc8,0x86,0x87},i;

void main(){

int d,b,j,k,s;

while(1){

i=0;

for(d=0;d<5;d++)

{

for(b=0;b<4;b++)

{

k=port[i++];

for(j=0;j<8;j++){

s=k;

s=s&0x80;

if(s==0x00)

P1= 0x00;

else

P1=0x1;

P2 = 0x1;

P2=0x00;

s=k;

s=s<<1;

k=s;

}

delay(10000);

}

void delay(int g)

{

int h;

for(h=0;h<=g;g++)

{

;

}

program for Dual DAC, square wave in 8051

2011-07-15T10:00:00.003-07:00

#include <REG51xD2.H>

#include "lcd.h"

sbit Amp = P3^3; /* Port line to change amplitude */

sbit Fre = P3^2; /* Port line to change frequency */

void delay(unsigned int x) /* delay routine */

{

for(;x>0;x--);

}

main()

{

unsigned char on = 0x7f,off=0x00;

unsigned int fre = 100;

InitLcd(); /* Initialize LCD */

WriteString("Squarewave"); /* Write to LCD */

while(1)

{

if(!Amp) /* if user choice is to change amplitude */

{

while(!Amp); /* wait for key release */

on+=0x08; /* Increase the amplitude */

}

if(!Fre) /* if user choice is to change frequency */

{

if(fre > 1000) /* if frequency exceeds 1000 reset to default */

fre = 100;

while(!Fre); /* wait for key release */

fre += 50; /* Increase the frequency */

}

P0=on; /* write amplitude to port */

P1=on;

delay(fre);

P0 = off; /* clear port */

P1 = off;

delay(fre);

}

program for Dual DAC, triangle wave in 8051

2011-07-15T10:00:00.001-07:00

#include <REG51xD2.H>

#include "lcd.h"

main()

{

unsigned char i=0;

InitLcd(); /* Initialise LCD */

WriteString("Triangular Wave"); /* Display on LCD */

P0 = 0x00; /* P0 as Output port */

while(1)

{

for(i=0;i<0xff;i++){ /* Generate ON pulse */

P1 = i;

P0 = i; }

for(i=0xfe;i>0x00;i--) /* Generate OFF pulse */

{P0 = i;

P1 = i;}

}

PIC 16f84a LED on/off with delay project

2011-07-15T09:59:00.001-07:00

Flowchart Explanation:

Set the Port B of the PIC 16F84A device as output Port. Turn the Led-on by sending the data one to the Port B and create a Delay of 0.5 seconds to keep the Led in on-state. Turn the Led-off by sending the data zero to the Port B and create a Delay of 0.5 seconds to keep the Led in off-state. this process is repeated untill the power supply to the PIC 16F84A goes off.Flowchart and Circuit Diagram:

Circuit Description:PIC 16F84A microcontroller device is programmed to turning a LED on/off continuously with delay. this device uses 4MHz crystal/Resonator oscillator to drive osc1 and osc2. Port B RB0 is used as output port and it output the positive current with some delay to blink the LED and this delay timing depends on the program. A 100 or120 ohms resistance is connected to the LED to limiting the output current from RB0. VDD(Pin 14) and pin 4 is connected to the +5V power supply. Vss(Pin 5) is connected to the -5V or ground.Embedded C Program: LED on/off with delayCompiler: PIC CCS C compilerEmbedded C program for Turning a Led On/Off with delay. its very easy to learn and you can able to understand the concept and logic of the program from the flowchart and comment lines of the program.

/*Project Name: LED on/off with 0.5 second delay*/

#include<16F84A.h>   /*defines type of device to include device files*/

#use delay(clock=4mhz)     /* defines crystal frequency 4MHz */

#fuses xt, nowdt, noprotect, noput
/* xt oscilator used and no watch dog timer, no code protection, no     power up timer is used */

#byte portb=6                  /* defines memory location of register */

void main()
  {
     set_tris_b(0x00);        /* it sets the portb as output port */

     loop1: portb=0x01;    /* sends 1 to portb RB0 to turn the LED-on */

     delay_ms(500);    /* creates half second delay between LED on/off*/

     portb=0x00;           /* sends 0 to portb RB0 to turn the LED-off */

     delay_ms(500);     /*creates half second delay between LED off/on*/

     goto loop1;
  }     /* loop1 just turns-on/off the LED continuously until the power supply             OFF */

Delay: delay is used to keep the processor output as constant for the period of specified time. this period of time is called as Delay time. Delay time can be programmed according to your specified timings. for example

delay in milli seconds	delay in seconds
250	0.25
500	0.5
1000	1
2000	2

PushButton for Led Chaser with microcontroller

PushButton Led Chaser:

PushButton micro switch is used as an input to ON and OFF Led chaser. when you press the pushbutton then it starts(ON) the Led chaser. Led chaser means Led blinks one by one in continuous motion. if you press the pushbutton when an Led chaser in ON condition then it stops(OFF) Led chaser.Flowchart Explanation:Set the PortA RA0 as input and PortB RB0 as output of the PIC 16F84A device. Create a never ending while loop and inside the while loop read the PortA RA0 bit.Check whether the PushButton switch is pressed or not. If the Button is Pressed means PortA RA0 = 1 or RA0 goes High and it enters into the while loop and starts the Led Chaser by shifting the data 1 stored in the variable value using Left Shift Operator with a 0.25 second delay and again checks for button is pressed if it is pressed again then Stops the Led Chaser by sending 0x00 to PortB and the control comes out of the second while loop and the same process is repeated. If the Button is not Pressed means it will go to while loop and again checks for switch press.Circuit Diagram:

Circuit Description: PIC 16F84A microcontroller device is programmed for Led Chaser with Push Button when the button is pressed. this device uses the capacitor C1, C2(33pf) and 4MHz crystal/Resonator oscillator to drive the oscillator1 and oscillator2. The Push Button is connected to the PortA RA0 and +5V and pull down Resistor R2(10k) is connected to the PortA RA0 and Gnd.(Gnd means ground)In this circuit Active High Input is used. Resistor R2(10k) is used to pull down the PIC input to Logic '0' or Low or Pull down the Voltage down to zero. when you press the switch it pulls the voltage from 0 to 5V and makes the input to Logic '1' or High. Resistor 1K is connected to the PortB and Leds. the other negative terminal of all the eight Led is connected to the ground.Resistor R is a Current Limiting Resistor R(1K) is used to prevent the damage to both the PIC and the Leds. Resistor R reduces the current to the sufficient level.Embedded C Program: PushButton for Led ChaserCompiler: PIC CCS C compilerEmbedded C program for PushButton for Led Chaser. its very easy to learn and you can able to understand the concept and logic of the program from the flowchart and comment lines of the program.

/* Project Name: PushButton for Led Chaser */

#include<16F84A.h>         /*defines type of device to include device files*/

#use delay(clock=4mhz)    /* defines crystal frequency 4MHz */

#fuses xt, nowdt, noprotect, noput
/* xt oscilator used and no watch dog timer, no code protection, no power up     timer is used */

#byte portb=5               /* defines memory location of register */
#byte portb=6                /* defines memory location of register */

void main()
  {
    byte c,d;
    set_tris_a(0x01);        /* it sets the portA RA0 as input port */
    set_tris_b(0x00);        /* it sets the portB RB0 as output port */
    while(true)
    {
      if(porta == 0x01)       /* if switch pressed starts Disco Led */
      {
     while(true)
        {
         c = 0;                   /*initialize the count c equal to zero */
         d = 0x01;              /* assigns the content of d to 0x01 */
         while(c < 8)
         {
           portb = d; /*sends content of d to portb to turn-on 1st Led*/
           delay_ms(250); /* creates 0.25 second delay */
           d = d << 1;      /* shifts the value of data to the left by 1*/           c++;                /* increments the value of c by 1*/
          }
           if(porta == 0x01)   /*if switch pressed again stops DiscoLed*/
             {
              portb = 0x00; /*assigns portB RB0 to 0x00 to turn-offLed*/
              break;            /* comes out of the loop*/
              }
         }
      }
    }
  }

PIC16f84a Push Button for Blinking Led project

2011-07-15T09:58:00.001-07:00

Flowchart Explanation:

Set the PortA RA0 as input and PortB RB0 as output of the PIC 16F84A device as output Port. Create a never ending while loop and inside the while loop read the PortA RA0 bit.

Check whether the Push Button is pressed or not. If the Button is Pressed means PortA RA0 = 1 or RA0 goes High and it enters into the while loop and starts the Led Blinking by sending 1 and 0 Alternately to RB0 with a 0.25 second delay and again checks for button is pressed if it is pressed again then stops the Led Blinking and the control comes out of the second while loop and the same process is repeated. If the Button is not Pressed means it will go to while loop and again checks for switch press.Flowchart and Circuit Diagram:

Circuit Description:

PIC 16F84A microcontroller device is programmed for Blinking Led with Push Button when the button is pressed. This device uses 4MHz crystal/Resonator oscillator to drive the oscillator1 and oscillator2. The Push Button is connected to the PortA RA0 and +5V and pull down Resistor R2(10k) is connected to the PortA RA0 and Gnd.

In this circuit Active High Input is used. Resistor R2(10k) is used to pull down the PIC input to Logic '0' or Low or Pull down the Voltage down to zero. when you press the switch it pulls the voltage from 0 to 5V and makes the input to Logic '1' or High.Resistor R1 is connected to the PIC pin and Led. the other negative terminal of the Led is connected to the ground.Resistor R1 is a Current Limiting Resistor R1(1K) is used to prevent the damage to both the PIC and the Led. Resistor R1 reduces the current to the sufficient level.Embedded C Program: Push Button for Blinking Led
Compiler: PIC CCS C compilerEmbedded C program for Push Button for Blinking Led. its very easy to learn and you can able to understand the concept and logic of the program from the flowchart and comment lines of the program.

/* Project Name: Push Button for Blinking Led */

#include<16F84A.h>         /*defines type of device to include device files*/

#use delay(clock=4mhz)    /* defines crystal frequency 4MHz */

#fuses xt, nowdt, noprotect, noput
/* xt oscilator used and no watch dog timer, no code protection, no power up     timer is used */

#byte portb=5               /* defines memory location of register */
#byte portb=6                /* defines memory location of register */

void main()
  {
    set_tris_a(0x01);        /* it sets the portA RA0 as input port */
    set_tris_b(0x00);        /* it sets the portB RB0 as output port */
    while(true)
    {
       if(porta == 0x01)       /* if switch pressed Led starts Blinking*/
       {
     while(true)
           { portb = 0x01;      /*assigns portB RB0 to 0x01 for turn-on Led*/
                delay_ms(250);
                portb = 0x00;      /*assigns portB RB0 to 0x00 for turn-off Led*/
                delay_ms(250);
                if(porta == 0x01)    /* if switch pressed again Led stops Blinking*/
                 {
                    break; /* comes out of the loop*/
                  }
            }
         }
     }
  }

First PICMicro Project

2011-07-15T09:57:00.000-07:00

First PICMicro Project

In the past two weeks, I discussed the prerequisits for starting your first application and the issues surrounding PICMicro programmers and what to look for. With this background, I am now ready to present what I think is a good first application for somebody learning about the PICMicro. This circuit is not as simple as what I started with in "Programming and Customizing the PIC Microcontroller", but can be used in the same way to experiment with different ideas and trying out new concepts.
The application itself consists of the 16F84 PICMicro (with power, reset and clocking "core") with two LEDs and a button. One of the LEDs is lit by the PICMicro while the other is lit when the button is pressed.

Bill of Materials
Part Number R1 R2-R3 C1 C2 U1 U2 CR1-CR2 SW1 -- -- -- Y1	Value/Comments 4.7K 0.25 Watt Resistor 220 Ohm 0.25 Watt Resistor 10 uF 25 Volt Electrolytic Capacitor 0.1 uF 16 Volt Tantalum Capacitor 78L05 Voltage Regulator PIC16F84 Microcontroller 5 mm Red LEDs "Momentary On" SPST Pushbutton Prototype Card Wiring Power Supply (> 6 Volts if Voltage Regulator used) 4MHz Ceramic Resonator (With Internal Capacitors)

When I built the circuit, I put it on a spring loaded "Breadboard" as is shown at the top of the article. I was able to put on the Voltage regulator at one end of the breadboard with the "red" commoning bar as positive voltage and the blue bar as ground. I used a +12 Volt "Wall Wart" for powering my prototype, but this circuit could be powered by a 9 Volt Alkaline radio battery. As I pointed out in the earlier articles, three "AA" 1.5 Volt Alkaline batteries could be wired in series to provide power as well.

For my prototype, I used a 4 MHz "Ceramic Resonator" for clocking. For this circuit, the operating frequency is not important. If you haven't used a Ceramic Resonator before, I highly recommend that you look into them because they are a) easier to wire than a crystal and a couple of capacitors and b) are much more robust than a crystal, which means that you will be able to abuse them more and not loose your investment.

The LEDs are lit when the Microcontroller pins that they are connected to are pulled to ground. This is traditional in Microcontroller applications because in most devices, the "0" can "sink" more current than the "1" can "source". The PICmicro is capable of sourcing enough current to drive an LED, but I prefer using the sink feature because this is the only way that the 8051 can light LEDs directly and this eliminates the need for me to convert mentally how applications work for different devices.

The button connection probably seems unreasonably simple because I have not provided a "pull up" for the switch to pull down. In the interests of keeping the circuit simple, I rely on the internal pull ups in "PORTB" of the PICMicro to provide this function for me. A 4.7K Resistor connected between Vdd and the PICMicro's I/O pin could also be used if the internal pull ups are not used.

There is one point to make about the layout that you should always keep in mind when developing a circuit with a microcontroller or other programmable device; you should always design the circuit in such a way that the chip can be pulled easily. This means that there should be space at either end for prying the chip up out of its socket or, as I like to do, slide a small screwdriver underneath the PICMicro and "pop" it up simply by twisting it. I know a lot of people that end up cursing themselves because they've forgotten to remember this basic operation. In keeping with this theme, when using a "breadboard", I like to put in a connection between the row of holes above the Microcontroller. This allows me to pull the part without having to figure out where it goes back each time.

The application code is quite simple and can be blocked out as:

main() // First Application, Light 1st LED and { // Light 2nd LED when Button Pressed LED_1 = on; // Turn on the 1st LED while ( 1 == 1 ) // Loop forever if ( Button == Pushed ) LED_2 = on; else LED_2 = off; } // End First Application
To provide this function, I created the PICMicro Assembly code:

title "First Application - Light an LED and Poll a Button." ; ; This Code Simply Lights an LED and polls a button and turns ; on another LED when it is pressed. ; ; ; Hardware Notes: ; Reset is tied directly to Vcc and PWRT is Enabled. ; The PIC is a 16F84 Running at any speed. ; PortB.0 is Connected to a Button that pulls down to Ground when Pressed ; PortB.1 is Connected to an LED which is Pulled to Ground ("On" LED) ; PortB.2 is Connected to an LED which is Pulled to Ground ("Button" LED) ; ; Myke Predko ; 99.05.18 ; LIST P=16F84, R=DEC errorlevel 0,-305 INCLUDE "p16f84.inc" ; Register Usage CBLOCK 0x00C ; Start Registers at End of the Values ENDC PAGE __CONFIG _CP_OFF & _XT_OSC & _PWRTE_ON & _WDT_OFF ; Note that the WatchDog Timer is OFF ; First Application - Turn on LED and poll the Button. org 0 movlw 0x0FD ; Turn on LED on RB1 When Output Enabled movwf PORTB bsf STATUS, RP0 bcf TRISB ^ 0x080, 1 ; Enable RB1 for Output bcf TRISB ^ 0x080, 2 ; Enable RB2 for Output movlw 0x07F ; Enable Internal Pull-Ups movwf OPTION_REG ^ 0x080 bcf STATUS, RP0 Loop btfsc PORTB, 0 ; Is the Button Pressed? goto ButtonUp ; No, Light Off bcf PORTB, 2 ; Turn Light On goto Loop ButtonUp ; Button Up, Turn Light Off bsf PORTB, 2 goto Loop end
This code can be downloaded by clicking HERE.

The body of the assembler code should match the "C" pseudo code given above, but the initial code,

movlw 0x0FD                  : Turn on LED on RB1 When Output Enabled
movwf PORTB

bsf    STATUS, RP0
bcf    TRISB ^ 0x080, 1       ; Enable RB1 for Output
bcf    TRISB ^ 0x080, 2       ; Enable RB2 for Output
movlw 0x07F                  ; Enable Internal Pull-Ups
movwf OPTION_REG ^ 0x080
bcf    STATUS, RP0


is probably a bit confusing. To help explain what I have done, I wanted to explain a few things. The first is, in the PICMicro, upon power up, the "TRIS" ("TRI-State Enable" registers, which control the Input/Output operation of the PICmicro's I/O registers) have all their bits "set" (equal to "1") which puts the I/O pins into "input" mode. To put the pins into "output" mode, I simply "reset" (make equal to "0") the appropriate pins of the TRIS registers.
The TRIS (and "Option") Registers are located in "Bank 1" of the PICMicro 16F84's register space. Instead of resetting individual bits, I could have written full bytes to the registers like:

bsf STATUS RP0 ; Point to "Bank 1" movlw 0x0F9 ; Make RB1 and RB2 output movwf TRISB ^ 0x080 movlw 0x07F ; Enable the Internal Pull Ups movwf OPTION_REG ^ 0x080 bcf STATUS, RP0 ; Return to "Bank 0"
This works just as well. When the PICMicro first boots up, the "OPTION" register has all its bits set (like the TRIS registers) which means that to just enable the internal pull ups the instruction:

bcf OPTION_REG ^ 0x080, 7
could be used.
A common question from people just learning about the PICMicro and see other people's code is the use of "^ 0x080" when writing to "Bank 1" registers. In the mid-range PICMicros, up to 128 addresses can be accessed, which requires seven addressing bits. A byte is eight bits which leaves an additional bit for selecting between "Bank 0" and "Bank 1". Because the TRIS and OPTION registers are in Bank 1, this bit is normally set in the register addresses in the Microchip provided register definition files.
If bit seven of the address is set with an instruction, then the MPLAB assembler returns a "warning" to the user. This warning can be masked out using the "error" directive (like I use in the code above), but the accepted way of eliminating this problem is to set "RP0" of the STATUS register (making accesses access Bank 1 registers) and then XOR ("^") bit seven.
The reason for this convention is to add the "^ 0x080" characters to all addressed instructions between the "bsf STATUS, RP0" and "bcf STATUS, RP0" instructions and if any registers which are not in Bank 1 are accessed, the assembler will come back with a warning indicating that there is a register which is incorrectly accessed.
Another option is to use the "TRIS" and "OPTION" instructions which move the data bytes in the "w" (accumulator) register directly in to the TRIS and OPTION registers. Using these instructions would eliminate the need for the "bsf/bcf STATUS, RP0" instructions that I use above. The equivalent code would become:

movlw 0x0F9 ; Make RB1 and RB2 output TRIS PORTB movlw 0x07F ; Enable the Internal Pull Ups OPTION
These instructions are carry overs into the "mid-range" architecture from the "low-end" PICMicro architecture and Microchip indicates that these instructions may disappear in future products. The only real disadvantage to using these instructions is that the contents of the TRIS and OPTION registers cannot be read back. There is some debate over whether or not the instructions will ever disappear, so whether or not you use them, is up to you.
To develop the application, I used "MPLAB". If you haven't downloaded this excellent tool yet, then I highly recommend that you do so. Along with providing a simple "Windows-style" editor and and assembler, the tool also provides a source-code compatible simulator that is very easy to work with.

Even though this application is quite simple, I did set up a "watch" window" along with the "asynchronous inputs" to test out the application before I burned it into a 16F84.

Simulating an application before burning a part is probably the most effective way of ensuring the application will work when you first apply power to it. By simulating the application and testing out its function, you are eliminating one variable in the list of possible problems why an application won't work.

MPLAB is pretty easy to figure out how it works and includes a simple tutorial. If you are interested in learning more about it and how I work with it, please send me an email and I can answer the questions in a future article.

I wanted to end up this discussion on a developer's first application by discussing different ways the code could be written. I think I've beaten the different ways of setting the TRIS and OPTION registers appropriately, but there is also a number of different ways in which the mainline code could be written.

For example, instead of:

Loop btfsc PORTB, 0 ; Is the Button Pressed? goto ButtonUp ; No, Light Off bcf PORTB, 2 ; Turn Light On goto Loop ButtonUp ; Button Up, Turn Light Off bsf PORTB, 2 goto Loop
which sets or resets the button state LED according to the button's state, I could have coded this section as:

Loop movf PORTB, w ; Set/Reset RB2 According to Button iorlw 0x004 btfss PORTB, 0 andlw 0x0FB ; Turn on the LED if the Button is Low movwf PORTB goto Loop
Which executes in the same number of cycles for each loop (the original doesn't).
You might be tempted to simplify this to:

Loop bsf PORTB, 2 ; Set the Bit Assuming Button is up btfss PORTB, 0 bcf PORTB, 2 ; Reset the Bit if Button Pressed goto Loop
which will give you some interesting and probably unexpected results. Why don't you try it and figure out what is actually happening here?
In the PICMicro, like all programming situations, there are a lot of different ways to do something. My way of doing something is really my way, based on previous experiences and my way of thinking. Your way of thinking and previous experiences may be different and lead you to different or better ways of doing things. I highly recommend that when you start out in any new programming situation, that you try different ways of attacking a problem and writing your application code.
Not only will you learn much faster what is the best way to do things in a given situation but you will become an expert in finding problems much faster.
Just to follow up on last week's article about programmers and to show how an in-circuit programmer, such as my "YAP" can be of advantage. Using the YAP, Just the two LEDs and button have to be wired into the circuit because the YAP provides the "core" (power, clocking and reset) functions. This simplifies the circuit assembly by quite a bit as the following picture shows:

For this circuit, I was able to wire up the two LEDs, button and Vcc/Ground connections in literally two minutes. While this isn't a huge savings in effort (it probably took me ten minutes to wire the circuit into the bread board as shown at the top of this article), it does have the advantage of not requiring the developer to pull the device (and create a circuit which has access to be able to pull the device) every time they want to try something new (like I presented above). Unless you have a "ZIF" ("Zero Insertion Force") socket, this operation can be tedious and potentially damaging to the chip. Because the "YAP" leaves the PICMicro in place, there is less opportunity for the PICMicro to be damaged.

The simple circuit and code that I've shown here should really be the culmination of a lot of work. To get to this point, you should have become familiar with the following topics:

1. PICMicro device execution with power, clocking and reset
2. The PICMicro processor architecture and instruction operation
3. Code development tools and application simulating
4. device programming
5. PICMicro application debug

This is not a trivial amount of learning to do before you can develop your own application successfully. As well, depending on the complexity of the application, the amount of information to be worked through can be considerably more.

The circuit provided in this article can be used as a basis for other applications. For example, the execution "core" used, tested and wired in this circuit could be used for the LCD applications (the 2-wire interface and walking man) I presented in the first two articles.

email Questions and Comments

I received a couple of questions and comments this week about my LCD articles that I wanted to discuss. The first is a pointer from the PICList about the operation of Hitachi 44780 based LCDs. In my article (and on my LCD web page), I indicated that the 44780 was level triggered and the "E" Strobe line (used to latch in data/start an LCD operation) had to be "high" (logic "1") for at least 450 nsecs.

This seems to be not quite true. The comments both on the PICList and from Tom McGahee indicate that the Strobe is actually negative level (from "high" to "low") active. This makes sense with the 2-wire LCD interface I presented a few weeks ago because when the least significant bit is set, then the "E" Strobe will be high without ever going low before the data is strobed in.

This information doesn't change the code presented for the 2-wire LCD interface, but helps explain why there isn't a problem. To be on the safe side, always make sure that there is a 450 nsec or more delay between a line changing state and the "E" Strobe going low.

The other question, from Marcelo Cesar Asti was based on the 2-wire LCD code and how to use the "#DEFINE" information to reset the TRIS register bits for the output bits. If you look at "2wirelcd.asm", I "hardcoded" the TRIS bit writes with:

movlw 0x01C ; Enable PA0 & PA1 for Output bsf STATUS, RP0 movwf TRISA ^ 0x080 bcf STATUS, RP0
This code will not allow the "#DEFINES" to be changed for arbitrary I/O bits to be used for the 2-wire LCD interface.
Instead, the code:

bsf STATUS, RP0 bcf Data ; Clear the "Data" & "Clock" bits bcf Clock ; in the TRIS Registers bcf STATUS, RP0

program for Dual DAC, RAMP wave in 8051

2011-07-15T09:55:00.001-07:00

#include <REG51xD2.H>

main()

{

unsigned char i=0;

P0 = 0x00; /* P0 as Output port */

while(1)

{

for(i=0;i<0xff;i++)

{

P1 = i;

P0 = i;

}

P0 = 0;

P1 =0;

}

Demonstrate how to multiplex 64 LED's,

2011-07-15T09:54:00.001-07:00

These tutorials demonstrate how to multiplex 64 LED's, arranged as a matrix of 8x8, we use one port to 'source' the columns, and another port to 'sink' the rows. So the Multiplex LED board requires two port connections, one for rows and one for columns - notice that NEITHER of these have the 0V or 5V pins connected, they aren't used at all. The technique of multiplexing allows you to individually access any one LED, or any combination of LED's, with just sixteen output pins.

It's also worth noting that we're driving the LED's entirely from the PIC, which is why I chose 150 ohm current limiting resistors, this keeps the current down to within the PIC's individual pin limits, and also within the overall chip limits - but both are pushed pretty close!, this is done to get as much brightness as possible from the LED's, whilst minimising the component count on the board. Because of the current requirements the processor board MUST have a 7805 regulator, a 78L05 won't provide enough current.

The technique used for the display is to show each section in turn, so we display row 1, then row 2, then row 3, and continue through the other five rows - as long as we do this fast enough you can't see any flickering - this obviously restricts what else the program can be doing, as we must refresh the display regularly enough to prevent visible flicker. As with the previous 7 segment multiplexing tutorial, I'm again using timer driven interrupts in order to transparently refresh the LED matrix - and the code is basically very similar (and simply modified from it).

The interrupts are generated by Timer2, which is set to give an interrupt roughly every 16mS. Interrupts in a PIC cause the program to stop what it's doing, save it's current location, and jump to the 'Interrupt Vector' - which on a PIC is address 0x0004. The interrupt routine then does what it needs to do and exits using the 'REFIE' (REturn From IntErrupt) command - this works rather like a normal 'RETURN' in that it returns the program to where it was when the interrupt was called. An important point to bear in mind when using interrupts is that you mustn't change anything the main program is using - for that reason the first thing we must do is save various resisters - the W register, the PCLATH register, and the STATUS register - these are saved in data registers allocated for their use, and are restored before the routine exits via 'RETFIE'.

The interrupt routine is shown below, the first 5 lines save the registers mentioned above, the 'swapf' command is used as it doesn't affect the STATUS register, there's not much point saving the register if we've already changed it!. Next we check is the interrupt was generated by the timer or not, in this case we're only using one interrupt source (TIMER2) - but often you may be using multiple interrupt sources, if it's not TIMER2 we simply jump to the EXIT routine, which restores the registers saved and exits via RETFIE.

Now we start the actual interrupt routine itself, the first thing we have to do is reset TIMER2 - once it's triggered an interrupt it turns itself off, so we turn it back on here (bcf PIR1,TMR2IF). Next we start our display routine, first we need to find out which display we're updating - in this case we're selecting one of eight display ROWS in turn, we do this by simply checking which was the previous display (using seven 'btfss' instructions, with each one jumping to a different routine to set the new ROW to be displayed) - I originally tried to do this directly using the PORT register, but it didn't really work, so I added a GPR (row_pos) which I use to store the position. We only need seven tests, because if those seven fail it MUST be the eighth one that was the previous row. The actual values for the eight columns are stored in the variables 'zero', 'one', 'two' etc. Each of the eight row display routines (Do_Zero etc.) first turns OFF the previous row, which will blank the complete display, then preload the column data from the respective register. Lastly it turns that row ON, to display the data for that row. There's probably no need to blank the display before displaying the new row?, but it ensures that only one row at a time is ever displayed - and it only costs 400nS extra time with a 20MHz clock.

; Interrupt vector

ORG 0x0004

INT
movwf w_temp ; Save W register
swapf STATUS,W ; Swap status to be saved into W
movwf s_temp ; Save STATUS register
movfw PCLATH
movwf p_temp ; Save PCLATH

btfss PIR1,TMR2IF ; Flag set if TMR2 interrupt
goto INTX ; Jump if not timed out

; Timer (TMR2) timeout every 16 milliseconds

bcf PIR1,TMR2IF ; Clear the calling flag

btfss row_pos, 0 ;check which ROW was last
goto Do_One
btfss row_pos, 1 ;check which ROW was last
goto Do_Two
btfss row_pos, 2 ;check which ROW was last
goto Do_Three
btfss row_pos, 3 ;check which ROW was last
goto Do_Four
btfss row_pos, 4 ;check which ROW was last
goto Do_Five
btfss row_pos, 5 ;check which ROW was last
goto Do_Six
btfss row_pos, 6 ;check which ROW was last
goto Do_Seven

Do_Zero movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf zero, w
movwf COL_PORT ;load columns
bcf row_pos, 0
bcf ROW_PORT, 0 ;turn ON row zero
goto INTX

Do_One movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf one, w
movwf COL_PORT ;load columns
bcf row_pos, 1
bcf ROW_PORT, 1 ;turn ON row one
goto INTX

Do_Two movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf two, w
movwf COL_PORT ;load columns
bcf row_pos, 2
bcf ROW_PORT, 2 ;turn ON row two
goto INTX

Do_Three movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf three, w
movwf COL_PORT ;load columns
bcf row_pos, 3
bcf ROW_PORT, 3 ;turn ON row three
goto INTX

Do_Four movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf four, w
movwf COL_PORT ;load columns
bcf row_pos, 4
bcf ROW_PORT, 4 ;turn ON row four
goto INTX

Do_Five movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf five, w
movwf COL_PORT ;load columns
bcf row_pos, 5
bcf ROW_PORT, 5 ;turn ON row five
goto INTX

Do_Six movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf six, w
movwf COL_PORT ;load columns
bcf row_pos, 6
bcf ROW_PORT, 6 ;turn ON row six
goto INTX

Do_Seven movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf seven, w
movwf COL_PORT ;load columns
bcf row_pos, 7
bcf ROW_PORT, 7 ;turn ON row seven

INTX
movfw p_temp
movwf PCLATH ; Restore PCLATH
swapf s_temp,W
movwf STATUS ; Restore STATUS register - restores bank
swapf w_temp,F
swapf w_temp,W ; Restore W register
retfie

The interrupt routine above is complete and working, but it requires TIMER2 setting up before it can work, this is done in the 'Initialise' section of the program, which is the first section called when the program runs. This first turns the analogue inputs off, then sets the direction registers for the Ports to all outputs, then sets TIMER2 to the correct time, you will notice there's two lines (with one commented out) for setting the value of T2CON - if you comment out the second one, and use the first one, it makes the interrupt routine timing too slow - you can actually see the digits flickering, first one then the other - worth doing so you can see what's going on. After that we set up PR2, this sets the value that the timer counts to before it times out - then we enable TIMER2 interrupts by setting the TMR2IE flag in register PIE1. This still isn't enough, so finally we write to the INTCON register to enable 'Peripheral Interrupts' and 'Global Interrupts'.

Initialise BANKSEL ADCON1 ;disable analogue inputs
movlw 0x06
movwf ADCON1
BANKSEL PORTA
bsf STATUS, RP0 ;select bank 1
movlw b'00000000' ;Set port data directions, data output
movwf ROW_TRIS
movwf COL_TRIS
bcf STATUS, RP0 ;select bank 0

clrf COL_PORT ;turn OFF all LED's
movlw 0xFF
movwf ROW_PORT

call Clear ;clear display registers

; Set up Timer 2.

;movlw b'01111110' ; Post scale /16, pre scale /16, TMR2 ON
movlw b'00010110' ; Post scale /4, pre scale /16, TMR2 ON
movwf T2CON

bsf STATUS, RP0 ;select bank 1

movlw .249 ; Set up comparator
movwf PR2

bsf PIE1,TMR2IE ; Enable TMR2 interrupt

bcf STATUS, RP0 ;select bank 0

; Global interrupt enable

bsf INTCON,PEIE ; Enable all peripheral interrupts
bsf INTCON,GIE ; Global interrupt enable

bcf STATUS, RP0 ;select bank 0

This is the main section of the first program, as you can see there's not a great deal to it, all it does it display a 'square' using the outer layer of LED's, delay 1 second, then 'invert' the display (make lit ones dark, and dark ones lit), and delay a further second, then loop back, this give a simple flashing square pattern on the display. As with the previous interrupt multiplexing tutorial, the display function is handled totally transparently by the interrupt routine - all we need to do is place the values required in the eight display data registers.

Main call Square ;display a square
call Delay1Sec
call Invert ;and clear it
call Delay1Sec
goto Main ;endless loop

Tutorial 13.1

This tutorial flashes an inverting 'square' at 1 second intervals. To display a pattern, we simply write it to the eight data registers, zero is the bottom line, and seven is the top. To invert the display we simple XOR the display registers with 0xFF.

Tutorial 13.2

Where the previous tutorial used just eight display registers, this second one uses two sets of eight - one is the same as before (the actual registers which get displayed), the second is a duplicate set - labelled zero1 to seven 1. This allows a range of simple effects by changing from one to the other, and this tutorial gives routines for scrolling in all four directions, and displaying numeric digits. The code presented scrolls the digits 0 to 9 from left to right, right to left, bottom to top, and top to bottom, on the display. It's pretty obvious how the other routines can be used, just load the second set of registers, and call them as you wish. Here's a 20 second video clip of the scrolling in action LED1.WMV

Tutorial 13.3

Following on from the previous tutorial, this one adds the rest of the ASCII character set, including upper and lower case letters. The fonts used is based on the Hitachi text LCD character set - but as I've an extra line I've added true descenders on those characters which have them. Rather then the previous simple method of storing the character maps, this tutorial stores them in a large table - as the table exceeds the normal 256 byte table limit, we use an extended 16 bit table to provide sufficient room for all the data, this also overcomes the 256 byte boundary problem. The tutorial itself simply scrolls the entire character set (starting with a space) from left to right.

Tutorial 13.4

This is tutorial 13.3 with an extra table added, which is used to store a string to be displayed - the string scrolls across the display from right to left, the string can easily be changed, and as before is stored as a large table - you just need to add a 0x00 at the end to signify the end of the string.