独闷闷网

标题: 跟大家分享字库芯片GT20L16S1Y的IO口模拟SPI和硬件SPI这两种C语言驱动程序。 [打印本页]

---

作者: jianhong_wu    时间: 2016-5-1 13:12
标题: 跟大家分享字库芯片GT20L16S1Y的IO口模拟SPI和硬件SPI这两种C语言驱动程序。


★坚鸿-深圳：
字库芯片GT20L16S1Y很常用，芯片内部的取模方式是：纵向取模，字节倒序。
现在我把它的IO口模拟SPI和硬件SPI这两种驱动程序都分享给大家参考，我是直接节选我项目中的片段，大家使用的时候只要做一些简单的删减移植
就能使用。建议大家使用的时候应该辅助GT20L16S1Y的数据手册来看比较方便理解，然后再取其精华。

（1）IO口模拟SPI的驱动程序：
.H头文件：

1. #ifndef _GT20L16S1Y_
   
2. #define _GT20L16S1Y_
   
3. 
   
4. #define SPI0_CS_ON()         (GPIO_WriteHigh(GPIOB,GPIO_PIN_4))          //拉高
   
5. #define SPI0_CS_OFF()        (GPIO_WriteLow(GPIOB,GPIO_PIN_4))           //拉低
   
6. 
   
7. #define SPI0_SCLK_ON()       (GPIO_WriteHigh(GPIOB,GPIO_PIN_3))          //拉高
   
8. #define SPI0_SCLK_OFF()      (GPIO_WriteLow(GPIOB,GPIO_PIN_3))           //拉低
   
9. 
   
10. #define SPI0_MOSI_ON()       (GPIO_WriteHigh(GPIOB,GPIO_PIN_2))          //拉高
    
11. #define SPI0_MOSI_OFF()      (GPIO_WriteLow(GPIOB,GPIO_PIN_2))           //拉低
    
12. 
    
13. void SPI0_clear(void);
    
14. unsigned char SPI0_readByte(void);
    
15. void SPI0_writeByte(unsigned char dat);
    
16. void WORDLIB_read_ASCII_8x16(unsigned int ASCIICode, unsigned char *buffer);
    
17. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer);
    
18. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt);
    
19. extern const unsigned char  Zf8x16_zheng_san_jiao[];
    
20. extern const unsigned char  Zf8x16_dao_san_jiao[];
    
21. extern const unsigned char  Zf8x16_quan_xian[];
    
22. extern const unsigned char  Zf8x16_men_kuang_tu[];
    
23. extern const unsigned char  Zf8x16_shuang_jian_tou[];
    
24. extern const unsigned char  Zf8x16_zuo_san_jiao[];
    
25. extern const unsigned char  Zf8x16_you_san_jiao[];
    
26. extern const unsigned char  Zf8x16_you_biao[];
    
27. extern const unsigned char  Hz16x16_kong[];
    
28. extern const unsigned char  Hz16x16_full[];
    
29. 
    
30. #endif
    
31. 
    
32. 
    
33. 
    
34. 
    
35. 
    
36. 
    
37. 
    
38. 
    

复制代码

.C源文件：

1. #include  "stm8s.h"
   
2. #include "GT20L16S1Y.h"
   
3. #include "delay.h"
   
4. 
   
5. const unsigned char  Zf8x16_zheng_san_jiao[]=
   
6. {     
   
7. /*--  文字:  正三角   --*/
   
8. 0x00,0x20,0x60,0xE0,0xE0,0xE0,0x60,0x20,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,//68
   
9. };
   
10. 
    
11. const unsigned char  Zf8x16_dao_san_jiao[]=
    
12. {     
    
13. /*--  文字:  倒三角   --*/
    
14. 0x00,0x80,0xC0,0xE0,0xC0,0x80,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,//67
    
15. };
    
16. 
    
17. const unsigned char  Zf8x16_quan_xian[]=
    
18. {     
    
19. /*--  文字:  全显  --*/
    
20. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, //71
    
21. };
    
22. 
    
23. const unsigned char  Zf8x16_men_kuang_tu[]=
    
24. {     
    
25. /*--  文字: 门框图--*/
    
26. 0x00,0xFE,0x02,0x02,0x02,0x02,0xFE,0x00,0x00,0x7F,0x40,0x40,0x40,0x40,0x7F,0x00, //73
    
27. };
    
