找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2308|回复: 1
打印 上一主题 下一主题
收起左侧

基于51单片机的中文输入系统程序设计

[复制链接]
跳转到指定楼层
楼主


单片机源程序如下:
  1. #include <reg52.H>
  2. #include <string.h>
  3. #include <stdio.h>
  4. #include <intrins.h>


  5. #define uchar unsigned char
  6. #define uint  unsigned int

  7. #define LCD_Bus   P0    //P0口输出数据
  8. #define LCD_Busy  0x80

  9. //---------定义接口----------//
  10. sbit  LCD_RS=P2^7;
  11. sbit  LCD_RW=P2^6;
  12. sbit  LCD_E =P2^5;
  13. sbit  LCD_RST=P2^4;

  14. sbit key4=P1^0;    sbit key8=P1^1;       //定义按键的输入端
  15. sbit key12=P1^2;    sbit key16=P1^3;
  16. sbit key3=P1^4;    sbit key7=P1^5;
  17. sbit key11=P1^6;    sbit key14=P1^7;
  18. sbit key2=P3^0;    sbit key6=P3^1;
  19. sbit key10=P3^2;   sbit key15=P3^3;
  20. sbit key1=P3^4;   sbit key5=P3^5;
  21. sbit key9=P3^6;   sbit key13=P3^7;
  22. sbit key17=P2^1;
  23. sbit ds=P2^0;        //温度传感器信号线
  24. int tvalue,num1=0;//温度值
  25. uchar tflag;//温度正负标志
  26. uchar table[5];
  27. code char table1[]={"温度:"};
  28. //--------函数定义区--------//
  29. void  delay (uint t);                    //延时函数

  30. void  LCD_Rest();                       //LCD驱动函数
  31. void  LCD_Init();
  32. void  LCD_Wdata(uchar d);
  33. void  LCD_Wcode(char c);
  34. void  LCD_Rbusy();
  35. char get_key();                         //拼音及汉字输出函数
  36. display_hanzi(struct t9py_list *ptr);
  37. display_output_hanzi(struct t9py_list *ptr);
  38. void display_pinyin(struct t9py_list *ptr);
  39. void LCD_ShowString(char *st);

  40. void t9py_result_clear();              //拼音及汉字输出辅助函数
  41. void t9py_result_add(struct t9py_index *idx);
  42. void t9py_result_select_next();
  43. void t9py_result_select_prev();
  44. void t9py_result_select_reset();
  45. void t9py_result_hanzi_init();
  46. void t9py_result_hanzi_select_prev();
  47. void t9py_result_hanzi_select_next();
  48. uint t9_table_search();

  49. char  is_t9_key(char e);               //字符串处理辅助函数
  50. void str_uncat_char(char *s);
  51. void str_cat_char(char *s, char c);
  52. void str_clear(char *s);
  53. void LCD_qingchu_34( );      //清除三四行
  54. void LCD_qingchu_12( );
  55. void LCD_Clear( );


  56. int key;
  57. int weizhi=0;
  58. char Fkey[8]={""};
  59. char key_str[8]={""};        // 从键盘输入的T9数字序列
  60. char *zimu_str;
  61. char *biaodian_str;
  62. char pos=0;




  63. // T9数字字母索引表项
  64. struct t9py_index {
  65.     char code *t9_str;                           //按键数字序列
  66.     char code *py_str;                           //拼音编码字符串
  67.     char code *py_mb;                            //该拼音对应的汉字码表地址
  68. };

  69. // T9数字字母索引结果(多重表项)
  70. struct t9py_list {
  71.     struct t9py_index * entry[8];
  72.     int ele_num;                                // 拼音个数
  73.     char ele_idx;                                // 当前选中的拼音(index)
  74.     int hanzi_num;                                // 当前选中汉字中的汉字个数
  75.     char hanzi_idx;                                // 当前选中拼音中的选中的汉字(index)
  76.     char code *hanzi_ptr;                // 当前读音候选汉字字符串指针
  77. };
  78. //"拼音输入法汉字排列表,码表(mb)"
  79. code char PY_mb_a[]     ={"阿啊"};
  80. code char PY_mb_ai[]    ={"哎哀唉埃挨皑癌爱"};
