PSoC4进不了串口中断

只看该作者 · 2015-6-25 08:42

/*******************************************************************************
      * Function Name: UART_1_EnableTxInt
      ********************************************************************************
      *
      * Summary:
      *  Enable TX interrupt generation
      *
      * Parameters:
      *  None.
      *
      * Return:
      *  None.
      *
      * Theory:
      *  Enable the interrupt output -or- the interrupt component itself
      *
      *******************************************************************************/
      void UART_1_EnableTxInt(void)
      {
         CyIntEnable(UART_1_TX_VECT_NUM);
      }

只看该作者 · 2015-6-25 08:43

/*******************************************************************************
      * Function Name: UART_1_DisableTxInt
      ********************************************************************************
      *
      * Summary:
      *  Disable TX interrupt generation
      *
      * Parameters:
      *  None.
      *
      * Return:
      *  None.
      *
      * Theory:
      *  Disable the interrupt output -or- the interrupt component itself
      *
      *******************************************************************************/
      void UART_1_DisableTxInt(void)
      {
         CyIntDisable(UART_1_TX_VECT_NUM);
      }

只看该作者 · 2015-6-25 08:43

/*******************************************************************************
* Function Name: UART_1_SetTxInterruptMode
********************************************************************************
*
* Summary:
*  Configure which status bits trigger an interrupt event
*
* Parameters:
*  intSrc: An or'd combination of the desired status bit masks (defined in
*       the header file)
*
* Return:
*  None.
*
* Theory:
*  Enables the output of specific status bits to the interrupt controller
*
*******************************************************************************/
void UART_1_SetTxInterruptMode(uint8 intSrc)
{
      UART_1_TXSTATUS_MASK_REG = intSrc;
}

只看该作者 · 2015-6-25 08:43

/*******************************************************************************
* Function Name: UART_1_WriteTxData
********************************************************************************
*
* Summary:
*  Write a byte of data to the Transmit FIFO or TX buffer to be sent when the
*  bus is available. WriteTxData sends a byte without checking for buffer room
*  or status. It is up to the user to separately check status.
*
* Parameters:
*  TXDataByte: byte of data to place in the transmit FIFO
*
* Return:
* void
*
* Global Variables:
*  UART_1_txBuffer - RAM buffer pointer for save data for transmission
*  UART_1_txBufferWrite - cyclic index for write to txBuffer,
* incremented after each byte saved to buffer.
*  UART_1_txBufferRead - cyclic index for read from txBuffer,
* checked to identify the condition to write to FIFO directly or to TX buffer
*  UART_1_initVar - checked to identify that the component has been
* initialized.
*
* Reentrant:
*  No.
*
*******************************************************************************/
void UART_1_WriteTxData(uint8 txDataByte)
{
      /* If not Initialized then skip this function*/
      if(UART_1_initVar != 0u)
      {
         #if(UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH)

            /* Disable Tx interrupt. */
            /* Protect variables that could change on interrupt. */
            #if(UART_1_TX_INTERRUPT_ENABLED)
                  UART_1_DisableTxInt();
            #endif /* End UART_1_TX_INTERRUPT_ENABLED */

            if( (UART_1_txBufferRead == UART_1_txBufferWrite) &&
                  ((UART_1_TXSTATUS_REG & UART_1_TX_STS_FIFO_FULL) == 0u) )
            {
                  /* Add directly to the FIFO. */
                  UART_1_TXDATA_REG = txDataByte;
            }
            else
            {
                  if(UART_1_txBufferWrite >= UART_1_TXBUFFERSIZE)
                  {
                     UART_1_txBufferWrite = 0u;
                  }

                  UART_1_txBuffer[UART_1_txBufferWrite] = txDataByte;

                  /* Add to the software buffer. */
                  UART_1_txBufferWrite++;

            }

            /* Enable Tx interrupt. */
            #if(UART_1_TX_INTERRUPT_ENABLED)
                  UART_1_EnableTxInt();
            #endif /* End UART_1_TX_INTERRUPT_ENABLED */

         #else /* UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH */

            /* Add directly to the FIFO. */
            UART_1_TXDATA_REG = txDataByte;

         #endif /* End UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH */
      }
}

