21ic电子技术开发论坛»论坛首页 › 单片机与嵌入式系统 › 侃单片机论坛 › 用SAM-BA或JLINK跑ATSAM4E16的程序(8)USART例程
返回列表 发新帖我要提问

[Atmel] 用SAM-BA或JLINK跑ATSAM4E16的程序(8)USART例程

[复制链接]
 楼主| 发表于 2015-11-10 21:47 | 显示全部楼层 |阅读模式
link, SAM-BA, USART, sam4e, ST
这个例程实现了一个菜单，然后选则S会改变USART的传输方式而M会重显菜单
以下是运行的截图：


以下是程序：
复制
  1. #include <string.h>
    

  2. #include "asf.h"
    

  3. #include "stdio_serial.h"
    

  4. #include "conf_board.h"
    

  5. #include "conf_clock.h"
    

  6. #include "conf_example.h"
    


  7. 

  8. /** Size of the receive buffer used by the PDC, in bytes. */
    

  9. #define BUFFER_SIZE         100
    


  10. 

  11. /** USART PDC transfer type definition. */
    

  12. #define PDC_TRANSFER        1
    


  13. 

  14. /** USART FIFO transfer type definition. */
    

  15. #define BYTE_TRANSFER       0
    


  16. 

  17. /** Max buffer number. */
    

  18. #define MAX_BUF_NUM         1
    


  19. 

  20. /** All interrupt mask. */
    

  21. #define ALL_INTERRUPT_MASK  0xffffffff
    


  22. 

  23. /** Timer counter frequency in Hz. */
    

  24. #define TC_FREQ             1
    


  25. 

  26. #define STRING_EOL    "\r"
    

  27. #define STRING_HEADER "-- USART Serial Example --\r\n" \
    

  28.                 "-- "BOARD_NAME" --\r\n" \
    

  29.                 "-- Compiled: "__DATE__" "__TIME__" --"STRING_EOL
    


  30. 

  31. /** Receive buffer. */
    

  32. static uint8_t gs_puc_buffer[2][BUFFER_SIZE];
    


  33. 

  34. /** Next Receive buffer. */
    

  35. static uint8_t gs_puc_nextbuffer[2][BUFFER_SIZE];
    


  36. 

  37. /** Current bytes in buffer. */
    

  38. static uint32_t gs_ul_size_buffer = BUFFER_SIZE;
    


  39. 

  40. /** Current bytes in next buffer. */
    

  41. static uint32_t gs_ul_size_nextbuffer = BUFFER_SIZE;
    


  42. 

  43. /** Byte mode read buffer. */
    

  44. static uint32_t gs_ul_read_buffer = 0;
    


  45. 

  46. /** Current transfer mode. */
    

  47. static uint8_t gs_uc_trans_mode = PDC_TRANSFER;
    


  48. 

  49. /** Buffer number in use. */
    

  50. static uint8_t gs_uc_buf_num = 0;
    


  51. 

  52. /** PDC data packet. */
    

  53. pdc_packet_t g_st_packet, g_st_nextpacket;
    


  54. 

  55. /** Pointer to PDC register base. */
    

  56. Pdc *g_p_pdc;
    


  57. 

  58. /** Flag of one transfer end. */
    

  59. static uint8_t g_uc_transend_flag = 0;
    


  60. 

  61. /**
    

  62.  * \brief Interrupt handler for USART. Echo the bytes received and start the
    

  63.  * next receive.
    

  64.  */
    

  65. void USART_Handler(void)
    

  66. {
    

  67.         uint32_t ul_status;
    


  68. 

  69.         /* Read USART Status. */
    

  70.         ul_status = usart_get_status(BOARD_USART);
    


  71. 

  72.         if (gs_uc_trans_mode == PDC_TRANSFER) {
    

  73.                 /* Receive buffer is full. */
    

  74.                 if (ul_status & US_CSR_RXBUFF) {
    

  75.                         /* Disable timer. */
    

  76.                         tc_stop(TC0, 0);
    


  77. 

  78.                         /* Echo back buffer. */
    

  79.                         g_st_packet.ul_addr =
    

  80.                                         (uint32_t)gs_puc_buffer[gs_uc_buf_num];
    

  81.                         g_st_packet.ul_size = gs_ul_size_buffer;
    

  82.                         g_st_nextpacket.ul_addr =
    

  83.                                         (uint32_t)gs_puc_nextbuffer[gs_uc_buf_num];
    

  84.                         g_st_nextpacket.ul_size = gs_ul_size_nextbuffer;
    

  85.                         pdc_tx_init(g_p_pdc, &g_st_packet, &g_st_nextpacket);
    


  86. 

  87.                         if (g_uc_transend_flag) {
    

  88.                                 gs_ul_size_buffer = BUFFER_SIZE;
    

  89.                                 gs_ul_size_nextbuffer = BUFFER_SIZE;
    

  90.                                 g_uc_transend_flag = 0;
    

  91.                         }
    


  92. 

  93.                         gs_uc_buf_num = MAX_BUF_NUM - gs_uc_buf_num;
    


  94. 

  95.                         /* Restart read on buffer. */
    

  96.                         g_st_packet.ul_addr =
    

  97.                                         (uint32_t)gs_puc_buffer[gs_uc_buf_num];
    

  98.                         g_st_packet.ul_size = BUFFER_SIZE;
    

  99.                         g_st_nextpacket.ul_addr =
    

  100.                                         (uint32_t)gs_puc_nextbuffer[ gs_uc_buf_num];
    

  101.                         g_st_nextpacket.ul_size = BUFFER_SIZE;
    

  102.                         pdc_rx_init(g_p_pdc, &g_st_packet, &g_st_nextpacket);
    


  103. 

  104.                         /* Restart timer. */
    

  105.                         tc_start(TC0, 0);
    

  106.                 }
    

  107.         } else {
    

  108.                 /* Transfer without PDC. */
    

  109.                 if (ul_status & US_CSR_RXRDY) {
    

  110.                         usart_getchar(BOARD_USART, (uint32_t *)&gs_ul_read_buffer);
    

  111.                         usart_write(BOARD_USART, gs_ul_read_buffer);
    

  112.                 }
    

  113.         }
    

  114. }
    


  115. 

  116. /**
    

  117.  * \brief Interrupt handler for TC0. Record the number of bytes received,
    

  118.  * and then restart a read transfer on the USART if the transfer was stopped.
    

  119.  */
    

  120. void TC0_Handler(void)
    

  121. {
    

  122.         uint32_t ul_status;
    

  123.         uint32_t ul_byte_total = 0;
    


  124. 

  125.         /* Read TC0 Status. */
    

  126.         ul_status = tc_get_status(TC0, 0);
    


  127. 

  128.         /* RC compare. */
    

  129.         if (((ul_status & TC_SR_CPCS) == TC_SR_CPCS) &&
    

  130.                         (gs_uc_trans_mode == PDC_TRANSFER)) {
    

  131.                 /* Flush PDC buffer. */
    

  132.                 ul_byte_total = BUFFER_SIZE - pdc_read_rx_counter(g_p_pdc);
    

  133.                 if ((ul_byte_total != 0) && (ul_byte_total != BUFFER_SIZE)) {
    

  134.                         /* Log current size. */
    

  135.                         g_uc_transend_flag = 1;
    

  136.                         if (pdc_read_rx_next_counter(g_p_pdc) == 0) {
    

  137.                                 gs_ul_size_buffer = BUFFER_SIZE;
    

  138.                                 gs_ul_size_nextbuffer = ul_byte_total;
    

  139.                         } else {
    

  140.                                 gs_ul_size_buffer = ul_byte_total;
    

  141.                                 gs_ul_size_nextbuffer = 0;
    

  142.                         }
    


  143. 

  144.                         /* Trigger USART Receive Buffer Full Interrupt. */
    

  145.                         pdc_rx_clear_cnt(g_p_pdc);
    

  146.                 }
    

  147.         }
    

  148. }
    


  149. 

  150. /**
    

  151.  * \brief Configure USART in normal (serial rs232) mode, asynchronous,
    

  152.  * 8 bits, 1 stop bit, no parity, 115200 bauds and enable its transmitter
    

  153.  * and receiver.
    

  154.  */
    

  155. static void configure_usart(void)
    

  156. {
    

  157.         const sam_usart_opt_t usart_console_settings = {
    

  158.                 BOARD_USART_BAUDRATE,
    

  159.                 US_MR_CHRL_8_BIT,
    

  160.                 US_MR_PAR_NO,
    

  161.                 US_MR_NBSTOP_1_BIT,
    

  162.                 US_MR_CHMODE_NORMAL,
    

  163.                 /* This field is only used in IrDA mode. */
    

  164.                 0
    

  165.         };
    


  166. 

  167.         /* Enable the peripheral clock in the PMC. */
    

  168.         sysclk_enable_peripheral_clock(BOARD_ID_USART);
    


  169. 

  170.         /* Configure USART in serial mode. */
    

  171.         usart_init_rs232(BOARD_USART, &usart_console_settings,
    

  172.                         sysclk_get_cpu_hz());
    


  173. 

  174.         /* Disable all the interrupts. */
    

  175.         usart_disable_interrupt(BOARD_USART, ALL_INTERRUPT_MASK);
    


  176. 

  177.         /* Enable the receiver and transmitter. */
    

  178.         usart_enable_tx(BOARD_USART);
    

  179.         usart_enable_rx(BOARD_USART);
    


  180. 

  181.         /* Configure and enable interrupt of USART. */
    

  182.         NVIC_EnableIRQ(USART_IRQn);
    

  183. }
    


  184. 

  185. /**
    

  186.  * \brief Configure Timer Counter 0 (TC0) to generate an interrupt every 200ms.
    

  187.  * This interrupt will be used to flush USART input and echo back.
    

  188.  */
    

  189. static void configure_tc(void)
    

  190. {
    

  191.         uint32_t ul_div;
    

  192.         uint32_t ul_tcclks;
    

  193.         static uint32_t ul_sysclk;
    


  194. 

  195.         /* Get system clock. */
    

  196.         ul_sysclk = sysclk_get_cpu_hz();
    


  197. 

  198.         /* Configure PMC. */
    

  199.         pmc_enable_periph_clk(ID_TC0);
    


  200. 

  201.         /* Configure TC for a 50Hz frequency and trigger on RC compare. */
    

  202.         tc_find_mck_divisor(TC_FREQ, ul_sysclk, &ul_div, &ul_tcclks, ul_sysclk);
    

  203.         tc_init(TC0, 0, ul_tcclks | TC_CMR_CPCTRG);
    

  204.         tc_write_rc(TC0, 0, (ul_sysclk / ul_div) / TC_FREQ);
    


  205. 

  206.         /* Configure and enable interrupt on RC compare. */
    

  207.         NVIC_EnableIRQ((IRQn_Type)ID_TC0);
    

  208.         tc_enable_interrupt(TC0, 0, TC_IER_CPCS);
    

  209. }
    


  210. 

  211. /**
    

  212.  *  Configure UART for debug message output.
    

  213.  */
    

  214. static void configure_console(void)
    

  215. {
    

  216.         const usart_serial_options_t uart_serial_options = {
    

  217.                 .baudrate = CONF_UART_BAUDRATE,
    

  218.                 .paritytype = CONF_UART_PARITY
    

  219.         };
    


  220. 

  221.         /* Configure console UART. */
    

  222.         sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
    

  223.         stdio_serial_init(CONF_UART, &uart_serial_options);
    

  224. }
    


  225. 

  226. /**
    

  227.  * \brief Reset the TX & RX, and clear the PDC counter.
    

  228.  */
    

  229. static void usart_clear(void)
    

  230. {
    

  231.         /* Reset and disable receiver & transmitter. */
    

  232.         usart_reset_rx(BOARD_USART);
    

  233.         usart_reset_tx(BOARD_USART);
    


  234. 

  235.         /* Clear PDC counter. */
    

  236.         g_st_packet.ul_addr = 0;
    

  237.         g_st_packet.ul_size = 0;
    

  238.         g_st_nextpacket.ul_addr = 0;
    

  239.         g_st_nextpacket.ul_size = 0;
    

  240.         pdc_rx_init(g_p_pdc, &g_st_packet, &g_st_nextpacket);
    


  241. 

  242.         /* Enable receiver & transmitter. */
    

  243.         usart_enable_tx(BOARD_USART);
    

  244.         usart_enable_rx(BOARD_USART);
    

  245. }
    


  246. 

  247. /**
    

  248.  * \brief Display main menu.
    

  249.  */
    

  250. static void display_main_menu(void)
    

  251. {
    

  252.         puts("-- Menu Choices for this example --\r\n"
    

  253.                         "-- s: Switch mode for USART between PDC and without PDC.--\r\n"
    

  254.                         "-- m: Display this menu again.--\r");
    

  255. }
    


  256. 

  257. /**
    

  258.  * \brief Application entry point for usart_serial example.
    

  259.  *
    

  260.  * \return Unused (ANSI-C compatibility).
    

  261.  */
    

  262. int main(void)
    

  263. {
    

  264.         uint8_t uc_char;
    

  265.         uint8_t uc_flag;
    


  266. 

  267.         /* Initialize the SAM system. */
    

  268.         sysclk_init();
    

  269.         board_init();
    


  270. 

  271.         /* Configure UART for debug message output. */
    

  272.         configure_console();
    


  273. 

  274.         /* Output example information. */
    

  275.         puts(STRING_HEADER);
    


  276. 

  277.         /* Configure USART. */
    

  278.         configure_usart();
    


  279. 

  280.         /* Get board USART PDC base address. */
    

  281.         g_p_pdc = usart_get_pdc_base(BOARD_USART);
    

  282.         /* Enable receiver and transmitter. */
    

  283.         pdc_enable_transfer(g_p_pdc, PERIPH_PTCR_RXTEN | PERIPH_PTCR_TXTEN);
    


  284. 

  285.         /* Configure TC. */
    

  286.         configure_tc();
    


  287. 

  288.         /* Start receiving data and start timer. */
    

  289.         g_st_packet.ul_addr = (uint32_t)gs_puc_buffer[gs_uc_buf_num];
    

  290.         g_st_packet.ul_size = BUFFER_SIZE;
    

  291.         g_st_nextpacket.ul_addr = (uint32_t)gs_puc_nextbuffer[gs_uc_buf_num];
    

  292.         g_st_nextpacket.ul_size = BUFFER_SIZE;
    

  293.         pdc_rx_init(g_p_pdc, &g_st_packet, &g_st_nextpacket);
    


  294. 

  295.         puts("-- Start to echo serial inputs -- \r\n"
    

  296.                         "-I- Default Transfer with PDC \r\n"
    

  297.                         "-I- Press 's' to switch transfer mode \r");
    

  298.         gs_uc_trans_mode = PDC_TRANSFER;
    


  299. 

  300.         usart_disable_interrupt(BOARD_USART, US_IDR_RXRDY);
    

  301.         usart_enable_interrupt(BOARD_USART, US_IER_RXBUFF);
    


  302. 

  303.         tc_start(TC0, 0);
    


  304. 

  305.         while (1) {
    

  306.                 uc_char = 0;
    

  307.                 uc_flag = uart_read(CONSOLE_UART, &uc_char);
    

  308.                 if (!uc_flag) {
    

  309.                         switch (uc_char) {
    

  310.                         case 's':
    

  311.                         case 'S':
    

  312.                                 if (gs_uc_trans_mode == PDC_TRANSFER) {
    

  313.                                         /* Transfer to no PDC communication mode. */
    

  314.                                         /* Disable PDC controller. */
    

  315.                                         pdc_disable_transfer(g_p_pdc,
    

  316.                                                         PERIPH_PTCR_RXTDIS | PERIPH_PTCR_TXTDIS);
    

  317.                                         /* Disable the RXBUFF interrupt. */
    

  318.                                         usart_disable_interrupt(BOARD_USART, US_IDR_RXBUFF);
    


  319. 

  320.                                         /* Clear USART controller. */
    

  321.                                         usart_clear();
    


  322. 

  323.                                         /* Enable the RXRDY interrupt. */
    

  324.                                         usart_enable_interrupt(BOARD_USART, US_IER_RXRDY);
    

  325.                                         gs_uc_trans_mode = BYTE_TRANSFER;
    


  326. 

  327.                                         puts("-I- Transfer without PDC \r");
    

  328.                                 } else if (gs_uc_trans_mode == BYTE_TRANSFER) {
    

  329.                                         pdc_enable_transfer(g_p_pdc,
    

  330.                                                         PERIPH_PTCR_RXTEN | PERIPH_PTCR_TXTEN);
    

  331.                                         /* Clear USART controller. */
    

  332.                                         usart_clear();
    


  333. 

  334.                                         /* Reset pdc current buffer size. */
    

  335.                                         gs_ul_size_buffer = BUFFER_SIZE;
    

  336.                                         gs_ul_size_nextbuffer = BUFFER_SIZE;
    

  337.                                         gs_uc_buf_num = 0;
    


  338. 

  339.                                         /* Start receiving data. */
    

  340.                                         g_st_packet.ul_addr =
    

  341.                                                         (uint32_t)gs_puc_buffer[gs_uc_buf_num];
    

  342.                                         g_st_packet.ul_size = BUFFER_SIZE;
    

  343.                                         g_st_nextpacket.ul_addr =
    

  344.                                                         (uint32_t)gs_puc_nextbuffer[gs_uc_buf_num];
    

  345.                                         g_st_nextpacket.ul_size = BUFFER_SIZE;
    

  346.                                         pdc_rx_init(g_p_pdc, &g_st_packet, &g_st_nextpacket);
    

  347.                                         
    

  348.                                         /* Transfer to PDC communication mode, disable RXRDY interrupt and enable RXBUFF interrupt. */
    

  349.                                         usart_disable_interrupt(BOARD_USART, US_IER_RXRDY);
    

  350.                                         usart_enable_interrupt(BOARD_USART, US_IER_RXBUFF);
    


  351. 

  352.                                         gs_uc_trans_mode = PDC_TRANSFER;
    

  353.                                         puts("-I- Transfer with PDC \r");
    

  354.                                 }
    


  355. 

  356.                                 break;
    


  357. 

  358.                         case 'm':
    

  359.                         case 'M':
    

  360.                                 display_main_menu();
    

  361.                                 break;
    


  362. 

  363.                         default:
    

  364.                                 break;
    

  365.                         }
    

  366.                 }
    

  367.         }
    

  368. }

至于例程的解析明天再发表。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

举报

点评

xuxunfighting
请问关于如下问题： if (ul_status & US_CSR_RXRDY) { usart_getchar(BOARD_USART, (uint32_t *)&gs_ul_read_buffer); usart_write(BOARD_USART, gs_ul_read_buffer); } 采用这个方式进行串口的读写，发现在一次性接收很多字节数据时，出现usart_write发送丢包现象，检查之后usart_getchar可以完整读取，请问怎么可  发表于 2024-11-29 17:42

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

ddllxxrr
个人签名：http://shop34182318.taobao.com/ http://shop562064536.taobao.com

2403

主题

6995

帖子

68

粉丝
快速回复 返回顶部 返回列表