The job of the MCU in this project is to receive signals from the input device (keypad) and take corresponding actions. Whenever any key is pressed on the keypad, the software program in the MCU identifies the pressed key and accordingly turns on or turns off the appliance. A 4×4 matrix keypad is used to give commands and the password to the MCU. It consists of 16 keys (S2-S17) arranged in the form of a square matrix of four rows and four columns. Each key in the matrix is labeled according to the operation assigned to it. The connections from the pin-outs of the keypad to the MCU pins are shown in Fig. 1. Rows 1 through 4 are connected to pins RB3, RB2, RB1 and RB0 of Port B of the MCU, respectively.
The key identification is done by identifying the row and the column to which the key belongs. Fig. 1 shows how the keypad is connected to Port B of the MCU. The lower nibble of Port B is declared as output pins (scan lines) and the upper nibble is declared as input pins (return lines).

Whenever a key is pressed, the up- per nibble pin (return line) of Port B, to which the column containing the key is connected, goes high. Thus the column is identified. Column identification is done using a switch-case block in the main program. On identifying the column. To identify the row, scan lines are made low one by one in sequence and status of the return line corresponding to the key is checked. If it becomes low, the key belongs to that scan line or row. After identifying the key, the correct key is generate and the returned by the Getkey_Pressed() function.
To open the door, press the open button, enter the correct password, if correct the buzzer beeps three times and the door opens and closes, else beeps twice. to do download the circuit, click on the link below..

PASS_DOOOR.click to download circuit.

The software code is written with C language an compiled using Mikro C pro pic compiler.
Below is the C code.

/************************************************************************************
********************four digits password combination lock****************
************************************************************************************/
sbit Row0 at RB4_bit;
sbit Row1 at RB5_bit;
sbit Row2 at RB6_bit;
sbit Row3 at RB7_bit;

sbit MTR1 at RA4_bit;
sbit MTR0 at RA3_bit;
sbit Buzzer at RA2_bit;
sbit Status_Light at RA0_bit;
sbit Button at RA1_bit;

unsigned char  key_pressed;
bit key_flag;
bit Wait_Time;
unsigned char  Temp_Pass[5];
//unsigned char  Default_Pass[5]="0000";

unsigned char  KEYPAD at PORTB;
int count;
bit Default_State;
/************************************************************************************
********************this fuction gets the keypressed from the matrix keypad***********
************************************************************************************/
char Getkey_Pressed(void)
{
        key_flag=0;
        KEYPAD=0xFE;                                 //scan  col1
        if(!Row0 ||!Row1 || !Row2 || !Row3)
        {
        if(!Row0)key_pressed='1';                           // check for key pressed
        else if(!Row1)key_pressed='4';
        else if(!Row2)key_pressed='7';
        else if(!Row3)key_pressed='*';
        while(!Row0 ||!Row1 || !Row2 || !Row3) ;
        key_flag=1;
        }

        KEYPAD=0xFD;
        if(!Row0 ||!Row1 || !Row2 || !Row3)
        {
        if(!Row0)key_pressed='2';          //scan  col2
        else if(!Row1)key_pressed='5';          // check for key pressed
        else if(!Row2)key_pressed='8';
        else if(!Row3)key_pressed='0';
        while(!Row0 ||!Row1 || !Row2 || !Row3) ;
        key_flag=1;
        }

        KEYPAD=0xFB;                                                   //scan  col2
        if(!Row0 ||!Row1 || !Row2 || !Row3)
        {
        if(!Row0)key_pressed='3';
        else if(!Row1)key_pressed='6';        // check for key pressed
        else if(!Row2)key_pressed='9';
        else if(!Row3)key_pressed='#';
        while(!Row0 ||!Row1 || !Row2 || !Row3) ;
        key_flag=1;
        }

        KEYPAD=0xF7;                                                         //scan  col2
        if(!Row0 ||!Row1 || !Row2 || !Row3)
        {
        if(!Row0)key_pressed='A';
        else if(!Row1)key_pressed='B';           // check for key pressed
        else if(!Row2)key_pressed='C';
        else if(!Row3)key_pressed='D';
        while(!Row0 ||!Row1 || !Row2 || !Row3) ;
        key_flag=1;
        }
        return key_pressed;                        //return key pressed
}

