STM32F4 Probleme mit USART

[Johannes J. (jhne92)]

Ich möchte Daten zws. STM32F429 DiscoveryBoard und USB TLL Adapter 
austauschen.
Hierfür verwende ich USART3 (C10/c11) vom STM

#include "stm32f4xx.h"
#include "stm32f4xx_usart.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
#define STDIN_FILENO 2
void IO_Initialize(void) {
  
  RCC->AHB1ENR  |= (1UL << 6);
  
  GPIOG->MODER  &= 0x00000000;
  GPIOG->MODER  |= 0x55555555;
  GPIOG->OTYPER &= 0x0000;
  GPIOG->PUPDR  &= 0x00000000;
  GPIOG->OSPEEDR|= 0xFFFFFFFF;  
  
  /*BTN*/
  GPIOA->MODER    &= ~((3UL << 2*0)  );      /* PA.0 is input                 */
  GPIOA->OSPEEDR  &= ~((3UL << 2*0)  );      /* PA.0 is 50MHz Fast Speed      */
  GPIOA->OSPEEDR  |=  ((2UL << 2*0)  ); 
  GPIOA->PUPDR    &= ~((3UL << 2*0)  );      /* PA.0 is no Pull up            */
}

void Usart3Init(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;

   //   GPIO_InitTypeDef GPIO_InitStructure;

   //configure clock for USART
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    //configure clock for GPIO
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
    //configure AF
    GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_USART3);
    GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_USART3);

    //configure ports, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    USART_Init(USART3, &USART_InitStructure);

     /* Enable USART */
     USART_Cmd(USART3, ENABLE);
}

void SendUart (uint8_t byte) {
  while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);  
  USART_SendData(USART3, byte);    
}

int main() {
  uint8_t test=0;
  //Initialisierung
  IO_Initialize();
  Usart3Init();
  
  SendUart(10001101);
}

Wenn ich folgende 8-Bits sende, kommt das in den Klammern am Laptop an:
00 00 00 00 = (00 00 00 00)
10 00 00 01 = (10 00 00 01)
11 10 00 01 = (01 10 00 01) -> erster Fehler
11 00 11 00 = (00 00 11 00) -> zweiter Fehler

Woran kann das liegen?

[le compileur (Gast)]

Woher weiss der Compiler, ob er eine Dezimalzahl oder Dualzahl 
vorfindet?
> SendUart(10001101);
:-*

[Johannes (Gast)]

le compileur schrieb:
> :-*

Meinst du der Compiler erkennt die 8 Zahlen nicht als Bits?
Sollte ich statt dessen senden: SendUart(141);

Hätte gedacht das kann der C Compiler...müsste man dann noch was vor die 
8 Bits schreiben, wenn man wirklich "Bits" schreiben möchte?

[Frank M. (ukw) (Moderator)]

Johannes schrieb:
> Meinst du der Compiler erkennt die 8 Zahlen nicht als Bits?

Nö, wie denn? 10001101 ist erstmal die Zahl 
Zehnmillioneneintausendeinhundertundeins.

Für Zahlenformate kannst Du außer der Dezimalsystemschreibweise:

    0123      führende Null -> Oktahlzahl
    0x1234    führendes 0x  -> Hexadezimalzahl

verwenden.

Für den gcc wurde mal die Erweiterung

    0b010101   führendes 0b -> Dualzahl

eingebaut. Soviel ich weiß, ist das aber kein Standard.

> Sollte ich statt dessen senden: SendUart(141);

Ja. Oder halt 0b10001101

> Hätte gedacht das kann der C Compiler...

Ist er ein Hellseher? Wie soll ich denn dann 
Zehnmillioneneintausendeinhundertundeins schreiben?

> müsste man dann noch was vor die
> 8 Bits schreiben, wenn man wirklich "Bits" schreiben möchte?

Ja, siehe oben.

Ich empfehle Dir die Lektüre eines guten C-Buchs. Du hast schon Lücken 
in den Grundlagen.

[Johannes (Gast)]

Naja ein Hellseher müsste er ja nicht sein, ich gebe ihm 8 Zahlen für 
eine uint8_t

Da könnte man vermuten ich möchte Bits senden,
Aber habe ich jetzt verstanden.
Aber er hätte mir stattdessen wenigstens eine Warnung ausgeben können, 
dass er die Zahl Zehnmillioneneintausendeinhundertundeins nicht in eine 
uint8 schreiben kann;)


Vielen Dank für die Hilfe :)

[Frank M. (ukw) (Moderator)]

Johannes schrieb:
> Da könnte man vermuten ich möchte Bits senden,

Wenn ein Compiler "vermutet", dann ist man als Programmierer verratzt 
und verkauft. Es gibt klare Standards, die erklären, wie ein C-Compiler 
sich verhalten muss.

