# 功能





电风扇模拟控制系统设计

基本要求:

用LED/LCD 显示电风扇的工作状态 (1,2,3,4 四档风力),

显示风类:“自然风”、“常风”和“睡眠风”。

设计 “自然风”“常风”和“睡眠风” 三个风类键用于设置风类

设计一个“摇头”键用于控制电机摇头。

设计一个“定时”键，用于定时时间长短设置:

发挥部分:

设计过热检测与保护电路

若电风扇电机过热(用内存参数模拟温度，用键)，则电机停止转动，

蜂鸣器报警电机冷却后(用键模拟) 电机又恢复转动。

显示格式:

LED 数码管/LCD 屏显示方法自定

# 效果

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

# 部分代码

```cpp
void main(void)
{
    char t_j = 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 = 0;                  //PWM 占空比
    TBCCTL1 = OUTMOD_7;             //PWM 输出模式
    TBCTL = TBSSEL_2 + MC_1 + ID_3;      //SMCLK, UP 模式
    CCTL0 = CCIE;                         // CCR0 interrupt enabled
    CCR0 = 32768 - 1;
    TACTL = TASSEL_1 + MC_1;              // ACLK, upmode
    P5DIR = 0X00;              //其余的都是按键
    P5REN |= 0XFF;
    P5OUT = 0XFF;
    //P4.4输出给beep
    P4DIR |= BIT4;
    P4OUT &= ~BIT4;
    //P4.3输出给摇头电机
    P4DIR |= BIT3;
    P4OUT &= BIT3;
    //P4.2 继电器
    P4DIR |= 0X04;
    P4OUT |= 0X04;              //高电平是关闭继电器
    //P4.5输出
    P4DIR |= BIT5;
    P4OUT &= ~BIT5;
    __bis_SR_register( GIE);
    while (1)
    {
        delay_us(10);
        t_j++;
        if (t_j > 100)
        {
            if (Countdown_Flag)
            {
                tmp_r = (hour * 3600) + (minute * 60) + second;
                if (tmp_r>0)
                {
                    TBCCR1 = fengli[fengli_Flag_dangwei];        //每一秒钟检测一次风扇的转速
                }
                else
                {
                    fengli_Flag_dangwei = 0;
                    TBCCR1 = fengli[fengli_Flag_dangwei];        //每一秒钟检测一次风扇的转速
                }
            }
            else
            {
                TBCCR1 = fengli[fengli_Flag_dangwei];        //每一秒钟检测一次风扇的转速
            }
            Read_DS18B20(&TAM_KISIM, &ONDALIK_KISIM);
            if ((negative == 0) && (limited == 0))
            {
                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(0, 2, disp); /* 在第一行第一列显示"LCD TEST" */
            }
            if (TAM_KISIM > 50)
            {
                //P4.4输出给beep
                P4OUT &= ~BIT4;        //鸣叫
                P4OUT &= 0XFB;        //低电平是打开继电器，是关闭风扇
            }
            else
            {
                P4OUT |= BIT4;        //不鸣叫
                P4OUT |= 0X04;        //高电平是关闭继电器，是正常风扇工作
            }
            update_disp();
        }
        //按键检测
        if ((P5IN & BIT0) == 0)              //0档位风力
        {
//            delay_ms(10);
            if ((P5IN & BIT0) == 0)
            {
                fengli_Flag_dangwei = 0;
                update_disp();
                while ((P5IN & BIT0) == 0)
                    ;
            }
        }
        if ((P5IN & BIT1) == 0)              //1档位风力
        {
//            delay_ms(10);
            if ((P5IN & BIT1) == 0)
            {
                fengli_Flag_dangwei = 1;
                update_disp();
                while ((P5IN & BIT1) == 0)
                    ;
            }
        }
        if ((P5IN & BIT2) == 0)              //2档位风力
        {
//            delay_ms(10);
            if ((P5IN & BIT2) == 0)
            {
                fengli_Flag_dangwei = 2;
                update_disp();
                while ((P5IN & BIT2) == 0)
                    ;
            }
        }
        if ((P5IN & BIT3) == 0)              //3档位风力
        {
//            delay_ms(10);
            if ((P5IN & BIT3) == 0)
            {
                fengli_Flag_dangwei = 3;
                update_disp();
                while ((P5IN & BIT3) == 0)
                    ;
            }
        }
        if ((P5IN & BIT4) == 0)              //摇头电机
        {
//            delay_ms(10);
            if ((P5IN & BIT4) == 0)
            {
                if (shake_Flag == 1)
                    shake_Flag = 0;
                else
                    shake_Flag = 1;
                if (shake_Flag == 1)
                    P4OUT |= BIT3;
                else
                    P4OUT &= ~BIT3;
                update_disp();
                while ((P5IN & BIT4) == 0)
                    ;
            }
        }
        if ((P5IN & BIT5) == 0)              //加倒计时，一次加10分钟，小时不能多于12小时
        {
//            delay_ms(10);
            if ((P5IN & BIT5) == 0)
            {
                tmp_r = hour * 60 + minute;
                tmp_r += 10;
                hour = tmp_r / 60;
                minute = tmp_r % 60;
                update_disp();
                while ((P5IN & BIT5) == 0)
                    ;
            }
        }
        if ((P5IN & BIT6) == 0)              //减倒计时，一次减10分钟，分钟不能小于0
        {
//            delay_ms(10);
            if ((P5IN & BIT6) == 0)
            {
                tmp_r = hour * 60 + minute;
                if (tmp_r >= 10)
                {
                    tmp_r -= 10;
                    hour = tmp_r / 60;
                    minute = tmp_r % 60;
                }
                else
                {
                    fengli_Flag_dangwei = 0;
                    hour = 0;
                    minute = 0;
                    second=0;
                }
                update_disp();
                while ((P5IN & BIT6) == 0)
                    ;
            }
        }
        if ((P5IN & BIT7) == 0)              //定时模式的开关
        {
//            delay_ms(10);
            if ((P5IN & BIT7) == 0)
            {
                if (Countdown_Flag)
                {
                    Countdown_Flag = 0;
                    hour=0;
                    minute=0;
                    second=0;
                    fengli_Flag_dangwei=0;
                }
                else
                {
                    Countdown_Flag = 1;
                }
                update_disp();
                while ((P5IN & BIT7) == 0)
                    ;
            }
        }
    }
}
```

# 全部代码

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

【TB作品】MSP430 G2553 单片机口袋板，电风扇模拟控制系统设计

# 功能





温度测量与通信系统设计

利用MSP430G2口袋实验平台(需焊接32.768kHz晶振并使用外部晶振)的相应模块，基于MSP430G2553 MCU，CCS6.2例程进行调试，实现以下功能：

（1）开机LCD先显示AA2019三秒，123456三秒，然后在LCD显示MCU芯片温度信息xx.x℃。

（2）同时与PC进行RS232通信，05作为握手信号（PC发送，MSP430实验平台接收），当握手信号正确时，蜂鸣器响一声（1000Hz、响2秒），回送温度给PC机，格式为“测量的温度为xx.x摄氏度”；不正确时蜂鸣器响三声（2000Hz、响1秒停1秒重复三次），回送字符串给PC机，格式为“序号是05”。

通信参数设置为：波特率4800bps，校验位N，数据位8，停止位1。

参考例程

(1) http://www.hpati.com/ay_source_download/action_download_116.html

5_Interrupt_Key_LED                 中断按键（文献 [1] ch5）

7_2_Timer_Key_LED                 定时查询按键（文献 [1] ch7）

8_1_TouchPad_LED                  电容触摸按键（文献 [1] ch8）

10_UART_KeyBoard                  串口键盘（文献 [1] ch10）

14_LCD_SelfScan_Hard_or_Soft_I2C   LCD显示自检（文献 [1] ch14）

19_ADC10_Temperature               温度测量（文献 [1] ch19）

(2) http://www.ti.com/lit/sw/slac435f/slac435f.zip

MSP-EXP430G2 Software Examples (Rev. F) 


```cpp
警告：由于G2 LaunchPad上的LED2使用了P1.6（I2C引脚），所以所有涉及到I2C的实验都必须把P1.6跳线拔除,包含本例程！
 *
 *
 * P1.1接串口模块的TX    P1.2接串口模块的RX
 *
 * 程序上电后显示 AA2019 三秒钟
 *
 * 然后显示123456 三秒钟
 *
 *
 * 然后进入温度的实时刷新，使用ADC10读取芯片内部温度传感器，换算成摄氏度显示
 *
 *
 * 串口4800，8位数据，1位停止
 * 接受到05时，返回温度数值，并且让蜂鸣器1000HZ响3秒钟
 *
 * 接收到的不是05，返回警告，并且让蜂鸣器响一秒停一秒，三次，2000HZ
```

