# 功能





这段代码是一个基于msp430微控制器的嵌入式系统程序，主要实现了以下功能：

1. **初始化和配置**：

   - 初始化了OLED显示屏、DS18B20温度传感器、火焰传感器、风扇（通过PWM控制）和蜂鸣器。

   - 设置了CPU时钟源和分频，以满足各组件的工作需求。

   - 配置了中断服务例程用于定时更新温度显示。

2. **DS18B20温度传感器**：

   - 定义了一系列函数来初始化DS18B20传感器，并读取温度值。通过单总线协议与DS18B20通信，进行温度转换并读取温度数据。

   - `get_one_temperature`函数用于读取温度传感器的值，并将其转换为摄氏度的整数值。

3. **火焰传感器**：

   - 监测P1.2引脚上的火焰传感器状态。当检测到低电平（表示有火焰）时，蜂鸣器通过改变TA2CCR2的值产生声音警告。无火焰时蜂鸣器关闭。

4. **风扇控制**：

   - 根据温度值控制风扇速度。温度低于40°C时不转动，40°C到60°C之间以50%占空比转动，60°C以上全速转动。通过PWM控制风扇的转速。

5. **OLED显示**：

   - 使用OLED显示屏实时显示系统状态和当前温度。每隔0.5秒，通过中断服务例程更新一次温度显示。

6. **低功耗管理**：

   - 在等待下一次温度更新或事件触发时，微控制器进入低功耗模式（LPM0）以节省能源。

综上所述，这个程序设计了一个相对完整的环境监控系统，能够自动检测环境温度、响应火焰存在报警，并根据温度调节风扇转速，同时所有这些信息都会实时显示在OLED屏幕上。


# 硬件

```cpp
/*
 * OLED
 * SCL ----------P3.0
 * SDA ----------P3.1
 * VCC ----------3.3V
 * GND  ----------GND
 *
 *
 * DS18B20
 * DATA ----------P1.5
 * VCC ----------3.3V
 * GND  ----------GND
 *
 * 火焰传感器
 * DATA ----------P1.2
 * VCC ----------3.3V
 * GND  ----------GND
 *
 *
 * 风扇
 * 这里是PWM引脚 注意接驱动
 * DATA ----------P2.4
 * VCC ----------3.3V
 * GND  ----------GND
 *
 *
 * 蜂鸣器
 * DATA ----------P2.5
 * VCC ----------3.3V
 * GND  ----------GND
 *
 *
 *
 *
 *
 * 火焰传感器(输出低)检测到火焰蜂鸣器响（没有火焰时蜂鸣器关闭）
 * 没有火焰时蜂鸣器关闭
 *
 * 温度小于40  风扇不转
 * 40到60      占空比50%转
 * 60以上          全速转
 *
 * 显示屏实时显示温度
 *
 *
```

# 部分代码

```cpp
void main(void)
{
    WDTCTL = WDTPW | WDTHOLD; /* Stop watchdog timer */
    P5SEL |= BIT4 + BIT5; /* XT1引脚复用，用作晶振 */
    UCSCTL6 &= ~(XT1OFF + XT2OFF); /* 打开XT1、XT2 */
    P5SEL |= BIT2 + BIT3; /* XT2引脚复用，用作晶振 */
    while (SFRIFG1 & OFIFG) /* 等待晶振正常起振 */
    {
        SFRIFG1 &= ~OFIFG;
        UCSCTL7 &= ~(DCOFFG + XT1LFOFFG + XT2OFFG);
    }
    UCSCTL4 |= SELA__XT1CLK + SELS__XT2CLK + SELM__XT2CLK; /* 时钟源选择   ACLK---XT1CLK   SMCLK---XT2CLK   MCLK---XT2CLK */
    UCSCTL5 |= DIVA__1 + DIVS__4 + DIVM__1; /* 时钟源分频  ACLK/1=32768HZ     SMCLK/4=1MHZ        MCLK/1=4MHZ */
    OLED_Init(); /* OLED初始化 */
    P1DIR |= BIT0; /* LED0 */
    P1OUT |= BIT0;
    P4DIR |= BIT7; /* LED1 */
    P4OUT |= BIT7;
    P1REN |= BIT2; //火焰传感器
    P1OUT |= BIT2;
    DS18b20_Port_Init();
    TA1CTL |= MC_1 + TASSEL_1 + TACLR; /* 10MS 定时 */
    TA1CCR0 = 32768 / 100;
    TA1CCTL0 = CCIE;
    P2DIR |= (BIT4 + BIT5); /* 方向 */
    P2SEL |= (BIT4 + BIT5); /* 第二功能不开 */
    TA2CCR0 = 1000; /* PWM模式    计数到1000  PWM周期就是1MS */
    TA2CCTL1 = OUTMOD_7; /* 模式 */
    TA2CCR1 = 0; /* p2.4  占空比 */
    TA2CCTL2 = OUTMOD_7; /* 模式 */
    TA2CCR2 = 0; /* p2.5 占空比  蜂鸣器 */
    TA2CTL = TASSEL_2 + MC_1 + TACLR; /* smclk, up-down mode, clear TAR  1MHZ */
    OLED_ShowString(0, 1, "     SYSTEM");
    OLED_ShowString(0, 4, "Temp :");
    _EINT(); //打开总中断
    while (1)
    {
        //火焰传感器
        if ((P1IN & BIT2) == 0)
        {
            delay_ms(1);
            if ((P1IN & BIT2) == 0)
            {
                //低电平就是有火焰的情况
                TA2CCR2 = 500; /* p2.5 占空比  蜂鸣器 */
            }
        }
        if ((P1IN & BIT2) == 1)
        {
            delay_ms(1);
            if ((P1IN & BIT2) == 1)
            {
                //高电平就是没有火焰的情况
                TA2CCR2 = 0; /* p2.5 占空比  蜂鸣器 */
            }
        }
        //打开定时器
        TA1CTL |= MC_1 + TASSEL_1 + TACLR; /* 10MS 定时 */
        LPM0; //进入低功耗
    }
}
char counts = 0;
#pragma vector=TIMER1_A0_VECTOR
__interrupt void TIMER1_A0()
{
    TA1CTL = 0; //关闭定时器
    counts = (counts + 1) % 50;
    if (counts == 49)
    {
        //0.5s刷新一次温度
        temp_value = get_one_temperature();
        //根据温度改变占空比
        if (temp_value < 400)
        {
            //温度小于40度 不转
            TA2CCR1 = 0;
        }
        else if (temp_value < 60)
        {
            //温度小于60  50%占空比
            TA2CCR1 = 500; //最大值998
        }
        else
        {
            //温度大于60  99%占空比
            TA2CCR1 = 998; //最大值998
        }
        /* 距离存入数组里 */
        count = 0;
        xianshishuzu[count++] = temp_value % 1000 / 100 + '0';
        xianshishuzu[count++] = temp_value % 100 / 10 + '0';
        xianshishuzu[count++] = '.';
        xianshishuzu[count++] = temp_value % 10 / 1 + '0';
        xianshishuzu[count++] = ' ';
        xianshishuzu[count++] = 'C';
        xianshishuzu[count++] = 0;
        /* 显示出来 温度*/
        OLED_ShowString(50, 4, xianshishuzu);
    }
    LPM0_EXIT; //退出低功耗
}
```

# 全部代码

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

【TB作品】MSP430F5529单片机，火灾报警器，DS18B20温度显示，温控风扇

# 功能





/*

 * OLED

 * SCL ----------P3.0

 * SDA ----------P3.1

 * VCC ----------3.3V

 * GND  ----------GND

 *

 * 风扇

 * DATA ----------P2.4

 * VCC ----------3.3V

 * GND  ----------GND

 *

 * DS18B20

 * DATA ----------P1.5

 * VCC ----------3.3V

 * GND  ----------GND

 *

 *

 * 功能：

 * S1 改变占空比为  0  400  600  800

 *       S2 改变占空比为根据温度变化

 *       OLED每0.5S刷新一次温度显示

 *       DS18B20测温

 */

#  功能

S1 改变占空比为  0  400  600  800 手动档位

S2  自动档位

OLED显示温度

DS18B20测温


```cpp
 * S1 改变占空比为  0  400  600  800
 *       S2 改变占空比为根据温度变化
 *       OLED每0.5S刷新一次温度显示
 *       DS18B20测温
```

# 部分代码

```cpp
void main(void)
{
    WDTCTL = WDTPW | WDTHOLD; /* Stop watchdog timer */
    P5SEL |= BIT4 + BIT5; /* XT1引脚复用，用作晶振 */
    UCSCTL6 &= ~(XT1OFF + XT2OFF); /* 打开XT1、XT2 */
    P5SEL |= BIT2 + BIT3; /* XT2引脚复用，用作晶振 */
    while (SFRIFG1 & OFIFG) /* 等待晶振正常起振 */
    {
        SFRIFG1 &= ~OFIFG;
        UCSCTL7 &= ~(DCOFFG + XT1LFOFFG + XT2OFFG);
    }
    UCSCTL4 |= SELA__XT1CLK + SELS__XT2CLK + SELM__XT2CLK; /* 时钟源选择   ACLK---XT1CLK   SMCLK---XT2CLK   MCLK---XT2CLK */
    UCSCTL5 |= DIVA__1 + DIVS__4 + DIVM__1; /* 时钟源分频  ACLK/1=32768HZ     SMCLK/4=1MHZ        MCLK/1=4MHZ */
    OLED_Init(); /* OLED初始化 */
    P1DIR |= BIT0; /* LED0 */
    P1OUT |= BIT0;
    P4DIR |= BIT7; /* LED1 */
    P4OUT |= BIT7;
    P1REN |= BIT1; //KEY1
    P1OUT |= BIT1;
    P2REN |= BIT1; //KEY2
    P2OUT |= BIT1;
    DS18b20_Port_Init();
    TA1CTL |= MC_1 + TASSEL_1 + TACLR; /* 10MS 定时 */
    TA1CCR0 = 32768 / 100;
    TA1CCTL0 = CCIE;
    P2DIR |= BIT4; /* 方向 */
    P2SEL &= ~BIT4; /* 第二功能不开 */
    P2OUT |= BIT4; /* 方向 */
    OLED_ShowString(0, 1, "TEMP :");
    OLED_ShowString(0, 3, "POWER:");
    OLED_ShowChar(50, 3, '0', 16);
    _EINT(); //打开总中断
    while (1)
    {
        //按键S1  改变风扇占空比
        if ((P2IN & BIT1) == 0)
        {
            delay_ms(10);
            if ((P2IN & BIT1) == 0)
            {
                while ((P2IN & BIT1) == 0)
                    ;
                fengshansudu = (fengshansudu + 1) % 4; // 0 1  2  3代表不转和三档速度
                if (fengshansudu == 0)
                {
                    P2DIR |= BIT4; /* 方向 */
                    P2SEL &= ~BIT4; /* 第二功能不开 */
                    P2OUT |= BIT4; /* 方向 */
                }
                else
                {
                    P2DIR |= BIT4; /* 方向 */
                    P2SEL |= BIT4; /* 第二功能不开 */
                    TA2CCR0 = 1000; /* PWM模式    计数到1000  PWM周期就是1MS */
                    TA2CCTL1 = OUTMOD_3; /* 模式 */
                    TA2CCR1 = 2; /* 占空比 */
                    TA2CTL = TASSEL_2 + MC_1 + TACLR; /* smclk, up-down mode, clear TAR  1MHZ */
                    TA2CCR1 = 200 + fengshansudu * 200; /* 占空比 */
                }
                P1OUT ^= BIT0; //为了观察
            }
        }
        //按键S2  改变风扇  为 自动档位
        if ((P1IN & BIT1) == 0)
        {
            delay_ms(10);
            if ((P1IN & BIT1) == 0)
            {
                while ((P1IN & BIT1) == 0)
                    ;
                P2DIR |= BIT4; /* 方向 */
                P2SEL |= BIT4; /* 第二功能不开 */
                TA2CCR0 = 1000; /* PWM模式    计数到1000  PWM周期就是1MS */
                TA2CCTL1 = OUTMOD_3; /* 模式 */
                TA2CCR1 = 2; /* 占空比 */
                TA2CTL = TASSEL_2 + MC_1 + TACLR; /* smclk, up-down mode, clear TAR  1MHZ */
                fengshansudu = 4; //代表自动速度
                P4OUT ^= BIT7; //为了观察
            }
        }
        //打开定时器
        TA1CTL |= MC_1 + TASSEL_1 + TACLR; /* 10MS 定时 */
        LPM0; //进入低功耗
    }
}
```


