5.21 USART 使用说明

    /* Configure USARTy 485 function */
    USART_CfgDriverAssertTime(USARTy, 0);
    USART_CfgDriverdeassertTime(USARTy, 0);
    USART_DriverPolaritySet(USARTy, DISABLE);
    USART_DriverModeSet(USARTy, ENABLE);
    /* Configure USARTz 485 function */
    USART_CfgDriverAssertTime(USARTz, 0);
    USART_CfgDriverdeassertTime(USARTz, 0);
    USART_DriverPolaritySet(USARTz, DISABLE);
    USART_DriverModeSet(USARTz, ENABLE);

    /* Enable USARTy DMA TX request */
    USART_EnableDMA(USARTy, USART_DMAREQ_TX, ENABLE);
    /* Enable USARTz DMA Rx request */
    USART_EnableDMA(USARTz, USART_DMAREQ_RX, ENABLE);

    /* USARTy_Tx_DMA_Channel (triggered by USARTy Tx event) Config */
    DMA_DeInit(USARTy_Tx_DMA_Channel);
    DMA_StructInit(&DMA_InitStructure);
    DMA_InitStructure.PeriphAddr     = USARTy_DAT_Base;
    DMA_InitStructure.MemAddr        = (uint32_t)TxBuffer1;
    DMA_InitStructure.Direction      = DMA_DIR_PERIPH_DST;
    DMA_InitStructure.BufSize        = TxBufferSize1;
    DMA_InitStructure.PeriphInc      = DMA_PERIPH_INC_DISABLE;
    DMA_InitStructure.DMA_MemoryInc  = DMA_MEM_INC_ENABLE;
    DMA_InitStructure.PeriphDataSize = DMA_PERIPH_DATA_SIZE_BYTE;
    DMA_InitStructure.MemDataSize    = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.CircularMode   = DMA_MODE_NORMAL;
    DMA_InitStructure.Priority       = DMA_PRIORITY_VERY_HIGH;
    DMA_InitStructure.Mem2Mem        = DMA_M2M_DISABLE;
    DMA_Init(USARTy_Tx_DMA_Channel, &DMA_InitStructure);
    DMA_RequestRemap(USARTy_Tx_DMA_REMAP, DMA, USARTy_Tx_DMA_Channel, ENABLE);

    /* Wait until USARTy TX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTy_Tx_DMA_FLAG, DMA) == RESET)
    {
    }

    /* Wait until USARTz RX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTz_Rx_DMA_FLAG, DMA) == RESET)
    {
    }

    TransferStatus2 = Buffercmp(TxBuffer1, RxBuffer2, TxBufferSize1);
    /* TransferStatus2 = PASSED, if the data transmitted from USARTy and
       received by USARTz are the same */
    /* TransferStatus2 = FAILED, if the data transmitted from USARTy and
       received by USARTz are different */

    /* RS485 Driver Enable configuration */
    USART_CfgDriverAssertTime(USARTz, 1);
    USART_CfgDriverdeassertTime(USARTz, 0);
    USART_DriverPolaritySet(USARTz, DISABLE);
    USART_DriverModeSet(USARTz, ENABLE);

    /* Enable USARTz Receive and Transmit interrupts */
    USART_ConfigInt(USARTz, USART_INT_TXDE, ENABLE);
    USART_ConfigInt(USARTz, USART_INT_RXDNE, ENABLE);

