rc7017uart.c

pdh控制程序

#ifndef _RC7017UART_C_
#define _RC7017UART_C_

#include "api.h"
#include "serial.h"

#define FIBER_LOS_TIME 18
#define FIBER_LOS_OK_TIME 16

void EncapsulationSetCommand( SERIALSTRUCT *pUart, SYSTEM_INFOMATION *psys )
{
	BYTE counter;
	BYTE *pbuffer;

	pbuffer = pUart->SendBuffer + 2;

	pUart->SendLength = COMMAND_SET_LEGNTH;

	*pbuffer ++ = COMMAND_SET;
	for(counter=0; counter<sizeof( psys->setbuffer ); counter++)
		*pbuffer ++ = psys->setbuffer[counter];

	*pbuffer ++ = SERIAL_END;
}

void EncapsulationAlarmCommand( SERIALSTRUCT *pUart )
{
	BYTE *pbuffer;

	pbuffer = pUart->SendBuffer + 2;

	pUart->SendLength = COMMAND_ALARM_LEGNTH;

	*pbuffer ++ = COMMAND_ALARM;
	*pbuffer ++ = 0x00;
	*pbuffer ++ = SERIAL_END;
}

void EncapsulationValarCommand( SERIALSTRUCT *pUart )
{
	BYTE counter;
	BYTE *pbuffer;

	pbuffer = pUart->SendBuffer + 2;

	pUart->SendLength = COMMAND_VALAR_LEGNTH;

	*pbuffer ++ = COMMAND_VALAR;

	for(counter=0; counter<6; counter++)
		*pbuffer ++ = 0;

	*pbuffer ++ = SERIAL_END;
}

void EncapsulationSendBuffer( SERIALSTRUCT *pUart, SYSTEM_INFOMATION *psys )
{
	BYTE *pbuffer;

	pbuffer = pUart->SendBuffer;
	pUart->SendLength = 0;

	*pbuffer++ = SYNCHR1_0X7E;
	*pbuffer++ = SYNCHR2_0X81;

	switch( psys->sendrc7017  )
	{
	case SETCMDSERIAL:
		EncapsulationSetCommand( pUart, psys );
		break;

	case ALARMSERIAL:
		EncapsulationAlarmCommand( pUart );
		break;

	case VALARSERIAL:
		EncapsulationValarCommand( pUart );
		break;

	default :
		psys->sendrc7017= ALARMSERIAL;
		break;
	}
	pUart->SendCounter = 0;
}


void serial_set_command( SYSTEM_INFOMATION *psys )
{
	psys->SetCommandCounter ++;
	if( psys->SetCommandCounter == COMMAND_SET_COUNTER )
	{
		psys->sendrc7017 = ALARMSERIAL;
		psys->SetCommandCounter = 0;
	}
}

void alarm_check_first_status( SYSTEM_DEVICE_STATUS *psdev, BYTE status )
{
	if( status&BIT2 )
	{
		psdev->remote.alarm_hook &= HOOK_ON;
		psdev->remote.alarm_hook |= HOOK_OFF;
	}
	else
		psdev->remote.alarm_hook &= HOOK_ON;

	if( status&BIT0 )
	{
		psdev->local.alarm_hook &= HOOK_ON;
		psdev->local.alarm_hook |= PHONE_TALK;
		psdev->remote.alarm_hook &= HOOK_ON;
		psdev->remote.alarm_hook |= PHONE_TALK;
	}
}

void alarm_check_local_e1_alarm_status( SYSTEM_DEVICE_STATUS *psdev, SYSTEM_INFOMATION *psys )
{
	BYTE counter;

	for( counter=0; counter<psys->max_system_e1; counter++ )
	{
		psdev->local.e1_status[counter] &= E1_NOALARM;
		if( ((psys->alarm[4]>>counter)&BIT0) && ((psys->e1_use>>counter)&BIT0) )
		{
			psdev->local.e1_status[counter] |= E1_ALARM;
		}
	}
}

BYTE get_use_fiber( BYTE *fiber_status )
{
	BYTE counter;

	for( counter=0; counter<MAX_FIBER_NOMBER; counter++ )
		if( !(fiber_status[counter]&FIBER_NOUSE) )
			break;

	return counter;
}

