STM32Duino DMA DAC

[Marc (Gast)]

Ich möchte ein Sinus- und Cosinus Signal auf den zwei DACs eines 
STM32F303 ausgeben.
Praktischerweise hat hier "IVONOMICON" eine sehr schöne Bare-Metal 
Konfiguration für einen Kanal geschrieben.
Nun will ich nicht STM-Cube installieren, sondern das ganze mit der 
Arduino-IDE compilieren.

Ich habe die Bare-Metal Konfiguration etwas modifiziert und in "setup"- 
und "loop" verpackt, das Bare-Metal Delay und durch das Arduino Delay 
ersetzt, die Tabelle ins RAM verlagert und auf 1024 für einen 
hochauflösenden Sinus erweitert.
Und siehe da, es funktioniert super ! Cool :-)

// STM32F303 bare bone DMA DAC
// create a sin wave table an move the values via DMA to the DAC

// https://vivonomicon.com/2019/07/05/bare-metal-stm32-programming-part-9-dma-megamix/

uint16_t Frequency = 1000;
const size_t SINE_SAMPLES = 1024;
uint16_t SINE_WAVE[SINE_SAMPLES];

void initializeSineTable()
{
  float amplitude = 0.8;
  for (int n = 0; n < SINE_SAMPLES; n++)
  {
    SINE_WAVE[n] = sin(n * 2 * PI / SINE_SAMPLES) * amplitude * 2047 + 2048;
  }
}

// Global variable to hold the core clock speed in Hertz.
//uint32_t SystemCoreClock = 8000000;

void setup()
{
  initializeSineTable();

  // Enable peripherals: GPIOA, DMA, DAC, TIM6, SYSCFG.
  RCC->AHBENR   |= ( RCC_AHBENR_GPIOAEN |
                     RCC_AHBENR_DMA1EN );
  RCC->APB1ENR  |= ( RCC_APB1ENR_DAC1EN |
                     RCC_APB1ENR_TIM6EN );
  RCC->APB2ENR  |= RCC_APB2ENR_SYSCFGEN;
  // Pin A4: analog mode. (PA4 = DAC1, Channel 1)
  GPIOA->MODER    &= ~( 0x3 << ( 4 * 2 ) );
  GPIOA->MODER    |=  ( 0x3 << ( 4 * 2 ) );
  // Set the 'TIM6/DAC1 remap' bit in SYSCFG_CFGR1,
  // so that DAC1_Ch1 maps to DMA1_Ch3 instead of DMA2_Ch3.
  // (Not all STM32F303 chips have a DMA2 peripheral)
  SYSCFG->CFGR1 |=  ( SYSCFG_CFGR1_TIM6DAC1Ch1_DMA_RMP );
  // DMA configuration (DMA1, channel 3).
  // CCR register:
  // - Memory-to-peripheral
  // - Circular mode enabled.
  // - Increment memory ptr, don't increment periph ptr.
  // - 16-bit data size for both source and destination.
  // - High priority (2/3).
  DMA1_Channel3->CCR &= ~( DMA_CCR_MEM2MEM |
                           DMA_CCR_PL |
                           DMA_CCR_MSIZE |
                           DMA_CCR_PSIZE |
                           DMA_CCR_PINC |
                           DMA_CCR_EN );
  DMA1_Channel3->CCR |=  ( ( 0x2 << DMA_CCR_PL_Pos ) |
                           ( 0x1 << DMA_CCR_MSIZE_Pos ) |
                           ( 0x1 << DMA_CCR_PSIZE_Pos ) |
                           DMA_CCR_MINC |
                           DMA_CCR_CIRC |
                           DMA_CCR_DIR );
  // Set DMA source and destination addresses.
  // Source: Address of the sine wave buffer in memory.
  DMA1_Channel3->CMAR  = ( uint32_t )&SINE_WAVE;
  // Dest.: DAC1 Ch1 '12-bit right-aligned data' register.
  DMA1_Channel3->CPAR  = ( uint32_t ) & ( DAC1->DHR12R1 );
  // Set DMA data transfer length (# of sine wave samples).
  DMA1_Channel3->CNDTR = ( uint16_t )SINE_SAMPLES;
  // Enable DMA1 Channel 1.
  // Note: the transfer won't actually start here, because
  // the DAC peripheral is not sending DMA requests yet.
  DMA1_Channel3->CCR |= ( DMA_CCR_EN );
  // TIM6 configuration. This timer will set the frequency
  // at which the DAC peripheral requests DMA transfers.
  // Set prescaler and autoreload for a 440Hz sine wave.
  TIM6->PSC  =  ( 0x0000 );
  TIM6->ARR  =  ( SystemCoreClock / ( Frequency * SINE_SAMPLES ) );
  // Enable trigger output on timer update events.
  TIM6->CR2 &= ~( TIM_CR2_MMS );
  TIM6->CR2 |=  ( 0x2 << TIM_CR2_MMS_Pos );
  // Start the timer.
  TIM6->CR1 |=  ( TIM_CR1_CEN );
  // DAC configuration.
  // Set trigger sources to TIM6 TRGO (TRiGger Output).
  DAC1->CR  &= ~( DAC_CR_TSEL1 );
  // Enable DAC DMA requests for channel 1.
  DAC1->CR  |=  ( DAC_CR_DMAEN1 );
  // Enable DAC channel 1.
  DAC1->CR  |=  ( DAC_CR_EN1 );
  // Delay briefly to allow sampling to stabilize.

  delay(10);
  // Enable DAC channel trigger.
  // The DMA channel and timer are both already on, so the
  // DMA transfer will start as soon as the DAC peripheral
  // starts making requests. The DAC peripheral will make a
  // request every time that TIM6 ticks over, but only after
  // this 'trigger enable' bit is set.
  DAC1->CR  |=  ( DAC_CR_TEN1 );
  // Done; a low-res 440Hz sine wave should be playing on PA4.
  Serial.begin(115200);  
}

