STM32F103C8T6 mit Arduino Serial funktioniert nicht

[L. Beier (Gast)]

Ich habe alles für den MCU eingerichtet bei Arduino und SPI und I2C 
funktionierten. Als ich jetzt aber dieses Programm getestet habe:

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.write("Test");
  delay(10);       
}

konnte ich im Gegensatz zu meinem Arduino Nano nichts mit dem Logic 
Analyzer an PA9 messen.

Muss man bei dem Modul eine andere Library benutzen oder warum 
funktioniert das nicht?

[Joachim B. (jar)]

versuche mal
Serial.print("Test");
(besser Serial.print(F("Test"));)

oder Serial.print("Test\n");
oder Serial.print("Test\r\n");

ggffs nicht richtig eingestellt? flush()?

[L. Beier (Gast)]

Genervt schrieb im Beitrag #5114900:
> Schmeiß aurduino weg

Danke das hat geholfen

[yesitsme (Gast)]

Versuch mal Serial1, Serial2 oder so

Ich denke das Serial über USB geht.

[bianchifan (Gast)]

L. Beier schrieb:
> Ich habe alles für den MCU eingerichtet bei Arduino und SPI und I2C
> funktionierten.
Was heißt alles?
Ich habe keine Glaskugel..

ICH benutze Roger Clark's STM32DUINO als Arduino Aufsatz, DORT wird mit

> setup() {
>   Serial.begin(9600);
> }

der serielle USB-Transfer gestartet(PA12).
Zur Ausgabe finden die "print"-Methoden Anwendung.

Standard-Beispiel:

void setup() {
 Serial.begin(115200); // init Serial USB
 while(!Serial.isConnected()){};  // wait on USB is up and running
 Serial.println("Hello from USB Serial !!");
 }

IIRC muss zur Ausgabe auf PA9 Serial1 gestartet werden, meine Hand lege 
ich dafür aber nicht ins Feuer.
Doku lesen bzw. WIKI von STM32Duino

[L. Beier (Gast)]

Ne hat alles nicht geholfen. Ich glaube ehr, dass mein Board kaputt ist. 
Ich probiere jetzt aber USART nochmal mit CooCox.

[L. Beier (Gast)]

Komisch jetzt funktioniert es.

[L. Beier (Gast)]

USART2 funktioniert trotzdem noch nicht.

...

void RCC_Init(void)
{
    // Route and enable clocks for low and high speed bus
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
}

void InitUart1(void)
{
    // Create Structs
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    USART_ClockInitTypeDef USART_ClockInitStructure;

    // USART1 RX-Pin initialize
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // USART1 TX-Pin initialize
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // USART and clock initialize
    USART_ClockStructInit(&USART_ClockInitStructure);
    USART_ClockInit(USART1, &USART_ClockInitStructure);

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

    USART_Init(USART1, &USART_InitStructure);
    USART_Cmd(USART1, ENABLE);
}

void InitUart2(void)
{

    // Initialize Structs
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    USART_ClockInitTypeDef USART_ClockInitStructure;

    // USART1 RX-Pin initialize PA3
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // USART1 TX-Pin initialize PA2
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* Remap USART, as USART2 is used as alternate pins on PD5/6*/
    GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);

    // USART initialize
    USART_ClockStructInit(&USART_ClockInitStructure);
    USART_ClockInit(USART2, &USART_ClockInitStructure);

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

    USART_Init(USART2, &USART_InitStructure);
    USART_Cmd(USART2, ENABLE);
}


void USART1_SendString(char* data)
{
    while (*data)
    {
        USART_SendData(USART1, (uint16_t) *data);
        while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
        data++;
    }
}

void USART2_SendString(char* data)
{
    while (*data)
    {
        USART_SendData(USART2, (uint16_t) *data);
        while(USART_GetFlagStatus(USART2, USART_FLAG_TC)==RESET);
        data++;
    }
}

int main(void)
{
    SystemInit();
    RCC_Init();
    InitUart1();
    InitUart2();

    while(1)
    {
      delay_nus(100);

      USART2_SendString("Second String\n\r");
      while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);

        delay_nus(100);

        while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
        USART1_SendString("First String\n");
    }
}

Ich kann nur Daten bei USART1 empfangen

[L. Beier (Gast)]

Hab ich schon getestet und nur USART1 funktioniert wenn ich CooCox 
benutze.

[L. Beier (Gast)]

yesitsme schrieb:
> Versuch mal Serial1, Serial2 oder so
>
> Ich denke das Serial über USB geht.

Antwort hierfür

[Markus (Gast)]

>Komisch jetzt funktioniert es.

