#include<htc.h>
#include "delay.h"
#include "adc.h"

void ADC_Init()
 {
   ADCON0=0x00;    // sampling freq=osc_freq/2,ADC off initially
   ADCON1=0x80;    // All pins are configured as adc and the result is right justified  
  }

 
unsigned int ADC_StartConversion(unsigned char channel)
 {
    ADCON0=((1<<ADON) | (channel<<3));   //select particular channel and turn ON adc
    delay_us(50);
 
    GO=1;                      // Start ADC conversion
    while(GO==1);            // Wait for the conversion to complete
 
    return((ADRESH<<8) + ADRESL); // return right justified 10-bit result
   }

 
#include<htc.h>
#define DelayCountFor1msec 300

 
void delay_us(unsigned int us_count)
 {	
    while(us_count!=0)
      {
		 us_count--;
	   }
   }

void delay_ms(unsigned int ms_count)
 {
       while(ms_count!=0)
	    {
	      delay_us(DelayCountFor1msec);	//delay_us is called to generate 1ms delay
	         ms_count--;
	     }
 
   }

void delay_sec(unsigned char sec_count)
 {
 
 
	 while(sec_count!=0)
	  {
	     delay_ms(1000);	//delay_ms is called to generate 1sec delay
		 sec_count--;
		}
  }

#include<htc.h>
#include "delay.h"
#include "lcd.h"
 
#define databus	PORTB             //	LCD databus connected to PORTB
 
#define DataBusDirection TRISB    //Data and Control bus direction config registers  
#define ControlBusDirection TRISD
 
#define rs RD0		 // Register select pin connected to PORTD.0
#define rw RD1		 // Read Write pin connected to PORTD.1
#define en RD2		 // Enable pin connected to PORTD.2
 
 
/* 16x2 LCD Specification */
#define LCDMaxLines 2
#define LCDMaxChars 16
#define LineOne 0x80
#define LineTwo 0xc0
 
#define BlankSpace ' '

void LCD_Init()
{
    delay_us(5000);
 
   DataBusDirection=0x00; //Configure data and control bus as output
   ControlBusDirection=0x00;
 
   LCD_CmdWrite(0x38);  // LCD 2lines, 5*7 matrix
   LCD_CmdWrite(0x0E);	 // Display ON cursor ON
   LCD_CmdWrite(0x01);	 // Clear the LCD
   LCD_CmdWrite(0x80);	 // Move the Cursor to First line First Position
 
}

void LCD_Clear()
{
   LCD_CmdWrite(0x01);	// Clear the LCD and go to First line First Position
   LCD_CmdWrite(LineOne);
}

void LCD_GoToLineOne()
{
   LCD_CmdWrite(LineOne);	// Move the Cursor to First line First Position
}

void LCD_GoToLineTwo()
{
   LCD_CmdWrite(LineTwo);	// Move the Cursor to Second line First Position
}

void LCD_GoToXY(char row, char col)
{
   char pos;
 
    if(row<LCDMaxLines)
      {
		 pos= LineOne | (row << 6); // take the line number
		                            //row0->pos=0x80  row1->pos=0xc0
 
	    if(col<LCDMaxChars)
		   pos= pos+col;            //take the char number
		                            //now pos points to the given XY pos
 
		 LCD_CmdWrite(pos);	       // Move the Cursor to specified Position
       }
}

void LCD_CmdWrite( char cmd)
{
 
   databus=cmd;        // Send the command to LCD
     rs=0;             // Select the Command Register by pulling RS LOW
     rw=0;             // Select the Write Operation  by pulling RW LOW
     en=1;             // Send a High-to-Low Pusle at Enable Pin
 delay_us(10);
     en=0;
 
   delay_ms(1);
}

void LCD_DataWrite( char dat)
{
 
 
   databus=dat;	    // Send the data to LCD
     rs=1;			// Select the Data Register by pulling RS HIGH
     rw=0;			// Select the Write Operation  by pulling RW LOW
     en=1;			// Send a High-to-Low Pusle at Enable Pin
 delay_us(10);
     en=0;
 
   delay_ms(1);
 
}

 
 
void LCD_DisplayString(char *string_ptr)
{
   while(*string_ptr)
    LCD_DataWrite(*string_ptr++);
  }

