function.c

pdh控制程序

#ifndef _FUNCTION_C_
#define _FUNCTION_C_

#include "api.h"

void WriteChip( WORD address, BYTE value )
{
	XBYTE[address] = value;
}

BYTE ReadChip( WORD address )
{
	BYTE value;

	value = XBYTE[address];

	return value;
}

void taskDelay( WORD time )
{
	WORD counter;
	BYTE counter1;

	for( counter=0; counter<time; counter++ )
	for( counter1=0; counter1<200; counter1++ )
		_nop_();
}

void system_watchdog( BYTE status )
{
	gSystemInfo.reboot_flag = status;
}

BYTE disable_remote_alarm_status( void )
{
    SYSTEM_DEVICE_STATUS xdata *psdev = &gsystemStauts;
    BYTE xdata fiber;

    for( fiber=0; fiber<MAX_FIBER_NOMBER; fiber++ )
    {
        if( !(psdev->remote.fiber_status[fiber]&FIBER_NOUSE) )
            if( (psdev->remote.fiber_status[fiber]&FIBER_ALARM_STATUS) )
                return ALARM;
    }
    return NOALARM;
}


#if _LCD_MENU_

/*激光关断使能，0使能，1不使能，3无操作*/
void SetSystemFiberCloseDown( BYTE state )
{
    SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;
    SYSTEM_INFOMATION *psys = &gSystemInfo;

	psys->als_value &= ~ BIT7;
	switch( state )
	{
	case IDB_ENABLE_LASER_CLOSE:
	    psdev->local.laser_close[0] = IDB_ENABLE_LASER_CLOSE;
		psys->als_value |= BIT7;
	   break;

	case IDB_DISABLEE_LASER_CLOSE:
		psdev->local.laser_close[0] = IDB_DISABLEE_LASER_CLOSE;
	    break;
	}

    WriteChip( FIBERLOOP_LIGHT_ADDR, psys->als_value );
}

#if 0
void save_fiber_close( BYTE *status )
{
	BYTE Lock = 0xaa;

	I2C_WriteData( EEPROM_FIBER_CLOSEDOWN_ADDRESS, EEPROM_FIBER_CLOSEDOWN_LENGTH, status );
	I2C_WriteData( EEPROM_FIBER_CLOSEDOWN_LOCK_ADDRESS, LOCK_LENGTH, &Lock );
}

BYTE GetSystemFiberCloseDown( BYTE end )
{
    SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;
    BYTE status = INVALID;

	switch( end )
	{
    case LACAL_EQU:
    	status = psdev->local.laser_close[0];
		break;

    case REMOTE_EQU:
    	status = psdev->remote.laser_close[0];
		break;

	}
    return status;
}
#endif

void SetSystemProtectMode( BYTE mode )
{
    SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;
	BYTE status;
    SYSTEM_INFOMATION *psys = &gSystemInfo;

    psys->setbuffer[1] &=  SYSTEM_FIBER_AUTO_RC7017;
	psdev->local.protect_mode = mode;
    switch( mode )
    {
    case IDB_FIBER_AUTO:
        status |= SYSTEM_FIBER_AUTO;
        break;

    case IDB_FIBER_MASTER:
        psys->setbuffer[1] |=  BIT6;
        status |= SYSTEM_FIBER_MASTER;
        break;

    case IDB_FIBER_SLAVE:
        psys->setbuffer[1] |=  BIT5;
        status |= SYSTEM_FIBER_SLAVE;
        break;
    }
    psdev->local.protect_mode = mode;
    WriteChip( FIBER_CONFIG_ADDR, status );
    psys->sendrc7017 = SETCMDSERIAL;
    psys->SetCommandCounter = 0;
}

void save_protect_mode( BYTE mode )
{
	BYTE Lock = 0xaa;

	I2C_WriteData( EEPROM_PROTECT_MODE_ADDRESS, EEPROM_PROTECT_MODE_LENGTH, &mode );
	I2C_WriteData( EEPROM_PROTECT_MODE_LOCK_ADDRESS, LOCK_LENGTH, &Lock );
}

void SetSystemConstrast( BYTE value )
{
	ConstrastSet( value );
}

void save_constrast_set( BYTE value )
{
	BYTE Lock = 0xaa;

	I2C_WriteData( EEPROM_CONSTRAST_ADDRESS, EEPROM_CONSTRAST_ADDRESS_LENGTH, &value );
	I2C_WriteData( EEPROM_CONSTRAST_LOCK_ADDRESS, LOCK_LENGTH, &Lock );
}

void init_system_infomation( void )
{
	BYTE read_lock;
	BYTE status[2];

	I2C_ReadData( EEPROM_FIBER_CLOSEDOWN_LOCK_ADDRESS, LOCK_LENGTH, &read_lock );
	if( read_lock == LOCK )
	{
		I2C_ReadData( EEPROM_FIBER_CLOSEDOWN_ADDRESS, EEPROM_FIBER_CLOSEDOWN_LENGTH, status );
		SetSystemFiberCloseDown(  status[0] );
	}
	else
	{
		SetSystemFiberCloseDown( IDB_ENABLE_LASER_CLOSE );
	}

	I2C_ReadData( EEPROM_PROTECT_MODE_LOCK_ADDRESS, LOCK_LENGTH, &read_lock );
	if( read_lock == LOCK )
	{
		I2C_ReadData( EEPROM_PROTECT_MODE_ADDRESS, EEPROM_PROTECT_MODE_LENGTH, status );
		SetSystemProtectMode( status[0] );
	}
	else
		SetSystemProtectMode( IDB_FIBER_AUTO );

	/*在复位程序后，将对比度拉到最低*/
	wiperDown( 200 );

	I2C_ReadData( EEPROM_CONSTRAST_LOCK_ADDRESS, LOCK_LENGTH, &read_lock );
	if( read_lock == LOCK )
	{
		I2C_ReadData( EEPROM_CONSTRAST_ADDRESS, EEPROM_CONSTRAST_ADDRESS_LENGTH, status );
		if( status[0] >= 16 )
			status[0] = 5;
	}
	else
	{
		status[0] = 5;
	}
	SetSystemConstrast( status[0] );
    gSystemInfo.contrast_value = status[0];
}

#endif

void serial_interrupt( void ) interrupt SERIALO_INTERRUPT_VECTOR
{
	BYTE receive = 0x59;

	if( RI )
	{
		receive = SBUF;
//		SBUF = receive;
	}
	if( TI )
		return;
}

#endif