标题: 基于51单片机的中文输入系统程序设计 [打印本页]

---

作者: a282350757    时间: 2021-3-9 00:39
标题: 基于51单片机的中文输入系统程序设计


单片机源程序如下:

1. #include <reg52.H>
   
2. #include <string.h>
   
3. #include <stdio.h>
   
4. #include <intrins.h>
   
5. 
   
6. 
   
7. #define uchar unsigned char
   
8. #define uint  unsigned int
   
9. 
   
10. #define LCD_Bus   P0    //P0口输出数据
    
11. #define LCD_Busy  0x80
    
12. 
    
13. //---------定义接口----------//
    
14. sbit  LCD_RS=P2^7;
    
15. sbit  LCD_RW=P2^6;
    
16. sbit  LCD_E =P2^5;
    
17. sbit  LCD_RST=P2^4;
    
18. 
    
19. sbit key4=P1^0;    sbit key8=P1^1;       //定义按键的输入端
    
20. sbit key12=P1^2;    sbit key16=P1^3;
    
21. sbit key3=P1^4;    sbit key7=P1^5;
    
22. sbit key11=P1^6;    sbit key14=P1^7;
    
23. sbit key2=P3^0;    sbit key6=P3^1;
    
24. sbit key10=P3^2;   sbit key15=P3^3;
    
25. sbit key1=P3^4;   sbit key5=P3^5;
    
26. sbit key9=P3^6;   sbit key13=P3^7;
    
27. sbit key17=P2^1;
    
28. sbit ds=P2^0;        //温度传感器信号线
    
29. int tvalue,num1=0;//温度值
    
30. uchar tflag;//温度正负标志
    
31. uchar table[5];
    
32. code char table1[]={"温度:"};
    
33. //--------函数定义区--------//
    
34. void  delay (uint t);                    //延时函数
    
35. 
    
36. void  LCD_Rest();                       //LCD驱动函数
    
37. void  LCD_Init();
    
38. void  LCD_Wdata(uchar d);
    
39. void  LCD_Wcode(char c);
    
40. void  LCD_Rbusy();
    
41. char get_key();                         //拼音及汉字输出函数
    
42. display_hanzi(struct t9py_list *ptr);
    
43. display_output_hanzi(struct t9py_list *ptr);
    
44. void display_pinyin(struct t9py_list *ptr);
    
45. void LCD_ShowString(char *st);
    
46. 
    
47. void t9py_result_clear();              //拼音及汉字输出辅助函数
    
48. void t9py_result_add(struct t9py_index *idx);
    
49. void t9py_result_select_next();
    
50. void t9py_result_select_prev();
    
51. void t9py_result_select_reset();
    
52. void t9py_result_hanzi_init();
    
53. void t9py_result_hanzi_select_prev();
    
54. void t9py_result_hanzi_select_next();
    
55. uint t9_table_search();
    
56. 
    
57. char  is_t9_key(char e);               //字符串处理辅助函数
    
58. void str_uncat_char(char *s);
    
59. void str_cat_char(char *s, char c);
    
60. void str_clear(char *s);
    
61. void LCD_qingchu_34( );      //清除三四行
    
62. void LCD_qingchu_12( );
    
63. void LCD_Clear( );
    
64. 
    
65. 
    
66. int key;
    
67. int weizhi=0;
    
68. char Fkey[8]={""};
    
69. char key_str[8]={""};        // 从键盘输入的T9数字序列
    
70. char *zimu_str;
    
71. char *biaodian_str;
    
72. char pos=0;
    
73. 
    
74. 
    
75. 
    
76. 
    
77. // T9数字字母索引表项
    
78. struct t9py_index {
    
79.     char code *t9_str;                           //按键数字序列
    
80.     char code *py_str;                           //拼音编码字符串
    
81.     char code *py_mb;                            //该拼音对应的汉字码表地址
    
82. };
    
83. 
    
84. // T9数字字母索引结果（多重表项）
    
85. struct t9py_list {
    
86.     struct t9py_index * entry[8];
    
87.     int ele_num;                                // 拼音个数
    
88.     char ele_idx;                                // 当前选中的拼音（index）
    
89.     int hanzi_num;                                // 当前选中汉字中的汉字个数
    
90.     char hanzi_idx;                                // 当前选中拼音中的选中的汉字（index）
    
91.     char code *hanzi_ptr;                // 当前读音候选汉字字符串指针
    
92. };
    
