timer(8025).c

能检查电流

	#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 RTC_start (void)
{
	_bitTRISRTCSDA = 1;
	_bitTRISRTCSCL = 0;
	Delay_5us ();

	_bitOutRTCSCL = 1;
	Delay_5us ();

	_bitOutRTCSDA = 0;			/*SCL = 1,SDA from 1 to 0*/
	_bitTRISRTCSDA = 0;
	Delay_5us ();

	_bitOutRTCSCL = 0;
	Delay_5us ();

	_bitTRISRTCSDA = 1;
}

/*--------------------------------------------------------------------------*/
/* Send stop bit
 * Input:	none
 * Output:	none
 * Use:		none
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void RTC_stop (void)
{
	_bitOutRTCSDA = 0;
	_bitTRISRTCSDA = 0;
	_bitTRISRTCSCL = 0;
	Delay_5us ();

	_bitOutRTCSCL = 1;
	Delay_5us ();

	_bitTRISRTCSDA = 1;			/*SCL = 1,SDA from 0 to 1*/
	Delay_5us ();

	_bitOutRTCSCL = 0;
	Delay_5us ();
}

/*--------------------------------------------------------------------------*/
/* Send byte from vIICreg
 * Input:	vIICreg
 * Output:	none
 * Use:		geCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void RTC_byte_TX (void)
{
	_bitOutRTCSDA = 0;
	_bitTRISRTCSDA = 1;
	_bitTRISRTCSCL = 0;

	Delay_5us ();
//	Delay_5us ();

	geCount = 8;
	do
	{
		_bitTRISRTCSDA = vIICreg.Bit.b7;
		Delay_5us ();
		_bitOutRTCSCL = 1;		/*Send clock*/
		Delay_5us ();
		_bitOutRTCSCL = 0;
		Delay_5us ();

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

	_bitTRISRTCSDA = 1;
	Delay_5us ();

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

	meterRunState.Bit.b1 = 0;		/*RTC right*/
	if(_bitRTCSDA == 1)
	meterRunState.Bit.b1 = 1;		/*RTC wrong*/

//	Delay_5us ();

	_bitOutRTCSCL = 0;
	Delay_5us ();
}

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

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

		_bitOutRTCSCL = 1;
		Delay_5us ();

		vIICreg.Bit.b0 = _bitRTCSDA;	/*Receive bit*/

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

	}
	while( --geCount );

	return (vIICreg.Byte);
}

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

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

	_bitTRISRTCSDA = 1;
}

/*--------------------------------------------------------------------------*/
/* Generates a 9th clock pulsse receive no ACK bit
 * Input:	none
 * Output:	none
 * Use:		none
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void RTC_no_ACK (void)
{
	_bitTRISRTCSDA = 1;
	Delay_5us ();
	_bitOutRTCSCL = 1;
	Delay_5us ();
	_bitOutRTCSCL = 0;			/*No ACK*/
	Delay_5us ();
}


/*--------------------------------------------------------------------------*/
/* WRITE operation , write bytes to TIMER device
 * Input:	spCount、extRAMaddr、dataBuffTwo[]
 * Output:	none
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void RTC_write (unsigned char *buff)
{
	unsigned char a;
	unsigned char b;

	extRAMaddr2 = extRAMaddr;
	extRAMaddr3 = extRAMaddr;

	RTC_write_check ();

	a = 0;
	do
	{
		RTC_write_check ();

		RTC_start ();
		vIICreg.Byte = _8025slaveAddr;
		RTC_byte_TX ();

		b = extRAMaddr;
		b <<= 4;
		vIICreg.Byte = b;
		RTC_byte_TX ();

		vIICreg.Byte = buff[a];
		RTC_byte_TX ();

		if(a > 16)
		Err_process ();

		if(extRAMaddr++ > 16)
		Err_process ();

		extRAMaddr2++;
		extRAMaddr3++;

//		RTC_write_check ();
		Delay_5us ();
		RTC_stop ();
	}
	while( ++a < spCount );
     			/*Send stop*/

	errJudgeFlag[9] = 0;
}

