24c16a.c

AT24C16a的52单片机源码

/*++++++++++++++++++++++++++++++++++++++++
* 作者:殷少翔
* 日期:2006年11月10日
* 修改:2006年11月15日
* 说明:用于S51, 12M晶振
* 约定:每个函数以scl=0开始,scl=0结尾
++++++++++++++++++++++++++++++++++++++++++*/

#include "24c16a.h"
#include<intrins.h>				//可以使用_nop_()函数

UINT8 WorkpieceNum[4];
/****************************************************************************************************/
//关于中断,测频率的函数
/*****************************************************************************************************/
/*================
 外部中断 计数程序
 ================*/
/*void INTO(void) interrupt 0  using 0
{
 IE0 = 0 ;
 F_Num++ ;
}

/*===============
 T0计时的函数，1s
 ================*/
/*void Time0(void) interrupt 1 using 1
{
 TF0 = 0 ;
 TH0 = (65536-50000)/256 ;
 TL0 = (65536-50000)%256 ;

 T0_Num++ ;
 if(T0_Num==20)							//中断20次(1s)
 	{
		F = F_Num ;						//输出频率
		T0_Num = 0 ;					//从0计时
		F_Num = 0 ;						//从0计数

	}

}


/*===============
 各中断初始化函数
=================*/

/*void InterruptInit(void)
{
 TH0 = (65536-50000)/256 ;
 TL0 = (65536-50000)%256 ;
 TMOD = 0x01 ;							
 
 TR0 = 1 ;								//T0方式0 初值50000
 ET0 = 1 ;

 IT0 = 1 ;								//INT0下降沿触发
 EX0 = 1 ;

 EA = 1 ;
}
/*********************************************************************************************************/
//关于24C16的函数
/*********************************************************************************************************/
/*=======
 开始函数
========*/
void start_24(void)
{
 scl = 0 ;
 sda = 1 ;
 scl = 1 ; _nop_();
 sda = 0 ; _nop_();
 
 scl = 0 ;
}

/*=======
 结束函数
 =======*/
void stop_24(void)
{
 scl = 0 ;
 sda = 0 ;
 scl = 1 ; _nop_() ;
 sda = 1 ; _nop_() ;

 scl = 0 ;
}

/*===========
 读8 Bit 数据
 ============*/
UINT8 read_8_bit_24(void)
{
 UINT8 r_8_bit, n, m ;
 UINT8 temp[8] = 0 ;
 
 r_8_bit = 0 ;
 scl = 0 ;scl = 1 ;
 for(n=0; n<8; n++)					//得到数据，由高到低位
 	{
		scl = 1 ;
		_nop_() ;
		temp[n] = sda ;
		scl = 0 ;
	}
 scl = 0 ;
 sda = 1 ;scl = 1 ; 
 _nop_() ; _nop_() ;
 scl = 0 ;							//处理确认位
 
 for(m=0; m<8; m++)					//数据处理
 	{
		r_8_bit = r_8_bit << 1 ;
		if(temp[m]==1) r_8_bit = r_8_bit|0x01 ;
		else r_8_bit = r_8_bit|0x00 ;
	}
 return r_8_bit ;
}

/*===============
 写8 Bit 数据 x
 ================*/
void write_8_bit_24(UINT8 x)
{
 UINT8 w_8_bit, n, m, a;
 UINT8 temp[8] = 0 ;
 w_8_bit = x ;
 
 for(n=0; n<8; n++)
 	{
		a = w_8_bit&0x80 ;				//高位在前
		if(a==0x80) temp[n] = 1 ;
		else temp[n] = 0 ;
		w_8_bit = w_8_bit << 1 ;
	}
 
 sda = 1 ;scl = 0 ;
 for(m=0; m<8; m++)						//先写高位
	{
		sda = temp[m] ;
		scl = 1 ;
		_nop_() ;
		scl = 0 ;
	}
 
 scl = 1 ; _nop_() ;
 scl = 0 ;								//处理确认位

 }

/*===========================================================================
 *                         读1 Byte 数据
 * 输入参数：r_add      要读的数据的地址,格式为:1010+页码(3位)+0+地址(8位)
 * 返回参数：r_1_byte   读得到的数据
 ============================================================================*/
UINT8 read_1_byte_24(UINT16 r_add)
{
 UINT8 r_1_byte ;
 UINT8 H , L, h;
 
 H = r_add / 256 ;						//得到高8位数据
 L = r_add % 256 ;						//得到低8位数据
 h = H+1 ;								//得到读指令的数据
 
 wp = 0 ;								//写允许
 delay_n5ms_24(1);
 
 start_24();
 write_8_bit_24(H);						//发写指令
 	_nop_() ;_nop_() ;
 write_8_bit_24(L);						//写入地址
 	_nop_() ;_nop_() ;
 
 start_24();
 write_8_bit_24(h);						//发读命令
 	_nop_() ;_nop_() ;

 wp = 1 ;								//写保护

 r_1_byte = read_8_bit_24() ;			//读得数据
 	_nop_() ;_nop_() ;
 stop_24();

return r_1_byte ;
}

/*===============================================================
 *                          写1 Byte 数据
 * 输入参数：w_add     写的地址，格式为:1010+页码(3位)+0+地址(8位)
 *		     w_1_byte  要写入的数据
 =================================================================*/
