// 硬件：DS1302、按键、LCD1602、无源蜂鸣器





// 1、具有万年历功能的数字时钟 (本世纪100年通用)，能够正确的显示年、月、日、时、分、秒

// 2、按键设置时间(校时)

// 3、24小时内至少可设置3个闹钟，并具有不同的闹钟铃声。每个闹钟可以选择启用或者不启用。

// 4、具有秒表功能(计时精度0.1秒)

// 5、其它与数字时钟相关的功能扩展（整点报时、闹钟时间掉电保存功能AT24C02、）

//按键1 可以设置时间切换，秒表下是开始

//按键2 可以设置时间切换，秒表下是暂停

//按键3 可以设置闹钟切换，秒表下是复位

//按键4 可以设置闹钟切换

//按键5 +

//按键6 -

//按键7 直接回到主页面

//按键8 进入秒表

主页面：

![在这里插入图片描述](/static/img/images/04554.png)

闹钟0设置：

![在这里插入图片描述](/static/img/images/04555.png)

闹钟1设置：

![在这里插入图片描述](/static/img/images/04556.png)

闹钟2设置：

![在这里插入图片描述](/static/img/images/04557.png)

秒表：

![在这里插入图片描述](/static/img/images/04558.png)





部分源码：

```c
void main() {
    char miaoa = 0;
    char ifg = 0;
    unsigned char keyvl = 0;
    LCD_init();
    x24c02_init();
    ds1302_init();
    // LCD_write_str(1, 1, "2223123");
    get_time(&rtctime); /* 调用取时间函数 */
    ifg = 0;
    if (rtctime.nian > 99)
        ifg = 1;
    if (rtctime.yue > 12)
        ifg = 1;
    if (rtctime.ri > 31)
        ifg = 1;
    if (rtctime.zhou > 7)
        ifg = 1;
    if (rtctime.shi > 23)
        ifg = 1;
    if (rtctime.fen > 59)
        ifg = 1;
    if (rtctime.miao > 59)
        ifg = 1;
    if (ifg == 1) /* 如果时间有问题 就初始化时间 */
    {
        rtctime.nian = 20;
        rtctime.yue = 10;
        rtctime.ri = 10;
        rtctime.zhou = getWeekdayByYearday(rtctime.nian + 2000, rtctime.yue, rtctime.ri);
        rtctime.shi = 7;
        rtctime.fen = 59;
        rtctime.miao = 58;
        set_time(&rtctime);
    }
    read_alarm();
    ifg = 0;
    if ((ALARMtime.shi > 23) || (ALARMtime.shi < 0))
        ifg = 1;
    if ((ALARMtime.fen > 59) || (ALARMtime.fen < 0))
        ifg = 1;
    if ((ALARMtime.miao > 59) || (ALARMtime.miao < 0))
        ifg = 1;
    if ((ALARMtime1.shi > 23) || (ALARMtime1.shi < 0))
        ifg = 1;
    if ((ALARMtime1.fen > 59) || (ALARMtime1.fen < 0))
        ifg = 1;
    if ((ALARMtime1.miao > 59) || (ALARMtime1.miao < 0))
        ifg = 1;
    if ((ALARMtime2.shi > 23) || (ALARMtime2.shi < 0))
        ifg = 1;
    if ((ALARMtime2.fen > 59) || (ALARMtime2.fen < 0))
        ifg = 1;
    if ((ALARMtime2.miao > 59) || (ALARMtime2.miao < 0))
        ifg = 1;
    if (ifg == 1) /* 如果时间有问题 就初始化  闹钟 */
    {
        ALARMtime.shi = 10;
        ALARMtime.fen = 0;
        ALARMtime.miao = 0;
        ALARMtime1.shi = 10;
        ALARMtime1.fen = 5;
        ALARMtime1.miao = 0;
        ALARMtime2.shi = 10;
        ALARMtime2.fen = 10;
        ALARMtime2.miao = 0;
        write_alarm();
    }
    init_timer0();
    init_timer1();
    while (1) {
        delay_ms(10);
        keyvl = getkey();
        if (keyvl) {
            user_pro_key(keyvl);
            while (getkey())
                ;
        }
        if (set == 0) {
            get_time(&rtctime); /* 调用取时间函数 */
            if (miaoa != rtctime.miao) {
                miaoa = rtctime.miao;
                user_lcd_display(); /* 刷新显示 */
                user_zheng_con();   /* 整点报时控制 */
                user_alarm_con();   /* 闹钟控制 */
            }
        }
        if (naozhong_music) {
            music_beep(naozhong_music);
        }
        if (set == 19) {
            if (TR0 == 1) {
                /* 秒表 unsigned char num=0,ms100=0,second100=0,minute100=0; */
                memset(xianshi, 0, sizeof(xianshi));                                            /* 清空 */
                sprintf(xianshi, "%02d:%02d:%01d", (int)minute100, (int)second100, (int)ms100); /* 装填 */
                LCD_write_str(0, 1, xianshi);
            }
        }
    }
}
void T0_time0(void) interrupt 1 {
    TH0 = (65536 - 50000) / 256;
    TL0 = (65536 - 50000) % 256;
    num2++;
    if (num2 == 2) /* 1秒 */
    {
        num2 = 0;
        ms100++;
        if (ms100 == 10) {
            ms100 = 0;
            second100++;
            if (second100 == 60) {
                second100 = 0;
                minute100++;
            }
        }
    }
}
全部代码见：dt4.8tupian.net/2/28880a11b7000.pg3
```

