Getting Started and Creating Applications

187

The 8051 provides interrupt services for many on-chip peripheral events.

9

Interrupts are globally enabled and disabled using the EA bit of the Interrupt

Port

Direction

Width

Alternate Use

P0

I/O

8 bits

Mux’d. 8-bit bus:

A0-A7 & D0-D7

P1

I/O

8 bits

P1.0-P1.7:

Available for User I/O

P2

I/O

8 bits

Mux’d. 8-bit bus:

A8-A15

P3

I/O

8 bits

P3.0:

RXD (Serial Port Receive)

P3.1:

TXD (Serial Port Transmit)

P3.2:

/INT0 (Interrupt 0 Input)

P3.3:

/INT1 (Interrupt 1 Input)

P3.4:

T0 (Timer/Counter 0 Input)

P3.5:

T1 (Timer/Counter 1 Input)

P3.6:

/WR (Write Data Control)

P3.7:

/RD (Read Data Control)

be either inputs or outputs. To write to a port, you simple write the value you

want to appear on the port pins. To read from a port, you must first write a 1 to

9

the desired port bit (which is also the initial value after chip RESET).

The following example program shows how to read and write to I/O pins.

sfr

P1

= 0x90;

// SFR definition for Port 1

sfr

P3

= 0xB0;

// SFR definition for Port 3

sbit DIPswitch = P1^4;

// DIP switch input on Port 1 bit 4

sbit greenLED

= P1^5;

// green LED output on Port 1 bit 5

void main (void) {

unsigned char inval;

inval = 0;

// initial value for inval

while

(1)

{

if (DIPswitch == 1) {

// check if input P1.4 is high

inval = P1 & 0x0F;

// read bit 0 .. 3

from P1

greenLED = 0;

// set output P1.5

to low

}

else {

// if input P1.4 is low

greenLED = 1;

// set output P1.5

to high

}

P3 = (P3 & 0xF0) | inval;

// output inval to P3.0 .. P3.3

Getting Started and Creating Applications

189

The 80C52 has three timer/counter units (Timer 0, Timer 1, and Timer 2).

9

Timer 0 and Timer 1 are very similar and offer the same functionality while

overflow_count++;

// Increment the overflow count

}

TH1 = 256 - 100;

// Reload TL1 to count 100

clocks

TL1 = TH1;

ET1 = 1;

// Enable Timer 1 Interrupts

TR1 = 1;

// Start Timer 1 Running

EA = 1;

// Global Interrupt Enable

Serial Interface

9

The 8051 includes a standard RS-232 compatible serial port you may use with

your application programs. The 8051 uses port pins P3.1 and P3.0 for transmit

and receive respectively. There are several SFRs that you must properly

configure before the serial port will function.

The 8051 provides full interrupt control for the serial port transmit and receive

operations. You may poll the serial port control registers to determine when a

character has been received or when the next character may be sent or you may

create interrupt routines to handle these operations.

The serial interface is configured with the SFR registers SBUF, SCON and

PCON. In addition, you must also configure Timer 1 or Timer 2 as the baud

rate generator.

The following example program shows how to perform interrupt-driven serial

I/O using the 8051 serial port. Interrupt routines in this example handle transmit

interrupts and receive interrupts using 8-byte circular buffers. Routines are

provided to transmit (putbuf and putchar) and receive (_getkey) characters and

to initialize the serial channel (com_initialize). This source code can be used as

replacement for the library routines putchar and _getkey. This also allows the

printf, scanf and other library functions to work with the interrupt-driven I/O

routines in this example.

#include <reg51.h>

#include <stdio.h>

#define XTAL

11059200

// CPU Oscillator Frequency

#define baudrate

9600

// 9600 bps communication baudrate

#define

OLEN

8

// size of serial transmission buffer

unsigned char

ostart;

// transmission buffer start index

unsigned char

oend;

// transmission buffer end index

char idata

outbuf[OLEN];

// storage for transmission buffer

#define

ILEN

8

// size of serial receiving buffer

unsigned char

istart;

// receiving buffer start index

unsigned char

iend;

// receiving buffer end index

char idata

inbuf[ILEN];

// storage for receiving buffer

bit

sendfull;

// flag: marks transmit buffer full

bit

sendactive;

// flag: marks transmitter active

Getting Started and Creating Applications

191

/*----- Received data interrupt. ----------------------------------------*/

if (RI)

{

c = SBUF;

// read character

9

RI = 0;

// clear interrupt request flag

if (istart + ILEN != iend) {

} inbuf[iend++ & (ILEN-1)] = c;

// but character into buffer

}

/*------ Transmitted data interrupt. ------------------------------------*/

if (TI != 0)

{

TI = 0;

// clear interrupt request flag

if (ostart != oend) {

// if characters in buffer and

SBUF = outbuf[ostart++ & (OLEN-1)];

// transmit character

sendfull = 0;

// clear 'sendfull' flag

}

else

{

// if all characters transmitted

sendactive = 0;

// clear 'sendactive'

}

}

}

/*

* Function to initialize the serial port and the UART baudrate.

*/

void com_initialize (void) {

istart = 0;

// empty transmit buffers

iend = 0;

ostart = 0;

// empty transmit buffers

oend = 0;

sendactive = 0;

// transmitter is not active

sendfull = 0;

// clear 'sendfull' flag

// Configure timer 1 as a baud rate generator

PCON |= 0x80;

// 0x80=SMOD: set serial baudrate doubler

TMOD |= 0x20;

// put timer 1 into MODE 2

TH1 = (unsigned char) (256 - (XTAL / (16L * 12L * baudrate)));

TR1 = 1;

// start timer 1

SCON = 0x50;

// serial port MODE 1, enable serial receiver

ES = 1;

// enable serial interrupts

}

/*

* putbuf: write a character to SBUF or transmission buffer

*/

void putbuf (char c)

{

if (!sendfull)

{

// transmit only if buffer not full

if (!sendactive)

{

// if transmitter not active:

sendactive = 1;

// transfer first character direct

SBUF = c;

// to SBUF to start transmission

}

else

{

ES = 0;

// disable serial interrupts during buffer update

outbuf[oend++ & (OLEN-1)] = c;

// put char to transmission buffer

if (((oend ^ ostart) & (OLEN-1)) == 0)

{

sendfull = 1;

}

// set flag if buffer is full

ES = 1;

// enable serial interrupts again

192

Chapter 9. Using On-chip Peripherals

}

}

9

}

/*

*

Replacement routine for the standard library putchar routine.

*

The printf function uses putchar to output a character.

*/

char putchar (char c)

{

if (c == '\n') {

// expand new line character:

while (sendfull);

// wait until there is space in buffer

putbuf (0x0D);

// send CR before LF for <new line>

}

while (sendfull);

// wait until there is space in buffer

putbuf (c);

// place character into buffer

return (c);

}

char _getkey (void)

{

char c;

while (iend == istart) {

;

// wait until there are characters

}

ES = 0;

// disable serial interrupts during buffer update

c = inbuf[istart++ & (ILEN-1)];

ES = 1;

// enable serial interrupts again

return (c);

}

void main (void) {

EA = 1;

/* enable global interrupts */

com_initialize ();

/* initialize interrupt driven serial I/O */