ADC DMA data occasionally has errors

/*
 * dma.c
 *
 *  Created on: 2019楠烇拷2閺堬拷25閺冿拷
 *      Author: hxq
 */
#include <stdint.h>
#include <stddef.h>
#include <string.h>
/* POSIX Header files */
//#include <pthread.h>

/* Driver Header files */
#include <ti/drivers/ADC.h>
#include <ti/display/Display.h>
#include <ti/drivers/UART.h>

//#include <C:/ti/xdctools_3_50_08_24_core/packages/xdc/std.h>
//#include <ti/sysbios/knl/Clock.h>
//#include <ti/sysbios/knl/Task.h>

#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/devices/cc32xx/inc/hw_ocp_shared.h>
#include <ti/devices/cc32xx/inc/hw_memmap.h>
#include <ti/devices/cc32xx/inc/hw_adc.h>
#include <ti/devices/cc32xx/inc/hw_types.h>
#include <ti/devices/cc32xx/driverlib/rom.h>
#include <ti/devices/cc32xx/driverlib/rom_map.h>
#include <ti/devices/cc32xx/driverlib/adc.h>
#include <ti/devices/cc32xx/driverlib/gpio.h>
#include <ti/devices/cc32xx/driverlib/pin.h>
#include <ti/devices/cc32xx/driverlib/prcm.h>
#include <ti/devices/cc32xx/driverlib/spi.h>
#include <ti/devices/cc32xx/driverlib/sdhost.h>
#include <ti/devices/cc32xx/driverlib/timer.h>
#include <ti/devices/cc32xx/driverlib/uart.h>
#include <ti/devices/cc32xx/driverlib/udma.h>
#include <ti/devices/cc32xx/driverlib/wdt.h>


#include <ti/devices/cc32xx/inc/hw_memmap.h>
#include <ti/devices/cc32xx/inc/hw_ocp_shared.h>
#include <ti/devices/cc32xx/inc/hw_ints.h>
#include <ti/devices/cc32xx/inc/hw_types.h>
#include <ti/devices/cc32xx/inc/hw_adc.h>
#include <ti/devices/cc32xx/inc/hw_udma.h>

/* Driverlib Header Files */
#include <ti/devices/cc32xx/driverlib/rom.h>
#include <ti/devices/cc32xx/driverlib/rom_map.h>
#include <ti/devices/cc32xx/driverlib/udma.h>
#include <ti/devices/cc32xx/driverlib/adc.h>
#include <ti/devices/cc32xx/driverlib/interrupt.h>


/* Driver Header files */
#include <ti/drivers/GPIO.h>
#include <UDMACC32XX.h>
#include <ti/drivers/ADC.h>
#include <ti/drivers/adc/ADCCC32XX.h>
#include <ti/drivers/dpl/swip.h>


/* Example/Board Header files */
//#include "Board.h"
#include "uart_term.h"
#include "network_terminal.h"
#include "timeConfig.h"


void TempADC(uint16_t *temp);
void tempADCopen(void);
void tempADCclose(void);

void vMyOwnDMAInit(void);
void vMyOwnADCInit(void);
void vMyOwnDmaAdcInit(void);
void ADCIntHandler(void);
//UART_Handle uart;
uint16_t   sample;
UDMACC32XX_Handle udma;
ADC_Handle adc_ch2;
int dma_flag = 1; //0
int dmaDropCount = 0;
bool ADCDMABufFull = FALSE;

#define ADC_LEN 1024   //閺佺増宓侀梹鍨
#ifndef ADC_DMA_BUFFERSIZE
#define ADC_DMA_BUFFERSIZE 1027
#endif
unsigned short uShADCDMABufferPing[ADC_DMA_BUFFERSIZE + 5] = {0xFEFF};
unsigned short uShADCDMABufferPong[ADC_DMA_BUFFERSIZE + 5] = {0xFEFF};
unsigned short uShADCDMABufferNull[ADC_DMA_BUFFERSIZE] = {0xFEFF};
static ADCDMABuffer_t gADCDMABuffer[MAX_ADC_DMA_LEN + 1];
static int readADCDMAIdx = 0;
static int writeADCDMAIdx = 0;