【51单片机】万年历功能的数字时钟+倒计时 Proteus仿真 普中板子可用

读取效果：





![在这里插入图片描述](/static/img/images/04569.png)

标准的SPI时序：

![在这里插入图片描述](/static/img/images/04570.png)

寄存器：

![在这里插入图片描述](/static/img/images/04571.png)

部分代码：

float toFloat(signed int tempr)

{

    float result = (float) (tempr >> 8); //Discard LSByte (Only holds fraction flag bits)

    char count = tempr & FRAC_FLAG;

    if (count)

    {

        count = count >> 6;

        result = result + (count * 0.25);

    }

    return (result);

}

void main(void)

{

    char cnt = 0;

    unsigned char disp[16];

    float temp1 = 0.0f;

    WDTCTL = WDTPW + WDTHOLD; /* 关闭看门狗 */

    P1DIR = 0xFF; /* 设置方向 */

    P1SEL = 0; /* 设置为普通I/O 口 */

    P2DIR = 0xFF; /* 设置方向 */

    P2SEL = 0; /* 设置为普通I/O 口 */

    P2OUT = 0x00;

    P1OUT = 0x00;

    delay_ms(200);

    LCD_init();

    TC72_Init();

    while (1)

    {

        temp1 = toFloat(TC72_ReadTempr());

        cnt = 0;

        disp[cnt++] = 0x30 + ((int) temp1 / 10);

        disp[cnt++] = 0x30 + ((int) temp1 % 10);

        disp[cnt++] = '.';

        disp[cnt++] = 0x30 + ((int) (temp1 * 10) % 10);

        disp[cnt++] = 0x30 + ((int) (temp1 * 100) % 10);

        LCD_dsp_string(0, 1, disp);

        delay_ms(100);

    }

}

这段代码是一个温度转换程序。它将一个有符号的整数温度值转换为浮点数，并在 LCD 显示屏上显示出来。

首先，给出了一个名为 toFloat 的函数，用于将有符号整数 tempr 转换为浮点数。函数内部的具体操作如下：

将 tempr 右移 8 位，得到一个浮点数类型的 result，这里右移 8 位是为了舍弃低字节（仅包含小数部分标志位）。

从 tempr 中获取一个名为 count 的变量，用于表示低字节中的计数值。

如果 count 不为零，则将 count 右移 6 位，得到实际的计数值，并将其乘以 0.25，然后加到 result 上去。

返回转换后的浮点数 result。

然后，在 main 函数中，使用了以下步骤：

初始化一些变量和设置引脚的方向。

初始化 LCD 屏幕和 TC72 温度传感器。

进入一个无限循环，不断读取温度并显示在 LCD 屏幕上：

使用 TC72_ReadTempr 函数读取温度值，并调用 toFloat 函数将其转换为浮点数赋给 temp1。

将 temp1 的整数部分和小数部分拆分并转换为字符，存储在 disp 数组中。

调用 LCD_dsp_string 函数将 disp 数组中的内容显示在 LCD 屏幕上。

延时 100 毫秒。

通过这段代码，可以实现温度读取和显示功能。


源码：http://dt4.8tupian.net/2/28880a13b6880.pg3

# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】MSP430单片机 Proteus仿真 TC72 温度传感器 温度的设置与显示

# 读取与显示





Burst模式连续读取到DS1302数组，存放顺序是 秒、分、时、日、月、周、年。