# 部分程序

```cpp
    //显示AA2019
    LCD_DisplayDigit(8, 1);
    LCD_DisplayDigit(8, 2);
    LCD_DisplayDigit(2, 3);
    LCD_DisplayDigit(0, 4);
    LCD_DisplayDigit(1, 5);
    LCD_DisplayDigit(9, 6);
    LCD_ClearSeg(4);
    LCD_ClearSeg(12);
    HT1621_Reflash(LCD_Buffer);
    TACTL = TASSEL_1 + MC_1 + TACLR; /* 打开定时器 */
    //等待3s
    delay_ms(3000);
    //显示123456
    LCD_DisplayDigit(1, 1);
    LCD_DisplayDigit(2, 2);
    LCD_DisplayDigit(3, 3);
    LCD_DisplayDigit(4, 4);
    LCD_DisplayDigit(5, 5);
    LCD_DisplayDigit(6, 6);
    HT1621_Reflash(LCD_Buffer);
    TACTL = TASSEL_1 + MC_1 + TACLR; /* 打开定时器 */
    //等待3s
    delay_ms(3000);
    /* 定时器0 检测按键的 */
    CCTL0 = CCIE;
    TACCR0 = 20000; /* 10MS */
    TACTL = TASSEL_2 + MC_0 + ID_3; //2MHZ
    _EINT();
    //初始化显示芯片内部温度
    dis_num_6(275);
    while (1)
    {
        if (ifg == 1)
        {
            ifg = 0;
            cycaaa = 2000; //响声2s
            while (cycaaa--)
            {
                //一个周期是6个数字给蜂鸣器  6个166us就是1ms  1000HZ的声音
                for (numasa = 0; numasa < 6; numasa++)
                {
                    write2DAC8411(Data[numasa]);
                    delay_us(166);
                }
            }
        }
        else if (ifg == 2)
        {
            for (xunhuan = 0; xunhuan < 3; xunhuan++)
            {
                cycaaa = 800; //响声1s应该是cycaaa=2000  太难听  适当减少点
                while (cycaaa--)
                {
                    //一个周期是6个数字给蜂鸣器  6个83us就是0.5ms  2000HZ的声音
                    for (numasa = 0; numasa < 6; numasa++)
                    {
                        write2DAC8411(Data[numasa]);
                        delay_us(83);
                    }
                }
                delay_ms(500); //停1s  适当减少了
            }
            ifg = 0;
        }
        init_ad_rxtx();
        //Print_Str("测量的温度为");
        ADC10CTL0 |= ENC + ADC10SC;                    //开始转换
        while (ADC10IFG == 0)
            ;       //等待 ADC10IFG 标志变高（转换完成）
        temp = ADC10MEM;
        IntDegC = (int) ((((float) temp - 673.0) / 1024.0) * 4230.0);
        if ((IntDegC < 1000) && (IntDegC > 0))
        {
            init_banzi();
            dis_num_6(IntDegC);
            init_ad_rxtx();
        }
        TACTL = TASSEL_1 + MC_1 + TACLR; /* 打开定时器 */
        LPM0;
    }
}
/* Timer A0 interrupt service routine */
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A(void)
{
    //正常刷新温度
    time_c++;
    if (time_c == 10)
    {
        time_c = 0;
        TACTL = TASSEL_1 + MC_0 + TACLR; /* 停下时钟 */
        //bofang(); /* 播放嘟 */
        LPM0_EXIT;
    }
}
char xianshia[6];
char count_xianshia = 0;
//  Echo back RXed character, confirm TX buffer is ready first
#pragma vector=USCIAB0RX_VECTOR
__interrupt void USCI0RX_ISR(void)
{
    //while (!(IFG2 & UCA0TXIFG))
    //    ;                // USCI_A0 TX buffer ready?
    //UCA0TXBUF = UCA0RXBUF;                    // TX -> RXed character
    if (UCA0RXBUF == 0x05)
    {
        count_xianshia = 0;
        xianshia[count_xianshia++] = IntDegC % 1000 / 100 + '0';
        xianshia[count_xianshia++] = IntDegC % 100 / 10 + '0';
        xianshia[count_xianshia++] = '.';
        xianshia[count_xianshia++] = IntDegC % 10 + '0';
        xianshia[count_xianshia++] = 0;
        Print_Str("测量的温度为");
        Print_Str(xianshia);
        Print_Str("摄氏度\r\n");
        ifg = 1;    //控制蜂鸣器
    }
    else
    {
        Print_Str("序号是05\r\n");
        ifg = 2;    //控制蜂鸣器
    }
}
```


# 全部程序

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

【TB作品】MSP430 G2553 单片机口袋板，读取单片机的内部温度显示

# 功能





ADC，读取P1.4引脚的电压，将电压显示到口袋板的显示屏。

# 部分程序



```cpp
    _EINT();
    while (1)
    {
        ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
        LPM0;
        adtest = (float) ADC10MEM / 1024.0 * 3.3;
        dis_num_6(adtest);//显示电压
    }
}
// ADC10 interrupt service routine
#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR(void)
{
    LPM0_EXIT;
}
```


# 全部代码

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

【TB作品】MSP430 G2553 单片机口袋板，ADC，读取P1.4电压，电压表

# 功能





按键修改流水灯的花型，一共四种花型。

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

# 效果

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



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

# 部分代码

```cpp
    while (1)
    {
        PinIN();
        I2C_IODect(); /*按键检测处理 */
        delay_ms(20);
        time++;
        if (time > 6)
        {
            time = 0;
            if (mode == 0)
            {
                index++;
                if (index > 7)
                {
                    index = 0;
                }
                PinOUT(0, 1); /* 指定0号管脚输出为0 */
                PinOUT(1, 1); /* 指定1号管脚输出为0 */
                PinOUT(2, 1); /* 指定0号管脚输出为0 */
                PinOUT(3, 1); /* 指定1号管脚输出为0 */
                PinOUT(4, 1); /* 指定0号管脚输出为0 */
                PinOUT(5, 1); /* 指定1号管脚输出为0 */
                PinOUT(6, 1); /* 指定0号管脚输出为0 */
                PinOUT(7, 1); /* 指定1号管脚输出为0 */
                PinOUT(index, 0); /* 指定0号管脚输出为0 */
            }
            else if (mode == 1)
            {
                if (index == 0)
                {
                    index = 7;
                }
                else
                {
                    index--;
                }
                PinOUT(0, 1); /* 指定0号管脚输出为0 */
                PinOUT(1, 1); /* 指定1号管脚输出为0 */
                PinOUT(2, 1); /* 指定0号管脚输出为0 */
                PinOUT(3, 1); /* 指定1号管脚输出为0 */
                PinOUT(4, 1); /* 指定0号管脚输出为0 */
                PinOUT(5, 1); /* 指定1号管脚输出为0 */
                PinOUT(6, 1); /* 指定0号管脚输出为0 */
                PinOUT(7, 1); /* 指定1号管脚输出为0 */
                PinOUT(index, 0); /* 指定0号管脚输出为0 */
            }
            else if (mode == 2)
            {
                index++;
                if (index > 15)
                {
                    index = 0;
                }
                PinOUT(0, 1); /* 指定0号管脚输出为0 */
                PinOUT(1, 1); /* 指定1号管脚输出为0 */
                PinOUT(2, 1); /* 指定0号管脚输出为0 */
                PinOUT(3, 1); /* 指定1号管脚输出为0 */
                PinOUT(4, 1); /* 指定0号管脚输出为0 */
                PinOUT(5, 1); /* 指定1号管脚输出为0 */
                PinOUT(6, 1); /* 指定0号管脚输出为0 */
                PinOUT(7, 1); /* 指定1号管脚输出为0 */
                if (index < 8)
                {
                    PinOUT(index, 0); /* 指定0号管脚输出为0 */
                }
                else
                {
                    PinOUT(7 - (index - 8), 0); /* 指定0号管脚输出为0 */
                }
            }
            else if (mode == 3)
            {
                index++;
                if (index > 3)
                {
                    index = 0;
                }
                PinOUT(0, 1); /* 指定0号管脚输出为0 */
                PinOUT(1, 1); /* 指定1号管脚输出为0 */
                PinOUT(2, 1); /* 指定0号管脚输出为0 */
                PinOUT(3, 1); /* 指定1号管脚输出为0 */
                PinOUT(4, 1); /* 指定0号管脚输出为0 */
                PinOUT(5, 1); /* 指定1号管脚输出为0 */
                PinOUT(6, 1); /* 指定0号管脚输出为0 */
                PinOUT(7, 1); /* 指定1号管脚输出为0 */
                if (index == 0)
                {
                    PinOUT(0, 0); /* 指定0号管脚输出为0 */
                    PinOUT(7, 0); /* 指定1号管脚输出为0 */
                }
                else if (index == 1)
                {
                    PinOUT(1, 0); /* 指定0号管脚输出为0 */
                    PinOUT(6, 0); /* 指定1号管脚输出为0 */
                }
                else if (index == 2)
                {
                    PinOUT(2, 0); /* 指定0号管脚输出为0 */
                    PinOUT(5, 0); /* 指定1号管脚输出为0 */
                }
                else if (index == 3)
                {
                    PinOUT(3, 0); /* 指定0号管脚输出为0 */
                    PinOUT(4, 0); /* 指定1号管脚输出为0 */
                }
            }
        }
    }
}
```