# 全部代码

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

【TB作品】MSP430F5529单片机，温控小风扇，DS18B20温度读取，PWM风扇

# 功能





MSP430F149单片机

LCD1602投票器一个主持人开始停止复位3个按键投票

# 部分程序

```cpp
char state = 0; /*三个状态 开始 停止复位 */
char piaoshu = 0;
char ifg1 = 0, ifg2 = 0, ifg3 = 0;
int main( void )
{
 char key_v;
 WDTCTL = WDTPW | WDTHOLD;               /* Stop watchdog timer */
 Clock_Init();                           /* 系统时钟设置 */
 key_init();                             /*按键初始化 */
 Port_init();                            /* 显示器引脚初始化 */
 LCD_init();                             /* 显示器初始化 */
 LCD_Desk();                             /* 显示界面初始化 */
 _EINT();                                /* 开中断 */
 state = 2;                              /* 初始状态 */
 LCD_write_char( 11, 1, piaoshu + '0' ); /* 显示投票数 */
 while ( 1 )
 {
  key_v = KeySscan();
  if ( key_v != 0 )
  {
   if ( key_v == 1 )
   {
    state++;
    if ( state == 3 )
     state = 0;  /* 改变状态 */
    if ( state == 0 )
    {
     LCD_write_str( 0, 1, "start" );
    }else if ( state == 1 )
    {
     LCD_write_str( 0, 1, "stop " );
    }else if ( state == 2 )
    {
     LCD_write_str( 0, 1, "reset" );
     delay_ms( 100 );
     LCD_write_str( 0, 1, "     " );
     piaoshu = 0;                            /* 投票数归零 */
     ifg1 = 0, ifg2 = 0, ifg3 = 0;        /* 标志归零 */
     LCD_write_char( 11, 1, piaoshu + '0' ); /* 显示投票数 */
    }
   }
   if ( state == 0 )
   {
    /* 状态开始状态  就可以投票 */
    if ( key_v == 2 )
    {
     if ( ifg1 == 0 )
     {
      piaoshu++;                      /* 票数+1 */
      ifg1 = 1;                       /* 只有复位后才恢复0 投票只能投一次 */
     }
     LCD_write_char( 11, 1, piaoshu + '0' ); /* 显示投票数 */
    }else if ( key_v == 3 )
    {
     if ( ifg2 == 0 )
     {
      piaoshu++;                      /* 票数+1 */
      ifg2 = 1;                       /* 只有复位后才恢复0 投票只能投一次 */
     }
     LCD_write_char( 11, 1, piaoshu + '0' ); /* 显示投票数 */
    }else if ( key_v == 4 )
    {
     if ( ifg3 == 0 )
     {
      piaoshu++;                      /* 票数+1 */
      ifg3 = 1;                       /* 只有复位后才恢复0 投票只能投一次 */
     }
     LCD_write_char( 11, 1, piaoshu + '0' ); /* 显示投票数 */
    }
   }
  }
 }
}
```


# 全部程序

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

【TB作品】MSP430F149单片机，LCD1602投票器一个主持人开始停止复位3个按键投票

LCD1602滚动显示切换播放暂停字符串





显示Public Places

显示No Smoking

播放

暂停

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

# 部分代码

```cpp
char zifu1[] = "Public Places   ";
char zifu2[] = "Class Now       ";
char zifu3[] = "No admittance   ";
char *zifu[] = { zifu1, zifu2, zifu3 };
char juti_L[3] = { 16, 16, 16 };
char zifu12[] = "No Smoking      ";
char zifu22[] = "Quiet Please    ";
char zifu32[] = "Staff Only      ";
char *zifu22a[] = { zifu12, zifu22, zifu32 };
char juti_L2[3] = { 16, 16, 16 };
int main(void)
{
    char key_v;
    char time = 0;
    char start_char_num = 0;
    WDTCTL = WDTPW | WDTHOLD; /* Stop watchdog timer */
    Clock_Init(); /* 系统时钟设置 */
    key_init(); /*按键初始化 */
    Port_init(); /* 显示器引脚初始化 */
    LCD_init(); /* 显示器初始化 */
    _EINT(); /* 开中断 */
    display(0, 0); /* 显示哪一个字符 从哪开始显示 */
    display_2(0, 0);
    while (1)
    {
        key_v = KeySscan();
        if (key_v != 0)
        {
            if (key_v == 1)
            {
                num++;
                if (num == 3)
                    num = 0;
                display(num, 0);
                display_2(num, 0);
                start_char_num = 0;
            }
            else if (key_v == 2)
            {
                start = 1;
            }
            else if (key_v == 3)
            {
                start = 0;
            }
        }
        delay_ms(10);
        if (start == 1)
        {
            time++;
            if (time == 27)
            {
                time = 0; /* 时间控制 */
                start_char_num++; //从哪里开始显示
                if (start_char_num >= juti_L[num])
                {
                    start_char_num = 0;
                }
                display(num, start_char_num); /* 显示哪一个字符 从哪开始显示 */
                display_2(num, start_char_num); /* 显示哪一个字符 从哪开始显示 */
            }
        }
    }
}
```


# 全部程序

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

【TB作品】MSP430F149单片机，广告牌，滚动显示

# 功能





用6个引脚采集ADC，串口发送到电脑

# 部分程序

```cpp
/*
 * Otherwise, the compiler removes it
 * because it is not used for anything.
 */
int kaiguanliang[4];                                    /* 四个开关量 */
unsigned char adok_ifg = 1;                             /* 转换结束后变成0 */
char fasong[20];
int main( void )
{
 WDTCTL = WDTPW | WDTHOLD;                       /* Stop watchdog timer */
 Clock_Init();                                   /* 系统时钟设置 */
 UART_Init();                                    /* 串口设置初始化 115200 */
 init_AD();                                      /* 初始化ad */
 init_key();                                     /* 初始化按键 */
 _EINT();                                        /* 开中断 */
 while ( 1 )
 {
  /* 检测AD */
  adok_ifg = 1;                    /* 转换结束后变成0 */
  ADC12CTL0 |= ADC12SC;             /* Start conversion */
  while ( adok_ifg == 1 )
   ;                               /* 等待装换结束 */
  /* p1.0 电平高低 决定了kaiguanliang【0】是1还是0 以此作为开关量 */
  if ( (P1IN & BIT0) == 0 )
  {
   kaiguanliang[0] = 0;
  } else {
   kaiguanliang[0] = 1;
  }
  if ( (P1IN & BIT1) == 0 )
  {
   kaiguanliang[1] = 0;
  } else {
   kaiguanliang[1] = 1;
  }
  if ( (P1IN & BIT2) == 0 )
  {
   kaiguanliang[2] = 0;
  } else {
   kaiguanliang[2] = 1;
  }
  if ( (P1IN & BIT3) == 0 )
  {
   kaiguanliang[3] = 0;
  } else {
   kaiguanliang[3] = 1;
  }
  /* 发送模拟量0 ad0 */
  memset( fasong, 0, sizeof(fasong) );    /* 清空发送数组 */
  sprintf( fasong, "AD0:%d  ", results[0] );
  Print_Str( fasong );
  delay_ms( 5 );
  /* 发送模拟量1 ad1 */
  memset( fasong, 0, sizeof(fasong) );    /* 清空发送数组 */
  sprintf( fasong, "AD1:%d  \r\n", results[1] );
  Print_Str( fasong );
  delay_ms( 5 );
  /* 发送模拟量2 ad2 */
  memset( fasong, 0, sizeof(fasong) );    /* 清空发送数组 */
  sprintf( fasong, "AD2:%d  ", results[2] );
  Print_Str( fasong );
  delay_ms( 5 );
  /* 发送模拟量3 ad3 */
  memset( fasong, 0, sizeof(fasong) );    /* 清空发送数组 */
  sprintf( fasong, "AD3:%d  \r\n", results[3] );
  Print_Str( fasong );
  delay_ms( 5 );
  /* 发送模开关量0 */
  memset( fasong, 0, sizeof(fasong) );    /* 清空发送数组 */
  sprintf( fasong, "KAIGUAN0:%d  ", kaiguanliang[0] );
  Print_Str( fasong );
  delay_ms( 5 );
  /* 发送开关量1 */
  memset( fasong, 0, sizeof(fasong) );    /* 清空发送数组 */
  sprintf( fasong, "KAIGUAN1:%d  \r\n\r\n\r\n", kaiguanliang[1] );
  Print_Str( fasong );
  delay_ms( 5 );
  delay_ms( 500 );
 }
}
```

# 全部代码

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

【TB作品】MSP430F149单片机，6通道ADC，串口发送

# 功能





msp430g2553单片机，读取adc电压，显示到oled

# 硬件

oled

// ------------------------------------------------------------

// IO口模拟I2C通信

// SCL接P2^0

// SDA接P2^1

采集P1.4电压 0到3.3V


# 部分程序