void Beep(void)
{
   Buzzer=1;
   Delay_ms(800);
   Buzzer=0;
}
/************************************************************************************
********************this function opens and closes the door         ****************
************************************************************************************/
void Open_Close_Door(void)
{
        MTR0=1;
        MTR1=0;
        Delay_ms(2000);
        MTR0=0;
        MTR1=0;
        Delay_ms(3000);

        MTR0=0;
        MTR1=1;
        Delay_ms(2000);
        MTR0=0;
        MTR1=0;
        return;
}
/************************************************************************************
**********this fuction writes a byte to the internal EEPROM of the pic16f84 chip*****
************************************************************************************/
unsigned char EEPROM_Read(char adr)
{
   INTCON.GIE = 0;    //global interrupt enable
   EEADR=adr;
   EECON1.RD=1; // set the read bit
   INTCON.GIE = 1;    //global interrupt enable
   return(EEDATA);
}
 /************************************************************************************
******this fuction reads from a byte from the internal EEPROM of the pic16f84 chip*****
************************************************************************************/
void EEPROM_Write(unsigned char adr, unsigned char dat)
{
   INTCON.GIE = 0;    //global interrupt enable
   EEADR = adr;
   EEDATA = dat;

   EECON1.WREN = 1;  // write enable
   EECON2 = 0x55; // protection sequence
   EECON2 = 0xaa;

   EECON1.WR = 1;  // begin programming sequnce
   Delay_ms(20);
   EECON1.WREN = 0;  // disable write enable
   INTCON.GIE = 1;    //global interrupt enable
   return;
}

/************************************************************************************
******this fuction matches the user entered password and the admin set password*****
************************************************************************************/
int Match_Password(unsigned char *Admin,unsigned char Chr )
{
        int pas;
        unsigned char Rx_key;
        unsigned char  temp[5];

        pas=0;
        for(pas=0;pas<4;pas++) temp[pas]='';
        pas=0;
        Rx_key='';

        temp[pas]=Chr;

        pas=1;

        do
                {
                Rx_key=Getkey_Pressed();
                if(key_flag!=0)
                {

                if(Rx_key!='*'&&Rx_key!='#'&&pas<4)
                {
                temp[pas]=Rx_key;
                pas=pas+1;
                Status_Light=1;
                Delay_ms(500);
                Status_Light=0;
                }
                }
         }while(Rx_key!='#'|| pas<4);

                 if(strncmp(Admin,temp,4)==0)//
                         return 1;

                else
                        return 0;
}
/************************************************************************************
*                        finger print and pass word based attendance system                                                *
************************************************************************************/
 int Set_Password(unsigned char *Admin )
 {
      int pas,ii;
        unsigned char Rx_key;
        unsigned char  temp[10];

        pas=0;
        for(pas=0;pas<4;pas++) temp[pas]='';
        pas=0;
        Rx_key='';

        do
                {
                Rx_key=Getkey_Pressed();
                if(key_flag!=0)
                {

                if(Rx_key!='*'&&Rx_key!='#'&&pas<4)
                {
                temp[pas]=Rx_key;
                pas=pas+1;
                Status_Light=1;
                Delay_ms(500);
                Status_Light=0;
                }
                }
         }while(Rx_key!='#'|| pas<4);

         do
                {
                Rx_key=Getkey_Pressed();
                if(key_flag!=0)
                {

                if(Rx_key!='*'&&Rx_key!='#'&&pas<8)
                {
                temp[pas]=Rx_key;
                pas=pas+1;
                Status_Light=1;
                Delay_ms(500);
                Status_Light=0;
                }
                }
         }while(Rx_key!='#'|| pas<8);

                 if(strncmp(Admin,temp,4)==0)//
                       {
                         for(ii = 0; ii < 4; ii++)             // Fill data buffer
                         EEPROM_Write(0x00+ii,temp[ii+4]);           // Write data to address 0x80+ii

                         for(ii = 0; ii < 4; ii++)           // Read 4 bytes block from address 0x80
                         Temp_Pass[ii]= EEPROM_Read(0x00+ii);        //   into temp storage;

                         return 1;
                       }
                else
                        return 0;
 }
 /*********************************************************************************
 * *********************body of main program***************************************
************************************************************************************/
void main (void)
{
     int ii;
    char Rx_Key;

    TRISB=0xF0;
    TRISA=0x02;
    Status_Light=0;
    MTR0=0;
    MTR1=0;

    /**********************************************************************************
      *********this fuction writes a default password to the EEPROM********************
      *****This is a manufacturer's function call and must be at program start up..****
      ****Note***this fuction must be evoked once and only once during the product's*****
      *                            life cycle...                                      *
      *********************************************************************************/
      if(!Button)
      {
       Delay_ms(200);
       if(!Button){
                  Delay_ms(3000);
                   if(!Button)
                    {
                   for(ii = 0; ii < 4; ii++)             // Fill data buffer
                    EEPROM_Write(0x00+ii,'0');           // Write data to address 0x80+ii
                    }
                   }
      }

    for(ii = 0; ii < 4; ii++)           // Read 4 bytes block from address 0x00
    Temp_Pass[ii]= EEPROM_Read(0x00+ii);        //   into temp storage;

while(1)                    //do this forever
    {
      if(!Button)            //check if the Button is pressed
      {
                   do
                   {
                   Rx_Key=Getkey_Pressed();    //get first character from keypad
                             }while(key_flag==0);  //do this untill a Button is pressed
                   if(key_flag!=0)
                        {
                        if(Rx_Key=='*')      //check if user intends to change the password
                         {
                            if(Set_Password(Temp_Pass))     // check if user old password is correct and save new password
                               {
                                    Beep();
                                    Beep();
                                    Beep();
                               }
                               else Beep();    //else wrong password

                         }
                         else
                         {
                          Status_Light=1;
                          Delay_ms(500);
                          Status_Light=0;
                             if(Match_Password(Temp_Pass,Rx_Key))  //check if user password entered is correct
                               {
                                   Beep();
                                   Beep();
                                   Beep();
                                   Open_Close_Door();    //open and close door
                               }
                               else Beep();        //else wrong password

                         }
                         key_flag=0;
                        }
    }
    }
}