#ifdef DMABUFFER2
static ADCDMABuffer_t gADCDMABufferSend[MAX_ADC_DMA_LEN + 1];
static int readADCDMASendIdx = 0;
static int writeADCDMASendIdx = 0;
static int remainCnt = 1, start = 2;
static int gBufIdx = 0;
int dmaDropSendCount = 0;
#endif

extern unsigned char checkdma;


ADC_Handle   adc;
ADC_Params   params;

SwiP_Handle swi0;

void swiFunc(uintptr_t arg0, uintptr_t arg1)
{
    //int key1;
    //key1 = SwiP_disable();

    UART_PRINT("swiFunc:%d,in ISR:%d........\n\r", SwiP_getTrigger(), SwiP_inISR());

    //SwiP_restore(key1);
}

void swi_create(void)
{
    SwiP_Params swiParams;

    SwiP_Params_init(&swiParams);
    swi0 = SwiP_create(swiFunc, &swiParams);
    if (swi0 ==  NULL)
    {
        UART_PRINT( "Swi create failed");
    }
    //SwiP_setPriority(swi0, 6);
}

//闁插洦淇惔锟?
void TempADC(uint16_t *temp)
{

    /* Blocking mode conversion */
    ADC_convert(adc, temp);

//    ADC_close(adc);
}

void tempADCopen(void)
{
    ADC_Params_init(&params);
    adc = ADC_open(0, &params); //pin59

}

void tempADCclose(void)
{
    if(adc == ADC_STATUS_SUCCESS)
    {
        ADC_close(adc);
    }
}

/*****************adc pin58888888888***************/


void vMyOwnDmaAdcInit()
{
    //vMyOwnDMAInit();
    vMyOwnADCInit();
}

void addReadADCDMAIdx(void)
{
    readADCDMAIdx = (readADCDMAIdx + 1) % MAX_ADC_DMA_LEN;
}

void addWriteADCDMAIdx(void)
{
    writeADCDMAIdx = (writeADCDMAIdx + 1) % MAX_ADC_DMA_LEN;
}

void resetRWADCDMAIdx(void)
{
    readADCDMAIdx = 0;
    writeADCDMAIdx = 0;
}

void initGADCDMABuffer(void)
{
    int i;

    /*init global adc dma buffer*/
    for(i = 0; i < MAX_ADC_DMA_LEN; i++)
    {
        gADCDMABuffer[i].used = FALSE;
        gADCDMABuffer[i].buf[0] = 0xFEFF;
        gADCDMABuffer[i].buf[ADC_DMA_BUFFERSIZE - 1] = 0xFCFB;
    }

#ifdef DMABUFFER2
    for(i = 0; i < MAX_ADC_DMA_LEN; i++)
    {
        gADCDMABufferSend[i].used = FALSE;
        gADCDMABufferSend[i].buf[0] = 0xFEFF;
        gADCDMABufferSend[i].buf[ADC_DMA_BUFFERSIZE - 1] = 0xFCFB;
    }
#endif

    uShADCDMABufferNull[0] = 0xFEFF;
    uShADCDMABufferNull[ADC_DMA_BUFFERSIZE - 1] = 0xFCFB;
}

bool sampleIsFinish(int idx)
{
    bool ret = FALSE;
    int vibrationRate = gRxTime.vibrationRate;

    if(vibrationRate == 62500 && idx == 62) //62.5K
    {
        ret = TRUE;
    }
    else if(vibrationRate == 10000 && idx == 10) //10K
    {
        ret = TRUE;
    }
    else if(vibrationRate == 1000 && idx == 1) //1K
    {
        ret = TRUE;
    }

#if 0
    if(ret)
        UART_PRINT("%s:%d-rate:%d,ret,%d\n\r", __FUNCTION__, __LINE__, vibrationRate, ret);
#endif
    return ret;
}

