dsPIC33E Probleme mit ADC/DMA

[Marc H. (hagy)]

Hallo zusammen,

ich möchte einen DSPIC33EP512MU810 nutzen, um mehrere analoge Eingänge 
einzulesen und schließlich PWM Signale zu erzeugen. Zur Entlastung des 
CPUs soll der ADC mittels DMA direkt in den SRAM schreiben.
Die PWM und der ADC funktioniert ohne DMA einwandfrei. Mit DMA werden 
die eingelesenen Werte zunächst ordnungsgemäß in den Buffer geschrieben 
und können ausgelesen werden. Allerdings erfolgt dann anscheinend kein 
Reset auf die Startadresse des Buffers, sodass sich die einmal 
gebufferten Werte nicht ändern. Dies kann ich nicht verstehen, da der 
DMA interrupt ständig ausgelöst wird.

Der Relevante Teil des Codes folgt hier. Der gesamte MAIN.c ist am 
Anhang.
Ich habe mich sehr eng an ein Beispiel von Microchip gehalten.

Ich hoffe jemand kann mir helfen.
Gruß
Marc

#include <xc.h>
#include "tglpin.h"

// User Defines
//#define FCY         70000000        // User must calculate and enter FCY here
#define NUMSAMP 16 // Number of Samples to Buffer until DMA Interrupt

// *****************************************************************************
// *****************************************************************************
// Section: File Scope or Global Constants
// *****************************************************************************
// *****************************************************************************
/* This section defines the input and the output buffers having an integer data type.
The input buffers are stored in either the extended data space or the x-memory area
depending on whether the extended data space (EDS) is available in the given dsPIC33E device.
 */
__eds__ int bufferA[NUMSAMP] __attribute__( (eds, space(dma)) );
__eds__ int bufferB[NUMSAMP] __attribute__( (eds, space(dma)) );

unsigned int adc_messwert = 0;
unsigned int PWM_PERIOD=2800;   //The PWM period can be computed: PWM_PERIOD = FOSC/(FPWM*PWMInputClockPrescaler)       
float DC =0.02;
float DC1=0.02;
float DC2=0.02;
float DC3=0.02;
float DC4=0.02;
float DC5=0.02;
unsigned int    dmaBuffer = 0;

/******************************************************************************
 * Function:        void InitAdc1(void)
 * Overview:        This function is used to configure A/D to convert channel 5 on Timer event.
 *                  It generates event to DMA on every sample/convert sequence. ADC clock is configured at 625Khz.
 *****************************************************************************/
void InitAdc1( void )
{
    AD1CON1bits.FORM = 0;       // Data Format: 0=Integer, 1=Signed Integer 3=Signed Fraction
    AD1CON1bits.SSRCG= 0;       // 
    AD1CON1bits.SSRC = 7;       // 7 Interan Counter (SAMC) ends sampling and starts convertion
    AD1CON1bits.ASAM = 1;       // ADC Sample Control: Sampling begins immediately after conversion
    AD1CON1bits.AD12B= 0;       // 10-bit ADC operation
    AD1CON2bits.CHPS = 1;       // 0: Converts CH0  //   1 for: CH0 and CH1
    AD1CON3bits.ADRC = 0;       // ADC Clock is derived from Systems Clock
    AD1CON3bits.SAMC = 0;       // Auto Sample Time = 0*Tad
    AD1CON3bits.ADCS = 6;       // ADC Conversion Clock Tad=Tcy*(ADCS+1)= (1/70M)*7 = 100ns (10.0Mhz)
      
    // ADC Conversion Time for 10-bit Tc=12*Tab =  900ns (1.1MHz)
    AD1CON1bits.ADDMABM = 1;    // 1: DMA buffers are built in conversion order mode ([0]1, [1]=2, [3]=1.. //0 Scatter gather mode
    AD1CON2bits.SMPI = 0;       // SMPI must be 0
    AD1CON4bits.ADDMAEN = 1;    // Converts in ADC1BUF0

    // AD1CHS0/AD1CHS123: A/D Input Select Register
    AD1CHS0bits.CH0SA = 0;      // MUXA +ve input selection (AIN0) for CH0
    AD1CHS0bits.CH0SA = 5;      // MUXA +ve input selection (AIN5) for CH0
    AD1CHS0bits.CH0NA = 0;      // MUXA -ve input selection (Vref-) for CH0
    AD1CHS123bits.CH123SA = 0;  // MUXA +ve input selection (AIN0) for CH1
    AD1CHS123bits.CH123NA = 0;  // MUXA -ve input selection (Vref-) for CH1
    IFS0bits.AD1IF = 0;         // Clear the A/D interrupt flag bit
    IEC0bits.AD1IE = 0;         // Do Not Enable A/D interrupt
    AD1CON1bits.ADON = 1;       // Turn on the A/D converter
    TglPinInit();
}

