熊那收的Btplug搞个盒子，不知道需不需要打散热孔？

72hour

外壳设计来源于 NNzT 估计也是这个坛子里的。原设计使用榫卯结构，可以不用胶水，但要双面雕刻对装夹要求高！我自己改成用胶水粘。省事！

这是原设计。


感谢 NNzT提供！

现在没有散热孔，不知道整体发热怎么样。

jckimi

这东西没抢到。。。。。

huojunan

呵呵，鼻涕擦~

文句子

我还以为你用btplug做了cnc的上位机呢
手工倒个角吧

holged

口水你的CNC控制器，我自己的机器准备装机了，兄弟可否分享资料仿照一个呢？

zzy9903

呵呵，我也在这坛子里混，今早起床看到你半夜发的消息了，恭喜你的盒子完工，我的好久都没动了，我是自己开店做买卖的，过完年好忙，一直没时间弄它，前两天测试了下GPIO，可以驱动1602LCD，我准备在盒子上加个LCD显示窗口，和关机按钮，还不知道什么年月能完工呢

72hour

zzy9903 发表于 2013-4-3 18:29 static/image/common/back.gif
呵呵，我也在这坛子里混，今早起床看到你半夜发的消息了，恭喜你的盒子完工，我的好久都没动了，我是自己开 ...

我也是拖了好久，才找到的材料！
驱动1602的源代码我找到了，可是我怎么编译都不通过，后来就没搞了！
你是怎么做到的啊？

aozima

口水雕刻机

zzy9903

72hour 发表于 2013-4-3 19:17 static/image/common/back.gif
我也是拖了好久，才找到的材料！
驱动1602的源代码我找到了，可是我怎么编译都不通过，后来就没搞了！
...

我的驱动1602还没做呢，现在只是在dos下测试GPIO端口成功，可以点灯了，但是dos下驱动1602也没啥意义，linux下编程我还不会呢，有空研究一下，路还很长啊

72hour

zzy9903 发表于 2013-4-3 19:49 static/image/common/back.gif
我的驱动1602还没做呢，现在只是在dos下测试GPIO端口成功，可以点灯了，但是dos下驱动1602也没啥意义，li ...

# RT1602C BTPlug GPIO接脚
DB0 ~ DB7   =>   GPIO00 ~ GPIO07
RS => GPIO10
RW => GPIO11
E  => GPIO13
Vdd/背光电压+ => 接串口的Vcc输出
GND => GPIO GND



makefile

1. DRIVER_VERSION := 1.0.0.000
   
2. 
   
3. KDIR := /lib/modules/$$$$(shell uname -r)/build
   
4. PWD := $$$$(shell pwd)
   
5. OBJ := gpio1602
   
6. 
   
7. obj-m := $$$$(OBJ).o
   
8. 
   
9. EXTRA_CFLAGS := -DDRIVER_VERSION="v$$$$(DRIVER_VERSION)"
   
10. 
    
11. all: clean compile
    
12. 
    
13. compile:
    
14. $$$$(MAKE) -C $$$$(KDIR) M=$$$$(PWD) modules
    
15. 
    
16. load:
    
17. su -c "insmod ./usbdpfp.ko"
    
18. 
    
19. load_debug:
    
20. @echo "try "tail -f /var/log/message" in another window as root...";
    
21. su -c "insmod ./$$$$(OBJ).ko debug=1"
    
22. 
    
23. unload:
    
24. -su -c "rmmod -s $$$$(OBJ)"
    
25. 
    
26. clean:
    
27. make -C /lib/modules/$$$$(shell uname -r)/build M=$$$$(PWD) clean
    
28. 
    
29. debug: unload clean compile load_debug
    

复制代码

gpio1602.c

