// for PIC16
unsigned short EEPROM_Read(unsigned short address); 
// for PIC18
unsigned short EEPROM_Read(unsigned int address);

unsigned short take;
...
take = EEPROM_Read(0x3F);

  // for PIC16
void EEPROM_Write(unsigned short address, unsigned short data); 
// for PIC18
void EEPROM_Write(unsigned int address, unsigned short data);

EEPROM_Write(0x32, 19);

unsigned short data = 0xAA, address=0x00;

void main() {
PORTB = 0x00;
TRISB = 0x00;

//writes 0xAA into the location 0x00
EEprom_Write(address,data); 

//insert 20 or 30 ms delay between every read and write cycle
Delay_ms(20);

// the following delay is just for making a feel
Delay_ms(1000); 

//reads the data from 0x00 and send it to PORTB
PORTB = Eeprom_Read(address); 
Delay_ms(1000);

void main (void)
{
	// Configure ports.
	TRISB = 0;
	PORTB = 0;
	while (1) // infinite loop.
	{
		// Displays the value on port B 
		// From address 0 of the EEPROM.
		PORTB =EEPROM_Read (0);
		// The if statement evaluates if the button is pressed.
		if (! PORTC.F0)
		{
			// Increase the value of port B.
			PORTB ++;
			// Store the new port value
			// At address 0 of the EERPOM.
			EEPROM_Write (0, PORTB);
			// Wait up to release.
			while (! PORTC.F0);
		}
	}
}
لمحاكاة هذا البرنامج يتم جلب العناصر التالية لبرنامج ISIS :

char ii;                                 // loop variable

void main(){
  
  PORTB = 0;
  PORTC = 0;
  PORTD = 0;

  TRISB = 0;
  TRISC = 0;
  TRISD = 0;
   
  for(ii = 0; ii < 32; ii++)             		// Fill data buffer
    EEPROM_Write(0x80+ii, ii);          	 // Write data ii to address 0x80+ii

  EEPROM_Write(0x02,0xAA);              	 // Write some data 0xAA at address 0x02
  EEPROM_Write(0x50,0x55);               	// Write some data 0x55 at address 0x50

  Delay_ms(1000);                        		// Blink PORTB and PORTC LEDs
  PORTB = 0xFF;                          		//   to indicate reading start
  PORTC = 0xFF;
  Delay_ms(1000);
  PORTB = 0x00;
  PORTC = 0x00;
  Delay_ms(1000);

  PORTB = EEPROM_Read(0x02);            // Read data from address 2 and display it on PORTB
  PORTC = EEPROM_Read(0x50);      // Read data from address 0x50 and display it on PORTC

  Delay_ms(1000);

  for(ii = 0; ii < 32; ii++) {           // Read 32 bytes block from address 0x80
    PORTD = EEPROM_Read(0x80+ii);        //   and display data on PORTD
    Delay_ms(250);
    }
}

void main() 
{
   unsigned int a, i;
   TRISC  = 0;
   do
   {
      for(i=0,a=1;i<8;i++)
      {
        EEPROM_Write(i, a);
        a = a<<1;
      }
      
      for(i=0;i<8;i++)
      {
         PORTC = EEPROM_Read(i);
         Delay_ms(1000);
      }
   }while(1);
}

/* Project name:
     Use of internal EEPROM for storing information
 * Copyright:
     (c) Rajendra Bhatt, 2011.
 * Description:
     This code demonstrates how to perform basic Read and Write operations
     with the internal EEPROM of PIC16F628A.
     MCU:             PIC16F628A
     Oscillator:      XT, 4.0 MHz
*/
// LCD connections definitions
sbit LCD_RS at RA0_bit;
sbit LCD_EN at RA1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISA0_bit;
sbit LCD_EN_Direction at TRISA1_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD connections definitions

// Other connections
sbit SW1 at RB0_bit;
sbit SW2 at RB1_bit;
sbit SW3 at RB2_bit;
/*
// String array to store 3 digit access code
char message1[] = "1.READ";
char message2[] = "2.WRITE";
char message3[] = "3.Delete";
char message4[] = "WRITE COMPLETED";
char message5[] = "Read Data";
char message6[] = "Data Deleted";
*/
char message7[] = "Embedded-Lab.com";
char Edata[] = "0000000000000000";
unsigned short  i ;
unsigned int ADD; // Start EEPROM Location
char temp;
void Delay2s(){
 Delay_ms(2000);
}

void Debounce(){
 Delay_ms(100);
}

void main() {
 PORTB = 0;
 PORTA = 0;
 TRISB = 0b00001111;
 TRISA = 0b00100000;
 CMCON=0x07;
 Lcd_Init();                        // Initialize LCD
 Lcd_Cmd(_LCD_CLEAR);               // Clear LCD
 Lcd_Cmd(_LCD_CURSOR_OFF);          // Turn cursor off
 Lcd_Out(1, 1, "Lab 13: Testing");
 Lcd_Out(2, 1, "internal EEPROM");
 Delay2s();
//=========================================
 start:
 Lcd_Cmd(_LCD_CLEAR);
 Lcd_Out(1,1, "1.READ");             // Write message1 in 1st row
 Lcd_Out(1,8, "2.WRITE");
 Lcd_Out(2,1, "3.Delete");
 do{

  // Read Operation
  if (!SW1) {
      Debounce();
      Lcd_Cmd(_LCD_CLEAR);
      Lcd_Out(1,1, "Read Data");
      ADD = 0;
      for (i=0; i<16; i++) {
       temp = EEPROM_Read(ADD+i);
       Edata[i] = temp;
      }
      Lcd_Out(2,1,Edata);
      Delay2s();
      goto start;
   }
  // Write Operation
  if (!SW2) {
      Debounce();
      ADD = 0;
      for (i=0; i<16; i++) {
      temp = message7[i];
      EEPROM_Write(ADD+i,temp);
      }
      Lcd_Cmd(_LCD_CLEAR);
      Lcd_Out(1,1, WRITE COMPLETED");
      Delay2s();
      goto start;
   }

  // Delete Operation
  if (!SW3) {
      Debounce();
      Lcd_Cmd(_LCD_CLEAR);
      Lcd_Out(1,1, "Data Deleted");
      for (i=0; i<16; i++) {
      temp = '0';
      EEPROM_Write(ADD+i, temp);
      }
      Delay2s() ;
      goto start;
   }
 
 
 } while(1);
 
}

 // Keypad module connections
char keypadPort at PORTD;
// End Keypad module connections
// LCD module connections
sbit LCD_RS at RB2_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connection
//================================
unsigned short kp,i=0,cnt,j=0;
char input_PW[10] ,user_PW[4];
//================================
char msg1[] = ".. PROTECTED ..",msg2[] = "ENTER PASSWORD";
char msg3[] = "ACCESS GRANETED",msg4[] = "ACCESS DENIED";
char msg5[] = "Enter New Code",msg6[] = "**Done**" ;
char msg7[] = " **WELCOME** " , msg8[] = " * WARNING * ";
//======================================================
 void Move_Delay() {                  // Function used for text moving
  Delay_ms(500);                     // change text moving speed here
}
//===============
void code_enter()
{
kp = 0; // Reset key code variable
        // Wait for key to be pressed and released
do
   kp = Keypad_Key_Click(); // Store key code in kp variable
while (!kp);
        // Prepare value for output, transform key to it's ASCII value
switch (kp)
  {
    case 1: kp = 49; break; // 1
    case 2: kp = 50; break; // 2
    case 3: kp = 51; break; // 3
    case 5: kp = 52; break; // 4
    case 6: kp = 53; break; // 5
    case 7: kp = 54; break; // 6
    case 9: kp = 55; break; // 7
    case 10: kp = 56; break; // 8
    case 11: kp = 57; break; // 9
    case  4: kp = 65; break; // A
    case  8: kp = 66; break; // B
    case 12: kp = 67; break; // C
    case 16: kp = 68; break; // D
    case 13: kp = 42; break; // *
    case 14: kp = 48; break; // 0
    case 15: kp = 35; break; // #
  }
input_PW[i] = kp;
Lcd_Chr(2, i+6, input_PW[i]);  // Print key ASCII value on Lcd
i++;
}
//======================================
void delay_20ms()
{
Delay_ms(20);
}
//=========================================
void code_read()    //Read data from EEPROM
{
  user_PW[0] = EEPROM_Read(0x00);// Read data from address 0
  delay_20ms();
  user_PW[1] = EEPROM_Read(0x01);// Read data from address 1
  delay_20ms();
  user_PW[2] = EEPROM_Read(0x02);// Read data from address 2
  delay_20ms();
  user_PW[3] = EEPROM_Read(0x03);// Read data from address 3
  delay_20ms();
}
//===============================================
void code_write()    //Write data from EEPROM
{
  EEPROM_Write(0x00,input_PW[0]);// Write some data to address 0
  delay_20ms();
  EEPROM_Write(0x01,input_PW[1]);// Write some data to address 1
  delay_20ms();
  EEPROM_Write(0x02,input_PW[2]);// Write some data to address 2
  delay_20ms();
  EEPROM_Write(0x03,input_PW[3]);// Write some data to address 3
  delay_20ms();
}
//================================================
void change_code()
{ loop:
	Lcd_Cmd(_LCD_CLEAR);
	Lcd_Out(1,2, "NEW PASSWORD");
	Delay_ms(500);
	i=0;
	code_enter();//get input_PW[0]
	if(input_PW[0] == 42)//test input_PW[0] if * return to loop .
	{goto loop ;}
	code_enter();//get input_PW[1]
	if(input_PW[1] == 42)//test input_PW[1] if * return to loop .
	{goto loop ;}
	code_enter();
	if(input_PW[2] == 42)//test input_PW[2] if * return to loop .
	{goto loop ;}
	code_enter();
	if(input_PW[3] == 42)//test input_PW[3] if * return to loop .
	{goto loop ;}
	code_enter();
	if(input_PW[4] == 42)//test input_PW[4] if * return to loop .
	{goto loop ;}

	if(input_PW[4] == 35){ //if # then
		code_write();//write input_PW[] to EEPROM from address 0 to 3
		code_read();// read EEPROM from address 0 to 3 , save at user_PW[0] t0 user_PW[3]
		Delay_ms(500);
		Lcd_Out(2,5,msg6);//"**Done**"
		Delay_ms(2000);
		}
	else {
	Lcd_Cmd(_LCD_CLEAR);
	Lcd_Out(1,7, "ERROR");
	Delay_ms(1000); }
}
//======================================

void main()
{
  ADCON1 = 0x07;   // Configure AN pins as digital
  TRISA = 0x00;     // set direction to be output
  Keypad_Init();    // Initialize Keypad
  Lcd_Init();       // Initialize Lcd
  //=========================================================
  code_read();//Read EEPROM to user_PW[0] to user_PW[3]
  //===========
  //Initially all EEPROM locatins has 0xFF value
  if(user_PW[0] == 0xFF && user_PW[1] == 0xFF && user_PW[2] == 0xFF && user_PW[3] == 0xFF )
  {
  EEPROM_Write(0x00,'1');// Write some data at address 00
  delay_20ms();
  EEPROM_Write(0x01,'2');// Write some data at address 01
  delay_20ms();
  EEPROM_Write(0x02,'3');// Write some data at address 02
  delay_20ms();
  EEPROM_Write(0x03,'4');// Write some data at address 03
 }
 //=========================================================
 code_read();
 //===========
 Lcd_Cmd(_LCD_CLEAR);      // Clear display
 Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off
 Delay_ms(500);
 Lcd_Out(1, 2,msg1 );//".. PROTECTED .."
 Delay_ms(2000);
 Lcd_Cmd(_LCD_CLEAR);      // Clear display
 //======================================
 cnt=0; // numbers of attempts
 //=====
 do
 { begin:
	PORTA.B0=1;//indication led on
	PORTA.B1=0; // lock off
	PORTA.B2=0; // alarm off
	Lcd_Cmd(_LCD_CLEAR);
	Lcd_Out(2, 4, " PRESS '*'");
	//========================
	i = 0;//before start of code enter
   code_enter();//press * to get input_PW[0]=42

   if(input_PW[0] == 42)// *
	{   start:
		Lcd_Cmd(_LCD_CLEAR);  // Clear display
		Lcd_Out(1, 2, msg2);//"ENTER PASSWORD"

     	i = 0;//before start of code enter
		code_enter();//get input_PW[0] ,  if you press * you will begin from start
		if(input_PW[0] == 42)//*
			{goto start ;}

		code_enter();//get input_PW[1]
		if(input_PW[1] == 42)
			{goto start ;}

		code_enter();//get input_PW[2]
		if(input_PW[2] == 42)
			{goto start ;}

		code_enter();//get input_PW[3]
		if(input_PW[3] == 42)
			{goto start ;}

		code_enter();//get input_PW[4]
		if(input_PW[4] == 42)
			{goto start ;}
	//=====================================
     // If you want to change Master Key, add your numbers to '2' '3' '4' '5' '6'
		if(input_PW[0] == '2' && input_PW[1] == '3' && input_PW[2] == '4' && input_PW[3] == '5' && input_PW[4] == '6')          //check master code
		{
			code_enter();//get input_PW[5]
			if(input_PW[5] == 35)//#
			{
				change_code();
				goto begin ;
			}
		}
		//=======================================
		if(cnt<3 && input_PW[0] == user_PW[0] && input_PW[1] == user_PW[1] && input_PW[2] == user_PW
		[2] && input_PW[3] == user_PW[3] && input_PW[4] == 35) //compare code with store one
		{
			Lcd_Cmd(_LCD_CLEAR);   // Clear display
			Lcd_Out(1, 2, msg3);//"ACCESS GRANETED"
			Lcd_Out(2, 2, msg7);//" **WELCOME** "
			cnt=0;
			PORTA.B0=0;//indication led off
			PORTA.B1=1; //  open
			Delay_ms(3000);
			Lcd_Cmd(_LCD_CLEAR);
			Lcd_Out(2, 2, msg7);//" **WELCOME** "
                                          //Moving text
			for(i=0; i<4; i++) {               // Move text to the right 4 times
				Lcd_Cmd(_LCD_SHIFT_RIGHT);
				Move_Delay();}
			Delay_ms(500);
			for(i=0; i<8; i++) {               // Move text to the right 8 times
				Lcd_Cmd(_LCD_SHIFT_LEFT);
				Move_Delay();}
				Delay_ms(500);
			for(i=0; i<4; i++) {               // Move text to the right 4 times
				Lcd_Cmd(_LCD_SHIFT_RIGHT);
				Move_Delay();}
			Delay_ms(5000);    // Lock reactivate Time
			PORTA.B1=0;//close
			Lcd_Cmd(_LCD_CLEAR);
			Delay_ms(500);
			Lcd_Out(1,2,msg1);//".. PROTECTED .."
			Delay_ms(3000);
			Lcd_Cmd(_LCD_CLEAR);
		}

		else
		{
			cnt++;
			Lcd_Cmd(_LCD_CLEAR);
			Lcd_Out(1, 3,msg4 );//"ACCESS DENIED"
			Delay_ms(2000);
		}

		if(cnt>=3)
		{
			do
			{
				PORTA.B0=0;// led off
				PORTA.B2=1;//alarm on

				while(j<3) {		//repeat blink  3 times
					Lcd_Cmd(_LCD_CLEAR);
					Delay_ms(500);
					Lcd_Out(1, 3, msg8 );//" * WARNING * "
					Delay_ms(1000);
					Lcd_Cmd(_LCD_CLEAR);
					Delay_ms(500);
					Lcd_Out(1, 3, msg8 );//" * WARNING * "
					Delay_ms(1000);
					j++;
				}

				cnt=2;// one attempt only
				j=0;
				goto begin ;
			}
			while(1);
		}
	}
}
while(1);
}

UART1_Init (const unsigned long baud_rate);

// Initialize hardware UART1 and establish communication at 9600 bps
UART1_Init(9600);

char UART1_Data_Ready();

// If data is ready, read it:
if (UART1_Data_Ready() == 1) { 
 receive = UART1_Read();
 }

 char UART1_Tx_Idle();

// If the previous data has been shifted out, send next data:
if (UART1_Tx_Idle() == 1) { 
  UART1_Write(_data);
 }

 char UART1_Read();

// If data is ready, read it:
if (UART1_Data_Ready() == 1) { 
 receive = UART1_Read();
 }

UART1_Read_Text (char * Output, char *Delimiter, char Attempts);

UART1_Init(4800);                         // initialize UART1 module
Delay_ms(100);
while (1) {
  if (UART1_Data_Ready() == 1) {          // if data is received 
    UART1_Read_Text(output, "OK", 10);    // reads text until 'OK' is found
    UART1_Write_Text(output);             // sends back text 
 }
}

UART1_Write(char _data);

unsigned char _data = 0x1E;
...
UART1_Write(_data);

UART1_Write_Text(char * UART_text);

UART1_Init(4800);                         // initialize UART1 module
Delay_ms(100);
while (1) {
  if (UART1_Data_Ready() == 1) {          // if data is received 
    UART1_Read_Text(output, "OK", 10);    // reads text until 'OK' is found
    UART1_Write_Text(output);             // sends back text 
 }
}

char uart_rd;

void main() {
  UART1_Init(9600);               // Initialize UART module at 9600 bps
  Delay_ms(100);                  // Wait for UART module to stabilize
  
  UART1_Write_Text("Start");
  UART1_Write(10);
  UART1_Write(13);
  
  while (1) {                     // Endless loop
    if (UART1_Data_Ready()) {     // If data is received,
      uart_rd = UART1_Read();     // read the received data,
      UART1_Write(uart_rd);       // and send data via UART
    }
  }
}

 void main (void)
 {
 	// Declaration of variables.
 	char Data;
 	UART1_Init (9600); 	//  initialize UART1 module
	Delay_ms(100);
 	// Transmitting the text: Welcome.
 	UART1_Write_Text ("Welcome to the simulator:");
 	UART1_Write (13); 	// It transmits the ASCII  CR = Crriage return
 	UART1_Write (10); 	// It transmits the ASCII NL=New line
 	// Text is transmitted with key.
 	UART1_Write_Text ("Press a key! ...");
 	UART1_Write (13); 	// It transmits the ASCII  CR = Crriage return
 	UART1_Write (10); 	// It transmits the ASCII NL=New line
 	while (1) // infinite loop.
 	{
 		// The if statement tests whether a data is ready to read.
 		if (UART1_Data_Ready () == 1)
 		{
 		 // It reads the data from the buffer.
 		 Data = UART1_Read ();
 		 // Print text feedback.
 		 UART1_Write_Text ("you pressed the key:");
 		 UART1_Write (Data); 	// received data is transmitted.
 		 UART1_Write (13); 	// It transmits the ASCII  CR = Crriage return
 		 UART1_Write (10); 		// It transmits the ASCII NL=New line
 		}
 	}
 }