void USARTz_IRQHandler(void)
{
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_RXDNE) != RESET))
    {
        /* Read one byte from the receive data register */
        RxBuffer2[RxCounter2++] = USART_ReceiveData(USARTz);

        if (RxCounter2 == NbrOfDataToRead1)
        {
            /* Disable the USARTz Receive interrupt */
            USART_ConfigInt(USARTz, USART_INT_RXDNE, DISABLE);
        }
    }

    if ((USART_GetFlagStatus(USARTz, USART_FLAG_TXDE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_TXDE) != RESET))
    {
        /* Write one byte to the transmit data register */
        USART_SendData(USARTz, TxBuffer2[TxCounter2++]);

        if (TxCounter2 == NbrOfDataToTransfer2)
        {
            /* Disable the USARTz Transmit interrupt */
            USART_ConfigInt(USARTz, USART_INT_TXDE, DISABLE);
        }
    }

    /* Determine if an error flag still exists and clear the error flag */
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_OREF) != RESET) ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_NEF) != RESET) ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_PEF) != RESET) ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_FEF) != RESET))
    {
        /*Read the sts register first,and the read the DAT register to clear the all error flag*/
        (void)USARTz->STS;
        (void)USARTz->DAT;

    /* Wait until end of transmission from Slave */
    while (RxCounter2 < RxBufferSize2)
    {
    }

    TransferStatus2 = Buffercmp(TxBuffer2, RxBuffer2, TxBufferSize2);
    if (TransferStatus2 == PASSED)
    {
        log_info(" N32G41x 485 Master test OK \r\n");
    }
    else
    {
        log_info(" N32G41x 485 Master test Fail \r\n");
    }

    /* Enable USARTz Receive interrupt (Slave waits for data first) */
    USART_ConfigInt(USARTz, USART_INT_RXDNE, ENABLE);

    /* Enable the USARTz */
    USART_Enable(USARTz, ENABLE);
    log_info(" N32G41x 485 Slave test START, Press Master 485 to reset the pins \r\n");

    /* Wait until all data received from Master */
    while (RxCounter2 < RxBufferSize2)
    {
    }

    TransferStatus2 = Buffercmp(TxBuffer2, RxBuffer2, TxBufferSize2);
    if (TransferStatus2 == PASSED)
    {
        log_info(" N32G41x 485 Slave test OK \r\n");
    }
    else
    {
        log_info(" N32G41x 485 Slave test Fail \r\n");
    }

    /* Now echo data back: enable Transmit interrupt */
    USART_ConfigInt(USARTz, USART_INT_TXDE, ENABLE);

void USARTz_IRQHandler(void)
{
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_RXDNE) != RESET))
    {
        /* Read one byte from the receive data register */
        RxBuffer2[RxCounter2++] = USART_ReceiveData(USARTz);

        if (RxCounter2 == NbrOfDataToRead1)
        {
            /* Disable the USARTz Receive interrupt */
            USART_ConfigInt(USARTz, USART_INT_RXDNE, DISABLE);
        }
    }

    if ((USART_GetFlagStatus(USARTz, USART_FLAG_TXDE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_TXDE) != RESET))
    {
        /* Write one byte to the transmit data register */
        USART_SendData(USARTz, TxBuffer2[TxCounter2++]);

        if (TxCounter2 == NbrOfDataToTransfer2)
        {
            /* Disable the USARTz Transmit interrupt */
            USART_ConfigInt(USARTz, USART_INT_TXDE, DISABLE);
        }
    }

    /* RS485 Driver Enable configuration */
    USART_CfgDriverAssertTime(USARTz, 1);
    USART_CfgDriverdeassertTime(USARTz, 0);
    USART_DriverPolaritySet(USARTz, DISABLE);
    USART_DriverModeSet(USARTz, ENABLE);

    /* Enable USARTy DMA Rx and TX request */
    USART_EnableDMA(USARTy, USART_DMAREQ_TX, ENABLE);
    /* Enable USARTz DMA Rx and TX request */
    USART_EnableDMA(USARTz, USART_DMAREQ_TX, ENABLE);

    /* Enable the USARTz Receive Interrupt */
    USART_ConfigInt(USARTz, USART_INT_RXDNE, ENABLE);

    /* Enable USARTy TX DMA Channel */
    DMA_EnableChannel(USARTy_Tx_DMA_Channel, ENABLE);
    /* Enable USARTz TX DMA Channel */
    DMA_EnableChannel(USARTz_Tx_DMA_Channel, ENABLE);

    /* Receive the TxBuffer2 */
    while (indexFlag < TxBufferSize2)
    {
        while (USART_GetFlagStatus(USARTy, USART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(USART_GetFlagStatus(USARTy, USART_FLAG_OREF) != RESET)
            {
                USARTy->DAT;
            }
        }
        RxBuffer1[indexFlag++] = USART_ReceiveData(USARTy);
    }

    /* USARTy_Tx_DMA_Channel (triggered by USARTy Tx event) Config */
    DMA_DeInit(USARTy_Tx_DMA_Channel);
    DMA_StructInit(&DMA_InitStructure);
    DMA_InitStructure.PeriphAddr     = USARTy_DAT_Base;
    DMA_InitStructure.MemAddr        = (uint32_t)TxBuffer1;
    DMA_InitStructure.Direction      = DMA_DIR_PERIPH_DST;
    DMA_InitStructure.BufSize        = TxBufferSize1;
    DMA_InitStructure.PeriphInc      = DMA_PERIPH_INC_DISABLE;
    DMA_InitStructure.DMA_MemoryInc  = DMA_MEM_INC_ENABLE;
    DMA_InitStructure.PeriphDataSize = DMA_PERIPH_DATA_SIZE_BYTE;
    DMA_InitStructure.MemDataSize    = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.CircularMode   = DMA_MODE_NORMAL;
    DMA_InitStructure.Priority       = DMA_PRIORITY_VERY_HIGH;
    DMA_InitStructure.Mem2Mem        = DMA_M2M_DISABLE;
    DMA_Init(USARTy_Tx_DMA_Channel, &DMA_InitStructure);
    DMA_RequestRemap(USARTy_Tx_DMA_REMAP, DMA, USARTy_Tx_DMA_Channel, ENABLE);

    /* Wait until USARTy TX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTy_Tx_DMA_FLAG, DMA) == RESET)
    {
    }
    /* Wait until USARTz TX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTz_Tx_DMA_FLAG, DMA) == RESET)
    {
    }

    /* Check the received data with the send ones */
    TransferStatus1 = Buffercmp(TxBuffer2, RxBuffer1, TxBufferSize2);
    /* TransferStatus1 = PASSED, if the data transmitted from USARTz and
       received by USARTy are the same */
    /* TransferStatus1 = FAILED, if the data transmitted from USARTz and
       received by USARTy are different */
    TransferStatus2 = Buffercmp(TxBuffer1, RxBuffer2, TxBufferSize1);

    /* Enable USARTy DMA Rx and TX request */
    USART_EnableDMA(USARTy, USART_DMAREQ_RX | USART_DMAREQ_TX, ENABLE);
    /* Enable USARTz DMA Rx and TX request */
    USART_EnableDMA(USARTz, USART_DMAREQ_RX | USART_DMAREQ_TX, ENABLE);

    /* Enable USARTy TX DMA Channel */
    DMA_EnableChannel(USARTy_Tx_DMA_Channel, ENABLE);
    /* Enable USARTy RX DMA Channel */
    DMA_EnableChannel(USARTy_Rx_DMA_Channel, ENABLE);

    /* Enable USARTz TX DMA Channel */
    DMA_EnableChannel(USARTz_Tx_DMA_Channel, ENABLE);
    /* Enable USARTz RX DMA Channel */
    DMA_EnableChannel(USARTz_Rx_DMA_Channel, ENABLE);

    /* USARTy_Tx_DMA_Channel (triggered by USARTy Tx event) Config */
    DMA_DeInit(USARTy_Tx_DMA_Channel);
    DMA_StructInit(&DMA_InitStructure);
    DMA_InitStructure.PeriphAddr     = USARTy_DAT_Base;
    DMA_InitStructure.MemAddr        = (uint32_t)TxBuffer1;
    DMA_InitStructure.Direction      = DMA_DIR_PERIPH_DST;
    DMA_InitStructure.BufSize        = TxBufferSize1;
    DMA_InitStructure.PeriphInc      = DMA_PERIPH_INC_DISABLE;
    DMA_InitStructure.DMA_MemoryInc  = DMA_MEM_INC_ENABLE;
    DMA_InitStructure.PeriphDataSize = DMA_PERIPH_DATA_SIZE_BYTE;
    DMA_InitStructure.MemDataSize    = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.CircularMode   = DMA_MODE_NORMAL;
    DMA_InitStructure.Priority       = DMA_PRIORITY_VERY_HIGH;
    DMA_InitStructure.Mem2Mem        = DMA_M2M_DISABLE;
    DMA_Init(USARTy_Tx_DMA_Channel, &DMA_InitStructure);
    DMA_RequestRemap(USARTy_Tx_DMA_REMAP, DMA, USARTy_Tx_DMA_Channel, ENABLE);

    /* Wait until USARTy TX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTy_Tx_DMA_FLAG, DMA) == RESET)
    {
    }
    /* Wait until USARTy RX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTy_Rx_DMA_FLAG, DMA) == RESET)
    {
    }

    /* Wait until USARTz TX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTz_Tx_DMA_FLAG, DMA) == RESET)
    {
    }
    /* Wait until USARTz RX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(USARTz_Rx_DMA_FLAG, DMA) == RESET)
    {
    }

    /* Configure USARTy Tx as alternate function push-pull and pull-up */
    GPIO_InitStructure.Pin            = USARTy_TxPin;
    GPIO_InitStructure.GPIO_Pull      = GPIO_PULL_UP;
    GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_OD;
    GPIO_InitStructure.GPIO_Alternate = USARTy_Tx_GPIO_AF;
    GPIO_InitPeripheral(USARTy_GPIO, &GPIO_InitStructure);

    /* Configure USARTz Tx as alternate function push-pull and pull-up */
    GPIO_InitStructure.Pin            = USARTz_TxPin;
    GPIO_InitStructure.GPIO_Alternate = USARTz_Tx_GPIO_AF;
    GPIO_InitPeripheral(USARTz_GPIO, &GPIO_InitStructure);

    /* Enable the USARTy and USARTz */
    USART_Enable(USARTy, ENABLE);
    USART_Enable(USARTz, ENABLE);

    /* Enable USARTy Half Duplex Mode */
    USART_EnableHalfDuplex(USARTy, ENABLE);
    /* Enable USARTz Half Duplex Mode */
    USART_EnableHalfDuplex(USARTz, ENABLE);

    while (NbrOfDataToRead2--)
    {
        /* Wait until end of transmit */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
        {
        }
        /* Write one byte in the USARTy Transmit Data Register */
        USART_SendData(USARTy, TxBuffer1[TxCounter1++]);

        /* Wait the byte is entirely received by USARTz */
        while (USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if (USART_GetFlagStatus(USARTz, USART_FLAG_OREF) != RESET)
            {
                USARTz->DAT;
            }
        }
        /* Store the received byte in the RxBuffer2 */
        RxBuffer2[RxCounter2++] = USART_ReceiveData(USARTz);
    }

    /* Clear the USARTy Data Register */
    USART_ReceiveData(USARTy);

    /* Check the received data with the send ones */
    TransferStatus1 = Buffercmp(TxBuffer1, RxBuffer2, TxBufferSize1);
    /* TransferStatus = PASSED, if the data transmitted from USARTy and
       received by USARTz are the same */
    /* TransferStatus = FAILED, if the data transmitted from USARTy and
       received by USARTz are different */
    TransferStatus2 = Buffercmp(TxBuffer2, RxBuffer1, TxBufferSize2);

    /* Configure USARTz RTS as alternate function push-pull */
    GPIO_InitStructure.Pin            = USARTz_RTSPin;
    GPIO_InitStructure.GPIO_Alternate = USARTz_RTS_GPIO_AF;
    GPIO_InitPeripheral(USARTz_GPIO, &GPIO_InitStructure);

    /* Configure USARTy Rx as alternate function input and pull-up */
    GPIO_InitStructure.Pin            = USARTy_RxPin;
    GPIO_InitStructure.GPIO_Pull      = GPIO_PULL_UP;
    GPIO_InitStructure.GPIO_Alternate = USARTy_Rx_GPIO_AF;
    GPIO_InitPeripheral(USARTy_GPIO, &GPIO_InitStructure);

    /* Configure USARTz Rx as alternate function input and pull-up */
    GPIO_InitStructure.Pin            = USARTz_RxPin;
    GPIO_InitStructure.GPIO_Alternate = USARTz_Rx_GPIO_AF;
    GPIO_InitPeripheral(USARTz_GPIO, &GPIO_InitStructure);

    /* Configure USARTy CTS as alternate function input and pull-up */
    GPIO_InitStructure.Pin            = USARTy_CTSPin;
    GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_INPUT;
    GPIO_InitStructure.GPIO_Pull      = GPIO_PULL_UP;
    GPIO_InitStructure.GPIO_Alternate = USARTy_CTS_GPIO_AF;
    GPIO_InitPeripheral(USARTy_GPIO, &GPIO_InitStructure);

    while (NbrOfDataToRead2--)
    {
        /* Send one byte from USARTy to USARTz */
        USART_SendData(USARTy, TxBuffer1[TxCounter1++]);
        /* Loop until USARTy DAT register is empty */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
        {
        }

        /* Loop until the USARTz Receive Data Register is not empty */
        while (USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(USART_GetFlagStatus(USARTz, USART_FLAG_OREF) != RESET)
            {
                USARTz->DAT;
            }
        }
        /* Store the received byte in RxBuffer */
        RxBuffer2[RxCounter2++] = USART_ReceiveData(USARTz);
    }

    /* Check the received data with the send ones */
    TransferStatus1 = Buffercmp(TxBuffer1, RxBuffer2, TxBufferSize1);
    /* TransferStatus1 = PASSED, if the data transmitted from USARTy and
       received by USARTz are the same */
    /* TransferStatus1 = FAILED, if the data transmitted from USARTy and
       received by USARTz are different */
    TransferStatus2 = Buffercmp(TxBuffer2, RxBuffer1, TxBufferSize2);
    /* TransferStatus2 = PASSED, if the data transmitted from USARTz and
       received by USARTy are the same */
    /* TransferStatus2 = FAILED, if the data transmitted from USARTz and
       received by USARTy are different */

    /* Enable USARTy and USARTz Receive and Transmit interrupts */
    USART_ConfigInt(USARTy, USART_INT_RXDNE, ENABLE);
    USART_ConfigInt(USARTy, USART_INT_TXDE, ENABLE);
    USART_ConfigInt(USARTz, USART_INT_RXDNE, ENABLE);
    USART_ConfigInt(USARTz, USART_INT_TXDE, ENABLE);

    /* Enable the USARTy and USARTz */
    USART_Enable(USARTy, ENABLE);
    USART_Enable(USARTz, ENABLE);

void USARTy_IRQHandler(void)
{
    if ((USART_GetFlagStatus(USARTy, USART_FLAG_RXDNE) != RESET) &&
        (USART_GetIntStatus(USARTy, USART_INT_RXDNE) != RESET))
    {
        /* Read one byte from the receive data register */
        RxBuffer1[RxCounter1++] = USART_ReceiveData(USARTy);

        if (RxCounter1 == NbrOfDataToRead1)
        {
            /* Disable the USARTy Receive interrupt */
            USART_ConfigInt(USARTy, USART_INT_RXDNE, DISABLE);
        }
    }

    if ((USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) != RESET) &&
        (USART_GetIntStatus(USARTy, USART_INT_TXDE) != RESET))
    {
        /* Write one byte to the transmit data register */
        USART_SendData(USARTy, TxBuffer1[TxCounter1++]);

        if (TxCounter1 == NbrOfDataToTransfer1)
        {
            /* Disable the USARTy Transmit interrupt */
            USART_ConfigInt(USARTy, USART_INT_TXDE, DISABLE);
        }
    }

void USARTz_IRQHandler(void)
{
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_RXDNE) != RESET))
    {
        /* Read one byte from the receive data register */
        RxBuffer2[RxCounter2++] = USART_ReceiveData(USARTz);

        if (RxCounter2 == NbrOfDataToRead2)
        {
            /* Disable the USARTz Receive interrupt */
            USART_ConfigInt(USARTz, USART_INT_RXDNE, DISABLE);
        }
    }

    if ((USART_GetFlagStatus(USARTz, USART_FLAG_TXDE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_TXDE) != RESET))
    {
        /* Write one byte to the transmit data register */
        USART_SendData(USARTz, TxBuffer2[TxCounter2++]);

        if (TxCounter2 == NbrOfDataToTransfer2)
        {
            /* Disable the USARTz Transmit interrupt */
            USART_ConfigInt(USARTz, USART_INT_TXDE, DISABLE);
        }
    }

    /* Wait until all data are received */
    while (RxCounter2 < RxBufferSize2)
    {
    }
    while (RxCounter1 < RxBufferSize1)
    {
    }

    /* Check the received data with the send ones */
    TransferStatus1 = Buffercmp(TxBuffer1, RxBuffer2, TxBufferSize1);
    /* TransferStatus1 = PASSED, if the data transmitted from UARTy and
       received by UARTz are the same */
    /* TransferStatus1 = FAILED, if the data transmitted from UARTy and
       received by UARTz are different */
    TransferStatus2 = Buffercmp(TxBuffer2, RxBuffer1, TxBufferSize2);

    /* Set the USARTy and USARTz prescaler */
    USART_SetPrescaler(USARTy, 250);
    USART_SetPrescaler(USARTz, 125);
    /* Configure the USARTy IrDA mode */
    USART_ConfigIrDAMode(USARTy, USART_IRDAMODE_LOWPPWER);
    USART_ConfigIrDAMode(USARTz, USART_IRDAMODE_LOWPPWER);

    /* Enable the USARTy and USARTz IrDA mode */
    USART_EnableIrDA(USARTy, ENABLE);
    USART_EnableIrDA(USARTz, ENABLE);

    TIM_InitTimBaseStruct(&TIM_TimeBaseStructure);
    TIM_TimeBaseStructure.Period      = ADVANCE_TIM_Period;
    TIM_TimeBaseStructure.Prescaler   = ADVANCE_TIM_Prescaler;
    TIM_TimeBaseStructure.ClkDiv      = TIM_CLK_DIV1;
    TIM_TimeBaseStructure.CounterMode = TIM_CNT_MODE_UP;
    TIM_InitTimeBase(ADVANCE_TIM, &TIM_TimeBaseStructure);

