1、emWin 配套的软件工具
Bin2C： 二进制到C转换器。 Windows的命令行实用程序，它将二进制文件转换为C数组，以直接包含在目标应用程序代码中。
BmpCvtST： 位图转换器。 它将常见的图像文件格式（如BMP， GIF和PNG）转换为所需的emWin位图格式。
emVNC： 通用VNC客户端。 用于连接到网络中任何设备上的任何VNC服务器。拥有分别适用于Windows、 macOS和Linux的不同版本。
emWinPlayer： 视频播放器。 它允许emWin电影文件（EMF）在具有Windows操作系统的计算机上播放。
emWinSPY： 可直接从目标设备对 RAM 使用情况、窗口管理器内容进行运行时分析，以及进行用户输入和屏幕截图。
emWinView： 用于在逐步模拟时查看模拟的显示内容的工具。
GUIBuilder：界面编辑器。 用于显示界面的前期设计，或在不了解 C 语言的情况下设计界面。 emWin的小部件在GUIBuilder可以直接通过拖放来放置和调整大小，而不必编写源代码。可以按上下文菜单添加其他属性， 可以通过编辑小部件的属性来微调。 设计好的界面可以保存为 C 文件，直接添加进工程中使用，但是界面的交互逻辑需要用户自定义的代码来实现。
JPEG2Movie： 视频格式转换器。用于将几乎任何现有的电影格式转换为 emWin影片文件。
U2C： UTF-8编码到C转换器。 可将 UTF-8 文本转换为 C 代码， 它读取 UTF-8 文本文件， 并创建带有 C 字符串的 C 文件。
2、emWin 文件和应用架构
Config 文件夹：其中的 GUIConf.c 文件用于配置 emWin 的存储空间分配，GUIConf.h 文 件 用 于 裁 剪 emWin 的 功 能 。 其 余 的 GUIDRV_Template.c 、LCDConf_FlexColor.c、 GUIDRV_wf.c 是 emWin 应用在不同液晶时使用的不同驱动模板；
Documentation 文件夹：它包含了《STemWin544.pdf》文件，是关于 emWin 库的用户手册，由于 emWin 库不是开源代码，所以在使用 emWin 的函数接口时，唯一可以参考的说明就是这个手册；
inc 文件夹：它包含了全部的 emWin 库核心的头文件，各种关于库函数的声明、定义都在这些文件里面；
Lib 文件夹：它包含了 emWin 的代码库文件，针对 Cortex-M0、 M3 和 M4 这些不同 CPU 内核以及是否优化，都有一个相对应的 emWin 库，在使用的时候我们要根据自己的平台选择合适的库文件；
OS 文件夹：它包含了 GUI_X.c 及 GUI_X_FreeRTOS.c 文件，分别是对应裸机平台的 GUI 延时，和多任务系统平台的关于进程调度之类的一些 emWin 所需要的底层接口；
Simulation 文件夹：它包含了用于 PC 端仿真时的 lib 库和一些依赖，但是不包含PC 端仿真的完整工程。
Software 文件夹：它包含了 BmpCvt.exe、 GUIBuilder.exe 和 FontCvt.exe 等 PC 端软件工具。 BmpCvt.exe 用于把图片数据转换成 C 文件， GUIBuilder.exe 是一个使用图形界面方式开发 emWin 应用的工具(有点像 Qt 的图形开发方式)，而FontCvt.exe 则用于字体文件转换；
Release_Notes.html 文件：是关于 emWin 库不同发行版本的简要更新说明文档。
3、emWin 文件说明
下面的针对具体的文件进行介绍， inc 部分文件太多没有全部列出
4、emWin 应用的软件架构
5、emWin 在 Windows 上的仿真
（1）搭建 emWin 的 Windows 仿真环境
emWin 的 Windows 仿真版本是免费的，大家可以直接在 Segger 官网下载，下载链接：https://www.segger.com/downloads/emwin/。
下载得到压缩包的文件名为：SeggerEval_WIN32_MSVC_MinGW_GUI_V548.zip，它是 emWin 的V5.48 版本，本教程中我们就以这个版本为例子讲解。解压该压缩包，其文件内容说明
emWin 仿真版本的工程在 Windows 上是使用 Visual c++作为编译器的，而现在 Visualc++编译器一般都集成到 Visual Studio 开发环境中了。
（2）使用 VS 2022社区版仿真 emWin
1) 解压文件。解压 emWin 仿真版本压缩包，注意解压后的文件路径不要出现中文，否则在编译时会出错的；
2) 打开仿真工程。安装了 VS 2019 社区版集成环境后，打开 emWin 仿真版本的目录，找到“SimulationTrial.sln”文件，双击打开，打开后会弹出一个对话框提示 VC++版本的问题，直接选择“确定”即可，
3) 配置仿真工程属性。 成功打开工程后，右键单击 SimulationTrial 项目，在弹出的选项中选择属性。
4) 在弹出的工程属性页面中，展开链接器选项，进入输入设置；
5) 在其中的附加依赖项中添加： legacy_stdio_definitions.lib， 注意添加分号；
6) 在忽略所有默认库中填：否；
7) 在忽略特定默认库中添加： LIBC.lib;LIBCMTD.lib
8) 接下来转到链接器选项中的高级设置， 修改映像具有安全异常处理程序的值为：否。
9) 开始编译工程。工程属性修改完成后，可以直接按快捷键“ F5”，或者点击编译器中的“本地 Windows 调试器” 按钮，编译并运行工程。 接下来就开始了编译过程，正常的话都会编译通过，然后弹出一个 emWin 仿真运行的界面。
按照我们以上的步骤，默认编译的是 emWin 官方的演示例程，它向我们展示了使用emWin 库制作出来的 GUI 效果，跟嵌入式平台相比，受液晶屏及 CPU 运行速度的影响，一般其效果会好一些，读者可亲自品味一下。
（3）emWin 仿真文件概览
现在我们来看看 emWin 仿真工程里的文件，它主要包含了 Application、 Config、 GUI、Simulation 目录及一些外部依赖项文件。
从 V5.38 版本开始， emWin 仿真工程的文件内容和结构出现了较大变化， 下面我们就来介绍一下该工程下的各类文件。
a. Application 文件夹
Application 文件夹是默认演示例程的应用文件包。在上一个小节中，我们编译的文件都是在这个 Application 目录下的，它包含了一个官方演示例程的应用文件，展开Application 目录后，可以到这些文件命名都很规范， 文件内容一目了然。 读者如果看到很炫酷的示例，可以到这里找找它的源代码来学习(综合演示例程学习难度较大，适合有一定emWin 基础的用户)。 emWin 仿真工程附带了 8 个官方演示例程，除了默认启动的例程以外，其余的演示例程路径位于：\Sample\Application 中。
b.Config 文件夹
Config 文件夹是显示配置文件包。在 Config 文件夹下，有 GUIConf.c、 GUIConf.h、LCDConfig.c、 LCDConfig.h 及 SIMConfig.c 文件，其中前三个文件在实际的嵌入式平台是非常重要的，它们分别起到了分配存储空间、裁剪 emWin 功能模块和 LCD 底层驱动实现。而 LCDConfig.h 文件没有内容， SIMConfig.c 文件是 VS 2019 社区版仿真环境需求的一些特定设置，在此我们不作探讨。
GUIConf.c 文件主要包含了一个 GUI_X_Config 函数，在这个函数中向系统申请了一个大 小 为 2.5MB(0x280000) 的 静 态 空 间 aMemory ， 接 着 调 用 emWin 的 库 函 数GUI_ALLOC_AssignMemory 把这个空间分配给 emWin。 所以 emWin 的库函数使用的存储空间都是 aMemory 中分配的。在嵌入式平台上，我们需要根据其限制控制分配给 emWin库的 aMemory 大小，修改宏 GUI_NUMBYTES 即可。 根据我们的测试， STemWin 的演示例程在野火 STM32 开发板平台上使用 43KB 即可正常运行。
GUIConf.h 文件聚集了各种与 emWin 功能裁剪相关的宏，如 GUI_NUM_LAYERS 用于配置 emWin 的最大可用层数(多显示器及复合视图支持)， GUI_OS 用于告诉 emWin 是否运行在带多任务系统的平台上等等，通过设置这些宏，可以方便地根据需要裁剪 emWin 的大小。
/*********************************************************************
* Portions COPYRIGHT 2013 STMicroelectronics *
* Portions SEGGER Microcontroller GmbH & Co. KG *
* Solutions for real time microcontroller applications *
**********************************************************************
* *
* (c) 1996 - 2013 SEGGER Microcontroller GmbH & Co. KG *
* *
* Internet: www.segger.com Support: support@segger.com *
* *
**********************************************************************
** emWin V5.22 - Graphical user interface for embedded applications **
All Intellectual Property rights in the Software belongs to SEGGER.
emWin is protected by international copyright laws. Knowledge of the
source code may not be used to write a similar product. This file may
only be used in accordance with the following terms:
The software has been licensed to STMicroelectronics International
N.V. a Dutch company with a Swiss branch and its headquarters in Plan-
les-Ouates, Geneva, 39 Chemin du Champ des Filles, Switzerland for the
purposes of creating libraries for ARM Cortex-M-based 32-bit microcon_
troller products commercialized by Licensee only, sublicensed and dis_
tributed under the terms and conditions of the End User License Agree_
ment supplied by STMicroelectronics International N.V.
Full source code is available at: www.segger.com
We appreciate your understanding and fairness.
----------------------------------------------------------------------
File : GUIDRV_stm32f429i_discovery.c
Purpose : Driver for STM32429I-Discovery board RevB
The part between 'DISPLAY CONFIGURATION START' and 'DISPLAY CONFIGURA-
TION END' can be used to configure the following for each layer:
- Color mode
- Layer size
- Layer orientation
Further the background color used on positions without a valid layer
can be set here.
---------------------------END-OF-HEADER------------------------------
*/
/**
******************************************************************************
* @attention
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.st.com/software_license_agreement_liberty_v2
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************
*/
#include "GUI.h"
#include "GUI_Private.h"
#include "GUIDRV_Lin.h"
#include "stm32f4xx.h"
#include "./lcd/bsp_lcd.h"
#include "./usart/bsp_debug_usart.h"
#define GUI_DEBUG printf
/*********************************************************************
*
* Display configuration (to be modified)
*
**********************************************************************
*/
/*********************************************************************
*
* Common
*/
//
// Physical display size
//
#define XSIZE_PHYS LCD_PIXEL_WIDTH
#define YSIZE_PHYS LCD_PIXEL_HEIGHT
//
// Buffers / VScreens
//
#define NUM_BUFFERS 3 // Number of multiple buffers to be used
#define NUM_VSCREENS 1 // Number of virtual screens to be used
//
// BkColor shown if no layer is active
//
#define BK_COLOR GUI_DARKBLUE
//
// Redefine number of layers for this configuration file. Must be equal or less than in GUIConf.h!
//
#undef GUI_NUM_LAYERS
#define GUI_NUM_LAYERS 1
/*********************************************************************
*
* Color mode definitions
*/
#define _CM_ARGB8888 1
#define _CM_RGB888 2
#define _CM_RGB565 3
#define _CM_ARGB1555 4
#define _CM_ARGB4444 5
#define _CM_L8 6
#define _CM_AL44 7
#define _CM_AL88 8
/*********************************************************************
*
* Layer 0
*/
//
// Color mode layer 0
//
#define COLOR_MODE_0 _CM_RGB565
//
// Layer size
//
#define XSIZE_0 LCD_PIXEL_WIDTH
#define YSIZE_0 LCD_PIXEL_HEIGHT
/*********************************************************************
*
* Layer 1
*/
#define COLOR_MODE_1 _CM_ARGB8888
//
// Layer size
//
#define XSIZE_1 LCD_PIXEL_WIDTH
#define YSIZE_1 LCD_PIXEL_HEIGHT
/*********************************************************************
*
* Automatic selection of driver and color conversion
*/
#if (COLOR_MODE_0 == _CM_ARGB8888)
#define COLOR_CONVERSION_0 GUICC_M8888I
#define DISPLAY_DRIVER_0 GUIDRV_LIN_32
#elif (COLOR_MODE_0 == _CM_RGB888)
#define COLOR_CONVERSION_0 GUICC_M888
#define DISPLAY_DRIVER_0 GUIDRV_LIN_24
#elif (COLOR_MODE_0 == _CM_RGB565)
#define COLOR_CONVERSION_0 GUICC_M565
#define DISPLAY_DRIVER_0 GUIDRV_LIN_16
#elif (COLOR_MODE_0 == _CM_ARGB1555)
#define COLOR_CONVERSION_0 GUICC_M1555I
#define DISPLAY_DRIVER_0 GUIDRV_LIN_16
#elif (COLOR_MODE_0 == _CM_ARGB4444)
#define COLOR_CONVERSION_0 GUICC_M4444I
#define DISPLAY_DRIVER_0 GUIDRV_LIN_16
#else
#error Illegal color mode 0!
#endif
#if (GUI_NUM_LAYERS > 1)
#if (COLOR_MODE_1 == _CM_ARGB8888)
#define COLOR_CONVERSION_1 GUICC_M8888I
#define DISPLAY_DRIVER_1 GUIDRV_LIN_32
#elif (COLOR_MODE_1 == _CM_RGB888)
#define COLOR_CONVERSION_1 GUICC_M888
#define DISPLAY_DRIVER_1 GUIDRV_LIN_24
#elif (COLOR_MODE_1 == _CM_RGB565)
#define COLOR_CONVERSION_1 GUICC_M565
#define DISPLAY_DRIVER_1 GUIDRV_LIN_16
#elif (COLOR_MODE_1 == _CM_ARGB1555)
#define COLOR_CONVERSION_1 GUICC_M1555I
#define DISPLAY_DRIVER_1 GUIDRV_LIN_16
#elif (COLOR_MODE_1 == _CM_ARGB4444)
#define COLOR_CONVERSION_1 GUICC_M4444I
#define DISPLAY_DRIVER_1 GUIDRV_LIN_16
#else
#error Illegal color mode 1!
#endif
#else
/*********************************************************************
*
* Use complete display automatically in case of only one layer
*/
#undef XSIZE_0
#undef YSIZE_0
#define XSIZE_0 XSIZE_PHYS
#define YSIZE_0 YSIZE_PHYS
#endif
/*********************************************************************
*
* Configuration checking
*/
#ifndef XSIZE_PHYS
#error Physical X size of display is not defined!
#endif
#ifndef YSIZE_PHYS
#error Physical Y size of display is not defined!
#endif
#ifndef NUM_VSCREENS
#define NUM_VSCREENS 1
#else
#if (NUM_VSCREENS <= 0)
#error At least one screeen needs to be defined!
#endif
#endif
#if (NUM_VSCREENS > 1) && (NUM_BUFFERS > 1)
#error Virtual screens and multiple buffers are not allowed!
#endif
/*********************************************************************
*
* Redirect bulk conversion to DMA2D routines
*/
#define DEFINE_DMA2D_COLORCONVERSION(PFIX, PIXELFORMAT) \
static void _Color2IndexBulk_##PFIX##_DMA2D(LCD_COLOR * pColor, void * pIndex, U32 NumItems, U8 SizeOfIndex) { \
_DMA_Color2IndexBulk(pColor, pIndex, NumItems, SizeOfIndex, PIXELFORMAT); \
} \
static void _Index2ColorBulk_##PFIX##_DMA2D(void * pIndex, LCD_COLOR * pColor, U32 NumItems, U8 SizeOfIndex) { \
_DMA_Index2ColorBulk(pColor, pIndex, NumItems, SizeOfIndex, PIXELFORMAT); \
}
//
// Prototypes of DMA2D color conversion routines
//
static void _DMA_Index2ColorBulk(void * pIndex, LCD_COLOR * pColor, U32 NumItems, U8 SizeOfIndex, U32 PixelFormat);
static void _DMA_Color2IndexBulk(LCD_COLOR * pColor, void * pIndex, U32 NumItems, U8 SizeOfIndex, U32 PixelFormat);
//
// Color conversion routines using DMA2D
//
DEFINE_DMA2D_COLORCONVERSION(M8888I, LTDC_Pixelformat_ARGB8888)
DEFINE_DMA2D_COLORCONVERSION(M888, LTDC_Pixelformat_ARGB8888) // Internal pixel format of emWin is 32 bit, because of that ARGB8888
DEFINE_DMA2D_COLORCONVERSION(M565, LTDC_Pixelformat_RGB565)
DEFINE_DMA2D_COLORCONVERSION(M1555I, LTDC_Pixelformat_ARGB1555)
DEFINE_DMA2D_COLORCONVERSION(M4444I, LTDC_Pixelformat_ARGB4444)
/*********************************************************************
*
* Static data
*
**********************************************************************
*/
static LTDC_Layer_TypeDef * _apLayer[] = { LTDC_Layer1, LTDC_Layer2 };
static const U32 _aAddr[] = { LCD_FRAME_BUFFER, LCD_FRAME_BUFFER + XSIZE_PHYS * YSIZE_PHYS * sizeof(U32) * NUM_VSCREENS * NUM_BUFFERS };
static int _aPendingBuffer[GUI_NUM_LAYERS];
static int _aBufferIndex[GUI_NUM_LAYERS];
static int _axSize[GUI_NUM_LAYERS];
static int _aySize[GUI_NUM_LAYERS];
static int _aBytesPerPixels[GUI_NUM_LAYERS];
/*********************************************************************
*
* Static data
*
**********************************************************************
*/
static const LCD_API_COLOR_CONV * _apColorConvAPI[] = {
COLOR_CONVERSION_0,
#if GUI_NUM_LAYERS > 1
COLOR_CONVERSION_1,
#endif
};
/*********************************************************************
*
* Static code
*
**********************************************************************
*/
/*********************************************************************
*
* _GetPixelformat
*/
static U32 _GetPixelformat(int LayerIndex) {
const LCD_API_COLOR_CONV * pColorConvAPI;
if (LayerIndex >= GUI_COUNTOF(_apColorConvAPI)) {
return 0;
}
pColorConvAPI = _apColorConvAPI[LayerIndex];
if (pColorConvAPI == GUICC_M8888I) {
return LTDC_Pixelformat_ARGB8888;
} else if (pColorConvAPI == GUICC_M888) {
return LTDC_Pixelformat_RGB888;
} else if (pColorConvAPI == GUICC_M565) {
return LTDC_Pixelformat_RGB565;
} else if (pColorConvAPI == GUICC_M1555I) {
return LTDC_Pixelformat_ARGB1555;
} else if (pColorConvAPI == GUICC_M4444I) {
return LTDC_Pixelformat_ARGB4444;
} else if (pColorConvAPI == GUICC_8666) {
return LTDC_Pixelformat_L8;
} else if (pColorConvAPI == GUICC_1616I) {
return LTDC_Pixelformat_AL44;
} else if (pColorConvAPI == GUICC_88666I) {
return LTDC_Pixelformat_AL88;
}
while (1); // Error
}
/*********************************************************************
*
* _GetBytesPerLine
*/
static int _GetBytesPerLine(int LayerIndex, int xSize) {
int BitsPerPixel, BytesPerLine;
BitsPerPixel = LCD_GetBitsPerPixelEx(LayerIndex);
BytesPerLine = (BitsPerPixel * xSize + 7) / 8;
return BytesPerLine;
}
/*********************************************************************
*
* _DMA_LoadLUT
*/
static void _DMA_LoadLUT(LCD_COLOR * pColor, U32 NumItems) {
DMA2D->FGCMAR = (U32)pColor; // Foreground CLUT Memory Address Register
//
// Foreground PFC Control Register
//
DMA2D->FGPFCCR = LTDC_Pixelformat_RGB888 // Pixel format
| ((NumItems - 1) & 0xFF) << 8; // Number of items to load
DMA2D->FGPFCCR |= (1 << 5); // Start loading
//
// Waiting not required here...
//
}
/*********************************************************************
*
* _DMA_AlphaBlendingBulk
*/
static void _DMA_AlphaBlendingBulk(LCD_COLOR * pColorFG, LCD_COLOR * pColorBG, LCD_COLOR * pColorDst, U32 NumItems) {
//
// Set up mode
//
DMA2D->CR = 0x00020000UL | (1 << 9); // Control Register (Memory to memory with blending of FG and BG and TCIE)
//
// Set up pointers
//
DMA2D->FGMAR = (U32)pColorFG; // Foreground Memory Address Register
DMA2D->BGMAR = (U32)pColorBG; // Background Memory Address Register
DMA2D->OMAR = (U32)pColorDst; // Output Memory Address Register (Destination address)
//
// Set up offsets
//
DMA2D->FGOR = 0; // Foreground Offset Register
DMA2D->BGOR = 0; // Background Offset Register
DMA2D->OOR = 0; // Output Offset Register
//
// Set up pixel format
//
DMA2D->FGPFCCR = LTDC_Pixelformat_ARGB8888; // Foreground PFC Control Register (Defines the FG pixel format)
DMA2D->BGPFCCR = LTDC_Pixelformat_ARGB8888; // Background PFC Control Register (Defines the BG pixel format)
DMA2D->OPFCCR = LTDC_Pixelformat_ARGB8888; // Output PFC Control Register (Defines the output pixel format)
//
// Set up size
//
DMA2D->NLR = (U32)(NumItems << 16) | 1; // Number of Line Register (Size configuration of area to be transfered)
//
// Execute operation
//
DMA2D->CR |= 1;
while (DMA2D->CR & DMA2D_CR_START) {
//__WFI(); // Sleep until next interrupt
}
}
/*********************************************************************
*
* _DMA_MixColors
*
* Purpose:
* Function for mixing up 2 colors with the given intensity.
* If the background color is completely transparent the
* foreground color should be used unchanged.
*/
static LCD_COLOR _DMA_MixColors(LCD_COLOR Color, LCD_COLOR BkColor, U8 Intens) {
U32 ColorDst;
if ((BkColor & 0xFF000000) == 0x00000000) {
return Color;
}
//
// Set up mode
//
DMA2D->CR = 0x00020000UL | (1 << 9); // Control Register (Memory to memory with blending of FG and BG and TCIE)
//
// Set up pointers
//
DMA2D->FGMAR = (U32)&Color; // Foreground Memory Address Register
DMA2D->BGMAR = (U32)&BkColor; // Background Memory Address Register
DMA2D->OMAR = (U32)&ColorDst; // Output Memory Address Register (Destination address)
//
// Set up pixel format
//
DMA2D->FGPFCCR = LTDC_Pixelformat_ARGB8888
| (1UL << 16)
| ((U32)Intens << 24);
DMA2D->BGPFCCR = LTDC_Pixelformat_ARGB8888
| (0UL << 16)
| ((U32)(255 - Intens) << 24);
DMA2D->OPFCCR = LTDC_Pixelformat_ARGB8888;
//
// Set up size
//
DMA2D->NLR = (U32)(1 << 16) | 1; // Number of Line Register (Size configuration of area to be transfered)
//
// Execute operation
//
//_DMA_ExecOperation();
DMA2D->CR |= 1; // Control Register (Start operation)
//
// Wait until transfer is done
//
while (DMA2D->CR & DMA2D_CR_START) {
//__WFI(); // Sleep until next interrupt
}
return ColorDst;
}
/*********************************************************************
*
* _DMA_MixColorsBulk
*/
static void _DMA_MixColorsBulk(LCD_COLOR * pColorFG, LCD_COLOR * pColorBG, LCD_COLOR * pColorDst, U8 Intens, U32 NumItems) {
//
// Set up mode
//
DMA2D->CR = 0x00020000UL | (1 << 9); // Control Register (Memory to memory with blending of FG and BG and TCIE)
//
// Set up pointers
//
DMA2D->FGMAR = (U32)pColorFG; // Foreground Memory Address Register
DMA2D->BGMAR = (U32)pColorBG; // Background Memory Address Register
DMA2D->OMAR = (U32)pColorDst; // Output Memory Address Register (Destination address)
//
// Set up pixel format
//
DMA2D->FGPFCCR = LTDC_Pixelformat_ARGB8888
| (1UL << 16)
| ((U32)Intens << 24);
DMA2D->BGPFCCR = LTDC_Pixelformat_ARGB8888
| (0UL << 16)
| ((U32)(255 - Intens) << 24);
DMA2D->OPFCCR = LTDC_Pixelformat_ARGB8888;
//
// Set up size
//
DMA2D->NLR = (U32)(NumItems << 16) | 1; // Number of Line Register (Size configuration of area to be transfered)
//
// Execute operation
//
DMA2D->CR |= 1;
while (DMA2D->CR & DMA2D_CR_START) {
//__WFI(); // Sleep until next interrupt
}
}
/*********************************************************************
*
* _DMA_ConvertColor
*/
static void _DMA_ConvertColor(void * pSrc, void * pDst, U32 PixelFormatSrc, U32 PixelFormatDst, U32 NumItems) {
//
// Set up mode
//
DMA2D->CR = 0x00010000UL | (1 << 9); // Control Register (Memory to memory with pixel format conversion and TCIE)
//
// Set up pointers
//
DMA2D->FGMAR = (U32)pSrc; // Foreground Memory Address Register (Source address)
DMA2D->OMAR = (U32)pDst; // Output Memory Address Register (Destination address)
//
// Set up offsets
//
DMA2D->FGOR = 0; // Foreground Offset Register (Source line offset)
DMA2D->OOR = 0; // Output Offset Register (Destination line offset)
//
// Set up pixel format
//
DMA2D->FGPFCCR = PixelFormatSrc; // Foreground PFC Control Register (Defines the input pixel format)
DMA2D->OPFCCR = PixelFormatDst; // Output PFC Control Register (Defines the output pixel format)
//
// Set up size
//
DMA2D->NLR = (U32)(NumItems << 16) | 1; // Number of Line Register (Size configuration of area to be transfered)
//
// Execute operation
//
DMA2D->CR |= 1;
while (DMA2D->CR & DMA2D_CR_START) {
//__WFI(); // Sleep until next interrupt
}
}
/*********************************************************************
*
* _DMA_Index2ColorBulk
*/
static void _DMA_Index2ColorBulk(void * pIndex, LCD_COLOR * pColor, U32 NumItems, U8 SizeOfIndex, U32 PixelFormat) {
//
// Use DMA2D for the conversion
//
_DMA_ConvertColor(pIndex, pColor, PixelFormat, LTDC_Pixelformat_ARGB8888, NumItems);
}
/*********************************************************************
*
* _DMA_Color2IndexBulk
*/
static void _DMA_Color2IndexBulk(LCD_COLOR * pColor, void * pIndex, U32 NumItems, U8 SizeOfIndex, U32 PixelFormat) {
//
// Use DMA2D for the conversion
//
_DMA_ConvertColor(pColor, pIndex, LTDC_Pixelformat_ARGB8888, PixelFormat, NumItems);
}
/*********************************************************************
*
* _LCD_MixColorsBulk
*/
static void _LCD_MixColorsBulk(U32 * pFG, U32 * pBG, U32 * pDst, unsigned OffFG, unsigned OffBG, unsigned OffDest, unsigned xSize, unsigned ySize, U8 Intens) {
int y;
GUI_USE_PARA(OffFG);
GUI_USE_PARA(OffDest);
for (y = 0; y < ySize; y++) {
_DMA_MixColorsBulk(pFG, pBG, pDst, Intens, xSize);
pFG += xSize + OffFG;
pBG += xSize + OffBG;
pDst += xSize + OffDest;
}
}
/**
* @brief DMA2D Copy RGB 565 buffer
* @param pSrc : Source buffer pointer
* @param pDst : Destination buffer pointer
* @param xSize : Horizontal size
* @param ySize : Vertical size
* @param OffLineSrc: Source Line offset
* @param OffLineDst: Destination Line offset
* @retval None
*/
static void _DMA_CopyRGB565(const void * pSrc, void * pDst, int xSize, int ySize, int OffLineSrc, int OffLineDst)
{
/* Setup DMA2D Configuration */
DMA2D->CR = 0x00000000UL | (1 << 9);
DMA2D->FGMAR = (U32)pSrc;
DMA2D->OMAR = (U32)pDst;
DMA2D->FGOR = OffLineSrc;
DMA2D->OOR = OffLineDst;
DMA2D->FGPFCCR = LTDC_Pixelformat_RGB565;
DMA2D->NLR = (U32)(xSize << 16) | (U16)ySize;
/* Start the transfer, and enable the transfer complete IT */
DMA2D->CR |= (1|DMA2D_IT_TC);
/* Wait for the end of the transfer */
while (DMA2D->CR & DMA2D_CR_START) {}
}
/**
* @brief Draw alpha bitmap
* @param pDst : Destination buffer
* @param pSrc : Source buffer
* @param xSize : Picture horizontal size
* @param ySize : Picture vertical size
* @param OffLineSrc : Source line offset
* @param OffLineDst : Destination line offset
* @param PixelFormat: Pixel format
* @retval None
*/
static void _DMA_DrawAlphaBitmap(void * pDst, const void * pSrc, int xSize, int ySize, int OffLineSrc, int OffLineDst, int PixelFormat)
{
/* Setup DMA2D Configuration */
DMA2D->CR = 0x00020000UL | (1 << 9);
DMA2D->FGMAR = (U32)pSrc;
DMA2D->BGMAR = (U32)pDst;
DMA2D->OMAR = (U32)pDst;
DMA2D->FGOR = OffLineSrc;
DMA2D->BGOR = OffLineDst;
DMA2D->OOR = OffLineDst;
DMA2D->FGPFCCR = LTDC_Pixelformat_ARGB8888;
DMA2D->BGPFCCR = PixelFormat;
DMA2D->OPFCCR = PixelFormat;
DMA2D->NLR = (U32)(xSize << 16) | (U16)ySize;
/* Start the transfer, and enable the transfer complete IT */
DMA2D->CR |= (1|DMA2D_IT_TC);
/* Wait for the end of the transfer */
while (DMA2D->CR & DMA2D_CR_START) {}
}
/*********************************************************************
*
* _LCD_GetpPalConvTable
*
* Purpose:
* The emWin function LCD_GetpPalConvTable() normally translates the given colors into
* index values for the display controller. In case of index based bitmaps without
* transparent pixels we load the palette only to the DMA2D LUT registers to be
* translated (converted) during the process of drawing via DMA2D.
*/
static LCD_PIXELINDEX * _LCD_GetpPalConvTable(const LCD_LOGPALETTE GUI_UNI_PTR * pLogPal, const GUI_BITMAP GUI_UNI_PTR * pBitmap, int LayerIndex) {
void (* pFunc)(void);
int DoDefault = 0;
//
// Check if we have a non transparent device independent bitmap
//
if (pBitmap->BitsPerPixel == 8) {
pFunc = LCD_GetDevFunc(LayerIndex, LCD_DEVFUNC_DRAWBMP_8BPP);
if (pFunc) {
if (pBitmap->pPal) {
if (pBitmap->pPal->HasTrans) {
DoDefault = 1;
}
} else {
DoDefault = 1;
}
} else {
DoDefault = 1;
}
} else {
DoDefault = 1;
}
//
// Default palette management for other cases
//
if (DoDefault) {
//
// Return a pointer to the index values to be used by the controller
//
return LCD_GetpPalConvTable(pLogPal);
}
//
// Load LUT using DMA2D
//
_DMA_LoadLUT((LCD_COLOR *)pLogPal->pPalEntries, pLogPal->NumEntries);
//
// Return something not NULL
//
return (LCD_PIXELINDEX * )pLogPal->pPalEntries;
}
/*********************************************************************
*
* _LTDC_LayerEnableColorKeying
*/
static void _LTDC_LayerEnableColorKeying(LTDC_Layer_TypeDef * LTDC_Layerx, int NewState) {
if (NewState != DISABLE) {
LTDC_Layerx->CR |= (U32)LTDC_LxCR_COLKEN;
} else {
LTDC_Layerx->CR &= ~(U32)LTDC_LxCR_COLKEN;
}
LTDC->SRCR = LTDC_SRCR_VBR; // Reload on next blanking period
}
/*********************************************************************
*
* _LTDC_LayerEnableLUT
*/
static void _LTDC_LayerEnableLUT(LTDC_Layer_TypeDef * LTDC_Layerx, int NewState) {
if (NewState != DISABLE) {
LTDC_Layerx->CR |= (U32)LTDC_LxCR_CLUTEN;
} else {
LTDC_Layerx->CR &= ~(U32)LTDC_LxCR_CLUTEN;
}
LTDC->SRCR = LTDC_SRCR_VBR; // Reload on next blanking period
}
/*********************************************************************
*
* _LTDC_SetLayerPos
*/
static void _LTDC_SetLayerPos(int LayerIndex, int xPos, int yPos) {
int xSize, ySize;
U32 HorizontalStart, HorizontalStop, VerticalStart, VerticalStop;
xSize = LCD_GetXSizeEx(LayerIndex);
ySize = LCD_GetYSizeEx(LayerIndex);
HorizontalStart = xPos + HBP + 1;
HorizontalStop = xPos + HBP + xSize;
VerticalStart = yPos + VBP + 1;
VerticalStop = yPos + VBP + ySize;
//
// Horizontal start and stop position
//
_apLayer[LayerIndex]->WHPCR &= ~(LTDC_LxWHPCR_WHSTPOS | LTDC_LxWHPCR_WHSPPOS);
_apLayer[LayerIndex]->WHPCR = (HorizontalStart | (HorizontalStop << 16));
//
// Vertical start and stop position
//
_apLayer[LayerIndex]->WVPCR &= ~(LTDC_LxWVPCR_WVSTPOS | LTDC_LxWVPCR_WVSPPOS);
_apLayer[LayerIndex]->WVPCR = (VerticalStart | (VerticalStop << 16));
//
// Reload configuration
//
LTDC_ReloadConfig(LTDC_SRCR_VBR); // Reload on next blanking period
}
/*********************************************************************
*
* _LTDC_SetLayerAlpha
*/
static void _LTDC_SetLayerAlpha(int LayerIndex, int Alpha) {
//
// Set constant alpha value
//
_apLayer[LayerIndex]->CACR &= ~(LTDC_LxCACR_CONSTA);
_apLayer[LayerIndex]->CACR = Alpha;
//
// Reload configuration
//
LTDC_ReloadConfig(LTDC_SRCR_IMR/*LTDC_SRCR_VBR*/); // Reload on next blanking period/**/
}
/*********************************************************************
*
* _LTDC_SetLUTEntry
*/
static void _LTDC_SetLUTEntry(int LayerIndex, U32 Color, int Pos) {
U32 r, g, b, a;
r = Color & (0xff << 16);
g = Color & (0xff << 8);
b = Color & 0xff;
a = Pos << 24;
_apLayer[LayerIndex]->CLUTWR &= ~(LTDC_LxCLUTWR_BLUE | LTDC_LxCLUTWR_GREEN | LTDC_LxCLUTWR_RED | LTDC_LxCLUTWR_CLUTADD);
_apLayer[LayerIndex]->CLUTWR = r | g | b | a;
//
// Reload configuration
//
LTDC_ReloadConfig(LTDC_SRCR_IMR);
}
/*********************************************************************
*
* _DMA_Copy
*/
static void _DMA_Copy(int LayerIndex, void * pSrc, void * pDst, int xSize, int ySize, int OffLineSrc, int OffLineDst) {
U32 PixelFormat;
PixelFormat = _GetPixelformat(LayerIndex);
DMA2D->CR = 0x00000000UL | (1 << 9); // Control Register (Memory to memory and TCIE)
DMA2D->FGMAR = (U32)pSrc; // Foreground Memory Address Register (Source address)
DMA2D->OMAR = (U32)pDst; // Output Memory Address Register (Destination address)
DMA2D->FGOR = OffLineSrc; // Foreground Offset Register (Source line offset)
DMA2D->OOR = OffLineDst; // Output Offset Register (Destination line offset)
DMA2D->FGPFCCR = PixelFormat; // Foreground PFC Control Register (Defines the input pixel format)
DMA2D->NLR = (U32)(xSize << 16) | (U16)ySize; // Number of Line Register (Size configuration of area to be transfered)
DMA2D->CR |= 1; // Start operation
//
// Wait until transfer is done
//
while (DMA2D->CR & DMA2D_CR_START) {
//__WFI(); // Sleep until next interrupt
}
}
/*********************************************************************
*
* _DMA_Fill
*/
static void _DMA_Fill(int LayerIndex, void * pDst, int xSize, int ySize, int OffLine, U32 ColorIndex) {
U32 PixelFormat;
PixelFormat = _GetPixelformat(LayerIndex);
DMA2D->CR = 0x00030000UL | (1 << 9); // Register to memory and TCIE
DMA2D->OCOLR = ColorIndex; // Color to be used
DMA2D->OMAR = (U32)pDst; // Destination address
DMA2D->OOR = OffLine; // Destination line offset
DMA2D->OPFCCR = PixelFormat; // Defines the number of pixels to be transfered
DMA2D->NLR = (U32)(xSize << 16) | (U16)ySize; // Size configuration of area to be transfered
DMA2D->CR |= 1; // Start operation
//
// Wait until transfer is done
//
while (DMA2D->CR & DMA2D_CR_START) {
//__WFI(); // Sleep until next interrupt
}
}
/*********************************************************************
*
* _DMA_DrawBitmapL8
*/
static void _DMA_DrawBitmapL8(void * pSrc, void * pDst, U32 OffSrc, U32 OffDst, U32 PixelFormatDst, U32 xSize, U32 ySize) {
//
// Set up mode
//
DMA2D->CR = 0x00010000UL | (1 << 9); // Control Register (Memory to memory with pixel format conversion and TCIE)
//
// Set up pointers
//
DMA2D->FGMAR = (U32)pSrc; // Foreground Memory Address Register (Source address)
DMA2D->OMAR = (U32)pDst; // Output Memory Address Register (Destination address)
//
// Set up offsets
//
DMA2D->FGOR = OffSrc; // Foreground Offset Register (Source line offset)
DMA2D->OOR = OffDst; // Output Offset Register (Destination line offset)
//
// Set up pixel format
//
DMA2D->FGPFCCR = LTDC_Pixelformat_L8; // Foreground PFC Control Register (Defines the input pixel format)
DMA2D->OPFCCR = PixelFormatDst; // Output PFC Control Register (Defines the output pixel format)
//
// Set up size
//
DMA2D->NLR = (U32)(xSize << 16) | ySize; // Number of Line Register (Size configuration of area to be transfered)
//
// Execute operation
//
DMA2D->CR |= 1; // Start operation
//
// Wait until transfer is done
//
while (DMA2D->CR & DMA2D_CR_START) {
//__WFI(); // Sleep until next interrupt
}
}
/*********************************************************************
*
* _LCD_DisplayOn
*/
static void _LCD_DisplayOn(void) {
LTDC_Cmd(ENABLE); /* display ON */
}
/*********************************************************************
*
* _LCD_DisplayOff
*/
static void _LCD_DisplayOff(void) {
LTDC_Cmd(DISABLE); /* display OFF */
}
/*********************************************************************
*
* _GetBufferSize
*/
static U32 _GetBufferSize(int LayerIndex) {
U32 BufferSize;
BufferSize = _axSize[LayerIndex] * _aySize[LayerIndex] * _aBytesPerPixels[LayerIndex];
return BufferSize;
}
/*********************************************************************
*
* _LCD_CopyBuffer
*/
static void _LCD_CopyBuffer(int LayerIndex, int IndexSrc, int IndexDst) {
U32 BufferSize, AddrSrc, AddrDst;
BufferSize = _GetBufferSize(LayerIndex);
AddrSrc = _aAddr[LayerIndex] + BufferSize * IndexSrc;
AddrDst = _aAddr[LayerIndex] + BufferSize * IndexDst;
_DMA_Copy(LayerIndex, (void *)AddrSrc, (void *)AddrDst, _axSize[LayerIndex], _aySize[LayerIndex], 0, 0);
_aBufferIndex[LayerIndex] = IndexDst; // After this function has been called all drawing operations are routed to Buffer[IndexDst]!
}
/*********************************************************************
*
* _LCD_CopyRect
*/
static void _LCD_CopyRect(int LayerIndex, int x0, int y0, int x1, int y1, int xSize, int ySize) {
U32 BufferSize, AddrSrc, AddrDst;
BufferSize = _GetBufferSize(LayerIndex);
AddrSrc = _aAddr[LayerIndex] + BufferSize * _aBufferIndex[LayerIndex] + (y0 * _axSize[LayerIndex] + x0) * _aBytesPerPixels[LayerIndex];
AddrDst = _aAddr[LayerIndex] + BufferSize * _aBufferIndex[LayerIndex] + (y1 * _axSize[LayerIndex] + x1) * _aBytesPerPixels[LayerIndex];
_DMA_Copy(LayerIndex, (void *)AddrSrc, (void *)AddrDst, xSize, ySize, _axSize[LayerIndex] - xSize, _axSize[LayerIndex] - xSize);
}
/*********************************************************************
*
* _LCD_FillRect
*/
static void _LCD_FillRect(int LayerIndex, int x0, int y0, int x1, int y1, U32 PixelIndex) {
U32 BufferSize, AddrDst;
int xSize, ySize;
if (GUI_GetDrawMode() == GUI_DM_XOR) {
LCD_SetDevFunc(LayerIndex, LCD_DEVFUNC_FILLRECT, NULL);
LCD_FillRect(x0, y0, x1, y1);
LCD_SetDevFunc(LayerIndex, LCD_DEVFUNC_FILLRECT, (void(*)(void))_LCD_FillRect);
} else {
xSize = x1 - x0 + 1;
ySize = y1 - y0 + 1;
BufferSize = _GetBufferSize(LayerIndex);
AddrDst = _aAddr[LayerIndex] + BufferSize * _aBufferIndex[LayerIndex] + (y0 * _axSize[LayerIndex] + x0) * _aBytesPerPixels[LayerIndex];
_DMA_Fill(LayerIndex, (void *)AddrDst, xSize, ySize, _axSize[LayerIndex] - xSize, PixelIndex);
}
}
/*********************************************************************
*
* _LCD_DrawBitmap8bpp
*/
static void _LCD_DrawBitmap8bpp(int LayerIndex, int x, int y, U8 const * p, int xSize, int ySize, int BytesPerLine) {
U32 BufferSize, AddrDst;
int OffLineSrc, OffLineDst;
U32 PixelFormat;
BufferSize = _GetBufferSize(LayerIndex);
AddrDst = _aAddr[LayerIndex] + BufferSize * _aBufferIndex[LayerIndex] + (y * _axSize[LayerIndex] + x) * _aBytesPerPixels[LayerIndex];
OffLineSrc = BytesPerLine - xSize;
OffLineDst = _axSize[LayerIndex] - xSize;
PixelFormat = _GetPixelformat(LayerIndex);
_DMA_DrawBitmapL8((void *)p, (void *)AddrDst, OffLineSrc, OffLineDst, PixelFormat, xSize, ySize);
}
/*********************************************************************
*
* _LCD_DrawBitmap16bpp
*/
static void _LCD_DrawBitmap16bpp(int LayerIndex, int x, int y, U16 const * p, int xSize, int ySize, int BytesPerLine) {
U32 BufferSize, AddrDst;
int OffLineSrc, OffLineDst;
BufferSize = _GetBufferSize(LayerIndex);
AddrDst = _aAddr[LayerIndex] + BufferSize * _aBufferIndex[LayerIndex] + (y * _axSize[LayerIndex] + x) * _aBytesPerPixels[LayerIndex];
OffLineSrc = (BytesPerLine / 2) - xSize;
OffLineDst = _axSize[LayerIndex] - xSize;
_DMA_Copy(LayerIndex, (void *)p, (void *)AddrDst, xSize, ySize, OffLineSrc, OffLineDst);
}
/*********************************************************************
*
* _LCD_DrawBitmap32bpp
*/
static void _LCD_DrawBitmap32bpp(int LayerIndex, int x, int y, U8 const * p, int xSize, int ySize, int BytesPerLine)
{
U32 BufferSize, AddrDst;
int OffLineSrc, OffLineDst;
BufferSize = _GetBufferSize(LayerIndex);
AddrDst = _aAddr[LayerIndex] + BufferSize * _aBufferIndex[LayerIndex] + (y * _axSize[LayerIndex] + x) * _aBytesPerPixels[LayerIndex];
OffLineSrc = (BytesPerLine / 4) - xSize;
OffLineDst = _axSize[LayerIndex] - xSize;
_DMA_Copy(LayerIndex, (void *)p, (void *)AddrDst, xSize, ySize, OffLineSrc, OffLineDst);
}
/**
* @brief Draw 16 bits per pixel memory device
* @param pDst : Destination buffer
* @param pSrc : Source buffer
* @param xSize : Horizontal memory device size
* @param ySize : Vertical memory device size
* @param BytesPerLineDst: Destination number of bytes per Line
* @param BytesPerLineSrc: Source number of bytes per Line
* @retval None
*/
static void _LCD_DrawMemdev16bpp(void * pDst, const void * pSrc, int xSize, int ySize, int BytesPerLineDst, int BytesPerLineSrc)
{
int OffLineSrc, OffLineDst;
OffLineSrc = (BytesPerLineSrc / 2) - xSize;
OffLineDst = (BytesPerLineDst / 2) - xSize;
_DMA_CopyRGB565(pSrc, pDst, xSize, ySize, OffLineSrc, OffLineDst);
}
/**
* @brief Draw alpha memory device
* @param pDst : Destination buffer
* @param pSrc : Source buffer
* @param xSize : Horizontal memory device size
* @param ySize : Vertical memory device size
* @param BytesPerLineDst: Destination number of bytes per Line
* @param BytesPerLineSrc: Source number of bytes per Line
* @retval None
*/
static void _LCD_DrawMemdevAlpha(void * pDst, const void * pSrc, int xSize, int ySize, int BytesPerLineDst, int BytesPerLineSrc)
{
int OffLineSrc, OffLineDst;
OffLineSrc = (BytesPerLineSrc / 4) - xSize;
OffLineDst = (BytesPerLineDst / 4) - xSize;
_DMA_DrawAlphaBitmap(pDst, pSrc, xSize, ySize, OffLineSrc, OffLineDst, LTDC_Pixelformat_ARGB8888);
}
/**
* @brief Draw alpha Bitmap
* @param LayerIndex : Layer index
* @param x : Horizontal position on the screen
* @param y : vertical position on the screen
* @param xSize : Horizontal bitmap size
* @param ySize : Vertical bitmap size
* @param BytesPerLine: Bytes per Line
* @retval None
*/
static void _LCD_DrawBitmapAlpha(int LayerIndex, int x, int y, const void * p, int xSize, int ySize, int BytesPerLine)
{
U32 BufferSize, AddrDst;
int OffLineSrc, OffLineDst;
U32 PixelFormat;
PixelFormat = _GetPixelformat(LayerIndex);
BufferSize = _GetBufferSize(LayerIndex);
AddrDst = _aAddr[LayerIndex] + BufferSize * _aBufferIndex[LayerIndex] + (y * _axSize[LayerIndex] + x) * _aBytesPerPixels[LayerIndex];
OffLineSrc = (BytesPerLine / 4) - xSize;
OffLineDst = _axSize[LayerIndex] - xSize;
_DMA_DrawAlphaBitmap((void *)AddrDst, p, xSize, ySize, OffLineSrc, OffLineDst, PixelFormat);
}
/*********************************************************************
*
* Public code
*
**********************************************************************
*/
/*********************************************************************
*
* DMA2D_ISR_Handler
*
* Purpose:
* Transfer-complete-interrupt of DMA2D
*/
void DMA2D_ISR_Handler(void) {
DMA2D->IFCR = (U32)DMA2D_IFSR_CTCIF;
}
/*********************************************************************
*
* LTDC_ISR_Handler
*
* Purpose:
* End-Of-Frame-Interrupt for managing multiple buffering
*/
void LTDC_ISR_Handler(void) {
U32 Addr;
int i;
LTDC->ICR = (U32)LTDC_IER_LIE;
for (i = 0; i < GUI_NUM_LAYERS; i++) {
if (_aPendingBuffer[i] >= 0) {
//
// Calculate address of buffer to be used as visible frame buffer
//
Addr = _aAddr[i] + _axSize[i] * _aySize[i] * _aPendingBuffer[i] * _aBytesPerPixels[i];
//
// Store address into SFR
//
_apLayer[i]->CFBAR &= ~(LTDC_LxCFBAR_CFBADD);
_apLayer[i]->CFBAR = Addr;
//
// Reload configuration
//
LTDC_ReloadConfig(LTDC_SRCR_IMR);
//
// Tell emWin that buffer is used
//
GUI_MULTIBUF_ConfirmEx(i, _aPendingBuffer[i]);
//
// Clear pending buffer flag of layer
//
_aPendingBuffer[i] = -1;
}
}
}
/*********************************************************************
*
* _LCD_InitController
*/
static void _LCD_InitController(int LayerIndex) {
LTDC_Layer_InitTypeDef LTDC_Layer_InitStruct = {0};
static int xSize, ySize, BytesPerLine, BitsPerPixel, i;
static U32 Pixelformat, Color;
static int Done;
if (LayerIndex >= GUI_COUNTOF(_apLayer)) {
return;
}
if (Done == 0) {
Done = 1;
// LCD_Init();
//
// Enable line interrupt
//
LTDC_ITConfig(LTDC_IER_LIE, ENABLE);
NVIC_SetPriority(LTDC_IRQn, 0);
NVIC_EnableIRQ(LTDC_IRQn);
//
// Enable DMA2D transfer complete interrupt
//
DMA2D_ITConfig(DMA2D_CR_TCIE, ENABLE);
NVIC_SetPriority(DMA2D_IRQn, 0);
NVIC_EnableIRQ(DMA2D_IRQn);
//
// Clear transfer complete interrupt flag
//
DMA2D->IFCR = (U32)DMA2D_IFSR_CTCIF;
}
//
// Layer configuration
//
xSize = LCD_GetXSizeEx(LayerIndex);
ySize = LCD_GetYSizeEx(LayerIndex);
/* 层窗口配置 */
/* 配置本层的窗口边界，注意这些参数是包含HBP HSW VBP VSW的 */
//一行的第一个起始像素，该成员值应用为 (LTDC_InitStruct.LTDC_AccumulatedHBP+1)的值
LTDC_Layer_InitStruct.LTDC_HorizontalStart = HBP + HSW;
//一行的最后一个像素，该成员值应用为 (LTDC_InitStruct.LTDC_AccumulatedActiveW)的值
LTDC_Layer_InitStruct.LTDC_HorizontalStop = HSW+HBP+LCD_PIXEL_WIDTH-1;
//一列的第一个起始像素，该成员值应用为 (LTDC_InitStruct.LTDC_AccumulatedVBP+1)的值
LTDC_Layer_InitStruct.LTDC_VerticalStart = VBP + VSW;
//一列的最后一个像素，该成员值应用为 (LTDC_InitStruct.LTDC_AccumulatedActiveH)的值
LTDC_Layer_InitStruct.LTDC_VerticalStop = VSW+VBP+LCD_PIXEL_HEIGHT-1;
//
// Pixel Format configuration
//
Pixelformat = _GetPixelformat(LayerIndex);
LTDC_Layer_InitStruct.LTDC_PixelFormat = Pixelformat;
//
// Alpha constant (255 totally opaque)
//
LTDC_Layer_InitStruct.LTDC_ConstantAlpha = 255;
//
// Default Color configuration (configure A, R, G, B component values)
//
LTDC_Layer_InitStruct.LTDC_DefaultColorBlue = 0;
LTDC_Layer_InitStruct.LTDC_DefaultColorGreen = 0;
LTDC_Layer_InitStruct.LTDC_DefaultColorRed = 0;
LTDC_Layer_InitStruct.LTDC_DefaultColorAlpha = 0;
//
// Configure blending factors
//
BytesPerLine = _GetBytesPerLine(LayerIndex, xSize);
LTDC_Layer_InitStruct.LTDC_BlendingFactor_1 = LTDC_BlendingFactor1_PAxCA;;
LTDC_Layer_InitStruct.LTDC_BlendingFactor_2 = LTDC_BlendingFactor2_PAxCA;
LTDC_Layer_InitStruct.LTDC_CFBLineLength = BytesPerLine + 3;
LTDC_Layer_InitStruct.LTDC_CFBPitch = BytesPerLine;
LTDC_Layer_InitStruct.LTDC_CFBLineNumber = ySize;
//
// Input Address configuration
//
LTDC_Layer_InitStruct.LTDC_CFBStartAdress = _aAddr[LayerIndex];
LTDC_LayerInit(_apLayer[LayerIndex], <DC_Layer_InitStruct);
//
// Enable LUT on demand
//
BitsPerPixel = LCD_GetBitsPerPixelEx(LayerIndex);
if (BitsPerPixel <= 8) {
//
// Enable usage of LUT for all modes with <= 8bpp
//
_LTDC_LayerEnableLUT(_apLayer[LayerIndex], ENABLE);
} else {
//
// Optional CLUT initialization for AL88 mode (16bpp)
//
if (_apColorConvAPI[LayerIndex] == GUICC_88666I) {
_LTDC_LayerEnableLUT(_apLayer[LayerIndex], ENABLE);
for (i = 0; i < 256; i++) {
Color = LCD_API_ColorConv_8666.pfIndex2Color(i);
_LTDC_SetLUTEntry(LayerIndex, Color, i);
}
}
}
//
// Enable layer
//
LTDC_LayerCmd(_apLayer[LayerIndex], ENABLE);
//
// Reload configuration
//
LTDC_ReloadConfig(LTDC_SRCR_IMR);
}
/*********************************************************************
*
* LCD_X_DisplayDriver
*
* Purpose:
* This function is called by the display driver for several purposes.
* To support the according task the routine needs to be adapted to
* the display controller. Please note that the commands marked with
* 'optional' are not cogently required and should only be adapted if
* the display controller supports these features.
*
* Parameter:
* LayerIndex - Index of layer to be configured
* Cmd - Please refer to the details in the switch statement below
* pData - Pointer to a LCD_X_DATA structure
*
* Return Value:
* < -1 - Error
* -1 - Command not handled
* 0 - Ok
*/
int LCD_X_DisplayDriver(unsigned LayerIndex, unsigned Cmd, void * pData) {
int r = 0;
switch (Cmd) {
case LCD_X_INITCONTROLLER: {
//
// Called during the initialization process in order to set up the display controller and put it into operation.
//
_LCD_InitController(LayerIndex);
break;
}
case LCD_X_SETORG: {
//
// Required for setting the display origin which is passed in the 'xPos' and 'yPos' element of p
//
LCD_X_SETORG_INFO * p;
p = (LCD_X_SETORG_INFO *)pData;
_apLayer[LayerIndex]->CFBAR = _aAddr[LayerIndex] + p->yPos * _axSize[LayerIndex] * _aBytesPerPixels[LayerIndex];
LTDC_ReloadConfig(LTDC_SRCR_VBR); // Reload on next blanking period
break;
}
case LCD_X_SHOWBUFFER: {
//
// Required if multiple buffers are used. The 'Index' element of p contains the buffer index.
//
LCD_X_SHOWBUFFER_INFO * p;
p = (LCD_X_SHOWBUFFER_INFO *)pData;
_aPendingBuffer[LayerIndex] = p->Index;
break;
}
case LCD_X_SETLUTENTRY: {
//
// Required for setting a lookup table entry which is passed in the 'Pos' and 'Color' element of p
//
LCD_X_SETLUTENTRY_INFO * p;
p = (LCD_X_SETLUTENTRY_INFO *)pData;
_LTDC_SetLUTEntry(LayerIndex, p->Color, p->Pos);
break;
}
case LCD_X_ON: {
//
// Required if the display controller should support switching on and off
//
_LCD_DisplayOn();
break;
}
case LCD_X_OFF: {
//
// Required if the display controller should support switching on and off
//
_LCD_DisplayOff();
break;
}
case LCD_X_SETVIS: {
//
// Required for setting the layer visibility which is passed in the 'OnOff' element of pData
//
LCD_X_SETVIS_INFO * p;
p = (LCD_X_SETVIS_INFO *)pData;
LTDC_LayerCmd(_apLayer[LayerIndex], p->OnOff ? ENABLE : DISABLE);
break;
}
case LCD_X_SETPOS: {
//
// Required for setting the layer position which is passed in the 'xPos' and 'yPos' element of pData
//
LCD_X_SETPOS_INFO * p;
p = (LCD_X_SETPOS_INFO *)pData;
_LTDC_SetLayerPos(LayerIndex, p->xPos, p->yPos);
break;
}
case LCD_X_SETSIZE: {
//
// Required for setting the layer position which is passed in the 'xPos' and 'yPos' element of pData
//
LCD_X_SETSIZE_INFO * p;
int xPos, yPos;
GUI_GetLayerPosEx(LayerIndex, &xPos, &yPos);
p = (LCD_X_SETSIZE_INFO *)pData;
_axSize[LayerIndex] = p->xSize;
_aySize[LayerIndex] = p->ySize;
_LTDC_SetLayerPos(LayerIndex, xPos, yPos);
break;
}
case LCD_X_SETALPHA: {
//
// Required for setting the alpha value which is passed in the 'Alpha' element of pData
//
LCD_X_SETALPHA_INFO * p;
p = (LCD_X_SETALPHA_INFO *)pData;
_LTDC_SetLayerAlpha(LayerIndex, p->Alpha);
break;
}
case LCD_X_SETCHROMAMODE: {
//
// Required for setting the chroma mode which is passed in the 'ChromaMode' element of pData
//
LCD_X_SETCHROMAMODE_INFO * p;
p = (LCD_X_SETCHROMAMODE_INFO *)pData;
_LTDC_LayerEnableColorKeying(_apLayer[LayerIndex], (p->ChromaMode != 0) ? ENABLE : DISABLE);
break;
}
case LCD_X_SETCHROMA: {
//
// Required for setting the chroma value which is passed in the 'ChromaMin' and 'ChromaMax' element of pData
//
LCD_X_SETCHROMA_INFO * p;
U32 Color;
p = (LCD_X_SETCHROMA_INFO *)pData;
Color = ((p->ChromaMin & 0xFF0000) >> 16) | (p->ChromaMin & 0x00FF00) | ((p->ChromaMin & 0x0000FF) << 16);
_apLayer[LayerIndex]->CKCR = Color;
LTDC_ReloadConfig(LTDC_SRCR_VBR); // Reload on next blanking period
break;
}
default:
r = -1;
}
return r;
}
/*********************************************************************
*
* LCD_X_Config
*
* Purpose:
* Called during the initialization process in order to set up the
* display driver configuration.
*
*/
void LCD_X_Config(void) {
int i;
//
// At first initialize use of multiple buffers on demand
//
#if (NUM_BUFFERS > 1)
for (i = 0; i < GUI_NUM_LAYERS; i++) {
GUI_MULTIBUF_ConfigEx(i, NUM_BUFFERS);
}
#endif
//
// Set display driver and color conversion for 1st layer
//
GUI_DEVICE_CreateAndLink(DISPLAY_DRIVER_0, COLOR_CONVERSION_0, 0, 0);
//
// Set size of 1st layer
//
LCD_SetSizeEx (0, XSIZE_0, YSIZE_0);
LCD_SetVSizeEx(0, XSIZE_0, YSIZE_0 * NUM_VSCREENS);
#if (GUI_NUM_LAYERS > 1)
//
// Set display driver and color conversion for 2nd layer
//
GUI_DEVICE_CreateAndLink(DISPLAY_DRIVER_1, COLOR_CONVERSION_1, 0, 1);
//
// Set size of 2nd layer
//
LCD_SetSizeEx (1, XSIZE_1, YSIZE_1);
LCD_SetVSizeEx(1, XSIZE_1, YSIZE_1 * NUM_VSCREENS);
#endif
//
// Setting up VRam address and custom functions for CopyBuffer-, CopyRect- and FillRect operations
//
for (i = 0; i < GUI_NUM_LAYERS; i++) {
_aPendingBuffer[i] = -1;
//
// Set VRAM address
//
LCD_SetVRAMAddrEx(i, (void *)(_aAddr[i]));
//
// Remember color depth for further operations
//
_aBytesPerPixels[i] = LCD_GetBitsPerPixelEx(i) >> 3;
//
// Set custom functions for several operations
//
LCD_SetDevFunc(i, LCD_DEVFUNC_COPYBUFFER, (void(*)(void))_LCD_CopyBuffer);
LCD_SetDevFunc(i, LCD_DEVFUNC_COPYRECT, (void(*)(void))_LCD_CopyRect);
//
// Filling via DMA2D does only work with 16bpp or more
//
if (_GetPixelformat(i) <= LTDC_Pixelformat_ARGB4444) {
LCD_SetDevFunc(i, LCD_DEVFUNC_FILLRECT, (void(*)(void))_LCD_FillRect);
LCD_SetDevFunc(i, LCD_DEVFUNC_DRAWBMP_8BPP, (void(*)(void))_LCD_DrawBitmap8bpp);
}
//
// Set up drawing routine for 16bpp bitmap using DMA2D
//
if (_GetPixelformat(i) == LTDC_Pixelformat_RGB565) {
LCD_SetDevFunc(i, LCD_DEVFUNC_DRAWBMP_16BPP, (void(*)(void))_LCD_DrawBitmap16bpp);// Set up drawing routine for 16bpp bitmap using DMA2D. Makes only sense with RGB565
}
//
// Set up drawing routine for 32bpp bitmap using DMA2D
//
if (_GetPixelformat(i) == LTDC_Pixelformat_ARGB8888)
{
LCD_SetDevFunc(i, LCD_DEVFUNC_DRAWBMP_32BPP, (void(*)(void))_LCD_DrawBitmap32bpp);
}
GUICC_M1555I_SetCustColorConv(_Color2IndexBulk_M1555I_DMA2D, _Index2ColorBulk_M1555I_DMA2D); // Set up custom bulk color conversion using DMA2D for ARGB1555
GUICC_M565_SetCustColorConv (_Color2IndexBulk_M565_DMA2D, _Index2ColorBulk_M565_DMA2D); // Set up custom bulk color conversion using DMA2D for RGB565
GUICC_M4444I_SetCustColorConv(_Color2IndexBulk_M4444I_DMA2D, _Index2ColorBulk_M4444I_DMA2D); // Set up custom bulk color conversion using DMA2D for ARGB4444
GUICC_M888_SetCustColorConv (_Color2IndexBulk_M888_DMA2D, _Index2ColorBulk_M888_DMA2D); // Set up custom bulk color conversion using DMA2D for RGB888
GUICC_M8888I_SetCustColorConv(_Color2IndexBulk_M8888I_DMA2D, _Index2ColorBulk_M8888I_DMA2D); // Set up custom bulk color conversion using DMA2D for RGB888
//
// Set up custom alpha blending function using DMA2D
//
GUI_SetFuncAlphaBlending(_DMA_AlphaBlendingBulk);// Set up custom alpha blending function using DMA2D
//
// Set up custom function for translating a bitmap palette into index values.
// Required to load a bitmap palette into DMA2D CLUT in case of a 8bpp indexed bitmap
//
GUI_SetFuncGetpPalConvTable(_LCD_GetpPalConvTable);
//
// Set up a custom function for mixing up single colors using DMA2D
//
GUI_SetFuncMixColors(_DMA_MixColors);
//
// Set up a custom function for mixing up arrays of colors using DMA2D
//
GUI_SetFuncMixColorsBulk(_LCD_MixColorsBulk);
/* Set up custom function for drawing 16bpp memory devices */
GUI_MEMDEV_SetDrawMemdev16bppFunc(_LCD_DrawMemdev16bpp);
/* Set up custom function for Alpha drawing operations */
GUI_SetFuncDrawAlpha(_LCD_DrawMemdevAlpha, _LCD_DrawBitmapAlpha);
}
}
/*************************** End of file ****************************/
- LCDConfig.c 文 件 包 含 了 LCD_X_Config 和 LCD_X_DisplayDriver 两 个 函 数 。
- LCD_X_Config 函数调用 emWin 库函数 GUI_DEVICE_CreateAndLink 配置了显示驱动及颜色转换格式，该函数的输入参数是根据 Windows 系统的环境配置的。接着调用LCD_SetSizeEx 配置了显示尺寸，输入参数是本文件中的两个宏： #define XSIZE_PHYS800 及 #define YSIZE_PHYS 480， 也就是说把屏幕配置成了 800*480 分辨率大小， 我们可以通过修改这两个宏的数值改变仿真时的屏幕尺寸。
- LCD_X_DisplayDriver 是提供给 emWin 库的驱动回调函数，该函数根据输入的参数Cmd 区分要进行的操作，如 LCD_X_INITCONTROLLER 表示初始化液晶控制器，LCD_X_ON 表示启动液晶屏， LCD_X_OFF 表示关闭液晶屏，这些命令是由用户根据需要选择性实现的。
- 在使用 emWin 的应用函数之前，我们需要调用其库函数 GUI_Init 初始化 emWin 运行的环境，而 GUI_Init 函数会执行我们前面提到的 GUI_X_Config、 LCD_X_Config、LCD_X_DisplayDriver 三个函数，从而完成初始化工作。当我们移植 emWin 时，主要的移植工作就是根据自己的平台实现这些函数，而 emWin 的上层应用函数无需修改，也无法修改，因为那些函数都已经编译进库里了，不开放源码。
c.GUI 文件夹
GUI 文件夹是 emWin 库核心文件包。它包含一个 Include 文件夹和一个 Library 文件夹，在 Include 文件夹里的都是 emWin 库的头文件，由于 emWin 以库的形式提供给用户，所以必须带有这些头文件以方便我们使用。 Library 目录下的 GUI.lib 就是 emWin 的库文件了，它是编译好的二进制编码，无法查看源程序。在不同的 CPU 平台下，需要使用不同版本的库，如这个工程里的GUI.lib 库仅可以用在 windows 的 VC++编译平台下，针对 Cortex-M0、M3 和 M4 芯片及 IAR、 MDK 编译环境都有相对应的库文件，使用时要根据自己的平台选择适当的库文件。
d.Sample 文件夹
Sample 文件夹是 emWin 的基础应用示例程序包。我们使用仿真的一个重要目的就是学习这个文件夹下的工程代码。 此文件夹从仿真工程的 V5.38 版本开始不再包含在工程中，文件结构也有所变化。目前的 Sample 文件夹包含 3 个子文件夹： Application， Tutorial 和WinMain。 这里的 Application 文件夹包含着另外 7 个官方演示例程， Tutorial 文件夹内提供的都是一个个很小的工程，简化了学习的难度，而且这个文件夹下提供的应用示例更加丰富，基本上涵盖了 emWin 库提供的所有功能，当我们在 emWin 参考手册中看到某些功能不会使用时，可以来这里找找，一般都能找到示例程序， WinMain 文件夹则是一些模拟器相关的文件，我们不作讨论
（4）Hello emWin
a.配置工程文件
1) 把 Application 中的文件从生成中排除。因为 emWin 文件包中每个例程都是是独立的工程，不能同时存在，所以我们想编译其他的例程时首先要把 Application 的文件排除在工程编译之外。操作步骤如下：全选 Application 下的文件， 右键->属性，在弹出的对话框中“从生成中排除”一栏中填“是”，这样就可以把这些文件排除在工程编译之外了。
2) 新建 Sample 文件夹。操作步骤如下：右键单击 SimulationTrial 项目，在弹出的选项中选择添加->新建筛选器，然后将新建的文件夹命名为 Sample。
3) 添加将要学习的 Sample 例程。 在本小节中，我们选择一个最简单的程序，用emWin 库函数显示“HelloWorld”，这个程序是由 BASIC_HelloWorld.c 文件实现的，文件路径： SeggerEval_WIN32_MSVC_MinGW_GUI_V548\Sample\Tutorial。操作步骤如下：右键点击新建好的 Sample 文件夹->添加->现有项， 然后根据路径找到 BASIC_HelloWorld.c 文件，把该文件添加到工程中。
4) 完成了上面步骤之后，我们会看到 Application 下的文件图标都有了一个禁止的小标签， Sample 目录下的 BASIC_HelloWorld.c 文件图标则没有，接下来我们就可以编译工程，点击“本地 Windows 调试器”按钮或“F5”运行，在仿真界面可以看到它以黑底白字的形式显示了“Hello World!”字样。
b. 学习 BASIC_HelloWorld 工程代码
运 行 BASIC_HelloWorld 程 序之 后 ， 自然比 较好 奇它 的代码 是如 何实 现的 ，打 开BASIC_HelloWorld.c 文件，发现它的代码非常简单。
#include "GUI.h"
/*********************************************************************
*
* Defines
*
**********************************************************************
*/
//
// Recommended memory to run the sample with adequate performance
//
#define RECOMMENDED_MEMORY (1024L * 5)
/*********************************************************************
*
* Public code
*
**********************************************************************
*/
/*********************************************************************
*
* MainTask
*/
void MainTask(void)
{
GUI_Init();
//
// Check if recommended memory for the sample is available
//
if (GUI_ALLOC_GetNumFreeBytes() < RECOMMENDED_MEMORY) {
GUI_ErrorOut("Not enough memory available.");
return;
}
GUI_DispString("Hello world!");
while (1);
}
/*************************** End of file ****************************/
在这个文件中的 MainTask 函数是主函数，就相当于平时我们熟悉的 main 函数一样，程序开始后就从 MainTask 开始执行，在这个函数里先是调用了 GUI_Init 函数，初始化了emWin 所需要的运行环境，接着检查为例程分配的内存是否够用，然后调用 emWin 库函数GUI_DispString 在屏幕输出“Hello World!”的字符串。
扫一扫
915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
