STM32F205 der DMA und der ADC

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Hallo, bei mir verhält sich der DMA in Verbindung mit dem ADC1 etwas 
zickig.

Der ADC soll 4 Kanäle durchlaufen, also das SCAN Bit ist gesetzt und das 
soll er endlos tun -> CONT Bit ist auch gesetzt.
Wenn ich jetzt den IRQ auf den ADC draufloslasse, so bekomme ich auch 
jeden Wert zurück und kann den in ein Array einsortieren.

Jetzt soll aber der DMA das abholen, da der ADC doch recht schnell ist 
und die ganzen IRQs den CPU Kern zu sehr belasten.
Daher ist das DMA Bit gesetzt im ADC.
Der DMA selber ist auf den Circle Modus gestellt.
Beim ersten SCAN Durchlauf landen die Werte auch schön per DMA im Array, 
aber danach ist funkstille auf dem DMA Stream.
Ich weis nicht ob der ADC keinen DMA request mehr raushaut oder der DMA 
doch irgendwie meint, dass jetzt Schluss ist?

Als Code nutz ich nicht den Gencode vom STMCUBE, ich wollt da was selber 
häkeln ;)

Hier mal die wichtigen Codeschnipsel:

adc.c:

void adc_int_init(unsigned int adc_base){

  volatile struct adc * const adc = (struct adc *)adc_addrs[adc_base];
  volatile struct adcc * const adcc = (struct adcc *)ADCCOM_BASE;

  //ADC einschalten (RES = 12Bit -> 15ADCCLK cycles)
  adc->CR1 = 0;
  adc->CR2 = CR2_ADON;
  adc->SQR1 = 0;
  adc->SQR2 = 0;
  adc->SQR3 = 0;
  
  //ADC Takt setzen (1000x/s alles durchsamplen!) (APB/8)
  adcc->CCR = 0b11 << CCR_ADCPRE_SHIFT;
}

static void adc_int_xmode(volatile struct adc * const adc, enum adc_mode amode){

  //Modus setzen
  //adc->SR &=  ~SR_OVR;
  adc->CR1 &= ~CR1_SCAN;
  adc->CR2 &= ~CR2_CONT;
  
  switch (amode) {
    case ADCM_SINGLE:
      //nix setzen
      break;
    case ADCM_SCAN:
      adc->CR1 |= CR1_SCAN;
      break;
    case ADCM_SCANCONT:
      adc->CR1 |= CR1_SCAN;
      adc->CR2 |= CR2_CONT;
      break;
  }
  
  //fake abholen zum Flag löschen
  volatile unsigned int dr = adc->DR;
  (void)dr;
}

int adc_int_dmamode(
  unsigned int adc_base,               //Welcher ADC
  uint16_t *mem_buf,                 //ADC Daten wohin
  void (*callb_dma)(unsigned int, void*),     //IRQ Handler DMA
  void *callb_data_dma,               //IRQ Handler DMA Daten
  void (*callb)(unsigned int, uint16_t, void*),   //IRQ Handler ADc Err
  void *callb_data,                 //IRQ Handler ADc Err Daten
  enum adc_mode amode){              //ADC Mode

  volatile struct adc * const adc = (struct adc *)adc_addrs[adc_base];
  
  //Modus setzen
  adc_int_xmode(adc, amode);
  
  //es gibt 2 Versuche, denn jede Periph ist in 2 DMA Vetreten
  //beide belegt -> dammnit
  unsigned int circular = 0;
  if (ADCM_SCANCONT == amode){
    circular = 1;
  }
  unsigned int sequ_len = adc->SQR1 >> SQR1_SLEN_SHIFT;
  sequ_len &= 0b1111;
  sequ_len += 1;
  dprintf("DMA_ADC scanlen: %u\n", sequ_len);
  int i, dma_arr;
  for (i = 0; i < 2; i++){
    dma_arr = dma_periph(
      dma_streamchan[adc_base][i],    //Angabe der Peripherie
      (unsigned int)mem_buf,
      (unsigned int)&(adc->DR),
      sequ_len,      //Anzahl der zu übertragenden Elemente
      DMA_SIZE_HWORD,    //Größe der zu Übertragenden Daten
      circular,      //mem wird circulär befüllt = DMA geht nie zuende
      DMA_PERIPH_TO_MEM,  //in welche Richtung geht der DMA (mem to mem ist verboten)
      callb_dma,      //Callback be auftretendem IRQ
      callb_data_dma    //Daten für den Callback
      );
    if (0 == dma_arr){
      break;
    }
  }
  if (dma_arr){
    return -1;
  }
  
  callb_irq[adc_base] = callb;
  callb_irq_data[adc_base] = callb_data;
  
  //IRQ aktivieren
  nvic_enable_irq(IRQ_NBR_ADC, 0xF, 0xF);
  adc->CR1 |= CR1_OVRIE;
  
  //Leinen los!
  adc->CR1 &= ~CR1_EOCIE;
  adc->CR2 &= ~CR2_EOCS;
  adc->CR2 |= /*CR2_DDS |*/ CR2_DMA | CR2_SWSTART;
  
  return 0;
}

