STM32 F0 über UART senden zum PC

[Peter G. (trafel30)]

Hallo zusammen,

ich bin relativ neu in der STM32 Umgebung und bin schon teilweise 
wirklich an meine Verständnis Grenzen gestoßen. ^^ Ich wollte zum 
Debuggen über GPIOA PA2 und PA3 Nachrichten zu meinen PC auf Putty 
senden. Der Code gibt keine Compilefehler aber ebenso kommt auch nichts 
auf meinem PC an.

Der Code sieht wie folgt aus:

#include "CMSIS\stm32f0xx.h"
#include "STM32F0xx\stm32f0xx_hal_conf.h"
#include "STM32F0xx\stm32f0xx_hal.h"
#include "STM32F0xx\stm32f0xx_hal_tim.h"


GPIO_InitTypeDef GPIO_struct;
UART_HandleTypeDef UART_Struct;

uint8_t Transmitbuffer[8] = {1,2,3,4,5,7,8};

void GPIO_Initialise_USART()
{
  // Aktivieren der Peripherien
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_USART2_CLK_ENABLE();


        //PA3 als receive
  GPIO_struct.Pin = GPIO_PIN_3; // RX -> PA3 input
  GPIO_struct.Mode = GPIO_MODE_INPUT;
  GPIO_struct.Alternate = GPIO_AF1_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_struct);


        //PA2 als transmit
  GPIO_struct.Pin = GPIO_PIN_2; // TX -> output
  GPIO_struct.Mode = GPIO_MODE_AF_PP;
  GPIO_struct.Pull = GPIO_NOPULL;
  GPIO_struct.Speed = GPIO_SPEED_HIGH;
  GPIO_struct.Alternate = GPIO_AF1_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_struct);

  UART_Struct.Instance = USART2; // USART2 aktivieren

  UART_Struct.Init.BaudRate = 38400; // Baudrate auf 38400 BPS
  UART_Struct.Init.Mode = UART_MODE_TX_RX; //Empfangen/Senden
  UART_Struct.Init.Parity = UART_PARITY_NONE; 
  UART_Struct.Init.WordLength = UART_WORDLENGTH_8B; // 8Bit Wortlänge
  UART_Struct.Init.StopBits = UART_STOPBITS_1;
  UART_Struct.Init.HwFlowCtl = UART_HWCONTROL_NONE; // Kein HW

  UART_Struct.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; 
        // keine erweiterte Initialisierung

  
        //UART initialisieren
  HAL_UART_Init(&UART_Struct);

  //UART aktivieren
  __HAL_UART_ENABLE(&UART_Struct);

}





int main(void)
{
  GPIO_Initialise_USART();

  while(1)
        {

        // Datenübertragung über USART2
        HAL_UART_Transmit(&UART_Struct, Transmitbuffer, transmitBufferSize, 0xFFF);
        }
}

Wie gesagt, kein Compiler-Fehler. Bei Putty kommt gar nichts an, welches 
aber auch richtig konfiguriert ist - COM4 wie es im Geräte Manager unter 
STLink virtuell steht, ebenso gleiche Baudrate eingestellt. Weiß jemand 
woran es evtl harpern könnte? Ich bin für jede Hilfe dankbar.

[Markus (Gast)]

Nimm doch einfach STM32Duino:
http://grauonline.de/wordpress/?page_id=1004

[Daniel V. (voda)]

Markus schrieb:
> Nimm doch einfach STM32Duino:
> http://grauonline.de/wordpress/?page_id=1004

Eine Antwort die auch rein gar nichts mit der Fragestellung zu tun hat.

Prüfe ob der Takt für die Peripherie aktiviert ist.
Prüfe ob Du im CubeMX eine falsche Einstellung gemacht hast.
Gucke Dir die Flags im debugmode an.
Schaue mal alternativ mit HTerm dir die Schnittstelle an
Lese das Datenblatt.

Gruß
Daniel

[Patrick S. (pad)]

Moin,

