readline中的键盘码^[[A，^[[B，^[[D，^[[C （ANSI控制码）

最近调试u-boot的readline，对一些特殊按键键值有些疑惑，比如↑↓←→四个键，在linux的minicom敲下这几个键，串口会输出什么数据。
其实不需要用串口测试，我们可以写个小程序测试一下：

点击(此处)折叠或打开

1. #include <stdio.h>
   
2. #include <curses.h>
   
3. 
   
4. int main(int argc, char **argv)
   
5. {
   
6.     char a;
   
7.     char b[80];
   
8.     int i;
   
9.     printf("Please input a string
   
10.     :\n");
    
11. //    a = getc(stdin);
    
12.     scanf("%s",b);    
    
13. //    printf("The input a string is : 0x%x\n", a);
    
14.     printf("The input char is:\n");
    
15. 
    
16.     for(i = 0; b[i] !='\0' && i < 80; i++ )
    
17.         printf("0x%x ",b[i]);
    
18.     printf("\n");
    
19.     return 0;
    
20. }

测试：

点击(此处)折叠或打开

1. richard@richard-H81M-DS2:~/work/driver/test$ ./test
2. Please input a string:
3. ^[[A^[[B^[[D^[[C
4. The input char is:
5. 0x1b 0x5b 0x41 0x1b 0x5b 0x42 0x1b 0x5b 0x44 0x1b 0x5b 0x43

可以看到，当输入↑键，我们得到3个字节：0x1b 0x5b 0x41。
或者执行cat -v，然后输入 ↑↓←→（其他键也可以F1~F12）。

参考知乎一位大侠的说法：

http://www.zhihu.com/question/21518507
这下就明白了。再联系 cread_line 的代码片段：

点击(此处)折叠或打开

1. static int cread_line(const char *const prompt, char *buf, unsigned int *len,
   
2.         int timeout)
   
3. {
   
4.     unsigned long num = 0;
   
5.     unsigned long eol_num = 0;
   
6.     unsigned long wlen;
   
7.     char ichar;
   
8.     int insert = 1;
   
9.     int esc_len = 0;
   
10.     char esc_save[8];
    
11.     int init_len = strlen(buf);
    
12.     int first = 1;
    
13. 
    
14.     if (init_len)
    
15.         cread_add_str(buf, init_len, 1, &num, &eol_num, buf, *len);
    
16. 
    
17.     while (1) {
    
18. #ifdef CONFIG_BOOT_RETRY_TIME
    
19.         while (!tstc()) {    /* while no incoming data */
    
20.             if (retry_time >= 0 && get_ticks() > endtime)
    
21.                 return (-2);    /* timed out */
    
22.             WATCHDOG_RESET();
    
23.         }
    
24. #endif
    
25.         if (first && timeout) {
    
26.             uint64_t etime = endtick(timeout);
    
27. 
    
28.             while (!tstc()) {    /* while no incoming data */
    
29.                 if (get_ticks() >= etime)
    
30.                     return -2;    /* timed out */
    
31.                 WATCHDOG_RESET();
    
32.             }
    
33.             first = 0;
    
34.         }
    
35. 
    
36.         ichar = getcmd_getch();
    
37. 
    
38.         if ((ichar == '\n') || (ichar == '\r')) {
    
39.             putc('\n');
    
40.             break;
    
41.         }
    
42. 
    
43.         /*
    
44.          * handle standard linux xterm esc sequences for arrow key, etc.
    
45.          */
    
46.         if (esc_len != 0) {
    
47.             if (esc_len == 1) {
    
48.                 if (ichar == '[') {
    
49.                     esc_save[esc_len] = ichar;
    
50.                     esc_len = 2;
    
51.                 } else {
    
52.                     cread_add_str(esc_save, esc_len, insert,
    
53.                          &num, &eol_num, buf, *len);
    
54.                     esc_len = 0;
    
55.                 }
    
56.                 continue;
    
57.             }
    
58. 
    
59.             switch (ichar) {
    
60. 
    
61.             case 'D':    /* <- key */
    
62.                 ichar = CTL_CH('b');
    
63.                 esc_len = 0;
    
64.                 break;
    
65.             case 'C':    /* -> key */
    
66.                 ichar = CTL_CH('f');
    
67.                 esc_len = 0;
    
68.                 break;    /* pass off to ^F handler */
    
69.             case 'H':    /* Home key */
    
70.                 ichar = CTL_CH('a');
    
71.                 esc_len = 0;
    
72.                 break;    /* pass off to ^A handler */
    
73.             case 'A':    /* up arrow */
    
74.                 ichar = CTL_CH('p');
    
75.                 esc_len = 0;
    
76.                 break;    /* pass off to ^P handler */
    
77.             case 'B':    /* down arrow */
    
78.                 ichar = CTL_CH('n');
    
79.                 esc_len = 0;
    
80.                 break;    /* pass off to ^N handler */
    
81.             default:
    
82.                 esc_save[esc_len++] = ichar;
    
83.                 cread_add_str(esc_save, esc_len, insert,
    
84.                      &num, &eol_num, buf, *len);
    
85.                 esc_len = 0;
    
86.                 continue;
    
87.             }
    
88.         }
    
89. 
    
90.         switch (ichar) {
    
91.         case 0x1b:
    
92.             if (esc_len == 0) {
    
93.                 esc_save[esc_len] = ichar;
    
94.                 esc_len = 1;
    
95.             } else {
    
96.                 puts("impossible condition #876\n");
    
97.                 esc_len = 0;
    
98.             }
    
99.             break;
    
100. 
     
101.         case CTL_CH('a'):
     
102.             BEGINNING_OF_LINE();
     
103.             break;
     
104.         case CTL_CH('c'):    /* ^C - break */
     
105.             *buf = '\0';    /* discard input */
     
106.             return (-1);
     
107.         case CTL_CH('f'):
     
108.             if (num < eol_num) {
     
109.                 getcmd_putch(buf[num]);
     
110.                 num++;
     
111.             }
     
112.             break;
     
113.         case CTL_CH('b'):
     
114.             if (num) {
     
115.                 getcmd_putch(CTL_BACKSPACE);
     
116.                 num--;
     
117.             }
     
118.             break;
     
119.         case CTL_CH('d'):
     
120.             if (num < eol_num) {
     
121.                 wlen = eol_num - num - 1;
     
122.                 if (wlen) {
     
123.                     memmove(&buf[num], &buf[num+1], wlen);
     
124.                     putnstr(buf + num, wlen);
     
125.                 }
     
126. 
     
127.                 getcmd_putch(' ');
     
128.                 do {
     
129.                     getcmd_putch(CTL_BACKSPACE);
     
130.                 } while (wlen--);
     
131.                 eol_num--;
     
132.             }
     
133.             break;
     
134.         case CTL_CH('k'):
     
135.             ERASE_TO_EOL();
     
136.             break;
     
137.         case CTL_CH('e'):
     
138.             REFRESH_TO_EOL();
     
139.             break;
     
140.         case CTL_CH('o'):
     
141.             insert = !insert;
     
142.             break;
     
143.         case CTL_CH('x'):
     
144.         case CTL_CH('u'):
     
145.             BEGINNING_OF_LINE();
     
146.             ERASE_TO_EOL();
     
147.             break;
     
148.         case DEL:
     
149.         case DEL7:
     
150.         case 8:
     
151.             if (num) {
     
152.                 wlen = eol_num - num;
     
153.                 num--;
     
154.                 memmove(&buf[num], &buf[num+1], wlen);
     
155.                 getcmd_putch(CTL_BACKSPACE);
     
156.                 putnstr(buf + num, wlen);
     
157.                 getcmd_putch(' ');
     
158.                 do {
     
159.                     getcmd_putch(CTL_BACKSPACE);
     
160.                 } while (wlen--);
     
161.                 eol_num--;
     
162.             }
     
163.             break;
     
164.         case CTL_CH('p'):
     
165.         case CTL_CH('n'):
     
166.         {
     
167.             char * hline;
     
168. 
     
169.             esc_len = 0;
     
170. 
     
171.             if (ichar == CTL_CH('p'))
     
172.                 hline = hist_prev();
     
173.             else
     
174.                 hline = hist_next();
     
175. 
     
176.             if (!hline) {
     
177.                 getcmd_cbeep();
     
178.                 continue;
     
179.             }
     
180. 
     
181.             /* nuke the current line */
     
182.             /* first, go home */
     
183.             BEGINNING_OF_LINE();
     
184. 
     
185.             /* erase to end of line */
     
186.             ERASE_TO_EOL();
     
187. 
     
188.             /* copy new line into place and display */
     
189.             strcpy(buf, hline);
     
190.             eol_num = strlen(buf);
     
191.             REFRESH_TO_EOL();
     
192.             continue;
     
193.         }
     
194. #ifdef CONFIG_AUTO_COMPLETE
     
195.         case '\t': {
     
196.             int num2, col;
     
197. 
     
198.             /* do not autocomplete when in the middle */
     
199.             if (num < eol_num) {
     
200.                 getcmd_cbeep();
     
201.                 break;
     
202.             }
     
203. 
     
204.             buf[num] = '\0';
     
205.             col = strlen(prompt) + eol_num;
     
206.             num2 = num;
     
207.             if (cmd_auto_complete(prompt, buf, &num2, &col)) {
     
208.                 col = num2 - num;
     
209.                 num += col;
     
210.                 eol_num += col;
     
211.             }
     
212.             break;
     
213.         }
     
214. #endif
     
215.         default:
     
216.             cread_add_char(ichar, insert, &num, &eol_num, buf, *len);
     
217.             break;
     
218.         }
     
219.     }
     
220.     *len = eol_num;
     
221.     buf[eol_num] = '\0';    /* lose the newline */
     
222. 
     
223.     if (buf[0] && buf[0] != CREAD_HIST_CHAR)
     
224.         cread_add_to_hist(buf);
     
225.     hist_cur = hist_add_idx;
     
226. 
     
227.     return 0;
     
228. }

这些都是 ANSI 控制码 ，以ESC起始为标记，百度就知道了 。
在测试这个问题的时候，需要使用virtual box虚拟机中的xp串口进行测试，百度半天也没找到能完全说清楚的文章，下面介绍我个人的试验结果和理解：
第一种是裸文件，这种模式只能让虚拟机串口输出信息到宿主机（我的是ubuntu）的某个文件中，打开可以查看虚拟机串口发来的文字信息，基本没什么用。

第二种是主机管道，这个模式可以让主机和虚拟机进行串口通信，相当于建立一个模拟的串口通道，主机和虚拟机互联，这个模式非常有用，对于测试串口提供了很方便的测试条件，即使你电脑没有真是串口也没关系。再也不需要想办法去破解windows那些收费的虚拟串口软件了。
注意使用主机管道模式时，应在管道路径前加上前缀unix#，例如virtual box中设置了串口位置为/dev/xpserial，那么minicom中应设置Serial Device 为  unix#/dev/xpserial

第三种是主机设备，这个就相当于将真实主机绑定到虚拟机了，这时候真串口只能给虚拟机用，但是有延迟，有时候会丢数据，实际上个人认为如果只是简单数据收发没必要用这个模式，真串口给宿主机用就可以了。

F8:
ASCII 码：^[[19~
十六进制0x1b 0x5b 0x31 0x39 0x7e
第一个字节0x1b是"^[" ，第 二个字节0x5b是'['，第3个字节是0x31，第4字节就得到'9'， 同理，0x39得到'9 '，最后0x7e是'~'

\033\133\061\071\176
在securecrt做映射时可以使用 "\e[\061\071\176"

↑：
^[[A
^[是第一个字节0x1b ，第二个字节0x5b是[，最后的0x41是A
0x1b 0x5b 0x41
\033\133\101

Shift + F8:
^[[19;2~
0x1b 0x5b 0x31 0x39 0x3b 0x32 0x7e
"\e[\061\071\073\062\176"

关于控制码还可以参考：
http://bbs.csdn.net/topics/320015593