void write_1_byte_24(UINT16 w_add , UINT8 w_1_byte)
{
 UINT8 H,L;
 H = w_add / 256 ;
 L = w_add % 256 ;
 
 wp = 0 ;									//写允许
 delay_n5ms_24(1);							//加延时，解决了连续写要延时的问题
 
 start_24();
 
 write_8_bit_24(H);							//发写指令,写高8位
   	_nop_() ;_nop_() ;
 
 write_8_bit_24(L);							//写入地址,写低8位
   	_nop_() ;_nop_() ;
 
 write_8_bit_24(w_1_byte);					//写入数据
   	_nop_() ;_nop_() ;
 
 stop_24();

 wp = 1 ;									//写保护
 
}

/*=======================================================================
                     连续写入单个数据 
*说明：    每次调用后地址自动加1，此函数适用于隔段时间输入一个数据，
*          每次调用写入数据的地址是一个外部变量（R_Address）
*		   写完数据后在固定位置存放数据的地址的下一位
*输入参数：w_data  需存的的数据
========================================================================*/
void Continuum_Write_1_byte_24(UINT8 w_data)
{
 UINT8 H,L;
 UINT8 temp_data ;
 temp_data = w_data ;
 
 write_1_byte_24(W_Address, temp_data);			//在地址Address处写下w_data
 
 //以下是将地址(Address)加1
 H = W_Address / 256 ;						//取得地址的高8位				
 L = W_Address % 256 ;						//取得地址的低8位

 if(L == 255)								//若一页写满
	{
		L = 0 ;								//下一页的0地址
		H = H + 2 ;							//下一页
	}
 else L+=1 ;
 W_Address = H*256+L ;
 
 write_1_byte_24(0xaefe,H) ;				//在0xaefe存入地址的高8位
 write_1_byte_24(0xaeff,L) ;				//在0xaeff存入地址的低8位
											//W_Address此时为所存数据地址的下一个
 }

/*=======================================================================
                     连续读单个数据 
*说明：    每次调用后地址自动加1，此函数适用于隔段时间读出一个数据，
*		   从0单元开始，直到读完存入的所有数据（读到地址为写入的最后地址）
*          每次调用读出数据的地址是一个外部变量
*返回参数：r_data 读得的数据
========================================================================*/
UINT8 Continuum_Read_1_byte_24(void)
{
 UINT8 H,L;
 UINT8 r_data ;
 
 r_data = read_1_byte_24(R_Address) ;
 
 H = R_Address / 256 ;						//取得地址的高8位				
 L = R_Address % 256 ;						//取得地址的低8位

 if(L == 255)								//若一页写满
 	{
		L = 0 ;									//下一页的0地址
		H = H + 2 ;								//下一页
		R_Address = H*256+L ;
 	}
 else R_Address+=1 ;

 return r_data ;	
}
/***********************************************************************/
void ReadWorkpieceNum(void)
{
 WorkpieceNum[0] =read_1_byte_24(0xa000);delay_n5ms_24(1);
 WorkpieceNum[1] =read_1_byte_24(0xa001);delay_n5ms_24(1);
 WorkpieceNum[2] =read_1_byte_24(0xa002);delay_n5ms_24(1);
 WorkpieceNum[3] =read_1_byte_24(0xa003);delay_n5ms_24(1);
}

/*========================
 * 延时函数 5n ms
 =======================*/
void delay_n5ms_24(UINT8 n)
{
 UINT8 q ;
 UINT16 p ;
 for(q=0;q<n;q++)
 for(p=0;p<5000;p++){};
}



void main(void)
{
 UINT8 n ;

 /*R_Address = 0xa000 ;
 
 for(n=0;n<80;n++)
 	{
	 Continuum_Write_1_byte_24(0x64);
	}
  while(1);
*/




 write_1_byte_24(0xa000 , 1);
 write_1_byte_24(0xa001 , 2);
 write_1_byte_24(0xa002 , 3);
 write_1_byte_24(0xa003 , 4);
  //ReadWorkpieceNum();



while(1)
 {
  for(n=0 ; n<4 ; n++){P0 = read_1_byte_24(0xa000) ;delay_n5ms_24(20);}
  }

 /*UINT8 H ,L ;			
 H = read_1_byte_24(0xaefe) ;
 L = read_1_byte_24(0xaeff) ;
 W_Address = H*256+L ;  							//读出地址
 
 R_Address = 0xa000 ;
  		Continuum_Write_1_byte_24(0x50);
		Continuum_Write_1_byte_24(0x51);
		Continuum_Write_1_byte_24(0x52);
		Continuum_Write_1_byte_24(0x53);
		Continuum_Write_1_byte_24(0x54);
		Continuum_Write_1_byte_24(0x55);
		Continuum_Write_1_byte_24(0x56);
		Continuum_Write_1_byte_24(0x57);
        Continuum_Write_1_byte_24(0x58);
		Continuum_Write_1_byte_24(0x59);


while(1) 
{
 if(R_Address < W_Address)							//读到写的最后位
 	{
  		P0 = Continuum_Read_1_byte_24();delay_n5ms_24(20);
  	}


	
}*/
}