void LCD_DisplayNumber(unsigned int num)
{
   LCD_DataWrite((num/10000)+0x30);
   num=num%10000;
 
   LCD_DataWrite((num/1000)+0x30);
   num=num%1000;
 
   LCD_DataWrite((num/100)+0x30);
   num=num%100;
 
   LCD_DataWrite((num/10)+0x30);
 
   LCD_DataWrite((num%10)+0x30);
 
 }

void LCD_ScrollMessage(char *msg_ptr)
{
  unsigned char i,j;
  LCD_CmdWrite(0x0c);			 //Disable the Cursor
  for(i=0;msg_ptr[i];i++)        //Loop to display the complete string
    {                            //each time 16 chars are displayed and
                                 //pointer is incremented to point to next char
 
      LCD_GoToLineOne();                   //Move the Cursor to first line
 
      for(j=0;j<LCDMaxChars && msg_ptr[i+j];j++) //loop to Display first 16 Chars
	    LCD_DataWrite(msg_ptr[i+j]);                 //or till Null char
 
	  for(j=j; j<LCDMaxChars; j++)               //If the chars are below 16
        LCD_DataWrite(BlankSpace);              //then display blank spaces
 
       delay_ms(300);
    }
   LCD_CmdWrite(0x0E);			  //Enable the Cursor
}

void LCD_DisplayRtcTime(char hour,char min,char sec)
{
    LCD_DataWrite(((hour>>4) & 0x0f) + 0x30);
    LCD_DataWrite((hour & 0x0f) + 0x30);
    LCD_DataWrite(':');
 
    LCD_DataWrite(((min>>4) & 0x0f) + 0x30);
    LCD_DataWrite((min & 0x0f) + 0x30);
    LCD_DataWrite(':');
 
    LCD_DataWrite(((sec>>4) & 0x0f) + 0x30);
    LCD_DataWrite((sec & 0x0f) + 0x30);
 
 }

void LCD_DisplayRtcDate(char day,char month,char year)
 {
     LCD_DataWrite(((day>>4) & 0x0f) + 0x30);
     LCD_DataWrite((day & 0x0f) + 0x30);
     LCD_DataWrite('/');
 
     LCD_DataWrite(((month>>4) & 0x0f) + 0x30);
 	 LCD_DataWrite((month & 0x0f) + 0x30);
     LCD_DataWrite('/');
 
     LCD_DataWrite(((year>>4) & 0x0f) + 0x30);
 	LCD_DataWrite((year & 0x0f) + 0x30);
 
 }

#include<htc.h>
#include "delay.h"
#include "lcd.h"
 
#define databus	PORTB             //LCD databus connected to PORTB
#define DataBusDirection TRISB    //Data and Control bus direction config registers 
 
#define rs RB0		          // Register select pin connected to PORTB.0
#define rw RB1		          // Read Write pin connected to PORTB.1
#define en RB2		         // Enable pin connected to PORTB.2

#define LCDMaxLines 2
#define LCDMaxChars 16
#define LineOne 0x80
#define LineTwo 0xc0
#define BlankSpace ' '

 
void LCD_Init()
{
    delay_us(5000);
   DataBusDirection=0x00; //Configure data and control bus as output
   LCD_CmdWrite(0x02);	//Initilize the LCD in 4bit Mode
   LCD_CmdWrite(0x28);
   LCD_CmdWrite(0x0E);	// Display ON cursor ON
   LCD_CmdWrite(0x01);	// Clear the LCD
   LCD_CmdWrite(0x80);	// Move the Cursor to First line First Position
 
}

void LCD_CmdWrite( char cmd)
{
   databus=(cmd & 0xf0);        // Send the Higher Nibble of the command to LCD
     rs=0;				    // Select the Command Register by pulling RS LOW
     rw=0;				    // Select the Write Operation  by pulling RW LOW
     en=1;				    // Send a High-to-Low Pusle at Enable Pin
  delay_us(10);
     en=0;
 
   delay_us(10);					// wait for some time
 
   databus=((cmd<<4) & 0xf0);  // Send the Lower Nibble of the command to LCD
     rs=0;				    // Select the Command Register by pulling RS LOW
     rw=0;				    // Select the Write Operation  by pulling RW LOW
     en=1;			          // Send a High-to-Low Pusle at Enable Pin
  delay_us(10);
     en=0;
 
   delay_ms(1);
}