unsigned short *mallocGADCDMABuffer(void)
{
    unsigned short *p = uShADCDMABufferNull; //default write into drop buffer
    int idx;

    idx = writeADCDMAIdx;
    if(dma_flag == 0)
    {
        p = uShADCDMABufferNull;
    }
    else if(
#ifdef SAMPLE_INTERVAL
        !sampleIsFinish(idx) &&
#endif
        gADCDMABuffer[idx].used == FALSE)
    {
        UART_PRINT("writeADCDMAIdx=[%d]\n\r", idx);
        p = gADCDMABuffer[idx].buf;
#if 0
        gADCDMABuffer[idx].used = TRUE;
        addWriteADCDMAIdx();
#endif
    }
    else
    {
#ifdef SAMPLE_INTERVAL
        ADCDMABufFull = TRUE;
#endif
        //UART_PRINT("DMABuffer full=[%d] error!\n",idx);
        dmaDropCount++;
    }

    return p;
}

bool canReadDMABuffer(void)
{
    int diff;

    if(readADCDMAIdx < writeADCDMAIdx)
    {
        diff = writeADCDMAIdx - readADCDMAIdx;
    }
    else
    {
        diff = writeADCDMAIdx + MAX_ADC_DMA_LEN - readADCDMAIdx;
    }

    //UART_PRINT("diff=[%d]\n\r", diff);
    if(diff >= 2)
        return TRUE;

    return FALSE;
}

unsigned short *readGADCDMABuffer(void)
{
    unsigned short *p = NULL; //default
    int idx;

    idx = readADCDMAIdx;
    if(gADCDMABuffer[idx].used == TRUE && canReadDMABuffer())
    {
        //UART_PRINT("readADCDMAIdx=[%d]\n\r", idx);
        p = gADCDMABuffer[idx].buf;
    }

    return p;
}

void writeGADCDMABufferDone(void)
{
    int idx;

    idx = writeADCDMAIdx;
    gADCDMABuffer[idx].used = TRUE;
    addWriteADCDMAIdx();

}

void readGADCDMABufferDone(void)
{
    int idx;

    idx = readADCDMAIdx;
    gADCDMABuffer[idx].used = FALSE;
    addReadADCDMAIdx();
}

#ifdef DMABUFFER2
void addReadADCDMASendIdx(void)
{
    readADCDMASendIdx = (readADCDMASendIdx + 1) % MAX_ADC_DMA_LEN;
}

void addWriteADCDMASendIdx(void)
{
    writeADCDMASendIdx = (writeADCDMASendIdx + 1) % MAX_ADC_DMA_LEN;
}

bool addBufIdx(int add)
{
    int diff;
    bool ret = FALSE;

    diff = (gBufIdx + add) - ADC_LEN;
    if(diff >= 0)
        ret = TRUE;

    gBufIdx = (gBufIdx + add) % ADC_LEN;

    return ret;
}

unsigned short *mallocGADCDMABufferSend(void)
{
    unsigned short *p = NULL; //default write into drop buffer
    int idx;

    idx = writeADCDMASendIdx;
    if(gADCDMABufferSend[idx].used == FALSE)
    {
        //UART_PRINT("writeADCDMASendIdx=[%d]\n\r", idx);
        p = gADCDMABufferSend[idx].buf;
    }
    else
    {
        //UART_PRINT("gADCDMABufferSend full=[%d] error!\n",idx);
        dmaDropSendCount++;
    }

    return p;
}

unsigned short *readGADCDMABufferSend(void)
{
    unsigned short *p = NULL; //default
    int idx;

    idx = readADCDMASendIdx;
    if(gADCDMABufferSend[idx].used == TRUE)
    {
        //UART_PRINT("readADCDMASendIdx=[%d]\n\r", idx);
        p = gADCDMABufferSend[idx].buf;
    }

    return p;
}