void alarm_check_remote_e1_alarm_status( SYSTEM_DEVICE_STATUS *psdev, SYSTEM_INFOMATION *psys )
{
	BYTE counter;

    if( check_remote_status() == ALARM )
        return;

    if( disable_remote_alarm_status() == ALARM )
        return;

	for( counter=0; counter<psys->max_system_e1; counter++ )
	{
		psdev->remote.e1_status[counter] &= E1_NOALARM;
		if( ((psys->alarm[7]>>counter)&BIT0) && ((psys->valar[4]>>counter)&BIT0) )
		{
			psdev->remote.e1_status[counter] |= E1_ALARM;
		}
	}
}

BYTE fiber_status_form_chip( BYTE chip_status )
{
    static BYTE xdata los_time[MAX_FIBER_NOMBER] = {0,0};
    static BYTE xdata get_time[MAX_FIBER_NOMBER] = {17,17};
    static BYTE xdata fiber_status = 0xff;
/*    static BYTE xdata preview_chip_status = 0xff;*/
    BYTE xdata fiber;

/*
    if( preview_chip_status != chip_status )
    {
        for( fiber=0; fiber<MAX_FIBER_NOMBER; fiber++ )
            if( ((preview_chip_status>>fiber)&BIT0)
                && ( !((chip_status>>fiber)&BIT0)) )
            {
                los_time[fiber] = 0;
                get_time[fiber] = 0;
            }
        preview_chip_status = chip_status;
    }
*/
    for( fiber=0; fiber<MAX_FIBER_NOMBER; fiber++ )
    {
        get_time[fiber] = ( get_time[fiber] + 1 )%FIBER_LOS_TIME;
        if( !((chip_status>>fiber)&BIT0) )
	    los_time[fiber] ++;
        if( !get_time[fiber] )
		{
            if( los_time[fiber] >= FIBER_LOS_OK_TIME  )
                fiber_status &= ~(BIT0<<fiber);
            else
            {
				if( los_time[fiber] != 0 )
					gSystemInfo.remote_fiber_status[fiber] = ALARM;
				else
					gSystemInfo.remote_fiber_status[fiber] = NOALARM;
				fiber_status |= (BIT0<<fiber);
            }
            los_time[fiber] = 0;
        }
    }
    return fiber_status;
}

BYTE fiber_status_form_var( BYTE chip_status )
{
    static BYTE xdata los_time[MAX_FIBER_NOMBER] = {0,0};
    static BYTE xdata get_time[MAX_FIBER_NOMBER] = {17,17};
    static BYTE xdata fiber_status = 0xff;
/*    static BYTE xdata preview_chip_status = 0xff;*/
    BYTE xdata fiber;

/*
    if( preview_chip_status != chip_status )
    {
        for( fiber=0; fiber<MAX_FIBER_NOMBER; fiber++ )
            if( ((preview_chip_status>>fiber)&BIT0)
                && ( !((chip_status>>fiber)&BIT0)) )
            {
                los_time[fiber] = 0;
                get_time[fiber] = 0;
          }
            preview_chip_status = chip_status;
    }
*/
    for( fiber=0; fiber<MAX_FIBER_NOMBER; fiber++ )
    {
        get_time[fiber] = ( get_time[fiber] + 1 )%FIBER_LOS_TIME;
        if( !(chip_status&(BIT7>>fiber)) )
	    los_time[fiber] ++;
        if( !get_time[fiber] )
        {
            if( los_time[fiber] >= FIBER_LOS_OK_TIME  )
                fiber_status &= ~(BIT0<<fiber);
            else
	        fiber_status |= (BIT0<<fiber);
            los_time[fiber] = 0;
        }
    }

    return fiber_status;
}

