ht1380.c

用ansi c 实现针对时钟芯片HT1380的驱动程序

/* HT1380.C - Real Timer for the Keil Evaluation with 80C51 device*/
/******************************************************************
 Revision history:
        2005/04/01             Arthur Zhu            initial begin
*******************************************************************/

#include <REG51.H>
#include "ex.H"

#define DISP_DLY 100
#define CMD_DLY  4
#define KEY_DLY  50
#define BLK_TH   200

unsigned int  blk_ctrl;
unsigned char key3_hit;
unsigned char key2_hit;
unsigned char key1_hit;
unsigned char key0_hit;
unsigned char led_7seg[] = {        /* LED 7 segment data */
                            0x3F,   /* 0  */
                            0x06,   /* 1  */
                            0x5B,   /* 2  */
                            0x4F,   /* 3  */
                            0x66,   /* 4  */
                            0x6D,   /* 5  */
                            0x7D,   /* 6  */
                            0x07,   /* 7  */
                            0x7F,   /* 8  */
                            0x6F,   /* 9  */
                            0x77,   /* Aa */
                            0x7C,   /* Bb */
                            0x39,   /* Cc */
                            0x5E,   /* Dd */
                            0x79,   /* Ee */
                            0x71,   /* Ff */
                            0x73,   /* Pp */
                            0x76,   /* Hh */
                            0x5D,   /* Oo */
                            0x40,   /* -  */
                            0x00    /* None */
                            };

unsigned char FSM_State = SHOW_SEC;
unsigned char second = 0x40;
unsigned char minute = 0x42;
unsigned char hour   = 0x15;
unsigned char day    = 0x31;
unsigned char month  = 0x03;
unsigned char temp   = 0x01;
unsigned char year   = 0x05;

/*------------------------- Delay_n_us --------------------------*/
void Delay_n_us (unsigned int n_us)
{
    while (n_us--);
}

/*--------------------------- read_key --------------------------*/
void read_key ()
{
    unsigned char temp;
    ET0 = 0;    // disable interrupt
    P2   = P2 | 0x0F0;
    temp = P2;
    key3_hit = 0;
    key2_hit = 0;
    key1_hit = 0;
    key0_hit = 0;
    if      ( (temp & 0xF0) != 0xF0 )
    {
        Delay_n_us (KEY_DLY);
        temp = P2;
        if      ( (temp & 0x80) == 0x00 )
            key3_hit = 1;
        else if ( (temp & 0x10) == 0x00 )
            key0_hit = 1;
        else if ( (temp & 0x20) == 0x00 )
            key1_hit = 1;
        else if ( (temp & 0x40) == 0x00 )
            key2_hit = 1;
        else
        {
        }
    }
    ET0 = 1;    // enable interrupt
    while ( (temp & 0x0F0) != 0x0F0 ) temp = P2;
}

/*-------------------------- Write HT1380 -----------------------*/
void set_byte (unsigned char byte)
{
    unsigned char ii;
    for (ii = 0; ii < 8; ii++)
    {
        sclk_1380 = 0;
        if (byte & 0x01)
            io_1380 = 1;
        else
            io_1380 = 0;
        sclk_1380 = 1;
        byte >>= 1;
    }
}

/*-------------------------- Read HT1380 -----------------------*/
unsigned char get_byte ()
{
    unsigned char ii;
    unsigned char byte;
    unsigned char temp;
    byte = 0x00;
    temp = 0x01;
    for (ii = 0; ii < 8; ii++)
    {
        sclk_1380 = 1; // add for test
        sclk_1380 = 0;
        io_1380   = 1;
        if (io_1380 == 1)
            byte = byte | temp;
        sclk_1380 = 1;
        temp <<= 1;
    }
    return (byte);
}

/*-------------------------- HT1380 set_wp_off -----------------------*/
void set_wp_off ()
{
    rst_1380_ = 1;
    Delay_n_us (CMD_DLY);
    set_byte (0x8E);        //10001110b
    set_byte (0x00);        //00000000b
    sclk_1380 = 0;
    Delay_n_us (CMD_DLY);
    rst_1380_ = 0;
    Delay_n_us (CMD_DLY);
}

/*-------------------------- HT1380 set_wp_on -----------------------*/
void set_wp_on ()
{
    rst_1380_ = 1;
    Delay_n_us (CMD_DLY);
    set_byte (0x8E);        //10001110b
    set_byte (0x80);        //10000000b
    sclk_1380 = 0;
    Delay_n_us (CMD_DLY);
    rst_1380_ = 0;
    Delay_n_us (CMD_DLY);
}

