5.19 UART 使用说明

    /* Configure UARTy and UARTz */
    UART_Init(UARTy, &UART_InitStructure);
    UART_Init(UARTz, &UART_InitStructure);
    
    /* Configure UARTy 485 funtion */
    UART_CfgDriverAssertTime(UARTy,0);
    UART_CfgDriverdeassertTime(UARTy,0);
    UART_DriverPolaritySet(UARTy,DISABLE);
    UART_DriverModeSet(UARTy,ENABLE);
    /* Configure UARTz 485 funtion */
    UART_CfgDriverAssertTime(UARTz,0);
    UART_CfgDriverdeassertTime(UARTz,0);
    UART_DriverPolaritySet(UARTz,DISABLE);
    UART_DriverModeSet(UARTz,ENABLE);

    /* Configure UARTy DE as alternate function push-pull and pull-up */
    GPIO_InitStructure.Pin            = UARTy_DEPin;
    GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStructure.GPIO_Alternate = UARTy_DE_GPIO_AF;
    GPIO_InitPeripheral(UARTy_GPIO, &GPIO_InitStructure); 
    
    /* Configure UARTz DE as alternate function push-pull and pull-up */
    GPIO_InitStructure.Pin            = UARTz_DEPin;
    GPIO_InitStructure.GPIO_Alternate = UARTz_DE_GPIO_AF;
    GPIO_InitPeripheral(UARTz_GPIO, &GPIO_InitStructure); 

    /* UARTy_Tx_DMA_Channel (triggered by UARTy Tx event) Config */
    DMA_DeInit(UARTy_Tx_DMA_Channel);
    DMA_StructInit(&DMA_InitStructure);
    DMA_InitStructure.PeriphAddr     = UARTy_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(UARTy_Tx_DMA_Channel, &DMA_InitStructure);
    DMA_RequestRemap(UARTy_Tx_DMA_REMAP,DMA,UARTy_Tx_DMA_Channel,ENABLE);

    /* Wait until UARTy TX DMA Channel  Transfer Complete */
    while (DMA_GetFlagStatus(UARTy_Tx_DMA_FLAG,DMA) == RESET)
    {
    }
    
    /* Wait until UARTz RX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(UARTz_Rx_DMA_FLAG,DMA) == RESET)
    {
    }

    /* UARTz_Tx_DMA_Channel (triggered by UARTz Tx event) Config */
    DMA_DeInit(UARTz_Tx_DMA_Channel);
    DMA_InitStructure.PeriphAddr = UARTz_DAT_Base;
    DMA_InitStructure.MemAddr    = (uint32_t)TxBuffer2;
    DMA_InitStructure.Direction  = DMA_DIR_PERIPH_DST;
    DMA_InitStructure.BufSize    = TxBufferSize2;
    DMA_Init(UARTz_Tx_DMA_Channel, &DMA_InitStructure);
    DMA_RequestRemap(UARTz_Tx_DMA_REMAP,DMA,UARTz_Tx_DMA_Channel,ENABLE);

    /* Enable UARTy DMA TX request */
    UART_EnableDMA(UARTy, UART_DMAREQ_TX,ENABLE);
    /* Enable UARTz DMA TX request */
    UART_EnableDMA(UARTz, UART_DMAREQ_TX,ENABLE);

    /* Enable the UARTz Receive Interrupt */
    UART_ConfigInt(UARTz, UART_INT_RXDNE,ENABLE);

    /* Enable UARTy TX DMA Channel */
    DMA_EnableChannel(UARTy_Tx_DMA_Channel,ENABLE);
    /* Enable UARTz TX DMA Channel */
    DMA_EnableChannel(UARTz_Tx_DMA_Channel,ENABLE);

    /* Receive the TxBuffer2 */
    while (indexFlag < TxBufferSize2)
    {
        while (UART_GetFlagStatus(UARTy, UART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(UART_GetFlagStatus(UARTy, UART_FLAG_OREF) != RESET)
            {
                UARTy->DAT;
            }
        }
        RxBuffer1[indexFlag++] = UART_ReceiveData(UARTy);
    }

void UARTz_IRQHandler(void)
{
    if ((UART_GetFlagStatus(UARTz, UART_FLAG_RXDNE) != RESET) && (UART_GetIntStatus(UARTz, UART_INT_RXDNE) != RESET))
    {
        /* Read one byte from the receive data register */
        RxBuffer2[RxCounter++] = UART_ReceiveData(UARTz);

        if (RxCounter == NbrOfDataToRead)
        {
            /* Disable the UARTz Receive interrupt */
            UART_ConfigInt(UARTz, UART_INT_RXDNE, DISABLE);
        }
    }

    /* Configure UARTy and UARTz */
    UART_Init(UARTy, &UART_InitStructure);
    UART_Init(UARTz, &UART_InitStructure);

    /* Enable UARTy DMA TX request */
    UART_EnableDMA(UARTy, UART_DMAREQ_TX,ENABLE);
    /* Enable UARTz DMA Rx request */
    UART_EnableDMA(UARTz, UART_DMAREQ_RX,ENABLE);

    /* UARTz RX DMA1 Channel (triggered by UARTz Rx event) Config */
    DMA_DeInit(UARTz_Rx_DMA_Channel);
    DMA_InitStructure.PeriphAddr = UARTz_DAT_Base;
    DMA_InitStructure.MemAddr    = (uint32_t)RxBuffer2;
    DMA_InitStructure.Direction  = DMA_DIR_PERIPH_SRC;
    DMA_InitStructure.BufSize    = TxBufferSize1;
    DMA_Init(UARTz_Rx_DMA_Channel, &DMA_InitStructure);
    DMA_RequestRemap(UARTz_Rx_DMA_REMAP,DMA,UARTz_Rx_DMA_Channel,ENABLE);

    /* Wait until UARTy TX DMA Channel  Transfer Complete */
    while (DMA_GetFlagStatus(UARTy_Tx_DMA_FLAG,DMA) == RESET)
    {
    }
    
    /* Wait until UARTz RX DMA Channel Transfer Complete */
    while (DMA_GetFlagStatus(UARTz_Rx_DMA_FLAG,DMA) == RESET)
    {
    }

    /* Configure UARTy Tx as alternate function push-pull and pull-up */
    GPIO_InitStructure.Pin            = UARTy_TxPin;
    GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStructure.GPIO_Pull      = GPIO_PULL_UP;
    GPIO_InitStructure.GPIO_Alternate = UARTy_Tx_GPIO_AF;
    GPIO_InitPeripheral(UARTy_GPIO, &GPIO_InitStructure);

    /* Configure UARTz Tx as alternate function push-pull and pull-up */
    GPIO_InitStructure.Pin            = UARTz_TxPin;
    GPIO_InitStructure.GPIO_Alternate = UARTz_Tx_GPIO_AF;
    GPIO_InitPeripheral(UARTz_GPIO, &GPIO_InitStructure);

    /* Enable the UARTy and UARTz */
    UART_Enable(UARTy, ENABLE);
    UART_Enable(UARTz, ENABLE);

    /* Enable UARTy Half Duplex Mode*/
    UART_EnableHalfDuplex(UARTy, ENABLE);
    /* Enable UARTz Half Duplex Mode*/
    UART_EnableHalfDuplex(UARTz, ENABLE);

    while (NbrOfDataToRead2--)
    {
        /* Wait until end of transmit */
        while (UART_GetFlagStatus(UARTy, UART_FLAG_TXDE) == RESET)
        {
        }
        /* Write one byte in the UARTy Transmit Data Register */
        UART_SendData(UARTy, TxBuffer1[TxCounter1++]);

        /* Wait the byte is entirely received by UARTz */
        while (UART_GetFlagStatus(UARTz, UART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(UART_GetFlagStatus(UARTz, UART_FLAG_OREF) != RESET)
            {
                UARTz->DAT;
            }
        }
        /* Store the received byte in the RxBuffer2 */
        RxBuffer2[RxCounter2++] = UART_ReceiveData(UARTz);
    }

    /* Enable UARTy Receive and Transmit interrupts */
    UART_ConfigInt(UARTy, UART_INT_RXDNE, ENABLE);
    UART_ConfigInt(UARTy, UART_INT_TXDE, ENABLE);

    /* Enable UARTz Receive and Transmit interrupts */
    UART_ConfigInt(UARTz, UART_INT_RXDNE, ENABLE);
    UART_ConfigInt(UARTz, UART_INT_TXDE, ENABLE);

    /* Enable the UARTy Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel         = UARTy_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPriority = NVIC_PRIORITY_0;
    NVIC_InitStructure.NVIC_IRQChannelCmd      = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    /* Enable the UARTz Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel         = UARTz_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPriority = NVIC_PRIORITY_1;
    NVIC_InitStructure.NVIC_IRQChannelCmd      = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

void UARTy_IRQHandler(void)
{
    if ((UART_GetFlagStatus(UARTy, UART_FLAG_RXDNE) != RESET) && (UART_GetIntStatus(UARTy, UART_INT_RXDNE) != RESET))
    {
        /* Read one byte from the receive data register */
        RxBuffer1[RxCounter1++] = UART_ReceiveData(UARTy);

        if (RxCounter1 == NbrOfDataToRead1)
        {
            /* Disable the UARTy Receive interrupt */
            UART_ConfigInt(UARTy, UART_INT_RXDNE, DISABLE);
        }
    }

    if ((UART_GetFlagStatus(UARTy, UART_FLAG_TXDE) != RESET) && (UART_GetIntStatus(UARTy, UART_INT_TXDE) != RESET))
    {
        /* Write one byte to the transmit data register */
        UART_SendData(UARTy, TxBuffer1[TxCounter1++]);

        if (TxCounter1 == NbrOfDataToTransfer1)
        {
            /* Disable the UARTy Transmit interrupt */
            UART_ConfigInt(UARTy, UART_INT_TXDE, DISABLE);
        }
    }

    /* System Clocks Configuration */
    RCC_Configuration();

    RCC_ConfigPclk(RCC_HCLK_DIV8);
    /* NVIC configuration */
    NVIC_Configuration();

    /* Configure the GPIO ports */
    GPIO_Configuration();
    
    /* GPIO PB4 Output 38KHz Clock */
    ADVANCE_TIM_Init();

    UART_InitStructure.Mode       = UART_MODE_TX;
    UART_Init(UARTy, &UART_InitStructure);
    UART_InitStructure.Mode       = UART_MODE_RX;
    UART_Init(UARTz, &UART_InitStructure);

    /* Enable UARTz Receive and Transmit interrupts */
    UART_ConfigInt(UARTz, UART_INT_RXDNE, ENABLE);
    
    /* Set the UARTy and UARTz prescaler */
    UART_SetPrescaler(UARTy, 210);
    UART_SetPrescaler(UARTz, 210);
    /* Configure the UARTy IrDA mode */
    UART_ConfigIrDAMode(UARTy, UART_IRDAMODE_LOWPPWER);
    UART_ConfigIrDAMode(UARTz, UART_IRDAMODE_LOWPPWER);
    
    /* Enable the UARTy and UARTz IrDA mode */
    UART_EnableIrDA(UARTy,ENABLE);
    UART_EnableIrDA(UARTz,ENABLE);

    while (TxCounter < TxBufferSize1)
    {
        /* Send one byte from Board1_UARTy to Board2_UARTz */
        UART_SendData(UARTy, TxBuffer1[TxCounter++]);
        /* Loop until Board1_UARTy DAT register is empty */
        while (UART_GetFlagStatus(UARTy, UART_FLAG_TXDE) == RESET)
        {
        }
    }

    /* Configure the GPIO ports */
    GPIO_Configuration();
    
    /* GPIO PC2 Output 38KHz Clock */
    ADVANCE_TIM_Init();

    /* UARTy and UARTz configuration */
    UART_StructInit(&UART_InitStructure);
    UART_InitStructure.BaudRate   = 1200;
    UART_InitStructure.WordLength = UART_WL_8B;
    UART_InitStructure.StopBits   = UART_STPB_1;
    UART_InitStructure.Parity     = UART_PE_NO;
    UART_InitStructure.OverSampling        = UART_16OVER;

    /* Set the UARTy and UARTz prescaler */
    UART_SetPrescaler(UARTy, 0x01);
    UART_SetPrescaler(UARTz, 0x01);
    /* Configure the UARTy IrDA mode */
    UART_ConfigIrDAMode(UARTy, UART_IRDAMODE_NORMAL);
    UART_ConfigIrDAMode(UARTz, UART_IRDAMODE_NORMAL);
    
    /* Enable the UARTy and UARTz IrDA mode */
    UART_EnableIrDA(UARTy,ENABLE);
    UART_EnableIrDA(UARTz,ENABLE);

    while (TxCounter < TxBufferSize1)
    {
        /* Send one byte from Board1_UARTy to Board2_UARTz */
        UART_SendData(UARTy, TxBuffer1[TxCounter++]);
        /* Loop until Board1_UARTy DAT register is empty */
        while (UART_GetFlagStatus(UARTy, UART_FLAG_TXDE) == RESET)
        {
        }
    }
    while (RxCounter < TxBufferSize1)
    {
    }

    /* UARTx configuration */
    UART_StructInit(&UART_InitStructure);
    UART_InitStructure.BaudRate            = 9600;
    UART_InitStructure.WordLength          = UART_WL_8B;
    UART_InitStructure.StopBits            = UART_STPB_1;
    UART_InitStructure.Parity              = UART_PE_NO;
    UART_InitStructure.OverSampling        = UART_16OVER;
    UART_InitStructure.Mode                = UART_MODE_RX | UART_MODE_TX;
    /* Configure UARTx */
    UART_Init(UARTx, &UART_InitStructure);
    /* Enable the UARTx LIN mode*/
    UART_ConfigLINBreakDetectLength(UARTx,UART_LINBDL_10B);
    UART_EnableLIN(UARTx,ENABLE);
    /* Enable the UARTx */
    UART_Enable(UARTx,ENABLE);

void MasterSendBytes(uint8_t *pBuf, uint8_t Len)
{
    UART_SendBreak(UARTx);
    while(Len--)
    {
        while(UART_GetFlagStatus(UARTx, UART_FLAG_TXC) == RESET);
        UART_SendData(UARTx, *pBuf++);
    }
    while(UART_GetFlagStatus(UARTx, UART_FLAG_TXC ) == RESET);
}

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);
}

    /* Configure UARTx */
    UART_Init(UARTx, &UART_InitStructure);
    /* Enable the UARTx LIN mode*/
    UART_ConfigLINBreakDetectLength(UARTx,UART_LINBDL_10B);
    UART_EnableLIN(UARTx,ENABLE);
    
    /* Enable UARTx Receive and Transmit interrupts */
    UART_ConfigInt(UARTx, UART_INT_RXDNE,ENABLE);
    UART_ConfigInt(UARTx, UART_INT_LINBD,ENABLE);
    
    /* Enable the UARTx */
    UART_Enable(UARTx,ENABLE);

