MOTOR programming using PWM and USART (PIC16F877A)

#include<pic.h>
void main()
{
char a;
TRISB=0X00;
TRISC=0X80;
TMR2ON=1;
CCP1CON=0X0C;
TXSTA=0X24;
RCSTA=0X90;
SPBRG=0X19;
PORTB=0X03;
while(RCIF==0);
a=RCREG;
RCIF=0;
switch(a)
{
case '1':
{CCPR1L=0;
 break;
}
case '2':
{CCPR1L=50;
 break;
}
case '3':
{CCPR1L=100;
 break;
}
case '4':
{CCPR1L=250;
 break;
}
}
}

)

PWM programming of PIC16F877A

#include<pic.h>
void delay(int);
void main()

{
TRISC=0X80;
TMR2ON=1;

CCP1CON=0X0C;
CCP2CON=0X0C;

CCPR1L=0;
CCPR2L=0;
delay(1);

CCPR1L=255;
CCPR1H=0X00;
delay(1);
CCPR1L=200;
CCPR1H=0X00;
delay(1);
CCPR1L=170;
CCPR1H=0X00;
delay(1);
CCPR1L=100;
CCPR1H=0X00;
delay(1);
CCPR1L=0;
CCPR1H=0X00;
while(1);


}
void delay(int a)
{
int i;
for(i=0;i<a*1000;i++);
}

ADC programming of PIC16F877A

Convert the analog value(pot) to digital and display it on lcd

#include<pic.h>
void delay();
void cmd(int);
void data(char);
void main()
{
int a,e,i;
char b[]="00000";
TRISB=0X00;
TRISC=0X00;
cmd(0X38);
cmd(0X01);

cmd(0X0E);
cmd(0X80);

ADCON0=0X01;
ADCON1=0X00;
ADGO=1;
while(ADGO==0);
e=ADRESH;
for(i=0;e>0;i++)
{
a=e%10;
e=e/10;
a=a+48;
b[i]=a;
}
data('a');
for(i=2;i>=0;i--)
data(b[i]);

ADCON0=0X09;
ADCON1=0X00;
ADGO=1;
while(ADGO==0);
e=ADRESH;
for(i=0;e>0;i++)
{
a=e%10;
e=e/10;
a=a+48;
b[i]=a;
}
cmd(0XC0);
data('b');
for(i=2;i>=0;i--)
data(b[i]);
delay();
delay();
}
void cmd(int s)
{
PORTB=s;
RC0=0;
RC1=1;
delay();
RC1=0;
}

void data(char a)
{
PORTB=a;
RC0=1;
RC1=1;
delay();
RC1=0;
}
void delay()
{
int k,j;
for(k=0;k<100;k++)
for(j=0;j<100;j++);
}

USART INTERRUPT PROGRAMMING OF PIC16F877A(RECEIVER INTERRUPT)

#include<pic.h>
void transmit();
void main()
{
TXSTA=0X24;
RCSTA=0X90;
SPBRG=0X19;
TRISB=0X80;
RCIE=1;
GIE=1;
PEIE=1;
}
void interrupt isr()
{
char a;
if(RCIF==1)
{
a=RCREG;
transmit();
RCIF=0;
}

}
void transmit()
{
TXREG='t';
while(TXIF==0);
TXIF=0;
}

TIMER INTERRUPT PROGRAMMING OF PIC16F877A

Blink a port in every 1sec

#include<pic.h>
void delay(int);
int m=0;
void main()
{
TRISC=0X00;
OPTION=0X07;
TMR0=0X00;
GIE=1;
PEIE=1;
TMR0IE=1;
while(1);
}
void interrupt isr()
{
if(TMR0IF==1)
{
m++;
while(m<30)
{
PORTC=0XFF;
delay(10);
PORTC=0X00;
delay(10);
}
}
delay(100);
TMR0IF=0;
}
void delay(int k)
{
int j,i;
for(i=0;i<k;i++)
for(j=0;j<1000;j++);
}

EXTERNAL INTERRUPT PROGRAMMING OF PIC16F877A

Blinking of a port when a switch is pressed (switch is connected to the external interrupt pin)