void writeGADCDMABufferSendDone(void)
{
    int idx;

    idx = writeADCDMASendIdx;
    gADCDMABufferSend[idx].used = TRUE;
    addWriteADCDMASendIdx();

}

void readGADCDMABufferSendDone(void)
{
    int idx;

    idx = readADCDMASendIdx;
    gADCDMABufferSend[idx].used = FALSE;
    addReadADCDMASendIdx();
}

void ADCDataCopy(void)
{
    int i = 0, totalCnt, skipCnt = 0, pkg, oneCnt;
    unsigned short *p, *pBuf;

    totalCnt = skipCnt = 62500 / gRxTime.vibrationRate;
    if(skipCnt == 0)
    {
        UART_PRINT("totalCnt=0 error,vibrationRate:%d\n\r", gRxTime.vibrationRate);
        totalCnt = skipCnt = 1;
    }
    pkg = totalCnt;

    while(pkg > 0)
    {
        if((p = readGADCDMABuffer()) != NULL) //取一包数据
        {
            pBuf = mallocGADCDMABufferSend(); //分配目标缓存
            if(pBuf == NULL)
            {
                UART_PRINT("pBuf is NULL 11, break\n\r");
                break;
            }

            if(totalCnt == 1) //复制一整包数据,for 62.5K
            {

                memcpy((char *)(pBuf + 2), (char *)(p + 2), ADC_LEN * 2);
                UART_PRINT("total copy:[%d,%d]\n\r", totalCnt, gRxTime.vibrationRate);
                start = 2;
                gBufIdx = 0;
                remainCnt = 0;
                writeGADCDMABufferSendDone();
            }
            else
            {
#if 0
                start = totalCnt - remainCnt + 2; //开始位置
                if(start < 2)
                {
                    UART_PRINT("start error:[%d,%d,%d]\n\r", start, totalCnt, remainCnt);
                    start = 2;
                }
#endif
                oneCnt = 0;
                for(i = start; i < (ADC_LEN + 2); i += totalCnt)
                {
                    pBuf[gBufIdx + 2] = p[i]; //取数
                    oneCnt++;
                    if(addBufIdx(1))
                    {
                        UART_PRINT("gBufIdx is reset, remainCnt=[%d,%d,%d]-[%d,%d]\n\r", remainCnt, start, totalCnt, gRxTime.vibrationRate, i);
                        writeGADCDMABufferSendDone(); //目标缓存已满
                        if((i + totalCnt) < (ADC_LEN + 2)) //源缓存还有数据可取
                        {
                            pBuf = mallocGADCDMABufferSend();   //取下一个目标缓存
                            if(pBuf == NULL)
                            {
                                UART_PRINT("pBuf is NULL 22, break\n\r");
                                break;
                            }
                        }
                    }
                }
                remainCnt = ADC_LEN + 1 - (i - totalCnt); //剩余点数
                start = (i - 2) % ADC_LEN + 2; //开始位置
                UART_PRINT("pkg info=%d,[%d,%d,%d],%d-[%d,%d]-%d\n\r", totalCnt - pkg + 1, start, i - totalCnt, remainCnt, totalCnt, gRxTime.vibrationRate, i, oneCnt);
            }
            readGADCDMABufferDone();
        }
        pkg--;
    }
}
#endif

//*****************************************************************************
//
//! Setup a uDMA transfer.
//!
//! This function will perform all the steps necessary to set up a DMA transfer.
//! in burst mode.
//! \return None.
//
//*****************************************************************************
void
UDMASetupTransfer(unsigned long ulChannel, unsigned long ulMode,
                  unsigned long ulItemCount,
                  unsigned long ulItemSize, unsigned long ulArbSize,
                  void *pvSrcBuf, unsigned long ulSrcInc,
                  void *pvDstBuf, unsigned long ulDstInc)
{
    MAP_uDMAChannelAssign(ulChannel);

    //
    // Set up the transfer.
    //
    MAP_uDMAChannelControlSet(ulChannel,
                              ulItemSize | ulSrcInc | ulDstInc | ulArbSize);

    MAP_uDMAChannelTransferSet(ulChannel, ulMode,
                               pvSrcBuf, pvDstBuf, ulItemCount);

    //
    // Set burst mode
    //
    //MAP_uDMAChannelAttributeEnable(ulChannel, UDMA_ATTR_USEBURST);

    //
    // Enable the udma channel.
    //
    MAP_uDMAChannelEnable(ulChannel);

}