1. /*
   
2. 2011-04-18. version 0.1
   
3. 
   
4. TTY DRIVER TO CONNECT LCM 1602 VIA BTPLUG GPIO
   
5. 
   
6. 本源码以MIT-LICENSE授权发布
   
7. 
   
8. Copyright (c) 2011 Jia Huang, jia.huang@geneegroup.com
   
9. 
   
10. Permission is hereby granted, free of charge, to any person obtaining
    
11. a copy of this software and associated documentation files (the
    
12. "Software"), to deal in the Software without restriction, including
    
13. without limitation the rights to use, copy, modify, merge, publish,
    
14. distribute, sublicense, and/or sell copies of the Software, and to
    
15. permit persons to whom the Software is furnished to do so, subject to
    
16. the following conditions:
    
17. 
    
18. The above copyright notice and this permission notice shall be
    
19. included in all copies or substantial portions of the Software.
    
20. 
    
21. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    
22. EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    
23. MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    
24. NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
    
25. LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
    
26. OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    
27. WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    
28. 
    
29. */
    
30. 
    
31. #define DRV_NAME "gpio1602"
    
32. #define DEV_NAME "ttyG"
    
33. 
    
34. #include <linux/console.h>
    
35. #include <linux/delay.h>
    
36. #include <linux/err.h>
    
37. #include <linux/kernel.h>
    
38. #include <linux/module.h>
    
39. #include <linux/mutex.h>
    
40. #include <linux/tty.h>
    
41. #include <linux/tty_driver.h>
    
42. #include <linux/tty_flip.h>
    
43. #include <linux/io.h>
    
44. 
    
45. #define BYTE unsigned char
    
46. #define UINT unsigned int
    
47. #define BOOL unsigned char
    
48. 
    
49. #define TRUE 1
    
50. #define FALSE 0
    
51. 
    
52. #define FLAG_RS 0x01
    
53. #define FLAG_RW 0x02
    
54. #define FLAG_E 0x04
    
55. 
    
56. #define DATA_BUSY 0x80
    
57. 
    
58. #define DATA_CTL 0x98
    
59. #define DATA 0x78
    
60. 
    
61. #define FLAG_CTL 0x99
    
62. #define FLAG 0x79
    
63. 
    
64. #define CMD_SET_OPT 0x20
    
65. #define CMD_OPT_8BITS 0x10
    
66. #define CMD_OPT_2LINES 0x08
    
67. #define CMD_OPT_F5x10 0x04
    
68. 
    
69. #define CMD_SET_DISP 0x08
    
70. #define CMD_DISP_ON 0x04
    
71. #define CMD_DISP_CURSOR_ON 0x02
    
72. #define CMD_DISP_CURSOR_BLINK 0x01
    
73. 
    
74. #define CMD_CLEAR 0x01
    
75. #define CMD_RESET_CURSOR 0x02
    
76. #define CMD_SET_MODE 0x04
    
77. #define CMD_MODE_SHIFT_RIGHT 0x02
    
78. #define CMD_MODE_SHIFT_SCREEN 0x01
    
79. 
    
80. #define CMD_SET_MOVE 0x10
    
81. #define CMD_MOVE_CURSOR 0x00
    
82. #define CMD_MOVE_SCREEN 0x08
    
83. #define CMD_MOVE_RIGHT 0x04
    
84. #define CMD_MOVE_LEFT 0x00
    
85. 
    
86. //#define FLAG_LINE1 0x00 //第一行显示位置0~15 0x00~0x0F
    
87. //#define FLAG_LINE1 0x40 //第二行显示位置0~15 0x41~0x4F
    
88. #define CMD_LOCATE 0x80
    
89. #define CMD_LOCATE_LINE2 0x40
    
90. 
    
91. #define MAX_X 16
    
92. #define MAX_Y 2
    
93. 
    
94. #define OUT(x,y) outb(y, x)
    
95. #define IN(x) inb(x)
    
96. #define DELAY(x) udelay(x)
    
97. 
    
98. 
    