dma.c

int dma_periph(
  enum dma_periph peri,    //Angabe der Peripherie
  unsigned int mem_addr,
  unsigned int per_addr,
  uint16_t data_items_nbr,  //Anzahl der zu übertragenden Elemente
  enum dma_size dsize,    //Größe der zu Übertragenden Daten
  unsigned int circular,    //mem wird circulär befüllt = DMA geht nie zuende
  enum dma_dir ddir,      //in welche Richtung geht der DMA (mem to mem ist verboten)
  void (*callb)(unsigned int, void*),  //Callback be auftretendem IRQ
  void *callb_data            //Daten für den Callback
  ){

  volatile struct dma * const dma = (struct dma *)dma_get_dma_addr(peri);
  unsigned int dma_nbr = dma_get_dma_nbr(peri);
  unsigned int stream = dma_get_dma_stream(peri);
  unsigned int channel = dma_get_dma_channel(peri);
  
  if (dma->stream[stream].SCR & SCR_EN){
    //Hier wohnt schon wer
    return -1;
  }
  
  callb_irq[dma_nbr][stream] = callb;
  callb_data_irq[dma_nbr][stream] = callb_data;
  
  //Statusflags für diesen Stream löschen, sonst geht ein Neustart daneben
  dma_clear_irq(dma, stream, ISR_TCIF | ISR_HTIF | ISR_TEIF | ISR_DMEIF | ISR_FEIF);
  
  dma->stream[stream].SNDTR = data_items_nbr;
  dma->stream[stream].SPAR = per_addr;
  dma->stream[stream].SM0AR = mem_addr;
  
  dprintf("DMA%u Stream %u, Channel %u\n", dma_nbr+1, stream, channel);
  
  //config setzen
  unsigned int config = 0;
  config |= channel << SCR_CHSEL_SHIFT;
  //KEIN MBURST -> kracht wenn man über ne 1kb Grenze schreibt!
  //KEIN PBURST
  //erstmal kein DBM
  config |= dsize << SCR_MSIZE_SHIFT;
  config |= dsize << SCR_PSIZE_SHIFT;
  config |= SCR_MINC;
  //Peripherie Pointer bleibt auf einem Register stehen -> SCR_PINC = 0
  if (circular){
    config |= SCR_CIRC;
  }
  if (ddir == DMA_MEM_TO_MEM){
    return -2; //Argument Error
  }
  config |= ddir << SCR_DIR_SHIFT;
  //DMA is Flowcontroller
  //IRQs sind immer wichtig!
  config |= SCR_TCIE | SCR_TEIE | SCR_DMEIE;
  
  //FIFO config: IRQ an und Viertelfoll
  dma->stream[stream].SFCR = SFCR_FEIE | SFCR_DMDIS;
  
  //IRQ am NVIC aktivieren
  nvic_enable_irq(dma_irq_nbrs[dma_nbr][stream], 0xF, 0xF);
  
  //erst Config schreiben und DANN aktivieren!
  dma->stream[stream].SCR = config;
  dma->stream[stream].SCR |= SCR_EN;
  
  dprintf("DMA_SCR (INI): %X\n", dma->stream[stream].SCR);
  
  return 0;
  
}

Schlussendlich noch wie das Ganze initialisiert wird:

static volatile uint16_t adc_werte[ADC_VAL_COUNT];