# 全部代码

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

【TB作品】MSP430 G2553 单片机口袋板，流水灯，按键改变花型

# 功能





针对这块开发板做了一个打地鼠游戏：

1 给单片机上电后，初始化显示界面，显示出分数和等级。

2 游戏是一轮一轮进行的，每一轮会以50%几率点亮板子上的五个小灯，表示地鼠露头需要打了。

3 一轮游戏开始后，会有一个限定时间，在限定时间内没有打完地鼠，则表示游戏结束。

4 限定时间随着等级的上升，会改变。等级越高，限定时间越短，越需要快速打地鼠。

5 等级是由分数决定的，每五分一个等级。分数是一轮游戏正确完成后，加一分。

6 游戏结束后，显示屏显示游戏结束字样，并且不再更新游戏轮数。此时需要按下S1按键，重新开始游戏。

7 打地鼠是由电容按键进行，按下后，地鼠就被打，灯会对应地熄灭。

8 上电后，需要按S1进行游戏。

9 每一轮游戏进行过程中，还没有到限定时间地鼠就被打完的情况下，游戏会直接进入下一轮，十分快，让人手忙脚乱体验打地鼠乐趣。

# 硬件

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

# 全部代码


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

【TB作品】MSP430F5529，单片机，打地鼠游戏

# 功能





Picture to pixels. Use bitmaps to tell a story. Convert pictures to bitmaps and store the bitmaps in a

header file. In the main program, draw the pictures on the OLED screen in sequence to tell a story. Use

the text to help tell the story

# 乌鸦喝水故事

部分程序

```cpp
#define u8 unsigned char
#define u16 unsigned int
void SetVcoreUp(unsigned int level);
void initClock(void);
u8 bianliang = 0;
extern unsigned char BMP1[];
extern unsigned char BMP2[];
extern unsigned char BMP3[];
extern unsigned char BMP4[];
extern unsigned char BMP5[];
unsigned char *bmpall[] = { BMP1, BMP2, BMP3, BMP4, BMP5 };
void main(void)
{
    WDTCTL = WDTPW + WDTHOLD; // Stop WDT
    // Set Vcore to accomodate for max. allowed system speed#include "HAL_PMM.h"
    initClock();
    OLED_Init();
    P1DIR &= ~BIT1;
    P1REN |= BIT1;
    P1OUT |= BIT1;
    OLED_DrawBMP(bmpall[bianliang]);
    while (1)
    {
        if ((P1IN & BIT1) == 0)
        {
            delay_ms(5);
            if ((P1IN & BIT1) == 0)
            {
                while ((P1IN & BIT1) == 0)
                    ;
                bianliang = (bianliang + 1) % 5;
                OLED_DrawBMP(bmpall[bianliang]);
            }
        }
    }
}
```

# 全部程序

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

【TB作品】MSP430F5529，单片机，Picture to pixels，乌鸦喝水OLED

# 硬件





MSP430F5529开发板+7针0.96寸OLED

/*

 * OLED引脚分配 绿色板子

 * DO(SCLK)------P4.3

 * D1(DATA)------P4.0

 * RES-----------P3.7

 * DC------------P8.2

 * CS------------P8.1

 */

# 程序功能

该程序是一个用C语言编写的，用于msp430f5529微控制器上的简单电子秒表应用。它使用OLED显示屏显示经过的时间，并允许用户通过两个按钮来控制开始/暂停计时以及存储并显示过往的计时结果。以下是程序的主要功能概述：

1. **初始化时钟**：`initClock()`函数配置微控制器的时钟系统，设置DCO（数字控制振荡器）以得到8MHz的系统时钟频率，这为程序的定时提供基础。

2. **硬件设置**：

   - 配置了OLED显示屏的接口引脚。

   - 设置了两个按键输入（P1.1和P2.1），用于控制秒表的开始/暂停和存储计时结果。

3. **显示功能**：`display()`函数在OLED显示屏上显示给定的坐标位置上的时间信息，包括小时、分钟、秒和百分秒。

4. **主循环**：

   - 监听按键事件，P1.1用于切换秒表的开始与暂停状态，P2.1用于保存当前时间到记录数组中。

   - 每次循环都会更新OLED屏上的当前时间显示，并根据已保存记录的数量显示历史计时结果。

   - 使用了简单的状态标志`start`来控制是否更新计时（即是否在计时中）。

5. **定时中断服务例程**：通过Timer_A中断（每10ms触发一次），更新毫秒级和百分秒级的时间计数。当`start`标志为真时，表示秒表正在运行，此时会增加计时。

6. **记录功能**：程序能存储最多三条计时结果，当用户按下P2.1按钮时，当前的计时结果会被存储到数组`rtc_timeJILU`和`rtc_time_100msJILU`中，并在屏幕上显示这些记录。

综上所述，此程序设计用于实现一个具有基本计时、暂停、继续以及存储和显示多个计时结果功能的电子秒表，适用于运动计时、实验计时等多种场景。


# 部分程序

```cpp
    while (1)
    {
        if ((!(P1IN & BIT1)) && (keyifg1 == 0)) /*按键按下 且有状态 */
        {
            start = !start; /* 开始或者暂停 */
            keyifg1 = 1; /* 失去状态 */
        }
        if ((!(P2IN & BIT1)) && keyifg2 == 0) /*按键按下 且有状态 */
        {
            keyifg2 = 1; /* 失去状态 */
            /* 增加一条记录 */
            if (jilutiaoshu == 0) /* 一条记录都没有 */
            {
                rtc_timeJILU[0] = rtc_time;
                rtc_time_100msJILU[0] = rtc_time_100ms;
            }
            else if (jilutiaoshu == 1)
            {
                rtc_timeJILU[1] = rtc_timeJILU[0];
                rtc_time_100msJILU[1] = rtc_time_100msJILU[0];
                rtc_timeJILU[0] = rtc_time;
                rtc_time_100msJILU[0] = rtc_time_100ms;
            }
            else
            { /* 已经有2条记录以上就需要轮换 */
                rtc_timeJILU[2] = rtc_timeJILU[1];
                rtc_time_100msJILU[2] = rtc_time_100msJILU[1];
                rtc_timeJILU[1] = rtc_timeJILU[0];
                rtc_time_100msJILU[1] = rtc_time_100msJILU[0];
                rtc_timeJILU[0] = rtc_time;
                rtc_time_100msJILU[0] = rtc_time_100ms;
            }
            if (jilutiaoshu < 3)
                jilutiaoshu++; /*有多少条记录 */
        }
        display(0, 0, rtc_time, rtc_time_100ms); /* 显示秒表时间 */
        if (jilutiaoshu == 1) /*有一条记录 */
        {
            display(8 * 4, 2, rtc_timeJILU[0], rtc_time_100msJILU[0]);
        }
        else if (jilutiaoshu == 2) /*有2条记录 */
        {
            display(8 * 4, 2, rtc_timeJILU[0], rtc_time_100msJILU[0]);
            display(8 * 4, 4, rtc_timeJILU[1], rtc_time_100msJILU[1]);
        }
        else if (jilutiaoshu == 3) /*有3条记录 */
        {
            display(8 * 4, 2, rtc_timeJILU[0], rtc_time_100msJILU[0]);
            display(8 * 4, 4, rtc_timeJILU[1], rtc_time_100msJILU[1]);
            display(8 * 4, 6, rtc_timeJILU[2], rtc_time_100msJILU[2]);
        }
        if ( P1IN & BIT1) /*按键松开 */
        {
            keyifg1 = 0; /* 状态恢复 */
        }
        if ( P2IN & BIT1) /*按键松开 */
        {
            keyifg2 = 0; /* 状态恢复 */
        }
        delay_ms(10);
    }
}
/* Timer A0 interrupt service routine */
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A(void)
{
    if (start) /* 如果是开始的 */
    {
        rtc_time_100ms++; /* 过去了100ms */
        if (rtc_time_100ms == 100)
        {
            rtc_time_100ms = 0;
            rtc_time++; /* 过去了1秒钟 */
        }
    }
}
```


