/************************************************************************************
*********************FPM10A HEADER / DRIVER ….WRITTEN BY SUNDAY*******************
*****************COPY RIGHT … MICROSCALE EMBEDDED LTD. KADUNA NIG.*****************
************************************************************************************/
#ifndef __LIB_FPM10A_H__
#define __LIB_FPM10A_H__
/************************************************************************************
************************************BASIC STORAGE DEFINTION*************************
************************************************************************************/
char cnt;
unsigned int Templete_Num;
unsigned int ACK_Sum;

//unsigned char idata RECEVICE_BUFFER[24];
unsigned char idata receive_ACK[15];
//char idata receive_command[20];
/************************************************************************************
***************************FINGERPRINT PROTOCAL DEFINITION**************************
************************************************************************************/
const unsigned char code FP_SetPwd[10] = {0×01,0×00,0×07,0×12,0xff,0xff,0xff,0xff,0×04,0×16};
const unsigned char code FP_Pack_Head[6] = {0xEF,0×01,0xFF,0xFF,0xFF,0xFF}; //protcol header
const unsigned char code FP_VfyPwd[10] = {0×01,0×00,0×07,0×13,0xff,0xff,0xff,0xff,0×04,0×17};
const unsigned char code FP_Get_Img[6] = {0×01,0×00,0×03,0×01,0×00,0×05}; //get/record fingerprint image
const unsigned char code FP_Templete_Num[6] ={0×01,0×00,0×03,0x1D,0×00,0×21 }; //get total number of template
const unsigned char data FP_Search[11]={0×01,0×00,0×08,0×04,0×01,0×00,0×00,0×03,0xA1,0×0,0xB2}; //search range of fingeprints 0 – 929
const unsigned char data FP_Search_0_9[11]={0×01,0×00,0×08,0×04,0×01,0×0,0×00,0×00,0×13,0×00,0×21}; //search fingerprint no.0-9
unsigned char idata FP_Img_To_Buffer1[7]={0×01,0×00,0×04,0×02,0×01,0×0,0×08}; //save image to BUFFER1
unsigned char idata FP_Img_To_Buffer2[7]={0×01,0×00,0×04,0×02,0×02,0×0,0×09}; //save image to BUFFER2
unsigned char idata FP_Reg_Model[6]={0×01,0×00,0×03,0×05,0×0,0×09}; //Combine BUFFER1 and BUFFER2 to generate feature template
unsigned char idata FP_Delet_All_Model[6]={0×01,0×00,0×03,0x0d,0×00,0×11}; //clean up all templates in fingerprint module
unsigned char idata FP_Reg_Match[6]={0×01,0×00,0×03,0×03,0×00,0×07}; //compare charbuffer1 and charbuffer2
unsigned char FP_Reg_Store[9]={0×01,0×00,0×06,0×06,0×02,0×00,0×00,0×00,0x0f}; //save charbuffer2 to template ID0
unsigned char FP_Reg_LoadChar[9]={0×01,0×00,0×06,0×07,0×02,0×00,0×00,0×00,0×10}; //read template ID0 to charbuffer2
volatile unsigned char idata FP_Save_Finger[9]={0×01,0×00,0×06,0×06,0×01,0×00,0x0B,0×00,0×19}; //save the feature of BUFFER1 to specified position
volatile unsigned char idata FP_Delete_Model[10]={0×01,0×00,0×07,0x0C,0×00,0×0,0×00,0×01,0×00,0×00};
/************************************************************************************
************************************ACK storage, 12 bytes****************************
************************************************************************************/
void array_ACK(unsigned char temp)
{
unsigned char i;
for( i=0;i<temp;i++)
{
receive_ACK[i]= getkey();
}
}
/************************************************************************************
************************************PASSWORD VERIFICATION COMMAND*******************
************************************************************************************/
void FINGERPRINT_Cmd_vfypwd(void)
{
unsigned char i;

for(i=0;i<6;i++) //send header
putchar(FP_Pack_Head[i]);

for(i=0;i<10;i++) //send command 0x1d
putchar(FP_VfyPwd[i]);
}
/************************************************************************************
************************************PASSWORD SET COMMAND****************************
************************************************************************************/
void FINGERPRINT_Cmd_Setpwd(void)
{
unsigned char i;

for(i=0;i<6;i++) //send header
putchar(FP_Pack_Head[i]);

for(i=0;i<10;i++) //send command 0x1d
putchar(FP_SetPwd[i]);
}
/************************************************************************************
************************************GETS FINGER PRINT ON SCANNER*********************
************************************************************************************/
void FINGERPRINT_Cmd_Get_Img(void)
{
unsigned char i;
for(i=0;i<6;i++) //send header
putchar(FP_Pack_Head[i]);

for(i=0;i<6;i++) //send command 0x1d
putchar(FP_Get_Img[i]);
}
/************************************************************************************
************************************SAVES IMAGE TO BUFFER1****************************
************************************************************************************/
void FINGERPRINT_Cmd_Img_To_Buffer1(void)
{
unsigned char i;
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<7;i++)
putchar(FP_Img_To_Buffer1[i]);
}
/************************************************************************************
************************************SAVES IMAGE TO BUFFER2***************************
************************************************************************************/
void FINGERPRINT_Cmd_Img_To_Buffer2(void)
{
unsigned char i;
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<7;i++)
putchar(FP_Img_To_Buffer2[i]);
}
/************************************************************************************
************************************REG MODEL BUFFER1 AND BUFFER2********************
************************************************************************************/
void FINGERPRINT_Cmd_Reg_Model(void)
{
unsigned char i;
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<6;i++)
putchar(FP_Reg_Model[i]);
}
/************************************************************************************
****************************COMPARES CONTENTS OF BUFFER1 AND BUFFER2*****************
************************************************************************************/
void FINGERPRINT_Cmd_Match(void)
{
unsigned char i;
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<6;i++)
putchar(FP_Reg_Match[i]);
}
/************************************************************************************
****************************STORES CONTENTS OF BUFFER1 AND BUFFER2*****************
************************************************************************************/
void FINGERPRINT_Cmd_Store(void)
{
unsigned char i;
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<9;i++)
putchar(FP_Reg_Store[i]);
}
/************************************************************************************
************************************ DATA TO BUFFER1 OR BUFFER2**********************
************************************************************************************/
void FINGERPRINT_Cmd_LoadChar(void)
{
unsigned char i;

for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<9;i++)
putchar(FP_Reg_LoadChar[i]);
}
/************************************************************************************
**********************************DELETES ALL FINGER PRINT MODULES******************
************************************************************************************/
void FINGERPRINT_Cmd_Delete_All_Model(void)
{
unsigned char i;

for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i>8;
FP_Delete_Model[5]=(uiID_temp&0x00FF);

for(i=0;i>8;
FP_Delete_Model[9]=uiSum_temp&0x00FF;

for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<10;i++)
putchar(FP_Delete_Model[i]);
}
/************************************************************************************
************************************GETS TEMPLATE NUMBER ****************************
************************************************************************************/
void FINGERPRINT_Cmd_Get_Templete_Num(void)
{ unsigned int i;
// unsigned char temp[14];
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);
for(i=0;i<6;i++)
putchar(FP_Templete_Num[i]);
}
/************************************************************************************
*****************SEARCHES FINGER PRINT MODULE ***************************************
************************************************************************************/
void FINGERPRINT_Cmd_Search_Finger(void)
{
unsigned char i;
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<11;i++)
putchar(FP_Search[i]);
}
/************************************************************************************
******************************SEARCHES FINGER PRINT MODULE **************************
************************************************************************************/
void FINGERPRINT_Cmd_Search_Finger_Admin(void)
{
unsigned char i;
for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i<11;i++)
putchar(FP_Search_0_9[i]);
}
/************************************************************************************
************************************SAVES FINGER PRINT MODULE************************
************************************************************************************/
void FINGERPRINT_Cmd_Save_Finger( unsigned char ucH_Char,unsigned char ucL_Char )
{
unsigned long temp = 0;
unsigned char i;

FP_Save_Finger[5] = ucH_Char;
FP_Save_Finger[6] = ucL_Char;

for(i=0;i> 8;
FP_Save_Finger[8]= temp & 0x0000FF;

for(i=0;i<6;i++)
putchar(FP_Pack_Head[i]);

for(i=0;i> 4) & 0x0F)|LCD_EN;
DATA_PORT = ((cmd >> 4) & 0x0F);

DATA_PORT = (cmd & 0x0F)|LCD_EN;
DATA_PORT = (cmd & 0x0F);

Delay_ms(10);
}
/*****************************************************************************************
*********************FUNCTION TO DISPLAY CHARACTER ON THE LCD********************************
*****************************************************************************************/
void Lcd_Data (unsigned dat)
{
DATA_PORT = (((dat >> 4) & 0x0F)|LCD_EN|LCD_RS);
DATA_PORT = (((dat >> 4) & 0x0F)|LCD_RS);

DATA_PORT = ((dat & 0x0F)|LCD_EN|LCD_RS);
DATA_PORT = ((dat & 0x0F)|LCD_RS);

Delay_ms(5);
}

