Fragen zu DMA im Controller

[Owen S. (senmeis)]

Hallo,

ich möchte einen Entwicklungsboard Discovery von ST zum Laufen bringen. 
Nun bin ich überfordert von einem Beispiel mit USART und DMA. Der Code 
wird unten dargestellt.

Die Beschreibung hier:
The USART sends a predefined TxBuffer to the HyperTerminal and keep 
waiting data to be entered by user (The number of bytes to receive is 
defined by "DATA_TO_RECEIVE" constant). Each character sent by user is 
transferred using USART DMA receiver request to RxBuffer, when RxBuffer 
is filled the DMA transfer complete flag is set and LD1..LD4 start 
toggling in an infinite loop.

Frage 1: Welche Zeile startet die USART Kommunikation? Soweit ich 
verstehe sollte die zweite while() Schleife nur ausgeführt werden wenn 
die erste fertig ist, aber das ist der Fall. Der Controller sendet immer 
Daten egal ob Daten empfangen werden.

Frage 2: Was ist der Unterschied zwischen DMA und Interrupts? Ich meine, 
mit Interrupts können Tasks auch im Hintergrund laufen.

Code:

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#ifdef USE_STM8L1526_EVAL
/* define the DMA parameters related to USART1 since USE_STM8L1526_EVAL is used */
#define USART_DMA_CHANNEL_RX   DMA1_Channel2
#define USART_DMA_CHANNEL_TX   DMA1_Channel1
#define USART_DMA_FLAG_TCRX    (uint16_t)DMA1_FLAG_TC2
#define USART_DMA_FLAG_TCTX    (uint16_t)DMA1_FLAG_TC1
#define USART_DR_ADDRESS       (uint16_t)0x5231  /* USART1 Data register Address */
#else /* USE_STM8L1528_EVAL */
/* define the DMA parameters related to USART2 since USE_STM8L1528_EVAL is used */
#define USART_DMA_CHANNEL_RX   DMA1_Channel3
#define USART_DMA_CHANNEL_TX   DMA1_Channel0
#define USART_DMA_FLAG_TCRX    (uint16_t)DMA1_FLAG_TC3
#define USART_DMA_FLAG_TCTX    (uint16_t)DMA1_FLAG_TC0
#define USART_DR_ADDRESS       (uint16_t)0x53E1  /* USART2 Data register Address */
#endif /* USE_STM8L1526_EVAL */

#define USART_BAUDRATE         (uint32_t)9600
#define DATA_TO_TRANSFER       (countof(TxBuffer) - 1)
#define DATA_TO_RECEIVE        (uint8_t) 0x05

/* Private macro -------------------------------------------------------------*/
#define countof(a)            (sizeof(a) / sizeof(*(a)))

/* Private variables ---------------------------------------------------------*/
uint8_t TxBuffer[] = "\n\rUSART Example:USART-Hyperterminal communication using DMA.\nEnter your Text\n\r";
uint8_t RxBuffer[DATA_TO_RECEIVE] = {0};

/* Private function prototypes -----------------------------------------------*/
static void CLK_Config(void);
static void DMA_Config(void);
static void USART_Config(void);
void Delay (uint32_t nCount);
/* Private functions ---------------------------------------------------------*/

/**
  * @brief  Main program.
  * @param  None
  * @retval None
  */
void main(void)
{
   /* CLK configuration -------------------------------------------*/
  CLK_Config();
  
  /* Initialize LEDs mounted on STM8L152X-EVAL board */
  STM_EVAL_LEDInit(LED1);
  STM_EVAL_LEDInit(LED2);
  STM_EVAL_LEDInit(LED3);
  STM_EVAL_LEDInit(LED4);

   /* USART configuration -------------------------------------------*/
  USART_Config();
  
   /* DMA configuration -------------------------------------------*/
  DMA_Config();

  /* USART Enable */
  USART_Cmd(EVAL_COM1, ENABLE);

  /* Wait the USART DMA Tx\Rx transfer complete */
  while (DMA_GetFlagStatus((DMA_FLAG_TypeDef)USART_DMA_FLAG_TCRX) == RESET);
  while (DMA_GetFlagStatus((DMA_FLAG_TypeDef)USART_DMA_FLAG_TCTX) == RESET);
  
  while (1)
  {
    STM_EVAL_LEDToggle(LED1);
    STM_EVAL_LEDToggle(LED2);
    STM_EVAL_LEDToggle(LED3);
    STM_EVAL_LEDToggle(LED4);
    Delay((uint32_t)0xFFFFF);
  }
}

