lcd+rtos模板（6/2号更新红外解码） - STM32团队 ST意法半导体中文论坛

lcd+rtos模板（6/2号更新红外解码）精华

[复制链接]

netlhx 发布时间：2015-5-28 16:07

技术贴
文章封面:	-
文章简介:	-

本帖最后由 netlhx 于 2015-6-2 20:14 编辑

RTOS调度+LCD液晶显示模板，使用的是原子的探索者，只所以使用这个来做模板，是在为毕竟NUCLEO上的资源有限，比如FSMC就没法做。而要使用液晶，FSMC还是很有必要的。

看RTOS的资料看了一段时间，最近才勉强明白了一点，希望和大家一起讨论哈！

高手请多包容，多指导！

先看看效果图。

完整的工程可以参考github.com/netlhx/stm32f407，里面的general文件夹包含一个通用的模板，LCD文件夹里将LCD和RTOS的使用结合在一起。

后面准备将其它的模块功能添加进来，虽然以前基于NUCLEOF411做了一个模板，最近折腾原子的探索者，所以那一个就没有更新了。

几点说明：
1. 绘制文字的任务是一个守护者任务（GATEKEEPER TASK），这样输出就不会产生混乱。不过任务在输出实际内容时，每个像素点都带了各自输出的位置，所以如果不使用守护者任务来实现的话，应该也没有问题。这里之所以这样处理，是为了以后的统一处理。
2. 液晶驱动为ILI9341，分辨率为240X320.
3. 没有加注释，大部分代码都比较简单，以后再整理吧

实例一、添加一个日历任务

框架已经搭好，使用RTOS的好处之一在于：每个任务就是一个模块，所以接下来看看如何添加一个日历模块，并在LCD上显示。

添加一个新任务，需要完成下列步骤：
1. 定义一个任务ID，用来对任务进行管理操作，如果不需要管理该任务，也可以跳过这步
2. 设定任务相关参数，如优先级、堆栈大小等
3. 创建任务
4. 编写任务函数

在freertos.c文件中，添加如下

完整的任务代码：

void StartShowCalendarTask(void const *argument)
{
char calendarStr[30] = "";
RCC_OscInitTypeDef RCC_OscInitStruct;
RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_LSI;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.LSEState = RCC_LSE_ON;
RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
RCC_PeriphCLKInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
__HAL_RCC_RTC_ENABLE();
RtcHandle.Instance = RTC;
RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;
RtcHandle.Init.AsynchPrediv = 127;
RtcHandle.Init.SynchPrediv = 255;
RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
HAL_RTC_Init(&RtcHandle);
if(HAL_RTCEx_BKUPRead(&RtcHandle, RTC_BKP_DR0) != 0x32F2)
{
/* Configure RTC Calendar */
RTC_CalendarConfig();
}
for(;;)
{
RTC_DateTypeDef sdatestructureget;
RTC_TimeTypeDef stimestructureget;
/* Get the RTC current Time */
HAL_RTC_GetTime(&RtcHandle, &stimestructureget, RTC_FORMAT_BIN);
/* Get the RTC current Date */
HAL_RTC_GetDate(&RtcHandle, &sdatestructureget, RTC_FORMAT_BIN);
/* Display time Format: hh:mm:ss */
sprintf((char*)calendarStr,"%02d:%02d:%02d %02d-%02d-%04d",stimestructureget.Hours, stimestructureget.Minutes, stimestructureget.Seconds,
sdatestructureget.Month, sdatestructureget.Date, 2000 + sdatestructureget.Year);
ShowString(10, 60, calendarStr);
osDelay(100);
}
}
这是任务运行实例效果，外观与没有使用RTOS并没有区别。 <img alt="" src="https://www.stmcu.org.cn/module/forum/forum.php?mod=image&aid=344633&size=300x300&key=ef30ab9e6f6ce7f2&nocache=yes&type=fixnone" border="0" aid="attachimg_344633">

复制代码

赞收藏 1 评论24 发布时间：2015-5-28 16:07

24个回答

netlhx 回答时间：2015-6-2 20:21:43

suzhe_518 发表于 2015-5-29 11:49
不错哦能否提供些入门资料谢谢

很不错的资料，E文版

rtos.pdf (1.33 MB, 下载次数: 6902)

赞评论

netlhx 回答时间：2015-5-28 16:22:43

本帖最后由 netlhx 于 2015-6-2 20:19 编辑

实例二、加入红外解码，利用红外控制MCU

RTOS支持还是很不错的，加入RTOS之后，所有的任务都是一个独立的模块。