void LCD_DataWrite( char dat)
{
 
 
   databus=(dat & 0xf0);	    // Send the Higher Nibble of the Data to LCD
     rs=1;			   // Select the Data Register by pulling RS HIGH
     rw=0;			  // Select the Write Operation  by pulling RW LOW
     en=1;			 // Send a High-to-Low Pusle at Enable Pin
  delay_us(10);
     en=0;
 
   delay_us(10);		 // wait for some time.
 
   databus=((dat <<4) & 0xf0);	// Send the Lower Nibble of the Data to LCD
     rs=1;			// Select the Data Register by pulling RS HIGH
     rw=0;			// Select the Write Operation  by pulling RW LOW
     en=1;			// Send a High-to-Low Pusle at Enable Pin
 delay_us(10);
     en=0;
 
   delay_ms(1);
 
}

 
 
#include <htc.h>
#include "keypad.h"
#include "delay.h"
 
#define RowColDirection TRISC //Data Direction Configuration for keypad
 
#define ROW PORTC   //Lower four bits of P1 are used as ROWs
#define COL PORTC  //Higher four bits of P1 are used as COLs

 
 
void KEYPAD_Init()
{
       RowColDirection=0x0f;    // Configure Row lines as O/P and Column lines as I/P
}

void KEYPAD_WaitForKeyRelease()
{
   unsigned char key;
    do
	  {
        ROW=0xF0;           // Pull the ROW lines to high and Column lines low.
	    key=COL & 0x0f;   // Read the Columns, to check the key press
       }while(key!=0x00);  // Wait till the Key is released,
                              // If no Key is pressed, Column lines will be low(0x00)
}

void KEYPAD_WaitForKeyPress()
{
  unsigned char key;
  do
   {
	 do
      {
	    ROW=0xF0;		 // Pull the ROW lines to high and Column lines low.
	    key=COL & 0x0F;	 // Read the Columns, to check the key press
	  }while(key==0x00);  // Wait till the Key is pressed,
					 // if a Key is pressed the corresponding Column line go high
 
	   delay_ms(1);		  // Wait for some time(debounce Time);
 
	   ROW=0xF0;		  // After debounce time, perform the above operation
	   key=COL & 0x0F;	  // to ensure the Key press.
 
	}while(key==0x00);
 
 }

unsigned char KEYPAD_ScanKey()
 {
 
	 unsigned char ScanKey = 0x10,i, key;
 
   for(i=0;i<0x04;i++)            // Scan All the 4-Rows for key press
    {
      ROW=ScanKey;                // Select 1-Row at a time for Scanning the Key
      key=COL & 0x0F;             // Read the Column, for key press
 
      if(key!=0x00)               // If the KEY press is detected for the selected
         break;                   // ROW then stop Scanning,
 
     ScanKey=(ScanKey<<1); // Rotate the ScanKey to SCAN the remaining Rows
    }
 
 
    key = key | ScanKey;         // Retun the row and COL status to decode the key
    return(key);
}

unsigned char KEYPAD_GetKey()
{
	unsigned char key;
 
      KEYPAD_WaitForKeyRelease();    // Wait for the previous key release
      delay_ms(1);
 
      KEYPAD_WaitForKeyPress();      // Wait for the new key press
      key = KEYPAD_ScanKey();        // Scan for the key pressed.
 
   switch(key)                       // Decode the key
     {
         case 0x11: key='7'; break;
         case 0x12: key='8'; break;
         case 0x14: key='9'; break;
         case 0x18: key='%'; break;
  	   case 0x21: key='4'; break;
	   case 0x22: key='5'; break;
	   case 0x24: key='6'; break;
	   case 0x28: key='*'; break;
	   case 0x41: key='1'; break;
	   case 0x42: key='2'; break;
	   case 0x44: key='3'; break;
	   case 0x48: key='-'; break;
	   case 0x81: key='N'; break;
	   case 0x82: key='0'; break;
	   case 0x84: key='='; break;
	   case 0x88: key='+'; break;
       default: key='z';
      }
   return(key);                      // Return the key
}

 #include<htc.h>

