BvAutoController/Device/uart.c

/* Copyright Statement:
 *
 * This software/firmware and related documentation ("AutoChips Software") are
 * protected under relevant copyright laws. The information contained herein is
 * confidential and proprietary to AutoChips Inc. and/or its licensors. Without
 * the prior written permission of AutoChips inc. and/or its licensors, any
 * reproduction, modification, use or disclosure of AutoChips Software, and
 * information contained herein, in whole or in part, shall be strictly
 * prohibited.
 *
 * AutoChips Inc. (C) 2022. All rights reserved.
 *
 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
 * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("AUTOCHIPS SOFTWARE")
 * RECEIVED FROM AUTOCHIPS AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
 * ON AN "AS-IS" BASIS ONLY. AUTOCHIPS EXPRESSLY DISCLAIMS ANY AND ALL
 * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NONINFRINGEMENT. NEITHER DOES AUTOCHIPS PROVIDE ANY WARRANTY WHATSOEVER WITH
 * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
 * INCORPORATED IN, OR SUPPLIED WITH THE AUTOCHIPS SOFTWARE, AND RECEIVER AGREES
 * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
 * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
 * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN AUTOCHIPS
 * SOFTWARE. AUTOCHIPS SHALL ALSO NOT BE RESPONSIBLE FOR ANY AUTOCHIPS SOFTWARE
 * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND AUTOCHIPS'S
 * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE AUTOCHIPS SOFTWARE
 * RELEASED HEREUNDER WILL BE, AT AUTOCHIPS'S OPTION, TO REVISE OR REPLACE THE
 * AUTOCHIPS SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
 * CHARGE PAID BY RECEIVER TO AUTOCHIPS FOR SUCH AUTOCHIPS SOFTWARE AT ISSUE.
 */
/******************************************************************************
 * @version: V2.0.1  AC7840x  Demo
 ******************************************************************************/

#include "uart.h"
#include "string.h"
#include "ckgen_drv.h"
#include "ckgen_hw.h"
#include "gpio_drv.h"
#include "gpio_hw.h"
#include "uart_drv.h"
#include "uart_hw.h"
#include "uart_irq.h"
#include "dma_drv.h"
#include "dma_hw.h"
#include "cfg.h"

#define UART1_RX_DMA_CHANNEL   0
#define UART1_TX_DMA_CHANNEL   1
#define UART1_INSTANCE_ID   1

//#define UART_DATA_LEN         4  /*数据传输长度*/
uart_state_t s_uartState = {NULL}; /*UART运行变量状态*/


UART_INFO  uart1_info;

uint32_t dmaRxBuf[UART1_RECV_DATA_POOL_COUNT>>2];
uint32_t dmaTxBuf[UART1_TRANSMIT_DATA_POOL_COUNT>>2];



//uint8_t g_sendflag = 0;

void UART_TxDMAEventCallback(void *device, uint32_t wparam, uint32_t lparam);
void UART_RxDMAEventCallback(void *DMAx, uint32_t wparam, uint32_t lparam);

/* UART rx DMA channel config */
dma_channel_config_t s_uartRxDmaChConfig =
{
    .channelPriority = DMA_CHN_PRIORITY_LOW,
    .virtChnConfig = UART1_RX_DMA_CHANNEL,
    .source = DMA_REQ_UART1_RX,
    .callback = (dma_callback_t)UART_RxDMAEventCallback,
    .callbackParam = NULL,
    .enableTrigger = false,

};

/* UART tx DMA channel config */
dma_channel_config_t s_uartTxDmaChConfig =
{
    .channelPriority = DMA_CHN_PRIORITY_LOW,
    .virtChnConfig = UART1_TX_DMA_CHANNEL,
    .source = DMA_REQ_UART1_TX,
    .callback = (dma_callback_t)UART_TxDMAEventCallback,
    .callbackParam = NULL,
    .enableTrigger = false,

};