void loop()
{
  Serial.println(analogRead(A0)); // just reading the ADC to show something on the serial line
  delay(100);
}

Allerdings brauche ich ja zwei Kanäle. Den zweiten für den Cosinus.
Wie würdet ihr vorgehen?
Was gibt es für einen Grund, dass im Code "DMA1_Channel3" verwendet 
wird?
Kann man für den zweiten Kanal einfach "DMA1_Channel4" verwenden?

[J. S. (jojos)]

Die DMA Kanäle sind nicht ganz frei zuzuordnen, da muss man in das 
Reference Manual schauen welche Möglichkeiten es gibt.

[Marc (Gast)]

>Die DMA Kanäle sind nicht ganz frei zuzuordnen, da muss man in das
>Reference Manual schauen welche Möglichkeiten es gibt.

So richtig klar wird es mir nicht, wie die Kanäle zugeordnet sind.

Es gibt an der MCU

3 DACs: DAC1/1 DAC1/2 und DAC1/2 .. warum die seltsamen Bezeichnungen?
Dann scheint es so zu sein, dass man DAC1_CH1 auf DMA1 Kanal 3 routen 
kann (so wie oben im Code gemacht)

Frage:
Warum gibt es zwei DMAs, die aber mit vielen Kanälen?
Im Schaubild sieht es so aus, als wenn man DAC1_CH2 auf den DMA Kanal 4 
der DMA1 routen kann. Geht das gleichzeitig mit der Einstellung für 
Kanal 3 ?
Der Eintrag in der Tabelle 79 passt aber nicht, weil dort bei Kanal 4 
DAC2_CH2 steht .. ist das ein Fehler im Datenblatt?

[STK500-Besitzer (Gast)]

Marc schrieb:
> Warum gibt es zwei DMAs, die aber mit vielen Kanälen?

Weil andere Schnittstellen auch per DMA steuerbar sind.

Marc schrieb:
> Im Schaubild sieht es so aus, als wenn man DAC1_CH2 auf den DMA Kanal 4
> der DMA1 routen kann. Geht das gleichzeitig mit der Einstellung für
> Kanal 3 ?

Für diese Information bietet sich ein Blick in das Reference Manual des 
STM32F303 an.

[Marc (Gast)]

>Für diese Information bietet sich ein Blick in das Reference Manual des
>STM32F303 an.

Genau .. und daraus habe ich auch die obigen Bilder kopiert.
Im Pinout für den NucleoF303K8 gibt es einen DAC2_CH1 aber in der 
Tabelle gibt es DAC2_CH2. Das passt irgendwie nicht zusammen.

[Kevin M. (arduinolover)]

Auf dem NUCLEO sind DAC1 Ch1 und Ch2 rausgeführt. DMA1 kann aber nur 
DAC1 Ch1.

[Marc (Gast)]

>Auf dem NUCLEO sind DAC1 Ch1 und Ch2 rausgeführt. DMA1 kann aber nur
>DAC1 Ch1.