/******************************************************************************
 * Function:        void InitDma0(void)
 * Overview:        DMA0 configuration function.
                    Direction: Read from peripheral address 0-x300 (ADC1BUF0) and write to DMA RAM
                    AMODE: Register indirect with post increment
                    MODE: Continuous, Ping-Pong Mode
                    IRQ: ADC Interrupt
                    ADC stores results stored alternatively between DMA_BASE[0]/DMA_BASE[16] on every
                    16th DMA request
 *****************************************************************************/
void InitDma0( void )
{
    DMA0CONbits.AMODE = 0;  // Configure DMA for Register indirect with post increment
    DMA0CONbits.MODE = 2;   // 2 Configure DMA for Continuous Ping-Pong mode
        
    DMA0PAD = ( int ) &ADC1BUF0; // Point DMA to ADC1BUF
    DMA0CNT = ( NUMSAMP - 1 ); // Interrupt auf NUMSAMP Transfers

    DMA0REQ = 13; // ADC1 ? ADC1 Convert Done

    DMA0STAL = __builtin_dmaoffset( &bufferA );
    DMA0STAH = __builtin_dmapage( &bufferA );

    DMA0STBL = __builtin_dmaoffset( &bufferB );
    DMA0STBH = __builtin_dmapage( &bufferB );


    IFS0bits.DMA0IF = 0;    //Clear the DMA interrupt flag bit
    IEC0bits.DMA0IE = 1;    //Set the DMA interrupt enable bit
    DMA0CONbits.CHEN = 1;
}



/******************************************************************************
 * Function:        void ProcessADCSamples(__eds__ int16_t * adcBuffer)
 * Overview:        This function is just a prototype which can be used to perform
 *                  some activity on the samples taken by the ADC.
 *****************************************************************************/
void ProcessADCSamples( __eds__ int *adcBuffer )
{
    /* Do something with ADC Samples */
    int avg=0;
    avg=(adcBuffer[2]); //+adcBuffer[4]+adcBuffer[6])/3;
    adc_messwert= avg;
    IEC0bits.DMA0IE = 1;    //Set the DMA interrupt enable bit
 }

/******************************************************************************
 * Function:        void __attribute__((interrupt, auto_psv)) _DMA0Interrupt(void)
 * Overview:        Depending on the dmaBuffer value, the data in bufferA or bufferB is passed
 *****************************************************************************/
void __attribute__ ( (interrupt, auto_psv) ) _DMA0Interrupt( void )
{
    DMA0CONbits.CHEN=0; //Disable DMA
    
    if( dmaBuffer == 0 )
    {
        ProcessADCSamples( bufferA );
    }
    else
    {
        ProcessADCSamples( bufferB );
    }
   
    dmaBuffer ^= 1;
    TglPin();               // Toggle RA4 -> LED D7
    IFS0bits.DMA0IF = 0;    // Clear the DMA0 Interrupt Flag
    DMA0CONbits.CHEN=1; //Enable DMA
  }