[第3期空气质量分析仪]第四周作业。提交学习营每周的作业~

发布于 2019-11-07 22:51:04 浏览：1071 订阅该版

**0、前言**
    第四周任务是应用前面几周学习到的内容进行花式点灯，目前开发板正好是之前做物联网项目剩下的一块板子，拥有电量显示的十段数码管，和库仑计等一些外设，这几天准备陆陆续续在这块板子上完成一些开发，初步实现如下功能，这几天公司项目比较忙，经常加班到半夜，但是做事情喜欢有始有终，可能无法及时实现全部功能，还是喜欢做点什么上来，这周感觉大家学习热情消减了，仿佛没有人有动力完成这次作业，先实现一部分功能，供大家参考，后续慢慢在评论区实现这个项目，目前通过按键进行，多种模式切换,当前为全部变量传参，全部完成后，准备通过邮箱进行传参，减小开销：
（1）、检测充电，在充电状态下进行闪烁LED灯，指示充电状态；
（2）、电量显示，该状态下实时读取电池ADC，滤波防止回弹后，根据18650放电曲线，换算电量，进行数码管显示；
（3）、温度舒适度检测，人体感觉23摄氏度较为舒适，根据此温度，23摄氏度为慢格舒适度，上下每浮动1摄氏度，格数减一；
（4）、湿度检测，湿度范围可以变化较大，所以，湿度可以除以十进行显示；
（5）、PM2.5报警模块，当PM2.5超过标准时，十段数码管同时进行闪烁
1、电池电量采集线程
bsp_adc.c
```/* 包含头文件 ----------------------------------------------------------------*/
#include "bsp_adc.h"
#include "stm32f1xx_hal.h"

/* 私有类型定义 --------------------------------------------------------------*/
/* 私有宏定义 ----------------------------------------------------------------*/
/* 私有变量 ------------------------------------------------------------------*/
float PowerVoltage = 0; //电池电压
uint8_t PROGBAR_Value;
ADC_HandleTypeDef hadc2;

/* 扩展变量 ------------------------------------------------------------------*/
/* 私有函数原型 --------------------------------------------------------------*/
static void ShellSort(uint16_t *xArray, uint8_t len);
static uint8_t PowerConversion(float Voltage, uint8_t num);
static void adc_entry(void *param);

/* 函数体 --------------------------------------------------------------------*/

/**
  * 函数功能: ADC初始化函数
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：无
  */
int ADC_Init(void)
{
	rt_thread_t adc_thread;
    ADC_ChannelConfTypeDef sConfig = {0};

/** Common config
    */
    hadc2.Instance = ADC1;
    hadc2.Init.ScanConvMode = ADC_SCAN_DISABLE;
    hadc2.Init.ContinuousConvMode = DISABLE;
    hadc2.Init.DiscontinuousConvMode = DISABLE;
    hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc2.Init.NbrOfConversion = 1;
    if (HAL_ADC_Init(&hadc2) != HAL_OK)
    {
        Error_Handler();
    }
    /** Configure Regular Channel
    */
    sConfig.Channel = ADC_CHANNEL_14;
    sConfig.Rank = ADC_REGULAR_RANK_1;
    sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
    if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
    {
        Error_Handler();
    }
	
	/* 创建电量读取线程 */
    adc_thread = rt_thread_create("adc_batter",
                                   adc_entry,
                                   RT_NULL,
                                   1024,
                                   RT_THREAD_PRIORITY_MAX / 2,
                                   20);
    if (adc_thread != RT_NULL)
    {
        rt_thread_startup(adc_thread);
    }

return RT_EOK;
}

/**
  * 函数功能: ADC采样滤波函数
  * 输入参数: 无
  * 返 回 值: 无
  * 说    明：采样值保存于ADCVal中
  */
static void adc_entry(void *param)
{
    static uint8_t Count = 0;
    static uint16_t ADCVal[30];

HAL_ADC_Start(&hadc2);
    HAL_ADC_PollForConversion(&hadc2, 10); //等待转换完成，第二个参数表示超时时间，单位ms

if (HAL_IS_BIT_SET(HAL_ADC_GetState(&hadc2), HAL_ADC_STATE_REG_EOC)) 
	{
        ADCVal[Count++] = HAL_ADC_GetValue(&hadc2);
    }

if (Count >= 30) //采样结束，执行滤波输出
    {
        Count = 0;
        ShellSort(ADCVal, 30);                                                                                                    //数据排序
        PowerVoltage = ((float)ADCVal[13] + (float)ADCVal[14] + (float)ADCVal[15] + (float)ADCVal[16]) * 16.5f / 3103 / 4 + 0.3f; //输出电压
        PROGBAR_Value = PowerConversion(PowerVoltage, 4);                                                                         /* 输出电池电量 */
    }
}

/**
  * 函数功能: 希尔排序
  * 输入参数: array : 需要排序的数组
  * 输入参数: len   : 数组长度
  * 返 回 值: 无
  * 说    明：无
  */
static void ShellSort(uint16_t *xArray, uint8_t len) {
    int temp, gap = len / 2;

while (gap > 0) {
        for (int i = 0; i < len; i++) {
            temp = xArray*;

int preIndex = i - gap;

while (preIndex > 0 && xArray[preIndex] > temp) {
                xArray[preIndex + gap] = xArray[preIndex];
                preIndex -= gap;
            }
            xArray[preIndex + gap] = temp;
        }
        gap /= 2;
    }
}

/**
  * 函数功能: 锂电池电压电量转换函数
  * 输入参数: Voltage : 锂电池电压
  * 输入参数: num : 锂电池数量（必须大于0）
  * 返 回 值: 电池电量
  * 说    明：无
  */
static uint8_t PowerConversion(float Voltage, uint8_t num) {
    float BatteryVoltage;
    static uint8_t BatteryPower = 100;
    uint8_t BatteryPowerTmp;

BatteryVoltage = Voltage / num; /* 转换为单节电池电压 */

if (BatteryVoltage > 4.06f) /* 电池电量大于90% */
    {
        BatteryPowerTmp = 90 + (uint8_t)((BatteryVoltage - 4.06f) / 0.014f);
    } 
	else if ((BatteryVoltage > 3.98f) && (BatteryVoltage <= 4.06f)) /* 电池电量介于80% - 90% */
    {
        BatteryPowerTmp = 80 + (uint8_t)((BatteryVoltage - 3.98f) / 0.008f);
    } 
	else if ((BatteryVoltage > 3.92f) && (BatteryVoltage <= 3.98f)) /* 电池电量介于70% - 80% */
    {
        BatteryPowerTmp = 70 + (uint8_t)((BatteryVoltage - 3.92f) / 0.006f);
    } 
	else if ((BatteryVoltage > 3.87f) && (BatteryVoltage <= 3.92f)) /* 电池电量介于60% - 70% */
    {
        BatteryPowerTmp = 60 + (uint8_t)((BatteryVoltage - 3.87f) / 0.005f);
    } 
	else if ((BatteryVoltage > 3.82f) && (BatteryVoltage <= 3.87f)) /* 电池电量介于50% - 60% */
    {
        BatteryPowerTmp = 50 + (uint8_t)((BatteryVoltage - 3.82f) / 0.005f);
    } 
	else if ((BatteryVoltage > 3.79f) && (BatteryVoltage <= 3.82f)) /* 电池电量介于40% - 50% */
    {
        BatteryPowerTmp = 40 + (uint8_t)((BatteryVoltage - 3.79f) / 0.003f);
    } 
	else if ((BatteryVoltage > 3.77f) && (BatteryVoltage <= 3.79f)) /* 电池电量介于30% - 40% */
    {
        BatteryPowerTmp = 30 + (uint8_t)((BatteryVoltage - 3.77f) / 0.002f);
    } 
	else if ((BatteryVoltage > 3.74f) && (BatteryVoltage <= 3.77f)) /* 电池电量介于20% - 30% */
    {
        BatteryPowerTmp = 20 + (uint8_t)((BatteryVoltage - 3.74f) / 0.003f);
    } 
	else if ((BatteryVoltage > 3.68f) && (BatteryVoltage <= 3.74f)) /* 电池电量介于10% - 20% */
    {
        BatteryPowerTmp = 10 + (uint8_t)((BatteryVoltage - 3.78f) / 0.006f);
    } 
	else if ((BatteryVoltage > 3.45f) && (BatteryVoltage <= 3.68f)) /* 电池电量介于10% - 20% */
    {
        BatteryPowerTmp = (uint8_t)((BatteryVoltage - 3.45f) / 0.023f);
    } 
	else 
	{
        BatteryPowerTmp = (uint8_t)((BatteryVoltage - 3.0f) / 0.045f);
    }

if (BatteryPowerTmp > 100) /* 禁止超过临界值 */
    {
        return 100;
    } else if (BatteryPowerTmp > BatteryPower) /* 禁止电量回弹 */
    {
        return BatteryPower;
    } else {
        BatteryPower = BatteryPowerTmp; /* 记录最新电量 */
        return BatteryPower;
    }
}

/***************************** END OF FILE *********************************/
```

