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





实验名称: 利用声音控制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)