microvfd.c

来自「ESS3890+SL原代码（1*16内存）」· C语言 代码 · 共 1,859 行 · 第 1/3 页

{
    if (!VFDptr) 
      VFD_state_refresh_5();
    else 
      VFD_state_refresh_1();
}

PRIVATE void VFD_state_refresh_1()
{
    unsigned char * refresh_tbl = T_VFD_refresh_tbl;

    RefreshCounter = POPVFD;
    AddrCounter = (int)(RefreshCounter/2);
    if (RefreshCounter & 0x1)
      ShadowCounter = (RefreshCounter - 1);
    else
      ShadowCounter = RefreshCounter;             
    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(refresh_tbl[AddrCounter] | VFD_ADDRESS_MASK);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_refresh_2;
}

PRIVATE void VFD_state_refresh_2()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_objectSendByte(ShadowRam[ShadowCounter++]);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_refresh_3;
}

PRIVATE void VFD_state_refresh_3()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_objectSendByte(ShadowRam[ShadowCounter]);
    SCH_DELAY_AFTER_DATA;
    VFD_next_state = VFD_state_refresh_4;
}

PRIVATE void VFD_state_refresh_4()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_STROBE_INACTIVE;
    VFD_state_refresh_5();
}

PRIVATE void VFD_state_refresh_5()
{
    if (EnableFlashing && (glbTimer > ObjectTime.FlashTime)) {
	ObjectTime.FlashTime = glbTimer + HALF_SECOND;
	flashCalendar();
    }
    VFD_next_state = VFD_state_scan_key_0;
}

#endif /* MN12510 */


#ifdef BU2872
/* By Liang Weihua */
PRIVATE	int	AddrCounter;
PRIVATE	int	ShadowCounter;

/*
 * 2872 requires 
 * 	1) 40us between neighbouring bytes
 *	2) 80us overall for a data byte.
 *	3) 13.3us between end of data and rising of CS#
 */
#define	DELAY_BETWEEN_DATA	MICROSECOND(40)
#define DELAY_AFTER_DATA	MICROSECOND(40)

/************************************************************************
 ********************** State machine for 2872 **************************
 ************************************************************************/
PRIVATE void VFD_state_init()
{
    /*
     * BU2872AK VFD driver only send two bit per send a address,its speed
     * very slow, sending  0 to it in STATE_INIT use time,and it can reset ,
     * so I don't do it!  --- Liang Weihua
     */
    VFD_strobeSendByte(T_VFD_mode[0], DELAY_AFTER_DATA);
    VFD_next_state = VFD_state_scan_key_0;
}

PRIVATE void VFD_state_scan_key_0()
{
    VFD_STROBE_ACTIVE;
    DataLength = KEY_LENGTH;
    VFD_objectSendByte(VFD_READ_KEY);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_scan_key_1;
}

PRIVATE void VFD_state_scan_key_1()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_objectReadByte();
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_scan_key_2;
}

PRIVATE void VFD_state_scan_key_2()
{
    RETURN_BEFORE_SCHEDULED_TIME;

    ObjectKey.KeyBuffer[KEY_LENGTH - DataLength] = ReceivedByte;
    if (--DataLength)
      VFD_state_scan_key_1();
    else {
	VFD_STROBE_INACTIVE;
	VFD_state_scan_key_3();
    }
}

PRIVATE void VFD_state_scan_key_3()
{
    VFD_searchKey();
    VFD_next_state = VFD_state_scan_key_4;
}

PRIVATE void VFD_state_scan_key_4()
{
    VFD_parseKey();
    VFD_next_state = VFD_state_refresh_0;
}

PRIVATE void VFD_state_refresh_0()
{
    if (!VFDptr)
      VFD_state_refresh_5(); 
    else {
	VFD_STROBE_ACTIVE;
	VFD_objectSendByte(T_VFD_mode[0]);
	SCH_DELAY_AFTER_DATA;
	VFD_next_state = VFD_state_refresh_1;
    }
}

PRIVATE void VFD_state_refresh_1()
{
    unsigned char * refresh_tbl;

    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_STROBE_INACTIVE;
    refresh_tbl = T_VFD_refresh_tbl;
    RefreshCounter = POPVFD;
    AddrCounter = (int)(RefreshCounter/2) + 1;
    if (RefreshCounter & 0x1)
      ShadowCounter = RefreshCounter;
    else
      ShadowCounter = (RefreshCounter + 1);

    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(refresh_tbl[AddrCounter] | VFD_ADDRESS_MASK);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_refresh_2;
}