void remote_alarm_check( BYTE chip_status, BYTE status )
{
    SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;
    BYTE xdata fiber;

    if( check_remote_status() == ALARM )
    {
        psdev->remote.fiber_status[0] &= FIBER_NOALARM;
        psdev->remote.fiber_status[1] &= FIBER_NOALARM;
        return;
    }
    for( fiber=0; fiber<MAX_FIBER_NOMBER; fiber++ )
    {
        psdev->remote.fiber_status[fiber] &= FIBER_NOALARM;
        if( !((chip_status>>fiber)&BIT0) )
            psdev->remote.fiber_status[fiber] |= FIBER_LOS;
    }
    fiber = get_use_fiber( psdev->remote.fiber_status );
    if( (psdev->remote.fiber_status[fiber] & FIBER_ALARM_STATUS) == FIBER_OK )
    {
         if( status&BIT5 )
             psdev->remote.fiber_status[fiber] |= FIBER_LFA;
         else if( status&BIT4 )
             psdev->remote.fiber_status[fiber] |= FIBER_E_3;
/*         else if( status&BIT3 )
             psdev->remote.fiber_status[fiber] |= FIBER_E_6;*/
    }
}

void remote_alarm_check_fiber_status_with_als( BYTE status )
{
    SYSTEM_INFOMATION *psys = &gSystemInfo;
    BYTE xdata chip_status;

    chip_status = fiber_status_form_var( psys->valar[6] );
    remote_alarm_check( chip_status, status );
}

void remote_alarm_check_fiber_status_without_als( BYTE status )
{
    SYSTEM_INFOMATION *psys = &gSystemInfo;
    BYTE xdata chip_status;

    chip_status = ( psys->valar[6] ) >> 6;
    remote_alarm_check( chip_status, status );
}

void local_alarm_check( BYTE chip_status, BYTE status )
{
    SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;
    BYTE xdata fiber;

    for( fiber=0; fiber<MAX_FIBER_NOMBER; fiber++ )
    {
        psdev->local.fiber_status[fiber] &= FIBER_NOALARM;
        if( !((chip_status>>fiber)&BIT0) )
            psdev->local.fiber_status[fiber] |= FIBER_LOS;
    }

    fiber = get_use_fiber( psdev->local.fiber_status );
    if( (psdev->local.fiber_status[fiber]&FIBER_ALARM_STATUS) == FIBER_OK )
    {
        if( status&BIT5 )
            psdev->local.fiber_status[fiber] |= FIBER_LFA;
        else if( status&BIT4 )
            psdev->local.fiber_status[fiber] |= FIBER_E_3;
/*        else if( status&BIT3 )
            psdev->local.fiber_status[fiber] |= FIBER_E_6;*/
    }

    if( check_remote_status() == ALARM )
    {
        psdev->remote.fiber_status[0] &= FIBER_NOALARM;
        psdev->remote.fiber_status[1] &= FIBER_NOALARM;
    }
}

void local_alarm_check_fiber_status_with_als( BYTE status )
{
    BYTE xdata chip_status;
    BYTE xdata local_chip;

    local_chip = ReadChip( LOCAL_STATUS_ADDR );

    chip_status = fiber_status_form_chip( local_chip );
    local_alarm_check( chip_status, status );
}

void local_alarm_check_fiber_status_without_als( BYTE status )
{
    BYTE xdata chip_status;

    chip_status = ReadChip( LOCAL_STATUS_ADDR );

    local_alarm_check( chip_status, status );
}

BYTE get_local_als_status( void )
{
     SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;

    if( psdev->local.program&BIT1 )
        return 0;
     return 1;
}

void local_alarm_check_fiber_status( BYTE status )
{
    if( get_local_als_status() )
        local_alarm_check_fiber_status_without_als( status );
    else
        local_alarm_check_fiber_status_with_als( status );
}

void remote_alarm_check_fiber_status( BYTE status )
{
    if( get_local_als_status() )
        remote_alarm_check_fiber_status_without_als( status );
    else
        remote_alarm_check_fiber_status_with_als( status );
}

void serial_alarm_command( SERIALSTRUCT *pUart, SYSTEM_INFOMATION *psys )
{
	SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;

    if ( psys->sendrc7017 != SETCMDSERIAL )
         psys->sendrc7017= VALARSERIAL;

	memcpy( &(psys->alarm), pUart->ReceiceBuffer, pUart->ReceiceLength );

	alarm_check_first_status( psdev, psys->alarm[3] );

	alarm_check_local_e1_alarm_status( psdev, psys );
	local_alarm_check_fiber_status( psys->alarm[6] );

	alarm_check_remote_e1_alarm_status( psdev, psys );
	remote_alarm_check_fiber_status( psys->alarm[9] );
}