28. 
    
29. const unsigned char  Zf8x16_shuang_jian_tou[]=
    
30. {     
    
31. /*--  文字: 双箭头--*/
    
32. 0x40,0x60,0x70,0x78,0x70,0x60,0x40,0x00,0x02,0x06,0x0E,0x1E,0x0E,0x06,0x02,0x00, //74
    
33. };
    
34. 
    
35. const unsigned char  Zf8x16_zuo_san_jiao[]=
    
36. {     
    
37. /*--  文字: 左三角 --*/
    
38. 0x00,0x00,0x80,0xC0,0xE0,0xF0,0xF8,0x00,0x00,0x01,0x03,0x07,0x0F,0x1F,0x3F,0x00, //77
    
39. };
    
40. 
    
41. const unsigned char  Zf8x16_you_san_jiao[]=
    
42. {     
    
43. /*--  文字: 右三角--*/
    
44. 0x00,0xF8,0xF0,0xE0,0xC0,0x80,0x00,0x00,0x00,0x3F,0x1F,0x0F,0x07,0x03,0x01,0x00, //78
    
45. };
    
46. 
    
47. const unsigned char  Zf8x16_you_biao[]=
    
48. {   
    
49. /*--  文字:     --*/
    
50. 0x00,0x80,0x80,0x90,0xA0,0xC0,0x80,0x00,0x00,0x00,0x00,0x04,0x02,0x01,0x00,0x00,
    
51. };
    
52. 
    
53. const unsigned char  Hz16x16_kong[]=
    
54. {
    
55. /*--  文字:  空白无  --*/
    
56. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,   //100
    
57. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
58. };
    
59. 
    
60. 
    
61. const unsigned char  Hz16x16_full[]=
    
62. {
    
63. /*--  文字:  全显  --*/
    
64. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    
65. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    
66. };
    
67. 
    
68. /*******************************************************
    
69. *  函数名称：SPI0_clear
    
70. *  函数功能：清除SPI总线状态
    
71. *  入口参数：无
    
72. *  出口参数：无
    
73. ******************************************************/
    
74. void SPI0_clear(void)
    
75. {
    
76.         SPI0_CS_ON();    //拉高
    
77.         SPI0_SCLK_ON();  //拉高
    
78.         SPI0_MOSI_ON();  //拉高
    
79. }
    
80. 
    
81. /*******************************************************
    
82. *  函数名称：SPI0_readByte
    
83. *  函数功能：SPI0读取一个字节数据
    
84. *  入口参数：无
    
85. *  出口参数：unsigned char
    
86. ******************************************************/
    
87. unsigned char SPI0_readByte(void)
    
88. {
    
89.         unsigned char  i;
    
90.         unsigned char  dat;
    
91.         
    
92.         for(i = 0; i < 8; i++)
    
93.         {
    
94.                 dat <<= 1;
    
95.                 SPI0_SCLK_OFF();          //下降沿，MISO字库芯片移出一个bit        
    
96.                 if(GPIO_ReadInputPin(GPIOB,GPIO_PIN_1)!= 0)
    
97.                 {
    
98.                         dat |= 0x01;
    
99.                 }
    
100.                 else
     
101.                 {
     
102.                         dat |= 0x00;
     
103.                 }
     
104.                 delay(1);
     
105.                 SPI0_SCLK_ON();
     
106.                 delay(1);
     
107.         }
     
108.         return dat;
     
109. }
     
110. 
     
111. /*******************************************************
     
112. *  函数名称：SPI0_writeByte
     
113. *  函数功能：SPI0写出一个字节数据
     
114. *  入口参数：unsigned char
     
115. *  出口参数：无
     
116. ******************************************************/
     
117. void SPI0_writeByte(unsigned char dat)
     
118. {
     
119.         unsigned char i;
     
120. 
     
121.         for(i = 0; i < 8; i++)
     
122.         {
     
123.                 SPI0_SCLK_OFF();                                                                                                
     
124.                 if(dat & 0x80)
     
125.                 {
     
126.                         SPI0_MOSI_ON();
     
127.                 }
     
128.                 else
     
129.                 {
     
130.                         SPI0_MOSI_OFF();
     
131.                 }
     
132.                 dat <<= 1;
     
133.                 delay(1);
     
134.                 SPI0_SCLK_ON();                                                                                                        //上升沿，MOSI字库芯片移入一个bit
     
135.                 delay(1);               
     
136.         }
     
137. }
     