/*--------------------------------------------------------------------------*/
/* RTC write check
 * Input:	none
 * Output:	none
 * Use:		none
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void RTC_write_check (void)
{
	if(errJudgeFlag[9] != _TimerWriteValue)
	Err_process ();

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

/*--------------------------------------------------------------------------*/
/* Reset timer device
 * Input:	none
 * Output:	none
 * Use:		W、STATUS
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Timer_run_set (void)
{
	Read_timer (15);

	dataBuffTwo[15] &= 0x00FB;
	if((dataBuffTwo[7] != _8025offsetValue) || (dataBuffTwo[14] != _8025CON1value) || (dataBuffTwo[15] != _8025CON2value))
	{
		errJudgeFlag[9] = _TimerWriteValue;
	
		dataBuffTwo[0] = _8025offsetValue;	/*07*/
		spCount = 1;
		extRAMaddr = _8025offset;
		RTC_write (dataBuffTwo);
	
	
		errJudgeFlag[9] = _TimerWriteValue;
	
		dataBuffTwo[0] = _8025CON1value;	/*Byte count = E*/
		dataBuffTwo[1] = _8025CON2value;
		spCount = 2;
		extRAMaddr = _8025CON1;
		RTC_write (dataBuffTwo);
	}
}


/*--------------------------------------------------------------------------*/
/* Read bytes from timer device
 * Input:	none
 * Output:	dataBuffTwo[]
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void Read_timer (unsigned char a)
{
//	RTC_start ();
//	vIICreg.Byte = _8025slaveAddr;
//	RTC_byte_TX ();
//
//	vIICreg.Byte = _8025second;
//	RTC_byte_TX ();

	RTC_start ();
	vIICreg.Byte = _8025slaveAddr + 1;
	RTC_byte_TX ();

	dataBuffTwo[15] = RTC_byte_RX ();	/*Recieve 0FH address data*/
	RTC_ACK ();

	spCount = 0;
	do
	{
						/*Start from 00H address*/
		dataBuffTwo[spCount] = RTC_byte_RX ();

		if(spCount > 15)
		Err_process ();

		if(++spCount < a)
		RTC_ACK ();

	}
	while( spCount < a );

	RTC_no_ACK ();
	RTC_stop ();           			/*Send stop*/

	dataBuffTwo[0] = dataBuffTwo[0] & 0x007F;
	dataBuffTwo[1] = dataBuffTwo[1] & 0x007F;

	vRTCreg = dataBuffTwo[0];

	vRTCreg >>= 4;				/*Set RTC value*/
	vRTCreg = (vRTCreg & 0x000F) * 10;
	vRTCreg += (dataBuffTwo[0] & 0x000F);

	dataBuffTwo[2] = dataBuffTwo[2] & 0x003F;
	dataBuffTwo[3] = dataBuffTwo[3] & 0x0007;
	dataBuffTwo[4] = dataBuffTwo[4] & 0x003F;
	dataBuffTwo[5] = dataBuffTwo[5] & 0x001F;
}

/*--------------------------------------------------------------------------*/
/* LVP hour increment
 * Input:	none
 * Output:	dataBuffTwo[]
 * Use:		spCount
 * Memo:	require OSC frequency 10MHz
 */
/*--------------------------------------------------------------------------*/
void LVP_hour_increment (void)
{
	Read_timer (3);

	dataBuffTwo[2] = dataBuffTwo[2] & 0x007F;
	if(vRAMhourTemp != dataBuffTwo[2])
	{
		vRAMhourTemp = dataBuffTwo[2];	
		vLVPtimer = 0xAA;
	}
	
	dataBuffTwo[2] = dataBuffTwo[2] & 0x003F;

}