这段代码是一个嵌入式系统的程序，用于控制一个基于MSP430微控制器的时钟显示器。下面是代码的解释：

#include 部分是引入了所需要的头文件，包括MSP430微控制器的库、ds1302驱动以及LCD显示器的库。

void main(void) 是主函数的定义，程序从这里开始执行。

WDTCTL = WDTPW + WDTHOLD; 关闭了看门狗定时器，防止系统复位。

P1DIR = 0xFF; 和 P2DIR = 0xFF; 设置了P1和P2端口为输出模式。

P2OUT = 0x00; 和 P1OUT = 0x00; 将P1和P2端口的输出初始化为0。

delay_ms(200); 是一个延时函数，延时200毫秒。

LCD_init(); 初始化LCD显示器。

P5DIR = 0xFF; 和 P5SEL = 0; 设置了P5端口为输出模式。

TimeData 数组存储了时间和日期信息，依次表示秒、分、时、日、月、年和星期。

Init_DS1302(); 初始化ds1302实时时钟模块。

while (1) 是一个无限循环，程序将会在此处一直运行。

Read_DS1302_Time(DS1302_R_ADDR) 从ds1302模块读取时间和日期，并将其存储在TimeData数组中。

LCD_dsp_string(0, 1, disp); 在第一行显示日期信息。

LCD_dsp_string(0, 2, disp); 在第二行显示时间信息。

TimeData[5]=getWeekdayByYearday(2000+TimeData[6],TimeData[4],TimeData[3]); 计算当前日期对应的星期几，并将结果保存在TimeData[5]中。

switch (TimeData[5]) 根据TimeData[5]的值选择相应的星期字符串，在第二行的特定位置显示。

delay_ms(500); 延时500毫秒。

以上就是代码的大致解释。该程序通过读取ds1302实时时钟模块的数据，将时间和日期显示在LCD上，并且还会显示当前日期对应的星期几。循环执行，实现了时钟的实时更新。

```c
void main(void)
{
    char cnt=0;
    unsigned char disp[16];
    WDTCTL = WDTPW + WDTHOLD; /* 关闭看门狗 */
    P1DIR = 0xFF; /* 设置方向 */
    P1SEL = 0; /* 设置为普通I/O 口 */
    P2DIR = 0xFF; /* 设置方向 */
    P2SEL = 0; /* 设置为普通I/O 口 */
    P2OUT = 0x00;
    P1OUT = 0x00;
    delay_ms(200);
    LCD_init();
//    LCD_dsp_string(1, 1, "QQ742971636");
    DS1302[0]=58;//秒
    DS1302[1]=59;//分
    DS1302[2]=23;//时
    DS1302[3]=31;//日
    DS1302[4]=1;//月
    DS1302[6]=0;//年
    DS1302[5]=1;//星期
    Init_DS1302();
    while (1)
    {
        Read_DS1302_Burst_Mode();
        cnt=0;
        disp[cnt++]=DS1302[6]/10+'0';
        disp[cnt++]=DS1302[6]%10+'0';
        disp[cnt++]='-';
        disp[cnt++]=DS1302[4]/10+'0';
        disp[cnt++]=DS1302[4]%10+'0';
        disp[cnt++]='-';
        disp[cnt++]=DS1302[3]/10+'0';
        disp[cnt++]=DS1302[3]%10+'0';
        disp[cnt++]=0;
        LCD_dsp_string(0, 1, disp);
        cnt=0;
        disp[cnt++]=DS1302[2]/10+'0';
        disp[cnt++]=DS1302[2]%10+'0';
        disp[cnt++]=':';
        disp[cnt++]=DS1302[1]/10+'0';
        disp[cnt++]=DS1302[1]%10+'0';
        disp[cnt++]=':';
        disp[cnt++]=DS1302[0]/10+'0';
        disp[cnt++]=DS1302[0]%10+'0';
        disp[cnt++]=0;
        LCD_dsp_string(0, 2, disp);
        switch(DS1302[5])
        {
            case 1:  LCD_dsp_string(12, 2, "MON");break;
            case 2:  LCD_dsp_string(12, 2, "TUE");break;
            case 3:  LCD_dsp_string(12, 2, "WED");break;
            case 4:  LCD_dsp_string(12, 2, "THU");break;
            case 5:  LCD_dsp_string(12, 2, "FRI");break;
            case 6:  LCD_dsp_string(12, 2, "SAT");break;
            case 7:  LCD_dsp_string(12, 2, "SUN");break;
        }
        delay_ms(100);
    }
}
```

