Micro Controllers Lab Final- DSCE

8/2/2019 Micro Controllers Lab Final- DSCE

1/37

Microcontrollers lab

INTRODUCTION

PROCESSOR used is Atmel AT89C51ED2 - micro controller that has 64Kbytes of on-

chip program memory. It is a version of 8051 with enhanced features.

AT 89C51ED2 operates at 11.0592 MHz

PROCESSOR FEATURES

ON-CHIP MEMORY:

CODE MEMORY: 64K Bytes of flash.

DATA MEMORY: 256 Bytes of RAM, 1792 Bytes of XRAM, 2K Bytes of EEPROM.

ON-CHIP PERIPHERALS

3 16-bit Timers/Counters, Watch Dog Timer, Programmable Counter Array (PCA) on

Port1 i.e. PWM and Capture & Compare, SPI (Serial Peripheral Interface) on Port1,Full

duplex enhanced UART.

INTERRUPTS

Nine sources of interrupt (both external and internal).

Two External interrupts INT0 and INT1 are provided with push button switches; these can

also be used as general-purpose switches.

I/O (Port) Lines Four 10-pin connectors for all the 32 I/O lines.

P0, P1 and P2 Port lines are available on a 26-pin connector,

16X2 LCD & SERIAL I/O are also available.

Dept of Medical Electronics, D.S.C.E, Bangalore-78 1


2/37


Creating and compiling a Vision2 project

1. Double Click on the Vision3 icon on the desktop.

2. Close any previous projects that were opened using Project->Close.

3. Start Project New Project, and select the CPU from the device database (Database-

Atmel- AT89C51ED2). (Select AT89C51ED2 or AT89C51RD2 as per the board).On

clicking OK, the following option is displayed. Choose Yes.

4. Create a source file (using File->New), type in the assembly or C program and save this

(filename.asm/ filename.c) and add this source file to the project using either one of the

following two methods. (i) Project-Components,Environmentand Books->addfiles-> browse

to the required file -> OK OR

(ii) right click on the Source Group in the Project Window and the Add Files to Group

option.

5. Set the Target options using -> ProjectOptions for Target opens the Vision2

Options for Target Target configuration dialog. Set the Xtal frequency as 11.0592 Mhz,

and also the Options for Target Debug use either Simulator / Keil Monitor- 51

driver.

IfKeil Monitor- 51 driver is used click on Settings -> COM Port settings select the COM

Port to which the board is connected and select the baud rate as 19200 or 9600

(recommended). Enable Serial Interrupt option if the user application is not using on-chip

UART, to stop program execution.



3/37


6. Build the project; using Project -> Build Project. Vision translates all the user

application and links. Any errors in the code are indicated by Target not created in the

Build window, along with the error line. Debug the errors. After an error free build, goto

Debug mode

7. Now user can enter into Debug mode with Debug- Start / Stop Debug session dialog. Or

by clicking in the icon.

8.The program is run using the Debug-Run command & halted using Debug-Stop

Running. Also the (reset, run, halt) icons can be used. Additional icons are

(step, step over, step into, run till cursor).

9. If it is an interface program the outputs can be seen on the LCD, CRO, motor, led status,

etc. If it is a part A program, the appropriate memory window is opened using View ->memory window (for data RAM & XRAM locations), Watch window (for timer program),

serial window, etc.

Note: To access data RAM area type address as D:0020h.

Similarly to access the DPTR region (XRAM-present on chip in AT89C51ED2) say 9000h

location type in X:09000H.



4/37


VTU DRAFT SYLLABUS

SUBJECT: MICROCONTROLLERS LAB EXAM HOURS: 3EXAM MARKS: 50

I. PROGRAMMING

1. Data Transfer - Block move, Exchange, Sorting, Finding largest element in an array

2. Arithmetic Instructions - Addition/subtraction, multiplication and division, square, Cube

(16 bits Arithmetic operations bit addressable)

3. Counters

4. Boolean & Logical Instructions (Bit manipulations)

5. Conditional CALL & RETURN

6. Code conversion: BCD ASCII; ASCII Decimal; Decimal - ASCII;

HEX - Decimal and Decimal - HEX

7. Programs to generate delay, Programs using serial port and on-Chip timer /counter

II. INTERFACING:

Write C programs to interface 8051 chip to Interfacing modules to develop single

Chip solutions

8. Simple Calculator using 6 digit seven segment display and Hex Keyboard interface

to 8051

9. Alphanumeric LCD panel and Hex keypad input interface to 8051

10. External ADC and Temperature control interface to 8051

11. Generate different waveforms Sine, Square, Triangular, Ramp etc. using DAC

interface to 8051; change the frequency and amplitude

12. Stepper and DC motor control interface to 8051

13. Elevator interface to 8051



5/37


1. DATA TRANSFER INSTRUCTIONS1) Write an assembly language program to transfer n =10 bytes of data from location

8035h to location 8041h (without overlap).

ORG 0000HSJMP 30H

ORG 30HMOV DPH,#80HMOV R0,#35H //source addressMOV R1,#41H //destination addressMOV R3,#05H //count

BACK: MOV DPL, r0MOVX A,@dptrMOV DPL, R1MOVX @dptr,AINC R0INC R1DJNZ R3, BACK

HERE: SJMP HEREEND

RESULT:Before Execution: 10 locations X:8035h are filled up with data.

