独闷闷网

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

[原创] 跟大家分享字库芯片GT20L16S1Y的IO口模拟SPI和硬件SPI这两种C语言驱动程序。

[复制链接]
发表于 2016-5-1 13:12:21 | 显示全部楼层 |阅读模式

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

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

x
本帖最后由 jianhong_wu 于 2016-5-1 14:32 编辑

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

(1)IO口模拟SPI的驱动程序:
.H头文件:
  1. #ifndef _GT20L16S1Y_
  2. #define _GT20L16S1Y_

  3. #define SPI0_CS_ON()         (GPIO_WriteHigh(GPIOB,GPIO_PIN_4))          //拉高
  4. #define SPI0_CS_OFF()        (GPIO_WriteLow(GPIOB,GPIO_PIN_4))           //拉低

  5. #define SPI0_SCLK_ON()       (GPIO_WriteHigh(GPIOB,GPIO_PIN_3))          //拉高
  6. #define SPI0_SCLK_OFF()      (GPIO_WriteLow(GPIOB,GPIO_PIN_3))           //拉低

  7. #define SPI0_MOSI_ON()       (GPIO_WriteHigh(GPIOB,GPIO_PIN_2))          //拉高
  8. #define SPI0_MOSI_OFF()      (GPIO_WriteLow(GPIOB,GPIO_PIN_2))           //拉低

  9. void SPI0_clear(void);
  10. unsigned char SPI0_readByte(void);
  11. void SPI0_writeByte(unsigned char dat);
  12. void WORDLIB_read_ASCII_8x16(unsigned int ASCIICode, unsigned char *buffer);
  13. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer);
  14. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt);
  15. extern const unsigned char  Zf8x16_zheng_san_jiao[];
  16. extern const unsigned char  Zf8x16_dao_san_jiao[];
  17. extern const unsigned char  Zf8x16_quan_xian[];
  18. extern const unsigned char  Zf8x16_men_kuang_tu[];
  19. extern const unsigned char  Zf8x16_shuang_jian_tou[];
  20. extern const unsigned char  Zf8x16_zuo_san_jiao[];
  21. extern const unsigned char  Zf8x16_you_san_jiao[];
  22. extern const unsigned char  Zf8x16_you_biao[];
  23. extern const unsigned char  Hz16x16_kong[];
  24. extern const unsigned char  Hz16x16_full[];

  25. #endif








复制代码



