# 读取与显示





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显示器 温度读取与显示

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





# 帮助、问询

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

MSP430F5529 单片机 读取 GY-906 红外温度传感器

为了便于开发，我做了一块扩展板子：





[https://blog.csdn.net/x1131230123/article/details/108772807](https://blog.csdn.net/x1131230123/article/details/108772807)

扩展板有一些常用器件，这样开发MSP430 F5529程序的时候，就不用杜邦线连接了。当然也可以选择杜邦线连接器件，效果都一样。


Memory game. Draw 4 geometric shapes in positions on the screen touching each other. Display to  the player for 1 second. Move the 4 shapes to random points on the screen. The player must select each  shape and move it back to correct position in the least amount of time. Computer must judge “close” to  goal and show time to complete

接线
```bash
/*
 * OLED模式设置
 * -----------------OLED端口定义---------------
 * OLED----MSP430
 * VCC-----3.3V
 * GND-----GND
 * D0------P3.2
 * D1------P3.0
 * RES-----P2.0
 * DC------P2.2
 * CS------P8.1
 */
```

按键1 左移动

按键2 右移动

按键2长按  选中或者取消选中


随机生成形状顺序：

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

开始计时还原：

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

# 帮助、问询

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

MSP430F5529 单片机 Memory game 记忆游戏 OLED实验

# 步骤





1 读取 Manufacturer_ID_value  和 Device_ID_value，看是不是数据手册中的数值

2 写入0X02寄存器配置，关闭加热器，设置温湿度sequence mode读取，14位精度

Configuration_1 0x1000 // Heater disabled, Temperature and Humidity are acquired in sequence, Temperature first.,  14-bit  resolution

3 读取0x00 和 0x01 的温湿度数值

4 依据手册中的公式转化为温湿度


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

# 电路图

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


# 效果图

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

# 原理




这段代码是一个嵌入式系统程序，采用C语言编写。它的作用是通过DHT11传感器获取温湿度数据，并将数据显示在OLED屏幕上。

下面是对代码的详细解释：

int main(void)：定义了main函数，是程序的入口。

unsigned char dis[10];：定义了一个长度为10的无符号字符数组dis，用于存储要显示的字符串。

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

if (CALBC1_8MHZ == 0xFF)：检查校准常量是否被擦除。

while (1);：如果校准常量被擦除，则进入死循环，陷入无限等待状态。

DCOCTL = 0;：选择最低的DCOx和MODx设置，即最低频率设置。

BCSCTL1 = CALBC1_8MHZ;：设置系统时钟频率为8MHz。

DCOCTL = CALDCO_8MHZ;：设置DCO步进和调制。

OLED_Init();：执行OLED初始化操作，准备显示数据。

OLED_ShowString(0, 0, "dht11:");：在OLED屏幕的第一行显示"dht11:"。

while (1)：进入一个无限循环，用于不断读取并显示温湿度数据。

if (start_DHT11())：如果启动DHT11传感器成功。

dis[0] = DHT11T_Data_H % 100 / 10 + '0';：将温度数据的十位数转换为字符并存储在dis数组的第一个位置。

dis[1] = DHT11T_Data_H % 10 + '0';：将温度数据的个位数转换为字符并存储在dis数组的第二个位置。

dis[2] = 'C';：存储字符'C'，表示摄氏度单位。

dis[3] = ' ';：存储一个空格字符。

dis[4] = DHT11RH_Data_H % 100 / 10 + '0';：将湿度数据的十位数转换为字符并存储在dis数组的第四个位置。

dis[5] = DHT11RH_Data_H % 10 + '0';：将湿度数据的个位数转换为字符并存储在dis数组的第五个位置。

dis[6] = '%';：存储字符'%'，表示湿度的百分比符号。

dis[7] = 0;：在dis数组的末尾加上字符串结束符。

OLED_ShowString(0, 2, dis);：在OLED屏幕的第三行显示dis数组中的数据。

delay_ms(2000);：延时2秒，使程序每2秒读取一次温湿度数据。

以上就是这段代码的解释，它的功能是通过DHT11传感器获取温湿度数据，并将数据显示在OLED屏幕上。

```c
// 使用SysTick延时
//注意：断电的时候才能接线！不要把VCC和GND接反！也不要给HDC1080提供5V的电压供电！不然都有可能损坏HDC1080！
// *            |              3v3|----|HDC1080 +
// *            |                 |    |
// *            |                 |    |
// *            |              GND|----|HDC1080 -
// *            |                 |    |
// *            |                 |    |
// *            |             P3.7|----|HDC1080 DA
// *            |                 |    |
// *            |                 |    |
// *            |             P3.6|----|HDC1080 CL
// *            |                 |    |
// *            |                 |    |
// *       RST -|     P3.3/UCA0TXD|----|
// *            |                 |    |
// *            |                 |    |
// *            |     P3.2/UCA0RXD|----|
/* DriverLib Includes */
#include <ti/devices/msp432p4xx/driverlib/driverlib.h>
/* Standard Includes */
#include <stdint.h>
#include <stdbool.h>
#include "myiic.h"
uint8_t TXData = 1;
uint8_t RXData = 0;
const eUSCI_UART_ConfigV1 uartConfig = { EUSCI_A_UART_CLOCKSOURCE_SMCLK, // SMCLK Clock Source
        156,                                      // BRDIV = 13
        4,                                       // UCxBRF = 0
        0,                                      // UCxBRS = 37
        EUSCI_A_UART_NO_PARITY,                  // No Parity
        EUSCI_A_UART_LSB_FIRST,                  // LSB First
        EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
        EUSCI_A_UART_MODE,                       // UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION,  // Oversampling
        EUSCI_A_UART_8_BIT_LEN                  // 8 bit data length
        };
void send_str(unsigned char *p)
{
    while (*p)
    {
        MAP_UART_transmitData(EUSCI_A0_BASE, *p++);
        delay_ms(5);
    }
}
typedef enum
{
    TEMPERATURE = 0x00,
    HUMIDITY = 0x01,
    CONFIGURATION = 0x02,
    MANUFACTURER_ID = 0xFE,
    DEVICE_ID = 0xFF,
    SERIAL_ID_FIRST = 0xFB,
    SERIAL_ID_MID = 0xFC,
    SERIAL_ID_LAST = 0xFD,
} HDC1080_Pointers;
extern int org_tem, org_hum;
unsigned char send[50];
int sendi = 0;
int main(void)
{
    unsigned char datax1[4];
    /* Halting WDT  */
    MAP_WDT_A_holdTimer();
    /* Selecting P1.2 and P1.3 in UART mode and P1.0 as output (LED) */
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(
            GPIO_PORT_P1, GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
    /* Configuring P1.0 as output */
    MAP_GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
    MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
    FlashCtl_setWaitState(FLASH_BANK0, 1);
    FlashCtl_setWaitState(FLASH_BANK1, 1);
    /* Setting DCO to 24MHz  */
    MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);
    CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_24);
    /* Enabling the FPU for floating point operation */
    MAP_FPU_enableModule();
    MAP_FPU_enableLazyStacking();
    /* Configuring UART Module */
    MAP_UART_initModule(EUSCI_A0_BASE, &uartConfig);
    /* Enable UART module */
    MAP_UART_enableModule(EUSCI_A0_BASE);
    /* Enabling interrupts */
    MAP_UART_enableInterrupt(EUSCI_A0_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT);
    MAP_Interrupt_enableInterrupt(INT_EUSCIA0);
    //MAP_Interrupt_enableSleepOnIsrExit();
    /* Enabling MASTER interrupts */
    MAP_Interrupt_enableMaster();
    delay_init(24000000); /* 初始化 SysTick */
    delay_ms(200);
    IIC_Init();
    HDC1080_Init();
    delay_ms(200);
    while (1)
    {
        I2C_Read_HDC1080_TempHumidity(HDC1080_I2C_ADDR, Temperature, datax1);
        Convert_HDC1080_TempHumidity(datax1);
        sendi = 0;
        send[sendi++] = 'T';
        send[sendi++] = 'e';
        send[sendi++] = 'm';
        send[sendi++] = 'p';
        send[sendi++] = ':';
        send[sendi++] = '0' + org_tem % 1000 / 100;
        send[sendi++] = '0' + org_tem % 100 / 10;
        send[sendi++] = '.';
        send[sendi++] = '0' + org_tem % 10;
        send[sendi++] = 'C';
        send[sendi++] = ' ';
        send[sendi++] = ' ';
        send[sendi++] = ' ';
        send[sendi++] = 'H';
        send[sendi++] = 'u';
        send[sendi++] = 'm';
        send[sendi++] = 'i';
        send[sendi++] = ':';
        send[sendi++] = '0' + org_hum % 1000 / 100;
        send[sendi++] = '0' + org_hum % 100 / 10;
        send[sendi++] = '.';
        send[sendi++] = '0' + org_hum % 10;
        send[sendi++] = '%';
        send[sendi++] = '\r';
        send[sendi++] = '\n';
        send[sendi++] = 0;
        delay_ms(1000);
    }
}
/* EUSCI A0 UART ISR - Echos data back to PC host */
void EUSCIA0_IRQHandler(void)
{
    uint32_t status = MAP_UART_getEnabledInterruptStatus(EUSCI_A0_BASE);
    if (status & EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG)
    {
        RXData = MAP_UART_receiveData(EUSCI_A0_BASE);
        if(RXData=='G')
        {
            send_str(send);
        }
        //MAP_UART_transmitData(EUSCI_A0_BASE, RXData);
    }
}
```


# 代码

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430 MSP432P401R 单片机 HDC1080 温湿度传感器程序 串口发送

实践项目5——智能风扇控制器





一、功能说明 

基于AVR单片机设计一智能风扇控制器，该控制器可选根据温度控制风扇转速。

二、具体要求 

1、设计温度检测电路，对温度进行实时检测；

2、当温度小于25℃时，风扇停转；当温度超过25℃时，风扇以全速的25%的速度旋转；超过35℃以50%的速度旋转；超过45℃以75%的速度旋转；超过60℃全速运行； 

3、温度超过85℃进行声光报警，温度正常后自动解除报警； 

4、实时显示温度与转速百分比

5、通过串口将温度与转速百分比和报警信息发送给上位机，自定义发送格式，避免相同数据重复发送；

6、具有通信故障检测报警功能；

7、其它。可根据实际情况添加其它功能。

8、其它要求见文件最后说明。

ATmega16 单片机 AVR单片机 智能风扇控制器

实践项目4——自适应电压表





一、功能说明 

基于AVR单片机设计一自适应电压表，电压表量程分为三档，电压表根据所测电压自动选择相应量程。

二、具体要求 

1、量程分为“0—1V”、“0—5V”和“0—10V”三档； 

2、测量时单片机根据检测结果自动选择量程并调整电压放大倍数； 

3、在显示屏上显示最终量程以及测量结果，并通过串口上传，自定义发送格式，避免一次测量中相同数据重复发送；；    

4、测量结果精度：量程“0—1V”结果保留3位小数，“0—5V”保留两位小数，“0—10V保留一位小数；

5、具有通信故障检测报警功能；

6、其它。可根据实际情况添加其它功能。

7、其它要求见文件最后说明。

ATmega16 单片机 AVR单片机 自适应电压表

实践项目3——多路温度采集系统





一、功能说明

基于AVR单片机设计一多路温度采集系统。

该系统由一个主机和一到三个从机构成（测试使用两个从机），能够定时检测并显示现场温度，当温度超过预置温度时，进行声光报警。

二、具体要求

1、主机与从机之间采用串口通信；

2、从机采集温度并通过串口发送给主机；

3、主机接收从机信息并显示；

4、当温度超过上下限温度时进行声光报警并通过指示灯指示报警从机号；

5、当温度再次回归正常范围时，报警自动解除；

6、报警时按下“复位”键后关闭声音；

7、各路从机上下限温度可通过按键分别设定并查询；

8、具有通信故障检测报警功能；

9、其它。可根据实际情况添加其它功能。

10、其它要求见文件最后说明。

仿真和C程序。

ATmega16 单片机 AVR单片机 多路温度采集系统

实践项目2——自动计价电子秤





一、功能说明基于AVR单片机设计一自动计价电子秤。

二、具体要求

1、开机后实时检测重量并显示；

2、可以通过按键输入单价，也可以选择预先存储的价格（多个价格）；

3、预存价格可修改；

4、确认单价后自动计算并显示总价；

5、实时显示单价、重量和总价信息；

6、其它。可根据实际情况添加其它功能。

7、其它要求见文件最后说明。

仿真和C程序。