stm8s_uart1.c

STM8全部资料

/**
  ********************************************************************************
  * @file stm8s_uart1.c
  * @brief This file contains all the functions for the UART1 peripheral.
  * @author STMicroelectronics - MCD Application Team
  * @version V1.0.1
  * @date 09/22/2008
  ******************************************************************************
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2008 STMicroelectronics</center></h2>
  * @image html logo.bmp
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "stm8s_uart1.h"
#include "stm8s_clk.h"

/* LINKER SECTIONS DEFINITION FOR THIS FILE ONLY */
#ifdef USE_COSMIC_SECTIONS
#pragma section (UART1_CODE)
#pragma section const {UART1_CONST}
#pragma section @near [UART1_URAM]
#pragma section @near {UART1_IRAM}
#pragma section @tiny [UART1_UZRAM]
#pragma section @tiny {UART1_IZRAM}
#endif

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/* Public functions ----------------------------------------------------------*/

/** @}
  * @addtogroup UART1_Public_Functions
  * @{
  */

/**
  * @brief Deinitializes the UART1 peripheral.
  * @par Full description:
  * Set the UART1 peripheral registers to their default reset values.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * Deinitialize UART1 peripheral.
  * @code
  * UART1_DeInit();
  * @endcode
  */
void UART1_DeInit(void)
{
  u8 dummy = 0;

  /*< Clear the Idle Line Detected bit in the status rerister by a read
     to the UART1_SR register followed by a Read to the UART1_DR register */
  dummy = UART1->SR;
  dummy = UART1->DR;

  UART1->BRR2 = UART1_BRR2_RESET_VALUE;  /*< Set UART1_BRR2 to reset value 0x00 */
  UART1->BRR1 = UART1_BRR1_RESET_VALUE;  /*< Set UART1_BRR1 to reset value 0x00 */

  UART1->CR1 = UART1_CR1_RESET_VALUE; /*< Set UART1_CR1 to reset value 0x00  */
  UART1->CR2 = UART1_CR2_RESET_VALUE; /*< Set UART1_CR2 to reset value 0x00  */
  UART1->CR3 = UART1_CR3_RESET_VALUE;  /*< Set UART1_CR3 to reset value 0x00  */
  UART1->CR4 = UART1_CR4_RESET_VALUE;  /*< Set UART1_CR4 to reset value 0x00  */
  UART1->CR5 = UART1_CR5_RESET_VALUE; /*< Set UART1_CR5 to reset value 0x00  */

  UART1->GTR = UART1_GTR_RESET_VALUE;
  UART1->PSCR = UART1_PSCR_RESET_VALUE;
}

/**
 * @brief Initializes the UART1 according to the specified parameters.
  * @param[in] BaudRate: The baudrate.
 * @param[in] WordLength : This parameter can be any of the @ref UART1_WordLength_TypeDef enumeration.
  * @param[in] StopBits: This parameter can be any of the @ref UART1_StopBits_TypeDef enumeration.
  * @param[in] Parity: This parameter can be any of the @ref UART1_Parity_TypeDef enumeration.
  * @param[in] SyncMode: This parameter can be any of the @ref UART1_SyncMode_TypeDef values.
  * @param[in] Mode: This parameter can be any of the @ref UART1_Mode_TypeDef values
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * - CLK_GetClockFreq().
  * @par Example:
  * @code
  * UART1_Init(9600, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE);
  * @endcode
  */
