21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › M058S重定向
返回列表 发新帖我要提问

[牛人杂谈] M058S重定向

[复制链接]
 楼主| 734774645 发表于 2025-2-14 15:39 | 显示全部楼层 |阅读模式
m058s, 重定向, ar, ST, AN
复制
  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.  * $Revision: 4 $
    

  5.  * $Date: 15/11/04 9:35a $
    

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

  7.  *
    

  8.  * @note
    

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

  10.  *
    

  11.  * Copyright (C) 2011 Nuvoton Technology Corp. All rights reserved.
    

  12.  *
    

  13.  ******************************************************************************/
    


  14. 


  15. 

  16. #include <stdio.h>
    

  17. #include "M058S.h"
    


  18. 

  19. #if defined ( __CC_ARM   )
    

  20. #if (__ARMCC_VERSION < 400000)
    

  21. #else
    

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

  23. #pragma import _printf_widthprec
    

  24. #endif
    

  25. #endif
    


  26. 

  27. /*---------------------------------------------------------------------------------------------------------*/
    

  28. /* Global variables                                                                                        */
    

  29. /*---------------------------------------------------------------------------------------------------------*/
    

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

  31. struct __FILE
    

  32. {
    

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

  34. };
    

  35. #endif
    

  36. FILE __stdout;
    

  37. FILE __stdin;
    


  38. 

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


  40. 

  41. /**
    

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

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

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

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

  46.  */
    

  47. static void stackDump(uint32_t stack[])
    

  48. {   
    

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

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

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

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

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

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

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

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

  57. }
    


  58. 

  59. /**
    

  60.  * @brief       Hard fault handler
    

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

  62.  * @return      None
    

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

  64.  */
    

  65. void Hard_Fault_Handler(uint32_t stack[])
    

  66. {
    

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


  68. 

  69.     stackDump(stack);
    


  70. 

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

  72.     while(1);
    

  73.     //SYS->IPRSTC1 = SYS_IPRSTC1_CHIP_RST_Msk;
    

  74. }
    


  75. 

  76. /*---------------------------------------------------------------------------------------------------------*/
    

  77. /* Routine to write a char                                                                                 */
    

  78. /*---------------------------------------------------------------------------------------------------------*/
    


  79. 

  80. #if defined(DEBUG_ENABLE_SEMIHOST)
    

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

  82. static char g_buf[16];
    

  83. static char g_buf_len = 0;
    


  84. 

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

  86.    add !__CC_ARM and !__ICCARM__ checking */
    

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


  88. 

  89. # elif defined(__ICCARM__)
    


  90. 


  91. 

  92. void SH_End(void)
    

  93. {
    

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

  95.         "BX     lr    \n"            //; Return
    

  96.        );
    

  97. }
    


  98. 

  99. void SH_ICE(void)
    

  100. {
    

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

  102.       "BEQ   SH_End  \n"
    

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

  104.      );
    

  105. }
    


  106. 

  107. /**
    

  108.  *
    

  109.  * @brief      The function to process semihosted command
    

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

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

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

  113.  * @retval     0: No ICE debug
    

  114.  * @retval     1: ICE debug
    

  115.  *
    

  116.  */
    

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

  118. {
    

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

  120.         "B      SH_ICE \n"
    

  121.         "SH_HardFault: \n"       //; Captured by HardFault
    

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

  123.         "BX     lr     \n"       //; Return
    

  124.         );
    


  125. 

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

  127. }
    


  128. 

  129. /**
    

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

  131.  * @param       None
    

  132.  * @return      None
    

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

  134.  */
    

  135. void Get_LR_and_Branch(void)
    

  136. {
    

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

  138.         "B       Hard_Fault_Handler   \n"
    

  139.        );
    

  140. }
    


  141. 

  142. /**
    

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

  144.  * @param       None
    

  145.  * @return      None
    

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

  147.  */
    

  148. void Stack_Use_MSP(void)
    

  149. {
    

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

  151.         "B       Get_LR_and_Branch \n"
    

  152.        );
    

  153. }
    


  154. 

  155. /**
    

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

  157.  * @param       None
    

  158.  * @return      None
    

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

  160.  */
    

  161. void HardFault_Handler_Ret(void)
    

  162. {
    

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

  164.         "MOV     r1, LR                        \n"
    

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

  166.         "BEQ     Stack_Use_MSP                 \n" //; stack use MSP
    

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

  168.         "B       Get_LR_and_Branch             \n"
    

  169.        );
    

  170. }
    


  171. 

  172. /**
    

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

  174.  * @param    None
    

  175.  * @returns  None
    

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

  177.  *
    

  178.  */
    

  179. void SP_Read_Ready(void)
    

  180. {
    

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

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

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

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

  185.         "BNE     HardFault_Handler_Ret \n" //; Not BKPT
    

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

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

  188.         "BX      lr            \n"        //; Return
    

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

  190.         "B       HardFault_Handler_Ret \n"
    

  191.        );
    

  192. }
    


  193. 

  194. /**
    

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

  196.  * @param       None
    

  197.  * @return      None
    

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

  199.  */
    

  200. void SP_is_PSP(void)
    

  201. {
    

  202.     asm(
    

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

  204.         "B       Get_LR_and_Branch    \n"
    

  205.     
    

  206.        );
    

  207. }
    


  208. 

  209. /**
    

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

  211.  *
    

  212.  * @param    None
    

  213.  *
    

  214.  * @returns  None
    

  215.  *
    

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

  217.  *
    

  218.  */
    

  219. void HardFault_Handler (void)
    

  220. {
    

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

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

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

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

  225.         "B       SP_Read_Ready \n"
    

  226.        );
    


  227. 

  228.     while(1);
    

  229. }
    


  230. 


  231. 

  232. # else
    


  233. 

  234. /**
    

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

  236.  * @param    None
    

  237.  * @returns  None
    

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

  239.  *
    

  240.  */
    

  241. __asm int32_t HardFault_Handler(void)
    

  242. {
    

  243.     IMPORT  Hard_Fault_Handler
    


  244. 

  245.     MOV     R0, LR
    

  246.     LSLS    R0, #29               //; Check bit 2
    

  247.     BMI     SP_is_PSP             //; previous stack is PSP
    

  248.     MRS     R0, MSP               //; previous stack is MSP, read MSP
    

  249.     B       SP_Read_Ready
    

  250. SP_is_PSP
    

  251.     MRS     R0, PSP               //; Read PSP
    


  252. 

  253. SP_Read_Ready
    

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

  255.     LDRH    R3, [R1]              //; Get instruction
    

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

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

  258.     BNE     HardFault_Handler_Ret //; Not BKPT
    


  259. 

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

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


  262. 

  263.     BX      LR                    //; Return
    

  264. HardFault_Handler_Ret
    


  265. 

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

  267.     MOVS    r0, #4
    

  268.     MOV     r1, LR
    

  269.     TST     r0, r1                          //; check LR bit 2  
    

  270.     BEQ     Stack_Use_MSP                   //; stack use MSP
    

  271.     MRS     R0, PSP ;stack use PSP          //; stack use PSP, read PSP
    

  272.     B       Get_LR_and_Branch
    

  273. Stack_Use_MSP
    

  274.     MRS     R0, MSP ; stack use MSP         //; read MSP
    

  275. Get_LR_and_Branch
    

  276.     MOV     R1, LR ; LR current value       //; LR current value       
    

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

  278.     BX      R2
    


  279. 

  280.     B       .
    


  281. 

  282.                  ALIGN
    

  283. }
    


  284. 

  285. /**
    

  286.  *
    

  287.  * @brief      The function to process semihosted command
    

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

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

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

  291.  * @retval     0: No ICE debug
    

  292.  * @retval     1: ICE debug
    

  293.  *
    

  294.  */
    

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

  296. {
    

  297.     BKPT   0xAB          //; Wait ICE or HardFault
    

  298.     //; ICE will step over BKPT directly
    

  299.     //; HardFault will step BKPT and the next line
    

  300.     B      SH_ICE
    


  301. 

  302. SH_HardFault             //; Captured by HardFault
    

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

  304.     BX     lr            //; Return
    


  305. 

  306. SH_ICE                   //; Captured by ICE
    

  307.     //; Save return value
    

  308.     CMP    R2, #0
    

  309.     BEQ    SH_End
    

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


  311. 

  312. SH_End
    

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

  314.     BX     lr            //; Return
    

  315. }
    

  316. #endif
    


  317. 


  318. 

  319. #else // Non-semihost
    


  320. 

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

  322.    add !__CC_ARM and !__ICCARM__ checking */
    

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


  324. 

  325. /**
    

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

  327.  *
    

  328.  * @param    None
    

  329.  *
    

  330.  * @returns  None
    

  331.  *
    

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

  333.  *
    

  334.  */
    

  335. void HardFault_Handler(void)
    

  336. {
    

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

  338.         "MOV     r1, LR                        \n"
    

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

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

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

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

  343.         "B       Hard_Fault_Handler            \n"
    

  344.         "1:                                    \n"
    

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

  346.         "B       Hard_Fault_Handler            \n"
    

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

  348.     );
    

  349.     while(1);
    

  350. }
    


  351. 

  352. # elif defined(__ICCARM__)
    


  353. 

  354. void Get_LR_and_Branch(void)
    

  355. {
    

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

  357.         "B       Hard_Fault_Handler      \n"
    

  358.        );
    

  359. }
    


  360. 

  361. void Stack_Use_MSP(void)
    

  362. {
    

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

  364.         "B       Get_LR_and_Branch \n"
    

  365.        );
    

  366. }
    


  367. 

  368. /**
    

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

  370.  *
    

  371.  * @param    None
    

  372.  *
    

  373.  * @returns  None
    

  374.  *
    

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

  376.  *
    

  377.  */
    

  378. void HardFault_Handler(void)
    

  379. {
    

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

  381.         "MOV     r1, LR                        \n"
    

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

  383.         "BEQ     Stack_Use_MSP                 \n" //; stack use MSP
    

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

  385.         "B       Get_LR_and_Branch             \n"
    

  386.        );
    


  387. 

  388.     while(1);
    

  389. }
    


  390. 

  391. # else
    


  392. 

  393. /**
    

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

  395.  *
    

  396.  * @param    None
    

  397.  *
    

  398.  * @return   None
    

  399.  *
    

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

  401.  *
    

  402.  */
    

  403. __asm int32_t HardFault_Handler(void)
    

  404. {
    

  405.     IMPORT  Hard_Fault_Handler
    


  406. 

  407.     MOVS    r0, #4
    

  408.     MOV     r1, LR
    

  409.     TST     r0, r1          //; check LR bit 2                 
    

  410.     BEQ     Stack_Use_MSP   //; stack use MSP
    

  411.     MRS     R0, PSP         //; stack use PSP, read PSP
    

  412.     B       Get_LR_and_Branch
    

  413. Stack_Use_MSP
    

  414.     MRS     R0, MSP         //; read MSP
    

  415. Get_LR_and_Branch
    

  416.     MOV     R1, LR          //; LR current value
    

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

  418.     BX      R2
    

  419. }
    


  420. 

  421. #endif
    


  422. 

  423. #endif
    


  424. 


  425. 

  426. /**
    

  427.  * @brief    Routine to send a char
    

  428.  *
    

  429.  * @param[in] ch  A character data writes to debug port
    

  430.  *
    

  431.  * @returns  Send value from UART debug port
    

  432.  *
    

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

  434.  */
    

  435. #ifndef NONBLOCK_PRINTF
    

  436. void SendChar_ToUART(int ch)
    

  437. {
    


  438. 

  439.     while(DEBUG_PORT->FSR & UART_FSR_TX_FULL_Msk);
    

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

  441.     {
    

  442.         DEBUG_PORT->DATA = '\r';
    

  443.         while(DEBUG_PORT->FSR & UART_FSR_TX_FULL_Msk);
    

  444.     }
    


  445. 

  446.     DEBUG_PORT->DATA = ch;
    

  447. }
    


  448. 

  449. #else
    

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

  451. #define BUF_SIZE    512
    

  452. void SendChar_ToUART(int ch)
    

  453. {
    

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

  455.     static int32_t i32Head = 0;
    

  456.     static int32_t i32Tail = 0;
    

  457.     int32_t i32Tmp;
    


  458. 

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

  460.     if(ch)
    

  461.     {
    

  462.         // Push char
    

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

  464.         {
    

  465.             i32Tmp = i32Head + 1;
    

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

  467.             if(i32Tmp != i32Tail)
    

  468.             {
    

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

  470.                 i32Head = i32Tmp;
    

  471.             }
    

  472.         }
    


  473. 

  474.         i32Tmp = i32Head + 1;
    

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

  476.         if(i32Tmp != i32Tail)
    

  477.         {
    

  478.             u8Buf[i32Head] = ch;
    

  479.             i32Head = i32Tmp;
    

  480.         }
    

  481.     }
    

  482.     else
    

  483.     {
    

  484.         if(i32Tail == i32Head)
    

  485.             return;
    

  486.     }
    


  487. 

  488.     // pop char
    

  489.     do
    

  490.     {
    

  491.         i32Tmp = i32Tail + 1;
    

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


  493. 

  494.         if((DEBUG_PORT->FSR & UART_FSR_TX_FULL_Msk) == 0)
    

  495.         {
    

  496.             DEBUG_PORT->DATA = u8Buf[i32Tail];
    

  497.             i32Tail = i32Tmp;
    

  498.         }
    

  499.         else
    

  500.             break; // FIFO full
    

  501.     }
    

  502.     while(i32Tail != i32Head);
    

  503. }
    

  504. #endif
    


  505. 

  506. /**
    

  507.  * @brief    Routine to send a char
    

  508.  *
    

  509.  * @param[in] ch A character data writes to debug port
    

  510.  *
    

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

  512.  *
    

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

  514.  */
    

  515. void SendChar(int ch)
    

  516. {
    

  517. #if defined(DEBUG_ENABLE_SEMIHOST)
    

  518.     g_buf[g_buf_len++] = ch;
    

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

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

  521.     {
    

  522.         /* Send the char */
    

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

  524.         {
    

  525.             g_buf_len = 0;
    

  526.             return;
    

  527.         }
    

  528.         else
    

  529.         {
    

  530.             g_buf_len = 0;
    

  531.         }
    

  532.     }
    

  533. #else
    

  534.     SendChar_ToUART(ch);
    

  535. #endif
    

  536. }
    


  537. 

  538. /**
    

  539.  * @brief    Routine to get a char
    

  540.  *
    

  541.  * @param    None
    

  542.  *
    

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

  544.  *
    

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

  546.  */
    

  547. char GetChar(void)
    

  548. {
    

  549. #ifdef DEBUG_ENABLE_SEMIHOST
    

  550. # if defined (__CC_ARM)
    

  551.     int nRet;
    

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

  553.     {
    

  554.         if(nRet != 0)
    

  555.         {
    

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

  557.             return (char)nRet;
    

  558.         }
    

  559.     }
    

  560. # else
    

  561.     int nRet;
    

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

  563.     {
    

  564.         if(nRet != 0)
    

  565.             return (char)nRet;
    

  566.     }
    

  567. # endif
    

  568.     return (0);
    

  569. #else
    


  570. 

  571.     while(1)
    

  572.     {
    

  573.         if((DEBUG_PORT->FSR & UART_FSR_RX_EMPTY_Msk) == 0)
    

  574.         {
    

  575.             return (DEBUG_PORT->DATA);
    

  576.         }
    

  577.     }
    


  578. 

  579. #endif
    

  580. }
    


  581. 

  582. /**
    

  583.  * @brief    Check any char input from UART
    

  584.  *
    

  585.  * @param    None
    

  586.  *
    

  587.  * @retval   1: No any char input
    

  588.  * @retval   0: Have some char input
    

  589.  *
    

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

  591.  */
    


  592. 

  593. int kbhit(void)
    

  594. {
    

  595.     return !((DEBUG_PORT->FSR & UART_FSR_RX_EMPTY_Msk) == 0);
    

  596. }
    

  597. /**
    

  598.  * @brief    Check if debug message finished
    

  599.  *
    

  600.  * @param    None
    

  601.  *
    

  602.  * @retval   1: Message is finished
    

  603.  * @retval   0: Message is transmitting.
    

  604.  *
    

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

  606.  */
    


  607. 

  608. int IsDebugFifoEmpty(void)
    

  609. {
    

  610.     return ((DEBUG_PORT->FSR & UART_FSR_TE_FLAG_Msk) != 0);
    

  611. }
    


  612. 

  613. /**
    

  614.  * @brief    C library retargetting
    

  615.  *
    

  616.  * @param[in]  ch  Write a character data
    

  617.  *
    

  618.  * @returns  None
    

  619.  *
    

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

  621.  */
    


  622. 

  623. void _ttywrch(int ch)
    

  624. {
    

  625.     SendChar(ch);
    

  626.     return;
    

  627. }
    


  628. 


  629. 

  630. /**
    

  631.  * @brief      Write character to stream
    

  632.  *
    

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

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

  635.  *
    

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

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

  638.  *
    

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

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

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

  642.  *
    

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

  644.  *
    

  645.  *
    

  646.  */
    


  647. 

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

  649. {
    

  650.     SendChar(ch);
    

  651.     return ch;
    

  652. }
    


  653. 

  654. #if defined ( __GNUC__ )
    


  655. 

  656. #if !defined (OS_USE_SEMIHOSTING)
    

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

  658. {
    

  659.     int i = len;
    


  660. 

  661.     while(i--)
    

  662.     {
    

  663.         while(DEBUG_PORT->FSR & UART_FSR_TX_FULL_Msk);
    


  664. 

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

  666.         {
    

  667.             DEBUG_PORT->DATA = '\r';
    

  668.             while(DEBUG_PORT->FSR & UART_FSR_TX_FULL_Msk);
    

  669.         }
    


  670. 

  671.         DEBUG_PORT->DATA = *ptr++;
    

  672.         }
    

  673.     return len;
    

  674. }
    


  675. 

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

  677. {
    


  678. 

  679.     while((DEBUG_PORT->FSR & UART_FSR_RX_EMPTY_Msk) != 0);
    

  680.     *ptr = DEBUG_PORT->DATA;
    

  681.     return 1;
    


  682. 


  683. 

  684. }
    

  685. #endif
    


  686. 

  687. #else
    

  688. /**
    

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

  690.  *
    

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

  692.  *
    

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

  694.  *
    

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

  696.  *
    

  697.  */
    


  698. 

  699. int fgetc(FILE *stream)
    

  700. {
    

  701.     return (GetChar());
    

  702. }
    


  703. 

  704. /**
    

  705.  * @brief      Check error indicator
    

  706.  *
    

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

  708.  *
    

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

  710.  *             Otherwise, it returns a zero value.
    

  711.  *
    

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

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

  714.  *
    

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

  716.  *
    

  717.  */
    


  718. 

  719. // int ferror(FILE *stream)
    

  720. // {
    

  721. //     return EOF;
    

  722. // }
    

  723. #endif
    


  724. 

  725. #ifdef DEBUG_ENABLE_SEMIHOST
    

  726. # ifdef __ICCARM__
    

  727. void __exit(int return_code)
    

  728. {
    


  729. 

  730.     /* Check if link with ICE */
    

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

  732.     {
    

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

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

  735.     }
    

  736. label:
    

  737.     goto label;  /* endless loop */
    

  738. }
    

  739. # else
    

  740. void _sys_exit(int return_code)
    

  741. {
    


  742. 

  743.     /* Check if link with ICE */
    

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

  745.     {
    

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

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

  748.     }
    

  749. label:
    

  750.     goto label;  /* endless loop */
    

  751. }
    

  752. # endif
    

  753. #endif
    


  754. 


  755.