只看该作者 · 2015-6-25 08:43

/*******************************************************************************
* Function Name: UART_1_ReadTxStatus
********************************************************************************
*
* Summary:
*  Read the status register for the component
*
* Parameters:
*  None.
*
* Return:
*  Contents of the status register
*
* Theory:
*  This function reads the status register which is clear on read. It is up to
*  the user to handle all bits in this return value accordingly, even if the bit
*  was not enabled as an interrupt source the event happened and must be handled
*  accordingly.
*
*******************************************************************************/
uint8 UART_1_ReadTxStatus(void)
{
      return(UART_1_TXSTATUS_REG);
}

只看该作者 · 2015-6-25 08:44

/*******************************************************************************
* Function Name: UART_1_ReadTxStatus
********************************************************************************
*
* Summary:
*  Read the status register for the component
*
* Parameters:
*  None.
*
* Return:
*  Contents of the status register
*
* Theory:
*  This function reads the status register which is clear on read. It is up to
*  the user to handle all bits in this return value accordingly, even if the bit
*  was not enabled as an interrupt source the event happened and must be handled
*  accordingly.
*
*******************************************************************************/
uint8 UART_1_ReadTxStatus(void)
{
      return(UART_1_TXSTATUS_REG);
}

只看该作者 · 2015-6-25 08:44

/*******************************************************************************
* Function Name: UART_1_PutString
********************************************************************************
*
* Summary:
*  Write a Sequence of bytes on the Transmit line. Data comes from RAM or ROM.
*
* Parameters:
*  string: char pointer to character string of Data to Send.
*
* Return:
*  None.
*
* Global Variables:
*  UART_1_initVar - checked to identify that the component has been
*    initialized.
*
* Reentrant:
*  No.
*
* Theory:
*  This function will block if there is not enough memory to place the whole
*  string, it will block until the entire string has been written to the
*  transmit buffer.
*
*******************************************************************************/
void UART_1_PutString(const char8 string[])
{
      uint16 buf_index = 0u;
      /* If not Initialized then skip this function*/
      if(UART_1_initVar != 0u)
      {
         /* This is a blocking function, it will not exit until all data is sent*/
         while(string[buf_index] != (char8)0)
         {
            UART_1_PutChar((uint8)string[buf_index]);
            buf_index++;
         }
      }
}

只看该作者 · 2015-6-25 09:41

/*******************************************************************************
* Function Name: UART_1_PutString
********************************************************************************
*
* Summary:
*  Write a Sequence of bytes on the Transmit line. Data comes from RAM or ROM.
*
* Parameters:
*  string: char pointer to character string of Data to Send.
*
* Return:
*  None.
*
* Global Variables:
*  UART_1_initVar - checked to identify that the component has been
*    initialized.
*
* Reentrant:
*  No.
*
* Theory:
*  This function will block if there is not enough memory to place the whole
*  string, it will block until the entire string has been written to the
*  transmit buffer.
*
*******************************************************************************/
void UART_1_PutString(const char8 string[])
{
      uint16 buf_index = 0u;
      /* If not Initialized then skip this function*/
      if(UART_1_initVar != 0u)
      {
         /* This is a blocking function, it will not exit until all data is sent*/
         while(string[buf_index] != (char8)0)
         {
            UART_1_PutChar((uint8)string[buf_index]);
            buf_index++;
         }
      }
}

只看该作者 · 2015-6-25 09:41

/*******************************************************************************
* Function Name: UART_1_PutArray
********************************************************************************
*
* Summary:
*  Write a Sequence of bytes on the Transmit line. Data comes from RAM or ROM.
*
* Parameters:
*  string: Address of the memory array residing in RAM or ROM.
*  byteCount: Number of Bytes to be transmitted.
*
* Return:
*  None.
*
* Global Variables:
*  UART_1_initVar - checked to identify that the component has been
*    initialized.
*
* Reentrant:
*  No.
*
*******************************************************************************/
void UART_1_PutArray(const uint8 string[], uint8 byteCount)