/*****************************************************************************************
*********************LCD INITIALIZATION PARAMETERS****************************************
*****************************************************************************************/
void Lcd_Init ()
{
Lcd_Reset(); // Call LCD reset
Lcd_Cmd (0×28); // 4-bit mode – 2 line – 5×7 font.
Lcd_Cmd (0x0C); // Display no cursor – no blink.
Lcd_Cmd (0×06); // Automatic Increment – No Display shift.
Lcd_Cmd (0×80); // Address DDRAM with 0 offset 80h.
}
/*****************************************************************************************
*********************PLACES THE LCD CURSOR AT ANY POSITION ON THE DISPLY******************
*****************************************************************************************/
void Lcd_Cursor (char row, char column)
{
switch (row) {
case 1: Lcd_Cmd (0×80 + column – 1); break;
case 2: Lcd_Cmd (0xc0 + column – 1); break;
//case 3: Lcd_Cmd(0×94 + column – 1); break;
// case 4: Lcd_Cmd (0xd4 + column – 1); break;
default: break;
}
}
/*****************************************************************************************
*********************FUNCTION TO DISPLAY STRING ON THE LCD********************************
*****************************************************************************************
void Lcd_Chr(char row, char column, char c)
{
Lcd_Cursor (row, column);
Lcd_Data(c);
}
/*****************************************************************************************
*********************FUNCTION TO DISPLAY STRING ON THE LCD********************************
*****************************************************************************************/
void Lcd_Write(char row, char column, char *s)
{
Lcd_Cursor (row, column);
while (*s)
{
Lcd_Data(*(s++));
}
return;
}
/*****************************************************************************************
*********************SCROLLS TEXT ON LCD SCREEN*******************************************
***************************************************************************************** /
void Lcd_Scroll(char *word)
{
char *pos; // character pointers
char *adder;
int i,displayLen;
pos=word;
displayLen=16;
while (*pos != ”)
{
i=0;
adder=pos;
while ((i<displayLen)&&(*adder!=''))
{
Lcd_Data(*adder);
adder++;
i++;
}
Delay_ms(200);
Lcd_Cmd(_LCD_CLEAR);
pos++;
}
}

/*****************************************************************************************
*********************DISPLAY CHARACTER ON LCD AND USART***********************************
*****************************************************************************************/
#endif
/*****************************************************************************************
********ENLOY*************ENJOY***********ENJOY***************ENJOY*************ENJOY******
*****************************************************************************************/