PA2 und PA3 sind auch die UART-Pins die auf dem Nucleo an dem ST-Link 
dran sind?

[pegel (Gast)]

Ist das die komplette main Funktion?

Wo wird der Takt eingestellt? HAL Init?

Sieh dir ein Beispiel an.

[Peter G. (trafel30)]

@Daniel

Ich benutze kein CubeMX, initialisiere selber.

  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_USART2_CLK_ENABLE();

Sollte doch über RCC alle Peripherien aktivieren die ich benötige. Ich 
benutz Eclipse zum Programmieren, wo kann man dort denn die Flags 
betrachten?


@Patrick

Im Datenblatt unter USART Communication steht folgendes:

"The USART2 interface available on PA2 and PA3 of the STM32 
microcontroller can be connected to ST-LINK MCU, ST morpho connector or 
to Arduino connector. The choice can be changed by setting the related 
solder bridges. By default the USART2 communication
between the target STM32 and ST-LINK MCU is enabled, in order to support 
virtual COM port for mbed (SB13 and SB14 ON, SB62 and SB63 OFF)."

das hab ich daraus abgeleitet. ^^,

[Peter G. (trafel30)]

@Pegel,

das hab ich schon. In den meisten wird auch kein Takt eingestellt und es 
funktioniert trotzdem. :/

[pegel (Gast)]

Peter G. schrieb:
> In den meisten wird auch kein Takt eingestellt

Wo gibt es solche Beispiele? Nie gesehen.

Ich weiß nicht welchen F0 du hast, aber die mir bekannten Beispiele 
ähneln alle der main.c in der HAL Lib:

STM32Cube_FW_F0_V1.7.0/Projects/STM32F030R8-Nucleo/Examples/UART/UART_Tw 
oBoards_ComPolling/Src

[Peter G. (trafel30)]

Mit Takt meinst du die SystemClockConfig?

Bsp:
https://www.youtube.com/watch?v=-ZHJ31Q_5i8

Er programmiert zwar einen F103 und das mit der Standart Periphal 
Libary. Hab das nur nicht als all zu schlimm gesehen, bin nur mit der 
HAL Libary eine Schicht näher an der Hardware oder seh ich das falsch? 
Hab nur versucht über HAL Funktionen dasselbe zu deklarieren und 
initialisieren wie er auch.

[pegel (Gast)]

Mit einer Mischung aus Std und HAL habe ich mich nie beschäftigt.
Bei Nutzung der HAL Funktionen sollte aber mindestens ein HAL_Init() 
aufgerufen werden.

Mit der HAL bist du eine Schicht weiter weg von der Hardware, was die 
Sache einfacher macht - bei richtiger Anwendung.

CubeMX kennst du?

[Ingo L. (corrtexx)]

Peter G. schrieb:
> // Datenübertragung über USART2
>         HAL_UART_Transmit(&UART_Struct, Transmitbuffer,
> transmitBufferSize, 0xFFF);
>         }
Damit dürftest du deinen PC sowas von überlaufen... Überleg mal was dort 
an Daten rein kommt. Pack wenigstens irgendwie ein Delay von 200ms 
zwischen zwei Transaktionen.

Alternativ mal mitm Oszi gucken was ausm TXD rauskommt.

[Peter G. (trafel30)]

@Ingo

Danke, das ergibt ziemlichen Sinn. x_x Werde einen Timer dafür verwenden 
um ein Delay zu erzeugen.

@pegel

Das HAL_INIT(); hatte ich vergessen aber dies resettet doch eh nur die 
Peripherien, oder?


* @brief  This function configures the Flash prefetch,
  *       Configures time base source, NVIC and Low level hardware
  * @note This function is called at the beginning of program after 
reset and before
  *       the clock configuration
  * @note The time base configuration is based on HSI clock when exiting 
from Reset.
  *       Once done, time base tick start incrementing.
  *       In the default implementation,Systick is used as source of 
time base.
  *       The tick variable is incremented each 1ms in its ISR.