void alarm_check_remote_e1_loop_status( SYSTEM_DEVICE_STATUS *psdev, SYSTEM_INFOMATION *psys )
{
	BYTE counter;

	for( counter=0; counter<psys->max_system_e1; counter++ )
	{
		psdev->local.e1_status[counter] &= E1_NOLOOP;

		if( ((psys->valar[5]>>counter)&BIT0) )
			psdev->local.e1_status[counter] |= E1_LOOP;
	}
}

void remote_device_type( BYTE status )
{
    SYSTEM_DEVICE_STATUS xdata *psdev = &gsystemStauts;
    BYTE xdata  program_type;

    program_type = (status&7) | 0x80;
    psdev->remote.program = program_type;
}

void serial_valar_command( SERIALSTRUCT *pUart, SYSTEM_INFOMATION *psys )
{
	SYSTEM_DEVICE_STATUS *psdev = &gsystemStauts;
	BYTE *pbuffer;

	pbuffer = pUart->ReceiceBuffer;

    if ( psys->sendrc7017 != SETCMDSERIAL )
         psys->sendrc7017= ALARMSERIAL;

	pbuffer += RC7017_VALAR_ADDRESS;
	memcpy( &(psys->valar), pbuffer, RC7017_VALAR_LENGTH );


	if( !((psys->valar[6])&BIT5) ) 
	{
		psdev->remote.fiber_status[0] &= FIBER_USE;
		psdev->remote.fiber_status[1] |= FIBER_NOUSE;
	}
	else
	{
		psdev->remote.fiber_status[0] |= FIBER_NOUSE;
		psdev->remote.fiber_status[1] &= FIBER_USE;
	}

    if( disable_remote_alarm_status() == ALARM )
        return;

	alarm_check_remote_e1_alarm_status( psdev, psys );
	alarm_check_remote_e1_loop_status( psdev, psys );

    psdev->remote.laser_close[0] = ((~(psys->valar[6]))&BIT3) >>3;
    remote_device_type( psys->valar[7] );
}

BYTE serial_check_error( SERIALSTRUCT *pUart )
{
	BYTE *pbuffer;

	pbuffer = pUart->ReceiceBuffer;

	if( *pbuffer != SYNCHR1_0X7E )
		return ERROR;

	pbuffer ++;
	if( (*pbuffer != SYNCHR2_0X81) && (*pbuffer != SYNCHR2_0X82) )
		return ERROR;

	pbuffer += pUart->ReceiceLength - 2;
	if( *pbuffer != SERIAL_END )
		return ERROR;

	return OK;
}

void process_rc7017_serial( SERIALSTRUCT *pUart, SYSTEM_INFOMATION *psys )
{
	BYTE rc;
	BYTE type;

	if( ( rc = serial_check_error( pUart ) ) == ERROR )
		return;

	type = pUart->ReceiceBuffer[2]&0xc0;
	switch( type )
	{
	case COMMAND_SET:
		serial_set_command( psys );
		break;

	case COMMAND_ALARM:
		serial_alarm_command( pUart, psys );
		break;

	case COMMAND_VALAR:
		serial_valar_command( pUart, psys );
		break;

	default:
		break;
	}
	return;
}

void rc7017_serial_process( SERIALSTRUCT *pUart )
{
	SYSTEM_INFOMATION *psys = &gSystemInfo;

	/*发送数据处理*/
	if( psys->rc7017sendflag == SENDING )
	{
		EncapsulationSendBuffer( pUart, psys );

		emulateStartSend();

		psys->rc7017sendflag = SENDWAIT;
	}

	/*接收数据处理*/
	if( gIoSerial.ReveiveStatus == RECEIVE_OVER )
	{
		process_rc7017_serial( pUart, psys );

		pUart->ReceiceLength = 0;
		pUart->ReveiveStatus = RECEIVE_WAIT;
	}
}

/*对RC7017串口处理函数*/
void task_rc7017_serial_process(void)
{
	SERIALSTRUCT *pUart = &gIoSerial;

	rc7017_serial_process( pUart );
}




#endif