93. //"拼音输入法汉字排列表,码表(mb)"
    
94. code char PY_mb_a[]     ={"阿啊"};
    
95. code char PY_mb_ai[]    ={"哎哀唉埃挨皑癌爱"};
    

复制代码

1. char code zimu[][9]={"AaBbCc","DdEeFf","GgHhIi","JjKkLl","MmNnOo","PpQqRrSs","TtUuVv","WwXxYyZz"};
   
2. char code biaodian[]={".,?!:;\"'"};
   
3. 
   
4. 
   
5. // 每次查询T9索引表得到的表项结果
   
6. struct t9py_list t9py_result;
   
7. 
   
8. 
   
9. //-------延时函数--------//
   
10. void delay(uint t)
    
11. {
    
12.     uint j , k , l;
    
13.     for (j=0;j<t;j++)
    
14.         for (k=0;k<2;k++)
    
15.             for (l=0;l<255;l++);
    
16. }
    
17. //--------写命令--------//
    
18. void LCD_Wcode(char c)
    
19. {
    
20.     LCD_Rbusy();  //检测忙信号,如果忙碌，一直在这里循环
    
21.     LCD_RS=0;
    
22.     LCD_RW=0;
    
23.     LCD_Bus=c;
    
24.     LCD_E =1;
    
25.     delay(10);            //延时
    
26.     LCD_E=0;
    
27. }
    
28. 
    
29. //---------写数据------//
    
30. void LCD_Wdata(char d)
    
31. {
    
32.     LCD_Rbusy();
    
33.     LCD_RS=1;
    
34.     LCD_RW=0;
    
35.     LCD_Bus=d;
    
36.     LCD_E =1;
    
37.     delay(10);
    
38.     LCD_E=0;
    
39. }
    
40. 
    
41. 
    
42. //-------初始化函数------//
    
43. void  LCD_Init()
    
44. {
    
45.     LCD_RST=1;
    
46. // LCD_PSB=1;
    
47.     delay(2);
    
48.     LCD_Clear();         //清显示
    
49.     delay(2);
    
50.     LCD_Wcode(0x06);  //地址复位
    
51.     delay(2);
    
52.     LCD_Wcode(0x0c);  //整体显示，关游标，不反白
    
53.     delay(2);
    
54.     LCD_Wcode(0x30);  //基本指令集,选择八位数据流
    
55.     delay(2);
    
56. 
    
57. }
    
58. /*DS18B20复位，初始化*/
    
59. void chu18b20()               
    
60. {
    
61.         uint i;
    
62.         ds=0;
    
63.         i=103;
    
64.         while(i>0)i--;
    
65.         ds=1;
    
66.         i=4;
    
67.         while(i>0)i--;
    
68. }
    
69. /*读1位数据函数*/
    
70. bit du18b20bit()
    
71. {
    
72.         uint i;
    
73.         bit dat;
    
74.         ds=0;i++;                //i++延时
    
75.         ds=1;i++;i++;
    
76.         dat=ds;
    
77.         i=8;while(i>0)i--;
    
78.         return(dat);
    
79. }
    
80. /*读1个字节数*/
    
81. uchar du18b20()       
    
82. {
    
83.         uchar i,j,dat;
    
84.         dat=0;
    
85.         for(i=1;i<=8;i++)        //读一个字节数据
    
86.         {
    
87.                   j=du18b20bit();
    
88.                   dat=(j<<7)|(dat>>1);        //读出数据的最低位在前
    
89.         }
    
90.           return(dat);
    
91. }
    
92. /*向DS18B20写一个字节数据*/
    
93. void xie18b20(uchar dat)
    
94. {
    
95.           uint i;
    
96.           uchar j;
    
97.           bit wei;                //定义一个位型变量
    
98.           for(j=1;j<=8;j++)
    
99.         {
    
100.                   wei=dat&0x01;
     
101.                   dat=dat>>1;
     
102.                 if(wei)                //写位'1'
     
103.                   {
     
104.                         ds=0;
     
105.                         i++;i++;
     
106.                         ds=1;
     
107.                         i=8;
     
108.                         while(i>0)i--;        //延时
     
109.                  }
     
110.                 else
     
111.                 {
     
112.                           ds=0;        ////写位'0'
     
113.                           i=8;
     
114.                           while(i>0)i--;
     
115.                           ds=1;
     
116.                           i++;i++;
     
117.                 }
     
118.         }
     
119. }
     