After Execution: 10 locations X:8041h are filled up with data from 8035h.

Algorithm1. Initialize registers to hold count data & also the source & destination addresses.

2. Get data from source location into accumulator and transfer to the destinationlocation.

3. Decrement the count register and repeat step 2 till count is zero.

Note: For data transfer with overlap start transferring data from the last location ofsource array to the last location of the destination array.



6/37


2) ASSEMBLY LANGUAGE PROGRAM TO EXCHANGE A BLOCK OF DATA.

Write an assembly language program to exchange n = 5 bytes of data at location 0027h

and at location 0041h.

ORG 00H

SJMP 30HORG 30HMOV R0,#27H //source addressMOV R1,#41H //destination addressMOV R3,#05H //count

BACK: MOVX A,@r0MOV r2,aMOVX a,@r1MOVX @r0,aMOV a, r2MOVX @r1,a

INC R0INC R1DJNZ R3, BACK

HERE: SJMP HEREEND

Aliter using XCH command.

ORG 0000HSJMP 30HORG 30HMOV R0,#27H //source addressMOV R1,#41H //destination addressMOV R3,#05H //count

BACK: MOVX A,@r0MOV r2,aMOVX a,@r1XCH a, r2MOVX @r1,aXCH a, r2MOVX @r0,aINC R0INC R1

DJNZ R3, BACKHERE: SJMP HEREEND

RESULT:Before Execution: 5 locations at X:0027h & X:0041h are filled up with data.



7/37


After Execution: The data at X:8027h & X:8041h are exchanged.

Algorithm1. Initialize registers to hold count data (array size) & also the source & destination

addresses.2. Get data from source location into accumulator and save in a register.3. Get data from the destination location into accumulator.4. Exchange the data at the two memory locations.5. Decrement the count register and repeat from step 2 to 4 till count is zero.

3) ASSEMBLY LANGUAGE PROGRAM TO SORT NUMBERS.

//BUBBLE SORT PROGRAMWrite an assembly language program to sort an array of n= 5 bytes of data in

Descending order stored from location 9000h.(use bubble sort algorithm)

ORG 0000HSJMP 30HORG 30HMOV R0,#05 //count n-1 -ARRAY SIZE-n- Pass Counter

L1: MOV dptr, #9000h //array stored from address 9000hMOV A,R0 //initialize exchange counter MOV R1,A

L2: MOVX a, @dptr //GET NUMBER FROM ARRAYMOV B, A //& STORE IN BINC dptrMOVX a, @dptr //next number in the arrayCLR C //reset borrow flagMOV R2, A //STORE IN R2SUBB A, B //2nd - 1st no.no compare instruction in 8051JC NOEXCHG // JNC - FOR ASCENDING ORDER

MOV A,B //EXHANGE THE 2 NOES IN THE ARRAYMOVX @dptr,aDEC DPL //DEC dptr-INSTRUCTION NOT PTRESENTMOV a,R2MOVX @dptr,aINC DPTR

NOEXCHG: DJNZ R1,L2 //decrement compare counterDJNZ R0,L1 //decrement pass counter

here: SJMP hereEND



8/37


Algorithm1. Store the elements of the array from the address 9000h2. Initialize a pass counter with array size-1 count (for number of passes).3. Load compare counter with pass counter contents & initialize DPTR to point to the

start address of the array (here 9000h).

4. Store the current and the next array elements pointed by DPTR in registers B and r2respectively.

5. Subtract the next element from the current element.6. If the carry flag is set (for ascending order) then exchange the 2 numbers in the

array.7. Decrement the compare counter and repeat through step 4 until the counter becomes

0.8. Decrement the pass counter and repeat through step 3 until the counter becomes 0.

RESULT:

Before Execution:Unsorted Array at 9000h

After Execution: Sorted Array (Descending order) at 9000h

4) Write an assembly language program to find the largest element in a given string of

n = 6 bytes at location 4000h. Store the largest element at location 4062h.

ORG 0000HSJMP 30HORG 30HMOV R3,#6 //length of the arrayMOV DPTR,#4000H //starting address of the arrayMOVX A,@DPTRMOV r1,a

NEXTBYTE: INC DPTR

MOVX A,@DPTRCLR C //reset borrow flagMOV R2,A //next number in the arraySUBB A,R1 //OTHER Num - PREVIOUS LARGEST no.JC skip // JNC for smallest elementMOV A,r2 //UPDATE larger number in r1MOV R1,A

skip:DJNZ R3,NEXTBYTEMOV DPL, #62H //LOCATION OF THE RESULT-4062HMOV A,R1 //LARGEST NUMBER

MOVX @DPTR,A //STORE AT #4062HOVER: SJMP OVER

END



9/37


Algorithm1. Store the elements of the array from the address 4000h2. Store the length of the array in r3 and set it as counter.3. DPTR is loaded with starting address of the array.4. Store the first number of the array in r1 (r1 is assigned to hold the largest number).

5. Increment DPTR.6. Subtract the number pointed by DPTR from the contents of r1 (to compare whether

the next array element is larger than the one in r1).7. If the element pointed by DPTR is larger then load the larger number into r1.8. Decrement the counter and repeat steps through 5 until the counter becomes 0.9. Store the largest number in r1 in address 4062h

RESULT:

Before Execution:

After Execution: Location 4062 has the largest element.

