使用STM32F103VB芯片模拟SPI时序读取字库芯片GT30L32S4W

Lawrence

★坚鸿-深圳：
我点评一下，以下代码有段内容很容易出错，尤其是在移植到不同的单片机编译器上的时候，这段代码是在读取字库芯片数据时，参与地址变换的变量GBCode_MSB和GBCode_LSB不应该用8位的字节，很容易溢出出错。比如：

1.         uint32_t BaseAddr        = 0x2C9D0;                                                                                //16x16点阵的起始地址，见手册《GT23L32S4W用户手册》
   
2.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
   
3.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
   
4.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
   
5.         const uint32_t BUFSIZE        = 32;                                                                                //缓冲区的大小
   
6.         uint8_t        i;

复制代码

应该改成

1.         uint32_t BaseAddr        = 0x2C9D0;                                                                                //16x16点阵的起始地址，见手册《GT23L32S4W用户手册》
   
2.         uint32_t  GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
   
3.         uint32_t  GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
   
4.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
   
5.         const uint32_t BUFSIZE        = 32;                                                                                //缓冲区的大小
   
6.         uint8_t        i;

复制代码

//-------------坚鸿点评分割线------------------------------------------------------------------------------------------------------------------------------------


spi0.h文件

1. 
   
2. #include "stm32f10x.h"
   
3. #include "delay.h"
   
4. 
   
5. #ifndef        __SPI0__H_
   
6. #define __SPI0__H_
   
7. 
   
8. //MISO(MOSI)，M是主控CPU，S是SPI字库芯片
   
9. #define SPI0_CS_ON()        (GPIO_SetBits(GPIOA, GPIO_Pin_4))                                //拉高
   
10. #define SPI0_CS_OFF()        (GPIO_ResetBits(GPIOA, GPIO_Pin_4))                                //拉低
    
11. 
    
12. #define SPI0_SCLK_ON()        (GPIO_SetBits(GPIOA, GPIO_Pin_5))                                //拉高
    
13. #define SPI0_SCLK_OFF()        (GPIO_ResetBits(GPIOA, GPIO_Pin_5))                                //拉低
    
14. 
    
15. #define SPI0_MOSI_ON()        (GPIO_SetBits(GPIOA, GPIO_Pin_7))                                //拉高
    
16. #define SPI0_MOSI_OFF()        (GPIO_ResetBits(GPIOA, GPIO_Pin_7))                                //拉低
    
17. 
    
18. #define SPI0_MISO_READ()        ((uint8_t)GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6))        //读取MISO的电平
    
19. 
    
20. /*******************************************************
    
21. *  函数名称：SPI0_init
    
22. *  函数功能：初始化SPI0(驱动字库的模拟SPI接口)的IO口
    
23. *  入口参数：无
    
24. *  出口参数：无
    
25. ******************************************************/
    
26. void SPI0_init(void);
    
27. 
    
28. /*******************************************************
    
29. *  函数名称：SPI0_clear
    
30. *  函数功能：清除SPI总线状态
    
31. *  入口参数：无
    
32. *  出口参数：无
    
33. ******************************************************/
    
34. void SPI0_clear(void);
    
35. 
    
36. /*******************************************************
    
37. *  函数名称：SPI0_readByte
    
38. *  函数功能：SPI0读取一个字节数据
    
39. *  入口参数：无
    
40. *  出口参数：unsigned char
    
41. ******************************************************/
    
42. uint8_t SPI0_readByte(void);
    
43. 
    
44. /*******************************************************
    
45. *  函数名称：SPI0_writeByte
    
46. *  函数功能：SPI0写出一个字节数据
    
47. *  入口参数：unsigned char
    
48. *  出口参数：无
    
49. ******************************************************/
    
50. void SPI0_writeByte(uint8_t dat);
    
51. 
    
52. 
    
53. 
    
54. 
    
55. #endif        /* end of file */
    
56. 
    
57. 
    
58. 
    
