irDA + marvell 收发信号

点击(此处)折叠或打开

1. #include "gconf.h"
   
2. 
   
3. #include "peripheral.h"
   
4. 
   
5. #include "IrDA.h"
   
6. 
   
7. 
   
8. 
   
9. //############## recv ####################################################
   
10. 
    
11. static uint16_t ir_data[512];
    
12. 
    
13. static uint16_t oft;
    
14. 
    
15. 
    
16. 
    
17. static const char *IrDARecv_thread_name = "IrDARecv_thread";
    
18. 
    
19. static os_thread_t IrDARecv_thread;
    
20. 
    
21. static os_thread_stack_define(IrDARecv_thread_stack, 1024);
    
22. 
    
23. 
    
24. 
    
25. 
    
26. 
    
27. //???????è???í???é.
    
28. 
    
29. static int IrDA_RECV_PushBtn_Gpio;
    
30. 
    
31. static int IrDA_RECV_LED_Gpio, IrDA_MODE_LED_Gpio;
    
32. 
    
33. static volatile bool bInIrDARecvMode = false;
    
34. 
    
35. 
    
36. 
    
37. static void IrDARecv_task_exec(os_thread_arg_t arg)
    
38. 
    
39. {    
    
40. 
    
41.     volatile uint8_t curr, lasted;
    
42. 
    
43.         
    
44. 
    
45.     bInIrDARecvMode= true;
    
46. 
    
47.     led_on(IrDA_RECV_LED_Gpio);
    
48. 
    
49.     led_on(IrDA_MODE_LED_Gpio);
    
50. 
    
51.         
    
52. 
    
53.     lasted = GPIO_ReadPinLevel(CONFIG_IrDA_RECV);
    
54. 
    
55.     while ((curr = GPIO_ReadPinLevel(CONFIG_IrDA_RECV)) == lasted)
    
56. 
    
57.     {
    
58. 
    
59.     //    nd_delay_ms(1);
    
60. 
    
61.         os_thread_relinquish();
    
62. 
    
63.     }
    
64. 
    
65.     
    
66. 
    
67.     nd_reset_stopwatch();    
    
68. 
    
69.     lasted = curr;
    
70. 
    
71.     oft= 0;
    
72. 
    
73.     led_off(IrDA_MODE_LED_Gpio);
    
74. 
    
75.     
    
76. 
    
77.     while (1) {
    
78. 
    
79.         curr = GPIO_ReadPinLevel(CONFIG_IrDA_RECV);        
    
80. 
    
81.         if (curr != lasted) {
    
82. 
    
83.             ir_data[oft] =     nd_get_stopwatch();
    
84. 
    
85.             nd_reset_stopwatch();
    
86. 
    
87.             lasted = curr;
    
88. 
    
89.             oft++;
    
90. 
    
91.         }
    
92. 
    
93.         else {
    
94. 
    
95.             if (nd_get_stopwatch() > 10000) {
    
96. 
    
97.                 if (oft > 0) {
    
98. 
    
99.                     break;
    
100. 
     
101.                 }
     
102. 
     
103.             }
     
104. 
     
105.             os_thread_relinquish();
     
106. 
     
107.         }
     
108. 
     
109.     }
     
110. 
     
111.     nd_close_stopwatch();
     
112. 
     
113.     if (oft > 0) {
     
114. 
     
115.         dump_data_u16("ir_data",ir_data,oft);
     
116. 
     
117.     }
     
118. 
     
119.                         
     
120. 
     
121.     led_off(IrDA_RECV_LED_Gpio);
     
122. 
     
123.     bInIrDARecvMode= false;
     
124. 
     
125. 
     
126. 
     
127.     os_thread_self_complete(NULL);
     
128. 
     
129. }
     
130. 
     
131. 
     
132. 
     
133. 
     
134. 
     
135. static void IrDARecvMode_callback(void)
     
136. 
     