void init_adc(void){

  //STM32 ADC IO Pins und Clocks initialisieren
  rcc_enable_clock(RCC_GPIOA);
  gpio_initpin(PORTA, 6, GP_ANALOG, 0, 0); //Temp3
  gpio_initpin(PORTA, 7, GP_ANALOG, 0, 0); //Temp4
  rcc_enable_clock(RCC_GPIOB);
  gpio_initpin(PORTB, 0, GP_ANALOG, 0, 0); //Lüfter_VIN
  gpio_initpin(PORTB, 1, GP_ANALOG, 0, 0); //Lüfter_VLFT
  rcc_enable_clock(RCC_GPIOC);
  gpio_initpin(PORTC, 4, GP_ANALOG, 0, 0); //Temp1
  gpio_initpin(PORTC, 5, GP_ANALOG, 0, 0); //Temp2
  
  //STM32 ADC init
  rcc_enable_clock(RCC_ADC1);
  adc_int_init(ADC1);
  //STM32 ADC Sequenz basteln und übergeben
  uint8_t adc_seq[6];
  adc_seq[ADC_TEMP_KK1]   = ADC_TEMP_KK1_ADCCH;
  adc_seq[ADC_TEMP_KK2]   = ADC_TEMP_KK2_ADCCH;
  adc_seq[ADC_TEMP_2]   = ADC_TEMP_2_ADCCH;
  adc_seq[ADC_TEMP_4]   = ADC_TEMP_4_ADCCH;
  adc_seq[ADC_VCC_LFT]   = ADC_VCC_LFT_ADCCH;
  adc_seq[ADC_U_LFT]     = ADC_U_LFT_ADCCH;
  adc_int_set_sequence(ADC1, adc_seq, 4);
  
  adc_int_set_sampleclocks_all(ADC1, ADCSCLK_480CLK);
  //adc_int_irqmode(ADC1, callb_adc_int_irq, NULL, ADCM_SCANCONT);
  
  rcc_enable_clock(RCC_DMA1);
  rcc_enable_clock(RCC_DMA2);
  int dma_res;
  dma_res = adc_int_dmamode(
    ADC1,         //Welcher ADC
    (uint16_t*)&adc_werte[0],     //ADC Daten wohin
    callb_dma,       //IRQ Handler DMA
    NULL,         //IRQ Handler DMA Daten
    callb_adc_int_irq,   //IRQ Handler ADc Err
    NULL,         //IRQ Handler ADc Err Daten
    ADCM_SCANCONT);
  if (dma_res){
    dprintf("ADC DMA ERR: %i\n", dma_res);
  }
    
}

(Man is das viel Code, scrollend im Editor sieht das nach weniger aus)

[Simon (Gast)]

Du musst continuous requests für DMA aktivieren, damit das mit dem 
continuous conversion Modus funktioniert.

Ich weiß nicht, ob das im Datenblatt auch so heißt, aber so heißt es in 
CubeMX.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Das wäre das DDS bit.
Wie man sieht, hab ich das inzwischen wieder auskommentiert.
Wenns aktiviert ist dann landet der DMA nämlich andauernd (= 
Dauerschleife) im "DMA hat fertig" IRQ.

[Curby23523 N. (Gast)]

Mw E. schrieb:
> Wenns aktiviert ist dann landet der DMA nämlich andauernd (=
> Dauerschleife) im "DMA hat fertig" IRQ

Ich hab es mir jetzt nicht den ganzen Sourcecode zugeführt, aber du 
musst das Interrupt-Flag vom DMA manuell wieder löschen. Siehe 
Datenblatt.

[Simon (Gast)]

Dann kann ich dir leider nicht helfen. Ich arbeite immer mit cube und da 
funktioniert es jedes Mal sofort.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

@Simon,
Der Versuch zählt!

@Nils N.
Exakt und vor jedem INit eines DMA.

Den IRQ Handler hab ich ganz verpennt reinzuposten, ups!
Der macht nämlich genau das (Mitm Vorschlghammer alle Bits auf 0 
Klopfen):

dma.c:

static void dma_clear_irq(volatile struct dma * const dma, unsigned int stream, unsigned int bits){
  
  bits &= 0b111101;
  
  if (stream <= 3){
    dma->LIFCR = bits << (stream * 6);
  } else {
    stream -= 4;
    dma->HIFCR = bits << (stream * 6);
  }
}

//IRQ Callback bekommt Statusflags
void dma_irq (unsigned int dma_nbr, unsigned int stream){

  volatile struct dma * const dma = (struct dma *)dma_bases[dma_nbr];
  
  unsigned int errflags = dma_get_irq(dma, stream);
  dma_clear_irq(dma, stream, ISR_TCIF | ISR_HTIF | ISR_TEIF | ISR_DMEIF | ISR_FEIF);
  
  //wenn fertig, dann Stream abschalten
  /*if (errflags & ISR_TCIF){
    dma->stream[stream].SCR &= ~SCR_EN;
  }*/
  
  dprintf("DMA_SCR (IRQ): %X\n", dma->stream[stream].SCR);
  
  nvic_pending_clear(dma_irq_nbrs[dma_nbr][stream]);
  
  if (*callb_irq[dma_nbr][stream]){
    callb_irq[dma_nbr][stream](errflags, callb_data_irq[dma_nbr][stream]);
  }
};