void copyDma(void)
{
    unsigned short *pDataDumpBuff = NULL;
    unsigned short *p = mallocGADCDMABuffer();
    unsigned int key;
    unsigned int ulChannelStructIndex, ulMode, ulControl;
    tDMAControlTable *pControlTable;

    //
    // Check the DMA control table to see if the ping-pong "A" transfer is
    // complete.  The "A" transfer uses receive buffer "A", and the primary
    // control structure.
    //
    ulMode = MAP_uDMAChannelModeGet(UDMA_CH15_ADC_CH1 | UDMA_PRI_SELECT);
    //
    // If the primary control structure indicates stop, that means the "A"
    // receive buffer is done.  The uDMA controller should still be receiving
    // data into the "B" buffer.
    //
    if(ulMode == UDMA_MODE_STOP)
    {
        ulChannelStructIndex = UDMA_CH15_ADC_CH1 | UDMA_PRI_SELECT;
        pDataDumpBuff = &(uShADCDMABufferPing[0]);
    }
    else
    {
        //
        // Check the DMA control table to see if the ping-pong "A" transfer is
        // complete.  The "A" transfer uses receive buffer "A", and the primary
        // control structure.
        //
        ulMode = MAP_uDMAChannelModeGet(UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT);
        //
        // If the primary control structure indicates stop, that means the "A"
        // receive buffer is done.  The uDMA controller should still be receiving
        // data into the "B" buffer.
        //
        if(ulMode == UDMA_MODE_STOP)
        {
            ulChannelStructIndex = UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT;
            pDataDumpBuff = &(uShADCDMABufferPong[0]);
        }
    }

    if(pDataDumpBuff != NULL)
    {
        /* A lock is needed because we are accessing shared uDMA registers.*/
        key = HwiP_disable();

        memcpy(p, pDataDumpBuff, ADC_DMA_BUFFERSIZE - 3);

        if(uShADCDMABufferNull != p)
            writeGADCDMABufferDone();

        HwiP_restore(key);

        // Set up the next transfer for the "A" buffer, using the primary
        // control structure.  When the ongoing receive into the "B" buffer is
        // done, the uDMA controller will switch back to this one.
        //
        ulChannelStructIndex &= 0x3f;
        //
        // Get the base address of the control table.
        //
        pControlTable = (tDMAControlTable *)HWREG(UDMA_BASE + UDMA_O_CTLBASE);
        //
        // Get the current control word value and mask off the mode and size
        // fields.
        //
        ulControl = (pControlTable[ulChannelStructIndex].ulControl &
                     ~(UDMA_CHCTL_XFERSIZE_M | UDMA_CHCTL_XFERMODE_M));

        //
        // Set the transfer size and mode in the control word (but don't write the
        // control word yet as it could kick off a transfer).
        //
        ulControl |= UDMA_MODE_PINGPONG | ((ADC_DMA_BUFFERSIZE - 3 - 1) << 4);

        //
        // Write the new control word value.
        //
        pControlTable[ulChannelStructIndex].ulControl = ulControl;
    }
}