PRIVATE void VFD_state_refresh_2()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_objectSendByte(ShadowRam[ShadowCounter--]);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_refresh_3;
}

PRIVATE void VFD_state_refresh_3()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_objectSendByte(ShadowRam[ShadowCounter]);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_refresh_4;
}

PRIVATE void VFD_state_refresh_4()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_STROBE_INACTIVE;
    VFD_state_refresh_5();
}

PRIVATE void VFD_state_refresh_5()
{
    if (EnableFlashing && (glbTimer > ObjectTime.FlashTime)) {
	ObjectTime.FlashTime = glbTimer + HALF_SECOND;
	flashCalendar();
    }
    VFD_next_state = VFD_state_scan_key_0;
}

#endif /* BU2872 */

#ifdef HT1621
/************************************************************************
 ****************** State machine for 16311 or 16312 ********************
 ************************************************************************/
static ff= 1;
PRIVATE void VFD_state_init()
{
        int i;
        if(ff){
	LCD_objectSendcommand(LCD_SYS_EN);   /* only init one time */
	LCD_objectSendcommand(LCD_LCD_ON);
	LCD_objectSendcommand(LCD_RC_256);
	LCD_objectSendcommand(LCD_IRQ_DIS);
	LCD_objectSendcommand(LCD_BIAS);
           for(i = 0;i <=0x20; i ++){
              LCD_objectSenddata(i,0x00);   /* clear */
          }
          ff = 0;
        }
        VFD_next_state = VFD_state_refresh_0;
}
PRIVATE void VFD_state_refresh_0()
{
    if (!VFDptr)
      VFD_state_refresh_3();
    else {
        VFD_next_state = VFD_state_refresh_1;
    }
}


PRIVATE void VFD_state_refresh_1()
{
    VFD_next_state = VFD_state_refresh_2;
/*    if(tenkey)
         VFD_parseKey();  /* lyt */
}

PRIVATE void VFD_state_refresh_2()
{
    RefreshCounter = POPVFD;
    #ifdef LCD_2DANCE
           LCD_objectSenddata(RefreshCounter*2,ShadowRam[RefreshCounter]);
    #elif defined(LCD_6DANCE)
         LCD_objectSenddata(RefreshCounter,ShadowRam[RefreshCounter]);
    #else
    if(RefreshCounter == 16)
         LCD_objectSenddata(0x0f,ShadowRam[RefreshCounter]);
    else if(RefreshCounter == 17)
         LCD_objectSenddata(0x1d,ShadowRam[RefreshCounter]);
    else
         LCD_objectSenddata(RefreshCounter*2,ShadowRam[RefreshCounter]);
    #endif
    VFD_next_state = VFD_state_refresh_3;
}

#if 1
/*def LCD_6DANCE*/
char wheel_dance = 0;
int wheel_time2;
extern unsigned char cd_opened;
/*extern char initCD_done;*/
int cd_wheelstop;
#endif


unsigned int Wheel_Timer=0;
extern unsigned char cd_opened;
extern int CDinited;
PRIVATE void VFD_state_refresh_3()
{
#ifdef LCD_2DANCE
 static int mode=0;
#endif
#ifdef LCD_6DANCE
 static int mode=0;
#endif

    VFD_next_state = VFD_state_refresh_0;

    if(glbTimer > Wheel_Timer) {
         Wheel_Timer = glbTimer + 10;
             #ifdef LCD_2DANCE
                             mode++;
                             if(mode>11)mode=0;
             #endif
#if defined(LCD_6DANCE)||defined(LCD_DISC)
    if(cd_wheelstop == 2)
          VFD_spin_wheel(VFD_WHEEL_SET_FAN);

     else if((cd_wheelstop == 0)&&(initCD_done==1))
          VFD_spin_wheel(VFD_WHEEL_SPIN);

     else  if((cd_wheelstop == -1)&&(initCD_done==0))
          VFD_spin_wheel(VFD_WHEEL_CLEAR_FAN);
#else
       if((play_state != ENTRY_STATE || !cd_opened)&&(!IS_POWER_DOWN))
          {
          VFD_spin_wheel(2);
          #ifdef LCD_2DANCE
              VFD_dance(mode);
          #endif
          }
         else
          VFD_spin_wheel(0);
#endif
    }

#ifdef LCD_6DANCE
if ((play_state==PLAY_NORMAL_STATE) && (glbTimer >= wheel_time2)) {
	mode++;
	if(mode>11)mode=1;
        wheel_time2 = glbTimer + 15;
        VFD_dance(mode);
    }
#endif
}
void LCD_sendcmd(int cmd)
{
    int i;
     CLR_LCD_CS;
     for(i = 0;i<3;i++)
     {
	lcd_delay();
	CLR_LCD_WR;
        if(cmd & 0x01){
	   SET_LCD_DATA;
	}else{
	   CLR_LCD_DATA;
        }
        cmd>>=1;
        lcd_delay();
	SET_LCD_WR;
     }
}

