devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

项目——电子相框（1）：LCD屏幕显示字符和汉字_如何控制lcd显示希望显示的字母

作者：秋刀鱼在做梦 | 2024-08-08 13:26:46

赞

踩

如何控制lcd显示希望显示的字母

简介：

        本文主要介绍如何通过应用程序控制内核驱动以实现在LCD屏幕上显示字符和汉字。

声明：

        本文主要是看韦东山老师视频后并结合自己所查的一些知识所写，希望可以对你有所帮助。同时本文主要是针对应用程序编程，所以在阅读本文之前希望您先了解与LCD相关的驱动。

平台：

Linux内核：Linux-4.3.2

LCD驱动：嵌入式Linux——LCD驱动 （这篇文章是我以前写的LCD驱动，这其中有对本文所用LCD的详细介绍）

思路：

       首先，要实现在LCD上显示字母的功能，我们就需要去获得这个字母的实现数组。其实我们可以将一个屏幕想想成一个由点组成的二维数组，而我们通过控制这个二维数组中各个位置的亮灭从而已实现显示字母的功能。而这个数组就是我们常说的ASCII码。这里有一个字母A的数组，他是一个8*16像素的字母：

 

        上面显示的是用ASCII表示的躺倒了的字母A。而我们写程序要做的就是将这些ASCII码中的各个位对应到LCD的像素中，即通过控制各个位的值为1或0来表示各个像素的亮灭。而通过向framebuffer中写入对应的数组来实现从LCD显示字符和汉字的功能。

字符编码：

        在开始实现功能之前我想先介绍一些基础的知识——字符编码。以前我在使用电脑时喜欢将各种文件命名为中文的，这样可以方便去查找，同时也可以一目了然的知道各个文件的功能，但是这样的做法却是个不好的习惯，因为有的时候我电脑中的文件拷贝到他人的Linux服务器时会出现乱码的现象。我们应该使用英文的方式来为各个文件或者其他的东西命名。这样的好处是很难出现乱码。那时的我很少考虑字符编码的事，只是想着出现乱码可能是因为机器的问题。以前的我在使用LCD或者OLED时很少会使用到汉字，也就只是使用了ASCII码，而当我真正要在LCD上显示一个汉字时才发现他并不是那么简单的。他不会像ASCII码那样可以使用一个字节就可以表示出来，同时汉字在中国也有不同的版本。下面我列举一些常用到的字符编码方式：

ASCII：

        ascii是计算机最早使用的编码系统，由于计算机是欧美人发明的，所以他们认为用一字节的数据就可以完全的概括他们所需要的字母，所以ASCII是最早的编码集，他只占用一字节的数据空间。

GB2312：

        随着计算机的不断发展，中国人也希望可以将自己的汉字写到编码集中，所以大陆方面设计了自己国标码，也就是GB2312码，在国标码中，包含了六千多我们常用的汉字。而国标码显然超出一个字节数据所能表示的范围，所以国标码一般使用两个字节的数据表示。

BIG5：

        上面所说的国标码适用于我们现在的简体汉字，而在台湾等地方使用的是繁体的汉字，所以他们也设计了一套自己的编码基，即BIG5，BIG5码最早是由在台湾的5个大的公司提议所创建的，所以后面就叫BIG5码了。而BIG5码同样占用两个字节的数据空间。但是要注意的是，虽然国标码和BIG5码同样使用两个字节的数据表示一个汉字，但是同样一个两字节的数据在国标码和BIG5中却表示的是不同的汉字。所以有时候我们打开台湾的网站会发现虽然也显示的是汉字，但是却不能连城句子，就是因为两个字符集不同，出现乱码。

Unicode：

        如上面所说，同样一个两字节的数据在不同字符集中却表示的是不同的字符，这就容易出现乱码，所以我们需要一个统一的编码集，而Unicode就是这样一个统一的编码集，或者说是编码转化器。而常见的实现形式有UTF-8和UTF-16。

UTF-8：

        随着互联网的普及UTF-8得到了很好的应用，他被称为是一种会变长的字符编码，他有1到4个字节组成，同时UTF-8有一定的容错性，即一个数据出错只会影响到一个字符而并不会影响到其他的字符。UTF-8的设计有以下的多字符组序列的特质：

  1. 单字节字符的最高有效比特永远为0。
  2. 多字节序列中的首个字符组的几个最高有效比特决定了序列的长度。最高有效位为110的是2字节序列，而1110的是三字节序列，如此类推。
  3. 多字节序列中其余的字节中的首两个最高有效比特为10。