文件是新唐M058S单片机库函数中的一个重要文件，主要用于调试端口和半主机（Semihosting）的设置。以下是对该文件的详细解释，帮助你理解其功能和作用。

1. 文件概述
文件名: retarget.c

版本: V3.00

功能: 该文件主要用于配置调试端口和半主机功能，使得开发者可以通过调试端口或半主机进行调试信息的输入输出。

2. 主要功能模块
2.1 全局变量
FILE __stdout 和 FILE __stdin: 这两个全局变量用于标准输入输出的重定向。在嵌入式系统中，通常需要将标准输入输出重定向到调试端口或半主机。

2.2 寄存器转储函数
stackDump(uint32_t stack[]): 该函数用于在发生硬错误（Hard Fault）时，打印出寄存器的值（如 r0, r1, r2, r3, r12, lr, pc, psr），帮助开发者定位错误。

2.3 硬错误处理函数
Hard_Fault_Handler(uint32_t stack[]): 当发生硬错误时，该函数会被调用。它会调用 stackDump 函数打印寄存器值，并进入一个死循环（while(1)），等待开发者处理。

2.4 半主机支持
半主机（Semihosting）: 半主机是一种调试技术，允许嵌入式系统通过调试器与主机进行通信，例如打印调试信息到主机的控制台。