# 流程图

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

# 全部程序

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

【TB作品】MSP430F5529，单片机，电子秒表，秒表

以下是一个针对这个程序的详细实验报告：





实验名称: 利用声音控制LED灯的设备实验

目的: 利用声音控制LED灯的开关，实现对声音强度的简单反馈。

实验设备:

1. MSP430开发板

2. Sound Sensor (声音传感器)

3. LED灯

4. 可编程的开发环境

实验步骤:

1. 首先，我们在MSP430开发板上布线，将LED连接到P3.3，将声音传感器的输出连接到P3.4。

2. 然后，我们开始编写我们的代码，首先包含了我们需要的头文件，然后是一个延时函数定义。

3. 使用initClock()函数初始化时钟系统。在这个函数中，我们设置了DCO FLL的参考为REFO，ACLK也为REFO。我们设置了DCO的范围为16MHz，并开启了FLL控制环路。

4. 在主函数中，首先停止了看门狗计时器，然后调用了initClock()函数初始化时钟。LED和声音传感器的接口被设置为适当的模式，并设置了定时器。

5. 在一个无线循环中，我们首先检查是否有声音信号。如果有，延迟一点再次检查，如果还有声音信号，LED就会被打开。然后是一个长延时，然后继续下一个循环。

6. 在TIMER0_A0的中断服务函数中，如果LED开启的时间大于10秒，就会关闭LED。否则，就增加ledopen变量的值。

实验结果:

1. 没有声音时，LED灯没有亮。

2. 当有声音出现时，LED灯亮起。

3. 如果LED灯亮了10秒还未再次获取到声音信号，LED灯就会熄灭。

结论:

实验成功地实现了声音控制LED开关的目标，此程序可以灵活地响应环境中的声音变化，并可以通过LED灯的开关状态显示出这些变化。实验证明，MSP430开发板具有很好的实时性和可编程性，非常适合进行这种实时控制的实验。

可能的改进:

考虑到环境中可能存在的噪声，我们可以将声音检测的阈值设大一些，以避免误操作。此外，由于声音传感器通常都有一定的辐射角，为了扩大有效控制范围，可以使用多个声音传感器进行联合控制。




全部代码

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

【TB作品】msp430f5529单片机，声控灯，声控延时灯

# 功能





5529给串口发送实时时间。

可以通过串口修改万年历时间。

# 部分代码

```cpp
void main(void)
{
    WDTCTL = WDTPW + WDTHOLD; // Stop WDT
    initClock();
    SetupRTC();
    init_uart();
    Print_Str("MSP430F5529串口测试\r\n");
    delay_ms(100);
    //LED
    P1DIR |= (BIT0);
    P1OUT &= ~(BIT0);         //关灯0
    _EINT();
    while (1)
    {
    }
}
// Echo back RXed character, confirm TX buffer is ready first
#pragma vector=USCI_A1_VECTOR
__interrupt void USCI_A1_ISR(void)
{
    static unsigned char revbuff = 0;
    static unsigned char rev_modify_ifg = 0;
    static unsigned char rev_modify_count = 0;
    static unsigned char rev_modify_buffer[30]; //A2020-11-11B12:12:12Z2
    switch (__even_in_range(UCA1IV, 4))
    {
    case 0:
        break;                             // Vector 0 - no interrupt
    case 2:                                   // Vector 2 - RXIFG
//        while (!(UCA1IFG & UCTXIFG))
//            ;             // USCI_A0 TX buffer ready?
//        UCA1TXBUF = UCA1RXBUF;                  // TX -> RXed character
        revbuff = UCA1RXBUF;
        if (revbuff == 'A')
        {
            rev_modify_ifg = 1;
            rev_modify_count = 0;
        }
        if (rev_modify_ifg == 1)
        {
            rev_modify_buffer[rev_modify_count++] = revbuff;                //缓存
            if (rev_modify_count == 22)
            {
                rev_modify_ifg = 0;                                   //不再接受
                RTCCTL01 = RTCHOLD + RTCMODE + RTCTEV_0; //关闭RTC
                RTCYEAR=(rev_modify_buffer[1]-'0')*1000+(rev_modify_buffer[3]-'0')*100+(rev_modify_buffer[3]-'0')*10+(rev_modify_buffer[4]-'0')*1;
                RTCMON=(rev_modify_buffer[6]-'0')*10+(rev_modify_buffer[7]-'0')*1;
                RTCDAY=(rev_modify_buffer[9]-'0')*10+(rev_modify_buffer[10]-'0')*1;
                RTCHOUR=(rev_modify_buffer[12]-'0')*10+(rev_modify_buffer[13]-'0')*1;
                RTCMIN=(rev_modify_buffer[15]-'0')*10+(rev_modify_buffer[16]-'0')*1;
                RTCSEC=(rev_modify_buffer[18]-'0')*10+(rev_modify_buffer[19]-'0')*1;
                RTCDOW=(rev_modify_buffer[21]-'0');
                RTCCTL0 |= RTCRDYIE; /* RTCRDY中断使能 */
                RTCCTL01 &= ~RTCHOLD; //打开RTC
            }
        }
        break;
    case 4:
        break;                             // Vector 4 - TXIFG
    default:
        break;
    }
}
#pragma vector=RTC_VECTOR
__interrupt void RTC_ISR(void)
{
    switch (__even_in_range(RTCIV, RTC_RT1PSIFG))
    {
    case RTC_NONE:
        break;
    case RTC_RTCRDYIFG:
    {
        /* RTCDOW   RTCMON   RTCDAY  RTCHOUR  RTCMIN RTCSEC */
        //读取时间
        nian = RTCYEAR;
        yue = RTCMON;
        ri = RTCDAY;
        shi = RTCHOUR;
        fen = RTCMIN;
        miao = RTCSEC;
        zhou = RTCDOW;
        //闪烁灯
        P1OUT ^= BIT0;
        //发送串口
        memset(buf, 0, sizeof(buf));
        sprintf(buf, "%d-%02d-%02d \r\n", nian, yue, ri);
        Print_Str(buf);
        memset(buf, 0, sizeof(buf));
        sprintf(buf, "week %d \r\n", zhou);
        Print_Str(buf);
        memset(buf, 0, sizeof(buf));
        sprintf(buf, "%02d:%02d:%02d \r\n\r\n", shi, fen, miao);
        Print_Str(buf);
    }
        break;
    case RTC_RTCTEVIFG:
        break;
    case RTC_RTCAIFG:
        break;
    case RTC_RT0PSIFG:
        break; /* 分频器 0 */
    case RTC_RT1PSIFG:
        break; /* 分频器 1 */
    default:
        break;
    }
    __no_operation();
}
```

# 全部代码


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

【TB作品】MSP430F5529单片机，基于串口的万年历

# 功能






//1.在oled屏上面显示出年月日，小时，分钟，秒，可以通过按键来调整时间

//

//2.一个闹钟功能，通过按键设置闹钟的时间，到点了需要蜂鸣器响和LED闪烁

//

//3.一个倒计时，跟闹钟差不多，也是通过按键设置时间，到时间了LED闪烁

# 接线

//OLED----MSP430

//VCC-----3.3V

//GND-----GND

//D0------P3.2

//D1------P3.0

//RES-----P2.0

//DC------P2.2

//CS------P8.1

# 部分代码