2. ARITHMETIC INSTRUCTIONS

ASSEMBLY LANGUAGE PROGRAM ILLUSTRATING ADDITION,SUBTRACTION, MULTIPLICATION AND DIVISION .

5) Write an ALP to perform the following:If x=0-perform w + v; else if x=1-perform w-v; else if x=2-perform w*v; elseif x=3-performw/v, where w & v are eight bit numbers.

ORG 0000HSJMP 30HORG 30HMOV R0, #40HMOVX A,@R0MOV R1, A //R1 HAS CONDITION X

INC R0MOVX A,@R0MOV B, A //B HAS 1ST NUMBER-vINC R0MOVX A,@R0 //A HAS 2ND NUMBER-wCJNE R1,#00,CKSUBADD A,B //PERFORM ADDITIONMOV B,#00 //B HAS CARRYJNC SKIPMOV B,#01H

SKIP:SJMP LAST

CKSUB: CJNE R1,#01,CKMULCLR C //RESET BORROW FLAG



10/37


SUBB A,BMOV B,#00 //B INDICATES BORROWJNC SKIP1MOV B,#0FFH //FF INDICATES NEGATIVE NUMBER

SKIP1:SJMP LAST

CKMUL: CJNE R1,#02,CKDIVMUL AB //16 bit product in AB with A having lower byteSJMP LAST

CKDIV: CJNE R1,#03,OTHERDIV AB //Quotient in A & remainder in BSJMP LAST

OTHER:MOV A,#00MOV B,#00

LAST: INC R0MOVX @R0,AINC R0

MOV A,BMOVX @R0,A

HERE:SJMP HEREEND

Algorithm

1. Store the condition x in r1.2. Load the first and second numbers to A and B registers respectively3. Compare the contents of r1 and perform the operations add, sub, etc accordingly.4. Store the result present in A and B registers to the appropriate memory locations.

RESULT:Before Execution: ADD SUB

After Execution: ADD After Execution: SUB

Before Execution: MUL After Execution: MUL



11/37


ASSEMBLY PROGRAM ILLUSTRATING SQUARE AND CUBE OPERATIONS.

//cube is an example of 16-bit arithmetic operation//depending on flag condition, square or cube is performed// Flag is a bit in the bit addressable RAM, say 1st bit of location 20h is used, then bitaddress is 01

6) An eight bit number X is stored in external memory location 9000h. Write an ALP tocompute (i) the square of the number X if LSB of data RAM 20h (bit address 01H) is set(ii) the cube of the number X if LSB of data RAM 20h (bit address 01H) is reset.Store your result at locations 9001, 9002, 9003h.

ORG 0000HSJMP 30HORG 30HMOV DPTR,#9000HMOVX A,@DPTR //GET NUMBER-XMOV R0,A //STORE IN R0MOV B,A

MUL AB //SQUARE IT-X^2CLR C //FOR STORING RESULTJB 01,LAST //IF BIT 01 IS SET THEN END, ELSE DO CUBEPUSH B //STORE UPPER PART OF SQUAREMOV B,A //B-LOWER PART OF X^2MOV A,R0 //A-XMUL AB //X*LOWER X^2INC DPTRMOVX @DPTR,A //STORE PARTIAL RESULTMOV A,BMOV R2,A //UPPER PART OF X*LOWER X^2 IN R2POP B //GET BACK UPPER PART OF SQUAREMOV A,R0 //A-XMUL AB //X*UPPER X^2ADD A,R2 //ADD TO PARTIAL RESULT

LAST:INC DPTRMOVX @DPTR,AMOV A,BADDC A,#00 //ADD CARRY TO B(FOR SQUARE RESULT, C=0)INC DPTRMOVX @DPTR,A

HERE:SJMP HEREENDRESULT:

CUBE OF 56H IS 9B498 WHICH IS STORED AS 98, B4, 09 (LOWER BYTE FIRST)

To get square make the D1 bit of data memory 20h high, say FF,02,06,etc. The bit address is01. Similarly bit address 78h correspond to D0 bit 0f data ram location 2Fh.



12/37


Algorithm

1. Store the eight bit number x in A, r0 & B registers.2. Multiply A and B registers to obtain the square (say SQH:SQL) of the number x.3. Check if bit 01 is set. If set go to end (storing the result), else do the cube operations.4. The high part of the square result (SQH) is stored on the stack.5. Multiply the low part of the square result (SQL) with x (partial cube result).6. Store the low part of the above result at 9001h & the high part in R2.7. Retrieve the high part of the square result (SQH) stored on the stack & multiply with

x.8. Add the low part of the above result (SQH*X) with R2 and store in 9002h.

9. Add the high part (SQH*X) with the resulting carry and store in 9003.

3. PROGRAM ILLUSTRATING BIT MANIPULATIONS7) Two eight bit numbers NUM1 & NUM2 are stored in external memory locations 8000h& 80001h respectively. Write an ALP to compare the 2 nos.Reflect your result as: if NUMINUM2, SET MSB OF 2F(7FH). if NUM1 = NUM2-Clear both LSB & MSB of

bit addressable memory location 2FhORG 0000HSJMP 30HORG 30HMOV DPTR,#8000HMOVX A,@DPTRMOV R0,AINC DPTRMOVX A,@DPTRCLR CSUBB A,R0JZ EQUALJNC BIGSETB 78H