This is a simple calculator project.  You can use it to do your simple calculations such as addition, subtraction, multiplication and division. The hardware design is very simple: just interface your 16x2LCD and 4×4 keypad to the microcontroller.

All the components used are available here: www.microscale-embedded.com

The source code is shown below:

#include "main.h"
#include "lcd.c"
#include <stdio.h>
#include <stdlib.h>
char row = 0xef;
char col;
char Read_keypad()
{
   byte scancode;
   while(1)
   {
      if((row & 0xf0) != 0xf0) //check if we're not done shifting 4 places
         row <<= 1; //continue, shift left by one bit
      else
         row = 0xef;//done shifting, so reset to initial value

      output_C(row);
      col = input_A();
      col &= 0x0f;//clear upper 4 bits of colunm
      scancode = col | (row & 0xf0);//clear lower 4 bits of row and combine with
                               //upper 4 bits of colunm to form the scan code
      switch(scancode)
      {
         case 0x7D: return '0';    // note that the scancode is formed by
         case 0xBE: return '9';    // combining the row code and the column code
         case 0xBD: return '0';    // rows and columns are coded as follows;
         case 0xBB: return '+';    //    0  ->  E
         case 0xDE: return '5';    //    1  ->  D
         case 0xDD: return '6';    //    2  ->  B
         case 0xDB: return '7';    //    3  ->  7
         case 0xEE: return '1';    //
         case 0xED: return '2';    // so for key '0' for example, which is on
         case 0xEB: return '3';    // row 3 and column 1 the scancode will be:
         case 0x7E: return '.';    //      7D
         case 0x7B: return '*';
         case 0x77: return '+';
         case 0xB7: return '4';
         case 0xD7: return '8';
         case 0xE7: return '/';
      }
   }
}

void main()
{
double display = 0;//stores the value to be displayed on the screen
   double operand1, operand2;//store the operands to be used for the next operation
   char operation;//next operation to be performed
   char key;// stores the key pressed
   double digit;//stores key in numeric format

   int dp = 0; //indicates when the decimal point has been pressed

   lcd_init();
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
lcd_init();
   // TODO: USER CODE!!
while(1)
   {
      lcd_gotoxy(1,1);
      printf(lcd_putc,"%15.0f", display);
      key = Read_keypad();
      delay_ms(100);//delay for key-debounce, change the interval to tune performance
      if(key >= '0' && key <= '9')
      {
         digit = atof(&key);
         if(dp == 0)
         {
            if(operand1 < 10000000)
               operand1 = operand1 * 10 + digit;
            display = operand1;
         }
         else
           display = display * 10 + digit;//todo fix this
      }
      else if(key == '.')
      {
      }
      else
      {
         switch(operation)
         {
            case '+': display = operand2 + operand1; break;
            case '-': display = operand2 - operand1; break;
            case '*': display = operand2 * operand1; break;
            case '/': display = operand2 / operand1; break;
            case '=':
         }
         operation = key;
         operand2 = display;
         operand1 = 0;
      }
   }

}

Components lists

1.         STC90C52RC

2.        16X2 GRAPHIC LCD

3.        DS3102

4.        XTAL.  11.0592MHz.

5.        4.7K Ohms Resistor                (3 nos.)

6.        10K Ohms Resistor  (1 nos.)

7.        7805                                        (1 nos.)

8.        9V battery

C sources codes below

/***********************************************************************

(((((((((((((((((<digital clock and calender using 8051 mcu>)))))))))))))

************************************************************************/

#include <LIB_STC_MCU.h>

#include <intrins.h>

#include <Lib_Delay.c>

#include <stdio.h>

#include <RTC_C51.c>

#include <lcd_4.h>

/**************************************************************************

((((((((((((((((((((<this sets the time on the ds1302>)))))))))))))))))))))

***************************************************************************/