dma_chn_state_t s_uartRxDmaChState =
{
    .virtChn  = UART1_RX_DMA_CHANNEL,         /* dma virtual channel */
    .status   = DMA_CHN_NORMAL,               /* dma channel normal */
    .callback = NULL,                         /* no callback function */

};

/* UART tx dma channel state */
dma_chn_state_t s_uartTxDmaChState =
{
    .virtChn  = UART1_TX_DMA_CHANNEL,         /* dma virtual channel */
    .status   = DMA_CHN_NORMAL,               /* dma channel normal */
    .callback = NULL,
};

dma_state_t  g_dma_state;

typedef enum
{
    UART_RX_INIT   = 1,
    UART_RX_DATA   = 2,
    UART_RX_FINISH = 3,
    UART_TX_STA    = 4,
} uart_rx_step_t;

uart_rx_step_t g_uartRxStep = UART_RX_INIT;

/*!
* @brief Uart transmit event callback
* @param[in] DMAx: DMA_Type pointer
* @param[in] wparam: reserve for user's code
* @param[in] lparam: reserve for user's code
* @return none
*/
void UART_TxDMAEventCallback(void *device, uint32_t wparam, uint32_t lparam)
{

}

/*!
* @brief Uart dma receive handle
* @param[in] DMAx: DMA_Type pointer
* @param[in] wparam: reserve for user's code
* @param[in] lparam: reserve for user's code
* @return none
*/
void UART_RxDMAEventCallback(void *DMAx, uint32_t wparam, uint32_t lparam)
{

}

/*!
 * @brief   UART1接收中断回调函数
 *
 *
 * @param   none
 * @return  none
 */
void UART1_RX_Callback(void *driverState, uint32_t event, void *userData)
{
    if(event == UART_EVENT_IDLE_LINE){
			
			
				//UART_Type * uart_type = UART_DRV_GetBase(UART1_INSTANCE_ID);
				//UART_SetIdleInterrupt(uart_type, false);
			

				uint32_t rxRemainByte = UART1_RECV_DATA_POOL_COUNT;
				UART_DRV_GetReceiveStatus(UART1_INSTANCE_ID, &rxRemainByte);
				uart1_info.recv_len = UART1_RECV_DATA_POOL_COUNT - rxRemainByte;
			
				UART_DRV_AbortReceivingData(UART1_INSTANCE_ID);

		}else if(event == UART_EVENT_END_TRANSFER){
				//LED3_TOGGLE;

		}else{
		
		}
}

/*!
 * @brief   UART1发送中断回调函数
 *
 *
 * @param   none
 * @return  none
 */
void UART1_TX_Callback(void *driverState, uint32_t event, void *userData)
{
		if(UART_EVENT_TX_EMPTY == event){
		
			
		}else if(event == UART_EVENT_END_TRANSFER){

				//uart1_info.recv_len = 0;
				//UART_Type * uart_type = UART_DRV_GetBase(UART1_INSTANCE_ID);
				//UART_SetIdleInterrupt(uart_type, true);
				//UART_DRV_ReceiveData(1, uart1_info.recv_buffer, UART1_RECV_DATA_POOL_COUNT); /*接收数据*/
			
			
		}else{
		
		}

}