```cpp
unsigned int volt;
int main(void)
{
    char SENDSTR[20];
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    OLED_Init(); /* OLED初始化 */
    while (1)
    {
        ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
        __bis_SR_register(CPUOFF + GIE);      // LPM0, ADC10_ISR will force exit
        volt=volt*3.3*100/1024;
        SENDSTR[0] = volt % 1000 / 100 + '0';
        SENDSTR[1] =  '.';
        SENDSTR[2] = volt % 100 / 10 + '0';
        SENDSTR[3] = volt % 10 + '0';
        SENDSTR[4] = 'V';
        SENDSTR[5] = 0;
        OLED_ShowString(0, 2, SENDSTR);
        delay_ms(100);
    }
}
// ADC10 interrupt service routine
#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR(void)
{
    volt = ADC10MEM;
    __bic_SR_register_on_exit(CPUOFF);        // Clear CPUOFF bit from 0(SR)
}
```


# 全部程序

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

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

【TB作品】MSP430G2553单片机，电压表，oled显示电压，adc

# 功能





msp430f149单片机

读取ds18b20温度，显示到数码管，串口发送温度到电脑

# 部分程序

```cpp
/*************************************************
*  程序功能：用DS18B20测量室温并在数码管上显示。
*  -------------------------------------------------
*  测试说明：观察显示温度数值。
*************************************************/
#include <msp430x14x.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/* 延时函数，IAR自带，经常使用到 */
#define CPU_F ( (double) 8000000)   /* 外部高频晶振8MHZ */
/* #define CPU_F ((double)32768)   //外部低频晶振32.768KHZ */
#define delay_us( x ) __delay_cycles( (long) (CPU_F * (double) x / 1000000.0) )
#define delay_ms( x ) __delay_cycles( (long) (CPU_F * (double) x / 1000.0) )
/* 自定义数据结构，方便使用 */
#define uchar unsigned char
#define uint unsigned int
#define ulong unsigned long
/****************主函数****************/
void main( void )
{
 /*下面六行程序关闭所有的IO口*/
 P5DIR = 0xff;
 P5OUT = 0xff; P1DIR = 0XFF; P1OUT = 0XFF;
 P2DIR = 0XFF; P2OUT = 0XFF;
 P3DIR = 0XFF; P3OUT = 0XFF;
 P4DIR = 0XFF; P4OUT = 0XFF;
 P5DIR = 0XFF; P5OUT = 0XFF;
 P6DIR = 0XFF; P6OUT = 0XFF;
 WDTCTL = WDTPW + WDTHOLD;
 Clock_Init();
 UART_Init();
 P6DIR |= BIT6; P6OUT |= BIT6; /* 关闭电平转换 */
 P5DIR |= BIT5; P5OUT |= BIT5; /* 关闭电平转换 */
 P6DIR |= BIT7; P6OUT |= BIT7; /* 关闭蜂鸣器 */
 /* 设置看门狗定时器，初始化控制数码管的IO */
 WDTCTL = WDT_ADLY_1_9;
 IE1 |= WDTIE;
 /* 计数时钟选择SMLK=8MHz，1/8分频后为1MHz */
 TACTL |= TASSEL_2 + ID_3;
 /* 打开全局中断 */
 _EINT();
 /* 循环读数显示 */
 while ( 1 )
 {
  wendu = Do1Convert();                   /* 读取温度s */
  Disp_Numb( wendu );                     /* 显示温度 */
  /* 串口发送温度 wendu */
  memset( fasong, 0, sizeof(fasong) );    /* 清空发送数组 */
  sprintf( fasong, "%d%d.%d  \r\n", (int)dN[5],(int)dN[4] ,(int)dN[3]  );
  Print_Str( fasong );
 }
}
/*******************************************
 * 函数名称：watchdog_timer
 * 功    能：看门狗定时器中断服务函数，进行数码
 *        管动态扫描
 * 参    数：无
 * 返回值  ：无
 ********************************************/
#pragma vector = WDT_VECTOR
__interrupt void watchdog_timer( void )
{
 /*
  * P4OUT = 0xFF;
  *  wei_h;
  * wei_l;
  */
 P4OUT = scandata[dN[5 - cnt]];
 if ( cnt == 1 )
  P4OUT &= ~BIT7;  /* 在第二位显示小数点 */
 duan_h;
 duan_l;
 P4OUT = ~(1 << cnt);
 wei_h;
 wei_l;
 cnt++;
 if ( cnt == 3 )
  cnt = 0;
}
/*******************************************
 * 函数名称：Disp_Numb
 * 功    能：将从DS18B20读取的11bit温度数据转换
 *        成数码管显示的温度数字
 * 参    数：temper--11bit温度数据
 * 返回值  ：无
 ********************************************/
void Disp_Numb( uint temper )
{
 uchar i;
 for ( i = 0; i < 6; i++ )
  dN[i] = 0;          /* 初始化显示变量 */
 /* 数值转换 */
 if ( temper & BIT0 )
 {
  dN[0] = 5;
  dN[1] = 2;
  dN[2] = 6;
 }
 if ( temper & BIT1 )
 {
  dN[1] += 5;
  dN[2] += 2;
  dN[3] += 1;
 }
 if ( temper & BIT2 )
 {
  dN[2] += 5;
  dN[3] += 2;
  if ( dN[2] >= 10 )
  {
   dN[2] -= 10;
   dN[3] += 1;
  }
 }
 if ( temper & BIT3 )
 {
  dN[3] += 5;
 }
 if ( temper & BIT4 )
 {
  dN[4] += 1;
 }
 if ( temper & BIT5 )
 {
  dN[4] += 2;
 }
 if ( temper & BIT6 )
 {
  dN[4] += 4;
 }
 if ( temper & BIT7 )
 {
  dN[4] += 8;
  if ( dN[4] >= 10 )
  {
   dN[4] -= 10;
   dN[5] += 1;
  }
 }
 if ( temper & BIT8 )
 {
  dN[4] += 6;
  dN[5] += 1;
  if ( dN[4] >= 10 )
  {
   dN[4] -= 10;
   dN[5] += 1;
  }
 }
 if ( temper & BIT9 )
 {
  dN[4] += 2;
  dN[5] += 3;
  if ( dN[4] >= 10 )
  {
   dN[4] -= 10;
   dN[5] += 1;
  }
 }
 if ( temper & BITA )
 {
  dN[4] += 4;
  dN[5] += 6;
  if ( dN[4] >= 10 )
  {
   dN[4] -= 10;
   dN[5] += 1;
  }
  if ( dN[5] >= 10 )
  {
   dN[5] -= 10;
  }
 }
}
```


# 全部程序

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

【TB作品】msp430f149单片机，读取ds18b20温度，显示到数码管，串口发送温度到电脑

# 功能





msp430单片机，连接一个无源蜂鸣器，播放蜂鸣器音乐，天空之城。

适用于所有msp430单片机。


# 硬件

无源蜂鸣器，接单片机P1.5，使用vcc3.3v供电。


# 如果根据简谱修改音乐?

//第一步

//首先修改music0 的变量，

//低音下面加点

//中音不加点

//高音上面加点

//根据简朴的符号写出对应C调音

//第二步 修改music0_JP数组  这个数组和上一个数组对应 就是每一个音 响多长时间

//普通无点是延时 7 即是800ms

//如果音 下有一条下划线，延时 4

//如果音 下有两条下划线，延时2

//如果音 后加一个点  延时12

//如果音后加一条线 延时16

//如果音后加2条线 延时20

//当然 觉得不好听 可以适当修改延时的值

# 部分程序

```cpp
/*  ******************************************    */
//  ********  音乐0    天空之城
/*  ******************************************    */
//以下是《天空之城》简谱    //每行对应一小节音符
unsigned int  music0[]=
{ Z6,Z7,/**/H1,Z7,H1,H3,/**/Z7,Z3,Z3, /**/Z6,Z5,Z6,H1,/**/Z5,Z3,Z3, /**/Z4,Z3,Z4,H1,
 Z3,H1,H1,H1,/**/Z7,Z4,Z4,Z7,/**/Z7,Z6,Z7, /**/H1,Z7,H1,H3,/**/Z7,Z3,Z3, /**/Z6,Z5,Z6,H1,
 Z5, Z3,/**/Z4,H1,Z7,H1,/**/H2,H2,H2,H1,/**/H1,Z6,Z7,Z5,/**/Z6,H1,H2, /**/H3,H2,H3,H5,
 H2,Z5,Z5, /**/H1,Z7,H1,H3,/**/H3, /**/Z6,H1,Z7,H2,/**/H1,Z5,Z5, /**/H4,H3,H2,H1,
 H3, /**/Z3,H3, /**/H6,H5,H5, /**/H3,H2,H1,H1,/**/H2,H1,H2,H5,/**/H3,H3,
 H6,H5, /**/H3,H2,H1,H1,/**/H2,H1,H2,Z7,/**/Z6,Z6,Z7, /**/Z6,0xff}; //以0xff作为音符的结束标志
//以下是简谱中每个音符的节拍
//"4"对应4个延时单位，"2"对应2个延时单位，"1"对应1个延时单位
unsigned char  music0_JP[ ]=
{ 4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,4,12,
 20,4,4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,8,8,
 32, 4, /**/8,4,6,8, /**/4,4,4,16, /**/8,4,6,8, /**/24,4,4, /**/12,4,8,8,
 24,4,4, /**/4,4,8,8, /**/32, /**/4,8,8,6, /**/12,4,16, /**/8,8,8,8,
 30, /**/20,8, /**/16,8,8, /**/4,4,16,8, /**/8,4,4,8, /**/20,8,
 16,16, /**/4,20,8, /**/8,4,4,8, /**/20,4,4, /**/32};
/*  ******************************************    */
/*  ********   延时100ms 控制音乐节拍 */
/*  ******************************************    */
void delay1()
{
 delay_ms( 100 );
}
int main( void )
{
 unsigned char u = 0, t = 0;
 WDTCTL = WDTPW + WDTHOLD;                               /* Stop WDT */
 P1DIR |= BIT5;                                          /* P1.0 output */
 _EINT();
 while ( 1 )
 {
  u = 0, t = 0;
  while ( music0[u] != 0xff )                     /* 只要没有读到结束标志就继续播放 */
  {
   CCR0 = SYSCLK / music0[u] / 2;       /*选一个频率 */
   for ( t = 0; t < music0_JP[u]; t++ )    /* 控制节拍数 */
    delay1();                       /* 延时1个节拍单位 */
   TACTL = TASSEL_2 + MC_0;                /* 关闭 */
   u++;                                    /* 播放下一个音符 */
  }
 }
}
/* Timer A0 interrupt service routine */
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A( void )
{
 P1OUT ^= BIT5;
}
```


# 全部程序

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

【TB作品】msp430单片机，播放蜂鸣器音乐，天空之城

# 功能





读取dht11温湿度显示到oled

读取ds18b20温度显示到oled

按键修改温度上限

温度超出温度上限就蜂鸣器报警


# 硬件接法

oled接法 0.96 寸 7针 oled

//              GND    电源地

//              VCC  3.3v电源

//              D0   P23（时钟）

//              D1   P24（数据）

//              RES  接P21

//              DC   接P22

//              CS   接P20

