独闷闷网

 找回密码
 立即注册
搜索
查看: 4377|回复: 0
收起左侧

[原创] 使用STM32F103VB芯片SPI控制器读取字库芯片GT30L32S4W

[复制链接]
发表于 2014-6-26 13:19:46 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
spi1.h文件

  1. #include "stm32f10x.h"
  2. #include "delay.h"

  3. #ifndef        __SPI1__H_
  4. #define __SPI1__H_

  5. //MISO(MOSI),M是主控CPU,S是SPI字库芯片
  6. #define SPI1_CS_ON()        (GPIO_SetBits(GPIOA, GPIO_Pin_4))                                //拉高
  7. #define SPI1_CS_OFF()        (GPIO_ResetBits(GPIOA, GPIO_Pin_4))                                //拉低

  8. #define SPI1_CLEAR()        (SPI1_CS_ON())                                                                         //清除总线:禁止片选CS;SPI_CPOL_High已将SCLK空闲时设置为高电平

  9. /*******************************************************
  10. *  函数名称:SPI1_init
  11. *  函数功能:初始化SPI1(驱动字库芯片的SPI控制器)
  12. *  入口参数:无
  13. *  出口参数:无
  14. ******************************************************/
  15. void SPI1_init(void);

  16. /*******************************************************
  17. *  函数名称:spi_read_write_byte
  18. *  函数功能:
  19. *  入口参数:无
  20. *  出口参数:unsigned char
  21. ******************************************************/
  22. uint8_t spi_read_write_byte(uint8_t dat);

  23. /*******************************************************
  24. *  函数名称:SPI1_setSpeed
  25. *  函数功能:设置spi的速度,在通讯过程中是不能修改spi速度的,此函数不适用于I2S
  26. *  入口参数:: SPI_BaudRatePrescaler_2                2分频
  27.                           : SPI_BaudRatePrescaler_4           4分频
  28.                           : SPI_BaudRatePrescaler_8           8分频
  29.                           : SPI_BaudRatePrescaler_16          16分频
  30.                           : SPI_BaudRatePrescaler_32          32分频
  31.                           : SPI_BaudRatePrescaler_64          64分频
  32.                           : SPI_BaudRatePrescaler_128         128分频
  33.                           : SPI_BaudRatePrescaler_256         256分频                                  
  34. *  出口参数:无
  35. ******************************************************/
  36. void SPI1_setSpeed(SPI_TypeDef* SPIx, uint8_t SPI_BaudRatePrescaler);




  37. #endif        /* end of file */




复制代码

