ADC 12Bit dsPIC33 CH Scanning DMA - Index of the analog input ( Bufferüberlauf )

Hallo,

schon eine Antwort gefunden?

Kann zwar zu deiner Frage nichts beitragen, jedoch ist mir aufgefallen, 
dass du immer den BufferA auslesen wirst, da deine Variable DmaBuffer 
nur lokal ist und nach jedem Funktionsaufruf verworfen wird.
Also entweder static deklarieren oder außerhalb der Funktion definieren.

ich habe ein ähnliches problem wie oben beschrieben. mein code ist aus 
den examples in den datasheets. der example-code funtkioniert sehr gut 
wenn nur 4 channel gescannt werden sollen. ich möchte aber 5 channels 
scannen und habe entsprechende anpassungen vorgenommen.

Anapassungen:
- AD1CSSL = 0x001F;
- AD1CON2bits.SMPI = 4;
- DMA0CNT = 39;

leider geht das so nicht, keine ahnung wieso. vielleciht kann mir jemand 
weiterhelfen?
vielen dank für die Hilfe!



/*====================================================================== 
====================
ADC Initialization for Channel Scan
======================================================================== 
===================*/
void adcInit(void){
initDma0();

AD1CON1bits.FORM = 0; // Data Output Format: Signed Fraction (Q15 
format)
AD1CON1bits.SSRC = 2; // Sample Clock Source: GP Timer starts conversion
AD1CON1bits.ASAM = 1; // ADC Sample Control: Sampling begins immediately 
after conversion
AD1CON1bits.AD12B = 1; // 12-bit ADC operation
AD1CON1bits.SIMSAM = 0; // Samples multiple channels individually in 
sequence
AD1CON2bits.BUFM = 0;
AD1CON2bits.CSCNA = 1; // Scan Input Selections for CH0+ during Sample A 
bit
AD1CON2bits.CHPS = 0; // Converts CH0
AD1CON3bits.ADRC = 0; // ADC Clock is derived from Systems Clock
AD1CON3bits.ADCS = 63; // ADC Conversion Clock
//AD1CHS0: A/D Input Select Register
AD1CHS0bits.CH0SA = 0; // MUXA +ve input selection (AIN0) for CH0
AD1CHS0bits.CH0NA = 0; // MUXA -ve input selection (Vref-) for CH0

//AD1CHS123: A/D Input Select Register
AD1CHS123bits.CH123SA = 0; // MUXA +ve input selection (AIN0) for CH1
AD1CHS123bits.CH123NA = 0; // MUXA -ve input selection (Vref-) for CH1
//AD1CSSL: A/D Input Scan Selection Register
AD1CSSL = 0x001F; // Scan AIN0, AIN1, AIN2, AIN3, AIN4 inputs
AD1CON1bits.ADDMABM = 0; // DMA buffers are built in scatter/gather mode
AD1CON2bits.SMPI = 4; // 5 ADC buffers
AD1CON4bits.DMABL = 3; // Each buffer contains 8 words
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
initTmr3();
}
/*====================================================================== 
================
Timer 3 is setup to time-out every 125 microseconds (8Khz Rate). As a 
result, the module
will stop sampling and trigger a conversion on every Timer3 time-out, 
i.e., Ts=125us.
======================================================================== 
===============*/
void initTmr3(void)
{
TMR3 = 0x0000;
PR3 = 4999; // Trigger ADC1 every 125usec
IFS0bits.T3IF = 0; // Clear Timer 3 interrupt
IEC0bits.T3IE = 0; // Disable Timer 3 interrupt
T3CONbits.TON = 1; //Start Timer 3
}

// Linker will allocate these buffers from the bottom of DMA RAM.
struct
{
unsigned int Adc1Ch0[8];
unsigned int Adc1Ch1[8];
unsigned int Adc1Ch2[8];
unsigned int Adc1Ch3[8];
unsigned int Adc1Ch4[8];
} BufferA __attribute__((space(dma)));

struct
{
unsigned int Adc1Ch0[8];
unsigned int Adc1Ch1[8];
unsigned int Adc1Ch2[8];
unsigned int Adc1Ch3[8];
unsigned int Adc1Ch4[8];
} BufferB __attribute__((space(dma)));
// DMA0 configuration
// Direction: Read from peripheral address 0-x300 (ADC1BUF0) and write 
to DMA RAM
// AMODE: Peripheral Indirect Addressing Mode
// MODE: Continuous, Ping-Pong Mode
// IRQ: ADC Interrupt

void initDma0(void)
{
DMA0CONbits.AMODE = 2; // Configure DMA for Peripheral indirect mode
DMA0CONbits.MODE = 2; // Configure DMA for Continuous Ping-Pong mode
DMA0PAD = 0x0300; // Point DMA to ADC1BUF0
DMA0CNT = 39; // 40 DMA request (4 buffers, each with 8 words)
DMA0REQ = 13; // Select ADC1 as DMA Request source
DMA0STA = __builtin_dmaoffset(&BufferA);
DMA0STB = __builtin_dmaoffset(&BufferB);
IFS0bits.DMA0IF = 0; //Clear the DMA interrupt flag bit
IEC0bits.DMA0IE = 1; //Set the DMA interrupt enable bit
DMA0CONbits.CHEN=1; // Enable DMA
}

/*====================================================================== 
==================
_DMA0Interrupt(): ISR name is chosen from the device linker script.
======================================================================== 
================*/
unsigned int DmaBuffer = 0;
void __attribute__((_interrupt_)) _DMA0Interrupt(void)
{
if(DmaBuffer == 0){
xMsb = (unsigned char)(BufferA.Adc1Ch0[1] >> 8);
xLsb = (unsigned char)(BufferA.Adc1Ch0[1] & 0xFF);
yMsb = (unsigned char)(BufferA.Adc1Ch1[1] >> 8);
yLsb = (unsigned char)(BufferA.Adc1Ch1[1] & 0xFF);
vrefMsb = (unsigned char)(BufferA.Adc1Ch2[1] >> 8);
vrefMsb = (unsigned char)(BufferA.Adc1Ch2[1] & 0xFF);
temperatureMsb = (unsigned char)(BufferA.Adc1Ch3[1] >> 8);
temperatureLsb = (unsigned char)(BufferA.Adc1Ch3[1] & 0xFF);
zMsb = (unsigned char)(BufferA.Adc1Ch4[1] >> 8);
zLsb = (unsigned char)(BufferA.Adc1Ch4[1] & 0xFF);

}
else
{
xMsb = (unsigned char)(BufferB.Adc1Ch0[1] >> 8);
xLsb = (unsigned char)(BufferB.Adc1Ch0[1] & 0xFF);
yMsb = (unsigned char)(BufferB.Adc1Ch1[1] >> 8);
yLsb = (unsigned char)(BufferB.Adc1Ch1[1] & 0xFF);
vrefMsb = (unsigned char)(BufferB.Adc1Ch2[1] >> 8);
vrefMsb = (unsigned char)(BufferB.Adc1Ch2[1] & 0xFF);
temperatureMsb = (unsigned char)(BufferB.Adc1Ch3[1] >> 8);
temperatureLsb = (unsigned char)(BufferB.Adc1Ch3[1] & 0xFF);
zMsb = (unsigned char)(BufferB.Adc1Ch4[1] >> 8);
zLsb = (unsigned char)(BufferB.Adc1Ch4[1] & 0xFF);
}

DmaBuffer ^= 1;
IFS0bits.DMA0IF = 0; //Clear the DMA0 Interrupt Flag
}

LöSUNG:

AMODE = 0;

kein ahnung wieso, aber so funktionierts!