138. 
     
139. /*******************************************************
     
140. *  函数名称：WORDLIB_read_ASCII_8x16
     
141. *  函数功能：读取字库芯片中一个ASCII字符的8x16点阵编码
     
142. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
     
143.                                  buffer必须大于等于16个字节。
     
144. *  出口参数：无
     
145. ******************************************************/
     
146. void WORDLIB_read_ASCII_8x16(unsigned int ASCIICode,unsigned char *buffer)
     
147. {
     
148. 
     
149.         unsigned long BaseAddr        = 0x3b7c0;     //8x16点阵的起始地址，见手册《GT23L32S4W用户手册》
     
150.         unsigned long WordAddr        = 0;              //ASCII字符点阵在芯片中的字节地址
     
151.         unsigned long ASCIICodeTemp   =0;
     
152.         const unsigned int BUFSIZE    = 16;        //缓冲区的大小
     
153.         unsigned char  i;
     
154. 
     
155.         ASCIICodeTemp=ASCIICode&0xff;
     
156.         //计算地址，见手册《GT20L16S1Y用户手册》
     
157.         
     
158.         
     
159.         
     
160.         if(ASCIICodeTemp==0x7E)
     
161.         {
     
162.            diy_zi_ku(Zf8x16_you_biao,buffer,BUFSIZE);
     
163.            return;
     
164.         }
     
165.         else if(ASCIICodeTemp==1)
     
166.         {
     
167.            diy_zi_ku(Zf8x16_zheng_san_jiao,buffer,BUFSIZE);
     
168.            return;
     
169.         }
     
170.         else if(ASCIICodeTemp==2)
     
171.         {
     
172.            diy_zi_ku(Zf8x16_dao_san_jiao,buffer,BUFSIZE);
     
173.            return;
     
174.         }
     
175.         else if(ASCIICodeTemp==255)
     
176.         {
     
177.            diy_zi_ku(Zf8x16_quan_xian,buffer,BUFSIZE);
     
178.            return;
     
179.         }   
     
180.         else if(ASCIICodeTemp==254)
     
181.         {
     
182.            diy_zi_ku(Zf8x16_men_kuang_tu,buffer,BUFSIZE);
     
183.            return;
     
184.         }   
     
185.         else if(ASCIICodeTemp==0)
     
186.         {
     
187.            diy_zi_ku(Zf8x16_shuang_jian_tou,buffer,BUFSIZE);
     
188.            return;
     
189.         }   
     
190.         else if(ASCIICodeTemp==23)
     
191.         {
     
192.            diy_zi_ku(Zf8x16_zuo_san_jiao,buffer,BUFSIZE);
     
193.            return;
     
194.         }   
     
195.         else if(ASCIICodeTemp==22)
     
196.         {
     
197.            diy_zi_ku(Zf8x16_you_san_jiao,buffer,BUFSIZE);
     
198.            return;
     
199.         }   
     
200.         else if((ASCIICodeTemp >= 0x20) && (ASCIICodeTemp <= 0x7E))
     
201.         {
     
202.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
     
203.         }
     
204.         else   //空格0x20
     
205.         {
     
206.                 ASCIICodeTemp=0x20;
     
207.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
     
208.         }   
     
209. 
     
210.         SPI0_clear();           //清除SPI总线
     
211.         delay(1);
     
212.         
     
213.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
214.         SPI0_CS_OFF();
     
215.         delay(1);
     
216.         
     
217.         SPI0_writeByte(0x0b);  //发送命令字：0x0B
     
218.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低，依次发送三个字节的地址
     
219.         SPI0_writeByte((WordAddr >> 8) & 0xff);
     
220.         SPI0_writeByte(WordAddr & 0xff);
     
221.         SPI0_writeByte(0xff);           //最后发送一个字节的假数据 Dummy Byte
     
222.         for(i = 0; i < BUFSIZE; i++)
     
223.         {
     
224.                 *(buffer + i)        = SPI0_readByte();                                                                //读取字库芯片发送过来的点阵编码
     
225.         }
     
226. 
     
227.         SPI0_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
228.         delay(1);
     
229. 
     
230.         SPI0_clear();                                                                                                                //清除SPI总线
     
231.         delay(1);
     
232. }
     