99. /*
    
100. GPIO与1602连接：
     
101. DB0 = GPIO 00
     
102. |
     
103. DB7 = GPIO 07
     
104. 
     
105. RS = GPIO 10;
     
106. RW = GPIO 11;
     
107. E = GPIO 12;
     
108. */
     
109. 
     
110. static char g1602_buffer[MAX_Y][MAX_X];
     
111. 
     
112. static BYTE g1602_busy(void)
     
113. {
     
114. BYTE is_busy;
     
115. 
     
116. // rs = 0; rw = 1; e = 1; 检测忙标志
     
117. OUT(FLAG, FLAG_RW|FLAG_E);
     
118. OUT(DATA_CTL, 0); // set all pins to input mode
     
119. DELAY(5);
     
120. 
     
121. is_busy = (IN(DATA) & DATA_BUSY);
     
122. 
     
123. // e = 0;
     
124. OUT(FLAG, FLAG_RW);
     
125. 
     
126. OUT(DATA_CTL, 0xff); // set all pins to OUTPut mode
     
127. 
     
128. return is_busy;
     
129. }
     
130. 
     
131. static void g1602_command(BYTE cmd, int usec)
     
132. {
     
133. while (g1602_busy()) DELAY(5);
     
134. 
     
135. // rs = 0; rw = 0; e = 0;
     
136. OUT(FLAG, 0);
     
137. OUT(DATA, cmd);
     
138. 
     
139. // e = 1;
     
140. OUT(FLAG, FLAG_E);
     
141. DELAY(5);
     
142. 
     
143. // e = 0;
     
144. OUT(FLAG, 0);
     
145. 
     
146. DELAY(usec);
     
147. }
     
148. 
     
149. static int g1602_cur_x = 0, g1602_cur_y = 0;
     
150. 
     
151. static void g1602_locate(int x, int y)
     
152. {
     
153. BYTE flag = 0;
     
154. 
     
155. if (y > 0) flag |= CMD_LOCATE_LINE2;
     
156. flag |= (x >= MAX_X ? MAX_X - 1 : x);
     
157. 
     
158. g1602_command(CMD_LOCATE|flag, 50);
     
159. }
     
160. 
     
161. static void g1602_clear(void) {
     
162. g1602_cur_x = 0;
     
163. g1602_cur_y = 0;
     
164. g1602_command(CMD_CLEAR, 2000);
     
165. }
     
166. 
     
167. static void g1602_reset_cursor(void) {
     
168. g1602_cur_x = 0;
     
169. g1602_cur_y = 0;
     
170. g1602_command(CMD_RESET_CURSOR, 2000);
     
171. }
     
172. 
     
173. static void g1602_putc(BYTE ch)
     
174. {
     
175. while(g1602_busy()) DELAY(5);
     
176. 
     
177. // rs = 1; rw = 0; e = 0;
     
178. OUT(FLAG, FLAG_RS);
     
179. DELAY(5);
     
180. 
     
181. OUT(DATA, ch);
     
182. 
     
183. // rs = 1; rw = 0; e = 1;
     
184. OUT(FLAG, FLAG_RS|FLAG_E);
     
185. DELAY(5);
     
186. 
     
187. // rs = 1; rw = 0; e = 0;
     
188. OUT(FLAG, FLAG_RS);
     
189. }
     
190. 
     
191. static void g1602_raw_write(const char *s, int slen)
     
192. {
     
193. g1602_command(CMD_SET_MODE|CMD_MODE_SHIFT_RIGHT, 50);
     
194. while (slen--) {
     
195. g1602_putc(*s);
     
196. ++s;
     
197. }
     
198. }
     
199. 
     