> Aber er hätte mir stattdessen wenigstens eine Warnung ausgeben können,
> dass er die Zahl Zehnmillioneneintausendeinhundertundeins nicht in eine
> uint8 schreiben kann;)

Er kann durchaus Zehnmillioneneintausendeinhundertundeins in ein uint8_t 
schreiben. Es werden dann nur die untersten 8 Bit der Zahl gespeichert.
Das ist so beabsichtigt und C-Standard. Ich sagte ja: Dir fehlen 
wichtige Grundlagen.

Eine Warnung erhältst Du aber beim gcc, wenn Du die Option -Wall 
benutzt:

   warning: large integer implicitly truncated to unsigned type

[Johannes (Gast)]

Ok jetzt habe ich es verstanden...

kannst du mir eine lektüre zu genau dem Thema Bits & Co empfehlen?
Ich denke mit normalen Grundlagenbüchern werde ich keine Freude haben.
Ich lerne seit 3 Semestern C und seit 2 C++ an der Hochschule.

Das mit den Bits war bisher das einzige was mir gefehlt hat.
Und auch hier war es denk nur ein Denkfehler.

Gibt es eine Seite die sich mit dem Thema Bits beschäftigt?

[Frank M. (ukw) (Moderator)]

Johannes schrieb:

> Ich denke mit normalen Grundlagenbüchern werde ich keine Freude haben.
> Ich lerne seit 3 Semestern C und seit 2 C++ an der Hochschule.

Das heisst nichts. Es gibt Leute, die programmieren seit Jahren in C und 
lernen immer noch dazu.

> Das mit den Bits war bisher das einzige was mir gefehlt hat.

Das glaubst Du! Du wirst noch merken, dass Du tausende von Sachen noch 
nicht weisst. ;-)

> Gibt es eine Seite die sich mit dem Thema Bits beschäftigt?

Artikel Bitmanipulation wäre ein Anfang.

http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/006_c_operatoren_005.htm#mj8665462fba73385942e5ef4e23cddef6

http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/006_c_operatoren_005.htm#mjb9ea9c15a1d99fb02047978f41459bcd

http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/007_c_typumwandlung_001.htm#mj5c5e497ac2ab4367fe9df0ffd218cfca

http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/005_c_basisdatentypen_019.htm#mjb5d32a7c3c1c65c6a1658a8ab25ba0cb

Aber das ist nur ein Anriss der Thematik, die in Deinem kleinen 
"Problem" steckt.

Allgemein kann man natürlich immer das Standard-Werk

  Kernighan/ Ritchie "Programmieren in C" 2. Auflage

empfehlen - auch wenn das schon ein wenig angestaubt ist.

[Christian J. (Gast)]

Es gibt eine Seite im Nettz, die massenweise nützliche "Bit Routinen" 
und Makros bereit stellt, wie zb Spiegeln eines Bytes, rotieren über 64 
Bit usw. Habe mich nur leider danach tot gesucht die wieder zu finden.

>>Das heisst nichts. Es gibt Leute, die programmieren seit Jahren in C und
>>lernen immer noch dazu

Seit über 20 Jahren und trotzdem immer wieder was Neues :-)

[Johannes Jaeger (Gast)]

Christian J. schrieb:
> Es gibt eine Seite im Nettz, die massenweise nützliche "Bit
> Routinen"
> und Makros bereit stellt, wie zb Spiegeln eines Bytes, rotieren über 64
> Bit usw. Habe mich nur leider danach tot gesucht die wieder zu finden.
>
>>>Das heisst nichts. Es gibt Leute, die programmieren seit Jahren in C und
>>>lernen immer noch dazu
>
> Seit über 20 Jahren und trotzdem immer wieder was Neues :-)

Ich hab ja noch lange Zeit in meinem Leben :D
Ich denke nur immer, Learning by Doing ist besser als sich 100 Bücher 
durchzulesen...

Wäre cool wenn jemand die Seite kennt und sie hier reinstellt.
Würde denk für Viele hilfreicht sein.

[Frank M. (ukw) (Moderator)]

Johannes Jaeger schrieb:
> Ich denke nur immer, Learning by Doing ist besser als sich 100 Bücher
> durchzulesen...

Das halte ich für einen Irrglauben. Die Grundlagen sollte man sich schon 
systematisch aneignen. Dann kann man ja auf die Spielwiese gehen. Aber 
solange die Grundlagen nicht sitzen, kannst Du das Potential (gerade bei 
C) überhaupt nicht voll nutzen. Die Zeit, die Du fürs Lernen verbringst, 
holst Du dann später locker wieder raus.

[fbi (Gast)]

Johannes Jaeger schrieb:
> Wäre cool wenn jemand die Seite kennt und sie hier reinstellt.
Die hier?
https://graphics.stanford.edu/~seander/bithacks.html
http://bits.stephan-brumme.com/

[Johannes Jaeger (Gast)]

Perfekt Vielen Dank!:)

[Klaus W. (mfgkw)]

