433 接收 + marvell

点击(此处)折叠或打开

1. #include "gconf.h"
   
2. #include <mdev_wdt.h>
   
3. #include <mc200_driver.h>
   
4. 
   
5. static mdev_t *gpt3_dev = NULL;
   
6. 
   
7. #define SOF_HIGH_MAX    4900
   
8. #define SOF_HIGH_MIN    4700
   
9. #define SOF_LOW_MAX    1600
   
10. #define SOF_LOW_MIN    1400
    
11. 
    
12. #define LEVEL_0_MIN    300    
    
13. #define LEVEL_0_MAX    500    
    
14. #define LEVEL_1_MIN    600    
    
15. #define LEVEL_1_MAX    800    
    
16. 
    
17. #define MIN_SIZE_CODE    42
    
18. 
    
19. static volatile bool bTerminated = false;
    
20. static uint32_t data[8192];
    
21. static uint32_t idx_data = 0;
    
22. 
    
23. 
    
24. #define DUMP_WRAPAROUND 16
    
25. void dump_dec(const uint32_t *data, unsigned len)
    
26. {
    
27.     wmprintf("**** Dump @ 0x%x Len: %d ****\n\r", data, len);
    
28. 
    
29.     int i;
    
30.     for (i = 0; i < len;) {
    
31.         wmprintf("%8d ", data[i++]);
    
32.         if (!(i % DUMP_WRAPAROUND))
    
33.             wmprintf("\n\r");
    
34.     }
    
35. 
    
36.     wmprintf("\n\r******** End Dump *******\n\r");
    
37. }
    
38. 
    
39. static mdev_t *gpio_dev = NULL;
    
40. static uint32_t lasted_v = 0;
    
41. static bool bSOF = false;
    
42. 
    
43. static void edges_callback (int pin, void *arg);
    
44. 
    
45. static inline void check_capture(uint32_t value)
    
46. {
    
47.     if (!bSOF) {
    
48.         if (1 == GPIO_ReadPinLevel(IO_433_RECV))
    
49.         {
    
50.             idx_data = 0;
    
51. 
    
52.             if (((lasted_v > SOF_HIGH_MIN) && (lasted_v < SOF_HIGH_MAX)) && ((value > SOF_LOW_MIN) && (value < SOF_LOW_MAX)))
    
53.             {
    
54.                 data[idx_data++] = lasted_v;
    
55.                 data[idx_data++] = value ;
    
56.                 bSOF = true;
    
57.             }
    
58.         }
    
59.     }
    
60.     else
    
61.     {
    
62.         if (((value > LEVEL_0_MIN) && (value < LEVEL_0_MAX)) || ((value > LEVEL_1_MIN) && (value < LEVEL_1_MAX))) {
    
63.             data[idx_data++] = value;
    
64.         }
    
65.         else {
    
66.             bSOF = false;
    
67.             data[idx_data++] = value;
    
68.         }
    
69.         
    
70.         if ((!bSOF && (idx_data >= MIN_SIZE_CODE) )|| (idx_data > 250)) {
    
71.             gpio_drv_set_cb(NULL, IO_433_RECV, GPIO_INT_DISABLE, NULL, NULL);
    
72.             dump_dec(data, idx_data);
    
73.             memset(data, 0, sizeof(data));
    
74.             idx_data = 0;
    
75.             lasted_v = 0;
    
76.             bSOF = false;
    
77.             gpio_drv_set_cb(NULL, IO_433_RECV, GPIO_INT_BOTH_EDGES, NULL, edges_callback);
    
78.         }
    
79.     }
    
80. }
    
81. 
    
82. static void edges_callback (int pin, void *arg)
    
83. {    
    
84.     uint32_t value = GPT_GetCounterVal(GPT3_ID)/50; // -->> us
    
85.     gpt_drv_set(gpt3_dev, 0xFFFFFFFF/50);
    
86. 
    
87.     check_capture(value);    
    
88.     lasted_v = value;        
    
89. }
    