void ReloadDma(void)
{
    static uint8_t sw = 0;
    unsigned short *p = mallocGADCDMABuffer();
    unsigned int               key;

    /* Clear ALT SELECT Attribute */
    //MAP_uDMAChannelAttributeDisable(UDMA_CH15_ADC_CH1,UDMA_ATTR_ALTSELECT);

    /* A lock is needed because we are accessing shared uDMA registers.*/
    key = HwiP_disable();

    if((sw++ & 0x01) == 0)
    {
#if 0
        MAP_uDMAChannelControlSet(UDMA_CH15_ADC_CH1, UDMA_SIZE_16 | UDMA_SRC_INC_NONE | UDMA_DST_INC_16 | UDMA_ARB_1 | UDMA_MODE_PINGPONG);
        //MAP_uDMAChannelAttributeEnable(UDMA_CH15_ADC_CH1,UDMA_ATTR_USEBURST);
        MAP_uDMAChannelTransferSet(UDMA_CH15_ADC_CH1, UDMA_MODE_PINGPONG, (void*)(ADC_BASE + ADC_O_channel2FIFODATA),
                                   &p[2], ADC_DMA_BUFFERSIZE - 3); //ping
        MAP_uDMAChannelEnable(UDMA_CH15_ADC_CH1);
#else
        UDMASetupTransfer(UDMA_CH15_ADC_CH1 | UDMA_PRI_SELECT, UDMA_MODE_PINGPONG,
                          ADC_DMA_BUFFERSIZE - 3,
                          UDMA_SIZE_16, UDMA_ARB_1,
                          (void *)(ADC_BASE + ADC_O_channel2FIFODATA), UDMA_SRC_INC_NONE,
                          (void *) & (p[0]), UDMA_DST_INC_16);
#endif
    }
    else
    {
#if 0
        MAP_uDMAChannelControlSet(UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT, UDMA_SIZE_16 | UDMA_SRC_INC_NONE | UDMA_DST_INC_16 | UDMA_ARB_1 | UDMA_MODE_PINGPONG);
        //MAP_uDMAChannelAttributeEnable(UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT, UDMA_ATTR_USEBURST);
        MAP_uDMAChannelTransferSet(UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT, UDMA_MODE_PINGPONG, (void*)(ADC_BASE + ADC_O_channel2FIFODATA),
                                   &p[2], ADC_DMA_BUFFERSIZE - 3); //pong
        MAP_uDMAChannelEnable(UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT);
#else
        UDMASetupTransfer(UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT, UDMA_MODE_PINGPONG,
                          ADC_DMA_BUFFERSIZE - 3,
                          UDMA_SIZE_16, UDMA_ARB_1,
                          (void *)(ADC_BASE + ADC_O_channel2FIFODATA), UDMA_SRC_INC_NONE,
                          (void *) & (p[0]), UDMA_DST_INC_16);
#endif

    }
    //MAP_uDMAChannelEnable(UDMA_CH15_ADC_CH1);
    //MAP_uDMAEnable();

    if(uShADCDMABufferNull != p)
        writeGADCDMABufferDone();

    HwiP_restore(key);

#if 0
    if(!SwiP_inISR())
        SwiP_post(swi0);
#endif
}

void vMyOwnDMAInit(void)
{
//    UDMACC32XX_init();
//    udma = UDMACC32XX_open();

    //uDMADisable();
    //uDMAChannelAssign(UDMA_CH15_ADC_CH1);
#if 1
    //ping
    UDMASetupTransfer(UDMA_CH15_ADC_CH1 | UDMA_PRI_SELECT, UDMA_MODE_PINGPONG,
                      ADC_DMA_BUFFERSIZE - 3,
                      UDMA_SIZE_16, UDMA_ARB_1,
                      (void *)(ADC_BASE + ADC_O_channel2FIFODATA), UDMA_SRC_INC_NONE,
                      (void *) & (uShADCDMABufferPing[0]), UDMA_DST_INC_16);
    //pong
    UDMASetupTransfer(UDMA_CH15_ADC_CH1 | UDMA_ALT_SELECT, UDMA_MODE_PINGPONG,
                      ADC_DMA_BUFFERSIZE - 3,
                      UDMA_SIZE_16, UDMA_ARB_1,
                      (void *)(ADC_BASE + ADC_O_channel2FIFODATA), UDMA_SRC_INC_NONE,
                      (void *) & (uShADCDMABufferPong[0]), UDMA_DST_INC_16);
#else
	ReloadDma();
#endif
    //uDMAChannelEnable(UDMA_CH15_ADC_CH1);
    //uDMAEnable();
}

