devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

NRF52832 UART接收不定长数据

作者：菜鸟追梦旅行 | 2024-03-05 22:40:15

赞

踩

NRF52832 UART接收不定长数据

问题：

在使用NRF52832做串口透传的时候，示例程序里UARTE，接收长度为1个字节。如果串口接收到长数据（测试了1K），则很容易导致蓝牙发送的超时重启。

解决方案：使用PPI功能，使串口具备接收不定长数据的能力。

方案参考的是Nordic的libuarte工程，但是我们这里面有soft device，其本身会占用一些外设，比如RTC0，TIMER0等。那我们就只能选择其他外设，这里选用TIMER1和TIMER2。

PPI的配置之后的接收流程如下：

  1. 设置接收缓冲区，缓冲区的长度为UARTE能接受的最大长度。
  2. 触发UARTE的NRF_UARTE_TASK_STARTRX任务。
  3. 任务开始之后会触发NRF_UARTE_EVENT_RXSTARTED，在这个事件中断里切换缓冲区。由于UARTE的缓冲区指针是双缓冲的，所以此次设置的缓冲区为下次接收的缓冲区。
  4. 接收到数据触发NRF_UARTE_EVENT_RXDRDY事件，NRF_UARTE_EVENT_RXDRDY自动触发TIMER1的NRF_TIMER_TASK_START和NRF_TIMER_TASK_CLEAR。TIMER1的超时时间比UARTE接收一个字符的时间稍长，模拟的32类的单片机UART的IDLE功能。NRF_UARTE_EVENT_RXDRDY同时触发TIMER2的计数，记录一共接收了多少字节。
  5. NRF_UARTE_EVENT_ENDRX触发TIMER2的NRF_TIMER_TASK_CAPTURE1，获取到一共接收了多少数据，同时触发NRF_UARTE_TASK_STARTRX，将接收到的数据存入下一个缓冲区中。由于TIMER2捕获了一共接收的数据长度，则可以很容易的知道未处理的数据有多少，在中断中直接缓存数据即可。