200. static void g1602_scrollup(void) {
     
201. 
     
202. BYTE y=0;
     
203. for (y=1; y<MAX_Y; y++) {
     
204. memcpy(g1602_buffer[y-1], g1602_buffer[y], MAX_X);
     
205. }
     
206. 
     
207. memset(&g1602_buffer[MAX_Y-1], ' ', MAX_X);
     
208. 
     
209. // 更新整个屏幕
     
210. g1602_clear();
     
211. for (y=0; y<MAX_Y-1; y++) {
     
212. g1602_locate(0,0);
     
213. g1602_raw_write(g1602_buffer[y], MAX_X);
     
214. }
     
215. }
     
216. 
     
217. static void g1602_relocate(BOOL force) {
     
218. BOOL altered = FALSE;
     
219. 
     
220. if (g1602_cur_x == MAX_X) {
     
221. g1602_cur_x = 0;
     
222. g1602_cur_y ++;
     
223. altered = TRUE;
     
224. }
     
225. 
     
226. if (g1602_cur_y == MAX_Y) {
     
227. g1602_scrollup();
     
228. g1602_cur_x = 0;
     
229. g1602_cur_y = MAX_Y - 1;
     
230. altered = TRUE;
     
231. }
     
232. 
     
233. if (altered || force) {
     
234. g1602_locate(g1602_cur_x, g1602_cur_y);
     
235. }
     
236. }
     
237. 
     
238. static void g1602_show_cursor(BOOL show) {
     
239. if (show) {
     
240. g1602_command(CMD_SET_DISP|CMD_DISP_ON|CMD_DISP_CURSOR_ON|CMD_DISP_CURSOR_BLINK, 50);
     
241. }
     
242. else {
     
243. g1602_command(CMD_SET_DISP|CMD_DISP_ON, 50);
     
244. }
     
245. }
     
246. 
     
247. typedef enum {PARSE_NORMAL, PARSE_ESC, PARSE_CSI, PARSE_SPEC} PARSE_STATUS;
     
248. 
     
249. static void g1602_write(const char *s, int slen)
     
250. {
     
251. char ch;
     
252. int i;
     
253. static PARSE_STATUS status = PARSE_NORMAL;
     
254. static int codes[2] = {0, 0};
     
255. static int code_i = 0;
     
256. 
     
257. for (i=0; i < slen; i++) {
     
258. ch = s[i];
     
259. switch (status) {
     
260. case PARSE_SPEC:
     
261. if (ch >= '0' && ch <= '9') {
     
262. codes[code_i] = codes[code_i] * 10 + (ch - '0');
     
263. }
     
264. else switch (ch) {
     
265. case ';':
     
266. code_i++;
     
267. codes[code_i] = 0;
     
268. break;
     
269. case 'l':
     
270. if (codes[0] == 25) {
     
271. g1602_show_cursor(TRUE);
     
272. }
     
273. status = PARSE_NORMAL;
     
274. break;
     
275. case 'h':
     
276. if (codes[0] == 25) {
     
277. g1602_show_cursor(FALSE);
     
278. }
     
279. status = PARSE_NORMAL;
     
280. break;
     
281. default:
     
282. status = PARSE_NORMAL;
     
283. }
     
284. break;
     
285. case PARSE_CSI:
     
286. if (ch >= '0' && ch <= '9') {
     
287. codes[code_i] = codes[code_i] * 10 + (ch - '0');
     
288. }
     
289. else switch (ch) {
     
290. case ';': // sep
     
291. code_i++;
     
292. codes[code_i] = 0;
     
293. break;
     
294. case '?': //cursor ?
     
295. code_i = 0;
     
296. codes[0] = 0;
     
297. status = PARSE_SPEC;
     
298. break;
     
299. case 'J': //clear screen
     
300. g1602_clear();
     
301. status = PARSE_NORMAL;
     
302. break;
     
303. case 'K': //clean to end
     
304. g1602_relocate(FALSE);
     
305. {
     
306. int n = MAX_X - g1602_cur_x;
     
307. while (n--) g1602_putc(' ');
     
308. }
     
309. g1602_relocate(TRUE);
     
310. status = PARSE_NORMAL;
     
311. break;
     
312. case 'H': //locate to x:y *[x:yH
     
313. g1602_cur_x=codes[0];
     
314. g1602_cur_y=codes[1];
     
315. g1602_relocate(TRUE);
     
316. status = PARSE_NORMAL;
     
317. break;
     
318. default:
     
319. status = PARSE_NORMAL;
     
320. }
     
321. break;
     
322. case PARSE_ESC:
     
323. switch (ch) {
     
324. case '[':
     
325. status = PARSE_CSI;
     
326. code_i = 0;
     
327. codes[0] = 0;
     
328. break;
     
329. case 27:
     
330. break;
     
331. default:
     
332. status = PARSE_NORMAL;
     
333. i--; // 更新状态重新处理该字符
     
334. }
     
335. break;
     
336. default:
     
337. if (ch >= ' ') { // 空格
     
338. g1602_relocate(FALSE);
     
339. g1602_buffer[g1602_cur_y][g1602_cur_x] = ch;
     
340. g1602_putc(ch);
     
341. g1602_cur_x++;
     
342. }
     
343. else switch(ch) {
     
344. case '\e': // ESC
     
345. status = PARSE_ESC;
     
346. break;
     
347. case '\n':
     
348. g1602_cur_x = 0;
     
349. g1602_cur_y ++;
     
350. g1602_relocate(TRUE);
     
351. break;
     
352. /* default: skip */
     
353. }
     
354. }
     
355. }
     
356. }
     