void vMyOwnADCInit(void)
{
    //unsigned long das=0;
    //ADC_Params adcParams;
//    ADC_Params_init(&adcParams);
//    adc_ch2=ADC_open(2,&adcParams);//P58
    initGADCDMABuffer();
    //swi_create();

    ADCDisable(ADC_BASE);
    //disable     //clear
    vMyOwnDMAInit();
    ADCIntDisable(ADC_BASE, ADC_CH_1, ADC_DMA_DONE);
    ADCIntDisable(ADC_BASE, ADC_CH_1, ADC_FIFO_OVERFLOW);
    ADCIntDisable(ADC_BASE, ADC_CH_1, ADC_FIFO_UNDERFLOW);
    ADCIntDisable(ADC_BASE, ADC_CH_1, ADC_FIFO_EMPTY);
    ADCIntDisable(ADC_BASE, ADC_CH_1, ADC_FIFO_FULL);

    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_OVERFLOW);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_UNDERFLOW);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_EMPTY);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_FULL);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_DMA_DONE);

    //enable
    ADCIntEnable(ADC_BASE, ADC_CH_1, ADC_DMA_DONE);
    ADCChannelEnable(ADC_BASE, ADC_CH_1);

    // Set the priority
    IntPrioritySet(ADC_CH_1, INT_PRIORITY_LVL_2);
    IntPendClear(ADC_CH_1);
    ADCIntRegister(ADC_BASE, ADC_CH_1, ADCIntHandler);
    ADCDMAEnable(ADC_BASE, ADC_CH_1);

    // Enable ADC
    //ADCTimerConfig(ADC_BASE, 2 ^ 17);
    //ADCTimerEnable(ADC_BASE);
    ADCEnable(ADC_BASE);

//    Report("Irq 1st - %lx \n",ADCIntStatus(ADC_BASE,ADC_CH_1));
//    //while((ADC_FIFO_OVERFLOW&ADCIntStatus(ADC_BASE,ADC_CH_1)) != ADC_FIFO_OVERFLOW)
//    {
//        Report("Irq2 st - %lx \n",ADCIntStatus(ADC_BASE,ADC_CH_1));
//    }
//    Report("Irq 3st - %lx \n",ADCIntStatus(ADC_BASE,ADC_CH_1));

#if 0
    Report("Network Terminal - %ld \n", das);
    if( ADCFIFOLvlGet(ADC_BASE, ADC_CH_1) )
    {
        das = ADCFIFORead(ADC_BASE, ADC_CH_1);
    }
    Report("Network Terminal - %ld \n", das);
    if( ADCFIFOLvlGet(ADC_BASE, ADC_CH_1) )
    {
        das = ADCFIFORead(ADC_BASE, ADC_CH_1);
    }
    Report("Network Terminal - %ld \n", das);
#endif
}

void ADCIntHandler(void)
{
    unsigned long status = 0;
    
#if 0
    while( ADCFIFOLvlGet(ADC_BASE, ADC_CH_1) )
    {
        das = ADCFIFORead(ADC_BASE, ADC_CH_1);
        i++;
    }
#endif

    status = ADCIntStatus(ADC_BASE, ADC_CH_1);
    UART_PRINT("ADCIntStatus=[%d]-%d,%d\n\r", status, status & ADC_FIFO_FULL, status & ADC_DMA_DONE);
	#if 0
    if(status & ADC_FIFO_FULL) //ADC_FIFO_FULL
    {
		//copyDma();
        ReloadDma();
    }
	#endif
	copyDma();

    //uShADCDMABuffer[3] =0;s
    //Report("Irq 3st - %lx \n",ADCIntStatus(ADC_BASE,ADC_CH_1));
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_DMA_DONE);
#if 1
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_OVERFLOW);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_UNDERFLOW);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_EMPTY);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_FIFO_FULL);
#endif
}

