STM32 warum funktioniert printf?

[alu (Gast)]

Hallo zusammen,

Ich habe ein STM32F4-Discoveryboard und nutze die summon-arm-toolchain 
unter linux. Nachdem ich mir eine UART eingerichtet habe, habe ich 
einfach mal so printf ausprobiert und war erstaunt, dass es ich es 
tatsächlich verwenden konnte.
Mittlerweile habe ich überhaupt keine anderen tx-Funktionen (kein putc 
oder Ähnliches) und ich frage mich z.B. woher printf überhaupt weiß, 
dass ich die UART2 verwende und welche Funktionen/Mechanismen zum Senden 
aufgerufen werden.
Die Definitionen sind in stdio.h sind für mich nur kryptisches 
Makro-Chinesisch...

Es wäre schön, wenn jemand hier etwas Licht ins Dunkel bringen könnte

[Ingo (Gast)]

Die ARMs sind halt aus ner anderen Dimension, da brauchste nichtmal 
Code, die wissen was du willst. Musst du überhaupt noch Flaschen oder 
geht's schon per Zuruf?


SCNR ;),
Ingo

[Stefan (Gast)]

>> Nachdem ich mir eine UART eingerichtet habe...

Wie hast Du das denn gemacht? Dabei hast Du bestimmt die Konsole 
eingerichtet (stdin/stdout).

[alu (Gast)]

>> Wie hast Du das denn gemacht? Dabei hast Du bestimmt die Konsole eingerichtet 
(stdin/stdout).


Dies ist meine UART-Initialisierung. Weiterhin habe ich noch den 
IRQ-Handler implementiert, allerdings wird dort nur der Empfang 
bearbeitet.

void initUSART(uint32_t baudrate)
{
  USART_InitTypeDef   USART_InitStructure;
  GPIO_InitTypeDef    GPIO_InitStructure;
  NVIC_InitTypeDef   NVIC_InitStructure;   // nested vector interrupt controller

  // Enable clocks
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

  // Prepare required pins to alternative function
  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_2 | GPIO_Pin_3;
  GPIO_InitStructure.GPIO_Speed   = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_Mode   = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType   = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd   = GPIO_PuPd_UP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  // Now the pins can be set to alternative function (USART)
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);  // GPIOA PA2: USART2_TX
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);  // GPIOA PA3: USART2_RX


  // Configuration of USART
  USART_InitStructure.USART_BaudRate         = baudrate;
  USART_InitStructure.USART_WordLength       = USART_WordLength_8b;        // standard
  USART_InitStructure.USART_StopBits         = USART_StopBits_1;          // standard
  USART_InitStructure.USART_Parity         = USART_Parity_No;          // standard
  USART_InitStructure.USART_HardwareFlowControl   = USART_HardwareFlowControl_None;  // standard
  USART_InitStructure.USART_Mode           = USART_Mode_Tx | USART_Mode_Rx;
  USART_Init(USART2, &USART_InitStructure);


  // Configure interrupt handler USART2_IRQHandler()
  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

  NVIC_InitStructure.NVIC_IRQChannel             = USART2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority   = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority       = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd           = ENABLE;
  NVIC_Init(&NVIC_InitStructure);


  // Enable UART
  USART_Cmd(USART2, ENABLE);
}

[vampire (Gast)]

-echo (on)?;
-debug on?

alu schrieb:
> Weiterhin habe ich noch den
> IRQ-Handler implementiert, allerdings wird dort nur der Empfang
> bearbeitet.

??

[alu (Gast)]

vampire schrieb:
> -echo (on)?;
> -debug on?

Ich weiß leider nicht was du hiermit meinst. Bin noch nicht so lange mit 
dem ARM dabei..

Meinen IRQHandler habe ich inzwischen vollkommen geleert:

void USART2_IRQHandler(void){}

printf funktioniert immer noch.
Ich verstehe es einfach nicht..

[Karl (Gast)]

Quellcode? Automagisch geht das sicher nicht...

BTW hat die summon-arm toolchain einen recht fiesen Bug (siehe ARM).

[bösewicht (Gast)]

alu schrieb:
> und ich frage mich z.B. woher printf überhaupt weiß,
> dass ich die UART2 verwende und welche Funktionen/Mechanismen zum Senden
> aufgerufen werden.

und später

alu schrieb:
> // Enable UART
>   USART_Cmd(USART2, ENABLE);
> }

Warum soll dann printf nicht fkt.?
(die summon-arm-toolchain
unter linux kenn ich allerdings nicht -- )

[Bronco (Gast)]

Ich würde mal vermuten, daß printf eine Default-Konfig hat, die auf 
UART2 zeigt, und daß dort nicht per ISR, sondern per Polling gesendet 
wird.
Istaber nur eine Vermutung...

[Hui (Gast)]

USART_Init(USART2, &USART_InitStructure);

Blind geschossen würde ich sagen das in der Funktion etwas drinsteckt 
nach dem Motto
Hey Printf weist du schon wo du hin musst?
Nein!
Nimm mal UART2 der wird hier gerade aktiviert.
OK!

Oder bei USART_Cmd(USART2, ENABLE);

Ohne in das Fachchinesisch schauen zu wollen würde ich an deiner Stelle 
mal alles auf USART1 ummünzen und schauen ob auf 2 immer noch was 
rauskommt.
Dann mal sehen ob das zuletzt oder zuerst initialisierte USART den 
"Zuschlag" erhält oder beide. und ob es der init befehl oder der enable 
ist.

[♪Geist (Gast)]

>Die Definitionen sind in stdio.h sind für mich nur kryptisches
>Makro-Chinesisch...
Da wird bestimmt eine custom stdio.c automatisch gelinkt. Alles andere 
wäre Wunder ;)