/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2022 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "usart.h"
#include "gpio.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "rtthread.h"
#include "stdio.h"
#include "stdlib.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
typedef enum
{
KEY_UP = 0,//按键抬起
KEY_DEBOUNCE,//按键消抖
KEY_WAIT_RELEASE//按键等待释放
}KEY_STATE;
static rt_thread_t data_require_thread = RT_NULL;
static rt_thread_t display_thread = RT_NULL;
static rt_thread_t key_thread = RT_NULL;
static rt_thread_t KeyScan_thread = RT_NULL;
static rt_thread_t alert_thread1 = RT_NULL;
static rt_thread_t alert_thread2 = RT_NULL;
static rt_thread_t alert_thread3 = RT_NULL;
static rt_thread_t alert_thread4 = RT_NULL;
static rt_thread_t alert_thread5 = RT_NULL;
static rt_thread_t alert_thread6 = RT_NULL;
static rt_event_t env_event = RT_NULL;
#define env_event_1 (0x01 << 5)
#define env_event_2 (0x01 << 6)
#define env_event_3 (0x01 << 7)
#define env_event_4 (0x01 << 8)
#define env_event_5 (0x01 << 9)
#define env_event_6 (0x01 << 10)
static rt_event_t key_event = RT_NULL;
#define key_event_1 (0x01 << 0)
#define key_event_2 (0x01 << 1)
#define key_event_3 (0x01 << 2)
#define key_event_4 (0x01 << 3)
static rt_mq_t data_mq = RT_NULL;
static rt_mutex_t display_mutex = RT_NULL;
static rt_mutex_t key2_mutex = RT_NULL;
static void data_require_thread_entry(void *parameter);
static void display_thread_enrty(void *parameter);
static void key_thread_entry(void *parameter);
static void KeyScan_thread_entry(void *parameter);
static void alert_thread1_entry(void *parameter);
static void alert_thread2_entry(void *parameter);
static void alert_thread3_entry(void *parameter);
static void alert_thread4_entry(void *parameter);
static void alert_thread5_entry(void *parameter);
static void alert_thread6_entry(void *parameter);
/* 定义邮箱控制块 */
static rt_thread_t receive_thread = RT_NULL;
static rt_thread_t send_thread = RT_NULL;
//定义邮箱控制块
static rt_mailbox_t test_mail = RT_NULL;
static void receive_thread_entry(void* parameter);
static void send_thread_entry(void* parameter);
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
// GPIO输入输出宏定义
#define B1 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0)
#define B2 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1)
#define B3 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2)
#define B4 HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0)
#define BUZZ_ON HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET)
#define BUZZ_OFF HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET)
#define LED1_ON HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_RESET)
#define LED1_OFF HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_SET)
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
KEY_STATE KeyState=KEY_UP; //按键状态指示变量，初值为按键抬起状态
rt_uint16_t R37_TH1 = 1000;
rt_uint16_t R37_TH2 = 2500;
rt_uint16_t R38_TH1 = 2000;
rt_uint16_t R38_TH2 = 3500;
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint16_t getADC_R37(void)
{
uint16_t adc = 0;
HAL_ADC_Start(&hadc2);
HAL_ADC_PollForConversion(&hadc2,2);
adc = HAL_ADC_GetValue(&hadc2);
HAL_ADC_Stop(&hadc2);
return adc;
}
uint16_t getADC_R38(void)
{
uint16_t adc = 0;
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1,2);
adc = HAL_ADC_GetValue(&hadc1);
HAL_ADC_Stop(&hadc1);
return adc;
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
MX_GPIO_Init();
MX_USART1_UART_Init();
MX_ADC1_Init();
MX_ADC2_Init();
//系统初始化
// LED
// HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_RESET);
// rt_thread_delay(500);
// HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_SET);
//蜂鸣器
// HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
// rt_thread_delay(1000);
// HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
//系统功能描述
rt_kprintf("本系统为 系统\n");
//准备创建按键事件
key_event = rt_event_create("key_event", RT_IPC_FLAG_FIFO);
if (key_event != RT_NULL)
{
rt_kprintf("按键事件创建成功！\n");
}
// 消息队列创建
data_mq = rt_mq_create("data_mq",40,20,RT_IPC_FLAG_FIFO );
if(data_mq != RT_NULL)
rt_kprintf("消息队列创建成功！\n\n");
//界面切换的互斥量创建
display_mutex = rt_mutex_create("display_mutex", RT_IPC_FLAG_FIFO);
if(display_mutex != RT_NULL)
rt_kprintf("显示界面互斥量！\n\n");
//按键2的互斥量创建
key2_mutex = rt_mutex_create("key2_mutex", RT_IPC_FLAG_FIFO);
if(key2_mutex != RT_NULL)
rt_kprintf("显示界面互斥量！\n\n");
//环境报警事件的创建
env_event = rt_event_create("env_event", RT_IPC_FLAG_FIFO);
if(env_event != RT_NULL)
{
rt_kprintf("环境事件创建成功！\n");
}
//按键功能线程创建
key_thread = rt_thread_create( "key_thread", key_thread_entry, RT_NULL,256, 3, 20);
/* 启动线程，开启调度 */
if (key_thread != RT_NULL)
rt_thread_startup(key_thread);
else
return -1;
//按键扫描线程创建
KeyScan_thread = rt_thread_create( "KeyScan_thread", KeyScan_thread_entry, RT_NULL,256, 2, 20);
/* 启动线程，开启调度 */
if (KeyScan_thread != RT_NULL)
rt_thread_startup(KeyScan_thread);
else
return -1;
//数据获取线程创建
data_require_thread = rt_thread_create( "data_require_thread", data_require_thread_entry, RT_NULL, 256, 3, 20);
/* 启动线程，开启调度 */
if (data_require_thread != RT_NULL)
rt_thread_startup(data_require_thread);
else
return -1;
//显示线程创建
display_thread = rt_thread_create( "display_thread", display_thread_enrty, RT_NULL, 256, 2, 20);
/* 启动线程，开启调度 */
if (display_thread != RT_NULL)
rt_thread_startup(display_thread);
else
return -1;
//报警线程创建
alert_thread1 = rt_thread_create("alert_thread1", alert_thread1_entry, RT_NULL, 256, 1, 20);
rt_thread_startup(alert_thread1);
alert_thread2 = rt_thread_create("alert_thread2", alert_thread2_entry, RT_NULL, 256, 1, 20);
rt_thread_startup(alert_thread2);
alert_thread3 = rt_thread_create("alert_thread3", alert_thread3_entry, RT_NULL, 256, 1, 20);
rt_thread_startup(alert_thread3);
alert_thread4 = rt_thread_create("alert_thread4", alert_thread4_entry, RT_NULL, 256, 1, 20);
rt_thread_startup(alert_thread4);
alert_thread5 = rt_thread_create("alert_thread5", alert_thread5_entry, RT_NULL, 256, 1, 20);
rt_thread_startup(alert_thread5);
alert_thread6 = rt_thread_create("alert_thread6", alert_thread6_entry, RT_NULL, 256, 1, 20);
rt_thread_startup(alert_thread6);
//邮箱创建
test_mail = rt_mb_create("test_mail", 10, RT_IPC_FLAG_FIFO);
if(test_mail != RT_NULL)
rt_kprintf("邮箱创建成功！\n\n");
//接收线程创建
receive_thread = rt_thread_create( "receive", receive_thread_entry, RT_NULL, 256, 3, 20);
/* 启动线程，开启调度 */
if (receive_thread != RT_NULL)
rt_thread_startup(receive_thread);
else
return -1;
//发送线程创建
send_thread = rt_thread_create( "send", send_thread_entry, RT_NULL, 256, 2, 20);
/* 启动线程，开启调度 */
if (send_thread != RT_NULL)
rt_thread_startup(send_thread);
else
return -1;
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
/** Configure the main internal regulator output voltage
*/
HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
RCC_OscInitStruct.PLL.PLLN = 20;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
/** Initializes the peripherals clocks
*/
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_ADC12;
PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
PeriphClkInit.Adc12ClockSelection = RCC_ADC12CLKSOURCE_SYSCLK;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE BEGIN 4 */
static void alert_thread1_entry(void *parameter)
{
rt_uint32_t recved;
while(1)
{
rt_event_recv(env_event, env_event_1,
RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
// rt_kprintf("获取环境事件\n");
if(recved == env_event_1)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_RESET);
rt_thread_delay(600);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_SET);
rt_thread_delay(600);
}
else
{
rt_kprintf("环境事件错误！\n");
}
rt_thread_delay(20);
}
}
static void alert_thread2_entry(void *parameter)
{
rt_uint32_t recved;
while(1)
{
rt_event_recv(env_event, env_event_2,
RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
// rt_kprintf("获取环境事件\n");
if(recved == env_event_2)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, GPIO_PIN_RESET);
rt_thread_delay(300);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, GPIO_PIN_SET);
rt_thread_delay(300);
}
else
{
rt_kprintf("环境事件错误！\n");
}
rt_thread_delay(20);
}
}
static void alert_thread3_entry(void *parameter)
{
rt_uint32_t recved;
while(1)
{
rt_event_recv(env_event,env_event_3,
RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
// rt_kprintf("获取环境事件\n");
if(recved == env_event_3)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_10, GPIO_PIN_RESET);
rt_thread_delay(1000);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_10, GPIO_PIN_SET);
rt_thread_delay(1000);
}
else
{
rt_kprintf("环境事件错误！\n");
}
rt_thread_delay(20);
}
}
static void alert_thread4_entry(void *parameter)
{
rt_uint32_t recved;
while(1)
{
rt_event_recv(env_event,env_event_4,
RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
// rt_kprintf("获取环境事件\n");
if(recved == env_event_4)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_12, GPIO_PIN_RESET);
rt_thread_delay(500);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_12, GPIO_PIN_SET);
rt_thread_delay(500);
}
else
{
rt_kprintf("环境事件错误！\n");
}
rt_thread_delay(20);
}
}
static void alert_thread5_entry(void *parameter)
{
rt_uint32_t recved;
while(1)
{
rt_event_recv(env_event,env_event_5,
RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
// rt_kprintf("获取环境事件\n");
if(recved == env_event_5)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
rt_thread_delay(500);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
rt_thread_delay(500);
}
else
{
rt_kprintf("环境事件错误！\n");
}
rt_thread_delay(20);
}
}
static void alert_thread6_entry(void *parameter)
{
rt_uint32_t recved;
while(1)
{
rt_event_recv(env_event,env_event_6,
RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
// rt_kprintf("获取环境事件\n");
if(recved == env_event_6)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_RESET);
rt_thread_delay(500);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET);
rt_thread_delay(500);
}
else
{
rt_kprintf("环境事件错误！\n");
}
rt_thread_delay(20);
}
}
//数据获取线程和显示界面线程联合使用，获取并显示ADC对应的转换结果
static void data_require_thread_entry(void *parameter)
{
rt_err_t uwRet = RT_EOK;
while (1)
{
uint32_t send_data1= getADC_R37();
uint32_t send_data2 = getADC_R38();
uwRet = rt_mq_send(data_mq, &send_data1, sizeof(send_data1));
if(RT_EOK != uwRet)
{
rt_kprintf("数据不能发送到消息队列！错误代码： 0x%1x\n", uwRet);
}
uwRet = rt_mq_send(data_mq, &send_data2, sizeof(send_data2));
if(RT_EOK != uwRet)
{
rt_kprintf("数据不能发送到消息队列！错误代码： 0x%1x\n", uwRet);
}
rt_thread_mdelay(1000);
}
}
static void display_thread_enrty(void *parameter)
{
uint32_t r37;
uint32_t r38;
while (1)
{
rt_mq_recv(data_mq, &r37, sizeof(r37), 0);
rt_mq_recv(data_mq, &r38, sizeof(r38), 0);
if(display_mutex->hold % 2 == 0)
{
rt_kprintf("r37：%d\n", r37);
rt_kprintf("r38：%d\n", r38);
if(r37<R37_TH1)
{
rt_kprintf("r37低于%d！\n", R37_TH1);
rt_event_send(env_event, env_event_1);
}
else if((r37<R37_TH2)&&(r37>R37_TH1))
{
rt_kprintf("r37大于%d且小于%d！\n", R37_TH1, R37_TH2);
rt_event_send(env_event, env_event_2);
}
else if(r37>R37_TH2)
{
rt_kprintf("r37高于%d！\n", R37_TH2);
rt_event_send(env_event, env_event_3);
}
if(r38<R38_TH1)
{
rt_kprintf("r38小于%d！\n", R38_TH1);
rt_event_send(env_event, env_event_4);
}
else if((r38<R38_TH2)&&(r38>R38_TH1))
{
rt_kprintf("r38的值处于%d和%d之间！\n", R38_TH1, R38_TH2);
rt_event_send(env_event, env_event_5);
}
else if(r38>R38_TH2)
{
rt_kprintf("r38>%d！\n", R38_TH2);
rt_event_send(env_event, env_event_6);
}
}
else
{
rt_kprintf("R37对应两个阈值为阈值1：%d，阈值2：%d \n", R37_TH1, R37_TH2);
rt_kprintf("R38对应两个阈值为阈值1：%d，阈值2：%d \n", R38_TH1, R38_TH2);
}
rt_thread_delay(1000);
}
}
//发送线程和接收线程联合使用，获取并显示ADC对应的转换结果
static void send_thread_entry(void *parameter)
{
rt_uint8_t r37[] = " ";
rt_uint8_t r38[] = " ";
while (1)
{
rt_uint32_t send_data1= getADC_R37();
sprintf((char *)r37, "%d", send_data1);
rt_mb_send(test_mail, (rt_ubase_t)&r37);
rt_uint32_t send_date2= getADC_R38();
sprintf((char *)r38, "%d", send_date2);
rt_mb_send(test_mail, (rt_ubase_t)&r38);
rt_thread_delay(1000);
}
}
static void receive_thread_entry(void* parameter)
{
rt_err_t uwRet = RT_EOK;
char *num;
rt_uint16_t r37, r38;
while (1)
{
uwRet = rt_mb_recv(test_mail,(rt_ubase_t *)&num, RT_WAITING_FOREVER);
r37 = atoi(num);
uwRet = rt_mb_recv(test_mail,(rt_ubase_t *)&num, RT_WAITING_FOREVER);
r38 = atoi(num);
if(display_mutex->hold % 2 == 0)
{
rt_kprintf("r37：%d\n", r37);
rt_kprintf("r38：%d\n", r38);
if(r37<R37_TH1)
{
rt_kprintf("r37低于%d！\n", R37_TH1);
rt_event_send(env_event, env_event_1);
}
else if((r37<R37_TH2)&&(r37>R37_TH1))
{
rt_kprintf("r37大于%d且小于%d！\n", R37_TH1, R37_TH2);
rt_event_send(env_event, env_event_2);
}
else if(r37>R37_TH2)
{
rt_kprintf("r37高于%d！\n", R37_TH2);
rt_event_send(env_event, env_event_3);
}
if(r38<R38_TH1)
{
rt_kprintf("r38小于%d！\n", R38_TH1);
rt_event_send(env_event, env_event_4);
}
else if((r38<R38_TH2)&&(r38>R38_TH1))
{
rt_kprintf("r38的值处于%d和%d之间！\n", R38_TH1, R38_TH2);
rt_event_send(env_event, env_event_5);
}
else if(r38>R38_TH2)
{
rt_kprintf("r38>%d！\n", R38_TH2);
rt_event_send(env_event, env_event_6);
}
}
else
{
rt_kprintf("R37对应两个阈值为阈值1：%d，阈值2：%d \n", R37_TH1, R37_TH2);
rt_kprintf("R38对应两个阈值为阈值1：%d，阈值2：%d \n", R38_TH1, R38_TH2);
}
rt_thread_delay(1000);
}
}
//显示线程，阈值不可调整
//static void display_thread_enrty(void *parameter)
//{
// uint32_t r37;
// uint32_t r38;
rt_err_t uwRet = RT_EOK;
//
// while (1)
// {
// rt_mq_recv(data_mq, &r37, sizeof(r37), 0);
// rt_mq_recv(data_mq, &r38, sizeof(r38), 0);
//
// if(display_mutex->hold % 2 == 0)
// {
// rt_kprintf("r37：%d\n", r37);
// rt_kprintf("r38：%d\n", r38);
//
// if(r37<1000)
// {
// rt_kprintf("r37低于1000！\n");
// rt_event_send(env_event, env_event_1);
// }
// else if((r37<2500)&&(r37>1000))
// {
// rt_kprintf("r37大于1000且小于2500！\n");
// rt_event_send(env_event, env_event_2);
// }
// else if(r37>2500)
// {
// rt_kprintf("r37高于2500！\n");
// rt_event_send(env_event, env_event_3);
// }
//
// if(r38<2000)
// {
// rt_kprintf("r38小于2000！\n");
// rt_event_send(env_event, env_event_4);
// }
// else if((r38<3500)&&(r38>2000))
// {
// rt_kprintf("r38的值处于2000和3500之间！\n");
// rt_event_send(env_event, env_event_5);
// }
// else if(r38>3500)
// {
// rt_kprintf("r38>3500！\n");
// rt_event_send(env_event, env_event_6);
// }
//
// }
// else
// {
// rt_kprintf("R37对应两个阈值为阈值1：1000，阈值2：2500 \n");
// rt_kprintf("R38对应两个阈值为阈值1：2000，阈值2：3500 \n");
//
// }
//
// rt_thread_delay(1000);
// }
//}
static void key_thread_entry(void *parameter)
{
rt_uint32_t recved;
while(1)
{
rt_event_recv(key_event, key_event_1|key_event_2|key_event_3|key_event_4, RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
if(recved == key_event_1)
{
// rt_kprintf("按键1按下，获取按键1事件成功！\n ");
rt_mutex_take(display_mutex, RT_WAITING_FOREVER);
}
else if(recved == key_event_2)
{
// rt_kprintf("按键2按下，获取按键2事件成功！\n ");
rt_mutex_take(key2_mutex, RT_WAITING_FOREVER);
}
else if(recved == key_event_3)
{
if(key2_mutex->hold % 2 == 0)
{
if((R37_TH1+100)<4095)
{
R37_TH1 = R37_TH1 + 100;
}
else
{
R37_TH1 = 0;
R37_TH1 = R37_TH1 + 100;
}
}
else
{
if((R38_TH1+100)<4095)
{
R38_TH1 = R38_TH1 + 100;
}
else
{
R38_TH1 = 0;
R38_TH1 = R38_TH1 + 100;
}
}
}
else if(recved == key_event_4)
{
if(key2_mutex->hold % 2 == 0)
{
if((R37_TH2+100)<4095)
{
R37_TH2 = R37_TH2 + 100;
}
else
{
R37_TH2 = 0;
R37_TH2 = R37_TH2 + 100;
}
}
else
{
if((R38_TH2+100)<4095)
{
R38_TH2 = R38_TH2 + 100;
}
else
{
R38_TH2 = 0;
R38_TH2 = R38_TH2 + 100;
}
}
}
else
{
rt_kprintf("事件错误！\n");
}
rt_thread_delay(20);
}
}
static void KeyScan_thread_entry(void *parameter)
{
while(1)
{
switch(KeyState)
{
case KEY_UP: //按键抬起状态
{
//读到低电平，转换到按键消抖状态
if((B1==GPIO_PIN_RESET)||(B2==GPIO_PIN_RESET)||(B3==GPIO_PIN_RESET)||(B4==GPIO_PIN_RESET))
{
KeyState= KEY_DEBOUNCE;
}
break;
}
case KEY_DEBOUNCE: //按键消抖状态
{
// 读到低电平，转换到按键等待等待释放状态，并设置按键有效标志
if ((B1==GPIO_PIN_RESET)||(B2==GPIO_PIN_RESET)||(B3==GPIO_PIN_RESET)||(B4==GPIO_PIN_RESET))
{
KeyState = KEY_WAIT_RELEASE;
if (B1==GPIO_PIN_RESET) rt_event_send(key_event, key_event_1);
else if (B2==GPIO_PIN_RESET) rt_event_send(key_event, key_event_2);
else if (B3==GPIO_PIN_RESET) rt_event_send(key_event, key_event_3);
else if (B4==GPIO_PIN_RESET) rt_event_send(key_event, key_event_4);
}
//读到高电平，表明是干扰信号，转换到按键抬起状态
else
{
KeyState = KEY_UP;
}
break;
}
case KEY_WAIT_RELEASE: //按键等待释放状态
{
//读到低电平，说明按键仍然处于按下的状态，按键时间增加10ms
if((B1==GPIO_PIN_RESET)||(B2==GPIO_PIN_RESET)||(B3==GPIO_PIN_RESET)||(B4==GPIO_PIN_RESET))
{
}
//读到高电平，说明按键释放，转换到按键抬起状态
else
{
KeyState = KEY_UP;
}
break;
}
default: break;
}
rt_thread_delay(20);
}
}
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