void ADVANCE_TIM_IRQHandler(void)
{
    if (TIM_GetIntStatus(ADVANCE_TIM, TIM_INT_UPDATE) != RESET)
    {
        TIM_ClearFlag(ADVANCE_TIM, TIM_FLAG_UPDATE);
        digitalToggle(PORTx, PORTx_PIN);
    }
}

void USARTz_IRQHandler(void)
{
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_RXDNE) != RESET))
    {
        RxBuffer1[RxCounter++] = USART_ReceiveData(USARTz);

        {
            if (RxCounter == NbrOfDataToRead1)
            {
                /* Disable the USARTz Receive interrupt */
                USART_ConfigInt(USARTz, USART_INT_RXDNE, DISABLE);
            }
        }
    }

    /* Determine if an error flag still exists and clear the error flag */
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_OREF) != RESET) ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_NEF) != RESET)  ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_PEF) != RESET)  ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_FEF) != RESET))
    {
        (void)USARTz->STS;
        (void)USARTz->DAT;
    }
}

    while (TxCounter < TxBufferSize1)
    {
        /* Send one byte from Board1_USARTy to Board2_USARTz */
        USART_SendData(USARTy, TxBuffer1[TxCounter++]);
        /* Loop until Board1_USARTy DAT register is empty */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
        {
        }
    }
    while (RxCounter < TxBufferSize1)
    {
    }
    /* Check the received data with the send ones */
    TransferStatus = Buffercmp(TxBuffer1, RxBuffer1, TxBufferSize1);

    /* Set the USARTy and USARTz prescaler */
    USART_SetPrescaler(USARTy, 0x01);
    USART_SetPrescaler(USARTz, 0x01);
    /* Configure the USARTy IrDA mode */
    USART_ConfigIrDAMode(USARTy, USART_IRDAMODE_NORMAL);
    USART_ConfigIrDAMode(USARTz, USART_IRDAMODE_NORMAL);

    /* Enable the USARTy and USARTz IrDA mode */
    USART_EnableIrDA(USARTy, ENABLE);
    USART_EnableIrDA(USARTz, ENABLE);

    /* Configure USARTy Tx as alternate function push-pull */
    GPIO_InitStructure.Pin            = USARTy_TxPin;
    GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStructure.GPIO_Alternate = USARTy_Tx_GPIO_AF;
    GPIO_InitStructure.GPIO_Current   = GPIO_DS_HIGH;
    GPIO_InitPeripheral(USARTy_GPIO, &GPIO_InitStructure);

    /* Configure USARTz Rx as alternate function push-pull */
    GPIO_InitStructure.Pin            = USARTz_RxPin;
    GPIO_InitStructure.GPIO_Pull      = GPIO_PULL_UP;
    GPIO_InitStructure.GPIO_Alternate = USARTz_Rx_GPIO_AF;
    GPIO_InitPeripheral(USARTz_GPIO, &GPIO_InitStructure);

    ADVANCE_TIM_APBxClock_FUN(ADVANCE_TIM_CLK, ENABLE);
    TIM_InitTimBaseStruct(&TIM_TimeBaseStructure);
    TIM_TimeBaseStructure.Period      = ADVANCE_TIM_Period;
    TIM_TimeBaseStructure.Prescaler   = ADVANCE_TIM_Prescaler;
    TIM_TimeBaseStructure.ClkDiv      = TIM_CLK_DIV1;
    TIM_TimeBaseStructure.CounterMode = TIM_CNT_MODE_UP;
    TIM_InitTimeBase(ADVANCE_TIM, &TIM_TimeBaseStructure);