void UART1_Init(u32 BaudRate, UART1_WordLength_TypeDef WordLength, UART1_StopBits_TypeDef StopBits, UART1_Parity_TypeDef Parity, UART1_SyncMode_TypeDef SyncMode, UART1_Mode_TypeDef Mode)
{
  u32 BaudRate_Mantissa, BaudRate_Mantissa100 = 0;

  /* assert_param: BaudRate value should be <= 625000 bps */
  assert_param(IS_UART1_BAUDRATE_OK(BaudRate));

  assert_param(IS_UART1_WORDLENGTH_OK(WordLength));

  assert_param(IS_UART1_STOPBITS_OK(StopBits));

  assert_param(IS_UART1_PARITY_OK(Parity));

  /* assert_param: UART1_Mode value should exclude values such as  UART1_ModeTx_Enable|UART1_ModeTx_Disable */
  assert_param(IS_UART1_MODE_OK((u8)Mode));

  /* assert_param: UART1_SyncMode value should exclude values such as
     UART1_CLOCK_ENABLE|UART1_CLOCK_DISABLE */
  assert_param(IS_UART1_SYNCMODE_OK((u8)SyncMode));

  UART1->CR1 &= (u8)(~UART1_CR1_M);  /**< Clear the word length bit */
  UART1->CR1 |= (u8)WordLength; /**< Set the word length bit according to UART1_WordLength value */

  UART1->CR3 &= (u8)(~UART1_CR3_STOP);  /**< Clear the STOP bits */
  UART1->CR3 |= (u8)StopBits;  /**< Set the STOP bits number according to UART1_StopBits value  */

  UART1->CR1 &= (u8)(~(UART1_CR1_PCEN | UART1_CR1_PS  ));  /**< Clear the Parity Control bit */
  UART1->CR1 |= (u8)Parity;  /**< Set the Parity Control bit to UART1_Parity value */

  UART1->BRR1 &= (u8)(~UART1_BRR1_DIVM);  /**< Clear the LSB mantissa of UART1DIV  */
  UART1->BRR2 &= (u8)(~UART1_BRR2_DIVM);  /**< Clear the MSB mantissa of UART1DIV  */
  UART1->BRR2 &= (u8)(~UART1_BRR2_DIVF);  /**< Clear the Fraction bits of UART1DIV */

  /**< Set the UART1 BaudRates in BRR1 and BRR2 registers according to UART1_BaudRate value */
  BaudRate_Mantissa    = ((u32)CLK_GetClockFreq() / (BaudRate << 4));
  BaudRate_Mantissa100 = (((u32)CLK_GetClockFreq() * 100) / (BaudRate << 4));
  UART1->BRR2 |= (u8)((u8)(((BaudRate_Mantissa100 - (BaudRate_Mantissa * 100)) << 4) / 100) & (u8)0x0F); /**< Set the fraction of UART1DIV  */
  UART1->BRR2 |= (u8)((BaudRate_Mantissa >> 4) & (u8)0xF0); /**< Set the MSB mantissa of UART1DIV  */
  UART1->BRR1 |= (u8)BaudRate_Mantissa;           /**< Set the LSB mantissa of UART1DIV  */

  UART1->CR2 &= (u8)~(UART1_CR2_TEN | UART1_CR2_REN); /**< Disable the Transmitter and Receiver before seting the LBCL, CPOL and CPHA bits */
  UART1->CR3 &= (u8)~(UART1_CR3_CPOL | UART1_CR3_CPHA | UART1_CR3_LBCL); /**< Clear the Clock Polarity, lock Phase, Last Bit Clock pulse */
  UART1->CR3 |= (u8)((u8)SyncMode & (u8)(UART1_CR3_CPOL | UART1_CR3_CPHA | UART1_CR3_LBCL));  /**< Set the Clock Polarity, lock Phase, Last Bit Clock pulse */

  if ((u8)Mode & (u8)UART1_MODE_TX_ENABLE)
  {
    UART1->CR2 |= (u8)UART1_CR2_TEN;  /**< Set the Transmitter Enable bit */
  }
  else
  {
    UART1->CR2 &= (u8)(~UART1_CR2_TEN);  /**< Clear the Transmitter Disable bit */
  }
  if ((u8)Mode & (u8)UART1_MODE_RX_ENABLE)
  {
    UART1->CR2 |= (u8)UART1_CR2_REN;  /**< Set the Receiver Enable bit */
  }
  else
  {
    UART1->CR2 &= (u8)(~UART1_CR2_REN);  /**< Clear the Receiver Disable bit */
  }
  /**< Set the Clock Enable bit, lock Polarity, lock Phase and Last Bit Clock pulse bits according to UART1_Mode value */
  if ((u8)SyncMode&(u8)UART1_SYNCMODE_CLOCK_DISABLE)
  {
    UART1->CR3 &= (u8)(~UART1_CR3_CKEN); /**< Clear the Clock Enable bit */
    /**< configure in Push Pull or Open Drain mode the Tx I/O line by setting the correct I/O Port register according the product package and line configuration*/
  }
  else
  {
    UART1->CR3 |= (u8)((u8)SyncMode & UART1_CR3_CKEN);
  }
}

/**
  * @brief Enable the UART1 peripheral.
  * @par Full description:
  * Enable the UART1 peripheral.
  * @param[in] NewState new state of the UART1 Communication.
  * This parameter can be:
  * - ENABLE
  * - DISABLE
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * Enable UART1 peripheral.
  * @code
  * UART1_Cmd(ENABLE);
  * @endcode
  */