{
      uint8 buf_index = 0u;
      /* If not Initialized then skip this function*/
      if(UART_1_initVar != 0u)
      {
         do
         {
            UART_1_PutChar(string[buf_index]);
            buf_index++;
         }while(buf_index < byteCount);
      }
}

只看该作者 · 2015-6-25 09:41

/*******************************************************************************
* Function Name: UART_1_PutCRLF
********************************************************************************
*
* Summary:
*  Write a character and then carriage return and line feed.
*
* Parameters:
*  txDataByte: uint8 Character to send.
*
* Return:
*  None.
*
* Global Variables:
*  UART_1_initVar - checked to identify that the component has been
*    initialized.
*
* Reentrant:
*  No.
*
*******************************************************************************/
void UART_1_PutCRLF(uint8 txDataByte)
{
      /* If not Initialized then skip this function*/
      if(UART_1_initVar != 0u)
      {
         UART_1_PutChar(txDataByte);
         UART_1_PutChar(0x0Du);
         UART_1_PutChar(0x0Au);
      }
}

只看该作者 · 2015-6-25 09:42

/*******************************************************************************
* Function Name: UART_1_GetTxBufferSize
********************************************************************************
*
* Summary:
*  Determine the amount of space left in the TX buffer and return the count in
*  bytes
*
* Parameters:
*  None.
*
* Return:
*  Integer count of the number of bytes left in the TX buffer
*
* Global Variables:
*  UART_1_txBufferWrite - used to calculate left space.
*  UART_1_txBufferRead - used to calculate left space.
*
* Reentrant:
*  No.
*
* Theory:
*  Allows the user to find out how full the TX Buffer is.
*
*******************************************************************************/
uint8 UART_1_GetTxBufferSize(void)

{
      uint8 size;

      #if(UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH)

         /* Disable Tx interrupt. */
         /* Protect variables that could change on interrupt. */
         #if(UART_1_TX_INTERRUPT_ENABLED)
            UART_1_DisableTxInt();
         #endif /* End UART_1_TX_INTERRUPT_ENABLED */

         if(UART_1_txBufferRead == UART_1_txBufferWrite)
         {
            size = 0u;
         }
         else if(UART_1_txBufferRead < UART_1_txBufferWrite)
         {
            size = (UART_1_txBufferWrite - UART_1_txBufferRead);
         }
         else
         {
            size = (UART_1_TXBUFFERSIZE - UART_1_txBufferRead) + UART_1_txBufferWrite;
         }

         /* Enable Tx interrupt. */
         #if(UART_1_TX_INTERRUPT_ENABLED)
            UART_1_EnableTxInt();
         #endif /* End UART_1_TX_INTERRUPT_ENABLED */

      #else /* UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH */

         size = UART_1_TXSTATUS_REG;

         /* Is the fifo is full. */
         if((size & UART_1_TX_STS_FIFO_FULL) != 0u)
         {
            size = UART_1_FIFO_LENGTH;
         }
         else if((size & UART_1_TX_STS_FIFO_EMPTY) != 0u)
         {
            size = 0u;
         }
         else
         {
            /* We only know there is data in the fifo. */
            size = 1u;
         }

      #endif /* End UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH */

      return(size);
}

只看该作者 · 2015-6-25 09:42