bsp_adc.h
```#ifndef __BSP_ADC_H__
#define __BSP_ADC_H__

/* 包含头文件 ----------------------------------------------------------------*/
#include "main.h"

/* 类型定义 ------------------------------------------------------------------*/
/* 宏定义 --------------------------------------------------------------------*/
/* 扩展变量 ------------------------------------------------------------------*/
extern float PowerVoltage;

/* 函数声明 ------------------------------------------------------------------*/
void ADCSampling(void);

#endif  // __BSP_ADC_H__

```

**2、镇楼一张图**
![1.gif](/uploads/201911/07/224254o6luu7iilmz6mpz7.gif)

2 个回答

AaronZhang 2019-11-07

这家伙很懒，什么也没写！

字数限制10000字，下面继续
3、花式LED实现函数
digital_tube_alert.c

```
#include "digital_tube_alert.h"
#include "key.h"

/* 私有函数原型 --------------------------------------------------------------*/
static void digital_tube_entry(void *param);

/* 函数体 --------------------------------------------------------------------*/

/**
* 函数功能: LED灯初始化程序
* 输入参数: 无
* 返 回 值: 无
* 说 明：无
*/
int digital_tube_init(void)
{
rt_err_t result;
rt_thread_t digital_tube_thread;

/* 初始化GPIO口 */
rt_pin_mode(SMG1_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG2_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG3_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG4_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG5_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG6_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG7_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG8_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG9_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */
rt_pin_mode(SMG10_PIN_NUM, PIN_MODE_OUTPUT);	/* 设置为输出模式 */

rt_pin_write(SMG1_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG2_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG3_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG4_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG5_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG6_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */

result = rt_event_init(&event, "event", RT_IPC_FLAG_FIFO); /* 初始化事件对象 */

if (result != RT_EOK)
{
rt_kprintf("init event failed.\n");	/* 初始化事件失败 */
return -1;
}

digital_tube_thread = rt_thread_create("digital_tube_alarm",
digital_tube_entry,
RT_NULL,
1024,
RT_THREAD_PRIORITY_MAX / 2,
20);
if (digital_tube_thread != RT_NULL)
{
rt_thread_startup(digital_tube_thread);
}

return 0;
}

/**
* 函数功能: 功能1，进度条功能
* 输入参数: Num：进度值 0-10
* 返 回 值: 无
* 说 明：可以反映电池电量，
*/
static void Function_one(uint8_t Num)
{
switch (Num)
{
case 0:
{
rt_pin_write(SMG1_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG2_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG3_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG4_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG5_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG6_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH);	/* 将IO口置高 */
}
break;
case 1:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW);
rt_pin_write(SMG2_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG3_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG4_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG5_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG6_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH); 
}
break;
case 2:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW);
rt_pin_write(SMG2_PIN_NUM, PIN_LOW);
rt_pin_write(SMG3_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG4_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG5_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG6_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH);   
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH); 
}
break;
case 3:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW);
rt_pin_write(SMG2_PIN_NUM, PIN_LOW);
rt_pin_write(SMG3_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG4_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG5_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG6_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH); 
}
break;
case 4:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG2_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG3_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG4_PIN_NUM, PIN_LOW);
rt_pin_write(SMG5_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG6_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH);
}
break;
case 5:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW);
rt_pin_write(SMG2_PIN_NUM, PIN_LOW);
rt_pin_write(SMG3_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG4_PIN_NUM, PIN_LOW);
rt_pin_write(SMG5_PIN_NUM, PIN_LOW);
rt_pin_write(SMG6_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH); 
}
break;
case 6:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG2_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG3_PIN_NUM, PIN_LOW);
rt_pin_write(SMG4_PIN_NUM, PIN_LOW);
rt_pin_write(SMG5_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG6_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG7_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH); 
}
break;
case 7:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG2_PIN_NUM, PIN_LOW);
rt_pin_write(SMG3_PIN_NUM, PIN_LOW);
rt_pin_write(SMG4_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG5_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG6_PIN_NUM, PIN_LOW);
rt_pin_write(SMG7_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG8_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH); 
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH);
}
break;
case 8:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG2_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG3_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG4_PIN_NUM, PIN_LOW);
rt_pin_write(SMG5_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG6_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG7_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG8_PIN_NUM, PIN_LOW);
rt_pin_write(SMG9_PIN_NUM, PIN_HIGH);
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH); 
}
break;
case 9:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG2_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG3_PIN_NUM, PIN_LOW);
rt_pin_write(SMG4_PIN_NUM, PIN_LOW);
rt_pin_write(SMG5_PIN_NUM, PIN_LOW);
rt_pin_write(SMG6_PIN_NUM, PIN_LOW);
rt_pin_write(SMG7_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG8_PIN_NUM, PIN_LOW);
rt_pin_write(SMG9_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG10_PIN_NUM, PIN_HIGH); 
}
break;
case 10:
{
rt_pin_write(SMG1_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG2_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG3_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG4_PIN_NUM, PIN_LOW);
rt_pin_write(SMG5_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG6_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG7_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG8_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG9_PIN_NUM, PIN_LOW); 
rt_pin_write(SMG10_PIN_NUM, PIN_LOW); 
}
break;
default:
break;
}
}

/**
* 函数功能: 充电指示灯
* 输入参数: 无
* 返 回 值: 无
* 说 明：无
*/
static void ChargingLED(void)
{
for(int i=0;i<11;i++)
{
Function_one(i);
rt_thread_mdelay(200);
}
}

/**
* 函数功能: 电池电量指示灯
* 输入参数: Num 电量0-100
* 返 回 值: 无
* 说 明：无
*/
static void BatteryLED(uint8_t Num)
{
Function_one(Num / 10);
}

/**
* 函数功能: 数码管控制函数入口
* 输入参数: 无
* 返 回 值: 无
* 说 明：无
*/
static void digital_tube_entry(void *param)
{
while(1)
{
switch(KeyState)
{
case 0:/* 充电指示灯 */
{
ChargingLED();
}break;
case 1:/* 电量指示灯 */
{
rt_event_send(&event, EVENT_FLAG1);
BatteryLED(1);
}break;
case 2:/* 舒适温度指示灯 */
{
rt_event_send(&event, EVENT_FLAG2);
}break;
case 3:/* 湿度指示灯 */
{
rt_event_send(&event, EVENT_FLAG3);
}break;
case 4:/* PM2.5状态指示灯 */
{
rt_event_send(&event, EVENT_FLAG4);
}break;
case 5:/* 甲醛报警灯 */
{
rt_event_send(&event, EVENT_FLAG5);
}break;
default :break;
}
rt_thread_mdelay(200);
}
}

```