仿真图：

![在这里插入图片描述](/static/img/images/04572.jpeg)



# DS1302寄存器介绍

写入0x80到0x8c即可。

![在这里插入图片描述](/static/img/images/04573.png)

# 液晶显示代码

这段代码是为了控制液晶屏(LCD1602)显示内容的函数库。主要包括以下几个函数：

LCD_write_command(unsigned char command)：向液晶屏写入指令的函数。

LCD_write_dat(unsigned char dat)：向液晶屏写入数据的函数。

LCD_set_xy(unsigned char x, unsigned char y)：设置液晶屏的显示位置。

LCD_dsp_char(unsigned char x, unsigned char y, char dat)：在指定位置显示一个字符。

LCD_dsp_string(unsigned char X, unsigned char Y, char *s)：在指定位置显示一个字符串。

LCD_init(void)：初始化液晶屏。

其中，定义了一些接口和函数的宏，如LCDIO、LCD1602_RS_1等。这些宏定义用于控制具体的引脚和功能。

代码中还有一个LCD_check_busy()函数，用于检查液晶屏是否忙于执行操作，但实践证明该函数在某些液晶屏上不能正常使用，因此没有再使用该函数。

整体来说，这段代码实现了对液晶屏的基本操作，包括写入指令和数据、设置显示位置和显示内容等。通过调用这些函数，可以实现控制液晶屏显示不同的内容。

```c
#include "LCD.h"
#include <string.h>
/**************定义接口************************/
#define LCDIO       P1OUT
#define LCD1602_RS_1    P2OUT   |= 1
#define LCD1602_RS_0    P2OUT   &=~1
#define LCD1602_RW_1    P2OUT   |= 2
#define LCD1602_RW_0    P2OUT   &=~2
#define LCD1602_EN_1    P2OUT   |= 4
#define LCD1602_EN_0    P2OUT   &=~4
/**************定义函数************************/
void LCD_write_command(unsigned char command); /* 写入指令函数 */
void LCD_write_dat(unsigned char dat); /* 写入数据函数 */
void LCD_set_xy(unsigned char x, unsigned char y); /* 设置显示位置函数 */
void LCD_dsp_char(unsigned char x, unsigned char y, char dat); /* 显示一个字符函数 */
void LCD_dsp_string(unsigned char X, unsigned char Y, char *s); /* 显示字符串函数 */
void LCD_init(void); /* 初始化函数 */
/*******检查忙函数*************/
void LCD_check_busy() /* 实践证明，在我的LCD1602上，检查忙指令通过率极低，以 */
{ /* 至于不能正常使用LCD。因此我没有再用检查忙函数。而使 */
    P1DIR = 0x00;
    LCDIO = 0xff;
    LCD1602_RS_0; /* 要用200次循环便能完成。 */
    LCD1602_RW_1;
    LCD1602_EN_1;
    while (P1IN & 0x80)
        ;
    LCD1602_EN_0;
    P1OUT = 0x00;
    P1DIR = 0xFF;
}
/******************************/
/**************写指令函数********************************/
void LCD_write_command(unsigned char command)
{
    /* LCD_check_busy(); //加上这句仿真无法通过 */
    LCD1602_RS_0;
    LCDIO = command;
    LCD1602_EN_1;
    /* delay_ms(1); */
    LCD1602_EN_0;
    delay_ms(1);
}
/***************************************************/
/****************写数据函数************************/
void LCD_write_dat(unsigned char dat)
{
    /* LCD_check_busy();  //加上这句仿真无法通过 */
    LCD1602_RS_1;
    LCDIO = dat;
    LCD1602_EN_1;
    /* delay_ms(1); */
    LCD1602_EN_0;
    delay_ms(1);
    LCD1602_RS_0;
}
/****************************************************/
/***************设置显示位置**************************/
void LCD_set_xy(unsigned char x, unsigned char y)
{
    unsigned char address;
    if (y == 1)
        address = 0x80 + x;
    else if (y == 2)
    {
        address = 0x80 + 0x40 + x;
    }
    LCD_write_command(address);
}
/***************************************************/
/****************显示一个字符**********************/
void LCD_dsp_char(unsigned char x, unsigned char y, char dat)
{
    LCD_set_xy(x, y);
    LCD_write_dat(dat);
}
/**********************************************/
/***************显示字符串函数***************/
void LCD_dsp_string(unsigned char X, unsigned char Y, char *s)
{
    uchar len, List;
    len = strlen(s);
    LCD_set_xy(X, Y);
    for (List = 0; List < len; List++)
        LCD_write_dat(s[List]);
}
/**************************************/
/************初始化函数****************/
void LCD_init(void)
{
    LCD1602_RW_0;
    LCD1602_EN_0;
    /* CLEARSCREEN;//clear screen */
    LCD_write_command(0x38); /* set 8 bit data transmission mode */
    delay_ms(1);
    LCD_write_command(0x38); /* set 8 bit data transmission mode */
    delay_ms(1);
    LCD_write_command(0x38); /* set 8 bit data transmission mode */
    delay_ms(1);
    LCD_write_command(0x06); /* open display (enable lcd display) */
    delay_ms(1);
    LCD_write_command(0x0C); /* set lcd first display address */
    delay_ms(1);
    LCD_write_command(0x01); /* clear screen */
    delay_ms(1);
    /*
     * LCD_write_command(0x80);//clear screen
     * delay_ms(1);
     */
}
```