复制代码

  1. char code zimu[][9]={"AaBbCc","DdEeFf","GgHhIi","JjKkLl","MmNnOo","PpQqRrSs","TtUuVv","WwXxYyZz"};
  2. char code biaodian[]={".,?!:;\"'"};


  3. // 每次查询T9索引表得到的表项结果
  4. struct t9py_list t9py_result;


  5. //-------延时函数--------//
  6. void delay(uint t)
  7. {
  8.     uint j , k , l;
  9.     for (j=0;j<t;j++)
  10.         for (k=0;k<2;k++)
  11.             for (l=0;l<255;l++);
  12. }
  13. //--------写命令--------//
  14. void LCD_Wcode(char c)
  15. {
  16.     LCD_Rbusy();  //检测忙信号,如果忙碌,一直在这里循环
  17.     LCD_RS=0;
  18.     LCD_RW=0;
  19.     LCD_Bus=c;
  20.     LCD_E =1;
  21.     delay(10);            //延时
  22.     LCD_E=0;
  23. }

  24. //---------写数据------//
  25. void LCD_Wdata(char d)
  26. {
  27.     LCD_Rbusy();
  28.     LCD_RS=1;
  29.     LCD_RW=0;
  30.     LCD_Bus=d;
  31.     LCD_E =1;
  32.     delay(10);
  33.     LCD_E=0;
  34. }


  35. //-------初始化函数------//
  36. void  LCD_Init()
  37. {
  38.     LCD_RST=1;
  39. // LCD_PSB=1;
  40.     delay(2);
  41.     LCD_Clear();         //清显示
  42.     delay(2);
  43.     LCD_Wcode(0x06);  //地址复位
  44.     delay(2);
  45.     LCD_Wcode(0x0c);  //整体显示,关游标,不反白
  46.     delay(2);
  47.     LCD_Wcode(0x30);  //基本指令集,选择八位数据流
  48.     delay(2);

  49. }
  50. /*DS18B20复位,初始化*/
  51. void chu18b20()               
  52. {
  53.         uint i;
  54.         ds=0;
  55.         i=103;
  56.         while(i>0)i--;
  57.         ds=1;
  58.         i=4;
  59.         while(i>0)i--;
  60. }
  61. /*读1位数据函数*/
  62. bit du18b20bit()
  63. {
  64.         uint i;
  65.         bit dat;
  66.         ds=0;i++;                //i++延时
  67.         ds=1;i++;i++;
  68.         dat=ds;
  69.         i=8;while(i>0)i--;
  70.         return(dat);
  71. }
  72. /*读1个字节数*/
  73. uchar du18b20()       
  74. {
  75.         uchar i,j,dat;
  76.         dat=0;
  77.         for(i=1;i<=8;i++)        //读一个字节数据
  78.         {
  79.                   j=du18b20bit();
  80.                   dat=(j<<7)|(dat>>1);        //读出数据的最低位在前
  81.         }
  82.           return(dat);
  83. }
  84. /*向DS18B20写一个字节数据*/
  85. void xie18b20(uchar dat)
  86. {
  87.           uint i;
  88.           uchar j;
  89.           bit wei;                //定义一个位型变量
  90.           for(j=1;j<=8;j++)
  91.         {
  92.                   wei=dat&0x01;
  93.                   dat=dat>>1;
  94.                 if(wei)                //写位'1'
  95.                   {
  96.                         ds=0;
  97.                         i++;i++;
  98.                         ds=1;
  99.                         i=8;
  100.                         while(i>0)i--;        //延时
  101.                  }
  102.                 else
  103.                 {
  104.                           ds=0;        ////写位'0'
  105.                           i=8;
  106.                           while(i>0)i--;
  107.                           ds=1;
  108.                           i++;i++;
  109.                 }
  110.         }
  111. }
  112. /*读取温度值并转换*/
  113. zh18b20()
  114. {
  115.         uint a,b;
  116.         chu18b20();                //DS18B20初始化
  117.     delay(1);
  118.         xie18b20(0xcc);//跳过读序列号
  119.         xie18b20(0x44);//启动温度转换
  120.         chu18b20();
  121.         delay(1);
  122.         xie18b20(0xcc);//跳过读序列号
  123.         xie18b20(0xbe);//读取温度
  124.         a=du18b20();
  125.         b=du18b20();
  126.         tvalue=b;
  127.         tvalue<<=8;         //组合两个字节
  128.         tvalue=tvalue|a;
  129.         if(tvalue<0x08ff)         //判断温度符号
  130.         tflag=0;
  131.         else
  132. {                
  133.         tvalue=~tvalue+1;
  134.         tflag=1;
  135. }
  136.         tvalue=tvalue*(0.0625)*10;//温度值扩大10倍,精确到1位小数
  137.         return(tvalue);
  138. }
  139. /*温度值显示*/
  140. void xs18b20()
  141. {  
  142.         uchar space,num;
  143.         table[0]=tvalue/1000+0x30;//百位数
  144.         table[1]=tvalue%1000/100+0x30;//十位数
  145.         table[2]=tvalue%100/10+0x30;//个位数
  146.         table[3]=tvalue%10+0x30;//小数位
  147.         if(tflag==0)
  148.         space=0x20;//正温度不显示符号
  149.         else
  150.         space=0x2d;//负温度显示负号:-
  151.         if(table[0]==0x30)
  152.         {
  153.                 table[0]=0x20;        //如果百位为0,不显示
  154.                 if(table[1]==0x30)  
  155.                         table[1]=0x20;        //十位为0也不显示

  156.         }
  157.         LCD_Wcode(0x98+2); //0x80+0x40=0xc0,+4为前面空四列
  158.                 for(num=0;num<5;num++)
  159.                                         LCD_Wdata(table1[num]);
  160.         LCD_Wdata(space);//显示符号位
  161.         LCD_Wdata(table[0]);//显示百位
  162.         LCD_Wdata(table[1]);//显示十位
  163.         LCD_Wdata(table[2]);//显示个位
  164.         LCD_Wdata(0x2e);//显示小数点
  165.         LCD_Wdata(table[3]);//显示小数位
  166. }

  167. //-------复位函数-------//
  168. void LCD_Rest()
  169. {
  170.     LCD_RST=1;
  171.     delay(10);
  172.     LCD_RST=0;
  173.     delay(10);
  174.     LCD_RST=1;
  175.     delay(10);
  176. }
  177. //------检查忙碌函数-----//

  178. void LCD_Rbusy(void)
  179. {
  180.     LCD_RS=0;
  181.     LCD_RW=1;
  182.     LCD_E=1;
  183.     LCD_Bus=0xff;
  184.     while ((LCD_Bus&LCD_Busy)==LCD_Busy);
  185.     LCD_E=0;
  186. }


  187. //-----清屏函数--------//
  188. void LCD_Clear()
  189. {
  190.     LCD_Wcode(0x01);
  191. }

  192. //-----清除一二行-------//
  193. void LCD_qingchu_12( )
  194. {
  195.     uint i,j ;
  196.    LCD_Wcode(0x80);
  197.     for(i=16;i>0;i--)
  198.      LCD_Wdata(' ');
  199.      LCD_Wcode(0x90);
  200.     for(j=16;j>0;j--)
  201.      LCD_Wdata(' ');
  202. }


  203. //-----清除三四行-------//
  204. void LCD_qingchu_34( )
  205. {
  206.     uint i,j ;
  207.    LCD_Wcode(0x88);
  208.     for(i=16;i>0;i--)
  209.      LCD_Wdata(' ');
  210.      LCD_Wcode(0x98);
  211.     for(j=16;j>0;j--)
  212.      LCD_Wdata(' ');
  213. }
  214. //按键查询函数
  215. char get_key()
  216. {
  217.   while(1)
  218. {

  219.         if(key17==0)
  220.         {
  221.                 zh18b20();
  222.                 xs18b20();
  223.         }
  224.     if (key1==0)
  225.     {
  226.         delay(10);
  227.         if (key1==0)
  228.           {while(key1==0);
  229.            return 1;}
  230.     }
  231.    else if (key2==0)
  232.     {
  233.         delay(10);
  234.         if (key2==0)
  235.         {while(key2==0);
  236.            return 2;}
  237.     }
  238.    else  if (key3==0)
  239.     {
  240.         delay(10);
  241.         if (key3==0)
  242.         {while(key3==0);
  243.            return 3;}
  244.     }
  245.    else  if (key4==0)
  246.     {
  247.         delay(10);
  248.         if (key4==0)
  249.          {while(key4==0);
  250.            return 4;}
  251.      }

  252.   else  if (key5==0)
  253.     {
  254.          delay(10);
  255.          if (key5==0)
  256.          {while(key5==0);
  257.            return 5;}
  258.      }
  259.   else  if (key6==0)
  260.     {
  261.          delay(10);
  262.          if (key6==0)
  263.          {while(key6==0);
  264.             return 6;}
  265.     }
  266.   else  if (key7==0)
  267.     {
  268.           delay(10);
  269.           if (key7==0)
  270.           {while(key7==0);
  271.             return 7;}
  272.      }
  273.   else  if (key8==0)
  274.     {
  275.          delay(10);
  276.          if (key8==0)
  277.          {while(key8==0);
  278.            return 8;}
  279.     }
  280.   else  if (key9==0)
  281.     {
  282.          delay(10);
  283.          if (key9==0)
  284.          {while(key9==0);
  285.            return 9;}
  286.      }
  287.   else  if (key10==0)
  288.     {
  289.          delay(10);
  290.          if (key10==0)
  291.          {while(key10==0);
  292.            return 0;}
  293.     }
  294. else  if (key11==0)
  295.     {
  296.          delay(10);
  297.          if (key11==0)
  298.          {while(key11==0);
  299.            return 11;}
  300.     }
  301. else  if (key12==0)
  302.     {
  303.          delay(10);
  304.          if (key12==0)
  305.          {while(key12==0);
  306.            return 12;}
  307.      }
  308. else  if (key13==0)
  309.     {
  310.          delay(10);
  311.          if (key13==0)
  312.           {while(key13==0);
  313.            return 13;}
  314.      }
  315. else  if (key14==0)
  316.      {
  317.           delay(10);
  318.           if (key14==0)
  319.           {while(key14==0);
  320.            return 14;}
  321.      }
  322. else  if (key15==0)
  323.      {
  324.           delay(10);
  325.           if (key15==0)
  326.           {while(key15==0);
  327.            return 15;}
  328.      }

  329.   else  if (key16==0)
  330.      {
  331.          delay(10);
  332.          if (key16==0)
  333.          {while(key16==0);
  334.            return 16;}
  335.      }
  336.   }

  337. }





  338. /***********************************
  339.   *           T9辅助函数            *
  340. ***********************************/

  341. // 清空t9py_result
  342.    void t9py_result_clear()
  343.     {
  344.         int i;
  345.         for (i = 0; i < 8; i++)
  346.             t9py_result.entry[i] = NULL;
  347.         t9py_result.ele_num = 0;
  348.         t9py_result.ele_idx = 0;
  349.         t9py_result.hanzi_num = 0;
  350.         t9py_result.hanzi_idx = 0;
  351.     }

  352. // 判断t9py_result是否为空,空返回1
  353.     uint t9py_result_is_empty()
  354.     {
  355.         if (t9py_result.ele_num == 0)
  356.             return 1;
  357.         return 0;
  358.     }

  359. // 在t9py_result中增加一项
  360.     void t9py_result_add(struct t9py_index *idx)
  361.     {
  362.         int n=0;
  363.         while (t9py_result.entry[n] != NULL)
  364.             n++;
  365.         t9py_result.entry[n] = idx;
  366.         t9py_result.ele_num++;
  367.     }

  368. // 在t9py_result中选择下一项(作为当前拼音)
  369.     void t9py_result_select_next()
  370.     {
  371.         if (t9py_result.ele_num == 0)                // 无元素,没法选
  372.             return;
  373.         t9py_result.ele_idx++;
  374.         if (t9py_result.ele_idx > t9py_result.ele_num - 1)
  375.             t9py_result.ele_idx = t9py_result.ele_num - 1;
  376.     }

  377. // 在t9py_result中选择上一项(作为当前拼音)
  378.     void t9py_result_select_prev()
  379.     {
  380.         if (t9py_result.ele_num == 0)                // 无元素,没法选
  381.             return;

  382.         t9py_result.ele_idx--;
  383.         if (t9py_result.ele_idx < 0)
  384.             t9py_result.ele_idx = 0;
  385.     }

  386. // 复位t9py_result中的拼音选择
  387.     void t9py_result_select_reset()
  388.     {
  389.         t9py_result.ele_idx = 0;
  390.     }

  391. // 初始化当前选中拼音所对应的汉字选择结构
  392.     void t9py_result_hanzi_init()
  393.     {
  394.         if (t9py_result.ele_num == 0)
  395.             return;
  396.         t9py_result.hanzi_ptr =( (t9py_result.entry)[t9py_result.ele_idx])->py_mb;
  397.         t9py_result.hanzi_num = strlen(t9py_result.hanzi_ptr)/2 ;
  398.         t9py_result.hanzi_idx = 0;
  399.      }

  400. // 选择上一个当前读音的汉字
  401.     void t9py_result_hanzi_select_prev()
  402.     {
  403.         pos--;
  404.         if (pos<0)
  405.             pos=0;
  406.         if (t9py_result.hanzi_num == 0)                // 无元素,没法选
  407.             return;
  408.         t9py_result.hanzi_idx--;
  409.         if (t9py_result.hanzi_idx < 0)
  410.             t9py_result.hanzi_idx = 0;
  411.          LCD_Wcode(0x0f);
  412.          LCD_Wcode(0x98+pos);

  413.     }

  414. // 选择下一个当前读音的汉字
  415.     void t9py_result_hanzi_select_next()
  416.     {
  417.            pos++;
  418.             if(pos==8)
  419.                 pos=0;
  420.            if (t9py_result.hanzi_num== 0)                // 无元素,没法选
  421.                 return;
  422.               t9py_result.hanzi_idx++;
  423.            if (t9py_result.hanzi_idx > (t9py_result.hanzi_num - 1))
  424.              t9py_result.hanzi_idx = t9py_result.hanzi_num - 1;
  425.              LCD_Wcode(0x0f);
  426.               LCD_Wcode(0x98+pos);

  427.     }

  428. // 查询T9索引表 t9py_table[]
  429. // 查找数字序列与t9_str字符串相同的表项
  430. // 如找到匹配项,返回1,将结果存在t9py_result中
  431. // 如未找到匹配项,返回0,不改变t9py_result

  432.     uint t9_table_search()
  433.     {
  434.         int success;
  435.         char *str;
  436.         struct t9py_index *idx;
  437.         success = 0;
  438.         idx = &(t9py_table[0]);
  439.         str = idx->t9_str;
  440.         t9py_result_clear();        // 清空原来的结果
  441.         for (;strcmp(str,"");)
  442.         {
  443.             if (!strcmp(str, key_str))
  444.               {
  445.                 success=1;
  446.                 t9py_result_add(idx);
  447.               }
  448.             idx++;
  449.             str = idx->t9_str;
  450.         }
  451.               return success;
  452. }



  453. /***********************************
  454. *         字符串辅助函数          *
  455. ***********************************/

  456. // 判断T9数字按键
  457. char  is_t9_key(char e)
  458. {
  459.         if (e>=2&&e<=9)
  460.           return 1;
  461.         return 0;
  462. }
  463. // 删除字符串末尾的字符
  464. void str_uncat_char(char *s)
  465. {
  466.         if (!(*s))
  467.              return;
  468.         while (*s)
  469.           s++;
  470.           s--;
  471.          *s = 0;
  472. }
  473. // 在字符串末尾添加字符
  474. void str_cat_char(char *s, char c)
  475. {
  476.         while (*s)
  477.             s++;
  478.         *s = c;
  479.         s++;
  480.         *s = 0;
  481. }

  482. // 清除字符串
  483. void str_clear(char *s)
  484. {
  485.         *s = 0;
  486. }


  487. /***********************************
  488. *             显示汉字拼音函数             *
  489. ***********************************/

  490. void LCD_ShowString(char *st)
  491. {
  492.    uint i;
  493.    for(i=0;*st!='\0';i++,st++)
  494.    {
  495.       LCD_Wdata(*st);
  496.    }
  497.     delay(50);
  498.     LCD_Wdata(' ');

  499. }
  500. void display_pinyin(struct t9py_list *ptr)
  501. {
  502.         char *dizhi;
  503.         int j;
  504.         LCD_Wcode(0x88);
  505.         for(j=0;j<ptr->ele_num;j++)
  506.             {
  507.                 dizhi=ptr->entry[j]->py_str;
  508.                 LCD_ShowString(dizhi);
  509.             }
  510. }

  511. //显示选中拼音对应的汉字
  512. display_hanzi(struct t9py_list *ptr)
  513. {
  514.       int i, char_num;
  515.       char *hanzi;
  516.       hanzi=ptr->hanzi_ptr;
  517.       char_num=ptr->hanzi_num*2;
  518.       LCD_Wcode(0x98);
  519.       for(i=0;i<char_num;i++)
  520.       LCD_Wdata(*hanzi++);
  521. }


  522. //显示最后输出的字
  523. display_output_hanzi(struct t9py_list *ptr)
  524. {

  525.    char *hanzi;
  526.    int i;
  527.    char xx=0;
  528.    if(weizhi<=7)
  529.      LCD_Wcode(0x80+weizhi);
  530.    else  if(weizhi==16)
  531.        {
  532.           weizhi=0;
  533.           LCD_qingchu_12( );
  534.           LCD_Wcode(0x80+weizhi);
  535.          }
  536.    else
  537.       LCD_Wcode(0x90+weizhi-8);
  538.     xx=(ptr->hanzi_idx)*2;
  539.     hanzi=ptr->entry[ptr->ele_idx]->py_mb+xx;
  540.    for(i=0;i<2;i++)
  541.        LCD_Wdata( *hanzi++);
  542.     delay(5);
  543.     weizhi++;
  544. }


  545. /***********************************
  546. *            主函数             *
  547. ***********************************/
  548. #define STATE_PINYIN        1        // 输入拼音阶段
  549. #define STATE_HANZI        2       // 选择汉字阶段
  550. #define STATA_ZIMU      3       // 选择字母阶段
  551. #define STATA_BIAODIAN  4       // 选择标点阶段
  552. void main()
  553. {
  554.          uint ok, input_state, i,j;
  555.          LCD_Clear();
  556.          LCD_Rest();
  557.          LCD_Init();
  558.     while (1)
  559.          {               
  560.                  key = get_key();//获取键盘输入
  561.              if(key==0)                       //**********数字输入模块*********//
  562.                 {
  563.                    key=get_key();
  564.                    if(key>=0&&key<=9)
  565.                    sprintf(Fkey, " %d" , key);
  566.                    else
  567.                        break;
  568.                    if(weizhi<=7)
  569.                        LCD_Wcode(0x80+weizhi);
  570.                    else  if(weizhi==16)
  571.                       {
  572.                         weizhi=0;
  573.                          LCD_qingchu_12( );
  574.                          LCD_Wcode(0x80+weizhi);
  575.                       }
  576.                    else
  577.                      { LCD_Wcode(0x90+weizhi-8);  }
  578.                       LCD_Wdata(Fkey[1]);
  579.                       weizhi++;
  580.                  }


  581.         if(key==11)                        //********字母输入模块********//
  582.               {
  583.                  input_state=STATA_ZIMU;
  584.                  while(1)
  585.                    {

  586.                     if(input_state==STATA_ZIMU)
  587.                       {       
  588.                         key=get_key();
  589.                         if(key>=2&&key<=9)
  590.                           {
  591.                              zimu_str=zimu[key-2];
  592.                              LCD_Wcode(0x98);
  593.                              LCD_ShowString(zimu_str);

  594.                            }
  595.                           else   if(key==14)     //下键
  596.                            {
  597.                               zimu_str++;
  598.                            }
  599.                             else   if(key==15)   //上键
  600.                              {
  601.                                   zimu_str--;
  602.                              }
  603.                             else   if(key==16)
  604.                                {
  605.                                  if(weizhi<=7)
  606.                                    LCD_Wcode(0x80+weizhi);
  607.                                 else  if(weizhi==16)
  608.                                    {
  609.                                      weizhi=0;
  610.                                      LCD_qingchu_12( );
  611.                                      LCD_Wcode(0x80+weizhi);
  612.                                    }
  613.                                 else
  614.                                      LCD_Wcode(0x90+weizhi-8);
  615.                                   LCD_Wdata(*zimu_str);
  616.                                    weizhi++;
  617.                                   LCD_qingchu_34();
  618.                                   input_state = STATE_PINYIN;
  619.                         }
  620.                      }
  621.               if(input_state == STATE_PINYIN)  break;
  622.                  }
  623.             }


  624.          if(key==12)                          //********标点输入模块*********//
  625.                 {
  626.                      input_state=STATA_BIAODIAN;
  627.                      biaodian_str=biaodian;
  628.                      LCD_Wcode(0x98);
  629.                      LCD_ShowString(biaodian_str);      //把所有的标点符号显示在第四行
  630.                  while(1)
  631.                   {
  632.                     if(input_state==STATA_BIAODIAN)
  633.                        {
  634.                           key=get_key();
  635.                        if(key==14)
  636.                             biaodian_str++;
  637.                        else  if(key==15)
  638.                             biaodian_str--;
  639.                        else  if(key==16)
  640.                             {
  641.                              if(weizhi<=7)
  642.                                  LCD_Wcode(0x80+weizhi);
  643.                               else  if(weizhi==16)
  644.                                 {
  645.                                    weizhi=0;
  646.                                    LCD_qingchu_12( );
  647.                                    LCD_Wcode(0x80+weizhi);
  648.                                  }
  649.                                else
  650.                                      LCD_Wcode(0x90+weizhi-8);
  651.                                  LCD_Wdata(*biaodian_str);
  652.                                      weizhi++;
  653.                                  LCD_qingchu_34();
  654.                                   input_state = STATE_PINYIN;
  655.                             }
  656.                        }
  657.                    if(input_state == STATE_PINYIN) break;
  658.                  }
  659.                  }


  660.             if(key==13)                           //13键表示退格,把选出来的字或字母或数字删除
  661.                          {
  662.                            weizhi--;
  663.                            if(weizhi<=7)
  664.                               LCD_Wcode(0x80+weizhi);
  665.                            else
  666.                               LCD_Wcode(0x90+weizhi-8);
  667.                             for(j=0;j<=1;j++)
  668.                                LCD_Wdata(' ');
  669.                          }


  670.       if(key==1)                               //*********汉字输入程序模块********//
  671.         {
  672.            input_state = STATE_PINYIN;
  673.               while(1)
  674.                {
  675.                 key = get_key();
  676.                   sprintf(Fkey, " %d" , key);
  677.                 if (input_state == STATE_PINYIN)
  678.                    {
  679.                         if (is_t9_key(key))
  680.                             {
  681.                             str_cat_char(key_str, Fkey[1]);        // 将新输入的字符添加到末尾
  682.                                 ok = t9_table_search();
  683.                                   if(ok==1)
  684.                                                t9py_result_select_reset();        // 新输入成功,复位拼音选择
  685.                                       display_pinyin(&t9py_result);        // 刷新备选拼音显示
  686.                             }
  687.                           else {
  688.                                 if (key == 15)             //15表示上键
  689.                                     {
  690.                                    t9py_result_select_prev();

  691.                                     }
  692.                                   else if (key == 14)     //14表示下键
  693.                                      {
  694.                                         t9py_result_select_next();
  695.                                      }
  696.                                   else if(key==13)                //按下13退格键把三四行清
  697.                                     {
  698.                                       LCD_qingchu_34();           //清屏三四行
  699.                                       for (i = 0; i < 8; i++)
  700.                                       key_str[i] = NULL;       //复位key_str
  701.                                     }
  702.                                  else if (key == 16)
  703.                                      {
  704.                                         t9py_result_hanzi_init();       //16表示确定键
  705.                                         input_state = STATE_HANZI;        // 切换为显示汉字模式
  706.                                         display_hanzi(&t9py_result);        // 刷新备选汉字显示
  707.                                      }
  708.                                }
  709.                 }
  710.                else if (input_state == STATE_HANZI)
  711.                      {
  712.                         if (key == 15)
  713.                            {                                //15表示上键
  714.                              t9py_result_hanzi_select_prev();
  715.                            }
  716.                          else   if (key == 14)             //14表示下键
  717.                            {
  718.                              t9py_result_hanzi_select_next();
  719.                            }
  720.                          else   if (key == 16)            //16表示确定键
  721.                             {
  722.                              pos=0;
  723.                              LCD_Wcode(0x0c);
  724.                              input_state = STATE_PINYIN;
  725.                              display_output_hanzi(&t9py_result);        // 输出选中的汉字
  726.                              delay(100);
  727.                              LCD_qingchu_34();           //清屏三四行
  728.                              for (i = 0; i < 8; i++)
  729.                              key_str[i] = NULL;       //复位key_str
  730.                           }

  731.                     }

  732.         if(key==1)  break;            //当按下10或11或12或13时跳出汉字显示模块 再按相应键进入其他显示模块
  733.           }
  734.         }
  735.      }
  736. }
复制代码


输入法+温度.zip

78.87 KB, 下载次数: 13, 下载积分: 黑币 -5

评分

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

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:77675 发表于 2021-3-10 12:10 | 只看该作者
大神请收下我的膝盖,您真是太棒了。已经练到第几层?
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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