Das passt aber nicht zur Footnote im Reference-Manual.

Dort gibt es das Bit 14 im SYSCFG Register zum Mappen von Timer 7, 
DAC1_CH2

SYSCFG_CFGR1_TIM7DAC1Ch2_DMA_RMP

[LM337 vs. LM317 (Gast)]

Versuchs doch mal mit dem DualMode (siehe Anhang). Damit brauchst du für 
beide Kanäle nur einen DMA. Ein weiterer Vorteil ist das beide Kanäle 
gleichzeitig geschrieben werden.

Deine SIN Tabelle müsste dann mit uint32_t sein und sowohl sin als auch 
cos Werte enthalten.

Die DMA musst du auch noch anpassen.

Das DMA1_Channel3->CPAR kann DAC_DHR12LD oder DAC_DHR12RD sein
16-bit data size sollte noch 32-bit data size geändert werden.

Cheers

[Marc (Gast)]

>Versuchs doch mal mit dem DualMode (siehe Anhang).

Danke für den Hinweis. Nach einiger Suche bin ich auch schon auf den 
Dual-Mode gestoßen.
Aber irgendwie funktioniert trotzdem nur der Ausgang PA4. Es sieht so 
aus, als wenn PA5 hochohmig bleibt (das Oszi floated). Die Gegenprobe 
mit analogWrite zeigt aber, dass der Kanal hardwaremässig funktioniert.

Mache ich irgend was falsch bei der Port Konfiguration?

Hier mal der nur auf einem Kanal funktionierende Code, bei dem der 
zweite einfach nicht will:

// STM32F303 bare bone DMA DAC
// create a sin wave table an move the values via DMA to the DAC

// https://vivonomicon.com/2019/07/05/bare-metal-stm32-programming-part-9-dma-megamix/

uint16_t Frequency = 100;

const size_t SINE_SAMPLES = 1024;

uint32_t SINE_WAVE[SINE_SAMPLES];

void initializeSineTable()
{
  float amplitude = 0.8;
  for (int n = 0; n < SINE_SAMPLES; n++)
  {
    uint32_t x= sin(n * 2 * PI / SINE_SAMPLES) * amplitude * 2047 + 2048;
    uint32_t y= cos(n * 2 * PI / SINE_SAMPLES) * amplitude * 2047 + 2048;
    SINE_WAVE[n] = x+(y<<16);
  }
}