ds18b20

//              GND    电源地

//              VCC  3.3v电源

//             DATA  P1.5

DHT11

//              GND    电源地

//              VCC  3.3v电源

//             DATA  P1.4

按键1 P1.6

按键2 P1.7

有源蜂鸣器低电平触发 接P1.3

# 部分代码
```cpp
int main(void) {
 uchar o;
 uchar count = 0;
 uint warn_temp = 270;      //报警温度
 WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
 if (CALBC1_8MHZ == 0xFF)    // If calibration constant erased
   {
  while (1)
   ;                               // do not load, trap CPU!!
 }
 DCOCTL = 0;                          // Select lowest DCOx and MODx settings
 BCSCTL1 = CALBC1_8MHZ;                    // Set range
 DCOCTL = CALDCO_8MHZ;                     // Set DCO step + modulation */
 P1DIR |= BIT3;                     //BEEP
 P1OUT |= BIT3;                     //CLOSE
 P1DIR &= ~(BIT6 + BIT7); //KEY1 KEY2
 P1REN |= BIT6 + BIT7;
 P1OUT |= BIT6 + BIT7;
 OLED_Init();        //初始化OLED
 OLED_Clear();
 OLED_ShowString(40, 0, "SYSTEM");
 DS18b20_Init();
 //初始化显示报警温度
 memset(dis_str, 0, 15);
 count = 0;
 dis_str[count++] = warn_temp % 1000 / 100 + '0';
 dis_str[count++] = warn_temp % 100 / 10 + '0';
 dis_str[count++] = '.';
 dis_str[count++] = warn_temp % 10 + '0';
 dis_str[count++] = 'C';
 dis_str[count++] = 0;
 OLED_ShowString(0, 4, dis_str);
 while (1) {
  temp_value = get_one_temperature();
  o = start_DHT11();
  if (o) {
   memset(dis_str, 0, 15);
   count = 0;
   dis_str[count++] = temp_value % 1000 / 100 + '0';
   dis_str[count++] = temp_value % 100 / 10 + '0';
   dis_str[count++] = '.';
   dis_str[count++] = temp_value % 10 + '0';
   dis_str[count++] = 'C';
   dis_str[count++] = ' ';
   dis_str[count++] = ' ';
   dis_str[count++] = DHT11RH_Data_H % 100 / 10 + '0';
   dis_str[count++] = DHT11RH_Data_H % 10 + '0';
   dis_str[count++] = '%';
   dis_str[count++] = 'R';
   dis_str[count++] = 'H';
   dis_str[count++] = 0;
   OLED_ShowString(0, 2, dis_str);
  }
  if ((P1IN & BIT6) == 0) {
   delay_ms(3);
   if ((P1IN & BIT6) == 0) {
//    while ((P1IN & BIT6) == 0)
//     ;
    warn_temp++;
    //初始化显示报警温度
    memset(dis_str, 0, 15);
    count = 0;
    dis_str[count++] = warn_temp % 1000 / 100 + '0';
    dis_str[count++] = warn_temp % 100 / 10 + '0';
    dis_str[count++] = '.';
    dis_str[count++] = warn_temp % 10 + '0';
    dis_str[count++] = 'C';
    dis_str[count++] = 0;
    OLED_ShowString(0, 4, dis_str);
   }
  }
  if ((P1IN & BIT7) == 0) {
   delay_ms(3);
   if ((P1IN & BIT7) == 0) {
//    while ((P1IN & BIT7) == 0)
//     ;
    warn_temp--;
    //初始化显示报警温度
    memset(dis_str, 0, 15);
    count = 0;
    dis_str[count++] = warn_temp % 1000 / 100 + '0';
    dis_str[count++] = warn_temp % 100 / 10 + '0';
    dis_str[count++] = '.';
    dis_str[count++] = warn_temp % 10 + '0';
    dis_str[count++] = 'C';
    dis_str[count++] = 0;
    OLED_ShowString(0, 4, dis_str);
   }
  }
  if (temp_value > warn_temp) {
   P1OUT &= ~BIT3;
  } else {
   P1OUT |= BIT3;                     //CLOSE
  }
  delay_ms(10);
 }
}
```

# 全部代码

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

【TB作品】MSP430G2553单片机，读取dht11，读取ds18b20，温度报警器

./taobaozuopin.json```cpp

/*
 * 12864液晶串行显示测试程序
 *
 * P1.4模拟SID（接第5脚），
 * P1.5模拟SCLK（接第6脚）
 *
 * 4脚（CS信号）接高电平选通，
 * 15脚（PSB信号）接地选择串行方式
 * 17脚（RST信号）根据注释提示悬空
 *
 * 以上四根线
 * 另外还需要接四根线VCC GND BLA BLK
 * 边上的是GND或者BLK  都接GND
 * 第二个就是VCC或者BLA 都接5V
 * MSP430是3.3的单片机 但是不会烧 很安全
 *
 * 并不是所有的12864都支持串口，程序不行就考虑是不是买到次品了
 */
```



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

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

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

# 部分程序

```cpp
/*
 * ***********************************************************************
 * 显示屏制定起始位置写入字符串
 * ***********************************************************************
 */
void Lcd_WriteStr( unsigned char x, unsigned char y, unsigned char *Str )
{
 if ( (y > 3) || (x > 7) )
  return;                 /* 超出范围直接不写 */
 if ( y == 0 )
 {
  write_com( 0x80 + x );  /* 第一行显示 */
 }
 if ( y == 1 )
 {
  write_com( 0x90 + x );  /* 第二行显示 */
 }
 if ( y == 2 )
 {
  write_com( 0x88 + x );  /* 第三行显示 */
 }
 if ( y == 3 )
 {
  write_com( 0x98 + x );  /* 第四行显示 */
 }
 _NOP();
 while ( *Str )
 {
  write_data( *Str );
  Str++;
  _NOP();
 }
}
void main()
{
 WDTCTL = WDTPW + WDTHOLD;       /* 关闭看门狗 */
 lcdinit();                      /* LCD初始化 */
 Lcd_WriteStr( 1, 1, "显示屏测试" );
 while ( 1 )
  ;                       /* CPU空转 */
}
```



# 全部程序

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

【TB作品】MSP430单片机，LCD2864串行通信，两根线驱动显示

# 功能
MSP430G2553 单片机口袋板，流速，流量，检测与显示




# 部分代码