59. 
    

复制代码

spi0.c文件

1. 
   
2. #include "spi0.h"
   
3. 
   
4. /*******************************************************
   
5. *  函数名称：SPI0_init
   
6. *  函数功能：初始化SPI0(驱动字库的模拟SPI接口)的IO口
   
7. *  入口参数：无
   
8. *  出口参数：无
   
9. ******************************************************/
   
10. void SPI0_init(void)
    
11. {
    
12. GPIO_InitTypeDef GPIO_InitStructure;
    
13.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
14.         
    
15.         // spi0 gpio configuration
    
16.         // CS - PA.4        SCK - PA.5        MISO - PA.6                MOSI - PA.7
    
17.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;                                   
    
18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                        //推挽输出
    
19.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                                         //口线翻转速度为50MHz
    
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
21. 
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;                                   
    
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                        //推挽输出
    
24.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
25. 
    
26.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;                                   
    
27.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                                                //上拉输入
    
28.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
29. 
    
30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;                                   
    
31.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                        //推挽输出
    
32.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
33. 
    
34.         SPI0_clear();                                                                                                                //清除SPI总线状态
    
35. }
    
36. 
    
37. /*******************************************************
    
38. *  函数名称：SPI0_clear
    
39. *  函数功能：清除SPI总线状态
    
40. *  入口参数：无
    
41. *  出口参数：无
    
42. ******************************************************/
    
43. void SPI0_clear(void)
    
44. {
    
45.         SPI0_CS_ON();                                                                                                                //拉高
    
46.         SPI0_SCLK_ON();                                                                                                                //拉高
    
47.         SPI0_MOSI_ON();                                                                                                                //拉高
    
48. }
    
49. 
    
50. /*******************************************************
    
51. *  函数名称：SPI0_readByte
    
52. *  函数功能：SPI0读取一个字节数据
    
53. *  入口参数：无
    
54. *  出口参数：unsigned char
    
55. ******************************************************/
    
56. uint8_t SPI0_readByte(void)
    
57. {
    
58.         uint8_t i;
    
59.         uint8_t        dat;
    
60.         
    
61.         for(i = 0; i < 8; i++)
    
62.         {
    
63.                 dat <<= 1;
    
64.                 SPI0_SCLK_OFF();                                                                                                //下降沿，MISO字库芯片移出一个bit        
    
65.                 if(SPI0_MISO_READ() == 1)
    
66.                 {
    
67.                         dat |= 0x01;
    
68.                 }
    
69.                 else
    
70.                 {
    
71.                         dat |= 0x00;
    
72.                 }
    
73.                 delay_nop(2);
    
74.                 SPI0_SCLK_ON();
    
75.                 delay_nop(10);
    
76.         }
    
77.         return dat;
    
78. }
    
79. 
    
80. /*******************************************************
    
81. *  函数名称：SPI0_writeByte
    
82. *  函数功能：SPI0写出一个字节数据
    
83. *  入口参数：unsigned char
    
84. *  出口参数：无
    
85. ******************************************************/
    
86. void SPI0_writeByte(uint8_t dat)
    
87. {
    
88.         uint8_t i;
    
89. 
    
90.         for(i = 0; i < 8; i++)
    
91.         {
    
92.                 SPI0_SCLK_OFF();                                                                                                
    
93.                 if(dat & 0x80)
    
94.                 {
    
95.                         SPI0_MOSI_ON();
    
96.                 }
    
97.                 else
    
98.                 {
    
99.                         SPI0_MOSI_OFF();
    
100.                 }
     
101.                 dat <<= 1;
     
102.                 delay_nop(2);
     
103.                 SPI0_SCLK_ON();                                                                                                        //上升沿，MOSI字库芯片移入一个bit
     
104.                 delay_nop(10);               
     
105.         }
     
106. }
     
107. 
     

复制代码

字库驱动程序wordlib.h

1. 
   
2. #include "stm32f10x.h"
   