120. /*读取温度值并转换*/
     
121. zh18b20()
     
122. {
     
123.         uint a,b;
     
124.         chu18b20();                //DS18B20初始化
     
125.     delay(1);
     
126.         xie18b20(0xcc);//跳过读序列号
     
127.         xie18b20(0x44);//启动温度转换
     
128.         chu18b20();
     
129.         delay(1);
     
130.         xie18b20(0xcc);//跳过读序列号
     
131.         xie18b20(0xbe);//读取温度
     
132.         a=du18b20();
     
133.         b=du18b20();
     
134.         tvalue=b;
     
135.         tvalue<<=8;         //组合两个字节
     
136.         tvalue=tvalue|a;
     
137.         if(tvalue<0x08ff)         //判断温度符号
     
138.         tflag=0;
     
139.         else
     
140. {                
     
141.         tvalue=~tvalue+1;
     
142.         tflag=1;
     
143. }
     
144.         tvalue=tvalue*(0.0625)*10;//温度值扩大10倍，精确到1位小数
     
145.         return(tvalue);
     
146. }
     
147. /*温度值显示*/
     
148. void xs18b20()
     
149. {  
     
150.         uchar space,num;
     
151.         table[0]=tvalue/1000+0x30;//百位数
     
152.         table[1]=tvalue%1000/100+0x30;//十位数
     
153.         table[2]=tvalue%100/10+0x30;//个位数
     
154.         table[3]=tvalue%10+0x30;//小数位
     
155.         if(tflag==0)
     
156.         space=0x20;//正温度不显示符号
     
157.         else
     
158.         space=0x2d;//负温度显示负号:-
     
159.         if(table[0]==0x30)
     
160.         {
     
161.                 table[0]=0x20;        //如果百位为0，不显示
     
162.                 if(table[1]==0x30)  
     
163.                         table[1]=0x20;        //十位为0也不显示
     
164. 
     
165.         }
     
166.         LCD_Wcode(0x98+2); //0x80+0x40=0xc0,+4为前面空四列
     
167.                 for(num=0;num<5;num++)
     
168.                                         LCD_Wdata(table1[num]);
     
169.         LCD_Wdata(space);//显示符号位
     
170.         LCD_Wdata(table[0]);//显示百位
     
171.         LCD_Wdata(table[1]);//显示十位
     
172.         LCD_Wdata(table[2]);//显示个位
     
173.         LCD_Wdata(0x2e);//显示小数点
     
174.         LCD_Wdata(table[3]);//显示小数位
     
175. }
     
176. 
     
177. //-------复位函数-------//
     
178. void LCD_Rest()
     
179. {
     
180.     LCD_RST=1;
     
181.     delay(10);
     
182.     LCD_RST=0;
     
183.     delay(10);
     
184.     LCD_RST=1;
     
185.     delay(10);
     
186. }
     
187. //------检查忙碌函数-----//
     
188. 
     
189. void LCD_Rbusy(void)
     
190. {
     
191.     LCD_RS=0;
     
192.     LCD_RW=1;
     
193.     LCD_E=1;
     
194.     LCD_Bus=0xff;
     
195.     while ((LCD_Bus&LCD_Busy)==LCD_Busy);
     
196.     LCD_E=0;
     
197. }
     
198. 
     
199. 
     
200. //-----清屏函数--------//
     
201. void LCD_Clear()
     
202. {
     
203.     LCD_Wcode(0x01);
     
204. }
     
205. 
     
206. //-----清除一二行-------//
     
207. void LCD_qingchu_12( )
     
208. {
     
209.     uint i,j ;
     
210.    LCD_Wcode(0x80);
     
211.     for(i=16;i>0;i--)
     
212.      LCD_Wdata(' ');
     
213.      LCD_Wcode(0x90);
     
214.     for(j=16;j>0;j--)
     
215.      LCD_Wdata(' ');
     
216. }
     
