Project of Keil Programming

Embedded Project
LCD interfacing
#include <REGX52.H>
#define LCD_data P2
#define LCD_rs P1_0
#define LCD_rw P1_1
#define LCD_en P1_2
void LCD_busy(void);
void LCD_poweron(void);
void LCD_command(unsigned char var);
void LCD_senddata(unsigned char var);
void LCD_sendstring(unsigned char *var);
void LCD_init(void);
void main(void)
{
unsigned char msg[] ="Learning";
LCD_poweron(); // 15ms delay
LCD_init();
LCD_command (0x80); // Set CGRAM adress,data is Avaible from uC
LCD_sendstring(msg);
while(1);
}
void LCD_busy()
{
unsigned char i,j;
for(i=0;i<50;i++)
for(j=0;j<255;j++);
}
void LCD_poweron()
{
unsigned int i;
for (i=0;i<22500; i++);
}
void LCD_command(unsigned char var)
{
LCD_data = var; //Function set: 2 Line, 8-bit, 5x8 dots
LCD_rs = 0; //Selected command register
LCD_rw = 0; //We are writing in instruction register
LCD_en = 1; //Enable H->L
LCD_en = 0;
LCD_busy(); //Wait for LCD to process the command
}
void LCD_sendstring(unsigned char *var)

{
while(*var) //till string ends
LCD_senddata(*var++); //send characters one by one
}
void LCD_senddata(unsigned char var)

{
P2 = var; //Function set: 2 Line, 8-bit, 5x7 dots
LCD_rs = 1; //Selected data register
LCD_rw = 0; //We are writing
LCD_en = 0;
}
void LCD_init(void)
{
LCD_data = 0x38; //Function set: 2 Line, 8-bit, 5x8 dots
LCD_rw = 0; //We are writing in data register
LCD_en = 0;
LCD_data = 0x0F; //Display on, Curson blinking command
LCD_en = 0;
LCD_data = 0x01; //Clear LCD
LCD_en = 0;
LCD_data = 0x06; //Entry mode, auto increment with no shift
LCD_busy();
}
===============================================================
===========================
7segment for keil
keyport equ P2 ;Keypad port connected here
col1 equ P2.0 ;Column 1
keyval equ 30H ;To store key number

pressed bit 0H ;Flag
key_init:
mov keyport,#0FH ;Make rows as o/p and col as i/p
ret
get_key:
mov keyval,#0 ;reset the number
mov keyport,#7FH ;make Row1 low
acall read_col ;read columns
jb pressed, done ;check if flag is set
mov keyval,#4 ;if not then read next row

mov keyport,#0BFH ;make Row2 low
mov keyval,#8 ;if not then read next row

mov keyport,#0DFH ;make row3 low
mov keyval,#12 ;if not read row4

mov keyport,#0EFH ;make row4 low
done:
ret
read_col: ;read columns routine

clr pressed ;reset the flag
jb col1, nextcol ;check if first key is pressed

jnb col1,$ ;if yes then wait for key release
setb pressed ;set the flag
ret
nextcol: ;read col2

jb col2, nextcol1 ;check if second key is pressed
inc keyval ;its key number 2
ret
nextcol1: ;read col3

jb col3, nextcol2 ;check if third key is pressed
inc keyval ;its key 3
inc keyval
ret
nextcol2: ;read column 4

jb col4, exit ;check if fourth key pressed
inc keyval ;its key 4
inc keyval
inc keyval
ret
exit: ;if no key is pressed

clr pressed ;clr the flag
clr keyval ;reset the number
ret
end
unsigned char get_key(){

unsigned char i,k,key=0;
k=1;
for(i=0;i<4;i++){ //loop for 4 rows
keyport &=~(0x80>>i); //to make rows low 1 by 1
if(!col1){ //check if key1 is pressed
key = k+0; //set key number
while(!col1); //wait for release
return key; //return key number
}
}
}
}
k+=4; //next row key number
keyport |= 0x80>>i; //make the row high again
}
return FALSE; //return false if no key pressed
===============================================================
============
intrupt
//serial.c
#include <Reg51.h>
#include "serial.h"
#include "lcd.h"
#include "menu.h"
#include "keypad.h"
#include "define.h"
unsigned int byte_no=0;

