menuprocess_dopt.c

pdh控制程序

    flash_status = flash_time(  );

    for( endcouter=LACAL_EQU; endcouter<=REMOTE_EQU; endcouter++ )
    {
        for( e1counter=0; e1counter<psys->max_system_e1; e1counter++ )
        {
			if( endcouter == LACAL_EQU )
				status = (psdev->local.e1_status[e1counter-1]&(~E1_NOLOOP))>>2;
			else
				status = (psdev->remote.e1_status[e1counter-1]&(~E1_NOLOOP))>>2;
            switch( status )
            {
            case IDB_E1_LOOP:
                loop[endcouter-1] = IDB_E1_LOOP;
                continue;
                break;
    
            case IDB_E1_NOLOOP:
                break;
            }
        }
    }

    if( loop[1] == IDB_E1_LOOP )
        last_status = flash_status;
    else
        last_status = SHOW_CHAR_STATUS;
    flash_char_status( &pbuffer[1], "Local", last_status, 5 );
    LcdDisplay_length( ROW_2, CHAR_0, pbuffer, 6 );

    if( loop[0] == IDB_E1_LOOP )
        last_status = flash_status;
    else
        last_status = SHOW_CHAR_STATUS;
    flash_char_status( &pbuffer[8], "Remote", last_status, 6 );
    LcdDisplay_length( ROW_2, CHAR_8, &pbuffer[8], 6 );

    if(  psys->set_value == 1 )
        list_char = 14;
	diaplay_char( ROW_2, list_char, LCD_PRINT_TRIANGLE );
	if( list_char == 6 )
		LcdDisplay_length( ROW_2, CHAR_14, rownull, 1 );
	else
		LcdDisplay_length( ROW_2, CHAR_6, rownull, 1 );
}

BYTE menu_2_loop_set( BYTE FlashLcd )
{
    SYSTEM_INFOMATION xdata *psys = &gSystemInfo;
    BYTE xdata buffer[2][LCD_MAX_CASE];

    KeyPro.keyEnter = key_go_next;
    KeyPro.keyLeft = menu_set_left;
    KeyPro.keyRight = menu_set_rigth;
    KeyPro.keyCanncel = menu_1_preview;
    memcpy( &buffer[0][0], rownull, LCD_MAX_CASE );
    memcpy( &buffer[1][0], rownull, LCD_MAX_CASE );

    if( FlashLcd == FLASH_SCREEN )
    {
        psys->set_value = 0;
		LcdDisplay_length( ROW_2, CHAR_0, &buffer[1][0], LCD_MAX_CASE );
    }
    psys->e1_number = 1;


    memcpy( &buffer[0][0], "  E1 loop set  ", LCD_LAST_CASE );
    LcdDisplay_length( ROW_1, CHAR_0, &buffer[0][0], LCD_LAST_CASE );

    get_loop_status( &buffer[1][0], psys );

    return key_process_status( &KeyPro );
}


BYTE menu_sys_show( BYTE *pbuffer , BYTE FlashLcd )
{
    KeyPro.keyEnter = key_go_next;
    KeyPro.keyLeft = menu_1_left;
    KeyPro.keyRight = menu_1_right;
    KeyPro.keyCanncel = menu_1_preview;

    if( FlashLcd == FLASH_SCREEN )
    {
        LcdDisplay_length( ROW_1, CHAR_0, "   System set   ", LCD_LAST_CASE );
        LcdDisplay_length( ROW_2, CHAR_0, rownull, LCD_LAST_CASE );
    }
    else
    {
        LcdDisplay_length( ROW_2, CHAR_0, pbuffer, LCD_LAST_CASE );
    }

    return key_process_status( &KeyPro );
}

void ConstrastSet( BYTE value )
{
	static BYTE xdata  static_contrast_value = 50;

    if( static_contrast_value >= value )
        wiperDown( CONTRAST_VALUE*(static_contrast_value - value) );
    else
        wiperUp( CONTRAST_VALUE*(value - static_contrast_value) );
	static_contrast_value = value;
}

BYTE menu_contrast_set_rigth( void )
{
   SYSTEM_INFOMATION xdata *psys = &gSystemInfo;

   if( psys->preview_contrast_value > 0  )
   {
        psys->preview_contrast_value --;
		SetSystemConstrast( psys->preview_contrast_value );
   }
    return NOCHANGE_MENU;
}