void LIN_IRQHandler(void)
{
    if(UART_GetFlagStatus(UARTx, UART_FLAG_LINBD) == SET)
    {
        UART_ClrFlag(UARTx, UART_FLAG_LINBD);//Clear the LIN interval field detection flag bit
        //Read the status register and data register and clear the FE flag
        UARTx->STS;
        UARTx->DAT;
        LinRxState = SYNCH;
        return;
    }
    
    if (UART_GetFlagStatus(UARTx, UART_FLAG_RXDNE)  == SET)
    {
        UART_ClrFlag(UARTx, UART_FLAG_RXDNE); //Clear the receive interrupt flag bit
        if(UART_GetFlagStatus(UARTx, UART_FLAG_FEF) == RESET)
        {
            LIN_EX_RxAsync((uint8_t)UART_ReceiveData(UARTx));
        }
    }
    
    /* Determine if an error flag still exists and clear the error flag */
    if ((UART_GetFlagStatus(UARTx, UART_FLAG_OREF) != RESET)  || \
        (UART_GetFlagStatus(UARTx, UART_FLAG_NEF) != RESET)  || \
        (UART_GetFlagStatus(UARTx, UART_FLAG_PEF) != RESET)  || \
        (UART_GetFlagStatus(UARTx, UART_FLAG_FEF) != RESET))
    {
        /*Read the sts register first,and the read the DAT register to clear the all error flag*/
        (void)UARTx->STS;
        (void)UARTx->DAT;
        /* Under normal circumstances, all error flags will be cleared when the upper data is read and will not be executed here; 
           users can add their own processing according to the actual scenario. */
    }
}

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;
}

    /* USARTy and USARTz configuration */
    UART_StructInit(&UART_InitStructure);
    UART_InitStructure.BaudRate   = 115200;
    UART_InitStructure.WordLength = UART_WL_9B;
    UART_InitStructure.StopBits   = UART_STPB_1;
    UART_InitStructure.Parity     = UART_PE_NO;
    UART_InitStructure.OverSampling        = UART_16OVER;
    UART_InitStructure.Mode       = UART_MODE_RX | UART_MODE_TX;

    /* Configure UARTy and USARTz */
    UART_Init(UARTy, &UART_InitStructure);
    UART_Init(UARTz, &UART_InitStructure);

    /* Enable the UARTy and UARTz */
    UART_Enable(UARTy, ENABLE);
    UART_Enable(UARTz, ENABLE);

    /* Set the UARTy and UARTz Address */
    UART_SetAddr(UARTy, 0x1);
    UART_SetAddr(UARTz, 0x2);

    /* Select the UARTz WakeUp Method */
    UART_ConfigWakeUpMode(UARTz, UART_WUM_ADDRMASK);

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

        /* Wait while UARTy TXE = 0 */
        while(UART_GetFlagStatus(UARTy, UART_FLAG_TXDE) == RESET)
        {
        }

        if (UART_GetFlagStatus(UARTz, UART_FLAG_RXDNE) != RESET)
        {
            if (UART_ReceiveData(UARTz) == 0x33)
            {
                LED1_ON;
                Delay(0x1FFFFF);
                LED1_OFF;
                Delay(0x1FFFFF);
            }
            /* Overflow data loss */
            if(UART_GetFlagStatus(UARTz, UART_FLAG_OREF) != RESET)
            {
                UARTz->DAT;
            }
        }
    }

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

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

        ControlFlag = 1;
    }
    else if (ControlFlag == 1)
    {
        /* Send the address mark (0x102) to wakeup UARTz */
        UART_SendData(UARTy, 0x102);
        /* Wait while UARTy TXE = 0 */
        while (UART_GetFlagStatus(UARTy, UART_FLAG_TXDE) == RESET)
        {
        }

        ControlFlag = 2;
    }

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

    /* UARTy and UARTz configuration */
    UART_StructInit(&UART_InitStructure);
    UART_InitStructure.BaudRate   = 115200;
    UART_InitStructure.WordLength = UART_WL_8B;
    UART_InitStructure.StopBits   = UART_STPB_1;
    UART_InitStructure.Parity     = UART_PE_NO;
    UART_InitStructure.OverSampling        = UART_16OVER;
    UART_InitStructure.Mode       = UART_MODE_RX | UART_MODE_TX;

    /* Configure UARTy and UARTz */
    UART_Init(UARTy, &UART_InitStructure);
    UART_Init(UARTz, &UART_InitStructure);

    /* Enable the UARTy and UARTz */
    UART_Enable(UARTy, ENABLE);
    UART_Enable(UARTz, ENABLE);

    while (TxCounter1 < TxBufferSize1)
    {
        /* Send one byte from UARTy to UARTz */
        UART_SendData(UARTy, TxBuffer1[TxCounter1++]);
        /* Loop until UARTy DAT register is empty */
        while (UART_GetFlagStatus(UARTy, UART_FLAG_TXDE) == RESET)
        {
        }

        /* Loop until the UARTz Receive Data Register is not empty */
        while (UART_GetFlagStatus(UARTz, UART_FLAG_RXDNE) == RESET)
        {
            /* Overflow data loss */
            if(UART_GetFlagStatus(UARTz, UART_FLAG_OREF) != RESET)
            {
                UARTz->DAT;
            }
        }
        /* Store the received byte in RxBuffer */
        RxBuffer2[RxCounter2++] = UART_ReceiveData(UARTz);
    }    

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

