microvfd.c

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

/*
 * This routine turns on and off VFD icons.
 *
 * Input
 *	bitmap points to an array which looks like:
 *		index1 index2 0 index3 0
 *	"index1", "index2" ... point to T_VFDINCON_tbl table. 
 *	T_VFDINCON_tbl holds anode position of the corresponding anode.
 *	Those before first 0 are anodes that will be lite up. Those
 *	after first 0 are nodes that will be cleared.
 */
void VFD_icon(unsigned char *bitmap)
{
    unsigned char tmp;
    unsigned int i, index, lite;
    unsigned short anode;

    i = 0;
    lite = 1; /* begin with icons to be turned on */

    while (1) {
	index = bitmap[i++];

	if (!index) { 
	    /* 0 mark the boundary of lite icons and clear icons */
	    if (lite) {
		lite = 0;
		continue;
	    } else return;
	}

	anode = T_VFDICON_tbl[index]; /* icon's anode code */
	VFD_clear_lite_anode(anode, lite);
    }
}

/*
 * Show 7-segment message (6 characters)
 *
 * Input:
 *	Characters are NOT in ASCII. They are represented in 7 segment
 *	format corresponding to a paricular GP grid.
 */
void VFD_msg(unsigned char *msg)
{
    unsigned short *msgptr = (unsigned short *) msg;
    unsigned char *dispptr = T_VFD_msg_position;	/* Display order */
    VFD_CHAR_SEGMENTS * ptr;	/* 7 segment for corresponding character */

    while (*msgptr != CHAR_end) {
	/* Get the 7 segment for the corresponding character position	*/
	ptr = &(((VFD_CHAR_SEGMENTS *) T_VFD_char_segments)[*dispptr++]);
	VFD_set_char(ptr->seg, *msgptr);
	msgptr++;
    }
}

/*
 * Clean 2 7-segment characters.
 *
 * Inputs:
 *	pos:	VFD_TRACK, VFD_MINUTE, VFD_SECOND, VFD_MIN100, VFD_TITLE
 */
void VFD_blank(int pos)
{
#ifndef HOST_SLAVE
    VFD_CHAR_SEGMENTS * ptr;

    ptr = &(((VFD_CHAR_SEGMENTS *) T_VFD_char_segments)[pos]);
    EnableFlashing = 0;
    VFD_set_char(ptr->seg, CHAR_);

    if (pos != VFD_MIN100)	/* Min 100+ only has one character */
      VFD_set_char((ptr+1)->seg, CHAR_);
#endif /*HOST_SLAVE*/
}

/*
 * Turn off the entire VFD.
 */
void VFD_blank_all(void)
{
#ifndef HOST_SLAVE
    unsigned char i;
    EnableFlashing = 0;

    VFDptr = 0;
    for (i = 0; i < SHADOW_LENGTH; i++) {
	ShadowRam[i] = 0;
	VFD_refresh_stack[VFDptr++] = i;
    }
#endif /*HOST_SLAVE*/
}

/*
 * Turn on the entire VFD.
 */
#if NOT_USED
int VFD_fill_all()
{
    unsigned char i;
    EnableFlashing = 0;

    VFDptr = 0;
    for (i = 0; i < SHADOW_LENGTH; i++) {
	ShadowRam[i] = 0xff;
	VFD_refresh_stack[VFDptr++] = i;
    }
}
#endif NOT_USED


#ifndef HOST_SLAVE
volatile int KeySearchLock;
/*===========================================================================*/
PRIVATE void VFD_searchKey(void)
{
    int bitCounter,keyLength,keyCounter,keyInCounter,keyCode;
    char *p,tmp;
    
    p = ObjectKey.KeyBuffer;
    keyLength = KEY_LENGTH;
    keyCounter = keyInCounter = keyCode = 0;

    do {
        for (bitCounter = 0, tmp = *p; bitCounter < 8; bitCounter++) {
            if (tmp & 0x01) {
                keyInCounter++;
                keyCode = keyCounter;
            }
            keyCounter++;
            tmp >>= 1;
        }
        *p++;
    } while (--keyLength);

    ObjectKey.FireKey = -1;
    if (keyInCounter) {
        if (keyInCounter == 1 && !KeySearchLock) {
	    unsigned char * key_tbl = T_VFD_key_tbl;

	    KeySearchLock = 1;
            ObjectKey.FireKey = key_tbl[keyCode];
	}
    } else KeySearchLock = 0;
}

/*===========================================================================*/
int ReceivedByte = 0;

#if defined(D16311) || defined(D16312)
/************************************************************************
 ********************** State machine for 16311 or 16312 ****************
 ************************************************************************/
PRIVATE void VFD_state_init()
{
    VFD_strobeSendByte(T_VFD_mode[0], 0);
    VFD_strobeSendByte(VFD_DUTY_CYCLE, 0);
    VFD_strobeSendByte(VFD_ADDRESS_INC, 0);
    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(VFD_ADDRESS_MASK | 0x00);
    DataLength = SHADOW_LENGTH;
    while (--DataLength)
	VFD_objectSendByte(0x00);
    VFD_STROBE_INACTIVE;

    VFD_next_state = VFD_state_scan_key_0;
}