void Set_time(void)                   //

{

                Set_Seconds(0);                     //initialise seconds to 00

                Set_Minutes(any value btwn 00 to 59);

                Set_Hour(any value btwn 00 to 23);

                Set_Date(any value btwn 01 to 31) ;

                Set_Month(any value btwn 01 to 12);

                Set_Day(any value btwn 01 to 07);

                Set_Year(any value btwn 01 to 99);

}

/****************************************************************************

(((((((((((((((((((((<displays current time and date on lcd>)))))))))))))))))

*****************************************************************************/

void Display(void)

{

                                Read_Time();

                                Lcd_Cursor(1,1);

                                printf(“%d:%d:%d %s”,hours,minutes,seconds,*day[week_days-1]);

                                Lcd_Cursor(2,1);

                                printf(“Date: %d/%d/20%d “,date,month,year);

                                Delay_ms(1000);

}

/*************************************************************************

(((((((((((((((((((((((((((((<body of main program>)))))))))))))))))))))))))))))))))))))

*************************************************************************/

void main(void)

{

                                Lcd_Init();                                   //initialises lcd

                                DEVICE=LCD;                                   

                                Lcd_Cmd(_LCD_CLEAR);            //clear lcd screen at default

                                Delay_ms(500);                                      //wait awhile

                                Rtc_Start();                                             //start time clock

                                Set_time();                                              //set time

                while(1)    //loop forever

                {

                                Display();   //display current time and date

                }

}

/*************************************************************************

(((((((((((((((((((((((((((((((((((((<the end>)))))))))))))))))))))))))))))))))))))))))

*************************************************************************/

/******************************************************************

(((((((((((((((((((((((((((((((((((((<RTC_C51.c>)))))))))))))))))))))))))))))))))))))))))

*******************************************************************/

sbit SCLK =P0^5;

sbit DATA=P0^4;

sbit RST=P0^3;

int a;

void clk_write(unsigned char);

unsigned char clk_read(void);

void RST_toggle (void);

void clkburst(void);

int idata seconds, minutes, hours,week_days, date, month, year; // Global date/time variables

unsigned char idata *day[7]={“Sun.”,“Mon.”,“Tue.”,“Wed.”,“Thu.”,“Fri.”,“Sat.”};

/*************************************************************************

(((((((((((((((((((((((((((((((((((((<CE latch>)))))))))))))))))))))))))))))))))))))))))

**************************************************************************/

void RST_toggle (void)

{

   RST = 0;

   for(a=0;a<10;a++);

   RST = 1;

}

/*************************************************************************

(((((((((((((((((((((((((((((((((((((<writes a byte to rtc>)))))))))))))))))))))))))))

*************************************************************************/

void clk_write(unsigned char dat)

{

        char x;

        for(x=0;x<8;x++)

        {

                if(dat & 0×01)                        //put bit on data pin

                DATA = 1;

                else

                DATA = 0;

                SCLK = 1;                                //toggle clock to latch bit

                                                                for(a=0;a<10;a++);

                SCLK = 0;

                dat >>= 1;                        //move next bit into place

        }

}

/*********************************************************************

(((((((((((((((((((((((((((((((((((((<reads a byte from rtc>))))))))))))))))))))))))))))

**********************************************************************/

unsigned char clk_read(void)

{

        char x;

        unsigned char dat,tmpdat;

        dat = 0;

        DATA = 1;                                //make DATA input

        for(x=0;x<8;x++)

        {

                if(DATA)                                //read a bi

                        tmpdat |= 1;

                else tmpdat |= 0;

                tmpdat <<= 7;

                dat >>= 1;

                dat |= tmpdat;

                SCLK = 1;                                //toggle clock to latch bit

                                                                for(a=0;a<10;a++);

                SCLK = 0;

        }

        DATA= 0;

        return(dat);

}

/**********************************************************************

(((((((((((((((((((((((((((((((((((((<reads rtc time and date>))))))))))))))))))))))))))

***********************************************************************/

void Read_Time()

{

  RST = 1;

  clk_write(0×81);    seconds =clk_read(); RST_toggle ();   // Read seconds byte

  clk_write(0×83);    minutes = clk_read();    RST_toggle ();    // Read minutes byte

  clk_write(0×85);    hours = clk_read();      RST_toggle ();   // Read hours byte

  clk_write(0×87);    date = clk_read();       RST_toggle ();   // Read year/day byte

  clk_write(0×89);    month = clk_read();      RST_toggle (); // Read weekday/month byte

  clk_write(0x8d);    year  =clk_read();       RST_toggle ();

  clk_write(0x8b);    week_days  =clk_read();  RST = 0;        // Issue stop signal

     seconds  =  ((seconds & 0xF0) >> 4)*10 + (seconds & 0x0F);  // Transform seconds

     minutes  =  ((minutes & 0xF0) >> 4)*10 + (minutes & 0x0F);  // Transform months

     hours    =  ((hours & 0xF0)  >> 4)*10  + (hours & 0x0F);    // Transform hours

     date      =  ((date & 0×30) >> 4)*10    + (date & 0x0F);       // Transform day

     week_days =  ((week_days & 0×30) >> 4)*10    + (week_days & 0x0F);       // Transform day

     month    =  ((month & 0×10)  >> 4)*10 + (month & 0x0F);     // Transform month

     year  =  ((year & 0xF0) >> 4)*10 + (year & 0x0F);           // Transform year

}

