stm32f10x_usart.txt

STM32F103ZET6+UCOSII+UCGUI源码

000008  8a82              LDRH     r2,[r0,#0x14]
00000a  430a              ORRS     r2,r2,r1
00000c  8282              STRH     r2,[r0,#0x14]
;;;768    }
00000e  4770              BX       lr
;;;769    
                          ENDP


                          AREA ||i.USART_LINBreakDetectLengthConfig||, CODE, READONLY, ALIGN=1

                  USART_LINBreakDetectLengthConfig PROC
;;;521    *******************************************************************************/
;;;522    void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, u16 USART_LINBreakDetectLength)
000000  8a02              LDRH     r2,[r0,#0x10]
;;;523    {
;;;524      /* Check the parameters */
;;;525      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;526      assert_param(IS_USART_LIN_BREAK_DETECT_LENGTH(USART_LINBreakDetectLength));
;;;527      
;;;528      USARTx->CR2 &= CR2_LBDL_Mask;
000002  f0220220          BIC      r2,r2,#0x20
000006  8202              STRH     r2,[r0,#0x10]
;;;529      USARTx->CR2 |= USART_LINBreakDetectLength;  
000008  8a02              LDRH     r2,[r0,#0x10]
00000a  430a              ORRS     r2,r2,r1
00000c  8202              STRH     r2,[r0,#0x10]
;;;530    }
00000e  4770              BX       lr
;;;531    
                          ENDP


                          AREA ||i.USART_LINCmd||, CODE, READONLY, ALIGN=1

                  USART_LINCmd PROC
;;;542    *******************************************************************************/
;;;543    void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;544    {
;;;545      /* Check the parameters */
;;;546      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;547      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;548      
;;;549      if (NewState != DISABLE)
;;;550      {
;;;551        /* Enable the LIN mode by setting the LINEN bit in the CR2 register */
;;;552        USARTx->CR2 |= CR2_LINEN_Set;
000002  8a01              LDRH     r1,[r0,#0x10]
000004  d002              BEQ      |L16.12|
000006  f4414180          ORR      r1,r1,#0x4000
00000a  e001              B        |L16.16|
                  |L16.12|
;;;553      }
;;;554      else
;;;555      {
;;;556        /* Disable the LIN mode by clearing the LINEN bit in the CR2 register */
;;;557        USARTx->CR2 &= CR2_LINEN_Reset;
00000c  f4214180          BIC      r1,r1,#0x4000
                  |L16.16|
000010  8201              STRH     r1,[r0,#0x10]         ;552
;;;558      }
;;;559    }
000012  4770              BX       lr
;;;560    
                          ENDP


                          AREA ||i.USART_ReceiveData||, CODE, READONLY, ALIGN=1

                  USART_ReceiveData PROC
;;;589    *******************************************************************************/
;;;590    u16 USART_ReceiveData(USART_TypeDef* USARTx)
000000  8880              LDRH     r0,[r0,#4]
;;;591    {
;;;592      /* Check the parameters */
;;;593      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;594      
;;;595      /* Receive Data */
;;;596      return (u16)(USARTx->DR & (u16)0x01FF);
000002  f3c00008          UBFX     r0,r0,#0,#9
;;;597    }
000006  4770              BX       lr
;;;598    
                          ENDP


                          AREA ||i.USART_ReceiverWakeUpCmd||, CODE, READONLY, ALIGN=1

                  USART_ReceiverWakeUpCmd PROC
;;;489    *******************************************************************************/
;;;490    void USART_ReceiverWakeUpCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;491    {
;;;492      /* Check the parameters */
;;;493      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;494      assert_param(IS_FUNCTIONAL_STATE(NewState)); 
;;;495      
;;;496      if (NewState != DISABLE)
;;;497      {
;;;498        /* Enable the USART mute mode  by setting the RWU bit in the CR1 register */
;;;499        USARTx->CR1 |= CR1_RWU_Set;
000002  8981              LDRH     r1,[r0,#0xc]
000004  d002              BEQ      |L18.12|
000006  f0410102          ORR      r1,r1,#2
00000a  e001              B        |L18.16|
                  |L18.12|
;;;500      }
;;;501      else
;;;502      {
;;;503        /* Disable the USART mute mode by clearing the RWU bit in the CR1 register */
;;;504        USARTx->CR1 &= CR1_RWU_Reset;
00000c  f0210102          BIC      r1,r1,#2
                  |L18.16|
000010  8181              STRH     r1,[r0,#0xc]          ;499
;;;505      }
;;;506    }
000012  4770              BX       lr
;;;507    
                          ENDP


                          AREA ||i.USART_SendBreak||, CODE, READONLY, ALIGN=1

                  USART_SendBreak PROC
;;;607    *******************************************************************************/
;;;608    void USART_SendBreak(USART_TypeDef* USARTx)
000000  8981              LDRH     r1,[r0,#0xc]
;;;609    {
;;;610      /* Check the parameters */
;;;611      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;612      
;;;613      /* Send break characters */
;;;614      USARTx->CR1 |= CR1_SBK_Set;
000002  f0410101          ORR      r1,r1,#1
000006  8181              STRH     r1,[r0,#0xc]
;;;615    }
000008  4770              BX       lr
;;;616    
                          ENDP


                          AREA ||i.USART_SendData||, CODE, READONLY, ALIGN=1

                  USART_SendData PROC
;;;570    *******************************************************************************/
;;;571    void USART_SendData(USART_TypeDef* USARTx, u16 Data)
000000  f3c10108          UBFX     r1,r1,#0,#9
;;;572    {
;;;573      /* Check the parameters */
;;;574      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;575      assert_param(IS_USART_DATA(Data)); 
;;;576        
;;;577      /* Transmit Data */
;;;578      USARTx->DR = (Data & (u16)0x01FF);
000004  8081              STRH     r1,[r0,#4]
;;;579    }
000006  4770              BX       lr
;;;580    
                          ENDP


                          AREA ||i.USART_SetAddress||, CODE, READONLY, ALIGN=1

                  USART_SetAddress PROC
;;;443    *******************************************************************************/
;;;444    void USART_SetAddress(USART_TypeDef* USARTx, u8 USART_Address)
000000  8a02              LDRH     r2,[r0,#0x10]
;;;445    {
;;;446      /* Check the parameters */
;;;447      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;448      assert_param(IS_USART_ADDRESS(USART_Address)); 
;;;449        
;;;450      /* Clear the USART address */
;;;451      USARTx->CR2 &= CR2_Address_Mask;
000002  f022020f          BIC      r2,r2,#0xf
000006  8202              STRH     r2,[r0,#0x10]
;;;452      /* Set the USART address node */
;;;453      USARTx->CR2 |= USART_Address;
000008  8a02              LDRH     r2,[r0,#0x10]
00000a  430a              ORRS     r2,r2,r1
00000c  8202              STRH     r2,[r0,#0x10]
;;;454    }
00000e  4770              BX       lr
;;;455    
                          ENDP


                          AREA ||i.USART_SetGuardTime||, CODE, READONLY, ALIGN=1

                  USART_SetGuardTime PROC
;;;626    *******************************************************************************/
;;;627    void USART_SetGuardTime(USART_TypeDef* USARTx, u8 USART_GuardTime)
000000  8b02              LDRH     r2,[r0,#0x18]
;;;628    {    
;;;629      /* Check the parameters */
;;;630      assert_param(IS_USART_123_PERIPH(USARTx));
;;;631      
;;;632      /* Clear the USART Guard time */
;;;633      USARTx->GTPR &= GTPR_LSB_Mask;
000002  b2d2              UXTB     r2,r2
000004  8302              STRH     r2,[r0,#0x18]
;;;634      /* Set the USART guard time */
;;;635      USARTx->GTPR |= (u16)((u16)USART_GuardTime << 0x08);
000006  8b02              LDRH     r2,[r0,#0x18]
000008  ea422101          ORR      r1,r2,r1,LSL #8
00000c  8301              STRH     r1,[r0,#0x18]
;;;636    }
00000e  4770              BX       lr
;;;637    
                          ENDP


                          AREA ||i.USART_SetPrescaler||, CODE, READONLY, ALIGN=1

                  USART_SetPrescaler PROC
;;;648    *******************************************************************************/
;;;649    void USART_SetPrescaler(USART_TypeDef* USARTx, u8 USART_Prescaler)
000000  8b02              LDRH     r2,[r0,#0x18]
;;;650    { 
;;;651      /* Check the parameters */
;;;652      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;653      
;;;654      /* Clear the USART prescaler */
;;;655      USARTx->GTPR &= GTPR_MSB_Mask;
000002  f402427f          AND      r2,r2,#0xff00
000006  8302              STRH     r2,[r0,#0x18]
;;;656      /* Set the USART prescaler */
;;;657      USARTx->GTPR |= USART_Prescaler;
000008  8b02              LDRH     r2,[r0,#0x18]
00000a  430a              ORRS     r2,r2,r1
00000c  8302              STRH     r2,[r0,#0x18]
;;;658    }
00000e  4770              BX       lr
;;;659    
                          ENDP


                          AREA ||i.USART_SmartCardCmd||, CODE, READONLY, ALIGN=1

                  USART_SmartCardCmd PROC
;;;670    *******************************************************************************/
;;;671    void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;672    {
;;;673      /* Check the parameters */
;;;674      assert_param(IS_USART_123_PERIPH(USARTx));
;;;675      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;676    
;;;677      if (NewState != DISABLE)
;;;678      {
;;;679        /* Enable the SC mode by setting the SCEN bit in the CR3 register */
;;;680        USARTx->CR3 |= CR3_SCEN_Set;
000002  8a81              LDRH     r1,[r0,#0x14]
000004  d002              BEQ      |L24.12|
000006  f0410120          ORR      r1,r1,#0x20
00000a  e001              B        |L24.16|
                  |L24.12|
;;;681      }
;;;682      else
;;;683      {
;;;684        /* Disable the SC mode by clearing the SCEN bit in the CR3 register */
;;;685        USARTx->CR3 &= CR3_SCEN_Reset;
00000c  f0210120          BIC      r1,r1,#0x20
                  |L24.16|
000010  8281              STRH     r1,[r0,#0x14]         ;680
;;;686      }
;;;687    }
000012  4770              BX       lr
;;;688    
                          ENDP


                          AREA ||i.USART_SmartCardNACKCmd||, CODE, READONLY, ALIGN=1

                  USART_SmartCardNACKCmd PROC
;;;699    *******************************************************************************/
;;;700    void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;701    {
;;;702      /* Check the parameters */
;;;703      assert_param(IS_USART_123_PERIPH(USARTx));  
;;;704      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;705    
;;;706      if (NewState != DISABLE)
;;;707      {
;;;708        /* Enable the NACK transmission by setting the NACK bit in the CR3 register */
;;;709        USARTx->CR3 |= CR3_NACK_Set;
000002  8a81              LDRH     r1,[r0,#0x14]
000004  d002              BEQ      |L25.12|
000006  f0410110          ORR      r1,r1,#0x10
00000a  e001              B        |L25.16|
                  |L25.12|
;;;710      }
;;;711      else
;;;712      {
;;;713        /* Disable the NACK transmission by clearing the NACK bit in the CR3 register */
;;;714        USARTx->CR3 &= CR3_NACK_Reset;
00000c  f0210110          BIC      r1,r1,#0x10
                  |L25.16|
000010  8281              STRH     r1,[r0,#0x14]         ;709
;;;715      }
;;;716    }
000012  4770              BX       lr
;;;717    
                          ENDP


                          AREA ||i.USART_StructInit||, CODE, READONLY, ALIGN=1

                  USART_StructInit PROC
;;;231    *******************************************************************************/
;;;232    void USART_StructInit(USART_InitTypeDef* USART_InitStruct)
000000  f44f5116          MOV      r1,#0x2580
;;;233    {
;;;234      /* USART_InitStruct members default value */
;;;235      USART_InitStruct->USART_BaudRate = 9600;
;;;236      USART_InitStruct->USART_WordLength = USART_WordLength_8b;
000004  6001              STR      r1,[r0,#0]
000006  2100              MOVS     r1,#0
000008  8081              STRH     r1,[r0,#4]
;;;237      USART_InitStruct->USART_StopBits = USART_StopBits_1;
00000a  80c1              STRH     r1,[r0,#6]
;;;238      USART_InitStruct->USART_Parity = USART_Parity_No ;
00000c  8101              STRH     r1,[r0,#8]
;;;239      USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
00000e  220c              MOVS     r2,#0xc
000010  8142              STRH     r2,[r0,#0xa]
;;;240      USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
000012  8181              STRH     r1,[r0,#0xc]
;;;241    }
000014  4770              BX       lr
;;;242    
                          ENDP


                          AREA ||i.USART_WakeUpConfig||, CODE, READONLY, ALIGN=1

                  USART_WakeUpConfig PROC
;;;468    *******************************************************************************/
;;;469    void USART_WakeUpConfig(USART_TypeDef* USARTx, u16 USART_WakeUp)
000000  8982              LDRH     r2,[r0,#0xc]
;;;470    {
;;;471      /* Check the parameters */
;;;472      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;473      assert_param(IS_USART_WAKEUP(USART_WakeUp));
;;;474      
;;;475      USARTx->CR1 &= CR1_WAKE_Mask;
000002  f4226200          BIC      r2,r2,#0x800
000006  8182              STRH     r2,[r0,#0xc]
;;;476      USARTx->CR1 |= USART_WakeUp;
000008  8982              LDRH     r2,[r0,#0xc]
00000a  430a              ORRS     r2,r2,r1
00000c  8182              STRH     r2,[r0,#0xc]
;;;477    }
00000e  4770              BX       lr
;;;478    
                          ENDP