设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 分享一个tg12864-26b的单片机驱动程序,老王家的屏
返回列表 发新帖
查看: 2284|回复: 2
收起左侧

分享一个tg12864-26b的单片机驱动程序,老王家的屏

[复制链接]
ID:388135 发表于 2020-3-24 22:13 | 显示全部楼层 |阅读模式
lcd.c
  1. #include "lcd.h"
  2. #include "delay.h"
  3. #include "font.h"

  5. void LCD_DATA(u8 i)
  6. {
  7.                 if((i | 0xfe) == 0xfe) DB0 = 0; else DB0 = 1;
  8.                 if((i | 0xfd) == 0xfd) DB1 = 0; else DB1 = 1;
  9.                 if((i | 0xfb) == 0xfb) DB2 = 0; else DB2 = 1;
  10.                 if((i | 0xf7) == 0xf7) DB3 = 0; else DB3 = 1;
  11.                 if((i | 0xef) == 0xef) DB4 = 0; else DB4 = 1;
  12.                 if((i | 0xdf) == 0xdf) DB5 = 0; else DB5 = 1;
  13.                 if((i | 0xbf) == 0xbf) DB6 = 0; else DB6 = 1;
  14.                 if((i | 0x7f) == 0x7f) DB7 = 0; else DB7 = 1;
  15. }

  17. void LCD_Init(void)
  18. {
  19.           u8 i, j;

  21.           GPIO_InitTypeDef  GPIO_InitStructure;
  22.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);
  23.                 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 |GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
  24.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  25.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  26.                 GPIO_Init(GPIOB, &GPIO_InitStructure);

  28.                 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
  29.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  30.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  31.                 GPIO_Init(GPIOA, &GPIO_InitStructure);

  33.                 delay_us(10);
  34.                 RST = 0;
  35.                 delay_us(2);
  36.                 RST = 1; /*复位*/        
  37.           LCM_WRITE(com1, base);
  38.           LCM_WRITE(com2, base);
  39.           LCM_WRITE(com1, on);
  40.           LCM_WRITE(com2, on);
  41.                 for (j = 0; j < 8; j++) /*清屏*/
  42.                 {
  43.                                 LCM_WRITE(com1, 0xB8+j);        /*清左半屏*/
  44.                                 LCM_WRITE(com1, 0x40);
  45.                           LCM_WRITE(com2, 0xB8+j);        /*清左半屏*/
  46.                                 LCM_WRITE(com2, 0x40);
  47.                                 for(i = 0;i < 64; i++)
  48.                                 {
  49.                                                 LCM_WRITE(data1, 0x00);
  50.                                           LCM_WRITE(data2, 0x00);
  51.                                 }
  52.                 }

  54. }

  56. void LCM_WRITE(u8 cord, u8 ch)
  57. {
  58.           switch(cord)
  59.           {
  60.                                 case 0:
  61.                                 {
  62.                                                 delay_us(10);
  63.                                                 CS1=0;
  64.                                                 RS=0;
  65.                                                 RW=0;
  66.                                                 E=1;        
  67.                                                 LCD_DATA(ch);
  68.                                                 delay_us(2);
  69.                                                 E=0;
  70.                                                 delay_us(2);
  71.                                                 CS1=1;
  72.                                 }break;
  73.                                 case 1:
  74.                                 {
  75.                                     delay_us(10);
  76.                                                 CS2=0;
  77.                                                 RS=0;
  78.                                                 RW=0;
  79.                                                 E=1;        
  80.                                                 LCD_DATA(ch);
  81.                                                 delay_us(2);
  82.                                                 E=0;
  83.                                                 delay_us(2);
  84.                                                 CS2=1;
  85.                                 }break;
  86.                                 case 2:
  87.                                 {
  88.                                                 delay_us(10);
  89.                                                 CS1=0;
  90.                                                 RS=1;
  91.                                                 RW=0;        
  92.                                                 E=1;
  93.                                                 LCD_DATA(ch);
  94.                                                 delay_us(2);
  95.                                                 E=0;
  96.                                                 delay_us(2);
  97.                                                 CS1=1;
  98.                                 }break;
  99.                                 case 3:
  100.                                 {
  101.                                                 delay_us(30);
  102.                                                 CS2=0;
  103.                                                 RS=1;
  104.                                                 RW=0;        
  105.                                                 E=1;
  106.                                                 LCD_DATA(ch);
  107.                                                 delay_us(2);
  108.                                                 E=0;
  109.                                                 delay_us(2);
  110.                                                 CS2=1;
  111.                                 }break;
  112.                                 default : break;
  113.                 }
  114. }

  116. void Clr_Scr(u8 i)
  117. {
  118.                 u8 j, k;
  119.                 LCM_WRITE(com1, 0x40);
  120.           LCM_WRITE(com2, 0x40);
  121.                 for(k = 0; k < 8; k++)
  122.                 {
  123.                                 LCM_WRITE(com1, x_addr(k));
  124.         LCM_WRITE(com2, x_addr(k));
  125.                                 for(j = 0; j < 64; j++)
  126.                                 {
  127.                                                 LCM_WRITE(data1, i);
  128.                                           LCM_WRITE(data2, i);
  129.                                 }
  130.                 }
  131. }

  133. void show_hanzi1212(u8 page, u8 colum, u8 c[2])
  134. {
  135.                 u8 zimo[24];
  136.                 u8 i, j, k, l;
  137.         
  138.                 for(j = 0; j < (sizeof(codeGB_12) / sizeof(typFNT_GB12)); j++)  //查找汉字位置
  139.                 {
  140.                                 if((codeGB_12[j].Index[0] == c[0]) && (codeGB_12[j].Index[1] == c[1]))
  141.                                 {
  142.                                                 for(i = 0; i < 24; i++) //读出一个汉字的数据
  143.                                                 {
  144.                                                                 zimo[i] = codeGB_12[j].Msk[i];//将汉字数据存入显示缓存区
  145.                                                 }
  146.                                 }
  147.                 }
  148.     for(l = 0; l < 2; l++)
  149.                 {
  150.                     for(k = 0; k < 12; k++)
  151.                           {   
  152.                                           if((colum + k) < 64)
  153.                                           {
  154.                                                           LCM_WRITE(com1, y_addr(colum + k));
  155.                                   LCM_WRITE(com1, x_addr(page + l));
  156.                                                                 LCM_WRITE(data1, zimo[l * 12 + k]);
  157.                                                 }
  158.                                                 else if((colum + k) > 127)
  159.                                                 {
  160.                                                     LCM_WRITE(com1, y_addr(colum - 127 + k));
  161.                                   LCM_WRITE(com1, x_addr(page + l));
  162.                                                                 LCM_WRITE(data1, zimo[l * 12 + k]);
  163.                                                 }
  164.                                           else
  165.                                                 {
  166.                                                           LCM_WRITE(com2, y_addr(colum - 64 + k));
  167.                                   LCM_WRITE(com2, x_addr(page + l));
  168.                                                                 LCM_WRITE(data2, zimo[l * 12 + k]);
  169.                                                 }
  170.                                 }
  171.           }
  172. }

  174. void show_hanzi1616(u8 page, u8 colum, u8 c[2])
  175. {
  176.                 u8 zimo[32];
  177.                 u8 i, j, k, l;
  178.         
  179.                 for(j = 0; j < (sizeof(codeGB_16) / sizeof(typFNT_GB16)); j++)
  180.                 {
  181.                                 if((codeGB_16[j].Index[0] == c[0]) && (codeGB_16[j].Index[1] == c[1]))
  182.                                 {
  183.                                                 for(i = 0; i < 32; i++)
  184.                                                 {
  185.                                                                 zimo[i] = codeGB_16[j].Msk[i];
  186.                                                 }
  187.                                 }
  188.                 }
  189.     for(l = 0; l < 2; l++)
  190.                 {
  191.                     for(k = 0; k < 16; k++)
  192.                           {   
  193.                                           if((colum + k) < 64)
  194.                                           {
  195.                                                           LCM_WRITE(com1, y_addr(colum + k));
  196.                                   LCM_WRITE(com1, x_addr(page + l));
  197.                                                                 LCM_WRITE(data1, zimo[l * 16 + k]);
  198.                                                 }
  199.                                                 else if((colum + k) > 127)
  200.                                                 {
  201.                                                     LCM_WRITE(com1, y_addr(colum - 127 + k));
  202.                                   LCM_WRITE(com1, x_addr(page + l));
  203.                                                                 LCM_WRITE(data1, zimo[l * 16 + k]);
  204.                                                 }
  205.                                           else
  206.                                                 {
  207.                                                           LCM_WRITE(com2, y_addr(colum - 64 + k));
  208.                                   LCM_WRITE(com2, x_addr(page + l));
  209.                                                                 LCM_WRITE(data2, zimo[l * 16 + k]);
  210.                                                 }
  211.                                 }
  212.           }
  213. }

  215. void show_hanzi2424(u8 page, u8 colum, u8 c[2])
  216. {
  217.                 u8 zimo[72];
  218.                 u8 i, j, k, l;
  219.         
  220.                 for(j = 0; j < (sizeof(codeGB_24) / sizeof(typFNT_GB24)); j++)  //查找汉字位置
  221.                 {
  222.                                 if((codeGB_24[j].Index[0] == c[0]) && (codeGB_24[j].Index[1] == c[1]))
  223.                                 {
  224.                                                 for(i = 0; i < 72; i++) //读出一个汉字的数据
  225.                                                 {
  226.                                                                 zimo[i] = codeGB_24[j].Msk[i];//将汉字数据存入显示缓存区
  227.                                                 }
  228.                                 }
  229.                 }
  230.     for(l = 0; l < 3; l++)
  231.                 {
  232.                     for(k = 0; k < 24; k++)
  233.                           {   
  234.                                           if((colum + k) < 64)
  235.                                           {
  236.                                                           LCM_WRITE(com1, y_addr(colum + k));
  237.                                   LCM_WRITE(com1, x_addr(page + l));
  238.                                                                 LCM_WRITE(data1, zimo[l * 24 + k]);
  239.                                                 }
  240.                                                 else if((colum + k) > 127)
  241.                                                 {
  242.                                                     LCM_WRITE(com1, y_addr(colum - 127 + k));
  243.                                   LCM_WRITE(com1, x_addr(page + l));
  244.                                                                 LCM_WRITE(data1, zimo[l * 24 + k]);
  245.                                                 }
  246.                                           else
  247.                                                 {
  248.                                                           LCM_WRITE(com2, y_addr(colum - 64 + k));
  249.                                   LCM_WRITE(com2, x_addr(page + l));
  250.                                                                 LCM_WRITE(data2, zimo[l * 24 + k]);
  251.                                                 }
  252.                                 }
  253.           }
  254. }

  256. void display_hanzi(u8 page, u8 colum, u8 *c, u8 size)
  257. {
  258.     switch(size)
  259.                 {
  260.                                 case 12:
  261.                                               while(*c)
  262.                                                                 {
  263.                                                                                  show_hanzi1212(page,colum,c);
  264.                                                                                  colum += 12;
  265.                                                                                  c += 2;
  266.                                                                 }
  267.                                                                 break;
  268.                                 case 16:
  269.                                              while(*c)
  270.                                                                 {
  271.                                                                                  show_hanzi1616(page,colum,c);
  272.                                                                                  colum += 16;
  273.                                                                                  c += 2;
  274.                                                                 }
  275.                                                                 break;
  276.                                 case 24:
  277.                                              while(*c)
  278.                                                                 {
  279.                                                                                  show_hanzi2424(page,colum,c);
  280.                                                                                  colum += 24;
  281.                                                                                  c += 2;
  282.                                                                 }
  283.                                                                 break;
  284.                                 default:break;
  285.                 }
  286. }

  288. void show_letter_s(u8 page, u8 colum, u8 uletter[1])
  289. {
  290.     u8 zimo[12];
  291.                 u8 i, j, k, l;
  292.         
  293.                 for(i = 0; i < (sizeof(codeZF_12) / sizeof(typFNT_ZF12)); i++)  //查找数字位置
  294.                 {
  295.                                 if(codeZF_12[i].Index[0] == uletter[0])
  296.                                 {
  297.                                                 for(j = 0; j < 12; j++) //读出一个数字的数据
  298.                                                 {
  299.                                                                 zimo[j] = codeZF_12[i].Msk[j];//将数字数据存入显示缓存区
  300.                                                 }
  301.                                 }
  302.                 }
  303.     for(l = 0; l < 2; l++)
  304.                 {
  305.                     for(k = 0; k < 6; k++)
  306.                           {   
  307.                                           if((colum + k) < 64)
  308.                                           {
  309.                                                           LCM_WRITE(com1, y_addr(colum + k));
  310.                                   LCM_WRITE(com1, x_addr(page + l));
  311.                                                                 LCM_WRITE(data1, zimo[l * 6 + k]);
  312.                                                 }
  313.                                                 else if((colum + k) > 127)
  314.                                                 {
  315.                                                     LCM_WRITE(com1, y_addr(colum - 127 + k));
  316.                                   LCM_WRITE(com1, x_addr(page + l));
  317.                                                                 LCM_WRITE(data1, zimo[l * 6 + k]);
  318.                                                 }
  319.                                           else
  320.                                                 {
  321.                                                           LCM_WRITE(com2, y_addr(colum - 64 + k));
  322.                                   LCM_WRITE(com2, x_addr(page + l));
  323.                                                                 LCM_WRITE(data2, zimo[l * 6 + k]);
  324.                                                 }
  325.                                 }
  326.           }
  327. }

  329. void show_letter_m(u8 page, u8 colum, u8 uletter[1])
  330. {
  331.     u8 zimo[16];
  332.                 u8 i, j, k, l;
  333.         
  334.                 for(i = 0; i < (sizeof(codeZF_16) / sizeof(typFNT_ZF16)); i++)  //查找数字位置
  335.                 {
  336.                                 if(codeZF_16[i].Index[0] == uletter[0])
  337.                                 {
  338.                                                 for(j = 0;j < 16; j++) //读出一个数字的数据
  339.                                                 {
  340.                                                                 zimo[j] = codeZF_16[i].Msk[j];//将数字数据存入显示缓存区
  341.                                                 }
  342.                                 }
  343.                 }
  344.     for(l = 0; l < 2; l++)
  345.                 {
  346.                     for(k = 0; k < 8; k++)
  347.                           {   
  348.                                           if((colum + k) < 64)
  349.                                           {
  350.                                                           LCM_WRITE(com1, y_addr(colum + k));
  351.                                   LCM_WRITE(com1, x_addr(page + l));
  352.                                                                 LCM_WRITE(data1, zimo[l * 8 + k]);
  353.                                                 }
  354.                                                 else if((colum + k) > 127)
  355.                                                 {
  356.                                                     LCM_WRITE(com1, y_addr(colum - 127 + k));
  357.                                   LCM_WRITE(com1, x_addr(page + l));
  358.                                                                 LCM_WRITE(data1, zimo[l * 8 + k]);
  359.                                                 }
  360.                                           else
  361.                                                 {
  362.                                                           LCM_WRITE(com2, y_addr(colum - 64 + k));
  363.                                   LCM_WRITE(com2, x_addr(page + l));
  364.                                                                 LCM_WRITE(data2, zimo[l * 8 + k]);
  365.                                                 }
  366.                                 }
  367.           }
  368. }

  370. void show_letter_l(u8 page, u8 colum, u8 uletter[1])
  371. {
  372. u8 zimo[36];
  373.                 u8 i, j, k, l;

  375.                 for(i = 0; i < (sizeof(codeZF_24) / sizeof(typFNT_ZF24)); i++)  //查找数字位置
  376.                 {
  377.                                 if(codeZF_24[i].Index[0] == uletter[0])
  378.                                 {
  379.                                                 for(j = 0; j < 36; j++) //读出一个数字的数据
  380.                                                 {
  381.                                                                 zimo[j] = codeZF_24[i].Msk[j];//将数字数据存入显示缓存区
  382.                                                 }
  383.                                 }
  384.                 }
  385.     for(l = 0; l < 3; l++)
  386.                 {
  387.                     for(k = 0; k < 12; k++)
  388.                           {   
  389.                                           if((colum + k) < 64)
  390.                                           {
  391.                                                           LCM_WRITE(com1, y_addr(colum + k));
  392.                                   LCM_WRITE(com1, x_addr(page + l));
  393.                                                                 LCM_WRITE(data1, zimo[l * 12 + k]);
  394.                                                 }
  395.                                                 else if((colum + k) > 127)
  396.                                                 {
  397.                                                     LCM_WRITE(com1, y_addr(colum - 127 + k));
  398.                                   LCM_WRITE(com1, x_addr(page + l));
  399.                                                                 LCM_WRITE(data1, zimo[l * 12 + k]);
  400.                                                 }
  401.                                           else
  402.                                                 {
  403.                                                           LCM_WRITE(com2, y_addr(colum - 64 + k));
  404.                                   LCM_WRITE(com2, x_addr(page + l));
  405.                                                                 LCM_WRITE(data2, zimo[l * 12 + k]);
  406.                                                 }
  407.                                 }
  408.           }
  409. }

  411. void display_letter(u8 page, u8 colum, u8 *uletter, u8 size)
  412. {
  413.           switch(size)
  414.           {
  415.                                 case 12:
  416.                                                                 while(*uletter)
  417.                                                                 {
  418.                                                                                 show_letter_s(page, colum, uletter);
  419.                                                                                 colum += 6;
  420.                                                                                 uletter++;
  421.                                                                 }
  422.                                                                 break;
  423.                                 case 16:
  424.                                                                 while(*uletter)
  425.                                                                 {
  426.                                                                                 show_letter_m(page, colum, uletter);
  427.                                                                                 colum += 8;
  428.                                                                                 uletter++;
  429.                                                                 }
  430.                                                                 break;
  431.                                 case 24:
  432.                                                                 while(*uletter)
  433.                                                                 {
  434.                                                                                 show_letter_l(page, colum, uletter);
  435.                                                                                 colum += 12;
  436.                                                                                 uletter++;
  437.                                                                 }
  438.                                                                 break;
  439.                                 default : break;
  440.          }
  441. }

  443. void show_bitmap(u8 page, u8 colum, u8 c[1])
  444. {
  445.                 u8 zimo[32];
  446.                 u8 i, j, k, l;
  447.         
  448.                 for(j = 0; j < (sizeof(weitu) / sizeof(typFNT_ZF16)); j++)
  449.                 {
  450.                                 if((weitu[j].Index[0] == c[0]))
  451.                                 {
  452.                                                 for(i = 0; i < 32; i++)
  453.                                                 {
  454.                                                                 zimo[i] = weitu[j].Msk[i];
  455.                                                 }
  456.                                 }
  457.                 }
  458.     for(l = 0; l < 2; l++)
  459.                 {
  460.                     for(k = 0; k < 16; k++)
  461.                           {   
  462.                                           if((colum + k) < 64)
  463.                                           {
  464.                                                           LCM_WRITE(com1, y_addr(colum + k));
  465.                                   LCM_WRITE(com1, x_addr(page + l));
  466.                                                                 LCM_WRITE(data1, zimo[l * 16 + k]);
  467.                                                 }
  468.                                                 else if((colum + k) > 127)
  469.                                                 {
  470.                                                     LCM_WRITE(com1, y_addr(colum - 127 + k));
  471.                                   LCM_WRITE(com1, x_addr(page + l));
  472.                                                                 LCM_WRITE(data1, zimo[l * 16 + k]);
  473.                                                 }
  474.                                           else
  475.                                                 {
  476.                                                           LCM_WRITE(com2, y_addr(colum - 64 + k));
  477.                                   LCM_WRITE(com2, x_addr(page + l));
  478.                                                                 LCM_WRITE(data2, zimo[l * 16 + k]);
  479.                                                 }
  480.                                 }
  481.           }
  482. }