/*-------------------------- HT1380 read_time -----------------------*/
void read_time ()
{
    unsigned char temp;
    rst_1380_ = 1;
    Delay_n_us (CMD_DLY);
    set_byte (0xBF);        //10111111b
    second = get_byte ();
    minute = get_byte ();
    hour   = get_byte ();
    day    = get_byte ();
    month  = get_byte ();
    temp   = get_byte ();   // week day
    year   = get_byte ();
    temp   = get_byte ();
    sclk_1380 = 0;
    Delay_n_us (CMD_DLY);
    rst_1380_ = 0;
    Delay_n_us (CMD_DLY);
}

/*-------------------------- HT1380 set_time -----------------------*/
void set_time ()
{
    set_wp_off ();
    rst_1380_ = 1;
    Delay_n_us (CMD_DLY);
    second = second & 0x7F;
    set_byte (0xBE  );      //10111110b
    set_byte (second);
    set_byte (minute);
    set_byte (hour  );
    set_byte (day   );
    set_byte (month );
    set_byte (0x01  );      // week day
    set_byte (year  );
    set_byte (0x00  );
    sclk_1380 = 0;
    Delay_n_us (CMD_DLY);
    rst_1380_ = 0;
    Delay_n_us (CMD_DLY);
    set_wp_on ();
}

/*------------------------- HT1380 read_sec ------------------------*/
unsigned char read_sec ()
{
    unsigned char sec;
    rst_1380_ = 1;
    Delay_n_us (CMD_DLY);
    set_byte (0x81 );       //10000001b
    sec = get_byte();
    sclk_1380 = 0;
    Delay_n_us (CMD_DLY);
    rst_1380_ = 0;
    Delay_n_us (CMD_DLY);
    return (sec );
}

/*------------------------- HT1380 write_sec -----------------------*/
void write_sec (unsigned char sec)
{
    set_wp_off ();
    sec = sec & 0x7F;
    rst_1380_ = 1;
    Delay_n_us (CMD_DLY);
    set_byte (0x80 );       //10000000b
    set_byte (sec  );
    sclk_1380 = 0;
    Delay_n_us (CMD_DLY);
    rst_1380_ = 0;
    Delay_n_us (CMD_DLY);
    set_wp_on ();
}

/*-------------------------- HT1380 disp_led -------------------------*/
void disp_led (
               unsigned char dd,
               unsigned char addr1,
               unsigned char addr2,
               unsigned char ctrl
               )
{
    unsigned char temp;
    switch (ctrl)
    {
      case 0:       // show addr1 and addr2
        temp = dd >> 4;
        P0 = led_7seg[temp];
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = led_7seg[temp];
        P2 = addr2;
        break;

      case 1:       // not show addr1
        P2 = 0x00;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = led_7seg[temp];
        P2 = addr2;
        break;

      case 2:       // not show addr2
        temp = dd >> 4;
        P0 = led_7seg[temp];
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        P2 = 0x00;
        break;

      case 3:       // show addr1 . and addr2
        temp = dd >> 4;
        P0 = led_7seg[temp] | 0x80;
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = led_7seg[temp];
        P2 = addr2;
        break;

      case 4:       // show addr1 and addr2 . or :
        temp = dd >> 4;
        P0 = led_7seg[temp];
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = led_7seg[temp] | 0x80;
        P2 = addr2;
        break;

      case 5:       // show . and addr2 and not add1
        temp = dd >> 4;
        P0 = 0x80;
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = led_7seg[temp];
        P2 = addr2;
        break;

      case 6:       // show addr1 . and not addr2
        temp = dd >> 4;
        P0 = led_7seg[temp] | 0x80;
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        P2 = 0x00;
        break;

      case 7:       // not show addr1 and show addr2 . or :
        P2 = 0x00;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = led_7seg[temp] | 0x80;
        P2 = addr2;
        break;

      case 8:       // show addr1 and . or : and not addr2
        temp = dd >> 4;
        P0 = led_7seg[temp];
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = 0x80;
        P2 = addr2;
        break;

      default:      // show addr1 and addr2
        temp = dd >> 4;
        P0 = led_7seg[temp];
        P2 = addr1;
        Delay_n_us (DISP_DLY);
        temp = dd & 0x0F;
        P0 = led_7seg[temp];
        P2 = addr2;
        break;
    }
}

/*-------------------------- HT1380 disp_year ------------------------*/
void disp_year ()
{
    disp_led (year, 0x02, 0x01, 0);
}

/*-------------------------- HT1380 disp_mmdd ------------------------*/
void disp_mmdd ()
{
    disp_led (month, 0x08, 0x04, 3);
    Delay_n_us (DISP_DLY);
    disp_led (day,   0x02, 0x01, 0);
}