```cpp
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "m%d ", mode);
    OLED_ShowString(100, 16, buf, 16);
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "%02d:%02d:%02d", alarm_h, alarm_m, alarm_s);
    OLED_ShowString(0, 32, buf, 16);
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "%02d:%02d:%02d", DJS_h, DJS_m, DJS_s);
    OLED_ShowString(0, 48, buf, 16);
    OLED_Refresh_Gram();         //Update display to OLED
    while (1)
    {
        if ((P2IN & BIT1) == 0)
        {
            if ((P2IN & BIT1) == 0)
            {
                mode++;
                if (mode == 14)
                    mode = 0;
                memset(buf, 0, sizeof(buf));
                sprintf(buf, "m%d ", mode);
                OLED_ShowString(100, 16, buf, 16);
//                while ((P2IN & BIT1) == 0)
//                    ;
            }
        }
        else if ((P1IN & BIT1) == 0)
        {
            if ((P1IN & BIT1) == 0)
            {
                if (mode == 1)
                {
                    RTCCTL01 = RTCHOLD + RTCMODE + RTCTEV_0; //关闭RTC
                    RTCYEAR++;
                    if (RTCYEAR == 2030)
                        RTCYEAR = 2010;
                    RTCCTL0 |= RTCRDYIE; /* RTCRDY中断使能 */
                    RTCCTL01 &= ~RTCHOLD; //打开RTC
                }
                else if (mode == 2)
                {
                    RTCCTL01 = RTCHOLD + RTCMODE + RTCTEV_0; //关闭RTC
                    RTCMON++;
                    if (RTCMON == 13)
                        RTCMON = 1;
                    RTCCTL0 |= RTCRDYIE; /* RTCRDY中断使能 */
                    RTCCTL01 &= ~RTCHOLD; //打开RTC
                }
                else if (mode == 3)
                {
                    RTCCTL01 = RTCHOLD + RTCMODE + RTCTEV_0; //关闭RTC
                    RTCDAY++;
                    if (RTCDAY == 31)
                        RTCDAY = 1;
                    RTCCTL0 |= RTCRDYIE; /* RTCRDY中断使能 */
                    RTCCTL01 &= ~RTCHOLD; //打开RTC
                }
                else if (mode == 4)
                {
                    RTCCTL01 = RTCHOLD + RTCMODE + RTCTEV_0; //关闭RTC
                    RTCHOUR++;
                    if (RTCHOUR == 24)
                        RTCHOUR = 0;
                    RTCCTL0 |= RTCRDYIE; /* RTCRDY中断使能 */
                    RTCCTL01 &= ~RTCHOLD; //打开RTC
                }
                else if (mode == 5)
                {
                    RTCCTL01 = RTCHOLD + RTCMODE + RTCTEV_0; //关闭RTC
                    RTCMIN++;
                    if (RTCMIN == 60)
                        RTCMIN = 0;
                    RTCCTL0 |= RTCRDYIE; /* RTCRDY中断使能 */
                    RTCCTL01 &= ~RTCHOLD; //打开RTC
                }
                else if (mode == 6)
                {
                    RTCCTL01 = RTCHOLD + RTCMODE + RTCTEV_0; //关闭RTC
                    RTCSEC++;
                    if (RTCSEC == 60)
                        RTCSEC = 0;
                    RTCCTL0 |= RTCRDYIE; /* RTCRDY中断使能 */
                    RTCCTL01 &= ~RTCHOLD; //打开RTC
                }
                else if (mode == 7)
                {
                    alarm_h++;
                    if (alarm_h == 24)
                        alarm_h = 0;
                }
                else if (mode == 8)
                {
                    alarm_m++;
                    if (alarm_m == 60)
                        alarm_m = 0;
                }
                else if (mode == 9)
                {
                    alarm_s++;
                    if (alarm_s == 60)
                        alarm_s = 0;
                }
                else if (mode == 10)
                {
                    DJS_h++;
                    if (DJS_h == 24)
                        DJS_h = 0;
                }
                else if (mode == 11)
                {
                    DJS_m++;
                    if (DJS_m == 60)
                        DJS_m = 0;
                }
                else if (mode == 12)
                {
                    DJS_s++;
                    if (DJS_s == 60)
                        DJS_s = 0;
                }
                else if (mode == 13)
                {
                    //开始倒计时
                    DJS_IFG = 0;
                    DJS_start = 1;
                }
//                while ((P1IN & BIT1) == 0)
//                    ;
            }
        }
        memset(buf, 0, sizeof(buf));
        sprintf(buf, "%02d:%02d:%02d", alarm_h, alarm_m, alarm_s);
        OLED_ShowString(0, 32, buf, 16);
        memset(buf, 0, sizeof(buf));
        sprintf(buf, "%d-%02d-%02d", nian, yue, ri);
        OLED_ShowString(0, 0, buf, 16);
        memset(buf, 0, sizeof(buf));
        sprintf(buf, "%02d:%02d:%02d", shi, fen, miao);
        OLED_ShowString(0, 16, buf, 16);
        memset(buf, 0, sizeof(buf));
        sprintf(buf, "%02d:%02d:%02d", DJS_h, DJS_m, DJS_s);
        OLED_ShowString(0, 48, buf, 16);
        OLED_Refresh_Gram(); //Update display to OLED
        //闹钟闪烁灯
        if (alarm_ifg == 1)
        {
            P1OUT ^= BIT0;
            delay_ms(50);
        }
        //倒计时
        if (DJS_IFG == 1)
        {
            P4OUT ^= BIT7;
            delay_ms(50);
        }
    }
}
// Timer0 A0 interrupt service routine
#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR(void)
{
    int DJS = 0;
    if (DJS_start == 1)
    {
        DJS = DJS_h * 3600 + DJS_m * 60 + DJS_s; //倒计时多少秒
        if (DJS > 0)
        {
            DJS--;
            DJS_h = DJS / 3600;
            DJS_m = DJS % 3600 / 60;
            DJS_s = DJS % 3600 % 60;
        }
        else
        {
            DJS_start = 0; //不开始了
            DJS_IFG = 1; //倒计时结束标志
            DJS_time = 10; //闹腾10s
            BEEPOPEN; //打开PWM
        }
    }
    if (DJS_IFG == 1)
    {
        if (DJS_time > 0)
        {
            DJS_time--; //闹钟时间10s
        }
        else if (DJS_time == 0)
        {
            DJS_IFG = 0; //关闭定时器结束标志
            BEEPCLOSE; //关PWM
            P4OUT &= ~(BIT7); //关灯0
        }
    }
    if (alarm_ifg == 1)
    {
        if (alarm_time > 0)
        {
            alarm_time--; //闹钟时间10s
        }
        else if (alarm_time == 0)
        {
            alarm_ifg = 0; //关闭闹钟
            BEEPCLOSE; //关PWM
            P1OUT &= ~(BIT0); //关灯0
        }
    }
}
```


# 全部代码

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

【TB作品】MSP430F5529单片机，时钟闹钟倒计时，万年历，闹钟，倒计时

智能储物柜将实现的功能：





1在超市或者机场场景下，用户需要进行物品暂存时。按下储物柜键盘的需求按键，智能储物柜将会随机为用户分配一个还没使用的柜子，屏幕提示用户选择密码存储方式或者身份证存储方式；

2 用户选择密码存储方式后，用户需要根据屏幕提示（提示出可选柜子编号）输入想要的柜子编号（实物柜子有大有小可以选择），用户需要输入想要设置的8位数字密码，然后输入第二次相同的8位数字密码进行确认。用户输入的密码不能和之前别人设置的密码相同，智能储物柜系统检测到用户输入密码有5位和别人设置的密码相同就会提示重新设置一个数字密码。如果两次输入的数字密码一样，则智能储物柜系统将会把这个数字密码和分配的柜子号码进行绑定，然后控制柜门自动打开。如果两次输入的数字密码不一样，屏幕将提示用户重新进行操作；

3 用户选择身份证证存储方式，和密码存储方式相似，用户输入想要的柜子编号后，需要根据屏幕提示将身份证放入刷卡区域，等待系统确认后自动为其打开储物柜。用户将想要存储的物品放置于柜中后，需要手动关闭柜门；

5 当用户想要取回物品时，需要按下储物柜键盘的取回按键，然后根据屏幕提示选择密码方式取回或者身份证方式取回，根据屏幕提示输入自己设置的八位密码或者刷身份证，最后智能储物柜系统就会自动将用户的柜子打开；