void USARTz_IRQHandler(void)
{
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) != RESET) &&
        (USART_GetIntStatus(USARTz, USART_INT_RXDNE) != RESET))
    {
        /* Read one byte from the receive data register */
        RxBuffer1[RxCounter++] = USART_ReceiveData(USARTz);

        if (RxCounter == NbrOfDataToRead1)
        {
            /* Disable the USARTz Receive interrupt */
            USART_ConfigInt(USARTz, USART_INT_RXDNE, DISABLE);
        }
    }

    /* Determine if an error flag still exists and clear the error flag */
    if ((USART_GetFlagStatus(USARTz, USART_FLAG_OREF) != RESET) ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_NEF) != RESET)  ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_PEF) != RESET)  ||
        (USART_GetFlagStatus(USARTz, USART_FLAG_FEF) != RESET))
    {
        (void)USARTz->STS;
        (void)USARTz->DAT;
    }
}

    while (TxCounter < TxBufferSize1)
    {
        /* Send one byte from Board1_USARTy to Board2_USARTz */
        USART_SendData(USARTy, TxBuffer1[TxCounter++]);
        /* Loop until Board1_USARTy DAT register is empty */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
        {
        }
    }
    while (RxCounter < TxBufferSize1)
    {
    }
    /* Check the received data with the send ones */
    TransferStatus = Buffercmp(TxBuffer1, RxBuffer1, TxBufferSize1);

#define USARTx              USART2
#define USARTx_GPIO         GPIOA
#define USARTx_CLK          RCC_APB1_PERIPH_USART2
#define USARTx_RxPin        GPIO_PIN_3
#define USARTx_TxPin        GPIO_PIN_2
#define USARTx_Rx_GPIO_AF   GPIO_AF4
#define USARTx_Tx_GPIO_AF   GPIO_AF4
#define USARTx_APBxClkCmd   RCC_EnableAPB1PeriphClk
#define USARTx_IRQn         USART2_IRQn
#define USARTx_IRQHandler   USART2_IRQHandler

    /* USARTx configuration */
    USART_StructInit(&USART_InitStructure);
    USART_InitStructure.BaudRate            = 9600;
    USART_InitStructure.WordLength          = USART_WL_8B;
    USART_InitStructure.StopBits            = USART_STPB_1;
    USART_InitStructure.Parity              = USART_PE_NO;
    USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;
    USART_InitStructure.OverSampling        = USART_16OVER;
    USART_InitStructure.Mode                = USART_MODE_RX | USART_MODE_TX;
    /* Configure USARTx */
    USART_Init(USARTx, &USART_InitStructure);
    /* Enable the USARTx LIN mode */
    USART_ConfigLINBreakDetectLength(USARTx, USART_LINBDL_10B);
    USART_EnableLIN(USARTx, ENABLE);
    /* Enable the USARTx */
    USART_Enable(USARTx, ENABLE);

uint8_t MasterGetCheckSum(uint8_t *pData, uint8_t len)
{
    uint16_t check_sum_temp = 0;
    uint8_t i;
    for(i = 0; i < len; i++)
    {
        check_sum_temp += pData[i];
        if(check_sum_temp > 0xFF)
        {
            check_sum_temp -= 0xFF;
        }
    }
    return (~check_sum_temp) & 0xFF;
}

void MasterSendBytes(uint8_t *pBuf, uint8_t Len)
{
    USART_SendBreak(USARTx);
    while(Len--)
    {
        while(USART_GetFlagStatus(USARTx, USART_FLAG_TXC) == RESET);
        USART_SendData(USARTx, *pBuf++);
    }
    while(USART_GetFlagStatus(USARTx, USART_FLAG_TXC) == RESET);
}

void TestMasterReqFrame(void)
{
    int i = 0;
    M_LIN_EX_MSG CurLINTxMsg;
    CurLINTxMsg.Check = CLASSIC;
    CurLINTxMsg.DataLen = 8;
    CurLINTxMsg.Sync = 0x55;
    CurLINTxMsg.PID = 0x3C;
    for(i = 0; i < CurLINTxMsg.DataLen; i++)
    {
        CurLINTxMsg.Data[i] = 0x0F;
    }
    SetFrameMsg(&M_TxMsg, CurLINTxMsg);
    FrameHandle();
}

void FrameHandle(void)
{
    uint8_t tmp_PID  = M_TxMsg.PID;
    SetFramePID(&M_TxMsg);
    switch (tmp_PID)
    {
    case 0x3C://Master request frame
        SetFrameChecksum(&M_TxMsg);
        break;
    case 0x3D://Slave reply frame
        M_TxMsg.DataLen = 0;
        break;
    default:
        break;
    }
    MasterSendFrame(M_TxMsg);
}

    /* Enable the USARTx LIN mode */
    USART_ConfigLINBreakDetectLength(USARTx, USART_LINBDL_10B);
    USART_EnableLIN(USARTx, ENABLE);

    /* Enable USARTx Receive and LIN break detect interrupts */
    USART_ConfigInt(USARTx, USART_INT_RXDNE, ENABLE);
    USART_ConfigInt(USARTx, USART_INT_LINBD, ENABLE);

    /* Enable the USARTx */
    USART_Enable(USARTx, ENABLE);

    /* Configure slave ID mode */
    IDType[MSG_RECEIVE_ID & 0x3F] = ID_TYPE_SR;
    IDType[MSG_SEND_ID & 0x3F] = ID_TYPE_SW;

void LIN_IRQHandler(void)
{
    if(USART_GetFlagStatus(USARTx, USART_FLAG_LINBD) == SET)
    {
        USART_ClrFlag(USARTx, USART_FLAG_LINBD);
        USARTx->STS;
        USARTx->DAT;
        LinRxState = SYNCH;
        return;
    }

    if (USART_GetFlagStatus(USARTx, USART_FLAG_RXDNE) == SET)
    {
        USART_ClrFlag(USARTx, USART_FLAG_RXDNE);
        if(USART_GetFlagStatus(USARTx, USART_FLAG_FEF) == RESET)
        {
            LIN_EX_RxAsync((uint8_t)USART_ReceiveData(USARTx));
        }
    }

    /* Determine if an error flag still exists and clear the error flag */
    if ((USART_GetFlagStatus(USARTx, USART_FLAG_OREF) != RESET) ||
        (USART_GetFlagStatus(USARTx, USART_FLAG_NEF) != RESET)  ||
        (USART_GetFlagStatus(USARTx, USART_FLAG_PEF) != RESET)  ||
        (USART_GetFlagStatus(USARTx, USART_FLAG_FEF) != RESET))
    {
        (void)USARTx->STS;
        (void)USARTx->DAT;
    }
}