/*-------------------------- HT1380 disp_time ------------------------*/
void disp_time ()
{
    if (blk_ctrl < BLK_TH)
        disp_led (hour, 0x08, 0x04, 0);
    else
        // Not display the ten bits of year, that is let it flash
        disp_led (hour, 0x08, 0x04, 4);
    Delay_n_us (DISP_DLY);
    disp_led (minute, 0x02, 0x01, 0);
}

/*-------------------------- HT1380 disp_sec -------------------------*/
void disp_sec ()
{
    disp_led (second, 0x08, 0x04, 0);
}

/*----------------------- HT1380 disp_set_year_10 --------------------*/
void disp_set_year_10 ()
{
    if (blk_ctrl < BLK_TH)
        disp_led (year, 0x02, 0x01, 0);
    else
        // Not display the ten bits of year, that is let it flash
        disp_led (year, 0x02, 0x01, 1);
}

/*----------------------- HT1380 disp_set_year_1 ---------------------*/
void disp_set_year_1 ()
{
    if (blk_ctrl < BLK_TH)
        disp_led (year, 0x02, 0x01, 0);
    else
        // Not display the unit bits of year, that is let it flash
        disp_led (year, 0x02, 0x01, 2);
}

/*----------------------- HT1380 disp_set_mon_10 ---------------------*/
void disp_set_mon_10 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (month, 0x08, 0x04, 3);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 0);
    }
    else
    {
        // Not display the ten bits of month, that is let it flash
        disp_led (month, 0x08, 0x04, 5);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 0);
    }
}

/*----------------------- HT1380 disp_set_mon_1 ----------------------*/
void disp_set_mon_1 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (month, 0x08, 0x04, 3);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 0);
    }
    else
    {
        // Not display the unit bits of month, that is let it flash
        disp_led (month, 0x08, 0x04, 6);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 0);
    }
}

/*----------------------- HT1380 disp_set_day_10 ---------------------*/
void disp_set_day_10 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (month, 0x08, 0x04, 3);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 0);
    }
    else
    {
        // Not display the ten bits of day, that is let it flash
        disp_led (month, 0x08, 0x04, 3);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 1);
    }
}

/*----------------------- HT1380 disp_set_day_1 ----------------------*/
void disp_set_day_1 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (month, 0x08, 0x04, 3);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 0);
    }
    else
    {
        // Not display the unit bits of day, that is let it flash
        disp_led (month, 0x08, 0x04, 3);
        Delay_n_us (DISP_DLY);
        disp_led (day,   0x02, 0x01, 2);
    }
}

/*----------------------- HT1380 disp_set_hour_10 --------------------*/
void disp_set_hour_10 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (hour,   0x08, 0x04, 4);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 0);
    }
    else
    {
        // Not display the ten bits of hour, that is let it flash
        disp_led (hour,   0x08, 0x04, 7);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 0);
    }
}

/*----------------------- HT1380 disp_set_hour_1 ---------------------*/
void disp_set_hour_1 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (hour,   0x08, 0x04, 4);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 0);
    }
    else
    {
        // Not display the unit bits of hour, that is let it flash
        disp_led (hour,   0x08, 0x04, 8);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 0);
    }
}

/*----------------------- HT1380 disp_set_min_10 ---------------------*/
void disp_set_min_10 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (hour,   0x08, 0x04, 4);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 0);
    }
    else
    {
        // Not display the ten bits of minute, that is let it flash
        disp_led (hour,   0x08, 0x04, 4);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 1);
    }
}

/*----------------------- HT1380 disp_set_min_1 ----------------------*/
void disp_set_min_1 ()
{
    if (blk_ctrl < BLK_TH)
    {
        disp_led (hour,   0x08, 0x04, 4);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 0);
    }
    else
    {
        // Not display the unit bits of minute, that is let it flash
        disp_led (hour,   0x08, 0x04, 4);
        Delay_n_us (DISP_DLY);
        disp_led (minute, 0x02, 0x01, 2);
    }
}

/*----------------------- HT1380 disp_set_sec_10 ---------------------*/
void disp_set_sec_10 ()
{
    if (blk_ctrl < BLK_TH)
        disp_led (second, 0x08, 0x04, 0);
    else
        // Not display the ten bits of second, that is let it flash
        disp_led (second, 0x08, 0x04, 1);
}

/*------------------------ HT1380 disp_set_sec_1 ---------------------*/
void disp_set_sec_1 ()
{
    disp_led (second, 0x08, 0x04, 0);

    Delay_n_us (DISP_DLY);