#include<pic.h>
void delay(int);
void main()
{
int i;
TRISB=0XFF;
TRISC=0X00;
GIE=1;
PEIE=1;
INTE=1;
while(1)
{
PORTC=0X80;
for(i=0;i<8;i++)
{
PORTC=PORTC>>1;
}
}
}
void interrupt isr()
{
if(INTF==1)
{
PORTC=0XFF;
delay(25);
PORTC=0X00;
delay(25);
}
INTF=0;
}
void delay(int k)
{
int i,j;
for(i=0;i<k;i++)
for(j=0;j<1000;j++);

}

PIC16F877A Interrupt Programming:REGISTERS

TIMER2 MODULE OF PIC16F877A

Timer2 is an 8-bit timer with a prescaler and a postscaler. It can be used as the PWM time base for the PWM mode of the CCP module(s). The TMR2 register is readable and writable and is cleared on any device Reset. The input clock (FOSC/4) has a prescale option of 1:1, 1:4 or 1:16, selected by control bits T2CKPS1:T2CKPS0 (T2CON<1:0>).The Timer2 module has an 8-bit period register, PR2.Timer2 increments from 00h until it matches PR2 and then resets to 00h on the next increment cycle. PR2 is a readable and writable register. The PR2 register is initialized to FFh upon Reset.
The match output of TMR2 goes through a 4-bit postscaler (which gives a 1:1 to 1:16 scaling inclusive) to generate a TMR2 interrupt (latched in flag bit, TMR2IF (PIR1<1>)). Timer2 can be shut-off by clearing control bit, TMR2ON (T2CON<2>), to minimize power consumption.

Program to Generate a 1s delay ....

#include<pic.h>
void timer();
void main()
{
TRISD=0X00;
T2CON=0X7E;
while(1)
{
PORTD=0XFF;
timer();
PORTD=0X00;
timer();
}
}
void timer()
{
int i;
TMR2=0X00;
for(i=0;i<15;i++)
{
while(TMR2IF==0);
TMR2IF=0;
}
}

Generate a 1s delay using TIMER1 in PIC16F877A

#include<pic.h>
void timer();
void main()
{
TRISD=0X00;
T1CON=0X39;
while(1)
{
PORTD=0XFF;
timer();
PORTD=0X00;
timer();
}
}
void timer()
{
int i;
TMR1L=0X00;
TMR1H=0X00;
for(i=0;i<2;i++)
{
while(TMR1IF==0);
TMR1IF=0;
}
}

TIMER1 MODULE OF PIC16F877A

The Timer1 module is a 16-bit timer/counter consisting of two 8-bit registers (TMR1H and TMR1L) which are readable and writable. The TMR1 register pair (TMR1H:TMR1L) increments from 0000h to FFFFh and rolls over to 0000h. The TMR1 interrupt, if enabled, is generated on overflow which is latched in interrupt flag bit, TMR1IF (PIR1<0>). This interrupt can be enabled/disabled by setting/clearing TMR1 interrupt enable bit, TMR1IE (PIE1<0>). Timer1 can operate in one of two modes:

• As a Timer

• As a Counter

The operating mode is determined by the clock select bit, TMR1CS (T1CON<1>).In Timer mode, Timer1 increments every instruction cycle. In Counter mode, it increments on every rising

edge of the external clock input. Timer1 can be enabled/disabled by setting/clearing

control bit, TMR1ON (T1CON<0>). Timer1 also has an internal “Reset input”. This Reset

can be generated by either of the two CCP modules.When the Timer1 oscillator is enabled (T1OSCEN is set), the RC1/T1OSI/CCP2 and RC0/T1OSO/T1CKI pins become inputs. That is, the TRISC<1:0> value is ignored and these pins read as ‘0’. Additional information on timer modules is available in the PICmicro® Mid-Range MCU Family Reference Manual (DS33023).

Digital Clock using Timer0 in PIC16F877A