void LIN_EX_RxAsync(uint8_t data)
{
    switch(LinRxState)
    {
    case IDLE:
        break;
    case SYNCH:
        if(data == 0x55)
        {
            LINRxDataBuffer[LINRxDataIndex].Sync = 0x55;
            LinRxState = ID_LEN;
        }
        else
        {
            LinRxState = IDLE;
        }
        break;
    case ID_LEN:
        if(GET_PID(data) == data)
        {
            LINRxDataBuffer[LINRxDataIndex].PID = data;
            LINRxDataBuffer[LINRxDataIndex].DataLen = 0;
            if(IDType[data & 0x3F] == ID_TYPE_SR)
            {
                LinRxState = DATA_GET;
            }
            else
            {
                if(((LINTxMsg.PID & 0x3F) == (data & 0x3F)) && (LINTxMsg.DataLen > 0))
                {
                    LIN_SendBytes(LINTxMsg.Data, LINTxMsg.DataLen + 1);
                    LINTxMsg.DataLen = 0;
                }
                LinRxState = IDLE;
            }
        }
        else
        {
            LinRxState = IDLE;
        }
        break;
    case DATA_GET:
        LINRxDataBuffer[LINRxDataIndex].Data[LINRxDataBuffer[LINRxDataIndex].DataLen] = data;
        LINRxDataBuffer[LINRxDataIndex].Check = data;
        LINRxDataBuffer[LINRxDataIndex].DataLen++;
        if(LINRxDataBuffer[LINRxDataIndex].DataLen >= 8)
        {
            LinRxState = CHECKSUM;
        }
        else
        {
            LinRxState = DATA_GET;
        }
        break;
    case CHECKSUM:
        LINRxDataBuffer[LINRxDataIndex].Check = data;
        pLINMsg = &LINRxDataBuffer[LINRxDataIndex];
        GotMsgFlag = 1;
        LINRxDataIndex = (LINRxDataIndex + 1) % 2;
        LinRxState = IDLE;
        break;
    default:
        break;
    }
}

void BOOT_ExecutiveCommand(uint8_t *pData, FUN_RESP pFunResp)
{
    int i = 0;
    log_info("BOOT_ExecutiveCommand\r\n");
    for( i = 0; i < 8; i++)
    {
        log_info("pData[%d] = %02x \r\n", i, pData[i]);
        pData[i] = 0x1;
    }
    pFunResp(pData, 8);
}

void LIN_SetResp(uint8_t ID, uint8_t *pData, uint8_t Len, uint8_t CheckType)
{
    uint8_t i = 0;
    uint8_t CheckSum = 0;
    if(Len > 8)
    {
        Len = 8;
    }
    LINTxMsg.PID = GET_PID(ID);
    for(i = 0; i < Len; i++)
    {
        LINTxMsg.Data[i] = pData[i];
    }
    if(CheckType)
    {
        CheckSum = LIN_GetCheckSum(&LINTxMsg.PID, Len + 1);
    }
    else
    {
        CheckSum = LIN_GetCheckSum(LINTxMsg.Data, Len);
    }
    if(Len < 8)
    {
        LINTxMsg.Data[Len] = CheckSum;
    }
    else
    {
        LINTxMsg.Check = CheckSum;
    }
    LINTxMsg.DataLen = Len;
}

#define USARTy            USART1
#define USARTy_CLK        RCC_APB2_PERIPH_USART1
#define USARTy_GPIO       GPIOA
#define USARTy_TxPin      GPIO_PIN_9
#define USARTy_RxPin      GPIO_PIN_10
#if defined(N32G412)
#define USARTy_Tx_GPIO_AF GPIO_AF4 
#elif defined(N32G415)
#define USARTy_Tx_GPIO_AF GPIO_AF0
#endif
#define USARTy_Rx_GPIO_AF GPIO_AF4

#define USARTy_APBxClkCmd RCC_EnableAPB2PeriphClk

#define USARTz            USART2
#define USARTz_CLK        RCC_APB1_PERIPH_USART2
#define USARTz_GPIO       GPIOA
#define USARTz_TxPin      GPIO_PIN_2
#define USARTz_RxPin      GPIO_PIN_3
#define USARTz_Tx_GPIO_AF GPIO_AF4
#define USARTz_Rx_GPIO_AF GPIO_AF4
#define USARTz_APBxClkCmd RCC_EnableAPB1PeriphClk
#endif

    /* USARTy and USARTz configuration */
    USART_StructInit(&USART_InitStructure);
    USART_InitStructure.BaudRate            = 115200;
    USART_InitStructure.WordLength          = USART_WL_9B;
    USART_InitStructure.StopBits            = USART_STPB_1;
    USART_InitStructure.Parity              = USART_PE_NO;
    USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;
    USART_InitStructure.OverSampling        = USART_16OVER; 
    USART_InitStructure.Mode = USART_MODE_RX | USART_MODE_TX;
    
    /* Configure USARTy and USARTz */
    USART_Init(USARTy, &USART_InitStructure);
    USART_Init(USARTz, &USART_InitStructure);

    /* Enable USARTy and USARTz */
    USART_Enable(USARTy, ENABLE);
    USART_Enable(USARTz, ENABLE);
    
    /* Set USARTy address to 0x1, USARTz address to 0x2 */
    USART_SetAddr(USARTy, 0x1);
    USART_SetAddr(USARTz, 0x2);

    /* Configure USARTz to wake up by address mark */
    USART_ConfigWakeUpMode(USARTz, USART_WUM_ADDRMASK);

    while (1)
    {
        /* Send one byte from UARTy to UARTz */
        USART_SendData(USARTy, 0x33);

        /* Wait while UARTy TXE = 0 */
        while(USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
        {
        }

        if (USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) != RESET)
        {
            if (USART_ReceiveData(USARTz) == 0x33)
            {
                LED1_ON;
                Delay(0x1FFFFF);
                LED1_OFF;
                Delay(0x1FFFFF);
            }
            /* Overflow data loss */
            if(USART_GetFlagStatus(USARTz, USART_FLAG_OREF) != RESET)
            {
                USARTz->DAT;
            }
        }
    }