spi1.c文件

  1. #include "spi1.h"

  2. /*******************************************************
  3. *  函数名称:SPI1_init
  4. *  函数功能:初始化SPI1(驱动字库芯片的SPI控制器)
  5. *  入口参数:无
  6. *  出口参数:无
  7. ******************************************************/
  8. void SPI1_init(void)
  9. {
  10.         SPI_InitTypeDef                SPI_InitStructure;
  11.         GPIO_InitTypeDef         GPIO_InitStructure;

  12.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 ,ENABLE);
  13.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  14.        
  15.         // spi1 gpio configuration
  16.         // SCK - PA.5        MISO - PA.6                MOSI - PA.7
  17.         GPIO_InitStructure.GPIO_Pin         = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
  18.         GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_50MHz;
  19.         GPIO_InitStructure.GPIO_Mode         = GPIO_Mode_AF_PP;                                        //推挽复用输出
  20.         GPIO_Init(GPIOA, &GPIO_InitStructure);

  21. <span style="line-height: 1.5;">// CS - PA.4</span>
  22.         GPIO_InitStructure.GPIO_Pin         = GPIO_Pin_4;
  23.         GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_50MHz;
  24.         GPIO_InitStructure.GPIO_Mode         = GPIO_Mode_Out_PP;                                        //普通推挽输出
  25.         GPIO_Init(GPIOA, &GPIO_InitStructure);   
  26.        
  27.         SPI1_CS_ON();                                                                                                                //禁止片选

  28.         // spi1 disable
  29.         SPI_Cmd(SPI1, DISABLE);
  30.        
  31.         // spi1 configuration
  32.         SPI_InitStructure.SPI_Direction                 = SPI_Direction_2Lines_FullDuplex;        // 双线双线全双工
  33.         SPI_InitStructure.SPI_Mode                                 = SPI_Mode_Master;                                        // 主机模式
  34.         SPI_InitStructure.SPI_DataSize                         = SPI_DataSize_8b;                                        // 数据帧 8bit
  35.         SPI_InitStructure.SPI_CPOL                                 = SPI_CPOL_High;                                        // 通信空闲时,sck为高电平
  36.         SPI_InitStructure.SPI_CPHA                                 = SPI_CPHA_2Edge;                                        // 偶数边沿(上升沿)采集数据(字库芯片或者SPI_flash的MOSI引脚是在上升沿锁存数据)       
  37.         SPI_InitStructure.SPI_NSS                                  = SPI_NSS_Soft;                                                // 软件控制片选
  38.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                // 波特率 Fpclk的256分频
  39.         SPI_InitStructure.SPI_FirstBit                         = SPI_FirstBit_MSB;                                        // 高位数据在前
  40.         SPI_InitStructure.SPI_CRCPolynomial         = 7;                                                                // CRC校验多项式(本工程没用到)
  41.         SPI_Init(SPI1, &SPI_InitStructure);
  42.        
  43.         // spi1 enable
  44.         SPI_Cmd(SPI1, ENABLE);

  45.     return ;
  46. }

  47. /*******************************************************
  48. *  函数名称:SPI1_setSpeed
  49. *  函数功能:设置spi的速度,在通讯过程中是不能修改spi速度的,此函数不适用于I2S
  50. *  入口参数:: SPI_BaudRatePrescaler_2                2分频
  51.                           : SPI_BaudRatePrescaler_4           4分频
  52.                           : SPI_BaudRatePrescaler_8           8分频
  53.                           : SPI_BaudRatePrescaler_16          16分频
  54.                           : SPI_BaudRatePrescaler_32          32分频
  55.                           : SPI_BaudRatePrescaler_64          64分频
  56.                           : SPI_BaudRatePrescaler_128         128分频
  57.                           : SPI_BaudRatePrescaler_256         256分频                                  
  58. *  出口参数:无
  59. ******************************************************/
  60. void SPI1_setSpeed(SPI_TypeDef* SPIx, uint8_t SPI_BaudRatePrescaler)
  61. {
  62.     assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));

  63.         //修改SPI速度前先关闭SPI
  64.         while(RESET != SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY));                //检测SPI是否忙
  65.         SPI_Cmd(SPIx, DISABLE);                                                                       
  66.    
  67.     SPIx->CR1   &= 0xFFC7;
  68.     SPIx->CR1   |= SPI_BaudRatePrescaler;
  69.    
  70.     SPI_Cmd(SPIx, ENABLE);
  71.    
  72.     return ;
  73. }

  74. /*******************************************************
  75. *  函数名称:spi_read_write_byte
  76. *  函数功能:向SPI1写入一个字节数据,同时读取出一个字节数据
  77. *  入口参数:dat,写入的数据
  78. *  出口参数:unsigned char
  79. ******************************************************/
  80. uint8_t spi_read_write_byte(uint8_t dat)
  81. {
  82.         /*
  83.         **在双线全双工模式下,必须一边写发送缓冲区,一边读接收缓冲区,
  84.         **否则在多次发送之后,接收缓冲区和接收移位寄存器中会积压到两个字节的
  85.         **待读取数据,影响下次的读操作。
  86.         */
  87.    
  88.         uint8_t  err_cnt = 0;
  89.    
  90.     while(RESET == SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE))       // 发送缓存空标志位
  91.     {
  92.         err_cnt++;
  93.         if(err_cnt > 200)
  94.         {
  95.             return(0);
  96.         }
  97.     }
  98.    
  99.     SPI_I2S_SendData(SPI1, dat);

  100.     err_cnt        = 0;
  101.     while(RESET == SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE))      // 接收缓存非空标志位
  102.     {
  103.         err_cnt++;
  104.         if(err_cnt > 200)
  105.         {
  106.             return(0);
  107.         }
  108.     }
  109.    
  110.     return(SPI_I2S_ReceiveData(SPI1));
  111. }

