STM32F030F4P6 und USART1

[Ralph S. (jjflash)]

Ich bin glaub ich zu doof oder schlicht betriebsblind.

Ich bekomme USART1 auf dem STM32F030F4P6 einfach nicht hin ... und ich 
weiß nicht warum.

Gefühlt hab ich die entsprechenden Abschnitte im Datenblatt bereits 20 
mal gelesen ...

Als serielle Schnittstellenpins sollen PA9 und PA10 verwendet werden. 
Auch die Überlegung, dass die Portpins des Chips hinüber sind (immerhin 
hab den 20 pol. SMD Chip auf Adapter gelötet und kann immer was 
passieren) glaub ich nicht, weil ich auf den Pins eine LED blinken 
lassen kann.

Ich finde hier den Fehler einfach nicht:

#include "stm32f0xx.h"
#include "stm32f0xx_rcc.h"
#include "stm32f0xx_gpio.h"
#include "stm32f0xx_usart.h"

inline void delay_ms(uint32_t dtime)
{
  volatile uint32_t n = (dtime * 3750);
  while(n > 0) n--;
}
    
void serial_init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    USART_InitStructure.USART_BaudRate = 19200;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

    // Enable GPIO clock
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);

    // Enable USART clock
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

    // PA9 fuer USART1_Tx
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_1);

    // PA10 fuer USART1 Rx
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_1);

    // USART Tx und Rx als alternate function push-pull
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
    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_UP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // USART1 Register konfigurieren
    USART_Init(USART1, &USART_InitStructure);

    // USART1 starten
    USART_Cmd(USART1, ENABLE);
}

void serial_putchar(uint8_t ch)
{
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    USART_SendData(USART1, ch);
}

int main(void)
{

  serial_init();
        
  while(1)
  {
    serial_putchar('x');    
  }
}

Außer dass die Pins PA9 und PA10 permanente High-Pegel (mit Scope 
kontrolliert) haben, geschieht nix.

Hardware:

BOOT0 ==> GND
OSC_IN und OSC_OUT ==> offen (kein Quarz)
NRST ==> +3,3V
VDDA ==> +3,3V (mit 47 uF gegen GND)
VDD ==> +3,3V (mit 10 uF gegen GND)

Upload-Tool: Chinaclone ST-Link-V2 oder ST-Link eines Nucleo-Boards

Wäre nett wenn mir auf die Sprünge geholfen werden könnte, im Anhang 
alle in der Toolchain verwendeten Dateien.

[Uwe Bonnes (Gast)]

Wer schaltet die GPIO Clock ein? Vermutlich GPIO_Init(). Dann geht 
GPIO_PinAFConfig() zuvor ins Leere...

[Ralph S. (jjflash)]

... ich dachte ich schalte den Clock hiermit ein:

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);

Bin ich jetzt vollkommen daneben? (Ich werde mir das Startupfile noch 
mal ansehen)

[Jim M. (turboj)]

Äh, den USART RX möchte man als Input haben. Da ist Push-Pull Output 
IMHO falsch.

Der Stack wird im Linker Skript auf 0x20000FFF gesetzt, laut ARM ABI 
muss der aber durch 8 teilbar sein, 0x20001000 wäre besser. Das könnte 
Dir mit (Hard) Fault aussteigen, lass mal eine LED blinken.

Ich habe im Hard Fault Handler immer eine spezielle LED Blink Sequenz 
drin, damit ich Programmierfehler gleich mitbekomme.

[Ralph S. (jjflash)]

... im Hardfault-Handler LED blinken lassen ist gute Idee, das werde ich 
machen.

Den Stack im Linker hatte ich absichtlich auf 0x20000fff weil das die 
höchste Adresse des Ram's ist... werde ich wieder auf 0x20001000 ändern.

Hmmm, den RX hatte ich ursprünglich auf Input gehabt (und wieder 
geändert) weil ich grundsätzlich erst einmal "etwas sehen" wollte, also 
erst einmal nur schicken (also Ausgang).

Irgendwie ist der Wurm drin und ich bin knapp dran, mir ein Discovery 
oder ein Nucleo-Board mit STM32F0xx zu kaufen um dann mal mit 
"offiziellen" Beispielen zu spielen und zu vergleichen.

Grundsätzlich versteh ich aber nicht wo der Hund begraben liegt.

Dennoch vielen Dank, die Idee im Hardfault es blinken zu lassen als 
Anzeige dass was falsch läuft ist gut !

[Termi (Gast)]

Fehlt wohl noch die SystemInit();

zumindest im geposteten Code.

G Termi

[Termi (Gast)]

ach und eine kleine Pause nach dem senden von 'x' würde ich auch 
einbauen.

[chris (Gast)]

Hi,