Johannes schrieb:
> Aber er hätte mir stattdessen wenigstens eine Warnung ausgeben können,
> dass er die Zahl Zehnmillioneneintausendeinhundertundeins nicht in eine
> uint8 schreiben kann;)

Wenn ich das kompiliere:

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>


void f( uint8_t i )
{
  printf( "%u\n", (unsigned)i );
}


int main( int nargs, char **args )
{
  f( 10010001 );

  return 0;
}

bekomme ich:

klwa4731@eso1188 ~ $ gcc t.c
t.c: In Funktion »main«:
t.c:14:3: Warnung: Große Ganzzahl implizit auf vorzeichenlosen Typen abgeschnitten [-Woverflow]
klwa4731@eso1188 ~ $ gcc -v
Es werden eingebaute Spezifikationen verwendet.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.6/lto-wrapper
Ziel: x86_64-linux-gnu
Konfiguriert mit: ../src/configure -v --with-pkgversion='Ubuntu/Linaro 4.6.3-1ubuntu5' --with-bugurl=file:///usr/share/doc/gcc-4.6/README.Bugs --enable-languages=c,c++,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-4.6 --enable-shared --enable-linker-build-id --with-system-zlib --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --with-gxx-include-dir=/usr/include/c++/4.6 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --enable-gnu-unique-object --enable-plugin --enable-objc-gc --disable-werror --with-arch-32=i686 --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread-Modell: posix
gcc-Version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5) 
klwa4731@eso1188 ~ $

[Johannes Jaeger (Gast)]

Keil hatte mir glaub keine Warnung ausgespuckt.
Ich versuche es heute Abend nochmal.

[le compileur (Gast)]

Johannes schrieb:
> Ich denke mit normalen Grundlagenbüchern werde ich keine Freude haben.
> Ich lerne seit 3 Semestern C und seit 2 C++ an der Hochschule.

Du solltest an der Vorlesung und den Seminaren teilnehmen. Die 5 
Semester im Bistro schaffen keine Grundlagen.

Und wenn C++ zur Verfügung steht, solltest du es auch benutzen. Der 
schluckt auch C code, hat aber eine Typ Prüfung. Genau das, was du 
brauchst.

Johannes schrieb:
>
> Hätte gedacht das kann der C Compiler...müsste man dann noch was vor die
> 8 Bits schreiben, wenn man wirklich "Bits" schreiben möchte?

Und das ist Komedy vom Feinsten. :'(

[drama (Gast)]

le compileur schrieb:
> Und wenn C++ zur Verfügung steht, solltest du es auch benutzen. Der
> schluckt auch C code, hat aber eine Typ Prüfung. Genau das, was du
> brauchst.

Jemandem der grundlegendes an C nicht verstanden hat, würde ich jetzt 
nicht unbedingt C++ andrehen. Das ist immerhin eine der komplexesten und 
verworrensten Programmiersprachen überhaupt. Da gibt es so viele 
Fallstricke, die kann man kaum noch zählen.

Und es ist auch recht kühn zu behaupten C hätte gar keine Typsicherheit. 
Grundlegende Typsicherheit gibt es doch. Darüber hinaus warnen viele 
Compiler vor gefährlich anmutenden Konstrukten.

Also wie auch immer, meine Empfehlung lautet: erstmal richtig C lernen. 
:)

[le compileur (Gast)]

@drama
D e r  C++  C o p i l e r  ü b e r s e t z t  a u c h  C  c o d e. Und 
er hat eine T y p e p r ü f u n g.

Bei C++ kommt man auch nicht auf die Idee, dass der Compiler was 
schätzt. ;-)

[drama (Gast)]

le compileur schrieb:
> D e r  C++  C o p i l e r  ü b e r s e t z t  a u c h  C  c o d e.

Leider nicht so richtig. Da gibt es eben doch einige elementare 
Unterschiede, die C-Code inkompatibel zu C++ machen können. Gerade wenn 
man auch die neueren C-Standards wie C99 und C11 einbezieht.

C-Code einfach so mit einem C++-Compiler zu übersetzen ist ein Hack.

[le compileur (Gast)]

Du bist der Meister! :-)

@Joe
Übersetze seien erste Version mal mit C++. Du wirst es dann sehen.

[Jo (Gast)]

Also ich werde jetzt mal mit C weitermachen ;)
Schlagt euch nicht die Köpfe ein ;)

Achja, im Bistro ware ich bisher nie während der Informatik Vorlesung ;)

[le compileur (Gast)]

Jo schrieb:
> Also ich werde jetzt mal mit C weitermachen ;) Schlagt euch nicht
> die Köpfe ein ;)
>
> Achja, im Bistro ware ich bisher nie während der Informatik Vorlesung ;)

Ja, mach mit C weiter, aber lass den C code über den C++ Compiler 
laufen.
Es kann nur besser werden. ;-)