核心代码如下：

  1. #define AYSN_UARTE			NRF_UARTE0		// 使用uarte0 
  2. #define PPI_CH_SETUP(_ch, _evt, _tsk, _fork)            \
  3.     ret = nrfx_ppi_channel_assign(_ch, _evt, _tsk);     \
  4.     if (ret != NRF_SUCCESS)                             \
  5.     {                                                   \
  6.         return NRF_ERROR_INTERNAL;                      \
  7.     }                                                   \
  8.     if (_fork)                                          \
  9.     {                                                   \
  10.         ret = nrfx_ppi_channel_fork_assign(_ch, _fork); \
  11.         if (ret != NRF_SUCCESS)                         \
  12.         {                                               \
  13.             return NRF_ERROR_INTERNAL;                  \
  14.         }                                               \
  15.     }
  16.  
  17. extern gqueue_t qbtTx,qbtRx;
  18. // 使用uarte0,超时使用timer1，计数使用timer2
  19. static const nrfx_timer_t timeoutTimer = NRFX_TIMER_INSTANCE(1);
  20. static const nrfx_timer_t countTimer = NRFX_TIMER_INSTANCE(2);
  21. static nrf_ppi_channel_t uartePpiChannels[UARTE_ASYNC_PPI_CH_MAX];
  22. static uint32_t uarteRxOneByteTimeout = 120;		// 115200波特率的时候是100us左右
  23.  
  24. ret_code_t uarte_asyn_init(uarte_asyn_config_t* pconfig)
  25. {
  26. 	ret_code_t ret;
  27. 	uint32_t tmr_start_tsk = 0;
  28.     uint32_t tmr_clear_tsk = 0;
  29.     uint32_t tmr_stop_tsk = 0;
  30.     uint32_t tmr_compare_evt = 0;
  31. 	uarteRxOneByteTimeout = pconfig->timeout_us;
  32. 	
  33. 	// 环形接收缓冲区初始化
  34. 	uarte_rx_buf_init(puarteRxBuf);
  35. 	
  36. 	// timeoutTimer init
  37. 	nrfx_timer_config_t tmr_config = NRFX_TIMER_DEFAULT_CONFIG;
  38. 	tmr_config.frequency = NRF_TIMER_FREQ_1MHz;
  39. 	tmr_config.mode = TIMER_MODE_MODE_Timer;
  40. 	tmr_config.interrupt_priority = APP_IRQ_PRIORITY_LOW;
  41.  
  42. 	ret = nrfx_timer_init(&timeoutTimer, &tmr_config, tmr_evt_handler);
  43. 	if (ret != NRFX_SUCCESS)
  44. 	{
  45. 		return NRF_ERROR_INTERNAL;
  46. 	}
  47. 	nrfx_timer_compare(&timeoutTimer, NRF_TIMER_CC_CHANNEL0, uarteRxOneByteTimeout, true);
  48.  
  49. 	tmr_start_tsk = nrfx_timer_task_address_get(&timeoutTimer, NRF_TIMER_TASK_START);
  50. 	tmr_clear_tsk = nrfx_timer_task_address_get(&timeoutTimer, NRF_TIMER_TASK_CLEAR);
  51. 	tmr_stop_tsk = nrfx_timer_task_address_get(&timeoutTimer, NRF_TIMER_TASK_SHUTDOWN);
  52. 	tmr_compare_evt = nrfx_timer_compare_event_address_get(&timeoutTimer, NRF_TIMER_CC_CHANNEL0);
  53. 	
  54.  
  55. 	//UART init
  56.     nrf_gpio_pin_set(pconfig->tx_pin);
  57.     nrf_gpio_cfg_output(pconfig->tx_pin);
  58.     nrf_gpio_cfg_input(pconfig->rx_pin, pconfig->pullup_rx ?
  59.                         NRF_GPIO_PIN_PULLUP : NRF_GPIO_PIN_NOPULL);
  60.     nrf_uarte_baudrate_set(AYSN_UARTE, pconfig->baudrate);
  61.     nrf_uarte_configure(AYSN_UARTE, pconfig->parity, pconfig->hwfc);
  62.     nrf_uarte_txrx_pins_set(AYSN_UARTE, pconfig->tx_pin, pconfig->rx_pin);
  63. 	
  64. 	IRQn_Type irqn = NRFX_IRQ_NUMBER_GET(AYSN_UARTE);
  65. 	nrf_uarte_int_enable(AYSN_UARTE, UARTE_INTERRUPTS_MASK);
  66.     NVIC_SetPriority(irqn, pconfig->int_prio);
  67.     NVIC_ClearPendingIRQ(irqn);
  68.     NVIC_EnableIRQ(irqn);
  69.  
  70.     nrf_uarte_enable(AYSN_UARTE);
  71. 	
  72. 	// countTimer init
  73. 	nrfx_timer_config_t countTmr_config = NRFX_TIMER_DEFAULT_CONFIG;
  74.     countTmr_config.mode = NRF_TIMER_MODE_COUNTER;
  75.     countTmr_config.bit_width = NRF_TIMER_BIT_WIDTH_32;
  76.     ret = nrfx_timer_init(&countTimer, &countTmr_config, count_tmr_evt_handler);
  77. 	
  78. 	// 分配ppi channel
  79. 	for (int i = 0; i < UARTE_ASYNC_PPI_CH_MAX; i++)
  80. 	{
  81. 		ret = nrfx_ppi_channel_alloc(&uartePpiChannels[i]);
  82. 		if (ret != NRFX_SUCCESS)
  83. 		{
  84. 			//we don't free already allocated channels, system is wrongly configured.
  85. 			return NRF_ERROR_INTERNAL;
  86. 		}
  87. 	}
  88. 	
  89. 	// RXDRDY-->TIMER1_START&TIMER1_CLEAR	
  90. 	// 		 -->TIMER2_COUNT
  91. 	// ENDRX-->RXSTART&TIMER2_C1
  92. 	// TIMER1_C0-->TIMER1_STOP&TIMER2_C0
  93. 	PPI_CH_SETUP(uartePpiChannels[UARTE_ASYNC_PPI_CH_RXRDY_CLEAR],
  94. 				 nrf_uarte_event_address_get(AYSN_UARTE, NRF_UARTE_EVENT_RXDRDY),
  95. 				 tmr_start_tsk,
  96. 				 tmr_clear_tsk);
  97.  
  98. 	PPI_CH_SETUP(uartePpiChannels[UARTE_ASYNC_PPI_CH_COMPARE_SHUTDOWN],
  99. 				 tmr_compare_evt,
  100. 				 tmr_stop_tsk,
  101. 				 nrfx_timer_task_address_get(&countTimer, NRF_TIMER_TASK_CAPTURE0));
  102. 	
  103. 	PPI_CH_SETUP(
  104. 				uartePpiChannels[UARTE_DRV_PPI_CH_RXRDY_TIMER_COUNT],
  105. 				nrf_uarte_event_address_get(AYSN_UARTE, NRF_UARTE_EVENT_RXDRDY),
  106. 				nrfx_timer_task_address_get(&countTimer, NRF_TIMER_TASK_COUNT),
  107. 				0);
  108.  
  109.  
  110.     PPI_CH_SETUP(
  111. 				uartePpiChannels[UARTE_DRV_PPI_CH_ENDRX_STARTRX],
  112. 				nrf_uarte_event_address_get(AYSN_UARTE, NRF_UARTE_EVENT_ENDRX),
  113. 				nrf_uarte_task_address_get(AYSN_UARTE, NRF_UARTE_TASK_STARTRX),
  114. 				nrfx_timer_task_address_get(&countTimer, NRF_TIMER_TASK_CAPTURE1));
  115.  
  116. 	return NRF_SUCCESS;
  117. }
  118.  
  119.  
  120. ret_code_t uarte_asyn_enable(void)
  121. {
  122. 	nrfx_timer_clear(&timeoutTimer);
  123. 	nrf_uarte_rx_buffer_set(AYSN_UARTE, puarteRxBuf->pwriteBuf->buf, MAX_DMA_XFER_LEN);
  124. 	puarteRxBuf->pwriteBuf = puarteRxBuf->pwriteBuf->pnext;
  125.  
  126.     /* Reset byte counting */
  127.     nrfx_timer_enable(&countTimer);
  128.     nrfx_timer_clear(&countTimer);
  129.  
  130.     nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_ENDRX);
  131.     nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_RXSTARTED);
  132.  
  133. 	for (int i = 0; i < UARTE_ASYNC_PPI_CH_MAX; i++)
  134. 	{
  135. 		nrfx_ppi_channel_enable(uartePpiChannels[i]);
  136. 	}
  137. 	
  138. 	// 触发接收任务
  139.     nrf_uarte_task_trigger(AYSN_UARTE, NRF_UARTE_TASK_STARTRX);
  140.  
  141.     return NRF_SUCCESS;
  142. }
  143.  
  144. uarte_tx_result_t uarte_asyn_send(const uint8_t* buf,uint8_t len)
  145. {
  146. 	if(uarteTxCplt == true)
  147. 	{
  148. 		if(len > MAX_DMA_XFER_LEN)
  149. 		{
  150. 			return UARTE_TX_TOOLONG;
  151. 		}
  152. 		uarteTxCplt = false;
  153. 		nrf_uarte_tx_buffer_set(AYSN_UARTE, buf, len);
  154. 		nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_TXSTARTED);
  155. 		nrf_uarte_task_trigger(AYSN_UARTE, NRF_UARTE_TASK_STARTTX);
  156. 		return UARTE_TX_SUCCESS;
  157. 	}
  158. 	else
  159. 	{
  160. 		return UARTE_TX_BUSY;
  161. 	}
  162. }
  163.  
  164.  
  165. static void uarte_timeout_handler(void)
  166. {
  167. 	NRFX_IRQ_DISABLE((IRQn_Type)NRFX_IRQ_NUMBER_GET(AYSN_UARTE));
  168. 	uint32_t rcvTotalLen = countTimer.p_reg->CC[0];
  169. 	if(rcvTotalLen > puarteRxBuf->bufStartCount + puarteRxBuf->readBufIndex)
  170. 	{
  171. 		uint32_t rcvAmount = rcvTotalLen - puarteRxBuf->bufStartCount - puarteRxBuf->readBufIndex;
  172. 		uint32_t actualPushLen = 0;
  173. 		gqueue_push_multiple(&qbtTx,&puarteRxBuf->preadBuf->buf[puarteRxBuf->readBufIndex],rcvAmount,&actualPushLen);
  174. 		puarteRxBuf->readBufIndex += rcvAmount;
  175. 	}
  176. 	NRFX_IRQ_ENABLE((IRQn_Type)NRFX_IRQ_NUMBER_GET(AYSN_UARTE));
  177. }
  178.  
  179. // 设置了一个字符的超时时间。
  180. // 如果dma的数据还未到达产生endrx的长度，则过了一个字符的超时时间之后，
  181. // 可以通过此中断及时从dma的buf中获取一共收到了多少字符
  182. static void tmr_evt_handler(nrf_timer_event_t event_type, void * p_context)
  183. {
  184. 	uarte_timeout_handler();
  185. }
  186.  
  187. // 没有中断，不会发生
  188. static void count_tmr_evt_handler(nrf_timer_event_t event_type, void * p_context)
  189. {
  190.     UNUSED_PARAMETER(event_type);
  191. 	UNUSED_PARAMETER(p_context);
  192. }
  193.  
  194. static void irq_handler(void)
  195. {
  196.     if (nrf_uarte_event_check(AYSN_UARTE, NRF_UARTE_EVENT_ERROR))
  197.     {
  198.         nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_ERROR);
  199.  
  200.     }
  201.  
  202.     if (nrf_uarte_event_check(AYSN_UARTE, NRF_UARTE_EVENT_RXSTARTED))
  203.     {
  204.         nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_RXSTARTED);
  205. 		// 切换buf
  206. 		nrf_uarte_rx_buffer_set(AYSN_UARTE, puarteRxBuf->pwriteBuf->buf, MAX_DMA_XFER_LEN);
  207. 		puarteRxBuf->pwriteBuf = puarteRxBuf->pwriteBuf->pnext;
  208.  
  209.     }
  210.  
  211.     if (nrf_uarte_event_check(AYSN_UARTE, NRF_UARTE_EVENT_ENDRX))
  212.     {
  213.         nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_ENDRX);
  214. 		// 转存数据
  215. 		uint32_t rcvTotalLen = countTimer.p_reg->CC[1];
  216. 		if(rcvTotalLen > puarteRxBuf->bufStartCount + puarteRxBuf->readBufIndex)
  217. 		{
  218. 			uint32_t rcvAmount = rcvTotalLen - puarteRxBuf->bufStartCount - puarteRxBuf->readBufIndex;
  219. 			uint32_t actualPushLen = 0;
  220. 			gqueue_push_multiple(&qbtTx,&puarteRxBuf->preadBuf->buf[puarteRxBuf->readBufIndex],rcvAmount,&actualPushLen);
  221. 		}
  222. 		// 设置新的索引
  223. 		puarteRxBuf->bufStartCount = countTimer.p_reg->CC[1];
  224. 		puarteRxBuf->readBufIndex = 0;
  225. 		// 切换下一个缓冲区
  226. 		puarteRxBuf->preadBuf = puarteRxBuf->preadBuf->pnext;
  227.     }
  228.  
  229.     if (nrf_uarte_event_check(AYSN_UARTE, NRF_UARTE_EVENT_TXSTOPPED))
  230.     {
  231.         nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_TXSTOPPED);
  232. 		uarteTxCplt = true;
  233.  
  234.     }
  235.  
  236.     if (nrf_uarte_event_check(AYSN_UARTE, NRF_UARTE_EVENT_ENDTX))
  237.     {
  238. //		uint32_t actualLen = 0;
  239.         nrf_uarte_event_clear(AYSN_UARTE, NRF_UARTE_EVENT_ENDTX);
  240. 		uarteTxCplt = true;
  241. //		if(!gqueue_pop_multiple_most(&qbtRx,_uarteTxBuf,MAX_DMA_XFER_LEN,&actualLen))
  242. //		{
  243. //			zy_uarte_asyn_send(_uarteTxBuf,actualLen);
  244. //		}
  245.  
  246.     }
  247. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/194305
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号