.C源文件:
  1. #include  "stm8s.h"
  2. #include "GT20L16S1Y.h"
  3. #include "delay.h"

  4. const unsigned char  Zf8x16_zheng_san_jiao[]=
  5. {     
  6. /*--  文字:  正三角   --*/
  7. 0x00,0x20,0x60,0xE0,0xE0,0xE0,0x60,0x20,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,//68
  8. };

  9. const unsigned char  Zf8x16_dao_san_jiao[]=
  10. {     
  11. /*--  文字:  倒三角   --*/
  12. 0x00,0x80,0xC0,0xE0,0xC0,0x80,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,//67
  13. };

  14. const unsigned char  Zf8x16_quan_xian[]=
  15. {     
  16. /*--  文字:  全显  --*/
  17. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, //71
  18. };

  19. const unsigned char  Zf8x16_men_kuang_tu[]=
  20. {     
  21. /*--  文字: 门框图--*/
  22. 0x00,0xFE,0x02,0x02,0x02,0x02,0xFE,0x00,0x00,0x7F,0x40,0x40,0x40,0x40,0x7F,0x00, //73
  23. };

  24. const unsigned char  Zf8x16_shuang_jian_tou[]=
  25. {     
  26. /*--  文字: 双箭头--*/
  27. 0x40,0x60,0x70,0x78,0x70,0x60,0x40,0x00,0x02,0x06,0x0E,0x1E,0x0E,0x06,0x02,0x00, //74
  28. };

  29. const unsigned char  Zf8x16_zuo_san_jiao[]=
  30. {     
  31. /*--  文字: 左三角 --*/
  32. 0x00,0x00,0x80,0xC0,0xE0,0xF0,0xF8,0x00,0x00,0x01,0x03,0x07,0x0F,0x1F,0x3F,0x00, //77
  33. };

  34. const unsigned char  Zf8x16_you_san_jiao[]=
  35. {     
  36. /*--  文字: 右三角--*/
  37. 0x00,0xF8,0xF0,0xE0,0xC0,0x80,0x00,0x00,0x00,0x3F,0x1F,0x0F,0x07,0x03,0x01,0x00, //78
  38. };

  39. const unsigned char  Zf8x16_you_biao[]=
  40. {   
  41. /*--  文字:     --*/
  42. 0x00,0x80,0x80,0x90,0xA0,0xC0,0x80,0x00,0x00,0x00,0x00,0x04,0x02,0x01,0x00,0x00,
  43. };

  44. const unsigned char  Hz16x16_kong[]=
  45. {
  46. /*--  文字:  空白无  --*/
  47. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,   //100
  48. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  49. };


  50. const unsigned char  Hz16x16_full[]=
  51. {
  52. /*--  文字:  全显  --*/
  53. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
  54. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
  55. };

  56. /*******************************************************
  57. *  函数名称:SPI0_clear
  58. *  函数功能:清除SPI总线状态
  59. *  入口参数:无
  60. *  出口参数:无
  61. ******************************************************/
  62. void SPI0_clear(void)
  63. {
  64.         SPI0_CS_ON();    //拉高
  65.         SPI0_SCLK_ON();  //拉高
  66.         SPI0_MOSI_ON();  //拉高
  67. }

  68. /*******************************************************
  69. *  函数名称:SPI0_readByte
  70. *  函数功能:SPI0读取一个字节数据
  71. *  入口参数:无
  72. *  出口参数:unsigned char
  73. ******************************************************/
  74. unsigned char SPI0_readByte(void)
  75. {
  76.         unsigned char  i;
  77.         unsigned char  dat;
  78.         
  79.         for(i = 0; i < 8; i++)
  80.         {
  81.                 dat <<= 1;
  82.                 SPI0_SCLK_OFF();          //下降沿,MISO字库芯片移出一个bit        
  83.                 if(GPIO_ReadInputPin(GPIOB,GPIO_PIN_1)!= 0)
  84.                 {
  85.                         dat |= 0x01;
  86.                 }
  87.                 else
  88.                 {
  89.                         dat |= 0x00;
  90.                 }
  91.                 delay(1);
  92.                 SPI0_SCLK_ON();
  93.                 delay(1);
  94.         }
  95.         return dat;
  96. }

  97. /*******************************************************
  98. *  函数名称:SPI0_writeByte
  99. *  函数功能:SPI0写出一个字节数据
  100. *  入口参数:unsigned char
  101. *  出口参数:无
  102. ******************************************************/
  103. void SPI0_writeByte(unsigned char dat)
  104. {
  105.         unsigned char i;

  106.         for(i = 0; i < 8; i++)
  107.         {
  108.                 SPI0_SCLK_OFF();                                                                                                
  109.                 if(dat & 0x80)
  110.                 {
  111.                         SPI0_MOSI_ON();
  112.                 }
  113.                 else
  114.                 {
  115.                         SPI0_MOSI_OFF();
  116.                 }
  117.                 dat <<= 1;
  118.                 delay(1);
  119.                 SPI0_SCLK_ON();                                                                                                        //上升沿,MOSI字库芯片移入一个bit
  120.                 delay(1);               
  121.         }
  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(unsigned int ASCIICode,unsigned char *buffer)
  131. {

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

  137.         ASCIICodeTemp=ASCIICode&0xff;
  138.         //计算地址,见手册《GT20L16S1Y用户手册》
  139.         
  140.         
  141.         
  142.         if(ASCIICodeTemp==0x7E)
  143.         {
  144.            diy_zi_ku(Zf8x16_you_biao,buffer,BUFSIZE);
  145.            return;
  146.         }
  147.         else if(ASCIICodeTemp==1)
  148.         {
  149.            diy_zi_ku(Zf8x16_zheng_san_jiao,buffer,BUFSIZE);
  150.            return;
  151.         }
  152.         else if(ASCIICodeTemp==2)
  153.         {
  154.            diy_zi_ku(Zf8x16_dao_san_jiao,buffer,BUFSIZE);
  155.            return;
  156.         }
  157.         else if(ASCIICodeTemp==255)
  158.         {
  159.            diy_zi_ku(Zf8x16_quan_xian,buffer,BUFSIZE);
  160.            return;
  161.         }   
  162.         else if(ASCIICodeTemp==254)
  163.         {
  164.            diy_zi_ku(Zf8x16_men_kuang_tu,buffer,BUFSIZE);
  165.            return;
  166.         }   
  167.         else if(ASCIICodeTemp==0)
  168.         {
  169.            diy_zi_ku(Zf8x16_shuang_jian_tou,buffer,BUFSIZE);
  170.            return;
  171.         }   
  172.         else if(ASCIICodeTemp==23)
  173.         {
  174.            diy_zi_ku(Zf8x16_zuo_san_jiao,buffer,BUFSIZE);
  175.            return;
  176.         }   
  177.         else if(ASCIICodeTemp==22)
  178.         {
  179.            diy_zi_ku(Zf8x16_you_san_jiao,buffer,BUFSIZE);
  180.            return;
  181.         }   
  182.         else if((ASCIICodeTemp >= 0x20) && (ASCIICodeTemp <= 0x7E))
  183.         {
  184.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
  185.         }
  186.         else   //空格0x20
  187.         {
  188.                 ASCIICodeTemp=0x20;
  189.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
  190.         }   

  191.         SPI0_clear();           //清除SPI总线
  192.         delay(1);
  193.         
  194.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  195.         SPI0_CS_OFF();
  196.         delay(1);
  197.         
  198.         SPI0_writeByte(0x0b);  //发送命令字:0x0B
  199.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低,依次发送三个字节的地址
  200.         SPI0_writeByte((WordAddr >> 8) & 0xff);
  201.         SPI0_writeByte(WordAddr & 0xff);
  202.         SPI0_writeByte(0xff);           //最后发送一个字节的假数据 Dummy Byte
  203.         for(i = 0; i < BUFSIZE; i++)
  204.         {
  205.                 *(buffer + i)        = SPI0_readByte();                                                                //读取字库芯片发送过来的点阵编码
  206.         }

  207.         SPI0_CS_ON();                                                                                                                 //CS置高,结束本次操作
  208.         delay(1);

  209.         SPI0_clear();                                                                                                                //清除SPI总线
  210.         delay(1);
  211. }


  212. /*******************************************************
  213. *  函数名称:WORDLIB_read_GB_16x16
  214. *  函数功能:读取字库芯片中一个国标汉字的16x16点阵编码
  215. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  216.                                  buffer必须大于等于32个字节。
  217. *  出口参数:无
  218. ******************************************************/
  219. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer)
  220. {
  221.         unsigned long BaseAddr        = 0;       //16x16点阵的起始地址,见手册《GT20L16S1Y用户手册》
  222.         unsigned long GBCode_MSB        = 0;   //汉字内码的高八位
  223.         unsigned long GBCode_LSB        = 0;         //汉字内码的低八位
  224.         unsigned long WordAddr        = 0;                      //汉字或者ASCII字符点阵在芯片中的字节地址
  225.         const unsigned char BUFSIZE        = 32;              //缓冲区的大小
  226.         unsigned char   i;
  227.         GBCode_MSB        = (GBCode >> 8) & 0xFF;   //汉字内码的高八位
  228.         GBCode_LSB        = GBCode & 0xFF;         //汉字内码的低八位

  229.         //计算地址,见手册《GT20L16S1Y用户手册》
  230.         if(GBCode==256||GBCode==0x2020)
  231.         {
  232.            diy_zi_ku(Hz16x16_kong,buffer,BUFSIZE);
  233.            return;
  234.         }
  235.         else if(GBCode_MSB == 0xA9&& GBCode_LSB >= 0xA1)
  236.         {
  237.                 WordAddr        = (282+(GBCode_LSB-0xA1))*32+ BaseAddr;
  238.         }
  239.         else if(GBCode_MSB >= 0xA1&&GBCode_MSB <= 0xA3&& GBCode_LSB >= 0xA1)
  240.         {
  241.                 WordAddr        = (GBCode_MSB-0xA1)*94+(GBCode_LSB-0xA1)*32+ BaseAddr;
  242.         }
  243.         else if(GBCode_MSB >= 0xB0&&GBCode_MSB <= 0xF7&& GBCode_LSB >= 0xA1)
  244.         {
  245.                 WordAddr        = ((GBCode_MSB-0xB0)*94+(GBCode_LSB-0xA1)+846)*32+ BaseAddr;
  246.         }

  247.         SPI0_clear();           //清除SPI总线
  248.         delay(1);
  249.         
  250.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  251.         SPI0_CS_OFF();
  252.         delay(1);
  253.         
  254.         SPI0_writeByte(0x0B);                      //发送命令字:0x0B
  255.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低,依次发送三个字节的地址
  256.         SPI0_writeByte((WordAddr >> 8) & 0xff);
  257.         SPI0_writeByte(WordAddr & 0xff);
  258.         SPI0_writeByte(0xff);               //最后发送一个字节的假数据 Dummy Byte
  259.         for(i = 0; i < BUFSIZE; i++)
  260.         {
  261.                 *(buffer + i)        = SPI0_readByte();    //读取字库芯片发送过来的点阵编码
  262.         }

  263.         SPI0_CS_ON();                                                                                                                 //CS置高,结束本次操作
  264.         delay(1);

  265.         SPI0_clear();                                                                                                             //清除SPI总线
  266.         delay(1);
  267. }

  268. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt)
  269. {
  270.    unsigned char i;
  271.    for(i=0;i<ucZiKuCnt;i++)
  272.    {
  273.       pucResultBuffer[i]=pucConstZiKu[i];
  274.    }

  275. }

