使用STM32F103VB芯片SPI控制器读取字库芯片GT30L32S4W

Lawrence

spi1.h文件

1. 
   
2. #include "stm32f10x.h"
   
3. #include "delay.h"
   
4. 
   
5. #ifndef        __SPI1__H_
   
6. #define __SPI1__H_
   
7. 
   
8. //MISO(MOSI)，M是主控CPU，S是SPI字库芯片
   
9. #define SPI1_CS_ON()        (GPIO_SetBits(GPIOA, GPIO_Pin_4))                                //拉高
   
10. #define SPI1_CS_OFF()        (GPIO_ResetBits(GPIOA, GPIO_Pin_4))                                //拉低
    
11. 
    
12. #define SPI1_CLEAR()        (SPI1_CS_ON())                                                                         //清除总线：禁止片选CS；SPI_CPOL_High已将SCLK空闲时设置为高电平
    
13. 
    
14. /*******************************************************
    
15. *  函数名称：SPI1_init
    
16. *  函数功能：初始化SPI1(驱动字库芯片的SPI控制器)
    
17. *  入口参数：无
    
18. *  出口参数：无
    
19. ******************************************************/
    
20. void SPI1_init(void);
    
21. 
    
22. /*******************************************************
    
23. *  函数名称：spi_read_write_byte
    
24. *  函数功能：
    
25. *  入口参数：无
    
26. *  出口参数：unsigned char
    
27. ******************************************************/
    
28. uint8_t spi_read_write_byte(uint8_t dat);
    
29. 
    
30. /*******************************************************
    
31. *  函数名称：SPI1_setSpeed
    
32. *  函数功能：设置spi的速度，在通讯过程中是不能修改spi速度的,此函数不适用于I2S
    
33. *  入口参数：: SPI_BaudRatePrescaler_2                2分频
    
34.                           : SPI_BaudRatePrescaler_4           4分频
    
35.                           : SPI_BaudRatePrescaler_8           8分频
    
36.                           : SPI_BaudRatePrescaler_16          16分频
    
37.                           : SPI_BaudRatePrescaler_32          32分频
    
38.                           : SPI_BaudRatePrescaler_64          64分频
    
39.                           : SPI_BaudRatePrescaler_128         128分频
    
40.                           : SPI_BaudRatePrescaler_256         256分频                                  
    
41. *  出口参数：无
    
42. ******************************************************/
    
43. void SPI1_setSpeed(SPI_TypeDef* SPIx, uint8_t SPI_BaudRatePrescaler);
    
44. 
    
45. 
    
46. 
    
47. 
    
48. #endif        /* end of file */
    
49. 
    
50. 
    
51. 
    
52. 
    

复制代码

spi1.c文件

1. 
   
2. #include "spi1.h"
   
3. 
   
4. /*******************************************************
   
5. *  函数名称：SPI1_init
   
6. *  函数功能：初始化SPI1(驱动字库芯片的SPI控制器)
   
7. *  入口参数：无
   
8. *  出口参数：无
   
9. ******************************************************/
   
10. void SPI1_init(void)
    
11. {
    
12.         SPI_InitTypeDef                SPI_InitStructure;
    
13.         GPIO_InitTypeDef         GPIO_InitStructure;
    
14. 
    
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 ,ENABLE);
    
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
17.        
    
18.         // spi1 gpio configuration
    
19.         // SCK - PA.5        MISO - PA.6                MOSI - PA.7
    
20.         GPIO_InitStructure.GPIO_Pin         = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
    
21.         GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_50MHz;
    
22.         GPIO_InitStructure.GPIO_Mode         = GPIO_Mode_AF_PP;                                        //推挽复用输出
    
23.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
24. 
    
25. <span style="line-height: 1.5;">// CS - PA.4</span>
    
26.         GPIO_InitStructure.GPIO_Pin         = GPIO_Pin_4;
    
27.         GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_50MHz;
    
28.         GPIO_InitStructure.GPIO_Mode         = GPIO_Mode_Out_PP;                                        //普通推挽输出
    
29.         GPIO_Init(GPIOA, &GPIO_InitStructure);   
    
30.        
    
31.         SPI1_CS_ON();                                                                                                                //禁止片选
    
32. 
    
33.         // spi1 disable
    
34.         SPI_Cmd(SPI1, DISABLE);
    
35.        
    
36.         // spi1 configuration
    
37.         SPI_InitStructure.SPI_Direction                 = SPI_Direction_2Lines_FullDuplex;        // 双线双线全双工
    
