基于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个字节的点阵数据然后打点显示就可以把一个汉字显示出来了。
$ B7 Q; g' P  o　　获取点阵的代码如下

1. FATFS fs1; // 挂载SD卡的分区用
   
2. 
   
3. 　　FIL f1; // SD卡中字库的文件描述符
   2 M: D+ N' |6 K0 Y6 }. J% y- r- y
4. 
   ) b9 X7 r. I2 ?, z" Q5 r' ]
5. 　　FIL ftxt; // 要读取的txt文档的文件描述符
   
6. 
   ( r# u# ]4 r( Y9 r: M
7. 　　u8 fnGetChinese(u8 *p,u8 *buff) // 形参是要读取的汉字
   
8. 
   
9. 　　{
   ) A# m  u+ I* f% d4 S2 @9 V# P8 [
10. 
    : L) A$ ?$ i' X
11. 　　u8 res=0;
    : O6 z, W3 R: K" `2 T. k) H
12. 
    
13. 　　u8 H8,L8;
    
14. 
    
15. 　　UINT num;
    % J; x& Y8 H9 n; F* [7 x. b
16. 
    
17. 　　H8=*p;
    
18. 
    6 k) n% B; ~$ u& C' m' i4 q8 V
19. 　　L8=*(p+1);
    
20. 
    ) G! B6 a6 c5 |* B5 J" y, e
21. 　　f_mount(&fs1,"",1); // 挂载SD卡
    ( x" {% y2 S, B- G+ C" L
22. 
    4 I% g  |$ }. ]& l& Y) e/ P
23. 　　res=f_open(&f1,ReadPath,FA_OPEN_EXIStiNG|FA_READ); // 打开SD卡下的点阵字库
    
24. 
    
25. 　　IF(res!=0) // 判断点阵字库是否打开成功
    0 g) ^6 d+ c4 ]  y" a& {2 U
26. 
    
27. 　　{
    : a7 w- T" J. D
28. 
    
29. 　　fnShowString(10,120,"open hzk fail",16,RED,WHITE,0);
    9 n& a* s" w* B" V' k+ a  B; C0 \
30. 
    
31. 　　printf("res=%x",res);
    9 i+ ^# k7 u( v' E0 b, O* M4 I
32. 
    
33. 　　return 1;
    
34. 
    + N: l& C3 i9 K$ ]
35. 　　}
    ( m! O; c% E' ?$ a, ~
36. 
    
37. 　　else
    ; @+ V( M8 F# _1 t/ ~2 R
38. 
    
39. 　　{
      G- q# ^9 g# x6 T& j; J
40. 
    2 R# [# H7 X( V1 H& w& ~! z
41. 　　fnShowString(10,120,"open ok",16,RED,WHITE,0);
    7 P! c- m- O' w9 @" @, @' w
42. 
    
43. 　　}
    
44. 
    5 W# N$ v6 ~8 D
45. 　　f_lseek(&f1,32*((H8-0xa0-1)*94+(L8-0xa0-1))); // 在字库文件中做偏移取出32个字节的点阵数据
    
46. 
    
47. 　　res=f_read(&f1,buff,32,&num);
    ) P$ J7 K0 C, P9 Q
48. 
    7 h( z0 m) H7 m7 F% Y1 r+ C& }4 F
49. 　　f_close(&f1); // 读完后关闭点阵字库文件
    $ q0 ^2 v& C1 o, F5 V& o9 r