复制代码



(2)硬件SPI的驱动程序:
.H头文件:
  1. #ifndef _GT20L16S1Y_
  2. #define _GT20L16S1Y_

  3. #define  SPI0_CS_DIR_OUT  (1)
  4. #define  SPI0_CS_DIR_IN   (0)

  5. #define  SPI0_CS_PORT  (2)
  6. #define  SPI0_CS_PIN   (23)
  7. #define  SPI0_CS_MASK  (1<<SPI0_CS_PIN)


  8. #define  SPI0_CS_ON()     (GPIO_OutputValue(SPI0_CS_PORT, SPI0_CS_MASK, 1))
  9. #define  SPI0_CS_OFF()    (GPIO_OutputValue(SPI0_CS_PORT, SPI0_CS_MASK, 0))


  10. #define FIFOSIZE                  8



  11. /* SSP CR1 register */
  12. #define SSPCR1_LBM                (1 << 0)
  13. #define SSPCR1_SSE                (1 << 1)
  14. #define SSPCR1_MS                  (1 << 2)
  15. #define SSPCR1_SOD                (1 << 3)


  16. /* SSP Status register */
  17. #define SSPSR_TFE                (1 << 0)
  18. #define SSPSR_TNF                (1 << 1)
  19. #define SSPSR_RNE                (1 << 2)
  20. #define SSPSR_RFF                (1 << 3)
  21. #define SSPSR_BSY                (1 << 4)

  22. void Gt12l16s1y_Initial(void);
  23. void SPI0_clear(void);
  24. unsigned char SPI0_readByte(void);
  25. void SPI0_writeByte(unsigned char dat);
  26. void WORDLIB_read_ASCII_8x16(unsigned int ASCIICode, unsigned char *buffer);
  27. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer);
  28. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt);



  29. #endif










