motor_bootloader/uart_driver.c

/**
  ******************************************************************************
  * @file    uart_driver.c
  * @author  
  * @version V1.0.0
  * @date    23-12-2015
  * @brief  uart driver function.
  ******************************************************************************
  *
  * COPYRIGHT(c) 2015 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* Includes ------------------------------------------------------------------*/
#include "uart_driver.h"
#include "hwsetup.h"
/* Private variables ---------------鎺ユ敹缂撳瓨鍖�------------------------------------------*/

//uint8_t UART_RxBuff1[UART_BUFF_SIZE];
//USART_Buf_TypeDef UART_RxBuff_Struct1 = {UART_BUFF_SIZE,0,0,0,0,UART_RxBuff1,UART_BAT_INST};
//uint8_t UART_TxBuff1[UART_BUFF_SIZE];
//USART_Buf_TypeDef UART_TxBuff_Struct1 = {UART_BUFF_SIZE,0,0,0,0,UART_TxBuff1,UART_BAT_INST};

uint8_t UART_RxBuff2[UART_BUFF_SIZE];
USART_Buf_TypeDef UART_RxBuff_Struct2 = {UART_BUFF_SIZE,0,0,0,0,UART_RxBuff2,UART_HMI_INST};
uint8_t UART_TxBuff2[UART_BUFF_SIZE];
USART_Buf_TypeDef UART_TxBuff_Struct2 = {UART_BUFF_SIZE,0,0,0,0,UART_TxBuff2,UART_HMI_INST};

/* Private variables ---------------------------------------------------------*/

/* Private function prototypes -----------------------------------------------*/
void USARTx_RxTX_IRQ(USART_Buf_TypeDef *USARTx_TxBuf_Struct,USART_Buf_TypeDef *USARTx_RxBuf_Struct);
uint8_t UART_ReadChar(USART_Buf_TypeDef * ptRx, uint8_t ucNum)	 
{	
    uint8_t ucData;
    uint16_t  i;
    i = ucNum;
    if ((*ptRx).ucBufCnt >= ucNum)
    {
        i += (*ptRx).ucBufRdInde;
        if (i >= (*ptRx).ucBufSize)
        {	
            i -=((*ptRx).ucBufSize);
        }
    }
    else
    {
        i=0;
    }
    ucData = *((*ptRx).pcBufAddr + i);
    return ucData;
}

void UART_DelChar(USART_Buf_TypeDef * ptRx, uint8_t ucNum)	 
{	
    uint16_t i;
    if ((*ptRx).ucBufCnt >= ucNum)	
    {	
 //      usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, FALSE);
      DL_UART_Main_disableInterrupt(ptRx->usart_periph, DL_UART_MAIN_INTERRUPT_RX);
        (*ptRx).ucBufCnt -= ucNum;	
//        usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, TRUE);
        DL_UART_Main_enableInterrupt(ptRx->usart_periph, DL_UART_MAIN_INTERRUPT_RX);
        i = ucNum;
        i += (*ptRx).ucBufRdInde;
        if (i >= (*ptRx).ucBufSize)
        {
          i -= (*ptRx).ucBufSize;
        }
        (*ptRx).ucBufRdInde = i;
    }
    else
    {  
//        usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, FALSE);
        DL_UART_Main_disableInterrupt(ptRx->usart_periph, DL_UART_MAIN_INTERRUPT_RX);
        i = (*ptRx).ucBufCnt;
        (*ptRx).ucBufCnt = 0;
//        usart_interrupt_enable(ptRx->usart_periph, USART_RDBF_INT, TRUE);
        DL_UART_Main_enableInterrupt(ptRx->usart_periph, DL_UART_MAIN_INTERRUPT_RX);
        i += (*ptRx).ucBufRdInde;
        if (i >= (*ptRx).ucBufSize)
        {
            i -= (*ptRx).ucBufSize;
        }
        (*ptRx).ucBufRdInde = i;
     }
}