AaronZhang 2019-11-07

这家伙很懒，什么也没写！

digital_tube_alert.h

```
#ifndef __DIGITAL_TUBE_ALERT_H__
#define __DIGITAL_TUBE_ALERT_H__

/* 包含头文件 ----------------------------------------------------------------*/
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

/* 类型定义 ------------------------------------------------------------------*/
/* 宏定义 --------------------------------------------------------------------*/
/* 引脚编号，通过查看设备驱动文件drv_gpio.c确定 */
#ifndef SMG1_PIN_NUM
#define SMG1_PIN_NUM GET_PIN(B, 6) /* PB1 */
#endif

#ifndef SMG2_PIN_NUM
#define SMG2_PIN_NUM GET_PIN(B, 7) /* PB1 */
#endif

#ifndef SMG3_PIN_NUM
#define SMG3_PIN_NUM GET_PIN(B, 8) /* PB1 */
#endif

#ifndef SMG4_PIN_NUM
#define SMG4_PIN_NUM GET_PIN(B, 9) /* PB1 */
#endif

#ifndef SMG5_PIN_NUM
#define SMG5_PIN_NUM GET_PIN(B, 10) /* PB1 */
#endif

#ifndef SMG6_PIN_NUM
#define SMG6_PIN_NUM GET_PIN(B, 11) /* PB1 */
#endif

#ifndef SMG7_PIN_NUM
#define SMG7_PIN_NUM GET_PIN(B, 12) /* PB1 */
#endif

#ifndef SMG8_PIN_NUM
#define SMG8_PIN_NUM GET_PIN(B, 13) /* PB1 */
#endif

#ifndef SMG9_PIN_NUM
#define SMG9_PIN_NUM GET_PIN(B, 14) /* PB1 */
#endif

#ifndef SMG10_PIN_NUM
#define SMG10_PIN_NUM GET_PIN(B, 15) /* PB1 */
#endif

#define EVENT_FLAG1 (1 << 1)
#define EVENT_FLAG2 (1 << 2)
#define EVENT_FLAG3 (1 << 1)
#define EVENT_FLAG4 (1 << 2)
#define EVENT_FLAG5 (1 << 1)

/* 扩展变量 ------------------------------------------------------------------*/
extern struct rt_event event; /* 事件控制块 */

/* 函数声明-*/
int digital_tube_init(void);

#endif /* __LED_ALERT_H__ */
```