/***************************************************************************

(((((((((((((((((((((((((((((((((((((<sets seconds>)))))))))))))))))))))))))))))))))))))

***************************************************************************/

void Set_Seconds(unsigned char Sec)

{

    RST_toggle ();

    clk_write(0×80);

    clk_write(((Sec/10)<<4 | (Sec%10)));

    RST=0;

    return;

}

/**************************************************************************

(((((((((((((((((((((((((((((((((((((<sets minutes>)))))))))))))))))))))))))))))))))))))

**************************************************************************/

void Set_Minutes(unsigned char mins)

{

    RST_toggle ();

    clk_write(0×82);

    clk_write(((mins/10)<<4 | (mins%10)));

    RST=0;

    return;

}

/************************************************************************

(((((((((((((((((((((((((((((((((((((<sets the hour>))))))))))))))))))))))))))))))))))))

************************************************************************/

void Set_Hour(unsigned char hr)

{

    RST_toggle ();

    clk_write(0×84);

    clk_write(((hr/10)<<4 | (hr%10)));

    RST=0;

    return;

}

/*******************************************************************

(((((((((((((((((((((((((((((((((((((<sets the day of month>))))))))))))))))))))))))))))

********************************************************************/

void Set_Date(unsigned char date)

{

    RST_toggle ();

    clk_write(0×86);

    clk_write(((date/10)<<4 | (date%10)));

    RST=0;

    return;

}

/*********************************************************************

(((((((((((((((((((((((((((((((((((((<sets the month>)))))))))))))))))))))))))))))))))))))))))

**********************************************************************/

void Set_Month(unsigned char month)

{

    RST_toggle ();

    clk_write(0×88);

    clk_write(((month/10)<<4 | (month%10)));

    RST=0;

    return;

}

/*******************************************************************

(((((((((((((((((((((((((((((((((((((<sets day of the week>)))))))))))))))))))))))))))))

********************************************************************/

void Set_Day(unsigned char Day)

{

    RST_toggle ();

    clk_write(0x8A);

    clk_write(((Day/10)<<4 | (Day%10)));

    RST=0;

    return;

}

/*******************************************************************

(((((((((((((((((((((((((((((((((((((<sets the rtc year>))))))))))))))))))))))))))))))))

********************************************************************/

void Set_Year(unsigned char year)

{

    RST_toggle ();

    clk_write(0x8C);

    clk_write(((year/10)<<4 | (year%10)));

    RST=0;

    return;

}

/*******************************************************************

(((((((((((((((((((((((((((((((((((((<stars rtc clock>))))))))))))))))))))))))))))))))))

********************************************************************/

void Rtc_Start(void)

{

    RST_toggle ();

    clk_write(0×00);

    return;

}

/**********************************************************************

(((((((((((((((((((((((((((((((((((((<the end>)))))))))))))))))))))))))))))))))))))))))

***********************************************************************/

The circuit is here:

temp_logger

List of components used:

Components     quantity

PIC16F887         1

MAX232            1

16x2 LCD          1

LM35              1

100nF Capacitor   4

DB9 Connector     1

You can buy all these components at www.microscale-embedded.com

The source code is below:

#include <16f887.h>
#device ADC=10
#use delay(clock=4000000)
#fuses XT, NOWDT, NOPROTECT, NOLVP
#use RS232(baud = 9600, xmit = PIN_C6, rcv = PIN_C7)

#include <lcd.c>

void main(void)
{
       int16 temp_adc;
       float temp;

        setup_adc(ADC_CLOCK_DIV_8);
        setup_adc_ports(sAN0);
        set_adc_channel(0); //read analog input from channel 0

        lcd_init();

        printf ( lcd_putc, "Temperature is\n" );	//print to lcd
        printf ("Temperature is\n\r" );				//print to serial com

        while(true)
          {
            delay_ms(10);
            temp_adc = read_adc();
            temp = 5.00*temp_adc*100.00/1023.00; // = temp_adc*0.48828125;
         //  temp = temp_adc*0.48828125;
         lcd_gotoxy(5,2);
         printf ( lcd_putc,"%5.1f", (float)temp);
         lcd_putc(223);		//this number 223 will display the degree sign
         lcd_putc('C');

         printf ("%5.1f", (float)temp);
         putc(223);
         putc('C');
         printf ("\n\r");
         delay_ms(5000);
        }
}