ioctl函数：

        我们以往编程时用到ioctl函数常用到的是通过应用函数向内核驱动中的ioctl函数传递特定的参数，而这些参数在驱动的ioctl函数中通过switch来选取预设的特定命令，从而执行相应的命令。而对于这个项目中用到的ioctl函数就不一样了，他可以通过特定的宏定义参数从内核中获得驱动或者硬件相关的参数。而在电子相框这个项目中，我们通过宏FBIOGET_VSCREENINFO和FBIOGET_FSCREENINFO来获得我们在驱动中定义的LCD显示器的可变参数和固定参数。即struct fb_var_screeninfo 和struct fb_fix_screeninfo。详细的代码为：

  1. 	if(ioctl(fd_fb,FBIOGET_VSCREENINFO,&var)){
  2. 		printf("can't get var \n");
  3. 		return -1;
  4. 	}	
  5.  
  6. 	if(ioctl(fd_fb,FBIOGET_FSCREENINFO,&fix)){
  7. 		printf("can't get fix \n");
  8. 		return -1;
  9. 	}

        而在驱动函数的可变参数和固定参数中就有对LCD屏幕的设置，这里我复制在驱动中所写的关于可变参数和固定参数的中的各个设置变量：

固定参数（固定参数多为硬件相关而不会变化的，如屏幕的尺寸，显存物理地址，和屏幕类型等）：

  1. fix.smem_len    = 480*272*16/8;     //显存的长度
  2. fix.type        = FB_TYPE_PACKED_PIXELS;
  3. fix.visual      = FB_VISUAL_TRUECOLOR; //TFT屏为真彩色
  4. fix.line_length = 480*16/8; //一行的长度（单位：type）

可变参数（而可变的参数是可以根据不同情况而进行不同设置的，如：x，y方向虚拟分辨率，多少字节每像素，以及RGB所占有的比例等）：

  1.     var.xres          = 480;        //x方向真实的分辨率
  2.     var.yres          = 272;        //y方向真实的分辨率
  3.     var.xres_virtual  = 480;        //x方向虚拟的分辨率
  4.     var.yres_virtual  = 272;        //y方向虚拟的分辨率
  5.     var.xoffset       = 0;          //x方向真实分辨率与虚拟分辨率的差值
  6.     var.yoffset       = 0;          //y方向真实分辨率与虚拟分辨率的差值
  7.  
  8.     var.bits_per_pixel = 16;        //设置16个字节每像素
  9.  
  10.     /*RGB:565*/    
  11.     var.red.offset   = 11;
  12.     var.red.length   = 5;
  13.     var.green.offset = 5;
  14.     var.green.length = 6;
  15.     var.blue.offset  = 0;
  16.     var.blue.length  = 5;

        通过上面的介绍我们已经清楚，通过获得显示屏的可变参数和固定参数可以获得与显示屏相关的信息。

申请内存进行操作：

        通过上面的介绍我们获得了与LCD屏幕相关的所有信息，下面我们就要通过获得的LCD屏幕信息来为framebuffer申请空间了。这里有说明的一点是，由于在驱动中已有设置，所以我们LCD显示是通过从framebuffer中读出与LCD屏幕像素相应大小的数据去对LCD进行填充。所以这里要申请一个framebuffer大小的空间，代码为：

  1. 	screen_size = var.xres * var.yres * var.bits_per_pixel / 8;
  2. 	fbmem = (unsigned char*)mmap(NULL,screen_size,PROT_READ|PROT_WRITE,MAP_SHARED,fd_fb,0);
  3. 	if(fbmem == (unsigned char *)-1){
  4. 		printf("can't mmap fbmem\n");
  5. 		return -1;
  6. 	}

        我想可能会有人问为什么这里使用的是mmap函数来申请空间而不是malloc函数，我也查了一些资料，但是感觉有些抽象，所以这里我写一些自己的理解，不是是否正确：

        mmap是在进程中申请的空间，他其实是向进程申请空间，所以他就是声明要使用进程中的内存，或者说他只是使用进程中的内存，所以他内存申请的大小相对要小，同时也说明这片内存在申请之前就是存在的已经分给了进程。而malloc是向内核申请空间，所以他申请的空间相对较大，同时malloc申请时内存是不存在的，只有你申请了你才有。

