minigui触摸屏校准及界面程序

最新推荐文章于 2021-05-03 10:35:30 发布
最新推荐文章于 2021-05-03 10:35:30 发布
阅读量1.9k 收藏
点赞数
分类专栏： MiniGUI学习 文章标签： minigui校准
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BiYunXuanLv/article/details/54570935
版权

自己修改minigui库后的文件，可以直接用于800x600显示器的5点校准

程序1（修改后dummy.c文件）
/*
** Id:dummy.c73352007−08−1603:38:27Zxgwang
**
** dummy.c: The dummy IAL engine.
**
** Copyright (C) 2003 ~ 2007 Feynman Software.
** Copyright (C) 2001 ~ 2002 Wei Yongming.
**
** Created by Wei Yongming, 2001/09/13
*/

include

include

include

include “common.h”

ifdef _DUMMY_IAL

include

include

include

include

include

include

include

include

include

include “ial.h”

include “dummy.h”

static struct tsdev *ts = NULL;
static int mousex = 0;
static int mousey = 0;
static int button = 0;

static int kbfd = 0;
static char keystate[128] = { 0 };
static void getxy(int focus);

/************** Low Level Input Operations ************/
static int keyboard_update(void)
{
struct input_event input;
//printf(“keyboard update\n”);
if (kbfd > 0)
{
if (read(kbfd, &input, sizeof(input)) == sizeof(input))
{
memset(keystate, 0, sizeof(keystate));
if(input.type == EV_KEY)
{
if ((input.code >= 0) && (input.code < sizeof(keystate)/sizeof(keystate[0])))
{
if (input.value > 0)
{
keystate[input.code] = 1;
//printf(“keyboard_update, key down, input.code = %d\n”, input.code);
}
else
{
//printf(“keyboard_update, key up, input.code = %d\n”, input.code);
}
}
return 128;
}
}
} 

return 0;

}

static char* keyboard_getstate()
{
return keystate;
}

/*
* Mouse operations – Event
*/
static int mouse_update(void)
{
if(!calibrate_flag)
{
struct ts_sample samp;
int ret = ts_read(ts, &samp, 1);
if (ret == 1) {
if (samp.pressure > 0) {
mousex = samp.x;
mousey = samp.y;
}

        button = (samp.pressure > 0) ? IAL_MOUSE_LEFTBUTTON : 0;

// printf(“tslibial: button = %d, mousex = %d, mousey = %d\n”, button, mousex, mousey);
return 1;
}else{
return 0;
}
}
else
{
if(button)
{
button = 0;
}
else
{
if(cal_focus < 5)
{
printf(“cal_focus = %d\n”, cal_focus);
getxy(cal_focus);
cal_focus ++;
}
}
printf(“tslibial: button = %d, mousex = %d, mousey = %d\n”, button, mousex, mousey);
return 1;
}
}

static void mouse_getxy (int* x, int* y)
{
*x = mousex;
*y = mousey;
}

static int mouse_getbutton(void)
{
return button;
}

static int wait_event (int which, fd_set *in, fd_set *out, fd_set *except,
struct timeval *timeout)
{
struct timeval to = { 0, 10000 };

if (mouse_update() > 0)
{
    return IAL_MOUSEEVENT;
}

fd_set input_set;


FD_ZERO(&input_set);
FD_SET(kbfd, &input_set);

if(select(kbfd + 1, &input_set, NULL, NULL, &to) > 0)
{
    if(FD_ISSET(kbfd, &input_set))
    {
        return IAL_KEYEVENT;
    }
}

return -1;

}

BOOL InitDummyInput (INPUT* input, const char* mdev, const char* mtype)
{
const char* tsdevice;
printf(“InitTsLibInput\n”);
if ((tsdevice = getenv (“TSLIB_TSDEVICE”)) == NULL) {
tsdevice = mdev;
}

printf("tsdevice = %s\n", tsdevice);

if (tsdevice == NULL) {
    _MG_PRINTF ("IAL>TSLib: Please specify the ts device\n");
    return FALSE;
}

ts = ts_open (tsdevice, 0);

if (!ts) {
    _MG_PRINTF ("IAL>TSLib: can not open ts device\n");
    return FALSE;
}

if (ts_config (ts)) {
    _MG_PRINTF ("IAL>TSLib: can not config ts device\n");
    return FALSE;
}


input->update_mouse = mouse_update;
input->get_mouse_xy = mouse_getxy;
input->set_mouse_xy = NULL;
input->get_mouse_button = mouse_getbutton;
input->set_mouse_range = NULL;

input->wait_event = wait_event;

kbfd = open("/dev/input/event0", O_RDONLY | O_NONBLOCK);
printf("kbfd = %d\n", kbfd);
input->update_keyboard = keyboard_update;
input->get_keyboard_state = keyboard_getstate;
input->suspend_keyboard = NULL;
input->resume_keyboard = NULL;
input->set_leds = NULL;
return TRUE;

}