#ifdef MARANELLO_A9B8
/*
 * The following function will deal with VFD key scan
 * while playing game at share VFD_STB and VFD_CLK with
 * GAME_LATCH and GAME_CLK.
 * By zhyf 2005-3-31 10:17
 */
char VFD_game_scan_state=0;
char Data_l=0;
int  VFD_game_scankey()
{
    int scan_cnt, bit_cnt, tmp, key;
    unsigned char *vfdkey_tbl = T_VFD_key_tbl;
    

    switch(VFD_game_scan_state){	
    case 0:   
        CLEAR_VFD_STROBE;
        Data_l = 3;
        //tmp_key = EJECT_KEY;
        //for(scan_cnt=0;scan_cnt<3;scan_cnt++)
	// ObjectKey.KeyBuffer[scan_cnt]=0;
        VFD_objectSendByte(VFD_READ_KEY);
        VFD_game_scan_state = 1;
	//   OUTOSD(1,"","SCAN0",2);
        break;
    case 1:
        VFD_objectReadByte();
        VFD_game_scan_state = 2;
        //OUTOSD(4,"","SCAN1",2);
        break;
    case 2:
        //OUTOSD(7,"","SCAN2",2);
        ObjectKey.KeyBuffer[3 - Data_l] = ReceivedByte;
        if (--Data_l){
	    VFD_game_scan_state = 1;
	    //break;
        } else { 
	    VFD_game_scan_state = 3; 
	    SET_VFD_STROBE;
	}
	break;
    case 3:
	key = 0;
        for (tmp=0; tmp<3; tmp++) {
	    if (key = ObjectKey.KeyBuffer[tmp]) break;
	}

	for (bit_cnt=0; bit_cnt<8; bit_cnt++) {
	    if (ptrLshift[bit_cnt] == key) {
		scan_cnt = 8*tmp + bit_cnt; /* keyCode */
		ObjectKey.FireKey = vfdkey_tbl[scan_cnt];
		VFD_game_scan_state = 4;
		return (0);
	    }
	}
	VFD_game_scan_state = 5;   

        //OUTOSD(10,"","SCAN3",2);  
        break;
    case 4:
        key = ObjectKey.FireKey | 0xff00; /* STOP/EJECT are function keys */
	if ((key == STOP_KEY) || (key == EJECT_KEY)) {
	    put_keycode(key);
	    preprocess_function_key(key);
	}

        ObjectKey.FireKey= NO_KEY;
        VFD_game_scan_state = 0; 
        return 1; 
        //break;   
    default:
        VFD_game_scan_state = 0; 
        return 0;
        //break;     
    }
}
#endif /* MARANELLO_A9B8 */

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


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

PRIVATE void VFD_state_scan_key_2()
{
    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()
{
#if 0
    unsigned char tmpKey;
    if (REMOTE_VALID) {
	char * key_tbl =(char *) T_IR_key_tbl;
	
	CLEAR_REMOTE;
	if (REMOTE_KEY > 0x20)
	    tmpKey = key_tbl[REMOTE_KEY - 0x20];
	else
	    tmpKey = key_tbl[REMOTE_KEY];
	if (ObjectKey.FireKey != tmpKey) {
	    ObjectKey.FireKey = tmpKey;
	    VFD_parseKey();
	}
    }
    else 
#endif
	VFD_parseKey();
    
#ifdef MARANELLO_A9B8
    if(play_state == PLAY_GMBY_STATE) { 
	VFD_next_state = VFD_state_scan_key_0;
	//VFDptr = 0;
    } else   
#endif     
    {
	VFD_next_state = VFD_state_refresh_0;
    }
}

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

PRIVATE void VFD_state_refresh_1()
{
    VFD_strobeSendByte(VFD_DUTY_CYCLE, 0);
    VFD_next_state = VFD_state_refresh_2;
}

PRIVATE void VFD_state_refresh_2()
{
    VFD_strobeSendByte(VFD_ADDRESS_FIX, 0);
    VFD_next_state = VFD_state_refresh_3;
}

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

    RefreshCounter = POPVFD;
    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(refresh_tbl[RefreshCounter] | VFD_ADDRESS_MASK);
    VFD_next_state = VFD_state_refresh_4;
}