void setDMA_DAC_dualMode()
{
  // Enable peripherals: GPIOA, DMA, DAC, TIM6, SYSCFG.
  RCC->AHBENR   |= ( RCC_AHBENR_GPIOAEN | RCC_AHBENR_DMA1EN );
  RCC->APB1ENR  |= ( RCC_APB1ENR_DAC1EN | RCC_APB1ENR_TIM6EN );
  RCC->APB2ENR  |= RCC_APB2ENR_SYSCFGEN;
  // Pin A4: analog mode. (PA4 = DAC1, Channel 1)
  GPIOA->MODER    &= ~( 0x3 << ( 4 * 2 ) );
  GPIOA->MODER    |=  ( 0x3 << ( 4 * 2 ) );
  // Pin A5: analog mode. (PA5 = DAC1, Channel 2)
  GPIOA->MODER    &= ~( 0x3 << ( 5 * 2 ) );
  GPIOA->MODER    |=  ( 0x3 << ( 5 * 2 ) );
  // Set the 'TIM6/DAC1 remap' bit in SYSCFG_CFGR1,
  // so that DAC1_Ch1 maps to DMA1_Ch3 instead of DMA2_Ch3.
  // (Not all STM32F303 chips have a DMA2 peripheral)
  SYSCFG->CFGR1 |=  ( SYSCFG_CFGR1_TIM6DAC1Ch1_DMA_RMP );
  // DMA configuration (DMA1, channel 3).
  // CCR register:
  // - Memory-to-peripheral
  // - Circular mode enabled.
  // - Increment memory ptr, don't increment periph ptr.
  // - 32-bit data size for both source and destination.
  // - High priority (2/3).
  DMA1_Channel3->CCR &= ~( DMA_CCR_MEM2MEM |
                           DMA_CCR_PL |
                           DMA_CCR_MSIZE |
                           DMA_CCR_PSIZE |
                           DMA_CCR_PINC |
                           DMA_CCR_EN );
  DMA1_Channel3->CCR |=  ( ( 0x2 << DMA_CCR_PL_Pos ) |
                           ( 0x2 << DMA_CCR_MSIZE_Pos ) |
                           ( 0x2 << DMA_CCR_PSIZE_Pos ) |
                           DMA_CCR_MINC |
                           DMA_CCR_CIRC |
                           DMA_CCR_DIR );
               
  // Set DMA source and destination addresses.
  // Source: Address of the sine wave buffer in memory.
  DMA1_Channel3->CMAR  = ( uint32_t )&SINE_WAVE;
  //obsolete: Dest.: DAC1 Ch1 '12-bit right-aligned data' register.
  //Dual DAC 12-bit right-aligned data holding register
  //DMA1_Channel3->CPAR  = ( uint32_t ) & ( DAC1->DHR12RD );
  // Set DMA data transfer length (# of sine wave samples).
  DMA1_Channel3->CNDTR = ( uint16_t )SINE_SAMPLES;

  // TIM6 configuration. This timer will set the frequency
  // at which the DAC peripheral requests DMA transfers.
  // Set prescaler and autoreload for the frequency
  TIM6->PSC  =  ( 0x0000 );
  TIM6->ARR  =  ( SystemCoreClock / ( Frequency * SINE_SAMPLES ) );
  // Enable trigger output on timer update events.
  TIM6->CR2 &= ~( TIM_CR2_MMS );
  TIM6->CR2 |=  ( 0x2 << TIM_CR2_MMS_Pos );
  // Start the timer.
  TIM6->CR1 |=  ( TIM_CR1_CEN );
  
  // DAC dual mode
  // https://electronics.stackexchange.com/questions/607624/what-does-dual-dac-mode-mean-for-this-microcontroller-board
  // Reference Manual RM0316
  // page 432
  // DAC configuration.
  //
  // ***  Simultaneous trigger without wave generation **
  //  To configure the DAC in this conversion mode, the following sequence is required:
  //  1. Set the two DAC channel trigger enable bits TEN1 and TEN2
  DAC1->CR  |=  ( DAC_CR_TEN1 );
  DAC1->CR  |=  ( DAC_CR_TEN2 ); // channel 2 trigger enable

  // 2. Configure the same trigger source for both DAC channels by setting the same value in
  // the TSEL1[2:0] and TSEL2[2:0] bits
  // Set trigger sources to TIM6 TRGO (TRiGger Output).
  DAC1->CR  &= ~( DAC_CR_TSEL1 );
  DAC1->CR  &= ~( DAC_CR_TSEL2 ); // channel 2 trigger source the same

  //3. Load the dual DAC channel data to the desired DHR register (DAC_DHR12RD,
  //    DAC_DHR12LD or DAC_DHR8RD)
  DMA1_Channel3->CPAR  = ( uint32_t ) & ( DAC1->DHR12RD );
  // Note: the transfer won't actually start here, because

  //When a trigger arrives, the DHR1 and DHR2 registers are transferred into DAC_DOR1 and
  //DAC_DOR2, respectively (after three APB clock cycles).
  
  // Enable DAC DMA requests for channel 1.
  DAC1->CR  |=  ( DAC_CR_DMAEN1 );
  DAC1->CR  |=  ( DAC_CR_DMAEN2 );
  // Enable DAC channel 1.
  DAC1->CR  |=  ( DAC_CR_EN1 );
  DAC1->CR  |=  ( DAC_CR_EN2 );
  // Delay briefly to allow sampling to stabilize.

  delay(10);
  // the DAC peripheral is not sending DMA requests yet.
  DMA1_Channel3->CCR |= ( DMA_CCR_EN );
  
}

void setup()
{
  initializeSineTable();
  setDMA_DAC_dualMode();
  
  // Done; a low-res 440Hz sine wave should be playing on PA4.
  Serial.begin(115200);
}

void loop()
{
  static int n;

  Serial.print(SINE_WAVE[n]&0xFFFF); Serial.print(' ');Serial.println((SINE_WAVE[n++]>>16)&0xFFFF);
  if(n>=SINE_SAMPLES)n=0;
  delay(10);
}

[Marc (Gast)]