void TermDummyInput (void)
{
if (ts) {
ts_close(ts);
ts = NULL;
}

if (kbfd > 0)
{
    close(kbfd);
}

}

static int sort_by_x(const void* a, const void *b)
{
return (((struct ts_sample )a)->x - ((struct ts_sample )b)->x);
}

static int sort_by_y(const void* a, const void *b)
{
return (((struct ts_sample )a)->y - ((struct ts_sample )b)->y);
}

static void getxy(int focus)
{
static char tmp = -1;
if (tmp != focus)
{
mousex = cal.xfb[focus];
mousey = cal.yfb[focus];
tmp = focus;
button = IAL_MOUSE_LEFTBUTTON;
}

define MAX_SAMPLES 128

struct ts_sample samp[MAX_SAMPLES];
int index, middle;

do
{
    while (ts_read_raw(ts, &samp[0], 1) < 0)
    {
        continue;
    }
}
while (samp[0].pressure == 0);

/* Now collect up to MAX_SAMPLES touches into the samp array. */


index = 0;
do
{
    if (index < MAX_SAMPLES-1)
        index++;
    while (ts_read_raw(ts, &samp[index], 1) <= 0)
    {
        continue;
    }
}
while (samp[index].pressure > 0);
printf("Took %d samples...\n",index);
/*
 * At this point, we have samples in indices zero to (index-1)
 * which means that we have (index) number of samples.  We want
 * to calculate the median of the samples so that wild outliers
 * don't skew the result.  First off, let's assume that arrays
 * are one-based instead of zero-based.  If this were the case
 * and index was odd, we would need sample number ((index+1)/2)
 * of a sorted array; if index was even, we would need the
 * average of sample number (index/2) and sample number
 * ((index/2)+1).  To turn this into something useful for the
 * real world, we just need to subtract one off of the sample
 * numbers.  So for when index is odd, we need sample number
 * (((index+1)/2)-1).  Due to integer division truncation, we
 * can simplify this to just (index/2).  When index is even, we
 * need the average of sample number ((index/2)-1) and sample
 * number (index/2).  Calculate (index/2) now and we'll handle
 * the even odd stuff after we sort.
 */
middle = index/2;
if (&cal.x[focus])
{
    qsort(samp, index, sizeof(struct ts_sample), sort_by_x);
    if (index & 1)
        cal.x[focus] = samp[middle].x;
    else
        cal.x[focus] = (samp[middle-1].x + samp[middle].x) / 2;
}
if (&cal.y[focus])
{
    qsort(samp, index, sizeof(struct ts_sample), sort_by_y);
    if (index & 1)
        cal.y[focus] = samp[middle].y;
    else
        cal.y[focus] = (samp[middle-1].y + samp[middle].y) / 2;
}

}

static int calibration_perform(CALIBRATE *cal)
{
int j;
float n, x, y, x2, y2, xy, z, zx, zy;
float det, a, b, c, e, f, i;
float scaling = 65536.0;
// Get sums for matrix
n = x = y = x2 = y2 = xy = 0;
for(j=0; j<5; j++)
{
n += 1.0;
x += (float)cal->x[j];
y += (float)cal->y[j];
x2 += (float)(cal->x[j]*cal->x[j]);
y2 += (float)(cal->y[j]*cal->y[j]);
xy += (float)(cal->x[j]*cal->y[j]);
}

// Get determinant of matrix – check if determinant is too small
det = n*(x2*y2 - xy*xy) + x*(xy*y - x*y2) + y*(x*xy - y*x2);
if(det < 0.1 && det > -0.1)
{
printf(“ts_calibrate: determinant is too small – %f\n”,det);
return 0;
}

// Get elements of inverse matrix
a = (x2*y2 - xy*xy)/det;
b = (xy*y - x*y2)/det;
c = (x*xy - y*x2)/det;
e = (n*y2 - y*y)/det;
f = (x*y - n*xy)/det;
i = (n*x2 - x*x)/det;

// Get sums for x calibration
z = zx = zy = 0;
for(j=0; j<5; j++)
{
z += (float)cal->xfb[j];
zx += (float)(cal->xfb[j]*cal->x[j]);
zy += (float)(cal->xfb[j]*cal->y[j]);
}

// Now multiply out to get the calibration for framebuffer x coord
cal->a[0] = (int)((a*z + b*zx + c*zy)*(scaling));
cal->a[1] = (int)((b*z + e*zx + f*zy)*(scaling));
cal->a[2] = (int)((c*z + f*zx + i*zy)*(scaling));

printf("%f %f %f\n",(a*z + b*zx + c*zy),
       (b*z + e*zx + f*zy),
       (c*z + f*zx + i*zy));

// Get sums for y calibration
z = zx = zy = 0;
for(j=0; j<5; j++)
{
z += (float)cal->yfb[j];
zx += (float)(cal->yfb[j]*cal->x[j]);
zy += (float)(cal->yfb[j]*cal->y[j]);
}

// Now multiply out to get the calibration for framebuffer y coord
cal->a[3] = (int)((a*z + b*zx + c*zy)*(scaling));
cal->a[4] = (int)((b*z + e*zx + f*zy)*(scaling));
cal->a[5] = (int)((c*z + f*zx + i*zy)*(scaling));

printf("%f %f %f\n",(a*z + b*zx + c*zy),
       (b*z + e*zx + f*zy),
       (c*z + f*zx + i*zy));

// If we got here, we’re OK, so assign scaling to a[6] and return
cal->a[6] = (int)scaling;
return 1;
}

/*
* save pointercal file
* 2013/11/06
*/
int calibrate_save ()
{
char *calfile = NULL;
int cal_fd;
char cal_buffer[256];
int i;
calibration_perform(&cal);
printf (“Calibration constants: “);
for (i = 0; i < 7; i++) printf(“%d “, cal.a[i]);
printf(“\n”);
if ((calfile = getenv(“TSLIB_CALIBFILE”)) != NULL)
{
cal_fd = open (calfile, O_CREAT | O_RDWR);
}
else
{
cal_fd = open (“/etc/pointercal”, O_CREAT | O_RDWR);
}

sprintf (cal_buffer,"%d %d %d %d %d %d %d",
         cal.a[1], cal.a[2], cal.a[0],
         cal.a[4], cal.a[5], cal.a[3], cal.a[6]);
write (cal_fd, cal_buffer, strlen (cal_buffer) + 1);
sync ();
close (cal_fd);

ts_end ();
ts_init (1);

return TRUE;

}

void ts_end(void)
{
if (ts) {
ts_close(ts);
ts = NULL;
}
}

void ts_create(void)
{
char pcalbuf[200];
int index;
char *tokptr;
char *calfile = getenv(“TSLIB_CALIBFILE”);
if (calfile == NULL)
{
calfile = “/etc/pointercal”;
}
int pcal_fd = open(calfile, O_RDONLY);
if(pcal_fd < 0)
{
printf(“Error: open calibrate file\n”);
}
else
{
read(pcal_fd, pcalbuf, 200);
cal.a[0] = atoi(strtok(pcalbuf, ” “));
index = 1;
while(index < 7)
{
tokptr = strtok(NULL,” “);
if(*tokptr!=’\0’)
{
cal.a[index] = atoi(tokptr);
index++;
}
}
close(pcal_fd);
}
cal.xfb[0] = 50;
cal.xfb[1] = 750;
cal.xfb[2] = 750;
cal.xfb[3] = 50;
cal.xfb[4] = 400;
cal.yfb[0] = 50;
cal.yfb[1] = 50;
cal.yfb[2] = 550;
cal.yfb[3] = 550;
cal.yfb[4] = 300;
}

int ts_init(int nonblock)
{
const char* tsdevice;
printf(“InitTsLibInput\n”);
if ((tsdevice = getenv (“TSLIB_TSDEVICE”)) == NULL) {
tsdevice = “/dev/touchscreen-1wire”;
}

printf("tsdevice = %s\n", tsdevice);

if (tsdevice == NULL) {
    _MG_PRINTF ("IAL>TSLib: Please specify the ts device\n");
    return FALSE;
}

ts = ts_open (tsdevice, nonblock);

if (!ts) {
    _MG_PRINTF ("IAL>TSLib: can not open ts device\n");
    return FALSE;
}

if (ts_config (ts)) {
    _MG_PRINTF ("IAL>TSLib: can not config ts device\n");
    return FALSE;
}

if(nonblock)
{
    __mg_cur_input->update_mouse = mouse_update;
    __mg_cur_input->get_mouse_xy = mouse_getxy;
    __mg_cur_input->set_mouse_xy = NULL;
    __mg_cur_input->get_mouse_button = mouse_getbutton;
    __mg_cur_input->set_mouse_range = NULL;

    __mg_cur_input->wait_event = wait_event;
}
cal_focus = 0;

}

void SetCalFlag(char flag)
{
calibrate_flag = flag;
}

endif /* _DUMMY_IAL */

程序2（界面程序）：

include

include

include

include

include

include

include

include

include “resource.h”

include “func.h”

include “lang.h”

include “com.h”

include “tscal.h”

extern void ts_end(void);
extern void ts_create(void);
extern int ts_init(int nonblock);
extern int calibrate_save ();
extern void SetCalFlag(char flag);
/*
*
*/
static int TscalWinProc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
int fb[5][2] = {
{50, 50},
{750, 50},
{750, 550},
{50, 550},
{400, 300}
};
switch(message)
{
case MSG_CREATE:
{
ts_create();
ts_end();
ts_init(0);
SetCalFlag(1);
}
break;
case MSG_PAINT:
{
HDC hdc = GetClientDC(hWnd);
RECT rect;
GetClientRect(hWnd, &rect);

        SetBkMode(hdc, BM_TRANSPARENT);
        SetTextColor(hdc, COLOR_HQ_YELLOW(hdc));

        rect.left += 300;
        rect.right -= 300;
        rect.top = 200;
        rect.bottom = rect.top + 30;
        DrawText(hdc, GetWindowCaption(hWnd), -1, &rect, DT_CENTER
                | DT_VCENTER | DT_SINGLELINE);

        WND_EXTRA_DATA data;
        data.value = GetWindowAdditionalData(hWnd);
        rect.left = fb[data.pwnd_tscal->index][0] - 10;
        rect.right = rect.left + 20;
        rect.top = fb[data.pwnd_tscal->index][1] - 10;
        rect.bottom = rect.top + 20;
        DrawCross(hdc, &rect);

        ReleaseDC(hdc);
    }
    break;
case MSG_CLOSE:
    {
        DestroyMainWindow(hWnd);
        MainWindowCleanup(hWnd);
        ShowCursor(SW_SHOW);
    }
    return 0;
case MSG_DESTROY:
    {
        ShowWindow(hWnd, SW_HIDE);
        DestroyAllControls (hWnd);
    }
    break;
case MSG_ERASEBKGND:
    {
        HDC hdc = GetClientDC(hWnd);
        RECT rect;
        if(lParam)
        {
            memcpy(&rect, (RECT*) lParam, sizeof(RECT));
        }
        else
        {
            GetClientRect(hWnd, &rect);
        }
        int width = GET_RECT_WIDTH(rect);
        int height = GET_RECT_HEIGHT(rect);
        SetBrushColor(hdc, COLOR_HQ_BLACK(hdc));
        FillBox(hdc, rect.left, rect.top, width, height);
        ReleaseDC(hdc);
    }
    return 0;
case MSG_LBUTTONDOWN:
    {
        WND_EXTRA_DATA data;
        data.value = GetWindowAdditionalData(hWnd);
        int cal_focus = data.pwnd_tscal->index;
        printf("focus = %d\n", cal_focus);

        if(data.pwnd_tscal->index > 3)
        {
            SetCalFlag(0);
            calibrate_save();
            PostMessage(hWnd, MSG_CLOSE, 0, 0);
        }
        else
        {
            RECT rect;
            rect.left = fb[data.pwnd_tscal->index][0] - 10;
            rect.right = rect.left + 20;
            rect.top = fb[data.pwnd_tscal->index][1] - 10;
            rect.bottom = rect.top + 20;
            InvalidateRect(hWnd, &rect, TRUE);
            ++data.pwnd_tscal->index;
            rect.left = fb[data.pwnd_tscal->index][0] - 10;
            rect.right = rect.left + 20;
            rect.top = fb[data.pwnd_tscal->index][1] - 10;
            rect.bottom = rect.top + 20;
            InvalidateRect(hWnd, &rect, TRUE);
        }
    }
    break;
}
return DefaultMainWinProc(hWnd, message, wParam, lParam);

}
/*
*
*/
HWND CreateTscalWindow(HWND hHosting)
{
MAINWINCREATE CreateInfo;
CreateInfo.dwStyle = WS_VISIBLE;
CreateInfo.dwExStyle = WS_EX_NONE;
CreateInfo.spCaption = GetString(480);
CreateInfo.hMenu = 0;
CreateInfo.hCursor = GetSystemCursor(0);
CreateInfo.hIcon = 0;
CreateInfo.MainWindowProc = TscalWinProc;
CreateInfo.lx = 0;
CreateInfo.ty = 0;
CreateInfo.rx = CX_SCREEN;
CreateInfo.by = CY_SCREEN;
CreateInfo.iBkColor = COLOR_lightwhite;
CreateInfo.dwAddData = (int)calloc(1, sizeof(WND_TSCAL));
CreateInfo.hHosting = hHosting;
HWND hWnd = CreateMainWindow(&CreateInfo);
if(hWnd != HWND_INVALID)
{
ShowCursor(SW_HIDE);
ShowWindow(hWnd, SW_SHOWNORMAL);
}
return hWnd;
}

