externalram.c

外部RAM的读写操作及其确认

	#include <P18f4520.h>			/*reference file*/

	#include "Define.h"

#pragma code

/*--------------------------------------------------------------------------*/
/* Send start bit
 * Input:	none
 * Output:	none
 * Use:		none
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Byte_start (void)
{
	_bitTRISSDA = 1;
	_bitTRISSCL = 0;
	Delay_5us ();

	_bitOutSCL = 1;				/*SCL high*/
	Delay_5us ();

	_bitOutSDA = 0;
	_bitTRISSDA = 0;			/*SDA high to low*/
	Delay_5us ();

	_bitOutSCL = 0;
	Delay_5us ();

	_bitTRISSDA = 1;
}

/*--------------------------------------------------------------------------*/
/* Send stop bit
 * Input:	none
 * Output:	none
 * Use:		none
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Byte_stop (void)
{
	_bitOutSDA = 0;
	_bitTRISSDA = 0;
	_bitTRISSCL = 0;
	Delay_5us ();

	_bitOutSCL = 1;				/*SCL high*/
	Delay_5us ();

	_bitTRISSDA = 1;
	Delay_5us ();

	_bitOutSCL = 0;				/*SDA low to high*/
	Delay_5us ();
}

/*--------------------------------------------------------------------------*/
/* Send byte from vIICreg
 * Input:	vIICreg
 * Output:	none
 * Use:		geCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Byte_TX (void)
{
	_bitOutSDA = 0;
	_bitTRISSDA = 1;
	_bitTRISSCL = 0;

	Delay_5us ();
	Delay_5us ();

	geCount = 8;
	do
	{
		_bitTRISSDA = vIICreg.Bit.b7;	/*Send SDA data*/

		_bitOutSCL = 1;			/*Send clock*/
		Delay_5us ();
		_bitOutSCL = 0;
		Delay_5us ();

		vIICreg.Byte <<= 1;
	}
	while( --geCount );

	_bitTRISSDA = 1;
	Delay_5us ();

	_bitOutSCL = 1;				/*Clock pulse for ACK*/
	Delay_5us ();

//	meterRunState.Bit.b0 = 0;		/*Right*/
//	if(_bitSDA == 1)
//	meterRunState.Bit.b0 = 1;		/*Wrong*/

	Delay_5us ();

	_bitOutSCL = 0;
	Delay_5us ();
}

/*--------------------------------------------------------------------------*/
/* Received byte to vIICreg
 * Input:	none
 * Output:	vIICreg
 * Use:		geCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
unsigned char Byte_RX (void)
{
	_bitTRISSDA = 1;
	_bitTRISSCL = 0;

	geCount = 8;
	do
	{
		vIICreg.Byte <<= 1;

		_bitOutSCL = 1;
		Delay_5us ();
						/*Receive bit*/
		vIICreg.Bit.b0 = _bitSDA;

		_bitOutSCL = 0;			/*Send clock*/
		Delay_5us ();

	}
	while( --geCount );

	return (vIICreg.Byte);
}

/*--------------------------------------------------------------------------*/
/* Generates 9th clock pulsse receive ACK bit
 * Input:	none
 * Output:	none
 * Use:		none
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Byte_ACK (void)
{
//	_bitOutSDA = 0;
	_bitTRISSDA = 0;

	_bitOutSCL = 1;
	Delay_5us ();
	_bitOutSCL = 0;				/*ACK*/
	Delay_5us ();

	_bitTRISSDA = 1;
}

/*--------------------------------------------------------------------------*/
/* Generates 9th clock pulsse receive no ACK bit
 * Input:	none
 * Output:	none
 * Use:		none
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Byte_no_ACK (void)
{
	_bitTRISSDA = 1;

	_bitOutSCL = 1;
	Delay_5us ();
	_bitOutSCL = 0;				/*No ACK*/
	Delay_5us ();
}


/*--------------------------------------------------------------------------*/
/* Write I2C data
 * Input:	spCount、extRAMaddr、extRAMaddrHigh、&(dataBuff[])
 * Output:	none
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Write_I2C_data (unsigned char *buff)
{
	DINTH
//	_bitWP = 0;				/*Enable write*/

	extRAMaddr2 = extRAMaddr;
	extRAMaddrHigh2 = extRAMaddrHigh;

	ExtRAM_write_check ();

	baseCount = 0;
	do
	{
		ExtRAM_write_check ();
		Byte_start ();
		vIICreg.Byte = _ExtRAMslaveAddr;
		Byte_TX ();

		ExtRAM_write_check ();
		vIICreg.Byte = extRAMaddrHigh;
		Byte_TX ();
		vIICreg.Byte = extRAMaddr++;
		Byte_TX ();

		vIICreg.Byte = buff[baseCount];
		Byte_TX ();

		if(baseCount > 15)
		Err_process ();

		extRAMaddr2++;

		ExtRAM_write_check ();
	}
	while( ++baseCount < spCount );

	Byte_stop ();				/*Send stop*/

	extRAMaddr -= spCount;			/*Restore addr*/
	extRAMaddr2 -= spCount;

//	_bitWP = 1;				/*Disable write*/
}