38.         SPI_InitStructure.SPI_Mode                                 = SPI_Mode_Master;                                        // 主机模式
    
39.         SPI_InitStructure.SPI_DataSize                         = SPI_DataSize_8b;                                        // 数据帧 8bit
    
40.         SPI_InitStructure.SPI_CPOL                                 = SPI_CPOL_High;                                        // 通信空闲时,sck为高电平
    
41.         SPI_InitStructure.SPI_CPHA                                 = SPI_CPHA_2Edge;                                        // 偶数边沿(上升沿)采集数据（字库芯片或者SPI_flash的MOSI引脚是在上升沿锁存数据）       
    
42.         SPI_InitStructure.SPI_NSS                                  = SPI_NSS_Soft;                                                // 软件控制片选
    
43.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                // 波特率 Fpclk的256分频
    
44.         SPI_InitStructure.SPI_FirstBit                         = SPI_FirstBit_MSB;                                        // 高位数据在前
    
45.         SPI_InitStructure.SPI_CRCPolynomial         = 7;                                                                // CRC校验多项式(本工程没用到)
    
46.         SPI_Init(SPI1, &SPI_InitStructure);
    
47.        
    
48.         // spi1 enable
    
49.         SPI_Cmd(SPI1, ENABLE);
    
50. 
    
51.     return ;
    
52. }
    
53. 
    
54. /*******************************************************
    
55. *  函数名称：SPI1_setSpeed
    
56. *  函数功能：设置spi的速度，在通讯过程中是不能修改spi速度的,此函数不适用于I2S
    
57. *  入口参数：: SPI_BaudRatePrescaler_2                2分频
    
58.                           : SPI_BaudRatePrescaler_4           4分频
    
59.                           : SPI_BaudRatePrescaler_8           8分频
    
60.                           : SPI_BaudRatePrescaler_16          16分频
    
61.                           : SPI_BaudRatePrescaler_32          32分频
    
62.                           : SPI_BaudRatePrescaler_64          64分频
    
63.                           : SPI_BaudRatePrescaler_128         128分频
    
64.                           : SPI_BaudRatePrescaler_256         256分频                                  
    
65. *  出口参数：无
    
66. ******************************************************/
    
67. void SPI1_setSpeed(SPI_TypeDef* SPIx, uint8_t SPI_BaudRatePrescaler)
    
68. {
    
69.     assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    
70. 
    
71.         //修改SPI速度前先关闭SPI
    
72.         while(RESET != SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY));                //检测SPI是否忙
    
73.         SPI_Cmd(SPIx, DISABLE);                                                                       
    
74.    
    
75.     SPIx->CR1   &= 0xFFC7;
    
76.     SPIx->CR1   |= SPI_BaudRatePrescaler;
    
77.    
    
78.     SPI_Cmd(SPIx, ENABLE);
    
79.    
    
80.     return ;
    
81. }
    
82. 
    
83. /*******************************************************
    
84. *  函数名称：spi_read_write_byte
    
85. *  函数功能：向SPI1写入一个字节数据，同时读取出一个字节数据
    
86. *  入口参数：dat，写入的数据
    
87. *  出口参数：unsigned char
    
88. ******************************************************/
    
89. uint8_t spi_read_write_byte(uint8_t dat)
    
90. {
    
91.         /*
    
92.         **在双线全双工模式下，必须一边写发送缓冲区，一边读接收缓冲区，
    
93.         **否则在多次发送之后，接收缓冲区和接收移位寄存器中会积压到两个字节的
    
94.         **待读取数据，影响下次的读操作。
    
95.         */
    
96.    
    
97.         uint8_t  err_cnt = 0;
    
98.    
    
99.     while(RESET == SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE))       // 发送缓存空标志位
    
100.     {
     
101.         err_cnt++;
     
102.         if(err_cnt > 200)
     
103.         {
     
104.             return(0);
     
105.         }
     
106.     }
     
107.    
     
108.     SPI_I2S_SendData(SPI1, dat);
     
109. 
     
110.     err_cnt        = 0;
     
111.     while(RESET == SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE))      // 接收缓存非空标志位
     
112.     {
     
113.         err_cnt++;
     
114.         if(err_cnt > 200)
     
115.         {
     
116.             return(0);
     
117.         }
     
118.     }
     
119.    
     
120.     return(SPI_I2S_ReceiveData(SPI1));
     
121. }
     
122. 
     

复制代码

字库芯片驱动程序wordlib.h

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

复制代码

字库芯片驱动程序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. 
     
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. }
     

复制代码