/*******************************************************************************
* Function Name: UART_1_ClearTxBuffer
********************************************************************************
*
* Summary:
*  Clears the TX RAM buffer by setting the read and write pointers both to zero.
*  Clears the hardware TX FIFO.  Any data present in the FIFO will not be sent.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
* Global Variables:
*  UART_1_txBufferWrite - cleared to zero.
*  UART_1_txBufferRead - cleared to zero.
*
* Reentrant:
*  No.
*
* Theory:
*  Setting the pointers to zero makes the system believe there is no data to
*  read and writing will resume at address 0 overwriting any data that may have
*  remained in the RAM.
*
* Side Effects:
*  Any received data not read from the RAM buffer will be lost when overwritten.
*
*******************************************************************************/
void UART_1_ClearTxBuffer(void)
{
      uint8 enableInterrupts;

      /* Enter critical section */
      enableInterrupts = CyEnterCriticalSection();
      /* clear the HW FIFO */
      UART_1_TXDATA_AUX_CTL_REG |=  UART_1_TX_FIFO_CLR;
      UART_1_TXDATA_AUX_CTL_REG &= (uint8)~UART_1_TX_FIFO_CLR;
      /* Exit critical section */
      CyExitCriticalSection(enableInterrupts);

      #if(UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH)

         /* Disable Tx interrupt. */
         /* Protect variables that could change on interrupt. */
         #if(UART_1_TX_INTERRUPT_ENABLED)
            UART_1_DisableTxInt();
         #endif /* End UART_1_TX_INTERRUPT_ENABLED */

         UART_1_txBufferRead = 0u;
         UART_1_txBufferWrite = 0u;

         /* Enable Tx interrupt. */
         #if(UART_1_TX_INTERRUPT_ENABLED)
            UART_1_EnableTxInt();
         #endif /* End UART_1_TX_INTERRUPT_ENABLED */

      #endif /* End UART_1_TXBUFFERSIZE > UART_1_FIFO_LENGTH */
}

只看该作者 · 2015-6-25 09:42