/**
  * @brief  Configure peripherals Clock   
  * @param  None
  * @retval None
  */
static void CLK_Config(void)
{
  /*High speed external clock prescaler: 1*/
  CLK_SYSCLKDivConfig(CLK_SYSCLKDiv_1);

  /*Enable DMA clock */
  CLK_PeripheralClockConfig(CLK_Peripheral_DMA1, ENABLE);
}

/**
  * @brief  Configure DMA peripheral  
  * @param  None
  * @retval None
  */
static void DMA_Config(void)
{
  /* Deinitialize DMA channels */
  DMA_GlobalDeInit();

  DMA_DeInit(DMA1_Channel1);
  DMA_DeInit(DMA1_Channel2);

  /* DMA channel Rx of USART Configuration */
  DMA_Init(USART_DMA_CHANNEL_RX, (uint16_t)RxBuffer, (uint16_t)USART_DR_ADDRESS,
           DATA_TO_RECEIVE, DMA_DIR_PeripheralToMemory, DMA_Mode_Normal,
           DMA_MemoryIncMode_Inc, DMA_Priority_Low, DMA_MemoryDataSize_Byte);

  /* DMA channel Tx of USART Configuration */
  DMA_Init(USART_DMA_CHANNEL_TX, (uint16_t)TxBuffer, (uint16_t)USART_DR_ADDRESS,
           DATA_TO_TRANSFER, DMA_DIR_MemoryToPeripheral, DMA_Mode_Normal,
           DMA_MemoryIncMode_Inc, DMA_Priority_High, DMA_MemoryDataSize_Byte);

  /* Enable the USART Tx/Rx DMA requests */
  USART_DMACmd(EVAL_COM1, USART_DMAReq_TX, ENABLE);
  USART_DMACmd(EVAL_COM1, USART_DMAReq_RX, ENABLE);

  /* Global DMA Enable */
  DMA_GlobalCmd(ENABLE);

  /* Enable the USART Tx DMA channel */
  DMA_Cmd(USART_DMA_CHANNEL_TX, ENABLE);
  /* Enable the USART Rx DMA channel */
  DMA_Cmd(USART_DMA_CHANNEL_RX, ENABLE);         
}

/**
  * @brief  Configure USART peripheral  
  * @param  None
  * @retval None
  */
static void USART_Config(void)
{
  /* EVAL COM (USARTx) configuration -----------------------------------------*/
  /* USART configured as follow:
        - BaudRate = USART_BAUDRATE baud  
        - Word Length = 8 Bits
        - One Stop Bit
        - No parity
        - Receive and transmit enabled
        - USART Clock disabled
  */
  STM_EVAL_COMInit(COM1, (uint32_t)USART_BAUDRATE, USART_WordLength_8b, USART_StopBits_1,
                   USART_Parity_No, (USART_Mode_TypeDef)(USART_Mode_Tx | USART_Mode_Rx));

  /* USART Disable */
  USART_Cmd(EVAL_COM1, DISABLE);
}

/**
  * @brief  Delay.
  * @param  nCount
  * @retval None
  */
void Delay(uint32_t nCount)
{
  /* Decrement nCount value */
  while (nCount != 0)
  {
    nCount--;
  }
}

Gruss
Owen

[Reinhard B. (brainstorm)]

Hallo!

Also ich bin zwar auf dem STM32 unterwegs, aber die Peripherie ist ja 
recht ähnlich.

> Frage 1: Welche Zeile startet die USART Kommunikation? Soweit ich
> verstehe sollte die zweite while() Schleife nur ausgeführt werden wenn
> die erste fertig ist, aber das ist der Fall. Der Controller sendet immer
> Daten egal ob Daten empfangen werden.

Der USART wird mit der Zeile USART_Cmd(EVAL_COM1, ENABLE) gestartet.

