UART konfiguration STM32F030XC

[flo (Gast)]

Hallo zusammen,
ich versuche gerade die UART3 des STM32F32030XC ans laufen zu kriegen 
aber es tut sich gar nichts.
Meine Vermutung ist, dass ich irgendwo in dem Code unten was vergessen 
habe und hoffe dass einer von euch mir einen Hinweis geben kann.

Vielen Dank dafür.

void UART3_Config(void)
{

    RCC->AHBENR |= RCC_AHBENR_GPIOCEN;    // Enable GPIO clock Port C

    /* Configure UART */
     GPIOC->MODER |= (GPIO_MODER_MODER10_1 | GPIO_MODER_MODER11_1);  // Switch to alternate function mode
     GPIOC->AFR[1] |= (GPIO_AFRH_AFSEL10 | GPIO_AFRH_AFSEL11);    // Select UART3 RX and TX

     RCC->APB1ENR |= RCC_APB1ENR_USART3EN;    // Enable clock UART3

     /* Clear UART Configuration */
     USART3->CR1 = 0x00000000;
     USART3->CR2 = 0x00000000;
     USART3->CR3 = 0x00000000;

     USART3->BRR = 2500;  // Set Baudrate to 19200

     USART3->CR1 |= (USART_CR1_TE | USART_CR1_RE);  // Enable TX and RX
     USART3->CR1 |= (USART_CR1_RXNEIE);    // Enable RX interrupt

     USART3->CR1 |= USART_CR1_UE;    // Enable UART

     NVIC_SetPriority(USART3_6_IRQn, 1);
     // Enable USART3 interrupts
     NVIC_EnableIRQ(USART3_6_IRQn);
}

[Pieter (Gast)]

UART3_Config..und wo ist der Rest?

[flo (Gast)]

Hier nochmal der IRQ Handler, main und die Clock config.

void USART3_6_IRQHandler(void)
{
  unsigned int test;
  // Test for RXNE pending interrupt
  if ((USART3->ISR & USART_ISR_RXNE) == USART_ISR_RXNE)
    {
      test = USART3->RDR;
      // RXNE flags automatically clears when reading RDR.
    }
}


void SystemClock_Config(void)
{
  RCC->CR |= RCC_CR_HSION;

  RCC->CFGR &= ~(RCC_CFGR_SW);

  while(!(RCC->CR & RCC_CR_HSIRDY));

  RCC->CR &= ~(RCC_CR_PLLON);

  FLASH->ACR |= FLASH_ACR_LATENCY;

  RCC->CFGR |= RCC_CFGR_PLLSRC_HSI_PREDIV;

  RCC->CFGR = (RCC_CFGR_PLLMUL12 | RCC_CFGR_PPRE_DIV1);

  RCC->CR |= RCC_CR_PLLON;

  while(!(RCC->CR & RCC_CR_PLLRDY));

  RCC->CFGR &= ~(RCC_CFGR_SW);
  RCC->CFGR |= RCC_CFGR_SW_PLL;
}


int main(void)
{
  SystemClock_Config();
  UART3_Config();
  Timer6_Config();

  while(1)
  {
      Delay_ms(1000);
      USART3->TDR = '#';
  }
}

[A. B. (Gast)]

flo schrieb:
>      GPIOC->MODER |= (GPIO_MODER_MODER10_1 | GPIO_MODER_MODER11_1);  //
>      GPIOC->AFR[1] |= (GPIO_AFRH_AFSEL10 | GPIO_AFRH_AFSEL11);    //

Was sollen diese beiden Zeilen bewirken? Die machen nun nicht gerade 
das, was
in den Kommentaren steht. Ich würde mal gründlich lesen, was im RM zu 
den GPIO-Registern und im Datenblatt zu den AF steht. Und es schader 
auch nicht, in den
CMSIS Headern nachzusehen, was diese Makros eigentlich bedeuten.

UART3 liegt bei Port C auf AF01.

Das '|=' macht hier wenig Sinn, da damit ja höchstens Bits gesetzt 
werden können.
Zwar werden nach einem Reset die meisten (aber nicht alle!) Bits auf 0 
gesetzt,
aber spätestens, wenn man Pins *um*konfiguriert, fällt einem das auf die 
Füße.
Besser wäre es, mit GPIO_AFRH_AFSEL10_Msk erst alle Bits auszumaskieren 
(daher der Name _Msk) und dann die benötigten zu setzen.