233. 
     
234. 
     
235. /*******************************************************
     
236. *  函数名称：WORDLIB_read_GB_16x16
     
237. *  函数功能：读取字库芯片中一个国标汉字的16x16点阵编码
     
238. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
239.                                  buffer必须大于等于32个字节。
     
240. *  出口参数：无
     
241. ******************************************************/
     
242. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer)
     
243. {
     
244.         unsigned long BaseAddr        = 0;       //16x16点阵的起始地址，见手册《GT20L16S1Y用户手册》
     
245.         unsigned long GBCode_MSB        = 0;   //汉字内码的高八位
     
246.         unsigned long GBCode_LSB        = 0;         //汉字内码的低八位
     
247.         unsigned long WordAddr        = 0;                      //汉字或者ASCII字符点阵在芯片中的字节地址
     
248.         const unsigned char BUFSIZE        = 32;              //缓冲区的大小
     
249.         unsigned char   i;
     
250.         GBCode_MSB        = (GBCode >> 8) & 0xFF;   //汉字内码的高八位
     
251.         GBCode_LSB        = GBCode & 0xFF;         //汉字内码的低八位
     
252. 
     
253.         //计算地址，见手册《GT20L16S1Y用户手册》
     
254.         if(GBCode==256||GBCode==0x2020)
     
255.         {
     
256.            diy_zi_ku(Hz16x16_kong,buffer,BUFSIZE);
     
257.            return;
     
258.         }
     
259.         else if(GBCode_MSB == 0xA9&& GBCode_LSB >= 0xA1)
     
260.         {
     
261.                 WordAddr        = (282+(GBCode_LSB-0xA1))*32+ BaseAddr;
     
262.         }
     
263.         else if(GBCode_MSB >= 0xA1&&GBCode_MSB <= 0xA3&& GBCode_LSB >= 0xA1)
     
264.         {
     
265.                 WordAddr        = (GBCode_MSB-0xA1)*94+(GBCode_LSB-0xA1)*32+ BaseAddr;
     
266.         }
     
267.         else if(GBCode_MSB >= 0xB0&&GBCode_MSB <= 0xF7&& GBCode_LSB >= 0xA1)
     
268.         {
     
269.                 WordAddr        = ((GBCode_MSB-0xB0)*94+(GBCode_LSB-0xA1)+846)*32+ BaseAddr;
     
270.         }
     
271. 
     
272.         SPI0_clear();           //清除SPI总线
     
273.         delay(1);
     
274.         
     
275.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
276.         SPI0_CS_OFF();
     
277.         delay(1);
     
278.         
     
279.         SPI0_writeByte(0x0B);                      //发送命令字：0x0B
     
280.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低，依次发送三个字节的地址
     
281.         SPI0_writeByte((WordAddr >> 8) & 0xff);
     
282.         SPI0_writeByte(WordAddr & 0xff);
     
283.         SPI0_writeByte(0xff);               //最后发送一个字节的假数据 Dummy Byte
     
284.         for(i = 0; i < BUFSIZE; i++)
     
285.         {
     
286.                 *(buffer + i)        = SPI0_readByte();    //读取字库芯片发送过来的点阵编码
     
287.         }
     
288. 
     
289.         SPI0_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
290.         delay(1);
     
291. 
     
292.         SPI0_clear();                                                                                                             //清除SPI总线
     
293.         delay(1);
     
294. }
     
295. 
     
296. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt)
     
297. {
     
298.    unsigned char i;
     
299.    for(i=0;i<ucZiKuCnt;i++)
     
300.    {
     
301.       pucResultBuffer[i]=pucConstZiKu[i];
     
302.    }
     
303. 
     
304. }
     
305. 
     

复制代码

（2）硬件SPI的驱动程序：
.H头文件：

1. #ifndef _GT20L16S1Y_
   
2. #define _GT20L16S1Y_
   
3. 
   
4. #define  SPI0_CS_DIR_OUT  (1)
   
5. #define  SPI0_CS_DIR_IN   (0)
   
6. 
   
7. #define  SPI0_CS_PORT  (2)
   
8. #define  SPI0_CS_PIN   (23)
   
