📄 vfdcore.c
字号:
/**********************************************************************/
/*************** MTK CONFIDENTIAL ****************/
/*************** ****************/
/*************** Description : Vfd Update State ****************/
/*************** Machine ****************/
/*************** ****************/
/*************** Company : MediaTek Inc. ****************/
/*************** Programmer : Sung-Ching Lin ****************/
/**********************************************************************/
#define _VFD_C_
#pragma NOAREGS
#ifndef PC_EMULATION
#include "8032api.h"
#else
#include "emu_api.h"
#endif
#include "..\..\..\vardef.h"
#include ".\vfd\vfd.h"
#include VFD_DATA_H
extern void DRS232LogS(char *pcStr);
extern void DRS232LogB(BYTE bV1, BYTE bV2, BYTE bV3, BYTE bV4);
extern void vSendUopCmd(BYTE bCmd, BYTE bParm1, BYTE bParm2, BYTE bParm3) large;
#ifndef PLAYER_NO_VFD
/* both vfd_data.c and vfd_data.h are auto generated. */
#include ".\vfd\vfd_comm.h"
#include VFD_DATA_C
#include VFD_KEY_C
// *********************************************************************
// NEC 16311/2 command set
// *********************************************************************
#define VFD_ADDRESS_INC 0x40
#define VFD_ADDRESS_FIX 0x44
#define VFD_ADDRESS_MASK 0xc0
#define VFD_READ_KEY 0x42
#define VFD_SW_KEY 0x43
#define VFD_READ_SW 0x43
#ifdef PANEL_VFD_LED
#define VFD_WRITE_LED 0x41
#endif
#define VFD_DISP_MODE_OFF 0
#define VFD_DISP_MODE_DEFAULT 2
#define VFD_DISP_MODE_MAX 3
static code BYTE pbVfdDispCmd[VFD_DISP_MODE_MAX] = {
0x87, 0x8a, 0x8f
};
// *********************************************************************
// VFD Basic Routine
// *********************************************************************
#if !defined(PC_EMULATION)
#define VfdClrStb() { VFD_STB = VFD_LOW; VFD_STB = VFD_LOW; }
#define VfdSetStb() { VFD_STB = VFD_HIGH; VFD_STB = VFD_HIGH; }
#define VfdClrClk() { VFD_CLK = VFD_LOW; VFD_CLK = VFD_LOW; }
#define VfdSetClk() { VFD_CLK = VFD_HIGH; VFD_CLK = VFD_HIGH; }
#define VfdClrDat() { VFD_DATA = VFD_LOW; VFD_DATA = VFD_LOW; }
#define VfdSetDat() { VFD_DATA = VFD_HIGH; VFD_DATA = VFD_HIGH; }
static void VfdSend(BYTE bTmp) large
{
BYTE i;
for (i = 0; i < 8; i++)
{
VfdClrClk();
VFD_DATA = (bTmp & 0x1);
bTmp >>= 1;
VfdSetClk();
}
VfdSetDat();
}
static BYTE VfdRecv(void) large
{
BYTE i, bKeyData;
bKeyData = 0;
for(i = 0; i < 8; i++)
{
VfdSetClk();
bKeyData <<= 1;
VfdClrClk();
/* delay for data output ready */
_nop_(); _nop_(); _nop_();
if (VFD_DATA)
{
bKeyData |= 1;
}
}
return (bKeyData);
}
#else /* for PC_EMULATION */
extern __declspec(dllexport) void VfdClrStb(void);
extern __declspec(dllexport) void VfdSetStb(void);
extern __declspec(dllexport) void VfdSend(BYTE bTmp);
extern __declspec(dllexport) BYTE VfdRecv(void);
#endif /* PC_EMULATION */
// *********************************************************************
// Local Variables
// *********************************************************************
static xdata BYTE _bVfdIdx;
static xdata BYTE _bUpdateIdx;
static xdata BYTE _bVfdBuf;
static xdata BYTE _bVfdKeyBuf;
static xdata BYTE _bVfdDispMode;
#ifdef PANEL_VFD_LED
static xdata BYTE _bVfdLed;
#endif
#ifdef VFD_INIT_STATE_FLASHING
static xdata BYTE _bVfdFlashCnt;
#endif
#ifdef VFD_VOLATILE_MSG
static xdata BYTE _bVfdRestoreCnt;
#endif
#ifdef VFD_USE_TBL_SHADOW
static code WORD wWorkShadowShare[VFD_SHADOW_LEN_MAX] = {
SI_VFD_WORK_SHADOW, SI_VFD_WORK_SHADOW + 1, SI_VFD_WORK_SHADOW + 2, SI_VFD_WORK_SHADOW + 3,
SI_VFD_WORK_SHADOW + 4, SI_VFD_WORK_SHADOW + 5, SI_VFD_WORK_SHADOW + 6, SI_VFD_WORK_SHADOW + 7,
SI_VFD_WORK_SHADOW + 8, SI_VFD_WORK_SHADOW + 9, SI_VFD_WORK_SHADOW + 10, SI_VFD_WORK_SHADOW + 11,
SI_VFD_WORK_SHADOW + 12, SI_VFD_WORK_SHADOW + 13, SI_VFD_WORK_SHADOW + 14, SI_VFD_WORK_SHADOW + 15,
SI_VFD_WORK_SHADOW + 16, SI_VFD_WORK_SHADOW + 17, SI_VFD_WORK_SHADOW + 18, SI_VFD_WORK_SHADOW + 19,
SI_VFD_WORK_SHADOW + 20, SI_VFD_WORK_SHADOW + 21, SI_VFD_WORK_SHADOW + 22, SI_VFD_WORK_SHADOW + 23,
SI_VFD_WORK_SHADOW + 24, SI_VFD_WORK_SHADOW + 25, SI_VFD_WORK_SHADOW + 26, SI_VFD_WORK_SHADOW + 27,
SI_VFD_WORK_SHADOW + 28, SI_VFD_WORK_SHADOW + 29, SI_VFD_WORK_SHADOW + 30, SI_VFD_WORK_SHADOW + 31,
SI_VFD_WORK_SHADOW + 32, SI_VFD_WORK_SHADOW + 33, SI_VFD_WORK_SHADOW + 34, SI_VFD_WORK_SHADOW + 35,
SI_VFD_WORK_SHADOW + 36, SI_VFD_WORK_SHADOW + 37, SI_VFD_WORK_SHADOW + 38, SI_VFD_WORK_SHADOW + 39,
SI_VFD_WORK_SHADOW + 40, SI_VFD_WORK_SHADOW + 41, SI_VFD_WORK_SHADOW + 42, SI_VFD_WORK_SHADOW + 43,
SI_VFD_WORK_SHADOW + 44, SI_VFD_WORK_SHADOW + 45, SI_VFD_WORK_SHADOW + 46, SI_VFD_WORK_SHADOW + 47
};
static code WORD wUpdateShadowShare[VFD_SHADOW_LEN_MAX] = {
SI_VFD_UPDATE_SHADOW, SI_VFD_UPDATE_SHADOW + 1, SI_VFD_UPDATE_SHADOW + 2, SI_VFD_UPDATE_SHADOW + 3,
SI_VFD_UPDATE_SHADOW + 4, SI_VFD_UPDATE_SHADOW + 5, SI_VFD_UPDATE_SHADOW + 6, SI_VFD_UPDATE_SHADOW + 7,
SI_VFD_UPDATE_SHADOW + 8, SI_VFD_UPDATE_SHADOW + 9, SI_VFD_UPDATE_SHADOW + 10, SI_VFD_UPDATE_SHADOW + 11,
SI_VFD_UPDATE_SHADOW + 12, SI_VFD_UPDATE_SHADOW + 13, SI_VFD_UPDATE_SHADOW + 14, SI_VFD_UPDATE_SHADOW + 15,
SI_VFD_UPDATE_SHADOW + 16, SI_VFD_UPDATE_SHADOW + 17, SI_VFD_UPDATE_SHADOW + 18, SI_VFD_UPDATE_SHADOW + 19,
SI_VFD_UPDATE_SHADOW + 20, SI_VFD_UPDATE_SHADOW + 21, SI_VFD_UPDATE_SHADOW + 22, SI_VFD_UPDATE_SHADOW + 23,
SI_VFD_UPDATE_SHADOW + 24, SI_VFD_UPDATE_SHADOW + 25, SI_VFD_UPDATE_SHADOW + 26, SI_VFD_UPDATE_SHADOW + 27,
SI_VFD_UPDATE_SHADOW + 28, SI_VFD_UPDATE_SHADOW + 29, SI_VFD_UPDATE_SHADOW + 30, SI_VFD_UPDATE_SHADOW + 31,
SI_VFD_UPDATE_SHADOW + 32, SI_VFD_UPDATE_SHADOW + 33, SI_VFD_UPDATE_SHADOW + 34, SI_VFD_UPDATE_SHADOW + 35,
SI_VFD_UPDATE_SHADOW + 36, SI_VFD_UPDATE_SHADOW + 37, SI_VFD_UPDATE_SHADOW + 38, SI_VFD_UPDATE_SHADOW + 39,
SI_VFD_UPDATE_SHADOW + 40, SI_VFD_UPDATE_SHADOW + 41, SI_VFD_UPDATE_SHADOW + 42, SI_VFD_UPDATE_SHADOW + 43,
SI_VFD_UPDATE_SHADOW + 44, SI_VFD_UPDATE_SHADOW + 45, SI_VFD_UPDATE_SHADOW + 46, SI_VFD_UPDATE_SHADOW + 47
};
#define VfdWorkShadowRead(i) bSharedInfo(wWorkShadowShare[i])
#define VfdWorkShadowWrite(i,d) vSetSharedInfo(wWorkShadowShare[i],d)
#define VfdUpdateShadowRead(i) bSharedInfo(wUpdateShadowShare[i])
#define VfdUpdateShadowWrite(i,d) vSetSharedInfo(wUpdateShadowShare[i],d)
#ifdef VFD_VOLATILE_MSG
static code WORD wBackupShadowShare[VFD_SHADOW_LEN_MAX] = {
SI_VFD_BACKUP_SHADOW, SI_VFD_BACKUP_SHADOW + 1, SI_VFD_BACKUP_SHADOW + 2, SI_VFD_BACKUP_SHADOW + 3,
SI_VFD_BACKUP_SHADOW + 4, SI_VFD_BACKUP_SHADOW + 5, SI_VFD_BACKUP_SHADOW + 6, SI_VFD_BACKUP_SHADOW + 7,
SI_VFD_BACKUP_SHADOW + 8, SI_VFD_BACKUP_SHADOW + 9, SI_VFD_BACKUP_SHADOW + 10, SI_VFD_BACKUP_SHADOW + 11,
SI_VFD_BACKUP_SHADOW + 12, SI_VFD_BACKUP_SHADOW + 13, SI_VFD_BACKUP_SHADOW + 14, SI_VFD_BACKUP_SHADOW + 15,
SI_VFD_BACKUP_SHADOW + 16, SI_VFD_BACKUP_SHADOW + 17, SI_VFD_BACKUP_SHADOW + 18, SI_VFD_BACKUP_SHADOW + 19,
SI_VFD_BACKUP_SHADOW + 20, SI_VFD_BACKUP_SHADOW + 21, SI_VFD_BACKUP_SHADOW + 22, SI_VFD_BACKUP_SHADOW + 23,
SI_VFD_BACKUP_SHADOW + 24, SI_VFD_BACKUP_SHADOW + 25, SI_VFD_BACKUP_SHADOW + 26, SI_VFD_BACKUP_SHADOW + 27,
SI_VFD_BACKUP_SHADOW + 28, SI_VFD_BACKUP_SHADOW + 29, SI_VFD_BACKUP_SHADOW + 30, SI_VFD_BACKUP_SHADOW + 31,
SI_VFD_BACKUP_SHADOW + 32, SI_VFD_BACKUP_SHADOW + 33, SI_VFD_BACKUP_SHADOW + 34, SI_VFD_BACKUP_SHADOW + 35,
SI_VFD_BACKUP_SHADOW + 36, SI_VFD_BACKUP_SHADOW + 37, SI_VFD_BACKUP_SHADOW + 38, SI_VFD_BACKUP_SHADOW + 39,
SI_VFD_BACKUP_SHADOW + 40, SI_VFD_BACKUP_SHADOW + 41, SI_VFD_BACKUP_SHADOW + 42, SI_VFD_BACKUP_SHADOW + 43,
SI_VFD_BACKUP_SHADOW + 44, SI_VFD_BACKUP_SHADOW + 45, SI_VFD_BACKUP_SHADOW + 46, SI_VFD_BACKUP_SHADOW + 47
};
#define VfdBackupShadowRead(i) bSharedInfo(wBackupShadowShare[i])
#define VfdBackupShadowWrite(i,d) vSetSharedInfo(wBackupShadowShare[i],d)
#endif /* VFD_VOLATILE_MSG */
#else /* not define VFD_USE_TBL_SHADOW */
#define VfdWorkShadowRead(i) bSharedInfo(SI_VFD_WORK_SHADOW + i)
#define VfdWorkShadowWrite(i,d) vSetSharedInfo(SI_VFD_WORK_SHADOW + i,d)
#define VfdUpdateShadowRead(i) bSharedInfo(SI_VFD_UPDATE_SHADOW + i)
#define VfdUpdateShadowWrite(i,d) vSetSharedInfo(SI_VFD_UPDATE_SHADOW + i,d)
#ifdef VFD_VOLATILE_MSG
#define VfdBackupShadowRead(i) bSharedInfo(SI_VFD_BACKUP_SHADOW + i)
#define VfdBackupShadowWrite(i,d) vSetSharedInfo(SI_VFD_BACKUP_SHADOW + i,d)
#endif
#endif /* not define VFD_USE_TBL_SHADOW */
#ifdef VFD_VOLATILE_MSG
static code WORD wBackupIcon[] = {
VFDICON_title,
VFDICON_track,
VFDICON_colonon
};
#define VFD_BACKUP_ICON_SZ TBL_SIZE(wBackupIcon)
#endif /* VFD_VOLATILE_MSG */
// *********************************************************************
// Local Function Prototype
// *********************************************************************
void VfdSetChar(BYTE bSeg, BYTE bCode) large;
void VfdClearAllDirect(void) large;
#ifdef PANEL_VFD_LED
void VfdSetLed(BYTE bLed) large;
#endif
#ifdef VFD_STANDBY_LED
#define VfdStandbyLedOff() VfdSetLed(0xff)
#define VfdStandbyLedOn() VfdSetLed(0x00)
#endif
// *********************************************************************
// Local Defines
// *********************************************************************
#define VFD_LIST_END 0xff
#define VfdStbSend(bData) { VfdClrStb(); VfdSend(bData); VfdSetStb(); }
#define VfdUpdateStart()
#define VfdUpdateStop() (_rVfdFlag.fgVfdChange = TRUE)
#define VfdUpdateByte(a)
/* note the p can not be constant variable */
#define VfdScanList(p) while (*p != VFD_LIST_END) { \
_bVfdBuf = VfdWorkShadowRead(*p); \
_bVfdBuf |= *(p+1); _bVfdBuf &= *(p+2); /* byte no, on, off */ \
VfdWorkShadowWrite(*p, _bVfdBuf); \
VfdUpdateByte(*p); /* Send to VFD's RAM imdediately */ \
p += 3; \
}
#ifdef VFD_VOLATILE_MSG
/* note the p can not be constant variable */
#define VfdScanListBackup(p) while (*p != VFD_LIST_END) { \
_bVfdBuf = VfdBackupShadowRead(*p); \
_bVfdBuf |= *(p+1); _bVfdBuf &= *(p+2); /* byte no, on, off */ \
VfdBackupShadowWrite(*p, _bVfdBuf); \
p += 3; \
}
/* note the p can not be constant variable */
#define VfdBackupSeg(p) while (*p != VFD_LIST_END) { \
_bVfdBuf = VfdWorkShadowRead(*p); \
_bVfdBuf &= ~(*(p+2)); /* byte off inverse only */ \
_bVfdBuf |= VfdBackupShadowRead(*p); \
VfdBackupShadowWrite(*p, _bVfdBuf); \
p += 3; \
}
/* note the p can not be constant variable */
#define VfdBackupIcon(p) while (*p != VFD_LIST_END) { \
_bVfdBuf = VfdWorkShadowRead(*p); \
_bVfdBuf &= *(p+1); /* byte on only */ \
_bVfdBuf |= VfdBackupShadowRead(*p); \
VfdBackupShadowWrite(*p, _bVfdBuf); \
p += 3; \
}
/* note the p can not be constant variable */
#define VfdClearIcon(p) while (*p != VFD_LIST_END) { \
_bVfdBuf = VfdWorkShadowRead(*p); \
_bVfdBuf &= ~(*(p+1)); _bVfdBuf &= *(p+2); /* all off */ \
VfdWorkShadowWrite(*p, _bVfdBuf); \
p += 3; \
}
#endif /* VFD_VOLATILE_MSG */
// *********************************************************************
// VFD State Machine
// *********************************************************************
enum
{
VFD_INIT_STATE,
VFD_SCAN_STATE_0,
VFD_SCAN_STATE_1,
VFD_PARSE_STATE,
VFD_UPDATE_STATE_0,
VFD_UPDATE_STATE_1
};
void VfdInitState(BOOL fgShadow) large;
void VfdScanState0(void) large;
void VfdScanState1(void) large;
void VfdParseState(BOOL fgStandby) large;
void VfdUpdateState0(void) large;
void VfdUpdateState1(void) large;
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void VfdInit(BOOL fgClear, BOOL fgOff)
{
BYTE i;
_bVfdIdx = 0;
_bVfdKey = IR_NONE;
_bVfdKeyBuf = IR_NONE;
_fgVfdKeyValid = FALSE;
#ifdef VFD_VOLATILE_MSG
_rVfdFlag.fgSegBackupOn = FALSE;
_bVfdRestoreCnt = 0;
#endif
_bVfdDispMode = VFD_DISP_MODE_DEFAULT;
#ifdef VFD_INIT_STATE_FLASHING
_bVfdFlashCnt = 0;
#endif
if (fgClear == TRUE) /* if DRAM buffer is available */
{
for (i = 0; i < VFD_SHADOW_LEN; i++)
{
VfdWorkShadowWrite(i, 0);
VfdUpdateShadowWrite(i, 0);
#ifdef VFD_VOLATILE_MSG
VfdBackupShadowWrite(i, 0);
#endif
}
}
#ifdef VFD_STANDBY_LED
if (fgClear == TRUE) /* DRAM available means power on */
{
VfdStandbyLedOff();
}
else
{
VfdStandbyLedOn();
}
#endif /* VFD_STANDBY_LED */
if (fgOff == TRUE)
{
/* for AC power-on, show HELLO ASAP */
if (fgClear == TRUE)
{
VfdClearAllDirect();
#ifdef VFDMSG_hello
VfdMsgDirect(VFDMSG_hello);
#endif
}
else
{
VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_OFF]);
}
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void VfdStop(void) large
{
VfdSetClk();
VfdSetDat();
VfdSetStb();
_bVfdIdx = 0;
_bUpdateIdx = VFD_SHADOW_LEN;
#ifdef VFD_VOLATILE_MSG
_bVfdRestoreCnt = 0;
_rVfdFlag.fgSegBackupOn = FALSE;
#endif
_rVfdFlag.fgVfdKeyLock = FALSE;
_rVfdFlag.fgVfdChange = FALSE;
_rVfdFlag.fgVfdUpdate = FALSE;
_bVfdKey = IR_NONE;
_bVfdKeyBuf = IR_NONE;
_fgVfdKeyValid = FALSE;
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void VfdBright(BYTE bMode) large
{
if (bMode == VFD_DISP_BRIGHT)
{
_bVfdDispMode++;
if (_bVfdDispMode >= VFD_DISP_MODE_MAX)
{
_bVfdDispMode = VFD_DISP_MODE_OFF;
}
}
else if (bMode == VFD_DISP_DARK)
{
if (_bVfdDispMode <= VFD_DISP_MODE_OFF)
{
_bVfdDispMode = VFD_DISP_MODE_MAX - 1;
}
else
{
_bVfdDispMode--;
}
}
else if (bMode == VFD_DISP_RESET)
{
_bVfdDispMode = VFD_DISP_MODE_DEFAULT;
#ifdef VFD_INIT_STATE_FLASHING
_bVfdFlashCnt = 0;
#endif
}
VfdStbSend(pbVfdDispCmd[_bVfdDispMode]);
}
#ifdef PANEL_VFD_LED
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void VfdSetLed(BYTE bLed) large
{
VfdClrStb();
VfdSend(VFD_WRITE_LED);
VfdSend(bLed);
VfdSetStb();
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void VfdLed(BOOL fgLite, BYTE bMask) large
{
if (fgLite)
{
_bVfdLed |= bMask;
}
else
{
_bVfdLed &= (~bMask);
}
}
#endif /* PANEL_VFD_LED */
/************************************************************************
Function : void VfdSetIcon(WORD anode, BYTE lite)
Description : lite on/off anode
Parameter : wNode -> , bLite -> 0/1/2 for off/on/complement
Return : None
************************************************************************/
#if 0
void VfdSetIcon(WORD wNode, BYTE bLite) large
{
BYTE bIndex, bTmp;
BYTE i;
bIndex = ((BYTE *)&wNode)[0];
bTmp = ((BYTE *)&wNode)[1];
_bVfdBuf = VfdWorkShadowRead(bIndex);
if (bLite == 2)
{
_bVfdBuf ^= bTmp;
}
else
{
_bVfdBuf &= ~bTmp;
if(bLite)
{
_bVfdBuf |= bTmp;
}
}
VfdWorkShadowWrite(bIndex, _bVfdBuf);
VfdUpdateStart();
VfdUpdateByte(bIndex);
VfdUpdateStop();
}
#endif
/************************************************************************
Function : void VfdWheel(BYTE bType)
Description : lite on/off, spin wheel
Parameter : 0 for clear all, 1 for set all, 2 for spin
Return : None
************************************************************************/
void VfdWheel(BYTE bType) large
{
#if (VFD_WHEEL_SZ > 0)
static BYTE bWheelPos = 0;
BYTE code *pbList;
BYTE bTest1,bTest2,bTest3,bTest4; //add by Lzh
#ifdef VFD_WHEEL_REVERSE_ROTATE
BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
#endif
#ifdef RS232_LOG
DBGLogS("enter vfdwheel\n");
#endif
if (bType == VFD_WHEEL_ROTATE)
{
#ifdef VFD_WHEEL_REVERSE_ROTATE
if ((bPbcState == SV_FR) || (bPbcState == SV_SR))
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -