嵌入式实验报告触摸屏驱动实验.docx

资源描述

嵌入式实验报告触摸屏驱动实验.docx

《嵌入式实验报告触摸屏驱动实验.docx》由会员分享，可在线阅读，更多相关《嵌入式实验报告触摸屏驱动实验.docx（30页珍藏版）》请在冰点文库上搜索。

嵌入式实验报告触摸屏驱动实验.docx

嵌入式实验报告触摸屏驱动实验

武汉大学计算机学院

嵌入式系统设计

实验报告

题目：

触摸屏驱动实验

成员：

一、实验题目

在现有ARM平台上实现触摸屏功能。

编制触摸屏驱动，设计一个简单的俄罗斯方块的小游戏，通过触摸屏点击触发按钮动作进行游戏。

二、实验目的

综合运用ARM平台，掌握驱动程序设计方法，了解触摸屏工作原理。

三、实验原理

（一）、方块和背景的表示：

Ø在俄罗斯方块中共有7种方块，它们都由四个小方块组成，因此我们采用4*4的01数组表示。

这7种方块的图形以及对应的矩阵表示如下：

1、

0000

1111

0000

2、

0000

1110

0010

0000

3、0000

0111

0100

0000

4、

0000

0110

0011

0000

5、

0000

0110

1100

0000

6、

0000

0111

0010

0000

7、0000

0110

0000

Ø俄罗斯方块的背景为一个无盖的杯子，我们用一个20个短整型一维数组表示，其中数的低12位每位表示是否有方块，1为有方块，0表示没有。

初始时矩阵及其表示的图形如下,其中图中空白区域为活动区域：

【1】【0】【0】【0】【0】【0】【0】【0】【0】【0】【0】【1】

【1】【1】【1】【1】【1】【1】【1】【1】【1】【1】【1】【1】

Ø最后用两个整型变量（x,y）表示方块对应在背景中的位置。

其中（x,y）表示方块对应4*4矩阵的左上角小方块据背景左上角的横纵格子数个数，初始值为（3,0）。

（二）方块的变形。

方块的变形是用旋转的形式：

将表示方块的4*4矩阵绕着矩阵的中心顺时针旋转90度，用得到的新矩阵表示变形后的方块。

过程如下图

依此类推…..

（三）变形和下降、左右移动的可行性判断。

将变形或者下降、左右移动后的方块映射到背景矩阵的相应位置，如果在背景上的对应位置不为空（即为1），那么变形或者下降、左右移动不可执行。

如果是方块触底了，则将方块矩阵映射到背景矩阵相应位置，使其变为背景的一部分。

（四）消行。

当某一行全部被方块占满（即背景矩阵的该行对应的无符号短整型数前12位全为1），则删除该行，并将该行以上的所有行下降一行。

（五）到顶。

当方块堆满，即方块堆到背景矩阵的活动区域最上面一行，则游戏结束。

四、实验代码

#include

#defineFBDEV"/dev/fb/0"

#defineORANGE0xfb00

#defineBLUE0x00ff

#defineWHITE0xffff

staticchar*default_frameArraybuffer=FBDEV;

typedefstruct{

unsignedshortpressure;

unsignedshortx;

unsignedshorty;

unsignedshortpad;

}TS_EVENT;

/*方块*/

typedefstruct{

intx;

inty;

intcolor;

}block;

structfb_dev

{

intfb;

void*fb_mem;

intfb_width,fb_height,fb_line_len,fb_size;

intfb_bpp;

};

staticstructfb_devfbdev;

unsignedshortframeArray[20]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

blockO_up,O_down,O_left,O_right;

typedefstruct

{

unsignedshortfr[25];

}frame;

typedefstruct

{

unsignedshortx;

unsignedshorty;

}location;

typedefstruct

{

unsignedshorta[4][4];

}Shape;

framefra,fullFrame;

locationlo;//当前坐标

ShapeshapeMove,nextShape,sh[7]=

{

{{{0,0,0,0},

{1,1,1,1},

{0,0,0,0},

{0,0,0,0}}},

{{{0,0,0,0},

{0,1,1,1},

{0,1,0,0},

{0,0,0,0}}},

{{{0,0,0,0},

{1,1,1,0},

{0,0,1,0},

{0,0,0,0}}},

{{{0,0,0,0},

{0,1,1,1},

{0,0,1,0},

{0,0,0,0}}},

{{{0,0,0,0},

{0,1,1,0},

{0,0,1,1},

{0,0,0,0}}},

{{{0,0,0,0},

{0,1,1,0},

{1,1,0,0},

{0,0,0,0}}},

{{{0,0,0,0},

{0,1,1,0},

{0,0,0,0}}}

};

voidinit（）//产生随机shapeMove

{

Shapetemp;

inti;

shapeMove=nextShape;

srand（time（NULL））;

i=rand（）%7;

nextShape=sh[6-i];

lo.x=4;

lo.y=0;

}

voidinitial（）

{

inti;

//fra.fr[0]=fra.fr[1]=fra.fr[2]=0;

srand（time（NULL））;

i=rand（）%7;

nextShape=shapeMove=sh[i];

for（i=0;i<24;i++）

{

fra.fr[i]=1+（1<<11）;

}

fra.fr[24]=（1<<12）-1;

fullFrame=fra;

init（）;

}

unsignedshortchange（unsignedshortf,unsignedshortx,unsignedshortj）

{

return!

（f&（1<<（11-x-j）））;

}

voidjudge（Shapesha）//返回1，表示可变换.可，即变换

{

unsignedshorti,j;

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

{

if（change（fra.fr[lo.y+i],lo.x,j）&&sha.a[i][j]）

{

return;

}

shapeMove=sha;

}

voidtransform（）//变换形态,也是up（）

{

Shapetemp;

inti,j;

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

{

temp.a[j][3-i]=shapeMove.a[i][j];

}

judge（temp）;

}

intbeEnd（）//返回1到底

{

unsignedshorti,j,end;

//printf（"beEnd（）\n"）;

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

{

end=change（fra.fr[lo.y+i+1],lo.x,j）;

if（shapeMove.a[i][j]&end==1）

return1;

}

return0;

}

intbeLeft（）//返回1到左边

{

unsignedshorti,j,ledge;

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

{

ledge=change（fra.fr[lo.y+i],lo.x,j-1）&shapeMove.a[i][j];

if（ledge==1）

return1;

}

return0;

}

intbeRight（）//返回1到右边

{

unsignedshorti,j,redge;

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

{

redge=change（fra.fr[lo.y+i],lo.x,j+1）&shapeMove.a[i][j];

if（redge==1）

return1;

}

return0;

}

voidleft（）

{

if（!

beLeft（））

lo.x--;

}

voidright（）

{

if（!

beRight（））

lo.x++;

}

voidcombine（）

{

unsignedshorti,j;

//printf（"combine（）\n"）;

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

{

if（shapeMove.a[i][j]）

fra.fr[lo.y+i]+=（shapeMove.a[i][j]<<（11-lo.x-j））;

}

voiddown（）

{

//printf（"down（）\n"）;

if（!

beEnd（））

{

lo.y++;

}

else

{

if（lo.y<=2）

exit

（1）;

combine（）;

init（）;

}

voidview（）//生成显示数组

{

unsignedshorti,j;

//printf（"view（）\n"）;

fullFrame=fra;

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

{

if（shapeMove.a[i][j]）

{

fullFrame.fr[lo.y+i]+=（shapeMove.a[i][j]<<（11-lo.x-j））;

}

for（i=4;i<24;i++）

{

frameArray[i-4]=fullFrame.fr[i]/2;

}

//printf（"%u\n",frameArray[1]）;

}

unsignedgetBit（unsignedshortf,intbit）{

inti=0;

unsignedshortt=1;

while（i

t*=2;i++;}

return!

（t&f）;

}

voiddelrow（）{

inti,j,k;

//printf（"deldrow（）\n"）;

for（i=23;i>5;i--）{

for（j=1;j<11;j++）

if（getBit（fra.fr[i],j）==0）

break;

if（j==11）{

for（k=i;k>0;k--）

fra.fr[k]=fra.fr[k-1];

fra.fr[0]=（1<<11）+1;

i++;

}

fullFrame=fra;

//printf（"deldrowEnd（）\n"）;

for（i=4;i<24;i++）

{

frameArray[i-4]=fullFrame.fr[i]/2;

}

voiddrawNext（）

{

inti,j,m,k;

unsignedshortint*p=（unsignedshortint*）fbdev.fb_mem;

for（i=0;i<60;i++,p+=fbdev.fb_line_len/2）{

if（i>=50&&i<55）

for（j=470;j<582;j++）

p[j]=WHITE;

if（i>=55）{

for（k=470;k<475;k++）

p[k]=WHITE;

for（k=577;k<582;k++）

p[k]=WHITE;

}

for（i=0;i<4;i++）

{

for（m=0;m<20;m++,p+=fbdev.fb_line_len/2）

for（j=0;j<4;j++）

{

if（nextShape.a[i][j]==1）

{

for（k=0;k<20;k++）

p[j*24+k+480]=ORANGE;

}

for（k=470;k<475;k++）

p[k]=WHITE;

for（k=577;k<582;k++）

p[k]=WHITE;

}

for（m;m<24;m++,p+=fbdev.fb_line_len/2）{

for（k=470;k<475;k++）

p[k]=WHITE;

for（k=577;k<582;k++）

p[k]=WHITE;}

}

for（i=0;i<10;i++,p+=fbdev.fb_line_len/2）{

if（i>=5）

for（j=470;j<582;j++）

p[j]=WHITE;

else{

for（k=470;k<475;k++）

p[k]=WHITE;

for（k=577;k<582;k++）

p[k]=WHITE;

}

voiddrawOperate（blocka）

{

inti,j;

unsignedshortint*p=（unsignedshortint*）fbdev.fb_mem;

for（i=0;i

for（i=a.y;i

{

for（j=a.x;j

{

p[j]=a.color;

}

voiddrawEdge（）

{

inti,j;

unsignedshortint*p=（unsignedshortint*）fbdev.fb_mem;

for（i=0;i

{

for（j=110;j<115;j++）

{

p[j]=WHITE;

}

for（j=360;j<365;j++）

{

p[j]=WHITE;

}

voiddrawBlock（）

{

inti,j,m,k;

unsignedshortint*p=（unsignedshortint*）fbdev.fb_mem;

for（i=0;i<20;i++,p+=fbdev.fb_line_len/2）

{

for（m=0;m<20;m++,p+=fbdev.fb_line_len/2）

for（j=0;j<10;j++）

{

//if（m==0）

//printf（"%u",getBit（frameArray[i],9-j））;

if（getBit（frameArray[i],9-j）==1）

{

for（k=0;k<20;k++）

p[j*24+k+120]=ORANGE;

}

//printf（"\n"）;

for（m;m<23;m++,p+=fbdev.fb_line_len/2）;

}

drawEdge（）;

drawOperate（O_up）;

drawOperate（O_down）;

drawOperate（O_left）;

drawOperate（O_right）;

drawNext（）;

}

voidfunc（）//捕捉到定时器产生的SIGALARM信号时的操作，

{

//printf（"func（）\n"）;

down（）;

view（）;

delrow（）;

view（）;

frameArraybuffer_open（）;

drawBlock（）;

//signal（SIGALRM,func）;

}

intframeArraybuffer_open（void）

{

intfb;

structfb_var_screeninfofb_vinfo;

structfb_fix_screeninfofb_finfo;

char*fb_dev_name;

if（!

（fb_dev_name=getenv（"frameArrayBUFFER"）））

{

fb_dev_name=default_frameArraybuffer;

}

fb=open（fb_dev_name,O_RDWR）;//打开frameArraybuffer缓存

if（fb<0）

{

printf（"device%sopenfailed\n",fb_dev_name）;

return-1;

}

if（ioctl（fb,FBIOGET_VSCREENINFO,&fb_vinfo））//获取与frameArraybuffer有关的可变信息

{

printf（"Can'tgetVSCREENINFO:

%s\n",strerror（errno））;

close（fb）;

return-1;

}

if（ioctl（fb,FBIOGET_FSCREENINFO,&fb_finfo））//获取与frameArraybuffer有关的固定信息

{

printf（"Can'tgetFSCREENINFO:

%s\n",strerror（errno））;

return1;

}

fbdev.fb_bpp=fb_vinfo.red.length+fb_vinfo.green.length+fb_vinfo.blue.length+fb_vinfo.transp.length;

fbdev.fb_width=fb_vinfo.xres;

fbdev.fb_height=fb_vinfo.yres;

fbdev.fb_line_len=fb_finfo.line_length;

fbdev.fb_size=fb_finfo.smem_len;//映射区大小

//printf（"frameArraybuffer:

%d（%d）x%d,%dbpp0x%xbyte\n",fbdev.fb_width,fbdev.fb_line_len,fbdev.fb_height,fbdev.fb_bpp,fbdev.fb_size）;

if（fbdev.fb_bpp!

=16）

{

printf（"frameArraybuffermustbe16bppmode\n"）;

exit（0）;

}

fbdev.fb_mem=mmap（NULL,fbdev.fb_size,PROT_READ|PROT_WRITE,MAP_SHARED,fb,0）;//建立文件到内存的映射

if（fbdev.fb_mem==NULL||（int）fbdev.fb_mem==-1）

{

fbdev.fb_mem=NULL;

printf（"mmapfailed\n"）;

close（fb）;

ret

展开阅读全文