复制代码



.C源文件:
  1. #include "GT20L16S1Y.h"
  2. #include "Timer.h"
  3. #include "lpc177x_8x_gpio.h"
  4. #include "lpc177x_8x_ssp.h"
  5. #include "Delay.h"
  6. #include "Can.h"
  7. #include "UserGlobal.h"




  8. void Gt12l16s1y_Initial(void)
  9. {
  10.       uint8_t i, Dummy=Dummy;
  11.     //  uint8_t regVal;
  12.         
  13.                         /* Enable AHB clock to the SSP0. */
  14.                         LPC_SC->PCONP |= (0x1<<21);

  15.                         /* Further divider is needed on SSP clock. */
  16.                 //        regVal = LPC_SC->PCLKSEL;
  17.                 //        if ( regVal < 4 )
  18.                 //        {
  19.                 //                LPC_SC->PCLKSEL = 4;
  20.         //                }
  21.         

  22.         
  23.                         LPC_IOCON->P2_22 &= ~0x07;
  24.                         LPC_IOCON->P2_22 |= 0x02;                /* SSP CLK */
  25.                         LPC_IOCON->P2_26 &= ~0x07;
  26.                         LPC_IOCON->P2_26 |= 0x02;                /* SSP MISO */
  27.                         LPC_IOCON->P2_27 &= ~0x07;        
  28.                         LPC_IOCON->P2_27 |= 0x02;                /* SSP MOSI */
  29.         
  30.             LPC_IOCON->P2_23 &= ~0x07;
  31.             LPC_GPIO2->DIR |= (0x1<<23);
  32.             LPC_GPIO2->SET |= (0x1<<23);  /* port2, bit 23(SSEL) is set to GPIO output and high */
  33.                         
  34.                         
  35.                
  36.                         /* Set DSS data to 8-bit, Frame format SPI, CPOL = 0, CPHA = 0, and SCR is 15 */
  37.                         LPC_SSP0->CR0 = 0x0707;

  38.                         /* SSPCPSR clock prescale register, master mode, minimum divisor is 0x02 */
  39.                         LPC_SSP0->CPSR = 0x2;

  40.                         for ( i = 0; i < FIFOSIZE; i++ )
  41.                         {
  42.                                 Dummy = LPC_SSP0->DR;                /* clear the RxFIFO */
  43.                         }

  44.                   /* Master mode */
  45.                         LPC_SSP0->CR1 = SSPCR1_SSE;
  46.                         

  47. }


  48. void SPI0_clear(void)           //清除SPI总线
  49. {
  50.    SPI0_CS_ON();   
  51. }



  52. /*******************************************************
  53. *  函数名称:SPI0_readByte
  54. *  函数功能:SPI0读取一个字节数据
  55. *  入口参数:无
  56. *  出口参数:unsigned char
  57. ******************************************************/
  58. unsigned char SPI0_readByte(void)
  59. {
  60.         unsigned char  dat;

  61.                                 LPC_SSP0->DR = 0xFF;
  62.                                 /* Wait until the Busy bit is cleared */
  63.                                 while ( (LPC_SSP0->SR & (SSPSR_BSY|SSPSR_RNE)) != SSPSR_RNE );
  64.                                 dat = LPC_SSP0->DR;
  65.                                 
  66.         return dat;
  67. }

  68. /*******************************************************
  69. *  函数名称:SPI0_writeByte
  70. *  函数功能:SPI0写出一个字节数据
  71. *  入口参数:unsigned char
  72. *  出口参数:无
  73. ******************************************************/
  74. void SPI0_writeByte(unsigned char dat)
  75. {
  76.     uint8_t Dummy = Dummy;
  77.                                 
  78.     /* Move on only if NOT busy and TX FIFO not full. */
  79.           while ( (LPC_SSP0->SR & (SSPSR_TNF|SSPSR_BSY)) != SSPSR_TNF );
  80.           LPC_SSP0->DR = dat;


  81.           while ( (LPC_SSP0->SR & (SSPSR_BSY|SSPSR_RNE)) != SSPSR_RNE );
  82.           /* Whenever a byte is written, MISO FIFO counter increments, Clear FIFO
  83.           on MISO. Otherwise, when SSP0Receive() is called, previous data byte
  84.           is left in the FIFO. */
  85.           Dummy = LPC_SSP0->DR;
  86. }

  87. /*******************************************************
  88. *  函数名称:WORDLIB_read_ASCII_8x16
  89. *  函数功能:读取字库芯片中一个ASCII字符的8x16点阵编码
  90. *  入口参数:ASCIICode,ASCII码;buffer,点阵编码的缓冲区;
  91.                                  buffer必须大于等于16个字节。
  92. *  出口参数:无
  93. ******************************************************/
  94. void WORDLIB_read_ASCII_8x16(unsigned int ASCIICode,unsigned char *buffer)
  95. {

  96.         unsigned long BaseAddr        = 0x3b7c0;     //8x16点阵的起始地址,见手册《GT23L32S4W用户手册》
  97.         unsigned long WordAddr        = 0;              //ASCII字符点阵在芯片中的字节地址
  98.         unsigned long ASCIICodeTemp   =0;
  99.         const unsigned int BUFSIZE    = 16;        //缓冲区的大小
  100.         unsigned char  i;

  101.         ASCIICodeTemp=ASCIICode&0xff;
  102.         //计算地址,见手册《GT20L16S1Y用户手册》
  103.         
  104.         
  105.         

  106.         if((ASCIICodeTemp >= 0x20) && (ASCIICodeTemp <= 0x7E))
  107.         {
  108.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
  109.         }
  110.         else   //空格0x20
  111.         {
  112.                 ASCIICodeTemp=0x20;
  113.                 WordAddr        = (ASCIICodeTemp - 0x20) * BUFSIZE + BaseAddr;
  114.         }   

  115.         SPI0_clear();           //清除SPI总线
  116.         u8Delay_42Ns(2);
  117.         
  118.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  119.         SPI0_CS_OFF();
  120.         u8Delay_42Ns(2);
  121.         
  122.         SPI0_writeByte(0x0b);  //发送命令字:0x0B
  123.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低,依次发送三个字节的地址
  124.         SPI0_writeByte((WordAddr >> 8) & 0xff);
  125.         SPI0_writeByte(WordAddr & 0xff);
  126.         SPI0_writeByte(0xff);           //最后发送一个字节的假数据 Dummy Byte
  127.         for(i = 0; i < BUFSIZE; i++)
  128.         {
  129.                 *(buffer + i)        = SPI0_readByte();                                                                //读取字库芯片发送过来的点阵编码
  130.         }

  131.         SPI0_CS_ON();                                                                                                                 //CS置高,结束本次操作
  132.         u8Delay_42Ns(2);

  133.         SPI0_clear();                                                                                                                //清除SPI总线
  134.         u8Delay_42Ns(2);
  135. }


  136. /*******************************************************
  137. *  函数名称:WORDLIB_read_GB_16x16
  138. *  函数功能:读取字库芯片中一个国标汉字的16x16点阵编码
  139. *  入口参数:GBCode,汉字内码;buffer,点阵编码的缓冲区;
  140.                                  buffer必须大于等于32个字节。
  141. *  出口参数:无
  142. ******************************************************/
  143. void WORDLIB_read_GB_16x16(unsigned int GBCode, unsigned char  *buffer)
  144. {
  145.         unsigned long BaseAddr        = 0;       //16x16点阵的起始地址,见手册《GT20L16S1Y用户手册》
  146.         unsigned long GBCode_MSB        = 0;   //汉字内码的高八位
  147.         unsigned long GBCode_LSB        = 0;         //汉字内码的低八位
  148.         unsigned long WordAddr        = 0;                      //汉字或者ASCII字符点阵在芯片中的字节地址
  149.         const unsigned char BUFSIZE        = 32;              //缓冲区的大小
  150.         unsigned char   i;
  151.         GBCode_MSB        = (GBCode >> 8) & 0xFF;   //汉字内码的高八位
  152.         GBCode_LSB        = GBCode & 0xFF;         //汉字内码的低八位

  153.         //计算地址,见手册《GT20L16S1Y用户手册》

  154.         if(GBCode_MSB == 0xA9&& GBCode_LSB >= 0xA1)
  155.         {
  156.                 WordAddr        = (282+(GBCode_LSB-0xA1))*32+ BaseAddr;
  157.         }
  158.         else if(GBCode_MSB >= 0xA1&&GBCode_MSB <= 0xA3&& GBCode_LSB >= 0xA1)
  159.         {
  160.                 WordAddr        = (GBCode_MSB-0xA1)*94+(GBCode_LSB-0xA1)*32+ BaseAddr;
  161.         }
  162.         else if(GBCode_MSB >= 0xB0&&GBCode_MSB <= 0xF7&& GBCode_LSB >= 0xA1)
  163.         {
  164.                 WordAddr        = ((GBCode_MSB-0xB0)*94+(GBCode_LSB-0xA1)+846)*32+ BaseAddr;
  165.         }

  166.         SPI0_clear();           //清除SPI总线
  167.         u8Delay_42Ns(2);
  168.         
  169.         //开始快速读取点阵数据:Read Data Bytes At Higher Speed
  170.         SPI0_CS_OFF();
  171.         u8Delay_42Ns(2);
  172.         
  173.         SPI0_writeByte(0x0B);                      //发送命令字:0x0B
  174.         SPI0_writeByte((WordAddr >> 16) & 0xff);    //从高到低,依次发送三个字节的地址
  175.         SPI0_writeByte((WordAddr >> 8) & 0xff);
  176.         SPI0_writeByte(WordAddr & 0xff);
  177.         SPI0_writeByte(0xff);               //最后发送一个字节的假数据 Dummy Byte
  178.         for(i = 0; i < BUFSIZE; i++)
  179.         {
  180.                 *(buffer + i)        = SPI0_readByte();    //读取字库芯片发送过来的点阵编码
  181.         }

  182.         SPI0_CS_ON();                                                                                                                 //CS置高,结束本次操作
  183.         u8Delay_42Ns(2);

  184.         SPI0_clear();                                                                                                             //清除SPI总线
  185.         u8Delay_42Ns(2);
  186. }

  187. void diy_zi_ku(const unsigned char *pucConstZiKu,unsigned char *pucResultBuffer,unsigned char ucZiKuCnt)
  188. {
  189.    unsigned char i;
  190.    for(i=0;i<ucZiKuCnt;i++)
  191.    {
  192.       pucResultBuffer[i]=pucConstZiKu[i];
  193.    }

  194. }

复制代码


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

本版积分规则

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

GMT+8, 2018-4-24 11:09 , Processed in 0.100357 second(s), 19 queries .

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