/**
* Uart1_Initialize
* 
* @param[in] none
* @return none
*
* @brief uart 初始化
*/
void Uart1_Initialize(void)
{
		uart_user_config_t userConfig;
		memset(&userConfig, 0U, sizeof(userConfig));
	
    /*GPIO Configuration for UART1 */
    GPIO_DRV_SetMuxModeSel(PORTC, (gpio_channel_type_t)8U, PORT_MUX_ALT2);  /* PC8: UART1_RX */
    GPIO_DRV_SetMuxModeSel(PORTC, (gpio_channel_type_t)9U, PORT_MUX_ALT2);  /* PC9: UART1_TX */

    GPIO_DRV_SetPullSel(PORTC, (gpio_channel_type_t)8U, PORT_INTERNAL_PULL_UP_ENABLED);
    GPIO_DRV_SetPullSel(PORTC, (gpio_channel_type_t)9U, PORT_INTERNAL_PULL_UP_ENABLED);	
	
	    switch(config->br_index){
			case BaudRate_4800:
				userConfig.baudRate = 4800;
				break;
			case BaudRate_9600:
				userConfig.baudRate = 9600;
				break;
			case BaudRate_19200:
				userConfig.baudRate = 19200;
				break;
			case BaudRate_38400:
				userConfig.baudRate = 38400;
				break;
			case BaudRate_57600:
				userConfig.baudRate = 57600;
				break;
			case BaudRate_115200:
				userConfig.baudRate = 115200;
				break;
			case BaudRate_230400:
				userConfig.baudRate = 230400;
				break;
			default:
				userConfig.baudRate = 115200;
				break;
		};
			
		userConfig.parityMode = UART_PARITY_DISABLED;         /*奇偶校验模式选择 */
    userConfig.stopBitCount = UART_ONE_STOP_BIT;          /*停止位选择1-bit */
    userConfig.bitCountPerChar = UART_8_BITS_PER_CHAR;    /*数据长度选择8 */
	
    userConfig.transferType = UART_USING_INTERRUPTS;             /*UART传输方式选择 (interrupt or dma) */
    userConfig.rxDMAChannel = UART1_RX_DMA_CHANNEL;       /*DMA传输方式下的DMA rx 通道*/
    userConfig.txDMAChannel = UART1_TX_DMA_CHANNEL;       /*DMA传输方式下的DMA tx 通道*/
	
		userConfig.rxCallback = UART1_RX_Callback;
		userConfig.rxCallbackParam = NULL;
		userConfig.txCallback = UART1_TX_Callback;
		userConfig.txCallbackParam = NULL;

		UART_DRV_Init(UART1_INSTANCE_ID, &s_uartState, &userConfig);
		
		UART_Type * uart_type = UART_DRV_GetBase(UART1_INSTANCE_ID);
		UART_SetIdleFunc(uart_type, true);
		UART_SetIdleInterrupt(uart_type, true);
		
		
		uart1_info.recv_buffer = (uint8_t *)dmaRxBuf;
		uart1_info.send_buffer = (uint8_t *)dmaTxBuf;
		uart1_info.recv_len = 0;
		uart1_info.send_len = 0;
		
		UART_DRV_ReceiveData(UART1_INSTANCE_ID, uart1_info.recv_buffer, UART1_RECV_DATA_POOL_COUNT); /*接收数据*/
	
}


int Uart1_TransmitData(uint8_t *pdata, uint16_t length)
{
		//UART_DRV_SendData(UART1_INSTANCE_ID, pdata, length);
		UART_DRV_SendDataBlocking(UART1_INSTANCE_ID, pdata, length, 50);
		return 0;
}


void Uart1_RecvData(void)
{
		uart1_info.recv_len = 0;
		//UART_Type * uart_type = UART_DRV_GetBase(UART1_INSTANCE_ID);
		//UART_SetIdleFunc(uart_type, true);
		//UART_SetIdleInterrupt(uart_type, true);
		UART_DRV_ReceiveData(1, uart1_info.recv_buffer, UART1_RECV_DATA_POOL_COUNT); /*接收数据*/
}

/*!
 * @brief   UART模块配置
 *          UART1配置普通UART模式，波特率115200，数据长度为8bit,停止位为1bit
 *          使能接收和发送DMA功能
 * @param   none
 * @return  none
 */
