---





#### 作品功能

本项目利用MSP430单片机控制一个简单的流水灯，通过按键切换流水灯的模式。用户可以通过按键控制LED灯的方向，从左向右或从右向左依次点亮。

---

#### 作品的硬件材料

1. **MSP430单片机**

   - 具体型号：MSP430G2553

2. **LED灯**

   - 数量：8个

   - 类型：普通发光二极管

3. **电阻**

   - 数值：220欧姆

   - 数量：8个

4. **按键**

   - 数量：1个

5. **面包板和连接线**

   - 面包板：1块

   - 连接线：若干

6. **电源**

   - 3.3V电源

---

#### 电子元器件如何连接

1. **MSP430与LED的连接**

   - 将8个LED的正极分别连接到MSP430的P1.0、P1.1、P1.2、P2.3、P1.4、P1.5、P1.6和P1.7端口。

   - 每个LED的负极通过一个220欧姆电阻连接到GND。

2. **按键连接**

   - 将按键的一端连接到MSP430的P1.3端口，另一端连接到GND。

   - 在P1.3端口和VCC之间连接一个上拉电阻，数值为10k欧姆。

3. **电源连接**

   - 通过VCC和GND为MSP430单片机和其他组件供电。

---



# 全部代码

下载:https://www.lanzouh.com/iFNIz216vade 密码:bn3h

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

