# 功能





读取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
```

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