SH_DoCommand(int32_t n32In_R0, int32_t n32In_R1, int32_t *pn32Out_R0): 该函数用于处理半主机命令。通过 BKPT 指令触发调试器或硬错误，从而实现与主机的通信。

HardFault_Handler(void): 该函数是硬错误处理程序，支持半主机功能。它会根据堆栈指针（MSP或PSP）的不同，调用相应的处理函数。

2.5 调试端口输出函数
SendChar_ToUART(int ch): 该函数用于将字符发送到调试端口（通常是UART）。如果启用了非阻塞模式（NONBLOCK_PRINTF），则使用缓冲区来存储字符，以避免阻塞。

SendChar(int ch): 该函数根据是否启用了半主机功能，选择将字符发送到调试端口或通过半主机发送。

2.6 调试端口输入函数
GetChar(void): 该函数用于从调试端口或半主机获取一个字符。

kbhit(void): 该函数用于检查是否有字符输入。

IsDebugFifoEmpty(void): 该函数用于检查调试端口的FIFO是否为空。

2.7 C库重定向
_ttywrch(int ch): 该函数用于将字符写入调试端口。

fputc(int ch, FILE *stream): 该函数是C库的标准输出函数 fputc 的重定向实现，将字符发送到调试端口。

fgetc(FILE *stream): 该函数是C库的标准输入函数 fgetc 的重定向实现，从调试端口获取字符。