6 当遇到恶意操作，比如某人想要盗取不属于自己的物品，如果使用者进行了3次取回操作后依旧打不开对应柜子，智能储物柜系统将会进行蜂鸣器报警3秒钟起到威慑作用，然后自行解除报警。

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

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

代码和原理图

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

【TB作品】MSP430G2553单片机，智能储物柜

msp430f5529d单片机墨水屏，口袋板，tmp421温度，温控风扇





基本要求：高于20度开转，温度越高转速越快，高于40度风扇停转，温度报警器报警，同时水墨屏上显示实时温度。


# 一、扬声器模块介绍


//BEEP P36

平时没事就低电平。需要响就高低电平变换pwm输出。

蜂鸣器拔起来看看，是不是接对了。

蜂鸣器的正负别接错了，在蜂鸣器最顶上+号就是接vcc。

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

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


# 二、驱动介绍

P1.5 输出高电平，驱动芯片就处于工作状态。

P2.4 输出低电平，那么OUT1就输出低电平。

P2.5 输出低电平，那么OUT2就输出低电平。

P6跳线帽接1和2，那么OUT1高电平，OUT2低电平，灯就亮。控制灯亮的程度可以让P2.5输出PWM控制，占空比越高，灯就越亮。

电机同理，但是这个驱动供电是3.3v，电机需要也是3.3v的小电机，太大是带不动的，就需要外接驱动了。



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

# 三、程序介绍

最高最低温度改这里：

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

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



# 四、全部代码下载


下载：

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


资料：