SJMP END1BIG:SETB 7FHSJMP END1

EQUAL:CLR 77HCLR 7FH

END1:SJMP END1END

Algorithm:

1. Store the elements of the array from the address 4000h2. Move the first number in r0 and the second number in register A respectively3. Clear carry flag and subtract the two numbers, if the carry flag is 0(if the nos are

equal), Clear both LSB & MSB of bit addressable memory location 2Fh



13/37


4. If the carry bit is set then Set MSB of 2F(7FH), else LSB of data RAM 2F (bitaddress 78H).

RESULT: 1) Before Execution: X:08000h = 45 & X:8001 = 35After Executuion: D:02FH =01

2) Before Execution: X:08000h = 25 & X:8001 = 35After Executuion: D:02FH =803) Before Execution: X:08000h = 45 & X:8001 = 45After Executuion: D:02FH =00

4. LOGICAL INSTRUCTIONS8) ASSEMBLY PROGRAM ILLUSTRATING LOGICAL INSTRUCTIONS (BYTELEVEL)

3 eight bit numbers X, NUM1 & NUM2 are stored in internal data RAM locations 20h, 21h& 22H respectively. Write an ALP to compute the following.IF X=0; THEN NUM1 (AND) NUM2, IF X=1; THEN NUM1 (OR) NUM2,

IF X=2; THEN NUM1 (XOR) NUM2, ELSE RES =00, RES IS 23H LOCATIONORG 0000HSJMP 30HORG 30HMOV A, 20h //donot use #, as data ram 20h is to be accessedMOV R1,A //X IN R1MOV A,21H //A -NUM1CJNE R1,#0,CKORANL A, 22HSJMP END1

CKOR:CJNE R1,#01,CKXORORL A, 22HSJMP END1

CKXOR:CJNE R1,#02,OTHERXRL A, 22HSJMP END1

OTHER: CLR AEND1: MOV 23H,A //STORE RESULTHERE: SJMP HEREEND

Algorithm:1. Point to the data RAM register 20h and store the condition x.2. Point to 21h and 22h and move the first number to A register.3. Compare the contents of r1 and perform the operations accordingly.4. The result will be stored in 23H register.

RESULT: 1)Before Execution: D:020H =00, 21=0f, 22 = 12After Execution D:023H = 022)Before Execution: D:020H =01, 21=0f, 22 = 12After Execution D:023H = 1F3)Before Execution: D:020H =02, 21=0f, 22 = 12After Execution D:023H = 1D

4)Before Execution: D:020H =34, 21=0f, 22 = 12After Execution D:023H = 00



14/37


The above program can also be written as shown below (using indirect addressing)ORG 0000HSJMP 30HORG 30Hmov r0,#20h

MOV A,@R0 //ON CHIP DATA RAM-DONOT USE MOVXMOV R1,A //X IN R1INC R0MOV A,@R0 //A -NUM1INC R0 // R0 POINTS TO NUM2CJNE R1,#0,CKORANL A, @R0SJMP END1

CKOR:CJNE R1,#01,CKXORORL A, @R0SJMP END1

CKXOR:CJNE R1,#02,OTHERXRL A, @R0SJMP END1

OTHER: CLR AEND1:INC R0

MOV @R0,A //STORE RESULTHERE:SJMP HEREEND

Boolean variable instructions are also called as bit level logical instructions9) 3 eight bit numbers X, NUM1 & NUM2 are stored in internal data RAM locations 20h,21h & 22H respectively. Write an ALP to compute the following.IF X=0; THEN LSB OF NUM1 (AND) LSB OF NUM2,IF X=1; THEN MSB OF NUM1 (OR)MSB OF NUM2 ,IF X=2; THEN COMPLEMENT MSB OF NUM1STORE THE BIT RESULT IN RES, WHERE RES IS MSB OF 23H LOCATION

ORG 00HSJMP 30hORG 30hMOV R0,20H //R0-XCJNE R0,#0,CK1MOV C,08H //LSB OF NUM1 (21H) - BIT ADDRESS -08

ANL C,10H //LSB OF NUM2 (22H) - BIT ADDRESS -10SJMP LASTCK1:CJNE R0,#1,CK2

MOV C,0FH //MSB OF NUM1 (21H) - BIT ADDRESS -0FANL C,17H //MSB OF NUM2 (22H) - BIT ADDRESS -17SJMP LAST

CK2:CJNE R0,#2,CK3CPL 0FHMOV C,0FH //MSB OF NUM1 (21H) - BIT ADDRESS -0FSJMP LASTCK3:CLR C

LAST:MOV 1FH,C //RES IS MSB OF 23H LOCATION -1FHHERE:SJMP HERE



15/37


ENDRESULT: 20h = 00 => AND OF LSBs=1 (hence 80 in 23h location)

20h = 01 => OR of MSBs = 0 (hence 00 in 23h location)

20h = 01 =>complement of MSB of 21h location. Hence 21h is changed to A1 and 23hlocation has 80hBefore Execution After Execution

Algorithm:1. Move the condition X (from 20h location) into R0 register.2. If X=0; then move LSB bit of 21h to carry flag and AND Carry flag with LSB bit

of 22h. Goto step53. If X=1; then move MSB bit of 21h to carry flag and OR Carry flag with MSB bit