Wenn ich die direkte Initialisierung von GPIOA durch analogWrite ersetze 
geht es ...
Hat irgend jemand eine Idee, woran das liegen könnte?

  analogWrite(PA4,0);
  analogWrite(PA5,0);
  //GPIOA->MODER    &= ~( 0x3 << ( 4 * 2 ) );
  //GPIOA->MODER    |=  ( 0x3 << ( 4 * 2 ) );
  // Pin A5: analog mode. (PA5 = DAC1, Channel 2)
  //GPIOA->MODER    &= ~( 0x3 << ( 5 * 2 ) );
  //GPIOA->MODER    |=  ( 0x3 << ( 5 * 2 ) );

[LM337 vs. LM317 (Gast)]

Hast du ein Nucleo 32 F303?
Falls ja wie hast du PB7 konfiguriert? Bzw. wie sieht es mit SB18 aus?

[Marc (Gast)]

>Hast du ein Nucleo 32 F303?

Ja, es ist ein Nucleo F303K8 wie oben im Bild 
https://www.mikrocontroller.net/attachment/576207/NucleoF303K8_DAC_DMA.png
Das Board ist unverändert, I2C benutze ich nicht und die DMA 
funktioniert ja auf beiden Kanällen, wenn ich die analogWrite statt der 
Baremetal Initialisierung mit MODER benutze.

[Marc (Gast)]

Hier mal eine "baremetal" Implementierung für ein Nucleo STM32L432KC 
ohne DMA.

// Nucleo STM32L432KC baremetal DACs for STM32Duino
// Sawtooth signals are generated on DAC1 and DAC2 outputs
// 11.11.22 
// 
// https://www.mikrocontroller.net/topic/545574#7245120

/*
  RM0394
  Reference manual
  STM32L41xxx/42xxx/43xxx/44xxx/45xxx/46xxx
  advanced Arm ® -based 32-bit MCUs
*/

// definitions can be found in
// .. arduino15/packages/STMicroelectronics/hardware/stm32/2.3.0/system/Drivers/CMSIS/Device/ST/STM32L4xx/Include
// stm32l432xx.h


#define DAC1_1 A3
#define DAC1_2 A4


void initializeDAC()
{
  analogWrite(DAC1_1, 0); // initialize DAC1 port
  analogWrite(DAC1_2, 0); // initialize DAC2 port

  // DAC configuration.
  //TSEL1[2:0]: DAC channel1 trigger selection
  //These bits select the external event used to trigger DAC channel1
  //Refer to the trigger selection tables in Section 17.4.6: DAC trigger selection for the details on
  //trigger configuration and mapping.
  //Note: Only used if bit TEN1 = 1 (DAC channel1 trigger enabled).
  DAC1->CR  |=  ( DAC_CR_TSEL1 );
  
  //MODIFY_REG(DAC1->CCR, DAC_MCR_MODE1, 0);// 000: DAC Channel 1 is connected to external pin with Buffer enabled
  DAC1->CCR &= ~(DAC_MCR_MODE1);
  
  // Enable DAC channel 1.
  DAC1->CR  |=  ( DAC_CR_EN1 );
  // Delay briefly to allow sampling to stabilize.
  delay(10);
  
  //TEN1: DAC channel1 trigger enable
  //This bit is set and cleared by software to enable/disable DAC channel1 trigger.
  //0: DAC channel1 trigger disabled and data written into the DAC_DHR1 register are
  //transferred one APB1 clock cycle later to the DAC_DOR1 register
  //1: DAC channel1 trigger enabled and data from the DAC_DHR1 register are transferred
  //three APB1 clock cycles later to the DAC_DOR1 register
  //When software trigger is selected, the transfer from the DAC_DHR1 register to the
  //DAC_DOR1 register takes only one APB1 clock cycle.
  //DAC1->CR  |=  ( DAC_CR_TEN1 );
  DAC1->CR  &= ~  ( DAC_CR_TEN1 ); // no trigger, change directly after write

// channel 2
  DAC1->CR  |=  ( DAC_CR_TSEL2 );
  DAC1->CCR &= ~(DAC_MCR_MODE2);
  DAC1->CR  |=  ( DAC_CR_EN2 );
  delay(10);
  DAC1->CR  &= ~  ( DAC_CR_TEN2 );
}

void setup()
{
  initializeDAC();
}

void loop()
{
  for (uint16_t n = 0; n < 4096; n++)
  {
    uint32_t a=n;
    uint32_t b=4095-n;
    
    DAC1->DHR12RD = a+(b<<16);

    //DAC1->SWTRIGR|=(1<<DAC_SWTRIGR_SWTRIG1_Pos); // not trigger needed when TEN1=0

    //delayMicroseconds(1);
  }
}