基于GD32F450的红外解码--下位机篇

党国特派员

有段日子没有更新了，我就不给自己找原因了，今天更新下下位机的代码。
下位机的思想就是在收到上位机发送的开始捕获指令后，启动两个定时器来进行捕获计时和测量脉宽。
在串口通讯时，往上位机传输数据时使用USART+DMA的方式传输，节省CPU资源。这个DMA传输花费了不少时间，原因是GD32的例子误导了很长时间，最后还是自己看手册试出的。
下位机实物图：PB2接HS0038的Out引脚，然后就是一个电源，一个地。

下位机代码：

1. #include "gd32f4xx.h"                   // Device header
   
2. #include "stddef.h"
   
3. #include "ir_typedef.h"
   
4. 
   
5. #define LED_ON                gpio_bit_set(LED4PORT,LED4)
   
6. #define LED_OFF                gpio_bit_reset(LED4PORT,LED4)
   
7. 
   
8. #define LEDx_ON                gpio_bit_set(LED5PORT,LED5)
   
9. #define LEDx_OFF        gpio_bit_reset(LED5PORT,LED5)
   
10. 
    
11. #define MeasureTimer        TIMER6
    
12. #define CountTimer                TIMER5
    
13. 
    
14. //红外数据
    
15. IrDataType IrDat = {
    
16.     .datBuffer1 = {0},
    
17.     .i = 0
    
18. };
    
19. 
    
20. //能否上传
    
21. BOOL CanTransfer;
    
22. //开始捕获
    
23. BOOL StartCapture;
    
24. //
    
25. uint32_t PulseWidth_us;
    
26. //
    
27. uint32_t ElapseTime;
    
28. 
    
29. int main()
    
30. {
    
31.         InitLED();
    
32.         InitIR();
    
33.         InitUsart();
    
34.         InitMeasureTimer();
    
35.         InitCountTimer();
    
36.        
    
37.        
    
38.         while(TRUE)
    
39.         {
    
40.                 if(CanTransfer)
    
41.                 {
    
42.                         if(IrDat.i != 0)
    
43.                         {
    
44.                                 dma_transfer_number_config(DMA0,DMA_CH3,IrDat.i);
    
45.                                 dma_channel_enable(DMA0,DMA_CH3);
    
46.                         }
    
47.                         CanTransfer = FALSE;
    
48.                 }                       
    
49.         }
    
50. }
    
51. 
    
52. /*!
    
53.     \brief      initialize LED Pin
    
54.     \param[in]  none
    
55.     \param[out] none
    
56.     \retval     none
    
57. */
    
58. void InitLED(void)
    
59. {
    
60.         rcu_periph_clock_enable(RCU_GPIOB);
    
61.         rcu_periph_clock_enable(RCU_GPIOD);
    
62.        
    
63.         gpio_deinit(GPIOB);
    
64.         gpio_deinit(GPIOD);
    
65.        
    
66.         gpio_mode_set(LED4PORT,GPIO_MODE_OUTPUT,GPIO_PUPD_NONE,LED4|LED6);
    
67.         gpio_output_options_set(LED4PORT,GPIO_OTYPE_PP,GPIO_OSPEED_50MHZ,LED4|LED6);
    
68.        
    
69.         gpio_mode_set(LED5PORT,GPIO_MODE_OUTPUT,GPIO_PUPD_NONE,LED5);
    
70.         gpio_output_options_set(LED5PORT,GPIO_OTYPE_PP,GPIO_OSPEED_50MHZ,LED5);
    
71.        
    
72.         gpio_bit_reset(LED4PORT,LED4);
    
73.         gpio_bit_reset(LED6PORT,LED6);
    
74.         gpio_bit_reset(LED5PORT,LED5);
    
75. }
    
76. 
    
77. /*!
    
78.     \brief      initialize IR Pin and Exit2
    
79.     \param[in]  none
    
80.     \param[out] none
    
81.     \retval     none
    
82. */
    
83. void InitIR(void)
    