9. #define  SPI0_CS_MASK  (1<<SPI0_CS_PIN)
   
10. 
    
11. 
    
12. #define  SPI0_CS_ON()     (GPIO_OutputValue(SPI0_CS_PORT, SPI0_CS_MASK, 1))
    
13. #define  SPI0_CS_OFF()    (GPIO_OutputValue(SPI0_CS_PORT, SPI0_CS_MASK, 0))
    
14. 
    
15. 
    
16. #define FIFOSIZE                  8
    
17. 
    
18. 
    
19. 
    
20. /* SSP CR1 register */
    
21. #define SSPCR1_LBM                (1 << 0)
    
22. #define SSPCR1_SSE                (1 << 1)
    
23. #define SSPCR1_MS                  (1 << 2)
    
24. #define SSPCR1_SOD                (1 << 3)
    
25. 
    
26. 
    
27. /* SSP Status register */
    
28. #define SSPSR_TFE                (1 << 0)
    
29. #define SSPSR_TNF                (1 << 1)
    
30. #define SSPSR_RNE                (1 << 2)
    
31. #define SSPSR_RFF                (1 << 3)
    
32. #define SSPSR_BSY                (1 << 4)
    
33. 
    
34. void Gt12l16s1y_Initial(void);
    
35. void SPI0_clear(void);
    
36. unsigned char SPI0_readByte(void);
    
37. void SPI0_writeByte(unsigned char dat);
    
38. void WORDLIB_read_ASCII_8x16(unsigned int ASCIICode, unsigned char *buffer);
    
39. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer);
    
40. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt);
    
41. 
    
42. 
    
43. 
    
44. #endif
    
45. 
    
46. 
    
47. 
    
48. 
    
49. 
    
50. 
    
51. 
    
52. 
    
53. 
    
54. 
    

复制代码

.C源文件：

1. #include "GT20L16S1Y.h"
   
2. #include "Timer.h"
   
3. #include "lpc177x_8x_gpio.h"
   
4. #include "lpc177x_8x_ssp.h"
   
5. #include "Delay.h"
   
6. #include "Can.h"
   
7. #include "UserGlobal.h"
   
8. 
   
9. 
   
10. 
    
11. 
    
12. void Gt12l16s1y_Initial(void)
    
13. {
    
14.       uint8_t i, Dummy=Dummy;
    
15.     //  uint8_t regVal;
    
16.         
    
17.                         /* Enable AHB clock to the SSP0. */
    
18.                         LPC_SC->PCONP |= (0x1<<21);
    
19. 
    
20.                         /* Further divider is needed on SSP clock. */
    
21.                 //        regVal = LPC_SC->PCLKSEL;
    
22.                 //        if ( regVal < 4 )
    
23.                 //        {
    
24.                 //                LPC_SC->PCLKSEL = 4;
    
25.         //                }
    
26.         
    
27. 
    
28.         
    
29.                         LPC_IOCON->P2_22 &= ~0x07;
    
30.                         LPC_IOCON->P2_22 |= 0x02;                /* SSP CLK */
    
31.                         LPC_IOCON->P2_26 &= ~0x07;
    
32.                         LPC_IOCON->P2_26 |= 0x02;                /* SSP MISO */
    
33.                         LPC_IOCON->P2_27 &= ~0x07;        
    
34.                         LPC_IOCON->P2_27 |= 0x02;                /* SSP MOSI */
    
35.         
    
36.             LPC_IOCON->P2_23 &= ~0x07;
    
37.             LPC_GPIO2->DIR |= (0x1<<23);
    
38.             LPC_GPIO2->SET |= (0x1<<23);  /* port2, bit 23(SSEL) is set to GPIO output and high */
    
39.                         
    
40.                         
    
41.                
    
42.                         /* Set DSS data to 8-bit, Frame format SPI, CPOL = 0, CPHA = 0, and SCR is 15 */
    
43.                         LPC_SSP0->CR0 = 0x0707;
    
44. 
    
45.                         /* SSPCPSR clock prescale register, master mode, minimum divisor is 0x02 */
    
46.                         LPC_SSP0->CPSR = 0x2;
    
47. 
    
48.                         for ( i = 0; i < FIFOSIZE; i++ )
    
49.                         {
    
50.                                 Dummy = LPC_SSP0->DR;                /* clear the RxFIFO */
    
51.                         }
    
52. 
    
53.                   /* Master mode */
    
54.                         LPC_SSP0->CR1 = SSPCR1_SSE;
    
55.                         
    
56. 
    
57. }
    
