21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › printf重定向到串口
12下一页
返回列表 发新帖我要提问

[应用方案] printf重定向到串口

[复制链接]
2829|26
 楼主| maudlu 发表于 2024-7-25 20:36 | 显示全部楼层 |阅读模式
重定向, 串口, printf, print
在mdk 中用printf，需要同时重定义fputc函数和避免使用semihosting(半主机模式），
标准库函数的默认输出设备是显示器，要实现在串口或LCD输出，必须重定义标准库函数里调用的与输出设备相关的函数.
例如:printf输出到串口，需要将fputc里面的输出指向串口(重定向),方法如下:
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
     set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */
PUTCHAR_PROTOTYPE
{
/* Place your implementation of fputc here */
/* e.g. write a character to the USART */
USART_SendData(USART1, (uint8_t) ch);
/* Loop until the end of transmission */
while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
return ch;
}
因printf()之类的函数，使用了半主机模式。使用标准库会导致程序无法运行,以下是解决方法:
方法1.使用微库,因为使用微库的话,不会使用半主机模式.
方法2.仍然使用标准库,在主程序添加下面代码:
#pragma import(__use_no_semihosting)  
_sys_exit(int x)  
{  
x = x;  
}  
struct __FILE  
{  
int handle;  
/* Whatever you require here. If the only file you are using is */  
/* standard output using printf() for debugging, no file handling */  
/* is required. */  
};  
/* FILE is typedef’ d in stdio.h. */  
FILE __stdout;
如果使用的是MDK，请在工程属性的“Target“-》”Code Generation“中勾选”Use MicroLIB；今天参考了一下论坛，使用微库可以很好的解决这个问题。
2.另一种方法：（其实大同小异）   
需要添加以下代码  
(论坛里应该有完整介绍这个的帖子，但是我没搜到，也许是沉了。)
#pragma import(__use_no_semihosting)   
/******************************************************************************   
*标准库需要的支持函数   
******************************************************************************/   
struct __FILE   
{   
int handle;   
/* Whatever you require here. If the only file you are using is */   
/* standard output using printf() for debugging, no file handling */   
/* is required. */   
};   
/* FILE is typedef’ d in stdio.h. */   
FILE __stdout;  
///
  
/// 定义_sys_exit()以避免使用半主机模式   
///
  
///   
///   
_sys_exit(int x)   
{   
x = x;   
}  

int fputc(int ch, FILE *f)  
{  
    //USART_SendData(USART1, (u8) ch);  
    USART1->DR = (u8) ch;  

    /* Loop until the end of transmission */  
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    {  
    }
    return ch;  
}  

回复

收藏1 举报

相关帖子
jiekou001 发表于 2024-7-25 22:17 | 显示全部楼层
新唐一般会帮你实现这个。
回复

收藏1 举报

jiekou001 发表于 2024-7-25 22:18 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     retarget.c
    

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V3.00
    

  4.  * [url=home.php?mod=space&uid=247401]@brief[/url]    M480 Series Debug Port and Semihost Setting Source File
    

  5.  *
    

  6.  * SPDX-License-Identifier: Apache-2.0
    

  7.  * [url=home.php?mod=space&uid=17282]@CopyRight[/url] (C) 2016-2020 Nuvoton Technology Corp. All rights reserved.
    

  8.  ******************************************************************************/
    


  9. 


  10. 

  11. #include <stdio.h>
    

  12. #include "NuMicro.h"
    


  13. 

  14. #if defined ( __CC_ARM   )
    

  15. #if (__ARMCC_VERSION < 400000)
    

  16. #else
    

  17. /* Insist on keeping widthprec, to avoid X propagation by benign code in C-lib */
    

  18. #pragma import _printf_widthprec
    

  19. #endif
    

  20. #endif
    

  21. /* Uncomment this line to disable all printf and getchar. getchar() will always return 0x00*/
    

  22. /* #define DISABLE_UART */
    


  23. 

  24. #if defined(DEBUG_ENABLE_SEMIHOST)
    

  25.     #ifndef DISABLE_UART
    

  26.         #define DISABLE_UART
    

  27.     #endif
    

  28. #endif
    


  29. 

  30. #define DEBUG_PORT   UART0
    

  31. /*---------------------------------------------------------------------------------------------------------*/
    

  32. /* Global variables                                                                                        */
    

  33. /*---------------------------------------------------------------------------------------------------------*/
    

  34. #if !(defined(__ICCARM__) && (__VER__ >= 6010000))
    

  35. # if (__ARMCC_VERSION < 6040000)
    

  36. struct __FILE
    

  37. {
    

  38.     int handle; /* Add whatever you need here */
    

  39. };
    

  40. # endif
    

  41. #elif(__VER__ >= 8000000)
    

  42. struct __FILE
    

  43. {
    

  44.     int handle; /* Add whatever you need here */
    

  45. };
    

  46. #endif
    

  47. FILE __stdout;
    

  48. FILE __stdin;
    


  49. 


  50. 

  51. enum { r0, r1, r2, r3, r12, lr, pc, psr};
    


  52. 

  53. /**
    

  54.  * @brief       Helper function to dump register while hard fault occurred
    

  55.  * @param[in]   stack pointer points to the dumped registers in SRAM
    

  56.  * [url=home.php?mod=space&uid=266161]@return[/url]      None
    

  57.  * [url=home.php?mod=space&uid=1543424]@Details[/url]     This function is implement to print r0, r1, r2, r3, r12, lr, pc, psr
    

  58.  */
    

  59. static void stackDump(uint32_t stack[])
    

  60. {
    

  61.     printf("r0  = 0x%x\n", stack[r0]);
    

  62.     printf("r1  = 0x%x\n", stack[r1]);
    

  63.     printf("r2  = 0x%x\n", stack[r2]);
    

  64.     printf("r3  = 0x%x\n", stack[r3]);
    

  65.     printf("r12 = 0x%x\n", stack[r12]);
    

  66.     printf("lr  = 0x%x\n", stack[lr]);
    

  67.     printf("pc  = 0x%x\n", stack[pc]);
    

  68.     printf("psr = 0x%x\n", stack[psr]);
    

  69. }
    


  70. 

  71. /**
    

  72.  * @brief       Hard fault handler
    

  73.  * @param[in]   stack pointer points to the dumped registers in SRAM
    

  74.  * @return      None
    

  75.  * @details     Replace while(1) at the end of this function with chip reset if WDT is not enabled for end product
    

  76.  */
    

  77. void Hard_Fault_Handler(uint32_t stack[])
    

  78. {
    

  79.     printf("In Hard Fault Handler\n");
    


  80. 

  81.     stackDump(stack);
    

  82.     /* Replace while(1) with chip reset if WDT is not enabled for end product */
    

  83.     while(1);
    

  84.     /* SYS->IPRST0 = SYS_IPRST0_CHIPRST_Msk; */
    

  85. }
    


  86. 


  87. 


  88. 

  89. /*---------------------------------------------------------------------------------------------------------*/
    

  90. /* Routine to write a char                                                                                 */
    

  91. /*---------------------------------------------------------------------------------------------------------*/
    


  92. 

  93. #if defined(DEBUG_ENABLE_SEMIHOST)
    

  94. /* The static buffer is used to speed up the semihost    */
    

  95. static char g_buf[16];
    

  96. static char g_buf_len = 0;
    


  97. 

  98. /* Make sure won't goes here only because --gnu is defined , so
    

  99.    add !__CC_ARM and !__ICCARM__ checking */
    

  100. # if defined ( __GNUC__ ) && !(__CC_ARM) && !(__ICCARM__)
    


  101. 

  102. # elif defined(__ICCARM__)      // IAR
    


  103. 

  104. void SH_End(void)
    

  105. {
    

  106.     asm("MOVS   R0,#1 \n"        /*; Set return value to 1 */
    

  107.         "BX     lr    \n"        /*; Return */
    

  108.        );
    

  109. }
    


  110. 

  111. void SH_ICE(void)
    

  112. {
    

  113.   asm("CMP   R2,#0   \n"
    

  114.       "BEQ   SH_End  \n"
    

  115.       "STR   R0,[R2] \n"       /*; Save the return value to *pn32Out_R0 */
    

  116.      );
    

  117. }
    


  118. 

  119. /**
    

  120.  *
    

  121.  * @brief      The function to process semihosted command
    

  122.  * @param[in]  n32In_R0  : semihost register 0
    

  123.  * @param[in]  n32In_R1  : semihost register 1
    

  124.  * @param[out] pn32Out_R0: semihost register 0
    

  125.  * @retval     0: No ICE debug
    

  126.  * @retval     1: ICE debug
    

  127.  *
    

  128.  */
    

  129. int32_t SH_DoCommand(int32_t n32In_R0, int32_t n32In_R1, int32_t *pn32Out_R0)
    

  130. {
    

  131.     asm("BKPT   0xAB   \n"       /*; This instruction will cause ICE trap or system HardFault */
    

  132.         "B      SH_ICE \n"
    

  133.         "SH_HardFault: \n"       /*; Captured by HardFault */
    

  134.         "MOVS   R0,#0  \n"       /*; Set return value to 0 */
    

  135.         "BX     lr     \n"       /*; Return */
    

  136.         );
    


  137. 

  138.     return 1;                    /*; Return 1 when it is trap by ICE */
    

  139. }
    


  140. 

  141. /**
    

  142.  * @brief       Get LR value and branch to Hard_Fault_Handler function
    

  143.  * @param       None
    

  144.  * @return      None
    

  145.  * @details     This function is use to get LR value and branch to Hard_Fault_Handler function.
    

  146.  */
    

  147. void Get_LR_and_Branch(void)
    

  148. {
    

  149.     asm("MOV     R1, LR               \n" /*; LR current value */
    

  150.         "B       Hard_Fault_Handler   \n"
    

  151.        );
    

  152. }
    


  153. 

  154. /**
    

  155.  * @brief       Get MSP value and branch to Get_LR_and_Branch function
    

  156.  * @param       None
    

  157.  * @return      None
    

  158.  * @details     This function is use to get stack pointer value and branch to Get_LR_and_Branch function.
    

  159.  */
    

  160. void Stack_Use_MSP(void)
    

  161. {
    

  162.     asm("MRS     R0, MSP           \n" /*; read MSP */
    

  163.         "B       Get_LR_and_Branch \n"
    

  164.        );
    

  165. }
    


  166. 

  167. /**
    

  168.  * @brief       Get stack pointer value and branch to Get_LR_and_Branch function
    

  169.  * @param       None
    

  170.  * @return      None
    

  171.  * @details     This function is use to get stack pointer value and branch to Get_LR_and_Branch function.
    

  172.  */
    

  173. void HardFault_Handler_Ret(void)
    

  174. {
    

  175.     asm("MOVS    r0, #4                        \n"
    

  176.         "MOV     r1, LR                        \n"
    

  177.         "TST     r0, r1                        \n" /*; check LR bit 2 */
    

  178.         "BEQ     Stack_Use_MSP                 \n" /*; stack use MSP */
    

  179.         "MRS     R0, PSP                       \n" /*; stack use PSP, read PSP */
    

  180.         "B       Get_LR_and_Branch             \n"
    

  181.        );
    

  182. }
    


  183. 

  184. /**
    

  185.  * @brief    This function is implemented to support semihost
    

  186.  * @param    None
    

  187.  * @returns  None
    

  188.  * @details  This function is implement to support semihost message print.
    

  189.  *
    

  190.  */
    

  191. void SP_Read_Ready(void)
    

  192. {
    

  193.     asm("LDR     R1, [R0, #24] \n"        /*; Get previous PC */
    

  194.         "LDRH    R3, [R1]      \n"        /*; Get instruction */
    

  195.         "LDR     R2, [pc, #8]  \n"        /*; The special BKPT instruction */
    

  196.         "CMP     R3, R2        \n"        /*; Test if the instruction at previous PC is BKPT */
    

  197.         "BNE     HardFault_Handler_Ret \n" /*; Not BKPT */
    

  198.         "ADDS    R1, #4        \n"        /*; Skip BKPT and next line */
    

  199.         "STR     R1, [R0, #24] \n"        /*; Save previous PC */
    

  200.         "BX      lr            \n"        /*; Return */
    

  201.         "DCD     0xBEAB        \n"        /*; BKPT instruction code */
    

  202.         "B       HardFault_Handler_Ret \n"
    

  203.        );
    

  204. }
    


  205. 

  206. /**
    

  207.  * @brief       Get stack pointer value and branch to Get_LR_and_Branch function
    

  208.  * @param       None
    

  209.  * @return      None
    

  210.  * @details     This function is use to get stack pointer value and branch to Get_LR_and_Branch function.
    

  211.  */
    

  212. void SP_is_PSP(void)
    

  213. {
    

  214.     asm(
    

  215.         "MRS     R0, PSP       \n"      /*; stack use PSP, read PSP */
    

  216.         "B       Get_LR_and_Branch    \n"
    


  217. 

  218.        );
    

  219. }
    


  220. 

  221. /**
    

  222.  * @brief    This HardFault handler is implemented to support semihost
    

  223.  *
    

  224.  * @param    None
    

  225.  *
    

  226.  * @returns  None
    

  227.  *
    

  228.  * @details  This function is implement to support semihost message print.
    

  229.  *
    

  230.  */
    

  231. void HardFault_Handler (void)
    

  232. {
    

  233.     asm("MOV     R0, lr        \n"
    

  234.         "LSLS    R0, #29       \n"        /*; Check bit 2 */
    

  235.         "BMI     SP_is_PSP     \n"        /*; previous stack is PSP */
    

  236.         "MRS     R0, MSP       \n"        /*; previous stack is MSP, read MSP */
    

  237.         "B       SP_Read_Ready \n"
    

  238.        );
    


  239. 

  240.     while(1);
    

  241. }
    


  242. 

  243. # else
    


  244. 

  245. /**
    

  246.  * @brief    This HardFault handler is implemented to support semihost
    

  247.  * @param    None
    

  248.  * @returns  None
    

  249.  * @details  This function is implement to support semihost message print.
    

  250.  *
    

  251.  */
    

  252. __asm int32_t HardFault_Handler(void)
    

  253. {
    

  254.     MOV     R0, LR
    

  255.     LSLS    R0, #29               /*; Check bit 2 */
    

  256.     BMI     SP_is_PSP             /*; previous stack is PSP */
    

  257.     MRS     R0, MSP               /*; previous stack is MSP, read MSP */
    

  258.     B       SP_Read_Ready
    

  259. SP_is_PSP
    

  260.     MRS     R0, PSP               /*; Read PSP */
    


  261. 

  262. SP_Read_Ready
    

  263.     LDR     R1, [R0, #24]         /*; Get previous PC */
    

  264.     LDRH    R3, [R1]              /*; Get instruction */
    

  265.     LDR     R2, =0xBEAB           /*; The special BKPT instruction */
    

  266.     CMP     R3, R2                /*; Test if the instruction at previous PC is BKPT */
    

  267.     BNE     HardFault_Handler_Ret /*; Not BKPT */
    


  268. 

  269.     ADDS    R1, #4                /*; Skip BKPT and next line */
    

  270.     STR     R1, [R0, #24]         /*; Save previous PC */
    


  271. 

  272.     BX      LR                    /*; Return */
    

  273. HardFault_Handler_Ret
    


  274. 

  275.     /* TODO: Implement your own hard fault handler here. */
    

  276.     MOVS    r0, #4
    

  277.     MOV     r1, LR
    

  278.     TST     r0, r1                          /*; check LR bit 2 */
    

  279.     BEQ     Stack_Use_MSP                   /*; stack use MSP */
    

  280.     MRS     R0, PSP ;stack use PSP          /*; stack use PSP, read PSP */
    

  281.     B       Get_LR_and_Branch
    

  282. Stack_Use_MSP
    

  283.     MRS     R0, MSP ; stack use MSP         /*; read MSP */
    

  284. Get_LR_and_Branch
    

  285.     MOV     R1, LR ; LR current value       /*; LR current value */
    

  286.     LDR     R2,=__cpp(Hard_Fault_Handler)   /*; branch to Hard_Fault_Handler */
    

  287.     BX      R2
    


  288. 

  289.     B       .
    


  290. 

  291.     ALIGN
    

  292. }
    


  293. 

  294. /**
    

  295.  *
    

  296.  * @brief      The function to process semihosted command
    

  297.  * @param[in]  n32In_R0  : semihost register 0
    

  298.  * @param[in]  n32In_R1  : semihost register 1
    

  299.  * @param[out] pn32Out_R0: semihost register 0
    

  300.  * @retval     0: No ICE debug
    

  301.  * @retval     1: ICE debug
    

  302.  *
    

  303.  */
    

  304. __asm int32_t SH_DoCommand(int32_t n32In_R0, int32_t n32In_R1, int32_t *pn32Out_R0)
    

  305. {
    

  306.     BKPT   0xAB          /*; Wait ICE or HardFault */
    

  307.     /*; ICE will step over BKPT directly
    

  308.       ; HardFault will step BKPT and the next line */
    

  309.     B      SH_ICE
    


  310. 

  311. SH_HardFault             /*; Captured by HardFault */
    

  312.     MOVS   R0, #0        /*; Set return value to 0 */
    

  313.     BX     lr            /*; Return */
    


  314. 

  315. SH_ICE                   /*; Captured by ICE */
    

  316.     /*; Save return value */
    

  317.     CMP    R2, #0
    

  318.     BEQ    SH_End
    

  319.     STR    R0, [R2]      /*; Save the return value to *pn32Out_R0 */
    


  320. 

  321. SH_End
    

  322.     MOVS   R0, #1        /*; Set return value to 1 */
    

  323.     BX     lr            /*; Return */
    

  324. }
    

  325. #endif
    


  326. 

  327. #else   // ndef DEBUG_ENABLE_SEMIHOST
    


  328. 

  329. /* Make sure won't goes here only because --gnu is defined , so
    

  330.    add !__CC_ARM and !__ICCARM__ checking */
    

  331. # if defined ( __GNUC__ ) && !(__CC_ARM) && !(__ICCARM__) 
    


  332. 

  333. /**
    

  334.  * @brief    This HardFault handler is implemented to show r0, r1, r2, r3, r12, lr, pc, psr
    

  335.  *
    

  336.  * @param    None
    

  337.  *
    

  338.  * @returns  None
    

  339.  *
    

  340.  * @details  This function is implement to print r0, r1, r2, r3, r12, lr, pc, psr.
    

  341.  *
    

  342.  */
    

  343. void HardFault_Handler(void)
    

  344. {
    

  345.     asm("MOVS    r0, #4                        \n"
    

  346.         "MOV     r1, LR                        \n"
    

  347.         "TST     r0, r1                        \n" /*; check LR bit 2 */
    

  348.         "BEQ     1f                            \n" /*; stack use MSP */
    

  349.         "MRS     R0, PSP                       \n" /*; stack use PSP, read PSP */
    

  350.         "MOV     R1, LR                        \n" /*; LR current value */
    

  351.         "B       Hard_Fault_Handler            \n"
    

  352.         "1:                                    \n"
    

  353.         "MRS     R0, MSP                       \n" /*; LR current value */
    

  354.         "B       Hard_Fault_Handler            \n"    
    

  355.         ::[Hard_Fault_Handler] "r" (Hard_Fault_Handler) // input
    

  356.     );
    

  357.     while(1);
    

  358. }
    


  359. 

  360. # elif defined(__ICCARM__)
    


  361. 

  362. void Get_LR_and_Branch(void)
    

  363. {
    

  364.     asm("MOV     R1, LR                  \n" /*; LR current value */
    

  365.         "B       Hard_Fault_Handler      \n"
    

  366.        );
    

  367. }
    


  368. 

  369. void Stack_Use_MSP(void)
    

  370. {
    

  371.     asm("MRS     R0, MSP           \n" /*; read MSP */
    

  372.         "B       Get_LR_and_Branch \n"
    

  373.        );
    

  374. }
    


  375. 

  376. /**
    

  377.  * @brief    This HardFault handler is implemented to show r0, r1, r2, r3, r12, lr, pc, psr
    

  378.  *
    

  379.  * @param    None
    

  380.  *
    

  381.  * @returns  None
    

  382.  *
    

  383.  * @details  This function is implement to print r0, r1, r2, r3, r12, lr, pc, psr.
    

  384.  *
    

  385.  */
    

  386. void HardFault_Handler(void)
    

  387. {
    

  388.     asm("MOVS    r0, #4                        \n"
    

  389.         "MOV     r1, LR                        \n"
    

  390.         "TST     r0, r1                        \n" /*; check LR bit 2 */
    

  391.         "BEQ     Stack_Use_MSP                 \n" /*; stack use MSP */
    

  392.         "MRS     R0, PSP                       \n" /*; stack use PSP, read PSP */
    

  393.         "B       Get_LR_and_Branch             \n"
    

  394.        );
    


  395. 

  396.     while(1);
    

  397. }
    


  398. 

  399. # else
    


  400. 

  401. /**
    

  402.  * @brief    This HardFault handler is implemented to show r0, r1, r2, r3, r12, lr, pc, psr
    

  403.  *
    

  404.  * @param    None
    

  405.  *
    

  406.  * @return   None
    

  407.  *
    

  408.  * @details  The function extracts the location of stack frame and passes it to Hard_Fault_Handler function as a pointer
    

  409.  *
    

  410.  */
    

  411. __asm int32_t HardFault_Handler(void)
    

  412. {
    

  413.     MOVS    r0, #4
    

  414.     MOV     r1, LR
    

  415.     TST     r0, r1          /*; check LR bit 2 */
    

  416.     BEQ     Stack_Use_MSP   /*; stack use MSP */
    

  417.     MRS     R0, PSP         /*; stack use PSP, read PSP */
    

  418.     B       Get_LR_and_Branch
    

  419. Stack_Use_MSP
    

  420.     MRS     R0, MSP         /*; read MSP */
    

  421. Get_LR_and_Branch
    

  422.     MOV     R1, LR          /*; LR current value */
    

  423.     LDR     R2,=__cpp(Hard_Fault_Handler) /*; branch to Hard_Fault_Handler */
    

  424.     BX      R2
    

  425. }
    


  426. 

  427. #endif
    


  428. 

  429. #endif
    


  430. 

  431. #ifndef DISABLE_UART
    

  432. /**
    

  433.  * @brief       Routine to send a char
    

  434.  *
    

  435.  * @param[in]   ch Character to send to debug port.
    

  436.  *
    

  437.  * @returns     Send value from UART debug port
    

  438.  *
    

  439.  * @details     Send a target char to UART debug port .
    

  440.  */
    

  441. #ifndef NONBLOCK_PRINTF
    

  442. static void SendChar_ToUART(int ch)
    

  443. {
    

  444.     while(DEBUG_PORT->FIFOSTS & UART_FIFOSTS_TXFULL_Msk);
    


  445. 

  446.     if(ch == '\n')
    

  447.     {
    

  448.         DEBUG_PORT->DAT = '\r';
    

  449.         while(DEBUG_PORT->FIFOSTS & UART_FIFOSTS_TXFULL_Msk);
    

  450.     }
    

  451.     DEBUG_PORT->DAT = ch;
    

  452. }
    


  453. 

  454. #else
    

  455. /* Non-block implement of send char */
    

  456. #define BUF_SIZE    2048
    

  457. static void SendChar_ToUART(int ch)
    

  458. {
    

  459.     static uint8_t u8Buf[BUF_SIZE] = {0};
    

  460.     static int32_t i32Head = 0;
    

  461.     static int32_t i32Tail = 0;
    

  462.     int32_t i32Tmp;
    


  463. 

  464.     /* Only flush the data in buffer to UART when ch == 0 */
    

  465.     if(ch)
    

  466.     {
    

  467.         /* Push char */
    

  468.         if(ch == '\n')
    

  469.         {
    

  470.             i32Tmp = i32Head+1;
    

  471.             if(i32Tmp > BUF_SIZE) i32Tmp = 0;
    

  472.             if(i32Tmp != i32Tail)
    

  473.             {
    

  474.                 u8Buf[i32Head] = '\r';
    

  475.                 i32Head = i32Tmp;
    

  476.             }
    

  477.         }
    


  478. 

  479.         i32Tmp = i32Head+1;
    

  480.         if(i32Tmp > BUF_SIZE) i32Tmp = 0;
    

  481.         if(i32Tmp != i32Tail)
    

  482.         {
    

  483.             u8Buf[i32Head] = ch;
    

  484.             i32Head = i32Tmp;
    

  485.         }
    

  486.     }
    

  487.     else
    

  488.     {
    

  489.         if(i32Tail == i32Head)
    

  490.             return;
    

  491.     }
    


  492. 

  493.     /* pop char */
    

  494.     do
    

  495.     {
    

  496.         i32Tmp = i32Tail + 1;
    

  497.         if(i32Tmp > BUF_SIZE) i32Tmp = 0;
    


  498. 

  499.         if((DEBUG_PORT->FIFOSTS & UART_FIFOSTS_TXFULL_Msk) == 0)
    

  500.         {
    

  501.             DEBUG_PORT->DAT = u8Buf[i32Tail];
    

  502.             i32Tail = i32Tmp;
    

  503.         }
    

  504.         else
    

  505.             break; /* FIFO full */
    

  506.     }while(i32Tail != i32Head);
    

  507. }
    

  508. #endif   /* else for NONBLOCK_PRINTF */
    


  509. 

  510. #endif   /* if not def DISABLE_UART */
    


  511. 

  512. /**
    

  513.  * @brief       Routine to send a char
    

  514.  *
    

  515.  * @param[in]   ch Character to send to debug port.
    

  516.  *
    

  517.  * @returns     Send value from UART debug port or semihost
    

  518.  *
    

  519.  * @details     Send a target char to UART debug port or semihost.
    

  520.  */
    

  521. static void SendChar(int ch)
    

  522. {
    

  523. #if defined(DEBUG_ENABLE_SEMIHOST)
    

  524.     g_buf[g_buf_len++] = ch;
    

  525.     g_buf[g_buf_len] = '\0';
    

  526.     if(g_buf_len + 1 >= sizeof(g_buf) || ch == '\n' || ch == '\0')
    

  527.     {
    

  528.         /* Send the char */
    

  529.         if(SH_DoCommand(0x04, (int)g_buf, NULL) != 0)
    

  530.         {
    

  531.             g_buf_len = 0;
    

  532.             return;
    

  533.         }
    

  534.         else
    

  535.         {
    

  536. #ifndef DISABLE_UART
    

  537.             int i;
    


  538. 

  539.             for(i = 0; i < g_buf_len; i++)
    

  540.                 SendChar_ToUART(g_buf[i]);
    

  541. #endif
    

  542.             g_buf_len = 0;
    

  543.         }
    

  544.     }
    

  545. #else
    

  546. #ifndef DISABLE_UART
    

  547.     SendChar_ToUART(ch);
    

  548. #endif
    

  549. #endif
    

  550. }
    


  551. 

  552. /**
    

  553.  * @brief    Routine to get a char
    

  554.  *
    

  555.  * @param    None
    

  556.  *
    

  557.  * @returns  Get value from UART debug port or semihost
    

  558.  *
    

  559.  * @details  Wait UART debug port or semihost to input a char.
    

  560.  */
    

  561. static char GetChar(void)
    

  562. {
    

  563. #ifdef DEBUG_ENABLE_SEMIHOST
    

  564. # if defined (__CC_ARM)
    

  565.     int nRet;
    

  566.     while(SH_DoCommand(0x101, 0, &nRet) != 0)
    

  567.     {
    

  568.         if(nRet != 0)
    

  569.         {
    

  570.             SH_DoCommand(0x07, 0, &nRet);
    

  571.             return (char)nRet;
    

  572.         }
    

  573.     }
    

  574. # else
    

  575.     int nRet;
    

  576.     while(SH_DoCommand(0x7, 0, &nRet) != 0)
    

  577.     {
    

  578.         if(nRet != 0)
    

  579.             return (char)nRet;
    

  580.     }
    

  581. # endif
    

  582.     return (0);
    

  583. #else
    

  584. #ifndef DISABLE_UART
    

  585.     while(1)
    

  586.     {
    

  587.         if((DEBUG_PORT->FIFOSTS & UART_FIFOSTS_RXEMPTY_Msk) == 0)
    

  588.         {
    

  589.             return (DEBUG_PORT->DAT);
    

  590.         }
    

  591.     }
    

  592. #else
    

  593.     return 0;
    

  594. #endif
    

  595. #endif
    

  596. }
    


  597. 

  598. /**
    

  599.  * @brief    Check any char input from UART
    

  600.  *
    

  601.  * @param    None
    

  602.  *
    

  603.  * @retval   1: No any char input
    

  604.  * @retval   0: Have some char input
    

  605.  *
    

  606.  * @details  Check UART RSR RX EMPTY or not to determine if any char input from UART
    

  607.  */
    


  608. 

  609. int kbhit(void)
    

  610. {
    

  611. #ifndef DISABLE_UART
    

  612.     return !((DEBUG_PORT->FIFOSTS & UART_FIFOSTS_RXEMPTY_Msk) == 0);
    

  613. #else
    

  614.     return 0;
    

  615. #endif
    

  616. }
    

  617. /**
    

  618.  * @brief    Check if debug message finished
    

  619.  *
    

  620.  * @param    None
    

  621.  *
    

  622.  * @retval   1: Message is finished
    

  623.  * @retval   0: Message is transmitting.
    

  624.  *
    

  625.  * @details  Check if message finished (FIFO empty of debug port)
    

  626.  */
    


  627. 

  628. int IsDebugFifoEmpty(void)
    

  629. {
    

  630. #ifndef DISABLE_UART
    

  631.     return ((DEBUG_PORT->FIFOSTS & UART_FIFOSTS_TXEMPTYF_Msk) != 0);
    

  632. #else
    

  633.     return 1;
    

  634. #endif
    

  635. }
    


  636. 

  637. /**
    

  638.  * @brief       C library retargetting
    

  639.  *
    

  640.  * @param[in]   ch Character to send to debug port.
    

  641.  *
    

  642.  * @returns     None
    

  643.  *
    

  644.  * @details     Check if message finished (FIFO empty of debug port)
    

  645.  */
    


  646. 

  647. void _ttywrch(int ch)
    

  648. {
    

  649.     SendChar(ch);
    

  650.     return;
    

  651. }
    


  652. 


  653. 

  654. /**
    

  655.  * @brief      Write character to stream
    

  656.  *
    

  657.  * @param[in]  ch       Character to be written. The character is passed as its int promotion.
    

  658.  * @param[in]  stream   Pointer to a FILE object that identifies the stream where the character is to be written.
    

  659.  *
    

  660.  * @returns    If there are no errors, the same character that has been written is returned.
    

  661.  *             If an error occurs, EOF is returned and the error indicator is set (see ferror).
    

  662.  *
    

  663.  * @details    Writes a character to the stream and advances the position indicator.\n
    

  664.  *             The character is written at the current position of the stream as indicated \n
    

  665.  *             by the internal position indicator, which is then advanced one character.
    

  666.  *
    

  667.  * [url=home.php?mod=space&uid=536309]@NOTE[/url]       The above descriptions are copied from http://www.cplusplus.com/reference/clibrary/cstdio/fputc/.
    

  668.  *
    

  669.  *
    

  670.  */
    


  671. 

  672. int fputc(int ch, FILE *stream)
    

  673. {
    

  674.     SendChar(ch);
    

  675.     return ch;
    

  676. }
    


  677. 

  678. #if defined (__GNUC__) && !defined(__ARMCC_VERSION)
    


  679. 

  680. int _write (int fd, char *ptr, int len)
    

  681. {
    

  682.     int i = len;
    


  683. 

  684.     while(i--)
    

  685.     {
    

  686.         while(DEBUG_PORT->FIFOSTS & UART_FIFOSTS_TXFULL_Msk);
    


  687. 

  688.         if(*ptr == '\n')
    

  689.         {
    

  690.             DEBUG_PORT->DAT = '\r';
    

  691.             while(DEBUG_PORT->FIFOSTS & UART_FIFOSTS_TXFULL_Msk);
    

  692.         }
    


  693. 

  694.         DEBUG_PORT->DAT = *ptr++;
    


  695. 

  696.     }
    

  697.     return len;
    

  698. }
    


  699. 

  700. int _read (int fd, char *ptr, int len)
    

  701. {
    


  702. 

  703.     while((DEBUG_PORT->FIFOSTS & UART_FIFOSTS_RXEMPTY_Msk) != 0);
    

  704.     *ptr = DEBUG_PORT->DAT;
    

  705.     return 1;
    


  706. 


  707. 

  708. }
    


  709. 

  710. #else
    

  711. /**
    

  712.  * @brief      Get character from UART debug port or semihosting input
    

  713.  *
    

  714.  * @param[in]  stream   Pointer to a FILE object that identifies the stream on which the operation is to be performed.
    

  715.  *
    

  716.  * @returns    The character read from UART debug port or semihosting
    

  717.  *
    

  718.  * @details    For get message from debug port or semihosting.
    

  719.  *
    

  720.  */
    


  721. 

  722. int fgetc(FILE *stream)
    

  723. {
    

  724.     return (GetChar());
    

  725. }
    


  726. 

  727. /**
    

  728.  * @brief      Check error indicator
    

  729.  *
    

  730.  * @param[in]  stream   Pointer to a FILE object that identifies the stream.
    

  731.  *
    

  732.  * @returns    If the error indicator associated with the stream was set, the function returns a nonzero value.
    

  733.  *             Otherwise, it returns a zero value.
    

  734.  *
    

  735.  * @details    Checks if the error indicator associated with stream is set, returning a value different
    

  736.  *             from zero if it is. This indicator is generally set by a previous operation on the stream that failed.
    

  737.  *
    

  738.  * @note       The above descriptions are copied from http://www.cplusplus.com/reference/clibrary/cstdio/ferror/.
    

  739.  *
    

  740.  */
    


  741. 

  742. int ferror(FILE *stream)
    

  743. {
    

  744.     return EOF;
    

  745. }
    

  746. #endif
    

  747. #ifdef DEBUG_ENABLE_SEMIHOST
    

  748. # ifdef __ICCARM__
    

  749. void __exit(int return_code)
    

  750. {
    


  751. 

  752.     /* Check if link with ICE */
    

  753.     if(SH_DoCommand(0x18, 0x20026, NULL) == 0)
    

  754.     {
    

  755.         /* Make sure all message is print out */
    

  756.         while(IsDebugFifoEmpty() == 0);
    

  757.     }
    

  758. label:
    

  759.     goto label;  /* endless loop */
    

  760. }
    

  761. # else
    

  762. void _sys_exit(int return_code)
    

  763. {
    


  764. 

  765.     /* Check if link with ICE */
    

  766.     if(SH_DoCommand(0x18, 0x20026, NULL) == 0)
    

  767.     {
    

  768.         /* Make sure all message is print out */
    

  769.         while(IsDebugFifoEmpty() == 0);
    

  770.     }
    

  771. label:
    

  772.     goto label;  /* endless loop */
    

  773. }
    

  774. # endif
    

  775. #endif
回复

收藏1 举报

sdlls 发表于 2024-8-5 10:01 | 显示全部楼层
新唐单片机（Nuvoton）上的printf函数重定向到串口的方法与其他单片机类似。
回复

收藏1 举报

mattlincoln 发表于 2024-8-5 11:40 | 显示全部楼层
配置串口相关的寄存器，设置波特率、数据位、停止位等参数，使其能够正常工作。
回复

收藏1 举报

iyoum 发表于 2024-8-5 12:35 | 显示全部楼层
stdio.h：标准输入输出头文件，包含printf函数的声明。
serial.h：如果串口功能是通过特定的库实现的，则需要包含相应的头文件。对于新唐单片机，可能需要包含NuMicro.h或其他与串口相关的头文件。
回复

收藏1 举报

plsbackup 发表于 2024-8-5 16:33 | 显示全部楼层
需要定义一个新的函数，比如fputc_redirect，这个函数将被用作fputc的替代。在这个函数中，你将写入一个字符到串口。
回复

收藏1 举报

ccook11 发表于 2024-8-5 18:01 | 显示全部楼层
#include <stdio.h>
#include <stdarg.h>

// 串口发送字符的函数
void UART_SendChar(unsigned char c) {
    // 在此处添加将字符发送到串口的代码
}

// `printf` 重定向函数
int fputc(int ch, FILE *f) {
    UART_SendChar((unsigned char)ch);
    return ch;
}
回复

收藏1 举报

10299823 发表于 2024-8-5 19:51 | 显示全部楼层
需要包含标准的输入输出库以及其他必要的头文件，比如串口通信的头文件。
回复

收藏1 举报

benjaminka 发表于 2024-8-5 21:38 | 显示全部楼层
需要包含必要的头文件，并声明一个用于串口初始化的函数。
回复

收藏1 举报

lzmm 发表于 2024-8-6 10:19 | 显示全部楼层
使用的是Keil MDK或者其他集成开发环境，你可能需要在项目的选项设置中启用微库（MicroLib），因为它包含了优化的标准C库函数，更适合嵌入式系统，并且支持printf的重定向。
回复

收藏1 举报

药无尘 发表于 2024-8-6 11:44 | 显示全部楼层
/ 串口发送字符的函数
void UART_SendChar(unsigned char c) {
    // 在此处添加将字符发送到串口的代码
}

// `printf` 重定向函数
int fputc(int ch, FILE *f) {
    UART_SendChar((unsigned char)ch);
    return ch;
}
回复

收藏1 举报

backlugin 发表于 2024-8-6 11:55 | 显示全部楼层
需要调整缓冲区大小以适应特定的应用需求。
回复

收藏1 举报

i1mcu 发表于 2024-8-6 13:29 | 显示全部楼层
在Keil MDK中，你可以在“Project -> Options for Target -> Target”中找到“Use MicroLIB”选项并勾选它。
回复

收藏1 举报

minzisc 发表于 2024-8-6 15:09 | 显示全部楼层
重定向通常是通过一个简单的库函数来实现的，它会在程序开始时初始化串口，并在调用printf时将输出发送到串口。
回复

收藏1 举报

albertaabbot 发表于 2024-8-6 16:47 | 显示全部楼层
// 重定向fputc函数到串口
int fputc(int ch, FILE *stream) {
    // 发送字符到串口
    Uart_PutChar(UART0, (char)ch);
    return ch;
}
回复

收藏1 举报

updownq 发表于 2024-8-6 18:22 | 显示全部楼层
需要重新定义标准输入/输出（I/O）函数，特别是fputc函数，以便它将字符发送到串口而不是控制台。
回复

收藏1 举报

jimmhu 发表于 2024-8-6 20:02 | 显示全部楼层
需要实现一个串口通信接口，并将标准I/O库中的fputc函数重定向到串口。
回复

收藏1 举报

saservice 发表于 2024-8-6 21:45 | 显示全部楼层
可以像平常一样使用printf函数，它会自动将输出重定向到串口。
回复

收藏1 举报

uytyu 发表于 2024-8-8 09:26 | 显示全部楼层
典型的嵌入式C开发环境              
回复

收藏1 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

maudlu

54

主题

1693

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部