357. 
     
358. static void g1602_puts(const char *s) {
     
359. g1602_write(s, strlen(s));
     
360. }
     
361. 
     
362. static void g1602_init(void)
     
363. {
     
364. 
     
365. memset(g1602_buffer, ' ', MAX_Y * MAX_X);
     
366. 
     
367. /* set GPIO port0[7-0] as OUTPut mode */
     
368. OUT(DATA_CTL, 0xff);
     
369. /* set GPIO port1[2-0] as OUTPut mode */
     
370. OUT(FLAG_CTL, FLAG_RS|FLAG_RW|FLAG_E);
     
371. 
     
372. g1602_command(CMD_SET_OPT|CMD_OPT_8BITS|CMD_OPT_2LINES, 50);
     
373. g1602_command(CMD_SET_DISP|CMD_DISP_ON, 50);
     
374. g1602_command(CMD_SET_MODE|CMD_MODE_SHIFT_RIGHT, 50);
     
375. 
     
376. g1602_clear();
     
377. 
     
378. }
     
379. 
     
380. #define pr_init(fmt, args...) ({ static const __initconst char __fmt[] = fmt; printk(__fmt, ## args); })
     
381. 
     
382. static struct tty_driver *gpio_driver;
     
383. static struct tty_struct * volatile gpio_tty;
     
384. static unsigned long gpio_count;
     
385. static DEFINE_MUTEX(gpio_tty_mutex);
     
386. 
     
387. static int
     
388. gpio_open(struct tty_struct *tty, struct file *filp)
     
389. {
     
390. mutex_lock(&gpio_tty_mutex);
     
391. pr_debug("open %lu\n", gpio_count);
     
392. ++gpio_count;
     
393. gpio_tty = tty;
     
394. mutex_unlock(&gpio_tty_mutex);
     
395. return 0;
     
396. }
     
397. 
     
398. static void
     
399. gpio_close(struct tty_struct *tty, struct file *filp)
     
400. {
     
401. mutex_lock(&gpio_tty_mutex);
     
402. pr_debug("close %lu\n", gpio_count);
     
403. if (--gpio_count == 0)
     
404. gpio_tty = NULL;
     
405. mutex_unlock(&gpio_tty_mutex);
     
406. }
     
407. 
     
408. #ifndef CONFIG_BFIN_JTAG_COMM_CONSOLE
     
409. # define acquire_console_sem()
     
410. # define release_console_sem()
     
411. #endif
     