3. #include "delay.h"
   
4. #include "spi0.h"
   
5. 
   
6. #ifndef        __WORDLIB__H_
   
7. #define __WORDLIB__H_
   
8. 
   
9. //SPI0模拟时序的底层函数调用封装
   
10. #define SPI_CLEAR()                (SPI0_clear())
    
11. #define SPI_CS_ON()                (SPI0_CS_ON())
    
12. #define SPI_CS_OFF()        (SPI0_CS_OFF())
    
13. #define SPI_WRITE_BYTE(dat)                (SPI0_writeByte((dat)))
    
14. #define SPI_READ_BYTE()                        (SPI0_readByte())
    
15. 
    
16. 
    
17. //指令表
    
18. #define CMD_READ_WORDLIB                (0x03)                                                                                //读取数据命令
    
19. #define CMD_FASTREAD_WORDLIB        (0x0B)                                                                                //快速读取数据命令
    
20. #define CMD_DUMMY                                (0xFF)                                                                              //空指令、假数据
    
21. 
    
22. /*===============================================ASCII取码（非扩展等宽字符）==============================================*/
    
23. /*******************************************************
    
24. *  函数名称：WORDLIB_read_ASCII_5x7
    
25. *  函数功能：读取字库芯片中一个ASCII字符的5x7点阵编码
    
26. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
27.                                  buffer必须大于等于8个字节。
    
28. *  出口参数：无
    
29. ******************************************************/
    
30. void WORDLIB_read_ASCII_5x7(uint16_t ASCIICode, uint8_t *buffer);
    
31. 
    
32. /*******************************************************
    
33. *  函数名称：WORDLIB_read_ASCII_7x8
    
34. *  函数功能：读取字库芯片中一个ASCII字符的7x8点阵编码
    
35. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
36.                                  buffer必须大于等于8个字节。
    
37. *  出口参数：无
    
38. ******************************************************/
    
39. void WORDLIB_read_ASCII_7x8(uint16_t ASCIICode, uint8_t *buffer);
    
40. 
    
41. /*******************************************************
    
42. *  函数名称：WORDLIB_read_ASCII_6x12
    
43. *  函数功能：读取字库芯片中一个ASCII字符的6x12点阵编码
    
44. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
45.                                  buffer必须大于等于12个字节。
    
46. *  出口参数：无
    
47. ******************************************************/
    
48. void WORDLIB_read_ASCII_6x12(uint16_t ASCIICode, uint8_t *buffer);
    
49. 
    
50. /*******************************************************
    
51. *  函数名称：WORDLIB_read_ASCII_8x16
    
52. *  函数功能：读取字库芯片中一个ASCII字符的8x16点阵编码
    
53. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
54.                                  buffer必须大于等于16个字节。
    
55. *  出口参数：无
    
56. ******************************************************/
    
57. void WORDLIB_read_ASCII_8x16(uint16_t ASCIICode, uint8_t *buffer);
    
58. 
    
59. /*******************************************************
    
60. *  函数名称：WORDLIB_read_ASCII_12x24
    
61. *  函数功能：读取字库芯片中一个ASCII字符的12x24点阵编码
    
62. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
63.                                  buffer必须大于等于48个字节。
    
64. *  出口参数：无
    
65. ******************************************************/
    
66. void WORDLIB_read_ASCII_12x24(uint16_t ASCIICode, uint8_t *buffer);
    
67. 
    
68. /*******************************************************
    
69. *  函数名称：WORDLIB_read_ASCII_16x32
    
70. *  函数功能：读取字库芯片中一个ASCII字符的16x32点阵编码
    
71. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
72.                                  buffer必须大于等于64个字节。
    
73. *  出口参数：无
    
74. ******************************************************/
    
75. void WORDLIB_read_ASCII_16x32(uint16_t ASCIICode, uint8_t *buffer);
    
76. 
    
77. 
    
78. 
    
79. 
    
