stm32F103 DMA Uart3 und Uart4 zu tunneln

[Andreas M. (chillymu)]

Hi Leute

ich habe mal eine Frage.

Ist es im STM32F103 möglich, über DMA Zeichen von UART3 zu bekommen und 
sie direkt, ohne Interrupt, an UART4 zu senden und umgekehrt? Dabei ist 
die Zeichen länge nicht genau definiert.

RX_UART3 --> DMA --> TX_UART4
TX_UART3 <-- DMA <-- RX_UART4

Ich habe gelesen das der DMA Peripheral-to-Peripheral kann.

Ist das vielleicht das was ich suche und hat schon jemand damit 
Erfahrung?


Gruß Andreas

[Bimbo. (Gast)]

Also bei meinem STM32F4 ist das ohne Probleme möglich.
Der Rest steht im Datenblatt deines Controllers.

[Bernd (Gast)]

Gemacht habe ich es noch nicht. In der Referenz des STM32F103 (June 2014 
DocID13902 Rev 151/1128 RM0008 Reference manual) steht als Feature:

Peripheral-to-memory and memory-to-peripheral, and 
peripheral-to-peripheral transfers

Sollte also funktionieren.

[Andreas M. (chillymu)]

Genau Bernd, das habe ich auch gelesen.

Die Frage dabei ist wie genau funktioniert das bzw. was muss ich da wie 
programmieren?
Ich habe mit DMA noch nicht so viel Erfahrung.

[pegel (Gast)]

Nö.
der F103 hat nur USART1 .. USART3.

[Spongebob (Gast)]

Andreas M. schrieb:
> Genau Bernd, das habe ich auch gelesen.
>
> Die Frage dabei ist wie genau funktioniert das bzw. was muss ich da wie
> programmieren?
> Ich habe mit DMA noch nicht so viel Erfahrung.

Du hast Riesenglück:
Das steht im Reference Manual! Einfach durchlesen, Register setzen und 
schon läuft es.
Und das Beste: Dabei bekommst Du automatisch die Erfahrung!

[Spongebob (Gast)]

pegel schrieb:
> Nö.
> der F103 hat nur USART1 .. USART3.

Er hat nach UART gefragt.
Also korrekte Antwort:
Er hat je nach Modell USART1..3 und UART4..5.

[Gerd E. (robberknight)]

Andreas M. schrieb:
> Dabei ist
> die Zeichen länge nicht genau definiert.

das macht es schwierig.

Denn beim DMA musst Du immer genau angeben wieviele Bytes transferiert 
werden sollen.

Wenn dauerhaft einfach alles kopiert werden soll, wäre zu fragen warum 
Du nicht einfach die entsprechenden Pins direkt miteinander verbindest 
und den Controller ganz außen vor lässt.

[Alex D. (daum)]

Gerd E. schrieb:
> Denn beim DMA musst Du immer genau angeben wieviele Bytes transferiert
> werden sollen.

Man kann den DMA auch auf Continuous mode stellen, wenn kein die 
Register bzw Speicherstellen immer die gleichen bleiben, ist dann auch 
die eingestellte Länge egal, der fängt danach einfach wieder von vorne 
an.

[Andreas M. (chillymu)]

Also langsam.
1. Ja, mein STM32F103RE hat 5 UART-Schnittstellen.
2. Das mit dem direkten Verbinden geht nicht mehr da die Leiterplatte 
schon fertig ist.

SpongeBob: ich werde das mal anschauen mit dem Reference Manual.

[tgdfgdf (Gast)]

dann setz den auf bytetransfer
dann wird jedes byte einzeln durchgeschubst
lass den NVIC aus dann kommt auch kein interrupt

[Andreas M. (chillymu)]

Hi Leute,

ich habe mir das reference Manual jetzt mal angeschaut aber so richtig 
werde ich nicht daraus schlau.

Ich arbeite mit der Standardbibliothek und habe den UART eingebunden, 
die GPIOs gesetzt und den NVIC ausgeschaltet.
Wie mache ich das jetzt mit dem DMA? Ich finde den bytetransfer auch 
nirgends.

unsigned char sys_uart_init_dma_uart1()
{
  GPIO_InitTypeDef GPIO_InitStructure;
  DMA_InitTypeDef DMA_InitStructure;
  USART_InitTypeDef USART_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  
  // Baudrate einstellen
  USART_InitStructure.USART_BaudRate = 115200;
  // Anzahl an DatenBits einstellen
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  // Parität einstellen
  USART_InitStructure.USART_Parity = USART_Parity_No;
  // StopBits einstellen
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  // Flusssteuerng einstellen
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  // Richtung der Schnittstelle einstellen
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  USART_Init(USART1, &USART_InitStructure);
  USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
  USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
  USART_Cmd(USART1, ENABLE);

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);  // Periph clock enable
  
  // PINs konfigurieren
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;        //Txx
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;        //Rxx
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;        //CTS
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;        //RTS
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  // Interuppt ausschlaten
  NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  // DMA konfigurieren
  DMA_InitStructure.DMA_BufferSize = 0;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)DMA_UART_Buffer;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART3;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_Init(DMA1_Channel1, &DMA_InitStructure);

  DMA_Cmd(DMA1_Channel1, ENABLE);


  return 0;
}

[Beo Bachta (Gast)]

Grob drübergeflogen vermute ich dass du noch folgendes
berückschtigen musst:

- du brauchst zwei DMA Kanäle, je einen für Rx und Tx
- die Quell- bzw Ziel-Adresse des DMA-Memory muss dein
jeweiliges Rx- und TX-Register sein.
- der Funktionsaufruf DMA_Cmd (..) startet bereits DMA so
wie du DMA vorhergehend konfiguriert hast.

[Andreas M. (chillymu)]

Ich habe jetzt mal was hinzugefügt. Aber woher weiß jetzt der DMA das 
der alles was am UART1 ankommt an UART 2 geschickt werden soll und 
umgedreht?

// DMA UART1_RX konfigurieren
  DMA_InitStructure.DMA_BufferSize = 0;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)DMA_UART_RX_Buffer;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_Init(DMA1_Channel5, &DMA_InitStructure);

  // DMA UART1_TX konfigurieren
  DMA_InitStructure.DMA_BufferSize = 0;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)DMA_UART_TX_Buffer;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_Init(DMA1_Channel4, &DMA_InitStructure);
  
  
  DMA_Cmd(DMA1_Channel4, ENABLE);
  DMA_Cmd(DMA1_Channel5, ENABLE);