21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › STM8S 串口应用 UART2 STM8S105
返回列表 发新帖我要提问

[应用相关] STM8S 串口应用 UART2 STM8S105

[复制链接]
13538|1
 楼主| grfqq325 发表于 2021-6-22 23:29 | 显示全部楼层 |阅读模式
ar, UART2, 串口, STM8S105, pi, IO
复制

  1. 

  2. //使用MCU stm8s105c6  UART2
    

  3.  
    

  4. //初始化时调用：
    

  5.   GPIO_DeInit(GPIOD);
    

  6.   /* Configure PD5/6  */
    

  7.   GPIO_Init(GPIOD, GPIO_PIN_5, GPIO_MODE_IN_PU_NO_IT);//发送数据IO
    

  8.   GPIO_Init(GPIOD, GPIO_PIN_6, GPIO_MODE_IN_FL_NO_IT);//接受数据IO
    

  9.   UART2_DeInit();
    

  10.  UART2_Init(2400,UART2_WORDLENGTH_8D,UART2_STOPBITS_1,UART2_PARITY_NO,\
    

  11.             UART2_SYNCMODE_CLOCK_DISABLE,\
    

  12.       UART2_MODE_TX_ENABLE|UART2_MODE_RX_ENABLE);  //波特率 2400 8位数据  
    

  13.  
    

  14. //1个停止位  没有奇偶校验 关闭SCK 允许串口接受和发送
    

  15.   UART2_Cmd(ENABLE);//启用串口
    

  16.   UART2_ITConfig(UART2_IT_RXNE_OR,ENABLE);//允许接受中断
    

  17.  
    

  18.  
    

  19. //操作串口（发送接受数据）时调用：
    

  20.  
    

  21.  
    

  22.  
    

  23.                 if(UART2_GetFlagStatus(UART2_FLAG_TC))
    

  24.                  {//当前没有在发数据，可以发数据
    

  25.                     UART2_SendData8(Uart2TexData); 
    

  26.                      UART2_ClearFlag(UART2_FLAG_TC);
    

  27.                  }
    

  28.  
    

  29.  
    

  30.     UART2_ClearITPendingBit(UART2_FLAG_RXNE);//清中断标志位
    

  31.     Uart2RecData = UART2_ReceiveData8();//接受中断数据//后面两句需要发在
    

  32.  
    

  33. 串口接受中断中
    


  34.


回复

收藏 举报

相关帖子
 楼主| grfqq325 发表于 2021-6-22 23:30 | 显示全部楼层