217. 
     
218. 
     
219. //-----清除三四行-------//
     
220. void LCD_qingchu_34( )
     
221. {
     
222.     uint i,j ;
     
223.    LCD_Wcode(0x88);
     
224.     for(i=16;i>0;i--)
     
225.      LCD_Wdata(' ');
     
226.      LCD_Wcode(0x98);
     
227.     for(j=16;j>0;j--)
     
228.      LCD_Wdata(' ');
     
229. }
     
230. //按键查询函数
     
231. char get_key()
     
232. {
     
233.   while(1)
     
234. {
     
235. 
     
236.         if(key17==0)
     
237.         {
     
238.                 zh18b20();
     
239.                 xs18b20();
     
240.         }
     
241.     if (key1==0)
     
242.     {
     
243.         delay(10);
     
244.         if (key1==0)
     
245.           {while(key1==0);
     
246.            return 1;}
     
247.     }
     
248.    else if (key2==0)
     
249.     {
     
250.         delay(10);
     
251.         if (key2==0)
     
252.         {while(key2==0);
     
253.            return 2;}
     
254.     }
     
255.    else  if (key3==0)
     
256.     {
     
257.         delay(10);
     
258.         if (key3==0)
     
259.         {while(key3==0);
     
260.            return 3;}
     
261.     }
     
262.    else  if (key4==0)
     
263.     {
     
264.         delay(10);
     
265.         if (key4==0)
     
266.          {while(key4==0);
     
267.            return 4;}
     
268.      }
     
269. 
     
270.   else  if (key5==0)
     
271.     {
     
272.          delay(10);
     
273.          if (key5==0)
     
274.          {while(key5==0);
     
275.            return 5;}
     
276.      }
     
277.   else  if (key6==0)
     
278.     {
     
279.          delay(10);
     
280.          if (key6==0)
     
281.          {while(key6==0);
     
282.             return 6;}
     
283.     }
     
284.   else  if (key7==0)
     
285.     {
     
286.           delay(10);
     
287.           if (key7==0)
     
288.           {while(key7==0);
     
289.             return 7;}
     
290.      }
     
291.   else  if (key8==0)
     
292.     {
     
293.          delay(10);
     
294.          if (key8==0)
     
295.          {while(key8==0);
     
296.            return 8;}
     
297.     }
     
298.   else  if (key9==0)
     
299.     {
     
300.          delay(10);
     
301.          if (key9==0)
     
302.          {while(key9==0);
     
303.            return 9;}
     
304.      }
     
305.   else  if (key10==0)
     
306.     {
     
307.          delay(10);
     
308.          if (key10==0)
     
309.          {while(key10==0);
     
310.            return 0;}
     
311.     }
     
312. else  if (key11==0)
     
313.     {
     
314.          delay(10);
     
315.          if (key11==0)
     
316.          {while(key11==0);
     
317.            return 11;}
     
318.     }
     
319. else  if (key12==0)
     
320.     {
     
321.          delay(10);
     
322.          if (key12==0)
     
323.          {while(key12==0);
     
324.            return 12;}
     
325.      }
     
326. else  if (key13==0)
     
327.     {
     
328.          delay(10);
     
329.          if (key13==0)
     
330.           {while(key13==0);
     
331.            return 13;}
     
332.      }
     
333. else  if (key14==0)
     
334.      {
     
335.           delay(10);
     
336.           if (key14==0)
     
337.           {while(key14==0);
     
338.            return 14;}
     
339.      }
     
340. else  if (key15==0)
     
341.      {
     
342.           delay(10);
     
343.           if (key15==0)
     
344.           {while(key15==0);
     
345.            return 15;}
     
346.      }
     
347. 
     
348.   else  if (key16==0)
     
349.      {
     
350.          delay(10);
     
351.          if (key16==0)
     
352.          {while(key16==0);
     
353.            return 16;}
     
354.      }
     
355.   }
     
356. 
     
357. }
     
358. 
     
359. 
     
360. 
     
361. 
     
362. 
     
363. /***********************************
     
364.   *           T9辅助函数            *
     
365. ***********************************/
     
366. 
     
367. // 清空t9py_result
     
368.    void t9py_result_clear()
     