ich hab leider grade keine Zeit, deinen Code genauer zu studieren, aber 
im Anhang findest du mal eine funktionierende UART-Init etc.
Das ganze basiert auf der UART-Lib von hier:
http://mikrocontroller.bplaced.net/wordpress/

Ich hab das notwendige einigermaßen angepasst auf den STM32F0


Inhalt der main():

UB_Uart_Init();
uart_puts(COM1, "Hallo UART!", CRLF);

lg
Chris

[Little B. (lil-b)]

Uwe Bonnes schrieb:
> Wer schaltet die GPIO Clock ein? Vermutlich GPIO_Init(). Dann geht
> GPIO_PinAFConfig() zuvor ins Leere...

Falsch

Ralph S. schrieb:
> ... ich dachte ich schalte den Clock hiermit ein:
>
>     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);

Richtig

Jim M. schrieb:
> Äh, den USART RX möchte man als Input haben. Da ist Push-Pull Output
> IMHO falsch.

Irrelevant, da die Ports als Alternate Function konfiguriert werden.

Termi schrieb:
> Fehlt wohl noch die SystemInit();

Wird in der Startup.s aufgerufen

Termi schrieb:
> ach und eine kleine Pause nach dem senden von 'x' würde ich auch
> einbauen.

Braucht es nicht, da auf freien Buffer gewartet wird:

Ralph S. schrieb:
> while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);

Ich habe mir dein Programm nun eine weile angeschaut, die 
Initialisierung passt und es scheint nichts zu fehlen.
Du hast doch einen Debugger. Sag doch mal, was in den USART1-Registern 
steht (Adresse 0x40013800 bis 0x4001382B) und in den GPIOA-Registern 
(Adresse 0x48000000 bis 0x4800002B). Dann sieht man evtl eine falsche 
konfiguration.

[W.S. (Gast)]

Ralph S. schrieb:
> Irgendwie ist der Wurm drin und ich bin knapp dran, mir ein Discovery
> oder ein Nucleo-Board mit STM32F0xx

Ja, da ist tatsächlich der Wurm drin. Aber nicht im Prozessor, sondern 
in deinem Programm.

Ich hab schon so unsäglich oft den Leuten gepredigt, daß sie ihre 
verdammten Konfigurationen selber machen sollen und zu diesem Zwecke 
die im RefMan genannten Register in gehöriger Weise SELBST setzen 
mögen. Aber dann lese ich als Allererstes bei dir

USART_InitStructure.USART_BaudRate = ...

und bin wieder mal ... grmpff. Kannst du das nicht komplett bleiben 
lassen??

Hier mal ein Auszug au einem anderen Programm:

  // erstmal die benötigten Takte einschalten
  RCC_AHBENR  = (1<<17) |   // Port A enable
                (1<<18) |   // Port B enable
                (1<<19) |   // Port C enable
          (1<<20) |   // Port D enable
          (1<<22);    // Port F enable

  RCC_APB2ENR = (1<<16) |   // TIM15 enable
                (1<<14) |   // USART1 enable
     1;         // Sys Cfgen

  RCC_APB1ENR = (1<<23) |   // USB
                (1<<21) |   // I2C1
                (1<<17) |   // USART2 enable
                (1<<2)  |   // TIM4 enable
                (1<<1)  |   // TIM3 enable
                 1;         // TIM2 enable