80. /*===============================================国标汉字取码（非扩展等宽字符）===========================================*/
    
81. /*******************************************************
    
82. *  函数名称：WORDLIB_read_GB_12x12
    
83. *  函数功能：读取字库芯片中一个国标汉字的12x12点阵编码
    
84. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
    
85.                                  buffer必须大于等于24个字节。
    
86. *  出口参数：无
    
87. ******************************************************/
    
88. void WORDLIB_read_GB_12x12(uint16_t GBCode, uint8_t *buffer);
    
89. 
    
90. /*******************************************************
    
91. *  函数名称：WORDLIB_read_GB_16x16
    
92. *  函数功能：读取字库芯片中一个国标汉字的16x16点阵编码
    
93. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
    
94.                                  buffer必须大于等于32个字节。
    
95. *  出口参数：无
    
96. ******************************************************/
    
97. void WORDLIB_read_GB_16x16(uint16_t GBCode, uint8_t *buffer);
    
98. 
    
99. /*******************************************************
    
100. *  函数名称：WORDLIB_read_GB_24x24
     
101. *  函数功能：读取字库芯片中一个国标汉字的24x24点阵编码
     
102. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
103.                                  buffer必须大于等于72个字节。
     
104. *  出口参数：无
     
105. ******************************************************/
     
106. void WORDLIB_read_GB_24x24(uint16_t GBCode, uint8_t *buffer);
     
107. 
     
108. /*******************************************************
     
109. *  函数名称：WORDLIB_read_GB_32x32
     
110. *  函数功能：读取字库芯片中一个国标汉字的32x32点阵编码
     
111. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
112.                                  buffer的大小必须是128个字节。
     
113. *  出口参数：无
     
114. ******************************************************/
     
115. void WORDLIB_read_GB_32x32(uint16_t GBCode, uint8_t *buffer);
     
116. 
     
117. 
     
118. 
     
119. 
     
120. #endif        /* end of file */
     
121. 
     
122. 
     

复制代码

字库驱动程序wordlib.c

1. 
   
2. #include "wordlib.h"
   
3. 
   
4. /*===============================================ASCII取码（非扩展等宽字符）==============================================*/
   
5. /*******************************************************
   
6. *  函数名称：WORDLIB_read_ASCII_5x7
   
7. *  函数功能：读取字库芯片中一个ASCII字符的5x7点阵编码
   
8. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
   
9.                                  buffer必须大于等于8个字节。
   
10. *  出口参数：无
    
11. ******************************************************/
    
12. void WORDLIB_read_ASCII_5x7(uint16_t ASCIICode, uint8_t *buffer)
    
13. {
    
14.         uint32_t BaseAddr        = 0x1DDF80;                                                                                //5x7点阵的起始地址，见手册《GT23L32S4W用户手册》
    
15.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
    
16.         const uint32_t BUFSIZE        = 8;                                                                                //缓冲区的大小
    
17.         uint8_t        i;
    
18. 
    
19.         //计算地址，见手册《GT23L32S4W用户手册》
    
20.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
    
21.         {
    
22.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
    
23.         }
    
24. 
    
25.         SPI_CLEAR();                                                                                                                //清除SPI总线
    
26.         delay_nop(10);
    
27.         
    
28.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
    
29.         SPI_CS_OFF();
    
30.         delay_nop(10);
    
31.         
    
32.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
    
33.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
    
34.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
    
35.         SPI_WRITE_BYTE(WordAddr & 0xff);
    
36.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
    
37.         //delay_nop(10);
    
38.         for(i = 0; i < BUFSIZE; i++)
    
39.         {
    
40.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
    
41.         }
    
42. 
    
43.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
    
44.         delay_nop(10);
    
45. 
    
46.         SPI_CLEAR();                                                                                                                //清除SPI总线
    
47.         delay_nop(10);
    
48. }
    
49. 
    