4、按键进行状态切换
key.c

```
#include "key.h"
#include "led_alert.h"

/* 扩展变量 ------------------------------------------------------------------*/
/* 私有函数原型 --------------------------------------------------------------*/
/* 函数体 --------------------------------------------------------------------*/

/**
* 函数功能: 按键回调函数
* 输入参数: 无
* 返 回 值: 无
* 说 明：无
*/
void key_cb(void *args)
{
if(rt_pin_read(KEY1_PIN_NUM))
{
if(++KeyState>5)KeyState=0;
}
}

/**
* 函数功能: 按键初始化函数
* 输入参数: 无
* 返 回 值: 无
* 说 明：无
*/
void key_init(void)
{
/* 按键0引脚为输入模式 */
rt_pin_mode(KEY1_PIN_NUM, PIN_MODE_INPUT_PULLUP);
/* 绑定中断，边沿触发模式，回调函数名为key_cb */
rt_pin_attach_irq(KEY1_PIN_NUM, PIN_IRQ_MODE_RISING_FALLING, key_cb, RT_NULL);
/* 使能中断 */
rt_pin_irq_enable(KEY1_PIN_NUM, PIN_IRQ_ENABLE);
}

/***************************** END OF FILE *********************************/
```

key.h

```
#ifndef __KEY_H__
#define __KEY_H__

/* 包含头文件 ----------------------------------------------------------------*/
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

/* 类型定义 ------------------------------------------------------------------*/
/* 宏定义 --------------------------------------------------------------------*/

#ifndef KEY0_PIN_NUM
#define KEY0_PIN_NUM GET_PIN(A, 0) /* PA0 */
#endif

#ifndef KEY1_PIN_NUM
#define KEY1_PIN_NUM GET_PIN(A, 1) /* PA1 */
#endif

/* 扩展变量 ------------------------------------------------------------------*/
extern uint8_t KeyState;/* 按压状态 */

/* 函数声明 ------------------------------------------------------------------*/
void key_init(void);

#endif /* __KEY_H__ */
```