Lib _Uart.h
/***************************************************************************
(((((((((((((((((((((((((((UART ..HEADER FILE…SUNDAY))))))))))))))))))))))
****************************************************************************/
#ifndef __Lb_Uart_H__
#define __Lb_Uart_H__

#define FOSC 11059200//11059200 ///xtal value
/***************************************************************************
(((((((((((((((((((((((((((BACIC SERIAL COM INITIALS))))))))))))))))))))))))
****************************************************************************/
void Uart_Init(unsigned long BPS)
{
#ifndef MONITOR51
SCON = 0×50; /* SCON: mode 1, 8-bit UART, enable rcvr */
TMOD |= 0×21; /* TMOD: timer 1, mode 2, 8-bit reload */
if(BPS==1200) {TH1=0xE8;TL1=0xE;}
if(BPS==2400) {TH1=0xF4;TL1=0xF4;}
if(BPS==4800) {TH1=0xFA;TL1=0xFA;}
if(BPS==9600) {TH1=0xFD;TL1=0xFD;}
if(BPS==19200) {TH1=0xFD;TL1=0xFD; PCON=0×80;}
if(BPS==28800) {TH1=0xFF;TL1=0xFF; }
if(BPS==38400) {TH1=0xFE;TL1=0xFE;;PCON=0×80;}
if(BPS==57600) {TH1=0xFF;TL1=0xFF;PCON=0×80;}
TR1 = 1; /* TR1: timer 1 run */
TI = 1; /* TI: set TI to send first char of UART */
#endif
}
#endif
/***************************************************************************
((((((((((NOTE:The baud rate is accurate only at values ranging))))))))))))
(((((((from 9600 to 1200////any bps above 9600 gives errors))))))))))))///
****************************************************************************/