/*--------------------------------------------------------------------------*/
/* Read I2C data
 * Input:	spCount、extRAMaddr、extRAMaddrHigh、&(dataBuff[])
 * Output:	dataBuffTwo[16]
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Read_I2C_data (unsigned char *buff)
{
	extRAMaddr2 = extRAMaddr;
	extRAMaddrHigh2 = extRAMaddrHigh;

	Read_data_check ();

	Byte_start ();
	vIICreg.Byte = _ExtRAMslaveAddr;
	Byte_TX ();

	Read_data_check ();
	vIICreg.Byte = extRAMaddrHigh;
	Byte_TX ();
	vIICreg.Byte = extRAMaddr;
	Byte_TX ();

	Byte_start ();
	vIICreg.Byte = _ExtRAMslaveAddr + 1;
	Byte_TX ();

	baseCount = 0;
	do
	{
		Read_data_check ();
		buff[baseCount] = Byte_RX ();

		if(baseCount > 15)
		Err_process ();

		if(baseCount != (spCount - 1))
		Byte_ACK ();
	}
	while( ++baseCount < spCount );

	Byte_no_ACK ();

	Read_data_check ();
	Byte_stop ();				/*Send stop*/
}


/*--------------------------------------------------------------------------*/
/* Read and verify data
 * Input:	spCount、extRAMaddr、extRAMaddrHigh、&(dataBuff[])
 * Output:	dataBuffTwo[16]
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Read_verify_data (unsigned char *buff)
{
	upCount = 3;
	do
	{
		Read_I2C_data (buff);

		Read_data_check ();

		Read_I2C_data (dataBuffTwo);

		if(Indirect_compare_data (buff, dataBuffTwo) != _CompareDataright)
		{
			if(upCount != 1)
			continue;

			Err_process ();
		}

		else
		{
			return;		
		}
		
	}
	while( --upCount );				/*Repeat 3 times*/

	errJudgeFlag[2] = 0;
}

/*--------------------------------------------------------------------------*/
/* Read data check
 * Input:	none
 * Output:	none
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Read_data_check (void)
{
	if(errJudgeFlag[2] != _CountReadValue)	/*Read flag?*/
	Err_process ();

	_asm GOTO ExtRAM_addr_check _endasm
}


void ExtRAM_addr_check (void)
{						/*Check address?*/
	if(extRAMaddrHigh2 != extRAMaddrHigh)
	Err_process ();

	if(extRAMaddr2 != extRAMaddr)
	Err_process ();
}


/*--------------------------------------------------------------------------*/
/* Write and verify data
 * Input:	spCount、extRAMaddr、extRAMaddrHigh、&(dataBuff[])
 * Output:	dataBuffTwo[16]
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Write_verify_data (unsigned char *buff)
{
	DINTH
	upCount = 3;
	do
	{
		Write_I2C_data (buff);

		ExtRAM_write_check ();
		errJudgeFlag[2]	= _CountReadValue;
		Read_I2C_data (dataBuffOne);

		errJudgeFlag[2]	= _CountWriteValue;

		if(Indirect_compare_data (buff, dataBuffOne) != _CompareDataright)
		{
			if(upCount != 1)
			continue;
			Err_process ();
		}

		else
		{
			return;		
		}
	}
	while( --upCount );				/*Repeat 3 times*/

	errJudgeFlag[0] = 0;
	errJudgeFlag[1] = 0;
	errJudgeFlag[2] = 0;

}

/*--------------------------------------------------------------------------*/
/* Write data check
 * Input:	none
 * Output:	none
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void ExtRAM_write_check (void)
{
	if(errJudgeFlag[0] != _CountWriteValue)
	Err_process ();

	_asm GOTO ExtRAM_addr_check _endasm
}

/*--------------------------------------------------------------------------*/
/* Indirect compare data
 * Input:	spCount、*buff1、*buff2
 * Output:	dataBuffTwo[16]
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
unsigned char Indirect_compare_data (unsigned char *buff1, unsigned char *buff2)
{
	unsigned char a;

	baseCount = 0;
	do
	{
		if(buff1[baseCount] != buff2[baseCount])
		{
			a = _CompareDataErr;
			return (a);
		}
		a = _CompareDataright;
	}
	while( ++baseCount < spCount );

	return (a);
}

/*--------------------------------------------------------------------------*/
/* Delay 5us routine
 * Input:	none
 * Output:	none
 * Use:		W、STATUS、a
 * Memo:	require OSC frequency 10MHz delay:
 *		(12+4) * 0.0000004 = 6.4us
 */
/*--------------------------------------------------------------------------*/
void Delay_5us (void)
{
	smCount = 4;

	do
	{
		;
	}
	while( --smCount );
}
void Delay_us (unsigned char delayCount)
{
	do
	{
		;
	}
	while( --delayCount );
}
/*--------------------------------------------------------------------------*/
/* Delay (n=delayCount) ms routine
 * Input:	delayCount
 * Output:	none
 * Use:		W、STATUS、a、b
 * Memo:	require OSC frequency 10MHz delay:
 *		4 * 256 * 3 * delayCount * 0.0000004 = (delayCount)*1.2288ms
 */
/*--------------------------------------------------------------------------*/
void Delay_ms (unsigned char delayCount)
{
	unsigned char a;

	delayCount++;

	do
	{					/*Delay 1.23ms*/
		baseCount = 5;
		a = 0;
		do
		{
			do
			{
				;
			}
			while( --a );
		}
		while( --baseCount );
	}
	while( --delayCount );
}