复制代码

字库芯片驱动程序wordlib.h

  1. #include "stm32f10x.h"
  2. #include "delay.h"
  3. #include "spi0.h"
  4. #include "spi1.h"

  5. #ifndef        __WORDLIB__H_
  6. #define __WORDLIB__H_


  7. //指令表
  8. #define CMD_READ_WORDLIB                (0x03)                                                                                //读取数据命令
  9. #define CMD_FASTREAD_WORDLIB        (0x0B)                                                                                //快速读取数据命令
  10. #define CMD_DUMMY                                (0xFF)                                                                              //空指令、假数据

  11. <span style="line-height: 1.5;">//使用SPI控制器</span>
  12. #define SPI_INIT()                (SPI1_init())
  13. #define SPI_CLEAR()                (SPI1_CLEAR())
  14. #define SPI_CS_ON()                (SPI1_CS_ON())
  15. #define SPI_CS_OFF()        (SPI1_CS_OFF())
  16. #define SPI_WRITE_BYTE(dat)                (spi_read_write_byte((dat)))
  17. #define SPI_READ_BYTE()                        (spi_read_write_byte(CMD_DUMMY))


  18. /*===============================================ASCII取码(非扩展等宽字符)==============================================*/
  19. /*******************************************************
  20. *  函数名称:WORDLIB_read_ASCII_5x7
  21. *  函数功能:读取字库芯片中一个ASCII字符的5x7点阵编码
  22. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  23.                                 buffer必须大于等于8个字节。
  24. *  出口参数:无
  25. ******************************************************/
  26. void WORDLIB_read_ASCII_5x7(uint16_t ASCIICode, uint8_t *buffer);

  27. /*******************************************************
  28. *  函数名称:WORDLIB_read_ASCII_7x8
  29. *  函数功能:读取字库芯片中一个ASCII字符的7x8点阵编码
  30. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  31.                                 buffer必须大于等于8个字节。
  32. *  出口参数:无
  33. ******************************************************/
  34. void WORDLIB_read_ASCII_7x8(uint16_t ASCIICode, uint8_t *buffer);

  35. /*******************************************************
  36. *  函数名称:WORDLIB_read_ASCII_6x12
  37. *  函数功能:读取字库芯片中一个ASCII字符的6x12点阵编码
  38. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  39.                                 buffer必须大于等于12个字节。
  40. *  出口参数:无
  41. ******************************************************/
  42. void WORDLIB_read_ASCII_6x12(uint16_t ASCIICode, uint8_t *buffer);

  43. /*******************************************************
  44. *  函数名称:WORDLIB_read_ASCII_8x16
  45. *  函数功能:读取字库芯片中一个ASCII字符的8x16点阵编码
  46. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  47.                                 buffer必须大于等于16个字节。
  48. *  出口参数:无
  49. ******************************************************/
  50. void WORDLIB_read_ASCII_8x16(uint16_t ASCIICode, uint8_t *buffer);

  51. /*******************************************************
  52. *  函数名称:WORDLIB_read_ASCII_12x24
  53. *  函数功能:读取字库芯片中一个ASCII字符的12x24点阵编码
  54. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  55.                                 buffer必须大于等于48个字节。
  56. *  出口参数:无
  57. ******************************************************/
  58. void WORDLIB_read_ASCII_12x24(uint16_t ASCIICode, uint8_t *buffer);

  59. /*******************************************************
  60. *  函数名称:WORDLIB_read_ASCII_16x32
  61. *  函数功能:读取字库芯片中一个ASCII字符的16x32点阵编码
  62. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  63.                                 buffer必须大于等于64个字节。
  64. *  出口参数:无
  65. ******************************************************/
  66. void WORDLIB_read_ASCII_16x32(uint16_t ASCIICode, uint8_t *buffer);




  67. /*===============================================国标汉字取码(非扩展等宽字符)===========================================*/
  68. /*******************************************************
  69. *  函数名称:WORDLIB_read_GB_12x12
  70. *  函数功能:读取字库芯片中一个国标汉字的12x12点阵编码
  71. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  72.                                 buffer必须大于等于24个字节。
  73. *  出口参数:无
  74. ******************************************************/
  75. void WORDLIB_read_GB_12x12(uint16_t GBCode, uint8_t *buffer);

  76. /*******************************************************
  77. *  函数名称:WORDLIB_read_GB_16x16
  78. *  函数功能:读取字库芯片中一个国标汉字的16x16点阵编码
  79. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  80.                                 buffer必须大于等于32个字节。
  81. *  出口参数:无
  82. ******************************************************/
  83. void WORDLIB_read_GB_16x16(uint16_t GBCode, uint8_t *buffer);

  84. /*******************************************************
  85. *  函数名称:WORDLIB_read_GB_24x24
  86. *  函数功能:读取字库芯片中一个国标汉字的24x24点阵编码
  87. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  88.                                 buffer必须大于等于72个字节。
  89. *  出口参数:无
  90. ******************************************************/
  91. void WORDLIB_read_GB_24x24(uint16_t GBCode, uint8_t *buffer);

  92. /*******************************************************
  93. *  函数名称:WORDLIB_read_GB_32x32
  94. *  函数功能:读取字库芯片中一个国标汉字的32x32点阵编码
  95. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  96.                                 buffer的大小必须是128个字节。
  97. *  出口参数:无
  98. ******************************************************/
  99. void WORDLIB_read_GB_32x32(uint16_t GBCode, uint8_t *buffer);




  100. #endif        /* end of file */