369.     {
     
370.         int i;
     
371.         for (i = 0; i < 8; i++)
     
372.             t9py_result.entry[i] = NULL;
     
373.         t9py_result.ele_num = 0;
     
374.         t9py_result.ele_idx = 0;
     
375.         t9py_result.hanzi_num = 0;
     
376.         t9py_result.hanzi_idx = 0;
     
377.     }
     
378. 
     
379. // 判断t9py_result是否为空，空返回1
     
380.     uint t9py_result_is_empty()
     
381.     {
     
382.         if (t9py_result.ele_num == 0)
     
383.             return 1;
     
384.         return 0;
     
385.     }
     
386. 
     
387. // 在t9py_result中增加一项
     
388.     void t9py_result_add(struct t9py_index *idx)
     
389.     {
     
390.         int n=0;
     
391.         while (t9py_result.entry[n] != NULL)
     
392.             n++;
     
393.         t9py_result.entry[n] = idx;
     
394.         t9py_result.ele_num++;
     
395.     }
     
396. 
     
397. // 在t9py_result中选择下一项（作为当前拼音）
     
398.     void t9py_result_select_next()
     
399.     {
     
400.         if (t9py_result.ele_num == 0)                // 无元素，没法选
     
401.             return;
     
402.         t9py_result.ele_idx++;
     
403.         if (t9py_result.ele_idx > t9py_result.ele_num - 1)
     
404.             t9py_result.ele_idx = t9py_result.ele_num - 1;
     
405.     }
     
406. 
     
407. // 在t9py_result中选择上一项（作为当前拼音）
     
408.     void t9py_result_select_prev()
     
409.     {
     
410.         if (t9py_result.ele_num == 0)                // 无元素，没法选
     
411.             return;
     
412. 
     
413.         t9py_result.ele_idx--;
     
414.         if (t9py_result.ele_idx < 0)
     
415.             t9py_result.ele_idx = 0;
     
416.     }
     
417. 
     
418. // 复位t9py_result中的拼音选择
     
419.     void t9py_result_select_reset()
     
420.     {
     
421.         t9py_result.ele_idx = 0;
     
422.     }
     
423. 
     
424. // 初始化当前选中拼音所对应的汉字选择结构
     
425.     void t9py_result_hanzi_init()
     
426.     {
     
427.         if (t9py_result.ele_num == 0)
     
428.             return;
     
429.         t9py_result.hanzi_ptr =( (t9py_result.entry)[t9py_result.ele_idx])->py_mb;
     
430.         t9py_result.hanzi_num = strlen(t9py_result.hanzi_ptr)/2 ;
     
431.         t9py_result.hanzi_idx = 0;
     
432.      }
     
433. 
     
434. // 选择上一个当前读音的汉字
     
435.     void t9py_result_hanzi_select_prev()
     
436.     {
     
437.         pos--;
     
438.         if (pos<0)
     
439.             pos=0;
     
440.         if (t9py_result.hanzi_num == 0)                // 无元素，没法选
     
441.             return;
     
442.         t9py_result.hanzi_idx--;
     
443.         if (t9py_result.hanzi_idx < 0)
     
444.             t9py_result.hanzi_idx = 0;
     
445.          LCD_Wcode(0x0f);
     
446.          LCD_Wcode(0x98+pos);
     
447. 
     
448.     }
     
449. 
     
450. // 选择下一个当前读音的汉字
     
451.     void t9py_result_hanzi_select_next()
     
452.     {
     
453.            pos++;
     
454.             if(pos==8)
     
455.                 pos=0;
     
456.            if (t9py_result.hanzi_num== 0)                // 无元素，没法选
     
457.                 return;
     
458.               t9py_result.hanzi_idx++;
     
459.            if (t9py_result.hanzi_idx > (t9py_result.hanzi_num - 1))
     
460.              t9py_result.hanzi_idx = t9py_result.hanzi_num - 1;
     
461.              LCD_Wcode(0x0f);
     
462.               LCD_Wcode(0x98+pos);
     
463. 
     
464.     }
     
465. 
     
466. // 查询T9索引表 t9py_table[]
     
467. // 查找数字序列与t9_str字符串相同的表项
     
468. // 如找到匹配项，返回1，将结果存在t9py_result中
     
