基于STM32的简单电子书的实现

小样岁月

　　今天玩了会液晶屏，原来显示汉字都是也取模软件区模后在液晶屏上显示，显示内容改变以后还需要重新做字模，比较麻烦。这两天有时间，参考网友资料，实现了读取汉字的内码从SD卡的GB2312点阵字库读取点阵在液晶屏上显示，字库的生成软件用的是易木雨的点阵字库生成器。能生成很多种语言的字库。做完了读取显示后，我自己又琢磨了一下，简单的实现了从SD卡中读取txt文档然后再液晶屏上显示txt内容。
　　取模过程注意点阵的宽、高和字体大小的关系，宽、高是我们在液晶屏上要显示的像素大小，字体是汉字大小，如果宽、高一定，字体大小太到的话，字在液晶屏上只能显示一部分，可以在左侧的预览区看出来，如果字体在宽高像素点的范围内则可以在液晶上显示完整的字，如果不能显示完整则可以调整宽高或者字体大小。
　　国标字有GB2312和GBK编码，GBK完全兼容GB2312包括内码的兼容，A而且GBK字库增加了很多字。汉字都是用的两个字节表示，第一个字节是区号，第二个字节是在区内的相对偏移位置。通过内码来获取字库内的偏移位置，偏移位置与内码和生成字库的宽高都有关系。我生成的GB2312字库是16*16个像素点显示一个汉字，那在字库内的偏移位置：
　　offset=32* ( (H-0xa1)*94+(L-0xa1) )
　　H 表示内码的高字节，L表示内码的低字节。GB2312高字节是0xa1~0xfe表示区号，每个区有94个字节所以*94得到区的相对位置，L表示内码低字节也是从0xa1~0xfe，L-0xa1 得到的是在当前区内的偏移位置。 因为每个汉字有16*16=32个自己组成，所以最后乘以32得到在点阵字库中的偏移位置，从这个位置开始取出32个字节的点阵数据然后打点显示就可以把一个汉字显示出来了。
' R/ _* y4 L5 m# M　　获取点阵的代码如下

1. FATFS fs1; // 挂载SD卡的分区用
   
2. 
   
3. 　　FIL f1; // SD卡中字库的文件描述符
   
4. 
   
5. 　　FIL ftxt; // 要读取的txt文档的文件描述符
   
6. 
   1 i/ E8 Y, {* `5 B" O6 K- {
7. 　　u8 fnGetChinese(u8 *p,u8 *buff) // 形参是要读取的汉字
   5 H; @4 ?+ P$ J8 B
8. 
   
9. 　　{
     N7 D% e( N! ?" D; r  s+ L5 I
10. 
    
11. 　　u8 res=0;
    
12. 
    
13. 　　u8 H8,L8;
    / H8 w8 J) \' q: X. h
14. 
    
15. 　　UINT num;
    5 @, S) g0 S- X. K
16. 
    
17. 　　H8=*p;
    2 q9 T( q# X$ c6 S8 U1 g2 j
18. 
    
19. 　　L8=*(p+1);
    
20. 
    # y, f6 ~1 z* m8 k$ c. t$ A7 q
21. 　　f_mount(&fs1,"",1); // 挂载SD卡
    & h; r5 G; D( E, H0 w' m% w; B
22. 
    - c- n2 k$ x4 D% O5 r9 ^8 f' R
23. 　　res=f_open(&f1,ReadPath,FA_OPEN_EXIStiNG|FA_READ); // 打开SD卡下的点阵字库
    
24. 
    / ?$ x' Z& T% p$ T5 H' E! d
25. 　　IF(res!=0) // 判断点阵字库是否打开成功
    
26. 
    
27. 　　{
    
28. 
    " E: w7 \( R. y" q  b
29. 　　fnShowString(10,120,"open hzk fail",16,RED,WHITE,0);
    
30. 
    $ _4 V0 F( p0 C# b
31. 　　printf("res=%x",res);
    & Q% U5 B* e- d6 U+ P: `
32. 
    
33. 　　return 1;
    + t! N6 Q4 w% w( Q
34. 
    
35. 　　}
    7 i* l+ u9 f; {6 D+ x7 P
36. 
    1 Z5 N4 u9 y5 z9 l6 Y, H
37. 　　else
    ' b: l1 D9 Q- W7 P& b# a% K( W
38. 
    
39. 　　{
    : Q- g2 x' O+ a1 E$ A0 ^
40. 
    
41. 　　fnShowString(10,120,"open ok",16,RED,WHITE,0);
    
42. 
    
43. 　　}
    ' G8 \" X; }5 N
44. 
    
45. 　　f_lseek(&f1,32*((H8-0xa0-1)*94+(L8-0xa0-1))); // 在字库文件中做偏移取出32个字节的点阵数据
    ) X# I8 U8 U0 v: H' K' k
46. 
    / }4 w; Q" f8 I% f