unsigned char recieve_type = 'D'; // why D?
unsigned char serial_buff_temp[100];
unsigned int rx_count=0;
unsigned int lcd_writecount=0;
unsigned int position = 1;
unsigned int x=1;
unsigned int y=1;
unsigned char start_buffer='N'; // why N?
unsigned char key='N';
void init_serial(void)
{
// Init PCON (power Control Register)
PCON = 0x00 ; //reset SMOD=1, SMOD=0, general purpose usage (see
pg 16)
// Init SCON (serial Control Register see pg 54)

SCON = 0x50 ; // 8-bit UART, REN=1, 1 stop & 1 start
// BRL = 247 ; //115200

// BRL = 220 ; //2400
BRL = 247 ; //9600
// Init BDRCON (Baud Rate Control pg 59)

BDRCON = 0x1D ; // Set SPD = 0, BRG run on uart mode 0, 1D= 0001
1101
// Enable serial int (pg 77)

IE = IE | 0x90 ; // 0x90 = 1001 0000
}
void serial_rx(void)
{
switch(gMenuLine.serialrx_byte) //whatever wrong sequence will reset back to zero

{
case 0x36: //HEX form--> DECIMAL is 6
if(gMenuLine.sequence_number == 0)
{
gMenuLine.sequence_number = 1;
LcdDisplayLine("36\n", 1, 1, LCD_CLEAR); //temp check if 36 press will
come here
}
else
{
gMenuLine.sequence_wrong = gMenuLine.sequence_number; //
sequence_wrong is use to store number of bytes correct prior to wrong data rx (counter)
gMenuLine.sequence_number = 0; //to reset the number of correct bytes
receive to zero since a wrong data Rx
}
break;
case 0x30: //0
{
LcdDisplayLine("30\n", 1, 1, LCD_CLEAR);
}
else if(gMenuLine.sequence_number == 2)
{
LcdDisplayLine("30(2)\n", 1, 1, LCD_CLEAR);
}
{
}
else
{
}
break;
case 0x32: //2
{
}
{
}
else
{
}
break;
case 0x34: //4
{
}
{
}
else
{
}
break;
case 0x33: //3
{
}
else
{
}
break;
case 0x35: //5

{
gMenuLine.sequence_found = 1;
gMenuLine.serialtx_counter = 0;
gMenuLine.sequence_number = 0; //reset back to zero
}
else
{
}
break;
default:
gMenuLine.sequence_wrong = gMenuLine.sequence_number;
TI=1;
break;
}
}
//TI and RI are serial port interrupt bits

//TI & RI must be clear by software
void serial_isr(void) interrupt 4

