i2c.c

I2C实用源代码。KEIL C51编译器编写。

		       		     DOM_Data = _getkey();
				     Mon_Data = _getkey();	
		       		     Yr_Data =  _getkey();

		       		     I2CStart();                   		 

		       		     if (I2CMasterWrite(Dev_Add))
	   	   	 		I2CStop();    

		       		     if (I2CMasterWrite(Sec_Add_Reg))
	   	   	 		I2CStop();

				     I2CMasterWrite(Sec_Data);
				     I2CMasterWrite(Min_Data);
				     I2CMasterWrite(Hr_Data);
				     I2CMasterWrite(DOW_Data);
				     I2CMasterWrite(DOM_Data);
				     I2CMasterWrite(Mon_Data);
				     I2CMasterWrite(Yr_Data);
				     I2CStop();
                       		     break;



/******************************************************************************/
/*							 		      */
/*  	case 50 - Write all zeroes & all ones to the RAM. 		      */
/*	case 51 - Write data to certain location of the RAM.		      */
/*							   		      */
/******************************************************************************/

	      		    case 50: /* write all zeroes or ones pattern to the RAM */	
		       		     RAM_Data_In = _getkey();
				     RTC_Reg_Size = _getkey();
				     RAM_Density = RAM_Size - RTC_Reg_Size;
		       		     I2CStart();                   		 

		       		     if (I2CMasterWrite(Dev_Add))
	   	   	 		I2CStop();    

		       		     if (I2CMasterWrite(Word_Add))
	   	   	 		I2CStop();

                       		     for (j=0; j<RAM_Density; j++)
		       		     {
        		  		if (I2CMasterWrite(RAM_Data_In))
	   	   	     		I2CStop();
                       		     }
				     I2CStop();
                       		     break;


	      		    case 51: /* write data to certain location of the RAM */
				     RAM_Add = _getkey();
		       		     Number_Bytes = _getkey();
		       		     RAM_Data_In = _getkey();
		       		     I2CStart();                   		 

		       		     if (I2CMasterWrite(Dev_Add))
	   	   	  		I2CStop();    

		       		     if (I2CMasterWrite(RAM_Add))
	   	   	  		I2CStop();

                       		     for (j=0; j<Number_Bytes+1; j++)
		       		     {
        		  		if (I2CMasterWrite(RAM_Data_In))
	   	   	     		   I2CStop();
                       		     }
				     I2CStop();
                       		     break;



/******************************************************************************/
/*							 		      */
/*  	case 55 - Read all zeroes and all ones from the RAM. 		      */
/*	case 56 - Read entire data from the RAM.			      */
/*							   		      */
/******************************************************************************/

              		    case 55: /* read all zeroes or all ones from the RAM */
			 	     RAM_Data_In = _getkey();
				     RTC_Reg_Size = _getkey();
				     RAM_Density = RAM_Size - RTC_Reg_Size;
		       		     Error_Flag = 0x00;
				     I2CStart();           	 		

 		       		     if (I2CMasterWrite(Dev_Add))
	   	   	  		I2CStop(); 

		       		     if (I2CMasterWrite(Word_Add))
	      	   	  		I2CStop();
        
		       		     I2CStart();                     	
		 		     if (I2CMasterWrite(Dev_Add+1))  	                                   
	   	   	  		I2CStop();
        
		       		     for (i=0; i < RAM_Density-1 ; i++)
		       		     {
		    	   		RAM_Data_Out = I2CMasterRead(0);
					if (RAM_Data_Out != RAM_Data_In)
		       	   		{
			      		    Error_Flag = 0x01;
		    	   		}
				     }
	             
		       		     RAM_Data_Out = I2CMasterRead(1);
		       		     if (RAM_Data_Out != RAM_Data_In) 
		       		     {
		   	  		Error_Flag = 0x01;
		       		     }

		       		     if (Error_Flag == 0x01)
	    	          		putchar (Bad_Device);
	               		     else
	    	          		putchar (Good_Device);

		       		     I2CStop();
        	       		     break;


              		    case 56: /* read entire data from the RAM */
				     I2CStart();           	 		

 		       		     if (I2CMasterWrite(Dev_Add))
	   	   	  		I2CStop(); 

		       		     if (I2CMasterWrite(0))
	      	   	  		I2CStop();
        
		       		     I2CStart();                     	                                        	
 		       		     if (I2CMasterWrite(Dev_Add+1))  	                                   
	   	   	  		I2CStop();
        
		       		     for (i=0; i<RAM_Size-1; i++)
		       		     {
		    	   		RAM_Data_Out = I2CMasterRead(0);
		    	   		putchar(RAM_Data_Out);
		       		     }
	             
		       		     RAM_Data_Out = I2CMasterRead(1);
		       		     putchar(RAM_Data_Out);
		       		     I2CStop();
        	       		     break;

   	      		    default:
		       		     break;
	   		}        /* End of RTC Reg. Selection */
                   }             /* End of I2C Mode */

}                                /* End of Main Program */