90. 
    
91. void waiting_RF433_info(void)
    
92. {
    
93.     WDT_Disable();
    
94.     //init
    
95.     PMU_PowerOnVDDIO(PMU_VDDIO_D0);
    
96. 
    
97.     //start hwtimer    
    
98.     gpt_drv_init(GPT3_ID);    
    
99.     gpt3_dev = gpt_drv_open(GPT3_ID);
    
100.     gpt_drv_set(gpt3_dev, 0xFFFFFFFF/50);
     
101.     gpt_drv_start(gpt3_dev);
     
102.     
     
103.     //set gpio callback.
     
104.     gpio_drv_init();
     
105.     gpio_drv_set_cb(NULL, IO_433_RECV, GPIO_INT_BOTH_EDGES, NULL, edges_callback);    //GPIO_INT_BOTH_EDGES, GPIO_INT_RISING_EDGE, GPIO_INT_FALLING_EDGE
     
106.     
     
107.     idx_data = 0;
     
108.     bSOF = false;
     
109.     lasted_v = 0;
     
110.     memset(data, 0, sizeof(data));
     
111.     
     
112.     gpio_dev = gpio_drv_open("MDEV_GPIO");
     
113.     gpio_drv_setdir(gpio_dev, IO_433_RECV, GPIO_INPUT);
     
114.     gpio_drv_close(gpio_dev);
     
115.     
     
116.     //WDT_Enable();    
     
117.     
     
118. }
     
119. 
     
120. void start_rf433_recv_proc(void)
     
121. {
     
122.     dbg("Enter Recving ...");
     
123.     bTerminated = false;    
     
124. 
     
125.     waiting_RF433_info();    
     
126. }
     
127. 
     
128. void stop_rf433_recv_proc(void)
     
129. {
     
130.     dbg("Exit Recving ***");
     
131.     bTerminated = true;
     
132. }

开一个定时器， 在每次 IO的边沿触发时取出所有的时间， 判断是否引导头以及是否后续数据合适， 记入数据缓冲区即可。

点击(此处)折叠或打开

1. **** Dump @ 0x20000934 Len: 82 ****
   
2.     4818 1502 358 726 368 726 358 727 364 716 365 723 372 717 366 718
   
3.      371 725 376 715 717 366 375 718 365 719 374 719 367 716 367 717
   
4.      375 733 714 368 722 373 716 374 363 725 713 367 375 749 718 376
   
5.      716 390 358 723 714 372 371 722 710 377 355 726 370 721 364 721
   
6.      720 382 361 723 367 716 375 712 723 372 367 721 364 724 361 722
   
7.      712 32610
   
8. ******** End Dump *******
   
9. **** Dump @ 0x20000934 Len: 82 ****
   
10.     4830 1486 372 715 380 706 377 704 383 701 381 711 380 707 378 710
    
11.      376 731 374 705 726 363 382 715 371 707 381 701 382 709 380 706
    
12.      379 728 724 359 722 367 728 363 373 718 718 376 365 712 752 374
    
13.      716 388 360 720 720 374 363 718 719 378 360 721 370 719 363 718
    
14.      715 393 361 726 358 721 369 719 719 371 713 384 707 373 710 385
    
15.      359 9120
    
16. ******** End Dump *******
    
17. **** Dump @ 0x20000934 Len: 82 ****
    
18.     4815 1501 356 738 351 725 363 724 360 730 358 729 355 725 366 722
    
19.      368 763 365 727 707 377 359 728 358 727 363 723 362 725 362 723
    
20.      364 734 715 381 708 377 711 389 352 727 708 389 343 734 708 388
    
21.      699 400 356 730 704 385 353 729 703 383 359 730 351 737 360 725
    
22.      706 405 346 733 355 735 355 727 704 383 699 394 695 393 698 390
    
23.      350 9153
    
24. ******** End Dump *******