复制代码

字库芯片驱动程序wordlib.c

  1. #include "wordlib.h"

  2. /*===============================================ASCII取码(非扩展等宽字符)==============================================*/
  3. /*******************************************************
  4. *  函数名称:WORDLIB_read_ASCII_5x7
  5. *  函数功能:读取字库芯片中一个ASCII字符的5x7点阵编码
  6. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  7.                                 buffer必须大于等于8个字节。
  8. *  出口参数:无
  9. ******************************************************/
  10. void WORDLIB_read_ASCII_5x7(uint16_t ASCIICode, uint8_t *buffer)
  11. {
  12.         uint32_t BaseAddr        = 0x1DDF80;                                                                                //5x7点阵的起始地址,见手册《GT23L32S4W用户手册》
  13.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
  14.         const uint32_t BUFSIZE        = 8;                                                                                //缓冲区的大小
  15.         uint8_t        i;

  16.         //计算地址,见手册《GT23L32S4W用户手册》
  17.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
  18.         {
  19.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
  20.         }

  21.         SPI_CLEAR();                                                                                                                //清除SPI总线
  22.         delay_nop(10);
  23.        
  24.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  25.         SPI_CS_OFF();
  26.         delay_nop(10);
  27.        
  28.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  29.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  30.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  31.         SPI_WRITE_BYTE(WordAddr & 0xff);
  32.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  33.         //delay_nop(10);
  34.         for(i = 0; i < BUFSIZE; i++)
  35.         {
  36.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  37.         }

  38.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  39.         delay_nop(10);

  40.         SPI_CLEAR();                                                                                                                //清除SPI总线
  41.         delay_nop(10);
  42. }

  43. /*******************************************************
  44. *  函数名称:WORDLIB_read_ASCII_7x8
  45. *  函数功能:读取字库芯片中一个ASCII字符的7x8点阵编码
  46. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  47.                                 buffer必须大于等于8个字节。
  48. *  出口参数:无
  49. ******************************************************/
  50. void WORDLIB_read_ASCII_7x8(uint16_t ASCIICode, uint8_t *buffer)
  51. {

  52.         uint32_t BaseAddr        = 0x1DE280;                                                                                //7x8点阵的起始地址,见手册《GT23L32S4W用户手册》
  53.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
  54.         const uint32_t BUFSIZE        = 8;                                                                                //缓冲区的大小
  55.         uint8_t        i;

  56.         //计算地址,见手册《GT23L32S4W用户手册》
  57.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
  58.         {
  59.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
  60.         }

  61.         SPI_CLEAR();                                                                                                                //清除SPI总线
  62.         delay_nop(10);
  63.        
  64.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  65.         SPI_CS_OFF();
  66.         delay_nop(10);
  67.        
  68.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  69.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  70.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  71.         SPI_WRITE_BYTE(WordAddr & 0xff);
  72.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  73.         //delay_nop(10);
  74.         for(i = 0; i < BUFSIZE; i++)
  75.         {
  76.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  77.         }

  78.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  79.         delay_nop(10);

  80.         SPI_CLEAR();                                                                                                                //清除SPI总线
  81.         delay_nop(10);
  82. }

  83. /*******************************************************
  84. *  函数名称:WORDLIB_read_ASCII_6x12
  85. *  函数功能:读取字库芯片中一个ASCII字符的6x12点阵编码
  86. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  87.                                 buffer必须大于等于12个字节。
  88. *  出口参数:无
  89. ******************************************************/
  90. void WORDLIB_read_ASCII_6x12(uint16_t ASCIICode, uint8_t *buffer)
  91. {

  92.         uint32_t BaseAddr        = 0x1DBE00;                                                                                //6x12点阵的起始地址,见手册《GT23L32S4W用户手册》
  93.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
  94.         const uint32_t BUFSIZE        = 12;                                                                                //缓冲区的大小
  95.         uint8_t        i;

  96.         //计算地址,见手册《GT23L32S4W用户手册》
  97.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
  98.         {
  99.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
  100.         }

  101.         SPI_CLEAR();                                                                                                                //清除SPI总线
  102.         delay_nop(10);
  103.        
  104.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  105.         SPI_CS_OFF();
  106.         delay_nop(10);
  107.        
  108.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  109.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  110.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  111.         SPI_WRITE_BYTE(WordAddr & 0xff);
  112.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  113.         //delay_nop(10);
  114.         for(i = 0; i < BUFSIZE; i++)
  115.         {
  116.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  117.         }

  118.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  119.         delay_nop(10);

  120.         SPI_CLEAR();                                                                                                                //清除SPI总线
  121.         delay_nop(10);
  122. }

  123. /*******************************************************
  124. *  函数名称:WORDLIB_read_ASCII_8x16
  125. *  函数功能:读取字库芯片中一个ASCII字符的8x16点阵编码
  126. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  127.                                 buffer必须大于等于16个字节。
  128. *  出口参数:无
  129. ******************************************************/
  130. void WORDLIB_read_ASCII_8x16(uint16_t ASCIICode, uint8_t *buffer)
  131. {

  132.         uint32_t BaseAddr        = 0x1DD780;                                                                                //8x16点阵的起始地址,见手册《GT23L32S4W用户手册》
  133.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
  134.         const uint32_t BUFSIZE        = 16;                                                                                //缓冲区的大小
  135.         uint8_t        i;

  136.         //计算地址,见手册《GT23L32S4W用户手册》
  137.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
  138.         {
  139.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
  140.         }

  141.         SPI_CLEAR();                                                                                                                //清除SPI总线
  142.         delay_nop(10);
  143.        
  144.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  145.         SPI_CS_OFF();
  146.         delay_nop(10);
  147.        
  148.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  149.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  150.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  151.         SPI_WRITE_BYTE(WordAddr & 0xff);
  152.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  153.         //delay_nop(10);
  154.         for(i = 0; i < BUFSIZE; i++)
  155.         {
  156.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  157.         }

  158.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  159.         delay_nop(10);

  160.         SPI_CLEAR();                                                                                                                //清除SPI总线
  161.         delay_nop(10);
  162. }

  163. /*******************************************************
  164. *  函数名称:WORDLIB_read_ASCII_12x24
  165. *  函数功能:读取字库芯片中一个ASCII字符的12x24点阵编码
  166. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  167.                                 buffer必须大于等于48个字节。
  168. *  出口参数:无
  169. ******************************************************/
  170. void WORDLIB_read_ASCII_12x24(uint16_t ASCIICode, uint8_t *buffer)
  171. {
  172.         uint32_t BaseAddr        = 0x1DFF00;                                                                                //12x24点阵的起始地址,见手册《GT23L32S4W用户手册》
  173.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
  174.         const uint32_t BUFSIZE        = 48;                                                                                //缓冲区的大小
  175.         uint8_t        i;

  176.         //计算地址,见手册《GT23L32S4W用户手册》
  177.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
  178.         {
  179.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
  180.         }

  181.         SPI_CLEAR();                                                                                                                //清除SPI总线
  182.         delay_nop(10);
  183.        
  184.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  185.         SPI_CS_OFF();
  186.         delay_nop(10);
  187.        
  188.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  189.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  190.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  191.         SPI_WRITE_BYTE(WordAddr & 0xff);
  192.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  193.         //delay_nop(10);
  194.         for(i = 0; i < BUFSIZE; i++)
  195.         {
  196.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  197.         }

  198.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  199.         delay_nop(10);

  200.         SPI_CLEAR();                                                                                                                //清除SPI总线
  201.         delay_nop(10);
  202. }

  203. /*******************************************************
  204. *  函数名称:WORDLIB_read_ASCII_16x32
  205. *  函数功能:读取字库芯片中一个ASCII字符的16x32点阵编码
  206. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  207.                                 buffer必须大于等于64个字节。
  208. *  出口参数:无
  209. ******************************************************/
  210. void WORDLIB_read_ASCII_16x32(uint16_t ASCIICode, uint8_t *buffer)
  211. {
  212.         uint32_t BaseAddr        = 0x1E5A50;                                                                                //16x32点阵的起始地址,见手册《GT23L32S4W用户手册》
  213.         uint32_t WordAddr        = 0;                                                                                        //ASCII字符点阵在芯片中的字节地址
  214.         const uint32_t BUFSIZE        = 64;                                                                                //缓冲区的大小
  215.         uint8_t        i;

  216.         //计算地址,见手册《GT23L32S4W用户手册》
  217.         if((ASCIICode >= 0x20) && (ASCIICode <= 0x7E))
  218.         {
  219.                 WordAddr        = (ASCIICode - 0x20) * BUFSIZE + BaseAddr;
  220.         }

  221.         SPI_CLEAR();                                                                                                                //清除SPI总线
  222.         delay_nop(10);
  223.        
  224.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  225.         SPI_CS_OFF();
  226.         delay_nop(10);
  227.        
  228.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  229.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  230.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  231.         SPI_WRITE_BYTE(WordAddr & 0xff);
  232.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  233.         //delay_nop(10);
  234.         for(i = 0; i < BUFSIZE; i++)
  235.         {
  236.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  237.         }

  238.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  239.         delay_nop(10);

  240.         SPI_CLEAR();                                                                                                                //清除SPI总线
  241.         delay_nop(10);
  242. }


  243. /*===============================================国标汉字取码(非扩展等宽字符)===========================================*/
  244. /*******************************************************
  245. *  函数名称:WORDLIB_read_GB_12x12
  246. *  函数功能:读取字库芯片中一个国标汉字的12x12点阵编码
  247. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  248.                                 buffer必须大于等于24个字节。
  249. *  出口参数:无
  250. ******************************************************/
  251. void WORDLIB_read_GB_12x12(uint16_t GBCode, uint8_t *buffer)
  252. {
  253.         uint32_t BaseAddr        = 0;                                                                                        //12x12点阵的起始地址,见手册《GT23L32S4W用户手册》
  254.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
  255.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
  256.         uint32_t WordAddr        = 0;                                                                                        //汉字点阵在芯片中的字节地址
  257.         const uint32_t BUFSIZE        = 24;                                                                                //缓冲区的大小
  258.         uint8_t        i;

  259.         //计算地址,见手册《GT23L32S4W用户手册》
  260.         if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA3) && (GBCode_LSB >= 0xA1))
  261.         {
  262.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
  263.         }
  264.         else if((GBCode_MSB == 0xA9) &&        (GBCode_LSB >= 0xA1))
  265.         {
  266.                 WordAddr        = (282 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
  267.         }
  268.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
  269.         {
  270.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
  271.         }

  272.         SPI_CLEAR();                                                                                                                //清除SPI总线
  273.         delay_nop(10);
  274.        
  275.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  276.         SPI_CS_OFF();
  277.         delay_nop(10);
  278.        
  279.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  280.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  281.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  282.         SPI_WRITE_BYTE(WordAddr & 0xff);
  283.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  284.         //delay_nop(10);
  285.         for(i = 0; i < BUFSIZE; i++)
  286.         {
  287.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  288.         }

  289.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  290.         delay_nop(10);

  291.         SPI_CLEAR();                                                                                                                //清除SPI总线
  292.         delay_nop(10);
  293. }

  294. /*******************************************************
  295. *  函数名称:WORDLIB_read_GB_16x16
  296. *  函数功能:读取字库芯片中一个国标汉字的16x16点阵编码
  297. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  298.                                 buffer必须大于等于32个字节。
  299. *  出口参数:无
  300. ******************************************************/
  301. void WORDLIB_read_GB_16x16(uint16_t GBCode, uint8_t *buffer)
  302. {
  303.         uint32_t BaseAddr        = 0x2C9D0;                                                                                //16x16点阵的起始地址,见手册《GT23L32S4W用户手册》
  304.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
  305.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
  306.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
  307.         const uint32_t BUFSIZE        = 32;                                                                                //缓冲区的大小
  308.         uint8_t        i;

  309.         //计算地址,见手册《GT23L32S4W用户手册》
  310.         if((GBCode_MSB >= 0xA4) && (GBCode_MSB <= 0xA8) && (GBCode_LSB >= 0xA1))
  311.         {
  312.                 WordAddr        = BaseAddr;
  313.         }
  314.         else if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA9) &&        (GBCode_LSB >= 0xA1))
  315.         {
  316.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
  317.         }
  318.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
  319.         {
  320.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
  321.         }

  322.         SPI_CLEAR();                                                                                                                //清除SPI总线
  323.         delay_nop(10);
  324.        
  325.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  326.         SPI_CS_OFF();
  327.         delay_nop(10);
  328.        
  329.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  330.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  331.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  332.         SPI_WRITE_BYTE(WordAddr & 0xff);
  333.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  334.         //delay_nop(10);
  335.         for(i = 0; i < BUFSIZE; i++)
  336.         {
  337.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  338.         }

  339.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  340.         delay_nop(10);

  341.         SPI_CLEAR();                                                                                                                //清除SPI总线
  342.         delay_nop(10);
  343. }

  344. /*******************************************************
  345. *  函数名称:WORDLIB_read_GB_24x24
  346. *  函数功能:读取字库芯片中一个国标汉字的24x24点阵编码
  347. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  348.                                 buffer必须大于等于72个字节。
  349. *  出口参数:无
  350. ******************************************************/
  351. void WORDLIB_read_GB_24x24(uint16_t GBCode, uint8_t *buffer)
  352. {

  353.         uint32_t BaseAddr        = 0x68190;                                                                                //24x24点阵的起始地址,见手册《GT23L32S4W用户手册》
  354.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
  355.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
  356.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
  357.         const uint32_t BUFSIZE        = 72;                                                                                //缓冲区的大小
  358.         uint8_t        i;

  359.         //计算地址,见手册《GT23L32S4W用户手册》
  360.         if((GBCode_MSB >= 0xA4) && (GBCode_MSB <= 0xA8) && (GBCode_LSB >= 0xA1))
  361.         {
  362.                 WordAddr        = BaseAddr;
  363.         }
  364.         else if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA9) &&        (GBCode_LSB >= 0xA1))
  365.         {
  366.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
  367.         }
  368.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
  369.         {
  370.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
  371.         }

  372.         SPI_CLEAR();                                                                                                                //清除SPI总线
  373.         delay_nop(10);
  374.        
  375.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  376.         SPI_CS_OFF();
  377.         delay_nop(10);
  378.        
  379.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  380.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  381.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  382.         SPI_WRITE_BYTE(WordAddr & 0xff);
  383.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte
  384.         //delay_nop(10);
  385.         for(i = 0; i < BUFSIZE; i++)
  386.         {
  387.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  388.         }

  389.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  390.         delay_nop(10);

  391.         SPI_CLEAR();                                                                                                                //清除SPI总线
  392.         delay_nop(10);
  393. }

  394. /*******************************************************
  395. *  函数名称:WORDLIB_read_GB_32x32
  396. *  函数功能:读取字库芯片中一个国标汉字的32x32点阵编码
  397. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  398.                                 buffer必须大于等于128个字节。
  399. *  出口参数:无
  400. ******************************************************/
  401. void WORDLIB_read_GB_32x32(uint16_t GBCode, uint8_t *buffer)
  402. {
  403.         uint32_t BaseAddr        = 0xEDF00;                                                                                //32x32点阵的起始地址,见手册《GT23L32S4W用户手册》
  404.         uint8_t GBCode_MSB        = (GBCode >> 8) & 0xFF;                                                        //汉字内码的高八位
  405.         uint8_t GBCode_LSB        = GBCode & 0xFF;                                                                //汉字内码的低八位
  406.         uint32_t WordAddr        = 0;                                                                                        //汉字或者ASCII字符点阵在芯片中的字节地址
  407.         const uint32_t BUFSIZE        = 128;                                                                                //缓冲区的大小
  408.         uint8_t        i;

  409.         //计算地址,见手册《GT23L32S4W用户手册》
  410.         if((GBCode_MSB >= 0xA4) && (GBCode_MSB <= 0xA8) && (GBCode_LSB >= 0xA1))
  411.         {
  412.                 WordAddr        = BaseAddr;
  413.         }
  414.         else if((GBCode_MSB >= 0xA1) && (GBCode_MSB <= 0xA9) &&        (GBCode_LSB >= 0xA1))
  415.         {
  416.                 WordAddr        = ((GBCode_MSB - 0xA1) * 94 + (GBCode_LSB - 0xA1)) * BUFSIZE + BaseAddr;
  417.         }
  418.         else if((GBCode_MSB >= 0xB0) && (GBCode_MSB <= 0xF7) &&        (GBCode_LSB >= 0xA1))
  419.         {
  420.                 WordAddr        = ((GBCode_MSB - 0xB0) * 94 + (GBCode_LSB - 0xA1) + 846) * BUFSIZE + BaseAddr;
  421.         }

  422.         SPI_CLEAR();                                                                                                                //清除SPI总线
  423.         delay_nop(10);
  424.        
  425.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  426.         SPI_CS_OFF();
  427.         delay_nop(10);
  428.        
  429.         SPI_WRITE_BYTE(CMD_FASTREAD_WORDLIB);                                                                //发送命令字:0x0B
  430.         SPI_WRITE_BYTE((WordAddr >> 16) & 0xff);                                                        //从高到低,依次发送三个字节的地址
  431.         SPI_WRITE_BYTE((WordAddr >> 8) & 0xff);
  432.         SPI_WRITE_BYTE(WordAddr & 0xff);
  433.         SPI_WRITE_BYTE(CMD_DUMMY);                                                                                        //最后发送一个字节的假数据 Dummy Byte

  434.         for(i = 0; i < BUFSIZE; i++)
  435.         {
  436.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  437.         }

  438.         SPI_CS_ON();                                                                                                                 //CS置高,结束本次操作
  439.         delay_nop(10);

  440.         SPI_CLEAR();                                                                                                                //清除SPI总线
  441.         delay_nop(10);
  442. }
复制代码





乐于分享,勇于质疑!
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|独闷闷网 ( 粤ICP备12007667号-2 )

GMT+8, 2021-6-14 01:48 , Processed in 0.140998 second(s), 19 queries .

快速回复 返回顶部 返回列表