of 22h. Goto step54. If X=0; then complement MSB bit of 21h and move it to carry flag. Goto step55. Store Carry flag at MSB bit of 23h location.

5. COUNTERSASSEMBLY PROGRAM ILLUSTRATING HEX UP/DOWN COUNTERS.

//counter program - hex/binary counters10) Write an ALP to implement (display) an eight bit up/down binary (hex) counters onwatch window.Note: to run this program, after selecting DEBUG session in the main menu use

View-> Watch& call Stack window, in the Watches select watch 1(or 2) and

press F2 and enter a (for accumulator A)ORG 0HSJMP 30HORG 0HMOV a,#00

BACK: ACALL DELAYINC a //dec a for binary down counterJNZ BACK

HERE:SJMP HERE

DELAY: MOV r1,#0FFH

DECR1:MOV r2,#0FFHDECR: MOV r3,#OFFH



16/37


DJNZ r3,$DJNZ r2,DECRDJNZ r1,DECR1RETEND

RESULT: Accumulator A is incremented in binary from 00, 01,0209,0A, 0B,,0F,10,11,FF

Algorithm:

1. Move 00 to A register2. Call the delay subroutine for 1 second, in delay program move FFH to registers r1,

r2 and r3, loop and decrement until 0.3. Increment A register(decremant for down counter)

ASSEMBLY PROGRAM ILLUSTRATING BCD UP/DOWN COUNTERS.

//counter program BCD up/down counters11) Write an ALP to implement (display) an eight bit up/down BCD counters on watchwindow.

ORG 0HSJMP 30HORG 30HMOV a,#00

BACK:ACALL DELAYADD a,#99H //ADD 01 for BCD up counter

DA A //for bcd counterJNZ BACKHERE:SJMP HEREDELAY:MOV r1,#0FFHDECR1:MOV r2,#0FFHDECR:MOV r3, #0FFH

DJNZ r3,$DJNZ r2, DECRDJNZ r1, DECR1RETEND

Algorithm:4. Move 00 to A register



17/37


5. Call the delay subroutine for 1 second (in delay program move FFH to registers r1,r2 and r3, loop and decrement until 0).

6. Increment A register(add 99h for down counter)7. Decimal adjust accumulator for the BCD up/down counter.

RESULT: Accumulator A is incremented in BCD from 00, 01, 0209, 10, 11,99.

6. SERIAL DATA TRANSMISSION

Program illustrating serial ascii data transmission (data-yE)Note-to use result of this program, after selecting DEBUG session in the main menu useView-> serial window #1. On running & halting the program, the data is seen in the serialwindow.12) Conduct an experiment to configure 8051 microcontroller to transmit characters (yE) toa PC using the serial port and display on the serial window.

ORG 0HSJMP 30HORG 30HMOV TMOD,#20H //timer 1; mode 2MOV TH1,#-3 //-3=FD loaded into TH1 for 9600 baud, 11.0592MHz.MOV SCON,#50H //8-bit, 1 stop bit, REN enabledSETB TR1 //Start timer 1

AGAIN:MOV A,#y //transfer yACALL TRANSMOV a,#E //transfer EACALL TRANS

AGAIN1:SJMP AGAIN1TRANS: MOV SBUF,a //load SBUFHERE:JNB TI,HERE //Wait for last bit to transfer

CLR TI //get ready for next byteRETEND

RESULT: yE is printed on the serial window each time the program is executed.

Theory: In serial transmission as opposed to parallel transmission, one bit at a time istransmitted. In serial asynchronous transmission, the data consists of a Start bit (high),

followed by 8 bits of data to be transmitted and finally the stop bit. The byte character to betransmitted is written into the SBUF register. It transmits the start bit. The 8-bit character istransferred one bit at a time. The stop bit is transferred. After the transmission, the TI flag =1 indicating the completion of transmission. Hence in the subroutine wait until TI is set.Later clear the TI flag and continue with transmission of the next byte by writing into theSBUF register. (The program can also be written in interrupt mode). The speed of the serialtransmission is set by the baud rate which is done with the help of timer 1. (Refer Ayala).Timer1 must be programmed in mode 2 (that is, 8-bit, auto reload).Baud rate Calculation: Crystal freq/ (12*32) = (11.0592MHz)/(12*32) = 28800.Serial communication circuitry divides the machine cycle frequency(11.0592MHz)/(12) by32 before it is being used by the timer to set the baud rate.

To get 9600, 28800/3 is obtained by loading timer1 with -3 (i.e., FF 3 = FD) for furtherclock division. For 2400 baud rate, 28800/12 => -12 = F4 in TH1.



18/37


Algorithm:

1. Initialize timer 1 to operate in mode 2 by loading TMOD register.2. load TH1 with -3 to obtain 9600 baud.3. Initialize the asynchronous serial communication transmission (SCON) register.4. Start timer1 to generate the baud rate clock.

5. Transmit the characters y & E by writing into the SBUF register and waiting forthe TI flag.

7) TIMER DELAY PROGRAMProgram illustrating timer delay13) Generate a 1second delay continuously using the on chip timer in interrupt mode.

ORG 0H //Reset Vector SJMP 30HORG 0BH //TF0 vector SJMP ISR

ORG 30HMOV a,#00MOV R0,#0MOV R1,#0MOV TMOD,#02H //00000010-Run timer0 in mode 2MOV TH0,#118 //Set up timer 0 to overflow in 0.05msecMOV IE,#82H //%10000010 Enable timer0 interruptSETB TCON.4 //Start the timer0

