realclk.c

来自「一个两碟控制的VCD的代码,两碟之间的转动及连续播放,已大量生产的CODE.」· C语言 代码 · 共 233 行

/* Copyright 1997, ESS Technology, Inc.					*/
/* SCCSID @(#)realclk.c	1.1 9/4/97 */

/*
 * $Log$
 */


#ifdef REAL_CLOCK

#include    "const.h"
#include    "dsa.h"
#include    "util.h"
#include    "micro.h"
#include    "fsosd.h"
#include    "panelcmd.h"
#include    "realclk.h"

static int KeyState;
static int ClkArg;
static int DigitState;
static int ClkCopy;

/*===========================================================================*/
void realClkDisplay(int arg)
{
    if ((ClkArg = arg) != REAL_CLK_ON)
        DigitState = 0;
}
/*===========================================================================*/
/* return 0: FAIL                                                            */
/* return non zero: SUCESS                                                   */
int realClkAdjust(int num)
{
    unsigned int tmpClk;
    unsigned short hour,min;
    int		ret_value;

    ret_value = REAL_CLK_FAIL;
    tmpClk = *RISC_ptr_realtime;
    hour = (unsigned short)((tmpClk & 0x00ff0000) >> 16);
    min = (unsigned short)((tmpClk & 0x0000ff00) >> 8);
    if (hour > 23) {
        hour = 0;
        *RISC_ptr_realtime &= 0x0000ffff;
    }

    if (min > 59) {
        min = 0;
        *RISC_ptr_realtime &= 0x00ff00ff;
    }
    hour = hex2bcd[hour];
    min = hex2bcd[min];

    switch (KeyState) {
        case 0x00:                  /* higher digit of hour */
            if (num <= 2)
            {
                DigitState = 0x01;
                hour = (hour & 0x0f) | (unsigned short)((num & 0x0f) << 4);
                if (hour > 0x23)
                    hour = 0x20;
                *RISC_ptr_realtime = (tmpClk & 0x0000ffff) |
                 ((((unsigned int)(bcd2hex[hour])) << 16) & 0x00ff0000);
                KeyState++;
            }
        break;

        case 0x01:                  /* lower digit of hour */
            if ((hour & 0xf0) > 0x10) {
                if (num <= 3)
                {
                    DigitState = 0x02;
                    hour = (hour & 0xf0) | (unsigned short)(num & 0x0f);
                    *RISC_ptr_realtime = (tmpClk & 0x0000ffff) |
                    ((((unsigned int)(bcd2hex[hour])) << 16) & 0x00ff0000);
                    KeyState++;
                }
            }
            else if (num < 10) {
                DigitState = 0x02;
                hour = (hour & 0xf0) | (unsigned short)(num & 0x0f);
                *RISC_ptr_realtime = (tmpClk & 0x0000ffff) |
                 ((((unsigned int)(bcd2hex[hour])) << 16) & 0x00ff0000);
                KeyState++;
            }

        break;

        case 0x02:                  /* higher digit of min */
            if (num <= 5)
            {
                DigitState = 0x03;
                min = (min & 0x0f) | (unsigned short)((num & 0x0f) << 4);
                *RISC_ptr_realtime = (tmpClk & 0x00ff00ff) |
                 ((((unsigned int)(bcd2hex[min])) << 8) & 0x0000ff00);
                KeyState++;
            }
        break;

        case 0x03:                  /* lower digit of min */
            if (num < 10) {
                DigitState = 0x04;
                min = (min & 0xf0) | (unsigned short)(num & 0x0f);
                *RISC_ptr_realtime = (tmpClk & 0x00ff00ff) |
                 ((((unsigned int)(bcd2hex[min])) << 8) & 0x0000ff00);
                KeyState = 0;
                ret_value = REAL_CLK_OK;
            }
        break;

    }

    realClkTick();
    return (ret_value);
}

/*===========================================================================*/
char PM = 0;
char ClockMode = 1;              /* 1: 24 hours mode, 0: 12 hours */
unsigned char clock_buf[] = " CLOCK   :  ";