void EXTI4_IRQHandler(void)
{
    Delay(0x1FFF);;
    if (ControlFlag == 2)
    {
        ControlFlag = 0;
    }

    if (ControlFlag == 0)
    {
        /* Flush DAT register and clear the UARTz RXNE flag */
        USART_ReceiveData(USARTz);
        /* Enable the UARTz mute mode*/
        USART_EnableRcvWakeUp(USARTz, ENABLE);

        ControlFlag = 1;
    }
    else if (ControlFlag == 1)
    {
        /* Send the address mark (0x102) to wakeup UARTz */
        USART_SendData(USARTy, 0x102);
        /* Wait while UARTy TXE = 0 */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
        {
        }

        ControlFlag = 2;
    }

    /* Clear Key Button EXTI Line Pending Bit */
    EXTI_ClrITPendBit(KEY1_INT_EXTI_LINE);
}

    /* Configure the GPIO ports */
    USART_StructInit(&USART_InitStructure);
    USART_InitStructure.BaudRate     = 115200;
    USART_InitStructure.WordLength   = USART_WL_8B;
    USART_InitStructure.StopBits     = USART_STPB_1;
    USART_InitStructure.Parity       = USART_PE_NO;
    USART_InitStructure.OverSampling = USART_16OVER;
    USART_InitStructure.Mode         = USART_MODE_RX | USART_MODE_TX;

    /* USARTy and USARTz configuration */
    USART_Init(USARTy, &USART_InitStructure);
    USART_Init(USARTz, &USART_InitStructure);

    /* Configure USARTy and USARTz */
    USART_Enable(USARTy, ENABLE);
    USART_Enable(USARTz, ENABLE);

    while (TxCounter1 < TxBufferSize1)
    {
        /* Send one byte from USARTy to USARTz */
        USART_SendData(USARTy, TxBuffer1[TxCounter1++]); 
        /* Loop until USARTy DAT register is empty */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
        { 
        }
        /* Loop until the USARTz Receive Data Register is not empty */
        while (USART_GetFlagStatus(USARTz, USART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(USART_GetFlagStatus(USARTz, USART_FLAG_OREF) != RESET)
            {
                USARTz->DAT;
            }
        }
        /* Store the received byte in RxBuffer */
        RxBuffer2[RxCounter2++] = (uint8_t)USART_ReceiveData(USARTz);
    }

    while (TxCounter2 < TxBufferSize2)
    {
        /* Send one byte from USARTz to USARTy */
        USART_SendData(USARTz, TxBuffer2[TxCounter2++]);
        /* Loop until USARTz DAT register is empty */
        while (USART_GetFlagStatus(USARTz, USART_FLAG_TXDE) == RESET)
        {
        }

        /* Loop until the USARTy Receive Data Register is not empty */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(USART_GetFlagStatus(USARTy, USART_FLAG_OREF) != RESET)
            {
                USARTy->DAT;
            }
        }
        /* Store the received byte in RxBuffer */
        RxBuffer1[RxCounter1++] = (uint8_t)USART_ReceiveData(USARTy);
    }

TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
{
    while (BufferLength--)
    {
        if (*pBuffer1 != *pBuffer2)
        {
            return FAILED;
        }
        pBuffer1++;
        pBuffer2++;
    }

    return PASSED;
}

#if defined(N32G412)
#define USARTx             USART1
#define USARTx_CLK         RCC_APB2_PERIPH_USART1
#define USARTx_CLK_ENABLE() RCC_EnableAPB2PeriphClk(USARTx_CLK, ENABLE)

#define USARTx_GPIO        GPIOA
#define USARTx_GPIO_CLK    RCC_AHB_PERIPH_GPIO
#define USARTx_TX_PIN      GPIO_PIN_9
#define USARTx_RX_PIN      GPIO_PIN_10
#define USARTx_TX_AF       GPIO_AF4
#define USARTx_RX_AF       GPIO_AF4
#elif defined(N32G415)
#define USARTx             USART1
#define USARTx_CLK         RCC_APB2_PERIPH_USART1
#define USARTx_CLK_ENABLE() RCC_EnableAPB2PeriphClk(USARTx_CLK, ENABLE)

#define USARTx_GPIO        GPIOA
#define USARTx_GPIO_CLK    RCC_AHB_PERIPH_GPIO
#define USARTx_TX_PIN      GPIO_PIN_9
#define USARTx_RX_PIN      GPIO_PIN_10
#define USARTx_TX_AF       GPIO_AF0
#define USARTx_RX_AF       GPIO_AF4
#else
#error "Unsupported target. Please use N32G412 or N32G415."
#endif

void GPIO_Configuration(void)
{  
    GPIO_InitType gpio_init;
    GPIO_InitStruct(&gpio_init);

    gpio_init.Pin            = USARTx_TX_PIN;
    gpio_init.GPIO_Mode      = GPIO_MODE_AF_PP;
    gpio_init.GPIO_Alternate = USARTx_TX_AF;
    gpio_init.GPIO_Pull      = GPIO_PULL_UP;
    GPIO_InitPeripheral(USARTx_GPIO, &gpio_init);
}

    USART_StructInit(&usart_init);
    usart_init.BaudRate     = 115200;
    usart_init.WordLength   = USART_WL_8B;
    usart_init.StopBits     = USART_STPB_1;
    usart_init.Parity       = USART_PE_NO;
    usart_init.Mode         = USART_MODE_RX | USART_MODE_TX;
    usart_init.HardwareFlowControl = USART_HFCTRL_NONE;
    usart_init.OverSampling = USART_16OVER;

    USART_Init(USARTx, &usart_init);
    USART_Enable(USARTx, ENABLE);
    
    printf("This is a Printf demo of USART.\n\r");

/* USART3 on PB10(TX)/PB12(CK), both AF0 for G412 and G415 */
#define SC_USART                 USART3
#define SC_USART_CLK             RCC_APB1_PERIPH_USART3

#define SC_USART_GPIO            GPIOB
#define SC_USART_GPIO_CLK        RCC_AHB_PERIPH_GPIO
#define SC_USART_PIN_TX          GPIO_PIN_10
#define SC_USART_Tx_GPIO_AF      GPIO_AF0

#define SC_USART_CK_GPIO         GPIOB
#define SC_USART_GPIO_CK_CLK     RCC_AHB_PERIPH_GPIO
#define SC_USART_PIN_CK          GPIO_PIN_12
#define SC_USART_Clk_GPIO_AF     GPIO_AF0

#define SC_USART_APBxClkCmd      RCC_EnableAPB1PeriphClk
#define SC_USART_IRQn            USART3_IRQn
#define SC_USART_IRQHandler      USART3_IRQHandler

#define SC_USART_DMAx           DMA
#define SC_USART_DMAx_CLK       RCC_AHB_PERIPH_DMA
#define SC_USART_DR_Base        (USART3_BASE + 0x10)
#define SC_USART_Tx_DMA_Channel DMA_CH5
#define SC_USART_Tx_DMA_FLAG    DMA_FLAG_TC5
#define SC_USART_Tx_DMA_REMAP   DMA_REMAP_USART3_TX
#define SC_USART_Rx_DMA_Channel DMA_CH6
#define SC_USART_Rx_DMA_FLAG    DMA_FLAG_TC6
#define SC_USART_Rx_DMA_REMAP   DMA_REMAP_USART3_RX

    /* SC_USART Clock set to (PCLK1 / Clk_Div) */
    USART_SetPrescaler(SC_USART, SC_InitCfg->Clk_Div >> 1);
    /* USART Guard Time set to 16 Bit */
    USART_SetGuardTime(SC_USART, SC_InitCfg->GT);
    USART_ClockStructInit(&USART_ClockInitStructure);
    USART_ClockInitStructure.Clock      = USART_CLK_ENABLE;
    USART_ClockInitStructure.Polarity   = USART_CLKPOL_LOW;
    USART_ClockInitStructure.Phase      = USART_CLKPHA_1EDGE;
    USART_ClockInitStructure.LastBit    = USART_CLKLB_ENABLE;
    USART_ClockInit(SC_USART, &USART_ClockInitStructure);
    RCC_GetClocksFreqValue(&RCC_ClocksStatus);
    USART_StructInit(&USART_InitStructure);
    USART_InitStructure.BaudRate = RCC_ClocksStatus.Pclk1Freq / (372 * ((SC_USART->GTP & (uint16_t)0x00FF) * 2));
    log_info(" Pclk1 =%d,Clk_Div = %d,bps =%d\r\n", RCC_ClocksStatus.Pclk1Freq, (372 * ((SC_USART->GTP & (uint16_t)0x00FF) *2)),USART_InitStructure.BaudRate);
    USART_InitStructure.WordLength = USART_WL_9B;
    if(SC_InitCfg->StopBits == 1)
    {
        USART_InitStructure.StopBits = USART_STPB_0_5;
    }
    else if(SC_InitCfg->StopBits == 3)
    {
        USART_InitStructure.StopBits = USART_STPB_1_5;
    }
    else
    {
        log_info("\r\n StopBits value is error !!! \r\n");
    }
    if(SC_InitCfg->Parity == 1)
    {
        USART_InitStructure.Parity = USART_PE_EVEN;
    }
    else if(SC_InitCfg->Parity == 2)
    {
        USART_InitStructure.Parity = USART_PE_ODD;
    }
    else
    {
        log_info("\r\n Parity value is error !!! \r\n");
    }
    USART_InitStructure.Mode                  = USART_MODE_RX | USART_MODE_TX;
    USART_InitStructure.HardwareFlowControl   = USART_HFCTRL_NONE;
    USART_InitStructure.OverSampling          = USART_16OVER;
    USART_Init(SC_USART, &USART_InitStructure);

    /* Enable SC_USART */
    USART_Enable(SC_USART, ENABLE);
    /* Enable the NACK Transmission */
    if(SC_InitCfg->NackEn == 0)
    {
        USART_SetSmartCardNACK(SC_USART, DISABLE);
    }
    else if(SC_InitCfg->NackEn == 1)
    {
        USART_SetSmartCardNACK(SC_USART, ENABLE);
    }
    else
    {
        log_info("\r\n NACK Enable value is error !!! \r\n");
    }
    /* Enable the Smartcard Interface */
    USART_EnableSmartCard(SC_USART, ENABLE);
    /* Set RSTIN HIGH */
    SC_Reset(Bit_SET);
}