HERE:SJMP HEREISR: CLR TCON.4 //Disable timer0

INC r1 //r1*r2 = 100*200 = 20000 * 0.05msec = 1sec

CJNE r1,#100,SKIPMOV r1,#00INC r0CJNE r0,#200,SKIPMOV r0,#00HINC a

SKIP: SETB TCON.4 //Enable Timer RETI //Return from interrupt subroutineEND

RESULT: Accumulator A is incremented in binary from 00, 01,0209,0A, 0B, , 0F, 10,11, FF every 1 second (for 33MHz clock setting & every 3 seconds for 11.0598MHz)

Algorithm:1. Set up timer0 in mode 2 operation2. Load TH1 with 118 to generate an interrupt every 0.05msec.3. Reset registers a, r1 & r0.4. Repeat step 4 continuously5. On interrupt; ISR at 000B loaction goes to step 66. disable timer0

7. Update r1 & r08. Check if 20000 interrupts (=1 sec) over. Yes increment accumulator a.



19/37


9. enable timer & return from ISR.

Timerdelay = 12*(257-delay)/frequencyTimerdelay=0.05msec

Delay=256-((timerdelay * frequency)/12) =256-(0.05*10 -3 * 33*106)/12=256-137.5 =118.5 //loaded in TH0

To get 1sec delay1/0.05msec = 200*100 in the ISR(assuming 33 MHZ crystal frequency. For 11 MHz, the calculations change).



20/37


8. CONVERSION PROGRAMS

14) Write an ALP to implement decimal to hex conversion

ORG 0000H

SJMP 30hORG 30hMOV DPTR,#40H //2-digit decimal number to be converted is given in data

memory 40hMOVX A, @DPTRANL A, #0F0H //obtain upper decimal digitSWAP A //bring to the units placeMOV B,#0AH //MULTIPLY tens digit with #0A-toget tens in hexMUL ABMOV r1,a //temporarily store the converted tens valueMOVX A,@DPTR //get the decimal number again

ANL A,#0FH //obtain the units digitADD A,R1 //add to the converted tens valueINC DPTR //increment data addressMOVX @DPTR,A //converted hexadecimal number in next location

HERE:SJMP HEREEND

RESULT: before execution- X:0040H = 45 (Decimal/BCD)After Execution: X:0041h = 2D (hex value)

Algorithm

1. Move the decimal data to be converted from external memory 40h to accumulator.2. AND A reg with 0f0h and obtain the upper MSB of the decimal digit and swap the

LSB and MSB of accumulator to bring the same to units place.3. Move 0ah to B register and multiply with A reg to convert to hex value, store the

converted tens value in r14. Get the LSB of the decimal number and add to the converted tens value5. point to the next memory location and store the result (hexadecimal).

15) Write an ALP to implement hex to decimal conversion

ORG 0000HSJMP 30hORG 30hMOV DPTR,#9000HMOVX A,@DPTR //Get hex number MOV B,#10DIV AB //divide by 10 (0AH)INC DPTRXCH A,BMOVX @DPTR,A //Store the remainder (in B) In units placeXCH A,B

MOV B,#10 //Divide the quotient in A by 10DIV AB



21/37


INC DPTRXCH A,BMOVX @DPTR,A //Store the remainder (in B) In tens placeXCH A,BINC DPTR

MOVX @DPTR,A //Store the quotient (in A) in hundreds placeHERE:SJMP HERE

End

RESULT: 9000H FF (HEX NUMBER)9001 to 9003 unpacked BCD number (decimal)- 5,5,2 (i.e., 255 stored Lower digit first)

Algorithm1. Move the hex data to be converted to accumulator.2. Move 10 to B register and divide with A reg to convert to ascii value3. Store the converted LSB value in r74. Repeat the step 2 to obtain the converted MSB value5. Store the same in r6

16) Write an ALP to implement BCD to ASCII conversionORG 0000HSJMP 30hORG 30h

MOV R1,#50HMOV A,@R1 //get BCD data byte from RAM location 50hMOV R2,A //Store in R2ANL A,#0FH //Get the lower nibbleORL A,#30H //Add/or with 30h i.e., 0-9 converted to 30-39hINC R1MOV @R1,A //Store the lower digit's ASCII codeMOV A,R2 //Get back the numberSWAP A //Swap nibbles in AANL A,#0FH //Get the upper BCD digitORL A,#30H //Convert to ASCIIINC R1MOV @R1,A //Store the upper digit's ASCII code

here: sjmp hereEND

RESULT: The BCD code 28 at D:0050h is converted to 2 ASCII codes-38h 32h



22/37


Algorithm ://Converts the BCD byte in A into two ASCII characters.

1. Move the BCD data to be converted to accumulator.2. Get the lower nibble(BCD digit) & ADD (or ORL) with 30h3. Store the converted ASCII value

4. Get the higher nibble(tens BCD digit) & ADD (or ORL) with 30h5. Store the converted ASCII value

17) Write an ALP to implement hexadecimal to ASCII conversion

//This program also illustrates conditional branching (JNC), call and return

instructions.

ORG 0000HSJMP 30hORG 30hMOV R1,#50HMOV A,@R1 //get hexadecimal data byte from RAM location 50h