50. /*******************************************************
    
51. *  函数名称：WORDLIB_read_ASCII_7x8
    
52. *  函数功能：读取字库芯片中一个ASCII字符的7x8点阵编码
    
53. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
54.                                  buffer必须大于等于8个字节。
    
55. *  出口参数：无
    
56. ******************************************************/
    
57. void WORDLIB_read_ASCII_7x8(uint16_t ASCIICode, uint8_t *buffer)
    
58. {
    
59. 
    
60.         uint32_t BaseAddr        = 0x1DE280;                                                                                //7x8点阵的起始地址，见手册《GT23L32S4W用户手册》
    
61.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
    
62.         const uint32_t BUFSIZE        = 8;                                                                                //缓冲区的大小
    
63.         uint8_t        i;
    
64. 
    
65.         //计算地址，见手册《GT23L32S4W用户手册》
    
66.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
    
67.         {
    
68.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
    
69.         }
    
70. 
    
71.         SPI_CLEAR();                                                                                                                //清除SPI总线
    
72.         delay_nop(10);
    
73.         
    
74.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
    
75.         SPI_CS_OFF();
    
76.         delay_nop(10);
    
77.         
    
78.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
    
79.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
    
80.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
    
81.         SPI_WRITE_BYTE(WordAddr & 0xff);
    
82.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
    
83.         //delay_nop(10);
    
84.         for(i = 0; i < BUFSIZE; i++)
    
85.         {
    
86.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
    
87.         }
    
88. 
    
89.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
    
90.         delay_nop(10);
    
91. 
    
92.         SPI_CLEAR();                                                                                                                //清除SPI总线
    
93.         delay_nop(10);
    
94. }
    
95. 
    
96. /*******************************************************
    
97. *  函数名称：WORDLIB_read_ASCII_6x12
    
98. *  函数功能：读取字库芯片中一个ASCII字符的6x12点阵编码
    
99. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
    
100.                                  buffer必须大于等于12个字节。
     
101. *  出口参数：无
     
102. ******************************************************/
     
103. void WORDLIB_read_ASCII_6x12(uint16_t ASCIICode, uint8_t *buffer)
     
104. {
     
105. 
     
106.         uint32_t BaseAddr        = 0x1DBE00;                                                                                //6x12点阵的起始地址，见手册《GT23L32S4W用户手册》
     
107.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
     
108.         const uint32_t BUFSIZE        = 12;                                                                                //缓冲区的大小
     
109.         uint8_t        i;
     
110. 
     
111.         //计算地址，见手册《GT23L32S4W用户手册》
     
112.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
     
113.         {
     
114.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
     
115.         }
     
116. 
     
117.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
118.         delay_nop(10);
     
119.         
     
120.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
121.         SPI_CS_OFF();
     
122.         delay_nop(10);
     
123.         
     
124.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
125.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
126.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
127.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
128.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
129.         //delay_nop(10);
     
130.         for(i = 0; i < BUFSIZE; i++)
     
131.         {
     
132.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
133.         }
     
134. 
     
135.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
136.         delay_nop(10);
     
137. 
     
138.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
139.         delay_nop(10);
     
140. }
     
141. 
     
142. /*******************************************************
     
143. *  函数名称：WORDLIB_read_ASCII_8x16
     
144. *  函数功能：读取字库芯片中一个ASCII字符的8x16点阵编码
     
145. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
     
146.                                  buffer必须大于等于16个字节。
     
147. *  出口参数：无
     
148. ******************************************************/
     
149. void WORDLIB_read_ASCII_8x16(uint16_t ASCIICode, uint8_t *buffer)
     