2.8 其他函数
_write(int fd, char *ptr, int len) 和 _read(int fd, char *ptr, int len): 这些函数是GNU工具链中的系统调用，用于实现标准输入输出的重定向。

__exit(int return_code) 和 _sys_exit(int return_code): 这些函数用于在程序退出时，确保所有调试信息都已输出。

3. 关键点
调试端口: 该文件通过UART或其他调试端口实现调试信息的输入输出。

半主机: 通过半主机功能，开发者可以在调试器中查看调试信息，而不需要实际的硬件调试端口。

硬错误处理: 当系统发生硬错误时，该文件提供了寄存器转储功能，帮助开发者定位错误。

4. 使用场景
调试信息输出: 在开发过程中，开发者可以通过 printf 函数将调试信息输出到调试端口或半主机。

错误处理: 当系统发生硬错误时，可以通过该文件提供的函数查看寄存器状态，帮助定位问题。

输入输出重定向: 在嵌入式系统中，标准输入输出通常需要重定向到调试端口或半主机，该文件提供了相应的实现。

回复 赏

举报

相关帖子
598330983 发表于 2025-2-15 10:47 | 显示全部楼层
我一直没搞明白arm和51的重定向函数怎么是不同的。
回复 赏

举报

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

本版积分规则

734774645

210

主题

3585

帖子

15

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

210

主题

3585

帖子

15

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