58. 
    
59. 
    
60. void SPI0_clear(void)           //清除SPI总线
    
61. {
    
62.    SPI0_CS_ON();   
    
63. }
    
64. 
    
65. 
    
66. 
    
67. /*******************************************************
    
68. *  函数名称：SPI0_readByte
    
69. *  函数功能：SPI0读取一个字节数据
    
70. *  入口参数：无
    
71. *  出口参数：unsigned char
    
72. ******************************************************/
    
73. unsigned char SPI0_readByte(void)
    
74. {
    
75.         unsigned char  dat;
    
76. 
    
77.                                 LPC_SSP0->DR = 0xFF;
    
78.                                 /* Wait until the Busy bit is cleared */
    
79.                                 while ( (LPC_SSP0->SR & (SSPSR_BSY|SSPSR_RNE)) != SSPSR_RNE );
    
80.                                 dat = LPC_SSP0->DR;
    
81.                                 
    
82.         return dat;
    
83. }
    
84. 
    
85. /*******************************************************
    
86. *  函数名称：SPI0_writeByte
    
87. *  函数功能：SPI0写出一个字节数据
    
88. *  入口参数：unsigned char
    
89. *  出口参数：无
    
90. ******************************************************/
    
91. void SPI0_writeByte(unsigned char dat)
    
92. {
    
93.     uint8_t Dummy = Dummy;
    
94.                                 
    
95.     /* Move on only if NOT busy and TX FIFO not full. */
    
96.           while ( (LPC_SSP0->SR & (SSPSR_TNF|SSPSR_BSY)) != SSPSR_TNF );
    
97.           LPC_SSP0->DR = dat;
    
98. 
    
99. 
    
100.           while ( (LPC_SSP0->SR & (SSPSR_BSY|SSPSR_RNE)) != SSPSR_RNE );
     
101.           /* Whenever a byte is written, MISO FIFO counter increments, Clear FIFO
     
102.           on MISO. Otherwise, when SSP0Receive() is called, previous data byte
     
103.           is left in the FIFO. */
     
104.           Dummy = LPC_SSP0->DR;
     
105. }
     
106. 
     
107. /*******************************************************
     
108. *  函数名称：WORDLIB_read_ASCII_8x16
     
109. *  函数功能：读取字库芯片中一个ASCII字符的8x16点阵编码
     
110. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
     
111.                                  buffer必须大于等于16个字节。
     
112. *  出口参数：无
     
113. ******************************************************/
     
114. void WORDLIB_read_ASCII_8x16(unsigned int ASCIICode,unsigned char *buffer)
     
115. {
     
116. 
     
117.         unsigned long BaseAddr        = 0x3b7c0;     //8x16点阵的起始地址，见手册《GT23L32S4W用户手册》
     
118.         unsigned long WordAddr        = 0;              //ASCII字符点阵在芯片中的字节地址
     
119.         unsigned long ASCIICodeTemp   =0;
     
120.         const unsigned int BUFSIZE    = 16;        //缓冲区的大小
     
121.         unsigned char  i;
     
122. 
     
123.         ASCIICodeTemp=ASCIICode&0xff;
     
124.         //计算地址，见手册《GT20L16S1Y用户手册》
     
125.         
     
126.         
     
127.         
     
128. 
     
129.         if((ASCIICodeTemp >= 0x20) && (ASCIICodeTemp <= 0x7E))
     
130.         {
     
131.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
     
132.         }
     
133.         else   //空格0x20
     
134.         {
     
135.                 ASCIICodeTemp=0x20;
     
136.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
     
137.         }   
     
138. 
     
139.         SPI0_clear();           //清除SPI总线
     
140.         u8Delay_42Ns(2);
     
141.         
     
142.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
143.         SPI0_CS_OFF();
     
144.         u8Delay_42Ns(2);
     
145.         
     
146.         SPI0_writeByte(0x0b);  //发送命令字：0x0B
     
147.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低，依次发送三个字节的地址
     
148.         SPI0_writeByte((WordAddr >> 8) & 0xff);
     
149.         SPI0_writeByte(WordAddr & 0xff);
     
150.         SPI0_writeByte(0xff);           //最后发送一个字节的假数据 Dummy Byte
     
151.         for(i = 0; i < BUFSIZE; i++)
     
152.         {
     
153.                 *(buffer + i)        = SPI0_readByte();                                                                //读取字库芯片发送过来的点阵编码
     
154.         }
     
155. 
     
156.         SPI0_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
157.         u8Delay_42Ns(2);
     
158. 
     
159.         SPI0_clear();                                                                                                                //清除SPI总线
     
160.         u8Delay_42Ns(2);
     
161. }
     