```cpp
/*警告：由于G2 LaunchPad上的LED2使用了P1.6（I2C引脚），所以所有涉及到I2C的实验都必须把P1.6跳线拔除,包含本例程！
 * main.c
 */
#include"MSP430G2553.h"
#include "Slope.h"
#include "TCA6416A.h"
#include "HT1621.h"
#include "LCD_128.h"
#define CPU_F ( (double) 16000000)
#define delay_us( x )	__delay_cycles( (long) (CPU_F * (double) x / 1000000.0) )
#define delay_ms( x )	__delay_cycles( (long) (CPU_F * (double) x / 1000.0) )

#define u8	unsigned char
#define u16	unsigned int
#define u32	unsigned long

unsigned int Rsens = 0; //最后电阻值

int xianshi_choose = 0;

u32 leijiliang = 0;
u32 liusu = 0;

void WDT_OnTime();
void Slope_R_Dect();			//测得待测电阻后的事件处理函数

/* 显示一个数字 */
void dis_num_6( u32 num) {
	unsigned char bua;

	bua = num % 1000000 / 100000;
	LCD_DisplayDigit(bua, 1);
	bua = num % 100000 / 10000;
	LCD_DisplayDigit(bua, 2);
	bua = num % 10000 / 1000;
	LCD_DisplayDigit(bua, 3);
	bua = num % 1000 / 100;
	LCD_DisplayDigit(bua, 4);
	bua = num % 100 / 10;
	LCD_DisplayDigit(bua, 5);
	bua = num % 10;
	LCD_DisplayDigit(bua, 6);

	//LCD_DisplaySeg(i);

	LCD_DisplaySeg(_LCD_DOT4);
	HT1621_Reflash(LCD_Buffer);
}
/* 检测按键函数 */
void I2C_IODect() /* 检测事件确实发生了 */
{
	static unsigned char KEY_Past = 0, KEY_Now = 0;
	KEY_Past = KEY_Now;
	/* ----判断I2C_IO10所连的KEY1按键是否被按下------ */
	if ((TCA6416A_InputBuffer & BIT8) == BIT8)
		KEY_Now |= BIT0;
	else
		KEY_Now &= ~BIT0;
	if (((KEY_Past & BIT0) == BIT0) && (KEY_Now & BIT0) != BIT0) {
		/*按键1 事件 */
		xianshi_choose = 0;
		//改变xianshi_choose变量 主程序里 显示会切换

	}
	/* ----判断I2C_IO11所连的KEY2按键是否被按下------ */
	if ((TCA6416A_InputBuffer & BIT9) == BIT9)
		KEY_Now |= BIT1;
	else
		KEY_Now &= ~BIT1;
	if (((KEY_Past & BIT1) == BIT1) && (KEY_Now & BIT1) != BIT1) {
		/*按键2 事件 */
		xianshi_choose = 1;
	}
	/* ----判断I2C_IO12所连的KEY3按键是否被按下------ */
	if ((TCA6416A_InputBuffer & BITA) == BITA)
		KEY_Now |= BIT2;
	else
		KEY_Now &= ~BIT2;
	if (((KEY_Past & BIT2) == BIT2) && (KEY_Now & BIT2) == 0) {
		/*按键3 事件 */

	}

	/* ----判断I2C_IO13所连的KEY4按键是否被按下------ */
	if ((TCA6416A_InputBuffer & BITB) == BITB)
		KEY_Now |= BIT3;
	else
		KEY_Now &= ~BIT3;
	if (((KEY_Past & BIT3) == BIT3) && (KEY_Now & BIT3) == 0) {
		/*按键4 事件 */

	}
}
//串口发送单一字符
void sendan(unsigned char zifu) {
	while (!(IFG2 & UCA0TXIFG))
		;                 // USCI_A0 TX buffer ready?
	UCA0TXBUF = zifu;                     // TX -> RXed character
}
//串口发送字符串
void send_string(unsigned char *s) {
	while ((*s) != '\0') {
		sendan(*s);
		s++;
	}
}
//串口发送流量或者累积量
void send_liuliang_andleiji() {
	unsigned char bua;

	unsigned char zifuchuan[30];
	unsigned char countaa = 0;

	zifuchuan[countaa++] = liusu % 1000000 / 100000 + '0';
	zifuchuan[countaa++] = liusu % 100000 / 10000 + '0';
	zifuchuan[countaa++] = liusu % 10000 / 1000 + '0';
	zifuchuan[countaa++] = liusu % 1000 / 100 + '0';
	zifuchuan[countaa++] = liusu % 100 / 10 + '0';
	zifuchuan[countaa++] = '.';
	zifuchuan[countaa++] = liusu % 10 + '0';
	zifuchuan[countaa++] = 'L';
	zifuchuan[countaa++] = '/';
	zifuchuan[countaa++] = 'S';

	zifuchuan[countaa++] = ' ';
	zifuchuan[countaa++] = ' ';

	zifuchuan[countaa++] = leijiliang % 1000000 / 100000 + '0';
	zifuchuan[countaa++] = leijiliang % 100000 / 10000 + '0';
	zifuchuan[countaa++] = leijiliang % 10000 / 1000 + '0';
	zifuchuan[countaa++] = leijiliang % 1000 / 100 + '0';
	zifuchuan[countaa++] = leijiliang % 100 / 10 + '0';
	zifuchuan[countaa++] = '.';
	zifuchuan[countaa++] = leijiliang % 10 + '0';
	zifuchuan[countaa++] = 'L';

	send_string(zifuchuan);
	send_string("\r\n");
}

void main(void) {

	WDTCTL = WDTPW + WDTHOLD;

	BCSCTL1 = CALBC1_16MHZ; /* Set DCO to16MHz */
	DCOCTL = CALDCO_16MHZ;
	__delay_cycles(100000);			//等待电压稳定
	TCA6416A_Init();
	Slope_Measure_Init();
	HT1621_init();
	/* ----提示初始化成功---- */
	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 */
	LCD_Clear();

	//-----设定WDT为16ms定时中断-----
	WDTCTL = WDT_ADLY_16;
	//-----WDT中断使能-----
	IE1 |= WDTIE;

	TA1CCTL0 = CCIE;
	TA1CCR0 = 3276 / 5; /* 20MS */
	TA1CTL = TASSEL_1 + MC_1;			//up to CCR0

	//串口设置
//	P1DIR |= BIT2;
//	P1SEL = BIT1 + BIT2;                     // P1.1 = RXD, P1.2=TXD
//	P1SEL2 = BIT1 + BIT2;                     // P1.1 = RXD, P1.2=TXD
//	UCA0CTL1 |= UCSSEL_1;                     // CLK = ACLK
//	UCA0BR0 = 0x03;                           // 32kHz/9600 = 3.41
//	UCA0BR1 = 0x00;                           //
//	UCA0MCTL = UCBRS1 + UCBRS0;               // Modulation UCBRSx = 3
//	UCA0CTL1 &= ~UCSWRST;                   // **Initialize USCI state machine**
	//IE2 |= UCA0RXIE;                          // Enable USCI_A0 RX interrupt

	_enable_interrupts();

	while (1) {
		PinIN();
		I2C_IODect(); /*按键检测处理 */

		TA1CTL = TASSEL_1 + MC_1 + TACLR; /* 打开定时器 */
		LPM0;
	}
}

// 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
}


/* Timer A0 interrupt service routine */
#pragma vector=TIMER1_A0_VECTOR
__interrupt void Timer1_A(void) {
	//更新流速和累积量 每一秒钟来一次
	static float bufa;
	static unsigned char countasdf = 0;

	countasdf++;
	if (countasdf == 50) {
		countasdf=0;
		if (Rsens != 0) {
			bufa = (float) Rsens * 2.2;	//Rsens是拨码电阻值      2.2是系数 随便设置的  主要是得到流速
		}
		liusu = bufa * 10;			//因为要保留1位小数  乘以10 显示到LED后有小数
		leijiliang += liusu;			//每一秒的流速单位就是 L/S  一秒算多少升 加到累积量上
		if (leijiliang > 100000) {
			leijiliang = 0;
		}
		if (xianshi_choose == 0) {
			//xianshi_choose=0  显示流速 否则显示累积量
			dis_num_6(liusu);
		} else {
			dis_num_6(leijiliang);
		}
		//send_liuliang_andleiji();//串口发送流量和累积量

	}

	TA1CTL = TASSEL_1 + MC_0 + TACLR; /* 停下时钟 */
	LPM0_EXIT;



}

/******************************************************************************************************
 * 名       称：WDT_ISR(void)
 * 功       能：WDT定时中断子函数
 * 入口参数：无
 * 出口参数：无
 * 说       明：直接调用事件处理函数即可
 * 范       例：无
 ******************************************************************************************************/
#pragma vector=WDT_VECTOR
__interrupt void WDT_ISR(void) {
	IE1 &= ~WDTIE;
	WDT_OnTime();
	IE1 |= WDTIE;
}
/******************************************************************************************************
 * 名       称：WDT_OnTime()
 * 功       能：WDT定时中断的事件处理函数
 * 入口参数：无
 * 出口参数：无
 * 说       明：主要工作都在事件处理函数中体现
 * 范       例：无
 ******************************************************************************************************/
void WDT_OnTime() {
	static unsigned char Charge_Ready = 0;			//充满电标志位
	static unsigned char REF_Mreasure_Ready = 0;	//等于8表明参考电阻已测完
	static unsigned long R_REF_Sum = 0;			//暂存参考电阻的累加值
	if (Charge_Ready == 0)		//未充满电
			{
		Slope_Port_Charge();	//充电
		Slope_R_Dect();			//执行显示LED的任务
		Charge_Ready = 1;		//充满电标志
	} else {
		//-----测量8次参考电阻值-----
		if (REF_Mreasure_Ready < 8)					// 判断是否继续测量参考电阻值
				{
			Slope_Measure_REF();						//测参考电阻值
			R_REF_Sum = R_REF_Sum + R_REF;		//累加电阻值
			if (REF_Mreasure_Ready == 7)
				R_REF = R_REF_Sum >> 3;	//测量完毕求出参考电阻的平均值
			REF_Mreasure_Ready++;					//测量次数累加
		}
		//-----得到参考电阻值后，开始不停的测量传感器电阻值-----
		else
			Slope_Measure_SENS();					//测完参考电阻才测传感器电阻
		Charge_Ready = 0;							//测完一次，又该充电了
	}
}

/******************************************************************************************************
 * 名       称：Slope_R_Dect()
 * 功       能：对传感器电阻判断档位，调用LED显示程序
 * 入口参数：无
 * 出口参数：无
 * 说       明：主要工作都在事件处理函数中体现
 * 范       例：无
 ******************************************************************************************************/
void Slope_R_Dect() {

	//-----通过10k参考电阻，计算电阻绝对值，单位百欧-----
	Rsens = (((unsigned long int) 100) * (unsigned long int) R_SENS) / R_REF;

	//Rsens是最后电阻值

}

```

# 全部代码


![image.png](/static/img/ef7d70bd9f766535db816240a9043792.image.webp)

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

【TB作品】msp430g2553单片机，流速，流量，检测与显示

# 功能





msp430f5529单片机，读取DHT11温湿度，读取adc，oled显示

# 硬件

//OLED引脚分配 绿色板子

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

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

//RES-----------P3.7

//DC------------P8.2

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


//mq135 P6.5


//DHT11 P4.1


# 部分代码

```cpp
unsigned int adcsignal;
unsigned char   disp[15];
unsigned char   count = 0;
void main( void )
{
    unsigned char t = 0;
    WDTCTL = WDTPW + WDTHOLD;                                       /* Stop WDT */
    initClock();
    OLED_Init();
    OLED_ShowString( 0, 0, "DHT11:" );
    OLED_ShowString( 0, 4, "mq135:" );
    while ( 1 )
    {
        delay_ms( 10 );
        t = (t + 1) % 30;
        if ( t == 1 ) /* 30 个10ms执行一次 */
        {
            if ( receive_init() == 1 )
            {
                /* 存入数组 */
                count       = 0;
                disp[count++]   = ' ';
                disp[count++]   = ' ';
                disp[count++]   = humdh % 100 / 10 + '0';
                disp[count++]   = humdh % 10 / 1 + '0';
                disp[count++]   = '%';
                disp[count++]   = 'R';
                disp[count++]   = 'H';
                disp[count++]   = ' ';
                disp[count++]   = ' ';
                disp[count++]   = temph % 100 / 10 + '0';
                disp[count++]   = temph % 10 / 1 + '0';
                disp[count++]   = 'C';
                disp[count++]   = 0;
                /* 显示屏上显示温湿度字符串 */
                OLED_ShowString( 0, 2, disp );
                ADC12CTL0 |= ADC12SC;                                                           /* Start sampling/conversion */
                while ( (ADC12IFG & BIT5) == 0 )
                    ;                                                                       /* MEM5触发IFG5  意味着有了新的转换结果 */
                adcsignal   = ADC12MEM5;
                adcsignal   = (unsigned int ) ( ( (float) adcsignal) * 3.3 * 100 / 4096);   /* 换算到伏特 并乘以100 */
                count       = 0;
                disp[count++]   = adcsignal % 1000 / 100 + '0';
                disp[count++]   = '.';
                disp[count++]   = adcsignal % 100 / 10 + '0';
                disp[count++]   = adcsignal % 10 / 1 + '0';
                disp[count++]   = 'V';
                disp[count++]   = 0;
                OLED_ShowString( 0, 6, disp );
            }
        }
    }
}
```


# 全部代码


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

【TB作品】msp430f5529单片机，读取DHT11温湿度，读取adc，oled显示

# 功能





读取了GY-30 DS18B20 P6.0ADC P6.1ADC

显示到了LCD12864

# 硬件

//GY30

//SCL--P1.0

//SDA--P1.1

//VCC--3.3V

//GND--GND

//ADDR--不接

//DS18B20

//DATA--P1.6

//VCC--3.3V

//GND--GND

//ADC

//DATA--P1.6

//P6.0 P6.1 ADC输入口

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

# 部分程序