150. {
     
151. 
     
152.         uint32_t BaseAddr        = 0x1DD780;                                                                                //8x16点阵的起始地址，见手册《GT23L32S4W用户手册》
     
153.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
     
154.         const uint32_t BUFSIZE        = 16;                                                                                //缓冲区的大小
     
155.         uint8_t        i;
     
156. 
     
157.         //计算地址，见手册《GT23L32S4W用户手册》
     
158.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
     
159.         {
     
160.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
     
161.         }
     
162. 
     
163.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
164.         delay_nop(10);
     
165.         
     
166.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
167.         SPI_CS_OFF();
     
168.         delay_nop(10);
     
169.         
     
170.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
171.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
172.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
173.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
174.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
175.         //delay_nop(10);
     
176.         for(i = 0; i < BUFSIZE; i++)
     
177.         {
     
178.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
179.         }
     
180. 
     
181.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
182.         delay_nop(10);
     
183. 
     
184.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
185.         delay_nop(10);
     
186. }
     
187. 
     
188. /*******************************************************
     
189. *  函数名称：WORDLIB_read_ASCII_12x24
     
190. *  函数功能：读取字库芯片中一个ASCII字符的12x24点阵编码
     
191. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
     
192.                                  buffer必须大于等于48个字节。
     
193. *  出口参数：无
     
194. ******************************************************/
     
195. void WORDLIB_read_ASCII_12x24(uint16_t ASCIICode, uint8_t *buffer)
     
196. {
     
197.         uint32_t BaseAddr        = 0x1DFF00;                                                                                //12x24点阵的起始地址，见手册《GT23L32S4W用户手册》
     
198.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
     
199.         const uint32_t BUFSIZE        = 48;                                                                                //缓冲区的大小
     
200.         uint8_t        i;
     
201. 
     
202.         //计算地址，见手册《GT23L32S4W用户手册》
     
203.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
     
204.         {
     
205.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
     
206.         }
     
207. 
     
208.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
209.         delay_nop(10);
     
210.         
     
211.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
212.         SPI_CS_OFF();
     
213.         delay_nop(10);
     
214.         
     
215.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
216.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
217.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
218.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
219.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
220.         //delay_nop(10);
     
221.         for(i = 0; i < BUFSIZE; i++)
     
222.         {
     
223.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
224.         }
     
225. 
     
226.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
227.         delay_nop(10);
     
228. 
     
229.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
230.         delay_nop(10);
     
231. }
     
232. 
     
233. /*******************************************************
     
234. *  函数名称：WORDLIB_read_ASCII_16x32
     
235. *  函数功能：读取字库芯片中一个ASCII字符的16x32点阵编码
     
236. *  入口参数：ASCIICode，ASCII码；buffer，点阵编码的缓冲区；
     
237.                                  buffer必须大于等于64个字节。
     
238. *  出口参数：无
     
239. ******************************************************/
     
240. void WORDLIB_read_ASCII_16x32(uint16_t ASCIICode, uint8_t *buffer)
     
241. {
     
242.         uint32_t BaseAddr        = 0x1E5A50;                                                                                //16x32点阵的起始地址，见手册《GT23L32S4W用户手册》
     
243.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
     
244.         const uint32_t BUFSIZE        = 64;                                                                                //缓冲区的大小
     
245.         uint8_t        i;
     
246. 
     
247.         //计算地址，见手册《GT23L32S4W用户手册》
     
248.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
     
249.         {
     
250.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
     
251.         }
     
252. 
     
253.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
254.         delay_nop(10);
     
255.         
     
256.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
257.         SPI_CS_OFF();
     
258.         delay_nop(10);
     
259.         
     
260.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
261.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
262.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
263.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
264.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
265.         //delay_nop(10);
     
266.         for(i = 0; i < BUFSIZE; i++)
     
267.         {
     
268.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
269.         }
     
270. 
     
271.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
272.         delay_nop(10);
     
273. 
     
274.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
275.         delay_nop(10);
     
276. }
     
277. 
     
278. 
     
279. /*===============================================国标汉字取码（非扩展等宽字符）===========================================*/
     
280. /*******************************************************
     
281. *  函数名称：WORDLIB_read_GB_12x12
     
282. *  函数功能：读取字库芯片中一个国标汉字的12x12点阵编码
     
283. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
284.                                  buffer必须大于等于24个字节。
     
285. *  出口参数：无
     
286. ******************************************************/
     