Ich nehme an du beziehst dich auf diese zwei whiles:
>  while (DMA_GetFlagStatus((DMA_FLAG_TypeDef)USART_DMA_FLAG_TCRX) == RESET);
>  while (DMA_GetFlagStatus((DMA_FLAG_TypeDef)USART_DMA_FLAG_TCTX) == RESET);

Der Effekt dieser Zeilen ist der, dass der Code danach erst ausgeführt 
wird, wenn die DMA Transfers für RX und TX fertig sind. DMA Transfer 
hier nicht mit UART Transfer verwechseln!

Ich habe mit DMA selbst noch nichts gemacht, aber ich sehe den Ablauf 
so:
Durch das Enablen des UARTS mit USART_Cmd(...) setzt die UART Peripherie 
das TXE Bit. Deshalb schreibt der DMA das erste Byte ins DR und die 
Sache läuft. Die LEDs sollten meinem Verständnis nach erst blinken, wenn 
du zusätzlich auch noch DATA_TO_RECEIVE Bytes an den Controller gesendet 
hast, aber vielleicht übersehe ich da was.

> Frage 2: Was ist der Unterschied zwischen DMA und Interrupts? Ich meine,
> mit Interrupts können Tasks auch im Hintergrund laufen.

DMA kopiert Daten von einer Speicherstelle auf eine andere ohne Zutun 
der CPU. DMA führt also keine Befehle im Sinn von CPU-Instruktionen aus.

Der Handler eines Interrupts ist einfach ein Programmabschnitt, der von 
der CPU abgearbeitet wird. Da können Daten kopiert werden, aber auch 
andere Dinge geschehen.

mfg

[Owen S. (senmeis)]

Vielen Dank für Deine Hilfe.

Nun habe ich versucht, den Code so zu ändern, dass der Controller Daten 
zyklisch sendet. Das funktioniert soweit mit der folgenden Main Methode. 
Das ist irgendwie nicht effizient denn DMA_Config() und USART_Cmd() 
befinden sich in der while Schleife. Wenn diese aber herausgeholt werden 
funktioniert das Senden nicht mehr.

Ich bin dankbar für jeden Vorschlag.

void main(void)
{
   /* CLK configuration -------------------------------------------*/
  CLK_Config();
  
   /* USART configuration -------------------------------------------*/
  USART_Config();
   
  while (1)
  {
    /* DMA configuration -------------------------------------------*/
    DMA_Config();
  
    /* USART Enable */
    USART_Cmd(EVAL_COM1, ENABLE);
    
    /* Wait the USART DMA Tx transfer complete */
    while (DMA_GetFlagStatus((DMA_FLAG_TypeDef)USART_DMA_FLAG_TCTX) == RESET);
  
    Delay((uint32_t)0xFFFF);
  }
}

Gruss
Owen

[Reinhard B. (brainstorm)]

Owen Senmeis schrieb:
> Das ist irgendwie nicht effizient denn DMA_Config() und USART_Cmd()
> befinden sich in der while Schleife. Wenn diese aber herausgeholt werden
> funktioniert das Senden nicht mehr.

Wohin herausholen? Du müsstest entweder den DMA für den circular mode 
konfigurieren, oder den DMA in seiner ISR neu konfigurieren. Das erneute 
'enablen' des UART sollte nicht notwendig sein.

Du solltest dir den Abschnitt über DMA im Reference Manual mal von vorne 
bis hinten durchlesen.

mfg

[Owen S. (senmeis)]

In diesem Beispiel ist ein Makro zu sehen:

#define USART_DR_ADDRESS       (uint16_t)0x5231  /* USART1 Data register Address */

Diese Adresse wird aber im Manual nicht gefunden, nur im File stm8l15x.h 
steht:

#define USART1_BASE                 (uint16_t)0x5230

Ist diese Adresse frei wählbar?

Gruss
Owen

[Reinhard B. (brainstorm)]

Owen Senmeis schrieb:
> Ist diese Adresse frei wählbar?

Nein, das ist die Adresse der UART Peripheral - bzw. des DR des UARTs. 
Steht scheinbar nicht im RM, aber im Datasheet (Seite 37,  Fig. 9).

Frei wählen kannst du (natürlich nur in sinnvollem Kontext) TxBuffer und 
RxBuffer.

mfg