```cpp
#include <msp430.h> 
#include "lcd12864.h"
#include "gy30.h"
unsigned int temp_value = 0; /* 温度 */
unsigned int ADCresults[2];  //ADC结果
unsigned char dis[15];  //显示数组
float lx;  //光强
//***********************************************************************
//                   系统时钟初始化，外部8M晶振
//***********************************************************************
void Clock_Init(void)
{
    unsigned char i;
    BCSCTL1 &= ~XT2OFF;                 //打开XT2振荡器
    BCSCTL2 |= SELM1 + SELS;              //MCLK为8MHZ，SMCLK为8MHZ
    do
    {
        IFG1 &= ~OFIFG;                   //清楚振荡器错误标志
        for (i = 0; i < 100; i++)
            _NOP();
    }
    while ((IFG1 & OFIFG) != 0);           //如果标志位1，则继续循环等待
    IFG1 &= ~OFIFG;
}
void main(void)
{
    WDTCTL = WDTPW | WDTHOLD;   // stop watchdog timer
    Clock_Init();
    LCD_init();
    initADC();
    _EINT();
    while (1)
    {
        ADC12CTL0 |= ADC12SC;                     // Start conversion
        LPM0;
        temp_value = get_one_temperature(); //读取温度
        dis[0] = temp_value % 1000 / 100 + '0';
        dis[1] = temp_value % 100 / 10 + '0';
        dis[2] = '.';
        dis[3] = temp_value % 10 + '0';
        dis[4] = 'C';
        dis[5] = 0;
        DisplayCgrom(0x80, dis);    //第一行显示
        lx = get_lightpower(); //读取光强
        dis[0] = (int) lx % 100000 / 10000 + '0';
        dis[1] = (int) lx % 10000 / 1000 + '0';
        dis[2] = (int) lx % 1000 / 100 + '0';
        dis[3] = (int) lx % 100 / 10 + '0';
        dis[4] = (int) lx % 10 + '0';
        dis[5] = 'L';
        dis[6] = 'x';
        dis[7] = 0;
        DisplayCgrom(0x90, dis);    //第2行显示
        dis[0] = 'A';
        dis[1] = 'D';
        dis[2] = '0';
        dis[3] = ':';
        dis[4] = (int) ADCresults[0] % 10000 / 1000 + '0';
        dis[5] = (int) ADCresults[0] % 1000 / 100 + '0';
        dis[6] = (int) ADCresults[0] % 100 / 10 + '0';
        dis[7] = (int) ADCresults[0] % 10 + '0';
        dis[8] = 0;
        DisplayCgrom(0x88, dis);    //第3行显示
        dis[0] = 'A';
        dis[1] = 'D';
        dis[2] = '1';
        dis[3] = ':';
        dis[4] = (int) ADCresults[1] % 10000 / 1000 + '0';
        dis[5] = (int) ADCresults[1] % 1000 / 100 + '0';
        dis[6] = (int) ADCresults[1] % 100 / 10 + '0';
        dis[7] = (int) ADCresults[1] % 10 + '0';
        dis[8] = 0;
        DisplayCgrom(0x98, dis);    //第4行显示
    }
}
#pragma vector=ADC12_VECTOR
__interrupt void ADC12ISR(void)
{
    ADCresults[0] = ADC12MEM0;             // Move A0 results, IFG is cleared
    ADCresults[1] = ADC12MEM1;             // Move A1 results, IFG is cleared
    LPM0_EXIT;
}
```

# 全部程序

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

【TB作品】MSP430F149，ADC采集，光强GY-30，DS18B20温度采集

# 功能





读取P1.4电压，显示到口袋板显示屏，电压越高亮灯越多。


# 部分程序