# 全部源码

源码：http://dt2.8tupian.net/2/28880a14b9990.pg3

# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】MSP430单片机 Proteus仿真 DS1302 时钟的设置与显示 万年历 时钟

# 高仿真数码管电子钟





高仿真数码管电子钟

基本要求:

采用 6只7段 BCD 码数码管器件 7SEG;

采用 PCF8583 时钟芯片:

能显示时间。

发挥部分:

采用键盘，实现 12h/24h 切换功能:

有时间调整功能。

![在这里插入图片描述](/static/img/images/04574.png)


# 51单片机

![在这里插入图片描述](/static/img/images/04575.png)

# MSP430单片机

![在这里插入图片描述](/static/img/images/04576.png)


# 设置时间

PCF8583是 IIC通信，当引脚A0接GND，则I2C地址为0XA0。

设置时间的步骤：

（1）向 0x00 寄存器（控制地址） 写入 0x80 数据（停止运行始终、正常计数、32768、允许读出全部内容、闹钟全部关闭，详看芯片介绍中的寄存器介绍）；

（2）

向0x02 寄存器写入BCD格式的秒，低位存放秒数的个位数值，范围为0～9；高位存放秒数的十位数值，范围为0～5 ；

向0x03 寄存器写入BCD格式的分;

向0x04 寄存器写入BCD格式的时;

![在这里插入图片描述](/static/img/images/04577.png)

向0x05 寄存器写入BCD格式的日、年;

![在这里插入图片描述](/static/img/images/04578.png)

向0x06 寄存器写入BCD格式的 星期/月;

![在这里插入图片描述](/static/img/images/04579.png)

（3）向 0x00 寄存器（控制地址） 写入 0x00 数据，开始走时


# 读取时间

读取 0x02、0x03、0x04、0x05、0x06中的数值做转换即可。





# PCF8583介绍

PCF8583是飞利浦（Philips）公司生产的CMOS型实时时钟芯片，它带有240B的RAM，且具有I2C串行总线接口。只需要通过单片机并行I/O口的两条引脚模拟I2C总线的数据线SDA、时钟线SCL，就可以完成对PCF8583的参数设置、读取日期和时间数据等操作。PCF8583具有接口简单，占用单片机资源少等优点，因而被广泛应用在各类智能仪器仪表和电子工程项目中。

![在这里插入图片描述](/static/img/images/04580.png)

![在这里插入图片描述](/static/img/images/04581.png)

![在这里插入图片描述](/static/img/images/04582.png)


![在这里插入图片描述](/static/img/images/04583.png)

![在这里插入图片描述](/static/img/images/04584.png)

![在这里插入图片描述](/static/img/images/04585.png)


![在这里插入图片描述](/static/img/images/04586.png)

![在这里插入图片描述](/static/img/images/04587.png)

![在这里插入图片描述](/static/img/images/04588.png)

# 源码

下载：dt3.8tupian.net/2/28880a15b9990.pg3


这段代码是一个嵌入式系统中的主程序（main函数），用于控制一个数字时钟的功能。

首先，代码定义了一些变量和寄存器的配置。然后进入一个无限循环，不断执行下面的操作：

每隔4毫秒执行一次中断服务函数。

通过计数器t_j实现每50次循环（即200毫秒）执行一次读取时间的操作。

在读取时间后，根据是否是24小时制来设置显示数组disp中的小时值。

通过按键的检测修改时间：按下P5IN寄存器的BIT1增加小时，按下BIT2减少小时，按下BIT3增加分钟，按下BIT4减少分钟，按下BIT5增加秒，按下BIT6减少秒，按下BIT7切换24小时制。