咨询问询请访问：
```cpp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

MSP430单片机控制流水灯，Proteus仿真

使用 MSP430 单片机读取 SHT30 传感器并显示数据





### 作品功能

本文介绍了如何使用 MSP430 单片机读取 SHT30 温湿度传感器的数据，并通过 OLED 屏幕显示实时的温度和湿度信息。通过此项目，您将学习如何配置 MSP430 的 I2C 接口、读取 SHT30 传感器的数据以及使用 OLED 显示屏显示信息。

### 作品的硬件材料

1. **MSP430 单片机**

   - 用于控制和处理数据的核心组件。

2. **SHT30 温湿度传感器**

   - 用于测量环境的温度和湿度。

3. **OLED 显示屏**

   - 用于显示温度和湿度信息。

4. **连接线**

   - 用于连接各个电子元器件。

5. **电源**

   - 为电路提供必要的电力。

### 电子元器件如何连接

1. **SHT30 传感器与 MSP430 的连接**

   - **SCL（时钟线）** 连接到 MSP430 的 **P1.2 引脚**。

   - **SDA（数据线）** 连接到 MSP430 的 **P1.1 引脚**。

   - **VCC** 连接到电源的 **3.3V**。

   - **GND** 连接到电源的 **GND**。

2. **OLED 显示屏与 MSP430 的连接**

   - **SCL（时钟线）** 连接到 MSP430 的 **P2.0 引脚**。

   - **SDA（数据线）** 连接到 MSP430 的 **P2.1 引脚**。

   - **VCC** 连接到电源的 **3.3V**。

   - **GND** 连接到电源的 **GND**。

### 代码分析

该程序的主要功能包括初始化 I2C 接口、读取 SHT30 传感器的数据，并通过 OLED 显示屏显示读取到的温湿度值。以下是主要代码段的解释：

1. **I2C 初始化和基本操作**

   ```c
   void IIC_Init(void) {
       SCL_OUT; 
       SDA_OUT; 
       SCL_1;
       SDA_1;
   }
   void IIC_Start(void) {
       SDA_OUT; 
       SDA_1;
       SCL_1;
       delay_us(20);
       SDA_0; 
       delay_us(20);
       SCL_0; 
       delay_us(20);
   }
   void IIC_Stop(void) {
       SDA_OUT; 
       SCL_0;
       SDA_0; 
       delay_us(20);
       SCL_1;
       delay_us(20);
       SDA_1; 
       delay_us(20);
   }
   ```

2. **读取传感器数据并显示**

   ```c
   int main(void) {
       unsigned char dis[10];
       WDTCTL = WDTPW + WDTHOLD; 
       if (CALBC1_1MHZ == 0xFF) {
           while (1);
       }
       DCOCTL = 0;
       BCSCTL1 = CALBC1_1MHZ;
       DCOCTL = CALDCO_1MHZ;
       OLED_Init();
       OLED_ShowString(0, 0, "SHT30:");
       IIC_Init();
       delay_ms(50);
       while (1) {
           IIC_Start();
           IIC_Send_Byte(SHT30W);
           while (IIC_Wait_Ack());
           IIC_Send_Byte(0x22);
           while (IIC_Wait_Ack());
           IIC_Send_Byte(0x20);
           while (IIC_Wait_Ack());
           delay_ms(2);
           IIC_Start();
           IIC_Send_Byte(SHT30W);
           while (IIC_Wait_Ack());
           IIC_Send_Byte(0xe0);
           while (IIC_Wait_Ack());
           IIC_Send_Byte(0x00);
           while (IIC_Wait_Ack());
           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;
           OLED_ShowString(0, 2, dis);
           dis[0] = humi % 100 / 10 + '0';
           dis[1] = humi % 10 + '0';
           dis[2] = '%';
           dis[3] = 0;
           OLED_ShowString(0, 4, dis);
           delay_ms(200);
       }
   }
   ```

成功地实现了 MSP430 单片机与 SHT30 温湿度传感器之间的 I2C 通信，并将读取到的温湿度数据实时显示在 OLED 屏幕上。

# 全部代码

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

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

【TB作品】MSP430G2553单片机，MSP430 单片机读取 SHT30 传感器并显示数据

#### 作品功能





这个项目是一个使用单片机和HC595芯片驱动数码管显示的秒表。秒表可以记录时间，以秒和百分之一秒为单位，并通过按键进行启动和暂停操作。这个简单但功能完整的秒表项目展示了如何使用串行输入/输出移位寄存器HC595和MSP430单片机来驱动数码管显示数字。

#### 作品硬件材料

- **MSP430 单片机**

- **HC595 移位寄存器 + 共阳极数码管**

- **按键**


#### 电子元器件如何连接

在这个项目中，我们将使用MSP430单片机来控制HC595移位寄存器，从而驱动数码管显示时间。以下是详细的连接步骤：

1. **HC595与MSP430的连接**

   - **VCC** 和 **GND** 分别连接到电源和地。

   - **RCK** (锁存时钟) 连接到 **P2.1** 引脚。

   - **SCK** (移位时钟) 连接到 **P2.2** 引脚。

   - **DIO** (数据输入) 连接到 **P2.0** 引脚。

2. **数码管与HC595的连接（模块自己带了）**

   - 数码管的各段连接到HC595的输出引脚。

   - 由于是共阳极数码管，需要通过电阻将数码管的公共阳极连接到电源正极。

3. **按键连接**

   - 按键的一端连接到 **P1.3** 引脚，另一端接地。

   - 按键的上拉电阻连接到 **P1.3** 和电源正极。

#### 程序代码解析

以下是程序代码的主要部分解释：

1. **初始化函数 `init_hc595`**

   ```c
   void init_hc595(void) {
       P2DIR |= BIT0;
       P2OUT &= ~BIT0;
       P2DIR |= BIT1;
       P2OUT &= ~BIT1;
       P2DIR |= BIT2;
       P2OUT &= ~BIT2;
   }
   ```

   该函数将P2.0、P2.1和P2.2引脚配置为输出，用于控制HC595的移位时钟、锁存时钟和数据输入。

2. **数据写入函数 `LedScreen_WrTwoByte`**

   ```c
   void LedScreen_WrTwoByte(unsigned char SEGDat, unsigned char COMDat) {
       // 数据传输和移位时钟的实现
   }
   ```

   该函数用于将两个字节的数据（段选和位选）传输到HC595，从而控制数码管显示。

3. **主函数 `main`**

   ```c
   int main(void) {
       WDTCTL = WDTPW + WDTHOLD; // 停止看门狗定时器
       // 初始化系统时钟、定时器和按键
       // 设置初始显示内容
       while (1) {
           if (!(P1IN & BIT3)) {
               start = !start; // 切换开始/暂停状态
               while (!(P1IN & BIT3));
           }
       }
   }
   ```

   主函数初始化系统，进入主循环等待按键输入以启动或暂停秒表。

4. **定时器中断服务程序**

   ```c
   __interrupt void Timer_A(void) {
       // 定时器中断处理，用于更新时间和数码管显示
   }
   ```

   定时器每2毫秒触发一次中断，用于更新计时和数码管显示内容。


# 全部代码

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

【TB作品】MSP430G2553单片机，使用595数码管制作的秒表

### 使用MSP430制作一个简单电子琴





## 作品功能

这个项目基于MSP430单片机，实现了一个简单的电子琴。通过按键输入，电子琴可以发出对应的音符声音。具体功能包括：

1. 按下按键时发出对应音符的声音。

2. 松开按键时停止发声。

3. 支持C调低音、中音和高音。

## 硬件材料

1. **MSP430 单片机**

2. **蜂鸣器**

3. **矩阵键盘**


## 电子元器件如何连接

### 按键

- **按键1** 接 P1.3

- **按键2** 接 P1.4

- **按键3** 接 P1.5

- **按键4** 接 P2.0

- 其他按键 P1.0 P1.1 P1.2

### 蜂鸣器

- **蜂鸣器控制引脚** 接 P2.2

## 代码讲解

### 1. 宏定义和函数声明

定义了延时函数和不同音调的频率宏，提供了音符与频率之间的映射。

```c
#include <msp430.h>
#define SYSCLK  1000000
#define CPU_F   ( (double) 1000000)                                                    
#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 L1  262
#define L2  286
#define L3  311
#define L4  349
#define L5  392
#define L6  440
#define L7  494
#define Z1  523
#define Z2  587
#define Z3  659
#define Z4  698
#define Z5  784
#define Z6  880
#define Z7  987
#define H1  1046
#define H2  1174
#define H3  1318
#define H4  1396
#define H5  1567
#define H6  1760
#define H7  1975
#define IN1 (P1IN & BIT3)
#define IN2 (P1IN & BIT4)
#define IN3 (P1IN & BIT5)
#define IN4 (P2IN & BIT0)
const char map[] = { 12, 9, 6, 3, 11, 8, 5, 2, 10, 7, 4, 1 };
int fre_st[] = { L1, L2, L3, L4, L5, L6, L7, Z1, Z2, Z3, Z4, Z5, Z6, Z7, H1, H2, H3, H4, H5, H6, H7 };
```

### 2. 主函数

初始化系统时钟、按键、蜂鸣器等模块。通过循环检测按键输入，根据按键播放对应的音调。按下按键时蜂鸣器发声，松开按键时停止发声。

```c
int main(void) {
    char key;
    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
    // 定时器中断初始化
    CCTL0 = CCIE; // CCR0 interrupt enabled
    CCR0 = 0;
    TACTL = TASSEL_2 + MC_0; // SMCLK, upmode
    // 键盘引脚初始化
    P1SEL = 0;
    P1DIR |= (BIT0 + BIT1 + BIT2); // P1.0, P1.1, P1.2是输出
    P1OUT |= (BIT0 + BIT1 + BIT2); // P1.0, P1.1, P1.2输出高电平
    P1DIR &= ~(BIT3 + BIT4 + BIT5);
    P1REN |= (BIT3 + BIT4 + BIT5);
    P1OUT |= (BIT3 + BIT4 + BIT5);
    P2DIR &= ~(BIT0);
    P2REN |= (BIT0);
    P2OUT |= (BIT0);
    // 蜂鸣器引脚初始化
    P2DIR |= BIT2; // P2.2 output
    P2SEL |= BIT2; // P2.2 for TA1.1 output
    while (1) {
        key = get_key(); // 获取按键
        if (key) {
            key = map[key - 1];
            TA1CCR0 = SYSCLK / fre_st[key - 1]; // 选一个频率
            TA1CTL = TASSEL_2 + MC_1; // SMCLK, up mode
        } else {
            TA1CTL = TASSEL_2 + MC_0; // 停止蜂鸣器
        }
    }
}
```

## 全部代码

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

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


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

【TB作品】MSP430F5529 单片机，简单电子琴

一、msp430单片机





二、0.96寸OLED显示屏12864液晶屏模块IIC接口

三、ST042 5V蜂鸣器模块 无源蜂鸣器模块 音乐发声模块 脉冲信号控制

四、ST021 加热片模块 加热部件 恒温控制 升温模块 5V发热体 电热片

五、ST035 温湿度传感器模块 DHT11温度 湿度测量 数字传感器

## 作品功能

这个智能温度控制系统基于MSP430单片机设计，能够实时监测环境温度并根据预设的温度报警值自动调节风扇和加热片的工作状态。主要功能包括：

1. 实时显示当前温度。

2. 通过OLED屏幕显示温度报警值。

3. 通过按键设置温度报警值。

4. 实际温度超过报警值时，自动开启风扇。

5. 实际温度低于报警值时，自动开启加热片。

## 硬件材料

1. **MSP430 单片机**

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

3. **OLED 显示屏**

4. **风扇**

5. **加热片**

6. **按键**


## 电子元器件如何连接

1. **DS18B20 温度传感器**

   - VCC 接 3.3V

   - GND 接 GND

   - DATA 接 P1.5

2. **OLED 显示屏**

   - VCC 接 3.3V

   - GND 接 GND

   - SCL 接 P2.0

   - SDA 接 P2.2

3. **加热片**

   - VCC 接 5 V

   - GND 接 GND

   - DATA 接 P2.3

4. **风扇**

   - VCC 接 5 V

   - GND 接 GND

   - DATA 接 P2.6

5. **按键**

   - 按键1 接 P1.1 （板子上有）

   - 按键2 接 P2.1 （板子上有）

## 代码讲解

### 初始化部分

初始化了OLED显示屏并在屏幕上设置了温度控制相关的汉字显示位置，同时配置了按键和传感器的端口。

```c
WDTCTL = WDTPW + WDTHOLD; // Stop WDT
OLED_Init(); // OLED初始化
// 第一排显示 "温度检测控制"
OLED_ShowCHinese(16 * 1, 0, 0);
OLED_ShowCHinese(16 * 2, 0, 1);
OLED_ShowCHinese(16 * 3, 0, 2);
OLED_ShowCHinese(16 * 4, 0, 3);
OLED_ShowCHinese(16 * 5, 0, 4);
OLED_ShowCHinese(16 * 6, 0, 5);
// 第二排显示 "温度："
OLED_ShowCHinese(16 * 0, 2, 6);
OLED_ShowCHinese(16 * 1, 2, 7);
OLED_ShowCHinese(16 * 2, 2, 8);
// 第三排显示 "临界："
OLED_ShowCHinese(16 * 0, 4, 9);
OLED_ShowCHinese(16 * 1, 4, 10);
OLED_ShowCHinese(16 * 2, 4, 11);
// 显示临界值
display_num_oled(16 * 3, 4, Temp_critical_value);
```

### 主循环部分

在主循环中，系统会不断读取温度传感器的值并更新显示。如果按下按键1，增加临界值；按下按键2，减少临界值。根据当前温度和临界值的比较，自动控制风扇和加热片的开关。

```c
while (1) {
    delay_ms(10);
    t = (t + 1) % 20;
    if (t == 1) {
        temperature = get_one_temperature(); // 读取温度
        display_num_oled(16 * 3, 2, temperature); // 显示温度
    }
    // 按键1：增加临界值
    if (!(P1IN & BIT1)) {
        while (!(P1IN & BIT1));
        if (Temp_critical_value < 400) {
            Temp_critical_value += 10;
        }
        display_num_oled(16 * 3, 4, Temp_critical_value); // 显示临界值
    }
    // 按键2：减少临界值
    if (!(P2IN & BIT1)) {
        while (!(P2IN & BIT1));
        if (Temp_critical_value > 20) {
            Temp_critical_value -= 10;
        }
        display_num_oled(16 * 3, 4, Temp_critical_value); // 显示临界值
    }
    // 温度控制逻辑
    if (temperature > (Temp_critical_value + 10)) {
        P2OUT |= BIT3; // 关闭加热片
        P2OUT &= ~BIT6; // 打开风扇
        OLED_ShowCHinese(16 * 0, 6, 14); // 显示"制冷"
        OLED_ShowCHinese(16 * 1, 6, 15); // 显示"制冷"
    } else if (temperature < (Temp_critical_value - 10)) {
        P2OUT &= ~BIT3; // 打开加热片
        P2OUT |= BIT6; // 关闭风扇
        OLED_ShowCHinese(16 * 0, 6, 12); // 显示"加热"
        OLED_ShowCHinese(16 * 1, 6, 13); // 显示"加热"
    } else {
        P2OUT |= BIT3; // 关闭加热片
        P2OUT |= BIT6; // 关闭风扇
        OLED_ShowString(0, 6, "      ");
    }
}
```

### 全部代码

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

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

【TB作品】MSP430F5529 单片机，温度控制系统，DS18B20，使用MSP430实现的智能温度控制系统

### 作品功能





本项目设计并实现了一个基于MSP430单片机的智能温控系统。系统可以实时显示当前温度，并且可以根据设置的临界值对环境进行加热或降温。主要功能如下：

1. 实时显示当前温度。

2. 显示并调整温度临界值，临界值可在20~35摄氏度之间调节。

3. 当前温度高于（临界值+1）摄氏度时，绿灯亮，表示降温状态。

4. 当前温度低于（临界值-1）摄氏度时，加热片工作，表示加热状态。

5. 当前温度高于35摄氏度时，蜂鸣器报警。

6. 设置温度临界值高于30摄氏度时，红灯亮，提醒避免设置温度过高。

### 作品的硬件材料

1. MSP430F5529 单片机

2. DS18B20温度传感器

3. OLED显示屏（IIC接口）

4. 绿灯（LED） 板子上有

5. 红灯（LED） 板子上有

7. 无源蜂鸣器

8. 加热片

### 电子元器件连接

各元器件的连接如下：

- DS18B20：VCC - VCC, DS - P15, GND - GND

- OLED：GND - GND, VCC - VCC, SCL - P20, SDA - P22

- 蜂鸣器：VCC - VCC, GND - GND, IN - P36

- 加热片：VCC - VCC, GND - GND, IN - P23

- 按键：P21, P11

- 绿灯：P47

- 红灯：P10

### 部分代码

```dart
int main(void)
{
    unsigned char dis[10];
    unsigned char time_cyc = 0;
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    /* 初始化显示 */
    OLED_Init(); /* OLED初始化 */
    OLED_ShowString(0, 0, "DS18B20:");
    OLED_ShowString(0, 4, "SET:");
    display_set_temp();
    /*按键端口 */
    P1DIR &= ~BIT1;
    P1SEL &= ~BIT1;
    P1REN |= BIT1;
    P1OUT |= BIT1;
    P2DIR &= ~BIT1;
    P2SEL &= ~BIT1;
    P2REN |= BIT1;
    P2OUT |= BIT1;
    /* 绿灯端口 */
    P4DIR |= BIT7;
    /* 红灯端口 */
    P1DIR |= BIT0;
    /* 蜂鸣器端口  P3.6*/
    P3SEL |= BIT6;                       // P3.5-7.6 option select
    P3DIR |= BIT6;                       // P3.5-7.6 outputs
    /* 加热片端口 */
    P2DIR |= BIT3;
    while (1)
    {
        delay_ms(10);
        time_cyc = (time_cyc + 1) % 30;
        if (time_cyc == 1) /* 30 个10ms执行一次 */
        {
            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, 2, dis);
        }
        /* 以下是根据温度控制 */
        if (temp_value > (set_temp + 10)) /* 3 实际温度高于（临界值+1）后绿灯亮表示降温。 */
        {
            P4OUT |= BIT7; /* 高电平 绿灯点亮 */
            P2OUT |= BIT3; /* 加热片不工作 */
            OLED_ShowString(0, 6, "cooling");
        }
        else if (temp_value < (set_temp - 10)) /* 4 实际温度低于（临界值-1）后加热片工作表示加热。 */
        {
            P4OUT &= ~BIT7; /* 绿灯不亮 */
            P2OUT &= ~BIT3; /* 低电平 加热片工作 */
            OLED_ShowString(0, 6, "heating");
        }
        else
        {
            P4OUT &= ~BIT7; /* 绿灯不亮 */
            P2OUT |= BIT3; /* 加热片不工作 */
            OLED_ShowString(0, 6, "        ");
        }
        /* 5 实际温度高于35摄氏度无源蜂鸣器报警。 */
        if (temp_value > 350)
        {
            TBCCR6 = 500; //打开蜂鸣器 /* PWM占空比 500/1000  蜂鸣器响 */
        }
        else
        {
            TBCCR6 = 0; //关闭打开蜂鸣器
        }
        /* 6 设置温度时候，临界值高于30摄氏度，红灯亮，提醒避免设置温度过高。 */
        if (set_temp > 300)
        {
            P1OUT |= BIT0; /* 高电平 红灯点亮 */
        }
        else
        {
            P1OUT &= ~BIT0;
        }
        /* 以下是按键处理   2 显示临界值，按键可以加减临界值，临界值在20~35之间可调。 */
        //按键1检测处理
        if (!(P1IN & BIT1))
        {
            while (!(P1IN & BIT1))
                ;
            if (set_temp < 350)
            {
                set_temp += 10;
            }
            display_set_temp();
        }
        //按键2检测处理
        if (!(P2IN & BIT1))
        {
            while (!(P2IN & BIT1))
                ;
            if (set_temp > 200)
            {
                set_temp -= 10;
            }
            display_set_temp();
        }
    }
}
```


# 全部代码

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

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

【TB作品】MSP430F5529 单片机，智能温控系统，DS18B20

# 功能





声音越大，亮的灯越多。

oled显示出当前的声音大小。

# 硬件接线

//OLED----MSP430

//VCC-----3.3V

//GND-----GND

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

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

//RES-----P2.0

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

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


led

P4八个引脚

adc

P6.0

# 部分代码

```cpp
    _EINT();
    while (1)
    {
        adok_ifg = 1; /* 转换结束后变成0 */
        ADC12CTL0 |= ADC12SC;                   // Sampling open
        delay_ms(500);
        while (adok_ifg == 1)
            ; /* 等待装换结束 */
        fute = adcvalue * 0.00805;
        xianshi[0] = fute % 100 / 10 + '0';
        xianshi[1] = '.';
        xianshi[2] = fute % 10 + '0';
        xianshi[3] = 'V';
        xianshi[4] = 0;
        OLED_ShowString(0, 0, xianshi);
        xianshi[0] = adcvalue % 10000 / 1000 + '0';
        xianshi[1] = adcvalue % 1000 / 100 + '0';
        xianshi[2] = adcvalue % 100 / 10 + '0';
        xianshi[3] = adcvalue % 10 + '0';
        xianshi[4] = 'X';
        xianshi[5] = 0;
        OLED_ShowString(0, 2, xianshi);
        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)
        {
            P4OUT = 0X00;
        }
        else if (adcvalue > duan * 6)
        {
            P4OUT = BIT7;
        }
        else if (adcvalue > duan * 5)
        {
            P4OUT = BIT7 + BIT6;
        }
        else if (adcvalue > duan * 4)
        {
            P4OUT = BIT7 + BIT6 + BIT5;
        }
        else if (adcvalue > duan * 3)
        {
            P4OUT = BIT7 + BIT6 + BIT5 + BIT4;
        }
        else if (adcvalue > duan * 2)
        {
            P4OUT = BIT7 + BIT6 + BIT5 + BIT4 + BIT3;
        }
        else if (adcvalue > duan * 1)
        {
            P4OUT = BIT7 + BIT6 + BIT5 + BIT4 + BIT3 + BIT2;
        }
        else if (adcvalue > 50)
        {
            P4OUT = BIT7 + BIT6 + BIT5 + BIT4 + BIT3 + BIT2 + BIT1;
        }
        else
        {
            P4OUT = 0XFF;
        }
        temp1 = max_YIN - min_YIN;
        temp2 = (float) adcvalue / (float) temp1 * 300;
        temp3 = temp2;
        temp1 = 210 + temp3;
        CCR1 = temp1; //设置为210到510
        xianshi[0] = 'P';
        xianshi[1] = 'W';
        xianshi[2] = 'M';
        xianshi[3] = temp1 % 10000 / 1000 + '0';
        xianshi[4] = temp1 % 1000 / 100 + '0';
        xianshi[5] = temp1 % 100 / 10 + '0';
        xianshi[6] = temp1 % 10 + '0';
        xianshi[7] = 0;
        OLED_ShowString(0, 4, xianshi);
    }
}
// ADC12 interrupt service routine
#pragma vector=ADC12_VECTOR
__interrupt void ADC12_ISR(void)
{
    adcvalue = ADC12MEM0;
    adok_ifg = 0;
}
```

# 全部代码

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

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

【TB作品】MSP430F149 单片机 音乐喷泉

# 功能





题目5基于51单片机LED8x8点阵显示

流水灯

直接滚动显示HELLO

直接滚动显示老师好

# 代码

```cpp
void main( void )
{
 /*
  * 移位后，右边的是第一个595，接收0X02，显示出0X02
  * 移位后，左边的是第2个595，接收0Xfe，显示出0Xfe
  * LedScreen_WrTwoByte(0x02,0xfe);
  */
 /*
  * 入列  传入行
  * 第一列 高电平显示
  * LedScreen_WrTwoByte(ColArr[0],0xff);
  */
 char timunum, keyifg = 0;
 while ( 1 )
 {
  if ( S1 == 0 )                                  /*按键按下 */
  {
   DelayMS( 5 );
   if ( S1 == 0 )                          /*按键按下 */
   {
    while ( S1 == 0 )
     ;
    timunum = (timunum + 1) % 3;    /* 012 */
    i = 0; m = 0; n = 0;
   }
  }
  /* 题目演示 */
  if ( timunum == 0 )                //流水灯
  {
   Leftmove_LED();
   DelayMS( 500 );
  }else if ( timunum == 1 )               /* 直接滚动显示HELLO*/
  {
   Leftmove_Display();
  }else if ( timunum == 2 )               /* 直接滚动显示老师好 */
  {
   Leftmove_DisplayDIAN();
  }
 }
}
```

# 仿真图

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


# 全部程序

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

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

【TB作品】 51单片机8x8点阵显示滚动汉字仿真

# 功能





//家用可燃气体监测报警器

//硬件：MQ-2 MQ5 OLED 蜂鸣器  按键 风扇

//1 OLED显示天然气、液化气浓度

//2 OLED显示可燃气体报警临界值

//3 2个按键用于修改可燃气体报警临界值

//4 MQ2检测到的浓度或者MQ7检测到的浓度 高于临界值时，蜂鸣器报警+风扇打开

//line:

//mq2 vcc-3.3v gnd-gnd data-p6.0

//mq5 vcc-3.3v gnd-gnd data-p6.1

//oled vcc-3.3v gnd-gnd scl-p2.0 sda-p2.2

//buzzer vcc-3.3v gnd-gnd data-p3.6

//fan    vcc-3.3v gnd-gnd data-p3.5

//key1-p1.1 key2-p2.1 nocare


# 部分程序

```cpp
int main(void)
{
    unsigned char dis[10];
    unsigned char time_cyc = 0;
    int set_value = 50;  //设置临界值
    int adc_prec[4];  //adc结果的百分比结果
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    /* 初始化显示 */
    OLED_Init(); /* OLED初始化 */
    OLED_ShowString(0, 0, "MQ-2:");
    OLED_ShowString(0, 2, "MQ-5:");
    OLED_ShowString(0, 4, " SET:");
    dis[0] = set_value % 100 / 10 + '0';
    dis[1] = set_value % 10 + '0';
    dis[2] = 37;                     //这表示百分号
    dis[3] = 0;
    OLED_ShowString(8 * 6, 4, dis);
    /*按键端口 */
    P1DIR &= ~BIT1;
    P1SEL &= ~BIT1;
    P1REN |= BIT1;
    P1OUT |= BIT1;
    P2DIR &= ~BIT1;
    P2SEL &= ~BIT1;
    P2REN |= BIT1;
    P2OUT |= BIT1;
    /* 风扇端口 P35 */
    P3DIR |= BIT5;
    /* 蜂鸣器端口P3.6  PWM 频率是(1MHZ/1000)   占空比是TBCCR6/TBCCR0 */
    P3SEL |= BIT6;                       // P3.5-7.6 option select
    _EINT();
    while (1)
    {
        //显示MQ2 MQ5
        delay_ms(10);
        time_cyc = (time_cyc + 1) % 10;
        if (time_cyc == 1) /* 10 个10ms执行一次 */
        {
            adc_prec[0] = (int) ((float) (ADCresults[0]) * 1.0 / 4096.0 * 100); //结果转化成百分比
            dis[0] = adc_prec[0] % 100 / 10 + '0';
            dis[1] = adc_prec[0] % 10 + '0';
            dis[2] = 37;                     //这表示百分号
            dis[3] = 0;
            OLED_ShowString(8 * 6, 0, dis);//第一排显示MQ2
            adc_prec[1] = (int) ((float) (ADCresults[1]) * 1.0 / 4096.0 * 100); //结果转化成百分比
            dis[0] = adc_prec[1] % 100 / 10 + '0';
            dis[1] = adc_prec[1] % 10 + '0';
            dis[2] = 37;                     //这表示百分号
            dis[3] = 0;
            OLED_ShowString(8 * 6, 2, dis);//第一排显示MQ5
        }
        //按键1检测处理
        if (!(P1IN & BIT1))
        {
            while (!(P1IN & BIT1))
                ;
            if (set_value < 95)
                set_value += 1;                     //临界值加1
            adc_prec[0] = (int) ((float) (ADCresults[0]) * 1.0 / 4096.0 * 100); //结果转化成百分比
            dis[0] = set_value % 100 / 10 + '0';
            dis[1] = set_value % 10 + '0';
            dis[2] = 37;                     //这表示百分号
            dis[3] = 0;
            OLED_ShowString(8 * 6, 4, dis);
        }
        //按键2检测处理
        if (!(P2IN & BIT1))
        {
            while (!(P2IN & BIT1))
                ;
            if (set_value > 5)
                set_value -= 1;                     //临界值-1
            adc_prec[0] = (int) ((float) (ADCresults[0]) * 1.0 / 4096.0 * 100); //结果转化成百分比
            dis[0] = set_value % 100 / 10 + '0';
            dis[1] = set_value % 10 + '0';
            dis[2] = 37;                     //这表示百分号
            dis[3] = 0;
            OLED_ShowString(8 * 6, 4, dis);
        }
        //临界值判断
        if (adc_prec[0] > set_value || adc_prec[1] > set_value) //MQ2>临界值  或者 MQ7>临界值
        {
            TBCCR6 = 500; //打开蜂鸣器
            P3OUT &= ~BIT5;//打开风扇
        }
        else
        {
            TBCCR6 = 0; //关闭打开蜂鸣器
            P3OUT |= BIT5;//关闭风扇
        }
    }
}
#pragma vector=ADC12_VECTOR
__interrupt void ADC12ISR(void)
{
    switch (__even_in_range(ADC12IV, 34))
    {
    case 12:                                  // Vector 12:  ADC12IFG3
        ADCresults[0] = ADC12MEM0;         // Move A0 results, IFG is cleared
        ADCresults[1] = ADC12MEM1;         // Move A1 results, IFG is cleared
        ADCresults[2] = ADC12MEM2;         // Move A2 results, IFG is cleared
        ADCresults[3] = ADC12MEM3;         // Move A3 results, IFG is cleared
    default:
        break;
    }
}
```

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

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





# 全部程序


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

【TB作品】msp430g2553单片机，家用可燃气体监测报警器，MQ-2，MQ5，PWM风扇

# 功能





/*

 * 硬件：DS18B20+OLEDIIC+绿灯+红灯+一个按键+蜂鸣器+加热片

 * 功能：

 * 1 显示温度

 * 2 显示临界值，按键可以加减临界值，临界值在20~35之间可调。

 * 3 实际温度高于（临界值+1）后绿灯亮表示降温。

 * 4 实际温度低于（临界值-1）后加热片工作表示加热。

 * 5 实际温度高于35摄氏度无源蜂鸣器报警。

 * 6 设置温度时候，临界值高于30摄氏度，红灯亮，提醒避免设置温度过高。

 * LINE:

 * DS18B20: VCC-VCC DS-P15 GND-GND

 * OLED:GND-GND VCC-VCC SCL-P20 SDA-P21

 * BUZZER:VCC-VCC GND-GND IN-P22

 * JIAREPIAN:VCC-VCC GND-GND IN-P23

 * KEY:P13

 * GREEN LED :P16

 * RED LED:P10

 */

# 部分程序

```cpp
int main( void )
{
    unsigned char   dis[10];
    unsigned char   time_cyc = 0;
    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 * / */
    /* 初始化显示 */
    OLED_Init();                            /* OLED初始化 */
    OLED_ShowString( 0, 0, "DS18B20:" );
    OLED_ShowString( 0, 4, "SET:" );
    display_set_temp();
    /* 10MS */
    CCTL0   = 0;                            /* CCR0 interrupt enabled */
    CCR0    = 10000;                        /* 10ms */
    TACTL   = TASSEL_2 + MC_2 + ID_3;       /* SMCLK, contmode */
    _EINT();
    /*按键端口 */
    P1DIR   &= ~BIT3;
    P1SEL   &= ~BIT3;
    P1SEL2  &= ~BIT3;
    P1REN   |= BIT3;
    P1OUT   |= BIT3;
    /* 绿灯端口 */
    P1DIR |= BIT6;
    /* 红灯端口 */
    P1DIR |= BIT0;
    /* 蜂鸣器端口 PWM：当TA1CCR1=500 蜂鸣器响，当TA1CCR1=0，蜂鸣器不响 */
    P2DIR       |= BIT2;
    P2SEL       |= BIT2;
    /* 加热片端口 */
    P2DIR |= BIT3;
    while ( 1 )
    {
        CCTL0 = CCIE;
        LPM0;
        time_cyc = (time_cyc + 1) % 30;
        if ( time_cyc == 1 )                                    /* 30 个10ms执行一次 */
        {
            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, 2, dis );
        }
        /* 以下是根据温度控制 */
        if ( temp_value > (set_temp + 10) )             /* 3 实际温度高于（临界值+1）后绿灯亮表示降温。 */
        {
            P1OUT   |= BIT6;                        /* 高电平 绿灯点亮 */
            P2OUT   |= BIT3;                        /* 加热片不工作 */
            OLED_ShowString( 0, 6, "cooling" );
        }else if ( temp_value < (set_temp - 10) )       /* 4 实际温度低于（临界值-1）后加热片工作表示加热。 */
        {
            P1OUT   &= ~BIT6;                       /* 绿灯不亮 */
            P2OUT   &= ~BIT3;                       /* 低电平 加热片工作 */
            OLED_ShowString( 0, 6, "heating" );
        }else  {
            P1OUT   &= ~BIT6;                       /* 绿灯不亮 */
            P2OUT   |= BIT3;                        /* 加热片不工作 */
            OLED_ShowString( 0, 6, "        " );
        }
        /* 5 实际温度高于35摄氏度无源蜂鸣器报警。 */
        if ( temp_value > 350 )
        {
            TA1CCR1 = 500;                          /* PWM占空比 500/1000  蜂鸣器响 */
        }else  {
            TA1CCR1 = 0;
        }
        /* 6 设置温度时候，临界值高于30摄氏度，红灯亮，提醒避免设置温度过高。 */
        if ( set_temp > 300 )
        {
            P1OUT |= BIT0;                          /* 高电平 红灯点亮 */
        }else  {
            P1OUT &= ~BIT0;
        }
        /* 以下是按键处理   2 显示临界值，按键可以加减临界值，临界值在20~35之间可调。 */
        if ( time_key == 0 )
        {
            if ( double_key_ifg == 0 )
            {
                if ( (P1IN & BIT3) == 0 )
                {
                    while ( (P1IN & BIT3) == 0 )
                        ;               /* 当循环 等待按键松开 */
                    time_key    = 10;   /* 时间内双击按键检测 */
                    double_key_ifg  = 1;
                }
            }else  {
                double_key_ifg = 0;             /*上次按过 这次恢复到0 是单击 */
                /* 单击按键处理 */
                if ( set_temp < 350 )
                {
                    set_temp += 10;
                }
                display_set_temp();
            }
        }else  {
            if ( double_key_ifg == 1 )      /*上次按过 时间内再次按了 */
            {
                if ( (P1IN & BIT3) == 0 )
                {
                    while ( (P1IN & BIT3) == 0 )
                        ;       /* 当循环 等待按键松开 */
                    double_key_ifg  = 0;
                    time_key    = 0;
                    /* 双击按键处理 */
                    if ( set_temp > 200 )
                    {
                        set_temp -= 10;
                    }
                    display_set_temp();
                }
            }
        }
    }
}
```

# 全部程序


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

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

【TB作品】msp430g2553单片机，DS18B20，温控装置，iic OLED

# 效果





只用四根线。

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


# 全部代码

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

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

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

【TB作品】msp430g2553单片机，LCD1602显示屏，四线驱动

# 功能





读取DS18B20温度  显示到LCD1602显示屏上  温度超过27.0设置度  低电平触发的有缘蜂鸣器报警

# 硬件接线

//1  LCD1602:

//vss vdd     v0            rs  rw  en  D0  D1   D2  D3   D4   D5   D5   D6     A        K     （模块）

//GND VCC(5V) 滑动变阻器输出电压   P20  P21 P22 P10 P11  P12 P13  P14  P15  P16  P17  VCC(3.3V)   GND  （单片机板子）

//如果没有滑动变阻器 就把V0接到GND  斜视着看显示

//2  DS18B20:

// VCC DS  GND   （模块）

// VCC P25 GND    （单片机板子）

//3  蜂鸣器:

// VCC D  GND   （模块）

// VCC P24 GND    （单片机板子）

# 部分程序

```cpp
int main(void)
{
    unsigned char dis[10];
    WDTCTL = WDTPW | WDTHOLD;   // stop watchdog timer
    //设置单片机工作时钟 设置为8MHZ
    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 * / */
    Port_init(); /* 显示器引脚初始化 */
    LCD_init(); /* 显示器初始化 */
    P2DIR |= BIT4; //P2.4引脚设置为输出
    P2OUT |= BIT4; //P2.4引脚输出高电平 高电平蜂鸣器不响
    while (1)
    {
        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;
        LCD_write_str(0, 0, dis);  //显示在第0排 第0个位置
        if (temp_value > 270) //大于27.0摄氏度
        {
            P2OUT &= ~BIT4; //P2.4引脚输出低电平 低电平蜂鸣器响
        }
        else
        {
            P2OUT |= BIT4; //P2.4引脚输出高电平 高电平蜂鸣器不响
        }
    }
}
```

# 全部程序

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

【TB作品】msp430g2553单片机，温度报警器，DS18B20温度，LCD1602

# 功能





秒表

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

动图：

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

# 部分代码

这段代码是用C语言编写的，用于在基于德州仪器MSP430微控制器的平台上实现一个简易的电子秒表功能。
```cpp
#include <msp430.h>
#include "LCD.h"
unsigned int    second      = 0;
unsigned int    millisecond100  = 0;
char        Stopwatch_open  = 0;
int main( void )
{
    unsigned char display_str[15], str_count;
    WDTCTL = WDTPW | WDTHOLD;       /* stop watchdog timer */
    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 * / */
    Port_init();                    /* lcd */
    LCD_init();                     /* lcd */
    LCD_write_str( 0, 0, "Stopwatch" );
    _EINT();
    while ( 1 )
    {
        /*按键输入 */
        P1DIR   &= ~BIT3;
        P1SEL   &= ~BIT3;
        P1REN   |= BIT3;
        P1OUT   |= BIT3;
        if ( !(P1IN & BIT3) )
        {
            while ( !(P1IN & BIT3) )
                ;
            Stopwatch_open = !Stopwatch_open;      /* 开始或者暂停 */
        }
        delay_ms( 10 );
        str_count           = 0;
        display_str[str_count++]    = (second / 60) % 100 / 10 + '0';
        display_str[str_count++]    = (second / 60) % 10 + '0';
        display_str[str_count++]    = ':';
        display_str[str_count++]    = (second % 60) % 100 / 10 + '0';
        display_str[str_count++]    = (second % 60) % 10 + '0';
        display_str[str_count++]    = '.';
        display_str[str_count++]    = (millisecond100) % 10 + '0';
        display_str[str_count++]    = 0;
        Port_init(); /* lcd */
        LCD_write_str( 0, 1, display_str );
    }
}
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A( void )
{
    static char num2 = 0;
    if ( Stopwatch_open )
    {
        num2 = (num2 + 1) % 10;
        if ( num2 == 9 )
        {
            millisecond100++;
            if ( millisecond100 == 10 )
            {
                millisecond100 = 0;
                second++;
            }
        }
    }
}
```


# 全部代码

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


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

【TB作品】msp430g2553单片机，秒表，LCD1602，Proteus仿真

# 硬件





OLED

PCF8591


```cpp
/*
 * OLED
 * VCC GND
 * SCL接P2^0
 * SDA接P2^1
 */