操作LCD现实汉字：

        其实完成上面的步骤我们就可以通过将英文字母对应的数组写到framebuffer中来让LCD显示英文字母了。而ASCII码对应的数组大家可以很容易在网上找到。而大家需要做的就是将数组中每个位对应的1或者0表示为LCD中像素的亮和灭就好。代码为：

  1. void lcd_put_ascii(int x,int y,unsigned char c)
  2. {
  3. 	unsigned char *dots = (unsigned char *)&fontdata_8x16[c*16];
  4.  
  5. 	int i,b;
  6. 	unsigned char byte;
  7.  
  8. 	for(i=0;i<16;i++){
  9. 		byte = dots[i];
  10. 		for(b=7;b>=0;b--){
  11. 			if(byte & (1<<b)){
  12. 				/* show */
  13. 				lcd_put_pixel(x+7-b,y+i,0xffffff);
  14. 			}else{
  15. 				/* hide */
  16. 				lcd_put_pixel(x+7-b,y+i,0);
  17. 			}
  18. 		}
  19. 	}
  20. }

        LCD能显示英文后我们下一个要做的就是让LCD显示汉字。这里我们要使用一个库：HZK16 。网上关于HZK16的介绍很多，我在下面的参考文献中也列举了几篇。其中hzk16需要我们知道的几点是，hzk16中使用16*16的矩阵来表示一个汉字，而在hzk16中使用两字节的数据来查找一个汉字，这两个字节的前一个字节数据表示的是区码，即这个汉字在那个汉字区，而第二个数据表示的是位码，即你所查找的汉字在这个区中具体哪个位置。所以我们通过区码和位码就可以找到这个汉字所在的位置。由于区码和位码都是从A1位置开始的。所以每个区中有94个汉字，由于每个汉字都是16*16像素的所以一个汉字要使用16*16/2=32字节的数据来存储。所以我们要查找的数组开始位置应该为：

  1. unsigned int area  = str[0] - 0xA1;
  2. unsigned int where = str[1] - 0xA1;
  3. unsigned char *dots = hzkmem + (area * 94 + where) * 32;

        我们需要从网上下载这个hzk16的文件并从中读取相应的信息，这是就要用到一个函数：fstat 。通过该函数可以读取文件的大小以及一些其他的信息，由于这里我们是需要获得文件的大小所以认识并不深刻，详细的信息大家可以百度一下。相关的代码为：

  1. 	fd_hzk16 = open("HZK16",O_RDONLY);
  2. 	if(fd_hzk16 < 0){
  3. 		printf("can't open HZK16 \n");
  4. 		return -1;
  5. 	}
  6.  
  7. 	if(fstat(fd_hzk16,&hzk_stat)){
  8. 		printf("can't get HZK16 \n");
  9. 		return -1;
  10. 	}
  11.  
  12. 	hzkmem = (unsigned char *)mmap(NULL,hzk_stat.st_size,PROT_READ ,MAP_SHARED,fd_hzk16,0);
  13. 	if(hzkmem == (unsigned char *)-1){
  14. 		printf("can't mmap hzkmem\n");
  15. 		return -1;
  16. 	}
  17.  
  18.  
  19. void lcd_put_chinese(int x,int y,unsigned char *str)
  20. {
  21. 	unsigned int area  = str[0] - 0xA1;
  22. 	unsigned int where = str[1] - 0xA1;
  23. 	unsigned char *dots = hzkmem + (area * 94 + where) * 32;
  24. 	unsigned char byte;
  25. 	int i,j,b;
  26.  
  27. 	for(i=0;i<16;i++){
  28. 		for(j=0;j<2;j++){
  29. 			byte = dots[i*2+j];
  30. 			for(b=7;b>=0;b--){
  31. 				if(byte & (1<<b)){
  32. 					/* show */
  33. 					lcd_put_pixel(x+j*8+7-b,y+i,0xffffff);
  34. 				}else{
  35. 					/* hide */
  36. 					lcd_put_pixel(x+j*8+7-b,y+i,0);
  37. 				}
  38. 			}
  39. 		}
  40. 	}
  41. }

        好了讲到这里就讲完这些知识了。而整个实现的代码在文章的最后。