84. {
    
85.         rcu_periph_clock_enable(RCU_GPIOB);
    
86.         rcu_periph_clock_enable(RCU_SYSCFG);
    
87.        
    
88.         gpio_mode_set(IRPORT,GPIO_MODE_INPUT,GPIO_PUPD_PULLUP,IR_PIN);
    
89.        
    
90.         //initialize Exti Interrupt(PB2)       
    
91.         nvic_irq_enable(EXTI2_IRQn,0,1);
    
92.         exti_init(EXTI_2,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
    
93.         syscfg_exti_line_config(EXTI_SOURCE_GPIOB,EXTI_SOURCE_PIN2);
    
94.         exti_interrupt_flag_clear(EXTI_2);
    
95. }
    
96. 
    
97. /*!
    
98.     \brief      initialize Timer to Measuring pulse width; 10 us
    
99.     \param[in]  none
    
100.     \param[out] none
     
101.     \retval     none
     
102. */
     
103. void InitMeasureTimer(void)
     
104. {
     
105.         rcu_periph_clock_enable(RCU_TIMER6);
     
106.         timer_deinit(TIMER6);
     
107.        
     
108.         timer_parameter_struct timer_initpara;
     
109.         timer_initpara.prescaler = 99;
     
110.         timer_initpara.period = 9;
     
111.        
     
112.         timer_init(TIMER6,&timer_initpara);
     
113.         timer_auto_reload_shadow_enable(TIMER6);
     
114.         timer_interrupt_enable(TIMER6,TIMER_INT_UP);
     
115.        
     
116.         nvic_irq_enable(TIMER6_IRQn,0,0);
     
117.        
     
118. }
     
119. 
     
120. /*!
     
121.     \brief      initialize Timer,100 ms
     
122.     \param[in]  none
     
123.     \param[out] none
     
124.     \retval     none
     
125. */
     
126. void InitCountTimer(void)
     
127. {
     
128.         rcu_periph_clock_enable(RCU_TIMER5);
     
129.         timer_deinit(TIMER5);
     
130.        
     
131.         timer_parameter_struct timer_initpara;
     
132.         timer_initpara.prescaler = 9999;
     
133.         timer_initpara.period = 999;
     
134.        
     
135.         timer_init(TIMER5,&timer_initpara);
     
136.         timer_auto_reload_shadow_enable(TIMER5);
     
137.         timer_interrupt_enable(TIMER5,TIMER_INT_UP);
     
138.        
     
139.         nvic_irq_enable(TIMER5_DAC_IRQn,0,1);
     
140. }
     
141. 
     
142. /*!
     
143.     \brief      initialize USART2
     
144.     \param[in]  none
     
145.     \param[out] none
     
146.     \retval     none
     
147. */
     
148. void InitUsart(void)
     
149. {
     
150.         rcu_periph_clock_enable(RCU_USART2);
     
151.        
     
152.         gpio_af_set(GPIOD,GPIO_AF_7,USART_TX_PIN);
     
153.         gpio_af_set(GPIOD,GPIO_AF_7,USART_RX_PIN);
     
154.        
     
155.         gpio_mode_set(GPIOD,GPIO_MODE_AF,GPIO_PUPD_PULLUP,USART_TX_PIN);
     
156.         gpio_output_options_set(GPIOD,GPIO_OTYPE_PP,GPIO_OSPEED_50MHZ,USART_TX_PIN);
     
157.        
     
158.         gpio_mode_set(GPIOD,GPIO_MODE_AF,GPIO_PUPD_PULLUP,USART_RX_PIN);
     
159.         gpio_output_options_set(GPIOD,GPIO_OTYPE_PP,GPIO_OSPEED_50MHZ,USART_RX_PIN);
     
160.        
     
161.         usart_deinit(USART2);
     
162.         usart_baudrate_set(USART2,115200);
     
163.         usart_parity_config(USART2,USART_PM_NONE);
     
164.         usart_word_length_set(USART2,USART_WL_8BIT);
     
165.         usart_stop_bit_set(USART2,USART_STB_1BIT);
     
166.         usart_transmit_config(USART2,USART_TRANSMIT_ENABLE);
     
167.         usart_receive_config(USART2,USART_RECEIVE_ENABLE);
     
168.         usart_interrupt_enable(USART2,USART_INTEN_RBNEIE);
     
169.         usart_dma_transmit_config(USART2,USART_DENT_ENABLE);
     
170.         usart_enable(USART2);
     
171.         usart_flag_clear(USART2,USART_FLAG_TC);
     
172.        
     
173.         rcu_periph_clock_enable(RCU_DMA0);
     
174.         dma_deinit(DMA0,DMA_CH3);
     
175.         dma_transfer_direction_config(DMA0,DMA_CH3,DMA_MEMORY_TO_PERIPH);
     
176.         dma_transfer_number_config(DMA0,DMA_CH3,IRBUF_LEN);
     
177.         dma_memory_address_config(DMA0,DMA_CH3,DMA_MEMORY_0,(uint32_t)IrDat.datBuffer1);
     
178.         dma_memory_width_config(DMA0,DMA_CH3,DMA_MEMORY_WIDTH_8BIT);
     
179.         dma_memory_address_generation_config(DMA0,DMA_CH3,DMA_MEMORY_INCREASE_ENABLE);
     
180.         dma_periph_address_config(DMA0,DMA_CH3,(uint32_t)&USART_DATA(USART2));
     
181.         dma_periph_width_config(DMA0,DMA_CH3,DMA_PERIPH_WIDTH_8BIT);
     
182.         dma_peripheral_address_generation_config(DMA0,DMA_CH3,DMA_PERIPH_INCREASE_DISABLE);
     
183.         dma_priority_config(DMA0,DMA_CH3,DMA_PRIORITY_ULTRA_HIGH);
     
184.         dma_circulation_disable(DMA0,DMA_CH3);
     
185.         dma_channel_subperipheral_select(DMA0,DMA_CH3,DMA_SUBPERI4);
     
186.         dma_interrupt_enable(DMA0,DMA_CH3,DMA_CHXCTL_FTFIE);
     
187.        
     
188.        
     
189.         nvic_irq_enable(USART2_IRQn,0,2);
     
190.         nvic_irq_enable(DMA0_Channel3_IRQn,0,3);
     
191. }
     
192. 
     
193. 
     
194. /*!
     
195.     \brief      Exti2 Interrupt(PB2) Handler for ir input
     
196.     \param[in]  none
     
197.     \param[out] none
     
198.     \retval     none
     
199. */
     
200. void EXTI2_IRQHandler(void)
     
201. {
     
202.         exti_interrupt_flag_clear(EXTI_2);
     
203.         //判断是否开始捕获
     
204.         if(!StartCapture)
     
205.                 return;
     
206.        
     
207.         StopTiming();
     
208.         uint32_t us = 0;
     
209.         if(gpio_input_bit_get(GPIOB,GPIO_PIN_2) == SET)
     
210.         {
     
211.                 //上升沿触发（读取低电平的时间）
     
212.                 us = (PulseWidth_us * 10) & 0x7FFFFFFF;
     
213.                 LEDx_OFF;
     
214.         }
     
215.         else
     
216.         {
     
217.                 //T下降沿触发（读取高电平的时间）
     
218.                 us = (PulseWidth_us * 10) | 0x80000000;
     
219.                 LEDx_ON;
     
220.         }
     
221.         StartTiming();
     
222.         if(IrDat.i >= IRBUF_LEN)
     
223.     {
     
224.         CanTransfer = TRUE;
     
225.                 return;
     
226.     }
     
227.         IrDat.datBuffer1[IrDat.i] = us;
     
228.         IrDat.i++;
     
229. }
     
230. 
     
231. /*!
     
232.     \brief      TIMER6 interrupt Handler for measuring pulse width
     
233.     \param[in]  none
     
234.     \param[out] none
     
235.     \retval     none
     
236. */
     
237. void TIMER6_IRQHandler(void)
     
238. {
     
239.         PulseWidth_us++;
     
240.         timer_interrupt_flag_clear(TIMER6,TIMER_INT_UP);
     
241. }
     
242. 
     
243. /*!
     
244.     \brief      TIMER5 interrupt Handler,5 second timer
     
245.     \param[in]  none
     
246.     \param[out] none
     
247.     \retval     none
     
248. */
     
249. void TIMER5_DAC_IRQHandler(void)
     
250. {
     
251.         timer_interrupt_flag_clear(TIMER5,TIMER_INT_UP);
     
252.         if(ElapseTime >= 50)
     
253.         {
     
254.                 StartCapture = FALSE;
     
255.                 LED_OFF;
     
256.                 timer_disable(TIMER5);
     
257.                 StopTiming();
     
258.                 CanTransfer = TRUE;
     
259.                 return;
     
260.         }
     
261.         ElapseTime++;
     
262. }
     
263. 
     
264. /*!
     
265.     \brief      USART2 interrupt Handler
     
266.     \param[in]  none
     
267.     \param[out] none
     
268.     \retval     none
     
269. */
     
270. void USART2_IRQHandler()
     
271. {
     
272.         if(usart_interrupt_flag_get(USART2,USART_INT_RBNEIE) == SET)
     
273.         {
     
274.                 uint16_t dat = usart_data_receive(USART2);
     
275.                 if(dat == 's' || dat == 'S')
     
276.                 {
     
277.                         if(StartCapture) return;
     
278.                         IrDat.i = 0;
     
279.                         LED_ON;
     
280.                         Start_Capture();
     
281.                         StartTiming();
     
282.                 }
     
283.         }
     
284. }
     
285. 
     
286. void DMA0_Channel3_IRQHandler(void)
     
287. {
     
288.         if(dma_interrupt_flag_get(DMA0,DMA_CH3,DMA_INTC_FTFIFC) == SET)
     
289.         {
     
290.                 dma_interrupt_flag_clear(DMA0,DMA_CH3,DMA_INTF_FTFIF);
     
291.                 CanTransfer = FALSE;
     
292.         }
     
293. }
     
294. 
     
295. /*!
     
296.     \brief      Start capture ir data
     
297.     \param[in]  none
     
298.     \param[out] none
     
299.     \retval     none
     
300. */
     
301. void Start_Capture(void)
     
302. {
     
303.         StartCapture = TRUE;
     
304.         ElapseTime = 0;
     
305.         timer_enable(TIMER5);
     
306. }
     
307. /*!
     
308.     \brief      Start capture ir data
     
309.     \param[in]  none
     
310.     \param[out] none
     
311.     \retval     none
     
312. */
     
313. void StartTiming(void)
     
314. {
     
315.         PulseWidth_us = 0;
     
316.         timer_enable(TIMER6);
     
317. }
     
318. 
     
319. void StopTiming(void)
     
320. {
     
321.         timer_disable(TIMER6);
     
322. }
     
323. 
     
324. 
     
325. 
     
326. 
     

复制代码

代码已经做了很详细的注释。有感兴趣的同学可以参考，有任何疑问可以提出来。