复制代码
lcd.h
  1. #ifndef __LCD_H
  2. #define __LCD_H

  4. #include "sys.h"

  6. #define RS  PBout(15) //寄存器选择端 H:数据寄存器，L:命令寄存器
  7. #define RW  PBout(14) //读/写选择信号，R/W=1：读选通，R/W=0：写选通
  8. #define E   PBout(13) //读写使能信号，在E下降沿，数据被锁存(写)入,在E高电平器件，数据被读出
  9. #define CS1 PBout(10) //前64点选择，1有效
  10. #define CS2 PBout(11) //后64点选择，1有效
  11. #define RST PBout(12) //复位信号

  13. #define DB0 PAout(0)
  14. #define DB1 PAout(1)
  15. #define DB2 PAout(2)
  16. #define DB3 PAout(3)
  17. #define DB4 PAout(4)
  18. #define DB5 PAout(5)
  19. #define DB6 PAout(6)
  20. #define DB7 PAout(7)

  22. #define com            0x00
  23. #define data           0x01

  25. #define com1           0x00
  26. #define com2           0x01
  27. #define data1          0x02
  28. #define data2          0x03

  30. #define on             0x3f
  31. #define off            0x3e
  32. #define base           0xc0
  33. #define x_addr(x)      0xb8+x
  34. #define y_addr(y)      0x40+y

  36. void LCD_DATA(u8 i);
  37. void LCD_Init(void);
  38. void LCM_WRITE(u8 cord, u8 ch);
  39. void Clr_Scr(u8 i);

  41. void show_hanzi1212(u8 page, u8 colum, u8 c[2]);
  42. void show_hanzi1616(u8 page, u8 colum, u8 c[2]);
  43. void show_hanzi2424(u8 page, u8 colum, u8 c[2]);
  44. void display_hanzi(u8 page, u8 colum, u8 *c, u8 size);

  46. void show_letter_s(u8 page, u8 colum, u8 uletter[1]);
  47. void show_letter_m(u8 page, u8 colum, u8 uletter[1]);
  48. void show_letter_l(u8 page, u8 colum, u8 uletter[1]);
  49. void display_letter(u8 page, u8 colum, u8 *uletter, u8 size);

  51. void show_bitmap(u8 page, u8 colum, u8 c[2]);

  53. #endif