MOV R2,A //Store in R2ANL A,#0FH //Get the lower nibbleACALL ASCII //Convert to ASCIIINC R1MOV @R1,A //Store the lower digit's ASCII codeMOV A,R2 //Get back the numberSWAP A //Swap nibbles in AANL A,#0FH //Get the upper BCD digitACALL ASCIIINC R1MOV @R1,A //Store the upper digit's ASCII code

here: sjmp here

ASCII:MOV R4,A //Store aCLR CSUBB A,#0AH //Check if digit >=0AMOV A,R4JNC SKIPADD A,#07H //Add 07 if >09SKIP:ADD A,#30H //Else add only 30h for 0-9RET

END

RESULT: The BCD code 2C at D:0050h is converted to 2 ASCII codes-43h(for 0B) & 32h(for 02) Another Example-BA

Algorithm ://Converts the hexadecimal byte in A into two ASCII characters.

1. Move the hexadecimal data to be converted to accumulator.2. Get the lower nibble & call ASCII routine



23/37


3. Store the converted ASCII value4. Get the higher nibble & call ASCII routine5. Store the converted ASCII value

ASCII subroutine1. If digit greater than 09,(for A-F) add 07h & 30h

2. Else (i.e., for 0-9) add only 30h3. return

18) Write an ALP to implement ASCII to hexadecimal conversion

ORG 0000HSJMP 30hORG 30hMOV R1,#50HMOV A,@R1 //get ascii byte from RAM location 50hCLR CSUBB A,#41H

MOV A,@R1JC SKIPCLR CSUBB A,#07HSKIP:CLR CSUBB A,#30HINC R1MOV @R1,A //Store the hex code

here: sjmp hereEND

RESULT: The ASCII code 45 at D:0050h is converted to hexadecimal -0E at 51h

Note: For this program the input data should be only in the range 30h-39h & 41h to 46h.

Algorithm ://Converts the ASCII characters into hexadecimal number.

1. Move the ASCII character to be converted to accumulator.

2. If character is greater than 41h,(for A-F), then subtract 07h & 30h3. Else (i.e., for 0-9) subtract only 30h4. Store the converted hexadecimal number.



24/37


Hardware Interfacing

1. Waveform Generation using Dual DAC2. Stepper Motor interface.3.4X4 hexadecimal Keyboard interface4. DC motor interface5. Calculator using Keyboard and Seven segment display.6. Elevator control.7. Temperature sensor.

Features of Embedded C

C is a simple programming language and so very easy to code.

Embedded C has most features of C-language with more stress on certain bitmanipulative instructions.

This feature makes it easy to write program for C and P. Keil is a versatile software with a cross compiler that will convert the C program to

assembly language and thus the program can be executed on the desired target (say8051).

Some of the bit manipulative instructions used areSymbol Operation

& Bitwise AND| Bitwise OR

~ Bitwise NOT>> Shift Right


25/37


1.aAlgorithm for Square wave generation

Let initial, amplitude of the square wave be 2.5v(7F) and frequency count 100. Output the values 00h(0ff) and 7fh(on) Values through P0.

If amplitude key is pressed then increase the voltage in steps of 0.15v(8).

If the frequency key is pressed increment the count in steps of 50. If the countexceeds 1000 reset it back to 100.

Every time amplitude and frequency changes output the value thro P0 and note thewaveform on CRO.

Program for square wave

#include 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;

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);

}}



26/37


1.bAlgorithm for Triangular wave generation

Output the initial value 00 through P0.

Increment it in steps of 1 until a count value of FFh (5V) is reached. Every timerepeat step 1.

Decrement it in steps of 1 until a zero value is reached and repeat step 1.Program for triangular wave:

#include main(){unsigned char i=0;P0 = 0x00; /* P0 as Output port */

while(1){for(i=0;i0x00;i--) /* Generate OFF pulse */{P0 = i;P1 = i;}

}}

1.c.Algorithm for Ramp wave generation

Output the initial value 00 through P0.

Increment it in steps of 1 until a count value of FFh (5V) is reached. Every timerepeat step 1.

Repeat step 1 & 2 continuously.

Program for Ramp waveform

#include main (){ Unsigned char i=0;