50. 
    ( c  i. J: M+ [  A
51. 　　f_mount(&fs1,"",NULL); // 卸载SD卡
    2 {  k# N+ c0 |. D+ c2 P  n" C
52. 
    
53. 　　return 0;
    
54. 
    & A0 D: c; H( L( G' O
55. 　　}

复制代码

　　这个是得到汉字点阵的实现过程，得到点阵数据后就可以在液晶上打点实现汉字的显示，具体的底层驱动不再详细介绍。
& f9 r! l: X/ `1 f! F" w3 E3 |　　实现了在单片内显示汉字串以后，能不能读取SD卡中的txt文档中的汉字在液晶屏上显示呢?这块是我自己想的，不知道与别人的一样不一样，反正是实现了。
( I/ N& W# R1 g　　首先我读取SD卡上txt文档上的一个汉字，然后用串口打印出来，发现，读到的就是汉字的内码，百度了下说windows中txt文档的显示的用GB2312的字库。既然读到直接是内码，那就好办了。汉字内码用的是两个字节，字符用的是一个字节，这个一定要注意，因为在以后显示的过程中要用。
: E. U" c3 u& W; y2 B& c+ ?8 C1 M　　下面直接贴代码：
$ {/ G5 N# w$ u- a, T! {4 W& d, [

1. // x,y在液晶屏上的显示位置，我的液晶屏是320*240 ，竖屏显示
   
2. 
   ' R) F$ `7 U! ]5 L
3. 　　// color 是画笔的颜色，BkColor 是背景颜色
   
4. 
   
5. 　　u8 fnShowTxt( u16 x, u16 y , u16 color ,u16 BkColor )
   
6. 
   0 v( n; i) s4 B; t5 a
7. 　　{
   $ F3 Z  T# ?$ R& E9 X
8. 
   
9. 　　u8 res=0; // SD卡函数的返回值
   7 Y# K% T3 C8 T7 k
10. 
    8 m- ?/ {# P- W. c8 z
11. 　　u8 buff[100]={0}; // 存储从txt文档中读到的100个字节的内码
    
12. 
    - d6 W1 N: O/ o1 n1 h2 f
13. 　　u8 bitbuff[32]={0}; // 存储从点阵字库获得的32个字节的点阵数据
    
14. 
    " V+ z6 M# W" r# C  y9 E% {/ f
15. 　　u8 NeiMaH,NeiMaL; // GB2312内码的高位和低位
    
16. 
    
17. 　　u8 CntnuF=1; // 用来 判断是不是读到文档的末尾了，如果读到字节的个数小于100则表示读到末尾了
    
18. 
    9 ]5 W# r* X1 `( Z/ D7 p- ?
19. 　　u16 offset=0; // 读txt文档的偏移地址
    
20. 
    
21. 　　u8 i=0;
    
22. 
    ; l' {% {. |5 D& v
23. 　　UINT Hznum,bytenum; // 实际读回的内码字节个数、点阵字节个数
    
24. 
    4 J  t9 A. N* p% s: i; b
25. 　　u16 x0,y0; // 点阵显示的位置
    
26. 
    $ X/ O& m" w1 o0 l1 g& U
27. 　　u8 charCnt=0; // 读取的100个字节内码中有几个字符，如果字符个数是偶数则下次偏移再偏移100，如果是奇数，
    
28. 
    
29. 　　// 则读取的100个字节中的最后一个字节可能是下一个汉字的内码高位字节，则偏移99，下次再把这个字节读上。
    
30. 
    ' J# \8 h- I! F. [% F5 A% `3 v  d
31. 　　x0=x;
    
32. 
    0 @1 B+ ]0 w+ M8 N- ]
33. 　　y0=y;
    ; S1 i1 R# D3 S# F3 ^
34. 
    
35. 　　f_mount(&fs1,"",1); // 挂载SD卡
    
36. 
    # X1 y$ ^8 j6 a  c5 \* @. d# D
37. 　　res=f_open(&f1,ReadPath,FA_OPEN_EXISTING|FA_READ); // 打开字库文件
    
38. 
    
39. 　　if(res!=0)
    ' W5 l0 u1 V6 h$ c2 q
40. 
    
41. 　　{
    0 @& _6 v, [( ^! {$ k  f2 t3 n
42. 
    
43. 　　fnShowString(10,120,"open hzk fail",16,RED,WHITE,0);
    ! D' N, Q# Y3 ]2 R( A' b7 M. f& ]
44. 
    
45. 　　printf("res=%x",res);
    
46. 
    
47. 　　return 1;
    - M; s# Q; T3 Q0 o
48. 
    " B* e0 z1 Y" e
49. 　　}
    
50. 
    * C1 r% f, ^4 h' W
51. 　　res=f_open(&ftxt,TxtPath,FA_OPEN_EXISTING|FA_READ); // 打开txt文档
    
52. 
    
53. 　　if(res!=0)
    
54. 
    
55. 　　{
    
56. 
    9 w; D3 ?' ^& M3 ~
57. 　　fnShowString(10,120,"open txt fail",16,RED,WHITE,0);
    
58. 
    
59. 　　printf("res=%x",res);
    
60. 
    
61. 　　return 1;
    " Q) R3 u% \' D) U- H' Q( W0 G4 `
62. 
    * E* T/ N+ |& L( |
63. 　　}
    & F* t0 V; q% d- o) Y& M
64. 
    7 q( B# D6 Q& J
65. 　　f_lseek(&ftxt,offset); // 初始化偏移为0从头开始读。
    ; B+ V$ ?  [1 P
66. 
    
67. 　　res=f_read(&ftxt,buff,100,&Hznum); // 每次读100个内码字节
    
68. 
    
69. 　　while(CntnuF) // 循环判断是不是读到文件末尾了
    8 Y6 x& B8 J; R' W  W* p
70. 
    & C; J2 \5 Y+ [: V1 ~
71. 　　{
    + b. Y# Y  N% b4 r
72. 
    7 }: C1 J* a0 |+ N
73. 　　for(i=0;i
    
74. 
    
75. 　　{
    $ O( w: H9 X3 E, ]9 d, R9 a& b( s
76. 
    
77. 　　if(x>220) // 显示位置的判断
    # m/ q$ Z- V" a' s: h% U
78. 
    
79. 　　{
    
80. 
    $ q8 ^, V; ^5 i8 R9 j
81. 　　x=x0;
    ! z+ ?+ I! ^. z
82. 
    
83. 　　y+=16;
    $ `, i( ?% E0 l# q' U4 s0 Z9 b
84. 
    
85. 　　}
    9 K( ]7 E/ v$ F
86. 
    
87. 　　if((y>300))
    
88. 
    % [" N0 A% x1 M2 v8 E$ t
89. 　　{
    9 S" U% z" Q( s2 B9 {& e
90. 
    7 X5 [. O6 ~! K
91. 　　fnRefreshscreen(WHITE);
    ! b0 T- I9 h- W" V: ^
92. 
    * |$ k) k" P& |, ~
93. 　　x=x0;
    
94. 
    
95. 　　y=y0;
    
96. 
    ! U3 w+ z1 g, a+ t' x: F/ e
97. 　　}
    
98. 
    # T* Z7 d! z! G- V* T
99. 　　if(buff>0x80) // 是不是汉字
    
100. 
     
101. 　　{
     : y( M  E! S4 D& K8 v! l9 P$ \4 K
102. 
     
103. 　　f_lseek(&f1,32*((buff-0xa0-1)*94+(buff[i+1]-0xa0-1))); // 点阵字库内的偏移
     
104. 
     + h2 R7 {" t; |( Q
105. 　　res=f_read(&f1,bitbuff,32,&bytenum);
     
106. 
     
107. 　　fnShowHzk(x,y,bitbuff,color,BkColor);
       ~. e7 f( [8 e# ]0 \
108. 
     
109. 　　x+=16;
     
110. 
     
111. 　　i++; // 这个i++非常重要，因为一个汉字两个字节，除了判断语句i++,
     
112. 
     & i, O% v( N! [$ s8 d2 ?" i
113. 　　// 这里需要还要一个
     
114. 
     . S! Y' i  K% N4 K& F
115. 　　memset(bitbuff,0,sizeof(bitbuff));
     
116. 
     0 e* {" Q, f1 X
117. 　　}
     $ m) _, b3 j$ Q3 i+ z9 _% g% R9 F
118. 
     2 D+ I$ N) j/ f4 w& o
119. 　　else // 可能是标点也可能是换行符
     
120. 
       W6 I% ^$ q5 Y( x" g
121. 　　{
     6 _  E6 G' m2 z8 j
122. 
     & z4 @; J: P' N5 k
123. 　　if(buff==0x0D) // 换行标志
     
124. 
     ; P" t. ?" r7 c! t) `8 ^7 [2 |- P
125. 　　y+=16;
     
126. 
     - S' L3 ^+ ?) f8 F
127. 　　else
     
128. 
     / M) p2 O3 n( ]! ~% _# D+ `
129. 　　fnShowChar( x,y,buff,16,color,BkColor,0); // 字符
     
130. 
     ' M6 X2 ]& _  Z2 ~1 G4 |
131. 　　x+=8;
     
132. 
     4 e# Q3 C( S2 i) c
133. 　　charCnt++; // 字符个数计算，用于判断下一次读txt文档的偏移地址
     9 x* s% S- x% p1 l- Q- J( s: j9 k  y4 X
134. 
     
135. 　　}
     
136. 
     
137. 　　}
     ! I; x. r+ y" _% X8 K+ v
138. 
     
139. 　　// 计算txt文档的偏移地址
     
140. 
     1 L5 A; \! B6 M2 Q. W" j
141. 　　if(Hznum!=100) // 判断是不是读到文档末尾了
     
142. 
     
143. 　　{
     ( ?/ Y5 B. ]8 W
144. 
     : T% o: V! H9 {- r( J& v; b' U0 q7 g
145. 　　CntnuF=0;
     + ~: R5 w! Y" ~
146. 
     
147. 　　}
     
148. 
     
149. 　　else // 没有读到末尾继续读
     
150. 
     
151. 　　{
     
152. 
     3 S4 |* y9 \' n2 W. [  F
153. 　　if(charCnt%2==0) // 字符个数是偶数，100个字节内码里边正好成对出现，地址偏移+100
     , h% N: Q8 K2 P) S/ a# @. ^- _( j
154. 
     7 G+ m$ r, T* F  g
155. 　　offset +=100;
     ) @0 K2 r: y: K* l5 ~: c" z. V
156. 
     
157. 　　else
     3 ^% H/ {  d* [4 @( ?5 ^
158. 
     ' b. G- f1 [. d1 T* X1 I) A
159. 　　offset +=99;
     
160. 
     4 H6 r9 L3 S  T4 H
161. 　　memset(buff,0,sizeof(buff));
     - v# L9 J3 y+ p8 x
162. 
     % ~/ t7 f! |4 i& Q1 k
163. 　　f_lseek(&ftxt,offset); // txt 文档地址偏移
     & [5 \* H! E& @6 Z7 ?4 Y1 `
164. 
     
165. 　　res=f_read(&ftxt,buff,100,&Hznum); // 读内码数据
     3 K. A0 F5 y/ ]( w; b
166. 
     
167. 　　}
     
168. 
     
169. 　　}
     
170. 
     
171. 　　f_close(&f1); // 关闭打开的点阵字库
     
172. 
     
173. 　　f_close(&ftxt); // 关闭打开的txt文档
     + S& J. _# V4 J* v8 x
174. 
     
175. 　　f_mount(&fs1,"",NULL); // 卸载磁盘
     - ^% w. u; k( _
176. 
     ) S* u0 F6 a9 G, Y: x: U
177. 　　return 0;
     
178. 
     
179. 　　}

复制代码

, W5 o0 Y6 V( _# u9 h　　以上是简单的电子书的实现。
2 f8 M$ |" G+ R# l& Q6 m# b* l/ ~$ j& s　　因为不同的系统有不同的编码这个要注意，比如我再Windows上的汉字拷贝到CSDN网页上就是乱码，这是因为使用的汉字的编码不同，对于不同的编码格式，还需要做内码的对应转换，把其他的格式转换成GB2312或者GBK格式然后调用字库显示。
　　其他常用编码格式Unicode、utf-8等的具体介绍和转换成GB编码可以百度。
　　SD卡注意事项：
# Y2 b* m8 j, ^　　对一个文件读，必须先打开文件，读完后关闭。
　　对一个文件写，必须先打开文件，根据情况确定打开的权限，只读，读、写、创建等，先完后最好调用f_sync()函数，这是一个同步函数，类似于linux中的同步函数。SD卡中的写函数应该是带缓冲(猜的)，在关闭之前调用这个函数将缓冲区的内容写入SD卡中，然后关闭文件，否则可能写入失败，不能将内容成功写到文件上。
　　文件的打开路径，Windows中的文档可能是隐藏文件类型的，这个一定要注意，隐藏文件类型的a.txt和不隐藏文件类型的a.txt 不是同一个文件，这个一定要非常注意。

- t' U: _, r* J. v

ad_gao

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