//            /* Send PPSS */
            TxBuffer1[0] = 0xFF;
//            /* Send PPS0 */
            TxBuffer1[1] = 0x10;
//            /* PPS1~3  */
            TxBuffer1[2] = SC_A2R.T[0];
//            /* PCK */
            TxBuffer1[3] = (uint8_t)0xFF ^ (uint8_t)0x10 ^ (uint8_t)SC_A2R.T[0];
            DMA_Configuration(TxBuffer1, 4, RxBuffer1, 4);            
            /* Enable USARTy DMA Rx and TX request */
            USART_EnableDMA(SC_USART, USART_DMAREQ_RX | USART_DMAREQ_TX, ENABLE);

            /* Enable USARTy TX DMA Channel */
            DMA_EnableChannel(SC_USART_Tx_DMA_Channel, ENABLE);
            /* Enable USARTy RX DMA Channel */
            DMA_EnableChannel(SC_USART_Rx_DMA_Channel, ENABLE);

            /* Wait until USARTy TX DMA Channel Transfer Complete */
            while (DMA_GetFlagStatus(SC_USART_Tx_DMA_FLAG, SC_USART_DMAx) == RESET)
            {
            }
            DMA_ClearFlag(SC_USART_Tx_DMA_FLAG, SC_USART_DMAx);
            /* Wait until USARTy RX DMA Channel Transfer Complete */
            while (DMA_GetFlagStatus(SC_USART_Rx_DMA_FLAG, SC_USART_DMAx) == RESET)
            {
            }            
            DMA_ClearFlag(SC_USART_Rx_DMA_FLAG, SC_USART_DMAx);
            log_info(" locData =%02x %02x %02x %02x\r\n", RxBuffer1[0],RxBuffer1[1],RxBuffer1[2],RxBuffer1[3]);

#ifdef _USART1_SPI1_
#define USARTy            USART1
#define USARTy_CLK        RCC_APB2_PERIPH_USART1
#define USARTy_GPIO       GPIOA
#define USARTy_RxPin      GPIO_PIN_10
#define USARTy_TxPin      GPIO_PIN_9
#define USARTy_ClkPin     GPIO_PIN_8
#if defined(N32G412)
#define USARTy_Tx_GPIO_AF GPIO_AF4
#define USARTy_Clk_GPIO_AF GPIO_AF4
#elif defined(N32G415)
#define USARTy_Tx_GPIO_AF GPIO_AF0
#define USARTy_Clk_GPIO_AF GPIO_AF5
#endif
#define USARTy_Rx_GPIO_AF  GPIO_AF4
#define USARTy_APBxClkCmd  RCC_EnableAPB2PeriphClk

#define SPIy              SPI1
#define SPIy_CLK          RCC_APB2_PERIPH_SPI1
#define SPIy_GPIO         GPIOA
#define SPIy_SCKPin       GPIO_PIN_5
#define SPIy_MISOPin      GPIO_PIN_6
#define SPIy_MOSIPin      GPIO_PIN_7
#define SPIy_SCK_GPIO_AF  GPIO_AF0
#define SPIy_MISO_GPIO_AF GPIO_AF0
#define SPIy_MOSI_GPIO_AF GPIO_AF0
#define SPIy_APBxClkCmd   RCC_EnableAPB2PeriphClk
#endif

    USART_ClockStructInit(&USART_ClockInitStructure);
    USART_ClockInitStructure.Clock    = USART_CLK_ENABLE;
    USART_ClockInitStructure.Polarity = USART_CLKPOL_LOW;
    USART_ClockInitStructure.Phase    = USART_CLKPHA_2EDGE;
    USART_ClockInitStructure.LastBit  = USART_CLKLB_ENABLE;
    USART_ClockInit(USARTy, &USART_ClockInitStructure);

    USART_StructInit(&USART_InitStructure);
    USART_InitStructure.BaudRate            = 115200;
    USART_InitStructure.WordLength          = USART_WL_8B;
    USART_InitStructure.StopBits            = USART_STPB_1;
    USART_InitStructure.Parity              = USART_PE_NO;
    USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;
    USART_InitStructure.OverSampling        = USART_16OVER;
    USART_InitStructure.Mode                = USART_MODE_RX | USART_MODE_TX;

    /* Configure USARTy */
    USART_Init(USARTy, &USART_InitStructure);

    /* Enable the USARTy */
    USART_Enable(USARTy, ENABLE);

void SPI_Configuration(void)
{
    SPI_InitType SPI_InitStructure;

    /* Initialize SPI_InitStructure */
    SPI_InitStruct(&SPI_InitStructure);

    SPI_I2S_DeInit(SPIy);

    /* SPIy Config */
    SPI_InitStructure.DataDirection = SPI_DIR_DOUBLELINE_FULLDUPLEX;
    SPI_InitStructure.SpiMode       = SPI_MODE_SLAVE;
    SPI_InitStructure.DataLen       = SPI_DATA_SIZE_8BITS;
    SPI_InitStructure.CLKPOL        = SPI_CLKPOL_LOW;
    SPI_InitStructure.CLKPHA        = SPI_CLKPHA_SECOND_EDGE;
    SPI_InitStructure.NSS           = SPI_NSS_SOFT;
    SPI_InitStructure.FirstBit      = SPI_FB_LSB;

    /* Configure SPIy */
    SPI_Init(SPIy, &SPI_InitStructure);

    /* SPIy enable */
    SPI_Enable(SPIy, ENABLE);
}

    while(NbrOfDataToRead2--)
    {
        /* Write one byte in the USARTy Transmit Data Register */
        USART_SendData(USARTy, TxBuffer1[TxCounter1++]);
        /* Wait until end of transmit */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXC) == RESET)
        {
        }

        /* Wait the byte is entirely received by SPIy */
        while (SPI_I2S_GetStatus(SPIy, SPI_I2S_RNE_FLAG) == RESET)
        {
        }
        /* Store the received byte in the RxBuffer2 */
        RxBuffer2[RxCounter2++] = SPI_I2S_ReceiveData(SPIy);
    }

    while (NbrOfDataToRead1--)
    {
        /* Wait until end of transmit */
        while (SPI_I2S_GetStatus(SPIy, SPI_I2S_TE_FLAG) == RESET)
        {
        }
        /* Write one byte in the SPIy Transmit Data Register */
        SPI_I2S_TransmitData(SPIy, TxBuffer2[TxCounter2++]);

        /* Send a Dummy byte to generate clock to slave */
        USART_SendData(USARTy, DYMMY_BYTE);
        /* Wait until end of transmit */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_TXC) == RESET)
        {
        }
        /* Wait the byte is entirely received by USARTy */
        while (USART_GetFlagStatus(USARTy, USART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(USART_GetFlagStatus(USARTy, USART_FLAG_OREF) != RESET)
            {
                USARTy->DAT;
            }
        }
        /* Store the received byte in the RxBuffer1 */
        RxBuffer1[RxCounter1++] = USART_ReceiveData(USARTy);
    }