[Curby23523 N. (Gast)]

Ich finde es immer wieder klasse, wenn man erkennt, dass man HAL nicht 
braucht und Register viel praktischer sind. Lesbarer, kürzer und man 
lernt den Prozessor kennen und hat alles selber in der Hand.

Aber bitte, bitte benutze Registermasken.

Das

 if (stream <= 3){
    dma->LIFCR = bits << (stream * 6);
  } else {
    stream -= 4;
    dma->HIFCR = bits << (stream * 6);
  }

Verstehe ich nach 1 Monat nicht mehr. Z.B.

dma->LIFCR |= DMA_LIFCR_CTCIFx; //x = deine Stream-Nummer

Am besten packst du diese Zeile in ein Makro, dann wird es kurz und 
super lesbar! Und das Makro kommt natürlich in eine eigene Headerdatei 
und wird überall eingefügt, wo dus brauchst! Ist so natürlich noch nicht 
fertig das Makro, aber als Idee..

#define CLEAR_DMAINTFLAG(a) dma->LIFCR |= DMA_LIFCR_CTCIF(a)

CLEAR_DMAINTFLAG(x); //x = deine Stream-Nummer

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Is eben nur blöd, dass die 8 Streams über 2 Register verstreut sind.
Daher das ifelse, ne Maske gibts "obendrüber" und sie wird auch 
verwendet:

  //Statusflags für diesen Stream löschen, sonst geht ein Neustart daneben
  dma_clear_irq(dma, stream, ISR_TCIF | ISR_HTIF | ISR_TEIF | ISR_DMEIF | ISR_FEIF);

Die 4 und die 6 könnt man noch ersetzen durch defines.
"STREAM_PER_REG"
"BITS_PER_STREAM"

Ich wollt eben NICHT alle Bitnamen ins enum werfen wo sich nur ne Zahl 
ändert
.. mea culpa

Aber ich bin kuurz vorm umkippen meiner Meinung, gibts nochn starkes 
Argument ;)?

Der HAL für die STM32 ist mir zu viel Tipparbeit mit den ausschweifenden 
Elementnamen im struct und die passenden Values dazu.
Zudem versteht man dann auch nicht was es tut, genau richtig erkannt ;)
STMCube schießt dann noch den Vogel ab, dass es einen absoluten Pfas zum 
GCC will und der muss innerhalb des Projekts liegen.
(Ich kann den Pfad unter "Toolchain Folder Location" nur verlängern aber 
nicht kürzen)

Jetz funktioniert was nicht, da muss man sich mehr durch die Register 
wühlen.
Wenn mit dem HAL was nicht geht, dann muss man im HAL UND in den 
Registern nach dem Fehler wühlen.

[Curby23523 N. (Gast)]

Nun, ich programmiere den STM32 auch nur über Register. Zum Clock 
einstellen brauche ich z.B. 11 Zeilen Code, alles nur einzelne 
OR-Anweisungen etc. PLL aktivieren. HSE ektiviert, PLL aktivieren und 
einstellen, HSI deaktivieren usw...

Um einen Timer einzustellen sind es meist ~5 Zeilen.

Die Peripherie der STM32 bietet oft sehr viele Zusatzfunktionen. Wenn 
man diese aber einfach ignoriert und aus lässt - und das kann man in der 
Regel - ist die Peripherie mit Registern nicht schwerer zu 
parametrieren, als auf einem XMEGA oder gar einem Atmega (z.B. SPI).

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

LÄUFT!

Was wars?
Ersteinmal das fehlende DDS Bit beim SCAN+CONT Mode.
Dann liefs auch eigentlich schon, das "unendliche Aufrufen" des Transfer 
End IRQs scheint wohl auch richtig zu sein obwohl der DMA eigentlich nie 
zuende geht wenn er auf Zirkulär geschalten ist.
-> Trotzdem wird der IRQ ausgelöst.
-> Schalten wir den im SCAN+CONT Mode eben ab und lauschen nurnoch auf 
die Fehler IRQ des ADC und des DMA.
Dadurch hat meine kleine Debugausgabe im IRQ den UART so vollgespammt, 
ass die Arrayausgabe nicht mehr stattfand.

Manchmal sieht sone Tischkante echt lecker aus :/