47. 　　res=f_read(&f1,buff,32,&num);
    
48. 
    / m  Y" _& i& b# v
49. 　　f_close(&f1); // 读完后关闭点阵字库文件
    1 M$ V' T0 k" z4 ^' Z! p9 `" `
50. 
    
51. 　　f_mount(&fs1,"",NULL); // 卸载SD卡
    
52. 
    + C# W$ ^) V$ v2 t: g
53. 　　return 0;
    
54. 
    
55. 　　}

复制代码

　　这个是得到汉字点阵的实现过程，得到点阵数据后就可以在液晶上打点实现汉字的显示，具体的底层驱动不再详细介绍。
7 P' C, t9 Z* F$ Y　　实现了在单片内显示汉字串以后，能不能读取SD卡中的txt文档中的汉字在液晶屏上显示呢?这块是我自己想的，不知道与别人的一样不一样，反正是实现了。
- q, }! H- l, F" U  t　　首先我读取SD卡上txt文档上的一个汉字，然后用串口打印出来，发现，读到的就是汉字的内码，百度了下说windows中txt文档的显示的用GB2312的字库。既然读到直接是内码，那就好办了。汉字内码用的是两个字节，字符用的是一个字节，这个一定要注意，因为在以后显示的过程中要用。
　　下面直接贴代码：

1. // x,y在液晶屏上的显示位置，我的液晶屏是320*240 ，竖屏显示
   
2. 
   * e/ O7 z4 [  W8 k
3. 　　// color 是画笔的颜色，BkColor 是背景颜色
   
4. 
   9 v7 W* A9 q* c/ Z+ m9 H
5. 　　u8 fnShowTxt( u16 x, u16 y , u16 color ,u16 BkColor )
   
6. 
   3 \4 t* R- r! U! L" q
7. 　　{
   
8. 
   8 }2 ]- @8 x+ t9 G2 e
9. 　　u8 res=0; // SD卡函数的返回值
   
10. 
    
11. 　　u8 buff[100]={0}; // 存储从txt文档中读到的100个字节的内码
    
12. 
    7 Y8 J$ g* y% E' o& u
13. 　　u8 bitbuff[32]={0}; // 存储从点阵字库获得的32个字节的点阵数据
    
14. 
    
15. 　　u8 NeiMaH,NeiMaL; // GB2312内码的高位和低位
    ; S9 S8 w7 T( ^% p  w& y7 y3 V/ n
16. 
    " o# }1 L+ P1 [$ O. l( s2 ?
17. 　　u8 CntnuF=1; // 用来 判断是不是读到文档的末尾了，如果读到字节的个数小于100则表示读到末尾了
    9 Y0 r% a" g+ U4 e7 `8 \% X& Y
18. 
    
19. 　　u16 offset=0; // 读txt文档的偏移地址
    
20. 
    
21. 　　u8 i=0;
    ' u0 }7 ^' S2 \
22. 
    
23. 　　UINT Hznum,bytenum; // 实际读回的内码字节个数、点阵字节个数
    $ t) ^; l9 U; L/ l5 S0 [3 y3 j
24. 
    3 p7 I+ ]7 O# c
25. 　　u16 x0,y0; // 点阵显示的位置
    2 j7 h$ w; V. O+ W8 e3 l
26. 
    5 i3 {- y0 Q/ T. g; u/ U0 m! f- c
27. 　　u8 charCnt=0; // 读取的100个字节内码中有几个字符，如果字符个数是偶数则下次偏移再偏移100，如果是奇数，
    : Q! o* V5 J# E; e
28. 
    * j" V+ X- A  B  a
29. 　　// 则读取的100个字节中的最后一个字节可能是下一个汉字的内码高位字节，则偏移99，下次再把这个字节读上。
    
30. 
    7 x5 [  `* a1 L: H  p/ C
31. 　　x0=x;
    9 E. Y$ D0 I: z( J2 @/ _# e
32. 
    2 ]  h" M% S  V7 w' j' C
33. 　　y0=y;
      V. n/ s- x# ?1 B- _1 }& n
34. 
    ! d. E' P+ C/ Q
35. 　　f_mount(&fs1,"",1); // 挂载SD卡
    ; e4 y, z  T8 U0 U4 Z$ f
36. 
    & F, f+ r' X$ ?1 I* O. a6 ?/ r+ _( B
37. 　　res=f_open(&f1,ReadPath,FA_OPEN_EXISTING|FA_READ); // 打开字库文件
    
38. 
    2 }! i+ `% U( c) }
39. 　　if(res!=0)
    
40. 
    0 t0 ?7 O7 q6 ]" `& b/ w