412. static int gpio_write(struct tty_struct *tty, const unsigned char *buf, int count)
     
413. {
     
414. acquire_console_sem();
     
415. g1602_write(buf, count);
     
416. release_console_sem();
     
417. return count;
     
418. }
     
419. 
     
420. static void gpio_flush_chars(struct tty_struct *tty)
     
421. {
     
422. }
     
423. 
     
424. static int gpio_write_room(struct tty_struct *tty)
     
425. {
     
426. if (tty->stopped)
     
427. return 0;
     
428. return 32768;
     
429. }
     
430. 
     
431. static int gpio_chars_in_buffer(struct tty_struct *tty)
     
432. {
     
433. return 0;
     
434. }
     
435. 
     
436. static struct tty_operations gpio_ops = {
     
437. .open = gpio_open,
     
438. .close = gpio_close,
     
439. .write = gpio_write,
     
440. /*.put_char = gpio_put_char,*/
     
441. .flush_chars = gpio_flush_chars,
     
442. .write_room = gpio_write_room,
     
443. .chars_in_buffer = gpio_chars_in_buffer,
     
444. /*.wait_until_sent = gpio_wait_until_sent,*/
     
445. };
     
446. 
     
447. static int __init gpio_init(void)
     
448. {
     
449. int ret;
     
450. 
     
451. ret = -ENOMEM;
     
452. 
     
453. gpio_driver = alloc_tty_driver(1);
     
454. if (!gpio_driver)
     
455. goto err;
     
456. 
     
457. gpio_driver->owner = THIS_MODULE;
     
458. gpio_driver->driver_name = DRV_NAME;
     
459. gpio_driver->name = DEV_NAME;
     
460. gpio_driver->type = TTY_DRIVER_TYPE_SERIAL;
     
461. gpio_driver->subtype = SERIAL_TYPE_NORMAL;
     
462. gpio_driver->init_termios = tty_std_termios;
     
463. tty_set_operations(gpio_driver, &gpio_ops);
     
464. 
     
465. ret = tty_register_driver(gpio_driver);
     
466. if (ret)
     
467. goto err;
     
468. 
     
469. g1602_init();
     
470. 
     
471. pr_init(KERN_INFO DRV_NAME ": initialized\n");
     
472. 
     
473. return 0;
     
474. 
     
475. err:
     
476. put_tty_driver(gpio_driver);
     
477. return ret;
     
478. }
     
479. 
     
480. static void __exit gpio_exit(void)
     
481. {
     
482. tty_unregister_driver(gpio_driver);
     
483. put_tty_driver(gpio_driver);
     
484. }
     
485. 
     
486. static void gpio_console_write(struct console *co, const char *buf, unsigned count)
     
487. {
     
488. g1602_write(buf, count);
     
489. }
     
490. 
     
491. static struct tty_driver *gpio_console_device(struct console *co, int *index)
     
492. {
     
493. *index = co->index;
     
494. return gpio_driver;
     
495. }
     
496. 
     
497. static struct console gpio_console = {
     
498. .name = DEV_NAME,
     
499. .write = gpio_console_write,
     
500. .device = gpio_console_device,
     
501. .flags = CON_ANYTIME | CON_PRINTBUFFER,
     
502. .index = -1,
     
503. };
     
504. 
     
505. static int __init gpio_console_init(void)
     
506. {
     
507. register_console(&gpio_console);
     
508. return 0;
     
509. }
     
510. 
     
511. MODULE_AUTHOR("Jia Huang <jia.huang@geneegroup.com>");
     
512. MODULE_DESCRIPTION("TTY over GPIO for LCM1602");
     
513. MODULE_LICENSE("MIT");
     
514. 
     
515. module_init(gpio_init);
     
516. module_exit(gpio_exit);
     
517. console_initcall(gpio_console_init);
     

复制代码

现成的代码，但是在debian6现有能用的内核上没编译通过。