This is a simple digital clock with calendar project using Microchip’s
PIC16F887 microcontroller and 16x2 LCD display.
The project will display the current date and time on the LCD.
The software used were MPLAB IDE and CCS C Compiler.

List of Components used:

Components	Quantity
PIC16F887 	    1
16x2LCD		    1
4MHz Crytal	    1
22pF Capacitor	    2
10K resistor	    1
7805		    1 

You can get these components at www.microscale-embedded.com

The source code is shown below

#include <16F887.h>
#use delay(clock=20000000)
#fuses XT,NOWDT,NOLVP
#use rs232(baud=9600,xmit =PIN_C6, rcv = PIN_C7)
#include "lcd.c"

//RTC variables
#define XTAL_FREQUENCY  4000000
#define TIMER1_FREQUENCY (XTAL_FREQUENCY / 4) // 1 clock tick = 1 instr. cycle = crystal frequency / 4
int32 Ticker;
int8 Seconds=0; 

int8 Year=11,Month=11,Days=25,Hours=8,Minutes=35; 

// Test whether a given year is a leap year.
#define IS_LEAP(year) (year%4 == 0) 

//    Initialize RTC
void Initialize_RTC(void)
{
  Ticker = TIMER1_FREQUENCY;                  // initialize clock counter to number of clocks per second
  setup_timer_1( T1_INTERNAL | T1_DIV_BY_1 ); // initialize 16-bit Timer1 to interrupt
                                              // exactly every 65536 clock cycles
                                              // (about 76 times per second)
  enable_interrupts( INT_TIMER1 );            // Start RTC
} 

#int_TIMER1
void TIMER1_isr()
{
  Ticker -= 65536;                        // Decrement ticker by clocks per interrupt
  if ( Ticker < 65536 )                   // If second has expired
  {  Ticker += TIMER1_FREQUENCY;          //   Increment ticker by clocks per second
     seconds++;                           //   Increment number of seconds
  } 

  if(Seconds == 60) {Minutes++; Seconds=0;
    if(Minutes == 60) {Hours++; Minutes=0;
      if(Hours == 24) {Days++; Hours=0;
        if (  (Days == 29 && Month==2 && !IS_LEAP(Year))
           || (Days == 30 && Month==2)
           || (Days == 31 && (Month==4 || Month==6 || Month==9 || Month==11 ))
           || (Days == 32)
           ) {Month++;Days=0;}
        if(Month == 13) {Year++; Month=0;}
  }}}
} 

void main()
{
  int8 prev_second;
  Initialize_RTC();
  enable_interrupts( GLOBAL );
   lcd_init();
  // loop forever
  while(true)
  {
    if (seconds != prev_second)
    {
      prev_second = seconds;
      lcd_gotoxy(2,1);
      printf(lcd_putc,"Date:");
      lcd_gotoxy(7,1);
      printf(lcd_putc," %d:%d:%d \r\n",Days,Month,Year);

      lcd_gotoxy(2,2);
      printf(lcd_putc,"Time:");
      lcd_gotoxy(7,2);
      printf(lcd_putc," %d:%d:%d \r\n",Hours,Minutes,seconds);
    }
  }
}

These project utilize fingerprint recognition technology to allow access to only those whose fingerprints you choose. It contains all the necessary electronics to allow you to store, delete, and verify fingerprints with just the touch of a button. Stored fingerprints are retained even in the event of complete power failure or battery drain. These eliminates the need for keeping track of keys or remembering a combination password, or PIN. It can only be opened when an authorized user is present, since there are no keys or combinations to be copied or stolen, or locks that can be picked.

In this project the fingerprint module FPM10A is used. It can store up to 100 finger prints on its own memory. It can be controlled through its serial port.

The microcontroller STC90LE58AD interacts with the module. You can add a fingerprint, Delete a fingerprint and identify the fingerprint.

more robust home automation. The transmit TXD of the mega16 connected to receive RXD of SIM300CZ and transmit TXD of the SIM300CZ connected to receive RXD of the mega16, once sms message “Device1 ON” or “Device1 OFF” is sent from mobile phone, the sim300cz will receive and send to microcontroller, the microcontroller will check the command and ON or OFF any of the relay. The relay can be connected to any device.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>
#include <util/delay.h>

unsigned int i=0;
char enter=0x0D;
char ctrZ=0x1A;

