UCGUI的移植
2016-06-28 16:45
459 查看
转载：
http://www.openedv.com/posts/list/20610.htm
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D 文档说明：
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D 源代码：
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NTI2N3xlOTViNzk3MXwxNDY3MTAzMTAyfDB8MjA2MTA%3D
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
实际图片:
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include
Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config
/ GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver
/ LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y,
u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/posts/list/20610.htm
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D 文档说明：
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
个完整的
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D 源代码：
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NTI2N3xlOTViNzk3MXwxNDY3MTAzMTAyfDB8MjA2MTA%3D
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
http://www.openedv.com/forum.php?mod=attachment&aid=NDY5NXwyMDllMmY2ZXwxNDY3MTAzMTAyfDB8MjA2MTA%3D
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config / GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver / LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
实际图片:
UCGUI移植初级解析
-----------------如何建立一个简单的UC/GUI工程
仅供像我这样的新手学习UCGUI使用
做UCGUI移植，首先要选择好自己硬件平台，UCGUI源码，液晶的底层驱动。关于硬件和GUI源码（我选的源码3.90版，原子STM32MINI开发板）不必多说。其次，液晶的底层驱动函数得要好好准备，这可是直接和GUI源码打交道的。
补充说明：移植之前，先要准备一个完整的KEIL工程，所谓完整，就是没添加源码TFT也能任意画点显示。这一点对我们新手来说是至关重要的。如果你是用原子的mini做实验那就更好了，在准备KEIL工程的时候可以直接把原子的TFT实验复制过来。
好了，开始移植讲解！
1. 构建液晶底层驱动函数。
这部分代码，实际上包含这几个功能：液晶初始化功能、控制IC读取点坐标功能、画点功能。底层的驱动一般来说液晶的厂家都会给带，还有要注意驱动IC的型号，GUI源码所带的IC驱动函数往往没有合适的，至少我没碰到，呵呵呵。
这是我的底层函数，先列举三个比较重要的：
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y, u16 color );//画点
TFT_Init(void);//初始化函数
2. 从GUI源码里复制代码，进行工程搭建
（1）：复制 源码/Start 文件下的GUI和Config这两个文件夹到自己的工程模板；
图片指示：
（2）：复制 源码/Sample/GUI_X 文件夹下的 GUI_X.c 文件，粘贴到工程模板下的Config里；
图片指示：
（3）：打开KEIL工程（事先准备好的），KEIL界面左边有个Project视窗，在Target1单击右键，出现一个选项卡，在Groups里创建各文件，然后依次Add
Files，即添加.c .h文件，这里要着重说明：添加文件的时候，尤其是GUI源码，文件类型选择ALL
Files（系统默认.c文件），就是为了添加.h文件，这一点很重要。举个例子吧，在Config文件夹下要添加GUI_X.c
GUIConf.h GUITouch.h LCDConf.h。
还有一个问题，网上有人说触摸用不到，可以不用添加，然后字体也只添加几个用得到的，我的意见是：全部添加，避免难以修改的KEIL警告，这点很重要，我是新手，我很清楚怎么过来的，呵呵呵。
补充说明：新建 TFTDrive.h ILI93xx.c 两个文件，这个TFTDrive.h是 ILI93xx.c 的头文件，通过TFTDrive.h找到ILI93xx.c里的程序。 这两个文件里面的内容，是事先准备好的，也就是我所说的没加GUI源码之前的 完整的 KEIL工程的一部分。当然，这两个文件放到LCDDriver文件夹里面，添加的时候也一并添加进去就行。
（4）：文件添加完了，还有一步呢，还要在添加路径。点击魔术棒，出现一个选项卡，点击C/C++，在Include
Paths里包含文件路径，所有文件的都要包进来哦。能玩移植的朋友们，我相信（3）（4）两步对你们来说不难。
（5）
修改：Config
/ GUIConf.h文件
方法：
#define GUI_OS (0)
#define GUI_SUPPORT_TOUCH (0)
#define GUI_SUPPORT_UNICODE (0)
#define GUI_DEFAULT_FONT &GUI_Font6x8
#define GUI_ALLOC_SIZE 5000
#define GUI_WINSUPPORT （0）
#define GUI_SUPPORT_MEMDEV （0）
#define GUI_SUPPORT_AA （0）
其余部分不需要改动
（6）
修改Config / LCDConf.h
方法：
#ifndef LCDCONF_H
#define LCDCONF_H
#define LCD_XSIZE (240) /* 水平分辨率X-resolution of LCD, Logical coor. */
#define LCD_YSIZE (320) /* 垂直分辨率Y-resolution of LCD, Logical coor. */
#define LCD_BITSPERPIXEL (16) /*lcd颜色深度*/
#define LCD_CONTROLLER (-1) /*lcd控制器的具体型号*/
#define LCD_FIXEDPALETTE (565) /*RGB颜色位数*/
#define LCD_SWAP_RB (1) /*红蓝反色交换*/
#define LCD_INIT_CONTROLLER() TFT_Init(); /*底层初始化函数，自己写的，而非源码自带，这一步非常重要*/
#endif /* LCDCONF_H */
这是我修改之后的源码，大家看看是不是声明下面少了许多函数啊，没错，我删掉了，原因很简单，我的底层驱动IC程序是厂家提供的，而且GUI源码也没有我的这部分驱动程序。所以大家弄得时候也要一并删除，只留下红色代码部分。
(7)
修改：LCDDriver
/ LCDDummy.c文件
方法：在这里面添加几个函数，关于这几个函数就是我在开始列举的几个函数
LCD_ReadPoint(u16 x, u16 y);//读取点坐标
LCD_SetPoint(u16 x, u16 y,
u16 color );//画点
你的函数也许不是这个名字哦，大家不要照搬，这是你自己的驱动函数，在哪里添加这两个函数呢，不要着急，听我来说，
还有一个头文件 #include“TFTDrive.h” 这个是你自己的底层驱动文件，把这个头文件写在LCDDriver
/ LCDDummy.c 中即可。必须要写的 否则建立不起联系。
找到void LCD_L0_SetPixelIndex(int x, int y, int
ixelIndex) {
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Write into hardware ... Adapt to your system */
{
添加LCD_SetPoint(x,y,PixelIndex);/* 自己自行添加的，画点... */
}
}
找到unsigned int LCD_L0_GetPixelIndex(int x, int y) {
LCD_PIXELINDEX
ixelIndex;
/* Convert logical into physical coordinates (Dep. on LCDConf.h) */
#if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
int xPhys = LOG2PHYS_X(x, y);
int yPhys = LOG2PHYS_Y(x, y);
#else
#define xPhys x
#define yPhys y
#endif
/* Read from hardware ... Adapt to your system */
{
添加 PixelIndex=LCD_ReadPoint(x,y); //读点
}
return
ixelIndex;
}
至此，移植结束，大家是不是想看一看现象呢，接下来：
先修改主函数，添加 #include”GUI.h”//头文件包含嘛，呵呵呵
在main（）里，添加 ：
GUI_Init();
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_RED);
GUI_Clear();
GUI_DrawCircle(100,100,50);//画圆
while(1)；
点击编译：
感想：关于移植，我个人觉得最困难的地方是底层驱动函数与GUI源码打交道的部分，这部分的。C 。h文件一定要事先准备好，放到LCDDriver文件夹下面。这将直接决定你的移植是不是成功。
如有不足之处，敬请谅解！
制作
于2013/8/27
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- UI控件之菜单(Menu)
- UIGestureRecognizer(手势识别器)
- build AOSP for N6P/N5
- ios 调用系统相机，图库，相册。将照片保存在相册，保存图片在本地，UIImagePickerController
- Facebook开源的基于SQL的操作系统检测和监控框架:osquery
- VS2008 LINK : fatal error LNK1000: Internal error during IncrBuildImage
- 拍照图片方向
- IOS系列-UIProgressView控件用法
- 通用查询功能第三版EasyQueryVer3使用说明
- iOS开发系列--UISlider用法总结
- 转发（request.setRequestDispacter）和重定向（response.sendRedirect）的区别以及转发的include和forward的区别
- request和response的相关
- 体会建造者模式Builder
- Codeforces 245H Queries for Number of Palindromes
- 高效读写的队列：深度剖析ConcurrentLinkedQueue
- Android UI线程和非UI线程
- iOS将UIImage设置为圆角
- request中的方法小结
- UINavigationController、UITabBarController
- 导致UIButton半透明的原因