[https://qq742971636.blog.csdn.net/article/details/112093263](https://qq742971636.blog.csdn.net/article/details/112093263)

[https://qq742971636.blog.csdn.net/article/details/103341709](https://qq742971636.blog.csdn.net/article/details/103341709)

【TB作品】msp430f5529单片机墨水屏，口袋板，tmp421温度，温控风扇

# 一、部分程序





```cpp
int main(void)
{
    WDTCTL = WDTPW | WDTHOLD; //关闭看门狗
    init();                     //屏幕初始化
    InitIIC();     //I2C初始化
    TMP_Init();     //tmp421初始化
    SetupRTC();
    _EINT();
    while (1)
    {
    }
}
#pragma vector=RTC_VECTOR
__interrupt void RTC_ISR(void)
{
    switch (__even_in_range(RTCIV, RTC_RT1PSIFG))
    {
    case RTC_NONE:
        break;
    case RTC_RTCRDYIFG:
    {
        Temp_MSB = R_I2C(0x55, 0x00);          //读MSB  高八位，表达整数部分
        Temp_LSB = R_I2C(0x55, 0x10);       //读LSB  第八位，高四位有效，表达小数部分，一格代表0.0625℃
        Temp_LSB = Temp_LSB >> 4;           //右移四位
        float Temp_value = Temp_LSB * 0.0625; //小数部分处理
        unsigned char Temp_LSB1 = Temp_value * 100;
        sprintf(buf1, "%d", Temp_MSB);        //类型转换
        sprintf(buf2, "%d", Temp_LSB1);
        Init_buff();                        //数据显示
        //display("Temperature:", 20, 12, 0, 1, 0, 0);
        display(&buf1, 80, 84, 0, 1, 0, 0);
        display(".", 128, 84, 0, 1, 0, 0);
        display(&buf2, 144, 84, 0, 1, 0, 0);
        /* RTCDOW   RTCMON   RTCDAY  RTCHOUR  RTCMIN RTCSEC */
        //读取时间
        nian = RTCYEAR;
        yue = RTCMON;
        ri = RTCDAY;
        shi = RTCHOUR;
        fen = RTCMIN;
        miao = RTCSEC;
        zhou = RTCDOW;
    }
        break;
    case RTC_RTCTEVIFG:
        break;
    case RTC_RTCAIFG:
        break;
    case RTC_RT0PSIFG:
        break; /* 分频器 0 */
    case RTC_RT1PSIFG:
        break; /* 分频器 1 */
    default:
        break;
    }
    __no_operation();
}
```


# 二、展示

显示实时时间和温度。

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

# 三、全部代码下载


下载：

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


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

资料：

[https://qq742971636.blog.csdn.net/article/details/112093263](https://qq742971636.blog.csdn.net/article/details/112093263)

[https://qq742971636.blog.csdn.net/article/details/103341709](https://qq742971636.blog.csdn.net/article/details/103341709)

【TB作品】msp430f5529单片机墨水屏，口袋板，显示温度和万年历，tmp421温度，RTC时间

DS2401是由Analog Devices公司生产的一种硅序列号芯片，它提供了一个绝对唯一的64位ROM识别码，用于确保可追溯性。以下是对DS2401器件的分析：





### 特点和优势：

1. **唯一性**：每个DS2401芯片都有一个独一无二的64位注册码，由8位家族代码、48位序列号和8位CRC校验码组成。

2. **简化的1-Wire®接口**：降低了成本和接口复杂性，允许多个DS2401设备共享一个1-Wire网络。

3. **内置多路复用控制器**：确保与其他1-Wire网络产品的兼容性。

4. **低成本封装**：提供TO-92、SOT-223和TSOC表面贴装封装。

5. **宽电压和温度范围**：适用于-40°C至+85°C的工业温度范围，工作电压范围为2.8V至6.0V。

### 应用领域：

- **PCB识别**：用于识别和追踪印刷电路板。

- **网络节点ID**：在网络系统中作为节点的唯一标识。

- **设备注册**：用于设备注册和管理。

### 引脚配置：

- **DATA (DQ)**：数据引脚，用于1-Wire通信。

- **GROUND**：地线引脚。

- **N.C. (No Connect)**：无连接引脚。

### 订购信息：

提供了不同温度范围和封装类型的DS2401变体，例如：

- DS2401+：-40°C至+85°C，3引脚TO-92封装。

- DS2401P+：-40°C至+85°C，6引脚TSOC封装。

- DS2401Z+：-40°C至+85°C，4引脚SOT-223封装。

### 工作原理：

- DS2401通过1-Wire协议进行数据传输，该协议只需要一条数据线和地线返回。

- 电源通过数据线本身提供，无需外部电源。

- DS2401与DS2400完全反向兼容，但提供了多点能力，允许多个设备共存于单一数据线上。

### 1-Wire总线系统：

- 1-Wire总线系统由一个总线控制器和一个或多个外设组成，DS2401作为外设。

- 总线控制器通常是微控制器。

- 1-Wire总线的空闲状态为高电平，最大数据传输速率为16.3kbps。

### 存储器映射：

DS2401的64位ROM包括：

- 8位CRC校验码

- 48位序列号

- 8位家族代码[01h]

### 交易序列：

通过1-Wire端口访问DS2401的序列包括初始化、ROM功能命令和数据读取。

### 1-Wire信号：

DS2401要求严格的协议以确保数据完整性，包括重置序列、写0、写1和读数据。

### CRC生成：

为了验证从DS2401传输的数据，总线控制器可以从接收到的数据生成CRC值，并与DS2401中存储的最后8位的值进行比较。

### 定制DS2401：

Analog Devices提供定制服务，可以在48位序列号的12位最显著位中注册并分配特定的客户ID。

### 绝对最大额定值和电气特性：

文档提供了详细的电气特性和绝对最大额定值，包括工作电压范围、存储温度范围、引脚温度（焊接时）等。

### 封装信息：

提供了不同封装类型的详细信息，包括TO-92、TSOC、SOT-223、Flip Chip和WLP。




接线：

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



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


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


帮助：

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

【TB作品】stm32单片机读取DS2401程序

https://github.com/cv516Buaa/tph-yolov5





# 问询、帮助

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

 



“防火未燃”——渡船汽车火源和烟雾检测研究

2.1设计思路

1. 获取数据集。由于在船舱内部的火源图像数据较少，通过百度AI Studio、Kaggle公开的火源数据集、爬取百度火源图片等作为数据集来源，通过数据清洗，最终获得训练集8268张，测试集1167张，验证集1166张共计10601张。

2.标注数据集。采用标注工具LabelImg对未标注数据集进行标注，对已标注但格式不同的数据集进行格式转换，共标记两个类别，分别是yanwu（烟雾）和fire（火）。

3.搭建模型。模型采用TPH-YOLOv5[10]算法为基础，该模型识别密集物体，小物体效果显著。

4.修改模型。算法引入轻量化模块Ghost模块[11]，训练后的模型计算量参数量有效降低，加速模型推理。

5.训练模型。实验环境使用Ubuntu20.04操作系统，使用RTX5000显卡进行运算，显存大小为64GB，CPU配置为Intel@Xeon(R) Silver 4210R CPU @ 2.40GHz ×40，CUDA版本为10.1，Pytorch版本为1.10.1，Python语言环境为3.6.13。

6.目标检测。使用训练好的模型进行目标检测。

 图3设计思路

2.2研究方法

2.2.1计算机视觉原理（Computational Vision）

计算机视觉就是给出一张二维图像，计算机视觉系统识别出图像中的对象及其特征，如形状、纹理、颜色、大小、空间排列等，从而尽可能完整地描述该图像。

 

图4计算机视觉原理

2.2.2卷积原理（Conv）

Conv 是从视觉皮层的生物学上获得启发的。视觉皮层有小部分细胞对特定部分的视觉区域敏感。Hubel 和 Wiesel 发现视觉皮层的神经元细胞（卷积核）会寻找特定特征，这在机器中同样适用。

 

图5卷积原理

3.创新特色

通过引入C3Ghost模块替代原有的C3模块，用线性变换替代了部分卷积，降低了模型的计算量和参数量，加快了推理速度，下面从TPH-YOLOV5、Ghost模块、GhostBottleneck、改进进行详细介绍。

3.1采用TPH-YOLOV5应用到火源检测

TPH-YOLOV5为解决航拍高速和低空飞行导致的密集小物体的检测较差问题，增加了一个预测head以适应检测小物体；用Transformer Prediction Head（TPH）[12]代替了原有预测头，用自注意力机制进行预测；融合了CBAM[13]找到密集物体的注意区域采用数据增强，多尺度测试，多模型融合，用额外的分类方式提高了模型精度。

 

图5 TPH-YOLOV5网络结构图

3.2引入轻量化模型

深度卷积神经网络通常引用由大量卷积组成的卷积神经网络，导致大量的计算成本。Google的MobileNet[14 ]和ShuffleNet [15 ]引入了深度可分离卷积操作，以使用较小的卷积核来构建有效的CNN，其余卷积层仍将占用大量内存和FLOPs，这些卷积层在提取特征图时通常会包含丰富甚至冗余的特征图，以保证对输入数据有全面的理解。轻量化卷积Ghost模块的引入用“廉价”卷积代替普通卷积，改进后的TPH-YOLOV5模型，参数量和计算量都有所降低，推理速度加快。

 

图6普通卷积

Ghost模块是Han等人在保证检测精度的基础上，减少传统卷积神经网络的计算量与参数量而提出的一种轻量化神经网络，模型主要思想是利用“廉价”的方式，通过线性变换操作代替部分产生冗余特征图的传统卷积操作。

 

图7 Ghost 模块

利用Ghost模块生成与普通卷积层相同数量的特征图，可以轻松地将Ghost模块替换卷积层，集成到现有设计好的神经网络结构中，减少计算成本。Ghost模块具有一个恒等映射（Identity）和（s-1）个线性运算，并且每个线性运算的平均内核大小为n/s·h^'·w^'·d·d。理想情况下，（s-1）个线性运算可以具有不同的形状和参数，但是特别是考虑到CPU或GPU的实用性，在线推理会受到阻碍。因此，在一个Ghost模块中采用相同大小的线性运算以高效实现Ghost模块。使用Ghost模块升级普通卷积的理论加速比和模型压缩比为

r_s=(n·h^'·w^'·c·k·k)/(n/s·h^'·w^'·c·k·k+（s-1）·n/s·h^'·w^'·d·d)

=(c·k·k)/(1/s·c·k·k+(s-1)/s·d·d)≈(s·c)/(s+c-1)≈s （1）

r_c=(n·c·k·k)/(n/s·c·k·k+（s-1）·n/s·d·d)≈(s·c)/(s+c-1)≈s （2）

r_s是理论加速比；r_c是模型压缩比，n是输出特征图的通道数：h^' 、w^'分别为输出特征图的高、宽；c是输入的通道数；k·k卷积核大小；d·d是每一个线性操作的平均卷积核大小；s是所分的组数，s-1为Ghost的个数。

Ghost Bottleneck：利用Ghost模块的优势，专门为小型CNN设计的Ghost bottleneck（G-bneck）。如图8所示，Ghost bottleneck类似于ResNet中的基本残差块（Basic Residual Block），其中集成了多个卷积层和shortcut。Ghost bottleneck主要由两个堆叠的Ghost模块组成。

 

图8 Ghost bottleneck

由Ghost bottleneck组成的C3Ghost模块替换C3模块，利用“廉价”的方式获得和普通卷积相同的特征，降低了模型的参数量和计算量，加快了推理速度。

3.3火源和烟雾目标检测

改进后的模型在训练时只用了400个epoch，就可以准确的对火源和烟雾目标进行检测。模型的具体参数放到了补充材料里。因当前关于渡船的小火源目标检测较少，所以后期优化将重点放在火源小目标的获取和检测上，不断提高模型对小目标的检测精度。

 

图9火源和烟雾目标检测效果

【TB作品】tph-yolov5 火焰 烟雾 检测

# 需求





基于stm32单片机的指纹识别考勤系统

硬件：

stm32f103最小系统板、as608指纹模块、0.96寸oled显示屏、usb转ttl模块、温湿度dht11传感器、蜂鸣器、 GY-906红外测温模块、电磁门开门指示灯led

单片机软件功能：

（1）测温湿度显示到oled屏幕，并把温湿度串口发给上位机

（2）红外测温显示到oled屏幕，并把温度串口发给上位机

（3）用单片机按键搭配as608指纹模块，实现指纹录入、指纹删除功能

（4）指纹正确，oled显示ok，电磁门开门指示灯led亮2秒，表示正常开门，然后led熄灭

（5）指纹错误，oled显示error，蜂鸣器响5秒，表示开门失败

上位机电脑软件功能：

（1）用python写一个显示界面

（2）显示出单片机发过来的温湿度、红外测温

（3）可以通过上位机软件删除指纹，并与单片机通信同步

（5）显示已打卡的人数和未打卡人数（即是录入的所有指纹中，已打卡和未打卡的）

交付：

（1）单片机程序

（2）上位机程序

（3）电路图

（4）pcb图

（5）实物

（6）视频使用教程

（7）lunwen材料

#  实物图

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

# 上位机图

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

# 程序流程图



```mermaid
graph LR
A[开始] --> B{按键状态检测}
B -- 按键按下 --> C[消抖处理]
C --> D{按键动作识别}
D -- 按下 --> E[生成按下事件]
D -- 释放 --> F[生成释放事件]
E --> G[系统处理按下事件]
F --> H[系统处理释放事件]
G --> I[结束]
H --> I[结束]
B -- 无按键按下 --> I[结束]
```


```mermaid
graph LR
A[开始] --> B{模式检测}
B -- 模式0 --> C[显示考勤]
B -- 模式1 --> D[显示录入指纹]
B -- 模式2 --> E[显示删除指纹]
C --> F[显示温湿度]
C --> G[显示红外测温]
C --> H[显示指纹统计]
D --> I[显示录入指纹提示]
E -- 无指纹ID --> J[显示无ID删除提示]
E -- 有指纹ID --> K[显示删除指纹ID提示]
F --> L[结束]
G --> L[结束]
H --> L[结束]
I --> L[结束]
J --> L[结束]
K --> L[结束]
```



录指纹流程的Mermaid流程图：

```mermaid
graph LR
A[开始] --> B{获取指纹图像}
B -- 成功 --> C[生成特征]
C -- 成功 --> D{再次获取指纹图像}
D -- 成功 --> E[生成第二个特征]
E -- 成功 --> F[对比两次指纹]
F -- 成功 --> G[生成指纹模板]
G -- 成功 --> H[储存模板]
H -- 成功 --> I[结束]
B -- 失败 --> J[结束]
C -- 失败 --> J[结束]
D -- 失败 --> J[结束]
E -- 失败 --> J[结束]
F -- 失败 --> J[结束]
G -- 失败 --> J[结束]
H -- 失败 --> J[结束]
```

。

刷指纹流程的Mermaid流程图：

```mermaid
graph LR
A[开始] --> B[蜂鸣器响一次]
B --> C[获取指纹图像]
C -- 成功 --> D[生成特征]
D -- 成功 --> E[高速搜索]
E -- 成功 --> F[显示成功并开门]
E -- 失败 --> G[显示错误]
D -- 失败 --> G[显示错误]
C -- 失败 --> G[显示错误]
F --> H[结束]
G --> H[结束]
```



删除指纹流程的Mermaid流程图：

```mermaid
graph LR
A[开始] --> B[蜂鸣器响一次]
B --> C[输入指纹ID]
C -- 输入有效 --> D[删除指纹]
D -- 成功 --> E[显示成功]
D -- 失败 --> F[显示错误]
C -- 输入无效 --> F[显示错误]
E --> G[结束]
F --> G[结束]
```



```mermaid
graph LR
A[开始] --> B{初始化DHT11}
B -- 成功 --> C[复位DHT11]
C --> D{检测DHT11回应}
D -- 存在 --> E[读取数据]
E -- 成功 --> F[解码数据]
F -- 成功 --> G[返回温湿度数据]
D -- 不存在 --> H[结束]
E -- 失败 --> H[结束]
F -- 失败 --> H[结束]
G --> H[结束]
```






```mermaid
graph LR
A[开始] --> B[初始化SMBus]
B --> C[发送开始位]
C --> D[发送设备地址和读取命令]
D --> E[发送重复开始位和设备地址]
F[接收数据]
E --> F
F --> G[发送停止位]
G --> H[计算PEC]
H --> I[返回温度数据]
I --> J[结束]
```






```mermaid
graph LR
A[开始] --> B[初始化系统]
B --> C[检测PS_Sta状态]
C -->|有手指按下| D[刷指纹处理]
C -->|无手指按下| E[检查键盘输入]
E -->|键盘输入| F{键盘键值检测}
F -->|键值1| G[进入录指纹模式]
F -->|键值2| H[进入删除指纹模式]
F -->|键值3| I[确认删除指纹]
F -->|键值4| J[返回主页]
F -->|其他键| K[忽略其他键值]
G --> L[录入指纹流程]
H --> M[查找可删除的ID]
I --> N[删除指纹流程]
J --> O[清除签到人数]
L --> P[结束录入指纹]
M -->|找不到ID| Q[显示无ID可删除]
M -->|找到ID| R[显示可删除的ID]
P --> S[更新指纹库和显示]
R --> T[执行删除指纹]
T --> U[更新指纹库和显示]
Q --> V[结束删除指纹]
U --> V
S --> W[继续检测PS_Sta状态]
V --> W
W --> C
```








```mermaid
graph LR
A[开始] --> B[初始化系统]
B --> C[打开串口]
C --> D{解析串口数据}
D -- 温湿度数据 --> E[显示温湿度]
D -- 红外温度数据 --> F[显示红外温度]
C -- 按键1 --> G[发送录指纹指令]
C -- 按键2 --> H[发送删除指纹指令]
C -- 按键3 --> I[发送确认删除指令]
C -- 按键4 --> J[发送返回主页指令]
```



# 问询、帮助

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

【TB作品】基于stm32单片机的指纹识别考勤系统，实物，代码，AS608

# 读取效果





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

# kei工程

标准库：

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

# 使用方法

将这2个文件加入

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


main示例：

```csharp
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bmp280.h"
int main( void )
{
 float bmp280_temp;
 float bmp280_press;
 float high;
 NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
 delay_init();
 RCC_APB2PeriphClockCmd( RCC_APB2Periph_AFIO, ENABLE );
 GPIO_PinRemapConfig( GPIO_Remap_SWJ_JTAGDisable, ENABLE );
 delay_ms( 500 );
 uart_init( 115200 );
 bmp280Init();
 while ( 1 )
 {
  bmp280GetData( &bmp280_press, &bmp280_temp, &high );
  delay_ms( 500 );
  printf( "bmp280_press:%.2f\r\n", bmp280_press );
  delay_ms( 100 ); 
  printf( "bmp280_temp :%.2f\r\n", bmp280_temp );
  delay_ms( 100 );
  printf( "bmp280_high :%.2f\r\n\r\n", high );
  delay_ms( 100 );
 }
}
```

# 接线方法

vcc-3.3

gnd-gnd

SCL-PB12

SDA-PB13

如果需要更换引脚，改这2个地方的代码：

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

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

# 源码工程下载

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

源码为stm32f103c8t6 keil 标准库工程，如下：


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

下载请看：

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

【TB作品】STM32单片机读取大气压强传感器BMP280

# 实物





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

# main

```csharp
#include <msp430.h>
#include "stdio.h"
#include "OLED.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
// P2.2 oled scl
// P2.3 oled sda
// p1.0 bmp180 scl
// p1.1 bmp180 sda
// vcc 3.3v
// gnd gnd
#include "bmp180.h"
unsigned char disp[16];
unsigned char cnt = 0;
int main(void) {
    uchar test = 0;
    WDTCTL = WDTPW + WDTHOLD;
    if (CALBC1_8MHZ == 0xFF) {
        while (1);
    }
    DCOCTL = 0;
    BCSCTL1 = CALBC1_8MHZ;
    DCOCTL = CALDCO_8MHZ;
    OLED_Init();
    delay_ms(400);
    OLED_Init();
    BMP085_IIC_IOinit;
    delay_ms(50);                           //上电延时
    Init_BMP085();                //初始化BMP085
    test = Single_Read(0xd0);
    _EINT();
    while (1) {
        bmp085Convert();
        OLED_ShowString(0, 0, "BMP180:", 0);
        if (temperature >= 0) { //不满足这个条件的话，说明是负数，有可能是干扰
            cnt = 0;
            disp[cnt++] = temperature % 1000000 / 100000 + '0';
            disp[cnt++] = temperature % 100000 / 10000 + '0';
            disp[cnt++] = temperature % 10000 / 1000 + '0';
            disp[cnt++] = temperature % 1000 / 100 + '0';
            disp[cnt++] = temperature % 100 / 10 + '0';
            disp[cnt++] = temperature % 10 + '0';
            disp[cnt++] = 'C';
            disp[cnt++] = 0;
            OLED_ShowString(0, 2, disp, 0);
            cnt = 0;
            disp[cnt++] = pressure % 10000000 / 1000000 + '0';
            disp[cnt++] = pressure % 1000000 / 100000 + '0';
            disp[cnt++] = pressure % 100000 / 10000 + '0';
            disp[cnt++] = pressure % 10000 / 1000 + '0';
            disp[cnt++] = pressure % 1000 / 100 + '0';
            disp[cnt++] = pressure % 100 / 10 + '0';
            disp[cnt++] = pressure % 10 + '0';
            disp[cnt++] = 'P';
            disp[cnt++] = 'a';
            disp[cnt++] = 0;
            OLED_ShowString(0, 4, disp, 0);
        }
        delay_ms(200);
        delay_ms(200);
        delay_ms(200);
        delay_ms(200);
        delay_ms(200);
    }
}
```

# 所有代码

这里获取：

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

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

【TB作品】MSP430单片机读取大气压强传感器BMP180

# 连接





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

硬件连接：

30102:

 VCC<->3.3V

 GND<->GND

 SCL<->PB7

 SDA<->PB8

 IM<->PB9

USB-TTL:

 GND<->GND

 RXD<->PA9

 TXD<->PA10

# MAX30102心率传感器

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

# 读取的数值

stm32f103c8t6读取，加上一定稳定算法，可见读取很稳定：

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

算法取自这里：

[https://github.com/HJ29/maxrefdes117-energia](https://github.com/HJ29/maxrefdes117-energia)


# 源代码获取请看：

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

可以得到文件：

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

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

【TB作品】STM32单片机读取MAX30102心率传感器，血氧传感器，稳定数值输出，stm32f103c8t6

# 题目





硬件：MSP430G2553、 SR04超声波传感器 、3*4键盘、 无源蜂鸣器、oled显示屏

软件

1 、实时显示测量得到的距离

2、按键设置一个报警门限数值，直接输入数值后确认

3、低于报警门限数值就开始报警，而且距离越近蜂鸣器的鸣叫频率越高

程序 

原理图+pcb 

代做实物到手即用: 



# 效果

![请添加图片描述](/static/img/images/03490.jpeg)

![请添加图片描述](/static/img/images/03491.png)

![请添加图片描述](/static/img/images/03492.png)

![请添加图片描述](/static/img/images/03493.png)

#  程序下载

接上VCC TEST RST即可下载程序给我们自己做的板子

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


# 获取资料


资料有：

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

资料:

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