[Peter G. (trafel30)]

Das mit dem überlaufen hab ich provisorisch erst einmal so gelöst:

if (count == 300000)
    {
    HAL_UART_Transmit(&UART_Struct, Transmitbuffer, transmitBufferSize, 0xFFF);
    count = 0;
    }
    ++count;

daran lag es zumindestens nicht. :/

[pegel (Gast)]

Peter G. schrieb:
> Werde einen Timer dafür verwenden
> um ein Delay zu erzeugen.

Peter G. schrieb:
> * @brief  This function configures the Flash prefetch,
>   *       Configures time base source, NVIC and Low level hardware

Warum willst du dir das so schwer machen?
Zum ausprobieren ist das ja schön, aber wenn es einfach funktionieren 
soll würde ich doch den kürzesten Weg gehen.

[Daniel V. (voda)]

Peter G. schrieb:
> Ich benutze kein CubeMX, initialisiere selber.

Ach so, warum benutzt Du dann die HAL? Installiere testhalber den CubeMX 
und konfiguiere deinen Controller. Im Video hat der Videoersteller die 
SPL genommen. Macht auch mehr Sinn wenn Du CubeMX nicht nimmst.

Sonst im Reference Manual den Clock-Tree anschauen und, wie ein 
Vorredner schon gesagt hat, mit einem Oszi mal messen ob überhaupt ein 
Signal da ist. Kommen denn mit HTerm die Signale an?

Gruß
Daniel

PS: Ich sehe gerade:

#include "CMSIS\stm32f0xx.h"
#include "STM32F0xx\stm32f0xx_hal_conf.h"
#include "STM32F0xx\stm32f0xx_hal.h"
#include "STM32F0xx\stm32f0xx_hal_tim.h"

Es müsste doch auch eine

#include "STM32F0xx\stm32f0xx_hal_usart.h"

geben, oder?

PPS:
Bustakt für APB/AHB fehlt auch. Bitte im Datenblatt nachlesen!!!

[Peter G. (trafel30)]

@Daniel

Danke für die Antwort, den Header von der usart hatte ich vergessen mit 
herauszuschreiben. Mein Code hat noch ein paar andere Funktionen. ^^,

Ich hab CubeMX, der generiert mir auch den Code,

Was meinst du mit Bustakt, ich weiß das man den RCC Takt konfigurieren 
kann... aber der hat doch auch eine Default Einstellung, oder?

Die Register werden doch durch die Funktionen aktiviert durch das RCC:

__HAL_RCC_GPIOA_CLK_ENABLE() sowie #define __HAL_RCC_USART2_CLK_ENABLE()

#define __HAL_RCC_GPIOA_CLK_ENABLE()   do { \
                                        __IO uint32_t tmpreg; \
                                        SET_BIT(RCC->AHBENR, RCC_AHBENR_GPIOAEN);\
                                        /* Delay after an RCC peripheral clock enabling */ \
                                        tmpreg = READ_BIT(RCC->AHBENR, RCC_AHBENR_GPIOAEN);\
                                        UNUSED(tmpreg); \
                                      } while(0)




#define __HAL_RCC_USART2_CLK_ENABLE()   do { \
                                        __IO uint32_t tmpreg; \
                                        SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USART2EN);\
                                        /* Delay after an RCC peripheral clock enabling */ \
                                        tmpreg = READ_BIT(RCC->APB1ENR, RCC_APB1ENR_USART2EN);\
                                        UNUSED(tmpreg); \
                                      } while(0)

@pegel, weil ich den Code verstehen wollte und selbst anwenden möchte 
bevor ich Hilfswerkzeug dazu verwende, aus Fehlern lernt man ja am 
besten, nur ist dieser echt komisch. Ich hab eben einen Kollegen darüber 
schauen lassen, der konnte kein Fehler entdecken, es sollte eigentlich 
funktionieren und dieser hat ein paar Jahre Berufserfahrung mit STM32. 
^^, Evtl... liegt der Fehler ganz woanders. x_x