PRIVATE void VFD_state_refresh_4()
{
    VFD_objectSendByte(ShadowRam[RefreshCounter]);
    VFD_STROBE_INACTIVE;
    VFD_next_state = 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 /* D16311 || D16312 */


#ifdef DSTC6311
#define	DELAY_BETWEEN_DATA	MICROSECOND(20)
#define DELAY_AFTER_DATA	MICROSECOND(20)

/************************************************************************
 ****************** State machine for DSTC6311 **************************
 ************************************************************************/
PRIVATE void VFD_state_init()
{
    volatile int *ptrDelay = (int *) bank3safe;
    int between_delay, after_delay;

    between_delay = DELAY_BETWEEN_DATA;
    after_delay   = DELAY_AFTER_DATA;
    if (IS_POWER_DOWN) {
	between_delay /= IDLEFACTOR;
	after_delay   /= IDLEFACTOR;
    }

    VFD_strobeSendByte(T_VFD_mode[0],   DELAY_AFTER_DATA);
    *ptrDelay; *ptrDelay;
    VFD_strobeSendByte(VFD_DUTY_CYCLE,  DELAY_AFTER_DATA);
    *ptrDelay; *ptrDelay;
    VFD_strobeSendByte(VFD_ADDRESS_INC, DELAY_AFTER_DATA);

    *ptrDelay; *ptrDelay;
    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(VFD_ADDRESS_MASK | 0x00);
    DataLength = SHADOW_LENGTH;
    while (--DataLength){
	risc_sleep_a_bit(between_delay);
	VFD_objectSendByte(0x00);
    }
    risc_sleep_a_bit(after_delay);
    VFD_STROBE_INACTIVE;

    *ptrDelay; *ptrDelay;
    VFD_strobeSendByte(VFD_ADDRESS_FIX, 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()
{
    volatile int *ptrDelay = (int *) bank3safe;

    RETURN_BEFORE_SCHEDULED_TIME;

    VFD_STROBE_INACTIVE;
    *ptrDelay; *ptrDelay;
    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(VFD_ADDRESS_FIX);
    SCH_DELAY_AFTER_DATA;
    VFD_next_state = VFD_state_refresh_2;
}

PRIVATE void VFD_state_refresh_2()
{
    unsigned char * refresh_tbl;
    volatile int *ptrDelay = (int *) bank3safe;


    RETURN_BEFORE_SCHEDULED_TIME;

    VFD_STROBE_INACTIVE;

    *ptrDelay; *ptrDelay;
    VFD_STROBE_ACTIVE;
    refresh_tbl = T_VFD_refresh_tbl;
    RefreshCounter = POPVFD;
    VFD_objectSendByte(refresh_tbl[RefreshCounter] | VFD_ADDRESS_MASK);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_refresh_3;
}

PRIVATE void VFD_state_refresh_3()
{
    RETURN_BEFORE_SCHEDULED_TIME;

    VFD_objectSendByte(ShadowRam[RefreshCounter]);
    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 /* DSTC6311 */

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

/*
 * 12510 requires some delays bewteen data and after data.
 */
#define	DELAY_BETWEEN_DATA	MICROSECOND(5)
#define DELAY_AFTER_DATA	MICROSECOND(5)

/************************************************************************
 ********************** State machine for 12510 *************************
 ************************************************************************/
PRIVATE void VFD_state_init()
{
/*  STATE_INIT is too long,and it can reset by itself,so I don't send 0 to it
                  --- Liang Weihua */
    int i;
    volatile int *ptrDelay = (int *) bank3safe;
    unsigned char *cmd = T_VFD_12510_cmd;
    unsigned char *dat = T_VFD_12510_dat;
    int between_delay, after_delay;

    between_delay = DELAY_BETWEEN_DATA;
    after_delay   = DELAY_AFTER_DATA;
    if (IS_POWER_DOWN) {
	between_delay /= IDLEFACTOR;
	after_delay   /= IDLEFACTOR;
    }
    for (i = 0; i < T_VFD_12510_cmd_SZ; i++) {
	VFD_STROBE_ACTIVE;
	VFD_objectSendByte(cmd[i]);
	risc_sleep_a_bit(between_delay); /* OK to wait in init. */
	VFD_objectSendByte(dat[i]);
	risc_sleep_a_bit(after_delay);   /* OK to wait in init. */
	VFD_STROBE_INACTIVE;
	*ptrDelay; *ptrDelay;	/* Requires delay between strobes	*/
    }

    VFD_next_state = VFD_state_scan_key_0;
}

PRIVATE void VFD_state_scan_key_0()
{
    DataLength = KEY_LENGTH;
    ReadKey = 0x60;
    VFD_state_scan_key_1();
}

PRIVATE void VFD_state_scan_key_1()
{
    VFD_STROBE_ACTIVE;
    VFD_objectSendByte(ReadKey++);
    SCH_DELAY_BETWEEN_DATA;
    VFD_next_state = VFD_state_scan_key_2;
}

PRIVATE void VFD_state_scan_key_2()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_objectReadByte();
    SCH_DELAY_BETWEEN_DATA;
    ObjectKey.KeyBuffer[KEY_LENGTH - DataLength] = ReceivedByte;
    --DataLength;
    VFD_next_state = VFD_state_scan_key_3;
}

PRIVATE void VFD_state_scan_key_3()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_objectReadByte();
    SCH_DELAY_AFTER_DATA;
    ObjectKey.KeyBuffer[KEY_LENGTH - DataLength] = ReceivedByte;
    VFD_next_state = VFD_state_scan_key_4;
}

PRIVATE void VFD_state_scan_key_4()
{
    RETURN_BEFORE_SCHEDULED_TIME;
    VFD_STROBE_INACTIVE;
    if (--DataLength)
      VFD_next_state = VFD_state_scan_key_1;
    else {
	VFD_searchKey();
	VFD_next_state = VFD_state_scan_key_5;
    }
}

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

PRIVATE void VFD_state_refresh_0()