#define USARTy              USART1
#define USARTy_CLK          RCC_APB2_PERIPH_USART1
#define USARTy_GPIO         GPIOA
#define USARTy_TxPin        GPIO_PIN_9
#define USARTy_RxPin        GPIO_PIN_10
#if defined(N32G412)
#define USARTy_Tx_GPIO_AF   GPIO_AF4
#elif defined(N32G415)
#define USARTy_Tx_GPIO_AF   GPIO_AF0
#endif
#define USARTy_Rx_GPIO_AF   GPIO_AF4
#define USARTy_APBxClkCmd   RCC_EnableAPB2PeriphClk
#define USARTy_IRQn         USART1_IRQn

    /* USART configuration: 115200-8-N-1 */
    USART_StructInit(&USART_InitStructure);
    USART_InitStructure.BaudRate            = 115200;
    USART_InitStructure.WordLength          = USART_WL_8B;
    USART_InitStructure.StopBits            = USART_STPB_1;
    USART_InitStructure.Parity              = USART_PE_NO;
    USART_InitStructure.OverSampling        = USART_16OVER;
    USART_InitStructure.Mode                = USART_MODE_RX | USART_MODE_TX;

    /* Initialize and enable USART1 */
    USART_Init(USARTy, &USART_InitStructure);
    USART_Enable(USARTy, ENABLE);

    while (1)
    {
        /* Insert a delay */
        SysTick_Delay_Ms(1000);

        if (USART_GetFlagStatus(USARTy, USART_FLAG_RXDNE) == SET)
        {
            if (USART_ReceiveData(USARTy) == 0x55)
            {
                /* Enable USART1 RXDNE interrupt for wakeup */
                USART_ConfigInt(USARTy, USART_INT_RXDNE, ENABLE);

                /* Enter SLEEP mode with WFI (SLEEP-NOW mode)
                   CPU stops, all peripherals keep running.
                   Any NVIC interrupt (here USART1 RXDNE) will wake up the CPU. */
                PWR_EnterSLEEPMode(PWR_SLEEP_NOW, PWR_SLEEPENTRY_WFI);

                /* --- Woken up from SLEEP mode by USART1 RXDNE interrupt --- */

                /* Disable USART1 RXDNE interrupt (no longer needed for wakeup) */
                USART_ConfigInt(USARTy, USART_INT_RXDNE, DISABLE);

                WakeUpFlag = 0;
            }
        }
        else
        {
            USART_SendData(USARTy, (uint8_t)(cnt_temp++ & 0xFF));
            while (USART_GetFlagStatus(USARTy, USART_FLAG_TXDE) == RESET)
            {
            }
        }

        /* Clear overrun error if occurred */
        if (USART_GetFlagStatus(USARTy, USART_FLAG_OREF) != RESET)
        {
            (void)USARTy->DAT;
        }
    }

#define USARTy              USART1
#define USARTy_CLK          RCC_APB2_PERIPH_USART1
#define USARTy_GPIO         GPIOA
#define USARTy_TxPin        GPIO_PIN_9
#define USARTy_RxPin        GPIO_PIN_10
#if defined(N32G412)
#define USARTy_Tx_GPIO_AF   GPIO_AF4
#elif defined(N32G415)
#define USARTy_Tx_GPIO_AF   GPIO_AF0
#endif
#define USARTy_Rx_GPIO_AF   GPIO_AF4
#define USARTy_APBxClkCmd   RCC_EnableAPB2PeriphClk

#define USARTy_WKUP_EXTI_LINE   EXTI_LINE24

extern volatile uint8_t UsartWakeupFlag;

static void USART1_PrepareStopWakeup(void)
{
    /* Configure USART on APB2, then make LSI the last clock-source change. */
    /* Reconfigure only while USART1 is clocked from APB2. */

    /* requires UEN=0: CTRL1.OSPM and BRCF are only writable while the
   USART is disabled, so a running port must be quiesced first. The baud rate
   change also aborts the frame being transmitted/received. */
    USART_Enable(USARTy, DISABLE);
    RCC_ConfigUsart1Clk(RCC_USART1_CLKSEL_APB2);
    USARTy_APBxClkCmd(USARTy_CLK, ENABLE);
    USART_Init(USARTy, &USART_InitStructure);

    if (USART_GetFlagStatus(USARTy, USART_FLAG_RXDNE) != RESET)
    {
        (void)USART_ReceiveData(USARTy);
    }

    /* The ISR sets this flag after the WFI wakeup interrupt occurs. */
    UsartWakeupFlag = 0U;
    USART_CfgWakeUpDataClr(USARTy, USART_WAKEUP_NOTCLRDATA);
    USART_EnableWakeUp(USARTy, ENABLE);
    /* RXDNE is the interrupt source that wakes WFI through EXTI24. */
    USART_ConfigInt(USARTy, USART_INT_RXDNE, ENABLE);
    USARTy->BRCF = 0x1AU;
    EXTI_ClrITPendBit(USARTy_WKUP_EXTI_LINE);
    USART_Enable(USARTy, ENABLE);
    RCC_ConfigUsart1Clk(RCC_USART1_CLKSEL_LSI);
}

static void USART1_RestoreAfterStop(void)
{
    RCC_EnableAHBPeriphClk(RCC_AHB_PERIPH_GPIO, ENABLE);
    LED1_Init();

    /* Reconfigure only while USART1 is clocked from APB2. */
    USART_Enable(USARTy, DISABLE);
    RCC_ConfigUsart1Clk(RCC_USART1_CLKSEL_APB2);
    USARTy_APBxClkCmd(USARTy_CLK, ENABLE);
    USART_Init(USARTy, &USART_InitStructure);
    USART_ConfigInt(USARTy, USART_INT_RXDNE, DISABLE);
    USART_EnableWakeUp(USARTy, DISABLE);
    USART_Enable(USARTy, ENABLE);
}

    RCC_EnableLsi(ENABLE);
    while (RCC_GetFlagStatus(RCC_CTRL_FLAG_LSIRDF) == RESET)
    {
    }
    RCC_ConfigLowPowerClk(RCC_LP_CLKSEL_LSI);

    /* USART1_IRQn also carries the USART1 low-power EXTI24 interrupt. */
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    NVIC_InitStructure.NVIC_IRQChannel                   = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    /* WFI requires an interrupt source: EXTI24 routes to USART1_IRQn. */
    EXTI_InitStructure.EXTI_Line    = USARTy_WKUP_EXTI_LINE;
    EXTI_InitStructure.EXTI_Mode    = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitPeripheral(&EXTI_InitStructure);

    while (1)
    {
        GPIO_ResetBits(LED1_PORT, LED1_PIN);
        USART1_PrepareStopWakeup();
        PWR_EnterSTOPMode(PWR_STOPENTRY_WFI);

        /* Only process the STOP exit after USART1_IRQHandler confirms it. */
        if (UsartWakeupFlag != 0U)
        {
            USART1_RestoreAfterStop();
            GPIO_SetBits(LED1_PORT, LED1_PIN);
            SysTick_Delay_Ms(1000);
        }
    }

void USART1_IRQHandler(void)
{
    /* Stop a level-held RXDNE from immediately retriggering this IRQ. */
    USART_ConfigInt(USARTy, USART_INT_RXDNE, DISABLE);

    if (USART_GetFlagStatus(USARTy, USART_FLAG_RXDNE) != RESET)
    {
        (void)USART_ReceiveData(USARTy);
    }

    /* Clear EXTI24 so a previous wake request cannot retrigger the IRQ. */
    EXTI_ClrITPendBit(USARTy_WKUP_EXTI_LINE);
    /* Notify main that this was a valid USART wakeup. */
    UsartWakeupFlag = 1U;
    GPIO_SetBits(LED1_PORT, LED1_PIN);
}