469. // 如未找到匹配项，返回0，不改变t9py_result
     
470. 
     
471.     uint t9_table_search()
     
472.     {
     
473.         int success;
     
474.         char *str;
     
475.         struct t9py_index *idx;
     
476.         success = 0;
     
477.         idx = &(t9py_table[0]);
     
478.         str = idx->t9_str;
     
479.         t9py_result_clear();        // 清空原来的结果
     
480.         for (;strcmp(str,"");)
     
481.         {
     
482.             if (!strcmp(str, key_str))
     
483.               {
     
484.                 success=1;
     
485.                 t9py_result_add(idx);
     
486.               }
     
487.             idx++;
     
488.             str = idx->t9_str;
     
489.         }
     
490.               return success;
     
491. }
     
492. 
     
493. 
     
494. 
     
495. /***********************************
     
496. *         字符串辅助函数          *
     
497. ***********************************/
     
498. 
     
499. // 判断T9数字按键
     
500. char  is_t9_key(char e)
     
501. {
     
502.         if (e>=2&&e<=9)
     
503.           return 1;
     
504.         return 0;
     
505. }
     
506. // 删除字符串末尾的字符
     
507. void str_uncat_char(char *s)
     
508. {
     
509.         if (!(*s))
     
510.              return;
     
511.         while (*s)
     
512.           s++;
     
513.           s--;
     
514.          *s = 0;
     
515. }
     
516. // 在字符串末尾添加字符
     
517. void str_cat_char(char *s, char c)
     
518. {
     
519.         while (*s)
     
520.             s++;
     
521.         *s = c;
     
522.         s++;
     
523.         *s = 0;
     
524. }
     
525. 
     
526. // 清除字符串
     
527. void str_clear(char *s)
     
528. {
     
529.         *s = 0;
     
530. }
     
531. 
     
532. 
     
533. /***********************************
     
534. *             显示汉字拼音函数             *
     
535. ***********************************/
     
536. 
     
537. void LCD_ShowString(char *st)
     
538. {
     
539.    uint i;
     
540.    for(i=0;*st!='\0';i++,st++)
     
541.    {
     
542.       LCD_Wdata(*st);
     
543.    }
     
544.     delay(50);
     
545.     LCD_Wdata(' ');
     
546. 
     
547. }
     
548. void display_pinyin(struct t9py_list *ptr)
     
549. {
     
550.         char *dizhi;
     
551.         int j;
     
552.         LCD_Wcode(0x88);
     
553.         for(j=0;j<ptr->ele_num;j++)
     
554.             {
     
555.                 dizhi=ptr->entry[j]->py_str;
     
556.                 LCD_ShowString(dizhi);
     
557.             }
     
558. }
     
559. 
     
560. //显示选中拼音对应的汉字
     
561. display_hanzi(struct t9py_list *ptr)
     
562. {
     
563.       int i, char_num;
     
564.       char *hanzi;
     
565.       hanzi=ptr->hanzi_ptr;
     
566.       char_num=ptr->hanzi_num*2;
     
567.       LCD_Wcode(0x98);
     
568.       for(i=0;i<char_num;i++)
     
569.       LCD_Wdata(*hanzi++);
     
570. }
     
571. 
     
572. 
     
573. //显示最后输出的字
     
574. display_output_hanzi(struct t9py_list *ptr)
     
575. {
     
576. 
     
577.    char *hanzi;
     
578.    int i;
     
579.    char xx=0;
     
580.    if(weizhi<=7)
     
581.      LCD_Wcode(0x80+weizhi);
     
582.    else  if(weizhi==16)
     
583.        {
     
584.           weizhi=0;
     
585.           LCD_qingchu_12( );
     
586.           LCD_Wcode(0x80+weizhi);
     
587.          }
     
588.    else
     
589.       LCD_Wcode(0x90+weizhi-8);
     
590.     xx=(ptr->hanzi_idx)*2;
     
591.     hanzi=ptr->entry[ptr->ele_idx]->py_mb+xx;
     
592.    for(i=0;i<2;i++)
     
593.        LCD_Wdata( *hanzi++);
     
594.     delay(5);
     
595.     weizhi++;
     
596. }
     
597. 
     
598. 
     