int main(void)
{
    /* Configure UART1 */
    log_init();
    /* Use the printf function to output a message on the upper computer */
    printf("This is a Printf demo of UART.\n\r");

    while (1)
    {
    }
}

    RCC_EnableAPBPeriphClk(LOG_PERIPH | LOG_PERIPH_GPIO, ENABLE);

    GPIO_InitStructure.Pin            = LOG_TX_PIN;
    GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStructure.GPIO_Alternate = GPIO_AF4;
    GPIO_InitStructure.GPIO_Pull      = GPIO_PULL_UP;
    GPIO_InitPeripheral(LOG_GPIO, &GPIO_InitStructure);

    GPIO_InitStructure.Pin             = LOG_RX_PIN;
    GPIO_InitStructure.GPIO_Alternate  = GPIO_AF4;
    GPIO_InitPeripheral(LOG_GPIO, &GPIO_InitStructure);

    USART_InitStructure.BaudRate            = 115200;
    USART_InitStructure.WordLength          = UART_WL_8B;
    USART_InitStructure.StopBits            = UART_STPB_1;
    USART_InitStructure.Parity              = UART_PE_NO;
    USART_InitStructure.Mode                = UART_MODE_RX | UART_MODE_TX;
    USART_InitStructure.OverSampling        = UART_16OVER;

    // init uart
    UART_Init(LOG_UARTx, &USART_InitStructure);

    // enable uart
    UART_Enable(LOG_UARTx, ENABLE);