Lib_Delay.h

/*****************************************************************************************
*********************LIB_DELAY.H FOR 8051 ***********************************
*****************************************************************************************/
#ifndef Lib_Delay_H_
#define Lib_Delay_H_
#include
#define XTAL 11059200

unsigned char Delay8Plus2xCycles (unsigned char x);
unsigned char Delay8Plus2nCycles (unsigned char LoopCount)
{
while (–LoopCount);
return (LoopCount);
}

#define Crystal 11059200L /* Crystal speed */
#define ClockRes (Crystal/12) /* Clock ticks per second */

#define NanoSecondsPerCycle (1000000000L / ClockRes)
#define uSecToInstCycles(x) ((1000L * (x)) / NanoSecondsPerCycle)

/*
#define NOPS(x) \
(((x) & 1) ? _nop_() : 0), \
(((x) & 2) ? _nop_(),_nop_() : 0), \
(((x) & 4) ? _nop_(),_nop_(),_nop_(),_nop_() : 0), \
(((x) & ? _nop_(),_nop_(),_nop_(),_nop_(),_nop_(),_nop_(),_nop_(),_nop_() : 0)*/

/*****************************************************************************************
******************** *MICRO SEC DELAY MACRO ***************************
*****************************************************************************************/
#define Delay_us(InstCycles) \
(((InstCycles) & 1) ? _nop_() : 0), \
(((InstCycles) & 2) ? _nop_(),_nop_() : 0), \
(((InstCycles) & ~7) ? Delay8Plus2nCycles(((InstCycles/4)-2)*2) \
: (((InstCycles) & 4) ? _nop_(),_nop_(),_nop_(),_nop_() : 0))

/*****************************************************************************************
******************** *DELAY IN MILI SECONDS ***********************************
*****************************************************************************************/
void Delay_ms(unsigned Time_ms) ;
void Delay_ms(unsigned Time_ms) {
unsigned long NumberOfCyc;
NumberOfCyc =XTAL / 12000; // this will be done by compiler, no asm will be genereated except that for assignment;
NumberOfCyc = NumberOfCyc * Time_ms;
NumberOfCyc = NumberOfCyc >> 5; // Dec and While below take around 32 instructions

if (NumberOfCyc > NumberOfCyc -= 8;
else
NumberOfCyc = 0;
while (NumberOfCyc) // while loop takes 32 cycles
{ //
–NumberOfCyc; //
_nop_(); //
_nop_(); //
_nop_(); //
}
}
/*****************************************************************************************
********************* THE END **********************************
*****************************************************************************************/
#endif
/*****************************************************************************************
********************* PLEASE DONOT EDIT **********************************
*****************************************************************************************/

if(rx[i-2]==13 && rx[i-1]==10)
{
rx[i-1]=”;
rx[i-2]=”;
i=0;

can u plz tell me the functioning of this block before any string comparison….

thanks in advance

and by the way, not all applications requires a graphical user interface. when we need to use GUI we develop on java/android and other platforms such as ucGUi. if you have a sample that uses MIDP, please share…

I will post the hex file if I recompile the code,but I will suggest that you try it again with this modification. If you don’t have the ccs c compiler, you can download the demo version from this link http://ccsinfo.com/ccsfreedemo.php