void UART1_Init(void)
{
    uart_user_config_t userConfig;

    /*GPIO Configuration for UART1 */
    GPIO_DRV_SetMuxModeSel(PORTC, (gpio_channel_type_t)8U, PORT_MUX_ALT2);  /* PC8: UART1_RX */
    GPIO_DRV_SetMuxModeSel(PORTC, (gpio_channel_type_t)9U, PORT_MUX_ALT2);  /* PC9: UART1_TX */

    GPIO_DRV_SetPullSel(PORTC, (gpio_channel_type_t)8U, PORT_INTERNAL_PULL_UP_ENABLED);
    GPIO_DRV_SetPullSel(PORTC, (gpio_channel_type_t)9U, PORT_INTERNAL_PULL_UP_ENABLED);

    memset(&userConfig, 0U, sizeof(userConfig));

    userConfig.baudRate = 115200;                         /*波特率配置 */
    userConfig.parityMode = UART_PARITY_DISABLED;         /*奇偶校验模式选择 */
    userConfig.stopBitCount = UART_ONE_STOP_BIT;          /*停止位选择1-bit */
    userConfig.bitCountPerChar = UART_8_BITS_PER_CHAR;    /*数据长度选择8 */
	
    userConfig.transferType = UART_USING_INTERRUPTS;             /*UART传输方式选择 (interrupt or dma) */
    userConfig.rxDMAChannel = UART1_RX_DMA_CHANNEL;       /*DMA传输方式下的DMA rx 通道*/
    userConfig.txDMAChannel = UART1_TX_DMA_CHANNEL;       /*DMA传输方式下的DMA tx 通道*/
	
		userConfig.rxCallback = UART1_RX_Callback;
		userConfig.rxCallbackParam = NULL;
		userConfig.txCallback = UART1_TX_Callback;
		userConfig.txCallbackParam = NULL;

		UART_DRV_Init(UART1_INSTANCE_ID, &s_uartState, &userConfig);
		
		UART_Type * uart_type = UART_DRV_GetBase(UART1_INSTANCE_ID);
		UART_SetIdleFunc(uart_type, true);
		UART_SetIdleInterrupt(uart_type, true);
	 

    /*DMA配置*/
    //DMA_DRV_Init(&g_dma_state, NULL, NULL, NULL);
    //DMA_DRV_ChannelInit(&s_uartRxDmaChState, &s_uartRxDmaChConfig);
    //DMA_DRV_ChannelInit(&s_uartTxDmaChState, &s_uartTxDmaChConfig);
		

		uart1_info.recv_buffer = (uint8_t *)dmaRxBuf;
		uart1_info.send_buffer = (uint8_t *)dmaTxBuf;
		uart1_info.recv_len = 0;
		uart1_info.send_len = 0;
		
		UART_DRV_ReceiveData(UART1_INSTANCE_ID, uart1_info.recv_buffer, UART1_RECV_DATA_POOL_COUNT); /*接收数据*/
}

/*!
 * @brief   UART数据传输处理
 *          UART查询接收数据，接收到数据后再将数据发送出去
 *
 * @param   none
 * @return  none
 */
void UART1_DATA_Proce(void)
{
		//uint32_t rxRemainByte = 0;
		#if 0
	
	  status_t status;

    status = UART_DRV_ReceiveDataPolling(1, uart1_info.recv_buffer, UART1_RECV_DATA_POOL_COUNT); /*接收数据*/
    if (status == STATUS_SUCCESS)
    {
        memcpy(uart1_info.send_buffer, uart1_info.recv_buffer, uart1_info.recv_len); /*将接收到的数据拷贝给发送数据*/
				uart1_info.send_len = uart1_info.recv_len;
				UART_DRV_SendData(UART1_INSTANCE, uart1_info.send_buffer, uart1_info.send_len);
    }
	
	#else
		if(uart1_info.recv_len > 0){
			
			memcpy(uart1_info.send_buffer, uart1_info.recv_buffer, uart1_info.recv_len); /*将接收到的数据拷贝给发送数据*/
			uart1_info.send_len = uart1_info.recv_len;
			UART_DRV_SendData(UART1_INSTANCE_ID, uart1_info.send_buffer, uart1_info.send_len);
			
			uart1_info.recv_len = 0;
		}
		
		#endif 
}