void UART_PutChar(USART_Buf_TypeDef * ptTx, uint8_t ucData)
{	
    while ((*ptTx).ucBufCnt == (*ptTx).ucBufSize);
//        usart_interrupt_enable(ptTx->usart_periph, USART_TDBE_INT, FALSE);
        DL_UART_Main_disableInterrupt(ptTx->usart_periph, DL_UART_MAIN_INTERRUPT_EOT_DONE);
    if((*ptTx).ucBufCnt == 0)
    {
//        if(usart_flag_get(ptTx->usart_periph, USART_TDBE_FLAG) == SET) //check if transmit data register full or not
       // if( (DL_UART_Main_getPendingInterrupt(ptTx->usart_periph)) ==DL_UART_MAIN_IIDX_EOT_DONE)
        if(DL_UART_isTXFIFOEmpty(ptTx->usart_periph) == true)
        {
//            usart_data_transmit(ptTx->usart_periph, ucData);
            DL_UART_Main_transmitData(ptTx->usart_periph, ucData);
//            usart_interrupt_enable(ptTx->usart_periph, USART_TDBE_INT, TRUE);
            DL_UART_Main_enableInterrupt(ptTx->usart_periph, DL_UART_MAIN_INTERRUPT_EOT_DONE);
            return;
        }
    }	
    *((*ptTx).pcBufAddr + (*ptTx).ucBufWrInde) = ucData;
    if(++(*ptTx).ucBufWrInde == (*ptTx).ucBufSize)
    {
        (*ptTx).ucBufWrInde = 0;
    }
    ++(*ptTx).ucBufCnt;
//    usart_interrupt_enable(ptTx->usart_periph, USART_TDBE_INT, TRUE);
    DL_UART_Main_enableInterrupt(ptTx->usart_periph, DL_UART_MAIN_INTERRUPT_EOT_DONE);
}

void UART_SendData(USART_Buf_TypeDef * ptTx, uint8_t* Data, uint8_t Length)
{
    uint8_t i;
	
    for(i=0; i<Length; i++)
    {
        UART_PutChar(ptTx, Data[i]);
    }
}
/*******************************************************************************
* Function:void USARTx_Rx_IRQ(USART_Buf_TypeDef *USARTx_RxBuf_Struct)
* Discrible:
* Input:
* Output: 
* Return: 
* Others: 
*    date    version	  author        record
* -----------------------------------------------
* 20151107     V1.0     VINCENT       Create
*********************************************************************************/
void USARTx_Rx_IRQ(USART_Buf_TypeDef *USARTx_RxBuf_Struct)
{
    uint8_t ucData;	
	
//		if(USARTx_RxBuf_Struct->usart_periph->ctrl1_bit.rdbfien != RESET)
    if(1) //TODO
		{
//				if(RESET != usart_flag_get(USARTx_RxBuf_Struct->usart_periph, USART_RDBF_FLAG))
		    if( (DL_UART_Main_getPendingInterrupt(USARTx_RxBuf_Struct->usart_periph)) ==DL_UART_MAIN_IIDX_RX)
				{
//						ucData = (uint8_t)usart_data_receive(USARTx_RxBuf_Struct->usart_periph);
						ucData =  DL_UART_Main_receiveDataBlocking(USARTx_RxBuf_Struct->usart_periph);
						//if(((USARTx_RxBuf_Struct->ptUartHandel->Instance->SR) & 0x0000) == 0)
						{
								*((* USARTx_RxBuf_Struct).pcBufAddr + (* USARTx_RxBuf_Struct).ucBufWrInde) = ucData;         
								if(++(* USARTx_RxBuf_Struct).ucBufWrInde >= (* USARTx_RxBuf_Struct).ucBufSize)
								{
										(* USARTx_RxBuf_Struct).ucBufWrInde = 0; 
								}	
								if(++(* USARTx_RxBuf_Struct).ucBufCnt > (* USARTx_RxBuf_Struct).ucBufSize)  
								{
										(* USARTx_RxBuf_Struct).ucBufCnt = (* USARTx_RxBuf_Struct).ucBufSize;  
										(* USARTx_RxBuf_Struct).ucBufOvf = 1;
								}
						}
				}
		}
}