void UART1_Cmd(FunctionalState NewState)
{
  if (NewState != DISABLE)
  {
    UART1->CR1 &= (u8)(~UART1_CR1_UARTD); /**< UART1 Enable */
  }
  else
  {
    UART1->CR1 |= UART1_CR1_UARTD;  /**< UART1 Disable (for low power consumption) */
  }
}

/**
  * @brief Enables or disables the specified UART1 interrupts.
  * @par Full description:
  * Enables or disables the specified UART1 interrupts.
  * @param[in] UART1_IT specifies the UART1 interrupt sources to be enabled or disabled.
  * This parameter can be one of the following values:
  *   - UART1_IT_LBDF:  LIN Break detection interrupt
  *   - UART1_IT_TXE:  Tansmit Data Register empty interrupt
  *   - UART1_IT_TC:   Transmission complete interrupt
  *   - UART1_IT_RXNE_OR: Receive Data register not empty/Over run error interrupt
  *   - UART1_IT_IDLE: Idle line detection interrupt
  *   - UART1_IT_PE:   Parity Error interrupt
  * @param[in] NewState new state of the specified UART1 interrupts.
  * This parameter can be: ENABLE or DISABLE.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * UART1_ITConfig(UART1_IT_PE, ENABLE)
  * @endcode
  */
void UART1_ITConfig(UART1_IT_TypeDef UART1_IT, FunctionalState NewState)
{
  u8 uartreg, itpos = 0x00;
  assert_param(IS_UART1_CONFIG_IT_OK(UART1_IT));
  assert_param(IS_FUNCTIONALSTATE_OK(NewState));

  /* Get the UART1 register index */
  uartreg = (u8)(UART1_IT >> (u8)0x08);
  /* Get the UART1 IT index */
  itpos = (u8)((u8)1 << (u8)((u8)UART1_IT & (u8)0x0F));

  if (NewState != DISABLE)
  {
    /**< Enable the Interrupt bits according to UART1_IT mask */
    if (uartreg == 0x01)
    {
      UART1->CR1 |= itpos;
    }
    else if (uartreg == 0x02)
    {
      UART1->CR2 |= itpos;
    }
    else
    {
      UART1->CR4 |= itpos;
    }
  }
  else
  {
    /**< Disable the interrupt bits according to UART1_IT mask */
    if (uartreg == 0x01)
    {
      UART1->CR1 &= (u8)(~itpos);
    }
    else if (uartreg == 0x02)
    {
      UART1->CR2 &= (u8)(~itpos);
    }
    else
    {
      UART1->CR4 &= (u8)(~itpos);
    }
  }

}
/**
  * @brief Enables or disables the UART1抯 Half Duplex communication.
  * @par Full description:
  * Enables or disables the UART1抯 Half Duplex communication.
  * @param[in] NewState new state of the UART1 Communication.
  *                    This parameter can be: ENABLE or DISABLE.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * UART1_HalfDuplexCmd(ENABLE);
  * @endcode
  */
void UART1_HalfDuplexCmd(FunctionalState NewState)
{
  assert_param(IS_FUNCTIONALSTATE_OK(NewState));

  if (NewState != DISABLE)
  {
    UART1->CR5 |= UART1_CR5_HDSEL;  /**< UART1 Half Duplex Enable  */
  }
  else
  {
    UART1->CR5 &= (u8)~UART1_CR5_HDSEL; /**< UART1 Half Duplex Disable */
  }
}

/**
  * @brief Configures the UART1抯 IrDA interface.
  * @par Full description:
  * Configures the UART1抯 IrDA interface.
  * @par This function is valid only for UART1.
  * @param[in] UART1_IrDAMode specifies the IrDA mode.
  * This parameter can be any of the @ref UART1_IrDAMode_TypeDef values.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * UART1_IrDAConfig(UART1_IRDAMODE_LOWPOWER)
  * @endcode
  */
void UART1_IrDAConfig(UART1_IrDAMode_TypeDef UART1_IrDAMode)
{
  assert_param(IS_UART1_IRDAMODE_OK(UART1_IrDAMode));

  if (UART1_IrDAMode != UART1_IRDAMODE_NORMAL)
  {
    UART1->CR5 |= UART1_CR5_IRLP;
  }
  else
  {
    UART1->CR5 &= ((u8)~UART1_CR5_IRLP);
  }
}

/**
  * @brief Enables or disables the UART1抯 IrDA interface.
  * @par Full description:
  * Enables or disables the UART1抯 IrDA interface.
  * @par This function is related to IrDA mode.
  * @param[in] NewState new state of the IrDA mode.
  *                    This parameter can be: ENABLE or DISABLE.