137. {
     
138. 
     
139.     if (bInIrDARecvMode) return;
     
140. 
     
141.     
     
142. 
     
143.     PMU_PowerOnVDDIO(PMU_VDDIO_D0);
     
144. 
     
145.     GPIO_PinMuxFun(CONFIG_IrDA_RECV,GPIO9_GPIO9);
     
146. 
     
147.     GPIO_SetPinDir(CONFIG_IrDA_RECV,GPIO_INPUT);    
     
148. 
     
149. 
     
150. 
     
151.     //when uart is OK, then prepare zigbee TASK and queue TASK.
     
152. 
     
153.     int ret = os_thread_create(&IrDARecv_thread,
     
154. 
     
155.         IrDARecv_thread_name, (void *)IrDARecv_task_exec, 0,
     
156. 
     
157.         &IrDARecv_thread_stack, OS_PRIO_1);
     
158. 
     
159. 
     
160.     if (ret)
     
161.     {
     
162.         dbg("Failed to create uart_monitor_thread");
     
163.         //appln_critical_error_handler(NULL);
     
164. 
     
165.     }
     
166. 
     
167. }
     
168. 
     
169. 
     
170. 
     
171. void init_IrDA_env(void)
     
172. 
     
173. {
     
174. 
     
175.     // push_button sw1 to indicate start SIR_RECV mode, and LED_2 for RUNNING
     
176. 
     
177.     IrDA_RECV_PushBtn_Gpio = board_button_1();
     
178. 
     
179.     IrDA_RECV_LED_Gpio = board_led_1();
     
180. 
     
181.     IrDA_MODE_LED_Gpio = board_led_2();
     
182. 
     
183.     gpio_drv_set_cb(NULL, IrDA_RECV_PushBtn_Gpio, GPIO_INT_FALLING_EDGE, IrDARecvMode_callback);    
     
184. 
     
185.     return;
     
186. 
     
187. }
     
188. 
     
189. 
     
190. 
     
191. void final_IrDA_env(void)
     
192. 
     
193. {
     
194. 
     
195.     gpio_drv_set_cb(NULL, IrDA_RECV_PushBtn_Gpio, GPIO_INT_FALLING_EDGE, NULL);
     
196. 
     
197.     return;
     
198. 
     
199. }
     
200. 
     
201. //######################### SIR send API ##############################################
     
202. 
     
203. static void IrDA_load(void)
     
204. 
     
205. {
     
206. 
     
207.     int div, ton, toff, period;
     
208. 
     
209. 
     
210. 
     
211.     /* Set GPT3 at ~ 32.768KHz */
     
212. 
     
213.     PMU_PowerOnVDDIO(PMU_VDDIO_D2);
     
214. 
     
215.     GPIO_PinMuxFun(CONFIG_IrDA_PWM, GPIO63_GPT3_CH2);    
     
216. 
     
217.     GPIO_PinMuxFun(CONFIG_IrDA_DATA,GPIO64_GPIO64);
     
218. 
     
219.     GPIO_SetPinDir(CONFIG_IrDA_DATA,GPIO_OUTPUT);
     
220. 
     
221.     
     
222. 
     
223.     CLK_GPTInternalClkSrc(CLK_GPT_ID_3, CLK_MAINXTAL); //32MHz. so cycle time is 1000000us/32M = 0.03125 us
     
224. 
     
225. 
     
226. 
     
227.     div = 8;
     
228. 
     
229.     period = (32000/div)/38; //cycles -- (1000000ns/38KHz) / (1000000/(32MHz/div))
     
230. 
     
231.     ton = period / 3;
     
232. 
     
233.     toff = period - ton;
     
234. 
     
235. 
     
236. 
     
237.     //dbg("pwm div=%d period=%d ton=%d toff=%d", div, period, ton, toff);
     
238. 
     
239.     
     
240. 
     
241.     CLK_ModuleClkDivider(CLK_GPT3, div);
     
242. 
     
243.     gpt_drv_pwm(g_rt_context.gpt3_dev, GPT_CH_2, ton, toff);
     
244. 
     
245.     
     
246. 
     
247. }
     
248. 
     
249. 
     
250. 
     
251. static void IrDA_unload(void)
     
252. 
     