Diese Aussage kommt in Entwicklungsabteilungen häufig vor :-)

Du könntest noch das STM32GENERIC-Framework ausprobieren, vielleicht 
geht's ja damit.
Obwohl das Framework von Roger Clark eigentlich ziemlich ausgreift ist 
..

[Stefan F. (Gast)]

> Ich denke das Serial über USB geht.

So ist es.

[L. Beier (Gast)]

Markus schrieb:
>>Komisch jetzt funktioniert es.
>
> Diese Aussage kommt in Entwicklungsabteilungen häufig vor :-)
>
> Du könntest noch das STM32GENERIC-Framework ausprobieren, vielleicht
> geht's ja damit.
> Obwohl das Framework von Roger Clark eigentlich ziemlich ausgreift ist
> ..

Dieser Code funktioniert jetzt:

#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_usart.h"
#include "stm32f10x_tim.h"
#include "misc.h"

GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
USART_InitTypeDef USART_InitStructure;

#define READ_BUFFER_SIZE 20

volatile char read_buffer[READ_BUFFER_SIZE];
volatile char read_buffer_single = 0;
volatile char string_complete = 0;
volatile int uart_str_count = 0;

void nvic_initialisierung(uint16_t IRQ)
{
       NVIC_InitTypeDef NVIC_InitStructure; //create NVIC structure
         NVIC_InitStructure.NVIC_IRQChannel = IRQ;
         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
         NVIC_Init(&NVIC_InitStructure);
}

void UARTSend(const unsigned char *pucBuffer)
{

    while(*pucBuffer)
    {
        USART_SendData(USART2, (uint16_t) *pucBuffer++);
        while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET)
        {
        }
    }
}

void USART_Configuration(void)
{

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_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;

  USART_Init(USART2, &USART_InitStructure);

  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

  USART_Cmd(USART2, ENABLE);
}

int main(void)
{

    SystemInit();
    nvic_initialisierung(USART2_IRQn);
    USART_Configuration();

    while(1){
      UARTSend("test");
    }
}

[F. F. (foldi)]

Known Issues
On most clones, the chip's analog circuitry is supplied by the same 
power track as the digital circuitry, meaning that sampling the ADC in 
close succession with e.g. SPI communication is known to cause 
interference. This is not a problem for most use cases, and can usually 
be solved by careful timing in software. It is worth noting that most 
Arduino boards (e.g. Uno, Nano) have the same "problem".

Kenne das so nicht und habe aus Interesse einmal gegoogelt.
Kann ja unter Umständen auch da zu Störungen führen.

Nur mal so eine Idee.

[L. Beier (Gast)]

Fehlt nur noch der Code für I2C und SPI...

[Markus (Gast)]

Also ist das Problem jetzt gelöst oder nicht?

Seriel.begin geht auf die USB-Schnittstelle.

Dort gibt es zwei Dinge zu beachten, falls es sich um ein BluePill-Board 
handelt
1. Ist ein Widerstand für die USB-Schnittstelle meist falsch bestückt 
und muss gepached werden.
2. Der USB-Anschluss ist an dem Board mechanisch ziemlich labil. Es 
passiert schnell, dass der Stecker nicht mehr richtig kontaktiert und 
ein Wackelkontakt auftritt.

[L. Beier (Gast)]

Markus schrieb:
> Also ist das Problem jetzt gelöst oder nicht?
>
> Seriel.begin geht auf die USB-Schnittstelle.
>
> Dort gibt es zwei Dinge zu beachten, falls es sich um ein BluePill-Board
> handelt
> 1. Ist ein Widerstand für die USB-Schnittstelle meist falsch bestückt
> und muss gepached werden.
> 2. Der USB-Anschluss ist an dem Board mechanisch ziemlich labil. Es
> passiert schnell, dass der Stecker nicht mehr richtig kontaktiert und
> ein Wackelkontakt auftritt.

Mein Board hat keinen USB Anschluss und Serial1 funktioniert auch nicht 
mit Arduino.
Es wäre für mich sehr viel einfacher, wenn UART mit Arduino 
funktionieren würde, aber anscheinend geht das nicht. Jedenfalls habe 
ich alle Vorschläge ausprobiert.

[Markus (Gast)]

Die Schnittstelle funktioniert mit ziemlicher Sicherheit.
https://github.com/rogerclarkmelbourne/Arduino_STM32/blob/master/STM32F1/cores/maple/HardwareSerial.cpp
Die Frage ist nur, wie auswählen. Beim STM32GENERIC kann man im 
tools-Menue bestimmte Peripherie ein- bzw. ausschalten.
Am schnellsten wäre es, wenn Du diese Frage direkt im stm32duino-Forum 
stellst.