void UART_Init()
{
    TRISC=0x80;      // Configure Rx pin as input and Tx as output  
  	TXSTA=0x20;      // Asynchronous mode, 8-bit data & enable transmitter
	RCSTA=0x90;      // 8-bit continous receive enable
	SPBRG=31;        // 9600 Baud rate at 20MHz
  }

 
 
char UART_RxChar()
{
   while(RCIF==0);    // Wait till the data is received 
     RCIF=0;            // Clear receiver flag
   return(RCREG);        // Return the received data to calling function
}

 void UART_TxChar(char ch)
{
   while(TXIF==0);  // Wait till the transmitter register becomes empty
	TXIF=0;        // Clear transmitter flag
      TXREG=ch;        // load the chr the to be transmitted into transmit reg
}

 
 
void UART_TxString(char *string_ptr)
 {
          while(*string_ptr)
           UART_TxChar(*string_ptr++);
   }

void UART_RxString(char *string_ptr)
 {
     char ch;
     while(1)
       {
          ch=UART_RxChar();    //Receive a char
          UART_TxChar(ch);     //Echo back the received char
 
        if((ch=='\r') || (ch=='\n')) //read till enter key is pressed
           {				     //once enter key is pressed
              *string_ptr=0;            //null terminate the string
                break;			     //and break the loop
             }
         *string_ptr=ch;                //copy the char into string.
         string_ptr++;			    //and increment the pointer
      }
 }

void UART_TxNumber(unsigned int num)
{
 
	   UART_TxChar((num/10000)+0x30);
	   num=num%10000;
 
	   UART_TxChar((num/1000)+0x30);
	   num=num%1000;
 
	   UART_TxChar((num/100)+0x30);
	   num=num%100;
 
	   UART_TxChar((num/10)+0x30);
 
       UART_TxChar((num%10)+0x30);
}

 
#include<reg51.h>
#include "delay.h"
#include "i2c.h"
 
sbit SCL=RC3;      //SCL Connected to PORTC.3
sbit SDA=RC4;      //SDA Connected to PORTC.4

 
 
void I2C_Clock(void)
{
    delay_us(1);
    SCL = 1;        // Wait for Some time and Pull the SCL line High
 
    delay_us(1);        // Wait for Some time
    SCL = 0;        // Pull back the SCL line low to Generate a clock pulse
}

 
 
void I2C_Start()
{
    SCL = 0;        // Pull SCL low
 
    SDA = 1;        // Pull SDA High
    delay_us(1);
 
    SCL = 1;        //Pull SCL high
    delay_us(1);
 
    SDA = 0;        //Now Pull SDA LOW, to generate the Start Condition
    delay_us(1);
 
    SCL = 0;        //Finally Clear the SCL to complete the cycle
}

void I2C_Stop(void)
{
    SCL = 0;            // Pull SCL low
    delay_us(1);
 
    SDA = 0;            // Pull SDA  low
    delay_us(1);
 
    SCL = 1;            // Pull SCL High
    delay_us(1);
 
    SDA = 1;            // Now Pull SDA High, to generate the Stop Condition
}

void I2C_Write(unsigned char dat)
{
    unsigned char i;
 
    for(i=0;i<8;i++)         // loop 8 times to send 1-byte of data
     {
        SDA = dat & 0x80;    // Send Bit by Bit on SDA line
        I2C_Clock();         // Generate Clock at SCL
        dat = dat<<1;
      }
        SDA = 1;                 // Set SDA at last
}

unsigned char I2C_Read(void)
{
    unsigned char i, dat=0x00;
 
       SDA=1;               //Make SDA as I/P
    for(i=0;i<8;i++)        // loop 8times to read 1-byte of data
     {
       delay_us(1);
        SCL = 1;            // Pull SCL High
        delay_us(1);
 
        dat = dat<<1;       //dat is Shifted each time and
        dat = dat | SDA;    //ORed with the received bit to pack into byte
 
        SCL = 0;            // Clear SCL to complete the Clock
       }
   return dat;               // Finally return the received Byte*
}