参考文献：

字符编码笔记：ASCII，Unicode 和 UTF-8

unicode,ansi,utf-8,unicode big endian编码的区别

十分钟搞清字符集和字符编码

UTF-8

mmap和malloc的区别是什么

进程表结构以及malloc和mmap的区别

字符理论--hzk16的介绍以及简单的使用方法 （转）

HZK16汉字16*16点阵字库的使用及示例程序

hzk16的介绍以及简单的使用方法

fstat

C语言:stat,fstat和lstat函数

C语言用fstat函数获取文件的大小

 

整体代码：

  1. #include <stdio.h>
  2. #include <linux/fb.h>
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <fcntl.h>
  6. #include <sys/mman.h>
  7. #include <string.h>
  8. #include <unistd.h>
  9. 	
  10. #define FONTDATAMAX 4096	
  11. 	static const unsigned char fontdata_8x16[FONTDATAMAX] = {
  12. 	
  13. 		/* 0 0x00 '^@' */
  14. 		0x00, /* 00000000 */
  15. 		0x00, /* 00000000 */
  16. 		0x00, /* 00000000 */
  17. 		0x00, /* 00000000 */
  18. 		0x00, /* 00000000 */
  19. 		0x00, /* 00000000 */
  20. 		0x00, /* 00000000 */
  21. 		0x00, /* 00000000 */
  22. 		0x00, /* 00000000 */
  23. 		0x00, /* 00000000 */
  24. 		0x00, /* 00000000 */
  25. 		0x00, /* 00000000 */
  26. 		0x00, /* 00000000 */
  27. 		0x00, /* 00000000 */
  28. 		0x00, /* 00000000 */
  29. 		0x00, /* 00000000 */
  30.  
  31. ········································
  32.  
  33. 		/* 255 0xff '??' */
  34. 		0x00, /* 00000000 */
  35. 		0x00, /* 00000000 */
  36. 		0x00, /* 00000000 */
  37. 		0x00, /* 00000000 */
  38. 		0x00, /* 00000000 */
  39. 		0x00, /* 00000000 */
  40. 		0x00, /* 00000000 */
  41. 		0x00, /* 00000000 */
  42. 		0x00, /* 00000000 */
  43. 		0x00, /* 00000000 */
  44. 		0x00, /* 00000000 */
  45. 		0x00, /* 00000000 */
  46. 		0x00, /* 00000000 */
  47. 		0x00, /* 00000000 */
  48. 		0x00, /* 00000000 */
  49. 		0x00, /* 00000000 */
  50. 	
  51. 	};
  52.  
  53. 	int fd_fb;
  54. 	int fd_hzk16;
  55. 	struct fb_var_screeninfo var;
  56. 	struct fb_fix_screeninfo fix;
  57.  
  58. 	struct stat hzk_stat;
  59. 	
  60. 	int screen_size;
  61. 	unsigned char *fbmem;
  62. 	unsigned char *hzkmem;
  63.  
  64. 	unsigned int line_width;
  65. 	unsigned int pixel_width;
  66.  
  67. void lcd_put_pixel(int x,int y,unsigned int color)
  68. {
  69.  
  70.  
  71. 	unsigned char  *pen_8  = fbmem + y*line_width + x*pixel_width;
  72. 	unsigned short *pen_16;
  73. 	unsigned int   *pen_32;
  74.  
  75. 	pen_16 = (unsigned short *)pen_8;
  76. 	pen_32 = (unsigned int *)pen_8;
  77.  
  78. 	unsigned int red,green,blue;
  79.  
  80. 	switch(var.bits_per_pixel){
  81. 		case 8 :{
  82. 			*pen_8 = color;
  83. 			break;
  84. 		}
  85.  
  86. 		case 16 :{
  87. 			red   = (color >> 16) & 0xff;
  88. 			green = (color >> 8) & 0xff;
  89. 			blue  = (color >> 0) & 0xff;
  90.  
  91. 			color = ((red >> 3) << 11) | ((green >> 2) << 5) | (blue >> 3);
  92. 			*pen_16 = color;
  93. 		
  94. 			break;
  95. 		}
  96.  
  97. 		case 32 :{
  98. 			*pen_32 = color;
  99. 			break;
  100. 		}
  101.  
  102. 		default:{
  103. 			printf("can't support %dbpp\n",var.bits_per_pixel);
  104. 			break;
  105. 		}
  106. 	}
  107. }
  108.  
  109.  
  110. void lcd_put_ascii(int x,int y,unsigned char c)
  111. {
  112. 	unsigned char *dots = (unsigned char *)&fontdata_8x16[c*16];
  113.  
  114. 	int i,b;
  115. 	unsigned char byte;
  116.  
  117. 	for(i=0;i<16;i++){
  118. 		byte = dots[i];
  119. 		for(b=7;b>=0;b--){
  120. 			if(byte & (1<<b)){
  121. 				/* show */
  122. 				lcd_put_pixel(x+7-b,y+i,0xffffff);
  123. 			}else{
  124. 				/* hide */
  125. 				lcd_put_pixel(x+7-b,y+i,0);
  126. 			}
  127. 		}
  128. 	}
  129. }
  130.  
  131.  
  132. void lcd_put_chinese(int x,int y,unsigned char *str)
  133. {
  134. 	unsigned int area  = str[0] - 0xA1;
  135. 	unsigned int where = str[1] - 0xA1;
  136. 	unsigned char *dots = hzkmem + (area * 94 + where) * 32;
  137. 	unsigned char byte;
  138. 	int i,j,b;
  139.  
  140. 	for(i=0;i<16;i++){
  141. 		for(j=0;j<2;j++){
  142. 			byte = dots[i*2+j];
  143. 			for(b=7;b>=0;b--){
  144. 				if(byte & (1<<b)){
  145. 					/* show */
  146. 					lcd_put_pixel(x+j*8+7-b,y+i,0xffffff);
  147. 				}else{
  148. 					/* hide */
  149. 					lcd_put_pixel(x+j*8+7-b,y+i,0);
  150. 				}
  151. 			}
  152. 		}
  153. 	}
  154. }
  155.  
  156. int main(int argc,char **argv)
  157. {
  158.  
  159.         unsigned char str[] = "中";
  160.  
  161. 	fd_fb = open("/dev/fb0",O_RDWR);
  162. 	if(fd_fb < 0){
  163. 		printf("can't open /dev/fb0 \n");
  164. 		return -1;
  165. 	}	
  166.  
  167. 	if(ioctl(fd_fb,FBIOGET_VSCREENINFO,&var)){
  168. 		printf("can't get var \n");
  169. 		return -1;
  170. 	}	
  171.  
  172. 	if(ioctl(fd_fb,FBIOGET_FSCREENINFO,&fix)){
  173. 		printf("can't get fix \n");
  174. 		return -1;
  175. 	}
  176. 	line_width = var.xres * var.bits_per_pixel / 8;
  177. 	pixel_width = var.bits_per_pixel/8;
  178. 	screen_size = var.xres * var.yres * var.bits_per_pixel / 8;
  179. 	fbmem = (unsigned char *)mmap(NULL,screen_size,PROT_READ | PROT_WRITE ,MAP_SHARED,fd_fb,0);
  180. 	if(fbmem == (unsigned char *)-1){
  181. 		printf("can't mmap fbmem\n");
  182. 		return -1;
  183. 	}
  184.  
  185. 	fd_hzk16 = open("HZK16",O_RDONLY);
  186. 	if(fd_hzk16 < 0){
  187. 		printf("can't open HZK16 \n");
  188. 		return -1;
  189. 	}
  190.  
  191. 	if(fstat(fd_hzk16,&hzk_stat)){
  192. 		printf("can't get HZK16 \n");
  193. 		return -1;
  194. 	}
  195.  
  196. 	hzkmem = (unsigned char *)mmap(NULL,hzk_stat.st_size,PROT_READ ,MAP_SHARED,fd_hzk16,0);
  197. 	if(hzkmem == (unsigned char *)-1){
  198. 		printf("can't mmap hzkmem\n");
  199. 		return -1;
  200. 	}
  201.  
  202.  
  203. 	/* 清屏，全部设为黑色 */
  204.  
  205. 	memset(fbmem,0,screen_size);
  206. 	lcd_put_ascii(var.xres/2,var.yres/2,'A');
  207. 	
  208. 	printf("chinese code : %02x  %02x \n",str[0],str[1]);
  209. 	lcd_put_chinese(var.xres/2+8,var.yres/2,str);	
  210. 	return 0;
  211. }

 

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/948477
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号