Jetzt noch ein Auszug, wegen des Takt-Aufsetzens:

  // USB erstmal passiv schalten
  GPIOA_BSRR = (1<<15);     /* PA15 von Hand auf High setzen wg. Transistor + 1k5 an D+ */

  monitor(1);

  // Takt aufsetzen: System = 72 MHz
  RCC_CIR = 0;                  // keine Interrupts für PLL usw.
  RCC_CR = 0x83 | (1<<16);      // Resetwerte, interner 8 MHz RC-Oszi ein und Quarzoszi ein

  while ((RCC_CR & 2)==0)       // warten auf ready vom RC-Oszi
  { monitor(2); }

  // RCC_CFGR vorläufig setzen
  RCC_CFGR = (7<<24)   |        // 7 = PLL:2 an MCO = PA.8 zur Beobachtung per Oszillograf
             (1<<22);           // USBPRES, vermutlich 72MHz/1.5-->48MHz

  // so, eigentlich sollte jetzt der interne 8 MHz RC-Oszi den Takt angeben
  RCC_CR   &= ~(1<<24);         // PLL aus, um sie einstellen zu können
  RCC_CFGR2 = 0;                // Clock für ADC aus, Vorteiler für PLL auf 1:1
  RCC_CFGR3 =  (1<<22) |        // Clock für Timer + UART's auf SysClk Takt
               (1<<20) |
         (1<<18) |
         (1<<16) |
          1;

  // RCC_CFGR fertig setzen bis auf PLL-Auswahl
  RCC_CFGR  =  (1<<16) |        // Quarz-Oszi als Input für PLL
               (4<<11) |        // APB2 Vorteiler auf :2 (72-->36 MHz)
               (4<<8)  |        // APB1 Vorteiler auf :2 (72-->36 MHz)
               (0<<17) |        // Quarz nicht :2 teilen vor der PLL
         (4<<18) |        // PLL Teiler: 4--> x6, also 12MHz*6-->72MHz
               (7<<24) |        // 7 = PLL:2 an MCO = PA.8 zur Beobachtung
               (1<<22) |        // USBPRES, vermutlich 72MHz/1.5-->48MHz
          0;

  // warten auf Quarz-Oszillator
  while (!(RCC_CR & (1<<17)))   // warten auf ready vom ext. Quarz-Oszi
  { monitor(3); }

  // PLL einschalten und warten auf Einschwingen
  RCC_CR |= (1<<24);            // PLL einschalten
  while (!(RCC_CR & (1<<25)))   // warten auf ready von PLL
  { monitor(4); --i; }

  // wichtig: die nötigen Waitstates einschalten
  FLASH_ACR = 0x32;             // 2 Waitstates ab 48 MHz

  // Finale
  RCC_CFGR = (RCC_CFGR & 0xFFFFFF00) | 2;   // mutig die PLL als Systemtakt einschalten

  monitor(5);

  // Restbedenken: an MCO = PA.8 liegen jetzt 36 MHz an.
  // Man kann dies jetzt oszillografieren, sollte es aber dann abschalten,
  // falle es nicht wirklich gebraucht wird
  // Alternative: MCO erst garnicht einschalten

}

 /* ende */

Und noch ein Auszug, diesmal vom UART-setup

dword InitSerial1 (long baudrate)    /* liefert tatsächliche Baudrate zurück */
{ long Baudteiler;

  Baudteiler = F_Platform / baudrate; /* SysClk Frequenz */
  U1Buf.InWP =                      /* alle Puffer rücksetzen */
  U1Buf.InRP =
  U1Buf.OutWP =
  U1Buf.OutRP = 0;
  /* Int 37 */
  NVIC_ICPR1 = (1<<(U1Int-32));     /* pending löschen */
  NVIC_ISER1 = (1<<(U1Int-32));     /* Int erlauben */
  USART1_CR1 = 0;                   /* erstmal aus */
  USART1_CR2 = (3<<12);             /* 1.5 Stopbits */
  USART1_CR3 = 0;
  USART1_GTPR = 0;
  USART1_BRR = Baudteiler & 0xFFFF; /* Baudratenteiler */
  USART1_CR1 = (1<<7)  |            /* TX Int enable */
               (1<<5)  |            /* RX Int enable */
         (1<<3)  |            /* TX enable     */
               (1<<2)  |            /* RX enable     */
               (1<<0);              /* UART enable   */
  return F_Platform / Baudteiler;
}

So. den Interrupthandler wirst du ja hoffentlich zuwege bringen, ebenso 
die Basis-Funktionalität, z der ich hier nur den Header poste - sonst 
wird's für den Rest der Welt zu langweilig:

extern dword InitSerial1 (long baudrate);    /* liefert tatsächliche Baudrate zurück */
extern char  V24Char_Out1  (char c);         /* Zeichen senden */
extern int   V24numTxFree1 (void);           /* Anzahl freier Plätze im Sendepuffer */
extern bool  V24RxAvail1   (void);           /* ob Zeichen empfangen wurden */
extern char  V24GetChar1   (void);           /* empfangene Zeichen abholen */
extern void  V24TxDone1    (void);           /* warten bis Sendepuffer geleert ist */

So. Jetzt fang an, es richtig zu machen - und zwar so, daß du weißt, was 
tatsächlich abgeht - bei dieser elenden ST-Lib weißt du es nämlich 
nicht, was du ganz weit oben bereits deutlich gezeigt hast.

W.S.

[Ralph S. (jjflash)]

W.S. schrieb:
> So. Jetzt fang an, es richtig zu machen - und zwar so, daß du weißt, was
> tatsächlich abgeht - bei dieser elenden ST-Lib weißt du es nämlich
> nicht, was du ganz weit oben bereits deutlich gezeigt hast.

... dann setz ich mich mal hin und wühl mich durch die Register... was 
ich eigentlich vermeiden wollte. Hrmpf... (aber letztlich hat der W.S. 
Gast wohl recht... und wenn ich überleg wieviel Zeit draufgegangen ist, 
hätte ich wohl gleich die Register nehmen sollen)...

Wird aber wohl auch n bissi dauern ...