void USARTInit()
{

	//Set Baud rate
	UCSRA=0;
	UBRRL = 51;
	UBRRH = 0;
	UCSRC=(1<<URSEL)|(3<<UCSZ0);

	//Enable The receiver and transmitter
	UCSRB=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
}

char get_char()
{
	//Wait untill a data is available
	while(!(UCSRA & (1<<RXC)))
	{  }
	return UDR;
}

void put_char(char data)
{
	//Wait untill the transmitter is ready
	while(!(UCSRA & (1<<UDRE)))
	{
	}

	//Now write the data to USART buffer
	UDR=data;
}

void put_str(char* str)
{
	unsigned char len;
	len=strlen(str);

	for(int i=0;i<len;i++)
	{
		_delay_ms(100);

		while((UCSRA & 0x20) == 0x0);

		UDR=str[i];
	}
}

int main (void)
{
	// set PORTA for output
	DDRA |= (1<<PA2) | (1<<PA1) | (1<<PD0);
	PORTA &= ~(1<<PA2) | (1<<PA1) | (1<<PA0);

	USARTInit();
	_delay_ms(1000);

	send("AT");
	put_str(dummy);

	while(get_char()!='O');
	while(get_char()!='K');//Waiting for modem response

	put_str("ATE0");
	put_str (dummy);

	while(get_char()!='O');
	while(get_char()!='K');//Waiting for modem response

	put_str ("AT+CMGF=1");
	put_str (dummy);

	while(get_char()!='O');
	while(get_char()!='K');//Waiting for modem response

	put_str ("AT+CNMI=2,2,0,0,0");
	put_str (dummy);

	while(get_char()!='O');
	while(get_char()!='K');//Waiting for modem response

	while(1)
	{

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

			if(strcmp(rx,"device1 ON")==0)
			{
				PORTA |= (1<<PA0);
				_delay_ms(1000);
				put_str ("AT");
				put_str (enter);
				put_str ("AT+CMGS=\"+gsm number\"");   // you need to add your gsm number here e.g +2348033870967
				put_str (enter);
				put_str ("device1 ON ");
				put_str (ctrZ);
			}

			if(strcmp(rx,"device1 OFF")==0)
			{
				PORTA |= (1<<PA1);
				_delay_ms(1000);
				put_str ("AT");
				put_str (enter);
				put_str ("AT+CMGS=\"+gsm number\"");
				put_str (enter);
				put_str ("device1 OFF ");
				put_str (ctrZ);
			}

			if(strcmp(rx,"device2 ON")==0)
			{
				PORTA |= (1<<PA2);
				_delay_ms(1000);
				put_str ("AT");
				put_str (enter);
				put_str ("AT+CMGS=\"+gsm number\"");
				put_str (enter);
				put_str ("device2 ON");
				put_str (ctrZ);
			}

			if(strcmp(rx,"device2 OFF")==0)
			{
				PORTA |= (1<<PA2);
				_delay_ms(1000);
				put_str ("AT");
				put_str (enter);
				put_str ("AT+CMGS=\"+gsm number\"");
				put_str (enter);
				put_str ("device2 OFF");
				put_str (ctrZ);
			}

			if(strcmp(rx,"device3 ON")==0)
			{
				PORTA |= (1<<PA2);
				_delay_ms(1000);
				put_str ("AT");
				put_str (enter);
				put_str ("AT+CMGS=\"+gsm number\"");
				put_str (enter);
				put_str ("device3 ON");
				put_str (ctrZ);
			}

			if(strcmp(rx,"device3 OFF")==0)
			{
				PORTA |= (1<<PA2);
				_delay_ms(1000);
				put_str ("AT");
				put_str (enter);
				put_str ("AT+CMGS=\"+gsm number\"");
				put_str (enter);
				put_str ("device3 OFF");
				put_str (ctrZ);
			}

		}

	}
}

Hardware Description:  MCU STC89Cxx, frequency up to 90MHz, on-chip FLASH program memory 4K above, 8K or so chip EEROM, 512B-1208B-chip RAM, 36 IO ports.

• TC35 module incorporates the standard RS232 interface and SIM card.
• 1 LED: a power indicator.
• LM2941 4.2V power supply IC.
• ISP interface (for program download, serial monitor).
• RS232 interface ISP; support serial debugging
• 12V DC power input with power indicator
• 8 LED indicators
• On-board microphone, handset interface for voice call.
• On-board digital temperature sensor DS18B20 interface which can be programmed for wireless temperature transmission applications.
• 16-channel digital output, 8 channels for relay control, and the other 8 TTL-level outputs for user expansion. (Relay control load: 250V/10A)
• TC35 module serial communication modes selection: supports connecting modem to MCU or modem to PC serial communication.

For availability and pricing, contact Microscale Embedded: info @ microscale-embedded. com

/******************************************************

******************************************************/

#include <avr/io.h>

#include <util/delay.h>