复制代码
驱动自己改，没什么可说的都会。
字体都是pctolcd2002扣的，
扣好的字
0x10,0x10,0x10,0xFF,0x10,0x90,0x00,0xFC,0x04,0x04,0x04,0x04,0x04,0xFC,0x00,0x00,
0x04,0x44,0x82,0x7F,0x01,0x00,0x00,0x7F,0x20,0x20,0x20,0x20,0x20,0x7F,0x00,0x00,/*"扣",0*/


放到数组里面要改为
  1. "扣",0x10,0x10,0x10,0xFF,0x10,0x90,0x00,0xFC,0x04,0x04,0x04,0x04,0x04,0xFC,0x00,0x00,0x04,0x44,0x82,0x7F,0x01,0x00,0x00,0x7F,0x20,0x20,0x20,0x20,0x20,0x7F,0x00,0x00,/*0*
复制代码
把索引放到前边
放个片段吧，免得你们说虎头蛇尾
  1. #ifndef __FONT_H_
  2. #define __FONT_H_

  4. // ------------------  汉字字模的数据结构定义 ------------------------ //
  5. typedef struct                   // 汉字字模数据结构
  6. {
  7.   unsigned char  Index[3];       // 汉字内码索引        
  8.   unsigned char   Msk[24];       // 点阵码数据
  9. }typFNT_GB12;


  12. typedef struct                   // 汉字字模数据结构
  13. {
  14.   unsigned char  Index[3];       // 汉字内码索引        
  15.   unsigned char   Msk[32];       // 点阵码数据
  16. }typFNT_GB16;

  18. typedef struct                  // 汉字字模数据结构
  19. {
  20.   unsigned char  Index[3];      // 汉字内码索引        
  21.   unsigned char   Msk[72];      // 点阵码数据
  22. }typFNT_GB24;
复制代码

  2. const  typFNT_GB16 codeGB_16[] =
  3. {
  4. "扣",0x10,0x10,0x10,0xFF,0x10,0x90,0x00,0xFC,0x04,0x04,0x04,0x04,0x04,0xFC,0x00,0x00,0x04,0x44,0x82,0x7F,0x01,0x00,0x00,0x7F,0x20,0x20,0x20,0x20,0x20,0x7F,0x00,0x00,/*0*
  5. };
复制代码

最后附上接线图

tg12864接线图.jpg

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:388135 发表于 2020-3-24 22:30 | 显示全部楼层
自己做了个rtc时钟
51hei图片20200324222947.jpg
回复

使用道具 举报

ID:388135 发表于 2020-3-24 22:28 | 显示全部楼层
够良心的了，版主通过吧
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

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