#include<pic.h>
void print(int);
void delay();
void dela();
void cmd(int);
void data(char);
char keypad();
void main()
{
int i,j=0,k=0,l=0,o=0;
int a,b,c,d,e,f;
OPTION=0X07;
TRISB=0X00;
TRISC=0X00;
TRISD=0X0F;
cmd(0x38);
cmd(0X0E);
cmd(0X06);
cmd(0X01);
cmd(0X80);
delay();
a=keypad();
data(a);
delay();
b=keypad();
data(b);
delay();
data(':');
c=keypad();
data(c);
delay();
d=keypad();
data(d);
delay();
data(':');
e=keypad();

data(e);
delay();
f=keypad();
data(f);
j=(e-48)*10+(f-48);
k=(c-48)*10+(d-48);
l=(a-48)*10+(b-48);

while(1)
{
TMR0=0X00;
for(i=0;i<15;i++)
{
while(TMR0IF==0);
TMR0IF=0;
}
cmd(0X80);
j++;
if(j>59)
{
j=0;
k++;
}
if(k>59)
{
k=0;
l++;
}
if(l>11)
{
l=0;
cmd(0X01);
o++;
}
print(l);
data(':');
print(k);
data(':');
print(j);
if(o%2==0)
{
data(' ');
data(' ');
data('A');
data('M');
}
else
{
data(' ');
data(' ');
data('P');
data('M');
}
}
}
void print(int h)
{
int c,p,a[2],q;
if(h==0)
data(0+48);
for(p=0;h>0;p++)
{
c=h%10;
h=h/10;
a[p]=c;
}
for(q=p-1;q>=0;q--)
data(a[q]+48);
}
void cmd(int s)
{
PORTB=s;
RC0=0;
RC1=1;
dela();
RC1=0;
}

void data(char a)
{
PORTB=a;
RC0=1;
RC1=1;
dela();
RC1=0;
}
void dela()
{int i,j;
for(i=0;i<100;i++)
for(j=0;j<100;j++);
}
void delay()
{int i,j;
for(i=0;i<100;i++)
for(j=0;j<1000;j++);
}
char keypad()
{
int e;
PORTD=0X7F;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
return '1';
break;
case 0X0B:
return '2';
break;
case 0X0D:
return '3';
break;
case 0X0E:
return('4');
break;
}
PORTD=0XBF;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
return('4');
break;
case 0X0B:
return('5');
break;
case 0X0D:
return('6');
break;
case 0X0E:
return('7');
break;
}
PORTD=0XDF;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
return('8');
break;
case 0X0B:
return('9');
break;
case 0X0D:
return('0');
break;
case 0X0E:
return('A');
break;
}
PORTD=0XEF;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
return('B');
break;
case 0X0B:
return('C');
break;
case 0X0D:
return('D');
break;
case 0X0E:
return('E');
break;
}
}

Program to Blink PORTC when TIMER0 overflows....

#include<pic.h>
void delay(int);
void main()
{
TRISC=0X00;
OPTION=0X07;
TMR0=0X00; 
while(TMR0IF==0);
while(1)
{
PORTC=0XFF;
delay(10);
PORTC=0X00;
delay(10);
}
}
void delay(int k)
{
int j,i;
for(i=0;i<k;i++)
for(j=0;j<1000;j++);
}

TIMER0 MODULE OF PIC16F877A

The Timer0 module timer/counter has the following
features:
• 8-bit timer/counter
• Readable and writable
• 8-bit software programmable prescaler
• Internal or external clock select
• Interrupt on overflow from FFh to 00h
• Edge select for external clock

Figure  is a block diagram of the Timer0 module andthe prescaler shared with the WDT.

Additional information on the Timer0 module is available in the PICmicro® Mid-Range MCU Family

Reference Manual (DS33023). Timer mode is selected by clearing bit T0CS (OPTION_REG<5>). In Timer mode, the Timer0 module will increment every instruction cycle (without prescaler). If the TMR0 register is written, the increment is inhibited for the following two instruction cycles.

The user can work around this by writing an adjusted value to the TMR0 register.Counter mode is selected by setting bit T0CS (OPTION_REG<5>). In Counter mode, Timer0 will increment either on every rising or falling edge of pin RA4/T0CKI. The incrementing edge is determined by the Timer0 Source Edge Select bit, T0SE (OPTION_REG<4>). Clearing bit T0SE selects the rising edge.

Display the characters between * and # using USART in PIC16F877A

#include<pic.h>
void main()
{

char c;
TRISC=0X80;
TXSTA=0X24;
RCSTA=0X90;
SPBRG=0X19;

while(RCIF==0);
c=RCREG;
RCIF=0;
if(c=='*')
while(1)
{
while(RCIF==0);
c=RCREG;
RCIF=0;
if(c=='#')
break;
TXREG=c;
while(TXIF==0);
TXIF=0;
}
}

USART ASYNCHRONOUS RECEPTION (PIC16F877A)