/*
 * PCF8591
 * VCC GND
 * SCL接P1^4
 * SDA接P1^5
 */
/* 板子上按键 P1.3 */
/* 单片机ADC输入引脚 P1.1 */
/* 说明：将PCF8591的DAC输出接到单片机ADC输入引脚 P1.1，单片机采集电压并显示 */
```


# 功能

这个程序是一个用于嵌入式系统的C语言程序，主要功能是控制一个数字模拟转换器(DAC)输出电压，并通过模数转换器(ADC)采集电压值，同时在OLED显示屏上实时显示这两组电压数据。具体步骤和功能如下：

1. **初始化**: 程序开始时，会停止看门狗定时器(WDT)，并根据系统时钟校准常数进行时钟配置，确保系统稳定运行。接着初始化OLED显示屏，并在其上显示字符串"DAC:"和"ADC:"作为标题。

2. **DAC控制**: 

   - 程序设定一个变量`dac_temp`来控制输出电压，默认值为0.0。

   - 通过公式`dac_value = dac_temp / 3.3 * 255`将期望的电压值转换成DAC能识别的数字量，并通过I2C协议写入到地址0x90的设备的0x40寄存器中，实现电压输出控制。

   - 同时，将`dac_temp`对应的电压值格式化为字符串，并在OLED的第二行显示该电压值。

3. **ADC读取与处理**:

   - 配置ADC10（10位模数转换器），开启中断并设置采样时间。

   - 设置P1.3作为按钮输入，启用内部上拉电阻。

   - 主循环中检测按钮状态，如果按钮被按下，则增加`dac_temp`的值（每次增加0.1V，范围限制在0到3V之间），并更新显示的DAC电压值及实际输出电压。

   - 在主循环中启动ADC采样与转换，进入低功耗模式等待转换完成中断。转换完成后，计算得到的实际电压值（0到3.3V范围内），将其扩大100倍后转换为整数，格式化为字符串，并在OLED的第四行显示ADC采集到的电压值。

综上所述，此程序实现了一个简单的电压控制系统，用户可以通过按钮调节DAC输出电压，并实时查看设置的电压值以及通过ADC采集到的电压反馈值，所有数据显示在连接的OLED显示屏上。


# 部分程序

```cpp
int main( void )
{
    unsigned char   display[10], counta;
    float       volt;
    int     last_volt;
    int dac_temp    = 0.0;
    uchar   dac_value   = 0;
    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 * / */
    OLED_Init();                                                            /* OLED初始化 */
    OLED_ShowString( 0, 0, "DAC:" );
    OLED_ShowString( 0, 4, "ADC:" );
    /* 控制DAC输出电压 */
    dac_value = dac_temp / 3.3 * 255;
    Single_WriteI2C( 0x90, 0x40, dac_value );                               /* 地址  寄存器  电压 */
    /* DAC输出电压的显示 */
    counta          = 0;
    display[counta++]   = dac_temp % 100 / 10 + '0';                    /* SHI位数字 */
    display[counta++]   = '.';
    display[counta++]   = dac_temp % 10 + '0';                          /* GE位数字 */
    display[counta++]   = 'V';
    display[counta++]   = 0;
    OLED_ShowString( 0, 2, display );                                       /* 在第2行显示DAC电压 */
    /* P1.1 ADC输入引脚 */
    ADC10CTL0   = ADC10SHT_2 + ADC10ON + ADC10IE;                       /* ADC10ON, interrupt enabled */
    P1DIR   &= ~BIT3;                                                       /*按键输入引脚寄存器设置 */
    P1REN   |= BIT3;
    P1OUT   |= BIT3;
    while ( 1 )
    {
        if ( (P1IN & BIT3) == 0 )                                       /*按键按下去了 */
        {
            while ( (P1IN & BIT3) == 0 )
                ;                                               /*按键按下去了条件一直成立 */
            dac_temp = dac_temp + 1;                                /* 加0.1V */
            if ( dac_temp > 30 )                                    /* 电压大于3V */
            {
                dac_temp = 0;
            }
            counta          = 0;
            display[counta++]   = dac_temp % 100 / 10 + '0';    /* SHI位数字 */
            display[counta++]   = '.';
            display[counta++]   = dac_temp % 10 + '0';          /* GE位数字 */
            display[counta++]   = 'V';
            display[counta++]   = 0;
            OLED_ShowString( 0, 2, display );                       /* 在第2行显示DAC电压 */
            dac_value = (float) dac_temp / 10 / 3.3 * 255;          /* 0到3.3转换到 0到255 传给模块 */
            Single_WriteI2C( 0x90, 0x40, dac_value );               /* 地址  寄存器  电压 */
        }
        ADC10CTL0 |= ENC + ADC10SC;                                     /* Sampling and conversion start */
        __bis_SR_register( CPUOFF + GIE );                              /* LPM0, ADC10_ISR will force exit */
        volt            = (float) ADC10MEM * 3.3 / 1025;        /* 得到电压 0到3.3V */
        last_volt       = (int) (volt * 100);                   /* 扩大100倍 */
        counta          = 0;
        display[counta++]   = last_volt / 100 + '0';                /* 百位数字 */
        display[counta++]   = '.';
        display[counta++]   = last_volt % 100 / 10 + '0';           /* 十位数字 */
        display[counta++]   = last_volt % 10 + '0';                 /* 个位数字 */
        display[counta++]   = 'V';
        display[counta++]   = 0;
        OLED_ShowString( 0, 6, display );                               /* 在第4行显示ADC采集到的电压 */
    }
}
```

# 全部程序


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

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

【TB作品】msp430g2553单片机，OLED，PCF8591，ADC，DAC

# 硬件





//GY-30

//SCL--P1.4

//SDA--P1.5

//VCC--3.3V

//GND--GND

//ADDR--不接


# 部分程序

```cpp
#include <msp430.h>
#include "gy30.h"
void Send_Byte(char data)
{
    while (!(IFG2 & UCA0TXIFG))
        ;                // USCI_A0 TX buffer ready?
    UCA0TXBUF = data;                    // TX -> RXed character
}
void Print_Str(char *s)
{
    while (*s != '\0')
    {
        Send_Byte(*s++);
        delay_ms(5);
    }
}
int lx;
int main(void)
{
    char SENDSTR[20];
    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 */
    while (1)
    {
        lx = (int)get_lightpower();
        Print_Str("GY30:");
        SENDSTR[0] = lx % 100000 / 10000 + '0';
        SENDSTR[1] = lx % 10000 / 1000 + '0';
        SENDSTR[2] = lx % 1000 / 100 + '0';
        SENDSTR[3] = lx % 100 / 10 + '0';
        SENDSTR[4] = lx % 10 + '0';
        SENDSTR[5] = 0;
        Print_Str (SENDSTR);                   //原始数据
        Print_Str("\r\n");
        delay_ms(200);
    }
}
```


# 全部程序


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

【TB作品】msp430g2553单片机，读取GY-30光强，串口发送

# 功能





msp430g2553单片机，读取gy-30的光照强度，oled显示光照强度，依据光照强度调节小灯亮度。

# 硬件

gy-30

0.96寸 iic oled

```cpp
//gy-30
//SCL--P1.4
//SDA--P1.5
//VCC--3.3V
//GND--GND
//ADDR--GND
//oled
//SCL--P2.0
//SDA--P2.1
//VCC--3.3V
//GND--GND
```


# 部分程序

```cpp
#include <msp430.h>
#include "gy30.h"
#include "oled.h"
float lx;
int main(void)
{
    int lx_int;
    unsigned char dis[10];
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    OLED_Init();
    OLED_ShowCHinese(16 * 2, 0, 0);
    OLED_ShowCHinese(16 * 3, 0, 1);
    OLED_ShowCHinese(16 * 4, 0, 2);
    OLED_ShowCHinese(16 * 5, 0, 3);
    while (1)
    {
        lx_int = (int) get_lightpower();
        CCR1 = lx_int/10;                               // PWM 高电平时间
        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] = 'L';
        dis[6] = 'x';
        dis[7] = 0;
        OLED_ShowString(8 * 3, 2, dis);
        delay_ms(200);
    }
}
```


# 全部程序


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

【TB作品】msp430g2553单片机，智能台灯，依据亮度调节小灯亮度，IIC oled，PWM亮度

# 硬件





gy-30

oled

```cpp
//gy-30
//SCL--P1.4
//SDA--P1.5
//VCC--3.3V
//GND--GND
//ADDR--GND
//oled
//SCL--P2.0
//SDA--P2.1
//VCC--3.3V
//GND--GND
```


# 原理图

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


# 部分程序

```cpp
#include <msp430.h>
#include "gy30.h"
#include "oled.h"
float lx;
int main(void)
{
    int lx_int;
    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 */
    OLED_Init();
    OLED_ShowString(0, 0, "GY-30:");
    OLED_ShowString(0, 2, "       Lx");
    while (1)
    {
        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;
        OLED_ShowString(0, 2, dis);
        delay_ms(200);
    }
}
```

# 所有代码下载


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


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

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

【TB作品】msp430g2553单片机，读取GY-30，光强传感器，IIC oled

# 硬件





七针 OLED

```cpp
 *  P2.0 CS
 *  P2.1 DC
 *  P2.2 RES
 *  P2.3 D1  SDA
 *  P2.4 D0
 * VCC 3.3V
 * GND GND