int fputc(int ch, FILE* f)
{
    if (ch == '\r')
    {
        is_lr_sent = 1;
    }
    else if (ch == '\n')
    {
        if (!is_lr_sent)
        {
            /* Loop until the end of transmission */
            while (UART_GetFlagStatus(LOG_UARTx, UART_FLAG_TXC) == RESET)
            {
            }
            UART_SendData(LOG_UARTx, (uint8_t)'\r');
        }
        is_lr_sent = 0;
    }
    else
    {
        is_lr_sent = 0;
    }
    /* Loop until the end of transmission */
    while (UART_GetFlagStatus(LOG_UARTx, UART_FLAG_TXC) == RESET)
    {
    }
    UART_SendData(LOG_UARTx, (uint8_t)ch);
    return ch;
}

    /* Enable PWR/UART3/GPIO Clock */
    RCC_EnableAPBPeriphClk(RCC_APB_PERIPH_PWR | RCC_APB_PERIPH_UART3 | RCC_APB_PERIPH_GPIO, ENABLE);

    /* Configure the GPIO ports */
    GPIO_Configuration();
    
    /*Configure key EXTI line*/
    EXTI_InitStructure.EXTI_Line = EXTI_LINE10;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Event;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitPeripheral(&EXTI_InitStructure);
    
    /* Configure the system clock as LSI */
    SetSysClock_LSI();
    /* Choose LSI as the clock source for UART3 */
    RCC_ConfigUart3Clk(RCC_UART3_CLKSRC_LSI);

    while (1)
    {
        /* Insert a long delay */
        SysTick_Delay_Ms(1000);
        
        if(UART_GetFlagStatus(UART3,UART_FLAG_RXDNE) == SET)
        {
            if(UART_ReceiveData(UART3) == 0x55)
            {
                /* configure uart3 wakeup mode */
                UART_CfgWakeupMode(UART3,UART_WAKEUP_DATACLR,UART_WAKEUP_ENABLE);
                /* Enter STOP mode */
                PWR_EnterSTOPMode(PWR_STOPENTRY_WFE);
                /* Configure UARTy and UARTz */
                UART_DeInit(UARTy);
                UART_Init(UARTy, &UART_InitStructure);
                /* Enable the UARTy and UARTz */
                UART_Enable(UARTy, ENABLE);
            }
        }
        else
        {
            UART_SendData(UART3,cnt_temp++);
        }

ErrorStatus SetSysClock_LSI(void)
{
    uint32_t timeout_value = 0xFFFFFFFF; 
    
    /* Wait till LSI is ready */
    if (RCC_GetFlagStatus(RCC_CLKINT_FLAG_LSIRDF) == SET)
    {
        /* HCLK = SYSCLK */
        RCC_ConfigHclk(RCC_SYSCLK_DIV1);

        /* PCLK = HCLK */
        RCC_ConfigPclk(RCC_HCLK_DIV1);
    
        RCC_ConfigSysclk(RCC_SYSCLK_SRC_LSI);
        while (RCC_GetSysclkSrc() != RCC_CFG_SCLKSTS_LSI)
        {
            if ((timeout_value--) == 0)
            {
                return ERROR;
            }
        }
        
        FLASH_SetLatency(FLASH_LATENCY_0);
    }
    else
    {
        /* If LSI fails to start-up, the application will have wrong clock
           configuration. User can add here some code to deal with this error */
        return ERROR;
    }
    return SUCCESS;

}