每次修改时间后，调用write_time函数将修改后的时间写入到相应的存储器中。

循环继续，重复以上步骤。

整个代码的功能是实现一个数字时钟，通过按键控制时钟的设置和调整，并将时间在数码管上进行显示。

```c
void main( void )
{
    int t_j = 0;
    char rchar;
    WDTCTL = WDTPW + WDTHOLD;       /* 关闭看门狗 */
    write_time();
    P1DIR = 0xFF;
    P1OUT = 0x00;                 /* 数码管段选 */
    P3DIR = 0xFF;
    P3OUT = 0x00;                 /* 数码管位选 */
    P5DIR &= 0X01;
    P5REN |= 0XFE;
    P5OUT |= 0XFE;                /* 7个按键 */
    P2DIR |= BIT1;
    P2OUT |= BIT1;                /* 小灯 */
    CCTL0 = CCIE;                 /* CCR0 interrupt enabled */
    CCR0 = 327 / 4;              /* 4ms */
    TACTL = TASSEL_1 + MC_1;      /* ACLK, upmode */
    __bis_SR_register( GIE );
    while ( 1 )
    {
        delay_ms( 2 );
        t_j++;
        if ( t_j > 50 )
        {
            t_j = 0;
            /* 读取时间 */
            rchar = ReadByteEE( SECOND );
            hour = (rchar >> 4) * 10 + (rchar & 0x0F);
            rchar = ReadByteEE( MINUTE );
            second = (rchar >> 4) * 10 + (rchar & 0x0F);
            rchar = ReadByteEE( HOUR );
            minute = (rchar >> 4) * 10 + (rchar & 0x0F);
            /* 将时间装入数组 */
            if ( flag24 == 1 )
            {
                disp[0] = hour % 100 / 10;
                disp[1] = hour % 10;
            }else{
                if ( hour > 12 )
                {
                    disp[0] = (hour - 12) % 100 / 10;
                    disp[1] = (hour - 12) % 10;
                }else {
                    disp[0] = hour % 100 / 10;
                    disp[1] = hour % 10;
                }
            }
            disp[2] = minute % 100 / 10;
            disp[3] = minute % 10;
            disp[4] = second % 100 / 10;
            disp[5] = second % 10;
        }
        if ( (P5IN & BIT1) == 0 ) /* 增加小时 */
        {
            if ( flag24 == 1 )
            {
                hour++;
                if ( hour > 23 )
                    hour = 0;
            } else{
                hour++;
                if ( hour > 11 )
                    hour = 0;
            }
            write_time();
            while ( (P5IN & BIT1) == 0 )
                ;
        }else if ( (P5IN & BIT2) == 0 ) /* 减少小时 */
        {
            if ( flag24 == 1 ) {
                if (hour > 0) {
                    hour--;
                } else {
                    hour = 23;
                }
            }else {
                if (hour > 0) {
                    hour--;
                } else {
                    hour = 11;
                }
            }
            write_time();
            while ( (P5IN & BIT2) == 0 )
                ;
        }else if ( (P5IN & BIT3) == 0 ) /* 增加分钟 */
        {
            minute++;
            if ( minute > 59 )
                minute = 0;
            write_time();
            while ( (P5IN & BIT3) == 0 )
                ;
        }else if ( (P5IN & BIT4) == 0 ) /* 减少分钟 */
        {
            if ( minute > 0 )
            {
                minute--;
            }else {
                minute = 59;
            }
            write_time();
            while ( (P5IN & BIT4) == 0 )
                ;
        }else if ( (P5IN & BIT5) == 0 ) /* 增加秒 */
        {
            second++;
            if ( second > 59 )
                second = 0;
            write_time();
            while ( (P5IN & BIT5) == 0 )
                ;
        }else if ( (P5IN & BIT6) == 0 ) /* 减少秒 */
        {
            if ( second > 0 )
            {
                second--;
            }else {
                second = 59;
            }
            write_time();
            while ( (P5IN & BIT6) == 0 )
                ;
        }else if ( (P5IN & BIT7) == 0 ) /* 切换24小时制 */
        {
            if ( flag24 == 1 )
            {
                flag24 = 0;
                P2OUT &= ~BIT1;
            } else{
                flag24 = 1;
                P2OUT |= BIT1;
            }
            while ( (P5IN & BIT7) == 0 )
                ;
        }
    }
}
```

# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】PCF8583时钟，proteus，LCD1602显示，51单片机，MSP430单片机，高仿真数码管电子钟

# proteus





效果图如下：

![在这里插入图片描述](/static/img/images/04589.png)


首先,让我们先来说说DS18B20集成电路。

• DS18B20是一款采用OneWire通讯协议的集成电路,因此只需要一条线就可以与微控制器通讯。它不需要额外的电源,但是也有外部电源输入端口。

• OneWire设备具有64位的ROM代码。如我们之前所说,这64位的前8位是家族代码,中间48位是序列号,最后8位是CRC码。

• 如果使用外部电源,工作电压范围在3V到5.5V之间。最高可以在750毫秒内获得12位精度(8位整数部分+4位小数部分)的温度数据。

• 虽然标准精度是12位,但是也可以设置为9,10或11位精度。精度降低时,温度数据的8位整数部分保持不变,只是4位小数部分的位数减少。

• 测量范围在-55°C到+125°C(-67°F到+257°F)之间,在-10°C到+85°C之间可以达到0.5°C的精度。

• 它具有用户可以定义的警报寄存器,可以作为温控器使用。集成电路测量的温度与警报寄存器中的温度会自动比较,通过向集成电路发送警报查询命令可以检测是否产生警报状态。

• 它可以采用TO92、SO8和uSOP封装。下面我们可以看到该集成电路不同封装的图片。

![在这里插入图片描述](/static/img/images/04590.png)

![在这里插入图片描述](/static/img/images/04591.png)

![在这里插入图片描述](/static/img/images/04592.png)

如上表所示,这些寄存器用于保存温度数据。它由两个字节组成:Low Byte和High Byte。Low Byte的前4位保存小数部分的数据。例如,前4位为“1000”,这意味着 BIT3的权重为0.5,所以温度数据为“XX.5”。BIT0,BIT1,BIT2和BIT3的权重分别为0.0625,0.125,0.25和0.5。如果我们想在软件中看到温度的小数部分,我们必须检查这些位并将其正确显示在LCD屏幕上。Low Byte的最后4位是温度数据的低四位,也就是低nibble。温度数据的高四位是High Byte的前四位。在获得温度数据时,Low Byte的最后四位与High Byte的前四位结合,得到8位数据(温度数据的整数部分)。High Byte的最后四位是符号位。如果测量温度为负值,这四位为1。温度数据以补码格式从这些寄存器中读取。因此,如果进行负温度测量,必须注意这一点。

所以,简单来说,这两个字节保存了完整的12位温度数据。低位字节的后4位是温度整数部分的低4位,与高位字节的前4位合并得到温度整数部分。低位字节的前4位表示温度的小数部分。高位字节的后4位是温度数据的符号位。

 ![在这里插入图片描述](/static/img/images/04593.png)

 这些寄存器是两个8位寄存器。如果要将集成电路用作温控器,可以通过比较测量的温度值与加载到这些寄存器的值来检测是否产生警报状态。这些寄存器的最后一位也是符号位。这些寄存器的值也保存在同名的EEPROM存储器中。上电时,ScratchPAD中的对应值与EEPROM中的值相同。如果不使用集成电路的温控功能,这些寄存器可以由用户用于一般用途。

简单来说,这两个8位寄存器可以与集成电路的温控功能一起使用,用于比较实际测量温度与设定温度,检测是否产生警报。这两个寄存器的值也可以保存在EEPROM中,并在上电时从EEPROM加载。如果不使用温控功能,这两个寄存器也可以用于用户的其他用途。

所以,对这段描述的总结是:

1) 两个8位寄存器,可以用于集成电路的温控功能,比较实测温度和设定温度,检测警报。

2) 这两个寄存器的值可以保存在EEPROM中,上电时从EEPROM加载。

3) 如果不使用温控功能,这两个寄存器可用于其他用途。

4) 最后一位是符号位。


![在这里插入图片描述](/static/img/images/04594.png)

ScratchPad的第4个字节是配置寄存器。通过此寄存器可以设置集成电路的精度。如开头所述,尽管集成电路的默认精度为12位,但也可以设置为9、10或11位。如上图所示,精度设置是通过配置寄存器的R0和R1位完成的。如表所示,随着精度的降低,获得温度数据所需的循环时间也会降低。此外,需要说明的一点是,降低精度时,减少的位数不会从温度数据的整数部分减少,而是从小数部分的位数中减少。这对用户来说是一个很好的功能。