[bianchifan (Gast)]

L. Beier schrieb:
> Mein Board hat keinen USB Anschluss und Serial1 funktioniert auch nicht
> mit Arduino.

Dann hol Dir irgendein Entwicklungsboard, die haben alle USB.
Preislich am günstigsten sind die "BLUEPILL"s vom Ali, so ca. 1,80$.
Für USB muss da aber ein Bootloader drauf, entweder via Serial-USB 
Adapter oder STLINK.
Null Problemo sollte ein Maple Mini Klon bereiten, dort ist aber bereits 
ein CBT6 drauf ;).
Gibt's beim Ali für ca. 3$ plus Cents.

[bianchifan (Gast)]

BLUEPILL = Minimum System Development Board

[Markus (Gast)]

Also, ich habe es mal mit dem Arduino STM32GENERIC Framework 
ausprobiert, da ich das von Roger Clark momentan nicht installiert habe.

Es funktioniert mit einem USB-Serial Adapter an PA9/PA10 einwandfrei.

Einstellungen in "Tools" siehe Screenshot.

void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(115200);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input on analog pin 0:
  int sensorValue = analogRead(PA0);
  // print out the value you read:
  Serial.println(sensorValue);
  delay(100);        // delay in between reads for stability
}

[L. Beier (Gast)]

Markus schrieb:
> Also, ich habe es mal mit dem Arduino STM32GENERIC Framework
> ausprobiert, da ich das von Roger Clark momentan nicht installiert habe.
>

Dann liegt es wohl an dem Board. Ich habe ein BLUEPILL und benutze 
Serial1.

[DraconiX (Gast)]

L. Beier schrieb:
> Mein Board hat keinen USB Anschluss

L. Beier schrieb:
> Ich habe ein BLUEPILL

Höö?! Das Bluepill hat doch aber den USB rausgeführt?

Und dieser ist halt Serial.beginn....

Im Grunde wiedersprichst du dich in jedem zweiten Post... Einmal sagst 
du das serial1 nicht funktioniert, dann funktioniert es wieder. USB hast 
du keins, aber USB hat dein Board...

WIE ist der aktuelle Stand? WELCHE UART des F103 willst du nun 
eigentlich nutzen? WAS funktioniert und WAS funktioniert nicht?

[W.S. (Gast)]

L. Beier schrieb:
> Dann liegt es wohl an dem Board.

Wohl eher nicht.

Es gibt für dich nur genau 2 Wege:

a) du beginnst, dich mit der eigentlichen Materie zu befassen, bis du in 
der Lage bist, aus eigener Kraft und eigenem Verstehen die vorliegende 
Hardware sinnvoll zu benutzen.

b) du bleibst bei der Arduino-Denkweise und bist darauf angewiesen, 
genau das und nur das zu benutzen, was irgend jemand für eine bestimmte 
Hardware und eine bestimmte Software-Konfiguration zuvor gebrauchsfertig 
dir vorgegeben hat.

Die Entscheidung liegt bei dir - aber du solltest berücksichtigen, daß 
es im Falle von b) eine nicht mehr überbrückbare Lücke gibt zwischen dir 
und all denjenigen, die solche Chips wie die STM32Fxxx und Konsorten 
direkt und selbst und ohne Arduino benutzen. Und eine noch viel größere 
Lücke besteht zu Leuten wie mir, der ich (aus guten Gründen) nicht 
einmal die diversen Hersteller-Krücken wie Cube, Dave, Cmsis benutze, 
sondern mein Zeug mit eigenem Portfolio mache.

In beiden Fällen führt der Versuch, dir Ratschläge quasi vom anderen 
Ufer der Lücke zu geben, mit Regelmäßigkeit zu gegenseitigem Frust.

W.S.

[L. Beier (Gast)]

DraconiX schrieb:
> L. Beier schrieb:
> Mein Board hat keinen USB Anschluss
>
> L. Beier schrieb:
> Ich habe ein BLUEPILL
>
> Höö?! Das Bluepill hat doch aber den USB rausgeführt?
> Und dieser ist halt Serial.beginn....
>
> Im Grunde wiedersprichst du dich in jedem zweiten Post... Einmal sagst
> du das serial1 nicht funktioniert, dann funktioniert es wieder. USB hast
> du keins, aber USB hat dein Board...
> WIE ist der aktuelle Stand? WELCHE UART des F103 willst du nun
> eigentlich nutzen? WAS funktioniert und WAS funktioniert nicht?