287. void WORDLIB_read_GB_12x12(uint16_t GBCode, uint8_t *buffer)
     
288. {
     
289.         uint32_t BaseAddr        = 0;                                                                                        //12x12点阵的起始地址，见手册《GT23L32S4W用户手册》
     
290.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
     
291.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
     
292.         uint32_t WordAddr        = 0;                                                                                        //汉字点阵在芯片中的字节地址
     
293.         const uint32_t BUFSIZE        = 24;                                                                                //缓冲区的大小
     
294.         uint8_t        i;
     
295. 
     
296.         //计算地址，见手册《GT23L32S4W用户手册》
     
297.         if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA3) && (GBCode_LSB >= 0xA1))
     
298.         {
     
299.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
     
300.         }
     
301.         else if((GBCode_MSB == 0xA9) &&        (GBCode_LSB >= 0xA1))
     
302.         {
     
303.                 WordAddr        = (282 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
     
304.         }
     
305.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
     
306.         {
     
307.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
     
308.         }
     
309. 
     
310.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
311.         delay_nop(10);
     
312.         
     
313.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
314.         SPI_CS_OFF();
     
315.         delay_nop(10);
     
316.         
     
317.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
318.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
319.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
320.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
321.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
322.         //delay_nop(10);
     
323.         for(i = 0; i < BUFSIZE; i++)
     
324.         {
     
325.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
326.         }
     
327. 
     
328.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
329.         delay_nop(10);
     
330. 
     
331.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
332.         delay_nop(10);
     
333. }
     
334. 
     
335. /*******************************************************
     
336. *  函数名称：WORDLIB_read_GB_16x16
     
337. *  函数功能：读取字库芯片中一个国标汉字的16x16点阵编码
     
338. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
339.                                  buffer必须大于等于32个字节。
     
340. *  出口参数：无
     
341. ******************************************************/
     
342. void WORDLIB_read_GB_16x16(uint16_t GBCode, uint8_t *buffer)
     
343. {
     
344.         uint32_t BaseAddr        = 0x2C9D0;                                                                                //16x16点阵的起始地址，见手册《GT23L32S4W用户手册》
     
345.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
     
346.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
     
347.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
     
348.         const uint32_t BUFSIZE        = 32;                                                                                //缓冲区的大小
     
349.         uint8_t        i;
     
350. 
     
351.         //计算地址，见手册《GT23L32S4W用户手册》
     
352.         if((GBCode_MSB >= 0xA4) && (GBCode_MSB <= 0xA8) && (GBCode_LSB >= 0xA1))
     
353.         {
     
354.                 WordAddr        = BaseAddr;
     
355.         }
     
356.         else if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA9) &&        (GBCode_LSB >= 0xA1))
     
357.         {
     
358.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
     
359.         }
     
360.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
     
361.         {
     
362.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
     
363.         }
     
364. 
     
365.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
366.         delay_nop(10);
     
367.         
     
368.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
369.         SPI_CS_OFF();
     
370.         delay_nop(10);
     
371.         
     
372.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
373.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
374.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
375.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
376.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
377.         //delay_nop(10);
     
378.         for(i = 0; i < BUFSIZE; i++)
     
379.         {
     
380.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
381.         }
     
382. 
     
383.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
384.         delay_nop(10);
     
385. 
     
386.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
387.         delay_nop(10);
     
388. }
     
389. 
     
390. /*******************************************************
     
391. *  函数名称：WORDLIB_read_GB_24x24
     
392. *  函数功能：读取字库芯片中一个国标汉字的24x24点阵编码
     
393. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
394.                                  buffer必须大于等于72个字节。
     
395. *  出口参数：无
     
396. ******************************************************/
     
397. void WORDLIB_read_GB_24x24(uint16_t GBCode, uint8_t *buffer)
     