{
IE = IE & 0x6F; //0110 1111
if(RI) // when RI==1, HT had already sent 1 byte data, indicating to 8051 that it can
start reading in
{ // when RI==0, HT is still sending the 1 byte data or 8051 telling HT that it can
start to send data
gMenuLine.serialrx_byte = SBUF;
RI = 0;
TI=1;// add on 040309 so it will go to the condition
serial_rx() ;
if(gMenuLine.sequence_found == 1)
{
LcdDisplayLine("seq found\n", 1, 1, LCD_CLEAR);
//TI=1; here or top also can
}
}
//TI=0 mean 8051 transmiting data, ready to transmit
else if(TI&&(gMenuLine.sequence_number == 0)&& (gMenuLine.sequence_found
== 0))//for wrong set of data recieved
{
TI=0;// clear to ack interrupt
//if all the correct btye is outputed, output the wrong byte or for the moment
first byte received not in sequence
if(gMenuLine.sequence_wrong == 0)
{
LcdDisplayLine("Wrong_seq1\n", 1, 1, LCD_CLEAR); //checking
purpose
SBUF = gMenuLine.serialrx_byte;
else //output the correct byte prior to the wrong one

{
SBUF = gMenuLine.serialtx_byte_wrong[gMenuLine.serialtx_counter];
gMenuLine.serialtx_counter++; // o/p one byte by one byte --->
gMenuLine.sequence_wrong--; // o/p one byte by one byte <---
// correct sequence found will come here to change to desire bytes one at a time.
else if(TI&&(gMenuLine.sequence_found == 1))
{
TI=0;// clear to ack interrupt
SBUF = gMenuLine.serialtx_byte[gMenuLine.serialtx_counter];
if(gMenuLine.serialtx_counter == 9) // change from 10 to 9 on 020309

{
//return; // 090309 using return will execute one time only! but no appending of
last byte endlessly
}
else
gMenuLine.serialtx_counter++;
IE = IE | 0x90; // enable sp interrupt // check for flag and copy data to & from SBUF
//main.c
#include <Reg51.h>
#include <stdio.h>
#include "serial.h"
#include "lcd.h"
#include "main.h"
#include "keypad.h"
#include "menu.h"
#include "timer.h"
#include "define.h"
void init_system(void)
{
// Clock X2 (6 clk period) Mode (clock control register)see pg 17-20 for advantages
CKCON0 = CKCON0 | 0x01 ;
// Settings for the ports, refer to user guide pg 13-14
P1 = 0xEB ; //1110 1011
P3 = 0xFF ;
// De-assert KFD control

// authen_KFD(1) ;
// Initialize E2prom
// initE2prom();
// Initialize serial
init_serial();
// Initialize timer
// init_timer0() ;
// Initialize Lcd
// DelayTime(40);
CLALCDinit();
// Initialize Menu
MenuInit();
// Initialize Keypad
init_keypad() ;
void main(void)
{
init_system() ;
LcdBlitOn();
gMenuLine.serialrx_byte = 0;
gMenuLine.sequence_wrong = 0; //added 020309
gMenuLine.serialtx_byte[0] = 0x36;
gMenuLine.serialtx_byte_wrong[0] = 0x36; //added 020309, 0x35 nt included

because it is the last byte
gMenuLine.serialtx_byte_wrong[1] = 0x30;
DisplayStartUpMsg() ;
//TI=1;
while(1) //endless loop
{
}
}
}

Project of Keil Programming

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Project of Keil Programming

Transféré par

Droits d'auteur :

Formats disponibles

Embedded Project

void LCD_sendstring(unsigned char *var)

void LCD_senddata(unsigned char var)

keyval equ 30H ;To store key number

jb pressed, done ;check if flag is set

mov keyval,#4 ;if not then read next row

jb pressed, done ;check if flag is set

mov keyval,#8 ;if not then read next row

jb pressed, done ;check if flag is set

mov keyval,#12 ;if not read row4

read_col: ;read columns routine

jb col1, nextcol ;check if first key is pressed

nextcol: ;read col2

nextcol1: ;read col3

nextcol2: ;read column 4

exit: ;if no key is pressed

unsigned char get_key(){

unsigned int byte_no=0;

// Init SCON (serial Control Register see pg 54)

// BRL = 247 ; //115200

// Init BDRCON (Baud Rate Control pg 59)

// Enable serial int (pg 77)

switch(gMenuLine.serialrx_byte) //whatever wrong sequence will reset back to zero

case 0x30: //0

case 0x32: //2

case 0x34: //4

case 0x33: //3

case 0x35: //5

//TI and RI are serial port interrupt bits

void serial_isr(void) interrupt 4

else //output the correct byte prior to the wrong one

if(gMenuLine.serialtx_counter == 9) // change from 10 to 9 on 020309

// De-assert KFD control

gMenuLine.serialtx_byte_wrong[0] = 0x36; //added 020309, 0x35 nt included

Vous aimerez peut-être aussi