单片机 ：STM32F407
开发板：DMF407电机开发板
平台：keil V5.31
HSE 为8MHZ
HSI为16MHZ
一、文本显示
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(void)
{
int i;
char acText[] = "This example demostrates text wrapping";
GUI_RECT Rect = {200, 240, 259, 299}; /* 定义矩形显示区域 */
GUI_WRAPMODE aWm[] = {GUI_WRAPMODE_NONE,
GUI_WRAPMODE_CHAR,
GUI_WRAPMODE_WORD};
GUI_SetBkColor(GUI_BLUE); /* 设置背景颜色 */
GUI_Clear(); /* 清屏 */
GUI_SetFont(&GUI_Font24_ASCII); /* 设置字体 */
GUI_SetColor(GUI_YELLOW); /* 设置前景色(如文本，画线等颜色) */
GUI_DispString("HELLO WORD!");
GUI_SetFont(&GUI_Font8x16); /* 设置字体 */
GUI_SetPenSize(10); /* 设置笔大小 */
GUI_SetColor(GUI_RED); /* 红色字体 */
GUI_DrawLine(300, 50, 500, 130); /* 绘线 */
GUI_DrawLine(300, 130, 500, 50); /* 绘线 */
GUI_SetBkColor(GUI_BLACK); /* 设置黑色背景 */
GUI_SetColor(GUI_WHITE); /* 设置字体颜色为白色 */
GUI_SetTextMode(GUI_TM_NORMAL); /* 正常模式 */
GUI_DispStringHCenterAt("GUI_TM_NORMAL", 400, 50);
GUI_SetTextMode(GUI_TM_REV); /* 反转文本 */
GUI_DispStringHCenterAt("GUI_TM_REV", 400, 66);
GUI_SetTextMode(GUI_TM_TRANS); /* 透明文本 */
GUI_DispStringHCenterAt("GUI_TM_TRANS", 400, 82);
GUI_SetTextMode(GUI_TM_XOR); /* 异或文本 */
GUI_DispStringHCenterAt("GUI_TM_XOR", 400, 98);
GUI_SetTextMode(GUI_TM_TRANS | GUI_TM_REV); /* 透明反转文本 */
GUI_DispStringHCenterAt("GUI_EM_TRANS|GUI_TM_REV", 400, 114);
GUI_SetTextMode(GUI_TM_TRANS); /* 透明文本 */
for (i = 0; i < 3; i++)
{
GUI_SetColor(GUI_WHITE);
GUI_FillRectEx(&Rect);
GUI_SetColor(GUI_BLACK);
GUI_DispStringInRectWrap(acText, &Rect, GUI_TA_LEFT, aWm[i]); /* 在当前窗口指定的矩形区域内显示字符串(并可自动换行) */
Rect.x0 += 70;
Rect.x1 += 70;
}
while(1)
{
GUI_Delay(5);
}
}实验结果
二、数值显示
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(100,50); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(uint16_t x,uint16_t y)
{
char* emwinversion; /* emwin版本号 */
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_SetTextMode(GUI_TM_TRANS); /* 透明显示模式 */
GUI_SetFont(&GUI_Font24_ASCII);
GUI_SetColor(GUI_YELLOW);
GUI_DispStringHCenterAt("ALIENTEK NUM DISPLAY DEMO",400,10);
GUI_SetColor(GUI_RED);
GUI_SetFont(&GUI_Font20_ASCII);
GUI_DispStringAt("GUI_DispDecAt():",x,y);
GUI_DispDecAt(200,x+150,y,3); /* 显示数值200 */
GUI_DispStringAt("GUI_DispFloat():",x,y+20);
GUI_GotoXY(x+150,y+20); /* 移动光标 */
GUI_DispFloat(49.35,5); /* 显示浮点数49.35 */
GUI_DispString(" ");
GUI_DispFloat(-0.345,6); /* 显示浮点数-0.345 */
GUI_DispStringAt("GUI_DispBinAt():",x,y+40);
GUI_DispBinAt(8,x+150,y+40,4); /* 显示十进制数8的二进制值 */
GUI_DispStringAt("GUI_DispHex():",x,y+60);
GUI_GotoXY(x+150,y+60); /* 移动光标 */
GUI_DispHex(100,3); /* 显示十进制数100的16进制值 */
GUI_DispStringAt("GUI_DispHexAt():",x,y+80);
GUI_DispHexAt(100,x+150,y+80,3); /* 在指定位置显示十进制数100的16进制值 */
GUI_DispStringAt("GUI_GetVersionString():",x,y+100);
emwinversion = (char*)GUI_GetVersionString(); /* 获取当前emwin版本号 */
GUI_DispStringAt(emwinversion,x+200,y+100); /* 显示emwin版本号 */
while(1)
{
GUI_Delay(5);
}
}实验结果
三、2D绘图
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(void)
{
while(1)
{
emwin_display_2d();
GUI_Delay(2000);
emwin_alpha_display();
GUI_Delay(2000);
emwin_draw_polygon();
GUI_Delay(2000);
emwin_draw_Pie();
GUI_Delay(4000);
}
}
void emwin_drawarcscale(void)
{
int x0 = 630;
int y0 = 380;
int i;
char ac[4];
GUI_SetPenSize( 5 );
GUI_SetTextMode(GUI_TM_TRANS);
GUI_SetFont(&GUI_FontComic18B_ASCII);
GUI_SetColor(GUI_BLACK);
GUI_DrawArc( x0, y0, 150, 150, -30, 210 );
for (i = 0; i <= 23; i++)
{
float a = (-30 + i * 10) * 3.1415926 / 180;
int x = -141 * cos(a) + x0;
int y = -141 * sin(a) + y0;
if (i % 2 == 0)
GUI_SetPenSize( 5 );
else
GUI_SetPenSize( 4 );
GUI_DrawPoint(x, y);
if (i % 2 == 0)
{
x = -123 * cos(a) + x0;
y = -130 * sin(a) + y0;
sprintf(ac, "%d", 10 * i);
GUI_SetTextAlign(GUI_TA_VCENTER);
GUI_DispStringHCenterAt(ac, x, y);
}
}
}
void emwin_draw_graph(void)
{
I16 aY[400];
int i;
for (i = 0; i < GUI_COUNTOF(aY); i++) aY[i] = rand() % 100;
GUI_ClearRect(0, 300, 400, 400); /* 每次显示前先清除显示区域 */
GUI_DrawGraph(aY, GUI_COUNTOF(aY), 0, 300);
}
void emwin_display_2d(void)
{
int i;
GUI_SetBkColor(GUI_BLUE); /* 设置背景颜色 */
GUI_Clear();
GUI_SetColor(GUI_YELLOW);
GUI_SetFont(&GUI_Font24_ASCII);
GUI_DispStringHCenterAt("ALIENTEK 2D DISPALY", 400, 10);
GUI_SetColor(GUI_RED);
GUI_SetFont(&GUI_Font16_ASCII);
GUI_SetBkColor(GUI_GREEN);
GUI_ClearRect(10, 50, 100, 150); /* 在一个矩形区域填充绿色背景 */
GUI_SetBkColor(GUI_BLUE); /* 背景改回蓝色 */
GUI_DrawGradientH(110, 50, 210, 150, 0X4117BB, 0XC6B6F5); /* 绘制用水平颜色梯度填充的矩形 */
GUI_DrawGradientV(220, 50, 320, 150, 0X4117BB, 0XC6B6F5); /* 绘制用垂直颜色梯度填充的矩形 */
GUI_DrawGradientRoundedH(330, 50, 430, 150, 25, 0X4117BB, 0XC6B6F5); /* 绘制水平颜色梯度填充的圆角矩形 */
GUI_DrawGradientRoundedV(440, 50, 540, 150, 25, 0X4117BB, 0XC6B6F5); /* 绘制垂直颜色梯度填充的圆角矩形 */
GUI_DrawRect(550, 50, 650, 150); /* 在当前窗口中指定的位置绘制矩形 */
GUI_FillRect(660, 50, 760, 150); /* 在当前窗口中指定位置绘制填充的矩形区域 */
GUI_SetPenSize(5); /* 设置画笔颜色,单位像素点 */
GUI_DrawLine(10, 160, 110, 260); /* 绘制线条 */
for (i = 0; i < 50; i += 3) GUI_DrawCircle(200, 220, i); /* 绘制圆，无法绘制半径大于180的圆 */
GUI_FillCircle(320, 220, 50); /* 在指定位置绘制指定尺寸的填充的圆,无法绘制半径大于180的圆 */
GUI_SetPenSize(2);
GUI_SetColor(GUI_CYAN);
GUI_DrawEllipse(450, 220, 70, 50); /* 在指定位置绘制指定尺寸的椭圆的轮廓 无法处理大于180的rx/ry参数 */
GUI_SetColor(GUI_MAGENTA);
GUI_FillEllipse(450, 220, 65, 45); /* 在指定位置绘制指定尺寸的填充的椭圆 */
emwin_drawarcscale();
emwin_draw_graph();
}
void emwin_alpha_display(void)
{
GUI_EnableAlpha(1); /* 使能Alpha功能 */
GUI_SetBkColor(GUI_WHITE); /* 设置背景颜色 */
GUI_Clear();
GUI_SetTextMode(GUI_TM_TRANS);/* 文本透明显示 */
GUI_SetColor(GUI_BLACK);
GUI_SetFont(&GUI_Font32_1);
GUI_DispStringHCenterAt("ALIENTEK ALPHA TEST", 400, 220);
GUI_SetAlpha(0x40); /* 设置alpha值0x00-0XFF */
GUI_SetColor(GUI_RED);
GUI_FillRect(100, 50, 300, 250); /* 绘制红色矩形 */
GUI_SetAlpha(0x80);
GUI_SetColor(GUI_GREEN);
GUI_FillRect(200, 150, 400, 350); /* 绘制绿色矩形 */
GUI_SetAlpha(0xC0);
GUI_SetColor(GUI_BLUE);
GUI_FillRect(300, 250, 500, 450); /* 绘制蓝色矩形 */
GUI_SetAlpha(0x80);
GUI_SetColor(GUI_YELLOW);
GUI_FillRect(400, 150, 600, 350); /* 绘制黄色矩形 */
GUI_SetAlpha(0x40);
GUI_SetColor(GUI_BROWN);
GUI_FillRect(500, 50, 700, 250); /* 绘制棕色矩形 */
GUI_SetAlpha(0); /* 恢复alpha通道 */
}
void emwin_draw_polygon(void)
{
int i, Mag, magy = 50, Count = 4;
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_YELLOW);
GUI_Clear();
GUI_SetTextMode(GUI_TM_TRANS); /* 透明显示 */
GUI_SetFont(&GUI_Font24_ASCII); /* 设置字体 */
GUI_DispStringHCenterAt("ALIENTEK PLAYGON DISPLAY", 400, 10);
GUI_SetColor(GUI_WHITE);
GUI_SetDrawMode(GUI_DM_XOR); /* 设置绘制模式 */
GUI_FillPolygon(aPoints, GUI_COUNTOF(aPoints), 140, 110);
for (i = 1; i < 10; i++)
{
GUI_EnlargePolygon(aEnlargedPoints, aPoints, GUI_COUNTOF(aPoints), i * 5); /* 放大坐标 */
GUI_FillPolygon(aEnlargedPoints, GUI_COUNTOF(aPoints), 140, 110); /* 绘制放大坐标后的多边形 */
}
GUI_SetDrawMode(GUI_DM_NORMAL); /* 恢复默认的绘制模式 */
GUI_SetColor(GUI_GREEN);
for (Mag = 1; Mag <= 4; Mag *= 2, Count /= 2)
{
int magx = 600;
GUI_MagnifyPolygon(aMagnifiedPoints, aPoints, GUI_COUNTOF(aPoints), Mag); /* 按指定系数放大多边形 */
for (i = Count; i > 0; i--, magx += 40 * Mag)
{
GUI_FillPolygon(aMagnifiedPoints, GUI_COUNTOF(aPoints), magx, magy); /* 绘制多边形 */
}
magy += 20 * Mag;
}
GUI_SetFont(&GUI_Font8x16);
GUI_DispStringAt("Polygons of arbitrary shape ", 100, 300);
GUI_DispStringAt("in any color", 220, 320);
GUI_SetColor(GUI_DARKRED);
GUI_FillPolygon (&aPointArrow[0], 7, 200, 400); /* 绘制多边形 */
}
void emwin_draw_Pie(void)
{
int i, a0, a1;
int xSize;
int ySize;
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_YELLOW);
GUI_Clear();
GUI_SetTextMode(GUI_TM_TRANS); /* 透明显示 */
GUI_SetFont(&GUI_Font24_ASCII); /* 设置字体 */
GUI_DispStringHCenterAt("ALIENTEK Pie DISPLAY", 400, 10);
xSize = LCD_GetXSize();
ySize = LCD_GetYSize();
const unsigned aValues[] = { 100, 135, 190, 240, 340, 360};
const GUI_COLOR aColors[] = { GUI_BLUE, GUI_GREEN, GUI_RED,
GUI_CYAN, GUI_MAGENTA, GUI_YELLOW };
for (i = 0; i < GUI_COUNTOF(aValues); i++)
{
a0 = (i == 0) ? 0 : aValues[i - 1];
a1 = aValues[i];
GUI_SetColor(aColors[i]);
GUI_DrawPie(xSize/2, ySize/2, 100, a0, a1, 0);
}
}实验结果
四、绘制位图
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(void)
{
int Xmag = 0 ,Ymag = 0; /* 缩放因子,单位 千分之 */
emwin_draw_bitmap();
GUI_Delay(2000);
while(1)
{
Xmag += 100;
Ymag += 100;
if(Xmag >= 2000)
{
Xmag = 100;
}
if(Ymag >= 2000)
{
Ymag = 100;
}
emwin_zoom_bitmap(Xmag,Ymag); /* 绘制缩放的位图 */
GUI_Delay(500);
}
}
void emwin_draw_bitmap(void)
{
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_YELLOW);
GUI_Clear();
GUI_SetFont(&GUI_Font24_ASCII);
GUI_SetTextMode(GUI_TM_TRANS); /* 透明显示 */
GUI_DispStringHCenterAt("ALIENTEK BITMAP DISPLAY",400,0 );
GUI_DrawBitmap(&bmALIENTEK,295,194); /* 绘制ALIENTEK图标 */
}
void emwin_zoom_bitmap(int Xmag,int Ymag)
{
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_DrawBitmapEx(&bmALIENTEK,400,240,105,46,Xmag,Ymag); /* 按照比例绘制位图 */
}实验结果
五、颜色条绘制
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(void)
{
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_YELLOW);
GUI_Clear();
GUI_SetFont(&GUI_Font24_ASCII);
GUI_SetTextMode(GUI_TM_TRANS); /*透明显示*/
GUI_DispStringHCenterAt("COLOR_BAR TEST!",400,0);
emwin_show_colorbar(); /*显示颜色条*/
}
static void emwin_show_colorbar(void)
{
GUI_RECT Rect;
int yStep;
int i;
int j;
int xSize;
int ySize;
int NumBars; /* 要显示的颜色条数量2+2+2+1+2+2+2=13 */
int NumColors; /* 要显示的颜色数量，这里有7个 */
/* 获取显示屏尺寸 */
xSize = LCD_GetXSize();
ySize = LCD_GetYSize();
/* 获取颜色条的数量 ，NumColors等于7 */
NumColors = GUI_COUNTOF(_aBarData);
for (i = NumBars = 0, NumBars = 0; i < NumColors; i++)
{
NumBars += _aBarData[i].NumBars; /* 获取_aBarData的颜色的数量 */
}
yStep = (ySize - Y_START) / NumBars;/* 获得显示颜色的平均值 */
/* 显示文本 */
Rect.x0 = 0;
Rect.x1 = X_START - 1;
Rect.y0 = Y_START;
GUI_SetFont(&GUI_Font8x16);
for (i = 0; i < NumColors; i++)
{
Rect.y1 = Rect.y0 + yStep * _aBarData[i].NumBars - 1;
GUI_DispStringInRect(_aBarData[i].s, &Rect, GUI_TA_LEFT | GUI_TA_VCENTER); /* 显示文本 */
Rect.y0 = Rect.y1 + 1;
}
/* 显示颜色 */
Rect.x0 = X_START;
Rect.x1 = xSize - 1;
Rect.y0 = Y_START;
for (i = 0; i < NumColors; i++)
{
for (j = 0; j < _aBarData[i].NumBars; j++)
{
Rect.y1 = Rect.y0 + yStep - 1;
GUI_DrawGradientH(Rect.x0, Rect.y0, Rect.x1, Rect.y1, _aColorStart[j], _aBarData[i].Color); /* 显示颜色 */
Rect.y0 = Rect.y1 + 1;
}
}
}实验结果
六、存储设备
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(void)
{
GUI_MEMDEV_Handle hMem; /* 存储设备的句柄 */
int i;
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_SetColor(GUI_YELLOW);
GUI_SetFont(&GUI_Font24_ASCII);
GUI_DispStringHCenterAt("MEMDEV_MemDev - Sample", 400, 0);
GUI_SetFont(&GUI_Font20_ASCII);
GUI_DispStringHCenterAt("Shows the advantage of using a\nmemorydevice", 400,50);
GUI_SetFont(&GUI_Font16_ASCII);
GUI_DispStringHCenterAt("Draws the picture\nwithout a\nmemory device", 250, 100);
GUI_DispStringHCenterAt("Draws the picture\nusing a\nmemory device", 550, 100);
hMem = GUI_MEMDEV_Create(Rect.x0, Rect.y0, Rect.x1 - Rect.x0, Rect.y1 - Rect.y0); /* 创建存储设备 */
GUI_MEMDEV_Select(hMem); /* 选择hMem作为绘制操作目标的存储设备 */
emwin_draw(0); /* 执行要显示的内容复制到存储设备中 */
GUI_MEMDEV_Select(0); /* 选中LCD */
while (1)
{
for (i = 0; i < 3; i++)
{
GUI_Delay(250);
GUI_ClearRect(LCD_GetXSize() - Rect.x1, Rect.y0, LCD_GetXSize(), Rect.y1); /* 清除选中的屏幕 */
GUI_Delay(250);
GUI_MEMDEV_CopyToLCDAt(hMem, LCD_GetXSize() - Rect.x1, Rect.y0); /* 将存储设备的内容从内存复制到LCD的指定位置 */
}
GUI_Delay(500);
/* 未使用存储设备 */
emwin_draw(400);
GUI_Delay(400);
GUI_ClearRect(0, 150, 799, 210);
}
}
static void emwin_draw(int Delay)
{
GUI_SetPenSize(5);
GUI_SetColor(GUI_RED);
GUI_DrawLine(Rect.x0 + 3, Rect.y0 + 3, Rect.x1 - 3, Rect.y1 - 3);
GUI_Delay(Delay);
GUI_SetColor(GUI_GREEN);
GUI_DrawLine(Rect.x0 + 3, Rect.y1 - 3, Rect.x1 - 3, Rect.y0 + 3);
GUI_Delay(Delay);
GUI_SetColor(GUI_WHITE);
GUI_SetFont(&GUI_FontComic24B_ASCII);
GUI_SetTextMode(GUI_TM_TRANS);
GUI_DispStringInRect("Closed", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_Delay(Delay);
}实验结果
七、分段存储设备
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(void)
{
tDrawItContext DrawItContext;
int i, swap=0;
GUI_SetBkColor(GUI_BLACK);
GUI_Clear();
GUI_SetColor(GUI_YELLOW);
GUI_SetFont(&GUI_Font24_ASCII);
GUI_DispStringHCenterAt("MEMDEV_Banding - Sample", 160, 5);
GUI_SetFont(&GUI_Font16_ASCII);
GUI_DispStringHCenterAt("Banding memory device\nwithout flickering", 160, 40);
DrawItContext.XPos_Poly = 160;
DrawItContext.YPos_Poly = 120;
DrawItContext.YPos_Text = 116;
while (1)
{
swap = ~swap;
for (i = 0; i < 220; i++)
{
float angle = i * 3.1415926 / 55;
DrawItContext.XPos_Text = (swap) ? i : 220 - i;
/* 旋转多边形 */
GUI_RotatePolygon(DrawItContext.aPointsDest, aPoints,
SIZE_OF_ARRAY(aPoints), angle);
#if USE_BANDING_MEMDEV
{
GUI_RECT Rect = {0, 70, 320,170};
GUI_MEMDEV_Draw(&Rect,&emwin_draw_it,&DrawItContext,0,0);/* 使用分段存储绘制 */
}
#else
{
/* 如果没有开启分段存储的话就使用普通绘制方式 */
emwin_draw_it((void *)&DrawItContext);
}
#endif
}
GUI_Delay(100);
}
}
static void emwin_draw_it(void * pData)
{
tDrawItContext * pDrawItContext = (tDrawItContext *)pData;
GUI_Clear();
GUI_SetFont(&GUI_Font8x8);
GUI_SetTextMode(GUI_TM_TRANS);
/* 绘制背景 */
GUI_SetColor(GUI_GREEN);
GUI_FillRect(pDrawItContext->XPos_Text,
pDrawItContext->YPos_Text - 25,
pDrawItContext->XPos_Text + 100,
pDrawItContext->YPos_Text - 5);
/* 绘制多边形 */
GUI_SetColor(GUI_BLUE);
GUI_FillPolygon(pDrawItContext->aPointsDest, SIZE_OF_ARRAY(aPoints), 160, 120);
/* 绘制前景 */
GUI_SetColor(GUI_RED);
GUI_FillRect(220 - pDrawItContext->XPos_Text,
pDrawItContext->YPos_Text + 5,
220 - pDrawItContext->XPos_Text + 100,
pDrawItContext->YPos_Text + 25);
}测试结果
八、自动设备对象
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
void emwin_main(void)
{
GUI_AUTODEV AutoDev; /* Object for banding memory device */
PARAM Param; /* Parameters for drawing routine */
int Cnt;
int tDiff;
int t0;
/* 显示信息 */
GUI_SetBkColor(GUI_BLACK);
GUI_Clear();
GUI_SetColor(GUI_WHITE);
GUI_SetFont(&GUI_Font24_ASCII);
GUI_DispStringHCenterAt("MEMDEV_AutoDev - Sample", 160, 5);
GUI_SetFont(&GUI_Font8x16);
GUI_DispStringHCenterAt("Scale using GUI_AUTODEV-object", 160, 50);
/* 使能高分辨率抗锯齿 */
GUI_AA_EnableHiRes();
GUI_AA_SetFactor(MAG);
while (1)
{
t0 = GUI_GetTime();
GUI_MEMDEV_CreateAuto(&AutoDev); /* 创建自动设备对象 */
for (Cnt = 0; (tDiff = GUI_GetTime() - t0) < 24000; Cnt++)
{
Param.Angle = emwin_get_angle(tDiff)* DEG2RAD;
GUI_RotatePolygon(Param.aPoints, _aNeedle, countof(_aNeedle), Param.Angle); /* 按照指定角度旋转多边形 */
GUI_MEMDEV_DrawAuto(&AutoDev, &Param.AutoDevInfo, &emwin_draw, &Param); /* 使用自动设备对象绘制图形 */
}
/* 显示milliseconds / picture图片 */
GUI_SetColor(GUI_WHITE);
GUI_SetFont(&GUI_Font8x16);
GUI_DispStringHCenterAt("Milliseconds / picture:", 160, 200);
GUI_SetTextAlign(GUI_TA_CENTER);
GUI_SetTextMode(GUI_TM_NORMAL);
GUI_DispNextLine();
GUI_GotoX(160);
GUI_DispFloatMin((float)tDiff / (float)Cnt, 2);
/* 删除自动设备对象 */
GUI_MEMDEV_DeleteAuto(&AutoDev);
GUI_Delay(3000);
GUI_ClearRect(0, 70, 319, 239);
}
}
static void emwin_draw(void * p)
{
PARAM * pParam;
pParam = (PARAM *)p;
/* 显示背景 */
if (pParam->AutoDevInfo.DrawFixed)
{
GUI_ClearRect (60, 80 + bmScaleR140.YSize, 60 + bmScaleR140.XSize - 1, 180);
GUI_DrawBitmap(&bmScaleR140, 60, 80);
}
/* 移动指针 */
GUI_SetColor(GUI_WHITE);
GUI_AA_FillPolygon(pParam->aPoints, countof(_aNeedle), MAG * 160, MAG * 220); //绘制实心无锯齿多边形
/* 显示前景色 */
if (pParam->AutoDevInfo.DrawFixed)
{
GUI_SetTextMode(GUI_TM_TRANS);
GUI_SetColor(GUI_RED);
GUI_SetFont(&GUI_Font24B_ASCII);
GUI_DispStringHCenterAt("RPM / 1000", 160, 140);
}
}
static float emwin_get_angle(int tDiff)
{
if (tDiff < 15000)
{
return 225 - 0.006 * tDiff ;
}
tDiff -= 15000;
if (tDiff < 7500)
{
return 225 - 90 + 0.012 * tDiff ;
}
return 225;
}测试i结果：
九、WM重绘背景
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
static void _cbBkWindow(WM_MESSAGE *pMsg)
{
switch (pMsg->MsgId) /*根据不同的消息类型处理 */
{
case WM_PAINT: /*WM_PAIMNT消息，窗口重绘自身 */
GUI_ClearRect(0, 50, 319, 239);
break;
default:
WM_DefaultProc(pMsg); /*此函数可处理未处理的消息 */
}
}
static void _cbWindow(WM_MESSAGE *pMsg)
{
GUI_RECT Rect;
switch (pMsg->MsgId)
{
case WM_PAINT:
WM_GetInsideRect(&Rect); /* 返回活动窗口减去边界后的尺寸 */
GUI_SetBkColor(GUI_RED); /* 红色背景色 */
GUI_SetColor(GUI_YELLOW); /* 黄色 */
GUI_ClearRectEx(&Rect); /* 清除Rect区域,既绘制红色区域 */
GUI_DrawRectEx(&Rect); /* 绘制Rect区域,既绘制黄色框框 */
GUI_SetColor(GUI_BLACK); /* 黑色 */
GUI_SetFont(&GUI_Font16_ASCII); /* 设置字体 */
GUI_DispStringHCenterAt("Foreground Window", 75, 40);
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _MoveWindow(const char *pText)
{
WM_HWIN hWnd;
int i;
/*创建前景窗口 */
hWnd = WM_CreateWindow(10, 50, 150, 100, WM_CF_SHOW, _cbWindow, 0);
GUI_Delay(500);
/*移动前景窗口 */
for (i = 0; i < 40; i++)
{
WM_MoveWindow(hWnd, 2, 2); /* 移动窗口 */
GUI_Delay(10);
}
/* 删除窗口之前显示文本 */
if (pText)
{
GUI_DispStringAt(pText, 5, 50);
GUI_Delay(2500);
}
/* 删除前景窗口 */
WM_DeleteWindow(hWnd); /* 删除窗口*/
WM_Invalidate(WM_HBKWIN); /* 背景窗口无效*/
GUI_Exec();
}
void emwin_main(void)
{
WM_CALLBACK *_cbOldBK;
GUI_SetBkColor(GUI_BLACK); /*设置背景颜色 */
GUI_Clear();
GUI_SetColor(GUI_WHITE); /*白色 */
GUI_SetFont(&GUI_Font24_ASCII); /*设置字体 */
GUI_DispStringHCenterAt("WM_Redraw-Sample", 160, 5);
GUI_SetFont(&GUI_Font16B_ASCII); /*设置字体 */
while (1)
{
_MoveWindow("Background has not been redraw"); //移动窗口 */
/* 清除背景 */
GUI_ClearRect(0, 50, 319, 239);
GUI_Delay(1000);
/* 为背景窗口设置回调函数 */
_cbOldBK = WM_SetCallback(WM_HBKWIN, _cbBkWindow);
/* 移动窗口 */
_MoveWindow("Background has been redraw");
/* 窗口WM_HBKWIN的回调函数重新设置为上一个回调函数 */
WM_SetCallback(WM_HBKWIN, _cbOldBK);
}
}测试结果：
十、WM函数使用
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
static void _ChangeInfoText(char *pStr)
{
WM_MESSAGE Message;
Message.MsgId = MSG_CHANGE_TEXT;
Message.Data.p = pStr;
WM_SendMessage(WM_HBKWIN, &Message); /* 向背景窗口发送消息 */
WM_InvalidateWindow(WM_HBKWIN); /* 使背景窗口失效 */
}
static void _DrawInfoText(char *pStr)
{
GUI_SetColor(GUI_WHITE);
GUI_SetFont(&GUI_Font24_ASCII);
GUI_DispStringHCenterAt("WindowManager - Sample", 160, 5);
GUI_SetFont(&GUI_Font8x16);
GUI_DispStringAtCEOL(pStr, 5, 40); /* 在指定位置显示字符串并清除至行末 */
}
static void _LiftUp(int dy)
{
int i;
int tm;
for (i = 0; i < (dy / 4); i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, 0, -4); /* 移动窗口1 */
WM_MoveWindow(_hWindow2, 0, -4); /* 移动窗口2 */
while ((GUI_GetTime() - tm) < 20)
{
WM_Exec(); /* 通过执行回调函数重绘无效窗口 */
}
}
}
static void _LiftDown(int dy)
{
int i;
int tm;
for (i = 0; i < (dy / 4); i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, 0, 4);
WM_MoveWindow(_hWindow2, 0, 4);
while ((GUI_GetTime() - tm) < 20)
{
WM_Exec();
}
}
}
static void _cbBkWindow(WM_MESSAGE *pMsg)
{
switch (pMsg->MsgId)
{
case MSG_CHANGE_TEXT:
strcpy(_acInfoText, (char const *)pMsg->Data.p);
case WM_PAINT:
GUI_SetBkColor(GUI_BLACK);
GUI_Clear();
GUI_SetColor(GUI_WHITE);
GUI_SetFont(&GUI_Font24_ASCII);
GUI_DispStringHCenterAt("WindowManager - Sample", 160, 5);
GUI_SetFont(&GUI_Font8x16);
GUI_DispStringAt(_acInfoText, 5, 40);
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbWindow1(WM_MESSAGE *pMsg)
{
GUI_RECT Rect;
int x;
int y;
switch (pMsg->MsgId)
{
case WM_PAINT:
WM_GetInsideRect(&Rect); /*返回客户区的坐标 */
GUI_SetBkColor(_WindowColor1);
GUI_SetColor(_FrameColor1);
GUI_ClearRectEx(&Rect); /*填充一个矩形区域 */
GUI_DrawRectEx(&Rect); /*绘制一个矩形 */
GUI_SetColor(GUI_WHITE);
GUI_SetFont(&GUI_Font24_ASCII);
x = WM_GetWindowSizeX(pMsg->hWin); /*获取窗口的X轴大小 */
y = WM_GetWindowSizeY(pMsg->hWin); /*获取窗口的Y轴大小 */
GUI_DispStringHCenterAt("Window 1", x / 2, (y / 2) - 12);
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbWindow2(WM_MESSAGE *pMsg)
{
GUI_RECT Rect;
int x;
int y;
switch (pMsg->MsgId)
{
case WM_PAINT:
WM_GetInsideRect(&Rect); /* 返回客户区的坐标 */
GUI_SetBkColor(_WindowColor2);
GUI_SetColor(_FrameColor2);
GUI_ClearRectEx(&Rect); /* 填充一个矩形区域 */
GUI_DrawRectEx(&Rect); /* 绘制一个矩形 */
GUI_SetColor(GUI_WHITE);
GUI_SetFont(&GUI_Font24_ASCII);
x = WM_GetWindowSizeX(pMsg->hWin); /* 获取窗口的X轴大小 */
y = WM_GetWindowSizeY(pMsg->hWin); /* 获取窗口的Y轴大小 */
GUI_DispStringHCenterAt("Window 2", x / 2, (y / 4) - 12);
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbChild(WM_MESSAGE *pMsg)
{
GUI_RECT Rect;
int x;
int y;
switch (pMsg->MsgId)
{
case WM_PAINT:
WM_GetInsideRect(&Rect);
GUI_SetBkColor(_ChildColor);
GUI_SetColor(_ChildFrame);
GUI_ClearRectEx(&Rect);
GUI_DrawRectEx(&Rect);
GUI_SetColor(GUI_RED);
GUI_SetFont(&GUI_Font24_ASCII);
x = WM_GetWindowSizeX(pMsg->hWin);
y = WM_GetWindowSizeY(pMsg->hWin);
GUI_DispStringHCenterAt("Child window", x / 2, (y / 2) - 12);
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbDemoCallback1(WM_MESSAGE *pMsg)
{
int x, y;
switch (pMsg->MsgId)
{
case WM_PAINT:
GUI_SetBkColor(GUI_GREEN);
GUI_Clear();
GUI_SetColor(GUI_RED);
GUI_SetFont(&GUI_FontComic18B_1);
x = WM_GetWindowSizeX(pMsg->hWin);
y = WM_GetWindowSizeY(pMsg->hWin);
GUI_DispStringHCenterAt("Window 1\nanother Callback", x / 2, (y / 2) - 18);
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbDemoCallback2(WM_MESSAGE *pMsg)
{
int x, y;
switch (pMsg->MsgId)
{
case WM_PAINT:
GUI_SetBkColor(GUI_MAGENTA);
GUI_Clear();
GUI_SetColor(GUI_YELLOW);
GUI_SetFont(&GUI_FontComic18B_1);
x = WM_GetWindowSizeX(pMsg->hWin);
y = WM_GetWindowSizeY(pMsg->hWin);
GUI_DispStringHCenterAt("Window 2\nanother Callback", x / 2, (y / 4) - 18);
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _DemoSetDesktopColor(void)
{
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
_DrawInfoText("WM_SetDesktopColor()");
GUI_Delay(SPEED * 3 / 2);
WM_SetDesktopColor(GUI_BLACK);
GUI_Delay(SPEED / 2);
GUI_SetBkColor(GUI_BLACK);
WM_SetDesktopColor(GUI_INVALID_COLOR); /* 设置桌面窗口颜色 */
}
static void _DemoCreateWindow(void)
{
_cbBkWindowOld = WM_SetCallback(WM_HBKWIN, _cbBkWindow); /* 设置背景桌面的回调函数 */
/* 创建窗口 */
_ChangeInfoText("WM_CreateWindow()");
GUI_Delay(SPEED);
_hWindow1 = WM_CreateWindow(50, 70, 165, 100, WM_CF_SHOW | WM_CF_MEMDEV, _cbWindow1, 0); /* 创建窗口1，使用自动存储设备 */
GUI_Delay(SPEED / 3);
_hWindow2 = WM_CreateWindow(105, 125, 165, 100, WM_CF_SHOW | WM_CF_MEMDEV, _cbWindow2, 0); /* 创建窗口2，使用自动存储设备 */
GUI_Delay(SPEED);
}
static void _DemoCreateWindowAsChild(void)
{
_ChangeInfoText("WM_CreateWindowChild()");
GUI_Delay(SPEED);
_hChild = WM_CreateWindowAsChild(10, 50, 145, 40, _hWindow2, WM_CF_SHOW | WM_CF_MEMDEV, _cbChild, 0); /* 向窗口2创建一个子窗口 */
GUI_Delay(SPEED);
}
static void _DemoInvalidateWindow(void)
{
_ChangeInfoText("WM_InvalidateWindow()");
_WindowColor1 = GUI_BLUE;
_FrameColor1 = GUI_GREEN;
GUI_Delay(SPEED);
/* 使窗口1无效，会重绘窗口，注意窗口颜色的变化 */
WM_InvalidateWindow(_hWindow1);
GUI_Delay(SPEED);
}
static void _DemoBringToTop(void)
{
_ChangeInfoText("WM_BringToTop()");
GUI_Delay(SPEED);
WM_BringToTop(_hWindow1); /* 使窗口1放在其他同属窗口的前面 */
GUI_Delay(SPEED);
}
static void _DemoMoveTo(void)
{
int i;
int tm;
int tDiff;
_ChangeInfoText("WM_MoveTo()");
GUI_Delay(SPEED);
for (i = 1; i < 56; i++)
{
tm = GUI_GetTime();
WM_MoveTo(_hWindow1, 50 + i, 70 + i); /* 移动指定窗口到指定位置 */
WM_MoveTo(_hWindow2, 105 - i, 125 - i);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 1; i < 56; i++)
{
tm = GUI_GetTime();
WM_MoveTo(_hWindow1, 105 - i, 125 - i);
WM_MoveTo(_hWindow2, 50 + i, 70 + i);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
GUI_Delay(SPEED);
}
static void _DemoBringToBottom(void)
{
_ChangeInfoText("WM_BringToBottom()");
GUI_Delay(SPEED);
WM_BringToBottom(_hWindow1); //使窗口1放在其他同属窗口的后面
GUI_Delay(SPEED);
}
static void _DemoMoveWindow(void)
{
int i;
int tm;
int tDiff;
_ChangeInfoText("WM_MoveWindow()");
GUI_Delay(SPEED);
for (i = 0; i < 55; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, 1, 1); /* 移动窗口1 */
WM_MoveWindow(_hWindow2, -1, -1); /* 移动窗口2 */
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 55; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, -1, -1);
WM_MoveWindow(_hWindow2, 1, 1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
GUI_Delay(SPEED);
}
static void _DemoHideShowParent(void)
{
_ChangeInfoText("WM_HideWindow(Parent)");
GUI_Delay(SPEED);
WM_HideWindow(_hWindow2); /* 隐藏窗口2 */
GUI_Delay(SPEED / 3);
WM_HideWindow(_hWindow1); /* 隐藏窗口 */
GUI_Delay(SPEED);
_ChangeInfoText("WM_ShowWindow(Parent)");
GUI_Delay(SPEED);
WM_ShowWindow(_hWindow1); /* 显示窗口1 */
WM_ShowWindow(_hWindow2); /* 示窗口2 */
GUI_Delay(SPEED);
}
static void _DemoHideShowChild(void)
{
_ChangeInfoText("WM_HideWindow(Child)");
GUI_Delay(SPEED);
WM_HideWindow(_hChild); /* 隐藏子窗口 */
GUI_Delay(SPEED);
_ChangeInfoText("WM_ShowWindow(Child)");
GUI_Delay(SPEED);
WM_ShowWindow(_hChild); /* 显示子窗口 */
GUI_Delay(SPEED);
}
static void _DemoClipping(void)
{
int i;
int tm;
int tDiff;
_ChangeInfoText("Demostrating clipping of child");
for (i = 0; i < 25; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hChild, 1, 0);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 25; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hChild, 0, 1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 50; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hChild, -1, 0);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 25; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hChild, 0, -1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 25; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hChild, 1, 0);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
GUI_Delay(SPEED);
}
static void _DemoRedrawing(void)
{
int i;
int tm;
int tDiff;
_ChangeInfoText("Demonstrating redrawing");
GUI_Delay(SPEED);
_LiftUp(40); /*上移40个像素 */
GUI_Delay(SPEED / 3);
_ChangeInfoText("Using a callback for redrawing");
GUI_Delay(SPEED / 3);
for (i = 0; i < 55; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, 1, 1);
WM_MoveWindow(_hWindow2, -1, -1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 55; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, -1, -1);
WM_MoveWindow(_hWindow2, 1, 1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
GUI_Delay(SPEED / 4);
_LiftDown(30);
GUI_Delay(SPEED / 2);
_ChangeInfoText("Without redrawing");
GUI_Delay(SPEED);
_LiftUp(30);
GUI_Delay(SPEED / 4);
WM_SetCallback(WM_HBKWIN, _cbBkWindowOld); /*取消背景窗口的回调函数 */
for (i = 0; i < 55; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, 1, 1);
WM_MoveWindow(_hWindow2, -1, -1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 55; i++)
{
tm = GUI_GetTime();
WM_MoveWindow(_hWindow1, -1, -1);
WM_MoveWindow(_hWindow2, 1, 1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
GUI_Delay(SPEED / 3);
WM_SetCallback(WM_HBKWIN, _cbBkWindow); /* 恢复背景窗口的回调函数 */
_LiftDown(40);
GUI_Delay(SPEED);
}
static void _DemoResizeWindow(void)
{
int i;
int tm;
int tDiff;
_ChangeInfoText("WM_ResizeWindow()");
GUI_Delay(SPEED);
_LiftUp(30);
for (i = 0; i < 20; i++)
{
tm = GUI_GetTime();
WM_ResizeWindow(_hWindow1, 1, 1); /* 窗口1的X,Y轴每次增加1个像素大小 */
WM_ResizeWindow(_hWindow2, -1, -1); /* 窗口2的X,Y轴每次减小一个像素大小 */
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 40; i++)
{
tm = GUI_GetTime();
WM_ResizeWindow(_hWindow1, -1, -1);
WM_ResizeWindow(_hWindow2, 1, 1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
for (i = 0; i < 20; i++)
{
tm = GUI_GetTime();
WM_ResizeWindow(_hWindow1, 1, 1);
WM_ResizeWindow(_hWindow2, -1, -1);
tDiff = 15 - (GUI_GetTime() - tm);
GUI_Delay(tDiff);
}
_LiftDown(30);
GUI_Delay(SPEED);
}
static void _DemoSetCallback(void)
{
_ChangeInfoText("WM_SetCallback()");
WM_SetCallback(_hWindow1, _cbDemoCallback1);
WM_InvalidateWindow(_hWindow1);
GUI_Delay(SPEED / 2);
WM_SetCallback(_hWindow2, _cbDemoCallback2);
WM_InvalidateWindow(_hWindow2);
GUI_Delay(SPEED * 3);
WM_SetCallback(_hWindow1, _cbWindow1);
WM_InvalidateWindow(_hWindow1);
GUI_Delay(SPEED / 2);
WM_SetCallback(_hWindow2, _cbWindow2);
WM_InvalidateWindow(_hWindow2);
GUI_Delay(SPEED);
}
static void _DemoDeleteWindow(void)
{
_ChangeInfoText("WM_DeleteWindow()");
GUI_Delay(SPEED);
WM_DeleteWindow(_hWindow2); /* 删除窗口2*/
GUI_Delay(SPEED / 3);
WM_DeleteWindow(_hWindow1); /* 删除窗口1*/
GUI_Delay(SPEED);
_ChangeInfoText("");
GUI_Delay(SPEED);
/* 恢复窗口颜色和回调函数 */
WM_SetCallback(WM_HBKWIN, _cbBkWindowOld);
_WindowColor1 = GUI_GREEN;
_WindowColor2 = GUI_RED;
}
void emwin_main(void)
{
GUI_SetBkColor(GUI_BLACK);
while (1)
{
_DemoSetDesktopColor();
_DemoCreateWindow();
_DemoCreateWindowAsChild();
_DemoInvalidateWindow();
_DemoBringToTop();
_DemoMoveTo();
_DemoBringToBottom();
_DemoMoveWindow();
_DemoHideShowParent();
_DemoHideShowChild();
_DemoClipping();
_DemoRedrawing();
_DemoResizeWindow();
_DemoSetCallback();
_DemoDeleteWindow();
}
}测试结果：
十一、WM裁剪
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
static void _cbBkWin(WM_MESSAGE *pMsg)
{
switch (pMsg->MsgId)
{
case WM_PAINT:
GUI_SetBkColor(GUI_BLACK);
GUI_Clear();
GUI_SetColor(0x0060FF);
GUI_DispStringAt("PaintCount (Early):", 0, 0);
GUI_DispDecAt(_PaintCount1, 120, 0, 5);
GUI_SetColor(0x00FFC0);
GUI_DispStringAt("PaintCount (Late):", 0, 12);
GUI_DispDecAt(_PaintCount2, 120, 12, 5);
break;
case WM_NOTIFY_PARENT:
if (pMsg->Data.v == WM_NOTIFICATION_RELEASED) /* 按钮被释放时 */
{
if (pMsg->hWinSrc == _hBut1) /* button1被释放 */
{
WM_InvalidateWindow(_hWin1); /* 窗口1失效 */
WM_InvalidateWindow(_hWin2); /* 窗口2失效 */
}
else if (pMsg->hWinSrc == _hBut2) /* button2被释放 */
{
_PaintCount1 = 0;
_PaintCount2 = 0;
WM_InvalidateWindow(pMsg->hWin); /* 主窗口失效 */
}
}
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbTop(WM_MESSAGE *pMsg)
{
switch (pMsg->MsgId)
{
case WM_PAINT:
GUI_SetBkColor(GUI_MAGENTA);
GUI_Clear();
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbFrameWin1(WM_MESSAGE *pMsg)
{
switch (pMsg->MsgId)
{
case WM_PAINT:
GUI_SetBkColor(_aColors[_PaintCount1 % 6]); /* 设置背景颜色 */
GUI_Clear();
GUI_SetColor(0x0060FF);
GUI_FillCircle(25, 25, 15);
GUI_SetColor(GUI_BLACK);
GUI_DrawCircle(25, 25, 15);
_PaintCount1++;
WM_InvalidateWindow(WM_HBKWIN); /* 背景窗口失效 */
break;
default:
WM_DefaultProc(pMsg);
}
}
static void _cbFrameWin2(WM_MESSAGE *pMsg)
{
switch (pMsg->MsgId)
{
case WM_PAINT:
GUI_SetBkColor(_aColors[_PaintCount2 % 6]);
GUI_Clear();
GUI_SetColor(0x00FFC0);
GUI_FillCircle(25, 25, 15);
GUI_SetColor(GUI_BLACK);
GUI_DrawCircle(25, 25, 15);
_PaintCount2++;
WM_InvalidateWindow(WM_HBKWIN);
break;
default:
WM_DefaultProc(pMsg);
}
}
void emwin_main(void)
{
WM_HWIN hWin0;
WM_HWIN hWin1;
WM_HWIN hWin2;
WM_HWIN hFrame1;
WM_HWIN hFrame2;
WM_HWIN hClient1;
WM_HWIN hClient2;
WM_SetCallback(WM_HBKWIN, _cbBkWin);
hFrame1 = FRAMEWIN_CreateEx(10, 30, 140, 140, 0, WM_CF_SHOW, FRAMEWIN_CF_MOVEABLE, 0, "Early Clipping", _cbFrameWin1); /*创建框架窗口1,可移动 */
hFrame2 = FRAMEWIN_CreateEx(170, 30, 140, 140, 0, WM_CF_SHOW, FRAMEWIN_CF_MOVEABLE, 0, "Late Clipping", _cbFrameWin2); /*创建框架窗口2,可移动 */
hClient1 = WM_GetClientWindow(hFrame1); /* 返回框架1的客户端窗口句柄 */
hClient2 = WM_GetClientWindow(hFrame2); /* 返回框架2的客户端窗口句柄 */
_hWin1 = WM_CreateWindowAsChild(0, 0, WM_GetWindowSizeX(hClient1), WM_GetWindowSizeY(hClient1), hClient1, WM_CF_SHOW, _cbFrameWin1, 0);
_hWin2 = WM_CreateWindowAsChild(0, 0, WM_GetWindowSizeX(hClient2), WM_GetWindowSizeY(hClient2), hClient2, WM_CF_SHOW | WM_CF_LATE_CLIP, _cbFrameWin2, 0);
_hBut1 = BUTTON_CreateEx(10, 210, 140, 20, 0, WM_CF_SHOW, 0, 1); /* 创建按钮1 */
_hBut2 = BUTTON_CreateEx(170, 210, 140, 20, 0, WM_CF_SHOW, 0, 2); /* 创建按钮2 */
hWin0 = FRAMEWIN_CreateEx(60, 80, 40, 40, 0, WM_CF_SHOW | WM_CF_STAYONTOP, FRAMEWIN_CF_MOVEABLE, 0, "Top 0", _cbTop);
hWin1 = FRAMEWIN_CreateEx(220, 80, 40, 40, 0, WM_CF_SHOW | WM_CF_STAYONTOP, FRAMEWIN_CF_MOVEABLE, 0, "Top 1", _cbTop);
hWin2 = FRAMEWIN_CreateEx(140, 170, 40, 40, 0, WM_CF_SHOW | WM_CF_STAYONTOP, FRAMEWIN_CF_MOVEABLE, 0, "Top 2", _cbTop);
FRAMEWIN_SetResizeable(hWin0, 1); /* 窗口设置为可缩放 */
FRAMEWIN_SetResizeable(hWin1, 1); /* 窗口设置为可缩放 */
FRAMEWIN_SetResizeable(hWin2, 1); /* 窗口设置为可缩放 */
BUTTON_SetText(_hBut1, "Invalidate"); /* 设置按钮的名字 */
BUTTON_SetText(_hBut2, "Reset counts");
while (1)
{
GUI_Delay(50);
}
}测试结果
十二、GUIBulider使用
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
static void _cbDialog(WM_MESSAGE *pMsg)
{
WM_HWIN hItem;
int NCode;
int Id;
switch (pMsg->MsgId)
{
case WM_INIT_DIALOG: /* Framewin初始化 */
hItem = pMsg->hWin;
FRAMEWIN_SetTitleHeight(hItem, 40);
FRAMEWIN_SetText(hItem, "ALIENTEK BUIBulider");
FRAMEWIN_SetFont(hItem, GUI_FONT_32B_ASCII);
FRAMEWIN_SetTextColor(hItem, 0x000000FF);
FRAMEWIN_SetTextAlign(hItem, GUI_TA_HCENTER | GUI_TA_VCENTER);
/* Edit控件初始化 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_EDIT_0);
EDIT_SetText(hItem, "123");
/* Listview控件初始化 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_LISTVIEW_0);
LISTVIEW_AddColumn(hItem, 30, "Name", GUI_TA_HCENTER | GUI_TA_VCENTER);
LISTVIEW_AddColumn(hItem, 30, "Year", GUI_TA_HCENTER | GUI_TA_VCENTER);
LISTVIEW_AddColumn(hItem, 30, "Num", GUI_TA_HCENTER | GUI_TA_VCENTER);
LISTVIEW_AddRow(hItem, NULL);
LISTVIEW_SetGridVis(hItem, 1);
LISTVIEW_SetFont(hItem, GUI_FONT_20_ASCII);
LISTVIEW_SetItemText(hItem, 0, 0, "ZhangSan");
LISTVIEW_SetAutoScrollH(hItem, 1);
LISTVIEW_SetAutoScrollV(hItem, 1);
LISTVIEW_SetHeaderHeight(hItem, 30);
LISTVIEW_SetItemText(hItem, 1, 0, "26");
LISTVIEW_SetItemText(hItem, 2, 0, "20150328001");
LISTVIEW_SetRowHeight(hItem, 25);
/* Button初始化 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_0);
BUTTON_SetText(hItem, "OK");
BUTTON_SetFont(hItem, GUI_FONT_COMIC24B_1);
/* Button初始化 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_1);
BUTTON_SetText(hItem, "CANCEL");
BUTTON_SetFont(hItem, GUI_FONT_COMIC24B_1);
break;
case WM_NOTIFY_PARENT:
Id = WM_GetId(pMsg->hWinSrc);
NCode = pMsg->Data.v;
switch (Id)
{
case ID_EDIT_0: /* Edit发送通知 */
switch (NCode)
{
case WM_NOTIFICATION_CLICKED: /* 通知被点击 */
/* 执行的功能............... */
break;
case WM_NOTIFICATION_RELEASED: /* 通知被释放 */
/* 执行的功能............... */
break;
case WM_NOTIFICATION_VALUE_CHANGED: /* 值被改变 */
/* 执行的功能............... */
break;
}
break;
case ID_LISTVIEW_0:
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED:
break;
case WM_NOTIFICATION_SEL_CHANGED:
break;
}
break;
case ID_BUTTON_0:
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED:
break;
}
break;
case ID_BUTTON_1:
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED:
break;
}
break;
case ID_SCROLLBAR_0:
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED:
break;
case WM_NOTIFICATION_VALUE_CHANGED:
break;
}
break;
}
break;
default:
WM_DefaultProc(pMsg);
break;
}
}
void emwin_main(void)
{
GUI_CreateDialogBox(_aDialogCreate, GUI_COUNTOF(_aDialogCreate), _cbDialog, WM_HBKWIN, 0, 0);
while(1)
{
GUI_Delay(200);
}
}测试结果：
十三、BUTTON使用
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
beep_init(); /* 初始化BEEP */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
static void _cbDialog(WM_MESSAGE *pMsg)
{
WM_HWIN hItem;
int NCode;
int Id;
switch (pMsg->MsgId)
{
case WM_INIT_DIALOG:
/* 初始化对话框 */
hItem = pMsg->hWin;
FRAMEWIN_SetTitleHeight(hItem, 30);
FRAMEWIN_SetText(hItem, "ALIENTE BUTTON USE");
FRAMEWIN_SetFont(hItem, GUI_FONT_24_ASCII);
FRAMEWIN_SetTextAlign(hItem, GUI_TA_HCENTER | GUI_TA_VCENTER);
FRAMEWIN_SetTextColor(hItem, 0x0000FFFF);
/* 初始化BUTTON0 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_0);
BUTTON_SetFont(hItem, GUI_FONT_24_ASCII);
BUTTON_SetText(hItem, "LED1");
/* 初始化BUTTON1 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_1);
BUTTON_SetText(hItem, "BEEP");
BUTTON_SetFont(hItem, GUI_FONT_24_ASCII);
break;
case WM_NOTIFY_PARENT:
Id = WM_GetId(pMsg->hWinSrc);
NCode = pMsg->Data.v;
switch (Id)
{
case ID_BUTTON_0: /* BUTTON_0的通知代码，控制LED1 */
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED: /* 按钮被按下并释放 */
LED1_TOGGLE(); /* LED1反转 */
break;
}
break;
case ID_BUTTON_1: /* BUTTON_1的通知代码，控制BEEP */
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED:
BEEP_TOGGLE(); /* 蜂鸣器反转 */
break;
}
break;
}
break;
default:
WM_DefaultProc(pMsg);
break;
}
}
WM_HWIN _CreateFramewin(void)
{
WM_HWIN hWin;
hWin = GUI_CreateDialogBox(_aDialogCreate, GUI_COUNTOF(_aDialogCreate), _cbDialog, WM_HBKWIN, 0, 0);
return hWin;
}
void emwin_main(void)
{
_CreateFramewin();
while (1)
{
GUI_Delay(100);
}
}测试结果
十四、BUTTON位图显示
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
beep_init(); /* 初始化BEEP */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
static void _cbDialog(WM_MESSAGE *pMsg)
{
WM_HWIN hItem;
int NCode;
int Id;
static uint8_t ledflag = 0;
static uint8_t beepflag = 0;
switch (pMsg->MsgId)
{
case WM_PAINT:
GUI_SetBkColor(GUI_WHITE);
GUI_Clear();
break;
case WM_INIT_DIALOG:
/* 初始化对话框 */
hItem = pMsg->hWin;
FRAMEWIN_SetTitleHeight(hItem, 30);
FRAMEWIN_SetText(hItem, "ALIENTEK BUTTONBMP DISP");
FRAMEWIN_SetFont(hItem, GUI_FONT_24_ASCII);
FRAMEWIN_SetTextAlign(hItem, GUI_TA_HCENTER | GUI_TA_VCENTER);
FRAMEWIN_SetTextColor(hItem, 0x0000FFFF);
/* 初始化BUTTON0 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_0);
BUTTON_SetBitmapEx(hItem, 0, &buttonbmp_tab[0], 0, 0);
BUTTON_SetText(hItem, "");
/* 初始化BUTTON1 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_1);
BUTTON_SetBitmapEx(hItem, 0, &buttonbmp_tab[0], 0, 0);
BUTTON_SetText(hItem, "");
/* 初始化TEXT0 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_TEXT_0);
TEXT_SetTextAlign(hItem, GUI_TA_HCENTER | GUI_TA_VCENTER);
TEXT_SetFont(hItem, GUI_FONT_32_ASCII);
TEXT_SetText(hItem, "LED1:");
/* 初始化TEXT1 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_TEXT_1);
TEXT_SetTextAlign(hItem, GUI_TA_HCENTER | GUI_TA_VCENTER);
TEXT_SetFont(hItem, GUI_FONT_32_ASCII);
TEXT_SetText(hItem, "BEEP:");
break;
case WM_NOTIFY_PARENT:
Id = WM_GetId(pMsg->hWinSrc);
NCode = pMsg->Data.v;
switch (Id)
{
case ID_BUTTON_0: /* BUTTON_0的通知代码，控制LED1 */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_0);
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED: /* 按钮被按下并释放 */
LED1_TOGGLE(); /* LED1反转 */
ledflag = ~ledflag;
BUTTON_SetBitmapEx(hItem, 0, ledflag ? &buttonbmp_tab[1] : &buttonbmp_tab[0], 0, 0);
break;
}
break;
case ID_BUTTON_1: /* BUTTON_1的通知代码，控制BEEP */
hItem = WM_GetDialogItem(pMsg->hWin, ID_BUTTON_1);
switch (NCode)
{
case WM_NOTIFICATION_CLICKED:
break;
case WM_NOTIFICATION_RELEASED:
BEEP_TOGGLE(); /* 蜂鸣器反转 */
beepflag = ~beepflag;
BUTTON_SetBitmapEx(hItem, 0, beepflag ? &buttonbmp_tab[1] : &buttonbmp_tab[0], 0, 0);
break;
}
break;
}
break;
default:
WM_DefaultProc(pMsg);
break;
}
}
WM_HWIN _CreateFramewin(void)
{
WM_HWIN hWin;
buttonbmp_tab[0] = bmBUTTONOFF;
buttonbmp_tab[1] = bmBUTTONON;
hWin = GUI_CreateDialogBox(_aDialogCreate, GUI_COUNTOF(_aDialogCreate), _cbDialog, WM_HBKWIN, 0, 0);
return hWin;
}
void emwin_main(void)
{
_CreateFramewin();
while (1)
{
GUI_Delay(100);
}
}测试结果
十五、CHECKBOX小工具
主函数
int main(void)
{
HAL_Init(); /* 初始化HAL库 */
sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
delay_init(168); /* 延时初始化 */
usart_init(115200); /* 串口初始化为115200 */
usmart_dev.init(84); /* 初始化USMART */
led_init(); /* 初始化LED */
lcd_init(); /* 初始化LCD */
key_init(); /* 初始化按键 */
tp_dev.init(); /* 触摸屏初始化 */
my_mem_init(SRAMIN); /* 初始化内部SRAM内存池 */
uc_os3_demo(); /* 创建任务，并执行emwin例程 */
while (1);
}
void uc_os3_demo(void)
{
OS_ERR err;
/* 关闭所有中断 */
CPU_IntDis();
/* 初始化uC/OS-III */
OSInit(&err);
/* 创建开始任务 */
OSTaskCreate((OS_TCB * )&StartTaskTCB, /* 任务控制块 */
(CPU_CHAR * )"start task", /* 任务名字 */
(OS_TASK_PTR )start_task, /* 任务函数 */
(void * )0, /* 传递给任务函数的参数 */
(OS_PRIO )START_TASK_PRIO, /* 任务优先级 */
(CPU_STK * )&START_TASK_STK[0], /* 任务堆栈基地址 */
(CPU_STK_SIZE )START_STK_SIZE / 10, /* 任务堆栈深度限位 */
(CPU_STK_SIZE )START_STK_SIZE, /* 任务堆栈大小 */
(OS_MSG_QTY )0, /* 任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息 */
(OS_TICK )0, /* 当使能时间片轮转时的时间片长度，为0时为默认长度 */
(void * )0, /* 用户补充的存储区 */
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR, /* 任务选项 */
(OS_ERR * )&err); /* 存放该函数错误时的返回值 */
/* 开始任务调度 */
OSStart(&err);
for (;;)
{
/* 不会进入这里 */
}
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_INT32U cnts;
p_arg = p_arg;
/* 初始化CPU库 */
CPU_Init();
/* 根据配置的节拍频率配置SysTick */
cnts = (CPU_INT32U)(HAL_RCC_GetSysClockFreq() / OSCfg_TickRate_Hz);
OS_CPU_SysTickInit(cnts);
/* 开启时间片调度，时间片设为默认值 */
OSSchedRoundRobinCfg(OS_TRUE, 0, &err);
__HAL_RCC_CRC_CLK_ENABLE(); /* 使能CRC时钟 */
GUI_Init(); /* emWin 初始化 */
/* 创建User任务 */
OSTaskCreate((OS_TCB * )&User_TaskTCB,
(CPU_CHAR * )"User task",
(OS_TASK_PTR )user_task,
(void * )0,
(OS_PRIO )USER_TASK_PRIO,
(CPU_STK * )&USER_TASK_STK,
(CPU_STK_SIZE)USER_STK_SIZE / 10,
(CPU_STK_SIZE)USER_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Led0任务 */
OSTaskCreate((OS_TCB * )&Led0_TaskTCB,
(CPU_CHAR * )"led0_task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK,
(CPU_STK_SIZE)LED0_STK_SIZE / 10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建Touch任务 */
OSTaskCreate((OS_TCB * )&Touch_TaskTCB,
(CPU_CHAR * )"Touch task",
(OS_TASK_PTR )touch_task,
(void * )0,
(OS_PRIO )TOUCH_TASK_PRIO,
(CPU_STK * )&TOUCH_TASK_STK,
(CPU_STK_SIZE)TOUCH_STK_SIZE / 10,
(CPU_STK_SIZE)TOUCH_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 删除Start Task */
OSTaskDel((OS_TCB *)0, &err);
}
void user_task(void *p_arg)
{
OS_ERR err;
p_arg = p_arg;
emwin_main(); /* 执行emwin例程 */
while(1)
{
OSTimeDly(5, OS_OPT_TIME_DLY, &err); /* 延时5ticks */
}
}
static void _cbCallback(WM_MESSAGE *pMsg)
{
int i;
int NCode, Id;
WM_HWIN hDlg, hItem;
hDlg = pMsg->hWin;
switch (pMsg->MsgId)
{
case WM_INIT_DIALOG:
hItem = WM_GetDialogItem(hDlg, GUI_ID_CHECK0); /* 获取CHECKBOX的句柄 */
for (i = 0; i < 8; i++)
{
int Index = i % 4;
hItem = WM_GetDialogItem(hDlg, GUI_ID_CHECK0 + i); /* 获取CHECKBOX的句柄 */
CHECKBOX_SetText(hItem, _apLabel[Index]);
switch (Index)
{
case 1:
CHECKBOX_SetNumStates(hItem, 3);
CHECKBOX_SetImage(hItem, &_abmBar[0], CHECKBOX_BI_INACTIV_3STATE);
CHECKBOX_SetImage(hItem, &_abmBar[1], CHECKBOX_BI_ACTIV_3STATE);
CHECKBOX_SetState(hItem, 2);
break;
case 2:
CHECKBOX_SetState(hItem, 1);
CHECKBOX_SetImage(hItem, &_abmXL[0], CHECKBOX_BI_INACTIV_CHECKED);
CHECKBOX_SetImage(hItem, &_abmXL[1], CHECKBOX_BI_ACTIV_CHECKED);
CHECKBOX_SetFont(hItem, &GUI_FontComic18B_ASCII);
break;
case 3:
CHECKBOX_SetState(hItem, 1);
CHECKBOX_SetImage(hItem, &_abmXXL[0], CHECKBOX_BI_INACTIV_CHECKED);
CHECKBOX_SetImage(hItem, &_abmXXL[1], CHECKBOX_BI_ACTIV_CHECKED);
CHECKBOX_SetFont(hItem, &GUI_FontComic24B_ASCII);
break;
}
if (i >= 4)
{
WM_DisableWindow(hItem);/* 能对话框右边的所有CHECK小工具 */
}
}
break;
case WM_NOTIFY_PARENT:
Id = WM_GetId(pMsg->hWinSrc); /* 小工具ID */
NCode = pMsg->Data.v; /* 通知代码 */
switch (NCode)
{
case WM_NOTIFICATION_RELEASED:
if (Id == GUI_ID_OK)
{
GUI_EndDialog(hDlg, 0); /* 关闭对话框 */
}
if (Id == GUI_ID_CANCEL)
{
GUI_EndDialog(hDlg, 1); /* 关闭对话框 */
}
break;
}
break;
default:
WM_DefaultProc(pMsg);
}
}
void emwin_main(void)
{
GUI_CURSOR_Show();
#if GUI_SUPPORT_MEMDEV
WM_SetCreateFlags(WM_CF_MEMDEV);
#endif
WM_SetDesktopColor(GUI_BLACK);
while (1)
{
GUI_ExecDialogBox(_aDialogCreate, GUI_COUNTOF(_aDialogCreate), &_cbCallback, 0, 0, 0);
GUI_Delay(500);
}
}测试结果：