398. {
     
399. 
     
400.         uint32_t BaseAddr        = 0x68190;                                                                                //24x24点阵的起始地址，见手册《GT23L32S4W用户手册》
     
401.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
     
402.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
     
403.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
     
404.         const uint32_t BUFSIZE        = 72;                                                                                //缓冲区的大小
     
405.         uint8_t        i;
     
406. 
     
407.         //计算地址，见手册《GT23L32S4W用户手册》
     
408.         if((GBCode_MSB >= 0xA4) && (GBCode_MSB <= 0xA8) && (GBCode_LSB >= 0xA1))
     
409.         {
     
410.                 WordAddr        = BaseAddr;
     
411.         }
     
412.         else if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA9) &&        (GBCode_LSB >= 0xA1))
     
413.         {
     
414.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
     
415.         }
     
416.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
     
417.         {
     
418.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
     
419.         }
     
420. 
     
421.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
422.         delay_nop(10);
     
423.         
     
424.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
425.         SPI_CS_OFF();
     
426.         delay_nop(10);
     
427.         
     
428.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
429.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
430.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
431.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
432.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
433.         //delay_nop(10);
     
434.         for(i = 0; i < BUFSIZE; i++)
     
435.         {
     
436.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
437.         }
     
438. 
     
439.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
440.         delay_nop(10);
     
441. 
     
442.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
443.         delay_nop(10);
     
444. }
     
445. 
     
446. /*******************************************************
     
447. *  函数名称：WORDLIB_read_GB_32x32
     
448. *  函数功能：读取字库芯片中一个国标汉字的32x32点阵编码
     
449. *  入口参数：GBCode，汉字内码；buffer，点阵编码的缓冲区；
     
450.                                  buffer必须大于等于128个字节。
     
451. *  出口参数：无
     
452. ******************************************************/
     
453. void WORDLIB_read_GB_32x32(uint16_t GBCode, uint8_t *buffer)
     
454. {
     
455.         uint32_t BaseAddr        = 0xEDF00;                                                                                //32x32点阵的起始地址，见手册《GT23L32S4W用户手册》
     
456.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
     
457.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
     
458.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
     
459.         const uint32_t BUFSIZE        = 128;                                                                                //缓冲区的大小
     
460.         uint8_t        i;
     
461. 
     
462.         //计算地址，见手册《GT23L32S4W用户手册》
     
463.         if((GBCode_MSB >= 0xA4) && (GBCode_MSB <= 0xA8) && (GBCode_LSB >= 0xA1))
     
464.         {
     
465.                 WordAddr        = BaseAddr;
     
466.         }
     
467.         else if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA9) &&        (GBCode_LSB >= 0xA1))
     
468.         {
     
469.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
     
470.         }
     
471.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
     
472.         {
     
473.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
     
474.         }
     
475. 
     
476.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
477.         delay_nop(10);
     
478.         
     
479.         //开始快速读取点阵数据：Read Data Bytes At Higher Speed
     
480.         SPI_CS_OFF();
     
481.         delay_nop(10);
     
482.         
     
483.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字：0x0B
     
484.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低，依次发送三个字节的地址
     
485.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
     
486.         SPI_WRITE_BYTE(WordAddr & 0xff);
     
487.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
     
488.         //delay_nop(10);
     
489.         for(i = 0; i < BUFSIZE; i++)
     
490.         {
     
491.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
     
492.         }
     
493. 
     
494.         SPI_CS_ON();                                                                                                                 //CS置高，结束本次操作
     
495.         delay_nop(10);
     
496. 
     
497.         SPI_CLEAR();                                                                                                                //清除SPI总线
     
498.         delay_nop(10);
     
499. }
     

复制代码

延时函数：

1. void delay_nop(unsigned int uiDelayNop)
   
2. {
   
3.         
   
4.         while(uiDelayNop!=0)
   
5.         {
   
6.                 uiDelayNop--;
   
7.         }
   
8.                
   
9. }

复制代码