BYTE menu_contrast_set_left( void )
{
   SYSTEM_INFOMATION xdata *psys = &gSystemInfo;

   if( psys->preview_contrast_value < LCD_LAST_CASE  )
   {
        psys->preview_contrast_value ++;
		SetSystemConstrast( psys->preview_contrast_value );
   }
    return NOCHANGE_MENU;
}

BYTE menu_contrast_set_entry( void )
{
    SYSTEM_INFOMATION xdata *psys = &gSystemInfo;

    noStorReturn();

    gSystemInfo.contrast_value = psys->preview_contrast_value;

	SetSystemConstrast( psys->preview_contrast_value );
	save_constrast_set( psys->preview_contrast_value );

    return PREVIEW_MENU;
}

BYTE menu_contrast_set_cancel( void )
{
    SYSTEM_INFOMATION xdata *psys = &gSystemInfo;

	SetSystemConstrast( psys->contrast_value );

    return PREVIEW_MENU;
}

BYTE menu_system_3_contrast_set( BYTE FlashLcd )
{
    SYSTEM_INFOMATION xdata *psys = &gSystemInfo;
    BYTE xdata buffer[2][LCD_MAX_CASE];
    BYTE counter;

    KeyPro.keyEnter = menu_contrast_set_entry;
    KeyPro.keyLeft = menu_contrast_set_left;
    KeyPro.keyRight = menu_contrast_set_rigth;
    KeyPro.keyCanncel = menu_contrast_set_cancel;

    memcpy( &buffer[0][0], rownull, LCD_LAST_CASE );
    memcpy( &buffer[1][0], rownull, LCD_LAST_CASE );

    if( FlashLcd == FLASH_SCREEN )
        psys->preview_contrast_value = psys->contrast_value;

    memcpy( &buffer[0][0], "  Contrast set ", LCD_LAST_CASE );
    LcdDisplay_length( ROW_1, CHAR_0, &buffer[0][0], LCD_LAST_CASE );

    for( counter=0; counter<psys->preview_contrast_value; counter++ )
        diaplay_char( ROW_2, counter, DISPLAY_ASTERISK );

    LcdDisplay_length( ROW_2, psys->preview_contrast_value, rownull, LCD_MAX_CASE-psys->preview_contrast_value );

    return key_process_status( &KeyPro );
}

BYTE menu_system_contrast_set( BYTE FlashLcd )
{
    return menu_sys_show( "  Contrast set ", FlashLcd );
}

BYTE menu_system_reboot_system_set( BYTE FlashLcd )
{
    return menu_sys_show( " Reboot system ", FlashLcd );
}

BYTE menu_reboot_yes_no( void )
{
    SYSTEM_INFOMATION *psys = &gSystemInfo;

    if( psys->yes_no == SET_YES )
    {
		system_watchdog( SYSTEM_REBOOT );
		((void(code *)(void))0x0000)();
    }
    return PREVIEW_MENU;
}

BYTE menu_system_3_reboot_set( BYTE FlashLcd )
{
    BYTE xdata buffer[2][LCD_MAX_CASE];
    SYSTEM_INFOMATION xdata *psys = &gSystemInfo;

    KeyPro.keyEnter = menu_reboot_yes_no;
    KeyPro.keyLeft = menu_yes_no_left;
    KeyPro.keyRight = menu_yes_no_rigth;
    KeyPro.keyCanncel = menu_1_preview;

    memcpy( &buffer[0][0], rownull, LCD_LAST_CASE );
    memcpy( &buffer[1][0], rownull, LCD_LAST_CASE );

    if( FlashLcd == FLASH_SCREEN )
	{
        LcdDisplay_length( ROW_1, CHAR_0, rownull, LCD_LAST_CASE );
        LcdDisplay_length( ROW_2, CHAR_0, rownull, LCD_LAST_CASE );
	}
    memcpy( &buffer[0][0], "   Reboot set   ", LCD_MAX_CASE );
    LcdDisplay_length( ROW_1, CHAR_0, &buffer[0][0], LCD_LAST_CASE );

    yes_no_display( FlashLcd, psys );

    return key_process_status( &KeyPro );
}

BYTE menu_1_system_set( BYTE FlashLcd )
{
    return menu_main_show( "   System set   ", FlashLcd );
}

BYTE key_process_status( KEY_STATUS_PROCESS *pkey )
{
    BYTE status, key_value;

    key_value = get_menu_key();

    switch( key_value )
    {
    case PRESS_ENTER:
        status = pkey->keyEnter(  );
        break;

    case PRESS_LEFT:
        status = pkey->keyLeft(  );
        break;

    case PRESS_RIGHT:
        status = pkey->keyRight(  );
        break;

    case PRESS_CANNCEL:
        status = pkey->keyCanncel(  );
        break;

    case PRESS_NONE:
    default:
        status = NOCHANGE_MENU;
        break;
	}

    return status;
}