void I2C_Ack()
{
    SDA = 0;        //Pull SDA low to indicate Positive ACK
    I2C_Clock();    //Generate the Clock
    SDA = 1;        // Pull SDA back to High(IDLE state)
}

void I2C_NoAck()
{
    SDA = 1;        //Pull SDA high to indicate Negative/NO ACK
   I2C_Clock();     // Generate the Clock  
    SCL = 1;        // Set SCL */
}

 
 
#include "ds1307.h"
#include "i2c.h"
#include "delay.h"

#define DS1307_ID 0xD0     // DS1307 ID
 
#define SEC_ADDRESS   0x00 // Address to access Ds1307 SEC register
#define DATE_ADDRESS  0x04 // Address to access Ds1307 DATE register
#define CONTROL 0x07       // Address to access Ds1307 CONTROL register

void DS1307_Init()
{
    I2C_Start();            // Start I2C communication
 
    DS1307_Write(DS1307_ID);   // Connect to DS1307 by sending its ID on I2c Bus
    DS1307_Write(CONTROL);     // Select the Ds1307 ControlRegister to configure Ds1307
 
    DS1307_Write(0x00);        // Write 0x00 to Control register to disable SQW-Out
 
    I2C_Stop();             // Stop I2C communication after initilizing DS1307
 
 }

void DS1307_Write(unsigned char dat)
{
    I2C_Write(dat);   // Connect to DS1307 by sending its ID on I2c Bus
    I2C_Clock();
 }

unsigned char DS1307_Read()
{
    unsigned char dat;
    dat = I2C_Read();   // Connect to DS1307 by sending its ID on I2c Bus
    return(dat);
 }

void DS1307_SetTime(unsigned char hh, unsigned char mm, unsigned char ss)
{
    I2C_Start();            // Start I2C communication
 
    DS1307_Write(DS1307_ID);    // connect to DS1307 by sending its ID on I2c Bus
    DS1307_Write(SEC_ADDRESS); // Select the SEC RAM address
 
    DS1307_Write(ss);           // Write sec on RAM address 00H
    DS1307_Write(mm);           // Write min on RAM address 01H
    DS1307_Write(hh);           // Write hour on RAM address 02H
 
    I2C_Stop();             // Stop I2C communication after Setting the Time
}

void DS1307_SetDate(unsigned char dd, unsigned char mm, unsigned char yy)
{
    I2C_Start();            // Start I2C communication
 
    DS1307_Write(DS1307_ID);    // connect to DS1307 by sending its ID on I2c Bus
    DS1307_Write(DATE_ADDRESS);     // Request DAY RAM address at 04H
 
    DS1307_Write(dd);           // Write date on RAM address 04H
    DS1307_Write(mm);           // Write month on RAM address 05H
    DS1307_Write(yy);           // Write year on RAM address 06h
 
    I2C_Stop();             // Stop I2C communication after Setting the Date
}

void DS1307_GetTime(unsigned char *h_ptr,unsigned char *m_ptr,unsigned char *s_ptr)
{
     I2C_Start();           // Start I2C communication
 
    DS1307_Write(DS1307_ID);    // connect to DS1307 by sending its ID on I2c Bus
    DS1307_Write(SEC_ADDRESS);          // Request Sec RAM address at 00H
 
     I2C_Stop();            // Stop I2C communication after selecting Sec Register
 
    I2C_Start();                // Start I2C communication
    DS1307_Write(0xD1);         // connect to DS1307( under Read mode)
                                //by sending its ID on I2c Bus
 
  *s_ptr = DS1307_Read();  I2C_Ack();     // read second and return Positive ACK
  *m_ptr = DS1307_Read();  I2C_Ack();      // read minute and return Positive ACK
  *h_ptr = DS1307_Read();  I2C_NoAck();   // read hour and return Negative/No ACK
 
  I2C_Stop();               // Stop I2C communication after reading the Time
 }

