独闷闷网

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

[原创] 使用STM32F103VB芯片模拟SPI时序读取字库芯片GT30L32S4W

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

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

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

x
本帖最后由 jianhong_wu 于 2015-6-17 13:36 编辑

★坚鸿-深圳:
我点评一下,以下代码有段内容很容易出错,尤其是在移植到不同的单片机编译器上的时候,这段代码是在读取字库芯片数据时,参与地址变换的变量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. #include "stm32f10x.h"
  2. #include "delay.h"

  3. #ifndef        __SPI0__H_
  4. #define __SPI0__H_

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

  8. #define SPI0_SCLK_ON()        (GPIO_SetBits(GPIOA, GPIO_Pin_5))                                //拉高
  9. #define SPI0_SCLK_OFF()        (GPIO_ResetBits(GPIOA, GPIO_Pin_5))                                //拉低

  10. #define SPI0_MOSI_ON()        (GPIO_SetBits(GPIOA, GPIO_Pin_7))                                //拉高
  11. #define SPI0_MOSI_OFF()        (GPIO_ResetBits(GPIOA, GPIO_Pin_7))                                //拉低

  12. #define SPI0_MISO_READ()        ((uint8_t)GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6))        //读取MISO的电平

  13. /*******************************************************
  14. *  函数名称:SPI0_init
  15. *  函数功能:初始化SPI0(驱动字库的模拟SPI接口)的IO口
  16. *  入口参数:无
  17. *  出口参数:无
  18. ******************************************************/
  19. void SPI0_init(void);

  20. /*******************************************************
  21. *  函数名称:SPI0_clear
  22. *  函数功能:清除SPI总线状态
  23. *  入口参数:无
  24. *  出口参数:无
  25. ******************************************************/
  26. void SPI0_clear(void);

  27. /*******************************************************
  28. *  函数名称:SPI0_readByte
  29. *  函数功能:SPI0读取一个字节数据
  30. *  入口参数:无
  31. *  出口参数:unsigned char
  32. ******************************************************/
  33. uint8_t SPI0_readByte(void);

  34. /*******************************************************
  35. *  函数名称:SPI0_writeByte
  36. *  函数功能:SPI0写出一个字节数据
  37. *  入口参数:unsigned char
  38. *  出口参数:无
  39. ******************************************************/
  40. void SPI0_writeByte(uint8_t dat);




  41. #endif        /* end of file */




复制代码
spi0.c文件

  1. #include "spi0.h"

  2. /*******************************************************
  3. *  函数名称:SPI0_init
  4. *  函数功能:初始化SPI0(驱动字库的模拟SPI接口)的IO口
  5. *  入口参数:无
  6. *  出口参数:无
  7. ******************************************************/
  8. void SPI0_init(void)
  9. {
  10. GPIO_InitTypeDef GPIO_InitStructure;
  11.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  12.         
  13.         // spi0 gpio configuration
  14.         // CS - PA.4        SCK - PA.5        MISO - PA.6                MOSI - PA.7
  15.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;                                   
  16.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                        //推挽输出
  17.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                                         //口线翻转速度为50MHz
  18.         GPIO_Init(GPIOA, &GPIO_InitStructure);

  19.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;                                   
  20.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                        //推挽输出
  21.         GPIO_Init(GPIOA, &GPIO_InitStructure);

  22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;                                   
  23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                                                //上拉输入
  24.         GPIO_Init(GPIOA, &GPIO_InitStructure);

  25.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;                                   
  26.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                        //推挽输出
  27.         GPIO_Init(GPIOA, &GPIO_InitStructure);

  28.         SPI0_clear();                                                                                                                //清除SPI总线状态
  29. }

  30. /*******************************************************
  31. *  函数名称:SPI0_clear
  32. *  函数功能:清除SPI总线状态
  33. *  入口参数:无
  34. *  出口参数:无
  35. ******************************************************/
  36. void SPI0_clear(void)
  37. {
  38.         SPI0_CS_ON();                                                                                                                //拉高
  39.         SPI0_SCLK_ON();                                                                                                                //拉高
  40.         SPI0_MOSI_ON();                                                                                                                //拉高
  41. }

  42. /*******************************************************
  43. *  函数名称:SPI0_readByte
  44. *  函数功能:SPI0读取一个字节数据
  45. *  入口参数:无
  46. *  出口参数:unsigned char
  47. ******************************************************/
  48. uint8_t SPI0_readByte(void)
  49. {
  50.         uint8_t i;
  51.         uint8_t        dat;
  52.         
  53.         for(i = 0; i < 8; i++)
  54.         {
  55.                 dat <<= 1;
  56.                 SPI0_SCLK_OFF();                                                                                                //下降沿,MISO字库芯片移出一个bit        
  57.                 if(SPI0_MISO_READ() == 1)
  58.                 {
  59.                         dat |= 0x01;
  60.                 }
  61.                 else
  62.                 {
  63.                         dat |= 0x00;
  64.                 }
  65.                 delay_nop(2);
  66.                 SPI0_SCLK_ON();
  67.                 delay_nop(10);
  68.         }
  69.         return dat;
  70. }

  71. /*******************************************************
  72. *  函数名称:SPI0_writeByte
  73. *  函数功能:SPI0写出一个字节数据
  74. *  入口参数:unsigned char
  75. *  出口参数:无
  76. ******************************************************/
  77. void SPI0_writeByte(uint8_t dat)
  78. {
  79.         uint8_t i;

  80.         for(i = 0; i < 8; i++)
  81.         {
  82.                 SPI0_SCLK_OFF();                                                                                                
  83.                 if(dat & 0x80)
  84.                 {
  85.                         SPI0_MOSI_ON();
  86.                 }
  87.                 else
  88.                 {
  89.                         SPI0_MOSI_OFF();
  90.                 }
  91.                 dat <<= 1;
  92.                 delay_nop(2);
  93.                 SPI0_SCLK_ON();                                                                                                        //上升沿,MOSI字库芯片移入一个bit
  94.                 delay_nop(10);               
  95.         }
  96. }

复制代码
字库驱动程序wordlib.h

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

  4. #ifndef        __WORDLIB__H_
  5. #define __WORDLIB__H_

  6. //SPI0模拟时序的底层函数调用封装
  7. #define SPI_CLEAR()                (SPI0_clear())
  8. #define SPI_CS_ON()                (SPI0_CS_ON())
  9. #define SPI_CS_OFF()        (SPI0_CS_OFF())
  10. #define SPI_WRITE_BYTE(dat)                (SPI0_writeByte((dat)))
  11. #define SPI_READ_BYTE()                        (SPI0_readByte())


  12. //指令表
  13. #define CMD_READ_WORDLIB                (0x03)                                                                                //读取数据命令
  14. #define CMD_FASTREAD_WORDLIB        (0x0B)                                                                                //快速读取数据命令
  15. #define CMD_DUMMY                                (0xFF)                                                                              //空指令、假数据

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

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

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

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

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

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




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

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

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

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




  98. #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.         //delay_nop(10);
  435.         for(i = 0; i < BUFSIZE; i++)
  436.         {
  437.                 *(buffer + i)        = SPI_READ_BYTE();                                                                //读取字库芯片发送过来的点阵编码
  438.         }

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

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

延时函数:
  1. void delay_nop(unsigned int uiDelayNop)
  2. {
  3.         
  4.         while(uiDelayNop!=0)
  5.         {
  6.                 uiDelayNop--;
  7.         }
  8.                
  9. }
复制代码





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

本版积分规则

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

GMT+8, 2021-6-12 19:23 , Processed in 0.171882 second(s), 19 queries .

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