162. 
     
163. 
     
164. /*******************************************************
     
165. *  函数名称：WORDLIB_read_GB_16x16
     
166. *  函数功能：读取字库芯片中一个国标汉字的16x16点阵编码
     
167. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
168.                                  buffer必须大于等于32个字节。
     
169. *  出口参数：无
     
170. ******************************************************/
     
171. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer)
     
172. {
     
173.         unsigned long BaseAddr        = 0;       //16x16点阵的起始地址，见手册《GT20L16S1Y用户手册》
     
174.         unsigned long GBCode_MSB        = 0;   //汉字内码的高八位
     
175.         unsigned long GBCode_LSB        = 0;         //汉字内码的低八位
     
176.         unsigned long WordAddr        = 0;                      //汉字或者ASCII字符点阵在芯片中的字节地址
     
177.         const unsigned char BUFSIZE        = 32;              //缓冲区的大小
     
178.         unsigned char   i;
     
179.         GBCode_MSB        = (GBCode >> 8) & 0xFF;   //汉字内码的高八位
     
180.         GBCode_LSB        = GBCode & 0xFF;         //汉字内码的低八位
     
181. 
     
182.         //计算地址，见手册《GT20L16S1Y用户手册》
     
183. 
     
184.         if(GBCode_MSB == 0xA9&& GBCode_LSB >= 0xA1)
     
185.         {
     
186.                 WordAddr        = (282+(GBCode_LSB-0xA1))*32+ BaseAddr;
     
187.         }
     
188.         else if(GBCode_MSB >= 0xA1&&GBCode_MSB <= 0xA3&& GBCode_LSB >= 0xA1)
     
189.         {
     
190.                 WordAddr        = (GBCode_MSB-0xA1)*94+(GBCode_LSB-0xA1)*32+ BaseAddr;
     
191.         }
     
192.         else if(GBCode_MSB >= 0xB0&&GBCode_MSB <= 0xF7&& GBCode_LSB >= 0xA1)
     
193.         {
     
194.                 WordAddr        = ((GBCode_MSB-0xB0)*94+(GBCode_LSB-0xA1)+846)*32+ BaseAddr;
     
195.         }
     
196. 
     
197.         SPI0_clear();           //清除SPI总线
     
198.         u8Delay_42Ns(2);
     
199.         
     
200.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
201.         SPI0_CS_OFF();
     
202.         u8Delay_42Ns(2);
     
203.         
     
204.         SPI0_writeByte(0x0B);                      //发送命令字：0x0B
     
205.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低，依次发送三个字节的地址
     
206.         SPI0_writeByte((WordAddr >> 8) & 0xff);
     
207.         SPI0_writeByte(WordAddr & 0xff);
     
208.         SPI0_writeByte(0xff);               //最后发送一个字节的假数据 Dummy Byte
     
209.         for(i = 0; i < BUFSIZE; i++)
     
210.         {
     
211.                 *(buffer + i)        = SPI0_readByte();    //读取字库芯片发送过来的点阵编码
     
212.         }
     
213. 
     
214.         SPI0_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
215.         u8Delay_42Ns(2);
     
216. 
     
217.         SPI0_clear();                                                                                                             //清除SPI总线
     
218.         u8Delay_42Ns(2);
     
219. }
     
220. 
     
221. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt)
     
222. {
     
223.    unsigned char i;
     
224.    for(i=0;i<ucZiKuCnt;i++)
     
225.    {
     
226.       pucResultBuffer[i]=pucConstZiKu[i];
     
227.    }
     
228. 
     
229. }
     
230. 
     

复制代码

---

欢迎光临 独闷闷网 (http://dumenmen.com/)

Powered by Discuz! X3.2