void DS1307_GetDate(unsigned char *d_ptr,unsigned char *m_ptr,unsigned char *y_ptr)
{
    I2C_Start();            // Start I2C communication
 
    DS1307_Write(DS1307_ID);    // connect to DS1307 by sending its ID on I2c Bus
    DS1307_Write(DATE_ADDRESS);     // Request DAY RAM address at 04H
 
    I2C_Stop();             // Stop I2C communication after selecting DAY Register
 
 
   I2C_Start();             // Start I2C communication
   DS1307_Write(0xD1);          // connect to DS1307( under Read mode)
                            // by sending its ID on I2c Bus
 
  *d_ptr = DS1307_Read(); I2C_Ack();     // read Day and return Positive ACK
  *m_ptr = DS1307_Read(); I2C_Ack();     // read Month and return Positive ACK
  *y_ptr = DS1307_Read(); I2C_NoAck();   // read Year and return Negative/No ACK
 
  I2C_Stop();         // Stop I2C communication after reading the Time
 }

#include<htc.h>
#include"delay.h"

           .
 
void EEPROM_WriteByte(unsigned char eeprom_Address, unsigned char eeprom_Data)
{
     while(RD || WR);    // check the WR&RD bit to see if a RD/WR is in progress
   EEADR=eeprom_Address; // Write the address to EEADR.
                         // Make sure that the address is not larger than the memory size 
   EEDATA=eeprom_Data;   // load the 8-bit data value to be written in the EEDATA register.
   WREN=1;               // Set the WREN bit to enable eeprom operation.
   EECON2=0x55;          //Execute the special instruction sequence
   EECON2=0xaa;          //Refer the datasheet for more info
   WR=1;                 // Set the WR bit to trigger the eeprom write operation.
   delay_us(10);
   WREN=0;               // Disable eeprom operation.
}

unsigned char EEPROM_ReadByte(unsigned char eeprom_Address)
{
    while(RD || WR);      // check the WR&RD bit to see if a RD/WR is in progress
  EEADR=eeprom_Address;   // Write the address to EEADR.
                          // Make sure that the address is not larger than the memory size 
    RD = 1;               // Set the WR bit to trigger the eeprom read operation.
    delay_us(50);
    return(EEDATA);       // Return the data read form eeprom.
 }

void EEPROM_WriteNBytes(unsigned char EepromAddr, unsigned char *RamAddr, char NoOfBytes)
 {
  while(NoOfBytes !=  0)
   {
	EEPROM_WriteByte(EepromAddr,*RamAddr); //Write a byte from RAM to EEPROM
	    EepromAddr++;				   //Incerement the Eeprom Address
		RamAddr++;				   //Increment the RAM Address
		NoOfBytes--;			   //Decrement NoOfBytes after writing each Byte
	   }
 }

void EEPROM_ReadNBytes(unsigned char EepromAddr, unsigned char *RamAddr, char NoOfBytes)
 {
   while(NoOfBytes !=  0)
	{
	 *RamAddr = EEPROM_ReadByte(EepromAddr);//Read a byte from EEPROM to RAM
	    EepromAddr++;				    //Incerement the Eeprom Address
	 	RamAddr++;			          //Increment the RAM Address
	 	NoOfBytes--;			    //Decrement NoOfBytes after Reading each Byte
 
	 }
 }

void EEPROM_WriteString(unsigned char eeprom_address, unsigned char * source_address)
  {
    do
 	{
 	  EEPROM_WriteByte(eeprom_address,*source_address); //Write a byte from RAM to EEPROM
 	    source_address++;				          //Incerement the RAM Address
 		eeprom_address++;					    //Increment the Eeprom Address
 	  }while(*(source_address-1)!=0);
  }

 
 
void EEPROM_ReadString(unsigned char eeprom_address, unsigned char * destination_address)
  {
   char eeprom_data;
 
     do
 	 {
	  eeprom_data = EEPROM_ReadByte(eeprom_address); //Read a byte from EEPROM to RAM
 	    *destination_address = eeprom_data;	       //Copy the data into String Buffer
 	     destination_address++;				 //Incerement the RAM Address
 	 	 eeprom_address++;				 //Increment the Eeprom Address
 		}while(eeprom_data!=0);
  }

  void EEPROM_Erase()
   {
	 unsigned char eeprom_address;
 
	 for(eeprom_address=0;eeprom_address<255;eeprom_address++)
	    {
		 EEPROM_WriteByte(eeprom_address,0xff); // Write Each memory location with OxFF
	      }
   }