STM32F4 - RCC Register Problem

[SUNP (Gast)]

Guten Morgen,

auf einem STM32F439 möchte ich gerne den USART1 verwenden.
Mein bisheriger Code funktioniert auch und tut das, was er soll aber 
leider nur im Debugger bzw. wenn ich einen Breakpoint ab einer 
bestimmten Stelle ich Code habe. Ohne Debugger bzw. Breakpoint habe ich 
ein für mich unerklärliches Verhalten.

RCC->APB2ENR |= ((uint32_t)1) << 4;

// Port PA9  -> Transmitter Out
GPIOA->MODER |= ((uint32_t)1) << 19; // Alternate Function UART-TX
GPIOA->OSPEEDR |= ((uint32_t)1) << 18; // Output Speed -> Medium
GPIOA->PUPDR |= ((uint32_t)1) << 18;   // Pull-Up Enable
GPIOA->AFR[1] |= ((uint32_t)7) << 4;   // Alternate Funktion 8 UART-TX 
   
// Port PA10 -> Receiver In
GPIOA->MODER |= ((uint32_t)1) << 21; // Alternate Function UART-RX     
GPIOA->PUPDR |= ((uint32_t)1) << 20;   // Pull-Up Enable
GPIOA->AFR[1] |= ((uint32_t)7) << 8;   // Alternate Funktion 8 UART-RX
   
// Port PC9 -> RS485 Treiber Enable
GPIOC->MODER |= ((uint32_t)1) << 18;   // Output
GPIOC->OSPEEDR |= ((uint32_t)1) << 18; // Output Speed -> Medium
GPIOC->PUPDR |= ((uint32_t)1) << 18;   // Pull-Up Enable
   
// Allgemeine USART-1-Tx-Rx Einstellungen
USART1->CR1 = 0x3800; // 9 Datenbits, UART Peripherie enable 
                      // aber Transmitter und Receiver disable, keine 
                      // Parity Control. Oversampling by 16.
USART1->CR2 = 0x00;   // 1 Stop Bit
USART1->CR3 = 0x808;  // CTS/RTS abgestellt, Half-Duplex Mode

// Baudrate einstellen
USART1->BRR = 0x0000222E; // 9600 Baud. Bei einem 84 MHz USART1

// Außgänge richtig setzen.
GPIOA->ODR |= ((uint32_t)1)<<9; // Transmitter und Receiver abgeschaltet. 
                                // Tx bin wird auf High gestellt.
  
GPIOC->ODR &= ~(((uint32_t)1)<<9); // RS485 Treiber Disable

Das war die Initialisierung vom USART 1.
Im zweiten Teil mache ich ein paar Einstellungen, damit der USART so 
funktioniert, wie ich es gerne hätte.

//UART ist eine von mir angelegte Struktur
// Alle USART1 Interupts werden zur Sicherheit abgeschaltet
USART1->CR1 &= ~(0x000001F0);
UART.TxData = stdata;
UART.TxLength = -1; // wegen den Dummy Daten
// Tx PortPin auf GPIO setzen, damit die Dummydaten nicht 
// an den Treiber übertragen werden.
// Port PA9  -> Transmitter Out
GPIOA->MODER &= ~(((uint32_t)1) << 19); // Alternate Function ausgestellt
GPIOA->MODER |= ((uint32_t)1) << 18;   // GPIO Mode für UART-TX PinA9

  
GPIOC->ODR |= ((uint32_t)1)<<9; // RS485 Treiber Enable
USART1->DR = 0x111;   // Nur ein Dummybyte
USART1->CR1 |= 0x00000088;   // TXE und TXE Interupt enable

Setze ich an einer beliebigen Stelle ! nach ! der Befehlszeile
RCC->APB2ENR |= ((uint32_t)1) << 4;
einen Breakpoint, dann funktioniert mein Code wie gewünscht. Habe ich am 
Oszi nachgemessen. Fehlt dieser Breakpoint kommt es zu einem 
Vehlverhalten.
Folgende IF-Bedinung wird in der USART1 Interuptroutine nur erfüllt, 
wenn irgendwo zuvor kurz an einem Breakpoint angehalten wurde.

volatile uint32_t ulInterrupt = USART1->SR;
if((ulInterrupt &  UART_TXE_FLAG) && !(ulInterrupt & UART_TC_FLAG))

Im Errata Sheet habe ich folgendes gelesen:

A delay between an RCC peripheral clock enabling and the effective 
peripheral enabling should be taken into account in order to manage the 
peripheral read/write to registers.

Setze ich ein __asm("DSB");  oder zwei __NOP(); hinter RCC->APB2ENR |= 
((uint32_t)1) << 4;  bringt das auch nicht das gewünschte Ergebniss.

Könnt ihr mir vielleicht weiterhelfen ?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Wie soll man - wir als Erstseher des Codes sowieso - diesen Code denn 
verstehen? Mit direkten Bits blickst du selber nach 1 Monat nicht mehr 
durch und der Code ist auch kein bisschen portierbar.

Ich bin ja oft selber kein Freund von vorgekautem Kram, aber bei den 
STM32 ist zumindest CMSIS problemlos, schnell und funktioniert - es muss 
ja nicht gleich Cube sein.
Schreib wenigstens statt

GPIOA->MODER |= ((uint32_t)1) << 19; // Alternate Function UART-TX

sowas wie

GPIOA->MODER |= (GPIO_MODE_AF << (GPIO_PinSource9 * 2); // Alternate Function UART-TX

Ist zwar immer noch nicht schön, aber wenigstens ein bisschen lesbar.
Die Initialisierung der UARTs mit CMSIS ist jedenfalls ein Spaziergang:

void USARTInit(uint32_t baudrate) {
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
// Clock Enable of usart pins
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE);
GPIO_PinAFConfig(USART_PORT, USART_RX_SOURCE, GPIO_AF_USART2);
GPIO_PinAFConfig(USART_PORT, USART_TX_SOURCE, GPIO_AF_USART2);
// the USART Pin config
GPIO_InitStructure.GPIO_Pin = USART_TX_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin =  USART_RX_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure USART
 *
 */
USART_DeInit(USART);
USART_StructInit(&USART_InitStructure);
USART_InitStructure.USART_BaudRate = baudrate;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_Init(USART,&USART_InitStructure);
/* Enable USART */
USART_Cmd(USART, ENABLE);
}