253. {
     
254. 
     
255.     GPIO_PinMuxFun(CONFIG_IrDA_PWM, GPIO63_GPIO63);    
     
256. 
     
257.     GPIO_SetPinDir(CONFIG_IrDA_DATA,GPIO_INPUT);
     
258. 
     
259.     //PMU_PowerOffVDDIO(PMU_VDDIO_D2);
     
260. 
     
261. }
     
262. 
     
263. 
     
264. 
     
265. #if 0
     
266. 
     
267. static inline void IrDA_Level_Change(bool high_level, uint16_t timeout)
     
268. 
     
269. {
     
270. 
     
271.     if (high_level) {
     
272. 
     
273.         GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);
     
274. 
     
275.     }
     
276. 
     
277.     else {
     
278. 
     
279.         GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_HIGH);
     
280. 
     
281.     }
     
282. 
     
283.     nd_delay_us(timeout);
     
284. 
     
285. 
     
286. 
     
287. }
     
288. 
     
289. 
     
290. 
     
291. static void IrDA_Send_Buffer(uint16_t *buf, uint16_t length)
     
292. 
     
293. {
     
294. 
     
295.     uint16_t idx;
     
296. 
     
297.     bool high_level = true;
     
298. 
     
299.     gpt_drv_start(g_rt_context.gpt3_dev);
     
300. 
     
301.     
     
302. 
     
303.     for (idx=0; idx<length; idx++) {
     
304. 
     
305.         IrDA_Level_Change(high_level, buf[idx]);
     
306. 
     
307.         high_level = !high_level;
     
308. 
     
309.     }
     
310. 
     
311.     
     
312. 
     
313.     gpt_drv_stop(g_rt_context.gpt3_dev);
     
314. 
     
315.     GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);
     
316. 
     
317. }
     
318. 
     
319. 
     
320. 
     
321. #else
     
322. 
     
323. #define Ir_int_time     10
     
324. 
     
325. uint16_t ir_idx = 0, ir_length=0;
     
326. 
     
327. uint16_t *ir_buf, ir_count;
     
328. 
     
329. bool high_level = true;
     
330. 
     
331. 
     
332. 
     
333. static inline void IrDA_Gptimer_cb(void);
     
334. 
     
335. 
     
336. 
     
337. static void IrDA_Level_Change(bool high_level, uint16_t timeout)
     
338. 
     
339. {
     
340. 
     
341.     if (high_level) {
     
342. 
     
343.         GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);
     
344. 
     
345.     }
     
346. 
     
347.     else {
     
348. 
     
349.         GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_HIGH);
     
350. 
     
351.     }
     
352. 
     
353. }
     
354. 
     
355. 
     
356. 
     
357. static void IrDA_Gptimer_cb(void)
     
358. 
     
359. {
     
360. 
     
361.     ir_count += Ir_int_time * 10;                 
     
362. 
     
363.     if (ir_buf[ir_idx] <= ir_count) {     
     
364. 
     
365.         ir_count = 0;                            
     
366. 
     
367.         ir_idx++;                                
     
368. 
     
369.         high_level= !high_level;            
     
370. 
     
371.         
     
372. 
     
373.         IrDA_Level_Change(high_level, ir_buf[ir_idx]);
     
374. 
     
375.         if (ir_idx >= ir_length) {
     
376. 
     
377.             gpt_drv_setcb(g_rt_context.gpt3_dev, NULL);
     
378. 
     
379.             gpt_drv_stop(g_rt_context.gpt3_dev);
     
380. 
     
381.             GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);
     
382. 
     
383.         }
     
384. 
     
385.     }
     
386. 
     
387. }
     
388. 
     
389. 
     
390. 
     
391. static void IrDA_Send_Buffer(uint16_t *buf, uint16_t length)
     
392. 
     