要控制MCU来完成一些任务，主要的方法一般是两个：串口通信、红外遥控。今天来加上红外遥控支持。

板载红外支持的协议是NEC协议，所以加上相应的读取值并解码之后，就能得到输入控制码，利用控制码来完成相应的任务即可。

先看一个逻辑分析仪抓到的信号

QQ截图20150602173539.png

同上一个实例一样，使用任务来处理红外信息。同上一个实例不同的是，加入了中断控制，使用中断来处理编码信息。例程中用到了任务、信号量、队列、中断。上代码，慢慢看

#include "FreeRTOS.h"
#include "task.h"
#include "cmsis_os.h"
#include "stm32f4xx_hal.h"
#include "ili9341.h"
#include "string.h"
extern uint16_t foreColor;
TIM_HandleTypeDef htim1;
uint8_t irState;
uint32_t irData;
uint32_t icValue;
uint8_t irCount;
osThreadId defaultTaskHandle;
//osThreadId displayTaskHandle;
osThreadId drawCharTaskHandle;
//task id
osThreadId showCalendarHandle;
osThreadId IrControlHandle;
RTC_HandleTypeDef RtcHandle;
//IR SEMAPHORE
osSemaphoreId irSemHandle;
static void ShowString(uint16_t x, uint16_t y, char *msg);
//osMessageQId displayQueueHandle;
osMessageQId charQueueHandle;
//add your own task definitions
void StartDefaultTask(void const * argument);
//void StartDisplayTask(void const * argument);
void StartDrawCharTask(void const *argument);
void StartLedTask(void const *argument);
void StartShowCalendarTask(void const *argument);
void StartIrControlTask(void const *argument);
static void ShowString(uint16_t x, uint16_t y, char *msg);
void FREERTOS_Init(void);
static void RTC_CalendarConfig(void);
void FREERTOS_Init(void)
{
osMessageQDef(charQueue, 16, uint32_t);
charQueueHandle = osMessageCreate(osMessageQ(charQueue), NULL);
osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
osThreadDef(drawCharTask, StartDrawCharTask, osPriorityAboveNormal, 0, 128);
drawCharTaskHandle = osThreadCreate(osThread(drawCharTask), NULL);
//create your own tasks
osSemaphoreDef(irSem);
irSemHandle = osSemaphoreCreate(osSemaphore(irSem), 1);
osThreadDef(showCalendarTask, StartShowCalendarTask, osPriorityNormal, 0, 128);
showCalendarHandle = osThreadCreate(osThread(showCalendarTask), NULL);
osThreadDef(IrControl, StartIrControlTask, osPriorityNormal, 0, 128);
IrControlHandle = osThreadCreate(osThread(IrControl), NULL);
}
void StartDefaultTask(void const * argument)
{
for(;;)
{
osDelay(1);
}
}
//your own task implementetions
void StartDrawCharTask(void const * argument)
{
osEvent event;
CharTypeDef ch;
for(;;)
{
event = osMessageGet(charQueueHandle, osWaitForever);
ch.data = event.value.v;
lcd_DrawCharEn(ch.charInfo.x, ch.charInfo.y, ch.charInfo.ch, foreColor);
}
}
static void ShowString(uint16_t x, uint16_t y, char *msg)
{
uint16_t len = strlen(msg);
uint32_t info;
for(uint16_t i = 0; i < len; i ++)
{
info = 0;
info |= x << 24;
info |= y << 16;
info |= msg[i];
osMessagePut(charQueueHandle, info, osWaitForever);
x += 8;
}
}
void StartShowCalendarTask(void const *argument)
{
char calendarStr[30] = "";
RCC_OscInitTypeDef RCC_OscInitStruct;
RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.LSEState = RCC_LSE_ON;
RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
RCC_PeriphCLKInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
__HAL_RCC_RTC_ENABLE();
RtcHandle.Instance = RTC;
RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;
RtcHandle.Init.AsynchPrediv = 127;
RtcHandle.Init.SynchPrediv = 255;
RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
HAL_RTC_Init(&RtcHandle);
if(HAL_RTCEx_BKUPRead(&RtcHandle, RTC_BKP_DR0) != 0x32F3)
{
/* Configure RTC Calendar */
RTC_CalendarConfig();
}
for(;;)
{
RTC_DateTypeDef sdatestructureget;
RTC_TimeTypeDef stimestructureget;
/* Get the RTC current Time */
HAL_RTC_GetTime(&RtcHandle, &stimestructureget, RTC_FORMAT_BIN);
/* Get the RTC current Date */
HAL_RTC_GetDate(&RtcHandle, &sdatestructureget, RTC_FORMAT_BIN);
/* Display time Format: hh:mm:ss */
sprintf((char*)calendarStr,"%02d:%02d:%02d %02d-%02d-%04d",stimestructureget.Hours, stimestructureget.Minutes, stimestructureget.Seconds,
sdatestructureget.Month, sdatestructureget.Date, 2000 + sdatestructureget.Year);
ShowString(10, 60, calendarStr);
osDelay(100);
}
}
static void RTC_CalendarConfig(void)
{
RTC_DateTypeDef sdatestructure;
RTC_TimeTypeDef stimestructure;
/*##-1- Configure the Date #################################################*/
sdatestructure.Year = 0x15;
sdatestructure.Month = RTC_MONTH_MAY;
sdatestructure.Date = 0x28;
sdatestructure.WeekDay = RTC_WEEKDAY_THURSDAY;
if(HAL_RTC_SetDate(&RtcHandle,&sdatestructure,RTC_FORMAT_BCD) != HAL_OK)
{
/* Error */
//Error_Handler();
}
/*##-2- Configure the Time #################################################*/
/* Set Time: 02:00:00 */
stimestructure.Hours = 0x21;
stimestructure.Minutes = 0x38;
stimestructure.Seconds = 0x00;
stimestructure.TimeFormat = RTC_HOURFORMAT12_AM;
stimestructure.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
stimestructure.StoreOperation = RTC_STOREOPERATION_RESET;
if(HAL_RTC_SetTime(&RtcHandle,&stimestructure,RTC_FORMAT_BCD) != HAL_OK)
{
/* Error */
//Error_Handler();
}
/*##-3- Writes a data in a RTC Backup data Register0 #######################*/
HAL_RTCEx_BKUPWrite(&RtcHandle,RTC_BKP_DR0,0x32F3);
}
void StartIrControlTask(void const *argument)
{
TIM_MasterConfigTypeDef sMasterConfig;
TIM_IC_InitTypeDef sConfigIC;
GPIO_InitTypeDef GPIO_InitStruct;
char irMsg[30] = "";
__GPIOA_CLK_ENABLE();
__TIM1_CLK_ENABLE();
GPIO_InitStruct.Pin = GPIO_PIN_8;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM1_CC_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM1_CC_IRQn);
HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
htim1.Instance = TIM1;
htim1.Init.Prescaler = 167;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 9999;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
// sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
// HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig);
HAL_TIM_IC_Init(&htim1);
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);
sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
sConfigIC.ICFilter = 3;
HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_1);
HAL_TIM_Base_Start_IT(&htim1);
HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_1);
osSemaphoreWait(irSemHandle, 0);
for(;;)
{
osSemaphoreWait(irSemHandle, osWaitForever);
sprintf(irMsg, "Key Code: %4u ", 0xFF & (irData >> 8));
ShowString(10, 90, irMsg);
}
}
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
if(__HAL_TIM_GET_ITSTATUS(&htim1, TIM_IT_CC1) == SET)
{
if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == GPIO_PIN_SET)
{
__HAL_TIM_SET_CAPTUREPOLARITY(&htim1, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_FALLING);
TIM1->CNT = 0;
irState |= 0x10;
}
else
{
icValue = HAL_TIM_ReadCapturedValue(&htim1, TIM_CHANNEL_1);
__HAL_TIM_SET_CAPTUREPOLARITY(&htim1, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_RISING);
if(irState & 0x10)
{
if(irState & 0x80)
{
if(icValue > 300 && icValue < 800)
{
irData <<= 1;
irData |= 0;
}
else if(icValue > 1400 && icValue < 1800)
{
irData <<= 1;
irData |= 1;
}
else if(icValue > 2200 && icValue < 2600)
{
irCount ++;
irState &= 0xF0;
}
}
else if(icValue > 4200 && icValue < 4700)
{
irState |= 1 << 7;
irCount = 0;
}
}
irState &= ~(1 << 4);
}
}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(__HAL_TIM_GET_ITSTATUS(&htim1, TIM_IT_UPDATE) == SET)
{
if(irState & 0x80)
{
irState &= ~0x10;
if((irState & 0x0F) == 0)
{
irState |= 1 << 6;
osSemaphoreRelease(irSemHandle);
}
if((irState & 0x0F) < 14)
irState ++;
else
{
irState &= ~(1 << 7);
irState &= 0xF0;
}
}
}
}