599. /***********************************
     
600. *            主函数             *
     
601. ***********************************/
     
602. #define STATE_PINYIN        1        // 输入拼音阶段
     
603. #define STATE_HANZI        2       // 选择汉字阶段
     
604. #define STATA_ZIMU      3       // 选择字母阶段
     
605. #define STATA_BIAODIAN  4       // 选择标点阶段
     
606. void main()
     
607. {
     
608.          uint ok, input_state, i,j;
     
609.          LCD_Clear();
     
610.          LCD_Rest();
     
611.          LCD_Init();
     
612.     while (1)
     
613.          {               
     
614.                  key = get_key();//获取键盘输入
     
615.              if(key==0)                       //**********数字输入模块*********//
     
616.                 {
     
617.                    key=get_key();
     
618.                    if(key>=0&&key<=9)
     
619.                    sprintf(Fkey, " %d" , key);
     
620.                    else
     
621.                        break;
     
622.                    if(weizhi<=7)
     
623.                        LCD_Wcode(0x80+weizhi);
     
624.                    else  if(weizhi==16)
     
625.                       {
     
626.                         weizhi=0;
     
627.                          LCD_qingchu_12( );
     
628.                          LCD_Wcode(0x80+weizhi);
     
629.                       }
     
630.                    else
     
631.                      { LCD_Wcode(0x90+weizhi-8);  }
     
632.                       LCD_Wdata(Fkey[1]);
     
633.                       weizhi++;
     
634.                  }
     
635. 
     
636. 
     
637.         if(key==11)                        //********字母输入模块********//
     
638.               {
     
639.                  input_state=STATA_ZIMU;
     
640.                  while(1)
     
641.                    {
     
642. 
     
643.                     if(input_state==STATA_ZIMU)
     
644.                       {       
     
645.                         key=get_key();
     
646.                         if(key>=2&&key<=9)
     
647.                           {
     
648.                              zimu_str=zimu[key-2];
     
649.                              LCD_Wcode(0x98);
     
650.                              LCD_ShowString(zimu_str);
     
651. 
     
652.                            }
     
653.                           else   if(key==14)     //下键
     
654.                            {
     
655.                               zimu_str++;
     
656.                            }
     
657.                             else   if(key==15)   //上键
     
658.                              {
     
659.                                   zimu_str--;
     
660.                              }
     
661.                             else   if(key==16)
     
662.                                {
     
663.                                  if(weizhi<=7)
     
664.                                    LCD_Wcode(0x80+weizhi);
     
665.                                 else  if(weizhi==16)
     
666.                                    {
     
667.                                      weizhi=0;
     
668.                                      LCD_qingchu_12( );
     
669.                                      LCD_Wcode(0x80+weizhi);
     
670.                                    }
     
671.                                 else
     
672.                                      LCD_Wcode(0x90+weizhi-8);
     
673.                                   LCD_Wdata(*zimu_str);
     
674.                                    weizhi++;
     
675.                                   LCD_qingchu_34();
     
676.                                   input_state = STATE_PINYIN;
     
677.                         }
     
678.                      }
     
679.               if(input_state == STATE_PINYIN)  break;
     
680.                  }
     
681.             }
     
682. 
     
683. 
     
684.          if(key==12)                          //********标点输入模块*********//
     
685.                 {
     
686.                      input_state=STATA_BIAODIAN;
     
687.                      biaodian_str=biaodian;
     
688.                      LCD_Wcode(0x98);
     
689.                      LCD_ShowString(biaodian_str);      //把所有的标点符号显示在第四行
     
690.                  while(1)
     
691.                   {
     
692.                     if(input_state==STATA_BIAODIAN)
     
693.                        {
     
694.                           key=get_key();
     
695.                        if(key==14)
     
696.                             biaodian_str++;
     
697.                        else  if(key==15)
     
698.                             biaodian_str--;
     
699.                        else  if(key==16)
     
700.                             {
     
701.                              if(weizhi<=7)
     
702.                                  LCD_Wcode(0x80+weizhi);
     
703.                               else  if(weizhi==16)
     
704.                                 {
     
705.                                    weizhi=0;
     
706.                                    LCD_qingchu_12( );
     
707.                                    LCD_Wcode(0x80+weizhi);
     
708.                                  }
     
709.                                else
     
710.                                      LCD_Wcode(0x90+weizhi-8);
     
711.                                  LCD_Wdata(*biaodian_str);
     
712.                                      weizhi++;
     
713.                                  LCD_qingchu_34();
     
714.                                   input_state = STATE_PINYIN;
     
715.                             }
     
716.                        }
     
717.                    if(input_state == STATE_PINYIN) break;
     
718.                  }
     
719.                  }
     
720. 
     
721. 
     
722.             if(key==13)                           //13键表示退格，把选出来的字或字母或数字删除
     
723.                          {
     
724.                            weizhi--;
     
725.                            if(weizhi<=7)
     
726.                               LCD_Wcode(0x80+weizhi);
     
727.                            else
     
728.                               LCD_Wcode(0x90+weizhi-8);
     
729.                             for(j=0;j<=1;j++)
     
730.                                LCD_Wdata(' ');
     
731.                          }
     
732. 
     
733. 
     
734.       if(key==1)                               //*********汉字输入程序模块********//
     
735.         {
     
736.            input_state = STATE_PINYIN;
     
737.               while(1)
     
738.                {
     
739.                 key = get_key();
     
740.                   sprintf(Fkey, " %d" , key);
     
741.                 if (input_state == STATE_PINYIN)
     
742.                    {
     
743.                         if (is_t9_key(key))
     
744.                             {
     
745.                             str_cat_char(key_str, Fkey[1]);        // 将新输入的字符添加到末尾
     
746.                                 ok = t9_table_search();
     
747.                                   if(ok==1)
     
748.                                                t9py_result_select_reset();        // 新输入成功，复位拼音选择
     
749.                                       display_pinyin(&t9py_result);        // 刷新备选拼音显示
     
750.                             }
     
751.                           else {
     
752.                                 if (key == 15)             //15表示上键
     
753.                                     {
     
754.                                    t9py_result_select_prev();
     
755. 
     
756.                                     }
     
757.                                   else if (key == 14)     //14表示下键
     
758.                                      {
     
759.                                         t9py_result_select_next();
     
760.                                      }
     
761.                                   else if(key==13)                //按下13退格键把三四行清
     
762.                                     {
     
763.                                       LCD_qingchu_34();           //清屏三四行
     
764.                                       for (i = 0; i < 8; i++)
     
765.                                       key_str[i] = NULL;       //复位key_str
     
766.                                     }
     
767.                                  else if (key == 16)
     
768.                                      {
     
769.                                         t9py_result_hanzi_init();       //16表示确定键
     
770.                                         input_state = STATE_HANZI;        // 切换为显示汉字模式
     
771.                                         display_hanzi(&t9py_result);        // 刷新备选汉字显示
     
772.                                      }
     
773.                                }
     
774.                 }
     
775.                else if (input_state == STATE_HANZI)
     
776.                      {
     
777.                         if (key == 15)
     
778.                            {                                //15表示上键
     
779.                              t9py_result_hanzi_select_prev();
     
780.                            }
     
781.                          else   if (key == 14)             //14表示下键
     
782.                            {
     
783.                              t9py_result_hanzi_select_next();
     
784.                            }
     
785.                          else   if (key == 16)            //16表示确定键
     
786.                             {
     
787.                              pos=0;
     
788.                              LCD_Wcode(0x0c);
     
789.                              input_state = STATE_PINYIN;
     
790.                              display_output_hanzi(&t9py_result);        // 输出选中的汉字
     
791.                              delay(100);
     
792.                              LCD_qingchu_34();           //清屏三四行
     
793.                              for (i = 0; i < 8; i++)
     
794.                              key_str[i] = NULL;       //复位key_str
     
795.                           }
     
796. 
     
797.                     }
     
798. 
     
799.         if(key==1)  break;            //当按下10或11或12或13时跳出汉字显示模块 再按相应键进入其他显示模块
     
800.           }
     
801.         }
     
802.      }
     
803. }
     

复制代码

输入法+温度.zip

2021-3-9 00:39 上传

点击文件名下载附件

下载积分: 黑币 -5

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

---

作者: lipen2008    时间: 2021-3-10 12:10
大神请收下我的膝盖，您真是太棒了。已经练到第几层？

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1