复制

  1. 

  2. void UART2_DeInit(void)
    

  3. {
    

  4.     u8 dummy = 0;
    

  5.     /*< Clear the Idle Line Detected bit in the status rerister by a read
    

  6.        to the UART2_SR register followed by a Read to the UART2_DR 
    

  7. register */
    

  8.     dummy = UART2->SR;
    

  9.     dummy = UART2->DR;
    

  10.  
    

  11.     UART2->BRR2 = UART2_BRR2_RESET_VALUE;  /*< Set UART2_BRR2 to reset 
    

  12. value 0x00 */
    

  13.     UART2->BRR1 = UART2_BRR1_RESET_VALUE;  /*< Set UART2_BRR1 to reset 
    

  14. value 0x00 */
    

  15.  
    

  16.     UART2->CR1 = UART2_CR1_RESET_VALUE; /*< Set UART2_CR1 to reset value 
    

  17. 0x00  */
    

  18.     UART2->CR2 = UART2_CR2_RESET_VALUE; /*< Set UART2_CR2 to reset value 
    

  19. 0x00  */
    

  20.     UART2->CR3 = UART2_CR3_RESET_VALUE;  /*< Set UART2_CR3 to reset value 
    

  21. 0x00  */
    

  22.     UART2->CR4 = UART2_CR4_RESET_VALUE;  /*< Set UART2_CR4 to reset value 
    

  23. 0x00  */
    

  24.     UART2->CR5 = UART2_CR5_RESET_VALUE; /*< Set UART2_CR5 to reset value 
    

  25. 0x00  */
    

  26.     UART2->CR6 = UART2_CR6_RESET_VALUE; /*< Set UART2_CR6 to reset value 
    

  27. 0x00  */
    

  28.  
    

  29. }
    

  30. void UART2_Init(u32 BaudRate, UART2_WordLength_TypeDef WordLength, 
    

  31. UART2_StopBits_TypeDef StopBits, UART2_Parity_TypeDef Parity, 
    

  32. UART2_SyncMode_TypeDef SyncMode, UART2_Mode_TypeDef Mode)
    

  33. {
    

  34.     u8 BRR2_1, BRR2_2 = 0;
    

  35.     u32 BaudRate_Mantissa, BaudRate_Mantissa100 = 0;
    

  36.  
    

  37.     /* assert_param: BaudRate value should be <= 625000 bps */
    

  38.     assert_param(IS_UART2_BAUDRATE_OK(BaudRate));
    

  39.  
    

  40.     assert_param(IS_UART2_WORDLENGTH_OK(WordLength));
    

  41.  
    

  42.     assert_param(IS_UART2_STOPBITS_OK(StopBits));
    

  43.  
    

  44.     assert_param(IS_UART2_PARITY_OK(Parity));
    

  45.  
    

  46.     /* assert_param: UART2_Mode value should exclude values such as  
    

  47. UART2_ModeTx_Enable|UART2_ModeTx_Disable */
    

  48.     assert_param(IS_UART2_MODE_OK((u8)Mode));
    

  49.  
    

  50.     /* assert_param: UART2_SyncMode value should exclude values such as
    

  51.        UART2_CLOCK_ENABLE|UART2_CLOCK_DISABLE */
    

  52.     assert_param(IS_UART2_SYNCMODE_OK((u8)SyncMode));
    

  53.  
    

  54.     UART2->CR1 &= (u8)(~UART2_CR1_M);  /**< Clear the word length bit */
    

  55.     UART2->CR1 |= (u8)WordLength; /**< Set the word length bit according 
    

  56. to UART2_WordLength value */
    

  57.  
    

  58.     UART2->CR3 &= (u8)(~UART2_CR3_STOP);  /**< Clear the STOP bits */
    

  59.     UART2->CR3 |= (u8)StopBits;  /**< Set the STOP bits number according 
    

  60. to UART2_StopBits value  */
    

  61.  
    

  62.     UART2->CR1 &= (u8)(~(UART2_CR1_PCEN | UART2_CR1_PS  ));  /**< Clear 
    

  63. the Parity Control bit */
    

  64.     UART2->CR1 |= (u8)Parity;  /**< Set the Parity Control bit to 
    

  65. UART2_Parity value */
    

  66.  
    

  67.     UART2->BRR1 &= (u8)(~UART2_BRR1_DIVM);  /**< Clear the LSB mantissa 
    

  68. of UARTDIV  */
    

  69.     UART2->BRR2 &= (u8)(~UART2_BRR2_DIVM);  /**< Clear the MSB mantissa 
    

  70. of UARTDIV  */
    

  71.     UART2->BRR2 &= (u8)(~UART2_BRR2_DIVF);  /**< Clear the Fraction bits 
    

  72. of UARTDIV */
    

  73.  
    

  74.     /**< Set the UART2 BaudRates in BRR1 and BRR2 registers according to 
    

  75. UART2_BaudRate value */
    

  76.     BaudRate_Mantissa    = ((u32)CLK_GetClockFreq() / (BaudRate << 4));
    

  77.     BaudRate_Mantissa100 = (((u32)CLK_GetClockFreq() * 100) / (BaudRate 
    

  78.  
    

  79. << 4));
    

  80.     /**< The fraction and MSB mantissa should be loaded in one step in 
    

  81. the BRR2 register*/
    

  82.     BRR2_1 = (u8)((u8)(((BaudRate_Mantissa100 - (BaudRate_Mantissa * 
    

  83.  
    

  84. 100))
    

  85.                         << 4) / 100) & (u8)0x0F); /**< Set the fraction 
    

  86. of UARTDIV  */
    

  87.     BRR2_2 = (u8)((BaudRate_Mantissa >> 4) & (u8)0xF0);
    

  88.  
    

  89.     UART2->BRR2 = (u8)(BRR2_1 | BRR2_2);
    

  90.     UART2->BRR1 = (u8)BaudRate_Mantissa;           /**< Set the LSB 
    

  91. mantissa of UARTDIV  */
    

  92.  
    

  93.     UART2->CR2 &= (u8)~(UART2_CR2_TEN | UART2_CR2_REN); /**< Disable the 
    

  94. Transmitter and Receiver before seting the LBCL, CPOL and CPHA bits */
    

  95.     UART2->CR3 &= (u8)~(UART2_CR3_CPOL | UART2_CR3_CPHA | 
    

  96.  
    

  97. UART2_CR3_LBCL); /**< Clear the Clock Polarity, lock Phase, Last Bit 
    

  98. Clock pulse */
    

  99.     UART2->CR3 |= (u8)((u8)SyncMode & (u8)(UART2_CR3_CPOL | 
    

  100.  
    

  101. UART2_CR3_CPHA | UART2_CR3_LBCL));  /**< Set the Clock Polarity, lock 
    

  102. Phase, Last Bit Clock pulse */
    

  103.  
    

  104.     if ((u8)Mode & (u8)UART2_MODE_TX_ENABLE)
    

  105.     {
    

  106.         UART2->CR2 |= (u8)UART2_CR2_TEN;  /**< Set the Transmitter Enable 
    

  107. bit */
    

  108.     }
    

  109.     else
    

  110.     {
    

  111.         UART2->CR2 &= (u8)(~UART2_CR2_TEN);  /**< Clear the Transmitter 
    

  112. Disable bit */
    

  113.     }
    

  114.     if ((u8)Mode & (u8)UART2_MODE_RX_ENABLE)
    

  115.     {
    

  116.         UART2->CR2 |= (u8)UART2_CR2_REN;  /**< Set the Receiver Enable 
    

  117. bit */
    

  118.     }
    

  119.     else
    

  120.     {
    

  121.         UART2->CR2 &= (u8)(~UART2_CR2_REN);  /**< Clear the Receiver 
    

  122. Disable bit */
    

  123.     }
    

  124.     /**< Set the Clock Enable bit, lock Polarity, lock Phase and Last Bit 
    

  125. Clock pulse bits according to UART2_Mode value */
    

  126.     if ((u8)SyncMode&(u8)UART2_SYNCMODE_CLOCK_DISABLE)
    

  127.     {
    

  128.         UART2->CR3 &= (u8)(~UART2_CR3_CKEN); /**< Clear the Clock Enable 
    

  129. bit */
    

  130.         /**< configure in Push Pull or Open Drain mode the Tx I/O line by 
    

  131. setting the correct I/O Port register according the product package and 
    

  132. line configuration*/
    

  133.     }
    

  134.     else
    

  135.     {
    

  136.         UART2->CR3 |= (u8)((u8)SyncMode & UART2_CR3_CKEN);
    

  137.     }
    

  138. }
    

  139.  
    

  140. void UART2_Cmd(FunctionalState NewState)
    

  141. {
    

  142.  
    

  143.     if (NewState != DISABLE)
    

  144.     {
    

  145.         UART2->CR1 &= (u8)(~UART2_CR1_UARTD); /**< UART2 Enable */
    

  146.     }
    

  147.     else
    

  148.     {
    

  149.         UART2->CR1 |= UART2_CR1_UARTD;  /**< UART2 Disable (for low power 
    

  150. consumption) */
    

  151.     }
    

  152. }
    

  153.  
    

  154. void UART2_ITConfig(UART2_IT_TypeDef UART2_IT, FunctionalState NewState)
    

  155. {
    

  156.     u8 uartreg, itpos = 0x00;
    

  157.     assert_param(IS_UART2_CONFIG_IT_OK(UART2_IT));
    

  158.     assert_param(IS_FUNCTIONALSTATE_OK(NewState));
    

  159.  
    

  160.     /* Get the UART2 register index */
    

  161.     uartreg = (u8)(UART2_IT >> 0x08);
    

  162.  
    

  163.     /* Get the UART2 IT index */
    

  164.     itpos = (u8)((u8)1 << (u8)((u8)UART2_IT & (u8)0x0F));
    

  165.  
    

  166.     if (NewState != DISABLE)
    

  167.     {
    

  168.         /**< Enable the Interrupt bits according to UART2_IT mask */
    

  169.         if (uartreg == 0x01)
    

  170.         {
    

  171.             UART2->CR1 |= itpos;
    

  172.         }
    

  173.         else if (uartreg == 0x02)
    

  174.         {
    

  175.             UART2->CR2 |= itpos;
    

  176.         }
    

  177.         else if (uartreg == 0x03)
    

  178.         {
    

  179.             UART2->CR4 |= itpos;
    

  180.         }
    

  181.         else
    

  182.         {
    

  183.             UART2->CR6 |= itpos;
    

  184.         }
    

  185.     }
    

  186.     else
    

  187.     {
    

  188.         /**< Disable the interrupt bits according to UART2_IT mask */
    

  189.         if (uartreg == 0x01)
    

  190.         {
    

  191.             UART2->CR1 &= (u8)(~itpos);
    

  192.         }
    

  193.         else if (uartreg == 0x02)
    

  194.         {
    

  195.             UART2->CR2 &= (u8)(~itpos);
    

  196.         }
    

  197.         else if (uartreg == 0x03)
    

  198.         {
    

  199.             UART2->CR4 &= (u8)(~itpos);
    

  200.         }
    

  201.         else
    

  202.         {
    

  203.             UART2->CR6 &= (u8)(~itpos);
    

  204.         }
    

  205.     }
    

  206. }
    

  207.  
    

  208. u8 UART2_ReceiveData8(void)
    

  209. {
    

  210.     return ((u8)UART2->DR);
    

  211. }
    

  212.  
    

  213. void UART2_SendData8(u8 Data)
    

  214. {
    

  215.     /* Transmit Data */
    

  216.     UART2->DR = Data;
    

  217. }
    

  218.  
    

  219. FlagStatus UART2_GetFlagStatus(UART2_Flag_TypeDef UART2_FLAG)
    

  220. {
    

  221.     FlagStatus status = RESET;
    

  222.  
    

  223.     /* Check parameters */
    

  224.     assert_param(IS_UART2_FLAG_OK(UART2_FLAG));
    

  225.  
    

  226.     /* Check the status of the specified UART2 flag*/
    

  227.     if (UART2_FLAG == UART2_FLAG_LBDF)
    

  228.     {
    

  229.         if ((UART2->CR4 & (u8)UART2_FLAG) != (u8)0x00)
    

  230.         {
    

  231.             /* UART2_FLAG is set*/
    

  232.             status = SET;
    

  233.         }
    

  234.         else
    

  235.         {
    

  236.             /* UART2_FLAG is reset*/
    

  237.             status = RESET;
    

  238.         }
    

  239.     }
    

  240.     else if (UART2_FLAG == UART2_FLAG_SBK)
    

  241.     {
    

  242.         if ((UART2->CR2 & (u8)UART2_FLAG) != (u8)0x00)
    

  243.         {
    

  244.             /* UART2_FLAG is set*/
    

  245.             status = SET;
    

  246.         }
    

  247.         else
    

  248.         {
    

  249.             /* UART2_FLAG is reset*/
    

  250.             status = RESET;
    

  251.         }
    

  252.     }
    

  253.     else if ((UART2_FLAG == UART2_FLAG_LHDF) || (UART2_FLAG == 
    

  254.  
    

  255. UART2_FLAG_LSF))
    

  256.     {
    

  257.         if ((UART2->CR6 & (u8)UART2_FLAG) != (u8)0x00)
    

  258.         {
    

  259.             /* UART2_FLAG is set*/
    

  260.             status = SET;
    

  261.         }
    

  262.         else
    

  263.         {
    

  264.             /* UART2_FLAG is reset*/
    

  265.             status = RESET;
    

  266.         }
    

  267.     }
    

  268.     else
    

  269.     {
    

  270.         if ((UART2->SR & (u8)UART2_FLAG) != (u8)0x00)
    

  271.         {
    

  272.             /* UART2_FLAG is set*/
    

  273.             status = SET;
    

  274.         }
    

  275.         else
    

  276.         {
    

  277.             /* UART2_FLAG is reset*/
    

  278.             status = RESET;
    

  279.         }
    

  280.     }
    

  281.  
    

  282.     /* Return the UART2_FLAG status*/
    

  283.     return  status;
    

  284. }
    

  285.  
    

  286. void UART2_ClearFlag(UART2_Flag_TypeDef UART2_FLAG)
    

  287. {
    

  288.     assert_param(IS_UART2_CLEAR_FLAG_OK(UART2_FLAG));
    

  289.  
    

  290.     /*< Clear the Receive Register Not Empty flag */
    

  291.     if (UART2_FLAG == UART2_FLAG_RXNE)
    

  292.     {
    

  293.         UART2->SR = (u8)~(UART2_SR_RXNE);
    

  294.     }
    

  295.     /*< Clear the LIN Break Detection flag */
    

  296.     else if (UART2_FLAG == UART2_FLAG_LBDF)
    

  297.     {
    

  298.         UART2->CR4 &= (u8)(~UART2_CR4_LBDF);
    

  299.     }
    

  300.     /*< Clear the LIN Header Detection Flag */
    

  301.     else if (UART2_FLAG == UART2_FLAG_LHDF)
    

  302.     {
    

  303.         UART2->CR6 &= (u8)(~UART2_CR6_LHDF);
    

  304.     }
    

  305.     /*< Clear the LIN Synch Field flag */
    

  306.     else
    

  307.     {
    

  308.         UART2->CR6 &= (u8)(~UART2_CR6_LSF);
    

  309.     }
    

  310.  
    

  311. }
回复

收藏 举报

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

本版积分规则

grfqq325

65

主题

687

帖子

4

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