#include <avr/interrupt.h>

#include “lcd.h”

volatile unsigned int      millisecond=0;

volatile char              second=0;

volatile char              minute=0;

volatile char              hour=0;

int main()

{

PORTB|=((1<<PB2)|(1<<PB1)|(1<<PB0));

int8_t hr,min;

hr=min=0;

lcd_Init(0);

LCDClear();

TCCR1B=(1<<WGM12)|(1<<CS11)|(1<<CS10);

OCR1A=250;

TIMSK|=(1<<OCIE1A);

sei();

LCDClear();

lcd_String(“     DIGITAL       “);

lcd_Stringxy(0,1,”   Stop Watch  “);

_delay_ms(100);

LCDClear();

lcd_String(“   STOP WATCH  “);

lcd_Stringxy(0,1,”Stop “);

lcd_Stringxy(6,1,”- 00:00:00″);

hour = hr;

minute = min;

second =0;

LCDClear();

lcd_String(“   STOP WATCH  “);

lcd_Stringxy(0,1,”Start “);

lcd_Stringxy(6,1,”-”);

while(1)

{

lcd_Intxy(8,1,hour,2);

lcd_String(“:”);

lcd_Intxy(11,1,minute,2);

lcd_String(“:”);

lcd_Intxy(14,1,second,2);

if(!(PINB & (1<<PB0)))

{

lcd_Stringxy(0,1,”Reset “);

millisecond=0;

second=0;

minute=0;

hour=0;

lcd_Stringxy(0,1,”Start “);

}

if(!(PINB & (1<<PB1)))

{

lcd_Stringxy(0,1,”Stop “);

TCCR1B&=(~((1<<CS12)|(1<<CS11)|(1<<CS10)));

}

if(!(PINB & (1<<PB2)))

{

lcd_Stringxy(0,1,”Start “);

TCCR1B=(1<<WGM12)|(1<<CS11)|(1<<CS10);

}

if((hour == 9) && (minute == 9) && (second == 9))

{

hour = 0;

minute = 0;

second =0;

}

}

}

ISR(TIMER1_COMPA_vect)

{

millisecond++;

if(millisecond==61)

{

second++;

millisecond=0;

if(second==59)

{

minute++;

second=0;

if(minute==59)

{

hour++;

minute=0;

}

}

}

}

The firmware (C source code in AVR Studio syntax) is shown below*

#include <avr/io.h>
#include <util/delay.h>
#include “lcd.h”
#include “lcd.c”

#define KB_PORT_OUT PORTD
#define KB_PORT_IN PIND

unsigned char upperNibble, keyCode, keyPressed, i;

int main()
{
DDRA = 0xff;
DDRB = 0xff;
DDRD = 0x0f;
PORTD = 0xff;
lcd_init(DISPLAY_ON);
lcd_puts(“Press any key”);
lcd_gotoXY(0,1);
while(1)
{
upperNibble = 0xff;

for(i=0; i<4; i++)
{
_delay_ms(1);
KB_PORT_OUT = ~(0×01 << i);
_delay_ms(1); //delay for port o/p settling
upperNibble = KB_PORT_IN | 0x0f;

if (upperNibble != 0xff)
{
_delay_ms(20); //key debouncing delay
upperNibble = KB_PORT_IN | 0x0f;
if(upperNibble == 0xff) goto OUT;

keyCode = (upperNibble & 0xf0) | (0x0f & ~(0×01 << i));

while (upperNibble != 0xff)
upperNibble = KB_PORT_IN | 0x0f;

_delay_ms(20); //key debouncing delay

switch (keyCode) //generating key characetr to display on LCD
{
case (0xee): keyPressed = ’7′;
break;
case (0xed): keyPressed = ’4′;
break;
case (0xeb): keyPressed = ’1′;
break;
case (0xe7): keyPressed = ‘ ‘;
break;
case (0xde): keyPressed = ’8′;
break;
case (0xdd): keyPressed = ’5′;
break;
case (0xdb): keyPressed = ’2′;
break;
case (0xd7): keyPressed = ’0′;
break;
case (0xbe): keyPressed = ’9′;
break;
case (0xbd): keyPressed = ’6′;
break;
case (0xbb): keyPressed = ’3′;
break;
case (0xb7): keyPressed = ‘=’;
break;
case (0x7e): keyPressed = ‘/’;
break;
case (0x7d): keyPressed = ‘X’;
break;
case (0x7b): keyPressed = ‘-’;
break;
case (0×77): keyPressed = ‘+’;
break;
default : keyPressed = ‘X’;
}//end of switch

lcd_putc((char)keyPressed);

OUT:;
}//end of if
}//end of for
}//end of while(1)

return 0;
}

The “lcd.h” and “lcd.c” will be made available on request.