#define CLOCK_HOUR_POS  7
#define CLOCK_COLON_POS 9
#define CLOCK_MIN_POS   (CLOCK_HOUR_POS + 3)

void realClkTick(void)
{
    unsigned int tmpClk;
    unsigned short hour,min;
    unsigned char *msg_ptr;
    unsigned int toggleFlag;
#ifdef BILINGUAL_OSD
    unsigned char *c_msg_ptr;
#endif

    tmpClk = *RISC_ptr_realtime;
    assign_osd_msg(msg_ptr, clock_buf, c_msg_ptr, c_clock_buf);


    hour = hex2bcd[(unsigned short)((tmpClk & 0x00ff0000) >> 16)];
    msg_ptr[CLOCK_HOUR_POS] = '0' + ((hour & 0xf0) >> 4);
    msg_ptr[CLOCK_HOUR_POS+1] = '0'+ (hour & 0x0f);

    min = hex2bcd[(unsigned short)((tmpClk & 0x0000ff00) >> 8)];
    msg_ptr[CLOCK_MIN_POS] = '0' + ((min & 0xf0) >> 4);
    msg_ptr[CLOCK_MIN_POS+1] = '0' + (min & 0x0f);


    if (tmpClk & 0x01)
        toggleFlag = 1;
    else
        toggleFlag = 0;

    if (ClkArg == REAL_CLK_ON) {
        OUTOSD(CLOCK_REGION, msg_ptr, c_msg_ptr, 0);
        DigitState = 0x05;
    }

    switch (DigitState) {
        case 0x00:
            if (toggleFlag)
                msg_ptr[CLOCK_HOUR_POS] = '_';
        break;

        case 0x01:                      /* higher digit of hour */
            msg_ptr[CLOCK_HOUR_POS] = '0' + ((hour & 0xf0) >> 4);
            if (toggleFlag)
                msg_ptr[CLOCK_HOUR_POS + 1] = '_';
        break;

        case 0x02:                      /* lower digit of hour */
            msg_ptr[CLOCK_HOUR_POS+1] = '0'+ (hour & 0x0f);
            if (toggleFlag)
                msg_ptr[CLOCK_MIN_POS] = '_';
        break;

        case 0x03:                      /* higher digit of minute */
            msg_ptr[CLOCK_MIN_POS] = '0' + ((min & 0xf0) >> 4);
            if (toggleFlag)
                msg_ptr[CLOCK_MIN_POS + 1] = '_';
        break;

        case 0x04:                      /* lower digit of minute */
            msg_ptr[CLOCK_MIN_POS+1] = '0' + (min & 0x0f);
            DigitState = 0;
            ClkArg = REAL_CLK_OFF;
	    OUTOSD(CLOCK_REGION, msg_ptr, c_msg_ptr, 2);
        break;

        case 0x05:                      /* flash colon when the clock is on */
            clock_buf[CLOCK_COLON_POS] = ':';
            if (toggleFlag)
                clock_buf[CLOCK_COLON_POS] = ' ';
        break;
    }

    if (ClkArg != REAL_CLK_OFF) {
	OUTOSD(CLOCK_REGION, msg_ptr, c_msg_ptr, 2);
    }
}

/*===========================================================================*/
#define MINUTE_HIGH             0x0a
#define MINUTE_LOW              0x08
#define SECOND_HIGH             0x06
#define SECOND_LOW              0x04
void realClkVFD(void)
{
    unsigned int tmpClk;
    unsigned int hour;

    tmpClk = *RISC_ptr_realtime;
    if ((ClkCopy & 0x1) ^ (tmpClk & 0x01)) {
	/* only do this every 1/2 second. */
	ClkCopy = tmpClk;

        addMicroRing(PANEL_MIN |
            hex2bcd[(unsigned short)((tmpClk >> 16) & 0xff)]);
        addMicroRing(PANEL_SEC |
            hex2bcd[(unsigned short)((tmpClk >> 8) & 0xff)]);

	if (tmpClk & 0x01)
	    addMicroRing(PANEL_IND4 | (int)SEG_COLON);
	else
	    addMicroRing(PANEL_IND4);   
    }
}

/*===========================================================================*/

#endif