```cpp
    while (1)
    {
        ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
        LPM0;
        adcvalue = ADC10MEM;             //原始数据 0到1023
        adtest = (float) adcvalue / 1024.0 * 3.3;
        dis_num_6(adtest);             //显示电压
        //电压最大值最小值限制
        if (adcvalue <= min_YIN)
            adcvalue = min_YIN;
        if (adcvalue > max_YIN)
            adcvalue = max_YIN;
        //偏差值
        adcvalue = adcvalue - min_YIN;
        //总体范围
        temp1 = max_YIN - min_YIN;
        //每一段多少
        duan = temp1 / 8;
        //控制小灯怎么点亮
        if (adcvalue > duan * 7)             //0就是点亮 1就是不亮  这里表示8个灯全部亮
        {
            PinOUT(0, 0); /* 指定0号管脚输出为0 */
            PinOUT(1, 0); /* 指定1号管脚输出为0 */
            PinOUT(2, 0); /* 指定0号管脚输出为0 */
            PinOUT(3, 0); /* 指定1号管脚输出为0 */
            PinOUT(4, 0); /* 指定0号管脚输出为0 */
            PinOUT(5, 0); /* 指定1号管脚输出为0 */
            PinOUT(6, 0); /* 指定0号管脚输出为0 */
            PinOUT(7, 0); /* 指定1号管脚输出为0 */
        }
        else if (adcvalue > duan * 6)             //0就是点亮 1就是不亮  这里表示7个灯全部亮
        {
            PinOUT(0, 0); /* 指定0号管脚输出为0 */
            PinOUT(1, 0); /* 指定1号管脚输出为0 */
            PinOUT(2, 0); /* 指定0号管脚输出为0 */
            PinOUT(3, 0); /* 指定1号管脚输出为0 */
            PinOUT(4, 0); /* 指定0号管脚输出为0 */
            PinOUT(5, 0); /* 指定1号管脚输出为0 */
            PinOUT(6, 0); /* 指定0号管脚输出为0 */
            PinOUT(7, 1); /* 指定1号管脚输出为0 */
        }
        else if (adcvalue > duan * 5)             //0就是点亮 1就是不亮  这里表示6个灯全部亮
        {
            PinOUT(0, 0); /* 指定0号管脚输出为0 */
            PinOUT(1, 0); /* 指定1号管脚输出为0 */
            PinOUT(2, 0); /* 指定0号管脚输出为0 */
            PinOUT(3, 0); /* 指定1号管脚输出为0 */
            PinOUT(4, 0); /* 指定0号管脚输出为0 */
            PinOUT(5, 0); /* 指定1号管脚输出为0 */
            PinOUT(6, 1); /* 指定0号管脚输出为0 */
            PinOUT(7, 1); /* 指定1号管脚输出为0 */
        }
        else if (adcvalue > duan * 4)             //0就是点亮 1就是不亮  这里表示5个灯全部亮
        {
            PinOUT(0, 0); /* 指定0号管脚输出为0 */
            PinOUT(1, 0); /* 指定1号管脚输出为0 */
            PinOUT(2, 0); /* 指定0号管脚输出为0 */
            PinOUT(3, 0); /* 指定1号管脚输出为0 */
            PinOUT(4, 0); /* 指定0号管脚输出为0 */
            PinOUT(5, 1); /* 指定1号管脚输出为0 */
            PinOUT(6, 1); /* 指定0号管脚输出为0 */
            PinOUT(7, 1); /* 指定1号管脚输出为0 */
        }
        else if (adcvalue > duan * 3)             //0就是点亮 1就是不亮  这里表示4个灯全部亮
        {
            PinOUT(0, 0); /* 指定0号管脚输出为0 */
            PinOUT(1, 0); /* 指定1号管脚输出为0 */
            PinOUT(2, 0); /* 指定0号管脚输出为0 */
            PinOUT(3, 0); /* 指定1号管脚输出为0 */
            PinOUT(4, 1); /* 指定0号管脚输出为0 */
            PinOUT(5, 1); /* 指定1号管脚输出为0 */
            PinOUT(6, 1); /* 指定0号管脚输出为0 */
            PinOUT(7, 1); /* 指定1号管脚输出为0 */
        }
        else if (adcvalue > duan * 2)             //0就是点亮 1就是不亮  这里表示3个灯全部亮
        {
            PinOUT(0, 0); /* 指定0号管脚输出为0 */
            PinOUT(1, 0); /* 指定1号管脚输出为0 */
            PinOUT(2, 0); /* 指定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 */
        }
        else if (adcvalue > duan * 1)             //0就是点亮 1就是不亮  这里表示2个灯全部亮
        {
            PinOUT(0, 0); /* 指定0号管脚输出为0 */
            PinOUT(1, 0); /* 指定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 */
        }
        else if (adcvalue > 50)             //0就是点亮 1就是不亮  这里表示1个灯全部亮
        {
            PinOUT(0, 0); /* 指定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 */
        }
        else             //0就是点亮 1就是不亮  这里表示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 */
        }
    }
}
// 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 单片机口袋板，读取单片机P1.4电压显示，ADC，电压表

# 功能





msp430g2553，读取SHT31，读取gy-30，显示到lcd12864

# 硬件

/*

 * 12864液晶串行显示测试程序

 *

 * P1.4模拟SID（接第5脚），

 * P1.5模拟SCLK（接第6脚）

 *

 * 4脚（CS信号）接高电平选通，  接P2.0 !!!!!!

 * 15脚（PSB信号）接地选择串行方式

 * 17脚（RST信号）根据注释提示悬空

 *

 * 以上四根线

 * 另外还需要接四根线VCC GND BLA BLK

 * 边上的是GND或者BLK  都接GND

 * 第二个就是VCC或者BLA 都接5V

 * MSP430是3.3的单片机 但是不会烧

 *

 * 并不是所有的12864都支持串口，程序不行就考虑是不是买到次品了

 */

//SHT31

//SCL--P1.2

//SDA--P1.1

//VCC--3.3V

//GND--GND

//ADDR--GND

//gy-30

//SCL--P2.1

//SDA--P2.2

//VCC--3.3V

//GND--GND

//ADDR--GND


# 部分代码

```cpp
int lx_int;
float lx;
int main(void)
{
    u8 BUFt[6] = { 0 };
    u16 temp = 0, humi = 0;
    unsigned char dis[10];
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    if (CALBC1_1MHZ == 0xFF)                  // If calibration constant erased
    {
        while (1)
            ;                               // do not load, trap CPU!!
    }
    DCOCTL = 0;                          // Select lowest DCOx and MODx settings
    BCSCTL1 = CALBC1_1MHZ;                    // Set range
    DCOCTL = CALDCO_1MHZ;                     // Set DCO step + modulation */
    lcdinit(); /* LCD初始化 */
    P2DIR = 0XFF;
    P2OUT = 0XFF;
    Lcd_WriteStr(0, 0, "温度");
    Lcd_WriteStr(0, 1, "湿度");
    Lcd_WriteStr(0, 2, "光强");
    IIC_Init();
    while (1)
    {
        IIC_Start();
        IIC_Send_Byte(SHT30W);          //发送设备地址+写信号
        while (IIC_Wait_Ack())
            ;          //从机应答
        IIC_Send_Byte(0x2C);            //命令高8位,0x2220,周期测量
        while (IIC_Wait_Ack())
            ;
        IIC_Send_Byte(0x06);            //命令高8位,0x2220,周期测量
        while (IIC_Wait_Ack())
            ;
        delay_ms(2);
        IIC_Start();
        IIC_Send_Byte(SHT30R);          //发送设备地址+写信号
        while (IIC_Wait_Ack())
            ;          //从机应答
        BUFt[0] = IIC_Read_Byte(1); //温度高
        BUFt[1] = IIC_Read_Byte(1); //温度低
        BUFt[2] = IIC_Read_Byte(1); //温度crc
        BUFt[3] = IIC_Read_Byte(1); //湿度高
        BUFt[4] = IIC_Read_Byte(1); //湿度低
        BUFt[5] = IIC_Read_Byte(0); //湿度crc
        IIC_Stop();
        temp = (BUFt[0] << 8) | BUFt[1];
        humi = (BUFt[3] << 8) | BUFt[4];
        temp = (u16) (175 * (float) temp / 65535 - 45);
        humi = (u16) (100 * (float) humi / 65535);
        delay_ms(10);
        dis[0] = temp % 100 / 10 + '0';
        dis[1] = temp % 10 + '0';
        dis[2] = 'C';
        dis[3] = 0;
        Lcd_WriteStr(2, 0, dis);
        dis[0] = humi % 100 / 10 + '0';
        dis[1] = humi % 10 + '0';
        dis[2] = 'R';
        dis[3] = 0;
        Lcd_WriteStr(2, 1, dis);
        lx_int = (int) get_lightpower();
        dis[0] = lx_int / 10000 + '0';
        dis[1] = lx_int % 10000 / 1000 + '0';
        dis[2] = lx_int % 1000 / 100 + '0';
        dis[3] = lx_int % 100 / 10 + '0';
        dis[4] = lx_int % 10 + '0';
        dis[5] = 0;
        Lcd_WriteStr(2, 2, dis);
        delay_ms(200);
    }
}
```

# 全部代码

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

【TB作品】msp430g2553，读取SHT31，读取gy-30，显示到lcd12864，温度湿度光强

# 硬件





OLED 

ADXL345  

msp430g2553

ds18b20 

# 功能

//OLED 接线 oled 是7针 0.96寸

OLED VCC接3.3V

OLED GND接GND

其他五根线：

 *  P2.0 CS

 *  P2.1 DC

 *  P2.2 RES

 *  P2.3 D1  SDA

 *  P2.4 D0


//ADXL345  接线

//只需要接五根线，其余乱七八糟的不用接

//P1.4接SCL

//P1.5接SDA

//3.3接3.3V

//CS接3.3V

//GND接GND

//

//执行到while1之后，会循环读取传感器，跟新全局变量x y  z，即是三个加速度的值。

//如果平放传感器并且静止，x和y趋于0或者很小的数值，z趋于1100。即是重力加速度。

//ds18b20 接线

//vcc 接 vcc 3.3V

//gnd 接gnd

// 数据引脚接  P1.7


# 部分代码

```cpp
    OLED_Init(); /* OLED初始化 */
    //OLED_ShowString(0, 0, "123123123123");
    ADXL345_Init(); //初始化时钟
    ADXL345_GetValue(); //更新x y z三个加速度 可以仿真设置断点查看
    ADXL345_GetValue(); //更新x y z三个加速度 可以仿真设置断点查看
    ADXL345_GetValue(); //更新x y z三个加速度 可以仿真设置断点查看
    //key
    P1DIR &= ~BIT3;
    P1REN |= BIT3;
    P1OUT |= BIT3;
    while (1)
    {
        if ((P1IN & BIT3) == 0)
        {
            delay_ms(5);
            if ((P1IN & BIT3) == 0)
            {
                display_mode = !display_mode;
                OLED_ShowString(0, 0, "              ");
                OLED_ShowString(0, 2, "              ");
                OLED_ShowString(0, 4, "              ");
                OLED_ShowString(0, 6, "              ");
                while ((P1IN & BIT3) == 0)
                    ;
            }
        }
        if (display_mode == 0)
        {
            temp_value = get_one_temperature(); //读取温度
            dis[0] = temp_value % 1000 / 100 + '0';
            dis[1] = temp_value % 100 / 10 + '0';
            dis[2] = '.';
            dis[3] = temp_value % 10 + '0';
            dis[4] = 'C';
            dis[5] = 0;
            OLED_ShowString(0, 0, "ds18b20:");
            OLED_ShowString(0, 2, dis);
            delay_ms(200);
        }
        if (display_mode == 1)
        {
            ADXL345_GetValue(); //更新x y z三个加速度 可以仿真设置断点查看
            x_temp = x;
            y_temp = y;
            z_temp = z;
            //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
            dis[0] = 'x';
            dis[1] = ' ';
            if (x_temp < 0)
            {
                dis[2] = '-';
                x_temp = -x_temp;
            }
            else
            {
                dis[2] = ' ';
            }
            dis[3] = x_temp % 10000 / 1000 + '0';
            dis[4] = x_temp % 1000 / 100 + '0';
            dis[5] = x_temp % 100 / 10 + '0';
            dis[6] = x_temp % 10 + '0';
            dis[7] = 0;
            OLED_ShowString(0, 2, dis);
            //yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy
            dis[0] = 'y';
            dis[1] = ' ';
            if (y_temp < 0)
            {
                dis[2] = '-';
                y_temp = -y_temp;
            }
            else
            {
                dis[2] = ' ';
            }
            dis[3] = y_temp % 10000 / 1000 + '0';
            dis[4] = y_temp % 1000 / 100 + '0';
            dis[5] = y_temp % 100 / 10 + '0';
            dis[6] = y_temp % 10 + '0';
            dis[7] = 0;
            OLED_ShowString(0, 4, dis);
            //zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
            dis[0] = 'z';
            dis[1] = ' ';
            if (z_temp < 0)
            {
                dis[2] = '-';
                z_temp = -z_temp;
            }
            else
            {
                dis[2] = ' ';
            }
            dis[3] = z_temp % 10000 / 1000 + '0';
            dis[4] = z_temp % 1000 / 100 + '0';
            dis[5] = z_temp % 100 / 10 + '0';
            dis[6] = z_temp % 10 + '0';
            dis[7] = 0;
            OLED_ShowString(0, 6, dis);
            OLED_ShowString(0, 0, "ADXL345:");
        }
        delay_ms(200);
    }
}
```

# 全部代码

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

【TB作品】msp430g2553，读取ADXL345+读取DS18B20

# 功能





读取dht11，显示到lcd1602显示屏，串口发送到电脑。


# 部分程序

```cpp
void main(void)
{
    char disp[20];
    char count = 0;
    WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
    P1DIR = 0Xff;
    P1SEL = 0X00;
    P1SEL2 = 0X00;
    P2DIR = 0Xff;
    P2SEL = 0X00;
    P2SEL2 = 0X00;
    LCD_init();
    LCD_clear_home();
    while (1)
    {
        /* 如果读取到了 并且校验成功 */
        if (receive_init() == 1)
        {
            /* 存入数组 */
            count = 0;
            disp[count++] = ' ';
            disp[count++] = humdh % 100 / 10 + '0';
            disp[count++] = humdh % 10 / 1 + '0';
            disp[count++] = '%';
            disp[count++] = 'R';
            disp[count++] = 'H';
            disp[count++] = ' ';
            disp[count++] = temph % 100 / 10 + '0';
            disp[count++] = temph % 10 / 1 + '0';
            disp[count++] = 'C';
            disp[count++] = 0;
            LCD_goto(0, 0);
            LCD_putstr(disp);
            Print_Str(disp);
            Print_Str("      ----\r\n");
        }
        delay_ms(500);
    }
}
```

# 全部代码

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

【TB作品】MSP430G2533，读取dht11，显示到lcd1602显示屏，串口发送到电脑

# 功能





//硬件：msp430f5529、dht22、LCD1602、蜂鸣器、烟雾传感器、蓝牙模块。

//功能：读取温湿度、烟雾浓度显示到屏幕；

//按键调节三个报警数值；

//温度、湿度、烟雾浓度，任意一个大于报警数值就蜂鸣器报警；

//单片机将温度、湿度、烟雾浓度，通过蓝牙模块，发送到电脑端显示。

//电脑端也可以调节三个报警数值。

# 引脚

```cpp
//PCF8574 LCD1602----MSP430F5529
//GND----------------GND
//VCC----------------3.3v
//SDA----------------P2.4
//SCL----------------P2.5
//HC05 蓝牙----------MSP430F5529
//GND----------------GND
//VCC----------------3.3v
//RX-----------------P3.3  T
//TX-----------------P3.4  R
//PM2烟雾传感器 0~3.3v电压转为ppm单位 20~20000ppm
//DHT22--------------MSP430F5529
//GND----------------GND
//VCC----------------3.3v
//DAT----------------P2.3
//烟雾---------------MSP430F5529
//GND----------------GND
//VCC----------------3.3v
//A0-----------------P6.5
//蜂鸣器-------------MSP430F5529
//GND----------------GND
//VCC----------------3.3v
//DAT----------------P1.6
//按键----------------MSP430F5529
//KEY1----------------P1.2
//KEY2----------------P1.3
//KEY3----------------P1.4
//KEY4----------------P1.5
//GND-----------------GND
//板子自己有的按键
//KEY5----------------P1.1
//KEY6----------------P2.1
```

# 部分程序

```cpp
unsigned char get_key(void) //声明一个函数，返回值类型为 unsigned char，函数名为 get_key，参数列表为空
{
    unsigned char key; //声明一个名为 key 的无符号字符变量
    if ((P1IN & BIT2) == 0) //如果 P1IN 寄存器的第二位是 0，说明按键1被按下
    {
        delay_ms(10); //延时 10 毫秒，以确保读取的值稳定
        if ((P1IN & BIT2) == 0) //再次检测按键1是否被按下
        {
            key = 1; //将 key 设置为 1，表示按下了按键1
            while ((P1IN & BIT2) == 0)
                //等待按键1松开
                ;
        }
    }
    else if ((P1IN & BIT3) == 0) //如果按键1未被按下，检测按键2是否被按下
    {
        delay_ms(10); //同样进行延时
        if ((P1IN & BIT3) == 0) //检测按键2是否被按下
        {
            key = 2; //将 key 设置为 2，表示按下了按键2
            while ((P1IN & BIT3) == 0)
                //等待按键2松开
                ;
        }
    }
    else if ((P1IN & BIT4) == 0)
    {
        delay_ms(10);
        if ((P1IN & BIT4) == 0)
        {
            key = 3;
            while ((P1IN & BIT4) == 0)
                ;
        }
    }
    else if ((P1IN & BIT5) == 0)
    {
        delay_ms(10);
        if ((P1IN & BIT5) == 0)
        {
            key = 4;
            while ((P1IN & BIT5) == 0)
                ;
        }
    }
    else if ((P1IN & BIT1) == 0)
    {
        delay_ms(10);
        if ((P1IN & BIT1) == 0)
        {
            key = 5;
            while ((P1IN & BIT1) == 0)
                ;
        }
    }
    else if ((P2IN & BIT1) == 0)
    {
        delay_ms(10);
        if ((P2IN & BIT1) == 0)
        {
            key = 6;
            while ((P2IN & BIT1) == 0)
                ;
        }
    }
    else
    {
        key = 0;
    }
    return key;
}
u8 data[5];
u16 shidu, wendu, yanwu;
u16 shidu_baojing = 900, wendu_baojing = 400, yanwu_baojing = 10000;
u8 disp[20];
u8 count = 0;
u8 timecnt = 0;
u8 keyvalue = 0;
void disp_line1(void) // 定义名为disp_line1的函数
{
    count = 0; // 初始化计数器
    disp[count++] = wendu % 1000 / 100 + '0'; // 将温度百位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = wendu % 100 / 10 + '0'; // 将温度十位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = 'C'; // 存入字符'C'，表示摄氏度，计数器+1
    disp[count++] = ' '; // 存入空格字符，计数器+1
    disp[count++] = shidu % 1000 / 100 + '0'; // 将湿度百位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = shidu % 100 / 10 + '0'; // 将湿度十位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = '%'; // 存入字符'%'，表示百分比符号，计数器+1
    disp[count++] = ' '; // 存入空格字符，计数器+1
    disp[count++] = yanwu % 100000 / 10000 + '0'; // 将烟雾万位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = yanwu % 10000 / 1000 + '0'; // 将烟雾千位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = yanwu % 1000 / 100 + '0'; // 将烟雾百位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = yanwu % 100 / 10 + '0'; // 将烟雾十位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = yanwu % 10 + '0'; // 将烟雾个位数字转换为字符存入显示缓存数组，计数器+1
    disp[count++] = 'p'; // 存入字符'p'，表示“ppm”（parts per million），计数器+1
    disp[count++] = 0; // 存入字符'\0'，表示字符串结束，计数器+1
    LCD_write_str(0, 0, disp); // 在LCD屏幕第0行显示disp数组中的内容
}
void send_computer(void)
{
    count = 0;
    disp[count++] = wendu % 1000 / 100 + '0';
    disp[count++] = wendu % 100 / 10 + '0';
    disp[count++] = 'C';
    disp[count++] = ' ';
    disp[count++] = shidu % 1000 / 100 + '0';
    disp[count++] = shidu % 100 / 10 + '0';
    disp[count++] = '%';
    disp[count++] = ' ';
    disp[count++] = yanwu % 100000 / 10000 + '0';
    disp[count++] = yanwu % 10000 / 1000 + '0';
    disp[count++] = yanwu % 1000 / 100 + '0';
    disp[count++] = yanwu % 100 / 10 + '0';
    disp[count++] = yanwu % 10 + '0';
    disp[count++] = 'p';
    disp[count++] = '\r';
    disp[count++] = '\n';
    disp[count++] = 0;
    Print_Str(disp);
}
void disp_line2(void)
{
    count = 0; //计数器清零
    //显示湿度报警值的百位、十位
    disp[count++] = shidu_baojing % 1000 / 100 + '0';
    disp[count++] = shidu_baojing % 100 / 10 + '0';
    disp[count++] = 'C'; //显示'C'
    disp[count++] = ' '; //显示空格
    //显示温度报警值的百位、十位
    disp[count++] = wendu_baojing % 1000 / 100 + '0';
    disp[count++] = wendu_baojing % 100 / 10 + '0';
    disp[count++] = '%'; //显示'%'
    disp[count++] = ' '; //显示空格
    //显示烟雾报警值的万位、千位、百位、十位、个位
    disp[count++] = yanwu_baojing % 100000 / 10000 + '0';
    disp[count++] = yanwu_baojing % 10000 / 1000 + '0';
    disp[count++] = yanwu_baojing % 1000 / 100 + '0';
    disp[count++] = yanwu_baojing % 100 / 10 + '0';
    disp[count++] = yanwu_baojing % 10 + '0';
    disp[count++] = 'p'; //显示'p'
    disp[count++] = 0; //末尾字符为0
    //在LCD的第1行第0列显示字符串disp
    LCD_write_str(0, 1, disp);
}
void deal_key(void)
{
    // 定义一个函数deal_key，没有返回值，没有参数
    if (keyvalue == 1)
    {
        // 如果keyvalue的值为1
        shidu_baojing += 10;
        // 湿度报警值加10
        if (shidu_baojing > 900)
        {
            // 如果湿度报警值大于900
            shidu_baojing = 900;
            // 把湿度报警值设为900
        }
    }
    else if (keyvalue == 2)
    {
        // 否则，如果keyvalue的值为2
        shidu_baojing -= 10;
        // 湿度报警值减10
        if (shidu_baojing < 100)
        {
            // 如果湿度报警值小于100
            shidu_baojing = 100;
            // 把湿度报警值设为100
        }
    }
    else if (keyvalue == 3)
    {
        // 否则，如果keyvalue的值为3
        wendu_baojing += 10;
        // 温度报警值加10
        if (wendu_baojing > 900)
        {
            // 如果温度报警值大于900
            wendu_baojing = 900;
            // 把温度报警值设为900
        }
    }
    else if (keyvalue == 4)
    {
        // 否则，如果keyvalue的值为4
        wendu_baojing -= 10;
        // 温度报警值减10
        if (wendu_baojing < 100)
        {
            // 如果温度报警值小于100
            wendu_baojing = 100;
            // 把温度报警值设为100
        }
    }
    else if (keyvalue == 5)
    {
        // 否则，如果keyvalue的值为5
        yanwu_baojing += 100;
        // 烟雾报警值加100
        if (yanwu_baojing > 20000)
        {
            // 如果烟雾报警值大于20000
            yanwu_baojing = 20000;
            // 把烟雾报警值设为20000
        }
    }
    else if (keyvalue == 6)
    {
        // 否则，如果keyvalue的值为6
        yanwu_baojing -= 100;
        // 烟雾报警值减100
        if (yanwu_baojing < 200)
        {
            // 如果烟雾报警值大于200
            yanwu_baojing = 200;
            // 把烟雾报警值设为200
        }
    }
}
void contorl_beep(void) // 定义一个名为 contorl_beep 的函数
{
    if ((shidu > shidu_baojing) || (wendu > wendu_baojing) // 如果湿度、温度或烟雾任意一个超过了警戒值
            || (yanwu > yanwu_baojing))
    {
        P1OUT &= ~BIT6; // 将 P1OUT 寄存器的第 6 位设置为 0，表示开启蜂鸣器
    }
    else // 如果湿度、温度和烟雾都没有超过警戒值
    {
        P1OUT |= BIT6; // 将 P1OUT 寄存器的第 6 位设置为 1，表示关闭开启蜂鸣器
    }
}
/* 烟雾浓度换算 */
static unsigned int  yw_ppm_count(unsigned int x1)
{
    float a =0 ,b = 0,c = 0,d = 0;
    float ax =0 ,bx = 0,cx = 0,dx = 0;
    float y;
    float x;
    x=x1*3.3/4096;
    a = x * x * x * x * x;
    b = x * x * x * x;
    c = x * x * x;
    d = x * x ;
    ax = 0.0001923 * a;
    bx = 0.006017 * b;
    cx = 0.07267 * c;
    dx = 0.425 * d;
    y = ax - bx + cx - dx + (1.267 * x) + 1.209;
    y = y * 1000;
    return (unsigned int)y;
}
void main(void)
{
    WDTCTL = WDTPW + WDTHOLD;                 // 停止看门狗定时器
    init_clock();                             // 初始化时钟
    init_uart();                              // 初始化UART串口
    init_adc();                               // 初始化ADC模块
    init_key();                               // 初始化按键
    init_beep();                              // 初始化蜂鸣器
    while (DHT22_Init() == 1)                 // 初始化DHT22温湿度传感器
    {
        delay_ms(100);                        // 延时100毫秒
    }
    delay_ms(1000);
    LCD_Init();                               // 初始化液晶屏
    disp_line2();                             // 在液晶屏上显示第二行
    _EINT();                                  // 开启总中断
    while (1)                                 // 无限循环
    {
        delay_ms(10);                         // 延时10毫秒
        timecnt++;                            // 时间计数器加1
        if (timecnt > 200)                    // 如果时间计数器超过200
        {
            timecnt = 0;                      // 重置时间计数器
            DHT22_Read_Data(data);            // 读取DHT22传感器数据
            shidu = data[0];                  // 湿度数据
            shidu = (shidu << 8) + data[1];   // 拼接数据
            wendu = data[2];                  // 温度数据
            wendu = (wendu << 8) + data[3];   // 拼接数据
            yanwu = get_adc();                // 获取烟雾浓度值
            //0到4096转为0到20000ppm
            yanwu = yw_ppm_count(yanwu);             // 将ADC值转换为烟雾浓度值
            contorl_beep();                    // 控制蜂鸣器
            disp_line1();                      // 在液晶屏上显示第一行
            disp_line2();                      // 在液晶屏上显示第二行
            send_computer();
        }
        keyvalue = get_key();                 // 获取按键值
        if (keyvalue)                         // 如果有按键按下
        {
            deal_key();                       // 处理按键
            disp_line2();                     // 在液晶屏上显示第二行
        }
    }
}
unsigned char revchar = 0;                      // 定义一个无符号字符变量，初始值为0，用于保存接收到的字符
unsigned char revchar_openflag = 0;       // 定义一个无符号字符变量，初始值为0，用于标志接收到的字符是否为有效数据
unsigned char revchar_cnt = 0;               // 定义一个无符号字符变量，初始值为0，用于计数接收到的有效数据个数
unsigned char revchar_buffer[20];              // 定义一个无符号字符数组，长度为20，用于存储接收到的有效数据
#pragma vector=USCI_A0_VECTOR                   // 定义中断函数，当 USCI_A0_VECTOR 中断发生时，执行以下函数
__interrupt void USCI_A0_ISR(void)
{
    switch (__even_in_range(UCA0IV, 4))
    // 获取 USCI_A0_VECTOR 中断的状态
    {
    case 0:                                     // Vector 0 - no interrupt，无中断状态
        break;
    case 2:                                     // Vector 2 - RXIFG，接收到数据的中断状态
        revchar = UCA0RXBUF;            // 读取 USCI_A0_VECTOR 的接收缓冲区数据到变量 revchar
        if (revchar_openflag)                   // 如果接收到的字符是有效数据
        {
            //S889912345                        // 检查接收到的数据是否符合特定的格式，如S889912345
            if ((revchar >= '0') && (revchar <= '9'))  // 如果接收到的数据是数字字符
            {
                revchar_buffer[revchar_cnt] = revchar - '0'; // 把接收到的数字字符转化为对应的数字存入 revchar_buffer 数组中
                revchar_cnt++;                              // 计数器加1
                if (revchar_cnt >= 9)                     // 如果接收到的数字字符数量达到特定的数量
                {
                    shidu_baojing = revchar_buffer[0] * 100
                            + revchar_buffer[1] * 10;  // 计算湿度报警值
                    wendu_baojing = revchar_buffer[2] * 100
                            + revchar_buffer[3] * 10;  // 计算温度报警值
                    yanwu_baojing = revchar_buffer[4] * 10000
                            + revchar_buffer[5] * 1000 + revchar_buffer[6] * 100
                            + revchar_buffer[7] * 10 + revchar_buffer[8]; // 计算烟雾报警值
                    revchar_openflag = 0;               // 清除接收标志
                    revchar_cnt = 0;                    // 清除计数器
                }
            }
            else                                    // 如果接收到的字符不是数字字符
            {
                revchar_openflag = 0;               // 清除接收标志
                revchar_cnt = 0;                    // 清除计数器
            }
        }
        if (revchar == 'S')
        {
            revchar_openflag = 1;
            revchar_cnt = 0;
        }
        break;
    case 4:
        break;                             // Vector 4 - TXIFG
    default:
        break;
    }
}
```


# 全部程序

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

【TB作品】msp430f5529单片机，dht22，烟雾传感器

# 功能





电风扇模拟控制系统设计

基本要求:

用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
```