碧云旋律
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用tslib为MiniGUI提供触摸屏IAL引擎.rar
09-24
用tslib为MiniGUI提供触摸屏IAL引擎,描述了在linux下移植2410的MiniGui的触摸屏的IAL层。
【MiniGUI】文字颜色实现透明度变化
最新发布
他山烈石
08-22 260
解决文字颜色无法变换透明度的问题
minigui 控件处理细节
weixin_30695195的博客
06-08 610
1,控件的隐藏 ShowWindow( GetDlgItem( hwnd, IDC_PROMPT ), SW_HIDE ); 2、控件之间切换 （ 1 ） 使用WS_EX_TOPMOST风格，然后用Tab键 。 （ 2 ） 在MSG_KEYDOWN中截取消息，然后用SetFocusChild函数 。 3、去掉对话框上的关闭按扭 用 WS_EX_NOCLOSEBOX 风格 4、...
minigui 处理细节
hollyhock13的专栏
07-06 4203
<br />minigui 控件处理细节(2023-05-00 00:00:00)转载标签：杂谈分类：minigui来源：(http://blog.sina.com.cn/s/blog_684a74300100j2fx.html) - minigui 控件处理细节_玻璃心_新浪博客<br /> <br />1,控件的隐藏   ShowWindow( GetDlgItem( hwnd, IDC_PROMPT ), SW_HIDE );<br /> <br />2、控件之间切换<br />（ 1 ） 使
minigui常用界面美化方法，及常用函数使用
panchunliang420的博客
10-20 6206
1.获得子窗体的文字内容 char buff[100]; HWND parent = GetParent(hwnd);   //通过子控件句柄获得父窗体句柄 SendDlgItemMessage(parent,IDC_STRING,MSG_GETTEXT,99,(LPARAM)buffer); IDC_STRING为字窗体id值，MSG_GETTEXT为获得文本的消息，99为最大接收字符串
在场景中输出文字--SetTextColor(),SetBkMode(),TextOut()的使用
eric1031的专栏
01-24 2717
一个在场景中输出文字的例子：HDC MemDC;  //建立一个HDC的对象。SetTextColor(MemDC,RGB(255,255,255));  //把MemDC场景中的文字颜色设定为白色。 SetBkMode(MemDC,TRANSPARENT);  //把MemDC场景中的文字背景变为透明。TextOut(MemDC,150,100,cc,lstrlen(cc));
MiniGUI更换键盘皮肤
逐梦的博客
01-15 1985
前言 MiniGUI原来的键盘GUI已经有点不符合现在的需求，所以需要定制一套皮肤，根据我定制皮肤的过程，写一遍流程文档，做一下笔记，为以后再定制皮肤提供参考，先看一下定制好的皮肤 录制的色彩有点失真，看一下截图 1. 皮肤资源位置 在libmgi-2.0.4/src/softkeyboard/softkeyboard/分辨率，目录下有一些图片资源，里面是图片转为十六进制的c文件，总共需要替换...
miniGUI 之配置控件字体和颜色
打不死的小五
04-25 1422
miniGUI 之配置控件字体和颜色， 以静态框为例
minigui 自定义按键
livesflying的博客
01-16 2936
本类按键是在静态框基础上增加了MSG_MOUSEMOVEIN（鼠标移入和移出窗口）和MSG_LBUTTONUP（鼠标在窗口松手）两个消息，通过发送NotifyParent消息给控件实现自定义控件消息，类似于静态框的超类。同样可以修改源码调用源码API将其他消息交给原控件完成，实现控件的超类。
MiniGUI——使用 GDI 函数
在不断学习中。。。
09-04 5421
简介： 本文讲述 MiniGUI 中 GDI 函数及其使用。主要包括：设备上下文的概念、获取和释放；矩形操作和区域操作；基本绘图函数；位图操作函数；逻辑字体操作函数等。
论文研究-基于MiniGUI的触摸屏校正的研究与应用 .pdf
08-16
基于MiniGUI的触摸屏校正的研究与应用，吴帆，沈维聪，随着嵌入式技术的发展，嵌入式系统的应用越来越广泛，对人机交互界面的要求越来越高, 触摸屏作为一种最新的输入设备，便于用户进�
Minigui学习--DC
hehongjihhh的专栏
09-02 1351
1.相关函数： MG_EXPORT HDC GUIAPI GetDC (HWND hwnd); //gets a window DC of the specified \a hwnd, and returns  the handle to the DC. MiniGUI will try to return an unused DC from the internal DC pool, rath
setTextColor设置颜色失效
梁超杰
08-13 2775
这个问题出在: tvText.setTextColor(R.color.***) 这里的int 值不是资源id而是一个十六进制的值 改成下面即可 tvText.setTextColor(ContextCompat.getColor(this,R.color.colorAccent)); ...
【转】minigui 1.6.10 + tslib 触摸屏较正方案
天下对手教会少林武僧
09-02 670
说明：因为最近做PDA，要实现摄像头功能，而我的开发板mini2440，只有一个USB，而我的摄像头是USB的，鼠标没办法用了，只能用触摸笔，而触摸坐标非常不准，首先想到了qt下用的tslib，网上找了一下，还真有minigui+tslib的触摸屏较正方案。经过几天的实验，我在V1.6.0上用tslib加SMDK2410实现了触摸屏较正，也在V1.6.10上用tslib+dummy作为ial实现了...
MiniGUI移植s3c2440（二）IAL 触摸屏
叶落寒
04-01 5564
1解决昨天的错误：昨天晚上安装了库文件和资源文件，最后运行demo的例子时出现了错误：[root@avantech same]$ ./sameNEWGAL: bad video mode parameter: 320*240-16bpp.InitGUI: Reading configuration failure! 最后去minigui的论坛上问了下斑竹，原来是配置选项错了，应
minigui增加tslib触摸屏响应
zcg1041的专栏
05-16 2674
1、修改minigui库中IAL的输入引擎，增加对触摸屏的操作         定义： static struct tsdev *ts;          打开：              ts = ts_open ("/dev/input/event0", 0);              ts_config(ts);          关闭：               ts_cl
嵌入式linux触摸屏校正命令,基于嵌入式Linux和MiniGUI的通用触摸屏校准程序
weixin_42128315的博客
05-03 585
本文介绍的正是笔者在制作实际的嵌入式Linux数控机床人机接口过程中，提出的一套基于嵌入式Linux和MiniGUI的通用触摸屏校准程序设计方案。笔者基于的ARM9内核，使用，640×480的触摸屏，嵌入式Linux内核 2.4.20和MiniGUI1.3.0，Lite版本，设计了一套简单可行的方案，可以方便地实现触摸屏的校准。在开始校正触摸屏的坐标前，首先要修改 MiniGUI.cfg文件使其适...
嵌入式GUI详解：MiniGUI程序设计
"该资料是关于MiniGUI程序设计的PDF文档，由大连东软信息学院嵌入式系统导论课程组编写，主要介绍了嵌入式GUI的基本概念，特别是MiniGUI的详细内容，包括编译、安装、程序框架以及编程基础。文档中提到了嵌入式GUI的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值