Zusammengefasst: Ich möchte UART2 (Serial1) nutzen, kein UART Interface 
funktioniert mit Arduino und diversen Code Variationen, jedoch 
funktionieren alle UARTs wenn ich statt Arduino CooCox benutze. Daher 
bin ich gerade dabei den Code, den ich für Arduino geschrieben habe in C 
mit CooCox neu zu schreiben

[L. Beier (Gast)]

Mit USB habe mich mich falsch ausgedrückt. Ich meinte, dass es nicht 
über USB angeschlossen ist und UART1 bei anderen Tests nicht benutzt 
wurde.

[DraconiX (Gast)]

L. Beier schrieb:
> Zusammengefasst: Ich möchte UART2 (Serial1) nutzen, kein UART Interface
> funktioniert mit Arduino und diversen Code Variationen, jedoch
> funktionieren alle UARTs wenn ich statt Arduino CooCox benutze.

Ahh okay. Jetzt begreife ich es!

L. Beier schrieb:
> Daher bin ich gerade dabei den Code, den ich für Arduino geschrieben
> habe in C mit CooCox neu zu schreiben

Gute... Sehr gute Entscheidung... Du wirst sehen das es sicherlich hart 
und schwer wird. Aber die Lernkurve, gerade beim Cortex, wird hoch und 
steil sein! Viel Erfolg, und bei Fragen gerne wieder fragen. ? Ist das 
dein Einstieg in die 32Bit-Welt?!

[Stefan F. (Gast)]

Schau auf meine Notizen-Seite: http://stefanfrings.de/stm32/index.html

Dort verlinke ich auf die richtige Doku im Arduino Kapitel: 
https://github.com/rogerclarkmelbourne/Arduino_STM32

Und da steht im Wiki:

"SerialUSB on Maple builds has now been changed to Serial. Serial1 is 
Hardware serial 1, Serial2 is Hardware serial 2 etc"

Demnach muss es damit funktionieren. Vielleicht hast du das falsche 
Arduino Plugin verwendet.

[Markus (Gast)]

L.Beier
>Zusammengefasst: Ich möchte UART2 (Serial1) nutzen, kein UART >Interface
>funktioniert mit Arduino und diversen Code Variationen, jedoch
>funktionieren alle UARTs wenn ich statt Arduino CooCox benutze. Daher
>bin ich gerade dabei den Code, den ich für Arduino geschrieben habe >in C mit 
CooCox neu zu schreiben

So, gerade mal mit Arduino STM32Generic probiert:

void setup() {
Serial.begin(115200);
Serial2.begin(115200);

}

int Counter=0;
void loop() 
{
  Serial.println(Counter);  
  Serial2.println(Counter++);
  delay(200);

}

Es funktioniert einwandfrei. Das Bild oben ist von PA2 also TX2.

Hast Du STM32Generic probiert?

[L. Beier (Gast)]

Markus schrieb:
> Es funktioniert einwandfrei. Das Bild oben ist von PA2 also TX2.
>
> Hast Du STM32Generic probiert?

Das ist ja ein ding! Ich habe bislang immer das Generic STM32F103C 
series von rogerclarkmelbourne benutzt und jetzt mit dem stm32generic 
von danieleff funktionierts!

[Markus (Gast)]

Gratulation :-)
Viel Spaß beim weiterentwickeln ;-)
Schreib mal, ob der Rest klappt ( SPI, I2C usw ).

[F. F. (foldi)]

Bei Arduino funktioniert so einiges nicht mehr.
Die alten Uno Boards, die ich noch habe, funktionieren nicht mehr. Die 
Nanos alle.
CH... funktionieren.
Da sind 8U2 drauf und die wollen nicht mehr.

[Markus (Gast)]

Was heißt funktioniert nicht mehr?
Vielleicht musst Du eine ältere IDE runterladen. Man kann ja mehrere 
parallel haben.

[Stefan F. (Gast)]

Klingt für mich eher nach einem Treiber Problem.
Die seriellen Ports kann man relativ einfach mit LED's an RxD und TxD 
testen.

[Markus (Gast)]

Auf jeden Fall ist Arduino schuld:
https://www.youtube.com/watch?v=nn2FB1P_Mn8

[L. Beier (Gast)]

Jetzt nachdem ich Arduino STM32 neu installiert habe funktioniert 
anscheinend alles wieder und ich habe statt Serial2 für USART2 Serial1 
benutzt, da ich in einem anderen Forum gelesen habe, dass die so benannt 
würden.
Trotzdem danke für die ganze Hilfe und ich werde jetzt in meinen 
nächsten Projekten direkt alles mal mit CooCox versuchen, wenn ich nicht 
einen bereits fertigen Code umschreiben müsste.

[L. Beier (Gast)]

I2C und SPI funktionieren auch alle jetzt