void menuInfo_process( void )
{
    if( menuInfo.menuBack == BACK_LIGHT_SHOW )
    {
        gSystemInfo.back_light_time = ( gSystemInfo.back_light_time + 1)%60;
        if( !gSystemInfo.back_light_time )
        {
            menuInfo.menuBack = BACK_LIGHT_DESTROY;
			gSystemInfo.system_type = 0xaa;
			get_system_type_init_menu();
        }
    }
}

void initial_menu( void )
{
    InitLcd();
    menuInfo.menuBack = BACK_LIGHT_SHOW;

	get_system_type_init_menu();
}

void init_menu_type( BYTE program_type )
{
	BYTE type;
	MENU *pusemenu = &menu_head_dam[1];

	type = program_type&(~BIT7);
	switch( type )
	{
	case TYPE_SIGLE_NOALS_MENU:
	case TYPE_SIGLE_NOALS_NOMENU:
		pusemenu = &menu_head_snm[1];
		break;

	case TYPE_DOUBLE_NOALS_MENU:
	case TYPE_DOUBLE_NOALS_NOMENU:
		pusemenu = &menu_head_dnm[1];
		break;

	case TYPE_SIGLE_ALS_MENU:
	case TYPE_SIGLE_ALS_NOMENU:
		pusemenu = &menu_head_sam[1];
		break;

	case TYPE_DOUBLE_ALS_MENU:
	case TYPE_DOUBLE_ALS_NOMENU:
		pusemenu = &menu_head_dam[1];
		break;
	}

    meunInit( pusemenu, scrol_control, backlight_control);
}

void get_system_type_init_menu( void )
{
	SYSTEM_DEVICE_STATUS xdata *psdev = &gsystemStauts;
    SYSTEM_INFOMATION xdata *psys = &gSystemInfo;
	BYTE type;

	type = ReadChip( SYSTEM_BOARD_TYPE_ADDR );

	if( psys->system_type != type )
	{
		psys->system_type = type;
		psdev->local.program = type&BOARD_TYPE;
		psdev->remote.program = type&BOARD_TYPE;

		if( type & BIT3 )
		{
		    psys->max_system_e1 = MAX_E1_NOMBER_08J;
		    psdev->local.device_type = SYSTEM_DEVICE_TYPE_08J;
		    psys->pdevice = device_type[GF34_08J];
		}
		else
		{
		    psys->max_system_e1 = MAX_E1_NOMBER_06J;
		    psdev->local.device_type = SYSTEM_DEVICE_TYPE_06J;
		    psys->pdevice = device_type[GF8_06J];
		}
		init_menu_type( psdev->local.program );
		psdev->remote.device_type =  psdev->local.device_type;
	}
}

#endif

void task_menu( void )
{
	#if _LCD_MENU_
		if( menu_process_flag )
		{
			menu_process_flag = disable;
			MenuProcess();
		}

		if( menu_init_flag )
		{
			menu_init_flag = disable;
			menuInfo_process();
		}
	#endif
}

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

    return psdev->local.fiber_status[fiber]&FIBER_ALARM_STATUS;
}

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

    return psdev->remote.fiber_status[fiber]&FIBER_ALARM_STATUS;
}

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

    if( psdev->local.program&BIT0 )
    {
        fiber = get_use_fiber( psdev->local.fiber_status );
        if(gSystemInfo.remote_fiber_status[fiber] == ALARM)
            return ALARM;
        for( fiber=0; fiber<B_FIBER; fiber++ )
        {
            if( !(psdev->local.fiber_status[fiber]&FIBER_NOUSE)  )
            {
                if( ((psdev->local.fiber_status[fiber]&FIBER_ALARM_STATUS) == FIBER_LOS)
                     || ((psdev->local.fiber_status[fiber]&FIBER_ALARM_STATUS) == FIBER_LFA))
                    return ALARM;
                return NOALARM;
            }
        }
    }
    else
    {
        if( gSystemInfo.remote_fiber_status[0] == ALARM )
			return ALARM;
        if( ((psdev->local.fiber_status[0]&FIBER_ALARM_STATUS) == FIBER_LOS)
		|| ((psdev->local.fiber_status[0]&FIBER_ALARM_STATUS) == FIBER_LFA))
			return ALARM;
        return NOALARM;
    }
    return NOALARM;
}



#endif