393. {
     
394. 
     
395.     ir_length = length;
     
396. 
     
397.     ir_idx = 0;
     
398. 
     
399.     high_level = true;
     
400. 
     
401.     ir_buf= buf;
     
402. 
     
403.     ir_count=0;
     
404. 
     
405. 
     
406. 
     
407.     dbg("IrDA_Send_Buffer...");
     
408. 
     
409.     gpt_drv_set(g_rt_context.gpt3_dev, Ir_int_time);
     
410. 
     
411.     gpt_drv_setcb(g_rt_context.gpt3_dev, IrDA_Gptimer_cb);
     
412. 
     
413. 
     
414. 
     
415.     IrDA_Level_Change(high_level, ir_buf[ir_idx]);
     
416. 
     
417.     gpt_drv_start(g_rt_context.gpt3_dev);
     
418. 
     
419. 
     
420. 
     
421.     while (ir_idx < ir_length) {
     
422. 
     
423.         //os_thread_relinquish();
     
424. 
     
425.         os_thread_sleep(os_msec_to_ticks(100));
     
426. 
     
427.     }
     
428. 
     
429. }
     
430. 
     
431. 
     
432. 
     
433. #endif
     
434. 
     
435. 
     
436. 
     
437. 
     
438. 
     
439. #ifdef _TEST_CODE_INC_
     
440. 
     
441. 
     
442. 
     
443. void test_IrDA_func(void)
     
444. 
     
445. {
     
446. 
     
447.     //vTaskPrioritySet(NULL, OS_PRIO_0);
     
448. 
     
449. 
     
450. 
     
451.     uint16_t gree_shake_data[] = {
     
452. 
     
453.         1310, 386,1256, 436, 410,1280,1306, 388,1258, 434, 412,1278, 406,1286, 462,1230,
     
454. 
     
455.          462,1230, 462,1232,1258, 436, 410,8046,1260, 436,1256, 436, 410,1280,1258, 436,
     
456. 
     
457.         1256, 436, 410,1280, 412,1280, 460,1232, 462,1230, 460,1232,1306, 388, 410,8048,
     
458. 
     
459.         1306, 388,1258, 434, 410,1280,1302, 392,1256, 436, 410,1280, 462,1230, 412,1280,
     
460. 
     
461.          458,1236, 456,1234,1304, 390, 412,8046,1260, 434,1258, 436, 410,1278,1304, 392,
     
462. 
     
463.         1256, 436, 410,1278, 462,1230, 462,1230, 464,1228, 462,1232,1258, 436, 410,8046,
     
464. 
     
465.         1310, 386,1256, 436, 410,1280,1258, 436,1256, 436, 410,1280, 412,1280, 412,1280,
     
466. 
     
467.          460,1232, 412,1280,1258, 436, 410,8048,1310, 386,1256, 436, 410,1280,1258, 436,
     
468. 
     
469.         1256, 436, 410,1280, 460,1230, 414,1280, 458,1234, 412,1280,1308, 386, 410
     
470. 
     
471.     };
     
472. 
     
473. 
     
474. 
     
475.     dbg("Enter IrDA test...");
     
476. 
     
477.     IrDA_load();
     
478. 
     
479.     IrDA_Send_Buffer(gree_shake_data, ARRAYSIZE(gree_shake_data));
     
480. 
     
481.     IrDA_unload();
     
482. 
     
483.     dbg("Exit IrDA test...");
     
484. 
     
485. 
     
486. 
     
487.     //vTaskPrioritySet(NULL, OS_PRIO_3);
     
488. 
     
489. }
     
490. 
     
491. 
     
492. 
     
493. #endif

点击(此处)折叠或打开

1. #ifndef _PERIPERAL_IrDA_INC_
   
2. 
   
3. #define _PERIPERAL_IrDA_INC_
   
4. 
   
5. 
   
6. 
   
7. 
   
8. 
   
9. #define CONFIG_IrDA_PWM         GPIO_63        //GPT3 channel 2
   
10. 
    
11. #define CONFIG_IrDA_DATA            GPIO_64     //GPT3 channel 3
    
12. 
    
13. 
    
14. 
    
15. #define CONFIG_IrDA_RECV            GPIO_9        //?ì???????·
    
16. 
    
17. 
    
18. 
    
19. void init_IrDA_env(void);
    
20. 
    
21. void final_IrDA_env(void);
    
22. 
    
23. 
    
24. 
    
25. #ifdef _TEST_CODE_INC_
    
26. 
    
27. void test_IrDA_func(void);
    
28. 
    
29. #endif
    
30. 
    
31. 
    
32. 
    
33. 
    
34. 
    
35. #endif //_PERIPERAL_IrDA_INC_