ScratchPad的第5、6和7字节保留未使用。第8个字节是CRC码。如我们前面所说,CRC码是通过错误检验算法获得的数据。它是测试读取数据准确性的一种很好的方法。在传输几个字节的数据时,它虽不太重要,但在传输包含许多数据包的通信协议中,错误检验算法(CRC、LRC等)非常重要。

如我们前面所述,要与OneWire设备通信,需要使用功能码。所执行的操作由这些功能码确定。DS18B20集成电路具有用于ROM代码和ScratchPad的各种功能码。我们将对此进行说明。

所以,对此段描述的总结为:

1) ScratchPad第4字节是配置寄存器,用于设置集成电路精度,默认12位,也可以设置9-11位。精度设置通过R0和R1位完成。

2) 精度降低时,减少的位数来自小数部分,整数部分不变。这是一个很好的功能。

3) ScratchPad第5-7字节未使用。

4) 第8字节是CRC码,用于检验读取数据的准确性。在通信协议中很重要。

5) 要与OneWire设备通信,需要使用功能码。DS18B20有用于ROM代码和ScratchPad的各种功能码。

6) 将在后续对各种功能码进行说明。

ROM命令

1. Search ROM (0xF0)

2. Read ROM (0x33)

3. Match ROM (0x55)

4. Skip ROM (0xCC)

5. Alarm Search (0xEC)

DS18B20功能命令

1. Convert T (0x44)

2. Write ScratchPad (0x4E)

3. Read ScratchPad (0xBE)

4. Copy ScratchPad (0x48)

5. Recall E2 (0xB8)

6. Read Power Supply (0xB4)

要与DS18B20通信,需要遵循数据顺序。首先复位总线并等待presence pulse。然后确定总线上有设备且设备准备好通信。然后发送ROM命令。在此阶段,可以使用match rom(0x55)命令读取设备序列号,以便在总线上有多个设备时进行识别。如果不发送ROM命令,可以发送skip rom(0xCC)命令跳过此第二步。第三步,发送功能码之一以执行所需操作。例如,要启动读取温度数据的转换循环,可以发送convert t(0x44)命令读取温度数据。


# 部分代码

```cpp
void main(void)
{
    int temperature;
    char disp[16];
    char cnt=0;
    unsigned char TAM_KISIM     = 0;
    unsigned int  ONDALIK_KISIM = 0;
    WDTCTL = WDTPW + WDTHOLD; /* 关闭看门狗 */
    P1DIR = 0xFF; /* 设置方向 */
    P1SEL = 0; /* 设置为普通I/O 口 */
    P2DIR = 0xFF; /* 设置方向 */
    P2SEL = 0; /* 设置为普通I/O 口 */
    P2OUT = 0x00;
    P1OUT = 0x00;
    delay_ms(200);
    LCD_init();
    //P4.1 设置为PWM 输出
    P4DIR |= BIT1;
    P4SEL |= BIT1;
    TBCCR0 = 1000;                 //PWM 周期
    TBCCR1 = 500;                  //PWM 占空比
    TBCCTL1 = OUTMOD_7;             //PWM 输出模式
    TBCTL = TBSSEL_2 + MC_1 + ID_3;      //SMCLK, UP 模式
    P4DIR=0XFF;
    P4OUT=0XFF;
    P2DIR|=BIT4;
    while (1)
    {
        Read_DS18B20(&TAM_KISIM,&ONDALIK_KISIM);
        cnt=0;
        disp[cnt++]='t';
        disp[cnt++]='=';
        disp[cnt++]='0'+(TAM_KISIM%1000/100);
        disp[cnt++]='0'+(TAM_KISIM%100/10);
        disp[cnt++]='0'+(TAM_KISIM%10);
        disp[cnt++]='.';
        disp[cnt++]='0'+(ONDALIK_KISIM%10000/1000);
        disp[cnt++]='0'+(ONDALIK_KISIM%1000/100);
        disp[cnt++]='0'+(ONDALIK_KISIM%100/10);
        disp[cnt++]='0'+(ONDALIK_KISIM%10);
        disp[cnt++]='C';
        disp[cnt++]=0;
        LCD_dsp_string(1, 1, disp); /* 在第一行第一列显示"LCD TEST" */
        LCD_dsp_string(1, 2, "  QQ742971636  "); /* 在第一行第一列显示"LCD TEST" */
        delay_ms(1200);
    }
}
```

# 全部代码

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】MSP430单片机 Proteus仿真 DS18B20温度 LCD1602显示器 温度读取与显示

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。