/******************************************************************************/
/*      Subroutine:	Delay	  					      */
/*                                                                            */
/*      Description:    This routine creates a time delay. It will	      */
/*			loop until the 'count' becomes zero. 		      */     															
/*                                                                            */
/*      Input:	        None				   		      */
/*                                                                            */
/*      Return:		None						      */
/*                                                                            */
/******************************************************************************/


void Delay(unsigned int count)
{
	while (count--);
}


void Board_Init()
{
	PCON = 0x00 ; 
	SCON = 0x52 ;
	TMOD = 0x20 ;
	TCON = 0xC0 ;
	TH1 =  0xFD ;

	P1 = 0xFF;
	P4 = 0xFF;
}


/******************************************************************************/
/*	Subroutine:	I2C_Init 				    	      */
/*			                             			      */
/*	Description:	Initialize the I2C bus 			              */	
/*                                                                            */
/*      Input:	    	None						      */
/*                       	                                              */
/******************************************************************************/

void I2C_Init()
{
	PCON = 0x00 ; 
	SCON = 0x52 ;
	TMOD = 0x20 ;
	TCON = 0xC0 ;
	TH1 =  0xFD ;

	P1 = 0xFF;
	P4 = 0xEF;
	P5 = 0xFF;
}
		


/******************************************************************************/
/*	Subroutine:	I2CStart     					      */
/*			                              			      */
/*	Description:	Generate a START condition on I2C bus		      */	
/*                                                                            */
/*      Input:	    	None						      */
/*                                                                            */
/*      Return:		None						      */
/*                                                                            */
/******************************************************************************/

void I2CStart()
{
	SDA = 1;        /* to make sure the SDA and SCL are both high */
	SCL = 1;
	Delay(5);       /* add delay */

	SDA = 0;        /* SDA line go LOW first */
	Delay(10);
	SCL = 0;        /* then followed by SCL line with time delay */
}



/******************************************************************************/
/*	Subroutine:	I2CMasterWrite			 		      */
/*			                                 		      */
/*	Description:	Output one byte of data to slave device. Check for    */
/* 			WAIT condition before every bit is sent.	      */ 
/*                                                                            */
/*      Input:	    	one byte of data to be sent to slave device.	      */
/*                                                                            */
/*      Return:		acknowledgement from slave:         		      */
/*		        0 = acknowledge is received			      */
/*	       	 	1 = no acknowledge is received			      */                       
/*                                                                    	      */
/******************************************************************************/

unsigned char I2CMasterWrite(unsigned char input_byte)
{
	unsigned char i;
	unsigned int mask;

        mask = 0x80;                      
	for (i=0; i<8; i++)		/* send one byte of data */
	{
   	   if (mask & input_byte) 	/* send bit according to data */
	      SDA = 1;
	   else SDA = 0;
	
	   mask = mask >> 1;		/* shift right for the next bit */
	   Delay(0);
	   SCL = 1;			/* clock is high */
           Delay (1);
	   SCL = 0;                     /* clock is low */
        }

      	mask = SDA;			/* read acknowledge */
      	Delay(3);
        SCL = 1;			/* generate 9th clock pulse */
	Delay(1);
	SCL = 0;                	/* clock is low */	
	Delay(6);			/* to avoid short pulse transition on SDA line */	
	return (mask);          	/* return acknowledge bit */
}	
						     			


/******************************************************************************/
/*	Subroutine:	I2CMasterRead			 		      */
/*			                                 		      */
/*	Description:	Read one byte of data from the slave device. Check    */
/*			for WAIT condition before every bit is received.      */	
/*                                                                            */
/*      Input:	     	Acknowledge require:				      */
/*			0 - generate LOW output after a byte is received      */
/*			1 - generate HIGH output after a byte is received     */
/*                                                                            */
/*      Return:  	received one byte of data from slave device	      */
/*		        						      */                       
/*                                                                    	      */
/******************************************************************************/
				
unsigned char I2CMasterRead(unsigned char ack)
{
	unsigned char i;
	unsigned int mask, rec_data;    

	rec_data = 0;	
	mask = 0x80;	
	for (i=0; i<8; i++)
	{
            if (SDA)                    
	    	rec_data |= mask;

	    mask = mask >> 1;   
            SCL = 1;       		/* clock is high */
	    Delay(2);      
	    SCL = 0;                    /* clock is low */                                                                       
	} 

	if (ack)               		/* set SDA data first before port direction */	
	   SDA = 1;             	/* send acknowledge */
	else SDA = 0;
       
	Delay(3);
 	SCL = 1;    	  		/* clock is high */
	Delay(1);
	SCL = 0;                	/* clock is low */
	SDA = 1;
	Delay(6);			/* to avoid short pulse transition on SDA line */
	return (rec_data);
}	


/******************************************************************************/
/*	Subroutine:	I2CStop				 		      */
/*			                                 		      */
/*	Description:	generate stop condition on the I2C bus	     	      */	
/*                                                                            */
/*      Input:	     	none                                                  */
/*                                                                            */
/*      Return:  	"0" - the bus line is OK		              */
/*                                                                    	      */
/******************************************************************************/
				
unsigned char I2CStop()
{
       	SDA  = 0;
	SCL =1 ;
   	Delay(10);		
	SDA = 1;
	return (0);
}