PRIVATE void LCD_objectSendcommand(int command)
{
    int i,j= 0x01;
    LCD_sendcmd(j);
     j = command;
     for(i = 0;i<8;i++)
     {
	lcd_delay();
	CLR_LCD_WR;
        if(j & 0x80){
	   SET_LCD_DATA;
	}else{
	   CLR_LCD_DATA;
        }
        j<<=1;
        lcd_delay();
	SET_LCD_WR;
     }
     lcd_delay();
     CLR_LCD_WR;
     CLR_LCD_DATA;
     lcd_delay();
     SET_LCD_WR;

   SET_LCD_CS;
}

PRIVATE void LCD_objectSenddata(int address,int data)
{
	char i;
        int command_id = 5;
        LCD_sendcmd(command_id);
        for(i=0; i<6; i++) {
    	   lcd_delay();
    	   CLR_LCD_WR;
           if(address & 0x20) {
    		SET_LCD_DATA;
    	   } else{
    		CLR_LCD_DATA;
           }
     	   lcd_delay();
           address <<= 1;
    	   SET_LCD_WR;
        }
     #ifdef LCD_2DANCE
        for(i=0; i<8; i++) {
     #else
        for(i=0; i<4; i++) {
     #endif
        	lcd_delay();
		CLR_LCD_WR;
                if(data & 0x80) {
			SET_LCD_DATA;
		} else{
			CLR_LCD_DATA;
                }
	        lcd_delay();
	 	SET_LCD_WR;
                data <<= 1;
	}
        SET_LCD_CS;
}
void lcd_delay()
{
   int i;
   for(i=0;i<35;i++) {
    asm("nop");
    asm("nop");
   }
}

#endif /* ht1621 */

#endif /* HOST_SLAVE */

PRIVATE int micro_convert_irkey(int ir_key)
{
    int irKey;
    int newKey;
    char *key_tbl = T_IR_key_tbl;
    
    irKey = ir_key & 0xff;
    
#ifdef IR_PHILIPS
    /* Philips IR */
    newKey = key_tbl[irKey];
#endif /* IR_PHILIPS */


#if (IR_NEC || IR_SANYO)
#ifndef  HOST_SLAVE
    /*
     * By IR_Key_tbl convention, there is no key between 0x20 and 0x3f!
     */
    if (irKey >= 0x40) irKey -= 0x20;

    /* Only assign key if it is defined within the IR_key_table */
    newKey = _NO_KEY;
    if (irKey < T_IR_key_tbl_SZ) newKey = key_tbl[irKey];
#endif /* HOST_SLAVE */        
    newKey = key_tbl[irKey];
#endif /* IR_NEC || IR_SANYO */	 
	
//zty changed
	IMPORT int zoom_level;
	if((newKey == _ZOOM_LEFT_KEY)&&(zoom_level == 0))
		newKey = _ECHO_MINUS;
	if((newKey == _ZOOM_RIGHT_KEY)&&(zoom_level == 0))
		newKey = _ECHO_PLUS;
//

    return (newKey);
}

int micro_is_power_key(int ir_key)
{
    int newKey;
    newKey = micro_convert_irkey(ir_key);
    return(newKey == _POWER_KEY);
}

#ifdef IO3898
#define DSC_status             POW_status
#define DSC_STATUS_RUNNING     POW_STATUS_RUNNING
#endif
int oldTimer;
void microEngine(void)
{

#ifdef TOP_LOADER
		extern int read_door_state(void);
		extern unsigned char cd_opened;
	    int i; 
		i = read_door_state();
		if(((i == 1)&&(cd_opened == 0))||((i == 2)&&(cd_opened != 0)))
		{
			ObjectKey.FireKey = EJECT_KEY;  
			VFD_parseKey();
		}
#endif 


    if (REMOTE_VALID) {
        CLEAR_REMOTE;
	ObjectKey.FireKey = (char) micro_convert_irkey(codeIR);  
	VFD_parseKey();
    }
    
#ifdef HOST_SLAVE
    Slave_Message_Dispatch();
    
#else
#if (defined DSC || defined IO3898)
    if (DSC_status == DSC_STATUS_RUNNING) {
#ifndef HT1621
#ifdef MARANELLO_A9B8
	if(play_state == PLAY_GMBY_STATE) { 
	    VFD_next_state();
	    return;
	}  
#endif /* MARANELLO_A9B8 */
	if (glbTimer <= oldTimer+5  && 
	    (VFD_next_state == VFD_state_scan_key_0) && !VFDptr)
	    return;
	oldTimer = glbTimer;
#if 0 /* according to Weihua, this will interfere with panel key inputs
       * during FF/FR.
       */
	if (VFDptr && (VFD_next_state == VFD_state_scan_key_0)) {
	    VFD_next_state = VFD_state_refresh_0;
	}
#endif
#else HT1621
/*        if (glbTimer <= oldTimer+5  &&
	    (VFD_next_state == VFD_state_refresh_0) && !VFDptr)
	    return;
        oldTimer = glbTimer;  */
	if (VFDptr && (VFD_next_state == VFD_state_refresh_0)) {
	    VFD_next_state = VFD_state_refresh_0;
    }
#endif HT1621
    }
#endif
    
    VFD_next_state();
    
#endif /* HOST_SLAVE */      
}


#ifndef HOST_SLAVE
PRIVATE void VFD_objectReadByte(void)
{
    int i;
    volatile int *ptrDelay = (int *) bank3safe;

    for (i = 0; i < 8; i++) {
#ifdef VFD_RCV_MSB_FIRST
	/* Receive most significant bit first */
        ReceivedByte <<= 1;
        CLEAR_VFD_CLK;
	*ptrDelay;
        SET_VFD_CLK;
	*ptrDelay;
	ReceivedByte &= ~0x01;
        if (VFD_DATA_HIGH) ReceivedByte |= 0x01;
#else
	/* Receive least significant bit first */
        ReceivedByte >>= 1;
        CLEAR_VFD_CLK;
	*ptrDelay;
	ReceivedByte &= ~0x80;
        if (VFD_DATA_HIGH) ReceivedByte |= 0x80;
        SET_VFD_CLK;
	*ptrDelay;
#endif /* VFD_RCV_MSB_FIRST */
    }
    TRISTATE_VFD_DATA;

#ifdef VFD_SHARED_PIN
    TRISTATE_VFD_CLK;
#endif
}

PRIVATE void VFD_objectSendByte(int SendByte)
{
    int i;
    volatile int *ptrDelay = (int *) bank3safe;
 
    for (i = 0;i <8;i++) {
#ifdef VFD_XMIT_MSB_FIRST
	/* Transmit most significant bit first */
        CLEAR_VFD_CLK;
	*ptrDelay;
        if (SendByte & 0x80) {
            SET_VFD_DATA;
        } else {
            CLEAR_VFD_DATA;
        }
        SET_VFD_CLK;
        SendByte <<= 1;
	*ptrDelay;
#else
	/* Transmit least significant bit first */
        CLEAR_VFD_CLK;
	*ptrDelay;
        if (SendByte & 0x01) {
            SET_VFD_DATA;
        } else {
            CLEAR_VFD_DATA;
        }
        SET_VFD_CLK;
        SendByte >>= 1;
	*ptrDelay;
#endif /* VFD_XMIT_MSB_FIRST */
    }
    TRISTATE_VFD_DATA;

#ifdef VFD_SHARED_PIN
    TRISTATE_VFD_CLK;
#endif
}

/*
 * Specify delay in microseconds. Delay can only be used during 
 * initialization.
 */
PRIVATE void VFD_strobeSendByte(int data, int delay)
{
    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(data);
    
    if (delay) {
	if (IS_POWER_DOWN) delay /= IDLEFACTOR;
	risc_sleep_a_bit(delay);
    }
    VFD_STROBE_INACTIVE;
}
#endif /* HOST_SLAVE */

void Waiting_powerkey_up()
{
#ifndef HOST_SLAVE	
    while (KeySearchLock)
#endif  
	microEngine();
}