Außerdem wäre es sinnvoll, erst AFR zu setzen, und erst danach den Port 
auf AF umzuschalten (sonst ist der --- wenn auch nur kurz --- eventuell 
auf eine andere AF eingestellt).

[Sergey (Gast)]

Isn't it easier to use STM32CubeMX?

[Ben S. (bensch123)]

Sergey schrieb:
> Isn't it easier to use STM32CubeMX?

Einfacher, aber das ist eher was für die Klicki-Bunti Fraktion.

[flo (Gast)]

Danke für die Antworten, ich lese mich gerade ein und schaue was die 
Makros so bedeuten.

>Isn't it easier to use STM32CubeMX?
Es ist zwar einfacher aber die Hintergründe hat man dann noch nicht 
verstanden.

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

Zum Pinstatus setzen empfehle ich eine Funktion zu bauen um das nicht 
immer neu zu machen.
Das ist fehlerträchtig und nervt irgendwann ;)
Die Funktion bekommt:
- Port -> GPIOA/B/C usw, also direkt dieses Makro welches vom Typ 
"GPIO_TypeDef*" ist.
- Pinnummer
- modus (output, input, pulldown/up, alternate, etc)
- geschwindigkeit (davon gibts 4)
- alternate function als nummer (bei manchen L0 kommt ein UARt auch mal 
als verschiednene AF numemrnr aus, wodurch ein enum leider nicht geht)
Kann man auch in ein struct packen wen man will ud dann kan man den pin 
"uart3_rx" durch die Gegend schubsen im Programm.

Anstatt ein UART3_config zu schreiben wäre doch eine allgemeinere 
Funktion besser.
UART_config und es wird übergeben welcher uart da konfiguiert werden 
soll.
Beispiel:

void uart_init(USART_TypeDef* uart) {
  
  uart->CR1  = USART_CR1_FIFOEN | USART_CR1_TE | USART_CR1_RE;
  uart->CR1 |= USART_CR1_UE;
}

[Stefan F. (Gast)]

Die CMSIS, auf welcher auch die HAL aufbaut, enthält hilfreiche Makros 
zum Ändern einzelner Bits. Beispiel für USART1 auf dem STM32L073:

#include <stdio.h>
#include "stm32l0xx.h"

uint32_t SystemCoreClock=2097000;

// delay loop for the default 2.1 MHz CPU clock with optimizer enabled
void delay(uint32_t msec)
{
    for (uint32_t j=0; j < 419UL * msec; j++)
    {
        __NOP();
    }
}

// Redirect standard output to the serial port
int _write(int file, char *ptr, int len)
{
    for (int i=0; i<len; i++)
    {
        while(!(USART1->ISR & USART_ISR_TXE));
        USART1->TDR = *ptr++;
    }
    return len;
}

// Called after each received character
void USART1_IRQHandler(void)
{
    // read the received character
    char received=USART1->RDR;

    // send echo back
    while(!(USART1->ISR & USART_ISR_TXE));
    USART1->TDR = received;
}

int main(void)
{
    // Enable clock for Port A
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);

    // PA5 = Output for the LED
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5, GPIO_MODER_MODE5_0);

    // Use system clock for USART1
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_USART1EN);
    MODIFY_REG(RCC->CCIPR, RCC_CCIPR_USART1SEL, RCC_CCIPR_USART1SEL_0);

    // PA9 (TxD) shall use the alternate function 4 (see data sheet)
    MODIFY_REG(GPIOA->AFR[1], GPIO_AFRH_AFSEL9, 4UL<<GPIO_AFRH_AFSEL9_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE9, GPIO_MODER_MODE9_1);

    // PA10 (RxD) shall use the alternate function 4 (see data sheet)
    MODIFY_REG(GPIOA->AFR[1], GPIO_AFRH_AFSEL10, 4UL<<GPIO_AFRH_AFSEL10_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE10, GPIO_MODER_MODE10_1);

    // Set baudrate
    USART1->BRR = (SystemCoreClock / 2400);

    // Enable transmitter, receiver and receive-interrupt of USART1
    USART1->CR1 = USART_CR1_UE + USART_CR1_TE + USART_CR1_RE + USART_CR1_RXNEIE;

    // Enable interrupt in NVIC
    NVIC_EnableIRQ(USART1_IRQn);

    while (1)
    {
        // LED on
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BS_5);
        delay(500);

        puts("Hello");

        // LED off
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR_5);
        delay(500);
    }
}