```

GY-30

```cpp
//gy-30
//SCL--P1.4
//SDA--P1.5
//VCC--3.3V
//GND--GND
//ADDR--GND
```

# 部分程序

```cpp
#include <msp430.h>
#include "gy30.h"
#include "oled.h"
float lx;
int main(void)
{
    int lx_int;
    unsigned char dis[10];
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    OLED_Init();                    /* OLED初始化 */
    P1DIR |= BIT6;
    P1SEL |= BIT6;
    P1SEL2 = 0;                              // Select default function for P1.2
    CCR0 = 1000;                             // PWM 周期
    CCTL1 = OUTMOD_7;                         // CCR1 reset/set
    CCR1 = 1;                               // PWM 高电平时间
    TACTL = TASSEL_2 + MC_1;                  // SMCLK, up mode
    while (1)
    {
        lx_int = (int) get_lightpower();
        CCR1 = lx_int/10;                               // PWM 高电平时间
        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] = 'L';
        dis[6] = 'x';
        dis[7] = 0;
        OLED_ShowString(0, 0, dis);
        delay_ms(200);
    }
}
```

# 全部代码

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

【TB作品】msp430g2553单片机，读取GY-30，光强传感器，显示到oled

# 功能





MSP430G2553单片机读取DS18B20

0.96寸 IIC 四针OLED

# 部分程序

```cpp
uint temp_value = 0; /* 温度 */
int main(void)
{
    unsigned char xianshi[10];
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    OLED_Init(); /* OLED初始化 */
    //显示汉字 温度：摄氏度
    OLED_ShowCHinese(16 * 0, 0, 0);
    OLED_ShowCHinese(16 * 1, 0, 1);
    OLED_ShowCHinese(16 * 2, 0, 2);
    OLED_ShowCHinese(16 * 2, 2, 3);
    OLED_ShowCHinese(16 * 3, 2, 4);
    OLED_ShowCHinese(16 * 4, 2, 5);
    while (1)
    {
        temp_value = get_one_temperature();//读取
        xianshi[0] = temp_value % 1000 / 100 + '0';
        xianshi[1] = temp_value % 100 / 10 + '0';
        xianshi[2] = '.';
        xianshi[3] = temp_value % 10 + '0';
        xianshi[4] = 0;
        OLED_ShowString(0, 2, xianshi);//显示
    }
}
```

# 实物

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

# 程序

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

# 程序下载

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

【TB作品】MSP430G2553单片机读取DS18B20温度传感器，OLED显示

霓虹灯：





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

跑马灯：

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

呼吸灯：

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

所有代码：

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

下载：

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