P0 = 0x00; /* P0 as Output port */while (1){for (i=0;i


27/37


1d.Algorothm for Sine wave

Compute different step values ( = 20o,15o) of sine using the equationV= 2.5V +2.5Vsin. . Output the values thro P0.

More the steps smoother will be sine wave.

E.g.: = 0o

V= 2.5V +2.5Vsin = 2.5VThe value sent to DAC is 25.6X5V= 128.

Program for sine wave

#include main()

{static int a[13]={128,192,238,255,238,192,128,64,17,0,17,64,128};unsigned char i=0;P0 = 0x00; /* P0 as Output port */

while (1){for(i=0;i


28/37


//Program for stepper motor interface

#include void delay (unsigned int x) /* Delay Routine */{for(;x>0;x--);return;

}Main ( ){unsigned char Val, i;P0=0x00;Val = 0x11;

for (i=0;i


29/37


//Program for 4X4 hex keypad.

#include < REG51xD2.H>#include #include "lcd.h"unsigned char rows,columns,result,abhi;unsigned char temp = 0;void delay(){unsigned int i;for(i = 0; i 0x09){result += 0x37;

WriteChar(result);}

else{result += 0x30;

WriteChar(result);}

}void KeyScan()

{again: columns = 0x77;

rows = 0x04;result = 0x0c;

next: P1 = columns;columns >>=1;if(CY)

columns = columns |0x08 ;

temp = P0;temp = (temp & 0x0f);

Dept of Medical Electronics, D.S.C.E, Bangalore-78

8051C

P0FRC 26pin

Cable

PS

4X4KeyboardInterfaceCard

PS

4X4 Hexkeypad

29


30/37


if(temp != 0x0f){

rot: temp >>= 1;if(!CY){

ClrLcd();return;

}else{result += 1;goto rot;

}}

else

{result -= 0x04;rows --;if(rows == 0)goto again;

else{goto next;

}}

}void main(){P0 = 0xff;P1 = 0x00;InitLcd();WriteString ("KEY PRESSED=");while(1)

{KeyScan();

WriteString ("KEY PRESSED=");

Display();}}

4.DC Motor

Algorithm for DC motor interface

Configure P0,P1 as output port and P3 as input port. Let initially the motor rotate with half speed count 7fh.

If INR button is pressed reduce the count because the speed is inverselyproportional to count.



31/37


If DEC button is pressed increase the count.

Program for DC motor

#include sbit inr= P3^2; //speed increment switchsbit dcr= P3^3; //speed decrement switchmain(){

unsigned char i=0x80;P0 = 0x7f; /*Run the motor at half speed.*/

while (1){ if (!inr){while (!inr);

if(i>10)i=i-10; //increase the DC motor speed

}if(!dcr){while(!dcr);if(i


32/37


Program for calculator

#include void DispChar(unsigned char ch);void ClrLED();unsigned char getkey();unsigned char getnum();unsigned char getOp();sbit Clk = P3^4; /* Clock line for 7 segment display */sbit Dat = P0^0; /* Data line for 7 segment display */

main(){unsigned char tmp=0x0ff,n1=0,n2,Op,Res;unsigned char NumTab[10] = {

0x0c0,0x0f9,0x0a4,0xb0,0x99,0x92,0x82,0x0f8,0x80,0x90 };unsigned char OpTab[4] = { 0x88,0x0Bf,0xc8,0x0a1};bit Neg=0;ClrLED(); /* Clear 7 segment display */while(1){Neg = 0; /* Negative flag */

n1=getnum(); /* Get 1st number */

Op = getOp() - 0x0B; /* Get Opcode. 0x0b is keycode of '+'(see keyboard schematics)*/

n2=getnum(); /* Get 2nd number */while(getkey()!=0x13); /* wait for '=' key */ClrLED();

switch(Op) /* Perform corresponding operation */{

case 0: Res = n1 + n2;break;

case 1:if(n2>n1) /* check for negativity */


8051C

P0FRC 26pin

Cable

PS

Keypad

PS

7 SegDisplay

32


33/37


{

Neg = 1;Res = n2 - n1;break; }

Res = n1 - n2; break;case 2: Res = n1 * n2;

break;case 3: Res = n1 / n2;

break; }DispChar(NumTab[Res%10]); /* Display number */DispChar(NumTab[Res/10]);if(Neg) /* if negative result display '-' */DispChar(0x0Bf);

}}void DispChar(unsigned char ch) /* Routine to display char on 7 segment */

{unsigned char i,tmp;P0=0x00;

for(i=0;i


34/37


if(t>0) /* If key press is true */{for(j=0;j>=1;

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

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

}}

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

} }}unsigned char getnum() /* Method for getting number */{unsigned char tmp;while(1)

{tmp = getkey();if(tmp < 0x0a || tmp==0x10) /* if pressed key is number, return */return(tmp);

}}unsigned char getOp() /* Method for getting Operator */{unsigned char tmp;while(1){tmp = getkey();if((tmp > 0x0a && tmp


35/37


Program for Elevator

#include 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 */{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;


8051C

P0FRC 26pin

Cable

PS

Elevatorinterface

PS

35


36/37


j++;delay(25000);

} }CurFlr = ReqFlr; /* Update Current floor */

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

}}void delay(unsigned int x){for(;x>0;x--);

}

7.Temperature Sensor

The interface card has a DAC to convert the actual temperature to digital this is comparedwith reference temperarture. Realay also a part of interface card will turn on and off toindicate if the actual temperature is above or below reference.

Algorithm for Temperature sensor

1. Configure P0 and P1 as o/p, P3 as input port.

2. Set up a counter with intial value 0xff send it to dac thro P0 after a delay check ifcomparator o/p has gone low.

3. If low compare with set value if actual greaterthan set turn on the relay else turn off.

Program for temperature sensor.

#include sbit Cmp_Out = P3^4; /*Input Bit for Comparator output*/sbit Rel_Con = P0^0; /*Relay controller Bit i.e Heater Power supply control*/

/*1- Supply OFF, 0-Supply ON*/#define Dac_Data P1 /*DAC input Data PORT i.e. P1*/

void delay(){ int l;


8051C

P0,P2,P3FRC 26pin

Cable

PS

TempSensorInterface

PS

HeatSource

36


37/37


for (l=0;l 0x20) /*Compare with the set value i.e.0x20*/Rel_Con = 1;elseRel_Con = 0; /* Relay ON, Supply OFF */}

}

Micro Controllers Lab Final- DSCE

Documents