void USARTx_Tx_IRQ(USART_Buf_TypeDef *USARTx_TxBuf_Struct)
{
//		if(USARTx_TxBuf_Struct->usart_periph->ctrl1_bit.tdbeien != RESET)
    if(1) //TODO
		{
//				if(RESET != usart_flag_get(USARTx_TxBuf_Struct->usart_periph, USART_TDBE_FLAG))
		    if( (DL_UART_Main_getPendingInterrupt(USARTx_TxBuf_Struct->usart_periph)) ==DL_UART_MAIN_IIDX_EOT_DONE)
				{      
					//usart_interrupt_enable(USART1, USART_TDBE_INT, FALSE);
						if((* USARTx_TxBuf_Struct).ucBufCnt)
						{
								--(* USARTx_TxBuf_Struct).ucBufCnt;
								/* write one byte to the transmit data register */
//								usart_data_transmit(USARTx_TxBuf_Struct->usart_periph, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
								DL_UART_Main_transmitData(USARTx_TxBuf_Struct->usart_periph,*(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
								if(++(* USARTx_TxBuf_Struct).ucBufRdInde >= (* USARTx_TxBuf_Struct).ucBufSize)
								{
									(* USARTx_TxBuf_Struct).ucBufRdInde = 0;
								}
						}
						else
						{
								/* Disable the UART Transmit Data Register Empty Interrupt */
//								usart_interrupt_enable(USARTx_TxBuf_Struct->usart_periph, USART_TDBE_INT, FALSE);
								 DL_UART_Main_disableInterrupt(USARTx_TxBuf_Struct->usart_periph, DL_UART_MAIN_INTERRUPT_EOT_DONE);
						}
				}
		}
}

void USARTx_RxTX_IRQ(USART_Buf_TypeDef *USARTx_TxBuf_Struct,USART_Buf_TypeDef *USARTx_RxBuf_Struct)
{
    uint8_t ucData;
      switch (DL_UART_Main_getPendingInterrupt(USARTx_TxBuf_Struct->usart_periph))
         {
             case DL_UART_MAIN_IIDX_RX:
               //  ucData = (uint8_t)usart_data_receive(USARTx_RxBuf_Struct->usart_periph);
                     ucData =  DL_UART_Main_receiveDataBlocking(USARTx_RxBuf_Struct->usart_periph);
                     //if(((USARTx_RxBuf_Struct->ptUartHandel->Instance->SR) & 0x0000) == 0)
                     {
                             *((* USARTx_RxBuf_Struct).pcBufAddr + (* USARTx_RxBuf_Struct).ucBufWrInde) = ucData;
                             if(++(* USARTx_RxBuf_Struct).ucBufWrInde >= (* USARTx_RxBuf_Struct).ucBufSize)
                             {
                                     (* USARTx_RxBuf_Struct).ucBufWrInde = 0;
                             }
                             if(++(* USARTx_RxBuf_Struct).ucBufCnt > (* USARTx_RxBuf_Struct).ucBufSize)
                             {
                                     (* USARTx_RxBuf_Struct).ucBufCnt = (* USARTx_RxBuf_Struct).ucBufSize;
                                     (* USARTx_RxBuf_Struct).ucBufOvf = 1;
                             }
                     }

                 break;
             case DL_UART_MAIN_IIDX_EOT_DONE:
                 //usart_interrupt_enable(USART1, USART_TDBE_INT, FALSE);
                         if((* USARTx_TxBuf_Struct).ucBufCnt)
                         {
                                 --(* USARTx_TxBuf_Struct).ucBufCnt;
                                 /* write one byte to the transmit data register */
 //                              usart_data_transmit(USARTx_TxBuf_Struct->usart_periph, *(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
                                 DL_UART_Main_transmitData(USARTx_TxBuf_Struct->usart_periph,*(USARTx_TxBuf_Struct->pcBufAddr + USARTx_TxBuf_Struct->ucBufRdInde));
                                 if(++(* USARTx_TxBuf_Struct).ucBufRdInde >= (* USARTx_TxBuf_Struct).ucBufSize)
                                 {
                                     (* USARTx_TxBuf_Struct).ucBufRdInde = 0;
                                 }
                         }
                         else
                         {
                                 /* Disable the UART Transmit Data Register Empty Interrupt */
 //                              usart_interrupt_enable(USARTx_TxBuf_Struct->usart_periph, USART_TDBE_INT, FALSE);
                                  DL_UART_Main_disableInterrupt(USARTx_TxBuf_Struct->usart_periph, DL_UART_MAIN_INTERRUPT_EOT_DONE);
                         }



                 break;
             default:
                 break;
         }

}
//void USART1_IRQHandler(void)
void UART_BAT_INST_IRQHandler(void)//UART1_IRQHandler
{
  //  USARTx_Rx_IRQ(&UART_RxBuff_Struct1);
  //  USARTx_Tx_IRQ(&UART_TxBuff_Struct1);
  //  USARTx_RxTX_IRQ(&UART_TxBuff_Struct1,&UART_RxBuff_Struct1);
}

//void USART2_IRQHandler(void)
void UART_HMI_INST_IRQHandler(void) //UART0_IRQHandler
{
   // USARTx_Rx_IRQ(&UART_RxBuff_Struct2);
   // USARTx_Tx_IRQ(&UART_TxBuff_Struct2);
    USARTx_RxTX_IRQ(&UART_TxBuff_Struct2,&UART_RxBuff_Struct2);
}

/************************ (C) END OF FILE *********************************/