void restart_dma(void)
{
    ADCEnable(ADC_BASE);
    ADCIntEnable(ADC_BASE, ADC_CH_1, ADC_DMA_DONE);
}

void stop_dma(void)
{
    ADCDisable(ADC_BASE);
    ADCIntDisable(ADC_BASE, ADC_CH_1, ADC_DMA_DONE);
    ADCIntClear(ADC_BASE, ADC_CH_1, ADC_DMA_DONE);
}

void adc_dma()
{
    vMyOwnDmaAdcInit();
}

///*****************adc pin59999999999***************/

//
//void vMyOwnDmaAdcInit()
//{
//   vMyOwnDMAInit();
//   vMyOwnADCInit();
//}
//
//void vMyOwnDMAInit(void)
//{
//    UDMACC32XX_init();
//    udma = UDMACC32XX_open();
//    uDMAChannelAssign(UDMA_CH16_ADC_CH2);
//    uDMAChannelControlSet(UDMA_CH16_ADC_CH2|UDMA_PRI_SELECT, UDMA_SIZE_16|UDMA_SRC_INC_NONE|UDMA_DST_INC_16|UDMA_ARB_1);
//    uDMAChannelTransferSet(UDMA_CH16_ADC_CH2|UDMA_PRI_SELECT,UDMA_MODE_BASIC,(void*)(ADC_BASE+ADC_O_channel4FIFODATA),(void *) &uShADCDMABuffer[2], ADC_DMA_BUFFERSIZE-3);
//
//    uDMAChannelEnable(UDMA_CH16_ADC_CH2);
//}
//
//void vMyOwnADCInit(void)
//{
//    ADC_Params adcParams;
//    ADC_Params_init(&adcParams);
//    adc_ch2=ADC_open(0,&adcParams);//P59
//
//    ADCDMAEnable(ADC_BASE, ADC_CH_2);
//    ADCIntRegister(ADC_BASE, ADC_CH_2,ADCIntHandler);
//    ADCIntClear(ADC_BASE, ADC_CH_2, ADC_DMA_DONE);
//    ADCIntEnable(ADC_BASE, ADC_CH_2,ADC_DMA_DONE);
//    ADCChannelEnable(ADC_BASE, ADC_CH_2);
//    ADCEnable(ADC_BASE);
//}
//
//void ADCIntHandler(void)
//{
//  unsigned int i;
//  // Turn off ADC and clear IRQ-Bit
//  ADCDisable(ADC_BASE);
//  ADCIntDisable(ADC_BASE, ADC_CH_2,ADC_DMA_DONE);
//  ADCIntClear(ADC_BASE, ADC_CH_2, ADC_DMA_DONE);
//
//  UDMACC32XX_close(udma);
//
//  for (i=2; i< (ADC_LEN + 2); i++)//鎼村繐褰挎禒锟?瀵拷婵绱濋崜宥勮⒈娑擃亜銇囩€涙濡稉鍝勬姎婢跺瓨鐖ｇ拋鏉挎嫲閸栧懎绨崣锟?
//  {
//      uShADCDMABuffer[i] >>= 2;
//      uShADCDMABuffer[i] &= 0x0FFF;
//  }
//
//    dma_flag = 1;
//}
//
//void restart_dma(void)
//{
//    ADCEnable(ADC_BASE);
//    ADCIntEnable(ADC_BASE, ADC_CH_2,ADC_DMA_DONE);
//}
//
//void stop_dma(void)
//{
//    ADCDisable(ADC_BASE);
//    ADCIntDisable(ADC_BASE, ADC_CH_2,ADC_DMA_DONE);
//    ADCIntClear(ADC_BASE, ADC_CH_2, ADC_DMA_DONE);
//}
//
//void adc_dma()
//{
//
//vMyOwnDmaAdcInit();
//
//}