/*******************************************************************************
* Function Name: UART_1_SendBreak
********************************************************************************
*
* Summary:
*  Write a Break command to the UART
*
* Parameters:
*  uint8 retMode:  Wait mode,
* 0 - Initialize registers for Break, sends the Break signal and return
*    imediately.
* 1 - Wait until Break sending is complete, reinitialize registers to normal
*    transmission mode then return.
* 2 - Reinitialize registers to normal transmission mode then return.
* 3 - both steps: 0 and 1
*    init registers for Break, send Break signal
*    wait until Break sending is complete, reinit registers to normal
*    transmission mode then return.
*
* Return:
*  None.
*
* Global Variables:
*  UART_1_initVar - checked to identify that the component has been
*    initialized.
*  tx_period - static variable, used for keeping TX period configuration.
*
* Reentrant:
*  No.
*
* Theory:
*  SendBreak function initializes registers to send 13-bit break signal. It is
*  important to return the registers configuration to normal for continue 8-bit
*  operation.
*  Trere are 3 variants for this API usage:
*  1) SendBreak(3) - function will send the Break signal and take care on the
*    configuration returning. Funcition will block CPU untill transmition
*    complete.
*  2) User may want to use bloking time if UART configured to the low speed
*    operation
*    Emample for this case:
*    SendBreak(0);    - init Break signal transmition
*       Add your code here to use CPU time
*    SendBreak(1);    - complete Break operation
*  3) Same to 2) but user may want to init and use the interrupt for complete
*    break operation.
*    Example for this case:
*    Init TX interrupt whith "TX - On TX Complete" parameter
*    SendBreak(0);    - init Break signal transmition
*       Add your code here to use CPU time
*    When interrupt appear with UART_TX_STS_COMPLETE status:
*    SendBreak(2);    - complete Break operation
*
* Side Effects:
* Uses static variable to keep registers configuration.
*
*******************************************************************************/
void UART_1_SendBreak(uint8 retMode)
{

      /* If not Initialized then skip this function*/
      if(UART_1_initVar != 0u)
      {
         /*Set the Counter to 13-bits and transmit a 00 byte*/
         /*When that is done then reset the counter value back*/
         uint8 tmpStat;

         #if(UART_1_HD_ENABLED) /* Half Duplex mode*/

            if( (retMode == UART_1_SEND_BREAK) ||
                  (retMode == UART_1_SEND_WAIT_REINIT ) )
            {
                  /* CTRL_HD_SEND_BREAK - sends break bits in HD mode*/
                  UART_1_WriteControlRegister(UART_1_ReadControlRegister() |
                                                      UART_1_CTRL_HD_SEND_BREAK);
                  /* Send zeros*/
                  UART_1_TXDATA_REG = 0u;

                  do /*wait until transmit starts*/
                  {
                     tmpStat = UART_1_TXSTATUS_REG;
                  }while((tmpStat & UART_1_TX_STS_FIFO_EMPTY) != 0u);
            }

            if( (retMode == UART_1_WAIT_FOR_COMPLETE_REINIT) ||
                  (retMode == UART_1_SEND_WAIT_REINIT) )
            {
                  do /*wait until transmit complete*/
                  {
                     tmpStat = UART_1_TXSTATUS_REG;
                  }while(((uint8)~tmpStat & UART_1_TX_STS_COMPLETE) != 0u);
            }

            if( (retMode == UART_1_WAIT_FOR_COMPLETE_REINIT) ||
                  (retMode == UART_1_REINIT) ||
                  (retMode == UART_1_SEND_WAIT_REINIT) )
            {
                  UART_1_WriteControlRegister(UART_1_ReadControlRegister() &
                                                (uint8)~UART_1_CTRL_HD_SEND_BREAK);
            }

         #else /* UART_1_HD_ENABLED Full Duplex mode */

            static uint8 tx_period;

            if( (retMode == UART_1_SEND_BREAK) ||
                  (retMode == UART_1_SEND_WAIT_REINIT) )
            {
                  /* CTRL_HD_SEND_BREAK - skip to send parity bit at Break signal in Full Duplex mode*/
                  #if( (UART_1_PARITY_TYPE != UART_1__B_UART__NONE_REVB) || \
                                    (UART_1_PARITY_TYPE_SW != 0u) )
                     UART_1_WriteControlRegister(UART_1_ReadControlRegister() |
                                                            UART_1_CTRL_HD_SEND_BREAK);
                  #endif /* End UART_1_PARITY_TYPE != UART_1__B_UART__NONE_REVB  */

                  #if(UART_1_TXCLKGEN_DP)
                     tx_period = UART_1_TXBITCLKTX_COMPLETE_REG;
                     UART_1_TXBITCLKTX_COMPLETE_REG = UART_1_TXBITCTR_BREAKBITS;
                  #else
                     tx_period = UART_1_TXBITCTR_PERIOD_REG;
                     UART_1_TXBITCTR_PERIOD_REG = UART_1_TXBITCTR_BREAKBITS8X;
                  #endif /* End UART_1_TXCLKGEN_DP */

                  /* Send zeros*/
                  UART_1_TXDATA_REG = 0u;

                  do /* wait until transmit starts */
                  {
                     tmpStat = UART_1_TXSTATUS_REG;
                  }while((tmpStat & UART_1_TX_STS_FIFO_EMPTY) != 0u);
            }

            if( (retMode == UART_1_WAIT_FOR_COMPLETE_REINIT) ||
                  (retMode == UART_1_SEND_WAIT_REINIT) )
            {
                  do /*wait until transmit complete*/
                  {
                     tmpStat = UART_1_TXSTATUS_REG;
                  }while(((uint8)~tmpStat & UART_1_TX_STS_COMPLETE) != 0u);
            }

            if( (retMode == UART_1_WAIT_FOR_COMPLETE_REINIT) ||
                  (retMode == UART_1_REINIT) ||
                  (retMode == UART_1_SEND_WAIT_REINIT) )
            {

                  #if(UART_1_TXCLKGEN_DP)
                     UART_1_TXBITCLKTX_COMPLETE_REG = tx_period;
                  #else
                     UART_1_TXBITCTR_PERIOD_REG = tx_period;
                  #endif /* End UART_1_TXCLKGEN_DP */

                  #if( (UART_1_PARITY_TYPE != UART_1__B_UART__NONE_REVB) || \
                     (UART_1_PARITY_TYPE_SW != 0u) )
                     UART_1_WriteControlRegister(UART_1_ReadControlRegister() &
                                                   (uint8)~UART_1_CTRL_HD_SEND_BREAK);
                  #endif /* End UART_1_PARITY_TYPE != NONE */
            }
         #endif /* End UART_1_HD_ENABLED */
      }
}