#include<pic.h>
void cmd(int);
void data(char);
void delay();
void main()
{
char c;
TRISB=0X00;
TRISC=0X80;
TXSTA=0X24;
RCSTA=0X90;
SPBRG=0X19;

cmd(0X38);
cmd(0X01);
cmd(0X06);
cmd(0X0E);
cmd(0X80);

while(1)
{
while(RCIF==0);
{
c=RCREG;
data(c);
RCIF=0;
}
}
}
void cmd(int a)
{
PORTB=a;
RC0=0;
RC1=0;
RC2=1;
delay();
RC2=0;
}

void data(char s)
{
PORTB=s;
RC0=1;
RC1=0;
RC2=1
delay();
RC2=0;
}

void delay()
{
int i,j;
for(i=0;i<100;i++)
for(j=0;j<100;j++);
}

USART ASYNCHRONOUS TRANSMITTER (PIC16F877A)

#include<pic.h>

void main()

{

TRISC=0X80;;

TXSTA=0X24;

RCSTA=0X90;

SPBRG=0X19;

TXREG='A';

while(TXIF==0);

TXIF=0;

while(1);

}

PIC16F877A : USART programing(Registers and its functions)

4x4 Keypad programming in PIC16F877A( text on LCD(LM016L) according to buttons pressed )

#include<pic.h>
void delay(int);
void cmd(int);
void data(char);
void main()
{
int e;
TRISB=0X00;
TRISC=0X00;
TRISD=0X0F;
cmd(0X38);
cmd(0X01);
cmd(0X0E);
cmd(0X06);
cmd(0X80);
while(1)
{
PORTD=0X7F;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
data('1');
break;
case 0X0B:
data('2');
break;
case 0X0D:
data('3');
break;
case 0X0E:
data('4');
break;
}
PORTD=0XBF;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
data('5');
break;
case 0X0B:
data('6');
break;
case 0X0D:
data('7');
break;
case 0X0E:
data('8');
break;
}
PORTD=0XDF;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
data('9');
break;
case 0X0B:
data('0');
break;
case 0X0D:
data('A');
break;
case 0X0E:
data('B');
break;
}
PORTD=0XEF;
e=PORTD&0X0F;
switch(e)
{
case 0X07:
data('C');
break;
case 0X0B:
data('D');
break;
case 0X0D:
data('E');
break;
case 0X0E:
data('F');
break;
}
}
}
void cmd(int s)
{
PORTB=s;
RC0=0;
RC1=0;
RC2=1;
delay(10);
RC2=0;
}

void data(char a)
{
PORTB=a;
RC0=1;
RC1=0;
RC2=1
delay(10);
RC2=0;
}
void delay(int k)
{
int i,j;
for(i=0;i<k;i++)
for(j=0;j<1000;j++);
}

16X2 LCD (LM016L) Programming in PIC (display the message "hello world")

#include<pic.h>
void delay();
void cmd(int);
void data(char);

void main()
{
int i;
char a[]="hello world";
TRISC=0X00;
TRISD=0X00;
cmd(0x38);
cmd(0X0E);
cmd(0X06);
cmd(0X01);
cmd(0X80);

for(i=0;a[i]!='\0';i++)
data(a[i]);
}
void cmd(int s)
{
PORTD=s;
RC0=0;
RC1=0;
RC2=1;
delay();
RC2=0;
}

void data(char a)
{
PORTD=a;
RC0=1;
RC1=0;
RC2=1;
delay();
RC2=0;
}
void delay()
{
int k,j;
for(k=0;k<100;k++)
for(j=0;j<100;j++);
}

LED Blinking and Chaser using 2 switches in PIC

#include<pic.h>
void DELAY();
void main()
{
int i;
TRISB=0X00;                          // PORT B as output 
TRISC=0XFF;                         //  PORT C as input
while(1)
{
if(RC0==1)                             // RC0 input for led blinking
{
PORTB=0XFF;
DELAY();
PORTB=0X00;
DELAY();
}
else if(RC1==1)                      // RC1 input for chaser
{
PORTB=0X01;
DELAY();
for(i=0;i<8;i++)
{
PORTB=PORTB<<1;
DELAY();
}
}
}
}
void DELAY()
{
int i,j;
for(i=0;i<100;i++)
for(j=0;j<100;j++);
}