AirControlValve/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) 2016. 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.
 */
 
#include "ac780x_uart_reg.h"
#include "ac780x_dma.h"
#include "uart.h" 
#include "gpio.h"
#include "cfg.h"

//#include "Comm.h"

#define UART485   UART1
#define UART485_IRQn  UART1_IRQn


UART_INFO  rs485_info;

uint32_t dmaRxBuf[UART_RECV_DATA_POOL_COUNT>>2];
uint32_t dmaTxBuf[UART_TRANSMIT_DATA_POOL_COUNT>>2];


int TransmitData(uint8_t *pdata, uint16_t length);


void Rs485_Timer1_CB(void)
{
		if(rs485_info.dmasend_count < 0xFF){
					rs485_info.dmasend_count++;
		}
}

/**
* UARTTX_DMA_EventCallback
*
* @param[in] device: DMA_Type pointer
* @param[in] wpara: DMA Channel Status
* @param[in] lpara: reserve for user's code
* @return    none
*
* @brief   uart transmit event callback
*/
void UartTxDMAEventCallback(void *device, uint32_t wpara, uint32_t lpara)
{
    if (wpara & DMA_CHANNEL_STATUS_FINISH_Msk)    //!<DMA finish
    {
			 rs485_info.dmasend_count = UART_DMASEND_COUNT_END;
    }
    else if (wpara & DMA_CHANNEL_STATUS_HALF_FINISH_Msk)  //!<DMA half finish
    {
        
    }
    else if (wpara & DMA_CHANNEL_STATUS_TRANS_ERROR_Msk)  //!<DMA error
    {
        
    }
    else
    {
        //!<never be here
    }
}

/**
* UARTRX_DMA_EventCallback
*
* @param[in] device: DMA_Type pointer
* @param[in] wpara: DMA Channel Status
* @param[in] lpara: reserve for user's code
* @return    none
*
* @brief   uart dma receive handle
*/
static void UartRxDMAEventCallback(void *device, uint32_t wpara, uint32_t lpara)
{
    /* Check if DMA Channel Receive Complete */
    if (wpara & DMA_CHANNEL_STATUS_FINISH_Msk)    //!<DMA finish
    {

    }
    else if (wpara & DMA_CHANNEL_STATUS_HALF_FINISH_Msk)  //!<DMA half finish
    {
        
    }
    else if (wpara & DMA_CHANNEL_STATUS_TRANS_ERROR_Msk)  //!<DMA error
    {
        
    }
    else
    {
        //!<never be here
    }
}

/**
* UARTRX_DMA_EventCallback
*
* @param[in] device: UART_Type pointer
* @param[in] wpara: UART lsr0 register
* @param[in] lpara: UART lsr1 register
* @return    none
*
* @brief   uart dma receive handle
*/
static void UartRxIdleCallBack(void *device, uint32_t wpara, uint32_t lpara)
{
    /* Check if IDLE interrupt happened */
    if (lpara & UART_LSR1_IDLE_Msk)
    {
				// 关闭DMA
				DMA_SetChannel(DMA0_CHANNEL1, DISABLE);
			
        ///接收不足4字节会在DMA fifo中缓存
        rs485_info.recv_len = DMA0_CHANNEL1->DATA_TRANS_NUM + DMA0_CHANNEL1->FIFO_LEFT_NUM;
			
        ///将DMA fifo数据flush出来，因为mem设置为32bit，所以fifo也是4字节对齐
        ///(即使fifo里只有1个字节也会刷出4字节，需要保证缓存冗余不会溢出)
        DMA_ChannelFlush(DMA0_CHANNEL1);
			  //DMA_SetChannel(DMA0_CHANNEL1, DISABLE);
			
    }
}


/**
* rs485_Initialize
* 
* @param[in] none
* @return none
*
* @brief rs485 初始化
*/
void rs485_Initialize(void)
{
    UART_ConfigType  uartConfig = {0}; 
		
    switch(config->br_index){
			case BaudRate_4800:
				uartConfig.baudrate = 4800;
				break;
			case BaudRate_9600:
				uartConfig.baudrate = 9600;
				break;
			case BaudRate_19200:
				uartConfig.baudrate = 19200;
				break;
			case BaudRate_38400:
				uartConfig.baudrate = 38400;
				break;
			case BaudRate_57600:
				uartConfig.baudrate = 57600;
				break;
			case BaudRate_115200:
				uartConfig.baudrate = 115200;
				break;
			case BaudRate_230400:
				uartConfig.baudrate = 230400;
				break;
			default:
				uartConfig.baudrate = 9600;
				break;
		};
		//uartConfig.baudrate = UART0_BaudRate;
    uartConfig.dataBits = UART_WORD_LEN_8BIT;
    uartConfig.stopBits = UART_STOP_1BIT;
    uartConfig.parity = UART_PARI_NO;
    uartConfig.fifoByteEn = ENABLE; ///<must enable fifoByte when use DMA
    uartConfig.dmaEn = UART_DMA_TXRX_EN;
	
		
    uartConfig.callBack = UartRxIdleCallBack;   ///<uart2 interrupt callback
    UART_Init(UART485, &uartConfig);
    UART485->IDLE |= UART_IDLE_IDLEIE_Msk | UART_IDLE_ILEN_Msk;    ///<enable uart idle interrupt
    
    ///Enable UARTx interrupt
    NVIC_SetPriority(UART485_IRQn, 5);
    NVIC_ClearPendingIRQ(UART485_IRQn);
    NVIC_EnableIRQ(UART485_IRQn);
		
		rs485_info.dmasend_count = 0;
		rs485_info.recv_buffer = (uint8_t *)dmaRxBuf;
		rs485_info.send_buffer = (uint8_t *)dmaTxBuf;
		rs485_info.recv_len = 0;
		rs485_info.send_len = 0;
		
		UART_ReceiveDMA(UART485, DMA0_CHANNEL1, rs485_info.recv_buffer, UART_RECV_DATA_POOL_COUNT, UartRxDMAEventCallback); 
    
}

/**
* TransmitData
* 
* @param[in] pdata :发送数据指针
* @param[in] length :发送数据长度
* @return none
*
* @brief uart 发送函数，通过中断发送 
*/
int rs485_TransmitData(uint8_t *pdata, uint16_t length) 
{
						
		RS485_TX_EN; 
		rs485_info.dmasend_count = UART_DMASEND_COUNT_START;
		UART_TransmitDMA(UART485, DMA0_CHANNEL0, pdata, length, UartTxDMAEventCallback); 

		//uart0_info.recv_len=0;
		//UART_ReceiveDMA(UARTx, DMA0_CHANNEL1, uart0_info.recv_buffer, UART0_RECV_DATA_POOL_COUNT, UartRxDMAEventCallback); 
		
    return 0;
}

void rs485_RecvData(void)
{
		rs485_info.recv_len=0;
		UART_ReceiveDMA(UART485, DMA0_CHANNEL1, rs485_info.recv_buffer, UART_RECV_DATA_POOL_COUNT, UartRxDMAEventCallback); 
}