只看该作者 · 2015-6-25 09:42

/*******************************************************************************
* Function Name: UART_1_SetTxAddressMode
********************************************************************************
*
* Summary:
*  Set the transmit addressing mode
*
* Parameters:
*  addressMode: 0 -> Space
*             1 -> Mark
*
* Return:
*  None.
*
*******************************************************************************/
void UART_1_SetTxAddressMode(uint8 addressMode)
{
      /* Mark/Space sending enable*/
      if(addressMode != 0u)
      {
         #if( UART_1_CONTROL_REG_REMOVED == 0u )
            UART_1_WriteControlRegister(UART_1_ReadControlRegister() |
                                                   UART_1_CTRL_MARK);
         #endif /* End UART_1_CONTROL_REG_REMOVED == 0u */
      }
      else
      {
         #if( UART_1_CONTROL_REG_REMOVED == 0u )
            UART_1_WriteControlRegister(UART_1_ReadControlRegister() &
                                                (uint8)~UART_1_CTRL_MARK);
         #endif /* End UART_1_CONTROL_REG_REMOVED == 0u */
      }
}

只看该作者 · 2015-6-25 09:43

/*******************************************************************************
* Function Name: UART_1_LoadTxConfig
********************************************************************************
*
* Summary:
*  Unloads the Rx configuration if required and loads the
*  Tx configuration. It is the users responsibility to ensure that any
*  transaction is complete and it is safe to unload the Tx
*  configuration.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
* Theory:
*  Valid only for half duplex UART.
*
* Side Effects:
*  Disable RX interrupt mask, when software buffer has been used.
*
*******************************************************************************/
void UART_1_LoadTxConfig(void)
{
      #if((UART_1_RX_INTERRUPT_ENABLED) && (UART_1_RXBUFFERSIZE > UART_1_FIFO_LENGTH))
         /* Disable RX interrupts before set TX configuration */
         UART_1_SetRxInterruptMode(0u);
      #endif /* UART_1_RX_INTERRUPT_ENABLED */

      UART_1_WriteControlRegister(UART_1_ReadControlRegister() | UART_1_CTRL_HD_SEND);
      UART_1_RXBITCTR_PERIOD_REG = UART_1_HD_TXBITCTR_INIT;
      #if(CY_UDB_V0) /* Manually clear status register when mode has been changed */
         /* Clear status register */
         CY_GET_REG8(UART_1_RXSTATUS_PTR);
      #endif /* CY_UDB_V0 */
}

/*******************************************************************************
* Function Name: UART_1_LoadRxConfig
********************************************************************************
*
* Summary:
*  Unloads the Tx configuration if required and loads the
*  Rx configuration. It is the users responsibility to ensure that any
*  transaction is complete and it is safe to unload the Rx
*  configuration.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
* Theory:
*  Valid only for half duplex UART
*
* Side Effects:
*  Set RX interrupt mask based on customizer settings, when software buffer
*  has been used.
*
*******************************************************************************/
void UART_1_LoadRxConfig(void)
{
      UART_1_WriteControlRegister(UART_1_ReadControlRegister() &
                                             (uint8)~UART_1_CTRL_HD_SEND);
      UART_1_RXBITCTR_PERIOD_REG = UART_1_HD_RXBITCTR_INIT;
      #if(CY_UDB_V0) /* Manually clear status register when mode has been changed */
         /* Clear status register */
         CY_GET_REG8(UART_1_RXSTATUS_PTR);
      #endif /* CY_UDB_V0 */

      #if((UART_1_RX_INTERRUPT_ENABLED) && (UART_1_RXBUFFERSIZE > UART_1_FIFO_LENGTH))
         /* Enable RX interrupt after set RX configuration */
         UART_1_SetRxInterruptMode(UART_1_INIT_RX_INTERRUPTS_MASK);
      #endif /* UART_1_RX_INTERRUPT_ENABLED */
}

只看该作者 · 2015-6-25 18:45

顶一下，表示也不会