41. 　　{
    
42. 
    
43. 　　fnShowString(10,120,"open hzk fail",16,RED,WHITE,0);
    # b" ~" Z( B4 Y2 G9 d
44. 
    * Y9 i: s% Q9 C* k
45. 　　printf("res=%x",res);
    
46. 
    
47. 　　return 1;
    * R- p, h# |# q" D7 e& G, l
48. 
    
49. 　　}
    
50. 
    + I) p  D; ]2 o* p/ J
51. 　　res=f_open(&ftxt,TxtPath,FA_OPEN_EXISTING|FA_READ); // 打开txt文档
    $ P1 N+ V/ }( S8 X; p: b, u7 ~4 e
52. 
    
53. 　　if(res!=0)
    
54. 
    
55. 　　{
    4 t, k9 U, d2 R2 z- u; O
56. 
    ! i  v/ V( S' h1 s* ]
57. 　　fnShowString(10,120,"open txt fail",16,RED,WHITE,0);
    / s3 B% B" Q7 k  K
58. 
    
59. 　　printf("res=%x",res);
    3 \6 A5 I3 l1 y3 s/ }+ _& i
60. 
    
61. 　　return 1;
    
62. 
    
63. 　　}
    
64. 
    
65. 　　f_lseek(&ftxt,offset); // 初始化偏移为0从头开始读。
    $ p! V" [" e! J/ J- q8 C
66. 
    
67. 　　res=f_read(&ftxt,buff,100,&Hznum); // 每次读100个内码字节
    3 T3 v4 t/ j, J( X) h; e9 g
68. 
    & V9 J8 ]( V( P$ }3 {  x0 D
69. 　　while(CntnuF) // 循环判断是不是读到文件末尾了
    
70. 
    + g7 k* J7 {/ d1 ?4 N/ F8 @
71. 　　{
    9 r0 T) s8 w! i; j& \
72. 
    
73. 　　for(i=0;i
    4 W/ D+ ]/ z3 u" r5 j
74. 
    # [: m4 I6 r# z! _: U5 ^7 z" b: s
75. 　　{
    . N1 O& y$ H+ f7 {) l
76. 
    " G# y+ |" B+ S) W4 E6 M
77. 　　if(x>220) // 显示位置的判断
    
78. 
    
79. 　　{
    4 W) N1 [+ C$ e0 I
80. 
    ( w  b( g/ z- ^( G" Y4 P
81. 　　x=x0;
    & ?0 @/ M" `9 E; T' y' g
82. 
    5 _5 s; v( e; Z+ G. O8 J
83. 　　y+=16;
    
84. 
    
85. 　　}
    
86. 
    
87. 　　if((y>300))
    
88. 
    
89. 　　{
    4 w9 c' s: _6 j# U6 K' P8 s
90. 
    ) [: O+ s) K1 e& r
91. 　　fnRefreshscreen(WHITE);
    3 j/ K3 C% p8 W
92. 
    ! C) m3 Q2 q: B
93. 　　x=x0;
    
94. 
    - }6 p; O4 y/ M# c' _4 L, j) ?
95. 　　y=y0;
    3 {- |- q9 B9 T& G
96. 
    
97. 　　}
    
98. 
    
99. 　　if(buff>0x80) // 是不是汉字
    
100. 
     - U& u! p+ j& m5 B8 z2 C
101. 　　{
     
102. 
     * D- s' i' {& G, R2 O+ @
103. 　　f_lseek(&f1,32*((buff-0xa0-1)*94+(buff[i+1]-0xa0-1))); // 点阵字库内的偏移
     
104. 
     4 [. o8 G! n  Z5 t
105. 　　res=f_read(&f1,bitbuff,32,&bytenum);
     
106. 
     1 Q0 E( X* o2 ?+ c9 _* x
107. 　　fnShowHzk(x,y,bitbuff,color,BkColor);
     
108. 
     
109. 　　x+=16;
     
110. 
     + Y9 F2 e" Y0 p. }  Z3 ], r
111. 　　i++; // 这个i++非常重要，因为一个汉字两个字节，除了判断语句i++,
     ( J6 d3 s! W0 n; [: }  A; z
112. 
     
113. 　　// 这里需要还要一个
     
114. 
     
115. 　　memset(bitbuff,0,sizeof(bitbuff));
     6 z* x$ u5 S$ g2 K" U
116. 
     
117. 　　}
     + J5 u) s+ `& T! z
118. 
     
119. 　　else // 可能是标点也可能是换行符
     $ }4 q( t( x  O1 j3 H1 z
120. 
     - ^# o1 }* t$ G4 N: ~$ |' i
121. 　　{
     
122. 
     3 p) S+ Z" l. [3 E' Q) p9 _1 ?8 D
123. 　　if(buff==0x0D) // 换行标志
     - \9 C* y/ t4 A
124. 
     
125. 　　y+=16;
     
126. 
     - B+ [# g$ T, T2 R5 v4 f
127. 　　else
     ) e. J# Y  _8 T  ?0 h& B3 E
128. 
     . S; M0 ?* @# w% a5 m) U
129. 　　fnShowChar( x,y,buff,16,color,BkColor,0); // 字符
     : ]1 Y% R7 u9 z- {
130. 
       i6 {0 t6 b' H3 L6 f' r2 Y, R/ K
131. 　　x+=8;
     
132. 
     
133. 　　charCnt++; // 字符个数计算，用于判断下一次读txt文档的偏移地址
     
134. 
     1 E6 b( b9 K3 C" ]% O- v0 I0 V  I
135. 　　}
     7 d/ z" @# W" J
136. 
     
137. 　　}
     : v$ `+ Q: A' s& K# J
138. 
     6 A5 m( L& r; e$ |5 S1 B
139. 　　// 计算txt文档的偏移地址
     
140. 
     
141. 　　if(Hznum!=100) // 判断是不是读到文档末尾了
     8 V* B0 E0 _( o( B
142. 
     7 b5 W' b/ \3 q, a9 U/ t5 u
143. 　　{
     
144. 
     
145. 　　CntnuF=0;
     1 Y- t! s) ?. f9 Q1 {
146. 
       `" u" X6 M) O" K6 a
147. 　　}
     7 g, T& E* z- m2 }) u' _9 g
148. 
     , r3 O, B% O% \0 Q, }* z& g
149. 　　else // 没有读到末尾继续读
     
150. 
     
151. 　　{
     
152. 
     
153. 　　if(charCnt%2==0) // 字符个数是偶数，100个字节内码里边正好成对出现，地址偏移+100
     
154. 
     
155. 　　offset +=100;
     4 C% w" b5 t+ w1 J  d! @, d
156. 
     
157. 　　else
     
158. 
     
159. 　　offset +=99;
     
160. 
     
161. 　　memset(buff,0,sizeof(buff));
     
162. 
     4 i; F! W" Q8 f, l+ f6 a
163. 　　f_lseek(&ftxt,offset); // txt 文档地址偏移
     
164. 
     / ~! e3 \8 ^% j( g7 [: N
165. 　　res=f_read(&ftxt,buff,100,&Hznum); // 读内码数据
     4 \; i8 B& [( j; B  x+ z7 j% K' q
166. 
       u# C) g) Y! p! w. `
167. 　　}
     8 H. P5 ?$ k+ V: S' U
168. 
     ) d- T% g" L5 h7 a5 ^. `& \
169. 　　}
     6 G6 Z; K8 ~5 P3 z, a4 g9 U2 e
170. 
     
171. 　　f_close(&f1); // 关闭打开的点阵字库
     
172. 
     
173. 　　f_close(&ftxt); // 关闭打开的txt文档
     
174. 
     $ R6 u! Y+ F5 A
175. 　　f_mount(&fs1,"",NULL); // 卸载磁盘
     $ s9 Q9 z3 _% J8 j; Q, |
176. 
     
177. 　　return 0;
     
178. 
     & u* c2 P# i+ {5 s* @$ ~/ e+ x
179. 　　}

复制代码

　　以上是简单的电子书的实现。
　　因为不同的系统有不同的编码这个要注意，比如我再Windows上的汉字拷贝到CSDN网页上就是乱码，这是因为使用的汉字的编码不同，对于不同的编码格式，还需要做内码的对应转换，把其他的格式转换成GB2312或者GBK格式然后调用字库显示。
" A* u: \" R, u2 M/ c　　其他常用编码格式Unicode、utf-8等的具体介绍和转换成GB编码可以百度。
/ r2 J$ Y9 E9 a* k/ Z! i& }　　SD卡注意事项：
3 ~1 O$ M; O' S' Y$ m7 L　　对一个文件读，必须先打开文件，读完后关闭。
　　对一个文件写，必须先打开文件，根据情况确定打开的权限，只读，读、写、创建等，先完后最好调用f_sync()函数，这是一个同步函数，类似于linux中的同步函数。SD卡中的写函数应该是带缓冲(猜的)，在关闭之前调用这个函数将缓冲区的内容写入SD卡中，然后关闭文件，否则可能写入失败，不能将内容成功写到文件上。
　　文件的打开路径，Windows中的文档可能是隐藏文件类型的，这个一定要注意，隐藏文件类型的a.txt和不隐藏文件类型的a.txt 不是同一个文件，这个一定要非常注意。

" c4 j. |& ^3 Y! ^; y
% e$ w. q& K  O+ w

ad_gao

现在STM32单片机用得人很多，资料也很详细